BadBob / Playground

আপনার মডেল।
বাস্তব জগতে।

প্রশিক্ষিত মডেলকে কাজে লাগান। ছোট ওপেন সোর্স উদাহরণ, স্পষ্ট ধাপ এবং নিজের মতো বদলে নেওয়ার কোড।

ওপেন সোর্স · MIT · আপনার মডেল আপনারই থাকে

মডেল থেকে অ্যাপ
প্রফেসর বব নাকের ডগায় নামানো পড়ার চশমার ওপর দিয়ে তাকিয়ে হাসছেন। পাশে জটিল পদার্থবিদ্যায় ভরা একটি চকবোর্ড। মুছে রাখা এক কোণে তিনি লিখেছেন: MODEL = mc² / 10 PRINT "BAD BOB" / 20 GOTO 10.
  1. 01ক্যামেরা
  2. 02মডেল
  3. 03পূর্বাভাস
  4. 04আপনার অ্যাপ
চিত্রণ · গণনা থেকে ফলাফলে

01 / আপনার পথ বেছে নিন

ছোট শুরু। এগিয়ে যাওয়ার সুযোগ।

পাওয়া যাচ্ছে

Swift

আপনার Core ML ডিটেক্টর দিয়ে Mac-এর নেটিভ ক্যামেরা অ্যাপ।

Core ML · macOS
পাওয়া যাচ্ছে

Python

মডেল পরীক্ষা ও দরকারি টুল তৈরির জন্য স্ক্রিপ্টিংয়ের পথ।

ONNX Runtime · OpenCV
পাওয়া যাচ্ছে

JavaScript

সমর্থিত ONNX মডেল দিয়ে ব্রাউজারের উদাহরণ।

Web · ONNX
পাওয়া যাচ্ছে

Rust

মডেল ও রানটাইমের স্পষ্ট চাহিদাসহ নেটিভ উন্নয়নের পথ।

OpenCV · ONNX
পাওয়া যাচ্ছে

Go

মডেল চালানোর স্পষ্ট ইন্টারফেসসহ ব্যবহারিক টুল।

GoCV · ONNX
পাওয়া যাচ্ছে

C++

OpenCV ও সমর্থিত ONNX মডেল দিয়ে ক্যামেরা ও স্থানীয় ইনফারেন্স।

OpenCV · ONNX

DeviconGo Gopher — Renee FrenchCC BY 3.0

মনে রাখুন
  1. লক্ষণ
    ক্যামেরা চালু হলে ইন্টারফেস আটকে যায়।
    কারণ
    সেশন চালু করা অবরোধকারী কাজ; শুধু async ব্যবহার করলে কাজ MainActor থেকে সরে যায় না।
    সমাধান
    ক্যাপচার ও ইনফারেন্স আলাদা সিরিয়াল executor-এ চালান। UI আপডেট করুন MainActor-এ।
  2. লক্ষণ
    প্রিভিউ পিছিয়ে পড়ে এবং মেমোরির ব্যবহার বাড়ে।
    কারণ
    ইনফারেন্স যত দ্রুত ফ্রেম প্রক্রিয়া করে, ক্যামেরা তার চেয়ে দ্রুত ফ্রেম দেয়, ফলে সীমাহীন সারি বাড়তে থাকে।
    সমাধান
    দেরি হওয়া ফ্রেম বাদ দিন, ধারাবাহিকভাবে প্রক্রিয়া করুন এবং শুধু সর্বশেষ অপেক্ষমাণ ফল রাখুন। প্রতিটি ফ্রেমের জন্য আলাদা Task তৈরি করবেন না।
  3. লক্ষণ
    বন্ধ করা বা মডেল বদলানোর পর পুরোনো বক্স ফিরে আসে।
    কারণ
    আগের কাজ দেরিতে শেষ হতে পারে; ধরে রাখা observer রিসোর্স সক্রিয় রাখতে পারে।
    সমাধান
    পুরোনো রান বাতিল করুন, পুরোনো ফল প্রত্যাখ্যান করুন, ক্যাপচার বন্ধ করুন ও observer সরান। অস্থায়ী মডেল মুক্ত করুন; বারবার চালু ও বন্ধ করার চক্র Instruments দিয়ে মাপুন।
