# 匯出為 ONNX 格式（最通用）
yolo export model=best.pt format=onnx

# 匯出為 TensorRT 格式（NVIDIA GPU 最佳化）
yolo export model=best.pt format=engine

# 匯出為 CoreML 格式（Apple 裝置）
yolo export model=best.pt format=coreml

# 匯出為 TFLite 格式（行動裝置、邊緣運算）
yolo export model=best.pt format=tflite

runs/detect/train/weights/
├── best.pt          # 原始 PyTorch 模型
├── best.onnx        # ONNX 格式
├── best.engine      # TensorRT 格式
└── best.mlmodel     # CoreML 格式

yolo export model=best.pt format=onnx imgsz=640 half=True simplify=True

格式比較表
┌─────────────┬──────────────┬──────────────┬─────────────┐
│    格式     │    適用場景   │     優點     │     缺點    │
├─────────────┼──────────────┼──────────────┼─────────────┤
│ PyTorch     │ 開發測試     │ 最靈活       │ 部署不便    │
│ ONNX        │ 跨平台部署   │ 通用性最高   │ 速度中等    │
│ TensorRT    │ NVIDIA GPU   │ 速度最快     │ 僅限 NVIDIA │
│ CoreML      │ Apple 裝置   │ 整合度高     │ 僅限 Apple  │
│ TFLite      │ 行動/邊緣    │ 檔案小       │ 精度可能降  │
└─────────────┴──────────────┴──────────────┴─────────────┘

精度與大小關係
┌──────────┬──────────┬──────────┬────────────┐
│   精度   │ 模型大小 │ 推論速度 │  精度損失  │
├──────────┼──────────┼──────────┼────────────┤
│  FP32    │   100%   │  基準    │    無      │
│  FP16    │    50%   │  1.5-2x  │   極小     │
│  INT8    │    25%   │  2-4x    │   可接受   │
└──────────┴──────────┴──────────┴────────────┘

# 匯出時啟用 FP16
yolo export model=best.pt format=onnx half=True

from ultralytics import YOLO

# 載入模型時指定半精度
model = YOLO('best.pt')
results = model.predict('image.jpg', half=True)

# TensorRT INT8 量化
yolo export model=best.pt format=engine int8=True data=coco.yaml

實測數據（輸入 640x640）
┌──────────┬──────────┬──────────┬──────────┐
│   模式   │ 模型大小 │   FPS    │   mAP    │
├──────────┼──────────┼──────────┼──────────┤
│ FP32     │  6.3 MB  │   180    │  37.3%   │
│ FP16     │  3.2 MB  │   280    │  37.2%   │
│ INT8     │  1.6 MB  │   420    │  36.8%   │
└──────────┴──────────┴──────────┴──────────┘

# server_deploy.py - 使用 FastAPI 建立偵測 API
from fastapi import FastAPI, UploadFile
from ultralytics import YOLO
import cv2
import numpy as np

app = FastAPI()
model = YOLO('best.engine')  # 使用 TensorRT 格式

@app.post("/detect")
async def detect(file: UploadFile):
    # 讀取上傳的圖片
    contents = await file.read()
    nparr = np.frombuffer(contents, np.uint8)
    img = cv2.imdecode(nparr, cv2.IMREAD_COLOR)

    # 執行偵測
    results = model(img)

    # 整理結果
    detections = []
    for r in results:
        for box in r.boxes:
            detections.append({
                'class': model.names[int(box.cls)],
                'confidence': float(box.conf),
                'bbox': box.xyxy[0].tolist()
            })

    return {'detections': detections}

uvicorn server_deploy:app --host 0.0.0.0 --port 8000

# 在 Jetson 上安裝 ultralytics
pip install ultralytics

# 確認 CUDA 可用
python -c "import torch; print(torch.cuda.is_available())"

# 直接在 Jetson 上匯出，確保相容性
yolo export model=best.pt format=engine device=0

# 匯出為 NCNN 格式（ARM CPU 優化）
yolo export model=best.pt format=ncnn

# 或使用 TFLite
yolo export model=best.pt format=tflite

# realtime_detect.py - 即時攝影機偵測
import cv2
from ultralytics import YOLO
import time

def main():
    # 載入模型
    model = YOLO('best.pt')  # 或 best.onnx, best.engine

    # 開啟攝影機
    cap = cv2.VideoCapture(0)  # 0 = 預設攝影機
    cap.set(cv2.CAP_PROP_FRAME_WIDTH, 640)
    cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 480)

    # FPS 計算
    prev_time = time.time()

    while True:
        ret, frame = cap.read()
        if not ret:
            break

        # 執行偵測
        results = model(frame, verbose=False)

        # 在畫面上繪製結果
        annotated_frame = results[0].plot()

        # 計算並顯示 FPS
        curr_time = time.time()
        fps = 1 / (curr_time - prev_time)
        prev_time = curr_time
        cv2.putText(annotated_frame, f'FPS: {fps:.1f}', (10, 30),
                    cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2)

        # 顯示結果
        cv2.imshow('YOLO Detection', annotated_frame)

        # 按 'q' 退出
        if cv2.waitKey(1) & 0xFF == ord('q'):
            break

    cap.release()
    cv2.destroyAllWindows()

if __name__ == '__main__':
    main()

# 使用較小的輸入尺寸
results = model(frame, imgsz=320)  # 預設是 640

frame_count = 0
skip_frames = 2  # 每 3 幀偵測 1 次

while True:
    ret, frame = cap.read()
    frame_count += 1

    if frame_count % (skip_frames + 1) == 0:
        results = model(frame)
        last_results = results

    # 使用上次的結果繪製
    if last_results:
        annotated_frame = last_results[0].plot()

import threading
from queue import Queue

