Update api_app.py

api_app.py

@@ -9,12 +9,17 @@ import io
 import numpy as np
 import os
 from typing import List, Dict, Any
+import logging # Dodajemy import modułu logging
 
 # Importy dla Grad-CAM
 from pytorch_grad_cam import GradCAMPlusPlus
 from pytorch_grad_cam.utils.model_targets import ClassifierOutputTarget
 from huggingface_hub import hf_hub_download # Do pobierania modelu z Huba
 
+# --- Konfiguracja Logowania ---
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
 # --- Konfiguracja ---
 # Upewnij się, że te wartości są zgodne z Twoim repozytorium modelu
 HF_MODEL_REPO_ID = "Enterwar99/MODEL_MAMMOGRAFII"
@@ -42,41 +47,44 @@ def initialize_model():
     if model_instance is not None:
         return
 
-    print(f"Pobieranie modelu {MODEL_FILENAME} z repozytorium {HF_MODEL_REPO_ID}...")
+    logger.info(f"Rozpoczynanie inicjalizacji modelu...")
+    logger.info(f"Pobieranie pliku modelu '{MODEL_FILENAME}' z repozytorium '{HF_MODEL_REPO_ID}'...")
     try:
         # Odczytaj token z sekretów, jeśli jest dostępny
         # Nazwa zmiennej środowiskowej musi być taka sama jak nazwa sekretu w ustawieniach Space
         hf_auth_token = os.environ.get("HF_TOKEN_MODEL_READ")
         if hf_auth_token:
-            print("Używam tokenu HF_TOKEN_MODEL_READ do pobrania modelu.")
+            logger.info("Używam tokenu HF_TOKEN_MODEL_READ do pobrania modelu.")
         else:
-            print("OSTRZEŻENIE: Sekret HF_TOKEN_MODEL_READ nie został znaleziony. Próba pobrania modelu bez tokenu (może się nie udać dla prywatnych repozytoriów).")
+            logger.warning("Sekret HF_TOKEN_MODEL_READ nie został znaleziony. Próba pobrania modelu bez tokenu.")
 
         model_pt_path = hf_hub_download(repo_id=HF_MODEL_REPO_ID, filename=MODEL_FILENAME, token=hf_auth_token)
+        logger.info(f"Plik modelu pomyślnie pobrany do: {model_pt_path}")
     except Exception as e:
-        print(f"Błąd podczas pobierania modelu z Hugging Face Hub: {e}")
+        logger.error(f"Błąd podczas pobierania modelu z Hugging Face Hub: {e}", exc_info=True)
         raise RuntimeError(f"Nie można pobrać modelu: {e}")
 
-    print(f"Inicjalizacja architektury modelu ResNet-18...")
+    logger.info(f"Inicjalizacja architektury modelu ResNet-18...")
     model_arch = models.resnet18(weights=None)
     num_feats = model_arch.fc.in_features
     model_arch.fc = nn.Sequential(
         nn.Dropout(0.5),
         nn.Linear(num_feats, 5)
     )
-    
-    print(f"Ładowanie wag modelu z {model_pt_path}...")
+    logger.info(f"Architektura modelu ResNet-18 zainicjalizowana.")
+
+    logger.info(f"Ładowanie wag modelu z {model_pt_path}...")
     model_arch.load_state_dict(torch.load(model_pt_path, map_location=DEVICE))
     model_arch.to(DEVICE)
     model_arch.eval()
     model_instance = model_arch
-
+    logger.info(f"Wagi modelu załadowane. Model przeniesiony na urządzenie: {DEVICE} i ustawiony w tryb eval().")
     transform_pipeline = transforms.Compose([
         transforms.Resize((224, 224)),
         transforms.ToTensor(),
         transforms.Normalize(mean=IMAGENET_MEAN, std=IMAGENET_STD)
     ])
-    print(f"Model BI-RADS classifier initialized successfully on device: {DEVICE}")
+    logger.info(f"Model BI-RADS classifier initialized successfully on device: {DEVICE}")
 
 # --- Aplikacja FastAPI ---
 app = FastAPI(title="BI-RADS Mammography Classification API")
@@ -84,6 +92,7 @@ app = FastAPI(title="BI-RADS Mammography Classification API")
 @app.on_event("startup")
 async def startup_event():
     """Wywoływane przy starcie aplikacji FastAPI."""
+    logger.info("Rozpoczynanie eventu startup aplikacji FastAPI.")
     initialize_model()
 
 @app.post("/predict/", response_model=List[Dict[str, Any]])
