Update app.py

app.py

@@ -6,126 +6,130 @@ model_name = "vai0511/flan-t5-ai-mock-interviewer"
 tokenizer = T5Tokenizer.from_pretrained(model_name)
 model = T5ForConditionalGeneration.from_pretrained(model_name)
 
-# Function to generate a question
-def generate_question_from_input(domain, company=None):
-    # Dynamically create input text based on domain and company
-    if company:
-        input_text = f"Generate a question for {domain} at {company}"
-    else:
-        input_text = f"Generate a question for {domain}"
-
-    # Tokenize the input text for model inference
-    inputs = tokenizer(input_text, return_tensors="pt", padding=True, truncation=True)
-    input_ids = inputs["input_ids"].to(model.device)
-    attention_mask = inputs["attention_mask"].to(model.device)
-
-    # Generate the question
-    generated_ids = model.generate(
-        input_ids=input_ids,
-        attention_mask=attention_mask,
-        max_length=128,
-        temperature=0.7,
-        top_k=50,
-        top_p=0.95,
-        do_sample=True
-    )
-    generated_question = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
-
-    return generated_question
-
-# Initialize the state for the interview
-def init_state():
+import json
+import gradio as gr
+from transformers import AutoTokenizer, AutoModelForCausalLM, BitsAndBytesConfig
+import torch
+
+# Set up device
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+model.to(device)
+
+# System prompt to guide the interview generation
+system_prompt = """
+You are conducting a mock technical interview. Generate questions and follow-up questions based on the domain provided. Consider these aspects:
+1. The question should be relevant to the domain (e.g., software engineering, machine learning).
+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.
+"""
+
+# Define sub-topic categories for different domains
+subtopic_keywords = {
+    "data analysis": ["data cleaning", "missing data", "outliers", "feature engineering", "EDA", "trend analysis", "data visualization"],
+    "machine learning": ["supervised learning", "unsupervised learning", "model evaluation", "bias-variance tradeoff", "overfitting", "hyperparameter tuning"],
+    "software engineering": ["agile methodology", "code optimization", "design patterns", "database design", "testing strategies"],
+}
+
+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]:
+            if subtopic in question.lower():
+                return subtopic
+    return None
+
+# Modified generate_question that accepts an optional state to track uniqueness per session
+def generate_question(prompt, domain, state=None):
+    while True:
+        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,
+            temperature=0.7,
+            do_sample=True,
+            pad_token_id=tokenizer.eos_token_id,
+        )
+        question = tokenizer.decode(outputs[0], skip_special_tokens=True)
+        question = question.replace(full_prompt, "").strip()
+        if not question.endswith("?"):
+            question = question.split("?")[0] + "?"
+        subtopic = identify_subtopic(question, domain)
+        # Use session state to ensure uniqueness
+        if state is not None:
+            if question not in state["asked_questions"] and (subtopic is None or subtopic not in state["asked_subtopics"]):
+                state["asked_questions"].add(question)
+                if subtopic:
+                    state["asked_subtopics"].add(subtopic)
+                return question
+        else:
+            # Fallback to global trackers if no state provided
+            if question not in asked_questions and (subtopic is None or subtopic not in asked_subtopics):
+                asked_questions.add(question)
+                if subtopic:
+                    asked_subtopics.add(subtopic)
+                return question
+
+# Reset session state for a new interview
+def reset_state(domain, company):
     return {
-        "domain": "",
-        "company": "",
-        "questions": [],
-        "current_step": 0,
+       "domain": domain,
+       "company": company,
+       "asked_questions": set(),
+       "asked_subtopics": set(),
+       "conversation": []  # List of tuples: (speaker, message)
     }
 
