Update app.py

app.py

@@ -42,11 +42,10 @@ def load_models():
             truncation=True
         )
         
-        # Load model for evaluation
+        # Load sentiment model for evaluation
         models['evaluator'] = pipeline(
-            "text2text-generation", 
-            model="Qwen/Qwen2.5-0.5B-Instruct",
-            max_length=300
+            "sentiment-analysis", 
+            model="distilbert/distilbert-base-uncased-finetuned-sst-2-english"
         )
         
         return models
@@ -412,7 +411,7 @@ def extract_job_requirements(job_description):
 #####################################
 def analyze_job_fit(resume_summary, job_description):
     """
-    Analyze how well the candidate fits the job requirements with detailed category breakdowns.
+    Analyze how well the candidate fits the job requirements with the DistilBERT sentiment model.
     """
     start_time = time.time()
     
@@ -570,149 +569,67 @@ def analyze_job_fit(resume_summary, job_description):
     # Apply final curve to keep scores in a realistic range
     match_percentage = min(95, max(35, int(weighted_score * 100)))
     
-    # Determine fit/not fit status
-    fit_status = "FIT" if match_percentage >= 70 else "NOT FIT"
+    # Prepare input for sentiment analysis
+    # Create a structured summary of the match for sentiment model
+    match_summary = f"""
+    Job title: {job_requirements['title']}
+    Match percentage: {match_percentage}%
     
-    # Get more specific information for a better prompt
-    # Get top skills across all categories (up to 5 total)
-    all_matching_skills = []
-    for category, matches in found_skills.items():
-        if matches:
-            all_matching_skills.extend(matches)
-    
-    top_skills = list(set(all_matching_skills))[:5]  # Remove duplicates and take top 5
-    skills_text = ", ".join(top_skills) if top_skills else "limited relevant skills"
-    
-    # Get strongest and weakest categories for more specific feedback
-    categories_sorted = sorted(
-        [(cat, category_details[cat]["adjusted_score"]) for cat in category_weights.keys() if cat in category_details],
-        key=lambda x: x[1], 
-        reverse=True
-    )
-    
-    top_category = category_weights[categories_sorted[0][0]]["label"] if categories_sorted else "Technical Skills"
-    weak_category = category_weights[categories_sorted[-1][0]]["label"] if categories_sorted else "Domain Knowledge"
-    
-    # Create a prompt for the evaluation model
-    prompt = f"""
-Generate a professional expert assessment for a job candidate applying for the position: {job_requirements['title']}.
-Skills detected in candidate: {skills_text}.
-Strongest area: {top_category} ({categories_sorted[0][1]}%).
-Weakest area: {weak_category} ({categories_sorted[-1][1]}%).
-Overall match: {match_percentage}%.
-Fit status: {fit_status}
-
-Write an evaluative assessment that analyzes the candidate's fit for this position.
-Start with "{fit_status}: This candidate" and provide a professional evaluation of their fit.
-
-{fit_status}: This candidate"""
-
-    try:
-        # Generate the assessment using the evaluation model
-        assessment_results = models['evaluator'](
-            prompt, 
-            max_length=300,
-            do_sample=True,
-            temperature=0.75,
-            num_return_sequences=3
-        )
+    Technical skills match: {category_details['technical_skills']['adjusted_score']}%
+    Required technical skills: {', '.join(job_requirements['technical_skills'][:5])}
+    Candidate has: {', '.join(found_skills['technical_skills'][:5])}
     
-        # Find the best response with thorough cleaning
-        best_assessment = None
-        for result in assessment_results:
-            # Get the raw text
-            raw_text = result['generated_text'].strip()
-        
-            # Extract just the part that starts with the fit status
-            if f"{fit_status}: This candidate" in raw_text:
-                # Find the start of the actual assessment
-                start_idx = raw_text.find(f"{fit_status}: This candidate")
-                text = raw_text[start_idx:]
-            
-                # Check if it's actually an assessment (not just instructions)
-                if len(text) > 50 and not any(x in text.lower() for x in [
-                    "actionable advice", 
-                    "include specific", 
-                    "make an assessment", 
-                    "evaluate their", 
-                    "assess their", 
-                    "provide specific areas"
-                ]):
-                    best_assessment = text
-                    break
+    Experience match: {category_details['experience']['adjusted_score']}%
+    Required years: {job_requirements['years_experience']}
+    Candidate years: {experience_years}
     
-        # Use the best response or generate a fallback if none were ideal
-        if best_assessment:
-            assessment = best_assessment
-        else:
-            # Generate a completely manual assessment
-            assessment = generate_fallback_assessment(
-                resume_summary, 
-                job_requirements, 
-                match_percentage,
-                top_skills,
-                top_category,
-                weak_category,
-                fit_status
-            )
-        
-    except Exception as e:
-        # Fallback to a manual assessment
-        assessment = generate_fallback_assessment(
-            resume_summary, 
-            job_requirements, 
-            match_percentage,
-            top_skills,
-            top_category,
-            weak_category,
-            fit_status
-        )
-
-    # Final cleanup
-    assessment = re.sub(r'include specific actionable advice.*?improvement\.', '', assessment, flags=re.DOTALL|re.IGNORECASE)
-    assessment = re.sub(r'make an assessment.*?resume\.', '', assessment, flags=re.DOTALL|re.IGNORECASE)
-    assessment = re.sub(r'evaluate their technical skills.*?position\.', '', assessment, flags=re.DOTALL|re.IGNORECASE)
-    assessment = re.sub(r'assess their strengths.*?contributions', '', assessment, flags=re.DOTALL|re.IGNORECASE)
-    assessment = re.sub(r'provide specific areas.*?needed', '', assessment, flags=re.DOTALL|re.IGNORECASE)
-    assessment = re.sub(r'give an overall.*?position', '', assessment, flags=re.DOTALL|re.IGNORECASE)
-
-    # Clean up any double spaces, newlines, etc.
-    assessment = re.sub(r'\s+', ' ', assessment)
-    assessment = assessment.strip()
-
-    # If cleaning removed too much text, use the fallback
-    if len(assessment) < 50 or not assessment.startswith(f"{fit_status}: This candidate"):
-        assessment = generate_fallback_assessment(
-            resume_summary, 
-            job_requirements, 
-            match_percentage,
-            top_skills,
-            top_category,
-            weak_category,
-            fit_status
-        )
+    Education match: {category_details['education']['adjusted_score']}%
     
-    # Make sure percentages are consistent
-    assessment = re.sub(r'\b\d{1,2}%\b', f"{match_percentage}%", assessment)
+    Overall profile match: The candidate's skills and experience appear to {match_percentage >= 70 and "match well with" or "partially match with"} the job requirements.
+    """
     
