Update app.py

app.py

@@ -3,14 +3,26 @@ import re
 from datetime import datetime
 import PyPDF2
 import torch
-from transformers import AutoTokenizer, AutoModelForSequenceClassification
+from transformers import AutoTokenizer, AutoModelForSequenceClassification, AutoModelForSeq2SeqLM
 from sentence_transformers import SentenceTransformer, util
-from groq import Groq
 import gradio as gr
 
-# Set your API key for Groq
-os.environ["GROQ_API_KEY"] = "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"
-client = Groq(api_key=os.environ.get("GROQ_API_KEY"))
+# --- Model Loading with Caching --- #
+class ModelCache:
+    _tokenizers = {}
+    _models = {}
+
+    @classmethod
+    def get_model(cls, model_name):
+        if model_name not in cls._models:
+            cls._models[model_name] = AutoModelForSeq2SeqLM.from_pretrained(model_name)
+        return cls._models[model_name]
+
+    @classmethod
+    def get_tokenizer(cls, model_name):
+        if model_name not in cls._tokenizers:
+            cls._tokenizers[model_name] = AutoTokenizer.from_pretrained(model_name)
+        return cls._tokenizers[model_name]
 
 # --- PDF/Text Extraction Functions --- #
 def extract_text_from_file(file_path):
@@ -23,39 +35,45 @@ def extract_text_from_file(file_path):
         raise ValueError("Unsupported file type. Only PDF and TXT files are accepted.")
 
 def extract_text_from_pdf(pdf_file_path):
-    """Extracts text from a PDF file."""
+    """Extracts text from a PDF file with logging for page extraction."""
+    text = []
     with open(pdf_file_path, 'rb') as pdf_file:
         pdf_reader = PyPDF2.PdfReader(pdf_file)
-        text = ''.join(page.extract_text() for page in pdf_reader.pages if page.extract_text())
-    return text
+        for i, page in enumerate(pdf_reader.pages):
+            page_text = page.extract_text()
+            if page_text:
+                text.append(page_text)
+            else:
+                print(f"Warning: Page {i} could not be extracted.")
+    return ''.join(text)
 
 def extract_text_from_txt(txt_file_path):
     """Extracts text from a .txt file."""
     with open(txt_file_path, 'r', encoding='utf-8') as txt_file:
         return txt_file.read()
 
-# --- Skill Extraction with Llama Model --- #
-def extract_skills_llama(text):
-    """Extracts skills from the text using the Llama model via Groq API."""
-    try:
-        response = client.chat.completions.create(
-            messages=[{"role": "user", "content": f"Extract skills from the following text: {text}"}],
-            model="llama3-70b-8192",
-        )
-        skills = response.choices[0].message.content.split(', ')  # Expecting a comma-separated list
-        return skills
-    except Exception as e:
-        raise RuntimeError(f"Error during skill extraction: {e}")
+# --- Skill Extraction with Hugging Face --- #
+def extract_skills_huggingface(text):
+    """Extracts skills from the text using a Hugging Face model."""
+    model_name = "google/flan-t5-base"
+    tokenizer = ModelCache.get_tokenizer(model_name)
+    model = ModelCache.get_model(model_name)
+
+    input_text = f"Extract skills from the following text: {text}"
+    inputs = tokenizer(input_text, return_tensors="pt", padding=True, truncation=True)
+    outputs = model.generate(**inputs)
+    skills = tokenizer.decode(outputs[0], skip_special_tokens=True).split(', ')  # Expecting a comma-separated list
+    return skills
 
 # --- Job Description Processing Function --- #
 def process_job_description(text):
     """Extracts skills or relevant keywords from the job description."""
-    return extract_skills_llama(text)
+    return extract_skills_huggingface(text)
 
 # --- Qualification and Experience Extraction --- #
 def extract_qualifications(text):
     """Extracts qualifications from text (e.g., degrees, certifications)."""
-    qualifications = re.findall(r'(bachelor|master|phd|certified|degree)', text, re.IGNORECASE)
+    qualifications = re.findall(r'\b(bachelor|master|phd|certified|degree|diploma|qualification|certification)\b', text, re.IGNORECASE)
     return qualifications if qualifications else ['No specific qualifications found']
 
 def extract_experience(text):
