Update app.py

app.py

@@ -1,34 +1,20 @@
 """
-LIFT UP Taksonomi Sınıflandırıcı — Backend API
+LIFT UP Taksonomi Sınıflandırıcı — Backend API v2
 Hugging Face Spaces (Docker) üzerinde çalışır.
-
-Endpoint:
-    POST /classify
-    {
-        "baslik": "Proje başlığı",
-        "ozet": "Proje özeti",
-        "keywords": ["opsiyonel", "liste"]  # opsiyonel
-    }
-    →
-    {
-        "prediction": "Kompozit Yapılar",
-        "confidence": 0.82,
-        "top_3": [...],
-        "extracted_keywords": [...],
-        "processing_time_ms": 1240
-    }
+ 
+YENİLİKLER v2:
+  - Gemini 2.5 Flash entegrasyonu (opsiyonel, GEMINI_API_KEY secret ile)
+  - IDF ağırlıklı, title-boost hibrit sınıflandırıcı
+  - Gemini keyword çıkarma + sınıflandırma pipeline
+  - Geriye dönük uyumlu aynı /classify endpoint
 """
-
-import os
-import re
-import time
-import unicodedata
-import logging
+ 
+import os, re, time, math, unicodedata, logging
 from contextlib import asynccontextmanager
-from collections import Counter
+from collections import Counter, defaultdict
 from dataclasses import dataclass, field
-from typing import Dict, List, Optional, Set
-
+from typing import Dict, List, Optional
+ 
 import numpy as np
 import torch
 import torch.nn as nn
@@ -39,23 +25,27 @@ from transformers import AutoTokenizer, AutoModel, AutoModelForSeq2SeqLM
 from sentence_transformers import SentenceTransformer
 from keybert import KeyBERT
 from huggingface_hub import hf_hub_download, snapshot_download
-
+ 
 logging.basicConfig(level=logging.INFO)
 log = logging.getLogger("liftup")
-
-HF_USERNAME = os.getenv("HF_USERNAME", "Engin34")
-HF_TOKEN    = os.getenv("HF_TOKEN", "")   # Space secret olarak eklenecek
-
-# ─── Global model değişkenleri ───────────────────────────────────────
+ 
+HF_USERNAME  = os.getenv("HF_USERNAME", "Engin34")
+HF_TOKEN     = os.getenv("HF_TOKEN", "")
+GEMINI_KEY   = os.getenv("GEMINI_API_KEY", "")
+ 
+# ── Global değişkenler ────────────────────────────────────────────────
 bert_model   = None
 bert_tok     = None
 kw_model     = None
 generator    = None
 clf          = None
 TOP_KEYWORDS = None
+gemini_model = None
+GEMINI_OK    = False
+ALL_CATS     = []
 device       = torch.device("cpu")
-
-
+ 
+ 
 # ═══════════════════════════════════════════════════════════════════
 # TAKSONOMİ PARSER
 # ═══════════════════════════════════════════════════════════════════
@@ -63,15 +53,15 @@ def _temizle(k):
     k = k.replace('\u200b','').replace('\ufeff','')
     k = unicodedata.normalize('NFKC', k)
     return re.sub(r'\s+',' ', k).strip().lower()
-
+ 
 def _parantez_ayir(k):
     m = re.match(r'^(.+?)\s*\((.+?)\)\s*$', k)
     if not m: return [k]
     ana, ic = m.group(1).strip(), m.group(2).strip()
-    if any(a in ic.lower() for a in ['bağlam','kısmı','tarafı','proses','analiz','anahtarları','servisleme']):
+    if any(a in ic.lower() for a in ['bağlam','proses','analiz','anahtarları']):
         return [ana]
     return [ana] + [p.strip() for p in ic.split('/') if p.strip()]
-
+ 
 def _virgul_ayir(metin):
     sonuc, buf, d = [], [], 0
     for c in metin:
@@ -81,15 +71,15 @@ def _virgul_ayir(metin):
         else: buf.append(c)
     if buf: sonuc.append(''.join(buf))
     return sonuc