class VideoStream:
    def __init__(self, src=0):
        self.cap = cv2.VideoCapture(src)
        self.queue = Queue(maxsize=2)
        self.stopped = False

    def start(self):
        threading.Thread(target=self._update, daemon=True).start()
        return self

    def _update(self):
        while not self.stopped:
            ret, frame = self.cap.read()
            if not self.queue.full():
                self.queue.put(frame)

    def read(self):
        return self.queue.get()

    def stop(self):
        self.stopped = True

# 使用方式
stream = VideoStream(0).start()
while True:
    frame = stream.read()
    results = model(frame)

# benchmark.py - 效能測試
from ultralytics import YOLO
import time
import numpy as np

def benchmark(model_path, num_iterations=100):
    model = YOLO(model_path)

    # 使用假圖片測試
    dummy_input = np.random.randint(0, 255, (640, 640, 3), dtype=np.uint8)

    # 暖機（讓 GPU 進入工作狀態）
    for _ in range(10):
        model(dummy_input, verbose=False)

    # 正式測試
    times = []
    for _ in range(num_iterations):
        start = time.time()
        model(dummy_input, verbose=False)
        times.append(time.time() - start)

    times = np.array(times) * 1000  # 轉換為毫秒

    print(f"模型: {model_path}")
    print(f"平均延遲: {times.mean():.2f} ms")
    print(f"標準差: {times.std():.2f} ms")
    print(f"FPS: {1000 / times.mean():.1f}")
    print(f"最快: {times.min():.2f} ms")
    print(f"最慢: {times.max():.2f} ms")

# 比較不同格式
benchmark('best.pt')
benchmark('best.onnx')
benchmark('best.engine')  # 需要 TensorRT

模型: best.pt
平均延遲: 12.45 ms
標準差: 1.23 ms
FPS: 80.3
最快: 10.21 ms
最慢: 18.67 ms

模型: best.engine
平均延遲: 4.32 ms
標準差: 0.45 ms
FPS: 231.5
最快: 3.89 ms
最慢: 5.67 ms

錯誤訊息: TensorRT export requires TensorRT>=7.0.0

# 安裝 TensorRT
pip install tensorrt

# 或者在 Jetson 上使用系統自帶的 TensorRT

# 指定 opset 版本
yolo export model=best.pt format=onnx opset=12

部署前檢查
[ ] 模型已匯出為目標格式
[ ] 在目標硬體上測試過效能
[ ] FPS 符合應用需求
[ ] 記憶體使用在合理範圍
[ ] 錯誤處理機制已實作
[ ] 有監控和日誌機制
[ ] 已準備回滾方案

yolo train data=data.yaml model=yolov8n.pt epochs=100

讓我們拆解這個指令的每個部分：

data.yaml 的結構

這個檔案告訴 YOLO 你的資料集在哪裡：

# data.yaml
path: /path/to/dataset    # 資料集根目錄
train: images/train       # 訓練圖片目錄（相對於 path）
val: images/val           # 驗證圖片目錄
test: images/test         # 測試圖片目錄（選填）

# 類別定義
names:
  0: person
  1: car
  2: dog

當你看到這個檔案時，重點關注：

• path：確認這個路徑是否正確指向你的資料集
• names：類別 ID 必須從 0 開始，且與標註檔案中的 ID 一致

預訓練權重：遷移學習的起點

什麼是遷移學習？

遷移學習是指利用已經在大量資料上訓練好的模型，作為你自己任務的起點。

從頭訓練        遷移學習

隨機權重        預訓練權重
    |               |
    v               v
  需要              需要
大量資料          較少資料
長時間訓練        短時間微調

預訓練權重的選擇

YOLOv8 提供不同大小的預訓練模型：

# 最小最快（推薦新手開始）
yolo train model=yolov8n.pt ...

# 中等大小
yolo train model=yolov8s.pt ...
yolo train model=yolov8m.pt ...

# 最大最準（需要更多資源）
yolo train model=yolov8l.pt ...
yolo train model=yolov8x.pt ...

選擇建議：

• 資料集 < 1000 張：使用 yolov8n.pt 或 yolov8s.pt
• 資料集 1000-5000 張：使用 yolov8s.pt 或 yolov8m.pt
• 資料集 > 5000 張：可以嘗試更大的模型

從頭訓練 vs 遷移學習

# 遷移學習：使用預訓練權重（.pt 檔案）
yolo train model=yolov8n.pt data=data.yaml

# 從頭訓練：只使用模型架構（.yaml 檔案）
yolo train model=yolov8n.yaml data=data.yaml

實務上，除非你的任務非常特殊（例如醫療影像），否則幾乎都應該使用遷移學習。

重要的超參數

超參數是訓練前需要設定的參數，它們會影響訓練的效果和速度。

epochs（訓練週期）

yolo train ... epochs=100

• 意義：模型會看過整個資料集幾次
• 太少：模型還沒學好（欠擬合）
• 太多：模型記住訓練資料但無法泛化（過擬合）
• 建議起始值：100-300

batch（批次大小）

yolo train ... batch=16

• 意義：每次更新權重前，模型會看幾張圖片
• 太小：訓練不穩定，權重更新方向不準
• 太大：需要更多 GPU 記憶體
• 建議：根據 GPU 記憶體選擇（8GB GPU 約用 batch=8-16）

使用自動批次大小：

yolo train ... batch=-1  # 自動選擇最大可用 batch size

imgsz（圖片尺寸）

yolo train ... imgsz=640

• 意義：訓練時將圖片縮放到的尺寸
• 較大：能偵測更小的物件，但需要更多記憶體
• 較小：訓練更快，但可能遺漏小物件
• 常見值：640（預設）、416、320

lr0（初始學習率）

yolo train ... lr0=0.01

• 意義：每次權重更新的幅度
• 太大：訓練不穩定，loss 跳動
• 太小：訓練太慢，可能卡在局部最小值
• 建議：通常不需調整，預設值經過優化

完整的訓練指令範例

