Upload 4 files

bert.py

@@ -0,0 +1,238 @@
+# Import necessary libraries
+import streamlit as st
+import nltk
+from gensim.models.doc2vec import Doc2Vec, TaggedDocument
+from nltk.tokenize import word_tokenize
+import PyPDF2
+import pandas as pd
+import re
+import matplotlib.pyplot as plt
+import seaborn as sns
+import spacy
+
+# Download necessary NLTK data
+nltk.download('punkt')
+
+# Define regular expressions for pattern matching
+float_regex = re.compile(r'^\d{1,2}(\.\d{1,2})?$')
+email_pattern = r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b'
+float_digit_regex = re.compile(r'^\d{10}$')
+email_with_phone_regex = re.compile(r'(\d{10}).|.(\d{10})')
+
+# Function to extract text from a PDF file
+def extract_text_from_pdf(pdf_file):
+    pdf_reader = PyPDF2.PdfReader(pdf_file)
+    text = ""
+    for page_num in range(len(pdf_reader.pages)):
+        text += pdf_reader.pages[page_num].extract_text()
+    return text
+
+# Function to tokenize text using the NLP model
+def tokenize_text(text, nlp_model):
+    doc = nlp_model(text, disable=["tagger", "parser"])
+    tokens = [(token.text.lower(), token.label_) for token in doc.ents]
+    return tokens
+
+# Function to extract CGPA from a resume
+def extract_cgpa(resume_text):
+    cgpa_pattern = r'\b(?:CGPA|GPA|C\.G\.PA|Cumulative GPA)\s*:?[\s-]([0-9]+(?:\.[0-9]+)?)\b|\b([0-9]+(?:\.[0-9]+)?)\s(?:CGPA|GPA)\b'
+    match = re.search(cgpa_pattern, resume_text, re.IGNORECASE)
+    if match:
+        cgpa = match.group(1) if match.group(1) else match.group(2)
+        return float(cgpa)
+    else:
+        return None
+
+# Function to extract skills from a resume
+def extract_skills(text, skills_keywords):
+    skills = [skill.lower() for skill in skills_keywords if re.search(r'\b' + re.escape(skill.lower()) + r'\b', text.lower())]
+    return skills
+
+# Function to preprocess text
+def preprocess_text(text):
+    return word_tokenize(text.lower())
+
+# Function to train a Doc2Vec model
+def train_doc2vec_model(documents):
+    model = Doc2Vec(vector_size=20, min_count=2, epochs=50)
+    model.build_vocab(documents)
+    model.train(documents, total_examples=model.corpus_count, epochs=model.epochs)
+    return model
+
+# Function to calculate similarity between two texts
+def calculate_similarity(model, text1, text2):
+    vector1 = model.infer_vector(preprocess_text(text1))
+    vector2 = model.infer_vector(preprocess_text(text2))
+    return model.dv.cosine_similarities(vector1, [vector2])[0]
+
+# Function to calculate accuracy
+def accuracy_calculation(true_positives, false_positives, false_negatives):
+    total = true_positives + false_positives + false_negatives
+    accuracy = true_positives / total if total != 0 else 0
+    return accuracy
+
+# Streamlit Frontend
+st.markdown("# Resume Matching Tool 📃📃")
+st.markdown("An application to match resumes with a job description.")
+
+# Sidebar - File Upload for Resumes
+st.sidebar.markdown("## Upload Resumes PDF")
+resumes_files = st.sidebar.file_uploader("Upload Resumes PDF", type=["pdf"], accept_multiple_files=True)
+
+if resumes_files:
+    # Sidebar - File Upload for Job Descriptions
+    st.sidebar.markdown("## Upload Job Description PDF")
+    job_descriptions_file = st.sidebar.file_uploader("Upload Job Description PDF", type=["pdf"])
+
+    if job_descriptions_file:
+        # Load the pre-trained NLP model
+        nlp_model_path = "en_Resume_Matching_Keywords"
+        nlp = spacy.load(nlp_model_path)
+
+        # Backend Processing
+        job_description_text = extract_text_from_pdf(job_descriptions_file)
+        resumes_texts = [extract_text_from_pdf(resume_file) for resume_file in resumes_files]
+        job_description_text = extract_text_from_pdf(job_descriptions_file)
+        job_description_tokens = tokenize_text(job_description_text, nlp)
+
+        # Initialize counters
+        overall_skill_matches = 0
+        overall_qualification_matches = 0
+
+        # Create a list to store individual results
+        results_list = []
+        job_skills = set()
+        job_qualifications = set()
+
+        for job_token, job_label in job_description_tokens:
+            if job_label == 'QUALIFICATION':
+                job_qualifications.add(job_token.replace('\n', ' '))
+            elif job_label == 'SKILLS':
+                job_skills.add(job_token.replace('\n', ' '))
+
+        job_skills_number = len(job_skills)
+        job_qualifications_number = len(job_qualifications)
+
+        # Lists to store counts of matched skills for all resumes
+        skills_counts_all_resumes = []
+
+        # Iterate over all uploaded resumes
+        for uploaded_resume in resumes_files:
+            resume_text = extract_text_from_pdf(uploaded_resume)
+            resume_tokens = tokenize_text(resume_text, nlp)
+
+            # Initialize counters for individual resume
+            skillMatch = 0
+            qualificationMatch = 0
+            cgpa = ""
+
+            # Lists to store matched skills and qualifications for each resume
+            matched_skills = set()
+            matched_qualifications = set()
+            email = set()
+            phone = set()
+            name = set()
+
+            # Compare the tokens in the resume with the job description
+            for resume_token, resume_label in resume_tokens:
+                for job_token, job_label in job_description_tokens:
+                    if resume_token.lower().replace('\n', ' ') == job_token.lower().replace('\n', ' '):
+                        if resume_label == 'SKILLS':
+                            matched_skills.add(resume_token.replace('\n', ' '))
+                        elif resume_label == 'QUALIFICATION':
+                            matched_qualifications.add(resume_token.replace('\n', ' '))
+                    elif resume_label == 'PHONE' and bool(float_digit_regex.match(resume_token)):
+                        phone.add(resume_token)  
+                    elif resume_label == 'QUALIFICATION':
+                        matched_qualifications.add(resume_token.replace('\n', ' '))
+
+            skillMatch = len(matched_skills)
+            qualificationMatch = len(matched_qualifications)
+
+            # Convert the list of emails to a set
+            email_set = set(re.findall(email_pattern, resume_text.replace('\n', ' ')))
+            email.update(email_set)
+
+            numberphone=""
+            for email_str in email:
+                numberphone = email_with_phone_regex.search(email_str)
+                if numberphone:
+                    email.remove(email_str)
+                    val=numberphone.group(1) or numberphone.group(2)
+                    phone.add(val)
+                    email.add(email_str.strip(val))
+
+            # Increment overall counters based on matches
+            overall_skill_matches += skillMatch
+            overall_qualification_matches += qualificationMatch
+
+            # Add count of matched skills for this resume to the list
+            skills_counts_all_resumes.append([resume_text.count(skill.lower()) for skill in job_skills])
+
+            # Create a dictionary for the current resume and append to the results list
+            result_dict = {
+                "Resume": uploaded_resume.name,
+                "Similarity Score": (skillMatch/job_skills_number)*100,
+                "Skill Matches": skillMatch,
+                "Matched Skills": matched_skills,
+                "CGPA": extract_cgpa(resume_text),
+                "Email": email,
+                "Phone": phone,
+                "Qualification Matches": qualificationMatch,
+                "Matched Qualifications": matched_qualifications
+            }
+
+            results_list.append(result_dict)
+
+        # Display overall matches
+        st.subheader("Overall Matches")
+        st.write(f"Total Skill Matches: {overall_skill_matches}")
+        st.write(f"Total Qualification Matches: {overall_qualification_matches}")
+        st.write(f"Job Qualifications: {job_qualifications}")
+        st.write(f"Job Skills: {job_skills}")
+
+        # Display individual results in a table
+        results_df = pd.DataFrame(results_list)
+        st.subheader("Individual Results")
+        st.dataframe(results_df)
+        tagged_resumes = [TaggedDocument(words=preprocess_text(text), tags=[str(i)]) for i, text in enumerate(resumes_texts)]
+        model_resumes = train_doc2vec_model(tagged_resumes)
+
+        st.subheader("\nHeatmap:")
+       
+        # Get skills keywords from user input
+        skills_keywords_input = st.text_input("Enter skills keywords separated by commas (e.g., python, java, machine learning):")
+        skills_keywords = [skill.strip() for skill in skills_keywords_input.split(',') if skill.strip()]
+
+        if skills_keywords:
+            # Calculate the similarity score between each skill keyword and the resume text
+            skills_similarity_scores = []
+            for resume_text in resumes_texts:
+                resume_text_similarity_scores = []
+                for skill in skills_keywords:
+                    similarity_score = calculate_similarity(model_resumes, resume_text, skill)
+                    resume_text_similarity_scores.append(similarity_score)
+                skills_similarity_scores.append(resume_text_similarity_scores)
+
+            # Create a DataFrame with the similarity scores and set the index to the names of the PDFs
+            skills_similarity_df = pd.DataFrame(skills_similarity_scores, columns=skills_keywords, index=[resume_file.name for resume_file in resumes_files])
+
+            # Plot the heatmap
+            fig, ax = plt.subplots(figsize=(12, 8))
+            sns.heatmap(skills_similarity_df, cmap='YlGnBu', annot=True, fmt=".2f", ax=ax)
+            ax.set_title('Heatmap for Skills Similarity')
+            ax.set_xlabel('Skills')
+            ax.set_ylabel('Resumes')
+
+            # Rotate the y-axis labels for better readability
+            plt.yticks(rotation=0)
+
+            # Display the Matplotlib figure using st.pyplot()
+            st.pyplot(fig)
+        else:
+            st.write("Please enter at least one skill keyword.")
+
+    else:
+        st.warning("Please upload the Job Description PDF to proceed.")
+else:
+    st.warning("Please upload Resumes PDF to proceed.")

