A fine-tuned YOLOv8n-cls model that classifies 64×64 image patches from a Go board into three classes: empty, black stone, or white stone. Trained on synthetic board renders from SGF game records, then exported to Core ML for on-device inference on iOS.

Model Details


Base Model	`yolov8n-cls.pt` (Ultralytics YOLOv8 Nano)
Task	Image Classification (3 classes)
Input Size	64×64 pixels
Classes	`empty`, `black`, `white`
Framework	Ultralytics YOLOv8
Training Device	Apple MPS (Metal Performance Shaders)
Optimizer	AdamW
Epochs	30 (early stopped at 17)
Batch Size	128
Learning Rate	0.001 (cosine schedule)

Performance

Metric	Value
Top-1 Accuracy	100%
Top-5 Accuracy	100%
Best Val Loss	0.00011 (epoch 17)
Best Train Loss	0.00204 (epoch 14)

The model converges rapidly — reaching >99.9% accuracy by epoch 1 — because the 64×64 patch classification task is well-separated for these three classes.

Training Data

Synthetic 64×64 image patches extracted from Go board renders generated from SGF game records. The dataset includes:

Renders with realistic stone textures, grid lines, star points
Multiple renders per board state (3 renders with random augmentation)
Up to 10 board snapshots per SGF game
Dataset split: 70% train / 15% val / 15% test

Repository Contents

.
├── weights/
│   ├── best.pt              # Best checkpoint (val_loss=0.00011)
│   └── last.pt              # Final epoch checkpoint
├── args.yaml                # Training configuration
├── results.csv              # Per-epoch metrics
├── results.png              # Training curves
├── confusion_matrix.png     # Confusion matrix
├── confusion_matrix_normalized.png
└── best.mlpackage/          # Core ML export for iOS
    ├── Manifest.json
    └── Data/com.apple.CoreML/
        ├── model.mlmodel
        └── weights/weight.bin

Usage

Python (Ultralytics)

python

from ultralytics import YOLO

model = YOLO("best.pt")
results = model("path/to/go_board.jpg")

iOS (Core ML)

Drop best.mlpackage into your Xcode project. The model accepts a 64×64 RGB image and outputs class probabilities for empty/black/white.

swift

import CoreML
import Vision

guard let model = try? VNCoreMLModel(for: go_stone_classifier().model) else { return }
let request = VNCoreMLRequest(model: model) { request, error in
    if let results = request.results as? [VNClassificationObservation] {
        for result in results {
            print("\(result.identifier): \(result.confidence)")
        }
    }
}

Citation

If you use this model, please cite:

bibtex

@misc{yolo-go-stone-classifier,
  author = {rociiu},
  title = {YOLOv8n-cls Go Stone Classifier},
  year = {2026},
  publisher = {Hugging Face},
  howpublished = {\url{https://huggingface.co/rociiu/yolo-go-stone-classifier}},
}

License

MIT