test

README.md

@@ -1,3 +1,41 @@
----
-license: mit
----
+---
+pipeline_tag: image-classification
+license: mit
+library_name: pytorch
+tags: [pytorch, minimal, demo]
+model-index:
+  - name: tiny-digits-cnn
+    results:
+      - task: {type: image-classification}
+        metrics:
+          - type: accuracy
+            value: 0.00   # demo-only (untrained)
+---
+
+# Tiny Digits CNN (demo-only)
+
+Toy 28×28 grayscale classifier (10 classes 0–9) for **Hugging Face deployment tests**.
+No training—weights are randomly initialized just to validate repo layout, Spaces, and Inference Endpoints.
+
+## Files
+- `model.py` — tiny CNN
+- `model.safetensors` — weights (create with `python generate_weights.py`)
+- `inference.py` — load → preprocess → predict
+- `handler.py` — Endpoint handler (`EndpointHandler`)
+- `app.py` — Gradio Space UI
+- `requirements.txt`, `.gitattributes`, `LICENSE`
+
+## Quickstart (local)
+```bash
+pip install -r requirements.txt
+python generate_weights.py
+python app.py
+
+Call via Hosted Inference API (if enabled) or Endpoint
+# Replace with your endpoint URL or model API URL
+API=https://api-inference.huggingface.co/models/ORG/REPO
+curl -X POST "$API" \
+  -H "Authorization: Bearer $HF_TOKEN" \
+  -H "Content-Type: application/json" \
+  -d '{"inputs": {"image_base64": "<PUT_BASE64_IMAGE_HERE>"}}'
+

app.py

@@ -0,0 +1,16 @@
+import gradio as gr
+from inference import predict_from_pil
+
+def infer(img):
+    return predict_from_pil(img)
+
+demo = gr.Interface(
+    fn=infer,
+    inputs=gr.Image(type="pil", label="28x28 grayscale image (any image will be resized)"),
+    outputs=gr.Label(num_top_classes=3, label="Top-3 predictions"),
+    title="Tiny Digits (Toy Classifier)",
+    description="Ultra-small CNN demo for deployment tests. Not trained; for pipeline sanity only."
+)
+
+if __name__ == "__main__":
+    demo.launch()

handler.py

@@ -0,0 +1,20 @@
+# Hugging Face Inference Endpoint handler
+# Expects {"inputs": {"image_base64": "<...>"}} or {"inputs": "<base64>"}
+from inference import load_model, predict_from_base64
+
+class EndpointHandler:
+    def __init__(self, path=""):
+        # path points to the repo dir inside the container
+        self.model = load_model(path)
+
+    def __call__(self, data):
+        inputs = data.get("inputs", {})
+        if isinstance(inputs, str):
+            b64 = inputs
+        else:
+            b64 = inputs.get("image_base64")
+        if not b64:
+            return {"error": "Provide base64 image under 'inputs' or 'inputs.image_base64'."}
+        preds = predict_from_base64(b64)
+        # Return {label: prob}
+        return {"predictions": preds}

inference.py

@@ -0,0 +1,37 @@
+import io, base64
+import numpy as np
+from PIL import Image
+import torch
+from safetensors.torch import load_file
+from model import TinyConv
+
+LABELS = [str(i) for i in range(10)]
+
+def load_model(path: str = ""):
+    m = TinyConv().eval()
+    try:
+        state = load_file(f"{path}model.safetensors")
+        m.load_state_dict(state, strict=True)
+    except Exception:
+        # Fallback to randomly initialized weights if file missing
+        pass
+    return m
+
+MODEL = load_model()
+
+def preprocess_pil(img: Image.Image) -> torch.Tensor:
+    img = img.convert("L").resize((28, 28))
+    x = torch.from_numpy(np.array(img)).float() / 255.0
+    x = x.unsqueeze(0).unsqueeze(0)  # [1,1,28,28]
+    return x
+
+def predict_from_pil(img: Image.Image):
+    x = preprocess_pil(img)
+    with torch.inference_mode():
+        logits = MODEL(x)
+        probs = torch.softmax(logits, dim=-1)[0].tolist()
+    return {label: float(probs[i]) for i, label in enumerate(LABELS)}
+
+def predict_from_base64(b64: str):
+    img = Image.open(io.BytesIO(base64.b64decode(b64)))
+    return predict_from_pil(img)

model.py

@@ -0,0 +1,17 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+class TinyConv(nn.Module):
+    def __init__(self, num_classes: int = 10):
+        super().__init__()
+        self.conv1 = nn.Conv2d(1, 8, 3, padding=1)   # 1x28x28 -> 8x28x28
+        self.conv2 = nn.Conv2d(8, 16, 3, padding=1)  # 8x28x28 -> 16x28x28
+        self.pool = nn.AdaptiveAvgPool2d((1, 1))     # 16x1x1
+        self.fc = nn.Linear(16, num_classes)
+
+    def forward(self, x):
+        x = F.relu(self.conv1(x))
+        x = F.relu(self.conv2(x))
+        x = self.pool(x).flatten(1)
+        return self.fc(x)

model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2041ab75c8398326a846e1a5f78a00a1a188e17fe512440ba7985315bff09f6c
+size 6104

requirements.txt

@@ -0,0 +1,5 @@
+torch
+numpy
+pillow
+safetensors
+gradio   # only needed if you’ll create a Space demo