Computer Vision: Object Detection — YOLO, R-CNN, SSD

# pip install ultralytics
from ultralytics import YOLO
import cv2
import numpy as np

# === 1. INFERENCE DENGAN PRE-TRAINED MODEL ===
# Load model pre-trained di COCO dataset (80 kelas)
model = YOLO('yolov8n.pt')  # 'n'=nano, 's'=small, 'm'=medium, 'l'=large, 'x'=extra-large

# Inference pada gambar
results = model('https://ultralytics.com/images/bus.jpg')

# Parse results
for result in results:
    boxes = result.boxes          # Bounding boxes
    masks = result.masks          # Segmentation masks (jika ada)
    probs = result.probs          # Classification probabilities
    
    print(f"\n=== Deteksi pada gambar ===")
    print(f"Jumlah objek terdeteksi: {len(boxes)}")
    
    for box in boxes:
        # Koordinat bounding box
        x1, y1, x2, y2 = box.xyxy[0].tolist()    # Format (x1, y1, x2, y2)
        confidence = box.conf[0].item()             # Confidence score
        class_id = int(box.cls[0].item())           # Class ID
        class_name = model.names[class_id]          # Class name
        
        print(f"  {class_name}: {confidence:.2f} "
              f"→ [{x1:.0f}, {y1:.0f}, {x2:.0f}, {y2:.0f}]")

# Simpan hasil dengan bounding box
result_plot = results[0].plot()  # Gambar dengan annotated boxes
cv2.imwrite('detection_result.jpg', result_plot)
print("\n✓ Hasil disimpan: detection_result.jpg")

# === 2. VIDEO DETECTION ===
def detect_video(model, video_path, output_path='output.mp4'):
    """Object detection pada video"""
    cap = cv2.VideoCapture(video_path)
    fps = int(cap.get(cv2.CAP_PROP_FPS))
    w = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
    h = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
    
    fourcc = cv2.VideoWriter_fourcc(*'mp4v')
    out = cv2.VideoWriter(output_path, fourcc, fps, (w, h))
    
    frame_count = 0
    while cap.isOpened():
        ret, frame = cap.read()
        if not ret:
            break
        
        # Run YOLOv8 inference
        results = model(frame, verbose=False)
        
        # Draw boxes on frame
        annotated = results[0].plot()
        out.write(annotated)
        
        frame_count += 1
        if frame_count % 30 == 0:
            print(f"  Processed {frame_count} frames...")
    
    cap.release()
    out.release()
    print(f"✓ Video saved: {output_path} ({frame_count} frames)")

# Uncomment untuk proses video:
# detect_video(model, 'input_video.mp4')

# === 3. WEBCAM REAL-TIME DETECTION ===
def detect_webcam(model):
    """Real-time object detection dari webcam"""
    cap = cv2.VideoCapture(0)  # Camera index 0
    
    while True:
        ret, frame = cap.read()
        if not ret:
            break
        
        results = model(frame, verbose=False)
        annotated = results[0].plot()
        
        cv2.imshow('YOLOv8 Real-Time Detection', annotated)
        
        if cv2.waitKey(1) & 0xFF == ord('q'):
            break
    
    cap.release()
    cv2.destroyAllWindows()

# Uncomment untuk webcam:
# detect_webcam(model)

from ultralytics import YOLO

# === FINE-TUNE YOLOv8 PADA CUSTOM DATASET ===

# 1. Load pre-trained model (transfer learning)
model = YOLO('yolov8m.pt')  # Start dari pre-trained medium model

# 2. Training dengan custom dataset
# Dataset harus dalam format YOLO:
#   dataset/
#     ├── train/
#     │   ├── images/ (gambar .jpg/.png)
#     │   └── labels/ (label .txt, format: class x_center y_center w h)
#     ├── val/
#     │   ├── images/
#     │   └── labels/
#     └── data.yaml
#
# data.yaml contoh:
#   train: dataset/train/images
#   val: dataset/val/images
#   nc: 3  # jumlah kelas
#   names: ['cat', 'dog', 'bird']  # nama kelas

results = model.train(
    data='dataset/data.yaml',   # Path ke data config
    epochs=100,                 # Jumlah epoch
    imgsz=640,                  # Ukuran gambar input
    batch=16,                   # Batch size
    lr0=0.01,                   # Initial learning rate
    lrf=0.01,                   # Final learning rate (lr0 * lrf)
    warmup_epochs=3,            # Warmup epochs
    optimizer='AdamW',          # Optimizer
    augment=True,               # Data augmentation
    mosaic=1.0,                 # Mosaic augmentation probability
    mixup=0.0,                  # Mixup augmentation
    copy_paste=0.0,             # Copy-paste augmentation
    device=0,                   # GPU device (0, 1, 'cpu')
    project='runs/detect',      # Output directory
    name='custom_model',        # Experiment name
    exist_ok=False,
    pretrained=True,
    verbose=True,
)

# 3. Evaluasi model
metrics = model.val()
print(f"\n=== Hasil Evaluasi ===")
print(f"mAP@50:    {metrics.box.map50:.4f}")
print(f"mAP@50-95: {metrics.box.map:.4f}")
print(f"Precision: {metrics.box.mp:.4f}")
print(f"Recall:    {metrics.box.mr:.4f}")

# 4. Export ke berbagai format
model.export(format='onnx')     # ONNX
model.export(format='torchscript')  # TorchScript
# model.export(format='tflite')  # TensorFlow Lite
# model.export(format='coreml')  # CoreML (iOS)

print("\n✓ Model exported!")
print("  - ONNX: best.onnx")
print("  - TorchScript: best.torchscript")

from ultralytics import YOLO

# === YOLOv8 UNTUK BERBAGAI TUGAS ===

# 1. OBJECT DETECTION
model_det = YOLO('yolov8n.pt')
results = model_det('image.jpg')

# 2. INSTANCE SEGMENTATION
model_seg = YOLO('yolov8n-seg.pt')
results = model_seg('image.jpg')

# 3. IMAGE CLASSIFICATION
model_cls = YOLO('yolov8n-cls.pt')
results = model_cls('image.jpg')

# 4. POSE ESTIMATION
model_pose = YOLO('yolov8n-pose.pt')
results = model_pose('image.jpg')

# 5. OBB (ORIENTED BOUNDING BOX)
model_obb = YOLO('yolov8n-obb.pt')
results = model_obb('image.jpg')

# === CONTOH: POSE ESTIMATION ===
model_pose = YOLO('yolov8n-pose.pt')
results = model_pose('person.jpg')

for result in results:
    keypoints = result.keypoints
    if keypoints is not None:
        for person_kp in keypoints:
            # 17 COCO keypoints
            # 0=nose, 1=left_eye, 2=right_eye, ...
            # 5=left_shoulder, 6=right_shoulder
            # 11=left_hip, 12=right_hip
            kp_data = person_kp.data[0]  # (17, 3): x, y, confidence
            print(f"Pose keypoints: {kp_data.shape}")
            print(f"  Nose: ({kp_data[0][0]:.0f}, {kp_data[0][1]:.0f})")

print("\n✓ Semua model YOLOv8 siap digunakan!")