Create app.py

app.py

@@ -0,0 +1,161 @@
+# app.py (for a Hugging Face Space using Gradio)
+import gradio as gr
+import torch
+import pytorch_lightning as pl
+from timm import create_model
+import torch.nn as nn
+from box import Box
+import albumentations as A
+from albumentations.pytorch.transforms import ToTensorV2
+import cv2
+import pickle
+from PIL import Image
+import numpy as np
+import os
+import requests # For fetching funny cat GIFs
+from huggingface_hub import hf_hub_download
+
+# --- Re-use your model definition and loading functions ---
+# (This part would be similar to your inference.py)
+
+HF_USERNAME = "Hajorda"  # Or the username of the model owner
+HF_MODEL_NAME = "keduClasifier"
+REPO_ID = f"{HF_USERNAME}/{HF_MODEL_NAME}"
+
+cfg_dict_for_inference = {
+    'model_name': 'swin_tiny_patch4_window7_224', # Match training
+    'dropout_backbone': 0.1, # Match training
+    'dropout_fc': 0.2,       # Match training
+    'img_size': (224, 224),
+    'num_classes': 37, # IMPORTANT: This must be correct for your trained model
+}
+cfg_inference = Box(cfg_dict_for_inference)
+
+class PetBreedModel(pl.LightningModule): # Paste your PetBreedModel class here
+    def __init__(self, cfg: Box):
+        super().__init__()
+        self.cfg = cfg
+        self.backbone = create_model(
+            self.cfg.model_name, pretrained=False, num_classes=0,
+            in_chans=3, drop_rate=self.cfg.dropout_backbone
+        )
+        h, w = self.cfg.img_size
+        dummy_input = torch.randn(1, 3, h, w)
+        with torch.no_grad(): num_features = self.backbone(dummy_input).shape[-1]
+        self.fc = nn.Sequential(
+            nn.Linear(num_features, num_features // 2), nn.ReLU(),
+            nn.Dropout(self.cfg.dropout_fc),
+            nn.Linear(num_features // 2, self.cfg.num_classes)
+        )
+    def forward(self, x):
+        features = self.backbone(x); output = self.fc(features)
+        return output
+
+def load_model_from_hf_for_space(repo_id=REPO_ID, ckpt_filename="pytorch_model.ckpt"):
+    model_path = hf_hub_download(repo_id=repo_id, filename=ckpt_filename)
+    # Important: Ensure cfg_inference is correctly defined with num_classes
+    if cfg_inference.num_classes is None:
+         raise ValueError("num_classes must be set in cfg_inference to load the model for Gradio.")
+    loaded_model = PetBreedModel.load_from_checkpoint(model_path, cfg=cfg_inference, strict=False)
+    loaded_model.eval()
+    return loaded_model
+
+def load_label_encoder_from_hf_for_space(repo_id=REPO_ID, le_filename="label_encoder.pkl"):
+    le_path = hf_hub_download(repo_id=repo_id, filename=le_filename)
+    with open(le_path, 'rb') as f: label_encoder = pickle.load(f)
+    return label_encoder
+
+# Load model and encoder once when the app starts
+model = load_model_from_hf_for_space()
+label_encoder = load_label_encoder_from_hf_for_space()
+device = "cuda" if torch.cuda.is_available() else "cpu"
+model.to(device)
+
+# --- Funny elements ---
+funny_cat_keywords = ["funny cat", "silly cat", "cat meme", "derp cat"]
+GIPHY_API_KEY = "YOUR_GIPHY_API_KEY" # Optional: For more variety, get a Giphy API key
+
+def get_funny_cat_gif(breed_name):
+    try:
+        # Use a public API if you don't have a Giphy key, or a simpler source
+        # For example, a predefined list of GIFs
+        predefined_gifs = {
+            "abyssinian": "https://media.giphy.com/media/v1.Y2lkPTc5MGI3NjExaWN4bDNzNWVzM2VqNHE4Ym5zN2ZzZHF0Zzh0bGRqZzRjMnhsZW5pZCZlcD12MV9pbnRlcm5hbF9naWZfYnlfaWQmY3Q9Zw/3oriO0OEd9QIDdllqo/giphy.gif",
+            "siamese": "https://media.giphy.com/media/v1.Y2lkPTc5MGI3NjExa3g0dHZtZmRncWN0cnZkNnVnMGRtYjN2ajZ2d3o1cHZtaW50ZHQ5ayZlcD12MV9pbnRlcm5hbF9naWZfYnlfaWQmY3Q9Zw/ICOgUNjpvO0PC/giphy.gif",
+            "default": "https://media.giphy.com/media/v1.Y2lkPTc5MGI3NjExNWMwNnU4NW9nZTV5c3Z0eThsOHhsOWN0Nnh0a3VzbjFxeGU0bjFuNiZlcD12MV9pbnRlcm5hbF9naWZfYnlfaWQmY3Q9Zw/BzyTuYCmvSORqs1ABM/giphy.gif"
+        }
+        return predefined_gifs.get(breed_name.lower().replace(" ", "_"), predefined_gifs["default"])
+
+        # If using Giphy API:
+        # search_term = f"{breed_name} {random.choice(funny_cat_keywords)}"
+        # params = {'api_key': GIPHY_API_KEY, 'q': search_term, 'limit': 1, 'rating': 'g'}
+        # response = requests.get("http://api.giphy.com/v1/gifs/search", params=params)
+        # response.raise_for_status()
+        # return response.json()['data'][0]['images']['original']['url']
+    except Exception as e:
+        print(f"Error fetching GIF: {e}")
+        return predefined_gifs["default"] # Fallback
+
+# --- Gradio Interface Function ---
+def classify_cat_breed(image_input):
+    # Gradio provides image as a NumPy array
+    img_rgb = cv2.cvtColor(image_input, cv2.COLOR_BGR2RGB) # Ensure it's RGB if needed
+
+    h, w = cfg_inference.img_size
+    transforms_gradio = A.Compose([
+        A.Resize(height=h, width=w),
+        A.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
+        ToTensorV2(),
+    ])
+    input_tensor = transforms_gradio(image=img_rgb)['image'].unsqueeze(0).to(device)
+
+    with torch.no_grad():
+        logits = model(input_tensor)
+        probabilities = torch.softmax(logits, dim=1)
+        # Get top N predictions if you want
+        # top_probs, top_indices = torch.topk(probabilities, 3, dim=1)
+
+        # For single prediction:
+        confidence, predicted_idx = torch.max(probabilities, dim=1)
+
+    predicted_breed_id = predicted_idx.item()
+    predicted_breed_name = label_encoder.inverse_transform([predicted_breed_id])[0]
+    conf_score = confidence.item()
+
+    # Funny message and GIF
+    funny_message = f"I'm {conf_score*100:.1f}% sure this adorable furball is a {predicted_breed_name}! What a purrfect specimen!"
+    if conf_score < 0.7:
+        funny_message += " ...Or maybe it's a new, super-rare breed only I can see. 😉"
+    
+    gif_url = get_funny_cat_gif(predicted_breed_name)
+
+    # Gradio expects a dictionary for multiple outputs if you name them
+    # Or a tuple if you don't name them in gr.Interface outputs
+    return (
+        f"{predicted_breed_name} (Confidence: {conf_score*100:.2f}%)",
+        funny_message,
+        gif_url # Gradio can display images/GIFs from URLs
+    )
+
+# --- Define the Gradio Interface ---
+title = "😸 Purrfect Breed Guesser 3000 😼"
+description = "Upload a picture of a cat, and I'll (hilariously) try to guess its breed! Powered by AI and a bit of cat-titude."
+article = "<p style='text-align: center'>Model based on Swin Transformer, fine-tuned on the Oxford-IIIT Pet Dataset. <a href='https://huggingface.co/YOUR_HF_USERNAME/my-pet-breed-classifier-swin-tiny' target='_blank'>Model Card</a></p>"
+
+iface = gr.Interface(
+    fn=classify_cat_breed,
+    inputs=gr.Image(type="numpy", label="Upload Cat Pic! 📸"),
+    outputs=[
+        gr.Textbox(label="🧐 My Guess Is..."),
+        gr.Textbox(label="💬 My Deep Thoughts..."),
+        gr.Image(type="filepath", label="🎉 Celebration GIF! 🎉") # 'filepath' for URLs
+    ],
+    title=title,
+    description=description,
+    article=article,
+    examples=[["example_cat1.jpg"], ["example_cat2.jpg"]], # Add paths to example images in your Space repo
+    theme=gr.themes.Soft() # Or try other themes!
+)
+
+if __name__ == "__main__":
+    iface.launch()