Update app.py

app.py

@@ -4,7 +4,6 @@ import streamlit as st
 import docx
 import docx2txt
 import tempfile
-import numpy as np
 import time
 import re
 import concurrent.futures
@@ -36,8 +35,14 @@ def load_models():
         # Load smaller summarization model for speed
         models['summarizer'] = pipeline("summarization", model="facebook/bart-large-cnn", max_length=130)
         
-        # Load Phi-4 model for evaluation
-        models['evaluator'] = pipeline("text-generation", model="TinyLlama/TinyLlama-1.1B-Chat-v1.0", max_new_tokens=150)
+        # Load TinyLlama model for evaluation
+        models['evaluator'] = pipeline(
+            "text-generation", 
+            model="TinyLlama/TinyLlama-1.1B-Chat-v1.0",
+            max_new_tokens=200,
+            do_sample=True,
+            temperature=0.7
+        )
         
         return models
 
@@ -296,64 +301,86 @@ def summarize_resume_text(resume_text):
     return formatted_summary, execution_time
 
 #####################################
-# Function: Evaluate Candidate with Phi-4
+# Function: Evaluate with TinyLlama
 #####################################
 @st.cache_data(show_spinner=False)
-def evaluate_suitability(candidate_summary, company_prompt, _evaluator=None):
+def evaluate_with_tiny_llama(candidate_summary, company_info, _evaluator=None):
     """
-    Use the Phi-4 model to evaluate the suitability of a candidate 
-    based on their resume summary and the company requirements.
+    Use TinyLlama to evaluate the match between a candidate's resume and company requirements.
     """
     start_time = time.time()
     
     evaluator = _evaluator or models['evaluator']
     
-    # Craft a prompt for the model
-    prompt = f"""You are an expert HR recruiter. Analyze the candidate's profile and the job requirements to provide:
-1. A suitability score from 0 to 100
-2. A brief evaluation explaining why the candidate is or isn't suitable
+    # Format the chat prompt for TinyLlama's chat format
+    prompt = f"""<|im_start|>system
+You are an expert HR recruiter. Your task is to evaluate how well a candidate's profile matches with a company's requirements. Be concise but thorough in your evaluation.
+<|im_end|>
+
+<|im_start|>user
+I need to evaluate a job candidate against company requirements. Please:
+1. Analyze the match between the candidate and the position
+2. Give a suitability score from 0-100
+3. Provide 2-3 sentences explaining your evaluation
+4. List the top 3 strengths of the candidate for this role
+5. List 1-2 potential gaps if any
 
 Candidate Profile:
 {candidate_summary}
 
-Job Requirements:
-{company_prompt}
+Company Requirements:
+{company_info}
+<|im_end|>
 