yolo train \
  data=my_dataset.yaml \
  model=yolov8s.pt \
  epochs=150 \
  batch=16 \
  imgsz=640 \
  patience=50 \
  project=runs/detect \
  name=my_experiment

新增的參數說明：

• patience=50：如果驗證指標 50 個 epoch 沒進步，提前停止
• project 和 name：指定訓練結果的儲存位置

訓練過程監控

當訓練開始後，你會看到類似這樣的輸出：

      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size
      1/100      3.42G      1.234      2.156      1.532        142        640
      2/100      3.42G      1.198      1.987      1.489        156        640
      ...

理解 Loss 數值

YOLO 的訓練會顯示三種 loss：

box_loss    物件框定位的損失
            ↓ 數值越低，框的位置越準

cls_loss    分類的損失
            ↓ 數值越低，類別判斷越準

dfl_loss    分佈焦點損失（YOLOv8 特有）
            ↓ 數值越低，框的邊界越精確

健康的訓練趨勢：

• 三種 loss 都應該逐漸下降
• 下降速度會越來越慢（這是正常的）
• 如果 loss 突然上升或劇烈震盪，可能需要調整學習率

解讀 mAP 指標

每個 epoch 結束後，YOLO 會在驗證集上計算 mAP：

                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95)
                   all        200        542      0.812      0.756      0.789      0.523
                person        200        312      0.856      0.801      0.834      0.578
                   car        200        230      0.768      0.711      0.744      0.468

mAP50-95 是最嚴格的指標，通常數值會比 mAP50 低 0.2-0.3。

驗證與測試

val 和 test 的差別

訓練集 (train)
├── 用於訓練模型
└── 模型直接從這裡學習

驗證集 (val)
├── 用於訓練中的評估
├── 影響 early stopping
└── 幫助調整超參數

測試集 (test)
├── 完全不參與訓練
├── 最後評估模型真實能力
└── 模擬實際應用場景

訓練完成後的驗證

# 使用驗證集評估
yolo val model=runs/detect/my_experiment/weights/best.pt data=data.yaml

# 使用測試集評估（如果有的話）
yolo val model=best.pt data=data.yaml split=test

訓練結果解讀

訓練完成後，YOLO 會在指定目錄產生以下檔案：

runs/detect/my_experiment/
├── weights/
│   ├── best.pt          # 驗證集上表現最好的權重
│   └── last.pt          # 最後一個 epoch 的權重
├── results.csv          # 每個 epoch 的指標
├── results.png          # 訓練曲線圖
├── confusion_matrix.png # 混淆矩陣
├── F1_curve.png         # F1 分數曲線
├── PR_curve.png         # Precision-Recall 曲線
└── ...

關鍵檔案說明

best.pt vs last.pt

best.pt  →  驗證集上 mAP 最高的那個 epoch 的權重
            （推薦用於部署）

last.pt  →  訓練結束時的權重
            （用於繼續訓練）

results.png 訓練曲線

這張圖包含多個子圖，重點關注：

• Loss 曲線：應該穩定下降
• mAP 曲線：應該穩定上升
• train vs val：兩者的差距反映過擬合程度

常見問題排解

過擬合（Overfitting）

症狀：

• 訓練 loss 持續下降
• 驗證 loss 開始上升
• 驗證 mAP 不再進步

解決方法：

# 1. 減少訓練週期
yolo train ... epochs=50

# 2. 增加資料增強
yolo train ... augment=True

# 3. 使用更簡單的模型
yolo train ... model=yolov8n.pt  # 改用較小的模型

# 4. 增加資料集（治本方法）

欠擬合（Underfitting）

症狀：

• 訓練 loss 居高不下
• 驗證 mAP 很低

解決方法：

# 1. 增加訓練週期
yolo train ... epochs=300

# 2. 使用更大的模型
yolo train ... model=yolov8m.pt

# 3. 提高學習率（小心調整）
yolo train ... lr0=0.02

# 4. 檢查資料標註是否正確

訓練不穩定

症狀：

• Loss 劇烈震盪
• 訓練過程中 mAP 忽高忽低

解決方法：

# 1. 降低學習率
yolo train ... lr0=0.001

# 2. 增加 batch size（如果記憶體允許）
yolo train ... batch=32

# 3. 使用 warmup（預設已啟用）
yolo train ... warmup_epochs=3

GPU 記憶體不足

錯誤訊息：CUDA out of memory

解決方法：

# 1. 減少 batch size
yolo train ... batch=4

# 2. 減少圖片尺寸
yolo train ... imgsz=416

# 3. 使用更小的模型
yolo train ... model=yolov8n.pt

繼續訓練（Resume）

如果訓練中斷，可以從上次停止的地方繼續：

yolo train resume=True model=runs/detect/my_experiment/weights/last.pt

這會載入 last.pt 並繼續訓練，包括：

• 權重狀態
• 優化器狀態
• 已完成的 epoch 數

實戰檢查清單

訓練前的確認事項：

□ data.yaml 路徑是否正確
□ 類別 ID 是否從 0 開始
□ 標註檔案是否與圖片對應
□ 訓練/驗證集是否有合理分割
□ GPU 記憶體是否足夠

訓練中的觀察重點：

□ Loss 是否穩定下降
□ 驗證 mAP 是否逐步提升
□ GPU 記憶體使用是否穩定
□ 沒有 NaN 或 Inf 出現

訓練後的評估：

□ 使用 best.pt 而非 last.pt
□ 在測試集上驗證最終效果
□ 查看混淆矩陣找出弱點類別
□ 視覺化幾張預測結果確認品質

小結

本篇文章涵蓋了 YOLO 模型訓練的完整流程：

• 基本指令：yolo train data=... model=... epochs=...
• 遷移學習：使用 .pt 預訓練權重可以大幅加速訓練
• 超參數：epochs、batch、imgsz、lr0 是最重要的參數
• 監控訓練：關注 loss 下降和 mAP 上升的趨勢
• 問題排解：過擬合、欠擬合、訓練不穩定各有對策

