vision - Bilgisayarlı Görü

ResNet, YOLO, UNet ve görüntü işleme modelleri

Model

Pre-trained

Ağırlıklar

ImageNet

Transfer

Real-time

Inference

Genel Bakış

vision modülü, görüntü sınıflandırma, nesne tespiti ve segmentasyon için popüler derin öğrenme mimarilerini sağlar.

ResNet

Görüntü sınıflandırma

ResNet-18, 34, 50, 101, 152
ImageNet pre-trained
Transfer learning

YOLO

Nesne tespiti

YOLOv5, YOLOv8
Real-time detection
80 COCO sınıfı

UNet

Segmentasyon

Tıbbi görüntü analizi
Pixel-wise classification
Skip connections

EfficientNet

Verimli sınıflandırma

B0-B7 varyantları
Compound scaling
Düşük parametre

ResNet - Görüntü Sınıflandırma

ImageNet Classification

kullan ai/vision;
kullan ai/tensor;

// Pre-trained ResNet-50 yükle
değişken model = ResNet::yeni(
    architecture: "resnet50",
    pretrained: doğru,
    num_classes: 1000  // ImageNet
);

// Görüntü yükle ve preprocess
değişken img = vision::load_image("cat.jpg")?;
değişken img_tensor = vision::preprocess(
    img,
    size: [224, 224],
    normalize: doğru
);

// Inference
model.değerlendirme();
değişken logits = model.ileri(img_tensor);
değişken probs = softmax(logits);
değişken top5 = probs.topk(5);

her (idx, prob) içinde top5 için yap
    değişken label = IMAGENET_LABELS[idx];
    yazdir("{}: {:.2f}%", label, prob * 100.0);
son

Transfer Learning

kullan ai/vision;
kullan ai/nn;

// ResNet-18 backbone, custom classifier
değişken model = ResNet::yeni(
    architecture: "resnet18",
    pretrained: doğru,
    num_classes: 10  // Kendi dataset'iniz
);

// Feature extractor'ı dondur
her param içinde model.backbone.parametreler() için yap
    param.requires_grad = yanlış;
son

// Sadece classifier'ı eğit
değişken optimizer = Adam::yeni(
    model.classifier.parametreler(),
    lr: 0.001
);

// Fine-tuning
her epoch içinde aralık(20) için yap
    değişken loss = train_epoch(model, train_loader);
    yazdir("Epoch {}: Loss = {:.4f}", epoch, loss);
son

YOLO - Nesne Tespiti

YOLOv8 Object Detection

kullan ai/vision;

// YOLOv8 medium model
değişken detector = YOLO::yeni(
    version: "v8m",
    pretrained: doğru,
    conf_threshold: 0.25,
    iou_threshold: 0.45
);

değişken img = vision::load_image("street.jpg")?;
değişken detections = detector.detect(img)?;

yazdir("{} nesne tespit edildi", detections.len());

her det içinde detections için yap
    yazdir!("Sınıf: {}, Güven: {:.2f}%, ", 
            COCO_LABELS[det.class_id], 
            det.confidence * 100.0);
    yazdir!("Bbox: ({}, {}, {}, {})", 
            det.x, det.y, det.width, det.height);
son

// Bounding box çizimi
değişken img_with_boxes = vision::draw_boxes(img, detections);
vision::save_image(img_with_boxes, "output.jpg")?;

Real-time Video Detection

kullan ai/vision;
kullan std/video;

değişken detector = YOLO::yeni(version: "v8n", pretrained: doğru);
değişken video = video::capture(0)?;  // Webcam

çevrim yap
    değişken frame = video.read()?;
    eğer frame.is_empty() ise yap
        kır;
    son
    
    // Detect
    değişken detections = detector.detect(frame)?;
    değişken annotated = vision::draw_boxes(frame, detections);
    
    // FPS hesapla
    değişken fps = video.get_fps();
    vision::put_text(annotated, f"FPS: {fps:.1f}", (10, 30));
    
    // Göster
    video::show("YOLO Detection", annotated);
    
    eğer video::wait_key(1) == 'q' ise yap
        kır;
    son
son

UNet - Segmentasyon

Semantic Segmentation

kullan ai/vision;

// UNet model
değişken model = UNet::yeni(
    in_channels: 3,
    num_classes: 21,  // Pascal VOC
    pretrained: doğru
);

değişken img = vision::load_image("scene.jpg")?;
değişken img_tensor = vision::preprocess(img, size: [512, 512]);