doc2vec.py

@@ -0,0 +1,277 @@
+# Importing necessary libraries
+from collections import Counter
+import streamlit as st
+import nltk
+from gensim.models.doc2vec import Doc2Vec, TaggedDocument
+from nltk.tokenize import word_tokenize
+import PyPDF2
+import pandas as pd
+import re
+import matplotlib.pyplot as plt
+import seaborn as sns
+
+# Downloading the 'punkt' tokenizer from NLTK
+nltk.download('punkt')
+
+# Function to extract text from a PDF file
+def extract_text_from_pdf(pdf_file):
+    pdf_reader = PyPDF2.PdfReader(pdf_file)
+    text = ""
+    for page_num in range(len(pdf_reader.pages)):
+        text += pdf_reader.pages[page_num].extract_text()
+    return text
+
+# Function to extract skills from a text using a list of skill keywords
+def extract_skills(text, skills_keywords):
+    skills = [skill.lower()
+              for skill in skills_keywords if re.search(r'\b' + re.escape(skill.lower()) + r'\b', text.lower())]
+    return skills
+
+# Function to preprocess text by tokenizing and converting to lowercase
+def preprocess_text(text):
+    return word_tokenize(text.lower())
+
+# Function to extract mobile numbers from a text
+def extract_mobile_numbers(text):
+    mobile_pattern = r'\b\d{10}\b|\b\d{3}[-.\s]?\d{3}[-.\s]?\d{4}\b'
+    return re.findall(mobile_pattern, text)
+
+# Function to extract emails from a text
+def extract_emails(text):
+    email_pattern = r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b'
+    return re.findall(email_pattern, text)
+
+# Function to train a Doc2Vec model on a list of tagged documents
+def train_doc2vec_model(documents):
+    model = Doc2Vec(vector_size=20, min_count=2, epochs=50)
+    model.build_vocab(documents)
+    model.train(documents, total_examples=model.corpus_count,
+                epochs=model.epochs)
+    return model
+
+# Function to calculate the cosine similarity between two texts using a trained Doc2Vec model
+def calculate_similarity(model, text1, text2):
+    vector1 = model.infer_vector(preprocess_text(text1))
+    vector2 = model.infer_vector(preprocess_text(text2))
+    return model.dv.cosine_similarities(vector1, [vector2])[0]
+
+# Function to calculate accuracy based on true positives, false positives, and false negatives
+def accuracy_calculation(true_positives, false_positives, false_negatives):
+    total = true_positives + false_positives + false_negatives
+    accuracy = true_positives / total if total != 0 else 0
+    return accuracy
+
+# Function to extract CGPA from a text
+def extract_cgpa(resume_text):
+    # Define a regular expression pattern for CGPA extraction
+    cgpa_pattern = r'\b(?:CGPA|GPA|C.G.PA|Cumulative GPA)\s*:?[\s-]* ([0-9]+(?:\.[0-9]+)?)\b|\b([0-9]+(?:\.[0-9]+)?)\s*(?:CGPA|GPA)\b'
+
+    # Search for CGPA pattern in the text
+    match = re.search(cgpa_pattern, resume_text, re.IGNORECASE)
+
+    # Check if a match is found
+    if match:
+        cgpa = match.group(1)
+        if cgpa is not None:
+            return float(cgpa)
+        else:
+            return float(match.group(2))
+    else:
+        return None
+
+# Regular expressions for email and phone number patterns
+email_pattern = r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b'
+phone_pattern = r'\b\d{10}\b|\b\d{3}[-.\s]?\d{3}[-.\s]?\d{4}\b'
+
+# Streamlit Frontend
+st.markdown("# Resume Matching Tool 📃📃")
+st.markdown("An application to match resumes with a job description.")
+
+# Sidebar - File Upload for Resumes
+st.sidebar.markdown("## Upload Resumes PDF")
+resumes_files = st.sidebar.file_uploader(
+    "Upload Resumes PDF", type=["pdf"], accept_multiple_files=True)
+
+if resumes_files:
+    # Sidebar - File Upload for Job Descriptions
+    st.sidebar.markdown("## Upload Job Description PDF")
+    job_descriptions_file = st.sidebar.file_uploader(
+        "Upload Job Description PDF", type=["pdf"])
+
+    if job_descriptions_file:
+        # Sidebar - Sorting Options
+        sort_options = ['Weighted Score', 'Similarity Score']
+        selected_sort_option = st.sidebar.selectbox(
+            "Sort results by", sort_options)
+
+        # Backend Processing
+        job_description_text = extract_text_from_pdf(job_descriptions_file)
+        resumes_texts = [extract_text_from_pdf(
+            resume_file) for resume_file in resumes_files]
+
+        tagged_resumes = [TaggedDocument(words=preprocess_text(
+            text), tags=[str(i)]) for i, text in enumerate(resumes_texts)]
+        model_resumes = train_doc2vec_model(tagged_resumes)
+
+        true_positives_mobile = 0
+        false_positives_mobile = 0
+        false_negatives_mobile = 0
+
+        true_positives_email = 0
+        false_positives_email = 0
+        false_negatives_email = 0
+
+        results_data = {'Resume': [], 'Similarity Score': [],
+                        'Weighted Score': [], 'Email': [], 'Contact': [], 'CGPA': []}
+
+        for i, resume_text in enumerate(resumes_texts):
+            extracted_mobile_numbers = set(extract_mobile_numbers(resume_text))
+            extracted_emails = set(extract_emails(resume_text))
+            extracted_cgpa = extract_cgpa(resume_text)
+
+            ground_truth_mobile_numbers = {'1234567890', '9876543210'}
+            ground_truth_emails = {
+                '[email protected]', '[email protected]'}
+
+            true_positives_mobile += len(
+                extracted_mobile_numbers.intersection(ground_truth_mobile_numbers))
+            false_positives_mobile += len(
+                extracted_mobile_numbers.difference(ground_truth_mobile_numbers))
+            false_negatives_mobile += len(
+                ground_truth_mobile_numbers.difference(extracted_mobile_numbers))
+
+            true_positives_email += len(
+                extracted_emails.intersection(ground_truth_emails))
+            false_positives_email += len(
+                extracted_emails.difference(ground_truth_emails))
+            false_negatives_email += len(
+                ground_truth_emails.difference(extracted_emails))
+
+            similarity_score = calculate_similarity(
+                model_resumes, resume_text, job_description_text)
+
+            other_criteria_score = 0
+
+            weighted_score = (0.6 * similarity_score) + \
+                (0.4 * other_criteria_score)
+
+            results_data['Resume'].append(resumes_files[i].name)
+            results_data['Similarity Score'].append(similarity_score * 100)
+            results_data['Weighted Score'].append(weighted_score)
+
+            emails = ', '.join(re.findall(email_pattern, resume_text))
+            contacts = ', '.join(re.findall(phone_pattern, resume_text))
+            results_data['Email'].append(emails)
+            results_data['Contact'].append(contacts)
+            results_data['CGPA'].append(extracted_cgpa)
+
+        results_df = pd.DataFrame(results_data)
+
+        if selected_sort_option == 'Similarity Score':
+            results_df = results_df.sort_values(
+                by='Similarity Score', ascending=False)
+        else:
+            results_df = results_df.sort_values(
+                by='Weighted Score', ascending=False)
+
+        st.subheader(f"Results Table (Sorted by {selected_sort_option}):")
+
+        # Define a custom function to highlight maximum values in the specified columns
+        def highlight_max(data, color='grey'):
+            is_max = data == data.max()
+            return [f'background-color: {color}' if val else '' for val in is_max]
+
+        # Apply the custom highlighting function to the DataFrame
+        st.dataframe(results_df.style.apply(highlight_max, subset=[
+                     'Similarity Score', 'Weighted Score', 'CGPA']))
+
+
+        highest_score_index = results_df['Similarity Score'].idxmax()
+        highest_score_resume_name = resumes_files[highest_score_index].name
+
+        st.subheader("\nDetails of Highest Similarity Score Resume:")
+        st.write(f"Resume Name: {highest_score_resume_name}")
+        st.write(
+            f"Similarity Score: {results_df.loc[highest_score_index, 'Similarity Score']:.2f}")
+
+        if 'Weighted Score' in results_df.columns:
+            weighted_score_value = results_df.loc[highest_score_index,
+                                                  'Weighted Score']
+            st.write(f"Weighted Score: {weighted_score_value:.2f}" if pd.notnull(
+                weighted_score_value) else "Weighted Score: Not Mentioned")
+        else:
+            st.write("Weighted Score: Not Mentioned")
+
+        if 'Email' in results_df.columns:
+            email_value = results_df.loc[highest_score_index, 'Email']
+            st.write(f"Email: {email_value}" if pd.notnull(
+                email_value) else "Email: Not Mentioned")
+        else:
+            st.write("Email: Not Mentioned")
+
+        if 'Contact' in results_df.columns:
+            contact_value = results_df.loc[highest_score_index, 'Contact']
+            st.write(f"Contact: {contact_value}" if pd.notnull(
+                contact_value) else "Contact: Not Mentioned")
+        else:
+            st.write("Contact: Not Mentioned")
+
+        if 'CGPA' in results_df.columns:
+            cgpa_value = results_df.loc[highest_score_index, 'CGPA']
+            st.write(f"CGPA: {cgpa_value}" if pd.notnull(
+                cgpa_value) else "CGPA: Not Mentioned")
+        else:
+            st.write("CGPA: Not Mentioned")
+
+        mobile_accuracy = accuracy_calculation(
+            true_positives_mobile, false_positives_mobile, false_negatives_mobile)
+        email_accuracy = accuracy_calculation(
+            true_positives_email, false_positives_email, false_negatives_email)
+
+        st.subheader("\nHeatmap:")
+        # st.write(f"Mobile Number Accuracy: {mobile_accuracy:.2%}")
+        # st.write(f"Email Accuracy: {email_accuracy:.2%}")
+
+        # Get skills keywords from user input
+        skills_keywords_input = st.text_input(
+            "Enter skills keywords separated by commas (e.g., python, java, machine learning):")
+        skills_keywords = [skill.strip()
+                        for skill in skills_keywords_input.split(',') if skill.strip()]
+
+        if skills_keywords:
+            # Calculate the similarity score between each skill keyword and the resume text
+            skills_similarity_scores = []
+            for resume_text in resumes_texts:
+                resume_text_similarity_scores = []
+                for skill in skills_keywords:
+                    similarity_score = calculate_similarity(
+                        model_resumes, resume_text, skill)
+                    resume_text_similarity_scores.append(similarity_score)
+                skills_similarity_scores.append(resume_text_similarity_scores)
+
+            # Create a DataFrame with the similarity scores and set the index to the names of the PDFs
+            skills_similarity_df = pd.DataFrame(
+                skills_similarity_scores, columns=skills_keywords, index=[resume_file.name for resume_file in resumes_files])
+
+            # Plot the heatmap
+            fig, ax = plt.subplots(figsize=(12, 8))
+
+            sns.heatmap(skills_similarity_df,
+                        cmap='YlGnBu', annot=True, fmt=".2f", ax=ax)
+            ax.set_title('Heatmap for Skills Similarity')
+            ax.set_xlabel('Skills')
+            ax.set_ylabel('Resumes')
+
+            # Rotate the y-axis labels for better readability
+            plt.yticks(rotation=0)
+
+            # Display the Matplotlib figure using st.pyplot()
+            st.pyplot(fig)
+        else:
+            st.write("Please enter at least one skill keyword.")
+
+
+    else:
+        st.warning("Please upload the Job Description PDF to proceed.")
+else:
+    st.warning("Please upload Resumes PDF to proceed.")

