Update app.py

app.py

@@ -1,15 +1,45 @@
 import os
 import tempfile
 import re
-import time
 import streamlit as st
 import docx
 import textract
 from sentence_transformers import SentenceTransformer, util
 from transformers import pipeline
+import threading
 
 #####################################
-# Function: Extract Text from File
+# Load Models - Optimized with Threading
+#####################################
+@st.cache_resource(show_spinner=False)
+def load_models():
+    """
+    Load all models in parallel using threading to speed up initialization
+    """
+    models = {}
+    
+    def load_summarizer_thread():
+        models['summarizer'] = pipeline("summarization", model="google/pegasus-xsum", device=0 if st.session_state.get('use_gpu', False) else -1)
+    
+    def load_sbert_thread():
+        models['sbert'] = SentenceTransformer("sentence-transformers/all-MiniLM-L6-v2", device='cuda' if st.session_state.get('use_gpu', False) else 'cpu')
+    
+    # Start threads to load models in parallel
+    threads = [
+        threading.Thread(target=load_summarizer_thread),
+        threading.Thread(target=load_sbert_thread)
+    ]
+    
+    for thread in threads:
+        thread.start()
+    
+    for thread in threads:
+        thread.join()
+    
+    return models
+
+#####################################
+# Function: Extract Text from File - Optimized
 #####################################
 def extract_text_from_file(file_obj):
     """
@@ -23,67 +53,70 @@ def extract_text_from_file(file_obj):
     if ext == ".docx":
         try:
             document = docx.Document(file_obj)
-            text = "\n".join([para.text for para in document.paragraphs])
+            # Use a list comprehension and join for better performance
+            text = "\n".join(para.text for para in document.paragraphs if para.text.strip())
         except Exception as e:
             text = f"Error processing DOCX file: {e}"
     elif ext == ".doc":
         try:
-            # textract requires a file name; save the file temporarily.
+            # Use a context manager for better file handling
             with tempfile.NamedTemporaryFile(delete=False, suffix=".doc") as tmp:
                 tmp.write(file_obj.read())
-                tmp.flush()
                 tmp_filename = tmp.name
             text = textract.process(tmp_filename).decode("utf-8")
+            # Clean up the temporary file immediately
+            os.unlink(tmp_filename)
         except Exception as e:
             text = f"Error processing DOC file: {e}"
-        finally:
-            try:
-                os.remove(tmp_filename)
-            except Exception:
-                pass
     else:
         text = "Unsupported file type."
     return text
 
 #####################################
-# Function: Summarize Resume Text using a Transformer Model
+# Function: Summarize Resume Text - Optimized
 #####################################
-@st.cache_resource(show_spinner=False)
-def load_summarizer():
-    """
-    Loads the summarization pipeline using a transformer model.
-    We use the model "google/pegasus-xsum" for summarization.
-    """
-    return pipeline("summarization", model="google/pegasus-xsum")
-
-def summarize_resume_text(resume_text):
+def summarize_resume_text(resume_text, models):
     """
