changes made to app.py

app.py

@@ -9,35 +9,58 @@ device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
 
 hf_token = os.environ["HF_TOKEN"]
 
-# Load model and tokenizer from local files
-model_path = "AI-Mock-Interviewer/T5"  # Assuming all files are in the root directory
+
+# ===============================
+# Load Question Generation Model
+# ===============================
+model_path = "AI-Mock-Interviewer/T5" 
 tokenizer = AutoTokenizer.from_pretrained(model_path)
 model = AutoModelForSeq2SeqLM.from_pretrained(model_path)
 
 # Move model to the appropriate device
 model.to(device)
 
-# ------------------- SYSTEM PROMPT -------------------
+# ===============================
+# Load Evaluation Model (QwQ)
+# ===============================
+bnb_config = BitsAndBytesConfig(
+    load_in_8bit=True,
+    llm_int8_enable_fp32_cpu_offload=True,
+)
+
+qwq_model_id = "unsloth/QwQ-32B-unsloth-bnb-4bit"
+qwq_tokenizer = AutoTokenizer.from_pretrained(qwq_model_id, trust_remote_code=True)
+qwq_model = AutoModelForCausalLM.from_pretrained(
+    qwq_model_id,
+    quantization_config=bnb_config,
+    device_map="auto",
+    trust_remote_code=True
+)
+
+# ===============================
+# Prompts and Scoring
+# ===============================
 system_prompt = """
 You are conducting a mock technical interview. The candidate's experience level can be entry-level, mid-level, or senior-level. Generate questions and follow-up questions based on the domain and the candidate's experience level. Consider these aspects:
-1. The question should be relevant to the domain (e.g., software engineering, machine learning) and appropriate for the candidate's experience level.
-2. For follow-up questions, analyze the candidate's last response and ask questions that probe deeper into their understanding, challenge their approach, or request clarification.
-3. The follow-up question should aim to explore the candidate's depth of knowledge and ability to adapt.
-4. Ensure each question is unique and does not repeat previously asked questions.
-5. Ensure each question covers a different sub-topic within the domain, avoiding redundancy.
-6. If no clear follow-up can be derived, generate a fresh, related question from a different aspect of the domain.
-Important: Ensure that each question is clear, concise, and allows the candidate to demonstrate their technical and communicative abilities effectively.
+1. The question should be relevant to the domain and appropriate for the candidate's experience level.
+2. For follow-up questions, analyze the candidate's last response and ask questions that probe deeper into their understanding.
+3. Avoid repeating previously asked questions or subtopics.
+4. Keep questions clear and concise, targeting core technical and communication skills.
 """
 
-# Define sub-topic categories for different domains
 subtopic_keywords = {
     "data analysis": ["data cleaning", "missing data", "EDA", "visualization"],
     "machine learning": ["supervised learning", "overfitting", "hyperparameter tuning"],
     "software engineering": ["code optimization", "design patterns", "database design"],
 }
 
+rating_scores = {"Good": 3, "Average": 2, "Needs Improvement": 1}
+score_categories = [(90, "Excellent"), (75, "Very Good"), (60, "Good"), (45, "Average"), (0, "Needs Improvement")]
+
+# ===============================
+# Helper Functions
+# ===============================
 def identify_subtopic(question, domain):
-    """Identify the sub-topic of a question using predefined keywords."""
     domain = domain.lower()
     if domain in subtopic_keywords:
         for subtopic in subtopic_keywords[domain]:
@@ -45,19 +68,12 @@ def identify_subtopic(question, domain):
                 return subtopic
     return None
 
-# Tracking asked questions
 def generate_question(prompt, domain, state=None):
-    """
-    Generates a unique question based on the prompt and domain.
-    Uses 'state' to track uniqueness in the conversation session.
-    """
     full_prompt = system_prompt + "\n" + prompt
     inputs = tokenizer(full_prompt, return_tensors="pt").to(device)
-    
     outputs = model.generate(
         inputs["input_ids"],
         max_new_tokens=50,
-        num_return_sequences=1,
         no_repeat_ngram_size=2,
         top_k=30,
         top_p=0.9,
@@ -65,17 +81,12 @@ def generate_question(prompt, domain, state=None):
         do_sample=True,
         pad_token_id=tokenizer.eos_token_id,
     )
-    
     question = tokenizer.decode(outputs[0], skip_special_tokens=True).strip()
-
-    # Ensure question ends with a question mark
     if not question.endswith("?"):
         question += "?"
 
-    # Identify the subtopic
     subtopic = identify_subtopic(question, domain)
 
-    # Check for uniqueness
     if state is not None:
         if (question not in state["asked_questions"] and
             (subtopic is None or subtopic not in state["asked_subtopics"])):
@@ -83,41 +94,121 @@ def generate_question(prompt, domain, state=None):
             if subtopic:
                 state["asked_subtopics"].add(subtopic)
             return question
