Update app.py

app.py

@@ -167,185 +167,153 @@ def basic_summarize(text, max_length=100):
     summary = " ".join(summary_sentences)
     return summary
 
-# Custom classification function for job fit assessment
+# Custom classification function for comprehensive job fit assessment
 def evaluate_job_fit(resume_summary, job_requirements, models):
     """
-    Use the sentiment model to evaluate job fit with multiple analyses
+    Use model to evaluate job fit with comprehensive analysis across multiple dimensions
     """
     start_time = time.time()
     
-    # We'll run multiple comparisons to get a more robust assessment
-    
-    # Prepare required information
-    resume_lower = resume_summary.lower()
+    # Extract basic information for context
     required_skills = job_requirements["required_skills"]
     years_required = job_requirements["years_experience"]
     job_title = job_requirements["title"]
     job_summary = job_requirements["summary"]
     
-    # Extract skills mentioned in resume
-    skills_in_resume = []
-    for skill in required_skills:
-        if skill.lower() in resume_lower:
-            skills_in_resume.append(skill)
+    # Create a comprehensive analysis prompt for the model to evaluate
+    analysis_prompt = f"""
+    RESUME SUMMARY:
+    {resume_summary}
+    
+    JOB DESCRIPTION:
+    Title: {job_title}
+    Required experience: {years_required} years
+    Required skills: {', '.join(required_skills)}
+    Description: {job_summary}
+    
+    TASK: Analyze how well the candidate matches this job based on:
+    1. Technical skills match
+    2. Experience level match
+    3. Role/position alignment
+    4. Industry familiarity
+    5. Potential for success in this position
+    
+    Assign a score from 0-2 where:
+    0 = NOT FIT (major gaps in requirements)
+    1 = POTENTIAL FIT (meets some key requirements)
+    2 = GOOD FIT (meets most or all key requirements)
+    """
     
-    # Skills match percentage
-    skills_match_percentage = int((len(skills_in_resume) / max(1, len(required_skills))) * 100)
+    # Truncate prompt if needed to fit model's input limits
+    max_prompt_length = 1024  # Set a reasonable limit
+    if len(analysis_prompt) > max_prompt_length:
+        analysis_prompt = analysis_prompt[:max_prompt_length]
     
-    # Extract years of experience from resume
-    experience_years = 0
-    year_patterns = [
-        r'(\d+)\s*(?:\+)?\s*years?\s*(?:of)?\s*experience',
-        r'experience\s*(?:of)?\s*(\d+)\s*(?:\+)?\s*years?'
-    ]
+    # Use sentiment analysis model for evaluation
+    # This is a smart use of a simple model - we're phrasing our prompt
+    # so that a positive sentiment = good match, negative sentiment = poor match
     
-    for pattern in year_patterns:
-        exp_match = re.search(pattern, resume_lower)
-        if exp_match:
-            try:
-                experience_years = int(exp_match.group(1))
-                break
-            except:
-                pass
+    fit_score = 0  # Default score
+    fit_assessment = ""
     
-    # If we couldn't find explicit years, try to count based on work history
-    if experience_years == 0:
-        # Try to extract from work experience section
-        work_exp_match = re.search(r'work experience:(.*?)(?=\n\n|$)', resume_summary, re.IGNORECASE | re.DOTALL)
-        if work_exp_match:
-            work_text = work_exp_match.group(1).lower()
-            years = re.findall(r'(\d{4})\s*-\s*(\d{4}|present|current)', work_text)
+    # Run multiple sub-analyses to build confidence in our result
+    sub_analyses = []
+    
+    # Function to run model evaluation
+    def run_model_evaluation(prompt_text):
+        if has_pipeline and 'evaluator' in models:
+            result = models['evaluator'](prompt_text)
+            # Convert sentiment to score
+            if result[0]['label'] == 'POSITIVE' and result[0]['score'] > 0.9:
+                return 2  # Strong positive = good fit
+            elif result[0]['label'] == 'POSITIVE':
+                return 1  # Positive but not strong = potential fit
+            else:
+                return 0  # Negative = not fit
+        else:
+            # Manual implementation if pipeline not available
+            tokenizer = models['evaluator_tokenizer']
+            model = models['evaluator_model']
             
-            total_years = 0
-            for year_range in years:
-                start_year = int(year_range[0])
-                if year_range[1].isdigit():
-                    end_year = int(year_range[1])
-                else:
-                    end_year = 2025  # Assume "present" is current year
-                
-                total_years += (end_year - start_year)
+            # Truncate to avoid exceeding model's max length
+            max_length = tokenizer.model_max_length if hasattr(tokenizer, 'model_max_length') else 512
+            truncated_text = " ".join(prompt_text.split()[:max_length])
             