BadBob / Playground
Core ML · Vision · MIT

02 / Swift Core ML + Vision

এমন কিছু বানান যা দেখতে পায়।

সম্পূর্ণ Swift উদাহরণ: মডেল বাছুন, ক্যামেরা চালু করুন এবং ছবির সঙ্গে মেলা পূর্বাভাস আঁকুন। ধাপগুলো অনুসরণ করুন বা পুরো সোর্স দেখুন।

উদাহরণগুলো নিয়ন্ত্রিত পরিবেশে বস্তু ও প্রাণী নিয়ে। মানুষের নজরদারি, পরিচয় শনাক্তকরণ বা আচরণ বিশ্লেষণ এর অন্তর্ভুক্ত নয়।

02.01

প্রকল্প তৈরি করুন

সোর্স ডাউনলোড করে পরীক্ষা চালান। একটি ক্যামেরা ও Vision-এর উপযোগী Core ML অবজেক্ট ডিটেক্টর দরকার। মডেলের ওজন অন্তর্ভুক্ত নয়।

মূল বিষয়

swift test
ক্যামেরা না খুলেই স্বয়ংক্রিয় পরীক্ষা চালায়।
Terminalbash
unzip badbob-playground-swift.zip
cd badbob-playground-swift
swift test
02.02

মডেল যুক্ত করুন

মডেল লোড করে Vision অনুরোধ তৈরি করুন। ক্যামেরা চালুর আগে ইনপুট পরীক্ষা করুন এবং ইনফারেন্স চলাকালে অস্থায়ী কম্পাইল করা ফাইল ধরে রাখুন।

মূল বিষয়

VisionDetector.init(modelURL:)
Core ML মডেল লোড বা কম্পাইল করে এবং তার ছবি ইনপুট যাচাই করে।
VisionDetector.predict(_:)
ছবি প্রস্তুত করে, মডেল চালায় এবং শনাক্তকরণের ফল ফেরত দেয়।

এই উদাহরণের জন্য এমন Core ML অবজেক্ট ডিটেক্টর দরকার, যা Vision অবজেক্ট পর্যবেক্ষণ ফেরত দেয়। অন্য মডেল ধরন ও ONNX ফাইলের জন্য আলাদা অ্যাডাপ্টার দরকার।

বিস্তারিত

Vision নিচের বাঁ দিক থেকে স্বাভাবিকীকৃত স্থানাঙ্ক দেয়। সেগুলো ভিউয়ের স্থানাঙ্কে বদলান, ছবির অনুপাত বজায় রাখুন এবং ছবি ও বাক্স একসঙ্গে মিরর করুন।

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

ক্যামেরা যুক্ত করুন

ক্যাপচার নিজস্ব সিরিয়াল এক্সিকিউটরে চলে। দেরিতে আসা ফ্রেম বাদ যায় এবং শুধু সর্বশেষ প্রক্রিয়াকৃত ফ্রেম ইন্টারফেসের অপেক্ষায় থাকে। ছবি ও পূর্বাভাস একসঙ্গে থাকে।

মূল বিষয়

CameraService.start(runID:modelURL:)
নিজস্ব সিরিয়াল এক্সিকিউটরে ক্যাপচার সেশন তৈরি করে এবং সর্বোচ্চ একটি অপেক্ষমাণ ফ্রেমসহ স্ট্রিম ফেরত দেয়।
CameraService.stop(runID:)
শুধু সংশ্লিষ্ট রানটি থামায় এবং তার সেশন, ডেলিগেট ও অবজারভার মুক্ত করে।
মনে রাখুন
  1. লক্ষণ
    ক্যামেরা চালু হলে ইন্টারফেস আটকে যায়।
    কারণ
    সেশন চালু করা অবরোধকারী কাজ; শুধু async ব্যবহার করলে কাজ MainActor থেকে সরে যায় না।
    সমাধান
    ক্যাপচার ও ইনফারেন্স আলাদা সিরিয়াল executor-এ চালান। UI আপডেট করুন MainActor-এ।
  2. লক্ষণ
    প্রিভিউ পিছিয়ে পড়ে এবং মেমোরির ব্যবহার বাড়ে।
    কারণ
    ইনফারেন্স যত দ্রুত ফ্রেম প্রক্রিয়া করে, ক্যামেরা তার চেয়ে দ্রুত ফ্রেম দেয়, ফলে সীমাহীন সারি বাড়তে থাকে।
    সমাধান
    দেরি হওয়া ফ্রেম বাদ দিন, ধারাবাহিকভাবে প্রক্রিয়া করুন এবং শুধু সর্বশেষ অপেক্ষমাণ ফল রাখুন। প্রতিটি ফ্রেমের জন্য আলাদা Task তৈরি করবেন না।
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

