Update app.py

app.py

@@ -28,14 +28,14 @@ st.markdown("""
 GOOGLE_DESCRIPTION = """Google LLC, a global leader in technology and innovation, specializes in internet services, cloud computing, artificial intelligence, and software development. As part of Alphabet Inc., Google seeks candidates with strong problem-solving skills, adaptability, and collaboration abilities. Technical roles require proficiency in programming languages such as Python, Java, C++, Go, or JavaScript, with expertise in data structures, algorithms, and system design. Additionally, skills in AI, cybersecurity, UX/UI design, and digital marketing are highly valued. Google fosters a culture of innovation, expecting candidates to demonstrate creativity, analytical thinking, and a passion for cutting-edge technology."""
 
 #####################################
-# Preload Models - Optimized
+# Preload Models
 #####################################
 @st.cache_resource(show_spinner=True)
 def load_models():
-    """Load models at startup - using smaller/faster models"""
+    """Load models at startup"""
     with st.spinner("Loading AI models... This may take a minute on first run."):
         models = {}
-        # Use bart-base instead of bart-large-cnn for faster processing
+        # Use bart-base for summarization
         models['summarizer'] = pipeline(
             "summarization", 
             model="facebook/bart-base", 
@@ -43,13 +43,11 @@ def load_models():
             truncation=True
         )
         
-        # Load T5-small model for evaluation with optimized settings
+        # Load model for evaluation
         models['evaluator'] = pipeline(
-            "text-generation", 
-            model="facebook/opt-1.3b",
-            max_length=200,
-            num_beams=2,
-            early_stopping=True
+            "text2text-generation", 
+            model="google-t5/t5-small",
+            max_length=300
         )
         
         return models
@@ -105,7 +103,7 @@ def extract_text_from_file(file_obj):
     return text[:15000] if text else text
 
 #####################################
-# Functions for Information Extraction - Optimized
+# Functions for Information Extraction
 #####################################
 
 # Cache the extraction functions to avoid reprocessing
@@ -271,11 +269,11 @@ def extract_skills_and_work(text):
     return skills_formatted, work_experience
 
 #####################################
-# Function: Summarize Resume Text - Optimized
+# Function: Summarize Resume Text
 #####################################
 def summarize_resume_text(resume_text):
     """
-    Generates a structured summary of the resume text - optimized for speed
+    Generates a structured summary of the resume text
     """
     start_time = time.time()
     
@@ -312,247 +310,78 @@ def summarize_resume_text(resume_text):
     return formatted_summary, execution_time
 
 #####################################
-# Function: Calculate Google Match Score - Detailed Breakdown
+# Function: Analyze Google Fit
 #####################################
-def calculate_google_match_score(candidate_summary):
+def analyze_google_fit(resume_summary):
     """
-    Calculate a detailed match score breakdown based on skills and experience in the candidate summary
-    compared with what Google requires.
-    
-    Returns:
-    - overall_score: A normalized score between 0 and 1
-    - category_scores: A dictionary with scores for each category
-    - score_breakdown: A formatted string explanation of the scoring
-    """
-    # Define categories that Google values with specific keywords
-    google_categories = {
-        "Technical Skills": {
-            "keywords": ["python", "java", "c++", "go", "javascript", "sql", "nosql", 
-                         "algorithms", "data structures", "system design"],
-            "weight": 0.35
-        },
-        "Advanced Technologies": {
-            "keywords": ["artificial intelligence", "machine learning", "cloud computing", 
-                         "ai", "ml", "cloud", "data science", "big data", 
-                         "tensorflow", "pytorch", "deep learning"],
-            "weight": 0.25
-        },
-        "Problem Solving": {
-            "keywords": ["problem solving", "algorithms", "analytical", "critical thinking",
-                         "debugging", "troubleshooting", "optimization"],
-            "weight": 0.20
-        },
-        "Innovation & Creativity": {
-            "keywords": ["innovation", "creative", "creativity", "novel", "cutting-edge", 
-                        "research", "design thinking", "innovative"],
-            "weight": 0.10
-        },
-        "Teamwork & Leadership": {
-            "keywords": ["team", "leadership", "collaborate", "collaboration", "communication",
-                        "mentoring", "lead", "coordinate", "agile", "scrum"],
-            "weight": 0.10
-        }
-    }
-    
-    summary_lower = candidate_summary.lower()
-    
-    # Calculate scores for each category
-    category_scores = {}
-    for category, details in google_categories.items():
-        keywords = details["keywords"]
-        max_possible = len(keywords)  # Maximum possible matches
-        
-        # Count matches (unique keywords found)
-        matches = sum(1 for keyword in keywords if keyword in summary_lower)
-        
-        # Calculate category score (0-1 range)
-        if max_possible > 0:
-            raw_score = matches / max_possible
-            # Apply a curve to reward having more matches
-            category_scores[category] = min(1.0, raw_score * 1.5)
-        else:
-            category_scores[category] = 0
-    
-    # Calculate weighted overall score
-    overall_score = sum(
-        score * google_categories[category]["weight"] 
-        for category, score in category_scores.items()
-    )
-    
-    # Ensure overall score is in 0-1 range
-    overall_score = min(1.0, max(0.0, overall_score))
-    
-    # Create score breakdown explanation
-    score_breakdown = "**Score Breakdown by Category:**\n\n"
-    
-    for category, score in category_scores.items():
-        percentage = int(score * 100)
-        weight = int(google_categories[category]["weight"] * 100)
-        score_breakdown += f"• **{category}** ({weight}% of total): {percentage}%\n"
-    
-    return overall_score, category_scores, score_breakdown
-
-#####################################
-# Function: Generate Robust Feedback - Template-Based
-#####################################
-def generate_template_feedback(category_scores):
-    """
-    Generate comprehensive template-based feedback without using ML model for speed.
+    Analyze how well the candidate fits Google's requirements.
+    This uses the T5 model to generate a natural language assessment.
     """
     start_time = time.time()
     
-    # Sort categories by score
-    sorted_categories = sorted(category_scores.items(), key=lambda x: x[1], reverse=True)
-    top_categories = sorted_categories[:2]
-    bottom_categories = sorted_categories[-2:]
-    
-    # More detailed template-based feedback for top category
-    top_feedback_templates = {
-        "Technical Skills": [
-            "demonstrates strong technical skills with proficiency in programming languages and technical tools that Google values.",
-            "shows excellent technical capabilities that align well with Google's engineering requirements.",
-            "possesses the technical expertise needed for Google's development environment."
-        ],
-        "Advanced Technologies": [
-            "has valuable experience with cutting-edge technologies that Google prioritizes in its innovation efforts.",
-            "demonstrates knowledge in advanced technological areas that align with Google's future direction.",
-            "shows proficiency in modern technologies that Google uses in its products and services."
-        ],
-        "Problem Solving": [
-            "exhibits strong problem-solving abilities which are fundamental to Google's engineering culture.",
-            "demonstrates analytical thinking and problem-solving skills that Google seeks in candidates.",
-            "shows the problem-solving aptitude that would be valuable in Google's collaborative environment."
-        ],
-        "Innovation & Creativity": [
-            "shows the creative thinking and innovation mindset that Google values in its workforce.",
-            "demonstrates the innovative approach that would fit well with Google's creative culture.",
-            "exhibits creativity that could contribute to Google's product development process."
-        ],
-        "Teamwork & Leadership": [
-            "demonstrates leadership qualities and teamwork skills that Google looks for in potential employees.",
-            "shows collaborative abilities that would integrate well with Google's team-based structure.",
-            "exhibits the interpersonal skills needed to thrive in Google's collaborative environment."
-        ]
-    }
-    
-    # More detailed template-based feedback for bottom categories
-    bottom_feedback_templates = {
-        "Technical Skills": [
-            "should strengthen their technical skills, particularly in programming languages commonly used at Google such as Python, Java, or C++.",
-            "would benefit from developing more depth in technical tools and programming capabilities to meet Google's standards.",
-            "needs to enhance their technical expertise to better align with Google's engineering requirements."
-        ],
-        "Advanced Technologies": [
-            "would benefit from gaining more experience with AI, machine learning, or cloud technologies that Google prioritizes.",
-            "should develop more expertise in advanced technologies like machine learning or data science to increase their value to Google.",
-            "needs more exposure to the cutting-edge technologies that drive Google's innovation."
-        ],
-        "Problem Solving": [
-            "should strengthen their problem-solving abilities, particularly with algorithms and data structures that are crucial for Google interviews.",
-            "would benefit from developing stronger analytical and problem-solving skills to match Google's expectations.",
-            "needs to improve their approach to complex problem-solving to meet Google's standards."
-        ],
-        "Innovation & Creativity": [
-            "could develop a more innovative mindset to better align with Google's creative culture.",
-            "should work on demonstrating more creative thinking in their approach to match Google's innovation focus.",
-            "would benefit from cultivating more creativity and out-of-the-box thinking valued at Google."
-        ],
-        "Teamwork & Leadership": [
-            "should focus on developing stronger leadership and teamwork skills to thrive in Google's collaborative environment.",
-            "would benefit from more experience in collaborative settings to match Google's team-oriented culture.",
-            "needs to strengthen their interpersonal and leadership capabilities to align with Google's expectations."
-        ]
-    }
-    
-    # Generate feedback with more detailed templates
-    import random
-    
-    # Get top strength feedback
-    top_category = top_categories[0][0]
-    top_score = top_categories[0][1]
-    top_feedback = random.choice(top_feedback_templates.get(top_category, ["shows notable skills"]))
-    
-    # Get improvement area feedback
-    bottom_category = bottom_categories[0][0]
-    bottom_score = bottom_categories[0][1]
-    bottom_feedback = random.choice(bottom_feedback_templates.get(bottom_category, ["could improve their skills"]))
-    
-    # Construct full feedback
-    feedback = f"This candidate {top_feedback} "
-    
-    # Add second strength if it's good
-    if top_categories[1][1] >= 0.6:
-        second_top = top_categories[1][0]
-        second_top_feedback = random.choice(top_feedback_templates.get(second_top, ["has good abilities"]))
-        feedback += f"The candidate also {second_top_feedback} "
-    
-    # Add improvement feedback
-    feedback += f"However, the candidate {bottom_feedback} "
-    
-    # Add conclusion based on overall score
-    overall_score = sum(score * weight for (category, score), weight in 
-                       zip(category_scores.items(), [0.35, 0.25, 0.20, 0.10, 0.10]))
-    
-    if overall_score >= 0.75:
-        feedback += "Overall, this candidate shows strong potential for success at Google."
-    elif overall_score >= 0.6:
-        feedback += "With these improvements, the candidate could be a good fit for Google."
-    else:
-        feedback += "The candidate would need significant development to meet Google's standards."
-    
-    execution_time = time.time() - start_time
-    
-    return feedback, execution_time
-
-#####################################
-# Function: Generate Aspect-Based Feedback with T5 - Enhanced with Fallback
-#####################################
-@st.cache_data(show_spinner=False)
-def generate_aspect_feedback(candidate_summary, category_scores, _evaluator=None):
-    """
-    Use T5-small model to generate feedback with robust fallback to template-based feedback.
-    """
-    start_time = time.time()
-    
-    evaluator = _evaluator or models['evaluator']
-    
-    # Sort categories by score
-    sorted_categories = sorted(category_scores.items(), key=lambda x: x[1], reverse=True)
-    top_categories = sorted_categories[:2]
-    bottom_categories = sorted_categories[-2:]
-    
-    # Create a more explicit prompt for T5
+    # Carefully craft a prompt that won't be repeated in the output
     prompt = f"""
-Generate a complete paragraph evaluating a job candidate for Google.
-The candidate is strong in: {', '.join([cat for cat, _ in top_categories])}.
-The candidate needs improvement in: {', '.join([cat for cat, _ in bottom_categories])}.
-Start with 'This candidate' and write at least 3 sentences about their fit for Google.
+Google hiring analysis:
+Resume summary: {resume_summary}
+
+Google requirements: {GOOGLE_DESCRIPTION}
+
+Evaluate this candidate for Google. Consider technical skills, experience, and culture fit. 
+Write a paragraph starting with "This candidate" describing their fit for Google.
+Include strengths, weaknesses, and a match percentage (0-100%).
 """
     
-    # Generate focused feedback with error handling
     try:
-        feedback_result = evaluator(prompt, max_length=200, do_sample=False)
-        feedback = feedback_result[0]['generated_text']
+        # Generate the assessment
+        response = models['evaluator'](
+            prompt, 
+            max_length=300,
+            do_sample=True,
+            temperature=0.7
+        )
+        
+        assessment = response[0]['generated_text']
+        
+        # Clean up assessment to prevent instruction leakage
+        assessment = assessment.replace("Google hiring analysis:", "")
+        assessment = assessment.replace("Resume summary:", "")
+        assessment = assessment.replace("Google requirements:", "")
+        assessment = assessment.replace("Evaluate this candidate for Google.", "")
+        assessment = assessment.replace("Write a paragraph", "")
+        assessment = assessment.replace("starting with", "")
+        assessment = assessment.replace("Consider technical skills, experience, and culture fit.", "")
+        assessment = assessment.replace("Include strengths, weaknesses, and a match percentage", "")
+        
+        # Make sure it starts properly
+        if not assessment.strip().startswith("This candidate"):
+            assessment = "This candidate " + assessment.strip()
+        
+        # Extract match percentage if present
+        match_percentage = None
+        percentage_pattern = r'(\d{1,3})%'
+        match = re.search(percentage_pattern, assessment)
+        if match:
+            match_percentage = int(match.group(1))
+            # Ensure it's in valid range
+            match_percentage = min(100, max(0, match_percentage))
+        
+        # If no percentage was found in the text, default to 50%
+        if match_percentage is None:
+            match_percentage = 50
+            # Add a percentage to the end of assessment
+            assessment += f" Overall match: {match_percentage}%."
         
-        # Validate the response - ensure it's not empty or too short
-        if len(feedback.strip()) < 20 or feedback.strip() == "This candidate" or feedback.strip() == "This candidate.":
-            # Fall back to template-based if T5 output is too short
-            return generate_template_feedback(category_scores)
-            
-        # Ensure third-person tone
-        if not any(feedback.lower().startswith(start) for start in ["the candidate", "this candidate"]):
-            feedback = f"This candidate {feedback}"
     except Exception as e:
-        # Fall back to template if there's an error
-        print(f"Error generating T5 feedback: {e}")
-        return generate_template_feedback(category_scores)
+        # Fallback if model fails
+        assessment = "This candidate's resume has been analyzed. Based on skills and experience, they may have some relevant qualities for Google, but a detailed assessment couldn't be generated. Please review the resume summary manually."
+        match_percentage = 50
     
     execution_time = time.time() - start_time
     
-    return feedback, execution_time
+    return assessment, match_percentage, execution_time
 
 #####################################
-# Main Streamlit Interface - with Progress Reporting
+# Main Streamlit Interface
 #####################################
 st.title("Google Resume Match Analyzer")
 st.markdown(
@@ -560,7 +389,7 @@ st.markdown(
 Upload your resume file in **.docx**, **.doc**, or **.txt** format to see how well you match with Google's hiring requirements. The app performs the following tasks:
 1. Extracts text from your resume.
 2. Uses AI to generate a structured candidate summary.
-3. Evaluates your fit for Google across key hiring criteria with a detailed score breakdown.
+3. Analyzes how well your profile fits Google's requirements.
 """
 )
 