-    return question  # Fallback
-
-# Initialize conversation state
-def reset_state(domain, company, level):
+    return question
+
+def evaluate_response(response, question):
+    eval_prompt = (
+        "Evaluate the following candidate response to an interview question.\n\n"
+        f"**Question:** {question}\n"
+        f"**Candidate's Response:** {response}\n\n"
+        "Provide a rating as: 'Good', 'Average', or 'Needs Improvement'.\n"
+        "Also, provide a brief suggestion for improvement. Format:\n"
+        "Rating: <Rating>\nSuggestion: <Suggestion>"
+    )
+    inputs = qwq_tokenizer(eval_prompt, return_tensors="pt", padding=True).to(qwq_model.device)
+    outputs = qwq_model.generate(
+        inputs["input_ids"],
+        max_new_tokens=100,
+        top_k=30,
+        top_p=0.9,
+        temperature=0.7,
+        do_sample=True,
+        pad_token_id=qwq_tokenizer.eos_token_id,
+    )
+    evaluation = qwq_tokenizer.decode(outputs[0], skip_special_tokens=True)
+    rating, suggestion = "Unknown", "No suggestion available."
+    for line in evaluation.splitlines():
+        if "Rating:" in line:
+            rating = line.split("Rating:")[1].strip()
+        if "Suggestion:" in line:
+            suggestion = line.split("Suggestion:")[1].strip()
+    return rating, suggestion
+
+def reset_state(name, domain, company, level):
     return {
+        "name": name,
         "domain": domain,
         "company": company,
         "level": level,
         "asked_questions": set(),
         "asked_subtopics": set(),
-        "conversation": []  # List of (speaker, message) tuples
+        "conversation": [],
+        "evaluations": [],
+        "interview_active": True
     }
 
-def start_interview(domain, company, level):
-    state = reset_state(domain, company, level)
+def start_interview(name, domain, company, level):
+    state = reset_state(name, domain, company, level)
     prompt = f"Domain: {domain}. Candidate experience level: {level}. Generate the first question:"
-    
     question = generate_question(prompt, domain, state)
     state["conversation"].append(("Interviewer", question))
     return state["conversation"], state
 
-def submit_response(candidate_response, state):
-    state["conversation"].append(("Candidate", candidate_response))
-    prompt = (f"Domain: {state['domain']}. Candidate's last response: {candidate_response}. Generate a follow-up question:")
-    
-    question = generate_question(prompt, state["domain"], state)
-    state["conversation"].append(("Interviewer", question))
+def submit_response(response, state):
+    if not state["interview_active"]:
+        return state["conversation"], state
+
+    if not response.strip():
+        state["conversation"].append(("System", "⚠️ Please answer the question before proceeding."))
+        return state["conversation"], state
+
+    if response.strip().lower() == "exit":
+        return end_interview(state)
+
+    state["conversation"].append(("Candidate", response))
+    last_q = [msg for role, msg in reversed(state["conversation"]) if role == "Interviewer"][0]
+    rating, suggestion = evaluate_response(response, last_q)
+
+    state["evaluations"].append({
+        "question": last_q,
+        "response": response,
+        "rating": rating,
+        "suggestion": suggestion
+    })
+
+    state["conversation"].append(("Evaluator", f"Rating: {rating}\nSuggestion: {suggestion}"))
+    prompt = f"Domain: {state['domain']}. Candidate's last response: {response}. Generate a follow-up question:"
+    follow_up = generate_question(prompt, state["domain"], state)
+    state["conversation"].append(("Interviewer", follow_up))
     return state["conversation"], state
 
-# ----------- Gradio UI -----------
+def end_interview(state):
+    state["interview_active"] = False
+    total = sum(rating_scores.get(ev["rating"], 0) for ev in state["evaluations"])
+    max_total = len(state["evaluations"]) * 3
+    percent = (total / max_total * 100) if max_total > 0 else 0
+    category = next(label for threshold, label in score_categories if percent >= threshold)
+
+    summary = {
+        "name": state["name"],
+        "domain": state["domain"],
+        "level": state["level"],
+        "company": state["company"],
+        "score": f"{total}/{max_total}",
+        "percentage": round(percent, 2),
+        "category": category,
+        "evaluations": state["evaluations"]
+    }
 
+    filename = f"sessions/{state['name'].replace(' ', '_').lower()}_session.json"
+    os.makedirs("sessions", exist_ok=True)
+    with open(filename, "w") as f:
+        json.dump(summary, f, indent=4)
+
+    state["conversation"].append(("System", f"✅ Interview ended.\nFinal Score: {summary['score']} ({summary['category']})"))
+    return state["conversation"], state
+
+def clear_state():
+    return [], None
+
+# ===============================
+# Gradio UI
+# ===============================
 with gr.Blocks() as demo:
-    gr.Markdown("# Interactive AI-Powered Mock Interview")
-    
+    gr.Markdown("# 🧠 AI Mock Interview with Evaluation, History & Exit")
+
     with gr.Row():
+        name_input = gr.Textbox(label="Your Name")
         domain_input = gr.Textbox(label="Domain", placeholder="e.g. Software Engineering")
         company_input = gr.Textbox(label="Company (Optional)", placeholder="e.g. Google")
         level_input = gr.Dropdown(
@@ -127,17 +218,21 @@ with gr.Blocks() as demo:
         )
 
     start_button = gr.Button("Start Interview")
-    chatbot = gr.Chatbot(label="Interview Conversation")
+    chatbot = gr.Chatbot(label="Interview Conversation", height=450)
 
     with gr.Row():
-        response_input = gr.Textbox(label="Your Response")
+        response_input = gr.Textbox(label="Your Response (type 'exit' to quit)", lines=2)
         submit_button = gr.Button("Submit")
-        clear_button = gr.Button("Clear Chat")
+        exit_button = gr.Button("Exit Interview")
+        clear_button = gr.Button("Clear Session")
 
-    state = gr.State()  # Holds session data
+    state = gr.State()
 
-    start_button.click(start_interview, inputs=[domain_input, company_input, level_input], outputs=[chatbot, state])
+    start_button.click(start_interview,
+                       inputs=[name_input, domain_input, company_input, level_input],
+                       outputs=[chatbot, state])
     submit_button.click(submit_response, inputs=[response_input, state], outputs=[chatbot, state]).then(lambda: "", None, response_input)
+    exit_button.click(end_interview, inputs=state, outputs=[chatbot, state])
     clear_button.click(lambda: ([], None), outputs=[chatbot, state])
 
-demo.launch()
+demo.launch()