# ╔══════════════════════════════════════════════════════════════════╗
# ║ Rig Conductor — gui.labelling_wizard ║
# ║ « more SLEAP training data from the recordings we make » ║
# ╠══════════════════════════════════════════════════════════════════╣
# ║ Start → Recordings → Frames → Package (new frames) ║
# ║ Start → Continue (picked frames) ║
# ║ Start → Bring back (labelled frames) ║
# ║ Start → Training data → Train (Aoraki, promote) ║
# ╚══════════════════════════════════════════════════════════════════╝
"""The training-data wizard (second wizard of Rig Conductor).
All SLEAP work runs in the SLEAP 1.6 env as child processes
(:mod:`rigconductor.sleapenv`); this window only shows progress and choices.
"""
from __future__ import annotations
import getpass
import sys
from pathlib import Path
from PyQt6.QtCore import QSize, Qt, QTimer
from PyQt6.QtGui import QColor, QPainter, QPixmap
from PyQt6.QtWidgets import (
QAbstractItemView,
QApplication,
QButtonGroup,
QCheckBox,
QComboBox,
QDialog,
QFileDialog,
QFormLayout,
QHBoxLayout,
QHeaderView,
QLabel,
QLineEdit,
QMessageBox,
QPlainTextEdit,
QPushButton,
QRadioButton,
QSpinBox,
QTableWidget,
QTableWidgetItem,
QVBoxLayout,
QWidget,
QWizard,
QWizardPage,
)
from rigconductor import ConductorError, sleapenv
from rigconductor import models as models_mod
from rigconductor.config import ConductorConfig
from rigconductor.constants import (
LABEL_FRAMES_PER_ARENA,
LABEL_MIN_GAP_S,
LABEL_MIX,
LABEL_PROFILE,
LABEL_TEST_SHARE,
LABEL_THUMB_PX,
TRAIN_EPOCHS,
TRAIN_POLL_S,
TRAIN_TABLE_MAX_PX,
WONG,
)
from rigconductor.export import removable_disks
from rigconductor.gui import dialogs
from rigconductor.gui.help_window import add_help_button
from rigconductor.gui.progress import ProgressPanel, parse_progress
from rigconductor.gui.train_progress import TrainingProgress
from rigconductor.gui.wizard import Worker
from rigconductor.labels import package as pkg_mod
from rigconductor.labels import train as train_mod
from rigconductor.labels.recordings import Recording, find_recordings
from rigconductor.labels.store import LabelSet, default_set, list_sets, set_default
(
PAGE_START,
PAGE_RECS,
PAGE_FRAMES,
PAGE_PACKAGE,
PAGE_CONTINUE,
PAGE_BACK,
PAGE_DATA,
PAGE_TRAIN,
) = range(8)
MODES = (
("new", "Pick new frames to label", PAGE_RECS),
("continue", "Continue labelling frames picked earlier", PAGE_CONTINUE),
("back", "Bring labelled frames back", PAGE_BACK),
("train", "Choose training data and train a model on Aoraki", PAGE_DATA),
)
OPEN_PACKAGE_STATES = ("out", "returned") # packages not merged yet
def _item(text, checkable: bool = False, checked: bool = False) -> QTableWidgetItem:
it = QTableWidgetItem(str(text))
flags = Qt.ItemFlag.ItemIsEnabled | Qt.ItemFlag.ItemIsSelectable
if checkable:
flags |= Qt.ItemFlag.ItemIsUserCheckable
it.setCheckState(Qt.CheckState.Checked if checked else Qt.CheckState.Unchecked)
it.setFlags(flags)
return it
def _table(headers: list[str]) -> QTableWidget:
t = QTableWidget(0, len(headers))
t.setHorizontalHeaderLabels(headers)
t.horizontalHeader().setSectionResizeMode(QHeaderView.ResizeMode.ResizeToContents)
t.horizontalHeader().setStretchLastSection(True)
t.verticalHeader().setVisible(False)
return t
[docs]
class TaskPage(QWizardPage):
"""A page with a log, a progress bar and one background task at a time."""
def __init__(self, wiz: LabellingWizard, title: str, subtitle: str):
super().__init__()
self.wiz = wiz
self.setTitle(title)
self.setSubTitle(subtitle)
self.lay = QVBoxLayout(self)
self.progress = ProgressPanel()
self.log = QPlainTextEdit()
self.log.setReadOnly(True)
self.log.setMaximumBlockCount(2000)
def add_log_widgets(self, stretch: int = 1):
self.lay.addWidget(self.progress)
self.lay.addWidget(self.log, stretch)
def add_line(self, line: str):
p = parse_progress(line)
if p is not None:
self.progress.show_line(p)
else:
self.log.appendPlainText(line)
[docs]
def run(self, fn, done):
"""Run ``fn(emit)`` in the worker; ``done(ok, msg)`` afterwards."""
def finished(ok, msg):
self.progress.finish(ok)
if not ok:
dialogs.critical(self, "Failed", msg)
done(ok, msg)
self.wiz.run_in_worker(fn, finished, self.add_line)
def progress_to(emit):
return lambda frac, text: emit(f"@progress label {frac:.3f} {text}")
# ── start ─────────────────────────────────────────────────────────
[docs]
class StartPage(TaskPage):
manual_section = "Start"
def __init__(self, wiz):
super().__init__(wiz, "Training data", "Grow a label set, bring labels back, or train.")
form = QFormLayout()
self.set_combo = QComboBox()
self.set_combo.currentIndexChanged.connect(self._set_changed)
row = QHBoxLayout()
row.addWidget(self.set_combo, 1)
new_btn = QPushButton("New set from a SLEAP project…")
new_btn.clicked.connect(self._new_set)
row.addWidget(new_btn)
self.default_btn = QPushButton("Make default")
self.default_btn.setToolTip("Pre-selected here and copied to Aoraki by label-sync")
self.default_btn.clicked.connect(self._make_default)
row.addWidget(self.default_btn)
form.addRow("Label set", row)
self.summary = QLabel("")
self.summary.setWordWrap(True)
form.addRow("", self.summary)
self.lay.addLayout(form)
self.mode = QButtonGroup(self)
for i, (key, text, page) in enumerate(MODES):
b = QRadioButton(text)
b.setProperty("key", key)
b.setProperty("page", page)
self.mode.addButton(b, i)
self.lay.addWidget(b)
self.mode.button(0).setChecked(True)
sleap_row = QHBoxLayout()
self.sleap_status = QLabel("SLEAP: checking…")
sleap_row.addWidget(self.sleap_status, 1)
self.setup_btn = QPushButton("Set up SLEAP")
self.setup_btn.setToolTip("Install SLEAP (CPU build) for this user; no GPU or sudo needed")
self.setup_btn.clicked.connect(self._setup_sleap)
sleap_row.addWidget(self.setup_btn)
self.lay.addLayout(sleap_row)
self.add_log_widgets()
[docs]
def initializePage(self): # noqa: N802
self.fill_sets()
QTimer.singleShot(0, self.check_sleap)
def fill_sets(self, select: str | None = None):
self.set_combo.blockSignals(True)
self.set_combo.clear()
for name in list_sets():
self.set_combo.addItem(name)
select = select or default_set()
if select:
self.set_combo.setCurrentText(select)
self.set_combo.blockSignals(False)
self._set_changed()
def _set_changed(self, *_):
name = self.set_combo.currentText()
self.wiz.lset = LabelSet.load(name) if name else None
is_default = bool(name) and name == default_set()
self.default_btn.setEnabled(bool(name) and not is_default)
self.default_btn.setText("Default set" if is_default else "Make default")
self.summary.setText(describe_set(self.wiz.lset))
self.completeChanged.emit()
def _make_default(self):
set_default(self.set_combo.currentText())
self._set_changed()
def check_sleap(self):
self.wiz.env = sleapenv.find()
if self.wiz.env:
self.sleap_status.setText(
f"SLEAP {self.wiz.env.version} ready ({self.wiz.env.bin_dir})"
)
self.setup_btn.setText("Reinstall SLEAP")
else:
self.sleap_status.setText("SLEAP is not installed for this user yet.")
self.completeChanged.emit()
def _setup_sleap(self):
reinstall = self.wiz.env is not None
self.setup_btn.setEnabled(False)
def job(emit):
sleapenv.install(log=emit, reinstall=reinstall)
def done(ok, _msg):
self.setup_btn.setEnabled(True)
self.check_sleap()
self.run(job, done)
def _new_set(self):
if not self.wiz.env:
dialogs.information(self, "SLEAP", "Set up SLEAP first.")
return
src, _ = QFileDialog.getOpenFileName(
self, "SLEAP project with hand labels", str(Path.home() / "data"), "SLEAP (*.slp)"
)
if not src:
return
name = self.set_combo.currentText() or LABEL_PROFILE
name, ok = _ask_text(self, "Label set name", "Name of the new label set:", name)
if not ok or not name:
return
env = self.wiz.env
def job(emit):
info = sleapenv.run_task(env, "inspect", {"slp": src}, log=emit)
lset = LabelSet.create(name, info["nodes"])
res = sleapenv.run_task(
env,
"seed",
{"src": src, "out": str(lset.path / "v1.pkg.slp"), "set": name},
log=emit,
progress=progress_to(emit),
)
lset.add_version(res, note=f"seed from {Path(src).name}")
lset.add_project(src, note="seed of v1; keep labelling it and bring it back")
emit(f"label set '{name}' v1: {res['frames']} frames, {res['instances']} flies")
self.run(job, lambda ok, _m: ok and self.fill_sets(name))
[docs]
def isComplete(self): # noqa: N802
return self.wiz.lset is not None and self.wiz.env is not None
[docs]
def nextId(self): # noqa: N802
return self.mode.checkedButton().property("page")
def describe_set(lset: LabelSet | None) -> str:
if lset is None:
return "No label set yet: create one from an existing SLEAP project."
v = lset.latest()
if not v:
return f"{lset.name}: no versions yet"
recs = ", ".join(f"{r} ({n})" for r, n in v.get("recordings", {}).items())
scales = ", ".join(f"{s}: {n}" for s, n in v.get("scales", {}).items())
out_pk = sum(1 for p in lset.data["packages"] if p.get("status") in OPEN_PACKAGE_STATES)
val = "; ".join(f"{s}: {', '.join(r)}" for s, r in lset.data["validation"].items()) or "none"
return (
f"<b>v{v['version']}</b>: {v['frames']} frames, {v['instances']} flies · scales {scales}"
f"<br>recordings: {recs}<br>validation recordings: {val}"
f"<br>packages out for labelling: {out_pk}"
)
def _ask_text(parent, title, label, default=""):
return dialogs.get_text(parent, title, label, default)
# ── recordings ────────────────────────────────────────────────────
[docs]
class RecordingsPage(TaskPage):
manual_section = "Pick new frames: Recordings"
COLS = ["Use", "Validation only", "Recording", "Date", "Scale", "Arenas", "Poses", "In set"]
def __init__(self, wiz):
super().__init__(
wiz,
"Recordings",
"Tick the recordings to take frames from. Validation recordings are never "
"used for training; they test every new model (one per camera scale).",
)
filt = QHBoxLayout()
self.only_new = QCheckBox("Only recordings not in the label set yet")
self.only_new.setChecked(True)
self.only_new.toggled.connect(self.fill)
self.only_pose = QCheckBox("Only analysed recordings (with poses)")
self.only_pose.toggled.connect(self.fill)
filt.addWidget(self.only_new)
filt.addWidget(self.only_pose)
filt.addStretch(1)
self.lay.addLayout(filt)
self.table = _table(self.COLS)
self.table.itemChanged.connect(lambda *_: self.completeChanged.emit())
self.lay.addWidget(self.table, 1)
self.recs: list[Recording] = []
[docs]
def initializePage(self): # noqa: N802
self.all_recs = find_recordings(self.wiz.cfg.data_root)
self.fill()
def fill(self, *_):
lset = self.wiz.lset
in_set = set((lset.latest() or {}).get("recordings", {})) if lset else set()
val = lset.validation_recordings() if lset else set()
self.recs = [
r
for r in self.all_recs
if (not self.only_new.isChecked() or r.name not in in_set or r.name in val)
and (not self.only_pose.isChecked() or r.poses)
]
self.table.blockSignals(True)
self.table.setRowCount(len(self.recs))
for i, r in enumerate(self.recs):
cells = [
_item("", True, False),
_item("", True, r.name in val),
_item(r.name),
_item(r.date),
_item(r.scale),
_item(len(r.clips)),
_item(f"{len(r.poses)}/{len(r.clips)}"),
_item("yes" if r.name in in_set else ""),
]
for c, it in enumerate(cells):
self.table.setItem(i, c, it)
self.table.blockSignals(False)
self.completeChanged.emit()
def _checked(self, col: int) -> list[Recording]:
return [
r
for i, r in enumerate(self.recs)
if self.table.item(i, col).checkState() == Qt.CheckState.Checked
]
def chosen(self) -> list[Recording]:
return self._checked(0)
[docs]
def isComplete(self): # noqa: N802
return bool(self.chosen())
[docs]
def validatePage(self): # noqa: N802
val = self._checked(1)
if val:
by_scale: dict[str, list[str]] = {}
for r in val:
by_scale.setdefault(r.scale, []).append(r.name)
for scale, names in by_scale.items():
old = set(self.wiz.lset.data["validation"].get(scale, []))
self.wiz.lset.set_validation(scale, sorted(old | set(names)))
self.wiz.recordings = self.chosen()
return True
# ── frames ────────────────────────────────────────────────────────
[docs]
class FramesPage(TaskPage):
manual_section = "Pick new frames: Frames"
def __init__(self, wiz):
super().__init__(
wiz,
"Frames",
"How many frames per arena, and how to choose them. Unsure = the model doubted "
"itself; contact = flies touch; spread = evenly over the clip.",
)
form = QFormLayout()
self.n = QSpinBox()
self.n.setRange(1, 200)
self.n.setValue(LABEL_FRAMES_PER_ARENA)
form.addRow("Frames per arena", self.n)
mix_row = QHBoxLayout()
self.mix = {}
for key, text in (("unsure", "unsure"), ("contact", "contact"), ("uniform", "spread")):
s = QSpinBox()
s.setRange(0, 100)
s.setSuffix(" %")
s.setValue(round(LABEL_MIX[key] * 100))
self.mix[key] = s
mix_row.addWidget(QLabel(text))
mix_row.addWidget(s)
mix_row.addStretch(1)
form.addRow("Mix", mix_row)
self.prefill = QComboBox()
form.addRow("Pre-fill with model", self.prefill)
self.lay.addLayout(form)
btns = QHBoxLayout()
self.pick_btn = QPushButton("Choose frames")
self.pick_btn.clicked.connect(self.pick)
btns.addWidget(self.pick_btn)
self.picked_label = QLabel("")
btns.addWidget(self.picked_label, 1)
self.lay.addLayout(btns)
self.table = _table(["Recording", "Arena", "Frame", "Why", "Score"])
self.lay.addWidget(self.table, 2)
self.add_log_widgets(1)
self.frames: list[dict] = []
[docs]
def initializePage(self): # noqa: N802
self.prefill.clear()
self.prefill.addItem("none (empty frames)", None)
for run_id in train_mod.local_runs():
self.prefill.addItem(run_id, run_id)
want = self.wiz.default_model()
i = self.prefill.findData(want) if want else -1
self.prefill.setCurrentIndex(i if i >= 0 else min(1, self.prefill.count() - 1))
self.frames = []
self.table.setRowCount(0)
self.picked_label.setText("")
self.completeChanged.emit()
def pick(self):
env, lset = self.wiz.env, self.wiz.lset
clips = [c for r in self.wiz.recordings for c in r.clip_entries()]
val = lset.validation_recordings()
args = {
"clips": clips,
"n": self.n.value(),
"mix": {k: s.value() / 100 for k, s in self.mix.items()},
"min_gap_s": LABEL_MIN_GAP_S,
"n_expected": 3,
"exclude": [list(x) for x in lset.labelled_frames()],
}
self.pick_btn.setEnabled(False)
result = {}
def job(emit):
result.update(
sleapenv.run_task(env, "select", args, log=emit, progress=progress_to(emit))
)
def done(ok, _m):
self.pick_btn.setEnabled(True)
if ok:
self.show_frames(result["frames"], val)
self.run(job, done)
def show_frames(self, frames: list[dict], val: set[str]):
self.frames = frames
self.table.setRowCount(len(frames))
for i, f in enumerate(frames):
why = f["reason"] + (" · validation" if f["recording"] in val else "")
for c, v in enumerate(
[f["recording"], f"{int(f['arena']):02d}", f["frame"], why, f.get("score", "")]
):
self.table.setItem(i, c, _item(v))
n_rec = len({f["recording"] for f in frames})
self.picked_label.setText(f"{len(frames)} frames from {n_rec} recordings")
self.completeChanged.emit()
[docs]
def isComplete(self): # noqa: N802
return bool(self.frames)
[docs]
def validatePage(self): # noqa: N802
self.wiz.frames = self.frames
self.wiz.prefill_run = self.prefill.currentData()
return True
# ── package ───────────────────────────────────────────────────────
[docs]
class PackagePage(TaskPage):
manual_section = "Pick new frames: Where to label"
def __init__(self, wiz):
super().__init__(
wiz,
"Where to label",
"Label on this PC, or write a package to a USB stick for another Linux PC "
"(it carries the frames, the rules and a SLEAP installer).",
)
self.where = QComboBox()
self.lay.addWidget(self.where)
row = QHBoxLayout()
self.go = QPushButton("Make the package")
self.go.clicked.connect(self.make)
row.addWidget(self.go)
self.result = QLabel("")
self.result.setWordWrap(True)
row.addWidget(self.result, 1)
self.lay.addLayout(row)
self.add_log_widgets()
self.made = False
[docs]
def initializePage(self): # noqa: N802
self.where.clear()
self.where.addItem("Label here on this PC (opens SLEAP)", "here")
for d in removable_disks():
if d.mountpoint:
self.where.addItem(f"USB stick: {d.text}", d.mountpoint)
self.where.addItem("A folder…", "__dir__")
self.made = False
self.completeChanged.emit()
def make(self):
where = self.where.currentData()
dest = None
if where == "__dir__":
d = QFileDialog.getExistingDirectory(self, "Package folder", str(Path.home()))
if not d:
return
dest = Path(d)
elif where != "here":
dest = Path(where)
lset, env, frames = self.wiz.lset, self.wiz.env, self.wiz.frames
prefill = train_mod.model_dirs(self.wiz.prefill_run) if self.wiz.prefill_run else None
out = {}
self.go.setEnabled(False)
def job(emit):
out["path"] = pkg_mod.build_package(
lset, frames, env, prefill=prefill, dest=dest, log=emit, progress=progress_to(emit)
)
def done(ok, _m):
self.go.setEnabled(not ok)
if not ok:
return
self.made = True
path = out["path"]
if where == "here":
sleapenv.open_labelling(env, path / pkg_mod.LABELS_FILE)
self.result.setText(
f"SLEAP opened <b>{path / pkg_mod.LABELS_FILE}</b>. When you are done, "
"save and start this wizard again with 'Bring labelled frames back'."
)
else:
self.result.setText(
f"Package written to <b>{path}</b>. On the labelling PC run "
"<code>label.sh</code> in that folder (it installs SLEAP the first time)."
)
self.completeChanged.emit()
self.run(job, done)
[docs]
def isComplete(self): # noqa: N802
return self.made
[docs]
def nextId(self): # noqa: N802
return -1
# ── packages out for labelling ────────────────────────────────────
[docs]
def open_packages(lset: LabelSet, extra_roots: list[Path] = ()) -> list[tuple[Path, str, dict]]:
"""Unmerged packages of ``lset``: (folder, where, info), sticks before this PC.
A package written to a stick has a copy on this PC too; the stick copy is
the one that gets labelled, so it wins when both are there.
"""
roots = [(Path(d.mountpoint), "stick") for d in removable_disks() if d.mountpoint]
roots += [(Path(r), "folder") for r in extra_roots]
found = [(p, where) for root, where in roots for p in pkg_mod.find_packages(root)]
found += [(p, "this PC") for p in sorted((lset.path / "packages").glob("*"))]
out, seen = [], set()
for folder, where in found:
try:
info = pkg_mod.read_info(folder)
entry = lset.package(info["id"])
except (ConductorError, KeyError):
continue
if info.get("set") != lset.name or info["id"] in seen:
continue
if entry.get("status") not in OPEN_PACKAGE_STATES:
continue
seen.add(info["id"])
out.append((folder, where, {**info, **entry})) # entry: frame count, status
return out
STATE_COLOURS = { # labelled / only predicted / nothing yet
"labelled": WONG["bluish_green"],
"predicted": WONG["yellow"],
"empty": WONG["vermillion"],
}
[docs]
class LabelBar(QWidget):
"""Green / yellow / red bar of a project's frames."""
def __init__(self, states: dict | None = None):
super().__init__()
self.setMinimumSize(160, 18)
self.set_states(states)
def set_states(self, states: dict | None):
self.states = states or {}
if states:
self.setToolTip(
f"{states['labelled']} labelled · {states['predicted']} predicted only · "
f"{states['empty']} not labelled yet (of {states['total']})"
)
self.update()
[docs]
def paintEvent(self, _ev): # noqa: N802
p = QPainter(self)
r = self.rect().adjusted(2, 4, -2, -4)
p.fillRect(r, QColor(200, 200, 200))
total = self.states.get("total") or 0
x = r.left()
for key, colour in STATE_COLOURS.items():
if not total:
break
w = round(r.width() * self.states.get(key, 0) / total)
p.fillRect(x, r.top(), w, r.height(), QColor(*colour))
x += w
p.end()
[docs]
def labelling_items(lset: LabelSet, extra_roots: list[Path] = ()) -> list[dict]:
"""Everything that can be labelled further: wizard packages and SLEAP projects."""
items = [
{
"kind": "package",
"name": e["id"],
"where": where if where == "this PC" else f"{where}: {folder}",
"slp": folder / pkg_mod.LABELS_FILE,
"folder": folder,
"detail": ", ".join(e.get("recordings", [])),
}
for folder, where, e in open_packages(lset, extra_roots)
]
for pr in lset.projects():
path = Path(pr["path"])
merged = f"; last taken in: v{pr['merged_into']}" if pr.get("merged_into") else ""
items.append(
{
"kind": "project",
"name": path.name,
"where": str(path.parent),
"slp": path,
"missing": not path.is_file(),
"detail": (pr.get("note") or "") + merged,
}
)
return items
[docs]
class ContinuePage(TaskPage):
manual_section = "Continue labelling"
COLS = ["Name", "Kind", "Progress", "Labelled", "Predicted", "Not yet", "Where", "About"]
def __init__(self, wiz):
super().__init__(
wiz,
"Continue labelling",
"Packages and SLEAP projects that still have frames to label. Green = labelled, "
"yellow = only the model's prediction, red = nothing yet. Open one in SLEAP, "
"label, save; bring the new frames in with 'Bring labelled frames back'.",
)
self.table = _table(self.COLS)
self.table.setSelectionBehavior(QAbstractItemView.SelectionBehavior.SelectRows)
self.table.setSelectionMode(QAbstractItemView.SelectionMode.SingleSelection)
self.table.cellDoubleClicked.connect(lambda *_: self.open_selected())
self.lay.addWidget(self.table, 2)
row = QHBoxLayout()
self.open_btn = QPushButton("Open in SLEAP")
self.open_btn.clicked.connect(self.open_selected)
row.addWidget(self.open_btn)
add = QPushButton("Add a SLEAP project…")
add.setToolTip("A .slp labelled outside the wizard; its new hand labels can be taken in")
add.clicked.connect(self._add_project)
row.addWidget(add)
more = QPushButton("Look on a folder…")
more.clicked.connect(self._pick_folder)
row.addWidget(more)
self.copy_btn = QPushButton("Copy to USB…")
self.copy_btn.setToolTip(
"Copy the selected package, with what is labelled so far, to a stick or folder"
)
self.copy_btn.clicked.connect(self.copy_selected)
row.addWidget(self.copy_btn)
self.delete_btn = QPushButton("Delete…")
self.delete_btn.setToolTip(
"Delete a package (all its copies), or take a project off this list"
)
self.delete_btn.clicked.connect(self.delete_selected)
row.addWidget(self.delete_btn)
self.result = QLabel("")
self.result.setWordWrap(True)
row.addWidget(self.result, 1)
self.lay.addLayout(row)
self.add_log_widgets(1)
self.states: dict[int, dict] = {}
self.items: list[dict] = []
self.bars: list[LabelBar] = []
self.extra: list[Path] = []
self.opened = False
[docs]
def initializePage(self): # noqa: N802
self.opened = False
self.result.setText("")
self.fill()
def fill(self):
self.items = labelling_items(self.wiz.lset, self.extra)
self.states = {}
self.bars = []
self.table.setRowCount(len(self.items))
for i, it in enumerate(self.items):
vals = [it["name"], it["kind"], "", "…", "…", "…", it["where"], it["detail"]]
if it.get("missing"):
vals[3:6] = ["file missing", "", ""]
for c, v in enumerate(vals):
self.table.setItem(i, c, _item(v))
bar = LabelBar()
self.table.setCellWidget(i, 2, bar)
self.bars.append(bar)
self.table.setColumnWidth(2, 180)
if self.items:
self.table.selectRow(0)
self.count_states()
else:
self.result.setText("Nothing to continue. Pick new frames first.")
self.open_btn.setEnabled(bool(self.items))
self.delete_btn.setEnabled(bool(self.items))
self.copy_btn.setEnabled(any(it["kind"] == "package" for it in self.items))
[docs]
def count_states(self):
"""Labelled / predicted / empty frames of every item (read in the SLEAP env)."""
env, items, out = self.wiz.env, list(self.items), {}
def job(emit):
for k, it in enumerate(items):
if it["slp"].is_file():
out[k] = sleapenv.run_task(env, "inspect", {"slp": str(it["slp"])})["states"]
emit(f"read {len(out)} of {len(items)}")
def done(ok, _m):
if ok and items == self.items:
self.show_states(out)
self.run(job, done)
def show_states(self, states: dict[int, dict]):
self.states = dict(states)
for k, st in states.items():
self.bars[k].set_states(st)
for c, key in ((3, "labelled"), (4, "predicted"), (5, "empty")):
self.table.setItem(k, c, _item(st[key]))
def _pick_folder(self):
d = QFileDialog.getExistingDirectory(self, "Folder with labelling packages")
if d:
self.extra.append(Path(d))
self.fill()
def _add_project(self):
src, _ = QFileDialog.getOpenFileName(
self, "SLEAP project", str(Path.home() / "data"), "SLEAP (*.slp)"
)
if src:
self.wiz.lset.add_project(src)
self.fill()
def selected(self) -> tuple[int, dict] | None:
rows = self.table.selectionModel().selectedRows()
return (rows[0].row(), self.items[rows[0].row()]) if rows and self.items else None
def copy_selected(self):
sel = self.selected()
if not sel:
return
_, it = sel
if it["kind"] != "package":
dialogs.information(
self,
"Copy to USB",
"A SLEAP project needs its videos and cannot be carried on its own. "
"Pick new frames from its recordings to make a package instead.",
)
return
dest = self._ask_destination()
if dest is None:
return
lset, src = self.wiz.lset, it["folder"]
target = pkg_mod.copy_target(lset, it["name"], dest)
replace = False
if target.exists():
ask = dialogs.warning(
self,
"Copy to USB",
f"<b>{target}</b> exists already.<br><br>Replace it with the copy from "
f"{it['where']}? <b>Anything labelled in the copy on the stick will be "
"lost.</b> To keep those labels, bring them back first.",
QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.Cancel,
QMessageBox.StandardButton.Cancel,
)
if ask != QMessageBox.StandardButton.Yes:
return
replace = True
out = {}
def job(emit):
out["path"] = pkg_mod.copy_package(lset, src, dest, replace=replace)
emit(f"copied to {out['path']}")
def done(ok, _m):
if ok:
self.result.setText(
f"Copied to <b>{out['path']}</b>. On the labelling PC run "
"<code>label.sh</code> in that folder. Label only one copy of a package."
)
self.run(job, done)
def _ask_destination(self) -> Path | None:
"""A plugged-in stick, or a folder."""
sticks = [d for d in removable_disks() if d.mountpoint]
choices = [f"USB stick: {d.text}" for d in sticks] + ["A folder…"]
pick, ok = dialogs.get_item(self, "Copy to USB", "Copy the package to:", choices)
if not ok:
return None
if pick == "A folder…":
d = QFileDialog.getExistingDirectory(self, "Copy the package into", str(Path.home()))
return Path(d) if d else None
return Path(sticks[choices.index(pick)].mountpoint)
def delete_selected(self):
sel = self.selected()
if not sel:
return
k, it = sel
if it["kind"] == "project":
self._forget_project(it)
else:
self._delete_package(k, it)
def _forget_project(self, it: dict):
ask = dialogs.question(
self,
"Take project off the list",
f"Take <b>{it['name']}</b> off this list?<br><br>The file itself is not deleted "
f"({it['slp']}), and frames already brought in stay in the label set.",
QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.Cancel,
QMessageBox.StandardButton.Cancel,
)
if ask == QMessageBox.StandardButton.Yes:
self.wiz.lset.remove_project(it["slp"])
self.fill()
def _delete_package(self, k: int, it: dict):
lset, pkg_id = self.wiz.lset, it["name"]
copies = pkg_mod.package_copies(lset, pkg_id, [it["folder"]])
labelled = (self.states.get(k) or {}).get("labelled")
lost = (
f"<b>{labelled} labelled frame(s) in it have not been brought back and will be "
"lost.</b>"
if labelled
else "No labelled frames found in it."
if labelled == 0
else "<b>It could not be read, so labelled frames in it may be lost.</b>"
)
where = "<br>".join(f"• {c}" for c in copies) or "• (no copies found)"
ask = dialogs.warning(
self,
"Delete package",
f"Delete package <b>{pkg_id}</b> for good?<br><br>{lost}<br><br>These folders "
f"will be deleted:<br>{where}<br><br>Its frames can be picked again later. "
"Copies on sticks that are not plugged in are not touched. This cannot be undone.",
QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.Cancel,
QMessageBox.StandardButton.Cancel,
)
if ask != QMessageBox.StandardButton.Yes:
return
if labelled != 0:
typed, ok = _ask_text(
self, "Delete package", f"Type the package name ({pkg_id}) to delete it:"
)
if not ok or typed.strip() != pkg_id:
self.result.setText("Not deleted.")
return
try:
gone = pkg_mod.delete_package(lset, pkg_id, [it["folder"]])
except (ConductorError, OSError) as err:
dialogs.critical(self, "Delete package", str(err))
return
self.fill()
self.result.setText(f"Package {pkg_id} deleted ({len(gone)} folder(s)).")
def open_selected(self):
rows = self.table.selectionModel().selectedRows()
if not rows or not self.items:
return
it = self.items[rows[0].row()]
try:
sleapenv.open_labelling(self.wiz.env, it["slp"])
except ConductorError as err:
dialogs.critical(self, "SLEAP", str(err))
return
note = ""
if it["kind"] == "package" and it["where"] == "this PC":
note = (
" This is the copy on this PC; if the package also went out on a stick, "
"label only one of the two."
)
self.result.setText(
f"SLEAP opened <b>{it['name']}</b>. Save in SLEAP (Ctrl+S) when you stop; "
f"take the new frames in with 'Bring labelled frames back'.{note}"
)
self.opened = True
self.completeChanged.emit()
[docs]
def isComplete(self): # noqa: N802
return self.opened
[docs]
def nextId(self): # noqa: N802
return -1
# ── bring back ────────────────────────────────────────────────────
[docs]
class BackPage(TaskPage):
manual_section = "Bring labelled frames back"
def __init__(self, wiz):
super().__init__(
wiz,
"Bring labelled frames back",
"Pick the package, check every frame, then merge the good ones into a new "
"version of the label set.",
)
row = QHBoxLayout()
self.pkgs = QComboBox()
row.addWidget(self.pkgs, 1)
b = QPushButton("Look on a folder…")
b.clicked.connect(self._pick_folder)
row.addWidget(b)
self.lay.addLayout(row)
row2 = QHBoxLayout()
self.check_btn = QPushButton("Check frames")
self.check_btn.clicked.connect(self.check)
row2.addWidget(self.check_btn)
row2.addWidget(QLabel("Labeller initials"))
self.labeller = QLineEdit()
self.labeller.setMaximumWidth(80)
row2.addWidget(self.labeller)
self.with_warnings = QCheckBox("Also merge frames with warnings")
self.with_warnings.setChecked(True)
row2.addWidget(self.with_warnings)
self.merge_btn = QPushButton("Merge accepted frames")
self.merge_btn.clicked.connect(self.merge)
self.merge_btn.setEnabled(False)
row2.addWidget(self.merge_btn)
self.lay.addLayout(row2)
self.summary = QLabel("")
self.lay.addWidget(self.summary)
self.table = _table(["Status", "Recording", "Arena", "Frame", "Flies", "Why"])
self.lay.addWidget(self.table, 2)
self.add_log_widgets(1)
self.report = None
self.project: Path | None = None
self.merged = False
[docs]
def initializePage(self): # noqa: N802
self.fill_packages()
self.labeller.setText(self.labeller.text() or getpass.getuser()[:3].upper())
self.merged = False
def fill_packages(self, extra: list[Path] = ()):
self.pkgs.clear()
for it in labelling_items(self.wiz.lset, extra):
if it.get("missing"):
continue
self.pkgs.addItem(f"{it['kind']}: {it['name']} · {it['where']}", it)
def _pick_folder(self):
d = QFileDialog.getExistingDirectory(self, "Folder with labelling packages")
if d:
self.fill_packages([Path(d)])
i = self.pkgs.findText(d, Qt.MatchFlag.MatchContains)
self.pkgs.setCurrentIndex(i if i >= 0 else self.pkgs.count() - 1)
def check(self):
it = self.pkgs.currentData()
if not it:
return
lset, env = self.wiz.lset, self.wiz.env
self.project = it["slp"] if it["kind"] == "project" else None
out = {}
def job(emit):
if self.project:
out.update(info=None, returned=self.project)
out["report"] = pkg_mod.check_project(
lset, self.project, env, log=emit, progress=progress_to(emit)
)
return
folder = it["folder"]
for problem in pkg_mod.manifest_problems(Path(folder)):
emit(f"note: {problem}")
info, returned = pkg_mod.take_back(lset, Path(folder))
out.update(info=info, returned=returned)
out["report"] = pkg_mod.check_returned(
lset, info, returned, env, log=emit, progress=progress_to(emit)
)
def done(ok, _m):
if ok:
self.info, self.returned, self.report = out["info"], out["returned"], out["report"]
self.show_report()
self.run(job, done)
def show_report(self):
rep = self.report
if rep.get("skeleton"):
self.summary.setText(f"<b>Not merged:</b> {rep['skeleton']}")
self.merge_btn.setEnabled(False)
return
s = rep["summary"]
tail = (
f"{s['already_in_set']} already in the set"
if "already_in_set" in s
else f"{s.get('unlabelled', 0)} not labelled"
)
self.summary.setText(
f"{s.get('accepted', 0)} accepted ({s.get('warnings', 0)} with warnings), "
f"{s.get('rejected', 0)} rejected, {tail}"
)
rows = [r for r in rep["frames"] if r["status"] != "unlabelled"]
self.table.setRowCount(len(rows))
for i, r in enumerate(rows):
why = "; ".join(r["reasons"] + [f"warning: {w}" for w in r["warnings"]])
vals = [
r["status"],
r.get("recording", "?"),
r.get("arena", "?"),
r.get("source_frame", "?"),
r["flies"],
why,
]
for c, v in enumerate(vals):
self.table.setItem(i, c, _item(v))
self.merge_btn.setEnabled(s.get("accepted", 0) > 0)
def accepted(self) -> list[str]:
return [
r["hash"]
for r in self.report["frames"]
if r["status"] == "accepted" and (self.with_warnings.isChecked() or not r["warnings"])
]
def merge(self):
who = self.labeller.text().strip()
if not who:
dialogs.information(self, "Labeller", "Enter the labeller's initials.")
return
lset, env, acc = self.wiz.lset, self.wiz.env, self.accepted()
out = {}
project, report = self.project, self.report
def job(emit):
if project:
out["entry"] = pkg_mod.merge_project(lset, project, report, acc, who, env, log=emit)
return
out["entry"] = pkg_mod.merge_returned(
lset,
self.info,
self.returned,
acc,
who,
env,
report=self.report,
log=emit,
progress=progress_to(emit),
)
def done(ok, _m):
if ok:
e = out["entry"]
self.merged = True
self.merge_btn.setEnabled(False)
self.summary.setText(
f"Merged: label set <b>v{e['version']}</b> now has {e['frames']} frames "
f"({e['instances']} flies). Train it from the start page."
)
self.completeChanged.emit()
self.run(job, done)
[docs]
def isComplete(self): # noqa: N802
return self.merged
[docs]
def nextId(self): # noqa: N802
return -1
# ── training data ─────────────────────────────────────────────────
ROLES = (
("train", "Training"),
("all", "All (split automatically)"),
("val", "Validation"),
("out", "Leave out"),
)
[docs]
def flies_text(flies: dict) -> str:
"""``{"3": 28, "2": 3}`` → ``3 flies: 28 · 2 flies: 3`` (most first)."""
parts = sorted(flies.items(), key=lambda kv: -int(kv[0]))
return " · ".join(f"{n} {'fly' if n == '1' else 'flies'}: {c}" for n, c in parts)
[docs]
class ExampleDialog(QDialog):
def __init__(self, parent, path: str, title: str):
super().__init__(parent)
self.setWindowTitle(title)
lay = QVBoxLayout(self)
img = QLabel()
side = dialogs.screen_side(parent)
img.setPixmap(
QPixmap(path).scaled(
side,
side,
Qt.AspectRatioMode.KeepAspectRatio,
Qt.TransformationMode.SmoothTransformation,
)
)
lay.addWidget(img)
[docs]
class DataPage(TaskPage):
manual_section = "Training data"
COLS = [
"Example",
"Use as",
"Recording",
"Date",
"Scale",
"Frames",
"Flies",
"Flies per frame",
"Image size",
"Arenas",
"Labelled by",
]
def __init__(self, wiz):
super().__init__(
wiz,
"Training data",
"Which version of the label set, and what each recording is for. Validation "
"recordings are never trained on; they test the new and the current model "
"(pick ones the current model has not seen). <i>All</i> uses a recording for "
f"both: {LABEL_TEST_SHARE:.0%} of its frames, picked by their pixels so they stay "
"the same in later versions, test the models and the rest is trained on. "
"Double-click an example to enlarge.",
)
form = QFormLayout()
self.version = QComboBox()
self.version.currentIndexChanged.connect(self.load)
form.addRow("Label set version", self.version)
self.lay.addLayout(form)
self.table = _table(self.COLS)
self.table.setIconSize(QSize(LABEL_THUMB_PX, LABEL_THUMB_PX))
self.table.verticalHeader().setDefaultSectionSize(LABEL_THUMB_PX + 6)
self.table.cellDoubleClicked.connect(self._enlarge)
self.lay.addWidget(self.table, 4)
self.totals = QLabel("")
self.totals.setWordWrap(True)
self.lay.addWidget(self.totals)
self.add_log_widgets(1)
self.rows: list[dict] = []
self.roles: list[QComboBox] = []
[docs]
def initializePage(self): # noqa: N802
lset = self.wiz.lset
self.version.blockSignals(True)
self.version.clear()
for v in reversed(lset.versions):
self.version.addItem(
f"v{v['version']} · {v['frames']} frames · {v['note']}", v["version"]
)
self.version.blockSignals(False)
self.load()
def load(self, *_):
v = self.version.currentData()
self.rows, self.roles = [], []
self.table.setRowCount(0)
self.update_totals()
if v is None:
return
lset, env, out = self.wiz.lset, self.wiz.env, {}
def job(emit):
out["rows"] = train_mod.summarise(lset, v, env, log=emit, progress=progress_to(emit))
def done(ok, _m):
if ok and self.version.currentData() == v:
self.show_rows(out["rows"])
self.run(job, done)
def role_of(self, rec: str) -> str:
lset = self.wiz.lset
if rec in lset.validation_recordings():
return "val"
if rec in lset.shared():
return "all"
return "out" if rec in lset.left_out() else "train"
def show_rows(self, rows: list[dict]):
self.rows = rows
self.roles = []
self.table.setRowCount(len(rows))
for i, r in enumerate(rows):
thumb = QTableWidgetItem()
thumb.setFlags(Qt.ItemFlag.ItemIsEnabled)
thumb.setData(
Qt.ItemDataRole.DecorationRole,
QPixmap(r["example"]).scaled(
LABEL_THUMB_PX,
LABEL_THUMB_PX,
Qt.AspectRatioMode.KeepAspectRatio,
Qt.TransformationMode.SmoothTransformation,
),
)
arena, frame = r.get("example_from", [-1, -1])
thumb.setToolTip(f"arena {arena:02d}, frame {frame}" if frame >= 0 else "")
self.table.setItem(i, 0, thumb)
combo = QComboBox()
for key, text in ROLES:
combo.addItem(text, key)
combo.setCurrentIndex(combo.findData(self.role_of(r["recording"])))
combo.currentIndexChanged.connect(self.update_totals)
self.table.setCellWidget(i, 1, combo)
self.roles.append(combo)
date = Recording(r["recording"], Path()).date
vals = [
r["recording"],
date,
r["scale"],
r["frames"],
r["instances"],
flies_text(r["flies"]),
", ".join(r["sizes"]),
len(r["arenas"]),
", ".join(f"{k} ({n})" for k, n in r["labellers"].items()),
]
for c, val in enumerate(vals, start=2):
self.table.setItem(i, c, _item(val))
self.update_totals()
def chosen(self) -> dict[str, str]:
return {r["recording"]: c.currentData() for r, c in zip(self.rows, self.roles, strict=True)}
[docs]
def counts(self) -> dict[str, int]:
"""Frames per use; for *All* recordings the test share is an estimate."""
roles = self.chosen()
out = {"train": 0, "val": 0, "out": 0}
for r in self.rows:
role, n = roles[r["recording"]], r["frames"]
if role == "all":
test = round(n * LABEL_TEST_SHARE)
out["val"] += test
out["train"] += n - test
else:
out[role] += n
return out
def update_totals(self, *_):
if not self.rows:
self.totals.setText("")
self.completeChanged.emit()
return
n = self.counts()
roles = self.chosen()
val_scales = sorted(
{r["scale"] for r in self.rows if roles[r["recording"]] in ("val", "all")}
)
approx = "≈ " if "all" in roles.values() else ""
text = (
f"{approx}<b>{n['train']}</b> frames for training, "
f"{approx}<b>{n['val']}</b> for validation"
+ (f" ({', '.join(val_scales)})" if val_scales else "")
+ f", {n['out']} left out."
)
if not n["val"]:
text += (
"<br><b>No validation frames yet:</b> set one recording per camera scale "
"to Validation (ideally a recording made for it), or set recordings to "
"<i>All</i> to split their frames automatically."
)
if not n["train"]:
text += "<br><b>Nothing left to train on.</b>"
self.totals.setText(text)
self.completeChanged.emit()
def _enlarge(self, row: int, _col: int):
if 0 <= row < len(self.rows):
r = self.rows[row]
ExampleDialog(self, r["example"], r["recording"]).exec()
[docs]
def isComplete(self): # noqa: N802
n = self.counts() if self.rows else {}
return bool(n.get("train")) and bool(n.get("val"))
[docs]
def validatePage(self): # noqa: N802
roles = self.chosen()
self.wiz.lset.set_training_roles({r["recording"]: r["scale"] for r in self.rows}, roles)
self.wiz.train_version = self.version.currentData()
self.wiz.train_rows = self.rows
self.wiz.excluded = sorted(k for k, v in roles.items() if v == "out")
self.wiz.shared = sorted(k for k, v in roles.items() if v == "all")
return True
# ── train ─────────────────────────────────────────────────────────
[docs]
class TrainPage(TaskPage):
manual_section = "Train on Aoraki"
def __init__(self, wiz):
super().__init__(
wiz,
"Train on Aoraki",
"Fine-tune from an existing model, then compare with the current model on "
"every validation recording. A new model becomes the default only if it is "
"not worse anywhere and better somewhere, and only with your OK.",
)
form = QFormLayout()
self.data_label = QLabel("")
self.data_label.setWordWrap(True)
form.addRow("Training data", self.data_label)
self.base = QComboBox()
form.addRow("Start from model", self.base)
self.compare = QComboBox()
form.addRow("Compare with", self.compare)
self.epochs = QSpinBox()
self.epochs.setRange(1, 2000)
self.epochs.setValue(TRAIN_EPOCHS)
form.addRow("Epochs (at most)", self.epochs)
self.val_label = QLabel("")
self.val_label.setWordWrap(True)
form.addRow("Validation", self.val_label)
self.lay.addLayout(form)
row = QHBoxLayout()
self.start_btn = QPushButton("Start training")
self.start_btn.clicked.connect(self.start)
row.addWidget(self.start_btn)
self.state = QLabel("")
row.addWidget(self.state, 1)
self.lay.addLayout(row)
self.training = TrainingProgress()
self.lay.addWidget(self.training)
self.table = _table(["Validation set", "Frames", "New mAP", "Current mAP"])
self.table.setMaximumHeight(TRAIN_TABLE_MAX_PX) # a few validation sets
self.lay.addWidget(self.table)
prow = QHBoxLayout()
self.promote_btn = QPushButton("Make it the default model")
self.promote_btn.clicked.connect(lambda: self.register(True))
self.keep_btn = QPushButton("Register without making it the default")
self.keep_btn.clicked.connect(lambda: self.register(False))
for b in (self.promote_btn, self.keep_btn):
b.setEnabled(False)
prow.addWidget(b)
self.lay.addLayout(prow)
self.add_log_widgets(1)
self.timer = QTimer(self)
self.timer.timeout.connect(self.poll)
self.plan: train_mod.TrainPlan | None = None
self.verdict: dict | None = None
[docs]
def initializePage(self): # noqa: N802
lset = self.wiz.lset
out, shared = self.wiz.excluded, self.wiz.shared
self.data_label.setText(
f"v{self.wiz.train_version}"
+ (f"; left out: {', '.join(out)}" if out else "; all recordings")
+ (f"; split by frame: {', '.join(shared)}" if shared else "")
)
models = self.wiz.registry_models()
for combo in (self.base, self.compare):
combo.clear()
for m in models:
combo.addItem(m.label, m.id)
want = self.wiz.default_model()
for combo in (self.base, self.compare):
i = combo.findData(want) if want else -1
if i >= 0:
combo.setCurrentIndex(i)
val = lset.data["validation"]
parts = [f"{s}: {', '.join(r)}" for s, r in val.items()]
if lset.shared():
parts.append(f"{LABEL_TEST_SHARE:.0%} of the frames of {', '.join(lset.shared())}")
self.val_label.setText(
"; ".join(parts) or "<b>none yet</b>: go back and set a recording to Validation or All"
)
self.start_btn.setEnabled(lset.has_validation() and bool(models))
if not models:
self.state.setText("No models in the registry cache; open the main wizard once.")
self.resume()
[docs]
def resume(self):
"""Pick up a training run that is still going (wizard reopened)."""
for m in reversed(self.wiz.lset.data["models"]):
if m.get("status") in ("submitted", "trained"):
self.plan = train_mod.TrainPlan.from_entry(m)
self.training.show_status({}, m.get("epochs", TRAIN_EPOCHS))
self.state.setText(f"run {self.plan.run}, job {self.plan.job_id}: checking…")
self.start_btn.setEnabled(False)
self.timer.start(TRAIN_POLL_S * 1000)
QTimer.singleShot(0, self.poll)
return
def start(self):
lset, env, cfg = self.wiz.lset, self.wiz.env, self.wiz.cfg
version, excluded = self.wiz.train_version, list(self.wiz.excluded)
shared = list(self.wiz.shared)
plan = train_mod.TrainPlan(
lset.name,
version,
train_mod.run_name(lset, version),
self.base.currentData(),
self.compare.currentData(),
excluded=excluded,
shared=shared,
)
epochs = self.epochs.value()
scripts = self.wiz.thermokourt_scripts()
self.start_btn.setEnabled(False)
def job(emit):
emit("splitting into training and validation frames")
files = train_mod.prepare(
lset, version, env, exclude=excluded, log=emit, progress=progress_to(emit)
)
emit(f"uploading {', '.join(p.name for p in files.values())} to Aoraki")
train_mod.upload(cfg, LABEL_PROFILE, lset, plan, files, scripts)
train_mod.submit(cfg, LABEL_PROFILE, plan, epochs)
lset.add_model({**plan.__dict__, "status": "submitted", "epochs": epochs})
emit(f"training job {plan.job_id} submitted (run {plan.run})")
def done(ok, _m):
if ok:
self.plan = plan
self.training.show_status({}, epochs)
self.timer.start(TRAIN_POLL_S * 1000)
self.poll()
else:
self.start_btn.setEnabled(True)
self.run(job, done)
def poll(self):
if self.plan is None or (self.wiz.worker and self.wiz.worker.isRunning()):
return
plan, cfg = self.plan, self.wiz.cfg
out = {}
def job(emit):
out["st"] = train_mod.status(cfg, LABEL_PROFILE, plan)
if out["st"]["done"]:
out["rows"] = train_mod.fetch_eval(cfg, LABEL_PROFILE, plan.run)
def done(ok, _m):
if not ok:
return
st = out["st"]
self.state.setText(f"job {plan.job_id}: {(st['state'] or 'queued').lower()}")
self.training.show_status(st)
if st["failed"]:
self.timer.stop()
self.wiz.lset.update_model(plan.run, status="failed", error=st["failed"])
self.log.appendPlainText("\n".join(st["tail"]))
self.state.setText(f"training failed: {st['failed']}")
self.start_btn.setEnabled(True)
elif st["done"]:
self.timer.stop()
self.show_verdict(out["rows"])
self.wiz.run_in_worker(job, done, self.add_line)
def show_verdict(self, rows: list[dict]):
plan = self.plan
self.verdict = train_mod.compare(rows, plan.run, plan.compare_run)
self.wiz.lset.update_model(plan.run, status="trained", eval=rows)
t = self.verdict["table"]
self.table.setRowCount(len(t))
for i, r in enumerate(t):
vals = [r["set"], r["frames"], _fmt(r["new"]), _fmt(r["old"])]
for c, v in enumerate(vals):
self.table.setItem(i, c, _item(v))
ok = self.verdict["promotable"]
self.state.setText(
f"trained: {plan.run} — "
+ (
"better than the current model, can become the default"
if ok
else "not better everywhere; keep the current default"
)
)
self.promote_btn.setEnabled(ok)
self.keep_btn.setEnabled(True)
def register(self, promote: bool):
if (
promote
and dialogs.question(
self,
"Make default",
f"Make {self.plan.run} the default pose model for new recordings?",
)
!= QMessageBox.StandardButton.Yes
):
return
base = next((m for m in self.wiz.registry_models() if m.id == self.plan.base_run), None)
entry = train_mod.registry_entry(
self.plan.run,
base.__dict__ if base else {},
self.wiz.lset,
self.plan.version,
self.verdict,
promote,
excluded=self.plan.excluded,
shared=self.plan.shared,
)
cfg, plan = self.wiz.cfg, self.plan
def job(emit):
train_mod.append_registry(cfg, LABEL_PROFILE, entry)
models_mod.refresh(
cfg.cluster.ssh_host,
cfg.registry_remote(LABEL_PROFILE),
cfg.registry_cache(LABEL_PROFILE),
)
emit(f"registered {plan.run}" + (" as the default model" if promote else ""))
def done(ok, _m):
if ok:
self.wiz.lset.update_model(plan.run, status="registered", default=promote)
self.promote_btn.setEnabled(False)
self.keep_btn.setEnabled(False)
self.run(job, done)
[docs]
def nextId(self): # noqa: N802
return -1
def _fmt(x) -> str:
return "" if x is None else f"{x:.3f}"
# ── the wizard ────────────────────────────────────────────────────
[docs]
class LabellingWizard(QWizard):
def __init__(self, cfg: ConductorConfig):
super().__init__()
self.cfg = cfg
self.setWindowTitle("Rig Conductor — training data")
self.setWizardStyle(QWizard.WizardStyle.ModernStyle)
self.resize(1000, 760)
self.worker: Worker | None = None
self.lset: LabelSet | None = None
self.env: sleapenv.SleapEnv | None = None
self.recordings: list[Recording] = []
self.frames: list[dict] = []
self.prefill_run: str | None = None
self.train_version: int | None = None
self.train_rows: list[dict] = []
self.excluded: list[str] = []
self.shared: list[str] = []
for pid, cls in (
(PAGE_START, StartPage),
(PAGE_RECS, RecordingsPage),
(PAGE_FRAMES, FramesPage),
(PAGE_PACKAGE, PackagePage),
(PAGE_CONTINUE, ContinuePage),
(PAGE_BACK, BackPage),
(PAGE_DATA, DataPage),
(PAGE_TRAIN, TrainPage),
):
self.setPage(pid, cls(self))
add_help_button(self)
def run_in_worker(self, fn, on_done, sink):
if self.worker and self.worker.isRunning():
dialogs.information(self, "Busy", "Something is still running")
return
self.worker = Worker(fn)
self.worker.line.connect(sink)
self.worker.finished_ok.connect(on_done)
self.worker.start()
def registry_models(self) -> list[models_mod.Model]:
ms = models_mod.load_cached(self.cfg.registry_cache(LABEL_PROFILE))
return models_mod.models_for(ms, "drosophila", include_deprecated=False)
def default_model(self) -> str | None:
from rigconductor.presets import by_key
ms = self.registry_models()
return models_mod.default_for(ms, "drosophila") or by_key(LABEL_PROFILE, "heat").model
@staticmethod
def thermokourt_scripts() -> Path:
try:
import thermokourt
except ImportError as e:
raise ConductorError(
"ThermoKourt is not installed; it carries the training scripts"
) from e
return Path(thermokourt.__file__).resolve().parents[1] / "scripts"
def main(config_path: str | None = None) -> int:
app = QApplication.instance() or QApplication(sys.argv)
try:
cfg = ConductorConfig.load(config_path)
except FileNotFoundError as e:
dialogs.critical(None, "Rig Conductor", str(e))
return 1
w = LabellingWizard(cfg)
w.show()
return app.exec()
if __name__ == "__main__":
sys.exit(main())