Update app.py

app.py

@@ -1,187 +1,97 @@
-import os
-import sys
 import time
-import threading
-import traceback
+import sys
 from datetime import datetime
-from fastapi import FastAPI, HTTPException
-from pydantic import BaseModel
-from transformers import AutoTokenizer, AutoModelForCausalLM, BitsAndBytesConfig
-from contextlib import asynccontextmanager
+from fastapi import FastAPI, Request
+import uvicorn
+from transformers import AutoTokenizer, AutoModelForCausalLM
 import torch
+import threading
 
-# === Ortam değişkenleri
-os.environ.setdefault("HF_HOME", "/app/.cache")
-os.environ.setdefault("HF_HUB_CACHE", "/app/.cache")
-
-# === Zamanlı log fonksiyonu
+# 🕒 Zamanlı log fonksiyonu
 def log(message):
     timestamp = datetime.now().strftime("%H:%M:%S")
-    print(f"[{timestamp}] {message}", flush=True)
-
-# === Helper fonksiyonlar
-def trim_history(messages, max_blocks=20):
-    return messages[-max_blocks:]
-
-def enforce_token_budget(tokenizer, system_prompt, history_messages, user_input, total_ctx=4096, max_new_tokens=128):
-    system_tokens = len(tokenizer(system_prompt)['input_ids'])
-    user_tokens = len(tokenizer(user_input)['input_ids'])
-    history_tokens = sum(len(tokenizer(m['content'])['input_ids']) for m in history_messages)
-
-    log(f"ℹ️ Token hesaplama -> System: {system_tokens}, History: {history_tokens}, User: {user_tokens}")
-
-    available_budget = total_ctx - max_new_tokens
-    total_input_tokens = system_tokens + history_tokens + user_tokens
-
-    if total_input_tokens <= available_budget:
-        log(f"✅ Token bütçesi uygun (toplam {total_input_tokens}/{available_budget})")
-        return history_messages
-
-    trimmed_history = history_messages.copy()
-    while trimmed_history:
-        current_history_tokens = sum(len(tokenizer(m['content'])['input_ids']) for m in trimmed_history)
-        total_input_tokens = system_tokens + current_history_tokens + user_tokens
-        if total_input_tokens <= available_budget:
-            break
-
-        removed = trimmed_history.pop(0)
-        removed_tokens = len(tokenizer(removed['content'])['input_ids'])
-        log(f"⚠️ Token bütçesi aşıldı, en eski {removed['role']} mesajı ({removed_tokens} token) atıldı.")
+    print(f"[{timestamp}] {message}")
+    sys.stdout.flush()
 
-    final_tokens = system_tokens + sum(len(tokenizer(m['content'])['input_ids']) for m in trimmed_history) + user_tokens
-    log(f"✅ Budanmış token toplamı: {final_tokens}/{available_budget}")
+# ✅ Health check sunucusu
+app = FastAPI()
 
-    return trimmed_history
-
-# === Global model değişkenleri
-tokenizer = None
-model = None
-
-# === Lifespan tanımı
-@asynccontextmanager
-async def lifespan(app: FastAPI):
-    global tokenizer, model
-    try:
-        model_name = "ytu-ce-cosmos/Turkish-Llama-8b-DPO-v0.1"
-        log(f"⬇️ Model yükleme başlatılıyor: {model_name}")
-
-        tokenizer = AutoTokenizer.from_pretrained(model_name)
-        tokenizer.pad_token = tokenizer.eos_token
+@app.get("/")
+def health():
+    return {"status": "ok"}
 
-        quant_config = BitsAndBytesConfig(
-            load_in_4bit=True,
-            bnb_4bit_compute_dtype=torch.float16  # ✅ float16 hızlandırma
-        )
+def run_health_server():
+    uvicorn.run(app, host="0.0.0.0", port=7860)
 
-        model = AutoModelForCausalLM.from_pretrained(
-            model_name,
-            device_map="auto",
-            quantization_config=quant_config
-        )
+threading.Thread(target=run_health_server, daemon=True).start()
 
-        log("✅ Model ve tokenizer başarıyla hazır (4-bit quantized, float16 compute).")
-        yield
+# ✅ Model yükleme
+MODEL_ID = "ytu-ce-cosmos/Turkish-Llama-8b-DPO-v0.1"
+log("⬇️ Model ve tokenizer yükleme başlatılıyor...")
+start_time = time.time()
+try:
+    tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)
+    model = AutoModelForCausalLM.from_pretrained(
+        MODEL_ID,
+        torch_dtype=torch.bfloat16,
+        device_map="auto",
+    )
+    log(f"✅ Model yüklendi. Süre: {time.time() - start_time:.2f} sn")
+except Exception as e:
+    log(f"❌ Model yükleme hatası: {e}")
+    sys.exit(1)
 
-    except Exception as e:
-        log(f"❌ Model yükleme hatası: {e}")
-        traceback.print_exc()
-        raise
+@app.post("/generate")
+async def generate(request: Request):
+    req_data = await request.json()
+    user_input = req_data.get("user_input", "")
+    system_prompt = req_data.get("system_prompt", "")
 