-    execution_time = time.time() - start_time
+    # Use the sentiment model to get a fit classification
+    sentiment_result = models['evaluator'](match_summary)
     
-    return assessment, match_percentage, category_details, job_requirements, execution_time
-
-# Generate fallback assessment
-def generate_fallback_assessment(resume_summary, job_requirements, match_percentage, top_skills, top_category, weak_category, fit_status):
-    """Generate a fallback assessment if the model fails"""
-    job_title = job_requirements["title"]
-    skills_text = ", ".join(top_skills) if top_skills else "relevant skills"
-    
-    if fit_status == "FIT":
-        assessment = f"""{fit_status}: This candidate demonstrates strong alignment with the {job_title} position, achieving an overall match score of {match_percentage}%. Their proficiency in {skills_text} positions them well to contribute effectively, with particular strength in {top_category}. The candidate's experience level is suitable for the role's requirements. To maximize their success, they could consider developing expertise in {weak_category} to round out their skill set for this position.
-        """
+    # Map sentiment analysis to our score:
+    # NEGATIVE = 0 (poor fit)
+    # POSITIVE = 1 (good fit)
+    score_mapping = {
+        "NEGATIVE": 0,
+        "POSITIVE": 1
+    }
+    
+    # Get the sentiment score
+    sentiment_score = score_mapping.get(sentiment_result[0]['label'], 0)
+    
+    # Adjust the score based on the match percentage to get our 0,1,2 scale
+    if sentiment_score == 1 and match_percentage >= 85:
+        final_score = 2  # Excellent fit
+    elif sentiment_score == 1:
+        final_score = 1  # Good fit
     else:
-        assessment = f"""{fit_status}: This candidate currently shows limited alignment with the {job_title} position, with an overall match score of {match_percentage}%. While they demonstrate some capabilities in {top_category} and have experience with {skills_text}, they would need to develop expertise in {weak_category} to be more competitive for this role. The candidate may become a stronger fit by focusing on these skill gaps and gaining more relevant experience in the key requirements for this position.
-        """
+        final_score = 0  # Poor fit
+    
+    # Map to fit status
+    fit_status_map = {
+        0: "NOT FIT",
+        1: "POTENTIAL FIT",
+        2: "STRONG FIT"
+    }
+    
+    fit_status = fit_status_map[final_score]
+    
+    # Generate assessment summary based on the score
+    if final_score == 2:
+        assessment = f"{final_score}: The candidate is a strong match for this {job_requirements['title']} position, with excellent alignment in technical skills and experience. Their background demonstrates the required expertise in key areas such as {', '.join(found_skills['technical_skills'][:3]) if found_skills['technical_skills'] else 'relevant technical domains'}, and they possess the necessary {experience_years} years of experience (required: {years_required})."
+    elif final_score == 1:
+        assessment = f"{final_score}: The candidate shows potential for this {job_requirements['title']} position, with some good matches in required skills. They demonstrate experience with {', '.join(found_skills['technical_skills'][:2]) if found_skills['technical_skills'] else 'some relevant technologies'}, but may need development in areas like {', '.join(set(job_requirements['technical_skills']) - set(found_skills['technical_skills']))[:2] if set(job_requirements['technical_skills']) - set(found_skills['technical_skills']) else 'specific technical requirements'}."
+    else:
+        assessment = f"{final_score}: The candidate does not appear to be a strong match for this {job_requirements['title']} position. Their profile shows limited alignment with key requirements, particularly in {', '.join(set(job_requirements['technical_skills']) - set(found_skills['technical_skills']))[:3] if set(job_requirements['technical_skills']) - set(found_skills['technical_skills']) else 'required technical skills'}, and they have {experience_years} years of experience (required: {years_required})."
+    
+    execution_time = time.time() - start_time
     