পূর্বাভাস সঠিক স্থানে বসান

Vision নিচের বাঁ দিক থেকে স্বাভাবিকীকৃত স্থানাঙ্ক দেয়। সেগুলো ভিউয়ের স্থানাঙ্কে বদলান, ছবির অনুপাত বজায় রাখুন এবং ছবি ও বাক্স একসঙ্গে মিরর করুন।

মূল বিষয়

OverlayGeometry.project(...)
Vision বক্সকে অনুপাত বজায় রাখা ভিউতে রূপান্তর করে এবং ছবি ও বক্স একসঙ্গে মিরর করে।
মনে রাখুন

ছবির মাপ, ক্রপ, অভিমুখ ও স্থানাঙ্ককে একটিই চুক্তি হিসেবে ধরুন। চিহ্নে ভরসা করার আগে পরিচিত বাক্স দিয়ে পরীক্ষা করুন।

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

বিল্ড করুন। চালান। পরীক্ষা করুন।

স্থানীয় অ্যাপ বিল্ড করুন, ডিটেক্টর বাছুন ও Start camera চাপুন। আত্মবিশ্বাসের সীমা ও মিরর সেটিং বদলান। শেষে ক্যাপচার বন্ধ করুন।

মূল বিষয়

CameraController.start()
ক্যামেরার অনুমতি চায়, ক্যাপচার শুরু করে এবং MainActor-এ সংশ্লিষ্ট ফ্রেম আপডেট করে।
CameraController.stop()
সক্রিয় UI টাস্ক বাতিল করে এবং ক্যামেরা সার্ভিসকে একই রান থামাতে বলে।
মনে রাখুন
  1. লক্ষণ
    বন্ধ করা বা মডেল বদলানোর পর পুরোনো বক্স ফিরে আসে।
    কারণ
    আগের কাজ দেরিতে শেষ হতে পারে; ধরে রাখা observer রিসোর্স সক্রিয় রাখতে পারে।
    সমাধান
    পুরোনো রান বাতিল করুন, পুরোনো ফল প্রত্যাখ্যান করুন, ক্যাপচার বন্ধ করুন ও observer সরান। অস্থায়ী মডেল মুক্ত করুন; বারবার চালু ও বন্ধ করার চক্র Instruments দিয়ে মাপুন।
Terminalbash
./build-app.sh
open ".build/BadBob Playground.app"

02.06 / ভালো চর্চা

ছোট খুঁটিনাটি। ভালো উদাহরণ।

  • ক্যাপচার ও ইনফারেন্স UI থ্রেডের বাইরে রাখুন। পুরোনো ফ্রেম জমতে না দিয়ে সারির সীমা নির্ধারণ করুন।
  • ছবির মাপ, ক্রপ, অভিমুখ ও স্থানাঙ্ককে একটিই চুক্তি হিসেবে ধরুন। চিহ্নে ভরসা করার আগে পরিচিত বাক্স দিয়ে পরীক্ষা করুন।
  • অনুমতি না পাওয়া, অসামঞ্জস্যপূর্ণ মডেল ও বাতিলের ব্যবস্থা রাখুন। যে Mac ব্যবহার করবেন, তাতে পরিচিত পূর্বাভাস মিলিয়ে দেখুন।