Update app.py

app.py

@@ -3,8 +3,6 @@ import io
 import streamlit as st
 import docx
 from transformers import pipeline
-import numpy as np
-from scipy.spatial.distance import cosine
 import time
 
 # Set page title and hide sidebar
@@ -30,10 +28,10 @@ def load_models():
     with st.spinner("Loading AI models... This may take a minute on first run."):
         models = {}
         # Load summarization model
-        models['summarizer'] = pipeline("summarization", model="marianna13/flan-t5-base-summarization")
+        models['summarizer'] = pipeline("summarization", model="google/pegasus-xsum")
         
-        # Load feature extraction model for similarity
-        models['feature_extractor'] = pipeline("feature-extraction", model="bert-base-uncased")
+        # Load text generation model for suitability assessment
+        models['text_generator'] = pipeline("text-generation", model="gpt2")  # You can use different models
         
         return models
 
@@ -101,31 +99,64 @@ def summarize_resume_text(resume_text, models):
     return candidate_summary, execution_time
 
 #####################################
-# Function: Compare Candidate Summary to Company Prompt
+# Function: Generate Suitability Assessment
 #####################################
-def compute_suitability(candidate_summary, company_prompt, models):
+def generate_suitability_assessment(candidate_summary, company_prompt, models):
     """
-    Compute the similarity between candidate summary and company prompt.
-    Returns a score in the range [0, 1] and execution time.
+    Generate a suitability assessment using text generation instead of similarity.
+    Returns the generated assessment text and execution time.
     """
     start_time = time.time()
     
-    feature_extractor = models['feature_extractor']
+    text_generator = models['text_generator']
     
-    # Extract features (embeddings)
-    candidate_features = feature_extractor(candidate_summary)
-    company_features = feature_extractor(company_prompt)
+    # Create a prompt for the text generation model
+    prompt = f"""
+Resume Summary: {candidate_summary}
+
+Company Description: {company_prompt}
+
+Suitability Assessment:
+This candidate is a"""
+    
+    # Generate text
+    max_length = 80 + len(prompt.split())  # Limit output length
+    generated_text = text_generator(
+        prompt, 
+        max_length=max_length,
+        num_return_sequences=1,
+        temperature=0.7,
+        top_p=0.9,
+        do_sample=True
+    )[0]['generated_text']
+    
+    # Extract only the assessment part (after the prompt)
+    assessment = generated_text[len(prompt):].strip()
+    
+    # Determine a numerical score from the text
+    # This is a simplified approach - we're looking for positive and negative words
+    positive_words = ['excellent', 'perfect', 'great', 'good', 'strong', 'ideal', 'qualified']
+    negative_words = ['poor', 'weak', 'bad', 'insufficient', 'inadequate', 'not a good']
     
-    # Convert to numpy arrays and flatten if needed
-    candidate_vec = np.mean(np.array(candidate_features[0]), axis=0)
-    company_vec = np.mean(np.array(company_features[0]), axis=0)
+    assessment_lower = assessment.lower()
     
-    # Compute cosine similarity (1 - cosine distance)
-    similarity = 1 - cosine(candidate_vec, company_vec)
+    # Simple heuristic for score estimation
+    score = 0.5  # Default middle score
+    
+    for word in positive_words:
+        if word in assessment_lower:
+            score += 0.1  # Increase score for positive words
+            
+    for word in negative_words:
+        if word in assessment_lower:
+            score -= 0.1  # Decrease score for negative words
+    
+    # Clamp the score between 0 and 1
+    score = max(0.1, min(0.9, score))
     
     execution_time = time.time() - start_time
     
-    return similarity, execution_time
+    return assessment, score, execution_time
 
 #####################################
 # Main Streamlit Interface
@@ -136,7 +167,7 @@ st.markdown(
 Upload your resume file in **.docx** or **.txt** format. The app performs the following tasks:
 1. Extracts text from the resume.
 2. Uses a transformer-based model to generate a concise candidate summary.
-3. Compares the candidate summary with a company profile to produce a suitability score.
+3. Uses text generation to assess the candidate's suitability for the company.
 """
 )
 
@@ -167,21 +198,21 @@ if uploaded_file is not None and company_prompt and st.button("Analyze Resume"):
             st.write(summary)
             st.info(f"Summarization completed in {summarization_time:.2f} seconds")
             
-            # Only compute similarity if company description is provided
-            if company_prompt:
-                similarity_score, similarity_time = compute_suitability(summary, company_prompt, models)
-                
-                # Display similarity score
-                st.subheader("Suitability Assessment")
-                st.markdown(f"**Matching Score:** {similarity_score:.2%}")
-                st.info(f"Similarity computation completed in {similarity_time:.2f} seconds")
-                
-                # Provide interpretation
-                if similarity_score >= 0.85:
-                    st.success("Excellent match! This candidate's profile is strongly aligned with the company requirements.")
-                elif similarity_score >= 0.70:
-                    st.success("Good match! This candidate shows strong potential for the position.")
-                elif similarity_score >= 0.50:
-                    st.warning("Moderate match. The candidate meets some requirements but there may be gaps.")
-                else:
-                    st.error("Low match. The candidate's profile may not align well with the requirements.")
+            # Generate suitability assessment with text generation
+            assessment, estimated_score, generation_time = generate_suitability_assessment(summary, company_prompt, models)
+            
+            # Display assessment
+            st.subheader("Suitability Assessment")
+            st.write(assessment)
+            st.markdown(f"**Estimated Matching Score:** {estimated_score:.2%}")
+            st.info(f"Assessment generated in {generation_time:.2f} seconds")
+            
+            # Provide interpretation based on estimated score
+            if estimated_score >= 0.85:
+                st.success("Excellent match! This candidate's profile is strongly aligned with the company requirements.")
+            elif estimated_score >= 0.70:
+                st.success("Good match! This candidate shows strong potential for the position.")
+            elif estimated_score >= 0.50:
+                st.warning("Moderate match. The candidate meets some requirements but there may be gaps.")
+            else:
+                st.error("Low match. The candidate's profile may not align well with the requirements.")