Update app.py

app.py

@@ -21,10 +21,9 @@ REPO_URL = "https://github.com/supervisely-ecosystem/RT-DETRv2"
 REPO_DIR = os.path.join(os.getcwd(), "third_party", "RT-DETRv2")
 PY_IMPL_DIR = os.path.join(REPO_DIR, "rtdetrv2_pytorch")  # Supervisely keeps PyTorch impl here
 
-# Core deps + your requested packages; pinned as lower-bounds to avoid downgrades (local runs only)
+# Core deps — Ultralytics removed per request
 COMMON_REQUIREMENTS = [
     "gradio>=4.36.1",
-    "ultralytics>=8.2.0",
     "roboflow>=1.1.28",
     "requests>=2.31.0",
     "huggingface_hub>=0.22.0",
@@ -427,38 +426,28 @@ def _set_first_existing_key(d: dict, keys: list, value, fallback_key: str | None
     return None
 
 def _set_first_existing_key_deep(cfg: dict, keys: list, value):
-    """
-    Try to set one of `keys` at top-level, under 'model', or under 'solver'.
-    """
     for scope in [cfg, cfg.get("model", {}), cfg.get("solver", {})]:
         if isinstance(scope, dict):
             for k in keys:
                 if k in scope:
                     scope[k] = value
                     return True
-    # If nowhere found, set on model
     if "model" not in cfg or not isinstance(cfg["model"], dict):
         cfg["model"] = {}
     cfg["model"][keys[0]] = value
     return True
 
 def _install_supervisely_logger_shim():
-    """
-    Create a package shim so 'from supervisely.nn.training import train_logger' works.
-    """
     root = pathlib.Path(tempfile.gettempdir()) / "sly_shim_pkg"
     pkg_training = root / "supervisely" / "nn" / "training"
     pkg_training.mkdir(parents=True, exist_ok=True)
 
-    # Make each level a package
     for p in [root / "supervisely", root / "supervisely" / "nn", pkg_training]:
         init_file = p / "__init__.py"
         if not init_file.exists():
             init_file.write_text("")
 
-    # Expose train_logger from the package's __init__
     (pkg_training / "__init__.py").write_text(textwrap.dedent("""
-        # Minimal shim for backward-compat with older RT-DETRv2 training code.
         class _TrainLogger:
             def __init__(self): pass
             def reset(self): pass
@@ -498,10 +487,6 @@ def _ensure_checkpoint(model_key: str, out_dir: str) -> str | None:
 # --- include absolutizer ------------------------------------------------------
 def _absify_any_paths_deep(node, base_dir, include_keys=("base", "_base_", "BASE", "BASE_YAML",
                                                          "includes", "include", "BASES", "__include__")):
-    """
-    Walk dict/list; for known include keys or strings that look like ../*.yml/.yaml,
-    make them absolute against base_dir.
-    """
     def _absify(s: str) -> str:
         if os.path.isabs(s):
             return s
@@ -531,9 +516,6 @@ def _absify_any_paths_deep(node, base_dir, include_keys=("base", "_base_", "BASE
 
 # --- NEW: safe model field setters --------------------------------------------
 def _set_num_classes_safely(cfg: dict, n: int):
-    """
-    Set class count without breaking templates that use `model: "RTDETR"` indirection.
-    """
     def set_num_classes(node):
         if not isinstance(node, dict):
             return False
@@ -558,12 +540,9 @@ def _set_num_classes_safely(cfg: dict, n: int):
                 block["num_classes"] = int(n)
             return
 
-    cfg["num_classes"] = int(n)  # last resort
+    cfg["num_classes"] = int(n)
 
 def _maybe_set_model_field(cfg: dict, key: str, value):
-    """
-    Place fields like 'pretrain' under the proper model dict, respecting string indirection.
-    """
     m = cfg.get("model", None)
     if isinstance(m, dict):
         m[key] = value
@@ -571,7 +550,7 @@ def _maybe_set_model_field(cfg: dict, key: str, value):
     if isinstance(m, str) and isinstance(cfg.get(m), dict):
         cfg[m][key] = value
         return
-    cfg[key] = value  # fallback
+    cfg[key] = value
 
 # --- CRITICAL: dataset override + include cleanup + sync_bn off ---------------
 def patch_base_config(base_cfg_path, merged_dir, class_count, run_name,
@@ -586,6 +565,10 @@ def patch_base_config(base_cfg_path, merged_dir, class_count, run_name,
         cfg = yaml.safe_load(f)
     _absify_any_paths_deep(cfg, template_dir)
 
+    # Ensure the runtime knows which Python module hosts builders
+    cfg["task"] = cfg.get("task", "detection")
+    cfg["_pymodule"] = cfg.get("_pymodule", "rtdetrv2_pytorch.src")  # <= HINT for loader
+
     # Disable SyncBN for single GPU/CPU runs
     cfg["sync_bn"] = False
 
@@ -607,7 +590,6 @@ def patch_base_config(base_cfg_path, merged_dir, class_count, run_name,
         "out_dir":    os.path.abspath(os.path.join("runs", "train", run_name)),
     }
 
-    # Ensure/patch dataloaders to point to our dataset
     def ensure_and_patch_dl(dl_key, img_key, json_key, default_shuffle):
         block = cfg.get(dl_key)
         if not isinstance(block, dict):
@@ -634,7 +616,6 @@ def patch_base_config(base_cfg_path, merged_dir, class_count, run_name,
             }
             cfg[dl_key] = block
 
-        # Patch existing block
         ds = block.get("dataset", {})
         if isinstance(ds, dict):
             ds["img_folder"] = paths[img_key]
@@ -652,13 +633,9 @@ def patch_base_config(base_cfg_path, merged_dir, class_count, run_name,
 
     ensure_and_patch_dl("train_dataloader", "train_img", "train_json", default_shuffle=True)
     ensure_and_patch_dl("val_dataloader",   "val_img",   "val_json",   default_shuffle=False)
-    # Optional test loader
-    # ensure_and_patch_dl("test_dataloader",  "test_img",  "test_json",  default_shuffle=False)
 
-    # num classes (handles model: "RTDETR")
     _set_num_classes_safely(cfg, int(class_count))
 
-    # epochs / imgsz
     applied_epoch = False
     for key in ("epoches", "max_epoch", "epochs", "num_epochs"):
         if key in cfg:
@@ -675,7 +652,6 @@ def patch_base_config(base_cfg_path, merged_dir, class_count, run_name,
         cfg["epoches"] = int(epochs)
     cfg["input_size"] = int(imgsz)
 
-    # lr / optimizer / batch
     if "solver" not in cfg or not isinstance(cfg["solver"], dict):
         cfg["solver"] = {}
     sol = cfg["solver"]
@@ -689,24 +665,20 @@ def patch_base_config(base_cfg_path, merged_dir, class_count, run_name,
     if "train_dataloader" not in cfg or not isinstance(cfg["train_dataloader"], dict):
         sol["batch_size"] = int(batch)
 
-    # output dir
     if "output_dir" in cfg:
         cfg["output_dir"] = paths["out_dir"]
     else:
         sol["output_dir"] = paths["out_dir"]
 
-    # pretrained weights in the right model block
     if pretrained_path:
         p = os.path.abspath(pretrained_path)
         _maybe_set_model_field(cfg, "pretrain", p)
         _maybe_set_model_field(cfg, "pretrained", p)
 
-    # Save near the template so internal relative references still make sense
     cfg_out_dir = os.path.join(template_dir, "generated")
     os.makedirs(cfg_out_dir, exist_ok=True)
     out_path = os.path.join(cfg_out_dir, f"{run_name}.yaml")
 
-    # Force block style for lists (no inline [a, b, c])
     class _NoFlowDumper(yaml.SafeDumper): ...
     def _repr_list_block(dumper, data):
         return dumper.represent_sequence('tag:yaml.org,2002:seq', data, flow_style=False)
@@ -832,7 +804,6 @@ def training_handler(dataset_path, model_key, run_name, epochs, batch, imgsz, lr
     out_dir = os.path.abspath(os.path.join("runs", "train", run_name))
     os.makedirs(out_dir, exist_ok=True)
 
-    # Download matching COCO checkpoint for warm-start
     pretrained_path = _ensure_checkpoint(model_key, out_dir)
 
     cfg_path = patch_base_config(
@@ -855,13 +826,17 @@ def training_handler(dataset_path, model_key, run_name, epochs, batch, imgsz, lr
     def run_train():
         try:
             env = os.environ.copy()
+            # Make sure repo code can be imported
             env["PYTHONPATH"] = os.pathsep.join(filter(None, [
                 PY_IMPL_DIR, REPO_DIR, env.get("PYTHONPATH", "")
             ]))
-            # put our shim at the very front so the import always resolves
+            # Put our shim first so supervisely import never breaks
             shim_root = _install_supervisely_logger_shim()
             env["PYTHONPATH"] = os.pathsep.join([shim_root, env["PYTHONPATH"]])
             env.setdefault("WANDB_DISABLED", "true")
+            # Provide a secondary hint for some config loaders
+            env.setdefault("RTDETR_PYMODULE", "rtdetrv2_pytorch.src")
+
             proc = subprocess.Popen(cmd, cwd=os.path.dirname(train_script),
                                     stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
                                     bufsize=1, text=True, env=env)
@@ -882,13 +857,13 @@ def training_handler(dataset_path, model_key, run_name, epochs, batch, imgsz, lr
         if line.startswith("__EXITCODE__"):
             code = int(line.split(":", 1)[1])
             if code != 0:
-                head = "\n".join(first_lines[:60])
+                head = "\n".join(first_lines[-200:])
                 raise gr.Error(f"Training exited with code {code}.\nLast output:\n{head or 'No logs captured.'}")
             break
         if line.startswith("__ERROR__"):
             raise gr.Error(f"Training failed: {line.split(':', 1)[1]}")
 
-        if len(first_lines) < 120:
+        if len(first_lines) < 2000:
             first_lines.append(line)
         log_tail.append(line)
         log_tail = log_tail[-40:]
@@ -902,7 +877,6 @@ def training_handler(dataset_path, model_key, run_name, epochs, batch, imgsz, lr
                 pass
         progress(min(max(last_epoch / max(1, total_epochs), 0.0), 1.0), desc=f"Epoch {last_epoch}/{total_epochs}")
 
-        # Throttle plotting; close figs after yield to avoid leaks
         line_no += 1
         fig1 = fig2 = None
         if line_no % 80 == 0: