Updated structure

app.py

@@ -1,15 +1,17 @@
+# app.py
 import gradio as gr
 import asyncio
 from core.utils import generate_first_question
 from core.mbti_analyzer import analyze_mbti
 from core.interviewer import generate_question
 
-# ===============================================================
-# 3️⃣ Интерфейс Gradio
-# ===============================================================
-async def analyze_and_ask_async(user_text, prev_count, user_id="default_user"):
+# --------------------------------------------------------------
+# Асинхронная функция для стриминга ответов
+# --------------------------------------------------------------
+async def analyze_and_ask_stream(user_text, prev_count, user_id="default_user"):
     if not user_text.strip():
-        return "⚠️ Введите ответ.", "", prev_count
+        yield gr.update(value="⚠️ Введите ответ."), gr.update(), gr.update()
+        return
 
     try:
         n = int(prev_count.split("/")[0]) + 1
@@ -17,18 +19,26 @@ async def analyze_and_ask_async(user_text, prev_count, user_id="default_user"):
         n = 1
     counter = f"{n}/30"
 
+    yield gr.update(), gr.update(value="⏳ Анализируем..."), gr.update(value=counter)
+
+    # Параллельные задачи
     mbti_task = asyncio.create_task(analyze_mbti(user_text))
     interviewer_task = asyncio.create_task(generate_question(user_id, user_text))
 
-    mbti_text, next_question = await asyncio.gather(mbti_task, interviewer_task)
-    return mbti_text, next_question, counter
+    # Сначала MBTI
+    mbti_text = await mbti_task
+    yield gr.update(value=mbti_text), gr.update(value="💭 Интервьюер думает..."), gr.update(value=counter)
+
+    # Затем вопрос
+    next_question = await interviewer_task
+    yield gr.update(value=mbti_text), gr.update(value=next_question), gr.update(value=counter)
 
 
+# --------------------------------------------------------------
+# Gradio интерфейс
+# --------------------------------------------------------------
 with gr.Blocks(theme=gr.themes.Soft(), title="MBTI Personality Interviewer") as demo:
-    gr.Markdown(
-        "## 🧠 MBTI Personality Interviewer\n"
-        "Определи личностный тип и получи следующий вопрос от интервьюера."
-    )
+    gr.Markdown("## 🧠 MBTI Personality Interviewer\nОпредели личностный тип и получи следующий вопрос от интервьюера.")
 
     with gr.Row():
         with gr.Column(scale=1):
@@ -43,8 +53,9 @@ with gr.Blocks(theme=gr.themes.Soft(), title="MBTI Personality Interviewer") as
             interviewer_out = gr.Textbox(label="💬 Следующий вопрос от интервьюера", lines=3)
             progress = gr.Textbox(label="⏳ Прогресс", value="0/30")
 
-    btn.click(analyze_and_ask_async, inputs=[inp, progress], outputs=[mbti_out, interviewer_out, progress])
-    demo.load(lambda: ("", generate_first_question(), "0/30"), None, [mbti_out, interviewer_out, progress])
+    btn.click(analyze_and_ask_stream, inputs=[inp, progress], outputs=[mbti_out, interviewer_out, progress])
 
-demo.launch()
+    # Первый вопрос при загрузке
+    demo.load(lambda: ("", generate_first_question(), "0/30"), inputs=None, outputs=[mbti_out, interviewer_out, progress])
 
+demo.queue(streaming=True, max_size=20).launch(server_name="0.0.0.0", server_port=7860)

core/interviewer.py

@@ -1,22 +1,16 @@
-import torch, asyncio
+# core/interviewer.py
+import asyncio
 from transformers import AutoTokenizer, AutoModelForCausalLM, pipeline
-from peft import PeftModel
-from core.utils import clean_question
-from core.memory import update_user_context, get_user_context, was_asked
 
-INTERVIEWER_BASE = "TinyLlama/TinyLlama-1.1B-Chat-v1.0"
-INTERVIEWER_LORA = "f3nsmart/TinyLlama-MBTI-Interviewer-LoRA"
+INTERVIEWER_MODEL = "f3nsmart/TinyLlama-MBTI-Interviewer-LoRA"
 