-            experience_years = total_years
-    
-    # Check experience match
-    experience_match = "sufficient" if experience_years >= years_required else "insufficient"
-    
-    # Create multiple comparison texts to evaluate from different angles
-    # Each formatted to bias the sentiment model in a different way
-    
-    # 1. Skill-focused comparison
-    skill_comparison = f"""
-    Required skills for {job_title}: {', '.join(required_skills)}
-    
-    Skills found in candidate resume: {', '.join(skills_in_resume)}
-    
-    The candidate possesses {len(skills_in_resume)} out of {len(required_skills)} required skills ({skills_match_percentage}%).
-    
-    Based on skills alone, the candidate is {'well-qualified' if skills_match_percentage >= 70 else 'partially qualified' if skills_match_percentage >= 50 else 'not well qualified'} for this position.
+            inputs = tokenizer(truncated_text, return_tensors="pt", truncation=True, max_length=max_length)
+            with torch.no_grad():
+                outputs = model(**inputs)
+            
+            probabilities = torch.nn.functional.softmax(outputs.logits, dim=-1)
+            positive_prob = probabilities[0][1].item()  # Positive class probability
+            
+            # Convert probability to score
+            if positive_prob > 0.9:
+                return 2
+            elif positive_prob > 0.6:
+                return 1
+            else:
+                return 0
+    
+    # Run skills analysis
+    skills_prompt = f"""
+    RESUME SKILLS: {resume_summary}
+    JOB REQUIRED SKILLS: {', '.join(required_skills)}
+    
+    Does the candidate have most of the required technical skills for this position?
     """
+    skills_score = run_model_evaluation(skills_prompt)
+    sub_analyses.append(skills_score)
     
-    # 2. Experience-focused comparison
-    experience_comparison = f"""
-    The {job_title} position requires {years_required} years of experience.
-    
-    The candidate has approximately {experience_years} years of experience.
+    # Run experience analysis
+    experience_prompt = f"""
+    RESUME EXPERIENCE: {resume_summary}
+    JOB REQUIRED EXPERIENCE: {years_required} years in {job_title}
     
-    Based on experience alone, the candidate {'meets' if experience_years >= years_required else 'does not meet'} the experience requirements for this position.
+    Does the candidate have sufficient years of relevant experience for this position?
     """
+    experience_score = run_model_evaluation(experience_prompt)
+    sub_analyses.append(experience_score)
     
-    # 3. Overall job fit comparison
-    overall_comparison = f"""
-    Job: {job_title}
-    
-    Job description summary: {job_summary}
-    
-    Candidate summary: {resume_summary[:300]}
+    # Run role alignment analysis
+    role_prompt = f"""
+    CANDIDATE PROFILE: {resume_summary}
+    JOB ROLE: {job_title}, {job_summary}
     