-# Respond function for generating questions
-def respond(history, message, state):
-    if state["current_step"] == 0:
-        # First question generation
-        question = generate_question_from_input(state["domain"], state["company"])
-
-        state["questions"].append({"question": question, "response": None})
-        state["current_step"] += 1
-        
-        return [
-            (None, f"Starting {state['domain']} interview for {state['company'] or 'general'}"),
-            (None, question)
-        ], state
-    
-    else:
-        # Stop interview if the user types 'stop'
-        if message.strip().lower() == "stop":
-            return [(None, "Interview ended. Thank you for your participation!")], init_state()
-
-        # Store the response (not used here since no follow-up question)
-        state["questions"][-1]["response"] = message
-
-        # Generate the next question (if any)
-        question = generate_question_from_input(state["domain"], state["company"])
-
-        state["questions"].append({"question": question, "response": None})
-        state["current_step"] += 1
-        
-        history.append((message, None))  # User response
-        history.append((None, question))  # AI question
-        return history, state
-
-# Gradio interface
-with gr.Blocks(title="AI Interviewer") as demo:
-    state = gr.State(init_state)
-    
-    with gr.Column():
-        gr.Markdown("## Technical Interview Simulator")
-        
-        with gr.Row():
-            domain = gr.Textbox(label="Domain (e.g., Machine Learning)", interactive=True)
-            company = gr.Textbox(label="Company (Optional)", interactive=True)
-            start_btn = gr.Button("Start Interview")
-        
-        chatbot = gr.Chatbot(label="Conversation")
-        msg = gr.Textbox(label="Your Answer", interactive=True)
-        submit_btn = gr.Button("Submit Answer")
-        end_btn = gr.Button("End Interview")
-
-    # Start interview
-    start_btn.click(
-        fn=lambda d, c, s: (s.update({"domain": d, "company": c, "current_step": 0}), s),
-        inputs=[domain, company, state],
-        outputs=[state]
-    ).then(
-        respond,
-        inputs=[chatbot, gr.Textbox("", visible=False), state],
-        outputs=[chatbot, state]
-    )
-
-    # Handle responses
-    submit_btn.click(
-        lambda x: x,  # Temporary to capture input
-        inputs=[msg],
-        outputs=[msg]
-    ).then(
-        respond,
-        inputs=[chatbot, msg, state],
-        outputs=[chatbot, state]
-    ).then(
-        lambda: "",  # Clear input
-        None,
-        msg
-    )
-
-    # End interview
-    end_btn.click(
-        lambda: [(None, "Interview ended. Thank you!")],
-        None,
-        chatbot
-    ).then(
-        init_state,
-        None,
-        state
+def start_interview(domain, company):
+    """
+    Initializes a new interactive interview session.
+    Returns the initial conversation (with the first question) and the session state.
+    """
+    state = reset_state(domain, company)
+    prompt = f"Domain: {domain}. " + (f"Company: {company}. " if company else "") + "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):
+    """
+    Accepts the candidate's response, updates the conversation, and generates a follow-up question.
+    """
+    state["conversation"].append(("Candidate", candidate_response))
+    prompt = f"Domain: {state['domain']}. Candidate's last response: {candidate_response}. Generate a follow-up question with a new perspective:"
+    question = generate_question(prompt, state["domain"], state)
+    state["conversation"].append(("Interviewer", question))
+    return state["conversation"], state
+
+# Build an interactive Gradio interface using Blocks
+with gr.Blocks() as demo:
+    gr.Markdown("# Interactive Mock Interview")
+    with gr.Row():
+        domain_input = gr.Textbox(label="Domain")
+        company_input = gr.Textbox(label="Company (Optional)")
+    start_button = gr.Button("Start Interview")
+    chatbot = gr.Chatbot(label="Interview Conversation")
+    with gr.Row():
+        response_input = gr.Textbox(label="Your Response")
+        submit_button = gr.Button("Submit")
+    # gr.State to hold our session data (state is preserved across interactions)
+    state = gr.State()
+    # Clicking start initializes the interview and shows the first question.
+    start_button.click(start_interview, inputs=[domain_input, company_input], outputs=[chatbot, state])
+    # Submitting a response updates the conversation with a follow-up question.
+    submit_button.click(submit_response, inputs=[response_input, state], outputs=[chatbot, state]).then(
+        lambda: "", None, response_input  # Clear the response input after submission
     )
 
 demo.launch()
+