-
+ 
 def parse_taksonomi(icerik: str) -> Dict:
     icerik = icerik.replace('\u200b','')
     matches = list(re.finditer(r'^\s*(\d+)\)\s+(.+?)\s*$', icerik, re.MULTILINE))
     tax = {}
     for i, m in enumerate(matches):
-        kat = m.group(2).strip()
+        kat   = m.group(2).strip()
         govde = icerik[m.end():(matches[i+1].start() if i+1 < len(matches) else len(icerik))].strip()
-        pm = re.search(r'\((.+)\)', govde, re.DOTALL)
+        pm    = re.search(r'\((.+)\)', govde, re.DOTALL)
         if not pm: continue
         kw_set = set()
         for parca in _virgul_ayir(pm.group(1)):
@@ -99,208 +89,310 @@ def parse_taksonomi(icerik: str) -> Dict:
                     if len(temiz) >= 2: kw_set.add(temiz)
         tax[kat] = {'keywords': kw_set}
     return tax
-
-
+ 
+ 
 # ═══════════════════════════════════════════════════════════════════
-# HİBRİT SINIFLANDIRICI
+# GELİŞMİŞ HİBRİT SINIFLANDIRICI (IDF + title boost)
 # ═══════════════════════════════════════════════════════════════════
-@dataclass
-class EslesmeBilgisi:
-    keyword: str; eslesme_tipi: str; eslesen_taksonomi_kw: str; puan: float
-
+_EKSTRA_KW = {
+    'Yapay Zekâ & Veri Bilimi': {
+        'derin öğrenme','sinir ağı','transformer','lstm','gru',
+        'makine öğrenmesi','yapay sinir','classification','regresyon',
+        'veri madenciliği','takviyeli öğrenme','xgboost',
+    },
+    'Yapılar, Mukavemet & Analiz': {
+        'sonlu elemanlar','fea','burklanma','yorulma','hasar',
+        'gerilme','deformasyon','mod analizi','titreşim','nastran',
+        'abaqus','ansys','mukavemet','kırılma mekaniği',
+    },
+    'Görüntü İşleme & Algılama': {
+        'nesne tespiti','segmentasyon','lidar','radar','yolo',
+        'resnet','konvolüsyon','termal','infrared','optik akış',
+    },
+    'Otonom Sistemler & Robotik': {
+        'otonom','iha','uav','sürü','navigasyon','haritalama',
+        'slam','path planning','insansız',
+    },
+    'Uçuş Mekaniği': {
+        'stabilite','trim','manevra','irtifa','güdüm',
+        'uçuş yörüngesi','ağırlık merkezi','balistik',
+    },
+}
+ 
 @dataclass
 class KategoriSkoru:
-    kategori: str; final_skor: float; keyword_skor: float; semantic_skor: float
+    kategori: str
+    final_skor: float
+    keyword_skor: float
+    semantic_skor: float
     eslesmeler: list = field(default_factory=list)
-
+ 
 class HibritSiniflandirici:
-    def __init__(self, taxonomy, embedder, keyword_weight=0.4, semantic_weight=0.6):
-        self.taxonomy = {c: {'keywords':{str(k).lower().strip() for k in d.get('keywords',set()) if str(k).strip()}}
-                         for c,d in taxonomy.items()}
-        self.kw_w, self.sem_w = keyword_weight, semantic_weight
-        self.embedder = embedder
-        log.info("Centroid'ler hesaplanıyor...")
-        self.centroids = self._centroids()
-        self.idf = self._idf()
-        log.info(f"Hazır: {len(self.taxonomy)} kategori")
-
+    def __init__(self, taxonomy, embedder,
+                 keyword_weight=0.35, semantic_weight=0.65,
+                 title_boost=2.0):
+        self.taxonomy = self._expand(
+            {c: {'keywords': {str(k).lower().strip() for k in d.get('keywords', set()) if str(k).strip()}}
+             for c, d in taxonomy.items()}
+        )
+        self.kw_w        = keyword_weight
+        self.sem_w       = semantic_weight
+        self.title_boost = title_boost
+        self.embedder    = embedder
+        self.idf         = self._idf()
+        self.centroids   = self._centroids()
+        log.info(f"Hibrit sınıflandırıcı hazır: {len(self.taxonomy)} kategori, "
+                 f"alpha={keyword_weight}/{semantic_weight}")
+ 
+    def _expand(self, tax):
+        import copy; t = copy.deepcopy(tax)
+        for cat, kws in _EKSTRA_KW.items():
+            if cat in t: t[cat]['keywords'] |= kws
+        return t
+ 
+    def _idf(self):
+        cnt = Counter()
+        N   = len(self.taxonomy)
+        for d in self.taxonomy.values():
+            for k in d['keywords']: cnt[k] += 1
+        return {k: math.log((N+1)/(v+1))+1 for k, v in cnt.items()}
+ 
     def _centroids(self):
         c = {}
         for cat, d in self.taxonomy.items():
-            kws = list(d['keywords'])
-            if not kws: c[cat]=None; continue
+            kws = list(d['keywords'])[:30]
+            if not kws: c[cat] = None; continue
             embs = self.embedder.encode(kws, show_progress_bar=False, convert_to_numpy=True)
-            v = np.mean(embs, axis=0); n = np.linalg.norm(v)
-            c[cat] = v/n if n>0 else v
+            v    = np.mean(embs, axis=0)
+            n    = np.linalg.norm(v)
+            c[cat] = v / n if n > 0 else v
         return c
-
-    def _idf(self):
-        cnt = Counter()
-        for d in self.taxonomy.values():
-            for k in d['keywords']: cnt[k]+=1
-        N = len(self.taxonomy)
-        return {k: np.log(N/v)+1.0 for k,v in cnt.items()}
-
-    def _kw_score(self, extracted):
-        ext = [k.lower().strip() for k in extracted if k and str(k).strip()]
+ 
+    def _kw_score(self, extracted, title_kws=None):
+        ext     = [k.lower().strip() for k in extracted if k and str(k).strip()]
         max_idf = max(self.idf.values(), default=1.0)
         results = {}
         for cat, d in self.taxonomy.items():
-            cat_kws = d['keywords']; score, eslm = 0.0, []
+            cat_kws = d['keywords']
+            score, eslm = 0.0, []
             for kw in ext:
+                boost = self.title_boost if (title_kws and kw in title_kws) else 1.0
                 idf_w = self.idf.get(kw, 1.0)
                 if kw in cat_kws:
-                    p=2.0*idf_w; score+=p; eslm.append(EslesmeBilgisi(kw,'exact',kw,p)); continue
-                if len(kw)<4: continue
-                for ck in cat_kws:
-                    if len(ck)>=4 and (kw in ck or ck in kw):
-                        p=1.0*idf_w; score+=p; eslm.append(EslesmeBilgisi(kw,'partial',ck,p)); break
-            max_p = max(len(ext)*2.0*max_idf, 1e-6)
-            results[cat] = (min(score/max_p,1.0), eslm)
+                    p = 2.0 * boost * idf_w; score += p
+                    eslm.append(kw)
+                elif len(kw) >= 4 and any(kw in ck or ck in kw for ck in cat_kws):
+                    p = 1.0 * boost * idf_w; score += p
+                    eslm.append(kw)
+            max_p = max(len(ext) * 2.0 * max_idf, 1e-6)
+            results[cat] = (min(score / max_p, 1.0), eslm)
         return results
-
+ 
     def _sem_score(self, extracted, text=None):
         parts = []
         if text and str(text).strip(): parts.append(str(text).strip())
