first commit
This commit is contained in:
hatcher committed
commit
b680e09bbe
568 files changed
+54067
No files matched your search
@@ -0,0 +1,66 @@
|
||||
# UAV Drone Inference Package
|
||||
|
||||
这是无人机检测追踪推理包，可迁移到另一台机器做二次开发。
|
||||
|
||||
## 内容
|
||||
|
||||
- `run_detect_track.py`: 推理入口
|
||||
- `src/`: 检测、追踪、可视化代码
|
||||
- `ultralytics/`: 本项目使用的本地 YOLO 代码
|
||||
- `weights/uav_drone_yolov8s_best.pt`: 已训练好的无人机检测权重
|
||||
- `ykz.png`: 右上角 logo
|
||||
- `test_video/`: 原始测试视频
|
||||
- `scripts/run_demo.sh`: 一键运行示例
|
||||
|
||||
## 环境
|
||||
|
||||
先安装适配当前机器的 PyTorch/torchvision。RK3588 上建议使用该系统/板卡对应的 PyTorch wheel。
|
||||
|
||||
然后安装 Python 依赖：
|
||||
|
||||
```bash
|
||||
cd /data/uav-smart-detect/inference_uav_rk3588
|
||||
python3 -m pip install -r requirements.txt
|
||||
```
|
||||
|
||||
## 运行
|
||||
|
||||
```bash
|
||||
cd /data/uav-smart-detect/inference_uav_rk3588
|
||||
bash scripts/run_demo.sh
|
||||
```
|
||||
|
||||
输出在：
|
||||
|
||||
```text
|
||||
outputs/
|
||||
```
|
||||
|
||||
包括：
|
||||
|
||||
- `*_tracked.mp4`: 带检测框、轨迹、ID、logo 的视频
|
||||
- `*_tracks.csv`: 每帧追踪结果
|
||||
|
||||
## 单视频运行示例
|
||||
|
||||
```bash
|
||||
python3 run_detect_track.py \
|
||||
--input test_video/test_video_1.mp4 \
|
||||
--output outputs_test \
|
||||
--model weights/uav_drone_yolov8s_best.pt \
|
||||
--logo ykz.png \
|
||||
--classes 0 \
|
||||
--display-class-name drone \
|
||||
--imgsz 1280 \
|
||||
--conf 0.12 \
|
||||
--display-conf 0.32 \
|
||||
--det-iou 0.50 \
|
||||
--tracker motion \
|
||||
--stitch-ids
|
||||
```
|
||||
|
||||
如果需要更少漏检，可以增加：
|
||||
|
||||
```bash
|
||||
--rescue-detections --rescue-conf 0.45
|
||||
```
|
||||
@@ -0,0 +1,12 @@
|
||||
opencv-python-headless>=4.9.0
|
||||
numpy>=1.24.0
|
||||
scipy>=1.10.0
|
||||
PyYAML>=6.0
|
||||
tqdm>=4.66.0
|
||||
requests>=2.31.0
|
||||
pillow>=10.0.0
|
||||
matplotlib>=3.7.0
|
||||
pandas>=2.0.0
|
||||
seaborn>=0.13.0
|
||||
psutil>=5.9.0
|
||||
py-cpuinfo>=9.0.0
|
||||
Executable
+522
@@ -0,0 +1,522 @@
|
||||
#!/usr/bin/env python3
|
||||
from __future__ import annotations
|
||||
|
||||
import argparse
|
||||
import csv
|
||||
import math
|
||||
import time
|
||||
from pathlib import Path
|
||||
|
||||
|
||||
VIDEO_EXTENSIONS = {".mp4", ".mov", ".avi", ".mkv", ".m4v"}
|
||||
|
||||
|
||||
def parse_args() -> argparse.Namespace:
|
||||
parser = argparse.ArgumentParser(description="UAV video multi-object detection and tracking.")
|
||||
parser.add_argument("--input", default="test_video", help="Input video file or directory.")
|
||||
parser.add_argument("--output", default="outputs", help="Output directory.")
|
||||
parser.add_argument("--model", default="yolov8n.pt", help="YOLO model path, e.g. yolov8n.pt or custom.pt.")
|
||||
parser.add_argument("--imgsz", type=int, default=1280, help="YOLO inference image size.")
|
||||
parser.add_argument("--conf", type=float, default=0.25, help="Detection confidence threshold.")
|
||||
parser.add_argument("--det-iou", type=float, default=0.45, help="YOLO NMS IoU threshold.")
|
||||
parser.add_argument("--display-conf", type=float, default=0.25, help="Minimum tracked score to draw and write.")
|
||||
parser.add_argument("--display-min-hits", type=int, default=1, help="Visible frames required before drawing/writing a track.")
|
||||
parser.add_argument("--rescue-detections", action="store_true", help="Show high-confidence detections missed by the tracker.")
|
||||
parser.add_argument("--rescue-conf", type=float, default=0.45, help="Minimum score for tracker-missed detection rescue.")
|
||||
parser.add_argument("--rescue-max-missed", type=int, default=20, help="Frames to keep a rescue track alive while unmatched.")
|
||||
parser.add_argument("--track-nms-iou", type=float, default=0.55, help="Suppress duplicate visible tracks above this IoU.")
|
||||
parser.add_argument("--track-nms-center", type=float, default=0.65, help="Suppress duplicate tracks with very close centers.")
|
||||
parser.add_argument("--single-target", action="store_true", help="Keep one visible target and stabilize it as one ID.")
|
||||
parser.add_argument("--single-target-id", type=int, default=1, help="ID shown when --single-target is enabled.")
|
||||
parser.add_argument("--stitch-ids", action="store_true", help="Merge non-overlapping tracklets when motion continuity is plausible.")
|
||||
parser.add_argument("--stitch-buffer", type=int, default=180, help="Frames to keep disappeared IDs available for stitching.")
|
||||
parser.add_argument("--stitch-min-gap", type=int, default=4, help="Minimum absent frames before a new raw track may reuse an old ID.")
|
||||
parser.add_argument(
|
||||
"--tracker",
|
||||
choices=("bytetrack", "motion", "iou"),
|
||||
default="motion",
|
||||
help="Tracking backend. bytetrack is recommended for production-style ID continuity.",
|
||||
)
|
||||
parser.add_argument("--track-iou", type=float, default=0.3, help="Tracker IoU matching threshold.")
|
||||
parser.add_argument("--max-missed", type=int, default=30, help="Frames to keep a lost track alive.")
|
||||
parser.add_argument("--reconnect-buffer", type=int, default=60, help="Frames after removal when a lost track may be reconnected.")
|
||||
parser.add_argument("--max-match-gap", type=int, default=60, help="Maximum missed frames still allowed for direct matching.")
|
||||
parser.add_argument("--min-hits", type=int, default=2, help="Matched frames required before showing a new track.")
|
||||
parser.add_argument("--new-track-conf", type=float, default=0.20, help="Minimum score allowed to start a new motion track.")
|
||||
parser.add_argument("--allow-near-new-tracks", action="store_true", help="Allow new tracks near existing tracks; useful for dense multi-UAV scenes.")
|
||||
parser.add_argument("--smooth-alpha", type=float, default=0.75, help="Motion tracker box smoothing weight for current detection.")
|
||||
parser.add_argument("--trail-length", type=int, default=80, help="Trajectory history length per target.")
|
||||
parser.add_argument("--bt-high", type=float, default=0.25, help="ByteTrack first association confidence threshold.")
|
||||
parser.add_argument("--bt-low", type=float, default=0.05, help="ByteTrack second association confidence threshold.")
|
||||
parser.add_argument("--bt-new", type=float, default=0.20, help="ByteTrack new-track confidence threshold.")
|
||||
parser.add_argument("--bt-match", type=float, default=0.88, help="ByteTrack matching threshold.")
|
||||
parser.add_argument("--logo", default="ykz.png", help="Logo image path to overlay at top-right. Empty disables it.")
|
||||
parser.add_argument(
|
||||
"--classes",
|
||||
default="0",
|
||||
help="Comma-separated class IDs to keep. Default 0 keeps only the custom drone class.",
|
||||
)
|
||||
parser.add_argument("--display-class-name", default="drone", help="Class name shown in video labels and CSV.")
|
||||
parser.add_argument("--device", default=None, help="Ultralytics device string, e.g. cpu, 0, 0,1.")
|
||||
parser.add_argument("--limit-frames", type=int, default=0, help="Optional debug limit per video.")
|
||||
parser.add_argument("--show", action="store_true", help="Preview result while processing.")
|
||||
return parser.parse_args()
|
||||
|
||||
|
||||
def collect_videos(input_path: Path) -> list[Path]:
|
||||
if input_path.is_file():
|
||||
return [input_path]
|
||||
videos = [p for p in sorted(input_path.iterdir()) if p.suffix.lower() in VIDEO_EXTENSIONS]
|
||||
if not videos:
|
||||
raise FileNotFoundError(f"No videos found under {input_path}")
|
||||
return videos
|
||||
|
||||
|
||||
def parse_classes(value: str | None) -> list[int] | None:
|
||||
if not value:
|
||||
return None
|
||||
return [int(item.strip()) for item in value.split(",") if item.strip()]
|
||||
|
||||
|
||||
def filter_visible_tracks(tracks, min_score: float, nms_iou: float, center_ratio: float):
|
||||
from src.tracker import box_iou
|
||||
|
||||
candidates = [track for track in tracks if track.score >= min_score]
|
||||
candidates.sort(key=lambda track: (track.hits, track.score), reverse=True)
|
||||
kept = []
|
||||
for track in candidates:
|
||||
duplicate = False
|
||||
tx, ty = track.center
|
||||
tw, th = track.size
|
||||
tdiag = max(1.0, (tw * tw + th * th) ** 0.5)
|
||||
for selected in kept:
|
||||
sx, sy = selected.center
|
||||
sw, sh = selected.size
|
||||
sdiag = max(1.0, (sw * sw + sh * sh) ** 0.5)
|
||||
center_distance = ((tx - sx) ** 2 + (ty - sy) ** 2) ** 0.5
|
||||
if box_iou(track.xyxy, selected.xyxy) >= nms_iou:
|
||||
duplicate = True
|
||||
break
|
||||
if center_distance <= min(tdiag, sdiag) * center_ratio:
|
||||
duplicate = True
|
||||
break
|
||||
if not duplicate:
|
||||
kept.append(track)
|
||||
return kept
|
||||
|
||||
|
||||
def select_single_target_track(tracks, state: dict, target_id: int, trail_length: int):
|
||||
if not tracks:
|
||||
return []
|
||||
|
||||
if "center" in state:
|
||||
last_x, last_y = state["center"]
|
||||
selected = min(
|
||||
tracks,
|
||||
key=lambda track: ((track.center[0] - last_x) ** 2 + (track.center[1] - last_y) ** 2) ** 0.5
|
||||
- track.score * 18.0
|
||||
- min(track.hits, 12) * 1.5,
|
||||
)
|
||||
else:
|
||||
selected = max(tracks, key=lambda track: (track.hits, track.score))
|
||||
|
||||
state["center"] = selected.center
|
||||
history = state.setdefault("history", [])
|
||||
history.append(selected.center)
|
||||
if len(history) > trail_length:
|
||||
del history[:-trail_length]
|
||||
|
||||
selected.track_id = target_id
|
||||
selected.history = list(history)
|
||||
return [selected]
|
||||
|
||||
|
||||
def stitch_track_ids(
|
||||
tracks,
|
||||
state: dict,
|
||||
frame_index: int,
|
||||
frame_shape,
|
||||
buffer_frames: int,
|
||||
min_gap: int,
|
||||
trail_length: int,
|
||||
):
|
||||
if not tracks:
|
||||
return []
|
||||
|
||||
height, width = frame_shape[:2]
|
||||
frame_diag = (width * width + height * height) ** 0.5
|
||||
raw_to_canonical = state.setdefault("raw_to_canonical", {})
|
||||
canonical_state = state.setdefault("canonical_state", {})
|
||||
next_id = state.setdefault("next_id", 1)
|
||||
active_ids = set()
|
||||
stitched = []
|
||||
|
||||
ordered_tracks = sorted(
|
||||
tracks,
|
||||
key=lambda item: (item.track_id not in raw_to_canonical, -item.hits, -item.score),
|
||||
)
|
||||
|
||||
for track in ordered_tracks:
|
||||
raw_id = track.track_id
|
||||
cx, cy = track.center
|
||||
tw, th = track.size
|
||||
tdiag = max(1.0, (tw * tw + th * th) ** 0.5)
|
||||
|
||||
if raw_id in raw_to_canonical:
|
||||
canonical_id = raw_to_canonical[raw_id]
|
||||
else:
|
||||
best_id = None
|
||||
best_cost = 1e6
|
||||
for candidate_id, info in canonical_state.items():
|
||||
if candidate_id in active_ids:
|
||||
continue
|
||||
gap = frame_index - info["frame"]
|
||||
if gap < min_gap or gap > buffer_frames:
|
||||
continue
|
||||
px = info["center"][0] + info["velocity"][0] * min(gap, 45)
|
||||
py = info["center"][1] + info["velocity"][1] * min(gap, 45)
|
||||
distance = ((cx - px) ** 2 + (cy - py) ** 2) ** 0.5
|
||||
old_w, old_h = info["size"]
|
||||
size_cost = abs(math.log(tw / max(1.0, old_w))) + abs(math.log(th / max(1.0, old_h)))
|
||||
gate = max(60.0, min(frame_diag * 0.08, tdiag * (6.0 + gap * 0.08)))
|
||||
if distance > gate or size_cost > 1.35:
|
||||
continue
|
||||
cost = distance / gate + 0.18 * min(size_cost, 1.0) - track.score * 0.08
|
||||
if cost < best_cost:
|
||||
best_cost = cost
|
||||
best_id = candidate_id
|
||||
|
||||
if best_id is not None and best_cost < 0.92:
|
||||
canonical_id = best_id
|
||||
else:
|
||||
canonical_id = next_id
|
||||
next_id += 1
|
||||
raw_to_canonical[raw_id] = canonical_id
|
||||
state["next_id"] = next_id
|
||||
|
||||
if canonical_id in active_ids:
|
||||
canonical_id = next_id
|
||||
next_id += 1
|
||||
raw_to_canonical[raw_id] = canonical_id
|
||||
state["next_id"] = next_id
|
||||
|
||||
previous = canonical_state.get(canonical_id)
|
||||
if previous:
|
||||
gap = max(1, frame_index - previous["frame"])
|
||||
velocity = ((cx - previous["center"][0]) / gap, (cy - previous["center"][1]) / gap)
|
||||
history = previous.get("history", [])
|
||||
else:
|
||||
velocity = (0.0, 0.0)
|
||||
history = []
|
||||
history = history + [(cx, cy)]
|
||||
if len(history) > trail_length:
|
||||
history = history[-trail_length:]
|
||||
|
||||
canonical_state[canonical_id] = {
|
||||
"frame": frame_index,
|
||||
"center": (cx, cy),
|
||||
"velocity": velocity,
|
||||
"size": (tw, th),
|
||||
"history": history,
|
||||
}
|
||||
track.track_id = canonical_id
|
||||
track.history = list(history)
|
||||
active_ids.add(canonical_id)
|
||||
stitched.append(track)
|
||||
|
||||
state["canonical_state"] = {
|
||||
cid: info
|
||||
for cid, info in canonical_state.items()
|
||||
if frame_index - info["frame"] <= buffer_frames
|
||||
}
|
||||
return stitched
|
||||
|
||||
|
||||
def confirm_visible_tracks(tracks, state: dict, min_hits: int):
|
||||
if min_hits <= 1:
|
||||
return tracks
|
||||
counts = state.setdefault("counts", {})
|
||||
confirmed = []
|
||||
current_ids = {track.track_id for track in tracks}
|
||||
for track in tracks:
|
||||
counts[track.track_id] = counts.get(track.track_id, 0) + 1
|
||||
if counts[track.track_id] >= min_hits:
|
||||
confirmed.append(track)
|
||||
state["counts"] = {track_id: count for track_id, count in counts.items() if track_id in current_ids or count >= min_hits}
|
||||
return confirmed
|
||||
|
||||
|
||||
def rescue_missing_detections(detections, visible_tracks, state: dict, min_score: float, max_missed: int):
|
||||
import numpy as np
|
||||
|
||||
from src.tracker import Track, box_iou
|
||||
|
||||
rescue_tracks = state.setdefault("tracks", [])
|
||||
if "next_id" not in state:
|
||||
state["next_id"] = max([track.track_id for track in visible_tracks] + [0]) + 1
|
||||
|
||||
for track in rescue_tracks:
|
||||
track.missed += 1
|
||||
if track.history:
|
||||
cx, cy = track.center
|
||||
vx, vy = track.velocity
|
||||
track.xyxy = track.xyxy + np.array([vx, vy, vx, vy], dtype=float)
|
||||
track.history.append((int(cx + vx), int(cy + vy)))
|
||||
track.history = track.history[-80:]
|
||||
|
||||
def near_track(detection, track, center_scale=1.1):
|
||||
dcx = float((detection.xyxy[0] + detection.xyxy[2]) / 2.0)
|
||||
dcy = float((detection.xyxy[1] + detection.xyxy[3]) / 2.0)
|
||||
tx, ty = track.center
|
||||
tw, th = track.size
|
||||
dw = max(1.0, float(detection.xyxy[2] - detection.xyxy[0]))
|
||||
dh = max(1.0, float(detection.xyxy[3] - detection.xyxy[1]))
|
||||
gate = max(36.0, min((tw * tw + th * th) ** 0.5, (dw * dw + dh * dh) ** 0.5) * center_scale)
|
||||
return ((dcx - tx) ** 2 + (dcy - ty) ** 2) ** 0.5 <= gate or box_iou(detection.xyxy, track.xyxy) >= 0.20
|
||||
|
||||
for detection in detections:
|
||||
if detection.score < min_score:
|
||||
continue
|
||||
if any(near_track(detection, track) for track in visible_tracks):
|
||||
continue
|
||||
|
||||
best = None
|
||||
best_distance = 1e9
|
||||
dcx = float((detection.xyxy[0] + detection.xyxy[2]) / 2.0)
|
||||
dcy = float((detection.xyxy[1] + detection.xyxy[3]) / 2.0)
|
||||
for track in rescue_tracks:
|
||||
if track.missed > max_missed:
|
||||
continue
|
||||
tx, ty = track.center
|
||||
distance = ((dcx - tx) ** 2 + (dcy - ty) ** 2) ** 0.5
|
||||
if distance < best_distance and near_track(detection, track, center_scale=2.5):
|
||||
best = track
|
||||
best_distance = distance
|
||||
|
||||
if best is None:
|
||||
best = Track(
|
||||
track_id=state["next_id"],
|
||||
xyxy=detection.xyxy.copy(),
|
||||
score=detection.score,
|
||||
class_id=detection.class_id,
|
||||
class_name=detection.class_name,
|
||||
)
|
||||
state["next_id"] += 1
|
||||
rescue_tracks.append(best)
|
||||
else:
|
||||
old_cx, old_cy = best.center
|
||||
best.xyxy = detection.xyxy.copy()
|
||||
best.score = detection.score
|
||||
best.missed = 0
|
||||
best.hits += 1
|
||||
best.velocity = (0.6 * best.velocity[0] + 0.4 * (dcx - old_cx), 0.6 * best.velocity[1] + 0.4 * (dcy - old_cy))
|
||||
best.history.append(best.center)
|
||||
best.history = best.history[-80:]
|
||||
|
||||
rescue_tracks = [track for track in rescue_tracks if track.missed <= max_missed]
|
||||
state["tracks"] = rescue_tracks
|
||||
visible_ids = {track.track_id for track in visible_tracks}
|
||||
additions = [
|
||||
track
|
||||
for track in rescue_tracks
|
||||
if track.missed == 0 and track.track_id not in visible_ids and not any(near_track(DetectionLike(track), vt) for vt in visible_tracks)
|
||||
]
|
||||
return visible_tracks + additions
|
||||
|
||||
|
||||
class DetectionLike:
|
||||
def __init__(self, track):
|
||||
self.xyxy = track.xyxy
|
||||
|
||||
|
||||
def process_video(
|
||||
video_path: Path,
|
||||
output_dir: Path,
|
||||
detector,
|
||||
args: argparse.Namespace,
|
||||
) -> None:
|
||||
import cv2
|
||||
|
||||
from src.tracker import ByteTrackTracker, IouTracker, MotionTracker
|
||||
from src.visualization import draw_tracks, load_logo, overlay_logo
|
||||
|
||||
cap = cv2.VideoCapture(str(video_path))
|
||||
if not cap.isOpened():
|
||||
raise RuntimeError(f"Cannot open video: {video_path}")
|
||||
|
||||
fps = cap.get(cv2.CAP_PROP_FPS) or 25.0
|
||||
width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
|
||||
height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
|
||||
total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
|
||||
|
||||
output_video = output_dir / f"{video_path.stem}_tracked.mp4"
|
||||
output_csv = output_dir / f"{video_path.stem}_tracks.csv"
|
||||
writer = cv2.VideoWriter(
|
||||
str(output_video),
|
||||
cv2.VideoWriter_fourcc(*"mp4v"),
|
||||
fps,
|
||||
(width, height),
|
||||
)
|
||||
if not writer.isOpened():
|
||||
raise RuntimeError(f"Cannot create output video: {output_video}")
|
||||
|
||||
logo = load_logo(args.logo, width) if args.logo else None
|
||||
if args.tracker == "bytetrack":
|
||||
tracker = ByteTrackTracker(
|
||||
frame_rate=fps,
|
||||
track_high_thresh=args.bt_high,
|
||||
track_low_thresh=args.bt_low,
|
||||
new_track_thresh=args.bt_new,
|
||||
track_buffer=args.max_missed,
|
||||
match_thresh=args.bt_match,
|
||||
trail_length=args.trail_length,
|
||||
)
|
||||
elif args.tracker == "iou":
|
||||
tracker = IouTracker(
|
||||
iou_threshold=args.track_iou,
|
||||
max_missed=args.max_missed,
|
||||
min_hits=args.min_hits,
|
||||
trail_length=args.trail_length,
|
||||
)
|
||||
else:
|
||||
tracker = MotionTracker(
|
||||
max_missed=args.max_missed,
|
||||
min_hits=args.min_hits,
|
||||
new_track_thresh=args.new_track_conf,
|
||||
smooth_alpha=args.smooth_alpha,
|
||||
reconnect_buffer=args.reconnect_buffer,
|
||||
max_match_gap=args.max_match_gap,
|
||||
suppress_near_new_tracks=not args.allow_near_new_tracks,
|
||||
trail_length=args.trail_length,
|
||||
)
|
||||
|
||||
start = time.time()
|
||||
frame_index = 0
|
||||
single_target_state: dict = {}
|
||||
stitch_state: dict = {}
|
||||
display_confirm_state: dict = {}
|
||||
rescue_state: dict = {}
|
||||
with output_csv.open("w", newline="", encoding="utf-8") as csv_file:
|
||||
csv_writer = csv.writer(csv_file)
|
||||
csv_writer.writerow(["frame", "track_id", "class_id", "class_name", "score", "x1", "y1", "x2", "y2"])
|
||||
|
||||
while True:
|
||||
ok, frame = cap.read()
|
||||
if not ok:
|
||||
break
|
||||
frame_index += 1
|
||||
|
||||
detections = detector.detect(frame)
|
||||
try:
|
||||
tracks = tracker.update(detections, frame.shape)
|
||||
except TypeError:
|
||||
tracks = tracker.update(detections)
|
||||
visible_tracks = filter_visible_tracks(
|
||||
tracks,
|
||||
min_score=args.display_conf,
|
||||
nms_iou=args.track_nms_iou,
|
||||
center_ratio=args.track_nms_center,
|
||||
)
|
||||
if args.single_target:
|
||||
visible_tracks = select_single_target_track(
|
||||
visible_tracks,
|
||||
single_target_state,
|
||||
target_id=args.single_target_id,
|
||||
trail_length=args.trail_length,
|
||||
)
|
||||
elif args.stitch_ids:
|
||||
visible_tracks = stitch_track_ids(
|
||||
visible_tracks,
|
||||
stitch_state,
|
||||
frame_index=frame_index,
|
||||
frame_shape=frame.shape,
|
||||
buffer_frames=args.stitch_buffer,
|
||||
min_gap=args.stitch_min_gap,
|
||||
trail_length=args.trail_length,
|
||||
)
|
||||
visible_tracks = confirm_visible_tracks(
|
||||
visible_tracks,
|
||||
display_confirm_state,
|
||||
min_hits=args.display_min_hits,
|
||||
)
|
||||
if args.rescue_detections:
|
||||
visible_tracks = rescue_missing_detections(
|
||||
detections,
|
||||
visible_tracks,
|
||||
rescue_state,
|
||||
min_score=args.rescue_conf,
|
||||
max_missed=args.rescue_max_missed,
|
||||
)
|
||||
for track in visible_tracks:
|
||||
x1, y1, x2, y2 = track.xyxy
|
||||
csv_writer.writerow(
|
||||
[
|
||||
frame_index,
|
||||
track.track_id,
|
||||
track.class_id,
|
||||
track.class_name,
|
||||
f"{track.score:.4f}",
|
||||
f"{x1:.2f}",
|
||||
f"{y1:.2f}",
|
||||
f"{x2:.2f}",
|
||||
f"{y2:.2f}",
|
||||
]
|
||||
)
|
||||
|
||||
visualized = draw_tracks(frame, visible_tracks, frame_index)
|
||||
visualized = overlay_logo(visualized, logo)
|
||||
writer.write(visualized)
|
||||
|
||||
if args.show:
|
||||
cv2.imshow("UAV detection and tracking", visualized)
|
||||
if cv2.waitKey(1) & 0xFF == ord("q"):
|
||||
break
|
||||
|
||||
if frame_index % 30 == 0:
|
||||
elapsed = max(time.time() - start, 1e-6)
|
||||
print(
|
||||
f"[{video_path.name}] {frame_index}/{total_frames or '?'} frames, "
|
||||
f"{frame_index / elapsed:.2f} FPS"
|
||||
)
|
||||
|
||||
if args.limit_frames and frame_index >= args.limit_frames:
|
||||
break
|
||||
|
||||
cap.release()
|
||||
writer.release()
|
||||
if args.show:
|
||||
cv2.destroyAllWindows()
|
||||
|
||||
print(f"Saved video: {output_video}")
|
||||
print(f"Saved tracks: {output_csv}")
|
||||
|
||||
|
||||
def main() -> None:
|
||||
args = parse_args()
|
||||
try:
|
||||
from src.detector import YoloDetector
|
||||
except ImportError as exc:
|
||||
raise SystemExit(
|
||||
"Missing Python vision dependencies. Run `bash scripts/install_deps.sh` first."
|
||||
) from exc
|
||||
|
||||
input_path = Path(args.input)
|
||||
output_dir = Path(args.output)
|
||||
output_dir.mkdir(parents=True, exist_ok=True)
|
||||
|
||||
detector = YoloDetector(
|
||||
model_path=args.model,
|
||||
conf=args.conf,
|
||||
iou=args.det_iou,
|
||||
classes=parse_classes(args.classes),
|
||||
display_name=args.display_class_name,
|
||||
device=args.device,
|
||||
imgsz=args.imgsz,
|
||||
)
|
||||
|
||||
for video_path in collect_videos(input_path):
|
||||
process_video(video_path, output_dir, detector, args)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
Executable
+80
@@ -0,0 +1,80 @@
|
||||
#!/usr/bin/env bash
|
||||
set -euo pipefail
|
||||
|
||||
ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
|
||||
cd "$ROOT_DIR"
|
||||
|
||||
MODEL="$ROOT_DIR/weights/uav_drone_yolov8s_best.pt"
|
||||
LOGO="$ROOT_DIR/ykz.png"
|
||||
OUTPUT="$ROOT_DIR/outputs"
|
||||
|
||||
mkdir -p "$OUTPUT"
|
||||
|
||||
COMMON_ARGS=(
|
||||
--model "$MODEL"
|
||||
--logo "$LOGO"
|
||||
--classes 0
|
||||
--display-class-name drone
|
||||
--imgsz 1280
|
||||
--conf 0.12
|
||||
--display-conf 0.32
|
||||
--display-min-hits 4
|
||||
--det-iou 0.50
|
||||
--tracker motion
|
||||
--max-missed 45
|
||||
--max-match-gap 60
|
||||
--reconnect-buffer 45
|
||||
--min-hits 8
|
||||
--new-track-conf 0.34
|
||||
--smooth-alpha 0.75
|
||||
--track-nms-iou 0.45
|
||||
--track-nms-center 0.75
|
||||
--stitch-ids
|
||||
--stitch-buffer 45
|
||||
--stitch-min-gap 15
|
||||
--trail-length 180
|
||||
)
|
||||
|
||||
python3 run_detect_track.py \
|
||||
--input "$ROOT_DIR/test_video/test_video_1.mp4" \
|
||||
--output "$OUTPUT" \
|
||||
--rescue-detections \
|
||||
--rescue-conf 0.45 \
|
||||
--rescue-max-missed 20 \
|
||||
"${COMMON_ARGS[@]}"
|
||||
|
||||
for video in "$ROOT_DIR"/test_video/test_video_{2,3,4}.mp4; do
|
||||
python3 run_detect_track.py \
|
||||
--input "$video" \
|
||||
--output "$OUTPUT" \
|
||||
"${COMMON_ARGS[@]}"
|
||||
done
|
||||
|
||||
python3 - <<'PY'
|
||||
from pathlib import Path
|
||||
import csv
|
||||
import cv2
|
||||
import collections
|
||||
|
||||
root = Path.cwd()
|
||||
out = root / "outputs"
|
||||
for video in sorted(out.glob("*_tracked.mp4")):
|
||||
cap = cv2.VideoCapture(str(video))
|
||||
frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT)) if cap.isOpened() else 0
|
||||
fps = cap.get(cv2.CAP_PROP_FPS) if cap.isOpened() else 0
|
||||
cap.release()
|
||||
csv_path = out / video.name.replace("_tracked.mp4", "_tracks.csv")
|
||||
ids = set()
|
||||
rows = 0
|
||||
by_frame = collections.defaultdict(list)
|
||||
if csv_path.exists():
|
||||
with csv_path.open(newline="", encoding="utf-8") as f:
|
||||
for row in csv.DictReader(f):
|
||||
rows += 1
|
||||
ids.add(row["track_id"])
|
||||
by_frame[int(row["frame"])].append(row["track_id"])
|
||||
duplicate_same_id = 0
|
||||
for frame_ids in by_frame.values():
|
||||
duplicate_same_id += sum(1 for count in collections.Counter(frame_ids).values() if count > 1)
|
||||
print(f"{video.name}: frames={frames}, fps={fps:.3f}, rows={rows}, ids={len(ids)}, duplicate_same_id_frames={duplicate_same_id}")
|
||||
PY
|
||||
@@ -0,0 +1 @@
|
||||
"""UAV multi-object detection and tracking package."""
|
||||
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
@@ -0,0 +1,80 @@
|
||||
from __future__ import annotations
|
||||
|
||||
from dataclasses import dataclass
|
||||
from pathlib import Path
|
||||
from typing import Iterable
|
||||
|
||||
import numpy as np
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class Detection:
|
||||
xyxy: np.ndarray
|
||||
score: float
|
||||
class_id: int
|
||||
class_name: str
|
||||
|
||||
|
||||
class YoloDetector:
|
||||
"""Thin wrapper around Ultralytics YOLO for frame-by-frame detection."""
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
model_path: str | Path,
|
||||
conf: float = 0.25,
|
||||
iou: float = 0.45,
|
||||
classes: Iterable[int] | None = None,
|
||||
display_name: str | None = None,
|
||||
device: str | None = None,
|
||||
imgsz: int = 1280,
|
||||
) -> None:
|
||||
try:
|
||||
from ultralytics import YOLO
|
||||
except ImportError as exc:
|
||||
raise RuntimeError(
|
||||
"Missing dependency 'ultralytics'. Install dependencies with "
|
||||
"`python3 -m pip install -r requirements.txt`."
|
||||
) from exc
|
||||
|
||||
self.model = YOLO(str(model_path))
|
||||
self.conf = conf
|
||||
self.iou = iou
|
||||
self.classes = list(classes) if classes is not None else None
|
||||
self.display_name = display_name
|
||||
self.device = device
|
||||
self.imgsz = imgsz
|
||||
self.names = self.model.names
|
||||
|
||||
def detect(self, frame: np.ndarray) -> list[Detection]:
|
||||
results = self.model.predict(
|
||||
frame,
|
||||
conf=self.conf,
|
||||
iou=self.iou,
|
||||
classes=self.classes,
|
||||
device=self.device,
|
||||
imgsz=self.imgsz,
|
||||
verbose=False,
|
||||
)
|
||||
if not results:
|
||||
return []
|
||||
|
||||
boxes = results[0].boxes
|
||||
if boxes is None or len(boxes) == 0:
|
||||
return []
|
||||
|
||||
xyxy = boxes.xyxy.detach().cpu().numpy()
|
||||
scores = boxes.conf.detach().cpu().numpy()
|
||||
class_ids = boxes.cls.detach().cpu().numpy().astype(int)
|
||||
|
||||
detections: list[Detection] = []
|
||||
for box, score, class_id in zip(xyxy, scores, class_ids):
|
||||
class_name = self.display_name or str(self.names.get(class_id, class_id))
|
||||
detections.append(
|
||||
Detection(
|
||||
xyxy=box.astype(float),
|
||||
score=float(score),
|
||||
class_id=int(class_id),
|
||||
class_name=class_name,
|
||||
)
|
||||
)
|
||||
return detections
|
||||
+502
@@ -0,0 +1,502 @@
|
||||
from __future__ import annotations
|
||||
|
||||
from dataclasses import dataclass, field
|
||||
from types import SimpleNamespace
|
||||
|
||||
import numpy as np
|
||||
from scipy.optimize import linear_sum_assignment
|
||||
|
||||
from .detector import Detection
|
||||
|
||||
|
||||
@dataclass
|
||||
class Track:
|
||||
track_id: int
|
||||
xyxy: np.ndarray
|
||||
score: float
|
||||
class_id: int
|
||||
class_name: str
|
||||
age: int = 0
|
||||
missed: int = 0
|
||||
hits: int = 1
|
||||
velocity: tuple[float, float] = (0.0, 0.0)
|
||||
history: list[tuple[int, int]] = field(default_factory=list)
|
||||
|
||||
@property
|
||||
def center(self) -> tuple[int, int]:
|
||||
x1, y1, x2, y2 = self.xyxy
|
||||
return int((x1 + x2) / 2), int((y1 + y2) / 2)
|
||||
|
||||
@property
|
||||
def size(self) -> tuple[float, float]:
|
||||
x1, y1, x2, y2 = self.xyxy
|
||||
return max(1.0, float(x2 - x1)), max(1.0, float(y2 - y1))
|
||||
|
||||
@property
|
||||
def predicted_center(self) -> tuple[float, float]:
|
||||
cx, cy = self.center
|
||||
vx, vy = self.velocity
|
||||
return cx + vx, cy + vy
|
||||
|
||||
|
||||
class IouTracker:
|
||||
"""Small online multi-object tracker using IoU matching.
|
||||
|
||||
This is intentionally dependency-light. It is suitable as a first
|
||||
engineering baseline and can later be replaced with ByteTrack/DeepSORT.
|
||||
"""
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
iou_threshold: float = 0.3,
|
||||
max_missed: int = 30,
|
||||
min_hits: int = 1,
|
||||
trail_length: int = 60,
|
||||
) -> None:
|
||||
self.iou_threshold = iou_threshold
|
||||
self.max_missed = max_missed
|
||||
self.min_hits = min_hits
|
||||
self.trail_length = trail_length
|
||||
self.next_id = 1
|
||||
self.tracks: list[Track] = []
|
||||
|
||||
def update(self, detections: list[Detection]) -> list[Track]:
|
||||
for track in self.tracks:
|
||||
track.age += 1
|
||||
track.missed += 1
|
||||
for track in self.retired_tracks:
|
||||
track.age += 1
|
||||
track.missed += 1
|
||||
|
||||
if detections and self.tracks:
|
||||
matches, unmatched_tracks, unmatched_detections = self._match(detections)
|
||||
else:
|
||||
matches = []
|
||||
unmatched_tracks = set(range(len(self.tracks)))
|
||||
unmatched_detections = set(range(len(detections)))
|
||||
|
||||
for track_idx, det_idx in matches:
|
||||
detection = detections[det_idx]
|
||||
track = self.tracks[track_idx]
|
||||
track.xyxy = detection.xyxy
|
||||
track.score = detection.score
|
||||
track.class_id = detection.class_id
|
||||
track.class_name = detection.class_name
|
||||
track.missed = 0
|
||||
track.hits += 1
|
||||
track.history.append(track.center)
|
||||
if len(track.history) > self.trail_length:
|
||||
track.history = track.history[-self.trail_length :]
|
||||
|
||||
for det_idx in unmatched_detections:
|
||||
detection = detections[det_idx]
|
||||
track = Track(
|
||||
track_id=self.next_id,
|
||||
xyxy=detection.xyxy,
|
||||
score=detection.score,
|
||||
class_id=detection.class_id,
|
||||
class_name=detection.class_name,
|
||||
)
|
||||
track.history.append(track.center)
|
||||
self.tracks.append(track)
|
||||
self.next_id += 1
|
||||
|
||||
self.tracks = [track for track in self.tracks if track.missed <= self.max_missed]
|
||||
return [track for track in self.tracks if track.hits >= self.min_hits and track.missed == 0]
|
||||
|
||||
def _match(self, detections: list[Detection]) -> tuple[list[tuple[int, int]], set[int], set[int]]:
|
||||
iou_matrix = np.zeros((len(self.tracks), len(detections)), dtype=float)
|
||||
for track_idx, track in enumerate(self.tracks):
|
||||
for det_idx, detection in enumerate(detections):
|
||||
if track.class_id != detection.class_id:
|
||||
continue
|
||||
iou_matrix[track_idx, det_idx] = box_iou(track.xyxy, detection.xyxy)
|
||||
|
||||
matches: list[tuple[int, int]] = []
|
||||
unmatched_tracks = set(range(len(self.tracks)))
|
||||
unmatched_detections = set(range(len(detections)))
|
||||
|
||||
while iou_matrix.size:
|
||||
track_idx, det_idx = np.unravel_index(np.argmax(iou_matrix), iou_matrix.shape)
|
||||
if iou_matrix[track_idx, det_idx] < self.iou_threshold:
|
||||
break
|
||||
|
||||
matches.append((int(track_idx), int(det_idx)))
|
||||
unmatched_tracks.discard(int(track_idx))
|
||||
unmatched_detections.discard(int(det_idx))
|
||||
iou_matrix[track_idx, :] = -1
|
||||
iou_matrix[:, det_idx] = -1
|
||||
|
||||
return matches, unmatched_tracks, unmatched_detections
|
||||
|
||||
|
||||
def box_iou(box_a: np.ndarray, box_b: np.ndarray) -> float:
|
||||
ax1, ay1, ax2, ay2 = box_a
|
||||
bx1, by1, bx2, by2 = box_b
|
||||
inter_x1 = max(ax1, bx1)
|
||||
inter_y1 = max(ay1, by1)
|
||||
inter_x2 = min(ax2, bx2)
|
||||
inter_y2 = min(ay2, by2)
|
||||
inter_w = max(0.0, inter_x2 - inter_x1)
|
||||
inter_h = max(0.0, inter_y2 - inter_y1)
|
||||
inter_area = inter_w * inter_h
|
||||
|
||||
area_a = max(0.0, ax2 - ax1) * max(0.0, ay2 - ay1)
|
||||
area_b = max(0.0, bx2 - bx1) * max(0.0, by2 - by1)
|
||||
union = area_a + area_b - inter_area
|
||||
return float(inter_area / union) if union > 0 else 0.0
|
||||
|
||||
|
||||
class MotionTracker:
|
||||
"""Online tracker tuned for tiny UAV targets.
|
||||
|
||||
Pure IoU matching breaks easily when a drone moves farther than its own
|
||||
box width between adjacent frames. This tracker keeps a lightweight
|
||||
constant-velocity estimate and matches detections by predicted center,
|
||||
IoU, and box-size consistency.
|
||||
"""
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
iou_weight: float = 0.35,
|
||||
distance_weight: float = 0.55,
|
||||
size_weight: float = 0.10,
|
||||
max_missed: int = 45,
|
||||
min_hits: int = 2,
|
||||
trail_length: int = 120,
|
||||
max_distance_ratio: float = 0.045,
|
||||
min_match_distance: float = 36.0,
|
||||
new_track_thresh: float = 0.20,
|
||||
smooth_alpha: float = 0.75,
|
||||
reconnect_buffer: int = 240,
|
||||
reconnect_distance_ratio: float = 0.075,
|
||||
max_match_gap: int = 60,
|
||||
suppress_near_new_tracks: bool = True,
|
||||
) -> None:
|
||||
self.iou_weight = iou_weight
|
||||
self.distance_weight = distance_weight
|
||||
self.size_weight = size_weight
|
||||
self.max_missed = max_missed
|
||||
self.min_hits = min_hits
|
||||
self.trail_length = trail_length
|
||||
self.max_distance_ratio = max_distance_ratio
|
||||
self.min_match_distance = min_match_distance
|
||||
self.new_track_thresh = new_track_thresh
|
||||
self.smooth_alpha = smooth_alpha
|
||||
self.reconnect_buffer = reconnect_buffer
|
||||
self.reconnect_distance_ratio = reconnect_distance_ratio
|
||||
self.max_match_gap = max_match_gap
|
||||
self.suppress_near_new_tracks = suppress_near_new_tracks
|
||||
self.next_id = 1
|
||||
self.tracks: list[Track] = []
|
||||
self.retired_tracks: list[Track] = []
|
||||
|
||||
def update(
|
||||
self,
|
||||
detections: list[Detection],
|
||||
frame_shape: tuple[int, int] | tuple[int, int, int] | None = None,
|
||||
) -> list[Track]:
|
||||
for track in self.tracks:
|
||||
track.age += 1
|
||||
track.missed += 1
|
||||
|
||||
if detections and self.tracks:
|
||||
matches, unmatched_tracks, unmatched_detections = self._match(detections, frame_shape)
|
||||
else:
|
||||
matches = []
|
||||
unmatched_tracks = set(range(len(self.tracks)))
|
||||
unmatched_detections = set(range(len(detections)))
|
||||
|
||||
for track_idx, det_idx in matches:
|
||||
detection = detections[det_idx]
|
||||
track = self.tracks[track_idx]
|
||||
old_cx, old_cy = track.center
|
||||
new_xyxy = detection.xyxy
|
||||
new_cx = float((new_xyxy[0] + new_xyxy[2]) / 2.0)
|
||||
new_cy = float((new_xyxy[1] + new_xyxy[3]) / 2.0)
|
||||
dx = new_cx - old_cx
|
||||
dy = new_cy - old_cy
|
||||
vx, vy = track.velocity
|
||||
track.velocity = (0.65 * vx + 0.35 * dx, 0.65 * vy + 0.35 * dy)
|
||||
predicted_xyxy = track.xyxy + np.array([vx, vy, vx, vy], dtype=float)
|
||||
alpha = self.smooth_alpha
|
||||
track.xyxy = alpha * new_xyxy + (1.0 - alpha) * predicted_xyxy
|
||||
track.score = detection.score
|
||||
track.class_id = detection.class_id
|
||||
track.class_name = detection.class_name
|
||||
track.missed = 0
|
||||
track.hits += 1
|
||||
track.history.append(track.center)
|
||||
if len(track.history) > self.trail_length:
|
||||
track.history = track.history[-self.trail_length :]
|
||||
|
||||
for track_idx in unmatched_tracks:
|
||||
track = self.tracks[track_idx]
|
||||
vx, vy = track.velocity
|
||||
if abs(vx) > 0.01 or abs(vy) > 0.01:
|
||||
track.xyxy = track.xyxy + np.array([vx, vy, vx, vy], dtype=float)
|
||||
|
||||
for det_idx in unmatched_detections:
|
||||
detection = detections[det_idx]
|
||||
if detection.score < self.new_track_thresh:
|
||||
continue
|
||||
if self.suppress_near_new_tracks and self._is_near_existing_track(detection, frame_shape):
|
||||
continue
|
||||
reconnected = self._reconnect_retired_track(detection, frame_shape)
|
||||
if reconnected is not None:
|
||||
self.tracks.append(reconnected)
|
||||
continue
|
||||
track = Track(
|
||||
track_id=self.next_id,
|
||||
xyxy=detection.xyxy,
|
||||
score=detection.score,
|
||||
class_id=detection.class_id,
|
||||
class_name=detection.class_name,
|
||||
)
|
||||
track.history.append(track.center)
|
||||
self.tracks.append(track)
|
||||
self.next_id += 1
|
||||
|
||||
active_tracks = []
|
||||
for track in self.tracks:
|
||||
if track.missed <= self.max_missed:
|
||||
active_tracks.append(track)
|
||||
elif track.hits >= self.min_hits:
|
||||
self.retired_tracks.append(track)
|
||||
self.tracks = active_tracks
|
||||
self.retired_tracks = [
|
||||
track for track in self.retired_tracks if track.missed <= self.reconnect_buffer
|
||||
][-200:]
|
||||
return [track for track in self.tracks if track.hits >= self.min_hits and track.missed == 0]
|
||||
|
||||
def _match(
|
||||
self,
|
||||
detections: list[Detection],
|
||||
frame_shape: tuple[int, int] | tuple[int, int, int] | None,
|
||||
) -> tuple[list[tuple[int, int]], set[int], set[int]]:
|
||||
frame_diag = 1280.0
|
||||
if frame_shape:
|
||||
height, width = frame_shape[:2]
|
||||
frame_diag = float(np.hypot(width, height))
|
||||
|
||||
cost_matrix = np.full((len(self.tracks), len(detections)), 1e6, dtype=float)
|
||||
valid_matrix = np.zeros_like(cost_matrix, dtype=bool)
|
||||
for track_idx, track in enumerate(self.tracks):
|
||||
if track.missed > self.max_match_gap:
|
||||
continue
|
||||
track_w, track_h = track.size
|
||||
track_diag = float(np.hypot(track_w, track_h))
|
||||
max_distance = max(
|
||||
self.min_match_distance,
|
||||
track_diag * (4.0 + min(track.missed, 8) * 0.5),
|
||||
frame_diag * self.max_distance_ratio,
|
||||
)
|
||||
pcx, pcy = track.predicted_center
|
||||
for det_idx, detection in enumerate(detections):
|
||||
if track.class_id != detection.class_id:
|
||||
continue
|
||||
dx1, dy1, dx2, dy2 = detection.xyxy
|
||||
dcx = float((dx1 + dx2) / 2.0)
|
||||
dcy = float((dy1 + dy2) / 2.0)
|
||||
distance = float(np.hypot(dcx - pcx, dcy - pcy))
|
||||
if distance > max_distance:
|
||||
continue
|
||||
|
||||
det_w = max(1.0, float(dx2 - dx1))
|
||||
det_h = max(1.0, float(dy2 - dy1))
|
||||
iou = box_iou(track.xyxy, detection.xyxy)
|
||||
distance_cost = distance / max_distance
|
||||
size_cost = min(1.0, abs(np.log(det_w / track_w)) + abs(np.log(det_h / track_h)))
|
||||
cost = (
|
||||
self.distance_weight * distance_cost
|
||||
+ self.iou_weight * (1.0 - iou)
|
||||
+ self.size_weight * size_cost
|
||||
)
|
||||
cost_matrix[track_idx, det_idx] = cost
|
||||
valid_matrix[track_idx, det_idx] = True
|
||||
|
||||
matches: list[tuple[int, int]] = []
|
||||
unmatched_tracks = set(range(len(self.tracks)))
|
||||
unmatched_detections = set(range(len(detections)))
|
||||
if cost_matrix.size:
|
||||
track_indices, detection_indices = linear_sum_assignment(cost_matrix)
|
||||
for track_idx, det_idx in zip(track_indices, detection_indices):
|
||||
match_thresh = 0.82 if self.tracks[track_idx].missed == 1 else 0.93
|
||||
if valid_matrix[track_idx, det_idx] and cost_matrix[track_idx, det_idx] < match_thresh:
|
||||
matches.append((int(track_idx), int(det_idx)))
|
||||
unmatched_tracks.discard(int(track_idx))
|
||||
unmatched_detections.discard(int(det_idx))
|
||||
|
||||
return matches, unmatched_tracks, unmatched_detections
|
||||
|
||||
def _frame_diag(self, frame_shape: tuple[int, int] | tuple[int, int, int] | None) -> float:
|
||||
if not frame_shape:
|
||||
return 1280.0
|
||||
height, width = frame_shape[:2]
|
||||
return float(np.hypot(width, height))
|
||||
|
||||
def _is_near_existing_track(
|
||||
self,
|
||||
detection: Detection,
|
||||
frame_shape: tuple[int, int] | tuple[int, int, int] | None,
|
||||
) -> bool:
|
||||
frame_diag = self._frame_diag(frame_shape)
|
||||
dx1, dy1, dx2, dy2 = detection.xyxy
|
||||
dcx = float((dx1 + dx2) / 2.0)
|
||||
dcy = float((dy1 + dy2) / 2.0)
|
||||
det_diag = float(np.hypot(max(1.0, dx2 - dx1), max(1.0, dy2 - dy1)))
|
||||
for track in self.tracks:
|
||||
if track.class_id != detection.class_id:
|
||||
continue
|
||||
if track.missed > self.max_match_gap:
|
||||
continue
|
||||
tx, ty = track.predicted_center
|
||||
distance = float(np.hypot(dcx - tx, dcy - ty))
|
||||
gate = max(self.min_match_distance, det_diag * 2.2, frame_diag * 0.018)
|
||||
if distance <= gate or box_iou(track.xyxy, detection.xyxy) >= 0.18:
|
||||
return True
|
||||
return False
|
||||
|
||||
def _reconnect_retired_track(
|
||||
self,
|
||||
detection: Detection,
|
||||
frame_shape: tuple[int, int] | tuple[int, int, int] | None,
|
||||
) -> Track | None:
|
||||
if not self.retired_tracks:
|
||||
return None
|
||||
|
||||
frame_diag = self._frame_diag(frame_shape)
|
||||
dx1, dy1, dx2, dy2 = detection.xyxy
|
||||
dcx = float((dx1 + dx2) / 2.0)
|
||||
dcy = float((dy1 + dy2) / 2.0)
|
||||
det_w = max(1.0, float(dx2 - dx1))
|
||||
det_h = max(1.0, float(dy2 - dy1))
|
||||
best_idx = None
|
||||
best_cost = 1e6
|
||||
|
||||
for idx, track in enumerate(self.retired_tracks):
|
||||
if track.class_id != detection.class_id:
|
||||
continue
|
||||
track_w, track_h = track.size
|
||||
vx, vy = track.velocity
|
||||
cx, cy = track.center
|
||||
steps = min(track.missed, 45)
|
||||
pcx = cx + vx * steps
|
||||
pcy = cy + vy * steps
|
||||
distance = float(np.hypot(dcx - pcx, dcy - pcy))
|
||||
gate = max(
|
||||
self.min_match_distance * 2.0,
|
||||
float(np.hypot(track_w, track_h)) * (5.0 + min(track.missed, 30) * 0.12),
|
||||
frame_diag * self.reconnect_distance_ratio,
|
||||
)
|
||||
if distance > gate:
|
||||
continue
|
||||
size_cost = abs(np.log(det_w / track_w)) + abs(np.log(det_h / track_h))
|
||||
if size_cost > 1.4:
|
||||
continue
|
||||
cost = distance / gate + 0.2 * min(size_cost, 1.0) - detection.score * 0.15
|
||||
if cost < best_cost:
|
||||
best_cost = cost
|
||||
best_idx = idx
|
||||
|
||||
if best_idx is None or best_cost > 0.95:
|
||||
return None
|
||||
|
||||
track = self.retired_tracks.pop(best_idx)
|
||||
old_cx, old_cy = track.center
|
||||
dx = dcx - old_cx
|
||||
dy = dcy - old_cy
|
||||
vx, vy = track.velocity
|
||||
track.velocity = (0.55 * vx + 0.45 * dx, 0.55 * vy + 0.45 * dy)
|
||||
track.xyxy = detection.xyxy
|
||||
track.score = detection.score
|
||||
track.class_id = detection.class_id
|
||||
track.class_name = detection.class_name
|
||||
track.missed = 0
|
||||
track.hits += 1
|
||||
track.history.append(track.center)
|
||||
if len(track.history) > self.trail_length:
|
||||
track.history = track.history[-self.trail_length :]
|
||||
return track
|
||||
|
||||
|
||||
class _ByteTrackDetections:
|
||||
def __init__(self, detections: list[Detection]) -> None:
|
||||
if detections:
|
||||
xyxy = np.asarray([det.xyxy for det in detections], dtype=np.float32)
|
||||
xywh = xyxy.copy()
|
||||
xywh[:, 0] = (xyxy[:, 0] + xyxy[:, 2]) / 2.0
|
||||
xywh[:, 1] = (xyxy[:, 1] + xyxy[:, 3]) / 2.0
|
||||
xywh[:, 2] = xyxy[:, 2] - xyxy[:, 0]
|
||||
xywh[:, 3] = xyxy[:, 3] - xyxy[:, 1]
|
||||
self.xywh = xywh
|
||||
self.conf = np.asarray([det.score for det in detections], dtype=np.float32)
|
||||
self.cls = np.asarray([det.class_id for det in detections], dtype=np.float32)
|
||||
else:
|
||||
self.xywh = np.empty((0, 4), dtype=np.float32)
|
||||
self.conf = np.empty((0,), dtype=np.float32)
|
||||
self.cls = np.empty((0,), dtype=np.float32)
|
||||
|
||||
|
||||
class ByteTrackTracker:
|
||||
"""Adapter around Ultralytics BYTETracker with our Track output shape."""
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
frame_rate: float = 30.0,
|
||||
track_high_thresh: float = 0.25,
|
||||
track_low_thresh: float = 0.05,
|
||||
new_track_thresh: float = 0.20,
|
||||
track_buffer: int = 90,
|
||||
match_thresh: float = 0.88,
|
||||
trail_length: int = 160,
|
||||
) -> None:
|
||||
try:
|
||||
from ultralytics.trackers.byte_tracker import BYTETracker
|
||||
except ImportError as exc:
|
||||
raise RuntimeError(
|
||||
"BYTETracker requires the local multi_image_detect/ultralytics package on PYTHONPATH."
|
||||
) from exc
|
||||
|
||||
args = SimpleNamespace(
|
||||
track_high_thresh=track_high_thresh,
|
||||
track_low_thresh=track_low_thresh,
|
||||
new_track_thresh=new_track_thresh,
|
||||
track_buffer=track_buffer,
|
||||
match_thresh=match_thresh,
|
||||
)
|
||||
self.tracker = BYTETracker(args=args, frame_rate=frame_rate)
|
||||
self.trail_length = trail_length
|
||||
self.histories: dict[int, list[tuple[int, int]]] = {}
|
||||
|
||||
def update(
|
||||
self,
|
||||
detections: list[Detection],
|
||||
frame_shape: tuple[int, int] | tuple[int, int, int] | None = None,
|
||||
) -> list[Track]:
|
||||
tracked = self.tracker.update(_ByteTrackDetections(detections), img=None)
|
||||
tracks: list[Track] = []
|
||||
if tracked is None or len(tracked) == 0:
|
||||
return tracks
|
||||
|
||||
for row in tracked:
|
||||
x1, y1, x2, y2, track_id, score, class_id, _idx = row.tolist()
|
||||
xyxy = np.asarray([x1, y1, x2, y2], dtype=float)
|
||||
tid = int(track_id)
|
||||
center = (int((x1 + x2) / 2), int((y1 + y2) / 2))
|
||||
history = self.histories.setdefault(tid, [])
|
||||
history.append(center)
|
||||
if len(history) > self.trail_length:
|
||||
self.histories[tid] = history[-self.trail_length :]
|
||||
history = self.histories[tid]
|
||||
tracks.append(
|
||||
Track(
|
||||
track_id=tid,
|
||||
xyxy=xyxy,
|
||||
score=float(score),
|
||||
class_id=int(class_id),
|
||||
class_name="drone",
|
||||
history=list(history),
|
||||
)
|
||||
)
|
||||
return tracks
|
||||
@@ -0,0 +1,108 @@
|
||||
from __future__ import annotations
|
||||
|
||||
import cv2
|
||||
import numpy as np
|
||||
|
||||
from .tracker import Track
|
||||
|
||||
|
||||
def load_logo(path: str | None, frame_width: int, max_width_ratio: float = 0.12) -> np.ndarray | None:
|
||||
if not path:
|
||||
return None
|
||||
|
||||
logo = cv2.imread(path, cv2.IMREAD_UNCHANGED)
|
||||
if logo is None:
|
||||
raise FileNotFoundError(f"Cannot read logo image: {path}")
|
||||
|
||||
max_width = max(80, int(frame_width * max_width_ratio))
|
||||
if logo.shape[1] > max_width:
|
||||
scale = max_width / logo.shape[1]
|
||||
new_size = (max_width, max(1, int(logo.shape[0] * scale)))
|
||||
logo = cv2.resize(logo, new_size, interpolation=cv2.INTER_AREA)
|
||||
return logo
|
||||
|
||||
|
||||
def overlay_logo(
|
||||
frame: np.ndarray,
|
||||
logo: np.ndarray | None,
|
||||
margin: int = 24,
|
||||
opacity: float = 0.9,
|
||||
) -> np.ndarray:
|
||||
if logo is None:
|
||||
return frame
|
||||
|
||||
canvas = frame.copy()
|
||||
logo_h, logo_w = logo.shape[:2]
|
||||
x1 = max(0, canvas.shape[1] - logo_w - margin)
|
||||
y1 = margin
|
||||
x2 = min(canvas.shape[1], x1 + logo_w)
|
||||
y2 = min(canvas.shape[0], y1 + logo_h)
|
||||
|
||||
logo_crop = logo[: y2 - y1, : x2 - x1]
|
||||
roi = canvas[y1:y2, x1:x2]
|
||||
|
||||
if logo_crop.shape[2] == 4:
|
||||
alpha = (logo_crop[:, :, 3:4].astype(float) / 255.0) * opacity
|
||||
blended = alpha * logo_crop[:, :, :3].astype(float) + (1.0 - alpha) * roi.astype(float)
|
||||
canvas[y1:y2, x1:x2] = blended.astype(np.uint8)
|
||||
else:
|
||||
blended = cv2.addWeighted(logo_crop[:, :, :3], opacity, roi, 1.0 - opacity, 0)
|
||||
canvas[y1:y2, x1:x2] = blended
|
||||
|
||||
return canvas
|
||||
|
||||
|
||||
def color_for_id(track_id: int) -> tuple[int, int, int]:
|
||||
rng = np.random.default_rng(track_id * 1009)
|
||||
color = rng.integers(64, 255, size=3)
|
||||
return int(color[0]), int(color[1]), int(color[2])
|
||||
|
||||
|
||||
def draw_tracks(frame: np.ndarray, tracks: list[Track], frame_index: int) -> np.ndarray:
|
||||
canvas = frame.copy()
|
||||
for track in tracks:
|
||||
color = color_for_id(track.track_id)
|
||||
x1, y1, x2, y2 = track.xyxy.astype(int)
|
||||
|
||||
cv2.rectangle(canvas, (x1, y1), (x2, y2), color, 2)
|
||||
label = f"ID {track.track_id} {track.class_name} {track.score:.2f}"
|
||||
draw_label(canvas, label, x1, y1, color)
|
||||
|
||||
if len(track.history) >= 2:
|
||||
pts = np.array(track.history, dtype=np.int32).reshape((-1, 1, 2))
|
||||
cv2.polylines(canvas, [pts], isClosed=False, color=color, thickness=2)
|
||||
cv2.circle(canvas, track.history[-1], 4, color, -1)
|
||||
|
||||
cv2.putText(
|
||||
canvas,
|
||||
f"Frame {frame_index} | Active tracks: {len(tracks)}",
|
||||
(20, 36),
|
||||
cv2.FONT_HERSHEY_SIMPLEX,
|
||||
0.9,
|
||||
(20, 220, 255),
|
||||
2,
|
||||
cv2.LINE_AA,
|
||||
)
|
||||
return canvas
|
||||
|
||||
|
||||
def draw_label(frame: np.ndarray, text: str, x: int, y: int, color: tuple[int, int, int]) -> None:
|
||||
font = cv2.FONT_HERSHEY_SIMPLEX
|
||||
font_scale = 0.6
|
||||
thickness = 2
|
||||
(text_w, text_h), baseline = cv2.getTextSize(text, font, font_scale, thickness)
|
||||
top = max(0, y - text_h - baseline - 8)
|
||||
left = max(0, x)
|
||||
right = min(frame.shape[1] - 1, left + text_w + 10)
|
||||
bottom = min(frame.shape[0] - 1, top + text_h + baseline + 8)
|
||||
cv2.rectangle(frame, (left, top), (right, bottom), color, -1)
|
||||
cv2.putText(
|
||||
frame,
|
||||
text,
|
||||
(left + 5, bottom - baseline - 4),
|
||||
font,
|
||||
font_scale,
|
||||
(0, 0, 0),
|
||||
thickness,
|
||||
cv2.LINE_AA,
|
||||
)
|
||||
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
@@ -0,0 +1,27 @@
|
||||
# Ultralytics YOLO 🚀, AGPL-3.0 license
|
||||
|
||||
__version__ = "8.2.10"
|
||||
|
||||
from ultralytics.data.explorer.explorer import Explorer
|
||||
from ultralytics.models import RTDETR, SAM, YOLO, YOLOWorld
|
||||
from ultralytics.models.fastsam import FastSAM
|
||||
from ultralytics.models.nas import NAS
|
||||
from ultralytics.utils import ASSETS, SETTINGS
|
||||
from ultralytics.utils.checks import check_yolo as checks
|
||||
from ultralytics.utils.downloads import download
|
||||
|
||||
settings = SETTINGS
|
||||
__all__ = (
|
||||
"__version__",
|
||||
"ASSETS",
|
||||
"YOLO",
|
||||
"YOLOWorld",
|
||||
"NAS",
|
||||
"SAM",
|
||||
"FastSAM",
|
||||
"RTDETR",
|
||||
"checks",
|
||||
"download",
|
||||
"settings",
|
||||
"Explorer",
|
||||
)
|
||||
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
|
After Width: | Height: | Size: 134 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 49 KiB |
@@ -0,0 +1,620 @@
|
||||
# Ultralytics YOLO 🚀, AGPL-3.0 license
|
||||
|
||||
import contextlib
|
||||
import shutil
|
||||
import subprocess
|
||||
import sys
|
||||
from pathlib import Path
|
||||
from types import SimpleNamespace
|
||||
from typing import Dict, List, Union
|
||||
|
||||
from ultralytics.utils import (
|
||||
ASSETS,
|
||||
DEFAULT_CFG,
|
||||
DEFAULT_CFG_DICT,
|
||||
DEFAULT_CFG_PATH,
|
||||
LOGGER,
|
||||
RANK,
|
||||
ROOT,
|
||||
RUNS_DIR,
|
||||
SETTINGS,
|
||||
SETTINGS_YAML,
|
||||
TESTS_RUNNING,
|
||||
IterableSimpleNamespace,
|
||||
__version__,
|
||||
checks,
|
||||
colorstr,
|
||||
deprecation_warn,
|
||||
yaml_load,
|
||||
yaml_print,
|
||||
)
|
||||
|
||||
# Define valid tasks and modes
|
||||
MODES = {"train", "val", "predict", "export", "track", "benchmark"}
|
||||
TASKS = {"detect", "detectbin", "detectqg", "detrack", "demask", "detrackmask", "segment", "classify", "pose", "obb"}
|
||||
TASK2DATA = {
|
||||
"detect": "coco8.yaml",
|
||||
"detectbin": "coco8.yaml",
|
||||
"detectqg": "coco8.yaml",
|
||||
"detrack": "coco8.yaml",
|
||||
"demask": "coco8.yaml",
|
||||
"detrackmask": "coco8.yaml",
|
||||
"segment": "coco8-seg.yaml",
|
||||
"classify": "imagenet10",
|
||||
"pose": "coco8-pose.yaml",
|
||||
"obb": "dota8.yaml",
|
||||
}
|
||||
TASK2MODEL = {
|
||||
"detect": "yolov8n.pt",
|
||||
"detectbin": "yolov8n.pt",
|
||||
"detectqg": "yolov8n.pt",
|
||||
"detrack": "yolov8n.pt",
|
||||
"demask": "yolov8n.pt",
|
||||
"detrackmask": "yolov8n.pt",
|
||||
"segment": "yolov8n-seg.pt",
|
||||
"classify": "yolov8n-cls.pt",
|
||||
"pose": "yolov8n-pose.pt",
|
||||
"obb": "yolov8n-obb.pt",
|
||||
}
|
||||
TASK2METRIC = {
|
||||
"detect": "metrics/mAP50-95(B)",
|
||||
"detectbin": "metrics/mAP50-95(B)",
|
||||
"detectqg": "metrics/mAP50-95(B)",
|
||||
"detrack": "metrics/mAP50-95(B)",
|
||||
"demask": "metrics/mAP50-95(B)",
|
||||
"detrackmask": "metrics/mAP50-95(B)",
|
||||
"segment": "metrics/mAP50-95(M)",
|
||||
"classify": "metrics/accuracy_top1",
|
||||
"pose": "metrics/mAP50-95(P)",
|
||||
"obb": "metrics/mAP50-95(B)",
|
||||
}
|
||||
MODELS = {TASK2MODEL[task] for task in TASKS}
|
||||
|
||||
ARGV = sys.argv or ["", ""] # sometimes sys.argv = []
|
||||
CLI_HELP_MSG = f"""
|
||||
Arguments received: {str(['yolo'] + ARGV[1:])}. Ultralytics 'yolo' commands use the following syntax:
|
||||
|
||||
yolo TASK MODE ARGS
|
||||
|
||||
Where TASK (optional) is one of {TASKS}
|
||||
MODE (required) is one of {MODES}
|
||||
ARGS (optional) are any number of custom 'arg=value' pairs like 'imgsz=320' that override defaults.
|
||||
See all ARGS at https://docs.ultralytics.com/usage/cfg or with 'yolo cfg'
|
||||
|
||||
1. Train a detection model for 10 epochs with an initial learning_rate of 0.01
|
||||
yolo train data=coco8.yaml model=yolov8n.pt epochs=10 lr0=0.01
|
||||
|
||||
2. Predict a YouTube video using a pretrained segmentation model at image size 320:
|
||||
yolo predict model=yolov8n-seg.pt source='https://youtu.be/LNwODJXcvt4' imgsz=320
|
||||
|
||||
3. Val a pretrained detection model at batch-size 1 and image size 640:
|
||||
yolo val model=yolov8n.pt data=coco8.yaml batch=1 imgsz=640
|
||||
|
||||
4. Export a YOLOv8n classification model to ONNX format at image size 224 by 128 (no TASK required)
|
||||
yolo export model=yolov8n-cls.pt format=onnx imgsz=224,128
|
||||
|
||||
6. Explore your datasets using semantic search and SQL with a simple GUI powered by Ultralytics Explorer API
|
||||
yolo explorer
|
||||
|
||||
5. Run special commands:
|
||||
yolo help
|
||||
yolo checks
|
||||
yolo version
|
||||
yolo settings
|
||||
yolo copy-cfg
|
||||
yolo cfg
|
||||
|
||||
Docs: https://docs.ultralytics.com
|
||||
Community: https://community.ultralytics.com
|
||||
GitHub: https://github.com/ultralytics/ultralytics
|
||||
"""
|
||||
|
||||
# Define keys for arg type checks
|
||||
CFG_FLOAT_KEYS = {"warmup_epochs", "box", "cls", "obj", "dfl", "degrees", "shear", "time", "workspace"}
|
||||
CFG_FRACTION_KEYS = {
|
||||
"dropout",
|
||||
"iou",
|
||||
"lr0",
|
||||
"lrf",
|
||||
"momentum",
|
||||
"weight_decay",
|
||||
"warmup_momentum",
|
||||
"warmup_bias_lr",
|
||||
"label_smoothing",
|
||||
"hsv_h",
|
||||
"hsv_s",
|
||||
"hsv_v",
|
||||
"translate",
|
||||
"scale",
|
||||
"perspective",
|
||||
"flipud",
|
||||
"fliplr",
|
||||
"bgr",
|
||||
"mosaic",
|
||||
"mixup",
|
||||
"copy_paste",
|
||||
"conf",
|
||||
"iou",
|
||||
"fraction",
|
||||
} # fraction floats 0.0 - 1.0
|
||||
CFG_INT_KEYS = {
|
||||
"ch",
|
||||
"epochs",
|
||||
"patience",
|
||||
"batch",
|
||||
"workers",
|
||||
"seed",
|
||||
"close_mosaic",
|
||||
"mask_ratio",
|
||||
"max_det",
|
||||
"vid_stride",
|
||||
"line_width",
|
||||
"nbs",
|
||||
"save_period",
|
||||
}
|
||||
CFG_BOOL_KEYS = {
|
||||
"save",
|
||||
"exist_ok",
|
||||
"verbose",
|
||||
"deterministic",
|
||||
"single_cls",
|
||||
"rect",
|
||||
"cos_lr",
|
||||
"overlap_mask",
|
||||
"val",
|
||||
"save_json",
|
||||
"save_hybrid",
|
||||
"half",
|
||||
"dnn",
|
||||
"plots",
|
||||
"show",
|
||||
"save_txt",
|
||||
"save_conf",
|
||||
"save_crop",
|
||||
"save_frames",
|
||||
"show_labels",
|
||||
"show_conf",
|
||||
"visualize",
|
||||
"augment",
|
||||
"agnostic_nms",
|
||||
"retina_masks",
|
||||
"show_boxes",
|
||||
"keras",
|
||||
"optimize",
|
||||
"int8",
|
||||
"dynamic",
|
||||
"simplify",
|
||||
"nms",
|
||||
"profile",
|
||||
"multi_scale",
|
||||
}
|
||||
|
||||
|
||||
def cfg2dict(cfg):
|
||||
"""
|
||||
Convert a configuration object to a dictionary, whether it is a file path, a string, or a SimpleNamespace object.
|
||||
|
||||
Args:
|
||||
cfg (str | Path | dict | SimpleNamespace): Configuration object to be converted to a dictionary.
|
||||
|
||||
Returns:
|
||||
cfg (dict): Configuration object in dictionary format.
|
||||
"""
|
||||
if isinstance(cfg, (str, Path)):
|
||||
cfg = yaml_load(cfg) # load dict
|
||||
elif isinstance(cfg, SimpleNamespace):
|
||||
cfg = vars(cfg) # convert to dict
|
||||
return cfg
|
||||
|
||||
|
||||
def get_cfg(cfg: Union[str, Path, Dict, SimpleNamespace] = DEFAULT_CFG_DICT, overrides: Dict = None):
|
||||
"""
|
||||
Load and merge configuration data from a file or dictionary.
|
||||
|
||||
Args:
|
||||
cfg (str | Path | Dict | SimpleNamespace): Configuration data.
|
||||
overrides (str | Dict | optional): Overrides in the form of a file name or a dictionary. Default is None.
|
||||
|
||||
Returns:
|
||||
(SimpleNamespace): Training arguments namespace.
|
||||
"""
|
||||
cfg = cfg2dict(cfg)
|
||||
|
||||
# Merge overrides
|
||||
if overrides:
|
||||
overrides = cfg2dict(overrides)
|
||||
if "save_dir" not in cfg:
|
||||
overrides.pop("save_dir", None) # special override keys to ignore
|
||||
check_dict_alignment(cfg, overrides)
|
||||
cfg = {**cfg, **overrides} # merge cfg and overrides dicts (prefer overrides)
|
||||
|
||||
# Special handling for numeric project/name
|
||||
for k in "project", "name":
|
||||
if k in cfg and isinstance(cfg[k], (int, float)):
|
||||
cfg[k] = str(cfg[k])
|
||||
if cfg.get("name") == "model": # assign model to 'name' arg
|
||||
cfg["name"] = cfg.get("model", "").split(".")[0]
|
||||
LOGGER.warning(f"WARNING ⚠️ 'name=model' automatically updated to 'name={cfg['name']}'.")
|
||||
|
||||
# Type and Value checks
|
||||
check_cfg(cfg)
|
||||
|
||||
# Return instance
|
||||
return IterableSimpleNamespace(**cfg)
|
||||
|
||||
|
||||
def check_cfg(cfg, hard=True):
|
||||
"""Check Ultralytics configuration argument types and values."""
|
||||
for k, v in cfg.items():
|
||||
if v is not None: # None values may be from optional args
|
||||
if k in CFG_FLOAT_KEYS and not isinstance(v, (int, float)):
|
||||
if hard:
|
||||
raise TypeError(
|
||||
f"'{k}={v}' is of invalid type {type(v).__name__}. "
|
||||
f"Valid '{k}' types are int (i.e. '{k}=0') or float (i.e. '{k}=0.5')"
|
||||
)
|
||||
cfg[k] = float(v)
|
||||
elif k in CFG_FRACTION_KEYS:
|
||||
if not isinstance(v, (int, float)):
|
||||
if hard:
|
||||
raise TypeError(
|
||||
f"'{k}={v}' is of invalid type {type(v).__name__}. "
|
||||
f"Valid '{k}' types are int (i.e. '{k}=0') or float (i.e. '{k}=0.5')"
|
||||
)
|
||||
cfg[k] = v = float(v)
|
||||
if not (0.0 <= v <= 1.0):
|
||||
raise ValueError(f"'{k}={v}' is an invalid value. " f"Valid '{k}' values are between 0.0 and 1.0.")
|
||||
elif k in CFG_INT_KEYS and not isinstance(v, int):
|
||||
if hard:
|
||||
raise TypeError(
|
||||
f"'{k}={v}' is of invalid type {type(v).__name__}. " f"'{k}' must be an int (i.e. '{k}=8')"
|
||||
)
|
||||
cfg[k] = int(v)
|
||||
elif k in CFG_BOOL_KEYS and not isinstance(v, bool):
|
||||
if hard:
|
||||
raise TypeError(
|
||||
f"'{k}={v}' is of invalid type {type(v).__name__}. "
|
||||
f"'{k}' must be a bool (i.e. '{k}=True' or '{k}=False')"
|
||||
)
|
||||
cfg[k] = bool(v)
|
||||
|
||||
|
||||
def get_save_dir(args, name=None):
|
||||
"""Return save_dir as created from train/val/predict arguments."""
|
||||
|
||||
# if getattr(args, "save_dir", None):
|
||||
# save_dir = args.save_dir
|
||||
if getattr(args, "name", None):
|
||||
save_dir = args.name
|
||||
else:
|
||||
from ultralytics.utils.files import increment_path
|
||||
|
||||
project = args.project or (ROOT.parent / "tests/tmp/runs" if TESTS_RUNNING else RUNS_DIR) / args.task
|
||||
name = name or args.name or f"{args.mode}"
|
||||
save_dir = increment_path(Path(project) / name, exist_ok=args.exist_ok if RANK in {-1, 0} else True)
|
||||
|
||||
return Path(save_dir)
|
||||
|
||||
|
||||
def _handle_deprecation(custom):
|
||||
"""Hardcoded function to handle deprecated config keys."""
|
||||
|
||||
for key in custom.copy().keys():
|
||||
if key == "boxes":
|
||||
deprecation_warn(key, "show_boxes")
|
||||
custom["show_boxes"] = custom.pop("boxes")
|
||||
if key == "hide_labels":
|
||||
deprecation_warn(key, "show_labels")
|
||||
custom["show_labels"] = custom.pop("hide_labels") == "False"
|
||||
if key == "hide_conf":
|
||||
deprecation_warn(key, "show_conf")
|
||||
custom["show_conf"] = custom.pop("hide_conf") == "False"
|
||||
if key == "line_thickness":
|
||||
deprecation_warn(key, "line_width")
|
||||
custom["line_width"] = custom.pop("line_thickness")
|
||||
|
||||
return custom
|
||||
|
||||
|
||||
def check_dict_alignment(base: Dict, custom: Dict, e=None):
|
||||
"""
|
||||
This function checks for any mismatched keys between a custom configuration list and a base configuration list. If
|
||||
any mismatched keys are found, the function prints out similar keys from the base list and exits the program.
|
||||
|
||||
Args:
|
||||
custom (dict): a dictionary of custom configuration options
|
||||
base (dict): a dictionary of base configuration options
|
||||
e (Error, optional): An optional error that is passed by the calling function.
|
||||
"""
|
||||
custom = _handle_deprecation(custom)
|
||||
base_keys, custom_keys = (set(x.keys()) for x in (base, custom))
|
||||
mismatched = [k for k in custom_keys if k not in base_keys]
|
||||
if mismatched:
|
||||
from difflib import get_close_matches
|
||||
|
||||
string = ""
|
||||
for x in mismatched:
|
||||
matches = get_close_matches(x, base_keys) # key list
|
||||
matches = [f"{k}={base[k]}" if base.get(k) is not None else k for k in matches]
|
||||
match_str = f"Similar arguments are i.e. {matches}." if matches else ""
|
||||
string += f"'{colorstr('red', 'bold', x)}' is not a valid YOLO argument. {match_str}\n"
|
||||
raise SyntaxError(string + CLI_HELP_MSG) from e
|
||||
|
||||
|
||||
def merge_equals_args(args: List[str]) -> List[str]:
|
||||
"""
|
||||
Merges arguments around isolated '=' args in a list of strings. The function considers cases where the first
|
||||
argument ends with '=' or the second starts with '=', as well as when the middle one is an equals sign.
|
||||
|
||||
Args:
|
||||
args (List[str]): A list of strings where each element is an argument.
|
||||
|
||||
Returns:
|
||||
(List[str]): A list of strings where the arguments around isolated '=' are merged.
|
||||
"""
|
||||
new_args = []
|
||||
for i, arg in enumerate(args):
|
||||
if arg == "=" and 0 < i < len(args) - 1: # merge ['arg', '=', 'val']
|
||||
new_args[-1] += f"={args[i + 1]}"
|
||||
del args[i + 1]
|
||||
elif arg.endswith("=") and i < len(args) - 1 and "=" not in args[i + 1]: # merge ['arg=', 'val']
|
||||
new_args.append(f"{arg}{args[i + 1]}")
|
||||
del args[i + 1]
|
||||
elif arg.startswith("=") and i > 0: # merge ['arg', '=val']
|
||||
new_args[-1] += arg
|
||||
else:
|
||||
new_args.append(arg)
|
||||
return new_args
|
||||
|
||||
|
||||
def handle_yolo_hub(args: List[str]) -> None:
|
||||
"""
|
||||
Handle Ultralytics HUB command-line interface (CLI) commands.
|
||||
|
||||
This function processes Ultralytics HUB CLI commands such as login and logout.
|
||||
It should be called when executing a script with arguments related to HUB authentication.
|
||||
|
||||
Args:
|
||||
args (List[str]): A list of command line arguments
|
||||
|
||||
Example:
|
||||
```bash
|
||||
python my_script.py hub login your_api_key
|
||||
```
|
||||
"""
|
||||
from ultralytics import hub
|
||||
|
||||
if args[0] == "login":
|
||||
key = args[1] if len(args) > 1 else ""
|
||||
# Log in to Ultralytics HUB using the provided API key
|
||||
hub.login(key)
|
||||
elif args[0] == "logout":
|
||||
# Log out from Ultralytics HUB
|
||||
hub.logout()
|
||||
|
||||
|
||||
def handle_yolo_settings(args: List[str]) -> None:
|
||||
"""
|
||||
Handle YOLO settings command-line interface (CLI) commands.
|
||||
|
||||
This function processes YOLO settings CLI commands such as reset.
|
||||
It should be called when executing a script with arguments related to YOLO settings management.
|
||||
|
||||
Args:
|
||||
args (List[str]): A list of command line arguments for YOLO settings management.
|
||||
|
||||
Example:
|
||||
```bash
|
||||
python my_script.py yolo settings reset
|
||||
```
|
||||
"""
|
||||
url = "https://docs.ultralytics.com/quickstart/#ultralytics-settings" # help URL
|
||||
try:
|
||||
if any(args):
|
||||
if args[0] == "reset":
|
||||
SETTINGS_YAML.unlink() # delete the settings file
|
||||
SETTINGS.reset() # create new settings
|
||||
LOGGER.info("Settings reset successfully") # inform the user that settings have been reset
|
||||
else: # save a new setting
|
||||
new = dict(parse_key_value_pair(a) for a in args)
|
||||
check_dict_alignment(SETTINGS, new)
|
||||
SETTINGS.update(new)
|
||||
|
||||
LOGGER.info(f"💡 Learn about settings at {url}")
|
||||
yaml_print(SETTINGS_YAML) # print the current settings
|
||||
except Exception as e:
|
||||
LOGGER.warning(f"WARNING ⚠️ settings error: '{e}'. Please see {url} for help.")
|
||||
|
||||
|
||||
def handle_explorer():
|
||||
"""Open the Ultralytics Explorer GUI."""
|
||||
checks.check_requirements("streamlit")
|
||||
LOGGER.info("💡 Loading Explorer dashboard...")
|
||||
subprocess.run(["streamlit", "run", ROOT / "data/explorer/gui/dash.py", "--server.maxMessageSize", "2048"])
|
||||
|
||||
|
||||
def parse_key_value_pair(pair):
|
||||
"""Parse one 'key=value' pair and return key and value."""
|
||||
k, v = pair.split("=", 1) # split on first '=' sign
|
||||
k, v = k.strip(), v.strip() # remove spaces
|
||||
assert v, f"missing '{k}' value"
|
||||
return k, smart_value(v)
|
||||
|
||||
|
||||
def smart_value(v):
|
||||
"""Convert a string to an underlying type such as int, float, bool, etc."""
|
||||
v_lower = v.lower()
|
||||
if v_lower == "none":
|
||||
return None
|
||||
elif v_lower == "true":
|
||||
return True
|
||||
elif v_lower == "false":
|
||||
return False
|
||||
else:
|
||||
with contextlib.suppress(Exception):
|
||||
return eval(v)
|
||||
return v
|
||||
|
||||
|
||||
def entrypoint(debug=""):
|
||||
"""
|
||||
This function is the ultralytics package entrypoint, it's responsible for parsing the command line arguments passed
|
||||
to the package.
|
||||
|
||||
This function allows for:
|
||||
- passing mandatory YOLO args as a list of strings
|
||||
- specifying the task to be performed, either 'detect', 'segment' or 'classify'
|
||||
- specifying the mode, either 'train', 'val', 'test', or 'predict'
|
||||
- running special modes like 'checks'
|
||||
- passing overrides to the package's configuration
|
||||
|
||||
It uses the package's default cfg and initializes it using the passed overrides.
|
||||
Then it calls the CLI function with the composed cfg
|
||||
"""
|
||||
args = (debug.split(" ") if debug else ARGV)[1:]
|
||||
if not args: # no arguments passed
|
||||
LOGGER.info(CLI_HELP_MSG)
|
||||
return
|
||||
|
||||
special = {
|
||||
"help": lambda: LOGGER.info(CLI_HELP_MSG),
|
||||
"checks": checks.collect_system_info,
|
||||
"version": lambda: LOGGER.info(__version__),
|
||||
"settings": lambda: handle_yolo_settings(args[1:]),
|
||||
"cfg": lambda: yaml_print(DEFAULT_CFG_PATH),
|
||||
"hub": lambda: handle_yolo_hub(args[1:]),
|
||||
"login": lambda: handle_yolo_hub(args),
|
||||
"copy-cfg": copy_default_cfg,
|
||||
"explorer": lambda: handle_explorer(),
|
||||
}
|
||||
full_args_dict = {**DEFAULT_CFG_DICT, **{k: None for k in TASKS}, **{k: None for k in MODES}, **special}
|
||||
|
||||
# Define common misuses of special commands, i.e. -h, -help, --help
|
||||
special.update({k[0]: v for k, v in special.items()}) # singular
|
||||
special.update({k[:-1]: v for k, v in special.items() if len(k) > 1 and k.endswith("s")}) # singular
|
||||
special = {**special, **{f"-{k}": v for k, v in special.items()}, **{f"--{k}": v for k, v in special.items()}}
|
||||
|
||||
overrides = {} # basic overrides, i.e. imgsz=320
|
||||
for a in merge_equals_args(args): # merge spaces around '=' sign
|
||||
if a.startswith("--"):
|
||||
LOGGER.warning(f"WARNING ⚠️ argument '{a}' does not require leading dashes '--', updating to '{a[2:]}'.")
|
||||
a = a[2:]
|
||||
if a.endswith(","):
|
||||
LOGGER.warning(f"WARNING ⚠️ argument '{a}' does not require trailing comma ',', updating to '{a[:-1]}'.")
|
||||
a = a[:-1]
|
||||
if "=" in a:
|
||||
try:
|
||||
k, v = parse_key_value_pair(a)
|
||||
if k == "cfg" and v is not None: # custom.yaml passed
|
||||
LOGGER.info(f"Overriding {DEFAULT_CFG_PATH} with {v}")
|
||||
overrides = {k: val for k, val in yaml_load(checks.check_yaml(v)).items() if k != "cfg"}
|
||||
else:
|
||||
overrides[k] = v
|
||||
except (NameError, SyntaxError, ValueError, AssertionError) as e:
|
||||
check_dict_alignment(full_args_dict, {a: ""}, e)
|
||||
|
||||
elif a in TASKS:
|
||||
overrides["task"] = a
|
||||
elif a in MODES:
|
||||
overrides["mode"] = a
|
||||
elif a.lower() in special:
|
||||
special[a.lower()]()
|
||||
return
|
||||
elif a in DEFAULT_CFG_DICT and isinstance(DEFAULT_CFG_DICT[a], bool):
|
||||
overrides[a] = True # auto-True for default bool args, i.e. 'yolo show' sets show=True
|
||||
elif a in DEFAULT_CFG_DICT:
|
||||
raise SyntaxError(
|
||||
f"'{colorstr('red', 'bold', a)}' is a valid YOLO argument but is missing an '=' sign "
|
||||
f"to set its value, i.e. try '{a}={DEFAULT_CFG_DICT[a]}'\n{CLI_HELP_MSG}"
|
||||
)
|
||||
else:
|
||||
check_dict_alignment(full_args_dict, {a: ""})
|
||||
|
||||
# Check keys
|
||||
check_dict_alignment(full_args_dict, overrides)
|
||||
|
||||
# Mode
|
||||
mode = overrides.get("mode")
|
||||
if mode is None:
|
||||
mode = DEFAULT_CFG.mode or "predict"
|
||||
LOGGER.warning(f"WARNING ⚠️ 'mode' argument is missing. Valid modes are {MODES}. Using default 'mode={mode}'.")
|
||||
elif mode not in MODES:
|
||||
raise ValueError(f"Invalid 'mode={mode}'. Valid modes are {MODES}.\n{CLI_HELP_MSG}")
|
||||
|
||||
# Task
|
||||
task = overrides.pop("task", None)
|
||||
if task:
|
||||
if task not in TASKS:
|
||||
raise ValueError(f"Invalid 'task={task}'. Valid tasks are {TASKS}.\n{CLI_HELP_MSG}")
|
||||
if "model" not in overrides:
|
||||
overrides["model"] = TASK2MODEL[task]
|
||||
|
||||
# Model
|
||||
model = overrides.pop("model", DEFAULT_CFG.model)
|
||||
if model is None:
|
||||
model = "yolov8n.pt"
|
||||
LOGGER.warning(f"WARNING ⚠️ 'model' argument is missing. Using default 'model={model}'.")
|
||||
overrides["model"] = model
|
||||
stem = Path(model).stem.lower()
|
||||
if "rtdetr" in stem: # guess architecture
|
||||
from ultralytics import RTDETR
|
||||
|
||||
model = RTDETR(model) # no task argument
|
||||
elif "fastsam" in stem:
|
||||
from ultralytics import FastSAM
|
||||
|
||||
model = FastSAM(model)
|
||||
elif "sam" in stem:
|
||||
from ultralytics import SAM
|
||||
|
||||
model = SAM(model)
|
||||
else:
|
||||
from ultralytics import YOLO
|
||||
|
||||
model = YOLO(model, task=task)
|
||||
if isinstance(overrides.get("pretrained"), str):
|
||||
model.load(overrides["pretrained"])
|
||||
|
||||
# Task Update
|
||||
if task != model.task:
|
||||
if task:
|
||||
LOGGER.warning(
|
||||
f"WARNING ⚠️ conflicting 'task={task}' passed with 'task={model.task}' model. "
|
||||
f"Ignoring 'task={task}' and updating to 'task={model.task}' to match model."
|
||||
)
|
||||
task = model.task
|
||||
|
||||
# Mode
|
||||
if mode in {"predict", "track"} and "source" not in overrides:
|
||||
overrides["source"] = DEFAULT_CFG.source or ASSETS
|
||||
LOGGER.warning(f"WARNING ⚠️ 'source' argument is missing. Using default 'source={overrides['source']}'.")
|
||||
elif mode in {"train", "val"}:
|
||||
if "data" not in overrides and "resume" not in overrides:
|
||||
overrides["data"] = DEFAULT_CFG.data or TASK2DATA.get(task or DEFAULT_CFG.task, DEFAULT_CFG.data)
|
||||
LOGGER.warning(f"WARNING ⚠️ 'data' argument is missing. Using default 'data={overrides['data']}'.")
|
||||
elif mode == "export":
|
||||
if "format" not in overrides:
|
||||
overrides["format"] = DEFAULT_CFG.format or "torchscript"
|
||||
LOGGER.warning(f"WARNING ⚠️ 'format' argument is missing. Using default 'format={overrides['format']}'.")
|
||||
|
||||
# Run command in python
|
||||
getattr(model, mode)(**overrides) # default args from model
|
||||
|
||||
# Show help
|
||||
LOGGER.info(f"💡 Learn more at https://docs.ultralytics.com/modes/{mode}")
|
||||
|
||||
|
||||
# Special modes --------------------------------------------------------------------------------------------------------
|
||||
def copy_default_cfg():
|
||||
"""Copy and create a new default configuration file with '_copy' appended to its name."""
|
||||
new_file = Path.cwd() / DEFAULT_CFG_PATH.name.replace(".yaml", "_copy.yaml")
|
||||
shutil.copy2(DEFAULT_CFG_PATH, new_file)
|
||||
LOGGER.info(
|
||||
f"{DEFAULT_CFG_PATH} copied to {new_file}\n"
|
||||
f"Example YOLO command with this new custom cfg:\n yolo cfg='{new_file}' imgsz=320 batch=8"
|
||||
)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
# Example: entrypoint(debug='yolo predict model=yolov8n.pt')
|
||||
entrypoint(debug="")
|
||||
Binary file not shown.
Binary file not shown.
@@ -0,0 +1,74 @@
|
||||
# Ultralytics YOLO 🚀, AGPL-3.0 license
|
||||
# Argoverse-HD dataset (ring-front-center camera) https://www.cs.cmu.edu/~mengtial/proj/streaming/ by Argo AI
|
||||
# Documentation: https://docs.ultralytics.com/datasets/detect/argoverse/
|
||||
# Example usage: yolo train data=Argoverse.yaml
|
||||
# parent
|
||||
# ├── ultralytics
|
||||
# └── datasets
|
||||
# └── Argoverse ← downloads here (31.5 GB)
|
||||
|
||||
# Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..]
|
||||
path: ../datasets/Argoverse # dataset root dir
|
||||
train: Argoverse-1.1/images/train/ # train images (relative to 'path') 39384 images
|
||||
val: Argoverse-1.1/images/val/ # val images (relative to 'path') 15062 images
|
||||
test: Argoverse-1.1/images/test/ # test images (optional) https://eval.ai/web/challenges/challenge-page/800/overview
|
||||
|
||||
# Classes
|
||||
names:
|
||||
0: person
|
||||
1: bicycle
|
||||
2: car
|
||||
3: motorcycle
|
||||
4: bus
|
||||
5: truck
|
||||
6: traffic_light
|
||||
7: stop_sign
|
||||
|
||||
# Download script/URL (optional) ---------------------------------------------------------------------------------------
|
||||
download: |
|
||||
import json
|
||||
from tqdm import tqdm
|
||||
from ultralytics.utils.downloads import download
|
||||
from pathlib import Path
|
||||
|
||||
def argoverse2yolo(set):
|
||||
labels = {}
|
||||
a = json.load(open(set, "rb"))
|
||||
for annot in tqdm(a['annotations'], desc=f"Converting {set} to YOLOv5 format..."):
|
||||
img_id = annot['image_id']
|
||||
img_name = a['images'][img_id]['name']
|
||||
img_label_name = f'{img_name[:-3]}txt'
|
||||
|
||||
cls = annot['category_id'] # instance class id
|
||||
x_center, y_center, width, height = annot['bbox']
|
||||
x_center = (x_center + width / 2) / 1920.0 # offset and scale
|
||||
y_center = (y_center + height / 2) / 1200.0 # offset and scale
|
||||
width /= 1920.0 # scale
|
||||
height /= 1200.0 # scale
|
||||
|
||||
img_dir = set.parents[2] / 'Argoverse-1.1' / 'labels' / a['seq_dirs'][a['images'][annot['image_id']]['sid']]
|
||||
if not img_dir.exists():
|
||||
img_dir.mkdir(parents=True, exist_ok=True)
|
||||
|
||||
k = str(img_dir / img_label_name)
|
||||
if k not in labels:
|
||||
labels[k] = []
|
||||
labels[k].append(f"{cls} {x_center} {y_center} {width} {height}\n")
|
||||
|
||||
for k in labels:
|
||||
with open(k, "w") as f:
|
||||
f.writelines(labels[k])
|
||||
|
||||
|
||||
# Download 'https://argoverse-hd.s3.us-east-2.amazonaws.com/Argoverse-HD-Full.zip' (deprecated S3 link)
|
||||
dir = Path(yaml['path']) # dataset root dir
|
||||
urls = ['https://drive.google.com/file/d/1st9qW3BeIwQsnR0t8mRpvbsSWIo16ACi/view?usp=drive_link']
|
||||
print("\n\nWARNING: Argoverse dataset MUST be downloaded manually, autodownload will NOT work.")
|
||||
print(f"WARNING: Manually download Argoverse dataset '{urls[0]}' to '{dir}' and re-run your command.\n\n")
|
||||
# download(urls, dir=dir)
|
||||
|
||||
# Convert
|
||||
annotations_dir = 'Argoverse-HD/annotations/'
|
||||
(dir / 'Argoverse-1.1' / 'tracking').rename(dir / 'Argoverse-1.1' / 'images') # rename 'tracking' to 'images'
|
||||
for d in "train.json", "val.json":
|
||||
argoverse2yolo(dir / annotations_dir / d) # convert Argoverse annotations to YOLO labels
|
||||
@@ -0,0 +1,36 @@
|
||||
# Ultralytics YOLO 🚀, AGPL-3.0 license
|
||||
# DOTA 1.5 dataset https://captain-whu.github.io/DOTA/index.html for object detection in aerial images by Wuhan University
|
||||
# Documentation: https://docs.ultralytics.com/datasets/obb/dota-v2/
|
||||
# Example usage: yolo train model=yolov8n-obb.pt data=DOTAv1.5.yaml
|
||||
# parent
|
||||
# ├── ultralytics
|
||||
# └── datasets
|
||||
# └── dota1.5 ← downloads here (2GB)
|
||||
|
||||
# Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..]
|
||||
path: ../datasets/DOTAv1.5 # dataset root dir
|
||||
train: images/train # train images (relative to 'path') 1411 images
|
||||
val: images/val # val images (relative to 'path') 458 images
|
||||
test: images/test # test images (optional) 937 images
|
||||
|
||||
# Classes for DOTA 1.5
|
||||
names:
|
||||
0: plane
|
||||
1: ship
|
||||
2: storage tank
|
||||
3: baseball diamond
|
||||
4: tennis court
|
||||
5: basketball court
|
||||
6: ground track field
|
||||
7: harbor
|
||||
8: bridge
|
||||
9: large vehicle
|
||||
10: small vehicle
|
||||
11: helicopter
|
||||
12: roundabout
|
||||
13: soccer ball field
|
||||
14: swimming pool
|
||||
15: container crane
|
||||
|
||||
# Download script/URL (optional)
|
||||
download: https://github.com/ultralytics/yolov5/releases/download/v1.0/DOTAv1.5.zip
|
||||
@@ -0,0 +1,35 @@
|
||||
# Ultralytics YOLO 🚀, AGPL-3.0 license
|
||||
# DOTA 1.0 dataset https://captain-whu.github.io/DOTA/index.html for object detection in aerial images by Wuhan University
|
||||
# Documentation: https://docs.ultralytics.com/datasets/obb/dota-v2/
|
||||
# Example usage: yolo train model=yolov8n-obb.pt data=DOTAv1.yaml
|
||||
# parent
|
||||
# ├── ultralytics
|
||||
# └── datasets
|
||||
# └── dota1 ← downloads here (2GB)
|
||||
|
||||
# Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..]
|
||||
path: ../datasets/DOTAv1 # dataset root dir
|
||||
train: images/train # train images (relative to 'path') 1411 images
|
||||
val: images/val # val images (relative to 'path') 458 images
|
||||
test: images/test # test images (optional) 937 images
|
||||
|
||||
# Classes for DOTA 1.0
|
||||
names:
|
||||
0: plane
|
||||
1: ship
|
||||
2: storage tank
|
||||
3: baseball diamond
|
||||
4: tennis court
|
||||
5: basketball court
|
||||
6: ground track field
|
||||
7: harbor
|
||||
8: bridge
|
||||
9: large vehicle
|
||||
10: small vehicle
|
||||
11: helicopter
|
||||
12: roundabout
|
||||
13: soccer ball field
|
||||
14: swimming pool
|
||||
|
||||
# Download script/URL (optional)
|
||||
download: https://github.com/ultralytics/yolov5/releases/download/v1.0/DOTAv1.zip
|
||||
@@ -0,0 +1,53 @@
|
||||
# Ultralytics YOLO 🚀, AGPL-3.0 license
|
||||
# Global Wheat 2020 dataset https://www.global-wheat.com/ by University of Saskatchewan
|
||||
# Documentation: https://docs.ultralytics.com/datasets/detect/globalwheat2020/
|
||||
# Example usage: yolo train data=GlobalWheat2020.yaml
|
||||
# parent
|
||||
# ├── ultralytics
|
||||
# └── datasets
|
||||
# └── GlobalWheat2020 ← downloads here (7.0 GB)
|
||||
|
||||
# Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..]
|
||||
path: ../datasets/GlobalWheat2020 # dataset root dir
|
||||
train: # train images (relative to 'path') 3422 images
|
||||
- images/arvalis_1
|
||||
- images/arvalis_2
|
||||
- images/arvalis_3
|
||||
- images/ethz_1
|
||||
- images/rres_1
|
||||
- images/inrae_1
|
||||
- images/usask_1
|
||||
val: # val images (relative to 'path') 748 images (WARNING: train set contains ethz_1)
|
||||
- images/ethz_1
|
||||
test: # test images (optional) 1276 images
|
||||
- images/utokyo_1
|
||||
- images/utokyo_2
|
||||
- images/nau_1
|
||||
- images/uq_1
|
||||
|
||||
# Classes
|
||||
names:
|
||||
0: wheat_head
|
||||
|
||||
# Download script/URL (optional) ---------------------------------------------------------------------------------------
|
||||
download: |
|
||||
from ultralytics.utils.downloads import download
|
||||
from pathlib import Path
|
||||
|
||||
# Download
|
||||
dir = Path(yaml['path']) # dataset root dir
|
||||
urls = ['https://zenodo.org/record/4298502/files/global-wheat-codalab-official.zip',
|
||||
'https://github.com/ultralytics/yolov5/releases/download/v1.0/GlobalWheat2020_labels.zip']
|
||||
download(urls, dir=dir)
|
||||
|
||||
# Make Directories
|
||||
for p in 'annotations', 'images', 'labels':
|
||||
(dir / p).mkdir(parents=True, exist_ok=True)
|
||||
|
||||
# Move
|
||||
for p in 'arvalis_1', 'arvalis_2', 'arvalis_3', 'ethz_1', 'rres_1', 'inrae_1', 'usask_1', \
|
||||
'utokyo_1', 'utokyo_2', 'nau_1', 'uq_1':
|
||||
(dir / 'global-wheat-codalab-official' / p).rename(dir / 'images' / p) # move to /images
|
||||
f = (dir / 'global-wheat-codalab-official' / p).with_suffix('.json') # json file
|
||||
if f.exists():
|
||||
f.rename((dir / 'annotations' / p).with_suffix('.json')) # move to /annotations
|
||||
File diff suppressed because it is too large.
Load diff
@@ -0,0 +1,442 @@
|
||||
# Ultralytics YOLO 🚀, AGPL-3.0 license
|
||||
# Objects365 dataset https://www.objects365.org/ by Megvii
|
||||
# Documentation: https://docs.ultralytics.com/datasets/detect/objects365/
|
||||
# Example usage: yolo train data=Objects365.yaml
|
||||
# parent
|
||||
# ├── ultralytics
|
||||
# └── datasets
|
||||
# └── Objects365 ← downloads here (712 GB = 367G data + 345G zips)
|
||||
|
||||
# Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..]
|
||||
path: ../datasets/Objects365 # dataset root dir
|
||||
train: images/train # train images (relative to 'path') 1742289 images
|
||||
val: images/val # val images (relative to 'path') 80000 images
|
||||
test: # test images (optional)
|
||||
|
||||
# Classes
|
||||
names:
|
||||
0: Person
|
||||
1: Sneakers
|
||||
2: Chair
|
||||
3: Other Shoes
|
||||
4: Hat
|
||||
5: Car
|
||||
6: Lamp
|
||||
7: Glasses
|
||||
8: Bottle
|
||||
9: Desk
|
||||
10: Cup
|
||||
11: Street Lights
|
||||
12: Cabinet/shelf
|
||||
13: Handbag/Satchel
|
||||
14: Bracelet
|
||||
15: Plate
|
||||
16: Picture/Frame
|
||||
17: Helmet
|
||||
18: Book
|
||||
19: Gloves
|
||||
20: Storage box
|
||||
21: Boat
|
||||
22: Leather Shoes
|
||||
23: Flower
|
||||
24: Bench
|
||||
25: Potted Plant
|
||||
26: Bowl/Basin
|
||||
27: Flag
|
||||
28: Pillow
|
||||
29: Boots
|
||||
30: Vase
|
||||
31: Microphone
|
||||
32: Necklace
|
||||
33: Ring
|
||||
34: SUV
|
||||
35: Wine Glass
|
||||
36: Belt
|
||||
37: Monitor/TV
|
||||
38: Backpack
|
||||
39: Umbrella
|
||||
40: Traffic Light
|
||||
41: Speaker
|
||||
42: Watch
|
||||
43: Tie
|
||||
44: Trash bin Can
|
||||
45: Slippers
|
||||
46: Bicycle
|
||||
47: Stool
|
||||
48: Barrel/bucket
|
||||
49: Van
|
||||
50: Couch
|
||||
51: Sandals
|
||||
52: Basket
|
||||
53: Drum
|
||||
54: Pen/Pencil
|
||||
55: Bus
|
||||
56: Wild Bird
|
||||
57: High Heels
|
||||
58: Motorcycle
|
||||
59: Guitar
|
||||
60: Carpet
|
||||
61: Cell Phone
|
||||
62: Bread
|
||||
63: Camera
|
||||
64: Canned
|
||||
65: Truck
|
||||
66: Traffic cone
|
||||
67: Cymbal
|
||||
68: Lifesaver
|
||||
69: Towel
|
||||
70: Stuffed Toy
|
||||
71: Candle
|
||||
72: Sailboat
|
||||
73: Laptop
|
||||
74: Awning
|
||||
75: Bed
|
||||
76: Faucet
|
||||
77: Tent
|
||||
78: Horse
|
||||
79: Mirror
|
||||
80: Power outlet
|
||||
81: Sink
|
||||
82: Apple
|
||||
83: Air Conditioner
|
||||
84: Knife
|
||||
85: Hockey Stick
|
||||
86: Paddle
|
||||
87: Pickup Truck
|
||||
88: Fork
|
||||
89: Traffic Sign
|
||||
90: Balloon
|
||||
91: Tripod
|
||||
92: Dog
|
||||
93: Spoon
|
||||
94: Clock
|
||||
95: Pot
|
||||
96: Cow
|
||||
97: Cake
|
||||
98: Dinning Table
|
||||
99: Sheep
|
||||
100: Hanger
|
||||
101: Blackboard/Whiteboard
|
||||
102: Napkin
|
||||
103: Other Fish
|
||||
104: Orange/Tangerine
|
||||
105: Toiletry
|
||||
106: Keyboard
|
||||
107: Tomato
|
||||
108: Lantern
|
||||
109: Machinery Vehicle
|
||||
110: Fan
|
||||
111: Green Vegetables
|
||||
112: Banana
|
||||
113: Baseball Glove
|
||||
114: Airplane
|
||||
115: Mouse
|
||||
116: Train
|
||||
117: Pumpkin
|
||||
118: Soccer
|
||||
119: Skiboard
|
||||
120: Luggage
|
||||
121: Nightstand
|
||||
122: Tea pot
|
||||
123: Telephone
|
||||
124: Trolley
|
||||
125: Head Phone
|
||||
126: Sports Car
|
||||
127: Stop Sign
|
||||
128: Dessert
|
||||
129: Scooter
|
||||
130: Stroller
|
||||
131: Crane
|
||||
132: Remote
|
||||
133: Refrigerator
|
||||
134: Oven
|
||||
135: Lemon
|
||||
136: Duck
|
||||
137: Baseball Bat
|
||||
138: Surveillance Camera
|
||||
139: Cat
|
||||
140: Jug
|
||||
141: Broccoli
|
||||
142: Piano
|
||||
143: Pizza
|
||||
144: Elephant
|
||||
145: Skateboard
|
||||
146: Surfboard
|
||||
147: Gun
|
||||
148: Skating and Skiing shoes
|
||||
149: Gas stove
|
||||
150: Donut
|
||||
151: Bow Tie
|
||||
152: Carrot
|
||||
153: Toilet
|
||||
154: Kite
|
||||
155: Strawberry
|
||||
156: Other Balls
|
||||
157: Shovel
|
||||
158: Pepper
|
||||
159: Computer Box
|
||||
160: Toilet Paper
|
||||
161: Cleaning Products
|
||||
162: Chopsticks
|
||||
163: Microwave
|
||||
164: Pigeon
|
||||
165: Baseball
|
||||
166: Cutting/chopping Board
|
||||
167: Coffee Table
|
||||
168: Side Table
|
||||
169: Scissors
|
||||
170: Marker
|
||||
171: Pie
|
||||
172: Ladder
|
||||
173: Snowboard
|
||||
174: Cookies
|
||||
175: Radiator
|
||||
176: Fire Hydrant
|
||||
177: Basketball
|
||||
178: Zebra
|
||||
179: Grape
|
||||
180: Giraffe
|
||||
181: Potato
|
||||
182: Sausage
|
||||
183: Tricycle
|
||||
184: Violin
|
||||
185: Egg
|
||||
186: Fire Extinguisher
|
||||
187: Candy
|
||||
188: Fire Truck
|
||||
189: Billiards
|
||||
190: Converter
|
||||
191: Bathtub
|
||||
192: Wheelchair
|
||||
193: Golf Club
|
||||
194: Briefcase
|
||||
195: Cucumber
|
||||
196: Cigar/Cigarette
|
||||
197: Paint Brush
|
||||
198: Pear
|
||||
199: Heavy Truck
|
||||
200: Hamburger
|
||||
201: Extractor
|
||||
202: Extension Cord
|
||||
203: Tong
|
||||
204: Tennis Racket
|
||||
205: Folder
|
||||
206: American Football
|
||||
207: earphone
|
||||
208: Mask
|
||||
209: Kettle
|
||||
210: Tennis
|
||||
211: Ship
|
||||
212: Swing
|
||||
213: Coffee Machine
|
||||
214: Slide
|
||||
215: Carriage
|
||||
216: Onion
|
||||
217: Green beans
|
||||
218: Projector
|
||||
219: Frisbee
|
||||
220: Washing Machine/Drying Machine
|
||||
221: Chicken
|
||||
222: Printer
|
||||
223: Watermelon
|
||||
224: Saxophone
|
||||
225: Tissue
|
||||
226: Toothbrush
|
||||
227: Ice cream
|
||||
228: Hot-air balloon
|
||||
229: Cello
|
||||
230: French Fries
|
||||
231: Scale
|
||||
232: Trophy
|
||||
233: Cabbage
|
||||
234: Hot dog
|
||||
235: Blender
|
||||
236: Peach
|
||||
237: Rice
|
||||
238: Wallet/Purse
|
||||
239: Volleyball
|
||||
240: Deer
|
||||
241: Goose
|
||||
242: Tape
|
||||
243: Tablet
|
||||
244: Cosmetics
|
||||
245: Trumpet
|
||||
246: Pineapple
|
||||
247: Golf Ball
|
||||
248: Ambulance
|
||||
249: Parking meter
|
||||
250: Mango
|
||||
251: Key
|
||||
252: Hurdle
|
||||
253: Fishing Rod
|
||||
254: Medal
|
||||
255: Flute
|
||||
256: Brush
|
||||
257: Penguin
|
||||
258: Megaphone
|
||||
259: Corn
|
||||
260: Lettuce
|
||||
261: Garlic
|
||||
262: Swan
|
||||
263: Helicopter
|
||||
264: Green Onion
|
||||
265: Sandwich
|
||||
266: Nuts
|
||||
267: Speed Limit Sign
|
||||
268: Induction Cooker
|
||||
269: Broom
|
||||
270: Trombone
|
||||
271: Plum
|
||||
272: Rickshaw
|
||||
273: Goldfish
|
||||
274: Kiwi fruit
|
||||
275: Router/modem
|
||||
276: Poker Card
|
||||
277: Toaster
|
||||
278: Shrimp
|
||||
279: Sushi
|
||||
280: Cheese
|
||||
281: Notepaper
|
||||
282: Cherry
|
||||
283: Pliers
|
||||
284: CD
|
||||
285: Pasta
|
||||
286: Hammer
|
||||
287: Cue
|
||||
288: Avocado
|
||||
289: Hamimelon
|
||||
290: Flask
|
||||
291: Mushroom
|
||||
292: Screwdriver
|
||||
293: Soap
|
||||
294: Recorder
|
||||
295: Bear
|
||||
296: Eggplant
|
||||
297: Board Eraser
|
||||
298: Coconut
|
||||
299: Tape Measure/Ruler
|
||||
300: Pig
|
||||
301: Showerhead
|
||||
302: Globe
|
||||
303: Chips
|
||||
304: Steak
|
||||
305: Crosswalk Sign
|
||||
306: Stapler
|
||||
307: Camel
|
||||
308: Formula 1
|
||||
309: Pomegranate
|
||||
310: Dishwasher
|
||||
311: Crab
|
||||
312: Hoverboard
|
||||
313: Meat ball
|
||||
314: Rice Cooker
|
||||
315: Tuba
|
||||
316: Calculator
|
||||
317: Papaya
|
||||
318: Antelope
|
||||
319: Parrot
|
||||
320: Seal
|
||||
321: Butterfly
|
||||
322: Dumbbell
|
||||
323: Donkey
|
||||
324: Lion
|
||||
325: Urinal
|
||||
326: Dolphin
|
||||
327: Electric Drill
|
||||
328: Hair Dryer
|
||||
329: Egg tart
|
||||
330: Jellyfish
|
||||
331: Treadmill
|
||||
332: Lighter
|
||||
333: Grapefruit
|
||||
334: Game board
|
||||
335: Mop
|
||||
336: Radish
|
||||
337: Baozi
|
||||
338: Target
|
||||
339: French
|
||||
340: Spring Rolls
|
||||
341: Monkey
|
||||
342: Rabbit
|
||||
343: Pencil Case
|
||||
344: Yak
|
||||
345: Red Cabbage
|
||||
346: Binoculars
|
||||
347: Asparagus
|
||||
348: Barbell
|
||||
349: Scallop
|
||||
350: Noddles
|
||||
351: Comb
|
||||
352: Dumpling
|
||||
353: Oyster
|
||||
354: Table Tennis paddle
|
||||
355: Cosmetics Brush/Eyeliner Pencil
|
||||
356: Chainsaw
|
||||
357: Eraser
|
||||
358: Lobster
|
||||
359: Durian
|
||||
360: Okra
|
||||
361: Lipstick
|
||||
362: Cosmetics Mirror
|
||||
363: Curling
|
||||
364: Table Tennis
|
||||
|
||||
# Download script/URL (optional) ---------------------------------------------------------------------------------------
|
||||
download: |
|
||||
from tqdm import tqdm
|
||||
|
||||
from ultralytics.utils.checks import check_requirements
|
||||
from ultralytics.utils.downloads import download
|
||||
from ultralytics.utils.ops import xyxy2xywhn
|
||||
|
||||
import numpy as np
|
||||
from pathlib import Path
|
||||
|
||||
check_requirements(('pycocotools>=2.0',))
|
||||
from pycocotools.coco import COCO
|
||||
|
||||
# Make Directories
|
||||
dir = Path(yaml['path']) # dataset root dir
|
||||
for p in 'images', 'labels':
|
||||
(dir / p).mkdir(parents=True, exist_ok=True)
|
||||
for q in 'train', 'val':
|
||||
(dir / p / q).mkdir(parents=True, exist_ok=True)
|
||||
|
||||
# Train, Val Splits
|
||||
for split, patches in [('train', 50 + 1), ('val', 43 + 1)]:
|
||||
print(f"Processing {split} in {patches} patches ...")
|
||||
images, labels = dir / 'images' / split, dir / 'labels' / split
|
||||
|
||||
# Download
|
||||
url = f"https://dorc.ks3-cn-beijing.ksyun.com/data-set/2020Objects365%E6%95%B0%E6%8D%AE%E9%9B%86/{split}/"
|
||||
if split == 'train':
|
||||
download([f'{url}zhiyuan_objv2_{split}.tar.gz'], dir=dir) # annotations json
|
||||
download([f'{url}patch{i}.tar.gz' for i in range(patches)], dir=images, curl=True, threads=8)
|
||||
elif split == 'val':
|
||||
download([f'{url}zhiyuan_objv2_{split}.json'], dir=dir) # annotations json
|
||||
download([f'{url}images/v1/patch{i}.tar.gz' for i in range(15 + 1)], dir=images, curl=True, threads=8)
|
||||
download([f'{url}images/v2/patch{i}.tar.gz' for i in range(16, patches)], dir=images, curl=True, threads=8)
|
||||
|
||||
# Move
|
||||
for f in tqdm(images.rglob('*.jpg'), desc=f'Moving {split} images'):
|
||||
f.rename(images / f.name) # move to /images/{split}
|
||||
|
||||
# Labels
|
||||
coco = COCO(dir / f'zhiyuan_objv2_{split}.json')
|
||||
names = [x["name"] for x in coco.loadCats(coco.getCatIds())]
|
||||
for cid, cat in enumerate(names):
|
||||
catIds = coco.getCatIds(catNms=[cat])
|
||||
imgIds = coco.getImgIds(catIds=catIds)
|
||||
for im in tqdm(coco.loadImgs(imgIds), desc=f'Class {cid + 1}/{len(names)} {cat}'):
|
||||
width, height = im["width"], im["height"]
|
||||
path = Path(im["file_name"]) # image filename
|
||||
try:
|
||||
with open(labels / path.with_suffix('.txt').name, 'a') as file:
|
||||
annIds = coco.getAnnIds(imgIds=im["id"], catIds=catIds, iscrowd=None)
|
||||
for a in coco.loadAnns(annIds):
|
||||
x, y, w, h = a['bbox'] # bounding box in xywh (xy top-left corner)
|
||||
xyxy = np.array([x, y, x + w, y + h])[None] # pixels(1,4)
|
||||
x, y, w, h = xyxy2xywhn(xyxy, w=width, h=height, clip=True)[0] # normalized and clipped
|
||||
file.write(f"{cid} {x:.5f} {y:.5f} {w:.5f} {h:.5f}\n")
|
||||
except Exception as e:
|
||||
print(e)
|
||||
@@ -0,0 +1,57 @@
|
||||
# Ultralytics YOLO 🚀, AGPL-3.0 license
|
||||
# SKU-110K retail items dataset https://github.com/eg4000/SKU110K_CVPR19 by Trax Retail
|
||||
# Documentation: https://docs.ultralytics.com/datasets/detect/sku-110k/
|
||||
# Example usage: yolo train data=SKU-110K.yaml
|
||||
# parent
|
||||
# ├── ultralytics
|
||||
# └── datasets
|
||||
# └── SKU-110K ← downloads here (13.6 GB)
|
||||
|
||||
# Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..]
|
||||
path: ../datasets/SKU-110K # dataset root dir
|
||||
train: train.txt # train images (relative to 'path') 8219 images
|
||||
val: val.txt # val images (relative to 'path') 588 images
|
||||
test: test.txt # test images (optional) 2936 images
|
||||
|
||||
# Classes
|
||||
names:
|
||||
0: object
|
||||
|
||||
# Download script/URL (optional) ---------------------------------------------------------------------------------------
|
||||
download: |
|
||||
import shutil
|
||||
from pathlib import Path
|
||||
|
||||
import numpy as np
|
||||
import pandas as pd
|
||||
from tqdm import tqdm
|
||||
|
||||
from ultralytics.utils.downloads import download
|
||||
from ultralytics.utils.ops import xyxy2xywh
|
||||
|
||||
# Download
|
||||
dir = Path(yaml['path']) # dataset root dir
|
||||
parent = Path(dir.parent) # download dir
|
||||
urls = ['http://trax-geometry.s3.amazonaws.com/cvpr_challenge/SKU110K_fixed.tar.gz']
|
||||
download(urls, dir=parent)
|
||||
|
||||
# Rename directories
|
||||
if dir.exists():
|
||||
shutil.rmtree(dir)
|
||||
(parent / 'SKU110K_fixed').rename(dir) # rename dir
|
||||
(dir / 'labels').mkdir(parents=True, exist_ok=True) # create labels dir
|
||||
|
||||
# Convert labels
|
||||
names = 'image', 'x1', 'y1', 'x2', 'y2', 'class', 'image_width', 'image_height' # column names
|
||||
for d in 'annotations_train.csv', 'annotations_val.csv', 'annotations_test.csv':
|
||||
x = pd.read_csv(dir / 'annotations' / d, names=names).values # annotations
|
||||
images, unique_images = x[:, 0], np.unique(x[:, 0])
|
||||
with open((dir / d).with_suffix('.txt').__str__().replace('annotations_', ''), 'w') as f:
|
||||
f.writelines(f'./images/{s}\n' for s in unique_images)
|
||||
for im in tqdm(unique_images, desc=f'Converting {dir / d}'):
|
||||
cls = 0 # single-class dataset
|
||||
with open((dir / 'labels' / im).with_suffix('.txt'), 'a') as f:
|
||||
for r in x[images == im]:
|
||||
w, h = r[6], r[7] # image width, height
|
||||
xywh = xyxy2xywh(np.array([[r[1] / w, r[2] / h, r[3] / w, r[4] / h]]))[0] # instance
|
||||
f.write(f"{cls} {xywh[0]:.5f} {xywh[1]:.5f} {xywh[2]:.5f} {xywh[3]:.5f}\n") # write label
|
||||
@@ -0,0 +1,99 @@
|
||||
# Ultralytics YOLO 🚀, AGPL-3.0 license
|
||||
# PASCAL VOC dataset http://host.robots.ox.ac.uk/pascal/VOC by University of Oxford
|
||||
# Documentation: # Documentation: https://docs.ultralytics.com/datasets/detect/voc/
|
||||
# Example usage: yolo train data=VOC.yaml
|
||||
# parent
|
||||
# ├── ultralytics
|
||||
# └── datasets
|
||||
# └── VOC ← downloads here (2.8 GB)
|
||||
|
||||
# Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..]
|
||||
path: ../datasets/VOC
|
||||
train: # train images (relative to 'path') 16551 images
|
||||
- images/train2012
|
||||
- images/train2007
|
||||
- images/val2012
|
||||
- images/val2007
|
||||
val: # val images (relative to 'path') 4952 images
|
||||
- images/test2007
|
||||
test: # test images (optional)
|
||||
- images/test2007
|
||||
|
||||
# Classes
|
||||
names:
|
||||
0: aeroplane
|
||||
1: bicycle
|
||||
2: bird
|
||||
3: boat
|
||||
4: bottle
|
||||
5: bus
|
||||
6: car
|
||||
7: cat
|
||||
8: chair
|
||||
9: cow
|
||||
10: diningtable
|
||||
11: dog
|
||||
12: horse
|
||||
13: motorbike
|
||||
14: person
|
||||
15: pottedplant
|
||||
16: sheep
|
||||
17: sofa
|
||||
18: train
|
||||
19: tvmonitor
|
||||
|
||||
# Download script/URL (optional) ---------------------------------------------------------------------------------------
|
||||
download: |
|
||||
import xml.etree.ElementTree as ET
|
||||
|
||||
from tqdm import tqdm
|
||||
from ultralytics.utils.downloads import download
|
||||
from pathlib import Path
|
||||
|
||||
def convert_label(path, lb_path, year, image_id):
|
||||
def convert_box(size, box):
|
||||
dw, dh = 1. / size[0], 1. / size[1]
|
||||
x, y, w, h = (box[0] + box[1]) / 2.0 - 1, (box[2] + box[3]) / 2.0 - 1, box[1] - box[0], box[3] - box[2]
|
||||
return x * dw, y * dh, w * dw, h * dh
|
||||
|
||||
in_file = open(path / f'VOC{year}/Annotations/{image_id}.xml')
|
||||
out_file = open(lb_path, 'w')
|
||||
tree = ET.parse(in_file)
|
||||
root = tree.getroot()
|
||||
size = root.find('size')
|
||||
w = int(size.find('width').text)
|
||||
h = int(size.find('height').text)
|
||||
|
||||
names = list(yaml['names'].values()) # names list
|
||||
for obj in root.iter('object'):
|
||||
cls = obj.find('name').text
|
||||
if cls in names and int(obj.find('difficult').text) != 1:
|
||||
xmlbox = obj.find('bndbox')
|
||||
bb = convert_box((w, h), [float(xmlbox.find(x).text) for x in ('xmin', 'xmax', 'ymin', 'ymax')])
|
||||
cls_id = names.index(cls) # class id
|
||||
out_file.write(" ".join(str(a) for a in (cls_id, *bb)) + '\n')
|
||||
|
||||
|
||||
# Download
|
||||
dir = Path(yaml['path']) # dataset root dir
|
||||
url = 'https://github.com/ultralytics/yolov5/releases/download/v1.0/'
|
||||
urls = [f'{url}VOCtrainval_06-Nov-2007.zip', # 446MB, 5012 images
|
||||
f'{url}VOCtest_06-Nov-2007.zip', # 438MB, 4953 images
|
||||
f'{url}VOCtrainval_11-May-2012.zip'] # 1.95GB, 17126 images
|
||||
download(urls, dir=dir / 'images', curl=True, threads=3, exist_ok=True) # download and unzip over existing paths (required)
|
||||
|
||||
# Convert
|
||||
path = dir / 'images/VOCdevkit'
|
||||
for year, image_set in ('2012', 'train'), ('2012', 'val'), ('2007', 'train'), ('2007', 'val'), ('2007', 'test'):
|
||||
imgs_path = dir / 'images' / f'{image_set}{year}'
|
||||
lbs_path = dir / 'labels' / f'{image_set}{year}'
|
||||
imgs_path.mkdir(exist_ok=True, parents=True)
|
||||
lbs_path.mkdir(exist_ok=True, parents=True)
|
||||
|
||||
with open(path / f'VOC{year}/ImageSets/Main/{image_set}.txt') as f:
|
||||
image_ids = f.read().strip().split()
|
||||
for id in tqdm(image_ids, desc=f'{image_set}{year}'):
|
||||
f = path / f'VOC{year}/JPEGImages/{id}.jpg' # old img path
|
||||
lb_path = (lbs_path / f.name).with_suffix('.txt') # new label path
|
||||
f.rename(imgs_path / f.name) # move image
|
||||
convert_label(path, lb_path, year, id) # convert labels to YOLO format
|
||||
@@ -0,0 +1,72 @@
|
||||
# Ultralytics YOLO 🚀, AGPL-3.0 license
|
||||
# VisDrone2019-DET dataset https://github.com/VisDrone/VisDrone-Dataset by Tianjin University
|
||||
# Documentation: https://docs.ultralytics.com/datasets/detect/visdrone/
|
||||
# Example usage: yolo train data=VisDrone.yaml
|
||||
# parent
|
||||
# ├── ultralytics
|
||||
# └── datasets
|
||||
# └── VisDrone ← downloads here (2.3 GB)
|
||||
|
||||
# Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..]
|
||||
path: ../datasets/VisDrone # dataset root dir
|
||||
train: VisDrone2019-DET-train/images # train images (relative to 'path') 6471 images
|
||||
val: VisDrone2019-DET-val/images # val images (relative to 'path') 548 images
|
||||
test: VisDrone2019-DET-test-dev/images # test images (optional) 1610 images
|
||||
|
||||
# Classes
|
||||
names:
|
||||
0: pedestrian
|
||||
1: people
|
||||
2: bicycle
|
||||
3: car
|
||||
4: van
|
||||
5: truck
|
||||
6: tricycle
|
||||
7: awning-tricycle
|
||||
8: bus
|
||||
9: motor
|
||||
|
||||
# Download script/URL (optional) ---------------------------------------------------------------------------------------
|
||||
download: |
|
||||
import os
|
||||
from pathlib import Path
|
||||
|
||||
from ultralytics.utils.downloads import download
|
||||
|
||||
def visdrone2yolo(dir):
|
||||
from PIL import Image
|
||||
from tqdm import tqdm
|
||||
|
||||
def convert_box(size, box):
|
||||
# Convert VisDrone box to YOLO xywh box
|
||||
dw = 1. / size[0]
|
||||
dh = 1. / size[1]
|
||||
return (box[0] + box[2] / 2) * dw, (box[1] + box[3] / 2) * dh, box[2] * dw, box[3] * dh
|
||||
|
||||
(dir / 'labels').mkdir(parents=True, exist_ok=True) # make labels directory
|
||||
pbar = tqdm((dir / 'annotations').glob('*.txt'), desc=f'Converting {dir}')
|
||||
for f in pbar:
|
||||
img_size = Image.open((dir / 'images' / f.name).with_suffix('.jpg')).size
|
||||
lines = []
|
||||
with open(f, 'r') as file: # read annotation.txt
|
||||
for row in [x.split(',') for x in file.read().strip().splitlines()]:
|
||||
if row[4] == '0': # VisDrone 'ignored regions' class 0
|
||||
continue
|
||||
cls = int(row[5]) - 1
|
||||
box = convert_box(img_size, tuple(map(int, row[:4])))
|
||||
lines.append(f"{cls} {' '.join(f'{x:.6f}' for x in box)}\n")
|
||||
with open(str(f).replace(f'{os.sep}annotations{os.sep}', f'{os.sep}labels{os.sep}'), 'w') as fl:
|
||||
fl.writelines(lines) # write label.txt
|
||||
|
||||
|
||||
# Download
|
||||
dir = Path(yaml['path']) # dataset root dir
|
||||
urls = ['https://github.com/ultralytics/yolov5/releases/download/v1.0/VisDrone2019-DET-train.zip',
|
||||
'https://github.com/ultralytics/yolov5/releases/download/v1.0/VisDrone2019-DET-val.zip',
|
||||
'https://github.com/ultralytics/yolov5/releases/download/v1.0/VisDrone2019-DET-test-dev.zip',
|
||||
'https://github.com/ultralytics/yolov5/releases/download/v1.0/VisDrone2019-DET-test-challenge.zip']
|
||||
download(urls, dir=dir, curl=True, threads=4)
|
||||
|
||||
# Convert
|
||||
for d in 'VisDrone2019-DET-train', 'VisDrone2019-DET-val', 'VisDrone2019-DET-test-dev':
|
||||
visdrone2yolo(dir / d) # convert VisDrone annotations to YOLO labels
|
||||
@@ -0,0 +1,24 @@
|
||||
# Ultralytics YOLO 🚀, AGPL-3.0 license
|
||||
# African-wildlife dataset by Ultralytics
|
||||
# Documentation: https://docs.ultralytics.com/datasets/detect/african-wildlife/
|
||||
# Example usage: yolo train data=african-wildlife.yaml
|
||||
# parent
|
||||
# ├── ultralytics
|
||||
# └── datasets
|
||||
# └── african-wildlife ← downloads here (100 MB)
|
||||
|
||||
# Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..]
|
||||
path: ../datasets/african-wildlife # dataset root dir
|
||||
train: train/images # train images (relative to 'path') 1052 images
|
||||
val: valid/images # val images (relative to 'path') 225 images
|
||||
test: test/images # test images (relative to 'path') 227 images
|
||||
|
||||
# Classes
|
||||
names:
|
||||
0: buffalo
|
||||
1: elephant
|
||||
2: rhino
|
||||
3: zebra
|
||||
|
||||
# Download script/URL (optional)
|
||||
download: https://ultralytics.com/assets/african-wildlife.zip
|
||||
@@ -0,0 +1,22 @@
|
||||
# Ultralytics YOLO 🚀, AGPL-3.0 license
|
||||
# Brain-tumor dataset by Ultralytics
|
||||
# Documentation: https://docs.ultralytics.com/datasets/detect/brain-tumor/
|
||||
# Example usage: yolo train data=brain-tumor.yaml
|
||||
# parent
|
||||
# ├── ultralytics
|
||||
# └── datasets
|
||||
# └── brain-tumor ← downloads here (4.05 MB)
|
||||
|
||||
# Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..]
|
||||
path: ../datasets/brain-tumor # dataset root dir
|
||||
train: train/images # train images (relative to 'path') 893 images
|
||||
val: valid/images # val images (relative to 'path') 223 images
|
||||
test: # test images (relative to 'path')
|
||||
|
||||
# Classes
|
||||
names:
|
||||
0: negative
|
||||
1: positive
|
||||
|
||||
# Download script/URL (optional)
|
||||
download: https://ultralytics.com/assets/brain-tumor.zip
|
||||
@@ -0,0 +1,43 @@
|
||||
# Ultralytics YOLO 🚀, AGPL-3.0 license
|
||||
# Carparts-seg dataset by Ultralytics
|
||||
# Documentation: https://docs.ultralytics.com/datasets/segment/carparts-seg/
|
||||
# Example usage: yolo train data=carparts-seg.yaml
|
||||
# parent
|
||||
# ├── ultralytics
|
||||
# └── datasets
|
||||
# └── carparts-seg ← downloads here (132 MB)
|
||||
|
||||
# Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..]
|
||||
path: ../datasets/carparts-seg # dataset root dir
|
||||
train: train/images # train images (relative to 'path') 3516 images
|
||||
val: valid/images # val images (relative to 'path') 276 images
|
||||
test: test/images # test images (relative to 'path') 401 images
|
||||
|
||||
# Classes
|
||||
names:
|
||||
0: back_bumper
|
||||
1: back_door
|
||||
2: back_glass
|
||||
3: back_left_door
|
||||
4: back_left_light
|
||||
5: back_light
|
||||
6: back_right_door
|
||||
7: back_right_light
|
||||
8: front_bumper
|
||||
9: front_door
|
||||
10: front_glass
|
||||
11: front_left_door
|
||||
12: front_left_light
|
||||
13: front_light
|
||||
14: front_right_door
|
||||
15: front_right_light
|
||||
16: hood
|
||||
17: left_mirror
|
||||
18: object
|
||||
19: right_mirror
|
||||
20: tailgate
|
||||
21: trunk
|
||||
22: wheel
|
||||
|
||||
# Download script/URL (optional)
|
||||
download: https://ultralytics.com/assets/carparts-seg.zip
|
||||
@@ -0,0 +1,38 @@
|
||||
# Ultralytics YOLO 🚀, AGPL-3.0 license
|
||||
# COCO 2017 dataset https://cocodataset.org by Microsoft
|
||||
# Documentation: https://docs.ultralytics.com/datasets/pose/coco/
|
||||
# Example usage: yolo train data=coco-pose.yaml
|
||||
# parent
|
||||
# ├── ultralytics
|
||||
# └── datasets
|
||||
# └── coco-pose ← downloads here (20.1 GB)
|
||||
|
||||
# Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..]
|
||||
path: ../datasets/coco-pose # dataset root dir
|
||||
train: train2017.txt # train images (relative to 'path') 118287 images
|
||||
val: val2017.txt # val images (relative to 'path') 5000 images
|
||||
test: test-dev2017.txt # 20288 of 40670 images, submit to https://competitions.codalab.org/competitions/20794
|
||||
|
||||
# Keypoints
|
||||
kpt_shape: [17, 3] # number of keypoints, number of dims (2 for x,y or 3 for x,y,visible)
|
||||
flip_idx: [0, 2, 1, 4, 3, 6, 5, 8, 7, 10, 9, 12, 11, 14, 13, 16, 15]
|
||||
|
||||
# Classes
|
||||
names:
|
||||
0: person
|
||||
|
||||
# Download script/URL (optional)
|
||||
download: |
|
||||
from ultralytics.utils.downloads import download
|
||||
from pathlib import Path
|
||||
|
||||
# Download labels
|
||||
dir = Path(yaml['path']) # dataset root dir
|
||||
url = 'https://github.com/ultralytics/yolov5/releases/download/v1.0/'
|
||||
urls = [url + 'coco2017labels-pose.zip'] # labels
|
||||
download(urls, dir=dir.parent)
|
||||
# Download data
|
||||
urls = ['http://images.cocodataset.org/zips/train2017.zip', # 19G, 118k images
|
||||
'http://images.cocodataset.org/zips/val2017.zip', # 1G, 5k images
|
||||
'http://images.cocodataset.org/zips/test2017.zip'] # 7G, 41k images (optional)
|
||||
download(urls, dir=dir / 'images', threads=3)
|
||||
@@ -0,0 +1,114 @@
|
||||
# Ultralytics YOLO 🚀, AGPL-3.0 license
|
||||
# COCO 2017 dataset https://cocodataset.org by Microsoft
|
||||
# Documentation: https://docs.ultralytics.com/datasets/detect/coco/
|
||||
# Example usage: yolo train data=coco.yaml
|
||||
# parent
|
||||
# ├── ultralytics
|
||||
# └── datasets
|
||||
# └── coco ← downloads here (20.1 GB)
|
||||
|
||||
# Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..]
|
||||
path: ../datasets/coco # dataset root dir
|
||||
train: train2017.txt # train images (relative to 'path') 118287 images
|
||||
val: val2017.txt # val images (relative to 'path') 5000 images
|
||||
test: test-dev2017.txt # 20288 of 40670 images, submit to https://competitions.codalab.org/competitions/20794
|
||||
|
||||
# Classes
|
||||
names:
|
||||
0: person
|
||||
1: bicycle
|
||||
2: car
|
||||
3: motorcycle
|
||||
4: airplane
|
||||
5: bus
|
||||
6: train
|
||||
7: truck
|
||||
8: boat
|
||||
9: traffic light
|
||||
10: fire hydrant
|
||||
11: stop sign
|
||||
12: parking meter
|
||||
13: bench
|
||||
14: bird
|
||||
15: cat
|
||||
16: dog
|
||||
17: horse
|
||||
18: sheep
|
||||
19: cow
|
||||
20: elephant
|
||||
21: bear
|
||||
22: zebra
|
||||
23: giraffe
|
||||
24: backpack
|
||||
25: umbrella
|
||||
26: handbag
|
||||
27: tie
|
||||
28: suitcase
|
||||
29: frisbee
|
||||
30: skis
|
||||
31: snowboard
|
||||
32: sports ball
|
||||
33: kite
|
||||
34: baseball bat
|
||||
35: baseball glove
|
||||
36: skateboard
|
||||
37: surfboard
|
||||
38: tennis racket
|
||||
39: bottle
|
||||
40: wine glass
|
||||
41: cup
|
||||
42: fork
|
||||
43: knife
|
||||
44: spoon
|
||||
45: bowl
|
||||
46: banana
|
||||
47: apple
|
||||
48: sandwich
|
||||
49: orange
|
||||
50: broccoli
|
||||
51: carrot
|
||||
52: hot dog
|
||||
53: pizza
|
||||
54: donut
|
||||
55: cake
|
||||
56: chair
|
||||
57: couch
|
||||
58: potted plant
|
||||
59: bed
|
||||
60: dining table
|
||||
61: toilet
|
||||
62: tv
|
||||
63: laptop
|
||||
64: mouse
|
||||
65: remote
|
||||
66: keyboard
|
||||
67: cell phone
|
||||
68: microwave
|
||||
69: oven
|
||||
70: toaster
|
||||
71: sink
|
||||
72: refrigerator
|
||||
73: book
|
||||
74: clock
|
||||
75: vase
|
||||
76: scissors
|
||||
77: teddy bear
|
||||
78: hair drier
|
||||
79: toothbrush
|
||||
|
||||
# Download script/URL (optional)
|
||||
download: |
|
||||
from ultralytics.utils.downloads import download
|
||||
from pathlib import Path
|
||||
|
||||
# Download labels
|
||||
segments = True # segment or box labels
|
||||
dir = Path(yaml['path']) # dataset root dir
|
||||
url = 'https://github.com/ultralytics/yolov5/releases/download/v1.0/'
|
||||
urls = [url + ('coco2017labels-segments.zip' if segments else 'coco2017labels.zip')] # labels
|
||||
download(urls, dir=dir.parent)
|
||||
# Download data
|
||||
urls = ['http://images.cocodataset.org/zips/train2017.zip', # 19G, 118k images
|
||||
'http://images.cocodataset.org/zips/val2017.zip', # 1G, 5k images
|
||||
'http://images.cocodataset.org/zips/test2017.zip'] # 7G, 41k images (optional)
|
||||
download(urls, dir=dir / 'images', threads=3)
|
||||
@@ -0,0 +1,100 @@
|
||||
# Ultralytics YOLO 🚀, AGPL-3.0 license
|
||||
# COCO128-seg dataset https://www.kaggle.com/ultralytics/coco128 (first 128 images from COCO train2017) by Ultralytics
|
||||
# Documentation: https://docs.ultralytics.com/datasets/segment/coco/
|
||||
# Example usage: yolo train data=coco128.yaml
|
||||
# parent
|
||||
# ├── ultralytics
|
||||
# └── datasets
|
||||
# └── coco128-seg ← downloads here (7 MB)
|
||||
|
||||
# Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..]
|
||||
path: ../datasets/coco128-seg # dataset root dir
|
||||
train: images/train2017 # train images (relative to 'path') 128 images
|
||||
val: images/train2017 # val images (relative to 'path') 128 images
|
||||
test: # test images (optional)
|
||||
|
||||
# Classes
|
||||
names:
|
||||
0: person
|
||||
1: bicycle
|
||||
2: car
|
||||
3: motorcycle
|
||||
4: airplane
|
||||
5: bus
|
||||
6: train
|
||||
7: truck
|
||||
8: boat
|
||||
9: traffic light
|
||||
10: fire hydrant
|
||||
11: stop sign
|
||||
12: parking meter
|
||||
13: bench
|
||||
14: bird
|
||||
15: cat
|
||||
16: dog
|
||||
17: horse
|
||||
18: sheep
|
||||
19: cow
|
||||
20: elephant
|
||||
21: bear
|
||||
22: zebra
|
||||
23: giraffe
|
||||
24: backpack
|
||||
25: umbrella
|
||||
26: handbag
|
||||
27: tie
|
||||
28: suitcase
|
||||
29: frisbee
|
||||
30: skis
|
||||
31: snowboard
|
||||
32: sports ball
|
||||
33: kite
|
||||
34: baseball bat
|
||||
35: baseball glove
|
||||
36: skateboard
|
||||
37: surfboard
|
||||
38: tennis racket
|
||||
39: bottle
|
||||
40: wine glass
|
||||
41: cup
|
||||
42: fork
|
||||
43: knife
|
||||
44: spoon
|
||||
45: bowl
|
||||
46: banana
|
||||
47: apple
|
||||
48: sandwich
|
||||
49: orange
|
||||
50: broccoli
|
||||
51: carrot
|
||||
52: hot dog
|
||||
53: pizza
|
||||
54: donut
|
||||
55: cake
|
||||
56: chair
|
||||
57: couch
|
||||
58: potted plant
|
||||
59: bed
|
||||
60: dining table
|
||||
61: toilet
|
||||
62: tv
|
||||
63: laptop
|
||||
64: mouse
|
||||
65: remote
|
||||
66: keyboard
|
||||
67: cell phone
|
||||
68: microwave
|
||||
69: oven
|
||||
70: toaster
|
||||
71: sink
|
||||
72: refrigerator
|
||||
73: book
|
||||
74: clock
|
||||
75: vase
|
||||
76: scissors
|
||||
77: teddy bear
|
||||
78: hair drier
|
||||
79: toothbrush
|
||||
|
||||
# Download script/URL (optional)
|
||||
download: https://ultralytics.com/assets/coco128-seg.zip
|
||||
@@ -0,0 +1,100 @@
|
||||
# Ultralytics YOLO 🚀, AGPL-3.0 license
|
||||
# COCO128 dataset https://www.kaggle.com/ultralytics/coco128 (first 128 images from COCO train2017) by Ultralytics
|
||||
# Documentation: https://docs.ultralytics.com/datasets/detect/coco/
|
||||
# Example usage: yolo train data=coco128.yaml
|
||||
# parent
|
||||
# ├── ultralytics
|
||||
# └── datasets
|
||||
# └── coco128 ← downloads here (7 MB)
|
||||
|
||||
# Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..]
|
||||
path: ../datasets/coco128 # dataset root dir
|
||||
train: images/train2017 # train images (relative to 'path') 128 images
|
||||
val: images/train2017 # val images (relative to 'path') 128 images
|
||||
test: # test images (optional)
|
||||
|
||||
# Classes
|
||||
names:
|
||||
0: person
|
||||
1: bicycle
|
||||
2: car
|
||||
3: motorcycle
|
||||
4: airplane
|
||||
5: bus
|
||||
6: train
|
||||
7: truck
|
||||
8: boat
|
||||
9: traffic light
|
||||
10: fire hydrant
|
||||
11: stop sign
|
||||
12: parking meter
|
||||
13: bench
|
||||
14: bird
|
||||
15: cat
|
||||
16: dog
|
||||
17: horse
|
||||
18: sheep
|
||||
19: cow
|
||||
20: elephant
|
||||
21: bear
|
||||
22: zebra
|
||||
23: giraffe
|
||||
24: backpack
|
||||
25: umbrella
|
||||
26: handbag
|
||||
27: tie
|
||||
28: suitcase
|
||||
29: frisbee
|
||||
30: skis
|
||||
31: snowboard
|
||||
32: sports ball
|
||||
33: kite
|
||||
34: baseball bat
|
||||
35: baseball glove
|
||||
36: skateboard
|
||||
37: surfboard
|
||||
38: tennis racket
|
||||
39: bottle
|
||||
40: wine glass
|
||||
41: cup
|
||||
42: fork
|
||||
43: knife
|
||||
44: spoon
|
||||
45: bowl
|
||||
46: banana
|
||||
47: apple
|
||||
48: sandwich
|
||||
49: orange
|
||||
50: broccoli
|
||||
51: carrot
|
||||
52: hot dog
|
||||
53: pizza
|
||||
54: donut
|
||||
55: cake
|
||||
56: chair
|
||||
57: couch
|
||||
58: potted plant
|
||||
59: bed
|
||||
60: dining table
|
||||
61: toilet
|
||||
62: tv
|
||||
63: laptop
|
||||
64: mouse
|
||||
65: remote
|
||||
66: keyboard
|
||||
67: cell phone
|
||||
68: microwave
|
||||
69: oven
|
||||
70: toaster
|
||||
71: sink
|
||||
72: refrigerator
|
||||
73: book
|
||||
74: clock
|
||||
75: vase
|
||||
76: scissors
|
||||
77: teddy bear
|
||||
78: hair drier
|
||||
79: toothbrush
|
||||
|
||||
# Download script/URL (optional)
|
||||
download: https://ultralytics.com/assets/coco128.zip
|
||||
@@ -0,0 +1,25 @@
|
||||
# Ultralytics YOLO 🚀, AGPL-3.0 license
|
||||
# COCO8-pose dataset (first 8 images from COCO train2017) by Ultralytics
|
||||
# Documentation: https://docs.ultralytics.com/datasets/pose/coco8-pose/
|
||||
# Example usage: yolo train data=coco8-pose.yaml
|
||||
# parent
|
||||
# ├── ultralytics
|
||||
# └── datasets
|
||||
# └── coco8-pose ← downloads here (1 MB)
|
||||
|
||||
# Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..]
|
||||
path: ../datasets/coco8-pose # dataset root dir
|
||||
train: images/train # train images (relative to 'path') 4 images
|
||||
val: images/val # val images (relative to 'path') 4 images
|
||||
test: # test images (optional)
|
||||
|
||||
# Keypoints
|
||||
kpt_shape: [17, 3] # number of keypoints, number of dims (2 for x,y or 3 for x,y,visible)
|
||||
flip_idx: [0, 2, 1, 4, 3, 6, 5, 8, 7, 10, 9, 12, 11, 14, 13, 16, 15]
|
||||
|
||||
# Classes
|
||||
names:
|
||||
0: person
|
||||
|
||||
# Download script/URL (optional)
|
||||
download: https://ultralytics.com/assets/coco8-pose.zip
|
||||
@@ -0,0 +1,100 @@
|
||||
# Ultralytics YOLO 🚀, AGPL-3.0 license
|
||||
# COCO8-seg dataset (first 8 images from COCO train2017) by Ultralytics
|
||||
# Documentation: https://docs.ultralytics.com/datasets/segment/coco8-seg/
|
||||
# Example usage: yolo train data=coco8-seg.yaml
|
||||
# parent
|
||||
# ├── ultralytics
|
||||
# └── datasets
|
||||
# └── coco8-seg ← downloads here (1 MB)
|
||||
|
||||
# Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..]
|
||||
path: ../datasets/coco8-seg # dataset root dir
|
||||
train: images/train # train images (relative to 'path') 4 images
|
||||
val: images/val # val images (relative to 'path') 4 images
|
||||
test: # test images (optional)
|
||||
|
||||
# Classes
|
||||
names:
|
||||
0: person
|
||||
1: bicycle
|
||||
2: car
|
||||
3: motorcycle
|
||||
4: airplane
|
||||
5: bus
|
||||
6: train
|
||||
7: truck
|
||||
8: boat
|
||||
9: traffic light
|
||||
10: fire hydrant
|
||||
11: stop sign
|
||||
12: parking meter
|
||||
13: bench
|
||||
14: bird
|
||||
15: cat
|
||||
16: dog
|
||||
17: horse
|
||||
18: sheep
|
||||
19: cow
|
||||
20: elephant
|
||||
21: bear
|
||||
22: zebra
|
||||
23: giraffe
|
||||
24: backpack
|
||||
25: umbrella
|
||||
26: handbag
|
||||
27: tie
|
||||
28: suitcase
|
||||
29: frisbee
|
||||
30: skis
|
||||
31: snowboard
|
||||
32: sports ball
|
||||
33: kite
|
||||
34: baseball bat
|
||||
35: baseball glove
|
||||
36: skateboard
|
||||
37: surfboard
|
||||
38: tennis racket
|
||||
39: bottle
|
||||
40: wine glass
|
||||
41: cup
|
||||
42: fork
|
||||
43: knife
|
||||
44: spoon
|
||||
45: bowl
|
||||
46: banana
|
||||
47: apple
|
||||
48: sandwich
|
||||
49: orange
|
||||
50: broccoli
|
||||
51: carrot
|
||||
52: hot dog
|
||||
53: pizza
|
||||
54: donut
|
||||
55: cake
|
||||
56: chair
|
||||
57: couch
|
||||
58: potted plant
|
||||
59: bed
|
||||
60: dining table
|
||||
61: toilet
|
||||
62: tv
|
||||
63: laptop
|
||||
64: mouse
|
||||
65: remote
|
||||
66: keyboard
|
||||
67: cell phone
|
||||
68: microwave
|
||||
69: oven
|
||||
70: toaster
|
||||
71: sink
|
||||
72: refrigerator
|
||||
73: book
|
||||
74: clock
|
||||
75: vase
|
||||
76: scissors
|
||||
77: teddy bear
|
||||
78: hair drier
|
||||
79: toothbrush
|
||||
|
||||
# Download script/URL (optional)
|
||||
download: https://ultralytics.com/assets/coco8-seg.zip
|
||||
@@ -0,0 +1,100 @@
|
||||
# Ultralytics YOLO 🚀, AGPL-3.0 license
|
||||
# COCO8 dataset (first 8 images from COCO train2017) by Ultralytics
|
||||
# Documentation: https://docs.ultralytics.com/datasets/detect/coco8/
|
||||
# Example usage: yolo train data=coco8.yaml
|
||||
# parent
|
||||
# ├── ultralytics
|
||||
# └── datasets
|
||||
# └── coco8 ← downloads here (1 MB)
|
||||
|
||||
# Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..]
|
||||
path: ../datasets/coco8 # dataset root dir
|
||||
train: images/train # train images (relative to 'path') 4 images
|
||||
val: images/val # val images (relative to 'path') 4 images
|
||||
test: # test images (optional)
|
||||
|
||||
# Classes
|
||||
names:
|
||||
0: person
|
||||
1: bicycle
|
||||
2: car
|
||||
3: motorcycle
|
||||
4: airplane
|
||||
5: bus
|
||||
6: train
|
||||
7: truck
|
||||
8: boat
|
||||
9: traffic light
|
||||
10: fire hydrant
|
||||
11: stop sign
|
||||
12: parking meter
|
||||
13: bench
|
||||
14: bird
|
||||
15: cat
|
||||
16: dog
|
||||
17: horse
|
||||
18: sheep
|
||||
19: cow
|
||||
20: elephant
|
||||
21: bear
|
||||
22: zebra
|
||||
23: giraffe
|
||||
24: backpack
|
||||
25: umbrella
|
||||
26: handbag
|
||||
27: tie
|
||||
28: suitcase
|
||||
29: frisbee
|
||||
30: skis
|
||||
31: snowboard
|
||||
32: sports ball
|
||||
33: kite
|
||||
34: baseball bat
|
||||
35: baseball glove
|
||||
36: skateboard
|
||||
37: surfboard
|
||||
38: tennis racket
|
||||
39: bottle
|
||||
40: wine glass
|
||||
41: cup
|
||||
42: fork
|
||||
43: knife
|
||||
44: spoon
|
||||
45: bowl
|
||||
46: banana
|
||||
47: apple
|
||||
48: sandwich
|
||||
49: orange
|
||||
50: broccoli
|
||||
51: carrot
|
||||
52: hot dog
|
||||
53: pizza
|
||||
54: donut
|
||||
55: cake
|
||||
56: chair
|
||||
57: couch
|
||||
58: potted plant
|
||||
59: bed
|
||||
60: dining table
|
||||
61: toilet
|
||||
62: tv
|
||||
63: laptop
|
||||
64: mouse
|
||||
65: remote
|
||||
66: keyboard
|
||||
67: cell phone
|
||||
68: microwave
|
||||
69: oven
|
||||
70: toaster
|
||||
71: sink
|
||||
72: refrigerator
|
||||
73: book
|
||||
74: clock
|
||||
75: vase
|
||||
76: scissors
|
||||
77: teddy bear
|
||||
78: hair drier
|
||||
79: toothbrush
|
||||
|
||||
# Download script/URL (optional)
|
||||
download: https://ultralytics.com/assets/coco8.zip
|
||||
@@ -0,0 +1,21 @@
|
||||
# Ultralytics YOLO 🚀, AGPL-3.0 license
|
||||
# Crack-seg dataset by Ultralytics
|
||||
# Documentation: https://docs.ultralytics.com/datasets/segment/crack-seg/
|
||||
# Example usage: yolo train data=crack-seg.yaml
|
||||
# parent
|
||||
# ├── ultralytics
|
||||
# └── datasets
|
||||
# └── crack-seg ← downloads here (91.2 MB)
|
||||
|
||||
# Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..]
|
||||
path: ../datasets/crack-seg # dataset root dir
|
||||
train: train/images # train images (relative to 'path') 3717 images
|
||||
val: valid/images # val images (relative to 'path') 112 images
|
||||
test: test/images # test images (relative to 'path') 200 images
|
||||
|
||||
# Classes
|
||||
names:
|
||||
0: crack
|
||||
|
||||
# Download script/URL (optional)
|
||||
download: https://ultralytics.com/assets/crack-seg.zip
|
||||
@@ -0,0 +1,34 @@
|
||||
# Ultralytics YOLO 🚀, AGPL-3.0 license
|
||||
# DOTA8 dataset 8 images from split DOTAv1 dataset by Ultralytics
|
||||
# Documentation: https://docs.ultralytics.com/datasets/obb/dota8/
|
||||
# Example usage: yolo train model=yolov8n-obb.pt data=dota8.yaml
|
||||
# parent
|
||||
# ├── ultralytics
|
||||
# └── datasets
|
||||
# └── dota8 ← downloads here (1MB)
|
||||
|
||||
# Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..]
|
||||
path: ../datasets/dota8 # dataset root dir
|
||||
train: images/train # train images (relative to 'path') 4 images
|
||||
val: images/val # val images (relative to 'path') 4 images
|
||||
|
||||
# Classes for DOTA 1.0
|
||||
names:
|
||||
0: plane
|
||||
1: ship
|
||||
2: storage tank
|
||||
3: baseball diamond
|
||||
4: tennis court
|
||||
5: basketball court
|
||||
6: ground track field
|
||||
7: harbor
|
||||
8: bridge
|
||||
9: large vehicle
|
||||
10: small vehicle
|
||||
11: helicopter
|
||||
12: roundabout
|
||||
13: soccer ball field
|
||||
14: swimming pool
|
||||
|
||||
# Download script/URL (optional)
|
||||
download: https://github.com/ultralytics/yolov5/releases/download/v1.0/dota8.zip
|
||||
File diff suppressed because it is too large.
Load diff
@@ -0,0 +1,660 @@
|
||||
# Ultralytics YOLO 🚀, AGPL-3.0 license
|
||||
# Open Images v7 dataset https://storage.googleapis.com/openimages/web/index.html by Google
|
||||
# Documentation: https://docs.ultralytics.com/datasets/detect/open-images-v7/
|
||||
# Example usage: yolo train data=open-images-v7.yaml
|
||||
# parent
|
||||
# ├── ultralytics
|
||||
# └── datasets
|
||||
# └── open-images-v7 ← downloads here (561 GB)
|
||||
|
||||
# Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..]
|
||||
path: ../datasets/open-images-v7 # dataset root dir
|
||||
train: images/train # train images (relative to 'path') 1743042 images
|
||||
val: images/val # val images (relative to 'path') 41620 images
|
||||
test: # test images (optional)
|
||||
|
||||
# Classes
|
||||
names:
|
||||
0: Accordion
|
||||
1: Adhesive tape
|
||||
2: Aircraft
|
||||
3: Airplane
|
||||
4: Alarm clock
|
||||
5: Alpaca
|
||||
6: Ambulance
|
||||
7: Animal
|
||||
8: Ant
|
||||
9: Antelope
|
||||
10: Apple
|
||||
11: Armadillo
|
||||
12: Artichoke
|
||||
13: Auto part
|
||||
14: Axe
|
||||
15: Backpack
|
||||
16: Bagel
|
||||
17: Baked goods
|
||||
18: Balance beam
|
||||
19: Ball
|
||||
20: Balloon
|
||||
21: Banana
|
||||
22: Band-aid
|
||||
23: Banjo
|
||||
24: Barge
|
||||
25: Barrel
|
||||
26: Baseball bat
|
||||
27: Baseball glove
|
||||
28: Bat (Animal)
|
||||
29: Bathroom accessory
|
||||
30: Bathroom cabinet
|
||||
31: Bathtub
|
||||
32: Beaker
|
||||
33: Bear
|
||||
34: Bed
|
||||
35: Bee
|
||||
36: Beehive
|
||||
37: Beer
|
||||
38: Beetle
|
||||
39: Bell pepper
|
||||
40: Belt
|
||||
41: Bench
|
||||
42: Bicycle
|
||||
43: Bicycle helmet
|
||||
44: Bicycle wheel
|
||||
45: Bidet
|
||||
46: Billboard
|
||||
47: Billiard table
|
||||
48: Binoculars
|
||||
49: Bird
|
||||
50: Blender
|
||||
51: Blue jay
|
||||
52: Boat
|
||||
53: Bomb
|
||||
54: Book
|
||||
55: Bookcase
|
||||
56: Boot
|
||||
57: Bottle
|
||||
58: Bottle opener
|
||||
59: Bow and arrow
|
||||
60: Bowl
|
||||
61: Bowling equipment
|
||||
62: Box
|
||||
63: Boy
|
||||
64: Brassiere
|
||||
65: Bread
|
||||
66: Briefcase
|
||||
67: Broccoli
|
||||
68: Bronze sculpture
|
||||
69: Brown bear
|
||||
70: Building
|
||||
71: Bull
|
||||
72: Burrito
|
||||
73: Bus
|
||||
74: Bust
|
||||
75: Butterfly
|
||||
76: Cabbage
|
||||
77: Cabinetry
|
||||
78: Cake
|
||||
79: Cake stand
|
||||
80: Calculator
|
||||
81: Camel
|
||||
82: Camera
|
||||
83: Can opener
|
||||
84: Canary
|
||||
85: Candle
|
||||
86: Candy
|
||||
87: Cannon
|
||||
88: Canoe
|
||||
89: Cantaloupe
|
||||
90: Car
|
||||
91: Carnivore
|
||||
92: Carrot
|
||||
93: Cart
|
||||
94: Cassette deck
|
||||
95: Castle
|
||||
96: Cat
|
||||
97: Cat furniture
|
||||
98: Caterpillar
|
||||
99: Cattle
|
||||
100: Ceiling fan
|
||||
101: Cello
|
||||
102: Centipede
|
||||
103: Chainsaw
|
||||
104: Chair
|
||||
105: Cheese
|
||||
106: Cheetah
|
||||
107: Chest of drawers
|
||||
108: Chicken
|
||||
109: Chime
|
||||
110: Chisel
|
||||
111: Chopsticks
|
||||
112: Christmas tree
|
||||
113: Clock
|
||||
114: Closet
|
||||
115: Clothing
|
||||
116: Coat
|
||||
117: Cocktail
|
||||
118: Cocktail shaker
|
||||
119: Coconut
|
||||
120: Coffee
|
||||
121: Coffee cup
|
||||
122: Coffee table
|
||||
123: Coffeemaker
|
||||
124: Coin
|
||||
125: Common fig
|
||||
126: Common sunflower
|
||||
127: Computer keyboard
|
||||
128: Computer monitor
|
||||
129: Computer mouse
|
||||
130: Container
|
||||
131: Convenience store
|
||||
132: Cookie
|
||||
133: Cooking spray
|
||||
134: Corded phone
|
||||
135: Cosmetics
|
||||
136: Couch
|
||||
137: Countertop
|
||||
138: Cowboy hat
|
||||
139: Crab
|
||||
140: Cream
|
||||
141: Cricket ball
|
||||
142: Crocodile
|
||||
143: Croissant
|
||||
144: Crown
|
||||
145: Crutch
|
||||
146: Cucumber
|
||||
147: Cupboard
|
||||
148: Curtain
|
||||
149: Cutting board
|
||||
150: Dagger
|
||||
151: Dairy Product
|
||||
152: Deer
|
||||
153: Desk
|
||||
154: Dessert
|
||||
155: Diaper
|
||||
156: Dice
|
||||
157: Digital clock
|
||||
158: Dinosaur
|
||||
159: Dishwasher
|
||||
160: Dog
|
||||
161: Dog bed
|
||||
162: Doll
|
||||
163: Dolphin
|
||||
164: Door
|
||||
165: Door handle
|
||||
166: Doughnut
|
||||
167: Dragonfly
|
||||
168: Drawer
|
||||
169: Dress
|
||||
170: Drill (Tool)
|
||||
171: Drink
|
||||
172: Drinking straw
|
||||
173: Drum
|
||||
174: Duck
|
||||
175: Dumbbell
|
||||
176: Eagle
|
||||
177: Earrings
|
||||
178: Egg (Food)
|
||||
179: Elephant
|
||||
180: Envelope
|
||||
181: Eraser
|
||||
182: Face powder
|
||||
183: Facial tissue holder
|
||||
184: Falcon
|
||||
185: Fashion accessory
|
||||
186: Fast food
|
||||
187: Fax
|
||||
188: Fedora
|
||||
189: Filing cabinet
|
||||
190: Fire hydrant
|
||||
191: Fireplace
|
||||
192: Fish
|
||||
193: Flag
|
||||
194: Flashlight
|
||||
195: Flower
|
||||
196: Flowerpot
|
||||
197: Flute
|
||||
198: Flying disc
|
||||
199: Food
|
||||
200: Food processor
|
||||
201: Football
|
||||
202: Football helmet
|
||||
203: Footwear
|
||||
204: Fork
|
||||
205: Fountain
|
||||
206: Fox
|
||||
207: French fries
|
||||
208: French horn
|
||||
209: Frog
|
||||
210: Fruit
|
||||
211: Frying pan
|
||||
212: Furniture
|
||||
213: Garden Asparagus
|
||||
214: Gas stove
|
||||
215: Giraffe
|
||||
216: Girl
|
||||
217: Glasses
|
||||
218: Glove
|
||||
219: Goat
|
||||
220: Goggles
|
||||
221: Goldfish
|
||||
222: Golf ball
|
||||
223: Golf cart
|
||||
224: Gondola
|
||||
225: Goose
|
||||
226: Grape
|
||||
227: Grapefruit
|
||||
228: Grinder
|
||||
229: Guacamole
|
||||
230: Guitar
|
||||
231: Hair dryer
|
||||
232: Hair spray
|
||||
233: Hamburger
|
||||
234: Hammer
|
||||
235: Hamster
|
||||
236: Hand dryer
|
||||
237: Handbag
|
||||
238: Handgun
|
||||
239: Harbor seal
|
||||
240: Harmonica
|
||||
241: Harp
|
||||
242: Harpsichord
|
||||
243: Hat
|
||||
244: Headphones
|
||||
245: Heater
|
||||
246: Hedgehog
|
||||
247: Helicopter
|
||||
248: Helmet
|
||||
249: High heels
|
||||
250: Hiking equipment
|
||||
251: Hippopotamus
|
||||
252: Home appliance
|
||||
253: Honeycomb
|
||||
254: Horizontal bar
|
||||
255: Horse
|
||||
256: Hot dog
|
||||
257: House
|
||||
258: Houseplant
|
||||
259: Human arm
|
||||
260: Human beard
|
||||
261: Human body
|
||||
262: Human ear
|
||||
263: Human eye
|
||||
264: Human face
|
||||
265: Human foot
|
||||
266: Human hair
|
||||
267: Human hand
|
||||
268: Human head
|
||||
269: Human leg
|
||||
270: Human mouth
|
||||
271: Human nose
|
||||
272: Humidifier
|
||||
273: Ice cream
|
||||
274: Indoor rower
|
||||
275: Infant bed
|
||||
276: Insect
|
||||
277: Invertebrate
|
||||
278: Ipod
|
||||
279: Isopod
|
||||
280: Jacket
|
||||
281: Jacuzzi
|
||||
282: Jaguar (Animal)
|
||||
283: Jeans
|
||||
284: Jellyfish
|
||||
285: Jet ski
|
||||
286: Jug
|
||||
287: Juice
|
||||
288: Kangaroo
|
||||
289: Kettle
|
||||
290: Kitchen & dining room table
|
||||
291: Kitchen appliance
|
||||
292: Kitchen knife
|
||||
293: Kitchen utensil
|
||||
294: Kitchenware
|
||||
295: Kite
|
||||
296: Knife
|
||||
297: Koala
|
||||
298: Ladder
|
||||
299: Ladle
|
||||
300: Ladybug
|
||||
301: Lamp
|
||||
302: Land vehicle
|
||||
303: Lantern
|
||||
304: Laptop
|
||||
305: Lavender (Plant)
|
||||
306: Lemon
|
||||
307: Leopard
|
||||
308: Light bulb
|
||||
309: Light switch
|
||||
310: Lighthouse
|
||||
311: Lily
|
||||
312: Limousine
|
||||
313: Lion
|
||||
314: Lipstick
|
||||
315: Lizard
|
||||
316: Lobster
|
||||
317: Loveseat
|
||||
318: Luggage and bags
|
||||
319: Lynx
|
||||
320: Magpie
|
||||
321: Mammal
|
||||
322: Man
|
||||
323: Mango
|
||||
324: Maple
|
||||
325: Maracas
|
||||
326: Marine invertebrates
|
||||
327: Marine mammal
|
||||
328: Measuring cup
|
||||
329: Mechanical fan
|
||||
330: Medical equipment
|
||||
331: Microphone
|
||||
332: Microwave oven
|
||||
333: Milk
|
||||
334: Miniskirt
|
||||
335: Mirror
|
||||
336: Missile
|
||||
337: Mixer
|
||||
338: Mixing bowl
|
||||
339: Mobile phone
|
||||
340: Monkey
|
||||
341: Moths and butterflies
|
||||
342: Motorcycle
|
||||
343: Mouse
|
||||
344: Muffin
|
||||
345: Mug
|
||||
346: Mule
|
||||
347: Mushroom
|
||||
348: Musical instrument
|
||||
349: Musical keyboard
|
||||
350: Nail (Construction)
|
||||
351: Necklace
|
||||
352: Nightstand
|
||||
353: Oboe
|
||||
354: Office building
|
||||
355: Office supplies
|
||||
356: Orange
|
||||
357: Organ (Musical Instrument)
|
||||
358: Ostrich
|
||||
359: Otter
|
||||
360: Oven
|
||||
361: Owl
|
||||
362: Oyster
|
||||
363: Paddle
|
||||
364: Palm tree
|
||||
365: Pancake
|
||||
366: Panda
|
||||
367: Paper cutter
|
||||
368: Paper towel
|
||||
369: Parachute
|
||||
370: Parking meter
|
||||
371: Parrot
|
||||
372: Pasta
|
||||
373: Pastry
|
||||
374: Peach
|
||||
375: Pear
|
||||
376: Pen
|
||||
377: Pencil case
|
||||
378: Pencil sharpener
|
||||
379: Penguin
|
||||
380: Perfume
|
||||
381: Person
|
||||
382: Personal care
|
||||
383: Personal flotation device
|
||||
384: Piano
|
||||
385: Picnic basket
|
||||
386: Picture frame
|
||||
387: Pig
|
||||
388: Pillow
|
||||
389: Pineapple
|
||||
390: Pitcher (Container)
|
||||
391: Pizza
|
||||
392: Pizza cutter
|
||||
393: Plant
|
||||
394: Plastic bag
|
||||
395: Plate
|
||||
396: Platter
|
||||
397: Plumbing fixture
|
||||
398: Polar bear
|
||||
399: Pomegranate
|
||||
400: Popcorn
|
||||
401: Porch
|
||||
402: Porcupine
|
||||
403: Poster
|
||||
404: Potato
|
||||
405: Power plugs and sockets
|
||||
406: Pressure cooker
|
||||
407: Pretzel
|
||||
408: Printer
|
||||
409: Pumpkin
|
||||
410: Punching bag
|
||||
411: Rabbit
|
||||
412: Raccoon
|
||||
413: Racket
|
||||
414: Radish
|
||||
415: Ratchet (Device)
|
||||
416: Raven
|
||||
417: Rays and skates
|
||||
418: Red panda
|
||||
419: Refrigerator
|
||||
420: Remote control
|
||||
421: Reptile
|
||||
422: Rhinoceros
|
||||
423: Rifle
|
||||
424: Ring binder
|
||||
425: Rocket
|
||||
426: Roller skates
|
||||
427: Rose
|
||||
428: Rugby ball
|
||||
429: Ruler
|
||||
430: Salad
|
||||
431: Salt and pepper shakers
|
||||
432: Sandal
|
||||
433: Sandwich
|
||||
434: Saucer
|
||||
435: Saxophone
|
||||
436: Scale
|
||||
437: Scarf
|
||||
438: Scissors
|
||||
439: Scoreboard
|
||||
440: Scorpion
|
||||
441: Screwdriver
|
||||
442: Sculpture
|
||||
443: Sea lion
|
||||
444: Sea turtle
|
||||
445: Seafood
|
||||
446: Seahorse
|
||||
447: Seat belt
|
||||
448: Segway
|
||||
449: Serving tray
|
||||
450: Sewing machine
|
||||
451: Shark
|
||||
452: Sheep
|
||||
453: Shelf
|
||||
454: Shellfish
|
||||
455: Shirt
|
||||
456: Shorts
|
||||
457: Shotgun
|
||||
458: Shower
|
||||
459: Shrimp
|
||||
460: Sink
|
||||
461: Skateboard
|
||||
462: Ski
|
||||
463: Skirt
|
||||
464: Skull
|
||||
465: Skunk
|
||||
466: Skyscraper
|
||||
467: Slow cooker
|
||||
468: Snack
|
||||
469: Snail
|
||||
470: Snake
|
||||
471: Snowboard
|
||||
472: Snowman
|
||||
473: Snowmobile
|
||||
474: Snowplow
|
||||
475: Soap dispenser
|
||||
476: Sock
|
||||
477: Sofa bed
|
||||
478: Sombrero
|
||||
479: Sparrow
|
||||
480: Spatula
|
||||
481: Spice rack
|
||||
482: Spider
|
||||
483: Spoon
|
||||
484: Sports equipment
|
||||
485: Sports uniform
|
||||
486: Squash (Plant)
|
||||
487: Squid
|
||||
488: Squirrel
|
||||
489: Stairs
|
||||
490: Stapler
|
||||
491: Starfish
|
||||
492: Stationary bicycle
|
||||
493: Stethoscope
|
||||
494: Stool
|
||||
495: Stop sign
|
||||
496: Strawberry
|
||||
497: Street light
|
||||
498: Stretcher
|
||||
499: Studio couch
|
||||
500: Submarine
|
||||
501: Submarine sandwich
|
||||
502: Suit
|
||||
503: Suitcase
|
||||
504: Sun hat
|
||||
505: Sunglasses
|
||||
506: Surfboard
|
||||
507: Sushi
|
||||
508: Swan
|
||||
509: Swim cap
|
||||
510: Swimming pool
|
||||
511: Swimwear
|
||||
512: Sword
|
||||
513: Syringe
|
||||
514: Table
|
||||
515: Table tennis racket
|
||||
516: Tablet computer
|
||||
517: Tableware
|
||||
518: Taco
|
||||
519: Tank
|
||||
520: Tap
|
||||
521: Tart
|
||||
522: Taxi
|
||||
523: Tea
|
||||
524: Teapot
|
||||
525: Teddy bear
|
||||
526: Telephone
|
||||
527: Television
|
||||
528: Tennis ball
|
||||
529: Tennis racket
|
||||
530: Tent
|
||||
531: Tiara
|
||||
532: Tick
|
||||
533: Tie
|
||||
534: Tiger
|
||||
535: Tin can
|
||||
536: Tire
|
||||
537: Toaster
|
||||
538: Toilet
|
||||
539: Toilet paper
|
||||
540: Tomato
|
||||
541: Tool
|
||||
542: Toothbrush
|
||||
543: Torch
|
||||
544: Tortoise
|
||||
545: Towel
|
||||
546: Tower
|
||||
547: Toy
|
||||
548: Traffic light
|
||||
549: Traffic sign
|
||||
550: Train
|
||||
551: Training bench
|
||||
552: Treadmill
|
||||
553: Tree
|
||||
554: Tree house
|
||||
555: Tripod
|
||||
556: Trombone
|
||||
557: Trousers
|
||||
558: Truck
|
||||
559: Trumpet
|
||||
560: Turkey
|
||||
561: Turtle
|
||||
562: Umbrella
|
||||
563: Unicycle
|
||||
564: Van
|
||||
565: Vase
|
||||
566: Vegetable
|
||||
567: Vehicle
|
||||
568: Vehicle registration plate
|
||||
569: Violin
|
||||
570: Volleyball (Ball)
|
||||
571: Waffle
|
||||
572: Waffle iron
|
||||
573: Wall clock
|
||||
574: Wardrobe
|
||||
575: Washing machine
|
||||
576: Waste container
|
||||
577: Watch
|
||||
578: Watercraft
|
||||
579: Watermelon
|
||||
580: Weapon
|
||||
581: Whale
|
||||
582: Wheel
|
||||
583: Wheelchair
|
||||
584: Whisk
|
||||
585: Whiteboard
|
||||
586: Willow
|
||||
587: Window
|
||||
588: Window blind
|
||||
589: Wine
|
||||
590: Wine glass
|
||||
591: Wine rack
|
||||
592: Winter melon
|
||||
593: Wok
|
||||
594: Woman
|
||||
595: Wood-burning stove
|
||||
596: Woodpecker
|
||||
597: Worm
|
||||
598: Wrench
|
||||
599: Zebra
|
||||
600: Zucchini
|
||||
|
||||
# Download script/URL (optional) ---------------------------------------------------------------------------------------
|
||||
download: |
|
||||
from ultralytics.utils import LOGGER, SETTINGS, Path, is_ubuntu, get_ubuntu_version
|
||||
from ultralytics.utils.checks import check_requirements, check_version
|
||||
|
||||
check_requirements('fiftyone')
|
||||
if is_ubuntu() and check_version(get_ubuntu_version(), '>=22.04'):
|
||||
# Ubuntu>=22.04 patch https://github.com/voxel51/fiftyone/issues/2961#issuecomment-1666519347
|
||||
check_requirements('fiftyone-db-ubuntu2204')
|
||||
|
||||
import fiftyone as fo
|
||||
import fiftyone.zoo as foz
|
||||
import warnings
|
||||
|
||||
name = 'open-images-v7'
|
||||
fraction = 1.0 # fraction of full dataset to use
|
||||
LOGGER.warning('WARNING ⚠️ Open Images V7 dataset requires at least **561 GB of free space. Starting download...')
|
||||
for split in 'train', 'validation': # 1743042 train, 41620 val images
|
||||
train = split == 'train'
|
||||
|
||||
# Load Open Images dataset
|
||||
dataset = foz.load_zoo_dataset(name,
|
||||
split=split,
|
||||
label_types=['detections'],
|
||||
dataset_dir=Path(SETTINGS['datasets_dir']) / 'fiftyone' / name,
|
||||
max_samples=round((1743042 if train else 41620) * fraction))
|
||||
|
||||
# Define classes
|
||||
if train:
|
||||
classes = dataset.default_classes # all classes
|
||||
# classes = dataset.distinct('ground_truth.detections.label') # only observed classes
|
||||
|
||||
# Export to YOLO format
|
||||
with warnings.catch_warnings():
|
||||
warnings.filterwarnings("ignore", category=UserWarning, module="fiftyone.utils.yolo")
|
||||
dataset.export(export_dir=str(Path(SETTINGS['datasets_dir']) / name),
|
||||
dataset_type=fo.types.YOLOv5Dataset,
|
||||
label_field='ground_truth',
|
||||
split='val' if split == 'validation' else split,
|
||||
classes=classes,
|
||||
overwrite=train)
|
||||
@@ -0,0 +1,21 @@
|
||||
# Ultralytics YOLO 🚀, AGPL-3.0 license
|
||||
# Package-seg dataset by Ultralytics
|
||||
# Documentation: https://docs.ultralytics.com/datasets/segment/package-seg/
|
||||
# Example usage: yolo train data=package-seg.yaml
|
||||
# parent
|
||||
# ├── ultralytics
|
||||
# └── datasets
|
||||
# └── package-seg ← downloads here (102 MB)
|
||||
|
||||
# Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..]
|
||||
path: ../datasets/package-seg # dataset root dir
|
||||
train: images/train # train images (relative to 'path') 1920 images
|
||||
val: images/val # val images (relative to 'path') 89 images
|
||||
test: test/images # test images (relative to 'path') 188 images
|
||||
|
||||
# Classes
|
||||
names:
|
||||
0: package
|
||||
|
||||
# Download script/URL (optional)
|
||||
download: https://ultralytics.com/assets/package-seg.zip
|
||||
@@ -0,0 +1,24 @@
|
||||
# Ultralytics YOLO 🚀, AGPL-3.0 license
|
||||
# Tiger Pose dataset by Ultralytics
|
||||
# Documentation: https://docs.ultralytics.com/datasets/pose/tiger-pose/
|
||||
# Example usage: yolo train data=tiger-pose.yaml
|
||||
# parent
|
||||
# ├── ultralytics
|
||||
# └── datasets
|
||||
# └── tiger-pose ← downloads here (75.3 MB)
|
||||
|
||||
# Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..]
|
||||
path: ../datasets/tiger-pose # dataset root dir
|
||||
train: train # train images (relative to 'path') 210 images
|
||||
val: val # val images (relative to 'path') 53 images
|
||||
|
||||
# Keypoints
|
||||
kpt_shape: [12, 2] # number of keypoints, number of dims (2 for x,y or 3 for x,y,visible)
|
||||
flip_idx: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
|
||||
|
||||
# Classes
|
||||
names:
|
||||
0: tiger
|
||||
|
||||
# Download script/URL (optional)
|
||||
download: https://ultralytics.com/assets/tiger-pose.zip
|
||||
@@ -0,0 +1,152 @@
|
||||
# Ultralytics YOLO 🚀, AGPL-3.0 license
|
||||
# DIUx xView 2018 Challenge https://challenge.xviewdataset.org by U.S. National Geospatial-Intelligence Agency (NGA)
|
||||
# -------- DOWNLOAD DATA MANUALLY and jar xf val_images.zip to 'datasets/xView' before running train command! --------
|
||||
# Documentation: https://docs.ultralytics.com/datasets/detect/xview/
|
||||
# Example usage: yolo train data=xView.yaml
|
||||
# parent
|
||||
# ├── ultralytics
|
||||
# └── datasets
|
||||
# └── xView ← downloads here (20.7 GB)
|
||||
|
||||
# Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..]
|
||||
path: ../datasets/xView # dataset root dir
|
||||
train: images/autosplit_train.txt # train images (relative to 'path') 90% of 847 train images
|
||||
val: images/autosplit_val.txt # train images (relative to 'path') 10% of 847 train images
|
||||
|
||||
# Classes
|
||||
names:
|
||||
0: Fixed-wing Aircraft
|
||||
1: Small Aircraft
|
||||
2: Cargo Plane
|
||||
3: Helicopter
|
||||
4: Passenger Vehicle
|
||||
5: Small Car
|
||||
6: Bus
|
||||
7: Pickup Truck
|
||||
8: Utility Truck
|
||||
9: Truck
|
||||
10: Cargo Truck
|
||||
11: Truck w/Box
|
||||
12: Truck Tractor
|
||||
13: Trailer
|
||||
14: Truck w/Flatbed
|
||||
15: Truck w/Liquid
|
||||
16: Crane Truck
|
||||
17: Railway Vehicle
|
||||
18: Passenger Car
|
||||
19: Cargo Car
|
||||
20: Flat Car
|
||||
21: Tank car
|
||||
22: Locomotive
|
||||
23: Maritime Vessel
|
||||
24: Motorboat
|
||||
25: Sailboat
|
||||
26: Tugboat
|
||||
27: Barge
|
||||
28: Fishing Vessel
|
||||
29: Ferry
|
||||
30: Yacht
|
||||
31: Container Ship
|
||||
32: Oil Tanker
|
||||
33: Engineering Vehicle
|
||||
34: Tower crane
|
||||
35: Container Crane
|
||||
36: Reach Stacker
|
||||
37: Straddle Carrier
|
||||
38: Mobile Crane
|
||||
39: Dump Truck
|
||||
40: Haul Truck
|
||||
41: Scraper/Tractor
|
||||
42: Front loader/Bulldozer
|
||||
43: Excavator
|
||||
44: Cement Mixer
|
||||
45: Ground Grader
|
||||
46: Hut/Tent
|
||||
47: Shed
|
||||
48: Building
|
||||
49: Aircraft Hangar
|
||||
50: Damaged Building
|
||||
51: Facility
|
||||
52: Construction Site
|
||||
53: Vehicle Lot
|
||||
54: Helipad
|
||||
55: Storage Tank
|
||||
56: Shipping container lot
|
||||
57: Shipping Container
|
||||
58: Pylon
|
||||
59: Tower
|
||||
|
||||
# Download script/URL (optional) ---------------------------------------------------------------------------------------
|
||||
download: |
|
||||
import json
|
||||
import os
|
||||
from pathlib import Path
|
||||
|
||||
import numpy as np
|
||||
from PIL import Image
|
||||
from tqdm import tqdm
|
||||
|
||||
from ultralytics.data.utils import autosplit
|
||||
from ultralytics.utils.ops import xyxy2xywhn
|
||||
|
||||
|
||||
def convert_labels(fname=Path('xView/xView_train.geojson')):
|
||||
# Convert xView geoJSON labels to YOLO format
|
||||
path = fname.parent
|
||||
with open(fname) as f:
|
||||
print(f'Loading {fname}...')
|
||||
data = json.load(f)
|
||||
|
||||
# Make dirs
|
||||
labels = Path(path / 'labels' / 'train')
|
||||
os.system(f'rm -rf {labels}')
|
||||
labels.mkdir(parents=True, exist_ok=True)
|
||||
|
||||
# xView classes 11-94 to 0-59
|
||||
xview_class2index = [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 2, -1, 3, -1, 4, 5, 6, 7, 8, -1, 9, 10, 11,
|
||||
12, 13, 14, 15, -1, -1, 16, 17, 18, 19, 20, 21, 22, -1, 23, 24, 25, -1, 26, 27, -1, 28, -1,
|
||||
29, 30, 31, 32, 33, 34, 35, 36, 37, -1, 38, 39, 40, 41, 42, 43, 44, 45, -1, -1, -1, -1, 46,
|
||||
47, 48, 49, -1, 50, 51, -1, 52, -1, -1, -1, 53, 54, -1, 55, -1, -1, 56, -1, 57, -1, 58, 59]
|
||||
|
||||
shapes = {}
|
||||
for feature in tqdm(data['features'], desc=f'Converting {fname}'):
|
||||
p = feature['properties']
|
||||
if p['bounds_imcoords']:
|
||||
id = p['image_id']
|
||||
file = path / 'train_images' / id
|
||||
if file.exists(): # 1395.tif missing
|
||||
try:
|
||||
box = np.array([int(num) for num in p['bounds_imcoords'].split(",")])
|
||||
assert box.shape[0] == 4, f'incorrect box shape {box.shape[0]}'
|
||||
cls = p['type_id']
|
||||
cls = xview_class2index[int(cls)] # xView class to 0-60
|
||||
assert 59 >= cls >= 0, f'incorrect class index {cls}'
|
||||
|
||||
# Write YOLO label
|
||||
if id not in shapes:
|
||||
shapes[id] = Image.open(file).size
|
||||
box = xyxy2xywhn(box[None].astype(np.float), w=shapes[id][0], h=shapes[id][1], clip=True)
|
||||
with open((labels / id).with_suffix('.txt'), 'a') as f:
|
||||
f.write(f"{cls} {' '.join(f'{x:.6f}' for x in box[0])}\n") # write label.txt
|
||||
except Exception as e:
|
||||
print(f'WARNING: skipping one label for {file}: {e}')
|
||||
|
||||
|
||||
# Download manually from https://challenge.xviewdataset.org
|
||||
dir = Path(yaml['path']) # dataset root dir
|
||||
# urls = ['https://d307kc0mrhucc3.cloudfront.net/train_labels.zip', # train labels
|
||||
# 'https://d307kc0mrhucc3.cloudfront.net/train_images.zip', # 15G, 847 train images
|
||||
# 'https://d307kc0mrhucc3.cloudfront.net/val_images.zip'] # 5G, 282 val images (no labels)
|
||||
# download(urls, dir=dir)
|
||||
|
||||
# Convert labels
|
||||
convert_labels(dir / 'xView_train.geojson')
|
||||
|
||||
# Move images
|
||||
images = Path(dir / 'images')
|
||||
images.mkdir(parents=True, exist_ok=True)
|
||||
Path(dir / 'train_images').rename(dir / 'images' / 'train')
|
||||
Path(dir / 'val_images').rename(dir / 'images' / 'val')
|
||||
|
||||
# Split
|
||||
autosplit(dir / 'images' / 'train')
|
||||
@@ -0,0 +1,131 @@
|
||||
# Ultralytics YOLO 🚀, AGPL-3.0 license
|
||||
# Default training settings and hyperparameters for medium-augmentation COCO training
|
||||
|
||||
task: detect # (str) YOLO task, i.e. detect, segment, classify, pose
|
||||
mode: train # (str) YOLO mode, i.e. train, val, predict, export, track, benchmark
|
||||
|
||||
ch: 3
|
||||
|
||||
# Train settings -------------------------------------------------------------------------------------------------------
|
||||
model: # (str, optional) path to model file, i.e. yolov8n.pt, yolov8n.yaml
|
||||
data: # (str, optional) path to data file, i.e. coco8.yaml
|
||||
epochs: 100 # (int) number of epochs to train for
|
||||
time: # (float, optional) number of hours to train for, overrides epochs if supplied
|
||||
patience: 100 # (int) epochs to wait for no observable improvement for early stopping of training
|
||||
batch: 16 # (int) number of images per batch (-1 for AutoBatch)
|
||||
imgsz: 640 # (int | list) input images size as int for train and val modes, or list[w,h] for predict and export modes
|
||||
save: True # (bool) save train checkpoints and predict results
|
||||
save_period: -1 # (int) Save checkpoint every x epochs (disabled if < 1)
|
||||
cache: False # (bool) True/ram, disk or False. Use cache for data loading
|
||||
device: # (int | str | list, optional) device to run on, i.e. cuda device=0 or device=0,1,2,3 or device=cpu
|
||||
workers: 8 # (int) number of worker threads for data loading (per RANK if DDP)
|
||||
project: # (str, optional) project name
|
||||
name: # (str, optional) experiment name, results saved to 'project/name' directory
|
||||
exist_ok: False # (bool) whether to overwrite existing experiment
|
||||
pretrained: True # (bool | str) whether to use a pretrained model (bool) or a model to load weights from (str)
|
||||
optimizer: auto # (str) optimizer to use, choices=[SGD, Adam, Adamax, AdamW, NAdam, RAdam, RMSProp, auto]
|
||||
verbose: True # (bool) whether to print verbose output
|
||||
seed: 0 # (int) random seed for reproducibility
|
||||
deterministic: True # (bool) whether to enable deterministic mode
|
||||
single_cls: False # (bool) train multi-class data as single-class
|
||||
rect: False # (bool) rectangular training if mode='train' or rectangular validation if mode='val'
|
||||
cos_lr: False # (bool) use cosine learning rate scheduler
|
||||
close_mosaic: 10 # (int) disable mosaic augmentation for final epochs (0 to disable)
|
||||
resume: False # (bool) resume training from last checkpoint
|
||||
amp: True # (bool) Automatic Mixed Precision (AMP) training, choices=[True, False], True runs AMP check
|
||||
fraction: 1.0 # (float) dataset fraction to train on (default is 1.0, all images in train set)
|
||||
profile: False # (bool) profile ONNX and TensorRT speeds during training for loggers
|
||||
freeze: None # (int | list, optional) freeze first n layers, or freeze list of layer indices during training
|
||||
multi_scale: False # (bool) Whether to use multiscale during training
|
||||
# Segmentation
|
||||
overlap_mask: True # (bool) masks should overlap during training (segment train only)
|
||||
mask_ratio: 4 # (int) mask downsample ratio (segment train only)
|
||||
# Classification
|
||||
dropout: 0.0 # (float) use dropout regularization (classify train only)
|
||||
|
||||
# Val/Test settings ----------------------------------------------------------------------------------------------------
|
||||
val: True # (bool) validate/test during training
|
||||
split: val # (str) dataset split to use for validation, i.e. 'val', 'test' or 'train'
|
||||
save_json: False # (bool) save results to JSON file
|
||||
save_hybrid: False # (bool) save hybrid version of labels (labels + additional predictions)
|
||||
conf: # (float, optional) object confidence threshold for detection (default 0.25 predict, 0.001 val)
|
||||
iou: 0.7 # (float) intersection over union (IoU) threshold for NMS
|
||||
max_det: 300 # (int) maximum number of detections per image
|
||||
half: False # (bool) use half precision (FP16)
|
||||
dnn: False # (bool) use OpenCV DNN for ONNX inference
|
||||
plots: True # (bool) save plots and images during train/val
|
||||
|
||||
# Predict settings -----------------------------------------------------------------------------------------------------
|
||||
source: # (str, optional) source directory for images or videos
|
||||
vid_stride: 1 # (int) video frame-rate stride
|
||||
stream_buffer: False # (bool) buffer all streaming frames (True) or return the most recent frame (False)
|
||||
visualize: False # (bool) visualize model features
|
||||
augment: False # (bool) apply image augmentation to prediction sources
|
||||
agnostic_nms: False # (bool) class-agnostic NMS
|
||||
classes: # (int | list[int], optional) filter results by class, i.e. classes=0, or classes=[0,2,3]
|
||||
retina_masks: False # (bool) use high-resolution segmentation masks
|
||||
embed: # (list[int], optional) return feature vectors/embeddings from given layers
|
||||
|
||||
# Visualize settings ---------------------------------------------------------------------------------------------------
|
||||
show: False # (bool) show predicted images and videos if environment allows
|
||||
save_frames: False # (bool) save predicted individual video frames
|
||||
save_txt: False # (bool) save results as .txt file
|
||||
save_conf: False # (bool) save results with confidence scores
|
||||
save_crop: False # (bool) save cropped images with results
|
||||
show_labels: True # (bool) show prediction labels, i.e. 'person'
|
||||
show_conf: True # (bool) show prediction confidence, i.e. '0.99'
|
||||
show_boxes: True # (bool) show prediction boxes
|
||||
line_width: # (int, optional) line width of the bounding boxes. Scaled to image size if None.
|
||||
|
||||
# Export settings ------------------------------------------------------------------------------------------------------
|
||||
format: torchscript # (str) format to export to, choices at https://docs.ultralytics.com/modes/export/#export-formats
|
||||
keras: False # (bool) use Kera=s
|
||||
optimize: False # (bool) TorchScript: optimize for mobile
|
||||
int8: False # (bool) CoreML/TF INT8 quantization
|
||||
dynamic: False # (bool) ONNX/TF/TensorRT: dynamic axes
|
||||
simplify: False # (bool) ONNX: simplify model
|
||||
opset: # (int, optional) ONNX: opset version
|
||||
workspace: 4 # (int) TensorRT: workspace size (GB)
|
||||
nms: False # (bool) CoreML: add NMS
|
||||
|
||||
# Hyperparameters ------------------------------------------------------------------------------------------------------
|
||||
lr0: 0.01 # (float) initial learning rate (i.e. SGD=1E-2, Adam=1E-3)
|
||||
lrf: 0.01 # (float) final learning rate (lr0 * lrf)
|
||||
momentum: 0.937 # (float) SGD momentum/Adam beta1
|
||||
weight_decay: 0.0005 # (float) optimizer weight decay 5e-4
|
||||
warmup_epochs: 3.0 # (float) warmup epochs (fractions ok)
|
||||
warmup_momentum: 0.8 # (float) warmup initial momentum
|
||||
warmup_bias_lr: 0.1 # (float) warmup initial bias lr
|
||||
box: 7.5 # (float) box loss gain
|
||||
cls: 0.5 # (float) cls loss gain (scale with pixels)
|
||||
obj: 0.5 # (float) obj bin loss gain (scale with pixels)
|
||||
dfl: 1.5 # (float) dfl loss gain
|
||||
pose: 12.0 # (float) pose loss gain
|
||||
kobj: 1.0 # (float) keypoint obj loss gain
|
||||
label_smoothing: 0.0 # (float) label smoothing (fraction)
|
||||
nbs: 64 # (int) nominal batch size
|
||||
hsv_h: 0.0 #0.015 # (float) image HSV-Hue augmentation (fraction)
|
||||
hsv_s: 0.0 #0.7 # (float) image HSV-Saturation augmentation (fraction)
|
||||
hsv_v: 0.0 #0.4 # (float) image HSV-Value augmentation (fraction)
|
||||
degrees: 0.0 # (float) image rotation (+/- deg)
|
||||
translate: 0.1 # (float) image translation (+/- fraction)
|
||||
scale: 0.5 # (float) image scale (+/- gain)
|
||||
shear: 0.0 # (float) image shear (+/- deg)
|
||||
perspective: 0.0 # (float) image perspective (+/- fraction), range 0-0.001
|
||||
flipud: 0.0 # (float) image flip up-down (probability)
|
||||
fliplr: 0.5 # (float) image flip left-right (probability)
|
||||
bgr: 1.0 # 0.0 # (float) image channel BGR (probability)
|
||||
mosaic: 1.0 # (float) image mosaic (probability)
|
||||
mixup: 0.0 # (float) image mixup (probability)
|
||||
copy_paste: 0.0 # (float) segment copy-paste (probability)
|
||||
auto_augment: randaugment # (str) auto augmentation policy for classification (randaugment, autoaugment, augmix)
|
||||
erasing: 0.4 # (float) probability of random erasing during classification training (0-0.9), 0 means no erasing, must be less than 1.0.
|
||||
crop_fraction: 1.0 # (float) image crop fraction for classification (0.1-1), 1.0 means no crop, must be greater than 0.
|
||||
|
||||
# Custom config.yaml ---------------------------------------------------------------------------------------------------
|
||||
cfg: # (str, optional) for overriding defaults.yaml
|
||||
|
||||
# Tracker settings ------------------------------------------------------------------------------------------------------
|
||||
tracker: botsort.yaml # (str) tracker type, choices=[botsort.yaml, bytetrack.yaml]
|
||||
|
||||
file:
|
||||
@@ -0,0 +1,30 @@
|
||||
# Ultralytics YOLO 🚀, AGPL-3.0 license
|
||||
# YOLO11-cls image classification model. For Usage examples see https://docs.ultralytics.com/tasks/classify
|
||||
|
||||
# Parameters
|
||||
nc: 80 # number of classes
|
||||
scales: # model compound scaling constants, i.e. 'model=yolo11n-cls.yaml' will call yolo11-cls.yaml with scale 'n'
|
||||
# [depth, width, max_channels]
|
||||
n: [0.50, 0.25, 1024] # summary: 151 layers, 1633584 parameters, 1633584 gradients, 3.3 GFLOPs
|
||||
s: [0.50, 0.50, 1024] # summary: 151 layers, 5545488 parameters, 5545488 gradients, 12.2 GFLOPs
|
||||
m: [0.50, 1.00, 512] # summary: 187 layers, 10455696 parameters, 10455696 gradients, 39.7 GFLOPs
|
||||
l: [1.00, 1.00, 512] # summary: 309 layers, 12937104 parameters, 12937104 gradients, 49.9 GFLOPs
|
||||
x: [1.00, 1.50, 512] # summary: 309 layers, 28458544 parameters, 28458544 gradients, 111.1 GFLOPs
|
||||
|
||||
# YOLO11n backbone
|
||||
backbone:
|
||||
# [from, repeats, module, args]
|
||||
- [-1, 1, Conv, [64, 3, 2]] # 0-P1/2
|
||||
- [-1, 1, Conv, [128, 3, 2]] # 1-P2/4
|
||||
- [-1, 2, C3k2, [256, False, 0.25]]
|
||||
- [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
|
||||
- [-1, 2, C3k2, [512, False, 0.25]]
|
||||
- [-1, 1, Conv, [512, 3, 2]] # 5-P4/16
|
||||
- [-1, 2, C3k2, [512, True]]
|
||||
- [-1, 1, Conv, [1024, 3, 2]] # 7-P5/32
|
||||
- [-1, 2, C3k2, [1024, True]]
|
||||
- [-1, 2, C2PSA, [1024]] # 9
|
||||
|
||||
# YOLO11n head
|
||||
head:
|
||||
- [-1, 1, Classify, [nc]] # Classify
|
||||
@@ -0,0 +1,47 @@
|
||||
# Ultralytics YOLO 🚀, AGPL-3.0 license
|
||||
# YOLO11 Oriented Bounding Boxes (OBB) model with P3-P5 outputs. For Usage examples see https://docs.ultralytics.com/tasks/obb
|
||||
|
||||
# Parameters
|
||||
nc: 80 # number of classes
|
||||
scales: # model compound scaling constants, i.e. 'model=yolo11n-obb.yaml' will call yolo11-obb.yaml with scale 'n'
|
||||
# [depth, width, max_channels]
|
||||
n: [0.50, 0.25, 1024] # summary: 344 layers, 2695747 parameters, 2695731 gradients, 6.9 GFLOPs
|
||||
s: [0.50, 0.50, 1024] # summary: 344 layers, 9744931 parameters, 9744915 gradients, 22.7 GFLOPs
|
||||
m: [0.50, 1.00, 512] # summary: 434 layers, 20963523 parameters, 20963507 gradients, 72.2 GFLOPs
|
||||
l: [1.00, 1.00, 512] # summary: 656 layers, 26220995 parameters, 26220979 gradients, 91.3 GFLOPs
|
||||
x: [1.00, 1.50, 512] # summary: 656 layers, 58875331 parameters, 58875315 gradients, 204.3 GFLOPs
|
||||
|
||||
# YOLO11n backbone
|
||||
backbone:
|
||||
# [from, repeats, module, args]
|
||||
- [-1, 1, Conv, [64, 3, 2]] # 0-P1/2
|
||||
- [-1, 1, Conv, [128, 3, 2]] # 1-P2/4
|
||||
- [-1, 2, C3k2, [256, False, 0.25]]
|
||||
- [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
|
||||
- [-1, 2, C3k2, [512, False, 0.25]]
|
||||
- [-1, 1, Conv, [512, 3, 2]] # 5-P4/16
|
||||
- [-1, 2, C3k2, [512, True]]
|
||||
- [-1, 1, Conv, [1024, 3, 2]] # 7-P5/32
|
||||
- [-1, 2, C3k2, [1024, True]]
|
||||
- [-1, 1, SPPF, [1024, 5]] # 9
|
||||
- [-1, 2, C2PSA, [1024]] # 10
|
||||
|
||||
# YOLO11n head
|
||||
head:
|
||||
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
|
||||
- [[-1, 6], 1, Concat, [1]] # cat backbone P4
|
||||
- [-1, 2, C3k2, [512, False]] # 13
|
||||
|
||||
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
|
||||
- [[-1, 4], 1, Concat, [1]] # cat backbone P3
|
||||
- [-1, 2, C3k2, [256, False]] # 16 (P3/8-small)
|
||||
|
||||
- [-1, 1, Conv, [256, 3, 2]]
|
||||
- [[-1, 13], 1, Concat, [1]] # cat head P4
|
||||
- [-1, 2, C3k2, [512, False]] # 19 (P4/16-medium)
|
||||
|
||||
- [-1, 1, Conv, [512, 3, 2]]
|
||||
- [[-1, 10], 1, Concat, [1]] # cat head P5
|
||||
- [-1, 2, C3k2, [1024, True]] # 22 (P5/32-large)
|
||||
|
||||
- [[16, 19, 22], 1, OBB, [nc, 1]] # Detect(P3, P4, P5)
|
||||
@@ -0,0 +1,48 @@
|
||||
# Ultralytics YOLO 🚀, AGPL-3.0 license
|
||||
# YOLO11-pose keypoints/pose estimation model. For Usage examples see https://docs.ultralytics.com/tasks/pose
|
||||
|
||||
# Parameters
|
||||
nc: 80 # number of classes
|
||||
kpt_shape: [17, 3] # number of keypoints, number of dims (2 for x,y or 3 for x,y,visible)
|
||||
scales: # model compound scaling constants, i.e. 'model=yolo11n-pose.yaml' will call yolo11.yaml with scale 'n'
|
||||
# [depth, width, max_channels]
|
||||
n: [0.50, 0.25, 1024] # summary: 344 layers, 2908507 parameters, 2908491 gradients, 7.7 GFLOPs
|
||||
s: [0.50, 0.50, 1024] # summary: 344 layers, 9948811 parameters, 9948795 gradients, 23.5 GFLOPs
|
||||
m: [0.50, 1.00, 512] # summary: 434 layers, 20973273 parameters, 20973257 gradients, 72.3 GFLOPs
|
||||
l: [1.00, 1.00, 512] # summary: 656 layers, 26230745 parameters, 26230729 gradients, 91.4 GFLOPs
|
||||
x: [1.00, 1.50, 512] # summary: 656 layers, 58889881 parameters, 58889865 gradients, 204.3 GFLOPs
|
||||
|
||||
# YOLO11n backbone
|
||||
backbone:
|
||||
# [from, repeats, module, args]
|
||||
- [-1, 1, Conv, [64, 3, 2]] # 0-P1/2
|
||||
- [-1, 1, Conv, [128, 3, 2]] # 1-P2/4
|
||||
- [-1, 2, C3k2, [256, False, 0.25]]
|
||||
- [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
|
||||
- [-1, 2, C3k2, [512, False, 0.25]]
|
||||
- [-1, 1, Conv, [512, 3, 2]] # 5-P4/16
|
||||
- [-1, 2, C3k2, [512, True]]
|
||||
- [-1, 1, Conv, [1024, 3, 2]] # 7-P5/32
|
||||
- [-1, 2, C3k2, [1024, True]]
|
||||
- [-1, 1, SPPF, [1024, 5]] # 9
|
||||
- [-1, 2, C2PSA, [1024]] # 10
|
||||
|
||||
# YOLO11n head
|
||||
head:
|
||||
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
|
||||
- [[-1, 6], 1, Concat, [1]] # cat backbone P4
|
||||
- [-1, 2, C3k2, [512, False]] # 13
|
||||
|
||||
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
|
||||
- [[-1, 4], 1, Concat, [1]] # cat backbone P3
|
||||
- [-1, 2, C3k2, [256, False]] # 16 (P3/8-small)
|
||||
|
||||
- [-1, 1, Conv, [256, 3, 2]]
|
||||
- [[-1, 13], 1, Concat, [1]] # cat head P4
|
||||
- [-1, 2, C3k2, [512, False]] # 19 (P4/16-medium)
|
||||
|
||||
- [-1, 1, Conv, [512, 3, 2]]
|
||||
- [[-1, 10], 1, Concat, [1]] # cat head P5
|
||||
- [-1, 2, C3k2, [1024, True]] # 22 (P5/32-large)
|
||||
|
||||
- [[16, 19, 22], 1, Pose, [nc, kpt_shape]] # Detect(P3, P4, P5)
|
||||
@@ -0,0 +1,47 @@
|
||||
# Ultralytics YOLO 🚀, AGPL-3.0 license
|
||||
# YOLO11-seg instance segmentation model. For Usage examples see https://docs.ultralytics.com/tasks/segment
|
||||
|
||||
# Parameters
|
||||
nc: 80 # number of classes
|
||||
scales: # model compound scaling constants, i.e. 'model=yolo11n-seg.yaml' will call yolo11-seg.yaml with scale 'n'
|
||||
# [depth, width, max_channels]
|
||||
n: [0.50, 0.25, 1024] # summary: 355 layers, 2876848 parameters, 2876832 gradients, 10.5 GFLOPs
|
||||
s: [0.50, 0.50, 1024] # summary: 355 layers, 10113248 parameters, 10113232 gradients, 35.8 GFLOPs
|
||||
m: [0.50, 1.00, 512] # summary: 445 layers, 22420896 parameters, 22420880 gradients, 123.9 GFLOPs
|
||||
l: [1.00, 1.00, 512] # summary: 667 layers, 27678368 parameters, 27678352 gradients, 143.0 GFLOPs
|
||||
x: [1.00, 1.50, 512] # summary: 667 layers, 62142656 parameters, 62142640 gradients, 320.2 GFLOPs
|
||||
|
||||
# YOLO11n backbone
|
||||
backbone:
|
||||
# [from, repeats, module, args]
|
||||
- [-1, 1, Conv, [64, 3, 2]] # 0-P1/2
|
||||
- [-1, 1, Conv, [128, 3, 2]] # 1-P2/4
|
||||
- [-1, 2, C3k2, [256, False, 0.25]]
|
||||
- [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
|
||||
- [-1, 2, C3k2, [512, False, 0.25]]
|
||||
- [-1, 1, Conv, [512, 3, 2]] # 5-P4/16
|
||||
- [-1, 2, C3k2, [512, True]]
|
||||
- [-1, 1, Conv, [1024, 3, 2]] # 7-P5/32
|
||||
- [-1, 2, C3k2, [1024, True]]
|
||||
- [-1, 1, SPPF, [1024, 5]] # 9
|
||||
- [-1, 2, C2PSA, [1024]] # 10
|
||||
|
||||
# YOLO11n head
|
||||
head:
|
||||
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
|
||||
- [[-1, 6], 1, Concat, [1]] # cat backbone P4
|
||||
- [-1, 2, C3k2, [512, False]] # 13
|
||||
|
||||
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
|
||||
- [[-1, 4], 1, Concat, [1]] # cat backbone P3
|
||||
- [-1, 2, C3k2, [256, False]] # 16 (P3/8-small)
|
||||
|
||||
- [-1, 1, Conv, [256, 3, 2]]
|
||||
- [[-1, 13], 1, Concat, [1]] # cat head P4
|
||||
- [-1, 2, C3k2, [512, False]] # 19 (P4/16-medium)
|
||||
|
||||
- [-1, 1, Conv, [512, 3, 2]]
|
||||
- [[-1, 10], 1, Concat, [1]] # cat head P5
|
||||
- [-1, 2, C3k2, [1024, True]] # 22 (P5/32-large)
|
||||
|
||||
- [[16, 19, 22], 1, Segment, [nc, 32, 256]] # Detect(P3, P4, P5)
|
||||
@@ -0,0 +1,47 @@
|
||||
# Ultralytics YOLO 🚀, AGPL-3.0 license
|
||||
# YOLO11 object detection model with P3-P5 outputs. For Usage examples see https://docs.ultralytics.com/tasks/detect
|
||||
|
||||
# Parameters
|
||||
nc: 80 # number of classes
|
||||
scales: # model compound scaling constants, i.e. 'model=yolo11n.yaml' will call yolo11.yaml with scale 'n'
|
||||
# [depth, width, max_channels]
|
||||
n: [0.50, 0.25, 1024] # summary: 319 layers, 2624080 parameters, 2624064 gradients, 6.6 GFLOPs
|
||||
s: [0.50, 0.50, 1024] # summary: 319 layers, 9458752 parameters, 9458736 gradients, 21.7 GFLOPs
|
||||
m: [0.50, 1.00, 512] # summary: 409 layers, 20114688 parameters, 20114672 gradients, 68.5 GFLOPs
|
||||
l: [1.00, 1.00, 512] # summary: 631 layers, 25372160 parameters, 25372144 gradients, 87.6 GFLOPs
|
||||
x: [1.00, 1.50, 512] # summary: 631 layers, 56966176 parameters, 56966160 gradients, 196.0 GFLOPs
|
||||
|
||||
# YOLO11n backbone
|
||||
backbone:
|
||||
# [from, repeats, module, args]
|
||||
- [-1, 1, Conv, [64, 3, 2]] # 0-P1/2
|
||||
- [-1, 1, Conv, [128, 3, 2]] # 1-P2/4
|
||||
- [-1, 2, C3k2, [256, False, 0.25]]
|
||||
- [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
|
||||
- [-1, 2, C3k2, [512, False, 0.25]]
|
||||
- [-1, 1, Conv, [512, 3, 2]] # 5-P4/16
|
||||
- [-1, 2, C3k2, [512, True]]
|
||||
- [-1, 1, Conv, [1024, 3, 2]] # 7-P5/32
|
||||
- [-1, 2, C3k2, [1024, True]]
|
||||
- [-1, 1, SPPF, [1024, 5]] # 9
|
||||
- [-1, 2, C2PSA, [1024]] # 10
|
||||
|
||||
# YOLO11n head
|
||||
head:
|
||||
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
|
||||
- [[-1, 6], 1, Concat, [1]] # cat backbone P4
|
||||
- [-1, 2, C3k2, [512, False]] # 13
|
||||
|
||||
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
|
||||
- [[-1, 4], 1, Concat, [1]] # cat backbone P3
|
||||
- [-1, 2, C3k2, [256, False]] # 16 (P3/8-small)
|
||||
|
||||
- [-1, 1, Conv, [256, 3, 2]]
|
||||
- [[-1, 13], 1, Concat, [1]] # cat head P4
|
||||
- [-1, 2, C3k2, [512, False]] # 19 (P4/16-medium)
|
||||
|
||||
- [-1, 1, Conv, [512, 3, 2]]
|
||||
- [[-1, 10], 1, Concat, [1]] # cat head P5
|
||||
- [-1, 2, C3k2, [1024, True]] # 22 (P5/32-large)
|
||||
|
||||
- [[16, 19, 22], 1, Detect, [nc]] # Detect(P3, P4, P5)
|
||||
@@ -0,0 +1,40 @@
|
||||
## Models
|
||||
|
||||
Welcome to the Ultralytics Models directory! Here you will find a wide variety of pre-configured model configuration files (`*.yaml`s) that can be used to create custom YOLO models. The models in this directory have been expertly crafted and fine-tuned by the Ultralytics team to provide the best performance for a wide range of object detection and image segmentation tasks.
|
||||
|
||||
These model configurations cover a wide range of scenarios, from simple object detection to more complex tasks like instance segmentation and object tracking. They are also designed to run efficiently on a variety of hardware platforms, from CPUs to GPUs. Whether you are a seasoned machine learning practitioner or just getting started with YOLO, this directory provides a great starting point for your custom model development needs.
|
||||
|
||||
To get started, simply browse through the models in this directory and find one that best suits your needs. Once you've selected a model, you can use the provided `*.yaml` file to train and deploy your custom YOLO model with ease. See full details at the Ultralytics [Docs](https://docs.ultralytics.com/models), and if you need help or have any questions, feel free to reach out to the Ultralytics team for support. So, don't wait, start creating your custom YOLO model now!
|
||||
|
||||
### Usage
|
||||
|
||||
Model `*.yaml` files may be used directly in the Command Line Interface (CLI) with a `yolo` command:
|
||||
|
||||
```bash
|
||||
yolo task=detect mode=train model=yolov8n.yaml data=coco8.yaml epochs=100
|
||||
```
|
||||
|
||||
They may also be used directly in a Python environment, and accepts the same [arguments](https://docs.ultralytics.com/usage/cfg/) as in the CLI example above:
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
model = YOLO("model.yaml") # build a YOLOv8n model from scratch
|
||||
# YOLO("model.pt") use pre-trained model if available
|
||||
model.info() # display model information
|
||||
model.train(data="coco8.yaml", epochs=100) # train the model
|
||||
```
|
||||
|
||||
## Pre-trained Model Architectures
|
||||
|
||||
Ultralytics supports many model architectures. Visit https://docs.ultralytics.com/models to view detailed information and usage. Any of these models can be used by loading their configs or pretrained checkpoints if available.
|
||||
|
||||
## Contribute New Models
|
||||
|
||||
Have you trained a new YOLO variant or achieved state-of-the-art performance with specific tuning? We'd love to showcase your work in our Models section! Contributions from the community in the form of new models, architectures, or optimizations are highly valued and can significantly enrich our repository.
|
||||
|
||||
By contributing to this section, you're helping us offer a wider array of model choices and configurations to the community. It's a fantastic way to share your knowledge and expertise while making the Ultralytics YOLO ecosystem even more versatile.
|
||||
|
||||
To get started, please consult our [Contributing Guide](https://docs.ultralytics.com/help/contributing) for step-by-step instructions on how to submit a Pull Request (PR) 🛠️. Your contributions are eagerly awaited!
|
||||
|
||||
Let's join hands to extend the range and capabilities of the Ultralytics YOLO models 🙏!
|
||||
@@ -0,0 +1,50 @@
|
||||
# Ultralytics YOLO 🚀, AGPL-3.0 license
|
||||
# RT-DETR-l object detection model with P3-P5 outputs. For details see https://docs.ultralytics.com/models/rtdetr
|
||||
|
||||
# Parameters
|
||||
nc: 80 # number of classes
|
||||
scales: # model compound scaling constants, i.e. 'model=yolov8n-cls.yaml' will call yolov8-cls.yaml with scale 'n'
|
||||
# [depth, width, max_channels]
|
||||
l: [1.00, 1.00, 1024]
|
||||
|
||||
backbone:
|
||||
# [from, repeats, module, args]
|
||||
- [-1, 1, HGStem, [32, 48]] # 0-P2/4
|
||||
- [-1, 6, HGBlock, [48, 128, 3]] # stage 1
|
||||
|
||||
- [-1, 1, DWConv, [128, 3, 2, 1, False]] # 2-P3/8
|
||||
- [-1, 6, HGBlock, [96, 512, 3]] # stage 2
|
||||
|
||||
- [-1, 1, DWConv, [512, 3, 2, 1, False]] # 4-P3/16
|
||||
- [-1, 6, HGBlock, [192, 1024, 5, True, False]] # cm, c2, k, light, shortcut
|
||||
- [-1, 6, HGBlock, [192, 1024, 5, True, True]]
|
||||
- [-1, 6, HGBlock, [192, 1024, 5, True, True]] # stage 3
|
||||
|
||||
- [-1, 1, DWConv, [1024, 3, 2, 1, False]] # 8-P4/32
|
||||
- [-1, 6, HGBlock, [384, 2048, 5, True, False]] # stage 4
|
||||
|
||||
head:
|
||||
- [-1, 1, Conv, [256, 1, 1, None, 1, 1, False]] # 10 input_proj.2
|
||||
- [-1, 1, AIFI, [1024, 8]]
|
||||
- [-1, 1, Conv, [256, 1, 1]] # 12, Y5, lateral_convs.0
|
||||
|
||||
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
|
||||
- [7, 1, Conv, [256, 1, 1, None, 1, 1, False]] # 14 input_proj.1
|
||||
- [[-2, -1], 1, Concat, [1]]
|
||||
- [-1, 3, RepC3, [256]] # 16, fpn_blocks.0
|
||||
- [-1, 1, Conv, [256, 1, 1]] # 17, Y4, lateral_convs.1
|
||||
|
||||
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
|
||||
- [3, 1, Conv, [256, 1, 1, None, 1, 1, False]] # 19 input_proj.0
|
||||
- [[-2, -1], 1, Concat, [1]] # cat backbone P4
|
||||
- [-1, 3, RepC3, [256]] # X3 (21), fpn_blocks.1
|
||||
|
||||
- [-1, 1, Conv, [256, 3, 2]] # 22, downsample_convs.0
|
||||
- [[-1, 17], 1, Concat, [1]] # cat Y4
|
||||
- [-1, 3, RepC3, [256]] # F4 (24), pan_blocks.0
|
||||
|
||||
- [-1, 1, Conv, [256, 3, 2]] # 25, downsample_convs.1
|
||||
- [[-1, 12], 1, Concat, [1]] # cat Y5
|
||||
- [-1, 3, RepC3, [256]] # F5 (27), pan_blocks.1
|
||||
|
||||
- [[21, 24, 27], 1, RTDETRDecoder, [nc]] # Detect(P3, P4, P5)
|
||||
@@ -0,0 +1,42 @@
|
||||
# Ultralytics YOLO 🚀, AGPL-3.0 license
|
||||
# RT-DETR-ResNet101 object detection model with P3-P5 outputs.
|
||||
|
||||
# Parameters
|
||||
nc: 80 # number of classes
|
||||
scales: # model compound scaling constants, i.e. 'model=yolov8n-cls.yaml' will call yolov8-cls.yaml with scale 'n'
|
||||
# [depth, width, max_channels]
|
||||
l: [1.00, 1.00, 1024]
|
||||
|
||||
backbone:
|
||||
# [from, repeats, module, args]
|
||||
- [-1, 1, ResNetLayer, [3, 64, 1, True, 1]] # 0
|
||||
- [-1, 1, ResNetLayer, [64, 64, 1, False, 3]] # 1
|
||||
- [-1, 1, ResNetLayer, [256, 128, 2, False, 4]] # 2
|
||||
- [-1, 1, ResNetLayer, [512, 256, 2, False, 23]] # 3
|
||||
- [-1, 1, ResNetLayer, [1024, 512, 2, False, 3]] # 4
|
||||
|
||||
head:
|
||||
- [-1, 1, Conv, [256, 1, 1, None, 1, 1, False]] # 5
|
||||
- [-1, 1, AIFI, [1024, 8]]
|
||||
- [-1, 1, Conv, [256, 1, 1]] # 7
|
||||
|
||||
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
|
||||
- [3, 1, Conv, [256, 1, 1, None, 1, 1, False]] # 9
|
||||
- [[-2, -1], 1, Concat, [1]]
|
||||
- [-1, 3, RepC3, [256]] # 11
|
||||
- [-1, 1, Conv, [256, 1, 1]] # 12
|
||||
|
||||
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
|
||||
- [2, 1, Conv, [256, 1, 1, None, 1, 1, False]] # 14
|
||||
- [[-2, -1], 1, Concat, [1]] # cat backbone P4
|
||||
- [-1, 3, RepC3, [256]] # X3 (16), fpn_blocks.1
|
||||
|
||||
- [-1, 1, Conv, [256, 3, 2]] # 17, downsample_convs.0
|
||||
- [[-1, 12], 1, Concat, [1]] # cat Y4
|
||||
- [-1, 3, RepC3, [256]] # F4 (19), pan_blocks.0
|
||||
|
||||
- [-1, 1, Conv, [256, 3, 2]] # 20, downsample_convs.1
|
||||
- [[-1, 7], 1, Concat, [1]] # cat Y5
|
||||
- [-1, 3, RepC3, [256]] # F5 (22), pan_blocks.1
|
||||
|
||||
- [[16, 19, 22], 1, RTDETRDecoder, [nc]] # Detect(P3, P4, P5)
|
||||
@@ -0,0 +1,42 @@
|
||||
# Ultralytics YOLO 🚀, AGPL-3.0 license
|
||||
# RT-DETR-ResNet50 object detection model with P3-P5 outputs.
|
||||
|
||||
# Parameters
|
||||
nc: 80 # number of classes
|
||||
scales: # model compound scaling constants, i.e. 'model=yolov8n-cls.yaml' will call yolov8-cls.yaml with scale 'n'
|
||||
# [depth, width, max_channels]
|
||||
l: [1.00, 1.00, 1024]
|
||||
|
||||
backbone:
|
||||
# [from, repeats, module, args]
|
||||
- [-1, 1, ResNetLayer, [3, 64, 1, True, 1]] # 0
|
||||
- [-1, 1, ResNetLayer, [64, 64, 1, False, 3]] # 1
|
||||
- [-1, 1, ResNetLayer, [256, 128, 2, False, 4]] # 2
|
||||
- [-1, 1, ResNetLayer, [512, 256, 2, False, 6]] # 3
|
||||
- [-1, 1, ResNetLayer, [1024, 512, 2, False, 3]] # 4
|
||||
|
||||
head:
|
||||
- [-1, 1, Conv, [256, 1, 1, None, 1, 1, False]] # 5
|
||||
- [-1, 1, AIFI, [1024, 8]]
|
||||
- [-1, 1, Conv, [256, 1, 1]] # 7
|
||||
|
||||
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
|
||||
- [3, 1, Conv, [256, 1, 1, None, 1, 1, False]] # 9
|
||||
- [[-2, -1], 1, Concat, [1]]
|
||||
- [-1, 3, RepC3, [256]] # 11
|
||||
- [-1, 1, Conv, [256, 1, 1]] # 12
|
||||
|
||||
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
|
||||
- [2, 1, Conv, [256, 1, 1, None, 1, 1, False]] # 14
|
||||
- [[-2, -1], 1, Concat, [1]] # cat backbone P4
|
||||
- [-1, 3, RepC3, [256]] # X3 (16), fpn_blocks.1
|
||||
|
||||
- [-1, 1, Conv, [256, 3, 2]] # 17, downsample_convs.0
|
||||
- [[-1, 12], 1, Concat, [1]] # cat Y4
|
||||
- [-1, 3, RepC3, [256]] # F4 (19), pan_blocks.0
|
||||
|
||||
- [-1, 1, Conv, [256, 3, 2]] # 20, downsample_convs.1
|
||||
- [[-1, 7], 1, Concat, [1]] # cat Y5
|
||||
- [-1, 3, RepC3, [256]] # F5 (22), pan_blocks.1
|
||||
|
||||
- [[16, 19, 22], 1, RTDETRDecoder, [nc]] # Detect(P3, P4, P5)
|
||||
@@ -0,0 +1,54 @@
|
||||
# Ultralytics YOLO 🚀, AGPL-3.0 license
|
||||
# RT-DETR-x object detection model with P3-P5 outputs. For details see https://docs.ultralytics.com/models/rtdetr
|
||||
|
||||
# Parameters
|
||||
nc: 80 # number of classes
|
||||
scales: # model compound scaling constants, i.e. 'model=yolov8n-cls.yaml' will call yolov8-cls.yaml with scale 'n'
|
||||
# [depth, width, max_channels]
|
||||
x: [1.00, 1.00, 2048]
|
||||
|
||||
backbone:
|
||||
# [from, repeats, module, args]
|
||||
- [-1, 1, HGStem, [32, 64]] # 0-P2/4
|
||||
- [-1, 6, HGBlock, [64, 128, 3]] # stage 1
|
||||
|
||||
- [-1, 1, DWConv, [128, 3, 2, 1, False]] # 2-P3/8
|
||||
- [-1, 6, HGBlock, [128, 512, 3]]
|
||||
- [-1, 6, HGBlock, [128, 512, 3, False, True]] # 4-stage 2
|
||||
|
||||
- [-1, 1, DWConv, [512, 3, 2, 1, False]] # 5-P3/16
|
||||
- [-1, 6, HGBlock, [256, 1024, 5, True, False]] # cm, c2, k, light, shortcut
|
||||
- [-1, 6, HGBlock, [256, 1024, 5, True, True]]
|
||||
- [-1, 6, HGBlock, [256, 1024, 5, True, True]]
|
||||
- [-1, 6, HGBlock, [256, 1024, 5, True, True]]
|
||||
- [-1, 6, HGBlock, [256, 1024, 5, True, True]] # 10-stage 3
|
||||
|
||||
- [-1, 1, DWConv, [1024, 3, 2, 1, False]] # 11-P4/32
|
||||
- [-1, 6, HGBlock, [512, 2048, 5, True, False]]
|
||||
- [-1, 6, HGBlock, [512, 2048, 5, True, True]] # 13-stage 4
|
||||
|
||||
head:
|
||||
- [-1, 1, Conv, [384, 1, 1, None, 1, 1, False]] # 14 input_proj.2
|
||||
- [-1, 1, AIFI, [2048, 8]]
|
||||
- [-1, 1, Conv, [384, 1, 1]] # 16, Y5, lateral_convs.0
|
||||
|
||||
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
|
||||
- [10, 1, Conv, [384, 1, 1, None, 1, 1, False]] # 18 input_proj.1
|
||||
- [[-2, -1], 1, Concat, [1]]
|
||||
- [-1, 3, RepC3, [384]] # 20, fpn_blocks.0
|
||||
- [-1, 1, Conv, [384, 1, 1]] # 21, Y4, lateral_convs.1
|
||||
|
||||
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
|
||||
- [4, 1, Conv, [384, 1, 1, None, 1, 1, False]] # 23 input_proj.0
|
||||
- [[-2, -1], 1, Concat, [1]] # cat backbone P4
|
||||
- [-1, 3, RepC3, [384]] # X3 (25), fpn_blocks.1
|
||||
|
||||
- [-1, 1, Conv, [384, 3, 2]] # 26, downsample_convs.0
|
||||
- [[-1, 21], 1, Concat, [1]] # cat Y4
|
||||
- [-1, 3, RepC3, [384]] # F4 (28), pan_blocks.0
|
||||
|
||||
- [-1, 1, Conv, [384, 3, 2]] # 29, downsample_convs.1
|
||||
- [[-1, 16], 1, Concat, [1]] # cat Y5
|
||||
- [-1, 3, RepC3, [384]] # F5 (31), pan_blocks.1
|
||||
|
||||
- [[25, 28, 31], 1, RTDETRDecoder, [nc]] # Detect(P3, P4, P5)
|
||||
@@ -0,0 +1,42 @@
|
||||
# Ultralytics YOLO 🚀, AGPL-3.0 license
|
||||
# YOLOv10 object detection model. For Usage examples see https://docs.ultralytics.com/tasks/detect
|
||||
|
||||
# Parameters
|
||||
nc: 80 # number of classes
|
||||
scales: # model compound scaling constants, i.e. 'model=yolov10n.yaml' will call yolov10.yaml with scale 'n'
|
||||
# [depth, width, max_channels]
|
||||
b: [0.67, 1.00, 512]
|
||||
|
||||
backbone:
|
||||
# [from, repeats, module, args]
|
||||
- [-1, 1, Conv, [64, 3, 2]] # 0-P1/2
|
||||
- [-1, 1, Conv, [128, 3, 2]] # 1-P2/4
|
||||
- [-1, 3, C2f, [128, True]]
|
||||
- [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
|
||||
- [-1, 6, C2f, [256, True]]
|
||||
- [-1, 1, SCDown, [512, 3, 2]] # 5-P4/16
|
||||
- [-1, 6, C2f, [512, True]]
|
||||
- [-1, 1, SCDown, [1024, 3, 2]] # 7-P5/32
|
||||
- [-1, 3, C2fCIB, [1024, True]]
|
||||
- [-1, 1, SPPF, [1024, 5]] # 9
|
||||
- [-1, 1, PSA, [1024]] # 10
|
||||
|
||||
# YOLOv10.0n head
|
||||
head:
|
||||
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
|
||||
- [[-1, 6], 1, Concat, [1]] # cat backbone P4
|
||||
- [-1, 3, C2fCIB, [512, True]] # 13
|
||||
|
||||
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
|
||||
- [[-1, 4], 1, Concat, [1]] # cat backbone P3
|
||||
- [-1, 3, C2f, [256]] # 16 (P3/8-small)
|
||||
|
||||
- [-1, 1, Conv, [256, 3, 2]]
|
||||
- [[-1, 13], 1, Concat, [1]] # cat head P4
|
||||
- [-1, 3, C2fCIB, [512, True]] # 19 (P4/16-medium)
|
||||
|
||||
- [-1, 1, SCDown, [512, 3, 2]]
|
||||
- [[-1, 10], 1, Concat, [1]] # cat head P5
|
||||
- [-1, 3, C2fCIB, [1024, True]] # 22 (P5/32-large)
|
||||
|
||||
- [[16, 19, 22], 1, v10Detect, [nc]] # Detect(P3, P4, P5)
|
||||
@@ -0,0 +1,42 @@
|
||||
# Ultralytics YOLO 🚀, AGPL-3.0 license
|
||||
# YOLOv10 object detection model. For Usage examples see https://docs.ultralytics.com/tasks/detect
|
||||
|
||||
# Parameters
|
||||
nc: 80 # number of classes
|
||||
scales: # model compound scaling constants, i.e. 'model=yolov10n.yaml' will call yolov10.yaml with scale 'n'
|
||||
# [depth, width, max_channels]
|
||||
l: [1.00, 1.00, 512]
|
||||
|
||||
backbone:
|
||||
# [from, repeats, module, args]
|
||||
- [-1, 1, Conv, [64, 3, 2]] # 0-P1/2
|
||||
- [-1, 1, Conv, [128, 3, 2]] # 1-P2/4
|
||||
- [-1, 3, C2f, [128, True]]
|
||||
- [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
|
||||
- [-1, 6, C2f, [256, True]]
|
||||
- [-1, 1, SCDown, [512, 3, 2]] # 5-P4/16
|
||||
- [-1, 6, C2f, [512, True]]
|
||||
- [-1, 1, SCDown, [1024, 3, 2]] # 7-P5/32
|
||||
- [-1, 3, C2fCIB, [1024, True]]
|
||||
- [-1, 1, SPPF, [1024, 5]] # 9
|
||||
- [-1, 1, PSA, [1024]] # 10
|
||||
|
||||
# YOLOv10.0n head
|
||||
head:
|
||||
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
|
||||
- [[-1, 6], 1, Concat, [1]] # cat backbone P4
|
||||
- [-1, 3, C2fCIB, [512, True]] # 13
|
||||
|
||||
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
|
||||
- [[-1, 4], 1, Concat, [1]] # cat backbone P3
|
||||
- [-1, 3, C2f, [256]] # 16 (P3/8-small)
|
||||
|
||||
- [-1, 1, Conv, [256, 3, 2]]
|
||||
- [[-1, 13], 1, Concat, [1]] # cat head P4
|
||||
- [-1, 3, C2fCIB, [512, True]] # 19 (P4/16-medium)
|
||||
|
||||
- [-1, 1, SCDown, [512, 3, 2]]
|
||||
- [[-1, 10], 1, Concat, [1]] # cat head P5
|
||||
- [-1, 3, C2fCIB, [1024, True]] # 22 (P5/32-large)
|
||||
|
||||
- [[16, 19, 22], 1, v10Detect, [nc]] # Detect(P3, P4, P5)
|
||||
@@ -0,0 +1,42 @@
|
||||
# Ultralytics YOLO 🚀, AGPL-3.0 license
|
||||
# YOLOv10 object detection model. For Usage examples see https://docs.ultralytics.com/tasks/detect
|
||||
|
||||
# Parameters
|
||||
nc: 80 # number of classes
|
||||
scales: # model compound scaling constants, i.e. 'model=yolov10n.yaml' will call yolov10.yaml with scale 'n'
|
||||
# [depth, width, max_channels]
|
||||
m: [0.67, 0.75, 768]
|
||||
|
||||
backbone:
|
||||
# [from, repeats, module, args]
|
||||
- [-1, 1, Conv, [64, 3, 2]] # 0-P1/2
|
||||
- [-1, 1, Conv, [128, 3, 2]] # 1-P2/4
|
||||
- [-1, 3, C2f, [128, True]]
|
||||
- [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
|
||||
- [-1, 6, C2f, [256, True]]
|
||||
- [-1, 1, SCDown, [512, 3, 2]] # 5-P4/16
|
||||
- [-1, 6, C2f, [512, True]]
|
||||
- [-1, 1, SCDown, [1024, 3, 2]] # 7-P5/32
|
||||
- [-1, 3, C2fCIB, [1024, True]]
|
||||
- [-1, 1, SPPF, [1024, 5]] # 9
|
||||
- [-1, 1, PSA, [1024]] # 10
|
||||
|
||||
# YOLOv10.0n head
|
||||
head:
|
||||
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
|
||||
- [[-1, 6], 1, Concat, [1]] # cat backbone P4
|
||||
- [-1, 3, C2f, [512]] # 13
|
||||
|
||||
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
|
||||
- [[-1, 4], 1, Concat, [1]] # cat backbone P3
|
||||
- [-1, 3, C2f, [256]] # 16 (P3/8-small)
|
||||
|
||||
- [-1, 1, Conv, [256, 3, 2]]
|
||||
- [[-1, 13], 1, Concat, [1]] # cat head P4
|
||||
- [-1, 3, C2fCIB, [512, True]] # 19 (P4/16-medium)
|
||||
|
||||
- [-1, 1, SCDown, [512, 3, 2]]
|
||||
- [[-1, 10], 1, Concat, [1]] # cat head P5
|
||||
- [-1, 3, C2fCIB, [1024, True]] # 22 (P5/32-large)
|
||||
|
||||
- [[16, 19, 22], 1, v10Detect, [nc]] # Detect(P3, P4, P5)
|
||||
@@ -0,0 +1,42 @@
|
||||
# Ultralytics YOLO 🚀, AGPL-3.0 license
|
||||
# YOLOv10 object detection model. For Usage examples see https://docs.ultralytics.com/tasks/detect
|
||||
|
||||
# Parameters
|
||||
nc: 80 # number of classes
|
||||
scales: # model compound scaling constants, i.e. 'model=yolov10n.yaml' will call yolov10.yaml with scale 'n'
|
||||
# [depth, width, max_channels]
|
||||
n: [0.33, 0.25, 1024]
|
||||
|
||||
backbone:
|
||||
# [from, repeats, module, args]
|
||||
- [-1, 1, Conv, [64, 3, 2]] # 0-P1/2
|
||||
- [-1, 1, Conv, [128, 3, 2]] # 1-P2/4
|
||||
- [-1, 3, C2f, [128, True]]
|
||||
- [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
|
||||
- [-1, 6, C2f, [256, True]]
|
||||
- [-1, 1, SCDown, [512, 3, 2]] # 5-P4/16
|
||||
- [-1, 6, C2f, [512, True]]
|
||||
- [-1, 1, SCDown, [1024, 3, 2]] # 7-P5/32
|
||||
- [-1, 3, C2f, [1024, True]]
|
||||
- [-1, 1, SPPF, [1024, 5]] # 9
|
||||
- [-1, 1, PSA, [1024]] # 10
|
||||
|
||||
# YOLOv10.0n head
|
||||
head:
|
||||
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
|
||||
- [[-1, 6], 1, Concat, [1]] # cat backbone P4
|
||||
- [-1, 3, C2f, [512]] # 13
|
||||
|
||||
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
|
||||
- [[-1, 4], 1, Concat, [1]] # cat backbone P3
|
||||
- [-1, 3, C2f, [256]] # 16 (P3/8-small)
|
||||
|
||||
- [-1, 1, Conv, [256, 3, 2]]
|
||||
- [[-1, 13], 1, Concat, [1]] # cat head P4
|
||||
- [-1, 3, C2f, [512]] # 19 (P4/16-medium)
|
||||
|
||||
- [-1, 1, SCDown, [512, 3, 2]]
|
||||
- [[-1, 10], 1, Concat, [1]] # cat head P5
|
||||
- [-1, 3, C2fCIB, [1024, True, True]] # 22 (P5/32-large)
|
||||
|
||||
- [[16, 19, 22], 1, v10Detect, [nc]] # Detect(P3, P4, P5)
|
||||
@@ -0,0 +1,42 @@
|
||||
# Ultralytics YOLO 🚀, AGPL-3.0 license
|
||||
# YOLOv10 object detection model. For Usage examples see https://docs.ultralytics.com/tasks/detect
|
||||
|
||||
# Parameters
|
||||
nc: 80 # number of classes
|
||||
scales: # model compound scaling constants, i.e. 'model=yolov10n.yaml' will call yolov10.yaml with scale 'n'
|
||||
# [depth, width, max_channels]
|
||||
s: [0.33, 0.50, 1024]
|
||||
|
||||
backbone:
|
||||
# [from, repeats, module, args]
|
||||
- [-1, 1, Conv, [64, 3, 2]] # 0-P1/2
|
||||
- [-1, 1, Conv, [128, 3, 2]] # 1-P2/4
|
||||
- [-1, 3, C2f, [128, True]]
|
||||
- [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
|
||||
- [-1, 6, C2f, [256, True]]
|
||||
- [-1, 1, SCDown, [512, 3, 2]] # 5-P4/16
|
||||
- [-1, 6, C2f, [512, True]]
|
||||
- [-1, 1, SCDown, [1024, 3, 2]] # 7-P5/32
|
||||
- [-1, 3, C2fCIB, [1024, True, True]]
|
||||
- [-1, 1, SPPF, [1024, 5]] # 9
|
||||
- [-1, 1, PSA, [1024]] # 10
|
||||
|
||||
# YOLOv10.0n head
|
||||
head:
|
||||
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
|
||||
- [[-1, 6], 1, Concat, [1]] # cat backbone P4
|
||||
- [-1, 3, C2f, [512]] # 13
|
||||
|
||||
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
|
||||
- [[-1, 4], 1, Concat, [1]] # cat backbone P3
|
||||
- [-1, 3, C2f, [256]] # 16 (P3/8-small)
|
||||
|
||||
- [-1, 1, Conv, [256, 3, 2]]
|
||||
- [[-1, 13], 1, Concat, [1]] # cat head P4
|
||||
- [-1, 3, C2f, [512]] # 19 (P4/16-medium)
|
||||
|
||||
- [-1, 1, SCDown, [512, 3, 2]]
|
||||
- [[-1, 10], 1, Concat, [1]] # cat head P5
|
||||
- [-1, 3, C2fCIB, [1024, True, True]] # 22 (P5/32-large)
|
||||
|
||||
- [[16, 19, 22], 1, v10Detect, [nc]] # Detect(P3, P4, P5)
|
||||
@@ -0,0 +1,42 @@
|
||||
# Ultralytics YOLO 🚀, AGPL-3.0 license
|
||||
# YOLOv10 object detection model. For Usage examples see https://docs.ultralytics.com/tasks/detect
|
||||
|
||||
# Parameters
|
||||
nc: 80 # number of classes
|
||||
scales: # model compound scaling constants, i.e. 'model=yolov10n.yaml' will call yolov10.yaml with scale 'n'
|
||||
# [depth, width, max_channels]
|
||||
x: [1.00, 1.25, 512]
|
||||
|
||||
backbone:
|
||||
# [from, repeats, module, args]
|
||||
- [-1, 1, Conv, [64, 3, 2]] # 0-P1/2
|
||||
- [-1, 1, Conv, [128, 3, 2]] # 1-P2/4
|
||||
- [-1, 3, C2f, [128, True]]
|
||||
- [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
|
||||
- [-1, 6, C2f, [256, True]]
|
||||
- [-1, 1, SCDown, [512, 3, 2]] # 5-P4/16
|
||||
- [-1, 6, C2fCIB, [512, True]]
|
||||
- [-1, 1, SCDown, [1024, 3, 2]] # 7-P5/32
|
||||
- [-1, 3, C2fCIB, [1024, True]]
|
||||
- [-1, 1, SPPF, [1024, 5]] # 9
|
||||
- [-1, 1, PSA, [1024]] # 10
|
||||
|
||||
# YOLOv10.0n head
|
||||
head:
|
||||
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
|
||||
- [[-1, 6], 1, Concat, [1]] # cat backbone P4
|
||||
- [-1, 3, C2fCIB, [512, True]] # 13
|
||||
|
||||
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
|
||||
- [[-1, 4], 1, Concat, [1]] # cat backbone P3
|
||||
- [-1, 3, C2f, [256]] # 16 (P3/8-small)
|
||||
|
||||
- [-1, 1, Conv, [256, 3, 2]]
|
||||
- [[-1, 13], 1, Concat, [1]] # cat head P4
|
||||
- [-1, 3, C2fCIB, [512, True]] # 19 (P4/16-medium)
|
||||
|
||||
- [-1, 1, SCDown, [512, 3, 2]]
|
||||
- [[-1, 10], 1, Concat, [1]] # cat head P5
|
||||
- [-1, 3, C2fCIB, [1024, True]] # 22 (P5/32-large)
|
||||
|
||||
- [[16, 19, 22], 1, v10Detect, [nc]] # Detect(P3, P4, P5)
|
||||
@@ -0,0 +1,46 @@
|
||||
# Ultralytics YOLO 🚀, AGPL-3.0 license
|
||||
# YOLOv3-SPP object detection model with P3-P5 outputs. For details see https://docs.ultralytics.com/models/yolov3
|
||||
|
||||
# Parameters
|
||||
nc: 80 # number of classes
|
||||
depth_multiple: 1.0 # model depth multiple
|
||||
width_multiple: 1.0 # layer channel multiple
|
||||
|
||||
# darknet53 backbone
|
||||
backbone:
|
||||
# [from, number, module, args]
|
||||
- [-1, 1, Conv, [32, 3, 1]] # 0
|
||||
- [-1, 1, Conv, [64, 3, 2]] # 1-P1/2
|
||||
- [-1, 1, Bottleneck, [64]]
|
||||
- [-1, 1, Conv, [128, 3, 2]] # 3-P2/4
|
||||
- [-1, 2, Bottleneck, [128]]
|
||||
- [-1, 1, Conv, [256, 3, 2]] # 5-P3/8
|
||||
- [-1, 8, Bottleneck, [256]]
|
||||
- [-1, 1, Conv, [512, 3, 2]] # 7-P4/16
|
||||
- [-1, 8, Bottleneck, [512]]
|
||||
- [-1, 1, Conv, [1024, 3, 2]] # 9-P5/32
|
||||
- [-1, 4, Bottleneck, [1024]] # 10
|
||||
|
||||
# YOLOv3-SPP head
|
||||
head:
|
||||
- [-1, 1, Bottleneck, [1024, False]]
|
||||
- [-1, 1, SPP, [512, [5, 9, 13]]]
|
||||
- [-1, 1, Conv, [1024, 3, 1]]
|
||||
- [-1, 1, Conv, [512, 1, 1]]
|
||||
- [-1, 1, Conv, [1024, 3, 1]] # 15 (P5/32-large)
|
||||
|
||||
- [-2, 1, Conv, [256, 1, 1]]
|
||||
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
|
||||
- [[-1, 8], 1, Concat, [1]] # cat backbone P4
|
||||
- [-1, 1, Bottleneck, [512, False]]
|
||||
- [-1, 1, Bottleneck, [512, False]]
|
||||
- [-1, 1, Conv, [256, 1, 1]]
|
||||
- [-1, 1, Conv, [512, 3, 1]] # 22 (P4/16-medium)
|
||||
|
||||
- [-2, 1, Conv, [128, 1, 1]]
|
||||
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
|
||||
- [[-1, 6], 1, Concat, [1]] # cat backbone P3
|
||||
- [-1, 1, Bottleneck, [256, False]]
|
||||
- [-1, 2, Bottleneck, [256, False]] # 27 (P3/8-small)
|
||||
|
||||
- [[27, 22, 15], 1, Detect, [nc]] # Detect(P3, P4, P5)
|
||||
@@ -0,0 +1,37 @@
|
||||
# Ultralytics YOLO 🚀, AGPL-3.0 license
|
||||
# YOLOv3-tiny object detection model with P4-P5 outputs. For details see https://docs.ultralytics.com/models/yolov3
|
||||
|
||||
# Parameters
|
||||
nc: 80 # number of classes
|
||||
depth_multiple: 1.0 # model depth multiple
|
||||
width_multiple: 1.0 # layer channel multiple
|
||||
|
||||
# YOLOv3-tiny backbone
|
||||
backbone:
|
||||
# [from, number, module, args]
|
||||
- [-1, 1, Conv, [16, 3, 1]] # 0
|
||||
- [-1, 1, nn.MaxPool2d, [2, 2, 0]] # 1-P1/2
|
||||
- [-1, 1, Conv, [32, 3, 1]]
|
||||
- [-1, 1, nn.MaxPool2d, [2, 2, 0]] # 3-P2/4
|
||||
- [-1, 1, Conv, [64, 3, 1]]
|
||||
- [-1, 1, nn.MaxPool2d, [2, 2, 0]] # 5-P3/8
|
||||
- [-1, 1, Conv, [128, 3, 1]]
|
||||
- [-1, 1, nn.MaxPool2d, [2, 2, 0]] # 7-P4/16
|
||||
- [-1, 1, Conv, [256, 3, 1]]
|
||||
- [-1, 1, nn.MaxPool2d, [2, 2, 0]] # 9-P5/32
|
||||
- [-1, 1, Conv, [512, 3, 1]]
|
||||
- [-1, 1, nn.ZeroPad2d, [[0, 1, 0, 1]]] # 11
|
||||
- [-1, 1, nn.MaxPool2d, [2, 1, 0]] # 12
|
||||
|
||||
# YOLOv3-tiny head
|
||||
head:
|
||||
- [-1, 1, Conv, [1024, 3, 1]]
|
||||
- [-1, 1, Conv, [256, 1, 1]]
|
||||
- [-1, 1, Conv, [512, 3, 1]] # 15 (P5/32-large)
|
||||
|
||||
- [-2, 1, Conv, [128, 1, 1]]
|
||||
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
|
||||
- [[-1, 8], 1, Concat, [1]] # cat backbone P4
|
||||
- [-1, 1, Conv, [256, 3, 1]] # 19 (P4/16-medium)
|
||||
|
||||
- [[19, 15], 1, Detect, [nc]] # Detect(P4, P5)
|
||||
@@ -0,0 +1,46 @@
|
||||
# Ultralytics YOLO 🚀, AGPL-3.0 license
|
||||
# YOLOv3 object detection model with P3-P5 outputs. For details see https://docs.ultralytics.com/models/yolov3
|
||||
|
||||
# Parameters
|
||||
nc: 80 # number of classes
|
||||
depth_multiple: 1.0 # model depth multiple
|
||||
width_multiple: 1.0 # layer channel multiple
|
||||
|
||||
# darknet53 backbone
|
||||
backbone:
|
||||
# [from, number, module, args]
|
||||
- [-1, 1, Conv, [32, 3, 1]] # 0
|
||||
- [-1, 1, Conv, [64, 3, 2]] # 1-P1/2
|
||||
- [-1, 1, Bottleneck, [64]]
|
||||
- [-1, 1, Conv, [128, 3, 2]] # 3-P2/4
|
||||
- [-1, 2, Bottleneck, [128]]
|
||||
- [-1, 1, Conv, [256, 3, 2]] # 5-P3/8
|
||||
- [-1, 8, Bottleneck, [256]]
|
||||
- [-1, 1, Conv, [512, 3, 2]] # 7-P4/16
|
||||
- [-1, 8, Bottleneck, [512]]
|
||||
- [-1, 1, Conv, [1024, 3, 2]] # 9-P5/32
|
||||
- [-1, 4, Bottleneck, [1024]] # 10
|
||||
|
||||
# YOLOv3 head
|
||||
head:
|
||||
- [-1, 1, Bottleneck, [1024, False]]
|
||||
- [-1, 1, Conv, [512, 1, 1]]
|
||||
- [-1, 1, Conv, [1024, 3, 1]]
|
||||
- [-1, 1, Conv, [512, 1, 1]]
|
||||
- [-1, 1, Conv, [1024, 3, 1]] # 15 (P5/32-large)
|
||||
|
||||
- [-2, 1, Conv, [256, 1, 1]]
|
||||
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
|
||||
- [[-1, 8], 1, Concat, [1]] # cat backbone P4
|
||||
- [-1, 1, Bottleneck, [512, False]]
|
||||
- [-1, 1, Bottleneck, [512, False]]
|
||||
- [-1, 1, Conv, [256, 1, 1]]
|
||||
- [-1, 1, Conv, [512, 3, 1]] # 22 (P4/16-medium)
|
||||
|
||||
- [-2, 1, Conv, [128, 1, 1]]
|
||||
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
|
||||
- [[-1, 6], 1, Concat, [1]] # cat backbone P3
|
||||
- [-1, 1, Bottleneck, [256, False]]
|
||||
- [-1, 2, Bottleneck, [256, False]] # 27 (P3/8-small)
|
||||
|
||||
- [[27, 22, 15], 1, Detect, [nc]] # Detect(P3, P4, P5)
|
||||
@@ -0,0 +1,59 @@
|
||||
# Ultralytics YOLO 🚀, AGPL-3.0 license
|
||||
# YOLOv5 object detection model with P3-P6 outputs. For details see https://docs.ultralytics.com/models/yolov5
|
||||
|
||||
# Parameters
|
||||
nc: 80 # number of classes
|
||||
scales: # model compound scaling constants, i.e. 'model=yolov5n-p6.yaml' will call yolov5-p6.yaml with scale 'n'
|
||||
# [depth, width, max_channels]
|
||||
n: [0.33, 0.25, 1024]
|
||||
s: [0.33, 0.50, 1024]
|
||||
m: [0.67, 0.75, 1024]
|
||||
l: [1.00, 1.00, 1024]
|
||||
x: [1.33, 1.25, 1024]
|
||||
|
||||
# YOLOv5 v6.0 backbone
|
||||
backbone:
|
||||
# [from, number, module, args]
|
||||
- [-1, 1, Conv, [64, 6, 2, 2]] # 0-P1/2
|
||||
- [-1, 1, Conv, [128, 3, 2]] # 1-P2/4
|
||||
- [-1, 3, C3, [128]]
|
||||
- [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
|
||||
- [-1, 6, C3, [256]]
|
||||
- [-1, 1, Conv, [512, 3, 2]] # 5-P4/16
|
||||
- [-1, 9, C3, [512]]
|
||||
- [-1, 1, Conv, [768, 3, 2]] # 7-P5/32
|
||||
- [-1, 3, C3, [768]]
|
||||
- [-1, 1, Conv, [1024, 3, 2]] # 9-P6/64
|
||||
- [-1, 3, C3, [1024]]
|
||||
- [-1, 1, SPPF, [1024, 5]] # 11
|
||||
|
||||
# YOLOv5 v6.0 head
|
||||
head:
|
||||
- [-1, 1, Conv, [768, 1, 1]]
|
||||
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
|
||||
- [[-1, 8], 1, Concat, [1]] # cat backbone P5
|
||||
- [-1, 3, C3, [768, False]] # 15
|
||||
|
||||
- [-1, 1, Conv, [512, 1, 1]]
|
||||
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
|
||||
- [[-1, 6], 1, Concat, [1]] # cat backbone P4
|
||||
- [-1, 3, C3, [512, False]] # 19
|
||||
|
||||
- [-1, 1, Conv, [256, 1, 1]]
|
||||
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
|
||||
- [[-1, 4], 1, Concat, [1]] # cat backbone P3
|
||||
- [-1, 3, C3, [256, False]] # 23 (P3/8-small)
|
||||
|
||||
- [-1, 1, Conv, [256, 3, 2]]
|
||||
- [[-1, 20], 1, Concat, [1]] # cat head P4
|
||||
- [-1, 3, C3, [512, False]] # 26 (P4/16-medium)
|
||||
|
||||
- [-1, 1, Conv, [512, 3, 2]]
|
||||
- [[-1, 16], 1, Concat, [1]] # cat head P5
|
||||
- [-1, 3, C3, [768, False]] # 29 (P5/32-large)
|
||||
|
||||
- [-1, 1, Conv, [768, 3, 2]]
|
||||
- [[-1, 12], 1, Concat, [1]] # cat head P6
|
||||
- [-1, 3, C3, [1024, False]] # 32 (P6/64-xlarge)
|
||||
|
||||
- [[23, 26, 29, 32], 1, Detect, [nc]] # Detect(P3, P4, P5, P6)
|
||||
@@ -0,0 +1,48 @@
|
||||
# Ultralytics YOLO 🚀, AGPL-3.0 license
|
||||
# YOLOv5 object detection model with P3-P5 outputs. For details see https://docs.ultralytics.com/models/yolov5
|
||||
|
||||
# Parameters
|
||||
nc: 80 # number of classes
|
||||
scales: # model compound scaling constants, i.e. 'model=yolov5n.yaml' will call yolov5.yaml with scale 'n'
|
||||
# [depth, width, max_channels]
|
||||
n: [0.33, 0.25, 1024]
|
||||
s: [0.33, 0.50, 1024]
|
||||
m: [0.67, 0.75, 1024]
|
||||
l: [1.00, 1.00, 1024]
|
||||
x: [1.33, 1.25, 1024]
|
||||
|
||||
# YOLOv5 v6.0 backbone
|
||||
backbone:
|
||||
# [from, number, module, args]
|
||||
- [-1, 1, Conv, [64, 6, 2, 2]] # 0-P1/2
|
||||
- [-1, 1, Conv, [128, 3, 2]] # 1-P2/4
|
||||
- [-1, 3, C3, [128]]
|
||||
- [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
|
||||
- [-1, 6, C3, [256]]
|
||||
- [-1, 1, Conv, [512, 3, 2]] # 5-P4/16
|
||||
- [-1, 9, C3, [512]]
|
||||
- [-1, 1, Conv, [1024, 3, 2]] # 7-P5/32
|
||||
- [-1, 3, C3, [1024]]
|
||||
- [-1, 1, SPPF, [1024, 5]] # 9
|
||||
|
||||
# YOLOv5 v6.0 head
|
||||
head:
|
||||
- [-1, 1, Conv, [512, 1, 1]]
|
||||
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
|
||||
- [[-1, 6], 1, Concat, [1]] # cat backbone P4
|
||||
- [-1, 3, C3, [512, False]] # 13
|
||||
|
||||
- [-1, 1, Conv, [256, 1, 1]]
|
||||
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
|
||||
- [[-1, 4], 1, Concat, [1]] # cat backbone P3
|
||||
- [-1, 3, C3, [256, False]] # 17 (P3/8-small)
|
||||
|
||||
- [-1, 1, Conv, [256, 3, 2]]
|
||||
- [[-1, 14], 1, Concat, [1]] # cat head P4
|
||||
- [-1, 3, C3, [512, False]] # 20 (P4/16-medium)
|
||||
|
||||
- [-1, 1, Conv, [512, 3, 2]]
|
||||
- [[-1, 10], 1, Concat, [1]] # cat head P5
|
||||
- [-1, 3, C3, [1024, False]] # 23 (P5/32-large)
|
||||
|
||||
- [[17, 20, 23], 1, Detect, [nc]] # Detect(P3, P4, P5)
|
||||
@@ -0,0 +1,53 @@
|
||||
# Ultralytics YOLO 🚀, AGPL-3.0 license
|
||||
# YOLOv6 object detection model with P3-P5 outputs. For Usage examples see https://docs.ultralytics.com/models/yolov6
|
||||
|
||||
# Parameters
|
||||
nc: 80 # number of classes
|
||||
activation: nn.ReLU() # (optional) model default activation function
|
||||
scales: # model compound scaling constants, i.e. 'model=yolov6n.yaml' will call yolov8.yaml with scale 'n'
|
||||
# [depth, width, max_channels]
|
||||
n: [0.33, 0.25, 1024]
|
||||
s: [0.33, 0.50, 1024]
|
||||
m: [0.67, 0.75, 768]
|
||||
l: [1.00, 1.00, 512]
|
||||
x: [1.00, 1.25, 512]
|
||||
|
||||
# YOLOv6-3.0s backbone
|
||||
backbone:
|
||||
# [from, repeats, module, args]
|
||||
- [-1, 1, Conv, [64, 3, 2]] # 0-P1/2
|
||||
- [-1, 1, Conv, [128, 3, 2]] # 1-P2/4
|
||||
- [-1, 6, Conv, [128, 3, 1]]
|
||||
- [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
|
||||
- [-1, 12, Conv, [256, 3, 1]]
|
||||
- [-1, 1, Conv, [512, 3, 2]] # 5-P4/16
|
||||
- [-1, 18, Conv, [512, 3, 1]]
|
||||
- [-1, 1, Conv, [1024, 3, 2]] # 7-P5/32
|
||||
- [-1, 6, Conv, [1024, 3, 1]]
|
||||
- [-1, 1, SPPF, [1024, 5]] # 9
|
||||
|
||||
# YOLOv6-3.0s head
|
||||
head:
|
||||
- [-1, 1, Conv, [256, 1, 1]]
|
||||
- [-1, 1, nn.ConvTranspose2d, [256, 2, 2, 0]]
|
||||
- [[-1, 6], 1, Concat, [1]] # cat backbone P4
|
||||
- [-1, 1, Conv, [256, 3, 1]]
|
||||
- [-1, 9, Conv, [256, 3, 1]] # 14
|
||||
|
||||
- [-1, 1, Conv, [128, 1, 1]]
|
||||
- [-1, 1, nn.ConvTranspose2d, [128, 2, 2, 0]]
|
||||
- [[-1, 4], 1, Concat, [1]] # cat backbone P3
|
||||
- [-1, 1, Conv, [128, 3, 1]]
|
||||
- [-1, 9, Conv, [128, 3, 1]] # 19
|
||||
|
||||
- [-1, 1, Conv, [128, 3, 2]]
|
||||
- [[-1, 15], 1, Concat, [1]] # cat head P4
|
||||
- [-1, 1, Conv, [256, 3, 1]]
|
||||
- [-1, 9, Conv, [256, 3, 1]] # 23
|
||||
|
||||
- [-1, 1, Conv, [256, 3, 2]]
|
||||
- [[-1, 10], 1, Concat, [1]] # cat head P5
|
||||
- [-1, 1, Conv, [512, 3, 1]]
|
||||
- [-1, 9, Conv, [512, 3, 1]] # 27
|
||||
|
||||
- [[19, 23, 27], 1, Detect, [nc]] # Detect(P3, P4, P5)
|
||||
@@ -0,0 +1,62 @@
|
||||
# Ultralytics YOLO 🚀, AGPL-3.0 license
|
||||
# YOLOv8 object detection model with P3-P5 outputs. For Usage examples see https://docs.ultralytics.com/tasks/detect
|
||||
|
||||
# Parameters
|
||||
nc: 80 # number of classes
|
||||
scales: # model compound scaling constants, i.e. 'model=yolov8n.yaml' will call yolov8.yaml with scale 'n'
|
||||
# [depth, width, max_channels]
|
||||
n: [0.33, 0.25, 1024] # YOLOv8n summary: 225 layers, 3157200 parameters, 3157184 gradients, 8.9 GFLOPs
|
||||
s: [0.33, 0.50, 1024] # YOLOv8s summary: 225 layers, 11166560 parameters, 11166544 gradients, 28.8 GFLOPs
|
||||
m: [0.67, 0.75, 768] # YOLOv8m summary: 295 layers, 25902640 parameters, 25902624 gradients, 79.3 GFLOPs
|
||||
l: [1.00, 1.00, 512] # YOLOv8l summary: 365 layers, 43691520 parameters, 43691504 gradients, 165.7 GFLOPs
|
||||
x: [1.00, 1.25, 512] # YOLOv8x summary: 365 layers, 68229648 parameters, 68229632 gradients, 258.5 GFLOPs
|
||||
|
||||
# YOLOv8.0n backbone
|
||||
backbone:
|
||||
# [from, repeats, module, args]
|
||||
- [-1, 1, Conv, [64, 3, 2]] # 0-P1/2
|
||||
- [-1, 1, Conv, [128, 3, 2]] # 1-P2/4
|
||||
- [-1, 3, C2f, [128, True]]
|
||||
- [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
|
||||
- [-1, 6, C2f, [256, True]]
|
||||
- [-1, 1, Conv, [512, 3, 2]] # 5-P4/16
|
||||
- [-1, 6, C2f, [512, True]]
|
||||
- [-1, 1, Conv, [1024, 3, 2]] # 7-P5/32
|
||||
- [-1, 3, C2f, [1024, True]]
|
||||
- [-1, 1, SPPF, [1024, 5]] # 9
|
||||
|
||||
- [-31, 1, Conv, [64, 3, 2]] # 10-P1/2
|
||||
- [-1, 1, Conv, [128, 3, 2]] # 11-P2/4
|
||||
- [-1, 3, C2f, [128, True]]
|
||||
- [-1, 1, Conv, [256, 3, 2]] # 13-P3/8
|
||||
- [-1, 6, C2f, [256, True]]
|
||||
- [-1, 1, Conv, [512, 3, 2]] # 15-P4/16
|
||||
- [-1, 6, C2f, [512, True]]
|
||||
- [-1, 1, Conv, [1024, 3, 2]] # 17-P5/32
|
||||
- [-1, 3, C2f, [1024, True]]
|
||||
- [-1, 1, SPPF, [1024, 5]] # 19
|
||||
|
||||
######### Fuse Block #############
|
||||
- [[4,14], 1, Add, [1]] # 20 two stream fuse
|
||||
- [[6,16], 1, Add, [1]] # 21 two stream fuse
|
||||
- [[9,19], 1, Add, [1]] # 22 two stream fuse
|
||||
|
||||
# YOLOv8.0n head
|
||||
head:
|
||||
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
|
||||
- [[-1, 21], 1, Concat, [1]] # cat backbone P4
|
||||
- [-1, 3, C2f, [512]] # 25
|
||||
|
||||
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
|
||||
- [[-1, 20], 1, Concat, [1]] # cat backbone P3
|
||||
- [-1, 3, C2f, [256]] # 28 (P3/8-small)
|
||||
|
||||
- [-1, 1, Conv, [256, 3, 2]]
|
||||
- [[-1, 25], 1, Concat, [1]] # cat head P4
|
||||
- [-1, 3, C2f, [512]] # 31 (P4/16-medium)
|
||||
|
||||
- [-1, 1, Conv, [512, 3, 2]]
|
||||
- [[-1, 22], 1, Concat, [1]] # cat head P5
|
||||
- [-1, 3, C2f, [1024]] # 34 (P5/32-large)
|
||||
|
||||
- [[28, 31, 34], 1, Detect, [nc]] # Detect(P3, P4, P5)
|
||||
@@ -0,0 +1,62 @@
|
||||
# Ultralytics YOLO 🚀, AGPL-3.0 license
|
||||
# YOLOv8 object detection model with P3-P5 outputs. For Usage examples see https://docs.ultralytics.com/tasks/detect
|
||||
|
||||
# Parameters
|
||||
nc: 80 # number of classes
|
||||
scales: # model compound scaling constants, i.e. 'model=yolov8n.yaml' will call yolov8.yaml with scale 'n'
|
||||
# [depth, width, max_channels]
|
||||
n: [0.33, 0.25, 1024] # YOLOv8n summary: 225 layers, 3157200 parameters, 3157184 gradients, 8.9 GFLOPs
|
||||
s: [0.33, 0.50, 1024] # YOLOv8s summary: 225 layers, 11166560 parameters, 11166544 gradients, 28.8 GFLOPs
|
||||
m: [0.67, 0.75, 768] # YOLOv8m summary: 295 layers, 25902640 parameters, 25902624 gradients, 79.3 GFLOPs
|
||||
l: [1.00, 1.00, 512] # YOLOv8l summary: 365 layers, 43691520 parameters, 43691504 gradients, 165.7 GFLOPs
|
||||
x: [1.00, 1.25, 512] # YOLOv8x summary: 365 layers, 68229648 parameters, 68229632 gradients, 258.5 GFLOPs
|
||||
|
||||
# YOLOv8.0n backbone
|
||||
backbone:
|
||||
# [from, repeats, module, args]
|
||||
- [-1, 1, Conv, [64, 3, 2]] # 0-P1/2
|
||||
- [-1, 1, Conv, [128, 3, 2]] # 1-P2/4
|
||||
- [-1, 3, C2f, [128, True]]
|
||||
- [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
|
||||
- [-1, 6, C2f, [256, True]]
|
||||
- [-1, 1, Conv, [512, 3, 2]] # 5-P4/16
|
||||
- [-1, 6, C2f, [512, True]]
|
||||
- [-1, 1, Conv, [1024, 3, 2]] # 7-P5/32
|
||||
- [-1, 3, C2f, [1024, True]]
|
||||
- [-1, 1, SPPF, [1024, 5]] # 9
|
||||
|
||||
- [-31, 1, ConvMaskAtt, [64, 3, 2]] # 10-P1/2
|
||||
- [-1, 1, Conv, [128, 3, 2]] # 11-P2/4
|
||||
- [-1, 3, C2f, [128, True]]
|
||||
- [-1, 1, Conv, [256, 3, 2]] # 13-P3/8
|
||||
- [-1, 6, C2f, [256, True]]
|
||||
- [-1, 1, Conv, [512, 3, 2]] # 15-P4/16
|
||||
- [-1, 6, C2f, [512, True]]
|
||||
- [-1, 1, Conv, [1024, 3, 2]] # 17-P5/32
|
||||
- [-1, 3, C2f, [1024, True]]
|
||||
- [-1, 1, SPPF, [1024, 5]] # 19
|
||||
|
||||
######### Fuse Block #############
|
||||
- [[4,14], 1, CatConv, [256, 3, 1]] # 20 two stream fuse
|
||||
- [[6,16], 1, CatConv, [512, 3, 1]] # 21 two stream fuse
|
||||
- [[9,19], 1, CatConv, [1024, 3, 1]] # 22 two stream fuse
|
||||
|
||||
# YOLOv8.0n head
|
||||
head:
|
||||
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
|
||||
- [[-1, 21], 1, Concat, [1]] # cat backbone P4
|
||||
- [-1, 3, C2f, [512]] # 25
|
||||
|
||||
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
|
||||
- [[-1, 20], 1, Concat, [1]] # cat backbone P3
|
||||
- [-1, 3, C2f, [256]] # 28 (P3/8-small)
|
||||
|
||||
- [-1, 1, Conv, [256, 3, 2]]
|
||||
- [[-1, 25], 1, Concat, [1]] # cat head P4
|
||||
- [-1, 3, C2f, [512]] # 31 (P4/16-medium)
|
||||
|
||||
- [-1, 1, Conv, [512, 3, 2]]
|
||||
- [[-1, 22], 1, Concat, [1]] # cat head P5
|
||||
- [-1, 3, C2f, [1024]] # 34 (P5/32-large)
|
||||
|
||||
- [[28, 31, 34], 1, Detect, [nc]] # Detect(P3, P4, P5)
|
||||
@@ -0,0 +1,62 @@
|
||||
# Ultralytics YOLO 🚀, AGPL-3.0 license
|
||||
# YOLOv8 object detection model with P3-P5 outputs. For Usage examples see https://docs.ultralytics.com/tasks/detect
|
||||
|
||||
# Parameters
|
||||
nc: 80 # number of classes
|
||||
scales: # model compound scaling constants, i.e. 'model=yolov8n.yaml' will call yolov8.yaml with scale 'n'
|
||||
# [depth, width, max_channels]
|
||||
n: [0.33, 0.25, 1024] # YOLOv8n summary: 225 layers, 3157200 parameters, 3157184 gradients, 8.9 GFLOPs
|
||||
s: [0.33, 0.50, 1024] # YOLOv8s summary: 225 layers, 11166560 parameters, 11166544 gradients, 28.8 GFLOPs
|
||||
m: [0.67, 0.75, 768] # YOLOv8m summary: 295 layers, 25902640 parameters, 25902624 gradients, 79.3 GFLOPs
|
||||
l: [1.00, 1.00, 512] # YOLOv8l summary: 365 layers, 43691520 parameters, 43691504 gradients, 165.7 GFLOPs
|
||||
x: [1.00, 1.25, 512] # YOLOv8x summary: 365 layers, 68229648 parameters, 68229632 gradients, 258.5 GFLOPs
|
||||
|
||||
# YOLOv8.0n backbone
|
||||
backbone:
|
||||
# [from, repeats, module, args]
|
||||
- [-1, 1, Conv, [64, 3, 2]] # 0-P1/2
|
||||
- [-1, 1, Conv, [128, 3, 2]] # 1-P2/4
|
||||
- [-1, 3, C2f, [128, True]]
|
||||
- [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
|
||||
- [-1, 6, C2f, [256, True]]
|
||||
- [-1, 1, Conv, [512, 3, 2]] # 5-P4/16
|
||||
- [-1, 6, C2f, [512, True]]
|
||||
- [-1, 1, Conv, [1024, 3, 2]] # 7-P5/32
|
||||
- [-1, 3, C2f, [1024, True]]
|
||||
- [-1, 1, SPPF, [1024, 5]] # 9
|
||||
|
||||
- [-31, 1, ConvMaskAtt, [64, 3, 2]] # 10-P1/2
|
||||
- [-1, 1, Conv, [128, 3, 2]] # 11-P2/4
|
||||
- [-1, 3, C2f, [128, True]]
|
||||
- [-1, 1, Conv, [256, 3, 2]] # 13-P3/8
|
||||
- [-1, 6, C2f, [256, True]]
|
||||
- [-1, 1, Conv, [512, 3, 2]] # 15-P4/16
|
||||
- [-1, 6, C2f, [512, True]]
|
||||
- [-1, 1, Conv, [1024, 3, 2]] # 17-P5/32
|
||||
- [-1, 3, C2f, [1024, True]]
|
||||
- [-1, 1, SPPF, [1024, 5]] # 19
|
||||
|
||||
######### Fuse Block #############
|
||||
- [[4,14], 1, Add, [256, 3, 1]] # 20 two stream fuse CatConvAtt
|
||||
- [[6,16], 1, CatConvAtt, [512, 3, 1]] # 21 two stream fuse
|
||||
- [[9,19], 1, Add, [1024, 3, 1]] # 22 two stream fuse
|
||||
|
||||
# YOLOv8.0n head
|
||||
head:
|
||||
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
|
||||
- [[-1, 21], 1, Concat, [1]] # cat backbone P4
|
||||
- [-1, 3, C2f, [512]] # 25
|
||||
|
||||
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
|
||||
- [[-1, 20], 1, Concat, [1]] # cat backbone P3
|
||||
- [-1, 3, C2f, [256]] # 28 (P3/8-small)
|
||||
|
||||
- [-1, 1, Conv, [256, 3, 2]]
|
||||
- [[-1, 25], 1, Concat, [1]] # cat head P4
|
||||
- [-1, 3, C2f, [512]] # 31 (P4/16-medium)
|
||||
|
||||
- [-1, 1, Conv, [512, 3, 2]]
|
||||
- [[-1, 22], 1, Concat, [1]] # cat head P5
|
||||
- [-1, 3, C2f, [1024]] # 34 (P5/32-large)
|
||||
|
||||
- [[28, 31, 34], 1, Detect, [nc]] # Detect(P3, P4, P5)
|
||||
@@ -0,0 +1,62 @@
|
||||
# Ultralytics YOLO 🚀, AGPL-3.0 license
|
||||
# YOLOv8 object detection model with P3-P5 outputs. For Usage examples see https://docs.ultralytics.com/tasks/detect
|
||||
|
||||
# Parameters
|
||||
nc: 80 # number of classes
|
||||
scales: # model compound scaling constants, i.e. 'model=yolov8n.yaml' will call yolov8.yaml with scale 'n'
|
||||
# [depth, width, max_channels]
|
||||
n: [0.33, 0.25, 1024] # YOLOv8n summary: 225 layers, 3157200 parameters, 3157184 gradients, 8.9 GFLOPs
|
||||
s: [0.33, 0.50, 1024] # YOLOv8s summary: 225 layers, 11166560 parameters, 11166544 gradients, 28.8 GFLOPs
|
||||
m: [0.67, 0.75, 768] # YOLOv8m summary: 295 layers, 25902640 parameters, 25902624 gradients, 79.3 GFLOPs
|
||||
l: [1.00, 1.00, 512] # YOLOv8l summary: 365 layers, 43691520 parameters, 43691504 gradients, 165.7 GFLOPs
|
||||
x: [1.00, 1.25, 512] # YOLOv8x summary: 365 layers, 68229648 parameters, 68229632 gradients, 258.5 GFLOPs
|
||||
|
||||
# YOLOv8.0n backbone
|
||||
backbone:
|
||||
# [from, repeats, module, args]
|
||||
- [-1, 1, Conv, [64, 3, 2]] # 0-P1/2
|
||||
- [-1, 1, Conv, [128, 3, 2]] # 1-P2/4
|
||||
- [-1, 3, C2f, [128, True]]
|
||||
- [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
|
||||
- [-1, 6, C2f, [256, True]]
|
||||
- [-1, 1, Conv, [512, 3, 2]] # 5-P4/16
|
||||
- [-1, 6, C2f, [512, True]]
|
||||
- [-1, 1, Conv, [1024, 3, 2]] # 7-P5/32
|
||||
- [-1, 3, C2f, [1024, True]]
|
||||
- [-1, 1, SPPF, [1024, 5]] # 9
|
||||
|
||||
- [-31, 1, Conv, [64, 3, 2]] # 10-P1/2
|
||||
- [-1, 1, Conv, [128, 3, 2]] # 11-P2/4
|
||||
- [-1, 3, C2f, [128, True]]
|
||||
- [-1, 1, Conv, [256, 3, 2]] # 13-P3/8
|
||||
- [-1, 6, C2f, [256, True]]
|
||||
- [-1, 1, Conv, [512, 3, 2]] # 15-P4/16
|
||||
- [-1, 6, C2f, [512, True]]
|
||||
- [-1, 1, Conv, [1024, 3, 2]] # 17-P5/32
|
||||
- [-1, 3, C2f, [1024, True]]
|
||||
- [-1, 1, SPPF, [1024, 5]] # 19
|
||||
|
||||
######### Fuse Block #############
|
||||
- [[4,14], 1, Max, [1]] # 20 two stream fuse
|
||||
- [[6,16], 1, Max, [1]] # 21 two stream fuse
|
||||
- [[9,19], 1, Max, [1]] # 22 two stream fuse
|
||||
|
||||
# YOLOv8.0n head
|
||||
head:
|
||||
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
|
||||
- [[-1, 21], 1, Concat, [1]] # cat backbone P4
|
||||
- [-1, 3, C2f, [512]] # 25
|
||||
|
||||
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
|
||||
- [[-1, 20], 1, Concat, [1]] # cat backbone P3
|
||||
- [-1, 3, C2f, [256]] # 28 (P3/8-small)
|
||||
|
||||
- [-1, 1, Conv, [256, 3, 2]]
|
||||
- [[-1, 25], 1, Concat, [1]] # cat head P4
|
||||
- [-1, 3, C2f, [512]] # 31 (P4/16-medium)
|
||||
|
||||
- [-1, 1, Conv, [512, 3, 2]]
|
||||
- [[-1, 22], 1, Concat, [1]] # cat head P5
|
||||
- [-1, 3, C2f, [1024]] # 34 (P5/32-large)
|
||||
|
||||
- [[28, 31, 34], 1, Detect, [nc]] # Detect(P3, P4, P5)
|
||||
@@ -0,0 +1,79 @@
|
||||
# Ultralytics YOLO 🚀, AGPL-3.0 license
|
||||
# YOLOv8 object detection model with P3-P5 outputs. For Usage examples see https://docs.ultralytics.com/tasks/detect
|
||||
|
||||
# Parameters
|
||||
nc: 80 # number of classes
|
||||
scales: # model compound scaling constants, i.e. 'model=yolov8n.yaml' will call yolov8.yaml with scale 'n'
|
||||
# [depth, width, max_channels]
|
||||
n: [0.33, 0.25, 1024] # YOLOv8n summary: 225 layers, 3157200 parameters, 3157184 gradients, 8.9 GFLOPs
|
||||
s: [0.33, 0.50, 1024] # YOLOv8s summary: 225 layers, 11166560 parameters, 11166544 gradients, 28.8 GFLOPs
|
||||
m: [0.67, 0.75, 768] # YOLOv8m summary: 295 layers, 25902640 parameters, 25902624 gradients, 79.3 GFLOPs
|
||||
l: [1.00, 1.00, 512] # YOLOv8l summary: 365 layers, 43691520 parameters, 43691504 gradients, 165.7 GFLOPs
|
||||
x: [1.00, 1.25, 512] # YOLOv8x summary: 365 layers, 68229648 parameters, 68229632 gradients, 258.5 GFLOPs
|
||||
|
||||
# YOLOv8.0n backbone
|
||||
backbone:
|
||||
# [from, repeats, module, args]
|
||||
- [-1, 1, Conv, [64, 3, 2]] # 0-P1/2
|
||||
- [-1, 1, Conv, [128, 3, 2]] # 1-P2/4
|
||||
- [-1, 3, C2f, [128, True]]
|
||||
- [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
|
||||
- [-1, 6, C2f, [256, True]]
|
||||
- [-1, 1, Conv, [512, 3, 2]] # 5-P4/16
|
||||
- [-1, 6, C2f, [512, True]]
|
||||
- [-1, 1, Conv, [1024, 3, 2]] # 7-P5/32
|
||||
- [-1, 3, C2f, [1024, True]]
|
||||
- [-1, 1, SPPF, [1024, 5]] # 9
|
||||
|
||||
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
|
||||
- [[-1, 6], 1, Concat, [1]] # cat backbone P4
|
||||
- [-1, 3, C2f, [512]] # 12
|
||||
|
||||
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
|
||||
- [[-1, 4], 1, Concat, [1]] # cat backbone P3
|
||||
- [-1, 3, C2f, [256]] # 15 (P3/8-small)
|
||||
|
||||
- [-1, 1, Conv, [256, 3, 2]]
|
||||
- [[-1, 12], 1, Concat, [1]] # cat head P4
|
||||
- [-1, 3, C2f, [512]] # 18 (P4/16-medium)
|
||||
|
||||
- [-1, 1, Conv, [512, 3, 2]]
|
||||
- [[-1, 9], 1, Concat, [1]] # cat head P5
|
||||
- [-1, 3, C2f, [1024]] # 21 (P5/32-large)
|
||||
|
||||
# YOLOv8.0n head
|
||||
head:
|
||||
# [from, repeats, module, args]
|
||||
- [-31, 1, ConvMaskAtt, [64, 3, 2]] # 0-P1/2 # 22
|
||||
- [-1, 1, Conv, [128, 3, 2]] # 1-P2/4
|
||||
- [-1, 3, C2f, [128, True]]
|
||||
- [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
|
||||
- [-1, 6, C2f, [256, True]]
|
||||
- [-1, 1, Conv, [512, 3, 2]] # 5-P4/16
|
||||
- [-1, 6, C2f, [512, True]]
|
||||
- [-1, 1, Conv, [1024, 3, 2]] # 7-P5/32
|
||||
- [-1, 3, C2f, [1024, True]]
|
||||
- [-1, 1, SPPF, [1024, 5]] # 9
|
||||
|
||||
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
|
||||
- [[-1, 28], 1, Concat, [1]] # cat backbone P4
|
||||
- [-1, 3, C2f, [512]] # 12
|
||||
|
||||
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
|
||||
- [[-1, 26], 1, Concat, [1]] # cat backbone P3
|
||||
- [-1, 3, C2f, [256]] # 15 (P3/8-small)
|
||||
|
||||
- [-1, 1, Conv, [256, 3, 2]]
|
||||
- [[-1, 34], 1, Concat, [1]] # cat head P4
|
||||
- [-1, 3, C2f, [512]] # 18 (P4/16-medium)
|
||||
|
||||
- [-1, 1, Conv, [512, 3, 2]]
|
||||
- [[-1, 31], 1, Concat, [1]] # cat head P5
|
||||
- [-1, 3, C2f, [1024]] # 21 (P5/32-large) # 43
|
||||
|
||||
######### Fuse Block #############
|
||||
- [[15, 37], 1, CatConv, [256, 3, 1]] # 44 two stream fuse
|
||||
- [[18, 40], 1, CatConv, [512, 3, 1]] # 45 two stream fuse
|
||||
- [[21, 43], 1, CatConv, [1024, 3, 1]] # 46 two stream fuse
|
||||
|
||||
- [[44, 45, 46], 1, Detect, [nc]] # Detect(P3, P4, P5)
|
||||
@@ -0,0 +1,79 @@
|
||||
# Ultralytics YOLO 🚀, AGPL-3.0 license
|
||||
# YOLOv8 object detection model with P3-P5 outputs. For Usage examples see https://docs.ultralytics.com/tasks/detect
|
||||
|
||||
# Parameters
|
||||
nc: 80 # number of classes
|
||||
scales: # model compound scaling constants, i.e. 'model=yolov8n.yaml' will call yolov8.yaml with scale 'n'
|
||||
# [depth, width, max_channels]
|
||||
n: [0.33, 0.25, 1024] # YOLOv8n summary: 225 layers, 3157200 parameters, 3157184 gradients, 8.9 GFLOPs
|
||||
s: [0.33, 0.50, 1024] # YOLOv8s summary: 225 layers, 11166560 parameters, 11166544 gradients, 28.8 GFLOPs
|
||||
m: [0.67, 0.75, 768] # YOLOv8m summary: 295 layers, 25902640 parameters, 25902624 gradients, 79.3 GFLOPs
|
||||
l: [1.00, 1.00, 512] # YOLOv8l summary: 365 layers, 43691520 parameters, 43691504 gradients, 165.7 GFLOPs
|
||||
x: [1.00, 1.25, 512] # YOLOv8x summary: 365 layers, 68229648 parameters, 68229632 gradients, 258.5 GFLOPs
|
||||
|
||||
# YOLOv8.0n backbone
|
||||
backbone:
|
||||
# [from, repeats, module, args]
|
||||
- [-1, 1, Conv, [64, 3, 2]] # 0-P1/2
|
||||
- [-1, 1, Conv, [128, 3, 2]] # 1-P2/4
|
||||
- [-1, 3, C2f, [128, True]]
|
||||
- [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
|
||||
- [-1, 6, C2f, [256, True]]
|
||||
- [-1, 1, Conv, [512, 3, 2]] # 5-P4/16
|
||||
- [-1, 6, C2f, [512, True]]
|
||||
- [-1, 1, Conv, [1024, 3, 2]] # 7-P5/32
|
||||
- [-1, 3, C2f, [1024, True]]
|
||||
- [-1, 1, SPPF, [1024, 5]] # 9
|
||||
|
||||
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
|
||||
- [[-1, 6], 1, Concat, [1]] # cat backbone P4
|
||||
- [-1, 3, C2f, [512]] # 12
|
||||
|
||||
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
|
||||
- [[-1, 4], 1, Concat, [1]] # cat backbone P3
|
||||
- [-1, 3, C2f, [256]] # 15 (P3/8-small)
|
||||
|
||||
- [-1, 1, Conv, [256, 3, 2]]
|
||||
- [[-1, 12], 1, Concat, [1]] # cat head P4
|
||||
- [-1, 3, C2f, [512]] # 18 (P4/16-medium)
|
||||
|
||||
- [-1, 1, Conv, [512, 3, 2]]
|
||||
- [[-1, 9], 1, Concat, [1]] # cat head P5
|
||||
- [-1, 3, C2f, [1024]] # 21 (P5/32-large)
|
||||
|
||||
# YOLOv8.0n head
|
||||
head:
|
||||
# [from, repeats, module, args]
|
||||
- [-31, 1, ConvMaskAtt, [64, 3, 2]] # 0-P1/2 # 22
|
||||
- [-1, 1, Conv, [128, 3, 2]] # 1-P2/4
|
||||
- [-1, 3, C2f, [128, True]]
|
||||
- [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
|
||||
- [-1, 6, C2f, [256, True]]
|
||||
- [-1, 1, Conv, [512, 3, 2]] # 5-P4/16
|
||||
- [-1, 6, C2f, [512, True]]
|
||||
- [-1, 1, Conv, [1024, 3, 2]] # 7-P5/32
|
||||
- [-1, 3, C2f, [1024, True]]
|
||||
- [-1, 1, SPPF, [1024, 5]] # 9
|
||||
|
||||
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
|
||||
- [[-1, 28], 1, Concat, [1]] # cat backbone P4
|
||||
- [-1, 3, C2f, [512]] # 12
|
||||
|
||||
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
|
||||
- [[-1, 26], 1, Concat, [1]] # cat backbone P3
|
||||
- [-1, 3, C2f, [256]] # 15 (P3/8-small)
|
||||
|
||||
- [-1, 1, Conv, [256, 3, 2]]
|
||||
- [[-1, 34], 1, Concat, [1]] # cat head P4
|
||||
- [-1, 3, C2f, [512]] # 18 (P4/16-medium)
|
||||
|
||||
- [-1, 1, Conv, [512, 3, 2]]
|
||||
- [[-1, 31], 1, Concat, [1]] # cat head P5
|
||||
- [-1, 3, C2f, [1024]] # 21 (P5/32-large) # 43
|
||||
|
||||
######### Fuse Block #############
|
||||
- [[15, 37], 1, Add, [256, 3, 1]] # 44 two stream fuse CatConvAtt
|
||||
- [[18, 40], 1, CatConvAtt, [512, 3, 1]] # 45 two stream fuse
|
||||
- [[21, 43], 1, Add, [1024, 3, 1]] # 46 two stream fuse
|
||||
|
||||
- [[44, 45, 46], 1, Detect, [nc]] # Detect(P3, P4, P5)
|
||||
@@ -0,0 +1,27 @@
|
||||
# Ultralytics YOLO 🚀, AGPL-3.0 license
|
||||
# YOLOv8-cls image classification model. For Usage examples see https://docs.ultralytics.com/tasks/classify
|
||||
|
||||
# Parameters
|
||||
nc: 2 # number of classes
|
||||
scales: # model compound scaling constants, i.e. 'model=yolov8n-cls.yaml' will call yolov8-cls.yaml with scale 'n'
|
||||
# [depth, width, max_channels]
|
||||
n: [0.33, 0.25, 1024]
|
||||
s: [0.33, 0.50, 1024]
|
||||
m: [0.67, 0.75, 1024]
|
||||
l: [1.00, 1.00, 1024]
|
||||
x: [1.00, 1.25, 1024]
|
||||
|
||||
# YOLOv8.0n backbone
|
||||
backbone:
|
||||
# [from, repeats, module, args]
|
||||
- [-1, 1, Conv, [64, 3, 2]] # 0-P1/2
|
||||
- [-1, 1, Conv, [128, 3, 2]] # 1-P2/4
|
||||
- [-1, 3, C2f, [128, True]]
|
||||
- [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
|
||||
- [-1, 6, C2f, [256, True]]
|
||||
- [-1, 1, Conv, [512, 3, 2]] # 5-P4/16
|
||||
- [-1, 3, C2f, [512, True]]
|
||||
|
||||
# YOLOv8.0n head
|
||||
head:
|
||||
- [-1, 1, Classify, [nc]] # Classify
|
||||
@@ -0,0 +1,25 @@
|
||||
# Ultralytics YOLO 🚀, AGPL-3.0 license
|
||||
# YOLOv8-cls image classification model. For Usage examples see https://docs.ultralytics.com/tasks/classify
|
||||
|
||||
# Parameters
|
||||
nc: 1000 # number of classes
|
||||
scales: # model compound scaling constants, i.e. 'model=yolov8n-cls.yaml' will call yolov8-cls.yaml with scale 'n'
|
||||
# [depth, width, max_channels]
|
||||
n: [0.33, 0.25, 1024]
|
||||
s: [0.33, 0.50, 1024]
|
||||
m: [0.67, 0.75, 1024]
|
||||
l: [1.00, 1.00, 1024]
|
||||
x: [1.00, 1.25, 1024]
|
||||
|
||||
# YOLOv8.0n backbone
|
||||
backbone:
|
||||
# [from, repeats, module, args]
|
||||
- [-1, 1, ResNetLayer, [3, 64, 1, True, 1]] # 0-P1/2
|
||||
- [-1, 1, ResNetLayer, [64, 64, 1, False, 3]] # 1-P2/4
|
||||
- [-1, 1, ResNetLayer, [256, 128, 2, False, 4]] # 2-P3/8
|
||||
- [-1, 1, ResNetLayer, [512, 256, 2, False, 23]] # 3-P4/16
|
||||
- [-1, 1, ResNetLayer, [1024, 512, 2, False, 3]] # 4-P5/32
|
||||
|
||||
# YOLOv8.0n head
|
||||
head:
|
||||
- [-1, 1, Classify, [nc]] # Classify
|
||||
@@ -0,0 +1,25 @@
|
||||
# Ultralytics YOLO 🚀, AGPL-3.0 license
|
||||
# YOLOv8-cls image classification model. For Usage examples see https://docs.ultralytics.com/tasks/classify
|
||||
|
||||
# Parameters
|
||||
nc: 1000 # number of classes
|
||||
scales: # model compound scaling constants, i.e. 'model=yolov8n-cls.yaml' will call yolov8-cls.yaml with scale 'n'
|
||||
# [depth, width, max_channels]
|
||||
n: [0.33, 0.25, 1024]
|
||||
s: [0.33, 0.50, 1024]
|
||||
m: [0.67, 0.75, 1024]
|
||||
l: [1.00, 1.00, 1024]
|
||||
x: [1.00, 1.25, 1024]
|
||||
|
||||
# YOLOv8.0n backbone
|
||||
backbone:
|
||||
# [from, repeats, module, args]
|
||||
- [-1, 1, ResNetLayer, [3, 64, 1, True, 1]] # 0-P1/2
|
||||
- [-1, 1, ResNetLayer, [64, 64, 1, False, 3]] # 1-P2/4
|
||||
- [-1, 1, ResNetLayer, [256, 128, 2, False, 4]] # 2-P3/8
|
||||
- [-1, 1, ResNetLayer, [512, 256, 2, False, 6]] # 3-P4/16
|
||||
- [-1, 1, ResNetLayer, [1024, 512, 2, False, 3]] # 4-P5/32
|
||||
|
||||
# YOLOv8.0n head
|
||||
head:
|
||||
- [-1, 1, Classify, [nc]] # Classify
|
||||
@@ -0,0 +1,29 @@
|
||||
# Ultralytics YOLO 🚀, AGPL-3.0 license
|
||||
# YOLOv8-cls image classification model. For Usage examples see https://docs.ultralytics.com/tasks/classify
|
||||
|
||||
# Parameters
|
||||
nc: 1000 # number of classes
|
||||
scales: # model compound scaling constants, i.e. 'model=yolov8n-cls.yaml' will call yolov8-cls.yaml with scale 'n'
|
||||
# [depth, width, max_channels]
|
||||
n: [0.33, 0.25, 1024]
|
||||
s: [0.33, 0.50, 1024]
|
||||
m: [0.67, 0.75, 1024]
|
||||
l: [1.00, 1.00, 1024]
|
||||
x: [1.00, 1.25, 1024]
|
||||
|
||||
# YOLOv8.0n backbone
|
||||
backbone:
|
||||
# [from, repeats, module, args]
|
||||
- [-1, 1, Conv, [64, 3, 2]] # 0-P1/2
|
||||
- [-1, 1, Conv, [128, 3, 2]] # 1-P2/4
|
||||
- [-1, 3, C2f, [128, True]]
|
||||
- [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
|
||||
- [-1, 6, C2f, [256, True]]
|
||||
- [-1, 1, Conv, [512, 3, 2]] # 5-P4/16
|
||||
- [-1, 6, C2f, [512, True]]
|
||||
- [-1, 1, Conv, [1024, 3, 2]] # 7-P5/32
|
||||
- [-1, 3, C2f, [1024, True]]
|
||||
|
||||
# YOLOv8.0n head
|
||||
head:
|
||||
- [-1, 1, Classify, [nc]] # Classify
|
||||
@@ -0,0 +1,36 @@
|
||||
# Ultralytics YOLO 🚀, AGPL-3.0 license
|
||||
# YOLOv8-seg instance segmentation model. For Usage examples see https://docs.ultralytics.com/tasks/segment
|
||||
|
||||
# Parameters
|
||||
nc: 1 # number of classes
|
||||
scales: # model compound scaling constants, i.e. 'model=yolov8n-seg.yaml' will call yolov8-seg.yaml with scale 'n'
|
||||
# [depth, width, max_channels]
|
||||
n: [0.33, 0.25, 1024]
|
||||
s: [0.33, 0.50, 1024]
|
||||
m: [0.67, 0.75, 768]
|
||||
l: [1.00, 1.00, 512]
|
||||
x: [1.00, 1.25, 512]
|
||||
|
||||
# YOLOv8.0n backbone
|
||||
backbone:
|
||||
# [from, repeats, module, args]
|
||||
- [-1, 1, Conv, [64, 3, 2]] # 0-P1/2
|
||||
- [-1, 1, Conv, [128, 3, 2]] # 1-P2/4
|
||||
- [-1, 3, C2f, [128, True]]
|
||||
- [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
|
||||
- [-1, 6, C2f, [256, True]]
|
||||
- [-1, 1, Conv, [512, 3, 2]] # 5-P4/16
|
||||
- [-1, 3, C2f, [512, True]]
|
||||
- [-1, 1, SPPF, [512, 5]] # 7
|
||||
|
||||
# YOLOv8.0n head
|
||||
head:
|
||||
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
|
||||
- [[-1, 4], 1, Concat, [1]] # cat backbone P3
|
||||
- [-1, 3, C2f, [256]] # 10 (P3/8)
|
||||
|
||||
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
|
||||
- [[-1, 2], 1, Concat, [1]] # cat backbone P2
|
||||
- [-1, 3, C2f, [128]] # 13 (P2/4)
|
||||
|
||||
- [[13], 1, Demask, [nc]] #
|
||||
@@ -0,0 +1,60 @@
|
||||
# Ultralytics YOLO 🚀, AGPL-3.0 license
|
||||
# YOLOv8 object detection model with P3-P5 outputs. For Usage examples see https://docs.ultralytics.com/tasks/detect
|
||||
|
||||
# Parameters
|
||||
nc: 80 # number of classes
|
||||
scales: # model compound scaling constants, i.e. 'model=yolov8n.yaml' will call yolov8.yaml with scale 'n'
|
||||
# [depth, width, max_channels]
|
||||
n: [0.33, 0.25, 1024] # YOLOv8n summary: 225 layers, 3157200 parameters, 3157184 gradients, 8.9 GFLOPs
|
||||
s: [0.33, 0.50, 1024] # YOLOv8s summary: 225 layers, 11166560 parameters, 11166544 gradients, 28.8 GFLOPs
|
||||
m: [0.67, 0.75, 768] # YOLOv8m summary: 295 layers, 25902640 parameters, 25902624 gradients, 79.3 GFLOPs
|
||||
l: [1.00, 1.00, 512] # YOLOv8l summary: 365 layers, 43691520 parameters, 43691504 gradients, 165.7 GFLOPs
|
||||
x: [1.00, 1.25, 512] # YOLOv8x summary: 365 layers, 68229648 parameters, 68229632 gradients, 258.5 GFLOPs
|
||||
|
||||
# YOLOv8.0n backbone
|
||||
backbone:
|
||||
# [from, repeats, module, args]
|
||||
- [-1, 1, ConvMaskAtt, [64, 3, 2]] # 0-P1/2 # MaskAtt
|
||||
- [-1, 1, Conv, [128, 3, 2]] # 1-P2/4
|
||||
- [-1, 3, C2f, [128, True]]
|
||||
- [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
|
||||
- [-1, 6, C2f, [256, True]]
|
||||
- [-1, 1, Conv, [512, 3, 2]] # 5-P4/16
|
||||
- [-1, 6, C2f, [512, True]]
|
||||
- [-1, 1, Conv, [1024, 3, 2]] # 7-P5/32
|
||||
- [-1, 3, C2f, [1024, True]]
|
||||
- [-1, 1, SPPF, [1024, 5]] # 9
|
||||
|
||||
# YOLOv8.0n head
|
||||
head:
|
||||
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
|
||||
- [[-1, 6], 1, Concat, [1]] # cat backbone P4
|
||||
- [-1, 3, C2f, [512]] # 12
|
||||
|
||||
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
|
||||
- [[-1, 4], 1, Concat, [1]] # cat backbone P3
|
||||
- [-1, 3, C2f, [256]] # 15 (P3/8-small)
|
||||
|
||||
- [-1, 1, Conv, [256, 3, 2]]
|
||||
- [[-1, 12], 1, Concat, [1]] # cat head P4
|
||||
- [-1, 3, C2f, [512]] # 18 (P4/16-medium)
|
||||
|
||||
- [-1, 1, Conv, [512, 3, 2]]
|
||||
- [[-1, 9], 1, Concat, [1]] # cat head P5
|
||||
- [-1, 3, C2f, [1024]] # 21 (P5/32-large)
|
||||
|
||||
- [[15, 18, 21], 1, Detect, [nc]] # Detect(P3, P4, P5)
|
||||
|
||||
- [9, 1, nn.Upsample, [None, 2, "nearest"]]
|
||||
- [[-1, 6], 1, Concat, [1]] # cat backbone P4
|
||||
- [-1, 3, C2f, [512]] # 12
|
||||
|
||||
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
|
||||
- [[-1, 4], 1, Concat, [1]] # cat backbone P3
|
||||
- [-1, 3, C2f, [256]] # 10 (P3/8)
|
||||
|
||||
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
|
||||
- [[-1, 2], 1, Concat, [1]] # cat backbone P2
|
||||
- [-1, 3, C2f, [128]] # 13 (P2/4)
|
||||
|
||||
- [[13], 1, Demask, [nc]] #
|
||||
@@ -0,0 +1,54 @@
|
||||
# Ultralytics YOLO 🚀, AGPL-3.0 license
|
||||
# YOLOv8 object detection model with P2-P5 outputs. For Usage examples see https://docs.ultralytics.com/tasks/detect
|
||||
|
||||
# Parameters
|
||||
nc: 80 # number of classes
|
||||
scales: # model compound scaling constants, i.e. 'model=yolov8n.yaml' will call yolov8.yaml with scale 'n'
|
||||
# [depth, width, max_channels]
|
||||
n: [0.33, 0.25, 1024] # YOLOv8n-ghost-p2 summary: 491 layers, 2033944 parameters, 2033928 gradients, 13.8 GFLOPs
|
||||
s: [0.33, 0.50, 1024] # YOLOv8s-ghost-p2 summary: 491 layers, 5562080 parameters, 5562064 gradients, 25.1 GFLOPs
|
||||
m: [0.67, 0.75, 768] # YOLOv8m-ghost-p2 summary: 731 layers, 9031728 parameters, 9031712 gradients, 42.8 GFLOPs
|
||||
l: [1.00, 1.00, 512] # YOLOv8l-ghost-p2 summary: 971 layers, 12214448 parameters, 12214432 gradients, 69.1 GFLOPs
|
||||
x: [1.00, 1.25, 512] # YOLOv8x-ghost-p2 summary: 971 layers, 18664776 parameters, 18664760 gradients, 103.3 GFLOPs
|
||||
|
||||
# YOLOv8.0-ghost backbone
|
||||
backbone:
|
||||
# [from, repeats, module, args]
|
||||
- [-1, 1, Conv, [64, 3, 2]] # 0-P1/2
|
||||
- [-1, 1, GhostConv, [128, 3, 2]] # 1-P2/4
|
||||
- [-1, 3, C3Ghost, [128, True]]
|
||||
- [-1, 1, GhostConv, [256, 3, 2]] # 3-P3/8
|
||||
- [-1, 6, C3Ghost, [256, True]]
|
||||
- [-1, 1, GhostConv, [512, 3, 2]] # 5-P4/16
|
||||
- [-1, 6, C3Ghost, [512, True]]
|
||||
- [-1, 1, GhostConv, [1024, 3, 2]] # 7-P5/32
|
||||
- [-1, 3, C3Ghost, [1024, True]]
|
||||
- [-1, 1, SPPF, [1024, 5]] # 9
|
||||
|
||||
# YOLOv8.0-ghost-p2 head
|
||||
head:
|
||||
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
|
||||
- [[-1, 6], 1, Concat, [1]] # cat backbone P4
|
||||
- [-1, 3, C3Ghost, [512]] # 12
|
||||
|
||||
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
|
||||
- [[-1, 4], 1, Concat, [1]] # cat backbone P3
|
||||
- [-1, 3, C3Ghost, [256]] # 15 (P3/8-small)
|
||||
|
||||
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
|
||||
- [[-1, 2], 1, Concat, [1]] # cat backbone P2
|
||||
- [-1, 3, C3Ghost, [128]] # 18 (P2/4-xsmall)
|
||||
|
||||
- [-1, 1, GhostConv, [128, 3, 2]]
|
||||
- [[-1, 15], 1, Concat, [1]] # cat head P3
|
||||
- [-1, 3, C3Ghost, [256]] # 21 (P3/8-small)
|
||||
|
||||
- [-1, 1, GhostConv, [256, 3, 2]]
|
||||
- [[-1, 12], 1, Concat, [1]] # cat head P4
|
||||
- [-1, 3, C3Ghost, [512]] # 24 (P4/16-medium)
|
||||
|
||||
- [-1, 1, GhostConv, [512, 3, 2]]
|
||||
- [[-1, 9], 1, Concat, [1]] # cat head P5
|
||||
- [-1, 3, C3Ghost, [1024]] # 27 (P5/32-large)
|
||||
|
||||
- [[18, 21, 24, 27], 1, Detect, [nc]] # Detect(P2, P3, P4, P5)
|
||||
@@ -0,0 +1,56 @@
|
||||
# Ultralytics YOLO 🚀, AGPL-3.0 license
|
||||
# YOLOv8 object detection model with P3-P6 outputs. For Usage examples see https://docs.ultralytics.com/tasks/detect
|
||||
|
||||
# Parameters
|
||||
nc: 80 # number of classes
|
||||
scales: # model compound scaling constants, i.e. 'model=yolov8n-p6.yaml' will call yolov8-p6.yaml with scale 'n'
|
||||
# [depth, width, max_channels]
|
||||
n: [0.33, 0.25, 1024] # YOLOv8n-ghost-p6 summary: 529 layers, 2901100 parameters, 2901084 gradients, 5.8 GFLOPs
|
||||
s: [0.33, 0.50, 1024] # YOLOv8s-ghost-p6 summary: 529 layers, 9520008 parameters, 9519992 gradients, 16.4 GFLOPs
|
||||
m: [0.67, 0.75, 768] # YOLOv8m-ghost-p6 summary: 789 layers, 18002904 parameters, 18002888 gradients, 34.4 GFLOPs
|
||||
l: [1.00, 1.00, 512] # YOLOv8l-ghost-p6 summary: 1049 layers, 21227584 parameters, 21227568 gradients, 55.3 GFLOPs
|
||||
x: [1.00, 1.25, 512] # YOLOv8x-ghost-p6 summary: 1049 layers, 33057852 parameters, 33057836 gradients, 85.7 GFLOPs
|
||||
|
||||
# YOLOv8.0-ghost backbone
|
||||
backbone:
|
||||
# [from, repeats, module, args]
|
||||
- [-1, 1, Conv, [64, 3, 2]] # 0-P1/2
|
||||
- [-1, 1, GhostConv, [128, 3, 2]] # 1-P2/4
|
||||
- [-1, 3, C3Ghost, [128, True]]
|
||||
- [-1, 1, GhostConv, [256, 3, 2]] # 3-P3/8
|
||||
- [-1, 6, C3Ghost, [256, True]]
|
||||
- [-1, 1, GhostConv, [512, 3, 2]] # 5-P4/16
|
||||
- [-1, 6, C3Ghost, [512, True]]
|
||||
- [-1, 1, GhostConv, [768, 3, 2]] # 7-P5/32
|
||||
- [-1, 3, C3Ghost, [768, True]]
|
||||
- [-1, 1, GhostConv, [1024, 3, 2]] # 9-P6/64
|
||||
- [-1, 3, C3Ghost, [1024, True]]
|
||||
- [-1, 1, SPPF, [1024, 5]] # 11
|
||||
|
||||
# YOLOv8.0-ghost-p6 head
|
||||
head:
|
||||
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
|
||||
- [[-1, 8], 1, Concat, [1]] # cat backbone P5
|
||||
- [-1, 3, C3Ghost, [768]] # 14
|
||||
|
||||
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
|
||||
- [[-1, 6], 1, Concat, [1]] # cat backbone P4
|
||||
- [-1, 3, C3Ghost, [512]] # 17
|
||||
|
||||
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
|
||||
- [[-1, 4], 1, Concat, [1]] # cat backbone P3
|
||||
- [-1, 3, C3Ghost, [256]] # 20 (P3/8-small)
|
||||
|
||||
- [-1, 1, GhostConv, [256, 3, 2]]
|
||||
- [[-1, 17], 1, Concat, [1]] # cat head P4
|
||||
- [-1, 3, C3Ghost, [512]] # 23 (P4/16-medium)
|
||||
|
||||
- [-1, 1, GhostConv, [512, 3, 2]]
|
||||
- [[-1, 14], 1, Concat, [1]] # cat head P5
|
||||
- [-1, 3, C3Ghost, [768]] # 26 (P5/32-large)
|
||||
|
||||
- [-1, 1, GhostConv, [768, 3, 2]]
|
||||
- [[-1, 11], 1, Concat, [1]] # cat head P6
|
||||
- [-1, 3, C3Ghost, [1024]] # 29 (P6/64-xlarge)
|
||||
|
||||
- [[20, 23, 26, 29], 1, Detect, [nc]] # Detect(P3, P4, P5, P6)
|
||||
@@ -0,0 +1,47 @@
|
||||
# Ultralytics YOLO 🚀, AGPL-3.0 license
|
||||
# YOLOv8 object detection model with P3-P5 outputs. For Usage examples see https://docs.ultralytics.com/tasks/detect
|
||||
# Employs Ghost convolutions and modules proposed in Huawei's GhostNet in https://arxiv.org/abs/1911.11907v2
|
||||
|
||||
# Parameters
|
||||
nc: 80 # number of classes
|
||||
scales: # model compound scaling constants, i.e. 'model=yolov8n.yaml' will call yolov8.yaml with scale 'n'
|
||||
# [depth, width, max_channels]
|
||||
n: [0.33, 0.25, 1024] # YOLOv8n-ghost summary: 403 layers, 1865316 parameters, 1865300 gradients, 5.8 GFLOPs
|
||||
s: [0.33, 0.50, 1024] # YOLOv8s-ghost summary: 403 layers, 5960072 parameters, 5960056 gradients, 16.4 GFLOPs
|
||||
m: [0.67, 0.75, 768] # YOLOv8m-ghost summary: 603 layers, 10336312 parameters, 10336296 gradients, 32.7 GFLOPs
|
||||
l: [1.00, 1.00, 512] # YOLOv8l-ghost summary: 803 layers, 14277872 parameters, 14277856 gradients, 53.7 GFLOPs
|
||||
x: [1.00, 1.25, 512] # YOLOv8x-ghost summary: 803 layers, 22229308 parameters, 22229292 gradients, 83.3 GFLOPs
|
||||
|
||||
# YOLOv8.0n-ghost backbone
|
||||
backbone:
|
||||
# [from, repeats, module, args]
|
||||
- [-1, 1, Conv, [64, 3, 2]] # 0-P1/2
|
||||
- [-1, 1, GhostConv, [128, 3, 2]] # 1-P2/4
|
||||
- [-1, 3, C3Ghost, [128, True]]
|
||||
- [-1, 1, GhostConv, [256, 3, 2]] # 3-P3/8
|
||||
- [-1, 6, C3Ghost, [256, True]]
|
||||
- [-1, 1, GhostConv, [512, 3, 2]] # 5-P4/16
|
||||
- [-1, 6, C3Ghost, [512, True]]
|
||||
- [-1, 1, GhostConv, [1024, 3, 2]] # 7-P5/32
|
||||
- [-1, 3, C3Ghost, [1024, True]]
|
||||
- [-1, 1, SPPF, [1024, 5]] # 9
|
||||
|
||||
# YOLOv8.0n head
|
||||
head:
|
||||
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
|
||||
- [[-1, 6], 1, Concat, [1]] # cat backbone P4
|
||||
- [-1, 3, C3Ghost, [512]] # 12
|
||||
|
||||
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
|
||||
- [[-1, 4], 1, Concat, [1]] # cat backbone P3
|
||||
- [-1, 3, C3Ghost, [256]] # 15 (P3/8-small)
|
||||
|
||||
- [-1, 1, GhostConv, [256, 3, 2]]
|
||||
- [[-1, 12], 1, Concat, [1]] # cat head P4
|
||||
- [-1, 3, C3Ghost, [512]] # 18 (P4/16-medium)
|
||||
|
||||
- [-1, 1, GhostConv, [512, 3, 2]]
|
||||
- [[-1, 9], 1, Concat, [1]] # cat head P5
|
||||
- [-1, 3, C3Ghost, [1024]] # 21 (P5/32-large)
|
||||
|
||||
- [[15, 18, 21], 1, Detect, [nc]] # Detect(P3, P4, P5)
|
||||
@@ -0,0 +1,46 @@
|
||||
# Ultralytics YOLO 🚀, AGPL-3.0 license
|
||||
# YOLOv8 object detection model with P3-P5 outputs. For Usage examples see https://docs.ultralytics.com/tasks/detect
|
||||
|
||||
# Parameters
|
||||
nc: 80 # number of classes
|
||||
scales: # model compound scaling constants, i.e. 'model=yolov8n.yaml' will call yolov8.yaml with scale 'n'
|
||||
# [depth, width, max_channels]
|
||||
n: [0.33, 0.25, 1024] # YOLOv8n summary: 225 layers, 3157200 parameters, 3157184 gradients, 8.9 GFLOPs
|
||||
s: [0.33, 0.50, 1024] # YOLOv8s summary: 225 layers, 11166560 parameters, 11166544 gradients, 28.8 GFLOPs
|
||||
m: [0.67, 0.75, 768] # YOLOv8m summary: 295 layers, 25902640 parameters, 25902624 gradients, 79.3 GFLOPs
|
||||
l: [1.00, 1.00, 512] # YOLOv8l summary: 365 layers, 43691520 parameters, 43691504 gradients, 165.7 GFLOPs
|
||||
x: [1.00, 1.25, 512] # YOLOv8x summary: 365 layers, 68229648 parameters, 68229632 gradients, 258.5 GFLOPs
|
||||
|
||||
# YOLOv8.0n backbone
|
||||
backbone:
|
||||
# [from, repeats, module, args]
|
||||
- [-1, 1, ConvMaskAtt, [64, 3, 2]] # 0-P1/2 # MaskAtt
|
||||
- [-1, 1, Conv, [128, 3, 2]] # 1-P2/4
|
||||
- [-1, 3, C2f, [128, True]]
|
||||
- [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
|
||||
- [-1, 6, C2f, [256, True]]
|
||||
- [-1, 1, Conv, [512, 3, 2]] # 5-P4/16
|
||||
- [-1, 6, C2f, [512, True]]
|
||||
- [-1, 1, Conv, [1024, 3, 2]] # 7-P5/32
|
||||
- [-1, 3, C2f, [1024, True]]
|
||||
- [-1, 1, SPPF, [1024, 5]] # 9
|
||||
|
||||
# YOLOv8.0n head
|
||||
head:
|
||||
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
|
||||
- [[-1, 6], 1, Concat, [1]] # cat backbone P4
|
||||
- [-1, 3, C2f, [512]] # 12
|
||||
|
||||
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
|
||||
- [[-1, 4], 1, Concat, [1]] # cat backbone P3
|
||||
- [-1, 3, C2f, [256]] # 15 (P3/8-small)
|
||||
|
||||
- [-1, 1, Conv, [256, 3, 2]]
|
||||
- [[-1, 12], 1, Concat, [1]] # cat head P4
|
||||
- [-1, 3, C2f, [512]] # 18 (P4/16-medium)
|
||||
|
||||
- [-1, 1, Conv, [512, 3, 2]]
|
||||
- [[-1, 9], 1, Concat, [1]] # cat head P5
|
||||
- [-1, 3, C2f, [1024]] # 21 (P5/32-large)
|
||||
|
||||
- [[15, 18, 21], 1, Detect, [nc]] # Detect(P3, P4, P5)
|
||||
@@ -0,0 +1,46 @@
|
||||
# Ultralytics YOLO 🚀, AGPL-3.0 license
|
||||
# YOLOv8 Oriented Bounding Boxes (OBB) model with P3-P5 outputs. For Usage examples see https://docs.ultralytics.com/tasks/detect
|
||||
|
||||
# Parameters
|
||||
nc: 80 # number of classes
|
||||
scales: # model compound scaling constants, i.e. 'model=yolov8n.yaml' will call yolov8.yaml with scale 'n'
|
||||
# [depth, width, max_channels]
|
||||
n: [0.33, 0.25, 1024] # YOLOv8n summary: 225 layers, 3157200 parameters, 3157184 gradients, 8.9 GFLOPs
|
||||
s: [0.33, 0.50, 1024] # YOLOv8s summary: 225 layers, 11166560 parameters, 11166544 gradients, 28.8 GFLOPs
|
||||
m: [0.67, 0.75, 768] # YOLOv8m summary: 295 layers, 25902640 parameters, 25902624 gradients, 79.3 GFLOPs
|
||||
l: [1.00, 1.00, 512] # YOLOv8l summary: 365 layers, 43691520 parameters, 43691504 gradients, 165.7 GFLOPs
|
||||
x: [1.00, 1.25, 512] # YOLOv8x summary: 365 layers, 68229648 parameters, 68229632 gradients, 258.5 GFLOPs
|
||||
|
||||
# YOLOv8.0n backbone
|
||||
backbone:
|
||||
# [from, repeats, module, args]
|
||||
- [-1, 1, Conv, [64, 3, 2]] # 0-P1/2
|
||||
- [-1, 1, Conv, [128, 3, 2]] # 1-P2/4
|
||||
- [-1, 3, C2f, [128, True]]
|
||||
- [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
|
||||
- [-1, 6, C2f, [256, True]]
|
||||
- [-1, 1, Conv, [512, 3, 2]] # 5-P4/16
|
||||
- [-1, 6, C2f, [512, True]]
|
||||
- [-1, 1, Conv, [1024, 3, 2]] # 7-P5/32
|
||||
- [-1, 3, C2f, [1024, True]]
|
||||
- [-1, 1, SPPF, [1024, 5]] # 9
|
||||
|
||||
# YOLOv8.0n head
|
||||
head:
|
||||
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
|
||||
- [[-1, 6], 1, Concat, [1]] # cat backbone P4
|
||||
- [-1, 3, C2f, [512]] # 12
|
||||
|
||||
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
|
||||
- [[-1, 4], 1, Concat, [1]] # cat backbone P3
|
||||
- [-1, 3, C2f, [256]] # 15 (P3/8-small)
|
||||
|
||||
- [-1, 1, Conv, [256, 3, 2]]
|
||||
- [[-1, 12], 1, Concat, [1]] # cat head P4
|
||||
- [-1, 3, C2f, [512]] # 18 (P4/16-medium)
|
||||
|
||||
- [-1, 1, Conv, [512, 3, 2]]
|
||||
- [[-1, 9], 1, Concat, [1]] # cat head P5
|
||||
- [-1, 3, C2f, [1024]] # 21 (P5/32-large)
|
||||
|
||||
- [[15, 18, 21], 1, OBB, [nc, 1]] # OBB(P3, P4, P5)
|
||||
@@ -0,0 +1,96 @@
|
||||
# Ultralytics YOLO 🚀, AGPL-3.0 license
|
||||
# YOLOv8 object detection model with P3-P5 outputs. For Usage examples see https://docs.ultralytics.com/tasks/detect
|
||||
|
||||
# Parameters
|
||||
nc: 80 # number of classes
|
||||
scales: # model compound scaling constants, i.e. 'model=yolov8n.yaml' will call yolov8.yaml with scale 'n'
|
||||
# [depth, width, max_channels]
|
||||
n: [0.33, 0.25, 1024] # YOLOv8n summary: 225 layers, 3157200 parameters, 3157184 gradients, 8.9 GFLOPs
|
||||
s: [0.33, 0.50, 1024] # YOLOv8s summary: 225 layers, 11166560 parameters, 11166544 gradients, 28.8 GFLOPs
|
||||
m: [0.67, 0.75, 768] # YOLOv8m summary: 295 layers, 25902640 parameters, 25902624 gradients, 79.3 GFLOPs
|
||||
l: [1.00, 1.00, 512] # YOLOv8l summary: 365 layers, 43691520 parameters, 43691504 gradients, 165.7 GFLOPs
|
||||
x: [1.00, 1.25, 512] # YOLOv8x summary: 365 layers, 68229648 parameters, 68229632 gradients, 258.5 GFLOPs
|
||||
|
||||
# YOLOv8.0n backbone
|
||||
backbone:
|
||||
# [from, repeats, module, args]
|
||||
- [-1, 1, Conv, [64, 3, 2]] # 0-P1/2
|
||||
- [-1, 1, Conv, [128, 3, 2]] # 1-P2/4
|
||||
- [-1, 3, C2f, [128, True]]
|
||||
- [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
|
||||
- [-1, 6, C2f, [256, True]]
|
||||
- [-1, 1, Conv, [512, 3, 2]] # 5-P4/16
|
||||
- [-1, 6, C2f, [512, True]]
|
||||
- [-1, 1, Conv, [1024, 3, 2]] # 7-P5/32
|
||||
- [-1, 3, C2f, [1024, True]]
|
||||
- [-1, 1, SPPF, [1024, 5]] # 9
|
||||
|
||||
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
|
||||
- [[-1, 6], 1, Concat, [1]] # cat backbone P4
|
||||
- [-1, 3, C2f, [512]] # 12
|
||||
|
||||
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
|
||||
- [[-1, 4], 1, Concat, [1]] # cat backbone P3
|
||||
- [-1, 3, C2f, [256]] # 15 (P3/8-small)
|
||||
|
||||
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
|
||||
- [[-1, 2], 1, Concat, [1]] # cat backbone P2
|
||||
- [-1, 3, C2f, [128]] # 18 (P2/4-xsmall)
|
||||
|
||||
- [-1, 1, Conv, [128, 3, 2]]
|
||||
- [[-1, 15], 1, Concat, [1]] # cat head P3
|
||||
- [-1, 3, C2f, [256]] # 21 (P3/8-small)
|
||||
|
||||
- [-1, 1, Conv, [256, 3, 2]]
|
||||
- [[-1, 12], 1, Concat, [1]] # cat head P4
|
||||
- [-1, 3, C2f, [512]] # 24 (P4/16-medium)
|
||||
|
||||
- [-1, 1, Conv, [512, 3, 2]]
|
||||
- [[-1, 9], 1, Concat, [1]] # cat head P5
|
||||
- [-1, 3, C2f, [1024]] # 27 (P5/32-large)
|
||||
|
||||
# YOLOv8.0n head
|
||||
head:
|
||||
# [from, repeats, module, args]
|
||||
- [-31, 1, Conv, [64, 3, 2]] # 0-P1/2 # 28
|
||||
- [-1, 1, Conv, [128, 3, 2]] # 1-P2/4
|
||||
- [-1, 3, C2f, [128, True]]
|
||||
- [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
|
||||
- [-1, 6, C2f, [256, True]]
|
||||
- [-1, 1, Conv, [512, 3, 2]] # 5-P4/16
|
||||
- [-1, 6, C2f, [512, True]]
|
||||
- [-1, 1, Conv, [1024, 3, 2]] # 7-P5/32
|
||||
- [-1, 3, C2f, [1024, True]]
|
||||
- [-1, 1, SPPF, [1024, 5]] # 9
|
||||
|
||||
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
|
||||
- [[-1, 34], 1, Concat, [1]] # cat backbone P4
|
||||
- [-1, 3, C2f, [512]] # 12
|
||||
|
||||
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
|
||||
- [[-1, 32], 1, Concat, [1]] # cat backbone P3
|
||||
- [-1, 3, C2f, [256]] # 15 (P3/8-small)
|
||||
|
||||
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
|
||||
- [[-1, 30], 1, Concat, [1]] # cat backbone P2
|
||||
- [-1, 3, C2f, [128]] # 18 (P2/4-xsmall)
|
||||
|
||||
- [-1, 1, Conv, [128, 3, 2]]
|
||||
- [[-1, 43], 1, Concat, [1]] # cat head P3
|
||||
- [-1, 3, C2f, [256]] # 21 (P3/8-small)
|
||||
|
||||
- [-1, 1, Conv, [256, 3, 2]]
|
||||
- [[-1, 40], 1, Concat, [1]] # cat head P4
|
||||
- [-1, 3, C2f, [512]] # 24 (P4/16-medium)
|
||||
|
||||
- [-1, 1, Conv, [512, 3, 2]]
|
||||
- [[-1, 37], 1, Concat, [1]] # cat head P5
|
||||
- [-1, 3, C2f, [1024]] # 27 (P5/32-large)
|
||||
|
||||
######### Fuse Block #############
|
||||
- [[18, 46], 1, CatConvAtt, [128, 3, 1]] # 56 two stream fuse
|
||||
- [[21, 49], 1, CatConvAtt, [256, 3, 1]] # 57 two stream fuse
|
||||
- [[24, 52], 1, CatConvAtt, [512, 3, 1]] # 58 two stream fuse
|
||||
- [[27, 55], 1, CatConvAtt, [1024, 3, 1]] # 59 two stream fuse
|
||||
|
||||
- [[56, 57, 58, 59], 1, Detect, [nc]] # Detect(P2, P3, P4, P5)
|
||||
@@ -0,0 +1,96 @@
|
||||
# Ultralytics YOLO 🚀, AGPL-3.0 license
|
||||
# YOLOv8 object detection model with P3-P5 outputs. For Usage examples see https://docs.ultralytics.com/tasks/detect
|
||||
|
||||
# Parameters
|
||||
nc: 80 # number of classes
|
||||
scales: # model compound scaling constants, i.e. 'model=yolov8n.yaml' will call yolov8.yaml with scale 'n'
|
||||
# [depth, width, max_channels]
|
||||
n: [0.33, 0.25, 1024] # YOLOv8n summary: 225 layers, 3157200 parameters, 3157184 gradients, 8.9 GFLOPs
|
||||
s: [0.33, 0.50, 1024] # YOLOv8s summary: 225 layers, 11166560 parameters, 11166544 gradients, 28.8 GFLOPs
|
||||
m: [0.67, 0.75, 768] # YOLOv8m summary: 295 layers, 25902640 parameters, 25902624 gradients, 79.3 GFLOPs
|
||||
l: [1.00, 1.00, 512] # YOLOv8l summary: 365 layers, 43691520 parameters, 43691504 gradients, 165.7 GFLOPs
|
||||
x: [1.00, 1.25, 512] # YOLOv8x summary: 365 layers, 68229648 parameters, 68229632 gradients, 258.5 GFLOPs
|
||||
|
||||
# YOLOv8.0n backbone
|
||||
backbone:
|
||||
# [from, repeats, module, args]
|
||||
- [-1, 1, Conv, [64, 3, 2]] # 0-P1/2
|
||||
- [-1, 1, Conv, [128, 3, 2]] # 1-P2/4
|
||||
- [-1, 3, C2f, [128, True]]
|
||||
- [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
|
||||
- [-1, 6, C2f, [256, True]]
|
||||
- [-1, 1, Conv, [512, 3, 2]] # 5-P4/16
|
||||
- [-1, 6, C2f, [512, True]]
|
||||
- [-1, 1, Conv, [1024, 3, 2]] # 7-P5/32
|
||||
- [-1, 3, C2f, [1024, True]]
|
||||
- [-1, 1, SPPF, [1024, 5]] # 9
|
||||
|
||||
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
|
||||
- [[-1, 6], 1, Concat, [1]] # cat backbone P4
|
||||
- [-1, 3, C2f, [512]] # 12
|
||||
|
||||
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
|
||||
- [[-1, 4], 1, Concat, [1]] # cat backbone P3
|
||||
- [-1, 3, C2f, [256]] # 15 (P3/8-small)
|
||||
|
||||
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
|
||||
- [[-1, 2], 1, Concat, [1]] # cat backbone P2
|
||||
- [-1, 3, C2f, [128]] # 18 (P2/4-xsmall)
|
||||
|
||||
- [-1, 1, Conv, [128, 3, 2]]
|
||||
- [[-1, 15], 1, Concat, [1]] # cat head P3
|
||||
- [-1, 3, C2f, [256]] # 21 (P3/8-small)
|
||||
|
||||
- [-1, 1, Conv, [256, 3, 2]]
|
||||
- [[-1, 12], 1, Concat, [1]] # cat head P4
|
||||
- [-1, 3, C2f, [512]] # 24 (P4/16-medium)
|
||||
|
||||
- [-1, 1, Conv, [512, 3, 2]]
|
||||
- [[-1, 9], 1, Concat, [1]] # cat head P5
|
||||
- [-1, 3, C2f, [1024]] # 27 (P5/32-large)
|
||||
|
||||
# YOLOv8.0n head
|
||||
head:
|
||||
# [from, repeats, module, args]
|
||||
- [-31, 1, ConvMaskAtt, [64, 3, 2]] # 0-P1/2 # 28
|
||||
- [-1, 1, Conv, [128, 3, 2]] # 1-P2/4
|
||||
- [-1, 3, C2f, [128, True]]
|
||||
- [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
|
||||
- [-1, 6, C2f, [256, True]]
|
||||
- [-1, 1, Conv, [512, 3, 2]] # 5-P4/16
|
||||
- [-1, 6, C2f, [512, True]]
|
||||
- [-1, 1, Conv, [1024, 3, 2]] # 7-P5/32
|
||||
- [-1, 3, C2f, [1024, True]]
|
||||
- [-1, 1, SPPF, [1024, 5]] # 9
|
||||
|
||||
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
|
||||
- [[-1, 34], 1, Concat, [1]] # cat backbone P4
|
||||
- [-1, 3, C2f, [512]] # 12
|
||||
|
||||
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
|
||||
- [[-1, 32], 1, Concat, [1]] # cat backbone P3
|
||||
- [-1, 3, C2f, [256]] # 15 (P3/8-small)
|
||||
|
||||
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
|
||||
- [[-1, 30], 1, Concat, [1]] # cat backbone P2
|
||||
- [-1, 3, C2f, [128]] # 18 (P2/4-xsmall)
|
||||
|
||||
- [-1, 1, Conv, [128, 3, 2]]
|
||||
- [[-1, 43], 1, Concat, [1]] # cat head P3
|
||||
- [-1, 3, C2f, [256]] # 21 (P3/8-small)
|
||||
|
||||
- [-1, 1, Conv, [256, 3, 2]]
|
||||
- [[-1, 40], 1, Concat, [1]] # cat head P4
|
||||
- [-1, 3, C2f, [512]] # 24 (P4/16-medium)
|
||||
|
||||
- [-1, 1, Conv, [512, 3, 2]]
|
||||
- [[-1, 37], 1, Concat, [1]] # cat head P5
|
||||
- [-1, 3, C2f, [1024]] # 27 (P5/32-large)
|
||||
|
||||
######### Fuse Block #############
|
||||
- [[18, 46], 1, CatConvAtt, [128, 3, 1]] # 56 two stream fuse
|
||||
- [[21, 49], 1, CatConvAtt, [256, 3, 1]] # 57 two stream fuse
|
||||
- [[24, 52], 1, CatConvAtt, [512, 3, 1]] # 58 two stream fuse
|
||||
- [[27, 55], 1, CatConvAtt, [1024, 3, 1]] # 59 two stream fuse
|
||||
|
||||
- [[56, 57, 58, 59], 1, Detect, [nc]] # Detect(P2, P3, P4, P5)
|
||||
@@ -0,0 +1,54 @@
|
||||
# Ultralytics YOLO 🚀, AGPL-3.0 license
|
||||
# YOLOv8 object detection model with P2-P5 outputs. For Usage examples see https://docs.ultralytics.com/tasks/detect
|
||||
|
||||
# Parameters
|
||||
nc: 80 # number of classes
|
||||
scales: # model compound scaling constants, i.e. 'model=yolov8n.yaml' will call yolov8.yaml with scale 'n'
|
||||
# [depth, width, max_channels]
|
||||
n: [0.33, 0.25, 1024]
|
||||
s: [0.33, 0.50, 1024]
|
||||
m: [0.67, 0.75, 768]
|
||||
l: [1.00, 1.00, 512]
|
||||
x: [1.00, 1.25, 512]
|
||||
|
||||
# YOLOv8.0 backbone
|
||||
backbone:
|
||||
# [from, repeats, module, args]
|
||||
- [-1, 1, Conv, [64, 3, 2]] # 0-P1/2
|
||||
- [-1, 1, Conv, [128, 3, 2]] # 1-P2/4
|
||||
- [-1, 3, C2f, [128, True]]
|
||||
- [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
|
||||
- [-1, 6, C2f, [256, True]]
|
||||
- [-1, 1, Conv, [512, 3, 2]] # 5-P4/16
|
||||
- [-1, 6, C2f, [512, True]]
|
||||
- [-1, 1, Conv, [1024, 3, 2]] # 7-P5/32
|
||||
- [-1, 3, C2f, [1024, True]]
|
||||
- [-1, 1, SPPF, [1024, 5]] # 9
|
||||
|
||||
# YOLOv8.0-p2 head
|
||||
head:
|
||||
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
|
||||
- [[-1, 6], 1, Concat, [1]] # cat backbone P4
|
||||
- [-1, 3, C2f, [512]] # 12
|
||||
|
||||
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
|
||||
- [[-1, 4], 1, Concat, [1]] # cat backbone P3
|
||||
- [-1, 3, C2f, [256]] # 15 (P3/8-small)
|
||||
|
||||
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
|
||||
- [[-1, 2], 1, Concat, [1]] # cat backbone P2
|
||||
- [-1, 3, C2f, [128]] # 18 (P2/4-xsmall)
|
||||
|
||||
- [-1, 1, Conv, [128, 3, 2]]
|
||||
- [[-1, 15], 1, Concat, [1]] # cat head P3
|
||||
- [-1, 3, C2f, [256]] # 21 (P3/8-small)
|
||||
|
||||
- [-1, 1, Conv, [256, 3, 2]]
|
||||
- [[-1, 12], 1, Concat, [1]] # cat head P4
|
||||
- [-1, 3, C2f, [512]] # 24 (P4/16-medium)
|
||||
|
||||
- [-1, 1, Conv, [512, 3, 2]]
|
||||
- [[-1, 9], 1, Concat, [1]] # cat head P5
|
||||
- [-1, 3, C2f, [1024]] # 27 (P5/32-large)
|
||||
|
||||
- [[18, 21, 24, 27], 1, DetectBin, [nc]] # Detect(P2, P3, P4, P5)
|
||||
@@ -0,0 +1,54 @@
|
||||
# Ultralytics YOLO 🚀, AGPL-3.0 license
|
||||
# YOLOv8 object detection model with P2-P5 outputs. For Usage examples see https://docs.ultralytics.com/tasks/detect
|
||||
|
||||
# Parameters
|
||||
nc: 80 # number of classes
|
||||
scales: # model compound scaling constants, i.e. 'model=yolov8n.yaml' will call yolov8.yaml with scale 'n'
|
||||
# [depth, width, max_channels]
|
||||
n: [0.33, 0.25, 1024]
|
||||
s: [0.33, 0.50, 1024]
|
||||
m: [0.67, 0.75, 768]
|
||||
l: [1.00, 1.00, 512]
|
||||
x: [1.00, 1.25, 512]
|
||||
|
||||
# YOLOv8.0 backbone
|
||||
backbone:
|
||||
# [from, repeats, module, args]
|
||||
- [-1, 1, ConvMaskAtt, [64, 3, 2]] # 0-P1/2
|
||||
- [-1, 1, Conv, [128, 3, 2]] # 1-P2/4
|
||||
- [-1, 3, C2f, [128, True]]
|
||||
- [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
|
||||
- [-1, 6, C2f, [256, True]]
|
||||
- [-1, 1, Conv, [512, 3, 2]] # 5-P4/16
|
||||
- [-1, 6, C2f, [512, True]]
|
||||
- [-1, 1, Conv, [1024, 3, 2]] # 7-P5/32
|
||||
- [-1, 3, C2f, [1024, True]]
|
||||
- [-1, 1, SPPF, [1024, 5]] # 9
|
||||
|
||||
# YOLOv8.0-p2 head
|
||||
head:
|
||||
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
|
||||
- [[-1, 6], 1, Concat, [1]] # cat backbone P4
|
||||
- [-1, 3, C2f, [512]] # 12
|
||||
|
||||
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
|
||||
- [[-1, 4], 1, Concat, [1]] # cat backbone P3
|
||||
- [-1, 3, C2f, [256]] # 15 (P3/8-small)
|
||||
|
||||
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
|
||||
- [[-1, 2], 1, Concat, [1]] # cat backbone P2
|
||||
- [-1, 3, C2f, [128]] # 18 (P2/4-xsmall)
|
||||
|
||||
- [-1, 1, Conv, [128, 3, 2]]
|
||||
- [[-1, 15], 1, Concat, [1]] # cat head P3
|
||||
- [-1, 3, C2f, [256]] # 21 (P3/8-small)
|
||||
|
||||
- [-1, 1, Conv, [256, 3, 2]]
|
||||
- [[-1, 12], 1, Concat, [1]] # cat head P4
|
||||
- [-1, 3, C2f, [512]] # 24 (P4/16-medium)
|
||||
|
||||
- [-1, 1, Conv, [512, 3, 2]]
|
||||
- [[-1, 9], 1, Concat, [1]] # cat head P5
|
||||
- [-1, 3, C2f, [1024]] # 27 (P5/32-large)
|
||||
|
||||
- [[18, 21, 24, 27], 1, Detect, [nc]] # Detect(P2, P3, P4, P5)
|
||||
@@ -0,0 +1,54 @@
|
||||
# Ultralytics YOLO 🚀, AGPL-3.0 license
|
||||
# YOLOv8 object detection model with P2-P5 outputs. For Usage examples see https://docs.ultralytics.com/tasks/detect
|
||||
|
||||
# Parameters
|
||||
nc: 1 # number of classes
|
||||
scales: # model compound scaling constants, i.e. 'model=yolov8n.yaml' will call yolov8.yaml with scale 'n'
|
||||
# [depth, width, max_channels]
|
||||
n: [0.33, 0.25, 1024]
|
||||
s: [0.33, 0.50, 1024]
|
||||
m: [0.67, 0.75, 768]
|
||||
l: [1.00, 1.00, 512]
|
||||
x: [1.00, 1.25, 512]
|
||||
|
||||
# YOLOv8.0 backbone
|
||||
backbone:
|
||||
# [from, repeats, module, args]
|
||||
- [-1, 1, Conv, [64, 3, 2]] # 0-P1/2
|
||||
- [-1, 1, Conv, [128, 3, 2]] # 1-P2/4
|
||||
- [-1, 3, C2f, [128, True]]
|
||||
- [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
|
||||
- [-1, 6, C2f, [256, True]]
|
||||
- [-1, 1, Conv, [512, 3, 2]] # 5-P4/16
|
||||
- [-1, 6, C2f, [512, True]]
|
||||
- [-1, 1, Conv, [1024, 3, 2]] # 7-P5/32
|
||||
- [-1, 3, C2f, [1024, True]]
|
||||
- [-1, 1, SPPF, [1024, 5]] # 9
|
||||
|
||||
# YOLOv8.0-p2 head
|
||||
head:
|
||||
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
|
||||
- [[-1, 6], 1, Concat, [1]] # cat backbone P4
|
||||
- [-1, 3, C2f, [512]] # 12
|
||||
|
||||
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
|
||||
- [[-1, 4], 1, Concat, [1]] # cat backbone P3
|
||||
- [-1, 3, C2f, [256]] # 15 (P3/8-small)
|
||||
|
||||
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
|
||||
- [[-1, 2], 1, Concat, [1]] # cat backbone P2
|
||||
- [-1, 3, C2f, [128]] # 18 (P2/4-xsmall)
|
||||
|
||||
- [-1, 1, Conv, [128, 3, 2]]
|
||||
- [[-1, 15], 1, Concat, [1]] # cat head P3
|
||||
- [-1, 3, C2f, [256]] # 21 (P3/8-small)
|
||||
|
||||
- [-1, 1, Conv, [256, 3, 2]]
|
||||
- [[-1, 12], 1, Concat, [1]] # cat head P4
|
||||
- [-1, 3, C2f, [512]] # 24 (P4/16-medium)
|
||||
|
||||
- [-1, 1, Conv, [512, 3, 2]]
|
||||
- [[-1, 9], 1, Concat, [1]] # cat head P5
|
||||
- [-1, 3, C2f, [1024]] # 27 (P5/32-large)
|
||||
|
||||
- [[18, 21, 24, 27], 1, Detect, [nc]] # Detect(P2, P3, P4, P5)
|
||||
@@ -0,0 +1,54 @@
|
||||
# Ultralytics YOLO 🚀, AGPL-3.0 license
|
||||
# YOLOv8 object detection model with P2-P5 outputs. For Usage examples see https://docs.ultralytics.com/tasks/detect
|
||||
|
||||
# Parameters
|
||||
nc: 80 # number of classes
|
||||
scales: # model compound scaling constants, i.e. 'model=yolov8n.yaml' will call yolov8.yaml with scale 'n'
|
||||
# [depth, width, max_channels]
|
||||
n: [0.33, 0.25, 1024]
|
||||
s: [0.33, 0.50, 1024]
|
||||
m: [0.67, 0.75, 768]
|
||||
l: [1.00, 1.00, 512]
|
||||
x: [1.00, 1.25, 512]
|
||||
|
||||
# YOLOv8.0 backbone
|
||||
backbone:
|
||||
# [from, repeats, module, args]
|
||||
- [-1, 1, Conv, [64, 3, 2]] # 0-P1/2
|
||||
- [-1, 1, Conv, [128, 3, 2]] # 1-P2/4
|
||||
- [-1, 3, C2f, [128, True]]
|
||||
- [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
|
||||
- [-1, 6, C2f, [256, True]]
|
||||
- [-1, 1, Conv, [512, 3, 2]] # 5-P4/16
|
||||
- [-1, 6, C2f, [512, True]]
|
||||
- [-1, 1, Conv, [1024, 3, 2]] # 7-P5/32
|
||||
- [-1, 3, C2f, [1024, True]]
|
||||
- [-1, 1, SPPF, [1024, 5]] # 9
|
||||
|
||||
# YOLOv8.0-p2 head
|
||||
head:
|
||||
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
|
||||
- [[-1, 6], 1, Concat, [1]] # cat backbone P4
|
||||
- [-1, 3, C2f, [512]] # 12
|
||||
|
||||
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
|
||||
- [[-1, 4], 1, Concat, [1]] # cat backbone P3
|
||||
- [-1, 3, C2f, [256]] # 15 (P3/8-small)
|
||||
|
||||
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
|
||||
- [[-1, 2], 1, Concat, [1]] # cat backbone P2
|
||||
- [-1, 3, C2f, [128]] # 18 (P2/4-xsmall)
|
||||
|
||||
- [-1, 1, Conv, [128, 3, 2]]
|
||||
- [[-1, 15], 1, Concat, [1]] # cat head P3
|
||||
- [-1, 3, C2f, [256]] # 21 (P3/8-small)
|
||||
|
||||
- [-1, 1, Conv, [256, 3, 2]]
|
||||
- [[-1, 12], 1, Concat, [1]] # cat head P4
|
||||
- [-1, 3, C2f, [512]] # 24 (P4/16-medium)
|
||||
|
||||
- [-1, 1, Conv, [512, 3, 2]]
|
||||
- [[-1, 9], 1, Concat, [1]] # cat head P5
|
||||
- [-1, 3, C2f, [1024]] # 27 (P5/32-large)
|
||||
|
||||
- [[18, 21, 24, 27], 1, Detect, [nc]] # Detect(P2, P3, P4, P5)
|
||||
@@ -0,0 +1,56 @@
|
||||
# Ultralytics YOLO 🚀, AGPL-3.0 license
|
||||
# YOLOv8 object detection model with P3-P6 outputs. For Usage examples see https://docs.ultralytics.com/tasks/detect
|
||||
|
||||
# Parameters
|
||||
nc: 80 # number of classes
|
||||
scales: # model compound scaling constants, i.e. 'model=yolov8n-p6.yaml' will call yolov8-p6.yaml with scale 'n'
|
||||
# [depth, width, max_channels]
|
||||
n: [0.33, 0.25, 1024]
|
||||
s: [0.33, 0.50, 1024]
|
||||
m: [0.67, 0.75, 768]
|
||||
l: [1.00, 1.00, 512]
|
||||
x: [1.00, 1.25, 512]
|
||||
|
||||
# YOLOv8.0x6 backbone
|
||||
backbone:
|
||||
# [from, repeats, module, args]
|
||||
- [-1, 1, Conv, [64, 3, 2]] # 0-P1/2
|
||||
- [-1, 1, Conv, [128, 3, 2]] # 1-P2/4
|
||||
- [-1, 3, C2f, [128, True]]
|
||||
- [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
|
||||
- [-1, 6, C2f, [256, True]]
|
||||
- [-1, 1, Conv, [512, 3, 2]] # 5-P4/16
|
||||
- [-1, 6, C2f, [512, True]]
|
||||
- [-1, 1, Conv, [768, 3, 2]] # 7-P5/32
|
||||
- [-1, 3, C2f, [768, True]]
|
||||
- [-1, 1, Conv, [1024, 3, 2]] # 9-P6/64
|
||||
- [-1, 3, C2f, [1024, True]]
|
||||
- [-1, 1, SPPF, [1024, 5]] # 11
|
||||
|
||||
# YOLOv8.0x6 head
|
||||
head:
|
||||
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
|
||||
- [[-1, 8], 1, Concat, [1]] # cat backbone P5
|
||||
- [-1, 3, C2, [768, False]] # 14
|
||||
|
||||
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
|
||||
- [[-1, 6], 1, Concat, [1]] # cat backbone P4
|
||||
- [-1, 3, C2, [512, False]] # 17
|
||||
|
||||
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
|
||||
- [[-1, 4], 1, Concat, [1]] # cat backbone P3
|
||||
- [-1, 3, C2, [256, False]] # 20 (P3/8-small)
|
||||
|
||||
- [-1, 1, Conv, [256, 3, 2]]
|
||||
- [[-1, 17], 1, Concat, [1]] # cat head P4
|
||||
- [-1, 3, C2, [512, False]] # 23 (P4/16-medium)
|
||||
|
||||
- [-1, 1, Conv, [512, 3, 2]]
|
||||
- [[-1, 14], 1, Concat, [1]] # cat head P5
|
||||
- [-1, 3, C2, [768, False]] # 26 (P5/32-large)
|
||||
|
||||
- [-1, 1, Conv, [768, 3, 2]]
|
||||
- [[-1, 11], 1, Concat, [1]] # cat head P6
|
||||
- [-1, 3, C2, [1024, False]] # 29 (P6/64-xlarge)
|
||||
|
||||
- [[20, 23, 26, 29], 1, Detect, [nc]] # Detect(P3, P4, P5, P6)
|
||||
@@ -0,0 +1,57 @@
|
||||
# Ultralytics YOLO 🚀, AGPL-3.0 license
|
||||
# YOLOv8-pose-p6 keypoints/pose estimation model. For Usage examples see https://docs.ultralytics.com/tasks/pose
|
||||
|
||||
# Parameters
|
||||
nc: 1 # number of classes
|
||||
kpt_shape: [17, 3] # number of keypoints, number of dims (2 for x,y or 3 for x,y,visible)
|
||||
scales: # model compound scaling constants, i.e. 'model=yolov8n-p6.yaml' will call yolov8-p6.yaml with scale 'n'
|
||||
# [depth, width, max_channels]
|
||||
n: [0.33, 0.25, 1024]
|
||||
s: [0.33, 0.50, 1024]
|
||||
m: [0.67, 0.75, 768]
|
||||
l: [1.00, 1.00, 512]
|
||||
x: [1.00, 1.25, 512]
|
||||
|
||||
# YOLOv8.0x6 backbone
|
||||
backbone:
|
||||
# [from, repeats, module, args]
|
||||
- [-1, 1, Conv, [64, 3, 2]] # 0-P1/2
|
||||
- [-1, 1, Conv, [128, 3, 2]] # 1-P2/4
|
||||
- [-1, 3, C2f, [128, True]]
|
||||
- [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
|
||||
- [-1, 6, C2f, [256, True]]
|
||||
- [-1, 1, Conv, [512, 3, 2]] # 5-P4/16
|
||||
- [-1, 6, C2f, [512, True]]
|
||||
- [-1, 1, Conv, [768, 3, 2]] # 7-P5/32
|
||||
- [-1, 3, C2f, [768, True]]
|
||||
- [-1, 1, Conv, [1024, 3, 2]] # 9-P6/64
|
||||
- [-1, 3, C2f, [1024, True]]
|
||||
- [-1, 1, SPPF, [1024, 5]] # 11
|
||||
|
||||
# YOLOv8.0x6 head
|
||||
head:
|
||||
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
|
||||
- [[-1, 8], 1, Concat, [1]] # cat backbone P5
|
||||
- [-1, 3, C2, [768, False]] # 14
|
||||
|
||||
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
|
||||
- [[-1, 6], 1, Concat, [1]] # cat backbone P4
|
||||
- [-1, 3, C2, [512, False]] # 17
|
||||
|
||||
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
|
||||
- [[-1, 4], 1, Concat, [1]] # cat backbone P3
|
||||
- [-1, 3, C2, [256, False]] # 20 (P3/8-small)
|
||||
|
||||
- [-1, 1, Conv, [256, 3, 2]]
|
||||
- [[-1, 17], 1, Concat, [1]] # cat head P4
|
||||
- [-1, 3, C2, [512, False]] # 23 (P4/16-medium)
|
||||
|
||||
- [-1, 1, Conv, [512, 3, 2]]
|
||||
- [[-1, 14], 1, Concat, [1]] # cat head P5
|
||||
- [-1, 3, C2, [768, False]] # 26 (P5/32-large)
|
||||
|
||||
- [-1, 1, Conv, [768, 3, 2]]
|
||||
- [[-1, 11], 1, Concat, [1]] # cat head P6
|
||||
- [-1, 3, C2, [1024, False]] # 29 (P6/64-xlarge)
|
||||
|
||||
- [[20, 23, 26, 29], 1, Pose, [nc, kpt_shape]] # Pose(P3, P4, P5, P6)
|
||||
@@ -0,0 +1,47 @@
|
||||
# Ultralytics YOLO 🚀, AGPL-3.0 license
|
||||
# YOLOv8-pose keypoints/pose estimation model. For Usage examples see https://docs.ultralytics.com/tasks/pose
|
||||
|
||||
# Parameters
|
||||
nc: 1 # number of classes
|
||||
kpt_shape: [17, 3] # number of keypoints, number of dims (2 for x,y or 3 for x,y,visible)
|
||||
scales: # model compound scaling constants, i.e. 'model=yolov8n-pose.yaml' will call yolov8-pose.yaml with scale 'n'
|
||||
# [depth, width, max_channels]
|
||||
n: [0.33, 0.25, 1024]
|
||||
s: [0.33, 0.50, 1024]
|
||||
m: [0.67, 0.75, 768]
|
||||
l: [1.00, 1.00, 512]
|
||||
x: [1.00, 1.25, 512]
|
||||
|
||||
# YOLOv8.0n backbone
|
||||
backbone:
|
||||
# [from, repeats, module, args]
|
||||
- [-1, 1, Conv, [64, 3, 2]] # 0-P1/2
|
||||
- [-1, 1, Conv, [128, 3, 2]] # 1-P2/4
|
||||
- [-1, 3, C2f, [128, True]]
|
||||
- [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
|
||||
- [-1, 6, C2f, [256, True]]
|
||||
- [-1, 1, Conv, [512, 3, 2]] # 5-P4/16
|
||||
- [-1, 6, C2f, [512, True]]
|
||||
- [-1, 1, Conv, [1024, 3, 2]] # 7-P5/32
|
||||
- [-1, 3, C2f, [1024, True]]
|
||||
- [-1, 1, SPPF, [1024, 5]] # 9
|
||||
|
||||
# YOLOv8.0n head
|
||||
head:
|
||||
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
|
||||
- [[-1, 6], 1, Concat, [1]] # cat backbone P4
|
||||
- [-1, 3, C2f, [512]] # 12
|
||||
|
||||
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
|
||||
- [[-1, 4], 1, Concat, [1]] # cat backbone P3
|
||||
- [-1, 3, C2f, [256]] # 15 (P3/8-small)
|
||||
|
||||
- [-1, 1, Conv, [256, 3, 2]]
|
||||
- [[-1, 12], 1, Concat, [1]] # cat head P4
|
||||
- [-1, 3, C2f, [512]] # 18 (P4/16-medium)
|
||||
|
||||
- [-1, 1, Conv, [512, 3, 2]]
|
||||
- [[-1, 9], 1, Concat, [1]] # cat head P5
|
||||
- [-1, 3, C2f, [1024]] # 21 (P5/32-large)
|
||||
|
||||
- [[15, 18, 21], 1, Pose, [nc, kpt_shape]] # Pose(P3, P4, P5)
|
||||
Loaded 100 of 568 files, more files were not shown because too many files have changed in this diff.
Show more
Reference in new issue
Block a user