Update app.py

app.py

@@ -1,169 +1,152 @@
-# app.py
-import os
+import gradio as gr
+import tensorflow as tf
 import numpy as np
 from PIL import Image
-import gradio as gr
-
-# If you prefer to download the model from a HF model repo, set these:
-USE_HF_MODEL_REPO = False
-HF_MODEL_REPO = "berkeruveyik/food270-model"  # not used if USE_HF_MODEL_REPO=False
-HF_MODEL_FILENAME = "finetuned_food_270.keras"  # name on HF model repo (if used)
-
-# Local model filename (should be in the Space repo root)
-LOCAL_MODEL_PATH = "finetuned_food_270.keras"
 
-TOP_K = 5
-input_size = (224, 224)  # fallback - will try to infer from model
+# Model'i yükle
+print("Model yükleniyor...")
+model = tf.keras.models.load_model('finetuned_food_270.keras')
+print("Model başarıyla yüklendi!")
 
-# lazy imports / model loader
-model = None
-class_names = None
+# Sınıf isimlerini yükle
+with open('labels.txt', 'r', encoding='utf-8') as f:
+    class_names = [line.strip() for line in f.readlines()]
+print(f"{len(class_names)} sınıf yüklendi")
 
-def download_model_from_hub():
-    from huggingface_hub import hf_hub_download
-    print("Downloading model from HF repo...")
-    path = hf_hub_download(repo_id=HF_MODEL_REPO, filename=HF_MODEL_FILENAME, repo_type="model")
-    print("Downloaded to:", path)
-    return path
+# Görüntü boyutu (EfficientNet için)
+IMG_SIZE = (224, 224)  # EfficientNetB0 için, B2 kullanıyorsanız (260, 260) yapın
 
-def load_labels_from_file(path="labels.txt"):
-    if os.path.exists(path):
-        with open(path, "r", encoding="utf-8") as f:
-            labels = [l.strip() for l in f if l.strip()]
-        return labels
-    return None
-
-def load_model():
-    global model, class_names, input_size
-    if model is not None:
-        return model
-
-    # determine model path
-    model_path = None
-    if USE_HF_MODEL_REPO:
-        model_path = download_model_from_hub()
+def preprocess_image(image):
+    """Resmi model için hazırla"""
+    # PIL Image'a çevir ve RGB yap
+    if isinstance(image, np.ndarray):
+        img = Image.fromarray(image)
     else:
-        if os.path.exists(LOCAL_MODEL_PATH):
-            model_path = LOCAL_MODEL_PATH
-        else:
-            raise FileNotFoundError(
-                f"Model file not found at {LOCAL_MODEL_PATH}. Upload '{LOCAL_MODEL_PATH}' to the Space root or enable USE_HF_MODEL_REPO and set HF_MODEL_REPO."
-            )
+        img = image
+    
+    # RGB'ye çevir (grayscale olabilir)
+    img = img.convert('RGB')
+    
+    # Resize
+    img = img.resize(IMG_SIZE)
+    
+    # Numpy array'e çevir
+    img_array = np.array(img, dtype=np.float32)
+    
+    # Batch dimension ekle
+    img_array = np.expand_dims(img_array, axis=0)
+    
+    # EfficientNet preprocessing (imagenet normalization)
+    img_array = tf.keras.applications.efficientnet.preprocess_input(img_array)
+    
+    return img_array
 
-    # import tensorflow lazily (reduce startup errors)
-    import tensorflow as tf
-    # If the model is a weights-only file, user might have saved model.save_weights(...)
-    # We'll try to load it as a full model first, then as weights into a simple architecture if necessary.
+def predict(image):
+    """Yemek tahmin fonksiyonu"""
     try:
-        loaded = tf.keras.models.load_model(model_path, compile=False)
-        model = loaded
+        # Görüntüyü işle
+        processed_image = preprocess_image(image)
+        
+        # Tahmin yap
+        predictions = model.predict(processed_image, verbose=0)
+        
+        # Softmax çıktısını al (ilk batch)
+        predictions = predictions[0]
+        
+        # Top 5 tahmini bul
+        top_indices = np.argsort(predictions)[-5:][::-1]
+        
+        # Sonuçları hazırla
+        results = {}
+        for idx in top_indices:
+            label = class_names[idx]
+            confidence = float(predictions[idx])
+            results[label] = confidence
+        
+        return results
+        
     except Exception as e:
-        # Try to load weights into a minimal model architecture as fallback:
-        # WARNING: This fallback requires you to have the same architecture defined here.
-        # If that is not the case, prefer uploading a full model (model.save()) instead of only weights.
-        print("load_model failed, attempting to load weights into a small default model. Error:", e)
-        # Example fallback architecture (replace with your actual architecture if needed)
-        from tensorflow.keras import layers, models
-        try:
-            n_classes = 270
-            inp = layers.Input(shape=(224,224,3))
-            x = layers.Rescaling(1./255)(inp)
-            x = layers.Conv2D(32,3,activation="relu")(x)
-            x = layers.MaxPool2D()(x)
-            x = layers.GlobalAveragePooling2D()(x)
-            x = layers.Dense(256, activation="relu")(x)
-            out = layers.Dense(n_classes, activation=None)(x)
-            fallback = models.Model(inputs=inp, outputs=out)
-            fallback.load_weights(model_path)
-            model = fallback
-            print("Loaded weights into fallback model (verify architecture).")
-        except Exception as e2:
-            raise RuntimeError("Could not load model or weights. Please upload a full Keras model (model.save) instead of only weights, or adjust the fallback architecture.") from e2
-
-    # try infer input size from model
-    try:
-        shp = model.input_shape
-        if isinstance(shp, (list, tuple)):
-            if len(shp) == 4:
-                _, h, w, c = shp
-                if h and w:
-                    input_size = (int(h), int(w))
-            elif len(shp) == 3:
-                h, w, c = shp
-                input_size = (int(h), int(w))
-    except Exception:
-        pass
-
-    # load labels if available
-    lbls = load_labels_from_file("labels.txt")
-    if lbls:
-        class_names = lbls
-    else:
-        # fallback: create class_0...class_269 if model output size unknown
-        try:
-            out_shape = model.output_shape
-            if isinstance(out_shape, list):
-                out_shape = out_shape[0]
-            n_classes = int(out_shape[-1]) if out_shape is not None else 270
-        except Exception:
-            n_classes = 270
-        class_names = [f"class_{i}" for i in range(n_classes)]
-
-    print(f"Model loaded. input_size={input_size}, num_classes={len(class_names)}")
-    return model
-
-def preprocess_image(image: Image.Image):
-    # ensure RGB
-    if image.mode != "RGB":
-        image = image.convert("RGB")
-    # resize
-    image = image.resize(input_size, resample=Image.BILINEAR)
-    arr = np.asarray(image).astype(np.float32) / 255.0
-    if arr.ndim == 3:
-        arr = np.expand_dims(arr, axis=0)
-    return arr
-
-def predict(image):
-    model = load_model()
-    x = preprocess_image(image)
-    preds = model.predict(x)
-    if preds.ndim == 2:
-        probs = preds[0]
-    else:
-        probs = np.asarray(preds).reshape(-1)
-    # try softmax if not probability
-    s = float(np.sum(probs))
-    if not (0.9 < s < 1.1):
-        from scipy.special import softmax
-        probs = softmax(probs)
-    top_idx = probs.argsort()[-TOP_K:][::-1]
-    results = []
-    for i in top_idx:
-        name = class_names[i] if i < len(class_names) else str(i)
-        results.append((name, float(probs[i])))
-    md = "\n".join([f"{name}: {prob*100:.2f}%" for name, prob in results])
-    # return markdown + dict for chart
-    return md, {r[0]: r[1] for r in results}
-
-# Gradio UI
-title = "Food-270 Classifier"
-description = "Upload a food image and get top predictions (model: finetuned_cp.weights.h5)."
-
-with gr.Blocks() as demo:
-    gr.Markdown(f"# {title}\n\n{description}")
+        print(f"Hata: {e}")
+        return {"Hata": str(e)}
+
+# Gradio arayüzü
+with gr.Blocks(title="Food 270 Classifier") as demo:
+    # Başlık ve açıklama
+    gr.Markdown("""
+    # 🍽️ Food 270 Yemek Sınıflandırıcı
+    
+    **270 farklı yemek türünü tanıyabilen yapay zeka modeli**
+    
+    📸 Bir yemek fotoğrafı yükleyin ve hangi yemek olduğunu tahmin ettirin!
+    """)
+    
+    # Ana satır
     with gr.Row():
-        img_in = gr.Image(type="pil", label="Upload an image")
-        out_md = gr.Markdown()
-    with gr.Row():
-        btn = gr.Button("Predict")
+        # Sol kolon - Input
+        with gr.Column(scale=1):
+            input_image = gr.Image(
+                label="Yemek Fotoğrafı", 
+                type="numpy"
+            )
+            
+            # Butonlar
+            with gr.Row():
+                clear_btn = gr.Button("🗑️ Temizle", variant="secondary")
+                submit_btn = gr.Button("🔍 Tahmin Et", variant="primary")
+        
+        # Sağ kolon - Output
+        with gr.Column(scale=1):
+            output = gr.Label(
+                label="Tahmin Sonuçları",
+                num_top_classes=5,
+                show_label=True
+            )
+            
+            # Ek bilgi
+            gr.Markdown("""
+            ### 📊 Sonuç Açıklaması
+            - **En yüksek skor** en olası yemek türüdür
+            - Skorlar **0-1 arası** güven seviyesini gösterir
+            - **Top 5** en olası tahmin gösterilir
+            """)
+    
+    # Alt kısım - Örnekler ve bilgi
     with gr.Row():
-        chart = gr.Label(num_top_classes=TOP_K, label="Top predictions")
-    btn.click(fn=lambda img: predict(img), inputs=img_in, outputs=[out_md, chart])
-
+        gr.Markdown("""
+        ### 💡 İpuçları
+        - Net ve iyi ışıklandırılmış fotoğraflar daha iyi sonuç verir
+        - Yemeğin tam görünmesi tahmini iyileştirir
+        - Tek bir yemek türü içeren fotoğraflar idealdir
+        """)
+    
+    # Model bilgisi
+    gr.Markdown("""
+    ---
+    ### 🤖 Model Bilgileri
+    - **Model**: EfficientNet (Fine-tuned)
+    - **Dataset**: Food 270
+    - **Sınıf Sayısı**: 270 farklı yemek
+    - **Doğruluk**: Train sonrası elde edilen accuracy değerinizi buraya yazın
+    
+    *Geliştirici: Berker Üveyik*
+    """)
+    
+    # Event handlers
+    submit_btn.click(
+        fn=predict,
+        inputs=input_image,
+        outputs=output
+    )
+    
+    clear_btn.click(
+        lambda: (None, None),
+        inputs=None,
+        outputs=[input_image, output]
+    )
+
+# Uygulamayı başlat
 if __name__ == "__main__":
-    # optional warm-up model load
-    try:
-        load_model()
-    except Exception as e:
-        print("Model loading at start failed:", e)
-    demo.launch(server_name="0.0.0.0", share=False)
+    demo.launch(
+        share=False,  # Space'de False olmalı
+        debug=False   # Production'da False olmalı
+    )