BadBob / Playground

Líkanið þitt.
Út í raunheiminn.

Gerðu þjálfað líkan að einhverju gagnlegu. Lítil dæmi með opnum kóða, skýr skref og kóði sem þú getur aðlagað þínum hugmyndum.

Opinn kóði · MIT · Líkanið er áfram þitt

FRÁ LÍKANI Í APP
Prófessor Bob brosir og horfir yfir lesgleraugun sem sitja neðarlega á nefinu, við hlið krítartöflu sem er þakin flókinni eðlisfræði. Í horni sem hefur verið þurrkað af hefur hann skrifað: MODEL = mc² / 10 PRINT "BAD BOB" / 20 GOTO 10.
  1. 01Myndavél
  2. 02Líkan
  3. 03Spá
  4. 04Appið þitt
Myndskreyting · frá útreikningi að niðurstöðu

01 / VELDU ÞÍNA LEIÐ

Lítil byrjun. Pláss til að byggja meira.

Tilbúið

Swift

Innbyggt myndavélaapp fyrir Mac með Core ML-greininum þínum.

Core ML · macOS
Tilbúið

Python

Forskriftaleið til að skoða líkön og smíða gagnleg verkfæri.

ONNX Runtime · OpenCV
Tilbúið

JavaScript

Vafradæmi með studdu ONNX-líkani.

Web · ONNX
Tilbúið

Rust

Innbyggð leið með skýrum kröfum um líkan og keyrsluumhverfi.

OpenCV · ONNX
Tilbúið

Go

Hagnýt verkfæri með skýru viðmóti við keyrslu líkans.

GoCV · ONNX
Tilbúið

C++

Myndavél og staðbundin ályktun með OpenCV og studdu ONNX-líkani.

OpenCV · ONNX

DeviconGo Gopher — Renee FrenchCC BY 3.0

Hafðu í huga
  1. Einkenni
    Viðmótið frýs þegar myndavélin fer í gang.
    Orsök
    Ræsing upptökulotu er hindrandi; async eitt og sér flytur vinnuna ekki af MainActor.
    Lausn
    Keyrðu upptöku og ályktun á sérstökum raðbundnum keyrsluaðila. Uppfærðu viðmótið á MainActor.
  2. Einkenni
    Forskoðunin dregst aftur úr og minnisnotkun eykst.
    Orsök
    Myndavélin skilar römmum hraðar en ályktunin vinnur úr þeim, svo ótakmörkuð biðröð stækkar.
    Lausn
    Slepptu síðbúnum römmum, vinndu raðbundið og geymdu aðeins nýjustu niðurstöðuna í bið. Forðastu sérstakt Task fyrir hvern ramma.
  3. Einkenni
    Gamlir rammar utan um hluti birtast aftur eftir stöðvun eða líkanaskipti.
    Orsök
    Eldra verk getur klárast seint; athugarar sem enn er vísað í geta haldið auðlindum virkum.
    Lausn
    Hættu við eldri keyrslu, hafnaðu úreltum niðurstöðum, stöðvaðu upptöku og fjarlægðu athugara. Losaðu tímabundin líkön; mældu endurteknar ræsingar og stöðvanir með Instruments.
BadBob / Playground
Core ML · Vision · MIT
02.01

Undirbúðu verkefnið

Sæktu frumkóðann og keyrðu prófin. Þú þarft myndavél og Core ML-hlutagreini sem vinnur með Vision. Líkansþyngdir fylgja ekki.

Grunnatriði

swift test
Keyrir sjálfvirkar prófanir án þess að opna myndavélina.
Terminalbash
unzip badbob-playground-swift.zip
cd badbob-playground-swift
swift test
02.02

Tengdu líkanið

Hladdu líkaninu og búðu til Vision-beiðni. Athugaðu inntakið áður en myndavélin fer í gang og haltu tímabundnum þýðingum á meðan ályktunin notar þær.

Grunnatriði

VisionDetector.init(modelURL:)
Hleður eða þýðir Core ML-líkanið og staðfestir myndinntak þess.
VisionDetector.predict(_:)
Undirbýr myndina, keyrir líkanið og skilar greiningum.

Dæmið krefst Core ML-hlutgreinis sem skilar hlutathugunum í Vision. Aðrar líkanagerðir og ONNX-skrár þurfa annan aðlaga.

Nánari útskýring

