düzenleme

api.py

@@ -1,76 +1,73 @@
-from fastapi import FastAPI, File, UploadFile, HTTPException
-import numpy as np
-from io import BytesIO
-from PIL import Image, UnidentifiedImageError
+import cv2
 import tensorflow as tf
-from fastapi.middleware.cors import CORSMiddleware
+import numpy as np
+from fastapi import FastAPI, UploadFile, File
+from pydantic import BaseModel
+from huggingface_hub import from_pretrained_keras
 
 app = FastAPI()
 
-# CORS yapılandırması
-origins = ["*"]
-
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=origins,
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
+def load_ben_color(image, sigmaX=10):
+    image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+    image = cv2.resize(image, (224, 224))
+    image = cv2.addWeighted(image, 4, cv2.GaussianBlur(image, (0, 0), sigmaX), -4, 128)
+    return image
 
-MODEL = tf.keras.models.load_model("CLAHE_ODIR-ORJ-512_inception_v3.h5")
+def clahe(image):
+    clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8))
+    r, g, b = cv2.split(image)
+    r = clahe.apply(r)
+    g = clahe.apply(g)
+    b = clahe.apply(b)
+    result = cv2.merge((r, g, b))
+    return result
 
-# Sınıf isimleri
-class_names = [
-    'Age related Macular Degeneration', 'Cataract', 'Diabetes', 'Glaucoma',
-    'Hypertension', 'Normal', 'Others', 'Pathological Myopia'
-]
+def filter1(image):
+    image = load_ben_color(image)
+    return image
 
-@app.get("/ping")
-async def ping():
-    return {"message": "Hello, I am alive"}
+def filter2(image):
+    image = clahe(image)
+    image = cv2.resize(image, (224, 224))
+    return image
 
-def read_file_as_image(data) -> np.ndarray:
-    try:
-        image = Image.open(BytesIO(data))
-        return np.array(image)
-    except UnidentifiedImageError:
-        raise HTTPException(status_code=400, detail="Invalid image format")
-    except Exception as e:
-        raise HTTPException(status_code=400, detail=f"Image processing error: {str(e)}")
+def predict(image, model, filter_func):
+    model_image = filter_func(image)
+    model_image = np.array([model_image], dtype=np.float32) / 255.0
+    predictions = model(tf.constant(model_image))
+    return predictions.numpy()
 
+def result(predictions):
+    class_labels = ["Age related Macular Degeneration", "Cataract", "Diabetes", "Glaucoma", "Hypertension", "Normal", "Others", "Pathological Myopia"]
+    predictions = np.array(predictions)
+    predictions = predictions.tolist()[0]
+    predictions_index = np.argmax(predictions)
+    return class_labels[predictions_index]
 
-@app.post("/predict")
-async def predict(file: UploadFile = File(...)):
-    image_data = await file.read()
+# Model tanımlamaları
+models_names = ["ODIR-B-2K-5Class-LastTrain-Xception", "ODIR-B-2K-6Class-LastTrain-Xception"]
+model_paths = ["ODIR-B-2K-5Class-LastTrain-Xception", "ODIR-B-2K-6Class-LastTrain-Xception"]
 
-    # Dosya tipini kontrol et
-    if file.content_type not in ["image/jpeg", "image/png", "image/jpg"]:
-        raise HTTPException(status_code=400, detail="Invalid file type")
+filters = [filter1, filter2]  # İhtiyacınıza göre filtre fonksiyonları burada tanımlandı
 
-    # Dosya boyutunu kontrol et (örneğin, 5MB'den büyük dosyaları reddet)
-    max_file_size = 5 * 1024 * 1024  # 5MB
-    if len(image_data) > max_file_size:
-        raise HTTPException(status_code=400, detail="File size exceeds limit")
+models = []
+for model_path in model_paths:
+    model = tf.saved_model.load(model_path)
+    models.append(model)
 
-    try:
-        image = read_file_as_image(image_data)
-    except HTTPException as e:
-        return e
+class PredictionResponse(BaseModel):
+    predictions: dict
 
-    # Görüntüyü modelin beklediği boyuta getirme
-    image = tf.image.resize(image, (299, 299))  # InceptionV3 için 299x299 olmalı
-    # Görüntüyü normalize etme
-    image = tf.cast(image, tf.float32) / 255.0
-    # Batch haline getirme
-    img_batch = np.expand_dims(image, 0)
+@app.post("/predict", response_model=PredictionResponse)
+async def predict_endpoint(file: UploadFile = File(...)):
+    contents = await file.read()
+    nparr = np.frombuffer(contents, np.uint8)
+    image = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
 
-    # Model üzerinde tahmin yapma
-    predictions = MODEL.predict(img_batch)
-    predicted_class = class_names[np.argmax(predictions[0])]
-    confidence = np.max(predictions[0])
+    result_json = {}
+    for i in range(len(models)):
+        model = models[i]
+        prediction = predict(image, model, filters[i])
+        result_json[models_names[i]] = result(prediction)
 
-    return {
-        'class': predicted_class,
-        'confidence': float(confidence)
-    }
+    return {"predictions": result_json}