@@ -93,22 +102,32 @@ async def predict_image(file: UploadFile = File(...)):
     Oczekuje pliku obrazu (JPG, PNG).
     Zwraca listę z wynikami (nawet jeśli tylko jeden obraz).
     """
+    request_id = os.urandom(8).hex() # Prosty identyfikator żądania
+    logger.info(f"[RequestID: {request_id}] Otrzymano żądanie /predict/")
+
     if model_instance is None or transform_pipeline is None:
+        logger.error(f"[RequestID: {request_id}] Model nie jest zainicjalizowany podczas żądania /predict/.")
         raise HTTPException(status_code=503, detail="Model nie jest zainicjalizowany. Spróbuj ponownie za chwilę.")
 
     try:
+        logger.info(f"[RequestID: {request_id}] Odczytywanie i przetwarzanie wgranego pliku...")
         contents = await file.read()
         image = Image.open(io.BytesIO(contents)).convert("RGB")
+        logger.info(f"[RequestID: {request_id}] Plik obrazu pomyślnie odczytany i przekonwertowany do RGB.")
     except Exception as e:
+        logger.error(f"[RequestID: {request_id}] Błąd podczas odczytu pliku obrazu: {e}", exc_info=True)
         raise HTTPException(status_code=400, detail=f"Nie można odczytać pliku obrazu: {e}")
 
     # Preprocessing
+    logger.info(f"[RequestID: {request_id}] Rozpoczynanie preprocessingu obrazu...")
     input_tensor = transform_pipeline(image).unsqueeze(0).to(DEVICE)
+    logger.info(f"[RequestID: {request_id}] Preprocessing zakończony. Kształt tensora wejściowego: {input_tensor.shape}")
 
     # Inference
+    logger.info(f"[RequestID: {request_id}] Rozpoczynanie inferencji modelu...")
     with torch.no_grad():
         model_outputs = model_instance(input_tensor)
-    
+    logger.info(f"[RequestID: {request_id}] Inferencja zakończona.")
     # Postprocessing
     probs = torch.nn.functional.softmax(model_outputs, dim=1)
     confidences, predicted_indices = torch.max(probs, 1)
@@ -116,6 +135,7 @@ async def predict_image(file: UploadFile = File(...)):
     results = []
     for i in range(len(predicted_indices)): # Pętla na wypadek przyszłego batch processingu
         birads_category = predicted_indices[i].item() + 1
+        logger.info(f"[RequestID: {request_id}] Przewidziana kategoria BI-RADS: {birads_category}, Pewność: {confidences[i].item():.4f}")
         confidence = confidences[i].item()
         interpretation = interpretations_dict.get(birads_category, "Nieznana klasyfikacja")
         
@@ -124,11 +144,10 @@ async def predict_image(file: UploadFile = File(...)):
 
         # Generowanie Grad-CAM
         grad_cam_map_serialized = None
+        logger.info(f"[RequestID: {request_id}] Rozpoczynanie generowania Grad-CAM dla kategorii {birads_category}...")
         try:
-            for param in model_instance.parameters():
-                param.requires_grad_(True)
-            model_instance.eval()
-
+            # model_instance is already in eval mode from initialize_model()
+            # pytorch-grad-cam typically handles necessary gradient contexts.
             target_layers = [model_instance.layer4[-1]] # Dla ResNet-18
             cam_algorithm = GradCAMPlusPlus(model=model_instance, target_layers=target_layers)
             
@@ -140,9 +159,11 @@ async def predict_image(file: UploadFile = File(...)):
             if grayscale_cam is not None:
                 grad_cam_map_np = grayscale_cam[0, :]
                 grad_cam_map_serialized = grad_cam_map_np.tolist()
-
+                logger.info(f"[RequestID: {request_id}] Grad-CAM wygenerowany pomyślnie.")
+            else:
+                logger.warning(f"[RequestID: {request_id}] Wygenerowany Grad-CAM jest None.")
         except Exception as e:
-            print(f"Błąd podczas generowania Grad-CAM w API: {e}")
+            logger.error(f"[RequestID: {request_id}] Błąd podczas generowania Grad-CAM w API: {e}", exc_info=True)
 
         results.append({
             "birads": birads_category,
@@ -152,10 +173,12 @@ async def predict_image(file: UploadFile = File(...)):
             "grad_cam_map": grad_cam_map_serialized
         })
     
+    logger.info(f"[RequestID: {request_id}] Przetwarzanie żądania /predict/ zakończone. Zwracam wyniki.")
     return JSONResponse(content=results)
 
 @app.get("/")
 async def root():
+    logger.info("Otrzymano żądanie GET na /")
     return {"message": "Witaj w BI-RADS Classification API! Użyj endpointu /predict/ do wysyłania obrazów."}
 
 # Do uruchomienia lokalnie: uvicorn api_app:app --reload