下一篇文章，我們將學習如何將訓練好的模型部署到實際應用中。

延伸閱讀

• Ultralytics 官方訓練文件
• 超參數調優指南

Epoch 1/100:  box_loss=1.52, cls_loss=2.34, mAP50=0.12
Epoch 20/100: box_loss=0.85, cls_loss=1.12, mAP50=0.58
Epoch 40/100: box_loss=0.42, cls_loss=0.65, mAP50=0.72
Epoch 60/100: box_loss=0.28, cls_loss=0.41, mAP50=0.71
Epoch 80/100: box_loss=0.15, cls_loss=0.22, mAP50=0.69
Epoch 100/100: box_loss=0.08, cls_loss=0.12, mAP50=0.65

path: /home/user/dataset
train: train/images
val: validation/images

names:
  1: cat
  2: dog
  3: bird

0 0.5 0.5 0.3 0.4
1 0.2 0.3 0.1 0.15

Class      Images  Instances   P       R     mAP50  mAP50-95
all          500      1200   0.85    0.72    0.79     0.52
person       500       600   0.92    0.88    0.91     0.68
car          500       400   0.88    0.75    0.82     0.55
bicycle      500       200   0.75    0.53    0.64     0.33

pip install labelImg

啟動方式：

labelImg

操作流程：

1. 開啟圖片資料夾（Open Dir）
2. 設定輸出格式為 YOLO（左側選單）
3. 按 W 鍵開始畫框
4. 選擇類別名稱
5. 按 Ctrl+S 儲存標註

小提醒：LabelImg 會為每張圖片產生一個同名的 .txt 檔案。

2. Roboflow（雲端、有免費方案）

Roboflow 是一站式的資料集管理平台，特別適合團隊協作。

優點：

• 網頁介面，不需安裝
• 自動資料增強功能
• 支援多種匯出格式
• 提供預訓練資料集

使用流程：

1. 建立帳號並新增專案
2. 上傳圖片
3. 在網頁上進行標註
4. 匯出為 YOLOv8 格式

3. CVAT（自建或雲端、開源免費）

CVAT（Computer Vision Annotation Tool）是 Intel 開發的開源標註工具，功能最完整。

適合場景：

• 大型專案、需要多人協作
• 需要影片標註功能
• 企業內部自建標註系統

本地部署（使用 Docker）：

git clone https://github.com/opencv/cvat.git
cd cvat
docker compose up -d

二、YOLO 標註格式解析

YOLO 的標註格式是一種簡潔的純文字格式，每張圖片對應一個 .txt 檔案。

格式結構

每一行代表一個物件，格式為：

<class_id> <x_center> <y_center> <width> <height>

各欄位說明：

正規化座標的意義

「正規化」是指將實際像素座標除以圖片的寬度或高度。這樣做的好處是：

• 不同尺寸的圖片可以使用相同的座標系統
• 訓練時圖片縮放不會影響標註

計算公式：

x_center = (x_min + x_max) / 2 / image_width
y_center = (y_min + y_max) / 2 / image_height
width = (x_max - x_min) / image_width
height = (y_max - y_min) / image_height

實際範例

假設有一張 640×480 的圖片，上面有一隻貓（類別 0），框框位置為左上角 (100, 150)，右下角 (300, 350)：

# 原始像素座標
x_min, y_min = 100, 150
x_max, y_max = 300, 350
image_width, image_height = 640, 480

# 計算正規化座標
x_center = (100 + 300) / 2 / 640  # = 0.3125
y_center = (150 + 350) / 2 / 480  # = 0.5208
width = (300 - 100) / 640          # = 0.3125
height = (350 - 150) / 480         # = 0.4167

# 標註檔內容
# 0 0.3125 0.5208 0.3125 0.4167

對應的 image001.txt 內容：

0 0.3125 0.5208 0.3125 0.4167

如果同一張圖片有多個物件，每個物件一行：

0 0.3125 0.5208 0.3125 0.4167
1 0.7500 0.6000 0.2000 0.3000

三、資料集目錄結構

YOLOv8 預期的資料集結構非常明確：

dataset/
├── data.yaml           # 資料集設定檔
├── train/
│   ├── images/         # 訓練圖片
│   │   ├── img001.jpg
│   │   ├── img002.jpg
│   │   └── ...
│   └── labels/         # 訓練標註
│       ├── img001.txt
│       ├── img002.txt
│       └── ...
├── valid/
│   ├── images/         # 驗證圖片
│   └── labels/         # 驗證標註
└── test/               # （選用）測試集
    ├── images/
    └── labels/

關鍵規則：

• 圖片和標註檔必須同名（只有副檔名不同）
• images/ 和 labels/ 資料夾必須在同一層目錄下
• 沒有物件的圖片，對應的 .txt 檔可以是空的（或不建立）

四、data.yaml 設定檔

data.yaml 是告訴 YOLO 資料集在哪裡、有哪些類別的設定檔。

基本結構

# 資料集路徑（可用絕對或相對路徑）
path: /path/to/dataset    # 資料集根目錄
train: train/images       # 訓練集相對於 path 的路徑
val: valid/images         # 驗證集相對於 path 的路徑
test: test/images         # （選用）測試集

# 類別定義
names:
  0: cat
  1: dog
  2: bird

實際範例：寵物偵測資料集

path: ./pet_dataset
train: train/images
val: valid/images

names:
  0: cat
  1: dog
  2: rabbit
  3: hamster

使用這個設定檔訓練

from ultralytics import YOLO

model = YOLO('yolov8n.pt')
results = model.train(data='pet_dataset/data.yaml', epochs=100)

五、格式轉換

如果你的標註檔是其他格式（例如 COCO、Pascal VOC），需要轉換為 YOLO 格式。

COCO 格式轉 YOLO 格式

