AI TRAINING
NORDIC MODELS

Off-the-shelf YOLOv8 models are trained on general datasets (COCO, ImageNet). They can detect "car" and "person" but not "Strv 122 main battle tank in winter camouflage." Nordic-specific training creates models that see what matters in our operational environment.

Why Generic AI Fails In Nordic Terrain

A model trained on urban American road images recognizes Toyotas and Chevrolets on asphalt. Show it a white-painted Bandvagn 206 in a snowfield and it sees nothing. The backgrounds are different (snow vs asphalt), the vehicles are different (military vs civilian), and the camouflage is specifically designed to defeat visual recognition.

Nordic-specific training teaches the AI to see through winter camouflage against snow, distinguish military vehicles from civilian ones in Swedish terrain, detect personnel wearing white winter overalls in a birch forest, and function in the flat low-angle light of Nordic winter (sun barely above horizon at 66°N latitude in December).

How Training Works — Plain Language

Imagine teaching a child to recognize dogs. You show them 1,000 photos of dogs. For each photo, you point and say "dog." After enough photos, the child can recognize dogs in photos they've never seen before — including breeds they weren't shown. That's machine learning.

For military AI: you collect thousands of drone photos showing vehicles, personnel, and installations in Nordic terrain. For each photo, you draw a box around every object and label it: "armored_vehicle", "truck", "personnel", "observation_post." Then you feed these labeled photos into YOLOv8's training algorithm. After several hours of computation on a GPU, the model has learned to automatically detect and classify those objects in new, unseen camera frames.

Training Pipeline

Dataset Curation for Nordic Environments

The COCO dataset that YOLOv8 is pre-trained on contains zero images of Swedish military vehicles, zero images of snow-covered terrain, and zero images taken at -20°C where thermal contrast is fundamentally different from temperate conditions. Fine-tuning on a Nordic-specific dataset is not optional — it is the difference between a system that works and one that produces continuous false positives on snow-covered rocks that resemble vehicle hulls.

Nordic dataset construction: 5,000 annotated images collected across four seasons in Norrbotten, Gotland, and Skåne training areas. Vehicle classes: Strv 122, Strf 90, Patgb 360, Tgb 30, BV 206, civilian vehicles (for negative training). Conditions: daylight, darkness, rain, snow, fog, dawn, dusk. Camouflage: standard Swedish M90 pattern with and without thermal reduction nets. Thermal images: separate dataset of 3,000 frames from Infiray T2S+ at temperatures ranging from -30°C to +25°C. Data augmentation (mosaic, mixup, random brightness, horizontal flip) expands the effective dataset to 50,000+ training examples. Fine-tuning: 100 epochs on NVIDIA A100 (cloud) or 300 epochs on Jetson Orin Nano (local, 48 hours).

Training Mathematics — Derivation of Convergence Requirements

The number of training examples required for acceptable generalisation follows an empirical power law for deep convolutional networks. For YOLOv8-n (the smallest variant), the required dataset size N for a desired mean Average Precision (mAP) follows approximately:

N ≈ k · (mAP_target / (1 − mAP_target))^α

Expressed as runnable code: N_required = k * (mAP / (1 - mAP)) ** alpha where k = 200 and alpha = 1.5 are the empirically derived constants for YOLOv8-n fine-tuning. For the target mAP = 0.85: N = 200 * (0.85/0.15) ** 1.5 = 2580 boxes per class.

where k ≈ 200 and α ≈ 1.5 for fine-tuning from a COCO-pretrained checkpoint. To achieve mAP@0.5 = 0.85 on Nordic vehicle classes: N ≈ 200 × (0.85 / 0.15)^1.5 ≈ 200 × 12.9 ≈ 2,580 labelled examples per class minimum. With six vehicle classes, the minimum dataset is approximately 15,500 labelled boxes — the 50,000 we target with augmentation provides 3× headroom.

Loss convergence during training follows the characteristic three-phase curve: rapid descent during the first ~10 epochs (pre-trained weights adapt to new classes), slower refinement during epochs 10-60 (feature extractors tune to Nordic textures), and fine polish during epochs 60-100 (bounding-box regression sharpens). Training loss below 1.2 with validation loss within 15% of training loss indicates healthy convergence without overfitting.

Worked Example — Training a Tier-2 Armour Detector

Consider the operational scenario of training a detector that distinguishes T-72 and T-90 from friendly Strv 122 at Fischer 26E altitudes (500-700 m AGL, GSD ≈ 5-8 cm/px). The training pipeline for this three-class problem is as follows.

