Upload 2 files

app.py

@@ -0,0 +1,216 @@
+import gradio as gr
+import pandas as pd
+import numpy as np
+import torch
+from sentence_transformers import SentenceTransformer
+from sklearn.metrics.pairwise import cosine_similarity
+from transformers import AutoModelForCausalLM, AutoTokenizer
+import os
+
+# --- Configurations ---
+DATASET_URL = "https://huggingface.co/spaces/Davichick/InterviewForge/resolve/main/interview_fordge_dataset_FINAL.csv"
+EMBEDDINGS_PATH = "embeddings_MiniLM.npy"
+EMBEDDING_MODEL_NAME = "sentence-transformers/all-MiniLM-L6-v2"
+GEN_MODEL_NAME = "Qwen/Qwen2.5-1.5B-Instruct"
+DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
+
+# --- Load Data & Models ---
+print("Loading dataset...")
+try:
+    df = pd.read_csv(DATASET_URL, encoding="latin-1")
+except Exception as e:
+    print(f"Failed to load dataset from URL: {e}")
+    # Fallback to local if running locally and URL fails
+    df = pd.read_csv("interview_fordge_dataset_FINAL.csv", encoding="latin-1")
+df = df.reset_index(drop=True)
+
+print("Loading embeddings...")
+if os.path.exists(EMBEDDINGS_PATH):
+    embeddings = np.load(EMBEDDINGS_PATH, allow_pickle=True)
+else:
+    # Dummy fallback to prevent crashing if file missing during build
+    embeddings = np.zeros((len(df), 384))
+    print(f"Warning: {EMBEDDINGS_PATH} not found. Embeddings initialized to zeros.")
+
+print("Loading embedding model...")
+embed_model = SentenceTransformer(EMBEDDING_MODEL_NAME)
+
+print(f"Loading generation model {GEN_MODEL_NAME} on {DEVICE}...")
+tokenizer = AutoTokenizer.from_pretrained(GEN_MODEL_NAME)
+gen_model = AutoModelForCausalLM.from_pretrained(
+    GEN_MODEL_NAME,
+    torch_dtype=torch.bfloat16
+).to(DEVICE)
+gen_model.eval()
+
+# --- Dropdown Constants ---
+POSITIONS = ["Software Engineer", "Data Scientist", "Data Analyst", "Product Manager", "DevOps Engineer", "Machine Learning Engineer", "HR Specialist", "UX Designer", "Cybersecurity Analyst", "Marketing Specialist", "Finance Analyst", "Business Analyst", "Full Stack Developer", "Cloud Architect", "QA / Test Engineer", "Sales Representative", "Customer Success Specialist", "AI/ML Ops Engineer"]
+SENIORITY_LEVELS = ["Junior", "Mid-Level", "Senior", "Lead", "Director"]
+SECTORS = ["Technology", "Finance", "Healthcare", "E-Commerce", "Consulting", "Education", "Media & Entertainment", "Government", "Cybersecurity", "Real Estate & PropTech", "Legal & Compliance", "Gaming & Interactive Media", "Telecommunications", "Startups"]
+INTERVIEW_TYPES = ["HR / Culture Fit", "Technical", "Behavioral (STAR method)", "System Design", "Case Study / Problem Solving"]
+DIFFICULTY_LEVELS = ["Easy", "Medium", "Hard"]
+
+# --- Helper Functions ---
+def _generate(prompt, max_new_tokens=400, temperature=0.7):
+    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
+    with torch.no_grad():
+        output = gen_model.generate(
+            **inputs,
+            max_new_tokens=max_new_tokens,
+            temperature=temperature,
+            do_sample=True,
+            pad_token_id=tokenizer.eos_token_id
+        )
+    # Only decode the new tokens
+    new_tokens = output[0][inputs["input_ids"].shape[1]:]
+    return tokenizer.decode(new_tokens, skip_special_tokens=True).strip()
+
+def generate_model_answer(question, position, seniority, sector, interview_type, difficulty):
+    system_message = "You are an AI interview coach."
+    user_message = f"""You are an expert {seniority} {position} in the {sector} industry.
+You are in a {difficulty} {interview_type} interview.
+
+Answer the following interview question in 2-3 detailed paragraphs.
+Be specific: mention real tools, frameworks, metrics, and methodologies.
+Sound natural and confident, like a top-performing candidate.
+
+Question: {question}"""
+    
+    prompt = f"<|im_start|>system\n{system_message}<|im_end|>\n<|im_start|>user\n{user_message}<|im_end|>\n<|im_start|>assistant\n"
+    return _generate(prompt, max_new_tokens=400, temperature=0.7)
+
+def evaluate_user_answer(question, reference_answer, user_answer):
+    system_message = "You are a strict but fair interview coach. Always respond in the exact format requested."
+    user_message = f"""Compare the candidate's answer against the reference answer and evaluate it.
+
+Interview Question: {question[:300]}
+
+Reference Answer (gold standard): {reference_answer[:500]}
+
+Candidate's Answer: {user_answer[:500]}
+
+Respond in EXACTLY this format:
+Score: X/10
+Strength: (one specific thing done well)
+Weakness: (one specific thing missing or weak)
+Tip: (one concrete actionable improvement)"""
+
+    prompt = f"<|im_start|>system\n{system_message}<|im_end|>\n<|im_start|>user\n{user_message}<|im_end|>\n<|im_start|>assistant\n"
+    raw_output = _generate(prompt, max_new_tokens=200, temperature=0.3)
+    return raw_output
+
+# --- Gradio Callbacks ---
+def set_quick_start(qs_type):
+    if qs_type == 1:
+        return "Data Scientist", "Senior", "Finance", "Technical", "Hard"
+    elif qs_type == 2:
+        return "Software Engineer", "Junior", "Technology", "Technical", "Medium"
+    elif qs_type == 3:
+        return "Product Manager", "Lead", "Startups", "Case Study / Problem Solving", "Hard"
+
+def find_questions(position, seniority, sector, interview_type, difficulty, num_questions):
+    query = f"A {difficulty} {interview_type} interview question for a {seniority} {position} in the {sector} industry."
+    query_vector = embed_model.encode(query, convert_to_tensor=False)
+    
+    mask = (
+        (df["position"] == position) &
+        (df["seniority"] == seniority) &
+        (df["sector"] == sector) &
+        (df["interview_type"] == interview_type) &
+        (df["difficulty"] == difficulty)
+    )
+    
+    if mask.sum() == 0:
+        mask = pd.Series([True] * len(df))
+        
+    original_indices = df[mask].index.tolist()
+    df_filtered = df[mask].reset_index(drop=True)
+    emb_filtered = embeddings[original_indices]
+    
+    actual_k = min(int(num_questions), len(df_filtered))
+    scores = cosine_similarity([query_vector], emb_filtered)[0]
+    top_idx = scores.argsort()[::-1][:actual_k]
+    
+    questions = []
+    for idx in top_idx:
+        q = df_filtered.iloc[idx]['question']
+        questions.append(q)
+        
+    if not questions:
+        return gr.update(choices=[], value=None)
+    return gr.update(choices=questions, value=questions[0])
+
+def submit_answer(selected_question, user_answer, enable_eval, position, seniority, sector, interview_type, difficulty):
+    if not selected_question:
+        return user_answer, "Please select a question first.", gr.update(value="", visible=False)
+        
+    # Find the reference answer
+    match = df[df['question'] == selected_question]
+    reference_answer = match.iloc[0]['answer'] if len(match) > 0 else ""
+        
+    model_ans = generate_model_answer(selected_question, position, seniority, sector, interview_type, difficulty)
+    
+    if enable_eval:
+        eval_feedback = evaluate_user_answer(selected_question, reference_answer, user_answer)
+        return user_answer, model_ans, gr.update(value=eval_feedback, visible=True)
+    else:
+        return user_answer, model_ans, gr.update(value="", visible=False)
+
+# --- Gradio UI Layout ---
+with gr.Blocks(theme=gr.themes.Soft()) as demo:
+    gr.Markdown("# 🎯 Interview Forge — AI Interview Coach")
+    gr.Markdown("Select your profile to find relevant interview questions, answer them, and get AI feedback.")
+    
+    with gr.Row():
+        btn_qs1 = gr.Button("🚀 Quick Start 1\nSr. Data Scientist")
+        btn_qs2 = gr.Button("🚀 Quick Start 2\nJr. SWE Tech")
+        btn_qs3 = gr.Button("🚀 Quick Start 3\nPM Lead Case")
+        
+    with gr.Row():
+        pos_drop = gr.Dropdown(choices=POSITIONS, label="Position", value="Data Scientist")
+        sen_drop = gr.Dropdown(choices=SENIORITY_LEVELS, label="Seniority", value="Senior")
+        sec_drop = gr.Dropdown(choices=SECTORS, label="Sector", value="Finance")
+        
+    with gr.Row():
+        type_drop = gr.Dropdown(choices=INTERVIEW_TYPES, label="Interview Type", value="Technical")
+        diff_drop = gr.Dropdown(choices=DIFFICULTY_LEVELS, label="Difficulty", value="Hard")
+        num_q_radio = gr.Radio(choices=["1", "2", "3", "4", "5"], label="How many questions?", value="3")
+        
+    find_btn = gr.Button("🔍 Find Questions", variant="primary")
+    
+    gr.Markdown("### 📋 Recommended Questions")
+    q_radio = gr.Radio(choices=[], label="Select a question to answer")
+    
+    user_ans_box = gr.Textbox(lines=6, label="✍️ Your Answer", placeholder="Type your interview answer here...")
+    eval_checkbox = gr.Checkbox(label="Enable AI Evaluation (score + feedback)", value=True)
+    
+    submit_btn = gr.Button("📤 Submit Answer", variant="primary")
+    
+    gr.Markdown("### 📊 Results")
+    with gr.Row():
+        user_ans_display = gr.Textbox(label="Your Answer", interactive=False, lines=10)
+        model_ans_display = gr.Textbox(label="AI Model Answer", interactive=False, lines=10)
+        
+    eval_display = gr.Textbox(label="AI Evaluation", interactive=False, visible=False, lines=5)
+    
+    # Event wiring
+    btn_qs1.click(lambda: set_quick_start(1), inputs=None, outputs=[pos_drop, sen_drop, sec_drop, type_drop, diff_drop]).then(
+        find_questions, inputs=[pos_drop, sen_drop, sec_drop, type_drop, diff_drop, num_q_radio], outputs=[q_radio]
+    )
+    btn_qs2.click(lambda: set_quick_start(2), inputs=None, outputs=[pos_drop, sen_drop, sec_drop, type_drop, diff_drop]).then(
+        find_questions, inputs=[pos_drop, sen_drop, sec_drop, type_drop, diff_drop, num_q_radio], outputs=[q_radio]
+    )
+    btn_qs3.click(lambda: set_quick_start(3), inputs=None, outputs=[pos_drop, sen_drop, sec_drop, type_drop, diff_drop]).then(
+        find_questions, inputs=[pos_drop, sen_drop, sec_drop, type_drop, diff_drop, num_q_radio], outputs=[q_radio]
+    )
+    
+    find_btn.click(find_questions, inputs=[pos_drop, sen_drop, sec_drop, type_drop, diff_drop, num_q_radio], outputs=[q_radio])
+    
+    submit_btn.click(
+        submit_answer,
+        inputs=[q_radio, user_ans_box, eval_checkbox, pos_drop, sen_drop, sec_drop, type_drop, diff_drop],
+        outputs=[user_ans_display, model_ans_display, eval_display]
+    )
+
+if __name__ == "__main__":
+    demo.launch()

requirements.txt

@@ -0,0 +1,9 @@
+torch
+transformers
+gradio
+sentence-transformers
+scikit-learn
+pandas
+numpy
+datasets
+accelerate