COCO 格式使用 JSON 檔案，標註是絕對像素座標：

{
  "images": [...],
  "annotations": [
    {
      "image_id": 1,
      "category_id": 1,
      "bbox": [100, 150, 200, 200]  // [x, y, width, height]
    }
  ],
  "categories": [...]
}

轉換腳本：

import json
import os

def coco_to_yolo(coco_json_path, output_dir, image_dir):
    """將 COCO 格式轉換為 YOLO 格式"""

    with open(coco_json_path, 'r') as f:
        coco_data = json.load(f)

    # 建立圖片 ID 到檔名和尺寸的映射
    images = {img['id']: img for img in coco_data['images']}

    # 建立類別 ID 映射（COCO 類別 ID 可能不連續）
    category_map = {cat['id']: idx for idx, cat in enumerate(coco_data['categories'])}

    # 依照圖片分組標註
    annotations_by_image = {}
    for ann in coco_data['annotations']:
        img_id = ann['image_id']
        if img_id not in annotations_by_image:
            annotations_by_image[img_id] = []
        annotations_by_image[img_id].append(ann)

    os.makedirs(output_dir, exist_ok=True)

    # 轉換每張圖片的標註
    for img_id, img_info in images.items():
        img_w = img_info['width']
        img_h = img_info['height']
        file_name = os.path.splitext(img_info['file_name'])[0]

        yolo_lines = []
        for ann in annotations_by_image.get(img_id, []):
            # COCO bbox: [x, y, width, height]（左上角座標）
            x, y, w, h = ann['bbox']

            # 轉換為 YOLO 格式（中心點、正規化）
            x_center = (x + w / 2) / img_w
            y_center = (y + h / 2) / img_h
            width = w / img_w
            height = h / img_h

            class_id = category_map[ann['category_id']]
            yolo_lines.append(f"{class_id} {x_center:.6f} {y_center:.6f} {width:.6f} {height:.6f}")

        # 寫入 YOLO 標註檔
        output_path = os.path.join(output_dir, f"{file_name}.txt")
        with open(output_path, 'w') as f:
            f.write('\n'.join(yolo_lines))

# 使用方式
coco_to_yolo(
    'annotations.json',
    'labels/',
    'images/'
)

Pascal VOC 格式轉 YOLO 格式

Pascal VOC 使用 XML 檔案，每張圖片一個：

<annotation>
  <size>
    <width>640</width>
    <height>480</height>
  </size>
  <object>
    <name>cat</name>
    <bndbox>
      <xmin>100</xmin>
      <ymin>150</ymin>
      <xmax>300</xmax>
      <ymax>350</ymax>
    </bndbox>
  </object>
</annotation>

轉換腳本：

import xml.etree.ElementTree as ET
import os

def voc_to_yolo(xml_path, class_names):
    """將單個 VOC XML 轉換為 YOLO 格式字串"""

    tree = ET.parse(xml_path)
    root = tree.getroot()

    # 取得圖片尺寸
    size = root.find('size')
    img_w = int(size.find('width').text)
    img_h = int(size.find('height').text)

    yolo_lines = []
    for obj in root.findall('object'):
        class_name = obj.find('name').text
        if class_name not in class_names:
            continue

        class_id = class_names.index(class_name)

        bbox = obj.find('bndbox')
        xmin = float(bbox.find('xmin').text)
        ymin = float(bbox.find('ymin').text)
        xmax = float(bbox.find('xmax').text)
        ymax = float(bbox.find('ymax').text)

        # 轉換為 YOLO 格式
        x_center = (xmin + xmax) / 2 / img_w
        y_center = (ymin + ymax) / 2 / img_h
        width = (xmax - xmin) / img_w
        height = (ymax - ymin) / img_h

        yolo_lines.append(f"{class_id} {x_center:.6f} {y_center:.6f} {width:.6f} {height:.6f}")

    return '\n'.join(yolo_lines)

# 批次轉換
def batch_convert_voc_to_yolo(voc_dir, output_dir, class_names):
    os.makedirs(output_dir, exist_ok=True)

    for xml_file in os.listdir(voc_dir):
        if not xml_file.endswith('.xml'):
            continue

        xml_path = os.path.join(voc_dir, xml_file)
        yolo_content = voc_to_yolo(xml_path, class_names)

        output_path = os.path.join(output_dir, xml_file.replace('.xml', '.txt'))
        with open(output_path, 'w') as f:
            f.write(yolo_content)

# 使用方式
class_names = ['cat', 'dog', 'bird']
batch_convert_voc_to_yolo('voc_annotations/', 'yolo_labels/', class_names)

六、資料增強策略

資料增強是用程式自動產生更多變化版本的訓練資料，讓模型學到更多樣的特徵。

YOLOv8 內建的資料增強

YOLOv8 訓練時會自動套用這些增強：

from ultralytics import YOLO

model = YOLO('yolov8n.pt')

# 這些是預設值，可以自行調整
results = model.train(
    data='data.yaml',
    epochs=100,

    # 幾何變換
    flipud=0.0,        # 上下翻轉機率
    fliplr=0.5,        # 左右翻轉機率
    degrees=0.0,       # 旋轉角度範圍（-degrees ~ +degrees）
    translate=0.1,     # 平移範圍（圖片尺寸的比例）
    scale=0.5,         # 縮放範圍
    shear=0.0,         # 剪切角度
    perspective=0.0,   # 透視變換

    # 色彩變換
    hsv_h=0.015,       # 色相變化範圍
    hsv_s=0.7,         # 飽和度變化範圍
    hsv_v=0.4,         # 明度變化範圍

    # 進階增強
    mosaic=1.0,        # Mosaic 增強機率
    mixup=0.0,         # MixUp 增強機率
    copy_paste=0.0,    # Copy-Paste 增強機率
)

Mosaic 增強

