Upload 3 files

README.md

@@ -1,12 +1,40 @@
----
-title: Deepfakedetect
-emoji: 🔥
-colorFrom: green
-colorTo: blue
-sdk: gradio
-sdk_version: 5.49.1
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+
+# Image Classifier — Keras/TensorFlow (Hugging Face Space)
+
+A dead-simple image classification app you can deploy in minutes.
+
+## How it works
+
+- If `model.h5` exists in the repository root, the app loads **your custom Keras model**.
+  - Optionally add `labels.txt` (one class name per line) to show readable labels.
+  - Input is resized to **224×224**. Adjust `TARGET_SIZE` in `app.py` if your model expects a different size.
+- If no `model.h5` is found, it falls back to **MobileNetV2 (ImageNet)**.
+
+## Run locally
+
+```bash
+pip install -r requirements.txt
+python app.py
+```
+
+Then open the local URL printed by Gradio.
+
+## Deploy to Hugging Face Spaces
+
+1. Create a new **Space** → **Gradio** (Python).
+2. Upload these files: `app.py`, `requirements.txt`, `README.md`.
+3. (Optional) Upload your `model.h5` and `labels.txt` to use your own model.
+4. The Space will build and auto-start.
+
+## Using your notebook's model
+
+If your notebook trained a model, export it:
+
+```python
+model.save("model.h5")
+# Optional labels file (one per line)
+with open("labels.txt", "w") as f:
+    f.write("\n".join(class_names))
+```
+
+Commit both files to the Space.

app.py

@@ -0,0 +1,102 @@
+
+import os
+import typing as t
+
+import gradio as gr
+import numpy as np
+import tensorflow as tf
+from PIL import Image
+
+# Try to load a user-provided Keras model if available; else fallback to a pretrained MobileNetV2.
+CUSTOM_MODEL_PATH = "model.h5"
+LABELS_PATH = "labels.txt"
+
+# Global objects
+MODEL = None
+USE_IMAGENET_DECODE = False
+CLASS_NAMES: t.Optional[t.List[str]] = None
+TARGET_SIZE = (224, 224)
+
+def _maybe_load_labels(path: str) -> t.Optional[t.List[str]]:
+    if os.path.exists(path):
+        with open(path, "r", encoding="utf-8") as f:
+            lines = [x.strip() for x in f.readlines() if x.strip()]
+            return lines
+    return None
+
+def _load_model():
+    global MODEL, USE_IMAGENET_DECODE, CLASS_NAMES
+    if os.path.exists(CUSTOM_MODEL_PATH):
+        try:
+            MODEL = tf.keras.models.load_model(CUSTOM_MODEL_PATH, compile=False)
+            CLASS_NAMES = _maybe_load_labels(LABELS_PATH)
+            USE_IMAGENET_DECODE = False
+            print("Loaded custom model from model.h5")
+            return
+        except Exception as e:
+            print("Failed to load custom model:", e)
+
+    # Fallback: MobileNetV2 pretrained on ImageNet
+    MODEL = tf.keras.applications.MobileNetV2(weights="imagenet")
+    USE_IMAGENET_DECODE = True
+    CLASS_NAMES = None
+    print("Loaded MobileNetV2 (ImageNet) fallback.")
+
+def _preprocess(img: Image.Image) -> np.ndarray:
+    # Convert to RGB and resize
+    img = img.convert("RGB").resize(TARGET_SIZE)
+    arr = np.array(img).astype("float32")
+    # If it's the MobileNetV2 fallback, apply its preprocess; otherwise just scale 0..1
+    if USE_IMAGENET_DECODE:
+        arr = tf.keras.applications.mobilenet_v2.preprocess_input(arr)
+    else:
+        arr = arr / 255.0
+    arr = np.expand_dims(arr, axis=0)
+    return arr
+
+def _decode_predictions(preds: np.ndarray, top: int = 3):
+    # preds: (1, num_classes)
+    preds = preds[0]
+    if USE_IMAGENET_DECODE:
+        decoded = tf.keras.applications.imagenet_utils.decode_predictions(preds[np.newaxis, :], top=top)[0]
+        # decoded is list of tuples: (class_id, class_name, score)
+        return [(name, float(score)) for (_, name, score) in decoded]
+    else:
+        # For custom model: if CLASS_NAMES provided, map; else show class indices
+        top_indices = preds.argsort()[-top:][::-1]
+        out = []
+        for idx in top_indices:
+            label = CLASS_NAMES[idx] if (CLASS_NAMES is not None and idx < len(CLASS_NAMES)) else f"class_{idx}"
+            out.append((label, float(preds[idx])))
+        return out
+
+def predict(image: Image.Image):
+    if image is None:
+        return [], None
+    x = _preprocess(image)
+    preds = MODEL.predict(x)
+    top3 = _decode_predictions(preds, top=3)
+    # Also return a bar plot-friendly structure for Gradio's Label component
+    scores = {label: score for (label, score) in top3}
+    return scores, image
+
+# Initialize
+_load_model()
+
+with gr.Blocks(title="Image Classifier (Keras/TF)") as demo:
+    gr.Markdown("# Image Classifier\nUpload an image to classify using a Keras model.\n\n"
+                "- Drop in your own `model.h5` (and optional `labels.txt`) to switch from ImageNet to your custom model.\n"
+                "- For custom models, ensure input size is 224x224x3 or adjust code.\n")
+
+    with gr.Row():
+        with gr.Column(scale=1):
+            inp = gr.Image(type="pil", label="Upload image")
+            btn = gr.Button("Predict")
+        with gr.Column(scale=1):
+            out_label = gr.Label(num_top_classes=3, label="Top Predictions")
+            out_img = gr.Image(type="pil", label="Preview")
+
+    btn.click(fn=predict, inputs=inp, outputs=[out_label, out_img])
+
+if __name__ == "__main__":
+    demo.launch()

requirements.txt

@@ -0,0 +1,3 @@
+gradio>=4.44.0
+tensorflow>=2.12
+Pillow