main.py

@@ -0,0 +1,266 @@
+from collections import Counter
+import streamlit as st
+import nltk
+from gensim.models.doc2vec import Doc2Vec, TaggedDocument
+from nltk.tokenize import word_tokenize
+import os
+import PyPDF2
+import pandas as pd
+import re
+import matplotlib.pyplot as plt
+import seaborn as sns
+import spacy
+from PyPDF2 import PdfReader
+from io import BytesIO
+import re
+import pandas as pd
+import matplotlib.pyplot as plt
+import seaborn as sns
+
+nltk.download('punkt')
+
+
+nlp_model_path = "en_Resume_Matching_Keywords"
+nlp = spacy.load(nlp_model_path)
+
+float_regex = re.compile(r'^\d{1,2}(\.\d{1,2})?$')
+email_pattern = r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b'
+float_digit_regex = re.compile(r'^\d+$')
+email_with_phone_regex = email_with_phone_regex = re.compile(
+    r'(\d{10}).|.(\d{10})')
+
+
+def extract_text_from_pdf(pdf_file):
+    pdf_reader = PyPDF2.PdfReader(pdf_file)
+    text = ""
+    for page_num in range(len(pdf_reader.pages)):
+        text += pdf_reader.pages[page_num].extract_text()
+    return text
+
+
+def tokenize_text(text, nlp_model):
+    doc = nlp_model(text, disable=["tagger", "parser"])
+    tokens = [(token.text.lower(), token.label_) for token in doc.ents]
+    return tokens
+
+
+def extract_cgpa(resume_text):
+    # Define a regular expression pattern for CGPA extraction
+    cgpa_pattern = r'\b(?:CGPA|GPA|C\.G\.PA|Cumulative GPA)\s*:?[\s-]([0-9]+(?:\.[0-9]+)?)\b|\b([0-9]+(?:\.[0-9]+)?)\s(?:CGPA|GPA)\b'
+
+    # Search for CGPA pattern in the text
+    match = re.search(cgpa_pattern, resume_text, re.IGNORECASE)
+
+    # Check if a match is found
+    if match:
+        # Extract CGPA value
+        cgpa = match.group(1) if match.group(1) else match.group(2)
+        return float(cgpa)
+    else:
+        return None
+
+
+def extract_skills(text, skills_keywords):
+    skills = [skill.lower()
+              for skill in skills_keywords if re.search(r'\b' + re.escape(skill.lower()) + r'\b', text.lower())]
+    return skills
+
+
+def preprocess_text(text):
+    return word_tokenize(text.lower())
+
+
+
+
+
+def train_doc2vec_model(documents):
+    model = Doc2Vec(vector_size=20, min_count=2, epochs=50)
+    model.build_vocab(documents)
+    model.train(documents, total_examples=model.corpus_count,
+                epochs=model.epochs)
+    return model
+
+
+def calculate_similarity(model, text1, text2):
+    vector1 = model.infer_vector(preprocess_text(text1))
+    vector2 = model.infer_vector(preprocess_text(text2))
+    return model.dv.cosine_similarities(vector1, [vector2])[0]
+
+
+def accuracy_calculation(true_positives, false_positives, false_negatives):
+    total = true_positives + false_positives + false_negatives
+    accuracy = true_positives / total if total != 0 else 0
+    return accuracy
+
+
+
+
+
+
+# Streamlit Frontend
+st.markdown("# Resume Matching Tool 📃📃")
+st.markdown("An application to match resumes with a job description.")
+
+# Sidebar - File Upload for Resumes
+st.sidebar.markdown("## Upload Resumes PDF")
+resumes_files = st.sidebar.file_uploader(
+    "Upload Resumes PDF", type=["pdf"], accept_multiple_files=True)
+
+if resumes_files:
+    # Sidebar - File Upload for Job Descriptions
+    st.sidebar.markdown("## Upload Job Description PDF")
+    job_descriptions_file = st.sidebar.file_uploader(
+        "Upload Job Description PDF", type=["pdf"])
+
+    if job_descriptions_file:
+        
+        # Backend Processing
+        job_description_text = extract_text_from_pdf(job_descriptions_file)
+        resumes_texts = [extract_text_from_pdf(
+            resume_file) for resume_file in resumes_files]
+        job_description_text = extract_text_from_pdf(job_descriptions_file)
+        job_description_tokens = tokenize_text(job_description_text, nlp)
+
+        # st.subheader("Matching Keywords")
+
+        # Initialize counters
+        overall_skill_matches = 0
+        overall_qualification_matches = 0
+
+        # Create a list to store individual results
+        results_list = []
+        job_skills = set()
+        job_qualifications = set()
+
+        for job_token, job_label in job_description_tokens:
+            if job_label == 'QUALIFICATION':
+                job_qualifications.add(job_token)
+            elif job_label == 'SKILLS':
+                job_skills.add(job_token)
+
+        job_skills_number = len(job_skills)
+        job_qualifications_number = len(job_qualifications)
+
+        # Lists to store counts of matched skills for all resumes
+        skills_counts_all_resumes = []
+
+        # Iterate over all uploaded resumes
+        for uploaded_resume in resumes_files:
+            resume_text = extract_text_from_pdf(uploaded_resume)
+            resume_tokens = tokenize_text(resume_text, nlp)
+
+            # Initialize counters for individual resume
+            skillMatch = 0
+            qualificationMatch = 0
+            cgpa = ""
+
+            # Lists to store matched skills and qualifications for each resume
+            matched_skills = set()
+            matched_qualifications = set()
+            email = set()
+            phone = set()
+            name = set()
+
+            # Compare the tokens in the resume with the job description
+            for resume_token, resume_label in resume_tokens:
+                for job_token, job_label in job_description_tokens:
+                    if resume_token.lower() == job_token.lower():
+                        if resume_label == 'SKILLS':
+                            matched_skills.add(resume_token)
+                        elif resume_label == 'QUALIFICATION':
+                            matched_qualifications.add(resume_token)
+                    elif resume_label == 'CGPA' and bool(float_regex.match(resume_token)):
+                        cgpa = resume_token
+                    elif resume_label == 'PHONE' and bool(float_digit_regex.match(resume_token)):
+                        phone.add(resume_token)
+                    elif resume_label == 'QUALIFICATION':
+                        matched_qualifications.add(resume_token)
+
+            skillMatch = len(matched_skills)
+            qualificationMatch = len(matched_qualifications)
+
+            # Increment overall counters based on matches
+            overall_skill_matches += skillMatch
+            overall_qualification_matches += qualificationMatch
+
+            # Add count of matched skills for this resume to the list
+            skills_counts_all_resumes.append(
+                [resume_text.count(skill.lower()) for skill in job_skills])
+
+            # Create a dictionary for the current resume and append to the results list
+            result_dict = {
+                "Resume": uploaded_resume.name,
+                "Similarity Score": (skillMatch/job_skills_number)*100,
+                "Skill Matches": skillMatch,
+                "Matched Skills": matched_skills,
+                "CGPA": extract_cgpa(resume_text),
+                "Email": email,
+                "Phone": phone,
+                "Qualification Matches": qualificationMatch,
+                "Matched Qualifications": matched_qualifications
+            }
+
+            results_list.append(result_dict)
+
+        # Display overall matches
+        st.subheader("Overall Matches")
+        st.write(f"Total Skill Matches: {overall_skill_matches}")
+        st.write(
+            f"Total Qualification Matches: {overall_qualification_matches}")
+        st.write(f"Job Qualifications: {job_qualifications}")
+        st.write(f"Job Skills: {job_skills}")
+
+        # Display individual results in a table
+        results_df = pd.DataFrame(results_list)
+        st.subheader("Individual Results")
+        st.dataframe(results_df)
+        tagged_resumes = [TaggedDocument(words=preprocess_text(
+            text), tags=[str(i)]) for i, text in enumerate(resumes_texts)]
+        model_resumes = train_doc2vec_model(tagged_resumes)
+
+
+        
+        st.subheader("\nHeatmap:")
+       
+        # Get skills keywords from user input
+        skills_keywords_input = st.text_input(
+            "Enter skills keywords separated by commas (e.g., python, java, machine learning):")
+        skills_keywords = [skill.strip()
+                           for skill in skills_keywords_input.split(',') if skill.strip()]
+
+        if skills_keywords:
+            # Calculate the similarity score between each skill keyword and the resume text
+            skills_similarity_scores = []
+            for resume_text in resumes_texts:
+                resume_text_similarity_scores = []
+                for skill in skills_keywords:
+                    similarity_score = calculate_similarity(
+                        model_resumes, resume_text, skill)
+                    resume_text_similarity_scores.append(similarity_score)
+                skills_similarity_scores.append(resume_text_similarity_scores)
+
+            # Create a DataFrame with the similarity scores and set the index to the names of the PDFs
+            skills_similarity_df = pd.DataFrame(
+                skills_similarity_scores, columns=skills_keywords, index=[resume_file.name for resume_file in resumes_files])
+
+            # Plot the heatmap
+            fig, ax = plt.subplots(figsize=(12, 8))
+
+            sns.heatmap(skills_similarity_df,
+                        cmap='YlGnBu', annot=True, fmt=".2f", ax=ax)
+            ax.set_title('Heatmap for Skills Similarity')
+            ax.set_xlabel('Skills')
+            ax.set_ylabel('Resumes')
+
+            # Rotate the y-axis labels for better readability
+            plt.yticks(rotation=0)
+
+            # Display the Matplotlib figure using st.pyplot()
+            st.pyplot(fig)
+        else:
+            st.write("Please enter at least one skill keyword.")
+
+    else:
+        st.warning("Please upload the Job Description PDF to proceed.")
+else:
+    st.warning("Please upload Resumes PDF to proceed.")

requirements.txt

@@ -0,0 +1,11 @@
+gensim==4.3.2
+matplotlib==3.8.2
+nltk==3.8.1
+pandas==1.3.5
+PyPDF2==3.0.1
+seaborn==0.13.2
+streamlit==1.31.0
+torch==2.2.0
+transformers==4.37.2
+spacy
+https://huggingface.co/Priyanka-Balivada/en_Resume_Matching_Keywords/resolve/main/en_Resume_Matching_Keywords-any-py3-none-any.whl