@@ -65,121 +83,127 @@ def extract_experience(text):
     experience_years = [int(year[0]) for year in experience_years]
     return experience_years, job_titles
 
-# --- Updated Resume Analysis Function --- #
-def analyze_resume(resume_file, job_description_file):
-    if not resume_file or not job_description_file:
-        return "", "", "", "Please upload both files."
-
-    # Load and preprocess resume and job description
-    resume_text = extract_text_from_file(resume_file)
-    job_description_text = extract_text_from_file(job_description_file)
-
-    # Extract skills, qualifications, and experience from the resume
-    resume_skills = extract_skills_llama(resume_text)
-    resume_qualifications = extract_qualifications(resume_text)
-    resume_experience, _ = extract_experience(resume_text)
-    total_experience = sum(resume_experience)  # Assuming this returns a list of experiences
-
-    # Extract required skills, qualifications, and experience from the job description
-    job_description_skills = process_job_description(job_description_text)
-    job_description_qualifications = extract_qualifications(job_description_text)
-    job_description_experience, _ = extract_experience(job_description_text)
-    required_experience = sum(job_description_experience)  # Assuming total years required
-
-    # Calculate similarity scores
-    skills_similarity = len(set(resume_skills).intersection(set(job_description_skills))) / len(job_description_skills) * 100 if job_description_skills else 0
-    qualifications_similarity = len(set(resume_qualifications).intersection(set(job_description_qualifications))) / len(job_description_qualifications) * 100 if job_description_qualifications else 0
-    experience_similarity = 1.0 if total_experience >= required_experience else 0.0
-
-    # Fit assessment logic
-    fit_score = 0
-    if total_experience >= required_experience:
-        fit_score += 1
-    if skills_similarity > 50:  # Define a threshold for skills match
-        fit_score += 1
-    if qualifications_similarity > 50:  # Define a threshold for qualifications match
-        fit_score += 1
-
-    # Determine fit
-    if fit_score == 3:
-        fit_assessment = "Strong fit"
-    elif fit_score == 2:
-        fit_assessment = "Moderate fit"
+# --- Semantic Similarity Calculation --- #
+def calculate_semantic_similarity(text1, text2):
+    """Calculates semantic similarity using a sentence transformer model and returns the score as a percentage."""
+    model = SentenceTransformer('paraphrase-MiniLM-L6-v2')
+    embeddings1 = model.encode(text1, convert_to_tensor=True)
+    embeddings2 = model.encode(text2, convert_to_tensor=True)
+    similarity_score = util.pytorch_cos_sim(embeddings1, embeddings2).item()
+
+    # Convert similarity score to percentage
+    similarity_percentage = similarity_score * 100
+    return similarity_percentage
+
+# --- Thresholds --- #
+def categorize_similarity(score):
+    """Categorizes the similarity score into thresholds for better insights."""
+    if score >= 80:
+        return "High Match"
+    elif score >= 50:
+        return "Moderate Match"
     else:
