Create app.py

app.py

@@ -0,0 +1,196 @@
+import json
+import gradio as gr
+from transformers import AutoTokenizer, AutoModelForSeq2SeqLM, AutoModelForCausalLM, BitsAndBytesConfig
+import torch
+import os
+import gradio_client.utils as client_utils
+import sys
+
+
+# ===============================
+# Device and Model Setup
+# ===============================
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+hf_token = os.environ["HF_TOKEN"]
+
+#Load the model
+model_path = "AI-Mock-Interviewer/T5"
+tokenizer = AutoTokenizer.from_pretrained(model_path)
+model = AutoModelForSeq2SeqLM.from_pretrained(model_path)
+model.to(device)
+
+model = torch.compile(model)
+
+# ------------------- UPDATED SYSTEM PROMPT -------------------
+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. Ensure each question is unique and does not repeat previously asked questions.
+3. Ensure each question covers a different sub-topic within the domain, avoiding redundancy.
+4. 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
+
+# We'll keep global sets here only if needed as a fallback:
+asked_questions = set()
+asked_subtopics = set()
+
+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.
+    """
+    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()
+
+        # Ensure question ends with a question mark
+        if not question.endswith("?"):
+            question = question.split("?")[0] + "?"
+
+        # Identify the subtopic
+        subtopic = identify_subtopic(question, domain)
+
+        if state is not None:
+            # Use session-level sets to ensure uniqueness
+            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 sets if no state is 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
+
+def reset_state(domain, company, level):
+    """
+    Resets or initializes the session state.
+    """
+    return {
+       "domain": domain,
+       "company": company,
+       "level": level,
+       "asked_questions": set(),
+       "asked_subtopics": set(),
+       "conversation": []  # List of (speaker, message) tuples
+    }
+
+def start_interview(domain, company, level):
+    """
+    Initializes a new interactive interview session with the first question.
+    """
+    state = reset_state(domain, company, level)
+    prompt = (f"Domain: {domain}. "
+              + (f"Company: {company}. " if company else "")
+              + f"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):
+    """
+    Accepts the candidate's response, updates conversation, generates the next question.
+    Allows quitting the interview by typing 'quit'.
+    """
+    if candidate_response.strip().lower() == "quit":
+        state["conversation"].append(("Candidate", candidate_response))
+        state["conversation"].append(("Interviewer", "Interview session has ended. Thank you for participating!"))
+        return state["conversation"], state
+
+    state["conversation"].append(("Candidate", candidate_response))
+    prompt = (f"Domain: {state['domain']}. "
+              f"Candidate's experience level: {state['level']}. "
+               "Generate the next interview question:")
+
+    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", placeholder="e.g. Software Engineering")
+        company_input = gr.Textbox(label="Company (Optional)", placeholder="e.g. Google")
+        level_input = gr.Dropdown(
+            label="Experience Level",
+            choices=["Entry-Level", "Mid-Level", "Senior-Level"],
+            value="Entry-Level"
+        )
+
+    start_button = gr.Button("Start Interview")
+    chatbot = gr.Chatbot(label="Interview Conversation")
+
+    with gr.Row():
+        response_input = gr.Textbox(label="Your Response", placeholder="Type 'quit' to end the interview")
+        submit_button = gr.Button("Submit")
+
+    # State to hold session data
+    state = gr.State()
+
+    # Start interview
+    start_button.click(
+        start_interview,
+        inputs=[domain_input, company_input, level_input],
+        outputs=[chatbot, state]
+    )
+
+    # Submit response
+    submit_button.click(
+        submit_response,
+        inputs=[response_input, state],
+        outputs=[chatbot, state]
+    ).then(
+        lambda: "", None, response_input  # Clear input box after submission
+    )
+
+
+demo.launch()