@@ -571,10 +400,6 @@ with st.expander("Google's Requirements", expanded=False):
 # File uploader
 uploaded_file = st.file_uploader("Upload your resume (.docx, .doc, or .txt)", type=["docx", "doc", "txt"])
 
-# Add a checkbox for template-based feedback (faster)
-use_template_feedback = st.checkbox("Use faster template-based feedback (no ML)", value=False, 
-                                   help="Generate feedback using pre-defined templates instead of T5 model")
-
 # Process button with optimized flow
 if uploaded_file is not None and st.button("Analyze My Google Fit"):
     # Create a placeholder for the progress bar
@@ -599,18 +424,9 @@ if uploaded_file is not None and st.button("Analyze My Google Fit"):
         st.markdown(summary)
         st.info(f"Summary generated in {summarization_time:.2f} seconds")
         
-        # Step 3: Calculate scores and generate feedback
-        status_text.text("Step 3/3: Calculating Google fit scores...")
-        overall_score, category_scores, score_breakdown = calculate_google_match_score(summary)
-        
-        # Choose feedback generation method based on checkbox
-        if use_template_feedback:
-            feedback, feedback_time = generate_template_feedback(category_scores)
-        else:
-            feedback, feedback_time = generate_aspect_feedback(
-                summary, category_scores, _evaluator=models['evaluator']
-            )
-            
+        # Step 3: Generate Google fit assessment
+        status_text.text("Step 3/3: Evaluating Google fit...")
+        assessment, match_percentage, assessment_time = analyze_google_fit(summary)
         progress_bar.progress(100)
         
         # Clear status messages