Mosaic 是 YOLO 的招牌資料增強技術，將 4 張圖片拼成一張：

+--------+--------+
| 圖片 1  | 圖片 2  |
+--------+--------+
| 圖片 3  | 圖片 4  |
+--------+--------+

好處：

• 一次訓練看到更多物件
• 學習不同背景下的物件
• 提升小物件的偵測能力

MixUp 增強

MixUp 將兩張圖片「混合」（透明度疊加），標註也按比例混合：

混合圖片 = 0.5 * 圖片A + 0.5 * 圖片B

七、使用 Albumentations 進行進階資料增強

Albumentations 是專業的影像增強函式庫，可以和 YOLO 搭配使用。

安裝

pip install albumentations

基本範例：離線增強資料集

import albumentations as A
import cv2
import os

def augment_dataset(image_dir, label_dir, output_image_dir, output_label_dir, num_augmented=3):
    """對資料集進行離線增強"""

    # 定義增強流程（標註會自動轉換）
    transform = A.Compose([
        A.HorizontalFlip(p=0.5),
        A.RandomBrightnessContrast(p=0.5),
        A.GaussNoise(var_limit=(10, 50), p=0.3),
        A.Blur(blur_limit=3, p=0.2),
        A.Rotate(limit=15, p=0.3),
    ], bbox_params=A.BboxParams(
        format='yolo',           # 使用 YOLO 格式
        label_fields=['class_labels']
    ))

    os.makedirs(output_image_dir, exist_ok=True)
    os.makedirs(output_label_dir, exist_ok=True)

    for image_file in os.listdir(image_dir):
        if not image_file.lower().endswith(('.jpg', '.png', '.jpeg')):
            continue

        # 讀取圖片
        image_path = os.path.join(image_dir, image_file)
        image = cv2.imread(image_path)
        image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

        # 讀取標註
        label_file = os.path.splitext(image_file)[0] + '.txt'
        label_path = os.path.join(label_dir, label_file)

        bboxes = []
        class_labels = []
        if os.path.exists(label_path):
            with open(label_path, 'r') as f:
                for line in f:
                    parts = line.strip().split()
                    if len(parts) == 5:
                        class_id = int(parts[0])
                        bbox = [float(x) for x in parts[1:5]]
                        bboxes.append(bbox)
                        class_labels.append(class_id)

        # 儲存原始圖片
        base_name = os.path.splitext(image_file)[0]
        cv2.imwrite(
            os.path.join(output_image_dir, image_file),
            cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
        )
        if bboxes:
            with open(os.path.join(output_label_dir, label_file), 'w') as f:
                for cls, bbox in zip(class_labels, bboxes):
                    f.write(f"{cls} {bbox[0]:.6f} {bbox[1]:.6f} {bbox[2]:.6f} {bbox[3]:.6f}\n")

        # 產生增強版本
        for i in range(num_augmented):
            try:
                transformed = transform(
                    image=image,
                    bboxes=bboxes,
                    class_labels=class_labels
                )

                aug_image = transformed['image']
                aug_bboxes = transformed['bboxes']
                aug_labels = transformed['class_labels']

                # 儲存增強後的圖片
                aug_image_file = f"{base_name}_aug{i}.jpg"
                cv2.imwrite(
                    os.path.join(output_image_dir, aug_image_file),
                    cv2.cvtColor(aug_image, cv2.COLOR_RGB2BGR)
                )

                # 儲存增強後的標註
                aug_label_file = f"{base_name}_aug{i}.txt"
                with open(os.path.join(output_label_dir, aug_label_file), 'w') as f:
                    for cls, bbox in zip(aug_labels, aug_bboxes):
                        f.write(f"{cls} {bbox[0]:.6f} {bbox[1]:.6f} {bbox[2]:.6f} {bbox[3]:.6f}\n")

            except Exception as e:
                print(f"增強失敗 {image_file}: {e}")
                continue

# 使用方式
augment_dataset(
    'dataset/train/images',
    'dataset/train/labels',
    'dataset_augmented/train/images',
    'dataset_augmented/train/labels',
    num_augmented=3  # 每張圖產生 3 個增強版本
)

常用的增強組合

# 輕度增強（適合資料量充足時）
light_transform = A.Compose([
    A.HorizontalFlip(p=0.5),
    A.RandomBrightnessContrast(brightness_limit=0.1, contrast_limit=0.1, p=0.5),
], bbox_params=A.BboxParams(format='yolo', label_fields=['class_labels']))

# 中度增強（一般情況）
medium_transform = A.Compose([
    A.HorizontalFlip(p=0.5),
    A.ShiftScaleRotate(shift_limit=0.1, scale_limit=0.1, rotate_limit=15, p=0.5),
    A.RandomBrightnessContrast(p=0.5),
    A.GaussNoise(p=0.2),
], bbox_params=A.BboxParams(format='yolo', label_fields=['class_labels']))

# 重度增強（資料量不足時）
heavy_transform = A.Compose([
    A.HorizontalFlip(p=0.5),
    A.VerticalFlip(p=0.2),
    A.ShiftScaleRotate(shift_limit=0.2, scale_limit=0.3, rotate_limit=30, p=0.7),
    A.RandomBrightnessContrast(brightness_limit=0.3, contrast_limit=0.3, p=0.5),
    A.GaussNoise(var_limit=(10, 80), p=0.3),
    A.Blur(blur_limit=5, p=0.3),
    A.CLAHE(p=0.2),
    A.HueSaturationValue(p=0.3),
], bbox_params=A.BboxParams(format='yolo', label_fields=['class_labels']))

八、實作練習：準備一個完整資料集

以下是準備資料集的完整流程：

步驟 1：收集圖片

# 假設你已經有一批圖片在 raw_images/ 資料夾
import os
import shutil

