Update app.py

app.py

@@ -1,84 +1,99 @@
-from fastapi import FastAPI, UploadFile, HTTPException
+from fastapi import FastAPI, UploadFile, File, HTTPException
 from fastapi.responses import JSONResponse
-import uvicorn
 import torch
 import torch.nn as nn
-from torchvision.models import vgg19
 from torchvision import transforms
+from torchvision.models import vgg19
 from PIL import Image
 import io
+from huggingface_hub import hf_hub_download
 
-# FastAPI uygulaması
+# FastAPI uygulamasını başlat
 app = FastAPI()
 
-# Modeli yükle ve ayarla
+# Cihaz ayarı
 device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
 
+# Hugging Face modelini yükleme bilgileri
+REPO_ID = "kedimestan/retinoblastomaDetectionVGG19"
+MODEL_FILE = "pytorch_model.bin"
+
+# Modeli indir ve yükle
 def load_model():
-    model = vgg19(pretrained=False)  # Pretrained ağırlıklar olmadan model
+    model_path = hf_hub_download(repo_id=REPO_ID, filename=MODEL_FILE)
+    
+    # Model yapısını yeniden tanımla (VGG19 + özel sınıflandırıcı)
+    model = vgg19(pretrained=False)
     model.classifier = nn.Sequential(
-        nn.Linear(25088, 12544),  # 25088 -> 12544
+        nn.Linear(25088, 12544),
         nn.ReLU(),
         nn.Dropout(0.5),
-        nn.Linear(12544, 6272),   # 12544 -> 6272
+        nn.Linear(12544, 6272),
         nn.ReLU(),
         nn.Dropout(0.5),
-        nn.Linear(6272, 3136),    # 6272 -> 3136
+        nn.Linear(6272, 3136),
         nn.ReLU(),
         nn.Dropout(0.4),
-        nn.Linear(3136, 1568),    # 3136 -> 1568
+        nn.Linear(3136, 1568),
         nn.ReLU(),
         nn.Dropout(0.4),
-        nn.Linear(1568, 784),     # 1568 -> 784
+        nn.Linear(1568, 784),
         nn.ReLU(),
         nn.Dropout(0.3),
-        nn.Linear(784, 392),      # 784 -> 392
+        nn.Linear(784, 392),
         nn.ReLU(),
         nn.Dropout(0.3),
-        nn.Linear(392, 196),      # 392 -> 196
+        nn.Linear(392, 196),
         nn.ReLU(),
         nn.Dropout(0.2),
-        nn.Linear(196, 98),       # 196 -> 98
+        nn.Linear(196, 98),
         nn.ReLU(),
         nn.Dropout(0.2),
-        nn.Linear(98, 49),        # 98 -> 49
+        nn.Linear(98, 49),
         nn.ReLU(),
         nn.Dropout(0.1),
-        nn.Linear(49, 1),         # 49 -> 1 (Binary classification)
+        nn.Linear(49, 1),
         nn.Sigmoid()
     )
+    
+    # Model ağırlıklarını yükle
+    model.load_state_dict(torch.load(model_path, map_location=device))
     model = model.to(device)
-    model.load_state_dict(torch.load("best_model.pth", map_location=device))
     model.eval()
     return model
 
 model = load_model()
 
-# Görsel işleme transformasyonu
+# Görüntü dönüşüm pipeline'ı
 transform = transforms.Compose([
     transforms.Resize((224, 224)),
     transforms.ToTensor(),
-    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
+    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
 ])
 
-def process_image(file: UploadFile):
-    try:
-        image = Image.open(io.BytesIO(file.file.read())).convert("RGB")
-        return transform(image).unsqueeze(0).to(device)
-    except Exception as e:
-        raise HTTPException(status_code=400, detail=f"Invalid image file: {str(e)}")
+# Tahmin fonksiyonu
+def predict(image: Image.Image):
+    input_tensor = transform(image).unsqueeze(0).to(device)
+    with torch.no_grad():
+        output = model(input_tensor).squeeze(0).cpu().numpy()
+        prediction = "Positive" if output[0] > 0.5 else "Negative"
+        return {"Prediction": prediction, "Probability": round(float(output[0]), 2)}
 
-# Ana endpoint
+# Ana API rotası
 @app.post("/predict")
-async def predict(file: UploadFile):
-    if not file.content_type.startswith("image/"):
-        raise HTTPException(status_code=400, detail="File must be an image.")
-    image_tensor = process_image(file)
-    with torch.no_grad():
-        output = model(image_tensor)
-        prediction = float(output.item())
-    return JSONResponse({"prediction": prediction})
+async def predict_image(file: UploadFile = File(...)):
+    try:
+        # Görüntüyü oku
+        image_data = await file.read()
+        image = Image.open(io.BytesIO(image_data)).convert("RGB")
+        
+        # Tahmin yap
+        result = predict(image)
+        return JSONResponse(content=result)
+    except Exception as e:
+        return JSONResponse(content={"error": str(e)}, status_code=400)
 
-# Uygulama başlatıcı
-if __name__ == "__main__":
-    uvicorn.run(app, host="0.0.0.0", port=8000)
+# Ana sayfa
+@app.get("/")
+def home():
+    return {"message": "Upload an image to /predict for classification."}