Update app.py

app.py

@@ -4,6 +4,9 @@ import streamlit as st
 import docx
 import textract
 from transformers import pipeline
+import numpy as np
+from scipy.spatial.distance import cosine
+import time
 
 # Set page title
 st.set_page_config(page_title="Resume Analyzer and Company Suitability Checker")
@@ -12,14 +15,16 @@ st.set_page_config(page_title="Resume Analyzer and Company Suitability Checker")
 # Preload Models
 #####################################
 @st.cache_resource(show_spinner=True)
-def load_models():
-    """Load all models at startup"""
+def load_models(summarization_model="google/pegasus-xsum", similarity_model="sentence-transformers/all-MiniLM-L6-v2"):
+    """Load models at startup"""
     with st.spinner("Loading AI models... This may take a minute on first run."):
         models = {}
         # Load summarization model
-        models['summarizer'] = pipeline("summarization", model="google/pegasus-xsum")
-        # Load similarity model
-        models['similarity'] = pipeline("sentence-similarity", model="sentence-transformers/all-MiniLM-L6-v2")
+        models['summarizer'] = pipeline("summarization", model=summarization_model)
+        
+        # Load feature extraction model for similarity
+        models['feature_extractor'] = pipeline("feature-extraction", model=similarity_model)
+        
         return models
 
 # Preload models immediately when app starts
@@ -61,12 +66,14 @@ def extract_text_from_file(file_obj):
 #####################################
 def summarize_resume_text(resume_text, models):
     """
-    Generates a concise summary of the resume text using the summarization model.
+    Generates a concise summary of the resume text using the selected summarization model.
     """
+    start_time = time.time()
+    
     summarizer = models['summarizer']
     
     # Handle long text
-    max_input_length = 1024  # PEGASUS-XSUM limit
+    max_input_length = 1024  # Model limit
     
     if len(resume_text) > max_input_length:
         # Process in chunks if text is too long
@@ -83,7 +90,9 @@ def summarize_resume_text(resume_text, models):
     else:
         candidate_summary = summarizer(resume_text, max_length=150, min_length=40, do_sample=False)[0]['summary_text']
     
-    return candidate_summary
+    execution_time = time.time() - start_time
+    
+    return candidate_summary, execution_time
 
 #####################################
 # Function: Compare Candidate Summary to Company Prompt
@@ -91,22 +100,29 @@ def summarize_resume_text(resume_text, models):
 def compute_suitability(candidate_summary, company_prompt, models):
     """
     Compute the similarity between candidate summary and company prompt.
-    Returns a score in the range [0, 1].
+    Returns a score in the range [0, 1] and execution time.
     """
-    similarity_pipeline = models['similarity']
+    start_time = time.time()
+    
+    feature_extractor = models['feature_extractor']
     
-    # The pipeline expects a document and a list of candidates to compare to
-    result = similarity_pipeline(
-        candidate_summary,
-        [company_prompt]
-    )
+    # Extract features (embeddings)
+    candidate_features = feature_extractor(candidate_summary)
+    company_features = feature_extractor(company_prompt)
     
-    # Extract the similarity score from the result
-    score = result[0]['score']
-    return score
+    # 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)
+    
+    # Compute cosine similarity (1 - cosine distance)
+    similarity = 1 - cosine(candidate_vec, company_vec)
+    
+    execution_time = time.time() - start_time
+    
+    return similarity, execution_time
 
 #####################################