-        if extracted: parts.append(" ".join(extracted))
-        if not parts: return {c:0.0 for c in self.taxonomy}
-        emb = self.embedder.encode([" | ".join(parts)], show_progress_bar=False, convert_to_numpy=True)[0]
+        if extracted: parts.append(" ".join(str(k) for k in extracted))
+        if not parts: return {c: 0.0 for c in self.taxonomy}
+        emb = self.embedder.encode([" | ".join(parts)],
+                                   show_progress_bar=False, convert_to_numpy=True)[0]
         n = np.linalg.norm(emb)
-        if n>0: emb=emb/n
-        return {c: max(0.0, min(1.0,(float(np.dot(emb,cn))+1.0)/2.0)) if cn is not None else 0.0
-                for c,cn in self.centroids.items()}
-
-    def classify(self, keywords, text=None, top_k=3):
-        kw_r = self._kw_score(keywords)
+        if n > 0: emb = emb / n
+        return {cat: max(0.0, min(1.0, (float(np.dot(emb, cn)) + 1.0) / 2.0))
+                if cn is not None else 0.0
+                for cat, cn in self.centroids.items()}
+ 
+    def classify(self, keywords, text=None, title=None, top_k=3):
+        title_kws = {w.lower() for w in str(title).split()} if title else None
+        kw_r  = self._kw_score(keywords, title_kws)
         sem_s = self._sem_score(keywords, text)
         ks = {}
         for c in self.taxonomy:
             kwn, esl = kw_r[c]
-            f = self.kw_w*kwn + self.sem_w*sem_s[c]
+            f = self.kw_w * kwn + self.sem_w * sem_s[c]
             ks[c] = KategoriSkoru(c, f, kwn, sem_s[c], esl)
         srt = sorted(ks.values(), key=lambda x: x.final_skor, reverse=True)
-        return {'prediction': srt[0].kategori, 'confidence': srt[0].final_skor, 'top_k': srt[:top_k]}
-
-
+        return {
+            'prediction': srt[0].kategori,
+            'confidence': srt[0].final_skor,
+            'top_k':      srt[:top_k],
+        }
+ 
+ 
 # ═══════════════════════════════════════════════════════════════════
 # BERT MODEL
 # ═══════════════════════════════════════════════════════════════════
 class LiftUpBertModel(nn.Module):
     def __init__(self, num_labels=128):
         super().__init__()
-        self.bert = AutoModel.from_pretrained("dbmdz/bert-base-turkish-cased")
-        self.dropout = nn.Dropout(0.3)
+        self.bert       = AutoModel.from_pretrained("dbmdz/bert-base-turkish-cased")
+        self.dropout    = nn.Dropout(0.3)
         self.classifier = nn.Linear(768, num_labels)
     def forward(self, input_ids, attention_mask):
         out = self.bert(input_ids=input_ids, attention_mask=attention_mask)
-        return self.classifier(self.dropout(out.last_hidden_state[:,0]))
-
-
+        return self.classifier(self.dropout(out.last_hidden_state[:, 0]))
+ 
+ 
 # ═══════════════════════════════════════════════════════════════════
 # POST-PROCESSOR
 # ═══════════════════════════════════════════════════════════════════
 class SoftPostProcessor:
-    def __init__(self):
-        self.blacklist = {'kombinatür','hesonomik','modülasyonları','difüzörlü','optimizasyonlarını'}
-        self.acronyms = {'CFD','FEA','CAD','ROS','CNN','AI','ML','DL','IoT','GPU','SSD'}
-    def is_acronym(self,w): return w.isupper() and 2<=len(w)<=5
-    def fix_case(self,kw):
-        out=[]
+    BLACKLIST = {'kombinatür','hesonomik','modülasyonları','difüzörlü','optimizasyonlarını'}
+    ACRONYMS  = {'CFD','FEA','CAD','ROS','CNN','AI','ML','DL','IoT','GPU','SSD','API'}
+ 
+    def fix_case(self, kw):
+        parts = []
         for w in kw.split():