Vision skilar stöðluðum hnitum frá neðra vinstra horni. Umbreyttu þeim í hnit viðmótsins, haltu hlutföllum og speglaðu mynd og ramma saman.

Core ML · Visionyaml
model:
  runtime: Core ML + Vision
  formats: [.mlmodel, .mlpackage, .mlmodelc]
  image_inputs: 1
  results: VNRecognizedObjectObservation
preprocessing:
  crop_and_scale: scaleFill
  orientation: up
coordinates:
  range: [0, 1]
  origin: bottom_left
preview:
  scaling: aspect_fit
  mirroring: paired
VisionDetector.swiftswift
import CoreML
import Foundation
import Vision

/// Owned by one frame processor and used only on its serial capture queue.
final class VisionDetector {
    private let request: VNCoreMLRequest
    private let compiledURL: URL?
    private let scopedURL: URL?

    init(modelURL: URL) throws {
        guard modelURL.isFileURL,
            ["mlmodel", "mlpackage", "mlmodelc"].contains(modelURL.pathExtension.lowercased())
        else {
            throw CaptureFailure.unsupportedModel
        }

        let scoped = modelURL.startAccessingSecurityScopedResource()
        var ownedCompilation: URL?

        do {
            let loadURL: URL

            if modelURL.pathExtension.lowercased() == "mlmodelc" {
                loadURL = modelURL
            } else {
                loadURL = try MLModel.compileModel(at: modelURL)
                ownedCompilation = loadURL
            }

            let model = try MLModel(contentsOf: loadURL)
            guard
                model.modelDescription.inputDescriptionsByName.values.filter({ $0.type == .image })
                    .count == 1
            else {
                throw CaptureFailure.unsupportedModel
            }

            request = VNCoreMLRequest(model: try VNCoreMLModel(for: model))
            request.imageCropAndScaleOption = .scaleFill
            compiledURL = ownedCompilation
            scopedURL = scoped ? modelURL : nil
        } catch {
            if scoped {
                modelURL.stopAccessingSecurityScopedResource()
            }

            if let ownedCompilation {
                try? FileManager.default.removeItem(at: ownedCompilation)
            }

            throw error
        }
    }

    deinit {
        // Predictions have ended; remove only our own temporary compilation.
        if let compiledURL {
            try? FileManager.default.removeItem(at: compiledURL)
        }

        scopedURL?.stopAccessingSecurityScopedResource()
    }

    func predict(_ buffer: CVPixelBuffer) throws -> [Detection] {
        try VNImageRequestHandler(cvPixelBuffer: buffer, orientation: .up).perform([request])

        guard let objects = request.results as? [VNRecognizedObjectObservation] else {
            throw CaptureFailure.unsupportedModel
        }

        return objects.enumerated().compactMap { index, observation in

            guard let label = observation.labels.first, label.confidence.isFinite else {
                return nil
            }

            return Detection(
                id: index, label: label.identifier, confidence: label.confidence,
                bounds: observation.boundingBox)
        }
    }
}
02.03

Bættu myndavélinni við

Myndatakan keyrir á eigin raðbundna keyrara. Seinum römmum er sleppt og aðeins nýjasti unninn rammi bíður eftir viðmótinu. Mynd og spár fylgjast að.

Grunnatriði

CameraService.start(runID:modelURL:)
Stofnar myndavélarlotuna á sínum raðbundna keyrsluaðila og skilar streymi með í mesta lagi einni mynd í bið.
CameraService.stop(runID:)
Stöðvar aðeins samsvarandi keyrslu og losar lotu hennar, staðgengil og athugara.
Hafðu í huga
  1. Einkenni
    Viðmótið frýs þegar myndavélin fer í gang.
    Orsök
    Ræsing upptökulotu er hindrandi; async eitt og sér flytur vinnuna ekki af MainActor.
    Lausn
    Keyrðu upptöku og ályktun á sérstökum raðbundnum keyrsluaðila. Uppfærðu viðmótið á MainActor.
  2. Einkenni
    Forskoðunin dregst aftur úr og minnisnotkun eykst.
    Orsök
    Myndavélin skilar römmum hraðar en ályktunin vinnur úr þeim, svo ótakmörkuð biðröð stækkar.
    Lausn
    Slepptu síðbúnum römmum, vinndu raðbundið og geymdu aðeins nýjustu niðurstöðuna í bið. Forðastu sérstakt Task fyrir hvern ramma.
