Upload 3 files

README.md

@@ -1,252 +1,184 @@
 ---
-title: Ice Cream Counter
+title: Ice Cream Dataset + Counter
 emoji: 🍦
-colorFrom: blue
+colorFrom: yellow
 colorTo: red
-sdk: docker
+sdk: gradio
+sdk_version: 6.5.1
+app_file: app.py
 pinned: false
 ---
 
-# Ice Cream Counter
+# 🍦 Ice Cream Dataset + Counter — Gradio Space
 
-RT-DETR-based ice cream detection and counting API.
-
-## Features
-
-- Upload training freezer photos once
-- Save the dataset
-- Annotate individual ice creams
-- Train an RT-DETR model
-- Save the trained model
-- Upload new images one by one
-- Detect and count every ice cream by type
-- No YOLO
-
-## Main workflow
-
-1. Define your ice cream classes.
-2. Upload training images.
-3. Annotate each ice cream with a bounding box and product type.
-4. Train the RT-DETR model.
-5. The trained model is saved.
-6. Upload a new freezer image.
-7. Get the total count and count for every product type.
-
-## API
-
-- `GET /health`
-- `POST /dataset/images`
-- `GET /dataset`
-- `POST /dataset/annotations`
-- `POST /train`
-- `GET /training/status`
-- `GET /model`
-- `POST /count`
-
-## Local development
-
-```bash
-pip install -r requirements.txt
-uvicorn app.main:app --host 0.0.0.0 --port 7860
+This is the **Gradio version** of the uploaded Ice Cream Counter project. It does **not** use Docker, FastAPI, Uvicorn, or a custom HTML frontend.
 
+## What it does
 
+1. Upload training freezer photos.
+2. Define your product classes.
+3. Annotate each ice cream with bounding boxes.
+4. Train an RT-DETR object detector.
+5. Upload one new freezer image.
+6. Get the total count, per-product counts, confidence scores, and an annotated result image.
 
-# Ice Cream Freezer Counter — RT-DETR + Hugging Face
+The model is still:
 
-A complete object-detection project for counting individual ice creams in freezer photos and identifying each product type.
+`PekingU/rtdetr_r50vd`
 
-**No YOLO is used.** The detector is Hugging Face Transformers' RT-DETR (`PekingU/rtdetr_r50vd`), fine-tuned on your own annotated freezer images.
+No YOLO is used.
 
-## What it does
+## Create the Hugging Face Space
 
-Upload a freezer photo:
+Create a new Space and choose:
 
-- detects every visible ice cream
-- classifies each detected item (for example `cornetto`, `magnum`, `cone`, `cup`)
-- counts items per class
-- returns bounding boxes and confidence scores
-- optionally returns an annotated image
+- **SDK:** Gradio
+- **Hardware:** GPU is strongly recommended for training
 
-Example response:
+Then upload these files/folders:
 
-```json
-{
-  "total": 17,
-  "counts": {
-    "cornetto": 7,
-    "magnum": 5,
-    "cone": 3,
-    "cup": 2
-  },
-  "detections": [
-    {
-      "class": "cornetto",
-      "confidence": 0.96,
-      "box": [120, 85, 210, 310]
-    }
-  ]
-}
+```text
+app.py
+requirements.txt
+README.md
+training/
 ```
 
-## 1. Define your classes
-
-Edit `training/classes.txt`.
-
-Example:
+You do **not** need:
 
 ```text
-cornetto
-magnum
-cone
-cup
-sandwich
-stick
-other
+Dockerfile
+FastAPI
+Uvicorn
+static/index.html
+app/main.py
 ```
 
-Use the exact product names you want returned by the API. If "correto" is your actual product spelling, use `correto`; otherwise use the correct brand/product name.
-
-## 2. Annotate your images
-
-Use an annotation tool such as CVAT, Label Studio, Roboflow, or another COCO-compatible tool.
-
-Annotate **each individual ice cream**, not just the freezer shelf.
+## Persistent dataset and model
 
-Export in **COCO object-detection format**.
-
-Expected layout:
+The app stores:
 
 ```text
-data/
-  train/
-    images/
-      0001.jpg
-      0002.jpg
-    annotations.json
-  val/
-    images/
-      1001.jpg
-      1002.jpg
-    annotations.json
+images/
+dataset.json
+model/
+generated_dataset/
 ```
 
