Update app.py

app.py

@@ -4,74 +4,82 @@ from fastapi import FastAPI, Request
 from transformers import AutoTokenizer, AutoModelForCausalLM
 from peft import PeftModel
 from typing import Dict, Any
+import logging
 
-# Hugging Face token
+# Log ayarları
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Ortam değişkenleri ve konfigürasyon
 HF_TOKEN = os.getenv("HF_TOKEN")
 if not HF_TOKEN:
+    logger.error("HF_TOKEN environment variable not set!")
     raise ValueError("HF_TOKEN environment variable not set!")
 
-# Cache dizinini ayarla (yazma izni olan bir dizin)
-os.environ["HF_HOME"] = "/tmp/huggingface"
-os.environ["TRANSFORMERS_CACHE"] = "/tmp/huggingface"
-
-# Model IDs
-BASE_MODEL_ID = "google/gemma-1.1-2b-it"
-LORA_MODEL_ID = "programci48/heytak-lora-v1"
+# Model konfigürasyonu
+MODEL_CONFIG = {
+    "base_model": "google/gemma-1.1-2b-it",
+    "lora_model": "programci48/heytak-lora-v1",
+    "cache_dir": "/tmp/huggingface",
+    "device": "cuda" if torch.cuda.is_available() else "cpu",
+    "torch_dtype": torch.float16 if torch.cuda.is_available() else torch.float32
+}
 
-# Load models with error handling and optimizations
 def load_models() -> Dict[str, Any]:
+    """Modelleri yükleyen fonksiyon"""
     try:
-        # Load tokenizer (login işlemi olmadan doğrudan token kullanarak)
+        logger.info("Tokenizer yükleniyor...")
         tokenizer = AutoTokenizer.from_pretrained(
-            BASE_MODEL_ID,
+            MODEL_CONFIG["base_model"],
             token=HF_TOKEN,
-            cache_dir="/tmp/huggingface"
+            cache_dir=MODEL_CONFIG["cache_dir"]
         )
 
-        # Load base model with memory optimization
+        logger.info(f"Temel model yükleniyor ({MODEL_CONFIG['device']})...")
         base_model = AutoModelForCausalLM.from_pretrained(
-            BASE_MODEL_ID,
-            torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32,
+            MODEL_CONFIG["base_model"],
+            torch_dtype=MODEL_CONFIG["torch_dtype"],
             device_map="auto",
             token=HF_TOKEN,
             low_cpu_mem_usage=True,
-            cache_dir="/tmp/huggingface"
+            cache_dir=MODEL_CONFIG["cache_dir"]
         )
 
-        # Load LoRA adapter
+        logger.info("LoRA adaptörü yükleniyor...")
         model = PeftModel.from_pretrained(
             base_model,
-            LORA_MODEL_ID,
+            MODEL_CONFIG["lora_model"],
             token=HF_TOKEN
         )
         model.eval()
-
-        # Move to CPU if no GPU available
-        if not torch.cuda.is_available():
+        
+        if MODEL_CONFIG["device"] == "cpu":
             model = model.to("cpu")
-            print("Model moved to CPU")
+            torch.cuda.empty_cache()
 
-        return {
-            "tokenizer": tokenizer,
-            "model": model
-        }
+        logger.info("Modeller başarıyla yüklendi!")
+        return {"tokenizer": tokenizer, "model": model}
 
     except Exception as e:
-        raise RuntimeError(f"Model loading failed: {str(e)}")
-
-# Initialize models
-models = load_models()
-
-# FastAPI app
-app = FastAPI(title="Gemma-LoRA API")
-
+        logger.error(f"Model yükleme hatası: {str(e)}")
+        raise
+
+# Uygulama başlatma
+try:
+    models = load_models()
+    app = FastAPI(title="Gemma-LoRA API", version="1.0")
+except Exception as e:
+    logger.critical(f"Uygulama başlatılamadı: {str(e)}")
+    raise
+
+# API Endpoint'leri
 @app.post("/run/predict")
 async def predict(request: Request):
     try:
         data = await request.json()
         prompt = data["data"][0]
+        logger.info(f"Gelen istek: {prompt[:50]}...")
 
-        # Tokenize with truncation
         inputs = models["tokenizer"](
             prompt,
             return_tensors="pt",
@@ -79,7 +87,6 @@ async def predict(request: Request):
             max_length=512
         ).to(models["model"].device)
 
-        # Generate response
         with torch.no_grad():
             outputs = models["model"].generate(
                 **inputs,
@@ -90,17 +97,22 @@ async def predict(request: Request):
                 repetition_penalty=1.1
             )
 
-        # Decode and clean response
         response = models["tokenizer"].decode(
             outputs[0],
             skip_special_tokens=True
         ).strip()
 
+        logger.info(f"Oluşturulan yanıt: {response[:50]}...")
         return {"data": [response]}
 
     except Exception as e:
+        logger.error(f"İşlem hatası: {str(e)}")
         return {"error": str(e)}, 500
 
 @app.get("/health")
 async def health_check():
-    return {"status": "healthy"}
+    return {
+        "status": "healthy",
+        "device": MODEL_CONFIG["device"],
+        "torch_dtype": str(MODEL_CONFIG["torch_dtype"])
+    }