-    Skills match: {skills_match_percentage}%
-    Experience match: {experience_years}/{years_required} years
-    
-    Overall assessment: The candidate's profile {'appears to fit' if skills_match_percentage >= 60 and experience_match == "sufficient" else 'has some gaps compared to'} the key requirements for this position.
+    Is the candidate's background well-aligned with this job role and responsibilities?
     """
-    
-    # Now we'll analyze each comparison using the sentiment model
-    # This is deliberately more thorough to ensure the model is actually doing work
-    
-    # Function to get sentiment score with a consistent interface
-    def get_sentiment(text):
-        """Get sentiment score (1 for positive, 0 for negative)"""
-        if has_pipeline and 'evaluator' in models:
-            try:
-                # Add deliberate sleep to ensure the model has time to process
-                time.sleep(0.5)  # Add small delay to ensure model runs
-                result = models['evaluator'](text)
-                return 1 if result[0]['label'] == 'POSITIVE' else 0
-            except Exception as e:
-                st.warning(f"Error in pipeline sentiment analysis: {e}")
-        
-        # Fall back to manual model inference
-        if 'evaluator_model' in models and 'evaluator_tokenizer' in models and models['evaluator_model']:
-            try:
-                tokenizer = models['evaluator_tokenizer']
-                model = models['evaluator_model']
-                
-                # Add deliberate sleep to ensure the model has time to process
-                time.sleep(0.5)  # Add small delay to ensure model runs
-                
-                # Truncate to avoid exceeding model's max length
-                max_length = tokenizer.model_max_length if hasattr(tokenizer, 'model_max_length') else 512
-                truncated_text = " ".join(text.split()[:max_length])
-                
-                inputs = tokenizer(truncated_text, return_tensors="pt", truncation=True, max_length=max_length)
-                with torch.no_grad():
-                    outputs = model(**inputs)
-                
-                probabilities = torch.nn.functional.softmax(outputs.logits, dim=-1)
-                prediction = torch.argmax(probabilities, dim=-1).item()
-                
-                # Usually for sentiment models, 1 = positive, 0 = negative
-                return 1 if prediction == 1 else 0
-            except Exception as e:
-                st.warning(f"Error in manual sentiment analysis: {e}")
-        
-        # Fallback to keyword approach
-        positive_words = ["match", "fit", "qualified", "skilled", "experienced", "suitable", "aligned", "good", "strong"]
-        negative_words = ["mismatch", "gap", "insufficient", "lacking", "inadequate", "limited", "missing", "poor", "weak"]
-        
-        text_lower = text.lower()
-        positive_count = sum(text_lower.count(word) for word in positive_words)
-        negative_count = sum(text_lower.count(word) for word in negative_words)
-        
-        return 1 if positive_count > negative_count else 0
-    
-    # Analyze each comparison (this will take time, which is good)
-    skills_score = get_sentiment(skill_comparison)
-    experience_score = get_sentiment(experience_comparison)
-    overall_score = get_sentiment(overall_comparison)
-    
-    # Calculate a weighted combined score
-    # Skills: 50%, Experience: 30%, Overall: 20%
-    combined_score = skills_score * 0.5 + experience_score * 0.3 + overall_score * 0.2
-    
-    # Now determine the final score (0, 1, or 2)
-    if combined_score >= 0.7 and skills_match_percentage >= 70 and experience_match == "sufficient":
-        final_score = 2  # Good fit
-    elif combined_score >= 0.4 or (skills_match_percentage >= 50 and experience_match == "sufficient"):
-        final_score = 1  # Potential fit
+    role_score = run_model_evaluation(role_prompt)
+    sub_analyses.append(role_score)
+    
+    # Calculate overall score (weighted average)
+    # Skills: 40%, Experience: 30%, Role alignment: 30%
+    weights = [0.4, 0.3, 0.3]
+    weighted_score = sum(score * weight for score, weight in zip(sub_analyses, weights))
+    
+    # Convert to integer score (0-2)
+    if weighted_score >= 1.5:
+        fit_score = 2
+    elif weighted_score >= 0.8:
+        fit_score = 1
     else:
-        final_score = 0  # Not fit
+        fit_score = 0
     
-    # Generate concise assessment text based on the score
-    if final_score == 2:
-        assessment = f"{final_score}: Skills match {skills_match_percentage}%, Experience match {experience_years}/{years_required} yrs. Strong technical alignment with {len(skills_in_resume)}/{len(required_skills)} required skills."
-    elif final_score == 1:
-        assessment = f"{final_score}: Skills match {skills_match_percentage}%, Experience {experience_match}. Meets some requirements but has gaps in {len(required_skills) - len(skills_in_resume)} skill areas."
+    # Count matching skills for detailed assessment
+    resume_lower = resume_summary.lower()
+    matching_skills = [skill for skill in required_skills if skill.lower() in resume_lower]
+    missing_skills = [skill for skill in required_skills if skill.lower() not in resume_lower]
+    skills_match_percentage = int(len(matching_skills) / max(1, len(required_skills)) * 100)
+    
+    # Generate assessment text based on score
+    if fit_score == 2:
+        fit_assessment = f"{fit_score}: Strong match with {skills_match_percentage}% skill alignment and suitable experience for {job_title}. Candidate demonstrates relevant background and meets key requirements."
+    elif fit_score == 1:
+        fit_assessment = f"{fit_score}: Potential match with {skills_match_percentage}% skill alignment. Candidate meets some requirements for {job_title} but may have gaps in {', '.join(missing_skills[:3])}{'...' if len(missing_skills) > 3 else ''}."
     else:
-        assessment = f"{final_score}: Skills match only {skills_match_percentage}%, Experience {experience_match}. Significant gaps in critical requirements for this position."
+        fit_assessment = f"{fit_score}: Limited match with only {skills_match_percentage}% skill alignment for {job_title}. Significant gaps in required skills and experience suggests this may not be the right fit."
     
     execution_time = time.time() - start_time
     
-    return assessment, final_score, execution_time
+    return fit_assessment, fit_score, execution_time
 
 #####################################
 # Function: Extract Text from File