-The `annotations.json` files must be COCO detection JSON.
+When `/data` is available and writable, the app automatically uses:
 
-Important:
-- draw one bounding box around each visible product
-- assign the correct product class
-- include partially visible products if you want them counted
-- keep train and validation images separate
-- avoid putting near-duplicate photos in both sets
+```text
+/data/icecream_counter/
+```
 
-A useful starting target is 500–2,000+ annotated images. More variation is usually more valuable than many almost-identical photos.
+You can also explicitly set:
 
-## 3. Install
+```text
+DATA_DIR=/data/icecream_counter
+```
 
-Python 3.10+ is recommended.
+in the Space variables.
 
-```bash
-pip install -r requirements.txt
-```
+### Important Hugging Face storage point
 
-For NVIDIA GPU training, install the appropriate PyTorch build for your CUDA version first, following the official PyTorch instructions.
+A normal Space filesystem is not permanent storage across every rebuild/restart. If you need the dataset and trained model to survive Space restarts/rebuilds, attach **persistent storage** to the Space or move the data/model to an external persistent service.
 
-## 4. Train
+The Gradio conversion itself does not change this storage rule.
 
-Make sure the dataset is in the structure above, then:
+## Annotation workflow
 
-```bash
-python training/train.py \
-  --train-dir data/train \
-  --val-dir data/val \
-  --output-dir model \
-  --epochs 30 \
-  --batch-size 2 \
-  --learning-rate 1e-5
-```
+In the **Annotate** tab:
 
-For a small GPU, use `--batch-size 1`.
+1. Select a training image.
+2. Select the class.
+3. Enter the bounding box in the original image's pixel coordinates:
+   - X
+   - Y
+   - Width
+   - Height
+4. Click **Add Box**.
+5. Repeat for every ice cream.
+6. Use **Delete Box** or **Clear All Boxes** when needed.
 
-The script starts from `PekingU/rtdetr_r50vd` and replaces the classification head with your product classes.
+The preview displays the saved boxes.
 
-At the end, `model/` contains the fine-tuned Hugging Face model and processor.
+This coordinate-based annotation UI is intentionally implemented entirely in Gradio/Python so it does not depend on a custom JavaScript/FastAPI frontend.
 
-## 5. Test locally
+## Training
 
-```bash
-python -m uvicorn app.main:app --host 0.0.0.0 --port 7860
-```
+The app creates an 80/20 COCO train/validation split from the annotated images and starts the existing RT-DETR training script.
 
-Open:
+Default settings:
 
 ```text
-http://localhost:7860/docs
+Epochs: 30
+Batch size: 2
+Learning rate: 1e-5
 ```
 
-Use `POST /predict` to upload an image.
+For an initial test on a small dataset, use fewer epochs such as 2–5. Once everything works, increase the epochs.
 
-Or from Python:
+A GPU Space is strongly recommended.
 
-```python
-import requests
+## Counting
 
-with open("freezer.jpg", "rb") as f:
-    r = requests.post(
-        "http://localhost:7860/predict",
-        files={"file": ("freezer.jpg", f, "image/jpeg")}
-    )
+After training, open the **Count** tab and upload one image.
 
-print(r.json())
-```
+The result contains:
 
-## 6. Environment variables
-
-The API supports:
-
-```text
-MODEL_ID=./model
-CONFIDENCE_THRESHOLD=0.35
-MAX_IMAGE_MB=15
+```json
+{
+  "total": 31,
+  "counts": {
+    "cone": 6,
+    "correto": 7,
+    "cornetto": 12,
+    "magnum": 6
+  }
+}
 ```
 
-If the model is stored on the Hugging Face Hub instead of the local filesystem:
+The result image also shows the detected bounding boxes and confidence values.
+
+## Default classes
 
 ```text
-MODEL_ID=your-username/your-icecream-rtdetr
-HF_TOKEN=hf_...
+cornetto
+magnum
+correto
+cone
+cup
+sandwich
+stick
+other
 ```
 
-## 7. Deploy to Hugging Face
-
-Create a Hugging Face **Docker Space** and upload this repository.
+You can change them from the Dataset tab.
 
-The included `Dockerfile` listens on port `7860`.
+## Local test
 
-For a private model, add a Space secret named:
-
-```text
-HF_TOKEN
+```bash
+pip install -r requirements.txt
+python app.py
 ```
 