CameraService.swiftswift
import AVFoundation
import CoreImage
import Dispatch
import Foundation

/// A custom executor keeps blocking AVFoundation work off the main actor.
public actor CameraService: CameraCapturing {
    private nonisolated let queue = DispatchSerialQueue(label: "ai.badbob.playground.camera")
    public nonisolated var unownedExecutor: UnownedSerialExecutor {
        queue.asUnownedSerialExecutor()
    }

    private var session: AVCaptureSession?
    private var output: AVCaptureVideoDataOutput?
    private var processor: FrameProcessor?
    private var monitor: CaptureSessionMonitor?
    private var activeRunID: UUID?

    public init() {}

    public func start(runID: UUID, modelURL: URL) async throws -> FrameStream {
        stopActiveRun()
        let detector = try loadDetector(modelURL: modelURL)

        try Task.checkCancellation()

        guard let camera = AVCaptureDevice.default(for: .video) else {
            throw CaptureFailure.noCamera
        }

        let candidate = AVCaptureSession()
        let frames = AVCaptureVideoDataOutput()
        let (stream, continuation) = FrameStream.makeStream(bufferingPolicy: .bufferingNewest(1))
        let delegate = FrameProcessor(detector: detector, continuation: continuation)
        try configureSession(candidate, output: frames, processor: delegate, camera: camera)

        try Task.checkCancellation()
        session = candidate
        output = frames
        processor = delegate
        activeRunID = runID
        monitor = CaptureSessionMonitor(session: candidate, continuation: continuation)
        continuation.onTermination = { [weak self] _ in
            Task { await self?.stop(runID: runID) }
        }

        candidate.startRunning()

        guard candidate.isRunning else {
            stopActiveRun()
            throw CaptureFailure.configuration
        }

        return stream
    }

    private func loadDetector(modelURL: URL) throws -> VisionDetector {
        do {
            return try VisionDetector(modelURL: modelURL)
        } catch let error as CaptureFailure {
            throw error
        } catch {
            throw CaptureFailure.model(error.localizedDescription)
        }
    }

    private func configureSession(
        _ candidate: AVCaptureSession,
        output frames: AVCaptureVideoDataOutput,
        processor delegate: FrameProcessor,
        camera: AVCaptureDevice
    ) throws {
        candidate.beginConfiguration()

        do {
            let input = try AVCaptureDeviceInput(device: camera)

            guard candidate.canAddInput(input), candidate.canAddOutput(frames) else {
                throw CaptureFailure.configuration
            }

            candidate.addInput(input)
            candidate.addOutput(frames)

            if candidate.canSetSessionPreset(.hd1280x720) {
                candidate.sessionPreset = .hd1280x720
            }

            frames.alwaysDiscardsLateVideoFrames = true
            frames.videoSettings = [
                kCVPixelBufferPixelFormatTypeKey as String: kCVPixelFormatType_32BGRA
            ]
            // The delegate, Vision request and frame renderer share this one serial queue.
            frames.setSampleBufferDelegate(delegate, queue: queue)

            if let connection = frames.connection(with: .video),
                connection.isVideoMirroringSupported
            {
                connection.automaticallyAdjustsVideoMirroring = false
                connection.isVideoMirrored = false
            }

            candidate.commitConfiguration()
        } catch {
            candidate.commitConfiguration()
            frames.setSampleBufferDelegate(nil, queue: nil)
            delegate.finish()
            throw error
        }
    }

    public func stop(runID: UUID) {
        // A cancelled old task must not stop a more recent capture run.
        guard activeRunID == runID else {
            return
        }

        stopActiveRun()
    }

    private func stopActiveRun() {
        // Remove observers first so our deliberate stop cannot become a failure.
        monitor?.invalidate()
        monitor = nil
        session?.stopRunning()
        output?.setSampleBufferDelegate(nil, queue: nil)
        processor?.finish()
        processor = nil
        output = nil
        session = nil
        activeRunID = nil
    }
}

/// AVFoundation invokes this delegate only on CameraService's serial queue.
/// No sample buffer or mutable Vision object crosses into a Task or the UI.
private final class FrameProcessor: NSObject, AVCaptureVideoDataOutputSampleBufferDelegate {
    private let detector: VisionDetector
    private let continuation: FrameStream.Continuation
    private let renderer = CIContext(options: [.cacheIntermediates: false])
    private var finished = false

    init(detector: VisionDetector, continuation: FrameStream.Continuation) {
        self.detector = detector
        self.continuation = continuation
    }