-    Generates a concise summary of the resume text using the summarization model.
-    If the resume text is very long, we trim it to avoid hitting the model's maximum input size.
+    Generates a concise summary of the resume text using the pre-loaded summarization model.
     """
-    summarizer = load_summarizer()
+    summarizer = models['summarizer']
 
-    # Trim resume_text if it's too long
-    max_input_length = 1024  # adjust as needed
+    # Optimize text processing - only use essential text
+    # Break text into chunks and summarize important parts
+    max_input_length = 1024  # PEGASUS-XSUM limit
+    
     if len(resume_text) > max_input_length:
-        st.info(f"Resume text is longer than {max_input_length} characters. Trimming text for summarization...")
-        resume_text = resume_text[:max_input_length]
+        # Instead of simple trimming, extract key sections
+        chunks = [resume_text[i:i+max_input_length] for i in range(0, min(len(resume_text), 3*max_input_length), max_input_length)]
+        summaries = []
+        
+        for chunk in chunks:
+            chunk_summary = summarizer(chunk, max_length=100, min_length=30, do_sample=False)[0]['summary_text']
+            summaries.append(chunk_summary)
+        
+        candidate_summary = " ".join(summaries)
+        # Summarize again if combined summary is too long
+        if len(candidate_summary) > max_input_length:
+            candidate_summary = summarizer(candidate_summary[:max_input_length], max_length=150, min_length=40, do_sample=False)[0]['summary_text']
+    else:
+        candidate_summary = summarizer(resume_text, max_length=150, min_length=40, do_sample=False)[0]['summary_text']
     
-    # Generate summary
-    summary_result = summarizer(resume_text, max_length=150, min_length=40, do_sample=False)
-    candidate_summary = summary_result[0]['summary_text']
     return candidate_summary
 
 #####################################
-# Function: Compare Candidate Summary to Company Prompt
+# Function: Compare Candidate Summary to Company Prompt - Optimized
 #####################################
-def compute_suitability(candidate_summary, company_prompt, model):
+def compute_suitability(candidate_summary, company_prompt, models):
     """
     Compute the cosine similarity between candidate summary and company prompt embeddings.
     Returns a score in the range [0, 1].
     """
-    candidate_embed = model.encode(candidate_summary, convert_to_tensor=True)
-    company_embed = model.encode(company_prompt, convert_to_tensor=True)
+    sbert_model = models['sbert']
+    
+    # Encode texts in parallel (if supported by model)
+    embeddings = sbert_model.encode([candidate_summary, company_prompt], convert_to_tensor=True)
+    candidate_embed, company_embed = embeddings[0], embeddings[1]
+    
     cosine_sim = util.cos_sim(candidate_embed, company_embed)
     score = float(cosine_sim.item())
     return score
@@ -91,95 +124,128 @@ def compute_suitability(candidate_summary, company_prompt, model):
 #####################################
 # Main Resume Processing Logic
 #####################################
-def process_resume(file_obj):
+def process_resume(file_obj, models):
     """
     Extracts text from the uploaded file and then generates a summary
     using a text summarization model.
     """
-    st.info("Extracting text from resume...")
-    resume_text = extract_text_from_file(file_obj)
+    with st.status("Processing resume...") as status:
+        status.update(label="Extracting text from resume...")
+        resume_text = extract_text_from_file(file_obj)
+        
+        # Check if resume_text is valid
+        if not resume_text or resume_text.strip() == "":
+            status.update(label="Error: No text could be extracted", state="error")
+            return ""
+        
+        status.update(label=f"Extracted {len(resume_text)} characters. Generating summary...")
+        
+        candidate_summary = summarize_resume_text(resume_text, models)
+        status.update(label="Processing complete!", state="complete")
     
-    # Check if resume_text is valid
-    if not resume_text or resume_text.strip() == "":
-        st.error("No text could be extracted. Please check your resume file!")
-        return ""
-    
-    st.info(f"Text extraction complete. Extracted {len(resume_text)} characters.")
-    time.sleep(0.5)  # slight delay to let the user read the info message
-    
-    st.info("Generating candidate summary, please wait...")
-    candidate_summary = summarize_resume_text(resume_text)
-    st.info("Candidate summary generated.")
     return candidate_summary
 
 #####################################
-# Load the Sentence-BERT Model (Semantic Similarity Model)
-#####################################
-@st.cache_resource(show_spinner=False)
-def load_sbert_model():
-    # This loads the Sentence-BERT model "all-MiniLM-L6-v2"
-    return SentenceTransformer("sentence-transformers/all-MiniLM-L6-v2")
-
-# Load Sentence-BERT model for computing semantic similarity.
-sbert_model = load_sbert_model()
-
-#####################################
-# Streamlit Interface
+# Streamlit Interface - Optimized
 #####################################
-st.title("Resume Analyzer and Company Suitability Checker")
-st.markdown(
+def main():
+    st.set_page_config(page_title="Resume Analyzer", layout="wide")
+    
+    # Initialize session state for GPU usage
+    if 'use_gpu' not in st.session_state:
+        st.session_state.use_gpu = False
+    
+    # Only show sidebar settings on first run
+    with st.sidebar:
+        st.title("Settings")
+        if st.checkbox("Use GPU (if available)", value=st.session_state.use_gpu):
+            st.session_state.use_gpu = True
+        else:
+            st.session_state.use_gpu = False
+        
+        st.info("Using GPU can significantly speed up model inference if available")
+    
+    # Load models - this happens only once due to caching
+    with st.spinner("Loading AI models..."):
+        models = load_models()
+    
+    st.title("Resume Analyzer and Company Suitability Checker")
+    st.markdown(
+        """
+    Upload your resume file in **.doc** or **.docx** 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.
     """
-Upload your resume file in **.doc** or **.docx** format. The app performs the following tasks:
-1. Extracts text from the resume.
-2. Uses a transformer-based text summarization model (**google/pegasus-xsum**) to generate a concise candidate summary.
-3. Compares the candidate summary with a company profile (using Sentence-BERT) to produce a suitability score.
-"""
-)
-
-# File uploader for resume
-uploaded_file = st.file_uploader("Upload Resume", type=["doc", "docx"])
+    )
 
-# Button to process the resume and store the summary in session state.
-if st.button("Process Resume"):
-    if uploaded_file is None:
-        st.error("Please upload a resume file first.")
-    else:
-        with st.spinner("Processing resume..."):
-            candidate_summary = process_resume(uploaded_file)
-            if candidate_summary:  # only if summary is generated
-                st.session_state["candidate_summary"] = candidate_summary
-        if candidate_summary:
+    # Use columns for better layout
+    col1, col2 = st.columns([1, 1])
+    
+    with col1:
+        # File uploader for resume
+        uploaded_file = st.file_uploader("Upload Resume", type=["doc", "docx"])
+        
+        # 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:
+                candidate_summary = process_resume(uploaded_file, models)
+                if candidate_summary:  # only if summary is generated
+                    st.session_state["candidate_summary"] = candidate_summary
+        
+        # Display candidate summary if available
+        if "candidate_summary" in st.session_state:
             st.subheader("Candidate Summary")
-            st.markdown(candidate_summary)
+            st.markdown(st.session_state["candidate_summary"])
+    
+    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."
+        )
 
-# 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."
-)
+        # Company prompt text area.
+        company_prompt = st.text_area(
+            "Enter company details:",
+            value=default_company_prompt,
+            height=150,
+        )
 
-# Company prompt text area.
-company_prompt = st.text_area(
-    "Enter company details:",
-    value=default_company_prompt,
-    height=150,
-)
+        # 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!")
+            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 score with a progress bar for visual feedback
+                    st.success(f"Suitability Score: {score:.2f} (range 0 to 1)")
+                    st.progress(score)
+                    
+                    # 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.")
+                    else:
+                        st.info("Low match. Your profile may need significant adjustments to better align with this company.")
 
-# Button to compute the suitability score.
-if st.button("Compute Suitability Score"):
-    if "candidate_summary" not in st.session_state:
-        st.error("Please process the resume first!")
-    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, sbert_model)
-            st.success(f"Suitability Score: {score:.2f} (range 0 to 1)")
+
+if __name__ == "__main__":
+    main()