-            if w.upper() in self.acronyms or self.is_acronym(w): out.append(w.upper())
-            elif not out: out.append(w.capitalize())
-            else: out.append(w.lower())
-        return ' '.join(out)
-    def should_filter(self,kw):
-        if kw.lower() in self.blacklist: return True
-        if not(3<=len(kw)<=80): return True
-        if re.search(r'[^a-zA-ZçÇğĞıİöÖşŞüÜ\s\-]',kw): return True
-        return False
-    def process(self,keywords,min_kw=3):
-        processed=[]
-        for kw in keywords:
-            if self.should_filter(kw): continue
-            fixed=self.fix_case(kw)
-            if not any(p.lower()==fixed.lower() for p in processed): processed.append(fixed)
-        return processed[:8] if processed else keywords[:3]
-
-
+            if w.upper() in self.ACRONYMS: parts.append(w.upper())
+            elif not parts: parts.append(w.capitalize())
+            else: parts.append(w.lower())
+        return ' '.join(parts)
+ 
+    def ok(self, kw):
+        return (kw.lower() not in self.BLACKLIST
+                and 3 <= len(kw) <= 80
+                and not re.search(r'[^a-zA-ZçÇğĞıİöÖşŞüÜ\s\-]', kw))
+ 
+    def process(self, kws, min_kw=3):
+        out, seen = [], set()
+        for k in kws:
+            if not self.ok(k): continue
+            f = self.fix_case(k)
+            if f.lower() not in seen:
+                out.append(f); seen.add(f.lower())
+        return out[:8] if out else kws[:min_kw]
+ 
+ 
 # ═══════════════════════════════════════════════════════════════════
-# MODEL YÜKLEME (startup)
+# GEMİNİ ENTEGRASYONU
+# ═══════════════════════════════════════════════════════════════════
+def init_gemini(api_key: str, cat_list: list):
+    global gemini_model, GEMINI_OK
+    if not api_key:
+        log.info("GEMINI_API_KEY tanımlı değil — Gemini devre dışı")
+        return
+    try:
+        import google.generativeai as genai
+        genai.configure(api_key=api_key)
+        gemini_model = genai.GenerativeModel("gemini-2.5-flash")
+        # test isteği
+        gemini_model.generate_content("Hi")
+        GEMINI_OK = True
+        log.info("✅ Gemini 2.5 Flash hazır")
+    except Exception as e:
+        GEMINI_OK = False
+        log.warning(f"Gemini yüklenemedi: {e}")
+ 
+def gemini_classify(title: str, abstract: str, cat_list: list) -> Optional[str]:
+    """Gemini'ye hem keyword çıkarma hem sınıflandırma yaptırır."""
+    if not GEMINI_OK or gemini_model is None:
+        return None
+    cat_str = "\n".join(f"{i+1}. {c}" for i, c in enumerate(cat_list))
+    prompt  = f"""Sen bir havacılık ve savunma sanayi projesi analiz uzmanısın.
+ 
+PROJE BAŞLIĞI: {title}
+PROJE ÖZETİ: {str(abstract)[:500]}
+ 
+GÖREV:
+1. Bu projenin teknik anahtar kelimelerini belirle.
+2. Anahtar kelimelere göre aşağıdaki 15 kategoriden TAM OLARAK BİRİNE ata.
+ 
+KATEGORİLER:
+{cat_str}
+ 
+YANIT FORMATI (sadece bu iki satır):
+ANAHTAR_KELİMELER: kelime1, kelime2, kelime3
+KATEGORİ: SAYI. Kategori Adı"""
+    try:
+        raw = gemini_model.generate_content(prompt).text.strip()
+        for line in raw.split('\n'):
+            if 'KATEGORİ:' in line.upper():
+                m = re.search(r'(\d+)\.', line)
+                if m:
+                    num = int(m.group(1))
+                    if 1 <= num <= len(cat_list):
+                        return cat_list[num - 1]
+                for c in cat_list:
+                    if c.lower() in line.lower():
+                        return c
+    except Exception as e:
+        log.warning(f"Gemini classify hatası: {e}")
+    return None
+ 
+ 
+# ═══════════════════════════════════════════════════════════════════
+# MODEL YÜKLEME
 # ═══════════════════════════════════════════════════════════════════
 def load_models():