Dataset composition: 2,500 labelled Strv 122 boxes, 2,500 T-72 boxes (sourced from public-domain OSINT imagery per the lisa26-osint-humint.html pipeline), and 2,500 T-90 boxes. Negative examples: 5,000 civilian vehicles, birch trees with snow load, and rock outcrops that have historically caused false positives. Total: 12,500 labelled boxes. Augmentation expands this to 125,000 training examples. Train/validation split: 80/20. Expected training time on a single RTX 3060: 2.5 hours. Expected validation mAP@0.5: 0.88.

Runtime inference: Fischer 26E sends 1920×1080 H.264 frames to Jetson Orin Nano at 30 FPS. YOLOv8-n processes every frame in 22 ms, yielding 45 inference FPS — the bottleneck is the H.264 decoder, not the AI. Detection output feeds directly into libfischer26e.fusion where it combines with IR and radar tracks via Dempster-Shafer combination (see lisa26-dempster-shafer.html).

Why Training Matters — Operational Consequences

A model trained only on COCO will detect approximately 39% of visible military vehicles in Nordic terrain — the other 61% blend into the backgrounds the model has never seen. Under operational conditions this translates directly into missed threat warnings and false alarms on civilian traffic. Fischer 26/26E must achieve target classification accuracy above 85% — below that threshold, the operator overhead of clearing false positives exceeds the platform's productivity gain. Nordic-specific training is therefore not an optimisation; it is a threshold capability.

The second reason training matters is class distribution. An AI trained to recognise any armoured vehicle can still misclassify a Strv 122 as a T-72 if the model has never seen both in the same lighting conditions. For IFF-relevant classification (see lisa26-iff-deconfliction.html), the model must distinguish friendly from hostile platforms with per-class precision above 0.95, which is only achievable when training data includes both classes in every operational condition. Generic models collapse this distinction; Nordic-specific training preserves it.

Implementation

# YOLOv8 Nordic Fine-Tuning
# Train on Swedish terrain: snow, spruce forest, Swedish vehicles at -30°C
# pip install ultralytics
from ultralytics import YOLO

# Load pretrained (COCO) and fine-tune on Nordic dataset
model = YOLO("yolov8n.pt")

# nordic.yaml defines: train/val split, class names, augmentation
results = model.train(
    data="nordic.yaml",
    epochs=100,
    imgsz=640,
    batch=16,
    device=0,           # GPU 0
    augment=True,        # Random flip, rotate, brightness
    mosaic=1.0,          # Mosaic augmentation (critical for small objects)
    mixup=0.1,           # Cross-image mixing
    name="nordic_v3"
)

# Export to TensorRT for Jetson Orin Nano
model.export(format="engine", device=0, half=True)  # FP16

# Deploy: copy nordic_v3.engine to Jetson SD card
# Rollback: copy previous version. 30 seconds. Never untested model to combat.

Validation Script — Detect Overfitting

# pip install ultralytics
# validate_nordic.py — Run after training to verify generalisation
# Detects overfitting by comparing train vs validation mAP
from ultralytics import YOLO

model = YOLO("runs/detect/nordic_v3/weights/best.pt")

# Evaluate on held-out validation set
metrics = model.val(data="nordic.yaml", split="val")

train_map = metrics.box.map50_train if hasattr(metrics.box, 'map50_train') else None
val_map = metrics.box.map50

print(f"Validation mAP@0.5: {val_map:.3f}")
print(f"Per-class precision: {metrics.box.mp:.3f}")
print(f"Per-class recall:    {metrics.box.mr:.3f}")

# Fail CI if mAP drops below operational threshold
ACCEPTANCE_THRESHOLD = 0.85
if val_map < ACCEPTANCE_THRESHOLD:
    print(f"✗ Model mAP {val_map:.3f} below threshold {ACCEPTANCE_THRESHOLD}")
    print("  Do NOT deploy. Collect more data or adjust training.")
    exit(1)

# Warn if train/val gap indicates overfitting
if train_map and (train_map - val_map) > 0.10:
    print(f"⚠ Possible overfit: train mAP {train_map:.3f} vs val mAP {val_map:.3f}")
    print("  Reduce epochs, add more augmentation, or collect more data.")

print("✓ Model passes operational threshold. Safe to deploy.")

Sources

YOLOv8 training documentation (docs.ultralytics.com). CVAT annotation tool (github.com/cvat-ai/cvat). TensorRT deployment guide for Jetson (developer.nvidia.com). Transfer learning for military vehicle detection — FOI research (2024).

Related Chapters