@@ -619,50 +435,40 @@ if uploaded_file is not None and st.button("Analyze My Google Fit"):
         # Display Google fit results
         st.subheader("Google Fit Assessment")
         
-        # Display overall score with appropriate color and emoji
-        score_percent = int(overall_score * 100)
-        if overall_score >= 0.85:
-            st.success(f"**Overall Google Match Score:** {score_percent}% 🌟")
-        elif overall_score >= 0.70:
-            st.success(f"**Overall Google Match Score:** {score_percent}% ✅")
-        elif overall_score >= 0.50:
-            st.warning(f"**Overall Google Match Score:** {score_percent}% ⚠️")
+        # Display match percentage with appropriate color and emoji
+        if match_percentage >= 85:
+            st.success(f"**Overall Google Match Score:** {match_percentage}% 🌟")
+        elif match_percentage >= 70:
+            st.success(f"**Overall Google Match Score:** {match_percentage}% ✅")
+        elif match_percentage >= 50:
+            st.warning(f"**Overall Google Match Score:** {match_percentage}% ⚠️")
         else:
-            st.error(f"**Overall Google Match Score:** {score_percent}% 🔍")
-        
-        # Display score breakdown
-        st.markdown("### Score Calculation")
-        st.markdown(score_breakdown)
+            st.error(f"**Overall Google Match Score:** {match_percentage}% 🔍")
         