-# === FastAPI başlat
-app = FastAPI(lifespan=lifespan)
+    if not user_input or not system_prompt:
+        return {"error": "user_input ve system_prompt zorunludur."}
 
-class UserInputRequest(BaseModel):
-    user_input: str
-    system_prompt: str
-    history: list  # [{"role": "user"/"assistant", "content": "..."}, ...]
+    messages = [
+        {"role": "system", "content": system_prompt},
+        {"role": "user", "content": user_input},
+    ]
 
-@app.post("/generate")
-def generate(req: UserInputRequest):
     try:
-        overall_start = time.time()
-        log(f"�� Kullanıcı isteği alındı: {req.user_input}")
-
-        trimmed_history = trim_history(req.history, max_blocks=20)
-        trimmed_history = enforce_token_budget(tokenizer, req.system_prompt, trimmed_history, req.user_input, total_ctx=4096, max_new_tokens=128)
-
-        # === Apply chat template
-        t0 = time.time()
-        messages = [{"role": "system", "content": req.system_prompt}] + trimmed_history + [{"role": "user", "content": req.user_input}]
-        chat_template_raw = tokenizer.apply_chat_template(
+        log("🧩 Input preparation başlatılıyor...")
+        prep_start = time.time()
+        input_ids = tokenizer.apply_chat_template(
             messages,
             add_generation_prompt=True,
-            return_tensors=None
-        )
-        if chat_template_raw is None:
-            chat_template_str = ""
-        elif isinstance(chat_template_raw, str):
-            chat_template_str = chat_template_raw
-        else:
-            chat_template_str = str(chat_template_raw)
-        t1 = time.time()
-        log(f"⏱️ apply_chat_template süresi: {t1 - t0:.2f} saniye")
-
-        # === Tokenizer ile input_ids + attention_mask hazırla
-        t2 = time.time()
-        tokenized_inputs = tokenizer(
-            chat_template_str,
-            return_tensors="pt",
-            padding=True
+            return_tensors="pt"
         ).to(model.device)
-        input_ids = tokenized_inputs['input_ids']
-        attention_mask = tokenized_inputs['attention_mask']
-        t3 = time.time()
-        log(f"⏱️ tokenize süresi: {t3 - t2:.2f} saniye")
-
-        input_len = input_ids.shape[-1]
-        total_ctx = model.config.max_position_embeddings if hasattr(model.config, 'max_position_embeddings') else 4096
-        max_new_tokens = min(128, max(1, total_ctx - input_len))
+        log(f"✅ Input hazırlandı. Süre: {time.time() - prep_start:.2f} sn")
 
-        log(f"ℹ️ Input uzunluğu: {input_len}, max_new_tokens ayarlandı: {max_new_tokens}")
-
-        # === Generate
-        t4 = time.time()
         terminators = [
             tokenizer.eos_token_id,
-            tokenizer.convert_tokens_to_ids("<|eot_id|>") if "<|eot_id|>" in tokenizer.get_vocab() else tokenizer.eos_token_id
+            tokenizer.convert_tokens_to_ids("<|eot_id|>")
         ]
+
+        log("🧠 Generate çağrısı başlatılıyor...")
+        gen_start = time.time()
         outputs = model.generate(
-            input_ids=input_ids,
-            attention_mask=attention_mask,
-            max_new_tokens=max_new_tokens,
-            eos_token_id=terminators
+            input_ids,
+            max_new_tokens=256,
+            eos_token_id=terminators,
+            do_sample=True,
+            temperature=0.6,
+            top_p=0.9,
         )
-        t5 = time.time()
-        log(f"⏱️ generate süresi: {t5 - t4:.2f} saniye")
+        log(f"✅ Generate tamamlandı. Süre: {time.time() - gen_start:.2f} sn")
 
-        # === Decode
-        t6 = time.time()
-        response = outputs[0][input_len:]
-        answer = tokenizer.decode(response, skip_special_tokens=True)
-        t7 = time.time()
-        log(f"⏱️ decode süresi: {t7 - t6:.2f} saniye")
-
-        overall_end = time.time()
-        overall_elapsed = overall_end - overall_start
-        log(f"✅ Toplam yanıt süresi: {overall_elapsed:.2f} saniye")
-
-        return {"response": answer}
+        response = outputs[0][input_ids.shape[-1]:]
+        decoded_output = tokenizer.decode(response, skip_special_tokens=True)
+        log("✅ Cevap başarıyla decode edildi.")
+        return {"response": decoded_output}
 
     except Exception as e:
-        log(f"❌ /generate hatası: {e}")
-        traceback.print_exc()
-        raise HTTPException(status_code=500, detail=str(e))
-
-@app.get("/")
-def health():
-    return {"status": "ok"}
-
-def run_health_server():
-    import uvicorn
-    uvicorn.run(app, host="0.0.0.0", port=7860)
-
-threading.Thread(target=run_health_server, daemon=True).start()
+        log(f"❌ Generate hatası: {e}")
+        return {"error": str(e)}
 
-log("⏸️ Uygulama bekleme modunda...")
+# 🧘 Eğitim sonrası uygulama restart olmasın diye bekleme
+log("⏸️ Uygulama hazır, bekleme modunda...")
 while True:
     time.sleep(60)