def organize_images(source_dir, dest_dir, train_ratio=0.8):
    """將圖片分成訓練集和驗證集"""

    images = [f for f in os.listdir(source_dir)
              if f.lower().endswith(('.jpg', '.png', '.jpeg'))]

    # 隨機打亂
    import random
    random.shuffle(images)

    # 計算分割點
    split_idx = int(len(images) * train_ratio)
    train_images = images[:split_idx]
    valid_images = images[split_idx:]

    # 建立目錄結構
    for split, image_list in [('train', train_images), ('valid', valid_images)]:
        img_dir = os.path.join(dest_dir, split, 'images')
        lbl_dir = os.path.join(dest_dir, split, 'labels')
        os.makedirs(img_dir, exist_ok=True)
        os.makedirs(lbl_dir, exist_ok=True)

        for img in image_list:
            shutil.copy(
                os.path.join(source_dir, img),
                os.path.join(img_dir, img)
            )

    print(f"訓練集：{len(train_images)} 張")
    print(f"驗證集：{len(valid_images)} 張")

organize_images('raw_images/', 'my_dataset/')

步驟 2：使用 LabelImg 標註

# 啟動 LabelImg
labelImg my_dataset/train/images my_dataset/classes.txt my_dataset/train/labels

classes.txt 內容（每行一個類別）：

cat
dog
bird

步驟 3：建立 data.yaml

# 自動產生 data.yaml
def create_data_yaml(dataset_dir, class_names, output_path):
    import yaml

    data = {
        'path': os.path.abspath(dataset_dir),
        'train': 'train/images',
        'val': 'valid/images',
        'names': {i: name for i, name in enumerate(class_names)}
    }

    with open(output_path, 'w') as f:
        yaml.dump(data, f, default_flow_style=False, allow_unicode=True)

    print(f"data.yaml 已建立：{output_path}")

create_data_yaml(
    'my_dataset/',
    ['cat', 'dog', 'bird'],
    'my_dataset/data.yaml'
)

步驟 4：驗證資料集

def validate_dataset(data_yaml_path):
    """檢查資料集的完整性"""
    import yaml

    with open(data_yaml_path, 'r') as f:
        data = yaml.safe_load(f)

    base_path = data['path']

    for split in ['train', 'val']:
        img_dir = os.path.join(base_path, data[split])
        lbl_dir = img_dir.replace('images', 'labels')

        images = set(os.path.splitext(f)[0] for f in os.listdir(img_dir)
                    if f.lower().endswith(('.jpg', '.png', '.jpeg')))
        labels = set(os.path.splitext(f)[0] for f in os.listdir(lbl_dir)
                    if f.endswith('.txt'))

        missing_labels = images - labels
        orphan_labels = labels - images

        print(f"\n{split} 資料集：")
        print(f"  圖片數量：{len(images)}")
        print(f"  標註數量：{len(labels)}")

        if missing_labels:
            print(f"  缺少標註：{len(missing_labels)} 個")
        if orphan_labels:
            print(f"  孤立標註：{len(orphan_labels)} 個")

validate_dataset('my_dataset/data.yaml')

總結

這篇文章涵蓋了資料集準備的完整流程：

下一篇我們會進入模型訓練，學習如何調整超參數、監控訓練過程，以及處理常見的訓練問題。

延伸資源

• LabelImg GitHub
• Roboflow 官網
• CVAT 官方文件
• Albumentations 文件
• Ultralytics 資料集格式說明

# 配置 A
mosaic=1.0, mixup=0.5

# 配置 B
mosaic=0.0, hsv_h=0.015

# 配置 C
fliplr=0.5, degrees=45

# 配置 D
mosaic=0.0, mixup=0.0, fliplr=0.5

def voc_to_yolo(xml_path, class_names):
    tree = ET.parse(xml_path)
    root = tree.getroot()
    size = root.find('size')
    img_w = int(size.find('width').text)
    img_h = int(size.find('height').text)

    for obj in root.findall('object'):
        class_name = obj.find('name').text
        class_id = class_names.index(class_name)  # <-- 這行
        # ... 後續處理

Python 3.8 以上（建議 3.10 或 3.11）

python --version
# 輸出範例：Python 3.11.4

nvidia-smi

+-----------------------------------------------------------------------------+
| NVIDIA-SMI 535.104.05   Driver Version: 535.104.05   CUDA Version: 12.2    |
|-------------------------------+----------------------+----------------------+
| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |
| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |
|===============================+======================+======================|
|   0  NVIDIA GeForce ...  Off  | 00000000:01:00.0  On |                  N/A |
+-------------------------------+----------------------+----------------------+

pip install ultralytics

from ultralytics import YOLO
print("Ultralytics 安裝成功！")

yolo version
# 輸出範例：8.0.200

from ultralytics import YOLO

# 第一次執行會自動下載 yolov8n.pt
model = YOLO("yolov8n.pt")

yolo predict model=yolov8n.pt source=https://ultralytics.com/images/bus.jpg

yolo predict model=模型檔 source=輸入來源

yolo predict model=yolov8n.pt source=image.jpg

yolo predict model=yolov8n.pt source=./images/

yolo predict model=yolov8n.pt source=video.mp4

yolo predict model=yolov8n.pt source=0

yolo predict model=yolov8n.pt source=image.jpg conf=0.5

yolo predict model=yolov8n.pt source=image.jpg project=output name=my_result

from ultralytics import YOLO

# 載入預訓練模型
model = YOLO("yolov8n.pt")

# 執行偵測
results = model("image.jpg")

# 顯示結果
results[0].show()

from ultralytics import YOLO

model = YOLO("yolov8n.pt")
results = model("image.jpg")

# 儲存標註後的圖片
results[0].save("output.jpg")

from ultralytics import YOLO

model = YOLO("yolov8n.pt")
results = model("image.jpg")

# 取得第一張圖的結果
result = results[0]

# 遍歷每個偵測到的物件
for box in result.boxes:
    # 取得 bounding box 座標 (x1, y1, x2, y2)
    coords = box.xyxy[0].tolist()
    x1, y1, x2, y2 = coords

    # 取得信心度（0-1 之間）
    confidence = box.conf[0].item()

    # 取得類別 ID
    class_id = int(box.cls[0].item())

    # 取得類別名稱
    class_name = result.names[class_id]

    print(f"偵測到：{class_name}")
    print(f"  位置：({x1:.0f}, {y1:.0f}) 到 ({x2:.0f}, {y2:.0f})")
    print(f"  信心度：{confidence:.2%}")
    print()

偵測到：person
  位置：(42, 85) 到 (198, 520)
  信心度：92.34%

偵測到：car
  位置：(320, 200) 到 (580, 380)
  信心度：87.65%

box.xyxy  # tensor([[x1, y1, x2, y2]])

box.xywh  # tensor([[cx, cy, w, h]])

box.conf  # tensor([0.9234])

# 類別 ID（整數）
box.cls  # tensor([0])  # 0 = person

# 查詢類別名稱
result.names[0]  # 'person'

from ultralytics import YOLO
model = YOLO("yolov8n.pt")
print(model.names)

from ultralytics import YOLO

def detect_objects(image_path, conf_threshold=0.5):
    """偵測圖片中的物件並列出結果"""

    # 載入模型
    model = YOLO("yolov8n.pt")

    # 執行偵測，設定信心閾值
    results = model(image_path, conf=conf_threshold)

    # 取得結果
    result = results[0]

    # 統計各類別數量
    counts = {}

    for box in result.boxes:
        class_id = int(box.cls[0].item())
        class_name = result.names[class_id]
        confidence = box.conf[0].item()

        # 統計
        counts[class_name] = counts.get(class_name, 0) + 1

        # 印出詳細資訊
        coords = box.xyxy[0].tolist()
        print(f"{class_name}: {confidence:.1%} @ {[int(c) for c in coords]}")

    print(f"\n總共偵測到 {len(result.boxes)} 個物件")
    print("各類別數量:", counts)

    # 儲存標註後的圖片
    result.save("detected.jpg")
    print("結果已儲存到 detected.jpg")

# 使用範例
detect_objects("street.jpg")

results = model("image.jpg", imgsz=640)  # 預設 640，可以改小

第一階段：區域提議網路（RPN）
├── 掃描整張圖片
├── 產生數千個「可能有物體」的候選區域
└── 輸出候選框（Region Proposals）

第二階段：分類與精修
├── 對每個候選區域進行分類
├── 精修邊界框座標
└── 輸出最終偵測結果

YOLO 的處理流程
├── 輸入圖片
├── 通過單一卷積神經網路
└── 直接輸出所有物體的位置和類別

┌───┬───┬───┬───┬───┬───┬───┐
│   │   │   │   │   │   │   │
├───┼───┼───┼───┼───┼───┼───┤
│   │   │ * │   │   │   │   │  ← 物體中心落在這個格子
├───┼───┼───┼───┼───┼───┼───┤
│   │   │   │   │   │   │   │
├───┼───┼───┼───┼───┼───┼───┤
│   │   │   │   │   │   │   │
├───┼───┼───┼───┼───┼───┼───┤
│   │   │   │   │   │   │   │
├───┼───┼───┼───┼───┼───┼───┤
│   │   │   │   │   │   │   │
├───┼───┼───┼───┼───┼───┼───┤
│   │   │   │   │   │   │   │
└───┴───┴───┴───┴───┴───┴───┘

# 邊界框的 5 個預測值
bounding_box = {
    'x': 0.5,        # 邊界框中心的 x 座標（相對於網格）
    'y': 0.3,        # 邊界框中心的 y 座標（相對於網格）
    'w': 0.4,        # 邊界框寬度（相對於整張圖）
    'h': 0.6,        # 邊界框高度（相對於整張圖）
    'confidence': 0.85  # 信心分數：這個框包含物體的機率
}

# 假設有 3 個類別
class_probabilities = {
    'car': 0.8,
    'person': 0.1,
    'dog': 0.1
}

對於 7x7 網格、2 個邊界框、20 個類別：
輸出形狀 = 7 x 7 x (2 * 5 + 20) = 7 x 7 x 30

NMS 流程：
1. 按信心分數排序所有偵測框
2. 選取信心最高的框
3. 移除與該框重疊度（IoU）過高的其他框
4. 重複步驟 2-3 直到處理完所有框

YOLOv11 模型大小比較：
┌─────────┬────────────┬─────────┐
│ 模型    │ 參數量     │ mAP@50  │
├─────────┼────────────┼─────────┤
│ YOLO11n │ 2.6M       │ ~39.5%  │
│ YOLO11s │ 9.4M       │ ~47.0%  │
│ YOLO11m │ 20.1M      │ ~50.3%  │
└─────────┴────────────┴─────────┘

┌─────────────────────────────────────────────────┐
│                                                 │
│  高準確度                                        │
│     ▲                                           │
│     │           ┌───────────────┐               │
│     │           │ Faster R-CNN  │               │
│     │           └───────────────┘               │
│     │                                           │
│     │                    ┌───────────┐          │
│     │                    │ YOLOv8    │          │
│     │                    └───────────┘          │
│     │                                           │
│     │    ┌───────────┐                          │
│     │    │ YOLOv1    │                          │
│     │    └───────────┘                          │
│     │                                           │
│     └───────────────────────────────────► 高速度 │
│                                                 │
└─────────────────────────────────────────────────┘

from ultralytics import YOLO

# 載入模型
model = YOLO('yolo11n.pt')

# 執行推論
results = model('image.jpg')

# 解析結果
for result in results:
    boxes = result.boxes      # 邊界框資訊
    for box in boxes:
        xyxy = box.xyxy      # [x1, y1, x2, y2] 座標
        conf = box.conf      # 信心分數
        cls = box.cls        # 類別編號