-        # Display focused feedback
+        # Display assessment
         st.markdown("### Expert Assessment")
-        st.markdown(feedback)
+        st.markdown(assessment)
         
-        st.info(f"Assessment completed in {feedback_time:.2f} seconds")
+        st.info(f"Assessment completed in {assessment_time:.2f} seconds")
         
-        # Add potential next steps based on the score
+        # Add potential next steps based on the match percentage
         st.subheader("Recommended Next Steps")
         
-        # Find the weakest categories
-        weakest_categories = sorted(category_scores.items(), key=lambda x: x[1])[:2]
-        
-        if overall_score >= 0.80:
+        if match_percentage >= 80:
             st.markdown("""
             - Consider applying for positions at Google that match your experience
             - Prepare for technical interviews by practicing algorithms and system design
             - Review Google's interview process and STAR method for behavioral questions
             """)
-        elif overall_score >= 0.60:
-            improvement_areas = ", ".join([cat for cat, _ in weakest_categories])
-            st.markdown(f"""
-            - Focus on strengthening these areas: {improvement_areas}
+        elif match_percentage >= 60:
+            st.markdown("""
+            - Focus on strengthening your technical skills and advanced technology knowledge
             - Work on projects that demonstrate your skills in Google's key technology areas
             - Consider taking additional courses in algorithms, system design, or other Google focus areas
             """)
         else:
-            improvement_areas = ", ".join([cat for cat, _ in weakest_categories])
-            st.markdown(f"""
-            - Build experience in these critical areas: {improvement_areas}
+            st.markdown("""
+            - Build more relevant experience in software development or technical areas
             - Develop projects showcasing problem-solving abilities and technical skills
             - Consider gaining more experience before applying, or target specific Google roles that better match your profile
             """)