flashstudio 0.0.1__py3-none-any.whl

flashstudio/pages/inference/run/video.py

@@ -0,0 +1,195 @@
+"""Inference — Video processing utilities."""
+
+import os
+import time
+import tempfile
+import streamlit as st
+from PIL import Image, ImageDraw
+from flashstudio.constants import (
+    COCO_CLASSES, INFER_CONF_THRESHOLD, INFER_NMS_THRESHOLD,
+    INFER_IMG_SIZE, INFER_MAX_FRAMES, INFER_FRAME_SKIP,
+    INFER_DEFAULT_RESOLUTION, COLOR_PRIMARY,
+)
+from flashstudio.pages.inference._common import (
+    _get_class_names, _HAS_PREDICTOR, _SOLUTIONS_AVAILABLE,
+)
+from flashstudio.pages.inference.run.detection import _draw_boxes_cv2
+
+try:
+    from flashdet import Predictor, FlashTracker
+except ImportError:
+    pass
+
+
+def _run_video():
+    video = st.session_state.get("infer_video")
+    solution = st.session_state.get("selected_solution", "None (Detection Only)")
+    weights = st.session_state.get("infer_weights_path", "") or st.session_state.get("infer_weights_file")
+    if weights:
+        try:
+            _run_flashdet_video(video, solution)
+            return
+        except Exception as e:
+            st.warning(f"FlashDet error: {e}. Demo mode.")
+    _run_demo_video(solution)
+
+
+def _run_demo_video(solution_name):
+    t0 = time.perf_counter()
+    progress = st.progress(0)
+    frames = []
+    for i in range(4):
+        time.sleep(0.2)
+        progress.progress((i + 1) / 4)
+        img = Image.new("RGB", INFER_DEFAULT_RESOLUTION, (248, 248, 252))
+        draw = ImageDraw.Draw(img)
+        draw.rectangle([80 + i * 40, 80 + i * 30, 250 + i * 40, 230 + i * 30], outline=COLOR_PRIMARY, width=3)
+        draw.text((90 + i * 40, 65 + i * 30), f"car 0.{85 + i}", fill=COLOR_PRIMARY)
+        frames.append(img)
+    progress.empty()
+    elapsed = time.perf_counter() - t0
+
+    sol_output = {}
+    if "Counter" in solution_name:
+        sol_output = {"in_count": 12, "out_count": 8}
+    elif "Region" in solution_name:
+        sol_output = {"region_counts": {"Zone A": 5, "Zone B": 3}}
+    elif "Speed" in solution_name:
+        sol_output = {"speeds": [[1, 45.2], [2, 38.7], [3, 52.1]]}
+
+    st.session_state["video_results"] = {
+        "frames": 300, "detections": 1247, "processing_fps": 300 / max(elapsed, 0.001),
+        "elapsed_time": elapsed, "solution_output": sol_output, "frames_preview": frames,
+        "output_path": _get_output_path("output.mp4") if st.session_state.get("infer_save_video") else None,
+    }
+    st.rerun()
+
+
+def _get_output_path(filename):
+    """Resolve output path: prefer save_dir, fall back to tempdir."""
+    sd = st.session_state.get("save_dir", "")
+    if sd and os.path.isdir(sd):
+        return os.path.join(sd, filename)
+    return os.path.join(tempfile.gettempdir(), filename)
+
+
+def _run_flashdet_video(video_file, solution_name):
+    if not _HAS_PREDICTOR:
+        raise ImportError("Predictor unavailable")
+    import cv2
+    tmp = tempfile.NamedTemporaryFile(suffix=".mp4", delete=False)
+    tmp.write(video_file.read()); tmp.flush(); video_file.seek(0)
+    cap = cv2.VideoCapture(tmp.name)
+    total = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+    fps = cap.get(cv2.CAP_PROP_FPS) or 30
+
+    weights = st.session_state.get("infer_weights_path", "")
+    if not weights:
+        up = st.session_state.get("infer_weights_file")
+        if up:
+            wtmp = tempfile.NamedTemporaryFile(suffix=".pth", delete=False)
+            wtmp.write(up.read()); wtmp.flush(); up.seek(0)
+            weights = wtmp.name
+
+    custom_cls = _get_class_names()
+    predictor = Predictor(model_path=weights, device=st.session_state.get("infer_device", "cpu").split(" ")[0],
+                          conf_thresh=st.session_state.get("infer_conf", INFER_CONF_THRESHOLD),
+                          nms_thresh=st.session_state.get("infer_nms", INFER_NMS_THRESHOLD),
+                          input_size=st.session_state.get("infer_img_size", INFER_IMG_SIZE),
+                          class_names=custom_cls if custom_cls != COCO_CLASSES else None)
+    tracker = FlashTracker()
+    solution = _create_solution(solution_name, predictor, tracker, fps)
+
+    max_frames = st.session_state.get("infer_max_frames", INFER_MAX_FRAMES) or total
+    skip = st.session_state.get("infer_frame_skip", INFER_FRAME_SKIP)
+    frames_preview, processed, total_dets = [], 0, 0
+    t0 = time.perf_counter()
+    progress = st.progress(0)
+
+    for idx in range(min(total, max_frames)):
+        ret, frame = cap.read()
+        if not ret:
+            break
+        if idx % skip != 0:
+            continue
+        if solution:
+            annotated, results = solution.process_frame(frame)
+        else:
+            results = predictor(frame)
+            annotated = _draw_boxes_cv2(frame, results)
+        if isinstance(results, (list, tuple)):
+            total_dets += len(results)
+        processed += 1
+        if idx % max(total // 4, 1) == 0:
+            frames_preview.append(Image.fromarray(cv2.cvtColor(annotated or frame, cv2.COLOR_BGR2RGB)))
+        progress.progress(idx / min(total, max_frames))
+
+    cap.release(); progress.empty()
+    try:
+        os.unlink(tmp.name)
+    except OSError:
+        pass
+    elapsed = time.perf_counter() - t0
+    sol_output = {}
+    if solution:
+        try:
+            sol_output = solution.get_results()
+            if not isinstance(sol_output, dict):
+                sol_output = {}
+        except Exception:
+            pass
+
+    st.session_state["video_results"] = {
+        "frames": processed, "detections": total_dets, "processing_fps": processed / max(elapsed, 0.001),
+        "elapsed_time": elapsed, "solution_output": sol_output, "frames_preview": frames_preview,
+        "output_path": _get_output_path("output.mp4") if st.session_state.get("infer_save_video") else None,
+    }
+    st.rerun()
+
+
+def _create_solution(solution_name, predictor, tracker, fps):
+    line_pts = st.session_state.get("zone_line_points")
+    polygons = st.session_state.get("zone_polygons")
+    class_filter_names = st.session_state.get("infer_class_filter") or None
+    classes = None
+    if class_filter_names:
+        all_cls = _get_class_names()
+        classes = [all_cls.index(n) for n in class_filter_names if n in all_cls]
+        if not classes:
+            classes = None
+
+    if solution_name == "None (Detection Only)":
+        return None
+
+    first_poly = polygons[0] if polygons and len(polygons) > 0 else []
+    sol_map = {
+        "Object Counter": ("ObjectCounter", dict(line_points=line_pts, classes=classes)),
+        "Region Counter": ("RegionCounter", dict(regions={"zone_0": first_poly} if first_poly else {}, classes=classes)),
+        "Speed Estimator": ("SpeedEstimator", dict(fps=fps, classes=classes)),
+        "Heatmap": ("Heatmap", dict(classes=classes)),
+        "Security Alarm": ("SecurityAlarm", dict(restricted_zones=polygons or [], classes=classes)),
+        "Trajectory": ("TrajectoryVisualizer", dict(classes=classes)),
+        "Blurrer": ("ObjectBlurrer", dict(classes=classes)),
+        "Queue": ("QueueManager", dict(queue_regions=polygons or [], classes=classes, fps=fps)),
+        "Crowd": ("CrowdDensity", dict(classes=classes)),
+        "Parking": ("ParkingManager", dict(parking_spots=polygons or [], classes=classes)),
+        "Traffic": ("TrafficFlow", dict(fps=fps, classes=classes)),
+        "Dwell": ("DwellTimeAnalyzer", dict(zones={"zone_0": first_poly} if first_poly else {}, fps=fps, classes=classes)),
+        "Distance": ("DistanceCalculator", dict(classes=classes)),
+        "Workout": ("WorkoutMonitor", dict(classes=classes)),
+        "Cropper": ("ObjectCropper", dict(classes=classes)),
+        "Analytics": ("AnalyticsDashboard", dict(classes=classes)),
+    }
+
+    for keyword, (cls_name, kwargs) in sol_map.items():
+        if keyword in solution_name:
+            cls = _SOLUTIONS_AVAILABLE.get(cls_name)
+            if not cls:
+                return None
+            try:
+                if cls_name not in ("Heatmap", "ObjectBlurrer", "CrowdDensity"):
+                    return cls(predictor=predictor, tracker=tracker, **kwargs)
+                return cls(predictor=predictor, **kwargs)
+            except TypeError:
+                return cls(predictor=predictor, **kwargs)
+    return None

flashstudio/pages/inference/solution/__init__.py

@@ -0,0 +1,3 @@
+"""Inference — Solution tab sub-package."""
+
+from flashstudio.pages.inference.solution.tab import _tab_solution  # noqa: F401

flashstudio/pages/inference/solution/tab.py

@@ -0,0 +1,121 @@
+"""Inference — Solution tab."""
+
+import streamlit as st
+from flashstudio.constants import (
+    INFER_DISPLAY_WIDTH, INFER_DEFAULT_RESOLUTION,
+    ZONE_MAX_X, ZONE_MAX_Y, ZONE_DEFAULT_LINE, ZONE_DEFAULT_POLYGON,
+)
+from flashstudio.pages.inference._common import (
+    SOLUTIONS, _SOLUTIONS_AVAILABLE, _solution_classes, _HAS_ZONE_DRAWER,
+)
+from flashstudio.pages.inference.data.tab import _get_first_frame
+
+if _HAS_ZONE_DRAWER:
+    from flashstudio.components.zone_drawer import zone_drawer
+
+
+def _tab_solution():
+    sc1, sc2 = st.columns([2, 3])
+    with sc1:
+        selected = st.selectbox("Solution", list(SOLUTIONS.keys()), key="selected_solution",
+                                format_func=lambda x: x)
+        sol = SOLUTIONS[selected]
+        st.caption(sol["desc"])
+        avail = len(_SOLUTIONS_AVAILABLE)
+        total = len(_solution_classes)
+        st.caption(f"{avail}/{total} solutions available")
+
+    with sc2:
+        if sol["needs_zone"]:
+            st.info("Zone required — draw below using Polygon, Rectangle, or Line.")
+        else:
+            st.caption("Zone optional — draw one to limit detection area.")
+        has_line = bool(st.session_state.get("zone_line_points"))
+        has_poly = bool(st.session_state.get("zone_polygons"))
+        if has_line or has_poly:
+            zone_type = "Line" if has_line else "Polygon"
+            st.success(f"Zone set: {zone_type}")
+        elif sol["needs_zone"]:
+            st.warning("No zone defined yet")
+
+    _zone_draw_ui(sol)
+
+
+def _zone_draw_ui(sol):
+    default_type = sol.get("zone_type", "polygon")
+    mode_options = ["polygon", "rect", "line"]
+    default_idx = mode_options.index(default_type) if default_type in mode_options else 0
+    draw_mode = st.radio("Draw Mode", mode_options, index=default_idx, horizontal=True, key="zone_draw_mode",
+                         format_func=lambda x: {"polygon": "Polygon", "rect": "Rectangle", "line": "Line"}[x])
+
+    frame_img = _get_first_frame()
+
+    existing_points = st.session_state.get("zone_draw_points", [])
+    existing_closed = st.session_state.get("zone_closed", False)
+
+    if _HAS_ZONE_DRAWER:
+        result = zone_drawer(image=frame_img, mode=draw_mode, points=existing_points,
+                             closed=existing_closed, display_width=INFER_DISPLAY_WIDTH)
+        if result and result.get("points"):
+            pts = result["points"]
+            img_w = frame_img.size[0] if frame_img else INFER_DEFAULT_RESOLUTION[0]
+            img_h = frame_img.size[1] if frame_img else INFER_DEFAULT_RESOLUTION[1]
+            dw = result.get("displayWidth", INFER_DISPLAY_WIDTH)
+            dh = result.get("displayHeight", INFER_DEFAULT_RESOLUTION[1])
+            sx = img_w / dw if dw else 1
+            sy = img_h / dh if dh else 1
+            _store_zone_coords(pts, draw_mode, sx, sy)
+    else:
+        st.warning("Zone drawing component not available.")
+
+    with st.expander("Set coordinates manually", expanded=not _HAS_ZONE_DRAWER):
+        _manual_zone_input(draw_mode)
+
+
+def _manual_zone_input(draw_mode):
+    if draw_mode == "line":
+        c1, c2 = st.columns(2)
+        with c1:
+            x1 = st.number_input("X1", 0, ZONE_MAX_X, ZONE_DEFAULT_LINE[0][0], key="manual_line_x1")
+            y1 = st.number_input("Y1", 0, ZONE_MAX_Y, ZONE_DEFAULT_LINE[0][1], key="manual_line_y1")
+        with c2:
+            x2 = st.number_input("X2", 0, ZONE_MAX_X, ZONE_DEFAULT_LINE[1][0], key="manual_line_x2")
+            y2 = st.number_input("Y2", 0, ZONE_MAX_Y, ZONE_DEFAULT_LINE[1][1], key="manual_line_y2")
+        if st.button("Set Line", key="set_manual_line"):
+            st.session_state["zone_line_points"] = [(x1, y1), (x2, y2)]
+            st.success(f"({x1},{y1}) → ({x2},{y2})")
+    else:
+        pts = st.text_area("Points (x,y per line)", ZONE_DEFAULT_POLYGON, key="manual_polygon_text")
+        btn_label = "Set Rectangle" if draw_mode == "rect" else "Set Polygon"
+        min_pts = 2 if draw_mode == "rect" else 3
+        if st.button(btn_label, key="set_manual_polygon"):
+            parsed = []
+            for line in pts.strip().split("\n"):
+                p = line.strip().split(",")
+                if len(p) == 2:
+                    try:
+                        parsed.append((int(p[0].strip()), int(p[1].strip())))
+                    except ValueError:
+                        continue
+            if len(parsed) >= min_pts:
+                if draw_mode == "rect" and len(parsed) >= 2:
+                    x1, y1 = parsed[0]; x2, y2 = parsed[1]
+                    st.session_state["zone_polygons"] = [[(x1, y1), (x2, y1), (x2, y2), (x1, y2)]]
+                    st.success(f"Rectangle: ({x1},{y1}) → ({x2},{y2})")
+                else:
+                    st.session_state["zone_polygons"] = [parsed]
+                    st.success(f"{len(parsed)} vertices")
+
+
+def _store_zone_coords(display_points, draw_mode, scale_x, scale_y):
+    orig = [(int(x * scale_x), int(y * scale_y)) for x, y in display_points]
+    if draw_mode == "line" and len(orig) >= 2:
+        st.session_state["zone_line_points"] = [orig[0], orig[1]]
+        st.success(f"Line: {orig[0]} → {orig[1]}")
+    elif draw_mode == "rect" and len(orig) >= 2:
+        x1, y1 = orig[0]; x2, y2 = orig[1]
+        st.session_state["zone_polygons"] = [[(x1, y1), (x2, y1), (x2, y2), (x1, y2)]]
+        st.success(f"Rect: ({x1},{y1})→({x2},{y2})")
+    elif draw_mode == "polygon" and len(orig) >= 3:
+        st.session_state["zone_polygons"] = [orig]
+        st.success(f"Polygon: {len(orig)} pts") if st.session_state.get("zone_closed") else st.info(f"{len(orig)} pts, click more or close")

flashstudio/pages/model/__init__.py

@@ -0,0 +1,3 @@
+"""FlashStudio — Model page package."""
+
+from flashstudio.pages.model.page import render_model_page  # noqa: F401

flashstudio/pages/model/_common.py

@@ -0,0 +1,3 @@
+"""Shared constants and imports for model page tabs."""
+
+from flashstudio.constants import ARCH_FAMILIES, DEFAULT_MODEL_ARCH  # noqa: F401

flashstudio/pages/model/advanced/__init__.py

@@ -0,0 +1,3 @@
+"""Model advanced options sub-package."""
+
+from flashstudio.pages.model.advanced.tab import _tab_adv  # noqa: F401

flashstudio/pages/model/advanced/tab.py

@@ -0,0 +1,54 @@
+"""FlashStudio — Advanced options tab."""
+
+import streamlit as st
+
+
+def _tab_adv():
+    col1, col2 = st.columns(2)
+    with col1:
+        with st.container(border=True):
+            st.markdown("#### Memory")
+            ac1, ac2 = st.columns(2)
+            with ac1:
+                st.checkbox("Act. Checkpoint", False, key="activation_checkpointing")
+                st.checkbox("Act. Offload", False, key="activation_offloading")
+            with ac2:
+                st.checkbox("Optim in Bwd", False, key="optimizer_in_bwd")
+                st.checkbox("torch.compile", False, key="compile_model")
+            st.checkbox("8-bit Optimizer", False, key="use_8bit_optimizer")
+            st.checkbox("Chunked Loss", False, key="chunked_loss")
+            if st.session_state.get("chunked_loss"):
+                st.number_input("Chunk Size", 256, 4096, 1024, key="chunk_size")
+
+    with col2:
+        with st.container(border=True):
+            st.markdown("#### Distributed & IO")
+            st.checkbox("Multi-GPU (DDP)", False, key="ddp")
+
+            nc = st.session_state.get("num_classes", 0)
+            cls_names = st.session_state.get("class_names", "")
+            if isinstance(cls_names, list):
+                cls_names = "\n".join(cls_names)
+            if nc and cls_names.strip():
+                names_list = [c.strip() for c in cls_names.strip().split("\n") if c.strip()]
+                preview = ", ".join(names_list[:5])
+                if len(names_list) > 5:
+                    preview += f" ... (+{len(names_list) - 5})"
+                st.caption(f"Classes ({nc}): {preview}")
+            else:
+                st.caption("Classes: not set — go to Data → Upload")
+
+            st.text_input("Class File (.txt)", placeholder="auto-generated from dataset classes",
+                          key="class_file", help="Leave empty to auto-generate from dataset classes")
+
+            from flashstudio.utils import DEFAULTS
+            if "save_dir" not in st.session_state or not st.session_state.get("save_dir", "").strip():
+                st.session_state["save_dir"] = DEFAULTS["save_dir"]
+            st.text_input("Save Dir", key="save_dir", placeholder=DEFAULTS["save_dir"])
+            rc1, rc2 = st.columns(2)
+            with rc1:
+                st.checkbox("Save Best Only", True, key="save_best")
+            with rc2:
+                st.checkbox("Resume", False, key="resume_training")
+            if st.session_state.get("resume_training"):
+                st.text_input("Checkpoint", placeholder="checkpoint_last.pth", key="resume_path")

flashstudio/pages/model/architecture/__init__.py

@@ -0,0 +1,3 @@
+"""Model architecture sub-package."""
+
+from flashstudio.pages.model.architecture.tab import _tab_arch, _pretrain_finetune  # noqa: F401

flashstudio/pages/model/architecture/tab.py

@@ -0,0 +1,90 @@
+"""FlashStudio — Model architecture tab."""
+
+import streamlit as st
+from flashstudio.constants import (
+    FLASHDET_MODELS, LORA_VARIANTS, ARCH_FAMILIES,
+)
+
+
+def _tab_arch():
+    arch = st.radio("Family", ARCH_FAMILIES, key="arch_family", horizontal=True)
+
+    # Head config — num_classes from dataset
+    nc = st.session_state.get("num_classes", 0)
+    cls_names = st.session_state.get("class_names", "")
+    if isinstance(cls_names, list):
+        cls_names = "\n".join(cls_names)
+    if not nc and cls_names.strip():
+        nc = len([c for c in cls_names.strip().split("\n") if c.strip()])
+        st.session_state["num_classes"] = nc
+
+    if arch == "FlashDet (recommended)":
+        col_sel, col_info = st.columns([2, 3])
+        with col_sel:
+            model = st.radio("Size", list(FLASHDET_MODELS.keys()), index=0, key="model_arch")
+            info = FLASHDET_MODELS[model]
+            if model == "FlashDet-Pico":
+                st.selectbox("Backbone", ["LiteBackbone", "PicoBackbone"], key="pico_backbone")
+            else:
+                st.caption(f"Backbone: {info['backbone']}")
+            st.caption(f"{info['neck']} → {info['head']} · CIoU+BCE+L1 · STAL · ProgLoss")
+
+        with col_info:
+            m1, m2, m3, m4 = st.columns(4)
+            with m1:
+                st.metric("Params", info["params"])
+            with m2:
+                st.metric("Speed", info["speed"])
+            with m3:
+                st.metric("Best For", info["for"])
+            with m4:
+                st.metric("Head Classes", nc if nc else "—")
+            if nc:
+                st.caption(f"Model head output → **{nc}** classes (auto-set from dataset)")
+            else:
+                st.info("No classes detected yet. Go to **Data** → **Upload** to load a dataset and classes will be set automatically.")
+            _pretrain_finetune()
+    else:
+        name = arch.replace(" (recommended)", "")
+        col_sel, col_info = st.columns([2, 3])
+        with col_sel:
+            st.slider("Width ×", 0.25, 1.5, 0.5, 0.25, key="yolo_width_mult")
+            st.slider("Depth ×", 0.33, 1.5, 0.33, 0.33, key="yolo_depth_mult")
+            if name == "YOLOv9":
+                st.checkbox("PGI", True, key="yolo_use_pgi")
+            elif name == "YOLOv10":
+                st.checkbox("PSA", True, key="yolo_use_psa")
+            elif name == "YOLOv11":
+                st.checkbox("C2PSA", True, key="yolo_use_c2psa")
+        with col_info:
+            st.caption(f"{name} — fixed backbone/neck/head. Control via width/depth multipliers.")
+            if nc:
+                st.metric("Head Classes", nc)
+            _pretrain_finetune()
+
+
+def _pretrain_finetune():
+    with st.container(border=True):
+        c1, c2 = st.columns(2)
+        with c1:
+            st.markdown("#### Pretrained")
+            pt = st.radio("Init", ["COCO pretrained", "ImageNet backbone", "Random", "Custom"],
+                          key="pretrain_option", label_visibility="collapsed")
+            if pt == "Custom":
+                st.text_input("Path", placeholder="/path/model.pth", key="custom_weights")
+        with c2:
+            st.markdown("#### Fine-tune")
+            ft = st.radio("Mode", ["Full fine-tune", "Freeze backbone", "Freeze BB+neck", "LoRA"],
+                          key="finetune_strategy", label_visibility="collapsed")
+            if ft == "LoRA":
+                lc1, lc2 = st.columns(2)
+                with lc1:
+                    st.selectbox("Variant", LORA_VARIANTS, key="lora_variant")
+                    st.slider("Rank", 4, 64, 16, key="lora_rank")
+                with lc2:
+                    st.slider("Alpha", 8, 128, 32, key="lora_alpha")
+                    st.slider("Dropout", 0.0, 0.5, 0.0, key="lora_dropout")
+                st.multiselect("Targets", ["backbone", "neck", "head"], default=["backbone", "neck"], key="lora_targets")
+                st.checkbox("QLoRA", False, key="qlora")
+                if st.session_state.get("qlora"):
+                    st.selectbox("Quant", ["int8", "nf4"], key="qlora_dtype")

flashstudio/pages/model/augment/__init__.py

@@ -0,0 +1,3 @@
+"""Model augmentation sub-package."""
+
+from flashstudio.pages.model.augment.tab import _tab_aug  # noqa: F401

flashstudio/pages/model/augment/tab.py

@@ -0,0 +1,18 @@
+"""FlashStudio — Augmentation tab."""
+
+import streamlit as st
+
+
+def _tab_aug():
+    col1, col2 = st.columns(2)
+    with col1:
+        with st.container(border=True):
+            st.markdown("#### Multi-Image")
+            st.checkbox("Mosaic (4-image)", True, key="aug_mosaic")
+            st.checkbox("MixUp", False, key="aug_mixup")
+            st.checkbox("CopyPaste", False, key="aug_copypaste")
+    with col2:
+        with st.container(border=True):
+            st.markdown("#### Built-in (always on)")
+            for a in ["Scale jitter 0.5–1.5×", "Horizontal flip", "Color jitter", "Letterbox resize", "ImageNet norm"]:
+                st.markdown(f'<span style="font-size:0.88rem;color:#4B5563;">• {a}</span>', unsafe_allow_html=True)

flashstudio/pages/model/hyperparams/__init__.py

@@ -0,0 +1,4 @@
+"""Model hyperparams sub-package."""
+
+from flashstudio.pages.model.hyperparams.tab import _tab_hyper, _summary_bar  # noqa: F401
+from flashstudio.pages.model.utils.config import _build_cfg, _apply_cfg  # noqa: F401

flashstudio/pages/model/hyperparams/tab.py

@@ -0,0 +1,89 @@
+"""FlashStudio — Hyperparameters tab, summary bar."""
+
+import yaml
+import streamlit as st
+from flashstudio.constants import (
+    OPTIMIZERS,
+    TRAIN_EPOCHS, TRAIN_BATCH_SIZE, TRAIN_LR, TRAIN_IMG_SIZE,
+    TRAIN_WEIGHT_DECAY, TRAIN_WARMUP_EPOCHS, TRAIN_PATIENCE,
+    TRAIN_NUM_WORKERS, TRAIN_GRAD_ACCUM, TRAIN_VAL_INTERVAL,
+    TRAIN_LR_FINAL_RATIO, BATCH_SIZE_OPTIONS, IMG_SIZE_OPTIONS,
+    DEFAULT_MODEL_ARCH,
+)
+
+
+def _tab_hyper():
+    col1, col2 = st.columns(2)
+    with col1:
+        with st.container(border=True):
+            st.markdown("#### Core")
+            hc1, hc2 = st.columns(2)
+            with hc1:
+                st.number_input("Epochs", min_value=1, max_value=10000, value=TRAIN_EPOCHS, step=10, key="epochs")
+                st.select_slider("Batch", BATCH_SIZE_OPTIONS, value=TRAIN_BATCH_SIZE, key="batch_size")
+                st.select_slider("Img Size", IMG_SIZE_OPTIONS, value=TRAIN_IMG_SIZE, key="img_size")
+            with hc2:
+                st.slider("LR", 1e-5, 1e-1, TRAIN_LR, format="%.5f", key="lr")
+                st.slider("Weight Decay", 0.0, 0.1, TRAIN_WEIGHT_DECAY, format="%.3f", key="weight_decay")
+                st.selectbox("Optimizer", OPTIMIZERS, key="optimizer")
+
+    with col2:
+        with st.container(border=True):
+            st.markdown("#### Schedule & Options")
+            sc1, sc2 = st.columns(2)
+            with sc1:
+                st.slider("Warmup Ep", 0, 20, TRAIN_WARMUP_EPOCHS, key="warmup_epochs")
+                st.slider("LR Final ×", 0.01, 0.5, TRAIN_LR_FINAL_RATIO, format="%.2f", key="lr_final_ratio")
+                st.slider("Workers", 0, 16, TRAIN_NUM_WORKERS, key="num_workers")
+            with sc2:
+                st.slider("Patience", 5, 100, TRAIN_PATIENCE, key="patience")
+                st.number_input("Grad Accum", 1, 16, TRAIN_GRAD_ACCUM, key="grad_accum")
+                st.slider("Val Interval", 1, 20, TRAIN_VAL_INTERVAL, key="val_interval")
+            oc1, oc2, oc3 = st.columns(3)
+            with oc1:
+                st.checkbox("AMP FP16", True, key="amp")
+            with oc2:
+                st.checkbox("Grad Clip", True, key="grad_clip")
+            with oc3:
+                st.checkbox("Multi-Scale", False, key="multiscale")
+
+
+def _summary_bar():
+    model = st.session_state.get("model_arch", DEFAULT_MODEL_ARCH)
+    nc = st.session_state.get("num_classes", 0)
+    cls_names = st.session_state.get("class_names", "")
+    if isinstance(cls_names, list):
+        cls_names = "\n".join(cls_names)
+    nc_display = nc if nc else len([c for c in cls_names.strip().split("\n") if c.strip()]) if cls_names.strip() else "—"
+    st.markdown(
+        f'<div class="info-bar">'
+        f'Model: <b>{model.replace("FlashDet-", "")}</b> · '
+        f'Classes: <b>{nc_display}</b> · '
+        f'Ep: <b>{st.session_state.get("epochs", TRAIN_EPOCHS)}</b> · '
+        f'BS: <b>{st.session_state.get("batch_size", TRAIN_BATCH_SIZE)}</b> · '
+        f'LR: <b>{st.session_state.get("lr", TRAIN_LR):.1e}</b> · '
+        f'Img: <b>{st.session_state.get("img_size", TRAIN_IMG_SIZE)}</b> · '
+        f'AMP: <b>{"On" if st.session_state.get("amp", True) else "Off"}</b>'
+        f'</div>',
+        unsafe_allow_html=True,
+    )
+    with st.expander("Save / Load Config", expanded=False):
+        c1, c2 = st.columns(2)
+        with c1:
+            from flashstudio.utils.config import build_training_config
+            full_cfg = build_training_config()
+            st.download_button("Download YAML", yaml.dump(full_cfg, default_flow_style=False, sort_keys=False),
+                               file_name="config.yaml", mime="text/yaml", use_container_width=True)
+        with c2:
+            up = st.file_uploader("Load", type=["yaml", "yml"], key="cfg_upload", label_visibility="collapsed")
+            if up:
+                try:
+                    loaded = yaml.safe_load(up.read().decode("utf-8"))
+                    if st.button("Apply", key="apply_cfg", use_container_width=True):
+                        from flashstudio.utils import flash
+                        from flashstudio.pages.model.utils.config import _apply_cfg
+                        _apply_cfg(loaded)
+                        flash("Config applied", "success")
+                        st.rerun()
+                except Exception as e:
+                    st.error(str(e)[:40])

flashstudio/pages/model/page.py

@@ -0,0 +1,30 @@
+"""FlashStudio — Model Config (ultra-compact, no-scroll)."""
+
+import streamlit as st
+
+from flashstudio.pages.model.architecture.tab import _tab_arch
+from flashstudio.pages.model.hyperparams.tab import _tab_hyper, _summary_bar
+from flashstudio.pages.model.augment.tab import _tab_aug
+from flashstudio.pages.model.advanced.tab import _tab_adv
+
+
+def render_model_page():
+    from flashstudio.components.styles import render_page_header
+    from flashstudio.utils import show_flashes, update_config_mirror
+    render_page_header("", "Model")
+    show_flashes()
+
+    tab_arch, tab_hyper, tab_aug, tab_adv = st.tabs(["Architecture", "Hyperparams", "Augment", "Advanced"])
+
+    with tab_arch:
+        _tab_arch()
+    with tab_hyper:
+        _tab_hyper()
+    with tab_aug:
+        _tab_aug()
+    with tab_adv:
+        _tab_adv()
+
+    _summary_bar()
+
+    update_config_mirror()

flashstudio/pages/model/utils/__init__.py

@@ -0,0 +1,3 @@
+"""Model utility helpers."""
+
+from flashstudio.pages.model.utils.config import _build_cfg, _apply_cfg  # noqa: F401