-print("🔄 Loading interviewer (TinyLlama + LoRA)...")
-
-tokenizer = AutoTokenizer.from_pretrained(INTERVIEWER_LORA)
-base_model = AutoModelForCausalLM.from_pretrained(
-    INTERVIEWER_BASE,
-    torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32,
+# Инициализация
+tokenizer = AutoTokenizer.from_pretrained(INTERVIEWER_MODEL)
+model = AutoModelForCausalLM.from_pretrained(
+    INTERVIEWER_MODEL,
+    torch_dtype="auto",
     device_map="auto"
 )
-model = PeftModel.from_pretrained(base_model, INTERVIEWER_LORA)
-
 llm_pipe = pipeline(
     "text-generation",
     model=model,
@@ -24,29 +18,49 @@ llm_pipe = pipeline(
     max_new_tokens=70,
     temperature=0.7,
     top_p=0.9,
-    device_map="auto"
 )
 
+# Память для пользователей
+user_memory = {}
+
+def clean_question(text: str) -> str:
+    """Удаляет инструкции, оставляя только вопрос"""
+    text = text.strip().split("\n")[0]
+    text = text.strip('"').strip("'")
+    bad_tokens = ["user:", "assistant:", "instruction", "interviewer", "system:"]
+    for bad in bad_tokens:
+        if bad.lower() in text.lower():
+            text = text.split(bad)[-1].strip()
+    if not text.endswith("?"):
+        text += "?"
+    if len(text.split()) < 3:
+        return "What do you usually enjoy doing in your free time?"
+    return text.strip()
 
 async def generate_question(user_id: str, user_text: str) -> str:
-    """Асинхронная генерация вопроса"""
-    history = get_user_context(user_id)
-    prev_qs = " | ".join(history["questions"][-5:])  # последние 5 вопросов
+    """
+    Генерирует новый вопрос с учётом предыдущих.
+    """
+    prev_qs = user_memory.get(user_id, [])
+    prev_joined = "; ".join(prev_qs) if prev_qs else "None"
 
     prompt = (
         f"The following is an MBTI personality interview.\n"
         f"User: {user_text}\n"
         f"Interviewer: ask one new, open-ended question starting with 'What', 'Why', 'How', or 'When'. "
-        f"Ask naturally and concisely, without instructions or explanations.\n"
-        f"Previous questions: {prev_qs or 'None'}\n"
+        f"Avoid repeating or rephrasing previous questions.\n"
+        f"Previous questions: {prev_joined}\n"
         f"Interviewer:"
     )
 
     loop = asyncio.get_event_loop()
-    result = await loop.run_in_executor(None, lambda: llm_pipe(prompt)[0]["generated_text"])
-    cleaned = clean_question(result)
+    raw = await loop.run_in_executor(None, lambda: llm_pipe(prompt)[0]["generated_text"])
+    question = clean_question(raw)
+
+    valid_starts = ("What", "Why", "How", "When")
+    if not question.startswith(valid_starts):
+        question = "What motivates you to do the things you enjoy most?"
 
-    if was_asked(user_id, cleaned):
-        cleaned = "What new challenges have you faced recently?"
-    update_user_context(user_id, cleaned, user_text)
-    return cleaned
+    prev_qs.append(question)
+    user_memory[user_id] = prev_qs[-10:]  # храним последние 10
+    return question

core/mbti_analyzer.py

@@ -1,11 +1,17 @@
+# core/mbti_analyzer.py
 from transformers import pipeline
-from core.utils import format_mbti_output
+import asyncio
 
 MBTI_MODEL = "f3nsmart/MBTIclassifier"
 mbti_pipe = pipeline("text-classification", model=MBTI_MODEL, return_all_scores=True)
 
-async def analyze_mbti(text: str) -> str:
-    """Асинхронный анализ MBTI"""
-    loop = __import__("asyncio").get_event_loop()
-    result = await loop.run_in_executor(None, mbti_pipe, text)
-    return format_mbti_output(result[0])
+async def analyze_mbti(user_text: str) -> str:
+    """
+    Асинхронный анализ текста на MBTI типы.
+    Возвращает 3 лучших типа с их вероятностями.
+    """
+    loop = asyncio.get_event_loop()
+    res = await loop.run_in_executor(None, lambda: mbti_pipe(user_text)[0])
+    res_sorted = sorted(res, key=lambda x: x["score"], reverse=True)
+    mbti_text = "\n".join([f"{r['label']} → {r['score']:.3f}" for r in res_sorted[:3]])
+    return mbti_text

core/utils.py

@@ -1,20 +1,5 @@
-def clean_question(text: str) -> str:
-    text = text.strip().split("\n")[0].strip('"').strip("'")
-    bad_tokens = ["user:", "assistant:", "instruction", "interviewer", "system:"]
-    for bad in bad_tokens:
-        if bad.lower() in text.lower():
-            text = text.split(bad)[-1].strip()
-    if "?" not in text:
-        text = text.rstrip(".") + "?"
-    if len(text.split()) < 3:
-        return "What do you usually enjoy doing in your free time?"
-    return text.strip()
+# core/utils.py
 
-
-def generate_first_question():
+def generate_first_question() -> str:
+    """Первый вопрос фиксированный"""
     return "What do you usually enjoy doing in your free time?"
-
-
-def format_mbti_output(res):
-    res_sorted = sorted(res, key=lambda x: x["score"], reverse=True)
-    return "\n".join([f"{r['label']} → {r['score']:.3f}" for r in res_sorted[:3]])