Update app.py

app.py

@@ -1,46 +1,34 @@
 import gradio as gr
-import numpy as np
+import time
 from transformers import pipeline
 from sentence_transformers import SentenceTransformer
 from sklearn.metrics.pairwise import cosine_similarity
-import PyPDF2
 from TTS.api import TTS  # Coqui TTS library
+import PyPDF2
 
-# Initialize TTS model
+# Initialize Models
+stt_model = pipeline("automatic-speech-recognition", model="openai/whisper-tiny")
+embedding_model = SentenceTransformer("all-MiniLM-L6-v2")
 tts_model = TTS(model_name="tts_models/en/ljspeech/tacotron2-DDC", progress_bar=False, gpu=False)
 
-# Load local models for inference
-stt_model = pipeline("automatic-speech-recognition", model="openai/whisper-base")
-conversation_model = pipeline("text-generation", model="facebook/blenderbot-400M-distill")
-
-# Load a pre-trained model for vector embeddings
-embedding_model = SentenceTransformer('all-MiniLM-L6-v2')
-
 # Parse PDF and create resume content
 def parse_resume(pdf):
-    """Extract text from an uploaded PDF file."""
     reader = PyPDF2.PdfReader(pdf)
     text = "\n".join(page.extract_text() for page in reader.pages if page.extract_text())
-    sections = {"Resume Content": text}
-    return sections
-
-# Process job description text
-def process_job_description(job_desc):
-    """Encode the job description for analysis."""
-    return embedding_model.encode(job_desc)
+    return {"Resume Content": text}
 
-# Process resume and generate embeddings
-def process_resume(pdf):
-    resume_content = parse_resume(pdf)
+# Process inputs
+def process_inputs(resume, job_desc):
     resume_embeddings = {
-        section: embedding_model.encode(content) for section, content in resume_content.items()
+        section: embedding_model.encode(content)
+        for section, content in parse_resume(resume).items()
     }
-    return resume_embeddings
+    job_desc_embedding = embedding_model.encode(job_desc)
+    return resume_embeddings, job_desc_embedding
 
-# Generate question from user response
-def generate_question(user_input, resume_embeddings):
-    """Find the most relevant section in the resume and generate a question."""
-    user_embedding = embedding_model.encode(user_input)
+# Generate a follow-up question
+def generate_question(response, resume_embeddings):
+    user_embedding = embedding_model.encode(response)
     similarities = {
         section: cosine_similarity([user_embedding], [embedding])[0][0]
         for section, embedding in resume_embeddings.items()
@@ -48,78 +36,74 @@ def generate_question(user_input, resume_embeddings):
     most_relevant_section = max(similarities, key=similarities.get)
     return f"Based on your experience in {most_relevant_section}, can you elaborate more?"
 
-# Generate TTS output
-def generate_audio(text):
-    """Convert text to audio using Coqui TTS."""
+# Generate TTS audio for a question
+def generate_audio(question):
     audio_path = "output.wav"
-    tts_model.tts_to_file(text=text, file_path=audio_path)
+    tts_model.tts_to_file(text=question, file_path=audio_path)
     return audio_path
 
-# Gradio interface
+# Conduct a mock interview
 class MockInterview:
     def __init__(self):
         self.resume_embeddings = None
         self.job_desc_embedding = None
         self.interview_active = False
+        self.current_question = None
 
-    def upload_inputs(self, resume, job_desc):
-        self.resume_embeddings = process_resume(resume)
-        self.job_desc_embedding = process_job_description(job_desc)
+    def start_interview(self, resume, job_desc):
+        self.resume_embeddings, self.job_desc_embedding = process_inputs(resume, job_desc)
         self.interview_active = True
-        question = "Tell me about yourself."
-        audio_output = generate_audio(question)
-        return "Resume and job description processed. Starting the interview.", audio_output
+        self.current_question = "Tell me about yourself."
+        return self.current_question, generate_audio(self.current_question)
 
-    def conduct_interview(self, audio_file):
+    def next_interaction(self, user_audio):
         if not self.interview_active:
-            return "Please upload your resume and job description first.", None
+            return "Interview not started.", None
+
+        # Transcribe user's response
+        transcription = stt_model(user_audio)["text"]
 
-        # Transcribe audio
-        transcription = stt_model(audio_file)["text"]
         if not transcription.strip():
-            return "No audio detected. Please try again.", None
+            return "No response detected. Please try again.", None
 
-        # Generate next question
-        question = generate_question(transcription, self.resume_embeddings)
-        audio_output = generate_audio(question)
-        return transcription, audio_output
+        # Generate the next question
+        self.current_question = generate_question(transcription, self.resume_embeddings)
+        return transcription, generate_audio(self.current_question)
 
     def end_interview(self):
         self.interview_active = False
-        audio_output = generate_audio("Thank you for participating in the interview. Goodbye!")
-        return "Interview ended. Thank you for participating.", audio_output
+        return "Thank you for participating in the interview.", generate_audio("Thank you for participating in the interview. Goodbye!")
 
 mock_interview = MockInterview()
 
-def upload_inputs(resume, job_desc):
-    return mock_interview.upload_inputs(resume, job_desc)
+# Gradio Interface
+def start_interview(resume, job_desc):
+    return mock_interview.start_interview(resume, job_desc)
 
-def conduct_interview(audio_file):
-    return mock_interview.conduct_interview(audio_file)
+def next_interaction(user_audio):
+    return mock_interview.next_interaction(user_audio)
 
 def end_interview():
     return mock_interview.end_interview()
 
 interface = gr.Blocks()
+
 with interface:
-    gr.Markdown("""# Mock Interview AI
-Upload your resume and job description, then engage in a realistic audio-based interview simulation.""")
+    gr.Markdown("### Mock Interview AI\nUpload your resume and job description, and engage in a realistic audio-based mock interview simulation.")
 
     with gr.Row():
         resume_input = gr.File(label="Upload Resume (PDF)")
         job_desc_input = gr.Textbox(label="Paste Job Description")
-        upload_button = gr.Button("Upload and Start Interview")
 
-    with gr.Row():
-        audio_input = gr.Audio(type="filepath", label="Respond with Your Answer")
-        transcription_output = gr.Textbox(label="Transcription")
-        question_output = gr.Audio(label="Question Audio")
-        submit_button = gr.Button("Submit Response")
-        end_button = gr.Button("End Interview")
-
-    upload_button.click(upload_inputs, inputs=[resume_input, job_desc_input], outputs=[transcription_output, question_output])
-    submit_button.click(conduct_interview, inputs=[audio_input], outputs=[transcription_output, question_output])
-    end_button.click(end_interview, outputs=[transcription_output, question_output])
+    audio_input = gr.Audio(source="microphone", type="filepath", label="Your Response")
+    question_audio_output = gr.Audio(label="Question Audio")
+    transcription_output = gr.Textbox(label="Transcription")
+    interaction_button = gr.Button("Next Interaction")
+    end_button = gr.Button("End Interview")
+
+    resume_uploaded = resume_input.change(start_interview, inputs=[resume_input, job_desc_input], outputs=[transcription_output, question_audio_output])
+    interaction_button.click(next_interaction, inputs=[audio_input], outputs=[transcription_output, question_audio_output])
+    end_button.click(end_interview, outputs=[transcription_output, question_audio_output])
 
 if __name__ == "__main__":
     interface.launch()