-        fit_assessment = "Not a fit"
-
-    # Prepare output messages for tab display
-    summary_message = (
-        f"### Summary of Analysis\n"
-        f"- **Skills Similarity**: {skills_similarity:.2f}%\n"
-        f"- **Qualifications Similarity**: {qualifications_similarity:.2f}%\n"
-        f"- **Experience Similarity**: {experience_similarity * 100:.2f}%\n"
-        f"- **Candidate Experience**: {total_experience} years\n"
-        f"- **Fit Assessment**: {fit_assessment}\n"
-    )
-
-    skills_message = (
-        f"### Skills Overview\n"
-        f"- **Resume Skills:**\n" + "\n".join(f"  - {skill}" for skill in resume_skills) + "\n"
-        f"- **Job Description Skills:**\n" + "\n".join(f"  - {skill}" for skill in job_description_skills) + "\n"
-    )
-
-    qualifications_message = (
-        f"### Qualifications Overview\n"
-        f"- **Resume Qualifications:** " + ", ".join(resume_qualifications) + "\n" +
-        f"- **Job Description Qualifications:** " + ", ".join(job_description_qualifications) + "\n"
+        return "Low Match"
+
+# --- Communication Generation with Enhanced Response --- #
+def communication_generator(resume_skills, job_description_skills, skills_similarity, qualifications_similarity, experience_similarity, max_length=200):
+    """Generates a more detailed communication response based on similarity scores."""
+    model_name = "google/flan-t5-base"
+    tokenizer = ModelCache.get_tokenizer(model_name)
+    model = ModelCache.get_model(model_name)
+
+    # Assess candidate fit based on similarity scores
+    fit_status = "strong fit" if skills_similarity >= 80 and qualifications_similarity >= 80 and experience_similarity >= 80 else \
+                 "moderate fit" if skills_similarity >= 50 else "weak fit"
+
+    # Create a detailed communication message based on match levels
+    message = (
+        f"After a detailed analysis of the candidate's resume, we found the following insights:\n\n"
+        f"- **Skills Match**: {skills_similarity:.2f}% ({categorize_similarity(skills_similarity)})\n"
+        f"- **Qualifications Match**: {qualifications_similarity:.2f}% ({categorize_similarity(qualifications_similarity)})\n"
+        f"- **Experience Match**: {experience_similarity:.2f}% ({categorize_similarity(experience_similarity)})\n\n"
+        f"The overall assessment indicates that the candidate is a {fit_status} for the role. "
+        f"Skills such as {', '.join(resume_skills)} align {categorize_similarity(skills_similarity).lower()} with the job's requirements of {', '.join(job_description_skills)}. "
+        f"In terms of qualifications and experience, the candidate shows a {categorize_similarity(qualifications_similarity).lower()} match with the role's needs. "
+        f"Based on these findings, we believe the candidate could potentially excel in the role, "
+        f"but additional evaluation or interviews are recommended for further clarification."
     )
 
-    experience_message = (
-        f"### Experience Overview\n"
-        f"- **Total Experience:** {total_experience} years\n"
-        f"- **Required Experience:** {required_experience} years\n"
-    )
-
-    return summary_message, skills_message, qualifications_message, experience_message
-
-
-# --- Gradio Interface --- #
-def run_gradio_interface():
-    with gr.Blocks() as demo:
-        gr.Markdown("## Resume and Job Description Analyzer")
-        resume_file = gr.File(label="Upload Resume")
-        job_description_file = gr.File(label="Upload Job Description")
-
-        # Create placeholders for output messages
-        summary_output = gr.Textbox(label="Summary of Analysis", interactive=False, lines=10)
-        skills_output = gr.Textbox(label="Skills Overview", interactive=False, lines=10)
-        qualifications_output = gr.Textbox(label="Qualifications Overview", interactive=False, lines=10)
-        experience_output = gr.Textbox(label="Experience Overview", interactive=False, lines=10)
+    inputs = tokenizer(message, return_tensors="pt", padding=True, truncation=True)
+    response = model.generate(**inputs, max_length=max_length, num_beams=4, early_stopping=True)
 
-        # Create tabs for output sections
-        with gr.Tab("Analysis Summary"):
-            gr.Markdown("### Summary of Analysis")
-            summary_output  # This automatically renders the output box
+    return tokenizer.decode(response[0], skip_special_tokens=True)
 
-        with gr.Tab("Skills Overview"):
-            gr.Markdown("### Skills Overview")
-            skills_output  # This automatically renders the output box
+# --- Sentiment Analysis --- #
+def sentiment_analysis(text):
+    """Analyzes the sentiment of the text using a Hugging Face model."""
+    model_name = "distilbert-base-uncased-finetuned-sst-2-english"
+    tokenizer = ModelCache.get_tokenizer(model_name)
+    model = ModelCache.get_model(model_name)
 
-        with gr.Tab("Qualifications Overview"):
-            gr.Markdown("### Qualifications Overview")
-            qualifications_output  # This automatically renders the output box
+    inputs = tokenizer(text, return_tensors="pt", padding=True, truncation=True)
+    with torch.no_grad():
+        outputs = model(**inputs)
+        predicted_sentiment = torch.argmax(outputs.logits).item()
+    return ["Negative", "Neutral", "Positive"][predicted_sentiment]
 
-        with gr.Tab("Experience Overview"):
-            gr.Markdown("### Experience Overview")
-            experience_output  # This automatically renders the output box
-
-        analyze_button = gr.Button("Analyze")
+# --- Updated Resume Analysis Function --- #
+def analyze_resume(resume_file, job_description_file):
+    """Analyzes the resume and job description, returning similarity score, skills, qualifications, and experience matching."""
+    # Extract resume and job description text
+    try:
+        resume_text = extract_text_from_file(resume_file.name)
+        job_description_text = extract_text_from_file(job_description_file.name)
+    except ValueError as ve:
+        return str(ve)
 
-        # Button action
-        analyze_button.click(analyze, inputs=[resume_file, job_description_file], outputs=[summary_output, skills_output, qualifications_output, experience_output])
+    # Extract skills, qualifications, and experience
+    resume_skills = extract_skills_huggingface(resume_text)
+    job_description_skills = process_job_description(job_description_text)
+    resume_qualifications = extract_qualifications(resume_text)
+    job_description_qualifications = extract_qualifications(job_description_text)
+    resume_experience, resume_job_titles = extract_experience(resume_text)
+    job_description_experience, job_description_titles = extract_experience(job_description_text)
+
+    # Calculate semantic similarity for different sections in percentages
+    skills_similarity = calculate_semantic_similarity(' '.join(resume_skills), ' '.join(job_description_skills))
+    qualifications_similarity = calculate_semantic_similarity(' '.join(resume_qualifications), ' '.join(job_description_qualifications))
+    experience_similarity = calculate_semantic_similarity(' '.join([str(e) for e in resume_experience]), ' '.join([str(e) for e in job_description_experience]))
+
+    # Generate a communication response based on the similarity percentages
+    communication_response = communication_generator(
+        resume_skills, job_description_skills,
+        skills_similarity, qualifications_similarity, experience_similarity
+    )
 
-    demo.launch()
+    # Perform Sentiment Analysis
+    sentiment = sentiment_analysis(resume_text)
+
+    # Return the results including thresholds and percentage scores
+    return (
+        f"Skills Similarity: {skills_similarity:.2f}% ({categorize_similarity(skills_similarity)})",
+        f"Qualifications Similarity: {qualifications_similarity:.2f}% ({categorize_similarity(qualifications_similarity)})",
+        f"Experience Similarity: {experience_similarity:.2f}% ({categorize_similarity(experience_similarity)})",
+        communication_response,
+        f"Sentiment Analysis: {sentiment}",
+        f"Resume Skills: {', '.join(resume_skills)}",
+        f"Job Description Skills: {', '.join(job_description_skills)}",
+        f"Resume Qualifications: {', '.join(resume_qualifications)}",
+        f"Job Description Qualifications: {', '.join(job_description_qualifications)}",
+        f"Resume Experience: {', '.join(map(str, resume_experience))} years, Titles: {', '.join(resume_job_titles)}",
+        f"Job Description Experience: {', '.join(map(str, job_description_experience))} years, Titles: {', '.join(job_description_titles)}"
+    )
 
-def analyze(resume, job_desc):
-    # Always ensure the correct number of return values
-    summary, skills, qualifications, experience = analyze_resume(resume, job_desc)
-    return summary, skills, qualifications, experience
+# --- Gradio Interface --- #
+iface = gr.Interface(
+    fn=analyze_resume,
+    inputs=["file", "file"],
+    outputs=[
+        "text", "text", "text", "text", "text", "text", "text", "text", "text", "text", "text"
+    ],
+    title="Resume Analysis Tool",
+    description="Analyze a resume against a job description to evaluate skills, qualifications, experience, and sentiment."
+)
 
 if __name__ == "__main__":
-    run_gradio_interface()
+    iface.launch()