-    global bert_model, bert_tok, kw_model, generator, clf, TOP_KEYWORDS
-
+    global bert_model, bert_tok, kw_model, generator, clf, TOP_KEYWORDS, ALL_CATS
+ 
     auth = {"token": HF_TOKEN} if HF_TOKEN else {}
     log.info("Modeller yükleniyor...")
-
-    # 1) taksonomi
-    log.info("Taksonomi indiriliyor...")
-    tax_path = hf_hub_download(
-        repo_id=f"{HF_USERNAME}/liftup-bert",
-        filename="taksonomi.txt", **auth
-    )
+ 
+    # 1) Taksonomi
+    tax_path = hf_hub_download(repo_id=f"{HF_USERNAME}/liftup-bert",
+                                filename="taksonomi.txt", **auth)
     with open(tax_path, encoding='utf-8') as f:
         taxonomy = parse_taksonomi(f.read())
-
-    # 2) BERT checkpoint (TOP_KEYWORDS için)
-    log.info("BERT checkpoint indiriliyor...")
-    ckpt_path = hf_hub_download(
-        repo_id=f"{HF_USERNAME}/liftup-bert",
-        filename="checkpoint.pth", **auth
-    )
+    ALL_CATS = list(taxonomy.keys())
+    log.info(f"Taksonomi: {len(taxonomy)} kategori")
+ 
+    # 2) BERT checkpoint
+    ckpt_path = hf_hub_download(repo_id=f"{HF_USERNAME}/liftup-bert",
+                                 filename="checkpoint.pth", **auth)
     ckpt = torch.load(ckpt_path, map_location="cpu")
     TOP_KEYWORDS = ckpt["TOP_KEYWORDS"]
-
-    # 3) BERT model ağırlıkları
-    log.info("BERT model ağırlıkları indiriliyor (422 MB)...")
-    bert_path = hf_hub_download(
-        repo_id=f"{HF_USERNAME}/liftup-bert",
-        filename="best_bert_model.pth", **auth
-    )
+ 
+    # 3) BERT model
+    bert_path = hf_hub_download(repo_id=f"{HF_USERNAME}/liftup-bert",
+                                 filename="best_bert_model.pth", **auth)
     bert_tok = AutoTokenizer.from_pretrained("dbmdz/bert-base-turkish-cased")
-    model = LiftUpBertModel(len(TOP_KEYWORDS))
+    model    = LiftUpBertModel(len(TOP_KEYWORDS))
     model.load_state_dict(torch.load(bert_path, map_location="cpu"))
     model.eval()
     bert_model = model
-
-    # 4) KeyBERT (aynı zamanda hibrit sınıflandırıcının embedder'ı)
-    log.info("KeyBERT yükleniyor...")
+    log.info("✅ BERT hazır")
+ 
+    # 4) KeyBERT
     kw_model = KeyBERT(model='sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2')
     embedder = kw_model.model.embedding_model
-
+    log.info("✅ KeyBERT hazır")
+ 
     # 5) ByT5
-    log.info("ByT5 indiriliyor (1.1 GB)...")
-    byt5_dir = snapshot_download(
-        repo_id=f"{HF_USERNAME}/liftup-byt5", **auth
-    )
+    byt5_dir = snapshot_download(repo_id=f"{HF_USERNAME}/liftup-byt5", **auth)
     byt5_tok = AutoTokenizer.from_pretrained("google/byt5-small")
     byt5_mdl = AutoModelForSeq2SeqLM.from_pretrained(byt5_dir)
     byt5_mdl.eval()
     post = SoftPostProcessor()
-
+ 
     class Generator:
         def __init__(self, tok, mdl, pp):
             self.tok, self.mdl, self.pp = tok, mdl, pp
         def generate(self, title="", abstract=""):
             text = f"keywords: {title} {abstract}".strip()