-Give your assessment in this format:
-Score: [0-100]
-Evaluation: [Your brief evaluation]
+<|im_start|>assistant
 """
     
-    # Generate the evaluation with Phi-4
-    result = evaluator(prompt, do_sample=True, temperature=0.3)[0]['generated_text']
+    # Generate the response
+    response = evaluator(prompt)[0]['generated_text']
     
-    # Extract the score and evaluation from the result
-    score_match = re.search(r'Score:\s*(\d+)', result)
-    if score_match:
-        score = int(score_match.group(1))
-        # Normalize to 0-1 range
-        normalized_score = score / 100
-    else:
-        # Default score if extraction fails
-        normalized_score = 0.5
+    # Extract just the assistant's response after the prompt
+    assistant_response_start = response.find("<|im_start|>assistant") + len("<|im_start|>assistant")
+    assistant_response = response[assistant_response_start:].strip()
     
-    # Extract the evaluation text
-    evaluation_match = re.search(r'Evaluation:(.*?)($|\n\n)', result, re.DOTALL)
-    if evaluation_match:
-        evaluation = evaluation_match.group(1).strip()
-    else:
-        # Extract text after "Score:" line if specific evaluation format is not found
-        lines = result.split('\n')
-        for i, line in enumerate(lines):
-            if 'Score:' in line and i+1 < len(lines):
-                evaluation = '\n'.join(lines[i+1:]).strip()
+    # Remove any trailing tag if present
+    if "<|im_end|>" in assistant_response:
+        assistant_response = assistant_response.split("<|im_end|>")[0].strip()
+    
+    # Try to extract the score from the response
+    score_match = re.search(r'(\d{1,3})/100|score:?\s*(\d{1,3})|rating:?\s*(\d{1,3})|suitability:?\s*(\d{1,3})', 
+                           assistant_response.lower())
+    
+    if score_match:
+        # Find the first group that matched and isn't None
+        for group in score_match.groups():
+            if group is not None:
+                score = int(group)
+                normalized_score = min(100, max(0, score)) / 100  # Ensure it's in 0-1 range
                 break
         else:
-            evaluation = "The candidate's profile has been evaluated based on the job requirements."
+            normalized_score = 0.5  # Default if no group was extracted
+    else:
+        # If no explicit score, try to infer from sentiments
+        positive_words = ['excellent', 'perfect', 'outstanding', 'ideal', 'great']
+        negative_words = ['poor', 'inadequate', 'insufficient', 'lacks', 'mismatch']
+        
+        positive_count = sum(assistant_response.lower().count(word) for word in positive_words)
+        negative_count = sum(assistant_response.lower().count(word) for word in negative_words)
+        
+        if positive_count > negative_count * 2:
+            normalized_score = 0.85
+        elif positive_count > negative_count:
+            normalized_score = 0.7
+        elif negative_count > positive_count * 2:
+            normalized_score = 0.3
+        elif negative_count > positive_count:
+            normalized_score = 0.4
+        else:
+            normalized_score = 0.5
     
     execution_time = time.time() - start_time
     
-    return normalized_score, evaluation, execution_time
+    return normalized_score, assistant_response, execution_time
 
 #####################################
 # Main Streamlit Interface - with Progress Reporting
@@ -364,7 +391,7 @@ st.markdown(
 Upload your resume file in **.docx**, **.doc**, or **.txt** format. The app performs the following tasks:
 1. Extracts text from the resume.
 2. Uses AI to generate a structured candidate summary with name, age, expected job industry, previous work experience, and skills.
-3. Uses Phi-4 AI to evaluate the candidate's suitability for the company and provide feedback.
+3. Uses TinyLlama AI to evaluate the candidate's suitability for the company and provide detailed feedback.
 """
 )
 
@@ -402,9 +429,9 @@ if uploaded_file is not None and company_prompt and st.button("Analyze Resume"):
         st.markdown(summary)
         st.info(f"Summary generated in {summarization_time:.2f} seconds")
         
-        # Step 3: Evaluate candidate with Phi-4
-        status_text.text("Step 3/3: Evaluating candidate suitability with Phi-4...")
-        suitability_score, evaluation, evaluation_time = evaluate_suitability(
+        # Step 3: Evaluate with TinyLlama
+        status_text.text("Step 3/3: Evaluating candidate with TinyLlama...")
+        suitability_score, evaluation, evaluation_time = evaluate_with_tiny_llama(
             summary, company_prompt, _evaluator=models['evaluator']
         )
         progress_bar.progress(100)
@@ -414,16 +441,20 @@ if uploaded_file is not None and company_prompt and st.button("Analyze Resume"):
         
         # Display suitability results
         st.subheader("Suitability Assessment")
-        st.markdown(f"**Matching Score:** {suitability_score:.0%}")
         
-        # Display colored evaluation box based on score
+        # Display score with appropriate color
+        score_percent = int(suitability_score * 100)
         if suitability_score >= 0.85:
-            st.success(f"**Evaluation:** {evaluation}")
+            st.success(f"**Matching Score:** {score_percent}%")
         elif suitability_score >= 0.70:
-            st.success(f"**Evaluation:** {evaluation}")
+            st.success(f"**Matching Score:** {score_percent}%")
         elif suitability_score >= 0.50:
-            st.warning(f"**Evaluation:** {evaluation}")
+            st.warning(f"**Matching Score:** {score_percent}%")
         else:
-            st.error(f"**Evaluation:** {evaluation}")
+            st.error(f"**Matching Score:** {score_percent}%")
+        
+        # Display the full evaluation
+        st.markdown("### Detailed Evaluation")
+        st.markdown(evaluation)
             
-        st.info(f"Evaluation completed in {evaluation_time:.2f} seconds")
+        st.info(f"Evaluation completed in {evaluation_time:.2f} seconds using TinyLlama")