// Segmentation
model.değerlendirme();
değişken mask = model.ileri(img_tensor);
değişken predicted_mask = mask.argmax(dim: 1);

// Renklendirme
değişken colored_mask = vision::colorize_mask(
    predicted_mask,
    palette: PASCAL_VOC_COLORS
);

// Overlay
değişken overlay = vision::overlay(img, colored_mask, alpha: 0.5);
vision::save_image(overlay, "segmented.jpg")?;

Image Transformations

Data Augmentation

kullan ai/vision;

değişken transforms = vision::Compose([
    vision::RandomResizedCrop(224),
    vision::RandomHorizontalFlip(p: 0.5),
    vision::RandomRotation(degrees: 15),
    vision::ColorJitter(
        brightness: 0.2,
        contrast: 0.2,
        saturation: 0.2,
        hue: 0.1
    ),
    vision::ToTensor(),
    vision::Normalize(
        mean: [0.485, 0.456, 0.406],
        std: [0.229, 0.224, 0.225]
    )
]);

// Uygula
değişken img = vision::load_image("train_img.jpg")?;
değişken augmented = transforms(img);

Pre-trained Models

Model Zoo

kullan ai/vision;

// Mevcut modelleri listele
değişken modeller = vision::list_models();
her model içinde modeller için yap
    yazdir!("{}: {} parametreler", 
            model.name, 
            model.num_params);
son

// Model indir ve yükle
değişken model = vision::load_model(
    name: "resnet50",
    source: "torchvision",
    progress: doğru
)?;

// Model bilgisi
yazdir("Mimari: {}", model.architecture);
yazdir("Giriş boyutu: {:?}", model.input_size);
yazdir("Sınıf sayısı: {}", model.num_classes);

Custom Vision Model

Kendi Modelinizi Oluşturun

kullan ai/vision;
kullan ai/nn;

sınıf CustomClassifier {
    değişken backbone: ResNet;
    değişken classifier: Sequential;
    
    fonksiyon yeni(num_classes: tamsayı) -> CustomClassifier yap
        değişken backbone = ResNet::yeni("resnet34", pretrained: doğru);
        
        // Backbone'u dondur
        her param içinde backbone.parametreler() için yap
            param.requires_grad = yanlış;
        son
        
        // Custom classifier
        değişken classifier = Sequential::yeni([
            Linear::yeni(512, 256),
            ReLU::yeni(),
            Dropout::yeni(0.5),
            Linear::yeni(256, num_classes)
        ]);
        
        dön CustomClassifier { backbone, classifier };
    son
    
    fonksiyon ileri(değişken kendi, x: Tensor) -> Tensor yap
        değişken features = kendi.backbone.extract_features(x);
        değişken pooled = features.adaptive_avg_pool2d([1, 1]);
        değişken flattened = pooled.flatten(1);
        dön kendi.classifier.ileri(flattened);
    son
}

Model Karşılaştırması

Model	Parametreler	Top-1 Acc	FPS (GPU)	Kullanım
ResNet-18	11.7M	69.8%	~350	Hızlı sınıflandırma
ResNet-50	25.6M	76.1%	~240	Genel amaçlı
ResNet-152	60.2M	78.3%	~80	Yüksek doğruluk
EfficientNet-B0	5.3M	77.1%	~400	Mobil/edge
EfficientNet-B7	66M	84.3%	~40	SOTA accuracy
YOLOv8n	3.2M	-	~450	Hızlı tespit
YOLOv8m	25.9M	-	~180	Dengeli tespit
UNet	31M	-	~120	Segmentasyon

API Referansı

vision Modülü

load_image(path: dizgi) -> Image - Görüntü yükle
save_image(img: Image, path: dizgi) - Görüntü kaydet
preprocess(img: Image, ...) -> Tensor - Preprocessing
draw_boxes(img: Image, boxes: [Box]) -> Image - Bbox çiz
overlay(img1: Image, img2: Image, alpha: ondalık) -> Image

ResNet Sınıfı

yeni(architecture: dizgi, pretrained: mantıksal, ...) -> ResNet
ileri(kendi, x: Tensor) -> Tensor
extract_features(kendi, x: Tensor) -> Tensor

YOLO Sınıfı

yeni(version: dizgi, ...) -> YOLO
detect(kendi, img: Image) -> [Detection]
detect_batch(kendi, imgs: [Image]) -> [[Detection]]

Keyboard shortcuts

BERK Programlama Dili