-            inp = self.tok(text, max_length=512, truncation=True, return_tensors="pt")
+            inp  = self.tok(text, max_length=512, truncation=True, return_tensors="pt")
             with torch.no_grad():
                 out = self.mdl.generate(**inp, max_new_tokens=128, do_sample=False,
                                          no_repeat_ngram_size=4, repetition_penalty=1.5)
             pred = self.tok.decode(out[0], skip_special_tokens=True)
-            if pred.lower().startswith("keywords:"): pred=pred[9:].strip()
-            kws = [k.strip() for k in pred.split(';') if k.strip()]
+            if pred.lower().startswith("keywords:"): pred = pred[9:].strip()
+            kws  = [k.strip() for k in pred.split(';') if k.strip()]
             return self.pp.process(kws)
-
+ 
     generator = Generator(byt5_tok, byt5_mdl, post)
-
-    # 6) Hibrit sınıflandırıcı
-    log.info("Hibrit sınıflandırıcı başlatılıyor...")
-    clf = HibritSiniflandirici(taxonomy, embedder)
+    log.info("✅ ByT5 hazır")
+ 
+    # 6) Hibrit sınıflandırıcı (iyileştirilmiş)
+    clf = HibritSiniflandirici(taxonomy, embedder,
+                               keyword_weight=0.35,
+                               semantic_weight=0.65,
+                               title_boost=2.0)
+ 
+    # 7) Gemini (opsiyonel)
+    init_gemini(GEMINI_KEY, ALL_CATS)
+ 
     log.info("✅ Tüm modeller hazır!")
-
-
+ 
+ 
 # ═══════════════════════════════════════════════════════════════════
 # FASTAPI
 # ═══════════════════════════════════════════════════════════════════
@@ -308,100 +400,104 @@ def load_models():
 async def lifespan(app: FastAPI):
     load_models()
     yield
-
-app = FastAPI(title="LIFT UP Sınıflandırıcı", lifespan=lifespan)
-
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],
-    allow_methods=["POST","GET"],
-    allow_headers=["*"],
-)
-
+ 
+app = FastAPI(title="LIFT UP Sınıflandırıcı v2", lifespan=lifespan)
+app.add_middleware(CORSMiddleware, allow_origins=["*"],
+                   allow_methods=["POST","GET"], allow_headers=["*"])
+ 
 class ClassifyRequest(BaseModel):
-    baslik: str
-    ozet: str
+    baslik:   str
+    ozet:     str
     keywords: Optional[List[str]] = None
-
-
+    use_gemini: bool = False   # True gönderilirse Gemini de çalışır
+ 
 class KategoriResponse(BaseModel):
-    kategori: str
-    guven: float
-    keyword_skor: float
+    kategori:      str
+    guven:         float
+    keyword_skor:  float
     semantic_skor: float
-    eslesmeler: List[str]
-
-
+    eslesmeler:    List[str]
+ 
 class ClassifyResponse(BaseModel):
-    prediction: str
-    confidence: float
-    top_3: List[KategoriResponse]
-    extracted_keywords: List[str]
-    processing_time_ms: int
-
-
+    prediction:          str
+    confidence:          float
+    top_3:               List[KategoriResponse]
+    extracted_keywords:  List[str]
+    processing_time_ms:  int
+    gemini_prediction:   Optional[str] = None   # Gemini sonucu (varsa)
+    gemini_available:    bool = False
+ 
+ 
 def bert_extract(text):
     enc = bert_tok(str(text).lower(), truncation=True, padding='max_length',
                    max_length=256, return_tensors='pt')
     with torch.no_grad():
         logits = bert_model(enc['input_ids'], enc['attention_mask'])
-        probs = torch.sigmoid(logits)[0].numpy()
+        probs  = torch.sigmoid(logits)[0].numpy()
     idxs = np.argsort(probs)[-10:][::-1]