-and set:
+Then open:
 
 ```text
-MODEL_ID=your-username/your-icecream-rtdetr
+http://localhost:7860
 ```
 
-If the model is public, `HF_TOKEN` is not required.
-
-## Accuracy notes
-
-Counting accuracy depends heavily on the training data. Freezer images have difficult cases: occlusion, reflections, small objects, similar packaging, tilted products, and products stacked behind each other.
-
-Start with a confidence threshold around `0.35–0.50` and tune it on validation photos.
-
-If two products are touching or one is heavily hidden, the detector can still miss or merge them. Add examples of those exact situations to the training set.
+## Recommended Space setup
 
-## Why RT-DETR?
+For the first deployment:
 
-RT-DETR is a transformer-based object detector available in Hugging Face Transformers. It produces object boxes and class labels and is suitable for instance counting. This project deliberately does not use YOLO.
+1. Create the Space as **Gradio**.
+2. Upload `app.py`, `requirements.txt`, `README.md`, and `training/`.
+3. Wait for dependencies to install.
+4. Open the Dataset tab.
+5. Upload 2+ training images.
+6. Annotate them.
+7. Start with 2–5 epochs to verify training.
+8. After the model finishes, test the Count tab.
+9. For serious training, attach a GPU and persistent storage.
 
-Hugging Face reference:
-https://huggingface.co/docs/transformers/model_doc/rt_detr

app.py