    func finish() {
        guard !finished else {
            return
        }

        finished = true
        continuation.finish()
    }

    func captureOutput(
        _ output: AVCaptureOutput, didOutput sampleBuffer: CMSampleBuffer,
        from connection: AVCaptureConnection
    ) {
        guard !finished, let buffer = CMSampleBufferGetImageBuffer(sampleBuffer) else {
            return
        }

        autoreleasepool {
            do {
                let detections = try detector.predict(buffer)
                let image = CIImage(cvPixelBuffer: buffer)

                guard let pixels = renderer.createCGImage(image, from: image.extent) else {
                    throw CaptureFailure.imageCreation
                }

                continuation.yield(DetectionFrame(image: pixels, detections: detections))
            } catch {
                finished = true
                continuation.finish(throwing: error)
            }
        }
    }
}
02.04

Settu spárnar á réttan stað

Vision skilar stöðluðum hnitum frá neðra vinstra horni. Umbreyttu þeim í hnit viðmótsins, haltu hlutföllum og speglaðu mynd og ramma saman.

Grunnatriði

OverlayGeometry.project(...)
Varpar römmum Vision á sýn með réttum myndhlutföllum og speglar mynd og ramma saman.
Hafðu í huga

Líttu á myndstærð, skurð, stefnu og hnit sem eina heild. Prófaðu þekkta ramma áður en þú treystir merkingunum.

OverlayGeometry.swiftswift
import CoreGraphics

/// Convert Vision's normalized, bottom-left coordinates to an aspect-fit view.
public enum OverlayGeometry {
    public static func project(
        _ bounds: CGRect, imageSize: CGSize, viewport: CGSize, mirrored: Bool
    ) -> CGRect? {
        guard
            [imageSize.width, imageSize.height, viewport.width, viewport.height].allSatisfy({
                $0.isFinite && $0 > 0
            }),
            [bounds.origin.x, bounds.origin.y, bounds.width, bounds.height].allSatisfy(\.isFinite),
            bounds.width > 0, bounds.height > 0
        else { return nil }
        let clipped = bounds.intersection(CGRect(x: 0, y: 0, width: 1, height: 1))

        guard !clipped.isNull, !clipped.isEmpty else {
            return nil
        }

        let scale = min(viewport.width / imageSize.width, viewport.height / imageSize.height)
        let width = imageSize.width * scale
        let height = imageSize.height * scale

        return CGRect(
            x: (viewport.width - width) / 2 + (mirrored ? 1 - clipped.maxX : clipped.minX) * width,
            y: (viewport.height - height) / 2 + (1 - clipped.maxY) * height,
            width: clipped.width * width, height: clipped.height * height
        )
    }
}
02.05

Byggðu. Keyrðu. Prófaðu.

Byggðu staðbundna appið, veldu greininn og ýttu á Start camera. Stilltu öryggismörk spár og speglun. Stöðvaðu myndatökuna þegar þú ert búinn.

Grunnatriði

CameraController.start()
Biður um myndavélarheimild, byrjar töku og uppfærir samsvarandi myndir á MainActor.
CameraController.stop()
Hættir við virka viðmótsverkefnið og biður myndavélarþjónustuna að stöðva sömu keyrslu.
Hafðu í huga
  1. Einkenni
    Gamlir rammar utan um hluti birtast aftur eftir stöðvun eða líkanaskipti.
    Orsök
    Eldra verk getur klárast seint; athugarar sem enn er vísað í geta haldið auðlindum virkum.
    Lausn
    Hættu við eldri keyrslu, hafnaðu úreltum niðurstöðum, stöðvaðu upptöku og fjarlægðu athugara. Losaðu tímabundin líkön; mældu endurteknar ræsingar og stöðvanir með Instruments.
Terminalbash
./build-app.sh
open ".build/BadBob Playground.app"

02.06 / Góð vinnubrögð

Lítil smáatriði. Betri dæmi.

  • Haltu myndatöku og ályktun utan viðmótsþráðarins. Takmarkaðu biðröðina í stað þess að safna gömlum römmum.
  • Líttu á myndstærð, skurð, stefnu og hnit sem eina heild. Prófaðu þekkta ramma áður en þú treystir merkingunum.
  • Höndlaðu synjað leyfi, ósamhæf líkön og afturköllun. Berðu saman þekktar spár á þeim Mac sem þú munt nota.