-    return [TOP_KEYWORDS[i] for i in idxs if probs[i]>0.01][:5]
-
+    return [TOP_KEYWORDS[i] for i in idxs if probs[i] > 0.01][:5]
+ 
 def keybert_extract(text):
-    clean = re.sub(r'[^\w\sğüşıöçĞÜŞİÖÇ]',' ', text.lower()).strip()
+    clean = re.sub(r'[^\w\sğüşıöçĞÜŞİÖÇ]', ' ', text.lower()).strip()
     try:
         kws = kw_model.extract_keywords(clean, keyphrase_ngram_range=(1,3),
                                          top_n=5, use_mmr=True, diversity=0.2)
         return [k[0] for k in kws][:3]
     except:
         return []
-
-
+ 
+ 
 @app.get("/health")
-def health(): return {"status": "ok"}
-
-
+def health():
+    return {"status": "ok", "gemini": GEMINI_OK}
+ 
 @app.get("/")
-def root(): return {"message": "LIFT UP API çalışıyor", "endpoint": "POST /classify"}
-
-
+def root():
+    return {"message": "LIFT UP API v2 çalışıyor",
+            "endpoint": "POST /classify",
+            "gemini_available": GEMINI_OK}
+ 
 @app.post("/classify", response_model=ClassifyResponse)
 def classify(req: ClassifyRequest):
     if not req.baslik.strip() or not req.ozet.strip():
         raise HTTPException(400, "Başlık ve özet zorunludur")
-
-    t0 = time.time()
+ 
+    t0   = time.time()
     text = f"{req.baslik} {req.ozet}"
-
-    # Keyword extraction
+ 
+    # ── Keyword çıkarma ──────────────────────────────────────────────
     bert_kws   = bert_extract(text)
     kb_kws     = keybert_extract(text)
     byt5_kws   = generator.generate(req.baslik, req.ozet)
-
-    # Kullanıcı keyword'leri varsa ekle
-    extra = req.keywords or []
-    tum_kws = list(dict.fromkeys(bert_kws + kb_kws + byt5_kws + extra))
-
-    # Sınıflandırma
-    sonuc = clf.classify(tum_kws, text, top_k=3)
-
-    ms = int((time.time()-t0)*1000)
-
+    extra      = req.keywords or []
+    tum_kws    = list(dict.fromkeys(bert_kws + kb_kws + byt5_kws + extra))
+ 
+    # ── Hibrit sınıflandırma ─────────────────────────────────────────
+    sonuc = clf.classify(tum_kws, text, title=req.baslik, top_k=3)
+ 
+    # ── Gemini sınıflandırma (opsiyonel) ─────────────────────────────
+    gem_pred = None
+    if req.use_gemini and GEMINI_OK:
+        gem_pred = gemini_classify(req.baslik, req.ozet, ALL_CATS)
+ 
+    ms = int((time.time() - t0) * 1000)
+ 
     return ClassifyResponse(
-        prediction=sonuc['prediction'],
-        confidence=round(sonuc['confidence'], 4),
-        top_3=[
+        prediction           = sonuc['prediction'],
+        confidence           = round(sonuc['confidence'], 4),
+        top_3                = [
             KategoriResponse(
-                kategori=ks.kategori,
-                guven=round(ks.final_skor, 4),
-                keyword_skor=round(ks.keyword_skor, 4),
-                semantic_skor=round(ks.semantic_skor, 4),
-                eslesmeler=[e.keyword for e in ks.eslesmeler],
+                kategori      = ks.kategori,
+                guven         = round(ks.final_skor, 4),
+                keyword_skor  = round(ks.keyword_skor, 4),
+                semantic_skor = round(ks.semantic_skor, 4),
+                eslesmeler    = ks.eslesmeler[:5],
             )
             for ks in sonuc['top_k']
         ],
-        extracted_keywords=tum_kws,
-        processing_time_ms=ms,
+        extracted_keywords   = tum_kws,
+        processing_time_ms   = ms,
+        gemini_prediction    = gem_pred,
+        gemini_available     = GEMINI_OK,
     )
+