@@ -0,0 +1,490 @@
+import io
+import json
+import os
+import shutil
+import subprocess
+import sys
+import threading
+from collections import Counter
+from pathlib import Path
+
+import gradio as gr
+import torch
+from PIL import Image, ImageDraw
+from transformers import RTDetrForObjectDetection, RTDetrImageProcessor
+
+# Hugging Face Spaces can mount persistent storage at /data.
+# DATA_DIR can be overridden in Space Settings -> Variables.
+if os.getenv("DATA_DIR"):
+    BASE = Path(os.environ["DATA_DIR"])
+elif Path("/data").exists() and os.access("/data", os.W_OK):
+    BASE = Path("/data") / "icecream_counter"
+else:
+    BASE = Path("./data")
+
+ROOT = Path(__file__).resolve().parent
+IMAGE_DIR = BASE / "images"
+DATASET_FILE = BASE / "dataset.json"
+MODEL_DIR = BASE / "model"
+GENERATED_DIR = BASE / "generated_dataset"
+CLASSES_FILE = ROOT / "training" / "classes.txt"
+
+IMAGE_DIR.mkdir(parents=True, exist_ok=True)
+BASE.mkdir(parents=True, exist_ok=True)
+MODEL_DIR.mkdir(parents=True, exist_ok=True)
+
+CONFIDENCE_THRESHOLD = float(os.getenv("CONFIDENCE_THRESHOLD", "0.35"))
+MAX_IMAGE_MB = int(os.getenv("MAX_IMAGE_MB", "15"))
+
+_training = {"running": False, "message": "not started", "error": None}
+_model = None
+_processor = None
+_model_lock = threading.Lock()
+_annotation_click = None
+
+
+def load_dataset():
+    if not DATASET_FILE.exists():
+        return {"images": [], "classes": read_classes()}
+    try:
+        data = json.loads(DATASET_FILE.read_text(encoding="utf-8"))
+        data.setdefault("images", [])
+        data["classes"] = read_classes()
+        return data
+    except Exception:
+        return {"images": [], "classes": read_classes()}
+
+
+def save_dataset(data):
+    data["classes"] = read_classes()
+    tmp = DATASET_FILE.with_suffix(".tmp")
+    tmp.write_text(json.dumps(data, indent=2, ensure_ascii=False), encoding="utf-8")
+    tmp.replace(DATASET_FILE)
+
+
+def read_classes():
+    if not CLASSES_FILE.exists():
+        return []
+    return [x.strip() for x in CLASSES_FILE.read_text(encoding="utf-8").splitlines() if x.strip()]
+
+
+def image_path(image_id):
+    return IMAGE_DIR / f"{image_id}.jpg"
+
+
+def model_ready():
+    return (MODEL_DIR / "config.json").exists()
+
+
+def load_model():
+    global _model, _processor
+    if not model_ready():
+        raise RuntimeError("No trained model yet. Train the model first.")
+    with _model_lock:
+        if _model is None:
+            _processor = RTDetrImageProcessor.from_pretrained(str(MODEL_DIR))
+            _model = RTDetrForObjectDetection.from_pretrained(str(MODEL_DIR))
+            _model.to("cuda" if torch.cuda.is_available() else "cpu")
+            _model.eval()
+    return _processor, _model
+
+
+def dataset_status():
+    data = load_dataset()
+    annotated = sum(bool(x.get("annotations")) for x in data["images"])
+    return (
+        f"**Dataset:** {len(data['images'])} images  |  "
+        f"**Annotated:** {annotated}  |  "
+        f"**Classes:** {len(read_classes())}  |  "
+        f"**Model:** {'READY' if model_ready() else 'NOT TRAINED'}  |  "
+        f"**Storage:** `{BASE}`"
+    )
+
+
+def image_choices():
+    data = load_dataset()
+    return [(x["filename"], x["id"]) for x in data["images"]]
+
+
+def upload_training_images(files):
+    if not files:
+        return dataset_status(), gr.update(choices=image_choices()), "No files selected."
+
+    data = load_dataset()
+    saved = 0
+    skipped = []
+    for f in files:
+        path = Path(getattr(f, "path", getattr(f, "name", f)))
+        try:
+            raw = path.read_bytes()
+            if len(raw) > MAX_IMAGE_MB * 1024 * 1024:
+                skipped.append(f"{path.name}: over {MAX_IMAGE_MB} MB")
+                continue
+            im = Image.open(io.BytesIO(raw)).convert("RGB")
+            image_id = __import__("uuid").uuid4().hex
+            out = image_path(image_id)
+            im.save(out, "JPEG", quality=95)
+            data["images"].append({
+                "id": image_id,
+                "filename": path.name,
+                "width": im.width,
+                "height": im.height,
+                "annotations": [],
+            })
+            saved += 1
+        except Exception as e:
+            skipped.append(f"{path.name}: {e}")
+
+    save_dataset(data)
+    msg = f"Saved {saved} image(s)."
+    if skipped:
+        msg += "\nSkipped:\n- " + "\n- ".join(skipped)
+    return dataset_status(), gr.update(choices=image_choices()), msg
+
+
+def load_editor(image_id):
+    if not image_id:
+        return None, "Select an image.", [], None, None
+    data = load_dataset()
+    item = next((x for x in data["images"] if x["id"] == image_id), None)
+    if not item:
+        return None, "Image not found.", [], None, None
+    p = image_path(image_id)
+    return (
+        str(p),
+        f"**{item['filename']}** — {item['width']} × {item['height']} px",
+        item.get("annotations", []),
+        item["width"],
+        item["height"],
+    )
+
+
+def draw_annotations(image_id):
+    if not image_id:
+        return None
+    p = image_path(image_id)
+    if not p.exists():
+        return None
+    image = Image.open(p).convert("RGB")
+    data = load_dataset()
+    item = next((x for x in data["images"] if x["id"] == image_id), None)
+    if not item:
+        return image
+    draw = ImageDraw.Draw(image)
+    for i, a in enumerate(item.get("annotations", []), 1):
+        x, y, w, h = a["box"]
+        color = "red"
+        draw.rectangle([x, y, x+w, y+h], outline=color, width=4)
+        label = f"{i}. {a['class']}"
+        draw.rectangle([x, max(0, y-22), x+max(100, len(label)*8), y], fill=color)
+        draw.text((x+3, max(0, y-20)), label, fill="white")
+    return image
+
+
+def save_classes(text):
+    classes = [x.strip() for x in (text or "").splitlines() if x.strip()]
+    if not classes:
+        return "At least one class is required.", gr.update(choices=[]), dataset_status()
+    if len(set(classes)) != len(classes):
+        return "Classes must be unique.", gr.update(choices=classes), dataset_status()
+    CLASSES_FILE.write_text("\n".join(classes) + "\n", encoding="utf-8")
+    data = load_dataset()
+    save_dataset(data)
+    return f"Saved {len(classes)} classes.", gr.update(choices=classes, value=classes[0]), dataset_status()
+
+
+def add_annotation(image_id, cls, x, y, w, h):
+    if not image_id:
+        return None, "Select an image first.", [], []
+    if not cls:
+        return None, "Select a class.", [], []
+    try:
+        x, y, w, h = map(float, [x, y, w, h])
+    except Exception:
+        return None, "Coordinates must be numbers.", [], []
+    if w <= 0 or h <= 0:
+        return None, "Width and height must be greater than zero.", [], []
+    data = load_dataset()
+    item = next((z for z in data["images"] if z["id"] == image_id), None)
+    if not item:
+        return None, "Image not found.", [], []
+    x = max(0, min(x, item["width"] - 1))
+    y = max(0, min(y, item["height"] - 1))
+    w = min(w, item["width"] - x)
+    h = min(h, item["height"] - y)
+    item.setdefault("annotations", []).append({"class": cls, "box": [x, y, w, h]})
+    save_dataset(data)
+    anns = item["annotations"]
+    return draw_annotations(image_id), f"Added {cls}: [{x:.0f}, {y:.0f}, {w:.0f}, {h:.0f}]", anns, anns
+
+
+def remove_annotation(image_id, index):
+    if not image_id:
+        return None, "Select an image first.", []
+    data = load_dataset()
+    item = next((z for z in data["images"] if z["id"] == image_id), None)
+    if not item:
+        return None, "Image not found.", []
+    try:
+        idx = int(index) - 1
+    except Exception:
+        return None, "Enter the annotation number to delete.", item.get("annotations", [])
+    anns = item.get("annotations", [])
+    if idx < 0 or idx >= len(anns):
+        return None, "Annotation number not found.", anns
+    deleted = anns.pop(idx)
+    save_dataset(data)
+    return draw_annotations(image_id), f"Deleted annotation {index}: {deleted['class']}", anns
+
+
+def clear_annotations(image_id):
+    if not image_id:
+        return None, "Select an image first.", []
+    data = load_dataset()
+    item = next((z for z in data["images"] if z["id"] == image_id), None)
+    if not item:
+        return None, "Image not found.", []
+    item["annotations"] = []
+    save_dataset(data)
+    return draw_annotations(image_id), "Annotations cleared.", []
+
+
+def build_coco():
+    data = load_dataset()
+    classes = read_classes()
+    if not classes:
+        raise RuntimeError("No classes configured.")
+    items = [x for x in data["images"] if x.get("annotations")]
+    if len(items) < 2:
+        raise RuntimeError("Annotate at least 2 images before training.")
+
+    # Deterministic split; upload a reasonably shuffled dataset.
+    split = max(1, int(len(items) * 0.8))
+    if split == len(items):
+        split -= 1
+    train_items, val_items = items[:split], items[split:]
+    category_id = {name: i + 1 for i, name in enumerate(classes)}
+
+    def make_coco(selected):
+        images, annotations = [], []
+        ann_id = 1
+        for item in selected:
+            images.append({
+                "id": item["id"],
+                "file_name": item["id"] + ".jpg",
+                "width": item["width"],
+                "height": item["height"],
+            })
+            for ann in item["annotations"]:
+                x, y, w, h = ann["box"]
+                annotations.append({
+                    "id": ann_id,
+                    "image_id": item["id"],
+                    "category_id": category_id[ann["class"]],
+                    "bbox": [x, y, w, h],
+                    "area": w*h,
+                    "iscrowd": 0,
+                })
+                ann_id += 1
+        return {
+            "images": images,
+            "annotations": annotations,
+            "categories": [{"id": i+1, "name": n} for i, n in enumerate(classes)]
+        }
+
+    if GENERATED_DIR.exists():
+        shutil.rmtree(GENERATED_DIR)
+    for name, selected in [("train", train_items), ("val", val_items)]:
+        d = GENERATED_DIR / name
+        (d / "images").mkdir(parents=True, exist_ok=True)
+        for item in selected:
+            shutil.copy2(image_path(item["id"]), d / "images" / f"{item['id']}.jpg")
+        (d / "annotations.json").write_text(
+            json.dumps(make_coco(selected), indent=2), encoding="utf-8"
+        )
+
+
+def run_training(epochs, batch_size, learning_rate):
+    global _training, _model
+    try:
+        _training = {"running": True, "message": "building COCO dataset", "error": None}
+        build_coco()
+        _training["message"] = "training RT-DETR"
+        cmd = [
+            sys.executable, str(ROOT / "training" / "train.py"),
+            "--train-dir", str(GENERATED_DIR / "train"),
+            "--val-dir", str(GENERATED_DIR / "val"),
+            "--classes", str(CLASSES_FILE),
+            "--output-dir", str(MODEL_DIR),
+            "--epochs", str(int(epochs)),
+            "--batch-size", str(int(batch_size)),
+            "--learning-rate", str(float(learning_rate)),
+        ]
+        result = subprocess.run(cmd, cwd=ROOT, capture_output=True, text=True)
+        if result.returncode != 0:
+            raise RuntimeError((result.stderr or result.stdout)[-8000:])
+        _model = None
+        _training = {"running": False, "message": "training complete", "error": None}
+    except Exception as e:
+        _training = {"running": False, "message": "training failed", "error": str(e)}
+
+
+def start_training(epochs, batch_size, learning_rate):
+    if _training["running"]:
+        return "Training is already running."
+    threading.Thread(
+        target=run_training,
+        args=(epochs, batch_size, learning_rate),
+        daemon=True,
+    ).start()
+    return "Training started in the background. Use Refresh Training Status."
+
+
+def training_status():
+    return json.dumps(_training, indent=2)
+
+
+def count_image(image):
+    if image is None:
+        return None, "Upload an image first.", {}
+    if not model_ready():
+        return None, "Model is not trained yet. Go to Training.", {}
+    try:
+        proc, detector = load_model()
+        image = image.convert("RGB") if isinstance(image, Image.Image) else Image.fromarray(image).convert("RGB")
+        device = next(detector.parameters()).device
+        inputs = proc(images=image, return_tensors="pt")
+        inputs = {k: v.to(device) if torch.is_tensor(v) else v for k, v in inputs.items()}
+        with torch.inference_mode():
+            outputs = detector(**inputs)
+        target_sizes = torch.tensor([[image.height, image.width]], device=device)
+        result = proc.post_process_object_detection(
+            outputs, threshold=CONFIDENCE_THRESHOLD, target_sizes=target_sizes
+        )[0]
+
+        detections = []
+        counts = Counter()
+        for score, label, box in zip(result["scores"], result["labels"], result["boxes"]):
+            s = float(score.item())
+            cls = detector.config.id2label[int(label.item())]
+            coords = [round(float(v), 2) for v in box.tolist()]
+            detections.append({"class": cls, "confidence": round(s, 4), "box": coords})
+            counts[cls] += 1
+
+        out = image.copy()
+        draw = ImageDraw.Draw(out)
+        for d in detections:
+            x1, y1, x2, y2 = d["box"]
+            draw.rectangle([x1, y1, x2, y2], outline="red", width=4)
+            label = f"{d['class']} {d['confidence']:.2f}"
+            draw.rectangle([x1, max(0, y1-22), x1+max(120, len(label)*8), y1], fill="red")
+            draw.text((x1+3, max(0, y1-20)), label, fill="white")
+
+        response = {
+            "total": len(detections),
+            "counts": dict(sorted(counts.items())),
+            "detections": detections,
+        }
+        return out, json.dumps(response, indent=2), response["counts"]
+    except Exception as e:
+        return None, f"Counting failed: {e}", {}
+
+
+# ----- Gradio UI -----
+CSS = """
+.gradio-container { max-width: 1250px !important; }
+h1 { margin-bottom: 0.2rem !important; }
+.status { padding: 10px 14px; border-radius: 10px; }
+"""
+
+with gr.Blocks(title="Ice Cream Dataset + Counter", css=CSS) as demo:
+    gr.Markdown("# 🍦 Ice Cream Dataset + Counter\nUpload and annotate training images, train RT-DETR, then count ice creams in new images.")
+    status = gr.Markdown(dataset_status(), elem_classes="status")
+
+    with gr.Tab("1 · Dataset"):
+        gr.Markdown("### Upload training images")
+        files = gr.Files(file_count="multiple", file_types=["image"], label="Images")
+        upload_btn = gr.Button("Save Images", variant="primary")
+        upload_msg = gr.Markdown()
+        # Dataset selector
+        image_select = gr.Dropdown(choices=image_choices(), label="Training image", interactive=True)
+        refresh_btn = gr.Button("Refresh Dataset")
+        refresh_btn.click(lambda: (dataset_status(), gr.update(choices=image_choices())), None, [status, image_select])
+
+        gr.Markdown("### Classes")
+        class_text = gr.Textbox(value="\n".join(read_classes()), lines=8, label="One class per line")
+        save_class_btn = gr.Button("Save Classes")
+        class_msg = gr.Markdown()
+        # Class dropdown is updated after the Annotate tab creates it.
+
+    with gr.Tab("2 · Annotate"):
+        gr.Markdown(
+            "Select an image. To create a box, enter **X, Y, Width, Height** in original image pixels. "
+            "The preview shows saved boxes. This is deliberately simple and works reliably inside Gradio Spaces."
+        )
+        with gr.Row():
+            with gr.Column(scale=2):
+                editor_image = gr.Image(label="Training image", type="pil", interactive=False)
+                editor_info = gr.Markdown()
+            with gr.Column(scale=1):
+                ann_class = gr.Dropdown(choices=read_classes(), value=(read_classes()[0] if read_classes() else None), label="Class")
+                save_class_btn.click(save_classes, class_text, [class_msg, ann_class, status], preprocess=False)
+                with gr.Row():
+                    x = gr.Number(label="X", value=0)
+                    y = gr.Number(label="Y", value=0)
+                with gr.Row():
+                    w = gr.Number(label="Width", value=100)
+                    h = gr.Number(label="Height", value=100)
+                add_btn = gr.Button("➕ Add Box", variant="primary")
+                delete_index = gr.Number(label="Annotation # to delete", value=1, precision=0)
+                delete_btn = gr.Button("Delete Box")
+                clear_btn = gr.Button("Clear All Boxes")
+        annotations = gr.JSON(label="Saved annotations")
+        ann_msg = gr.Markdown()
+
+        def refresh_editor(image_id):
+            img, info, anns, _, _ = load_editor(image_id)
+            return draw_annotations(image_id), info, anns
+
+        image_select.change(refresh_editor, image_select, [editor_image, editor_info, annotations])
+        add_btn.click(add_annotation, [image_select, ann_class, x, y, w, h], [editor_image, ann_msg, annotations, annotations])
+        delete_btn.click(remove_annotation, [image_select, delete_index], [editor_image, ann_msg, annotations])
+        clear_btn.click(clear_annotations, image_select, [editor_image, ann_msg, annotations])
+
+    with gr.Tab("3 · Training"):
+        gr.Markdown("### Train RT-DETR")
+        gr.Markdown("Training runs in the Space process. A GPU Space is strongly recommended for practical training speed.")
+        with gr.Row():
+            epochs = gr.Number(value=int(os.getenv("EPOCHS", "30")), label="Epochs", precision=0)
+            batch = gr.Number(value=int(os.getenv("BATCH_SIZE", "2")), label="Batch size", precision=0)
+            lr = gr.Number(value=float(os.getenv("LEARNING_RATE", "1e-5")), label="Learning rate")
+        train_btn = gr.Button("🚀 Start Training", variant="primary")
+        refresh_train = gr.Button("Refresh Training Status")
+        train_out = gr.Code(value=training_status, language="json", label="Training status")
+        train_btn.click(start_training, [epochs, batch, lr], train_out)
+        refresh_train.click(training_status, None, train_out)
+
+    with gr.Tab("4 · Count"):
+        gr.Markdown("### Count ice creams")
+        count_in = gr.Image(type="pil", sources=["upload", "clipboard"], label="Image to count")
+        count_btn = gr.Button("🍦 Count", variant="primary")
+        count_out = gr.Image(label="Detections")
+        count_json = gr.Code(language="json", label="Detection details")
+        count_table = gr.JSON(label="Counts by class")
+        count_btn.click(count_image, count_in, [count_out, count_json, count_table])
+
+    # Correct the upload event now that image_select exists.
+    upload_btn.click(
+        upload_training_images,
+        files,
+        [status, image_select, upload_msg],
+        preprocess=False,
+        queue=False,
+    )
+    # The earlier placeholder event is harmlessly superseded by this real event.
+
+    demo.load(lambda: (dataset_status(), gr.update(choices=image_choices()), gr.update(choices=read_classes())),
+              None, [status, image_select, ann_class])
+
+if __name__ == "__main__":
+    demo.queue().launch(server_name="0.0.0.0", server_port=int(os.getenv("PORT", "7860")))

requirements.txt

@@ -1,11 +1,9 @@
+gradio>=6.5,<7
 torch>=2.3
 torchvision>=0.18
 transformers>=4.50
 huggingface_hub>=0.25
 Pillow>=10.0
-fastapi>=0.115
-uvicorn[standard]>=0.30
-python-multipart>=0.0.9
 numpy>=1.26
 tqdm>=4.66
 pycocotools>=2.0.8