-# Streamlit Interface
+# Main Streamlit Interface
 #####################################
 st.title("Resume Analyzer and Company Suitability Checker")
 st.markdown(
@@ -118,80 +134,77 @@ Upload your resume file in **.doc** or **.docx** format. The app performs the fo
 """
 )
 
-# Use two columns with equal width
-col1, col2 = st.columns(2)
+# File uploader
+uploaded_file = st.file_uploader("Upload your resume (.doc or .docx)", type=["doc", "docx"])
 
-with col1:
-    # File uploader for resume
-    uploaded_file = st.file_uploader("Upload Resume", type=["doc", "docx"])
-    
-    if uploaded_file is not None:
-        st.write(f"{uploaded_file.name}  {uploaded_file.size/1024:.1f}KB")
-    
-    # Button to process the resume
-    if st.button("Process Resume", type="primary", use_container_width=True):
-        if uploaded_file is None:
-            st.error("Please upload a resume file first.")
-        else:
-            with st.status("Processing resume...") as status:
-                status.update(label="Extracting text from resume...")
-                resume_text = extract_text_from_file(uploaded_file)
-                
-                if not resume_text or resume_text.strip() == "":
-                    status.update(label="Error: No text could be extracted", state="error")
-                else:
-                    status.update(label=f"Extracted {len(resume_text)} characters. Generating summary...")
-                    candidate_summary = summarize_resume_text(resume_text, models)
-                    st.session_state["candidate_summary"] = candidate_summary
-                    status.update(label="Processing complete!", state="complete")
-    
-    # Display candidate summary if available
-    if "candidate_summary" in st.session_state:
-        st.subheader("Candidate Summary")
-        st.markdown(st.session_state["candidate_summary"])
+# Company description text area
+company_prompt = st.text_area(
+    "Enter the company description or job requirements:",
+    height=150,
+    help="Enter a detailed description of the company culture, role requirements, and desired skills.",
+)
 
-with col2:
-    # Pre-defined company prompt for Google LLC.
-    default_company_prompt = (
-        "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."
-    )
+# Show model selection in sidebar
+st.sidebar.header("Model Settings")
 
-    # Company prompt text area.
-    company_prompt = st.text_area(
-        "Enter company details:",
-        value=default_company_prompt,
-        height=150,
-    )
+# Model dropdowns - we're now only allowing one model of each type to be selected
+summarization_model = st.sidebar.selectbox(
+    "Summarization Model",
+    ["google/pegasus-xsum", "facebook/bart-large-cnn", "t5-small", "sshleifer/distilbart-cnn-12-6"],
+    index=0,
+    help="Select the model to use for summarizing the resume text."
+)
+
+similarity_model = st.sidebar.selectbox(
+    "Similarity Model",
+    ["sentence-transformers/all-MiniLM-L6-v2", "sentence-transformers/all-mpnet-base-v2", 
+     "sentence-transformers/paraphrase-MiniLM-L3-v2", "sentence-transformers/multi-qa-mpnet-base-dot-v1"],
+    index=0,
+    help="Select the model to use for comparing candidate summary with company profile."
+)
 
-    # Button to compute the suitability score.
-    if st.button("Compute Suitability Score", type="primary", use_container_width=True):
-        if "candidate_summary" not in st.session_state:
-            st.error("Please process the resume first!")
+# Reload models if changed
+if st.sidebar.button("Reload Models"):
+    st.cache_resource.clear()
+    models = load_models(summarization_model, similarity_model)
+    st.sidebar.success("Models reloaded successfully!")
+
+# Process button
+if uploaded_file is not None and company_prompt and st.button("Analyze Resume"):
+    with st.spinner("Processing..."):
+        # Extract text from resume
+        resume_text = extract_text_from_file(uploaded_file)
+        
+        if resume_text.startswith("Error") or resume_text == "Unsupported file type.":
+            st.error(resume_text)
         else:
-            candidate_summary = st.session_state["candidate_summary"]
-            if candidate_summary.strip() == "":
-                st.error("Candidate summary is empty; please check your resume file.")
-            elif company_prompt.strip() == "":
-                st.error("Please enter the company information.")
-            else:
-                with st.spinner("Computing suitability score..."):
-                    score = compute_suitability(candidate_summary, company_prompt, models)
+            # Display extracted text
+            with st.expander("Extracted Text"):
+                st.text(resume_text)
+            
+            # Generate summary
+            summary, summarization_time = summarize_resume_text(resume_text, models)
+            
+            # Display summary
+            st.subheader("Candidate Summary")
+            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 score with a progress bar for visual feedback
-                st.success(f"Suitability Score: {score:.2f} (range 0 to 1)")
-                st.progress(score)
+                # 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")
                 
-                # Add interpretation of score
-                if score > 0.75:
-                    st.info("Excellent match! Your profile appears very well suited for this company.")
-                elif score > 0.5:
-                    st.info("Good match. Your profile aligns with many aspects of the company's requirements.")
-                elif score > 0.3:
-                    st.info("Moderate match. Consider highlighting more relevant skills or experience.")
+                # 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.info("Low match. Your profile may need significant adjustments to better align with this company.")
+                    st.error("Low match. The candidate's profile may not align well with the requirements.")