Spaces:

UcsTurkey
/

mistral7b

Paused

App Files Files Community

ciyidogan commited on May 21

Commit

3d30435

verified ·

1 Parent(s): 9870b98

Create fine_tune_inference_test_with_intents.py

Browse files

Files changed (1) hide show

fine_tune_inference_test_with_intents.py +211 -0

fine_tune_inference_test_with_intents.py ADDED Viewed

	@@ -0,0 +1,211 @@

+# fine_tune_inference_with_intent.py
+import os, torch, threading, uvicorn, time, traceback, zipfile, random, json, shutil, asyncio, re
+from fastapi import FastAPI
+from fastapi.responses import HTMLResponse, JSONResponse
+from pydantic import BaseModel
+from transformers import AutoTokenizer, AutoModelForCausalLM, AutoModelForSequenceClassification, Trainer, TrainingArguments
+from peft import PeftModel
+from datasets import Dataset
+from datetime import datetime
+# === Ortam
+HF_TOKEN = os.getenv("HF_TOKEN")
+os.environ["TRANSFORMERS_NO_ADVISORY_WARNINGS"] = "true"
+os.environ["TORCH_HOME"] = "/app/.torch_cache"
+os.makedirs("/app/.torch_cache", exist_ok=True)
+# === Ayarlar
+MODEL_BASE = "TURKCELL/Turkcell-LLM-7b-v1"
+USE_FINE_TUNE = False
+FINE_TUNE_REPO = "UcsTurkey/trained-zips"
+FINE_TUNE_ZIP = "trained_model_000_009.zip"
+USE_SAMPLING = False
+CONFIDENCE_THRESHOLD = -1.5
+FALLBACK_ANSWERS = [
+    "Bu konuda maalesef bilgim yok.",
+    "Ne demek istediğinizi tam anlayamadım.",
+    "Bu soruya şu an yanıt veremiyorum."
+]
+INTENT_MODEL_PATH = "intent_model"
+INTENT_MODEL_ID = "dbmdz/bert-base-turkish-cased"
+INTENT_MODEL = None
+INTENT_TOKENIZER = None
+LABEL2ID = {}
+INTENT_DEFINITIONS = {}
+# === FastAPI
+app = FastAPI()
+chat_history = []
+model = None
+tokenizer = None
+eos_token_id = None
+class Message(BaseModel):
+    user_input: str
+class TrainInput(BaseModel):
+    intents: list
+@app.get("/")
+def health():
+    return {"status": "ok"}
+@app.get("/start", response_class=HTMLResponse)
+def root():
+    return """
+    <html><body>
+        <h2>Turkcell LLM Chat</h2>
+        <textarea id='input' rows='4' cols='60'></textarea><br>
+        <button onclick='send()'>Gönder</button><br><br>
+        <label>Model Cevabı:</label><br>
+        <textarea id='output' rows='10' cols='80' readonly style='white-space: pre-wrap;'></textarea>
+        <script>
+        async function send() {
+            const input = document.getElementById("input").value;
+            const res = await fetch('/chat', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ user_input: input })
+            });
+            const data = await res.json();
+            document.getElementById('output').value = data.answer || data.response || data.error || 'Hata oluştu.';
+        }
+        </script>
+    </body></html>
+    """
+@app.post("/train_intents")
+def train_intents(train_input: TrainInput):
+    global INTENT_DEFINITIONS
+    try:
+        intents = train_input.intents
+        INTENT_DEFINITIONS = {intent["name"]: intent for intent in intents}
+        texts, labels, label2id = [], [], {}
+        for idx, intent in enumerate(intents):
+            label2id[intent["name"]] = idx
+            for ex in intent["examples"]:
+                texts.append(ex)
+                labels.append(idx)
+        dataset = Dataset.from_dict({"text": texts, "label": labels})
+        tokenizer = AutoTokenizer.from_pretrained(INTENT_MODEL_ID)
+        model = AutoModelForSequenceClassification.from_pretrained(INTENT_MODEL_ID, num_labels=len(label2id))
+        def tokenize(batch):
+            return tokenizer(batch["text"], truncation=True, padding=True)
+        tokenized = dataset.map(tokenize, batched=True)
+        args = TrainingArguments("./intent_train_output", per_device_train_batch_size=4, num_train_epochs=3, logging_steps=10, save_strategy="no", report_to=[])
+        trainer = Trainer(model=model, args=args, train_dataset=tokenized)
+        trainer.train()
+        if os.path.exists(INTENT_MODEL_PATH): shutil.rmtree(INTENT_MODEL_PATH)
+        model.save_pretrained(INTENT_MODEL_PATH)
+        tokenizer.save_pretrained(INTENT_MODEL_PATH)
+        with open(os.path.join(INTENT_MODEL_PATH, "label2id.json"), "w") as f:
+            json.dump(label2id, f)
+        return {"status": "ok", "message": "Intent modeli eğitildi."}
+    except Exception as e:
+        return JSONResponse(content={"error": str(e)}, status_code=500)
+@app.post("/load_intent_model")
+def load_intent_model():
+    global INTENT_MODEL, INTENT_TOKENIZER, LABEL2ID
+    try:
+        INTENT_TOKENIZER = AutoTokenizer.from_pretrained(INTENT_MODEL_PATH)
+        INTENT_MODEL = AutoModelForSequenceClassification.from_pretrained(INTENT_MODEL_PATH)
+        with open(os.path.join(INTENT_MODEL_PATH, "label2id.json")) as f:
+            LABEL2ID = json.load(f)
+        return {"status": "ok", "message": "Intent modeli yüklendi."}
+    except Exception as e:
+        return JSONResponse(content={"error": str(e)}, status_code=500)
+async def detect_intent(text):
+    inputs = INTENT_TOKENIZER(text, return_tensors="pt")
+    outputs = INTENT_MODEL(**inputs)
+    pred_id = outputs.logits.argmax().item()
+    id2label = {v: k for k, v in LABEL2ID.items()}
+    return id2label[pred_id]
+def extract_parameters(variables_list, user_input):
+    for pattern in variables_list:
+        regex = re.sub(r"(\w+):\{(.+?)\}", r"(?P<\1>.+?)", pattern)
+        match = re.match(regex, user_input)
+        if match:
+            return [{"key": k, "value": v} for k, v in match.groupdict().items()]
+    return []
+def execute_intent(intent_name, user_input):
+    if intent_name in INTENT_DEFINITIONS:
+        definition = INTENT_DEFINITIONS[intent_name]
+        variables = extract_parameters(definition.get("variables", []), user_input)
+        log(f"🚀 execute_intent('{intent_name}', {variables})")
+        return {"intent": intent_name, "parameters": variables}
+    return {"intent": intent_name, "parameters": []}
+async def generate_response(text):
+    messages = [{"role": "user", "content": text}]
+    encodeds = tokenizer.apply_chat_template(messages, return_tensors="pt", add_special_tokens=True)
+    eos_token = tokenizer("<|im_end|>", add_special_tokens=False)["input_ids"][0]
+    input_ids = encodeds.to(model.device)
+    attention_mask = (input_ids != tokenizer.pad_token_id).long()
+    with torch.no_grad():
+        output = model.generate(
+            input_ids=input_ids,
+            attention_mask=attention_mask,
+            max_new_tokens=128,
+            do_sample=USE_SAMPLING,
+            eos_token_id=eos_token,
+            pad_token_id=tokenizer.pad_token_id,
+            return_dict_in_generate=True,
+            output_scores=True
+        )
+    return tokenizer.decode(output.sequences[0], skip_special_tokens=True).strip()
+@app.post("/chat")
+async def chat(msg: Message):
+    user_input = msg.user_input.strip()
+    try:
+        if model is None or tokenizer is None:
+            return {"error": "Model yüklenmedi."}
+        if INTENT_MODEL:
+            intent_task = asyncio.create_task(detect_intent(user_input))
+            response_task = asyncio.create_task(generate_response(user_input))
+            intent = await intent_task
+            if intent in INTENT_DEFINITIONS:
+                result = execute_intent(intent, user_input)
+                return result
+            else:
+                response = await response_task
+                return {"response": response}
+        else:
+            response = await generate_response(user_input)
+            return {"response": response}
+    except Exception as e:
+        traceback.print_exc()
+        return JSONResponse(content={"error": str(e)}, status_code=500)
+def setup_model():
+    global model, tokenizer, eos_token_id
+    try:
+        device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        tokenizer = AutoTokenizer.from_pretrained(MODEL_BASE, use_fast=False)
+        model = AutoModelForCausalLM.from_pretrained(MODEL_BASE, torch_dtype=torch.float32).to(device)
+        tokenizer.pad_token = tokenizer.pad_token or tokenizer.eos_token
+        model.config.pad_token_id = tokenizer.pad_token_id
+        eos_token_id = tokenizer("<|im_end|>", add_special_tokens=False)["input_ids"][0]
+        model.eval()
+    except Exception as e:
+        traceback.print_exc()
+threading.Thread(target=setup_model, daemon=True).start()
+threading.Thread(target=lambda: uvicorn.run(app, host="0.0.0.0", port=7860), daemon=True).start()
+while True:
+    time.sleep(60)