-    return assessment
+    return assessment, final_score, match_percentage, category_details, job_requirements, execution_time
 
 #####################################
 # Main Streamlit Interface
@@ -759,7 +676,7 @@ if uploaded_file is not None and job_description and st.button("Analyze Job Fit"
         
         # Step 3: Generate job fit assessment
         status_text.text("Step 3/3: Evaluating job fit...")
-        assessment, match_percentage, category_details, job_requirements, assessment_time = analyze_job_fit(summary, job_description)
+        assessment, fit_score, match_percentage, category_details, job_requirements, assessment_time = analyze_job_fit(summary, job_description)
         progress_bar.progress(100)
 
         # Clear status messages
@@ -768,15 +685,29 @@ if uploaded_file is not None and job_description and st.button("Analyze Job Fit"
         # Display job fit results
         st.subheader("Job Fit Assessment")
 
-        # Display match percentage with appropriate color and emoji
+        # Display fit score with label
+        fit_labels = {
+            0: "NOT FIT ❌",
+            1: "POTENTIAL FIT ⚠️",
+            2: "STRONG FIT ✅"
+        }
+        
+        # Show the score prominently
+        st.markdown(f"## Overall Result: {fit_labels[fit_score]}")
+
+        # Display match percentage
         if match_percentage >= 85:
-            st.success(f"**Overall Job Match Score:** {match_percentage}% 🌟")
+            st.success(f"**Match Score:** {match_percentage}% 🌟")
         elif match_percentage >= 70:
-            st.success(f"**Overall Job Match Score:** {match_percentage}% ✅")
+            st.success(f"**Match Score:** {match_percentage}% ✅")
         elif match_percentage >= 50:
-            st.warning(f"**Overall Job Match Score:** {match_percentage}% ⚠️")
+            st.warning(f"**Match Score:** {match_percentage}% ⚠️")
         else:
-            st.error(f"**Overall Job Match Score:** {match_percentage}% 🔍")
+            st.error(f"**Match Score:** {match_percentage}% 🔍")
+
+        # Display assessment
+        st.markdown("### Assessment")
+        st.markdown(assessment)
 
         # Add detailed score breakdown
         st.markdown("### Score Breakdown")
@@ -824,30 +755,26 @@ if uploaded_file is not None and job_description and st.button("Analyze Job Fit"
             Scores are calculated based on keyword matches in your resume, with diminishing returns applied (first few skills matter more than later ones).
             """)
 
-        # Display assessment
-        st.markdown("### Expert Assessment")
-        st.markdown(assessment)
-
         st.info(f"Assessment completed in {assessment_time:.2f} seconds")
         
-        # Add potential next steps based on the match percentage
+        # Add potential next steps based on the fit score
         st.subheader("Recommended Next Steps")
         
-        if match_percentage >= 80:
+        if fit_score == 2:
             st.markdown("""
             - Consider applying for this position as you appear to be a strong match
             - Prepare for technical interviews by focusing on your strongest skills
             - Review the job description again to prepare for specific interview questions
             """)
-        elif match_percentage >= 60:
+        elif fit_score == 1:
             st.markdown("""
-            - Focus on strengthening your weaker areas before applying
-            - Highlight your strongest skills and experience in your cover letter
-            - Consider gaining additional experience or certifications in key required areas
+            - Focus on highlighting your strongest matching skills in your application
+            - Consider addressing skill gaps in your cover letter by connecting your experience to the requirements
+            - Prepare to discuss how your transferable skills apply to this position
             """)
         else:
             st.markdown("""
             - This position may not be the best fit for your current skills and experience
-            - Consider roles that better align with your strengths
+            - Consider roles that better align with your demonstrated strengths
             - If you're set on this type of position, focus on developing skills in the areas mentioned in the job description
             """)