Add application file

Models.py

@@ -0,0 +1,67 @@
+import gensim
+from gensim.models.doc2vec import Doc2Vec, TaggedDocument
+from nltk.tokenize import word_tokenize
+from gensim.models.doc2vec import Doc2Vec
+import nltk
+from transformers import AutoTokenizer, AutoModel
+from sklearn.metrics.pairwise import cosine_similarity
+import torch
+import numpy as np
+import streamlit as st
+
+#Mean Pooling - Take attention mask into account for correct averaging
+def mean_pooling(model_output, attention_mask):
+    token_embeddings = model_output[0] #First element of model_output contains all token embeddings
+    input_mask_expanded = attention_mask.unsqueeze(-1).expand(token_embeddings.size()).float()
+    return torch.sum(token_embeddings * input_mask_expanded, 1) / torch.clamp(input_mask_expanded.sum(1), min=1e-9)
+
+
+@st.cache_resource
+def get_HF_embeddings(sentences):
+
+  # Load model from HuggingFace Hub
+  tokenizer = AutoTokenizer.from_pretrained('sentence-transformers/bert-base-nli-mean-tokens')
+  model = AutoModel.from_pretrained('sentence-transformers/bert-base-nli-mean-tokens')
+  # Tokenize sentences
+  encoded_input = tokenizer(sentences, padding=True, truncation=True, return_tensors='pt', max_length=512)
+  # Compute token embeddings
+  with torch.no_grad():
+      model_output = model(**encoded_input)
+  # Perform pooling. In this case, max pooling.
+  embeddings = mean_pooling(model_output, encoded_input['attention_mask'])
+
+  # print("Sentence embeddings:")
+  # print(embeddings)
+  return embeddings
+
+
+@st.cache_data
+def get_doc2vec_embeddings(JD, text_resume):
+    nltk.download("punkt")
+    data = [JD]
+    resume_embeddings = []
+    
+    tagged_data = [TaggedDocument(words=word_tokenize(_d.lower()), tags=[str(i)]) for i, _d in enumerate(data)]
+    #print (tagged_data)
+
+    model = gensim.models.doc2vec.Doc2Vec(vector_size=512, min_count=3, epochs=80)
+    model.build_vocab(tagged_data)
+    model.train(tagged_data, total_examples=model.corpus_count, epochs=80)
+    JD_embeddings = np.transpose(model.docvecs['0'].reshape(-1,1))
+
+    for i in text_resume:
+        text = word_tokenize(i.lower())
+        embeddings = model.infer_vector(text)
+        resume_embeddings.append(np.transpose(embeddings.reshape(-1,1)))
+    return (JD_embeddings, resume_embeddings)
+
+
+def cosine(embeddings1, embeddings2):
+  # get the match percentage
+  score_list = []
+  for i in embeddings1:
+      matchPercentage = cosine_similarity(np.array(i), np.array(embeddings2))
+      matchPercentage = np.round(matchPercentage, 4)*100 # round to two decimal
+      print("Your resume matches about" + str(matchPercentage[0])+ "% of the job description.")
+      score_list.append(str(matchPercentage[0][0]))
+  return score_list

README.md

@@ -1,12 +1,26 @@
----
-title: Ats Resume
-emoji: 🚀
-colorFrom: indigo
-colorTo: yellow
-sdk: streamlit
-sdk_version: 1.33.0
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Resume Screening App
+This app is built for employers looking for candidates against a particular job description. This app looks into outputing a x% percent similarity score given the resume of the candidate and a job description.
+
+App deployed on [Streamlit Community Cloud](https://soumee2000-applicant-tracking-system-application-tqrpm0.streamlit.app/)
+
+## Intuition:
+1. Get [context-aware BERT Embeddings](https://towardsdatascience.com/nlp-extract-contextualized-word-embeddings-from-bert-keras-tf-67ef29f60a7b) or [document doc2vec embeddings](https://cs.stanford.edu/~quocle/paragraph_vector.pdf) for Resume and Job Description.
+2. [Hugging Face](https://huggingface.co/sentence-transformers/bert-base-nli-mean-tokens) Library was very useful alongwith doc2vec or nltk
+3. Get their [cosine similarity](https://developers.google.com/machine-learning/clustering/similarity/measuring-similarity)
+
+## Workflow:
+<img src = "https://github.com/SOUMEE2000/Applicant_Tracking_System/blob/main/Demo/Workflow.png">
+
+## Interface
+<img src = "https://github.com/SOUMEE2000/Resume_Scanner/blob/main/Demo/Interface.png" height=400>
+<img src = "https://github.com/SOUMEE2000/Applicant_Tracking_System/blob/main/Demo/Interface_Results.png" height = 400 width = 800>
+
+## Usage
+
+```
+pip install -r requirements.txt
+```
+**Run**: ``` streamlit run application.py```
+
+
+

Resume_scanner.py

@@ -0,0 +1,22 @@
+
+import streamlit as st
+from Models import get_HF_embeddings, cosine, get_doc2vec_embeddings
+
+def compare(resume_texts, JD_text, flag='HuggingFace-BERT'):
+    JD_embeddings = None
+    resume_embeddings = []
+
+    if flag == 'HuggingFace-BERT':
+        if JD_text is not None:
+            JD_embeddings = get_HF_embeddings(JD_text)
+        for resume_text in resume_texts:
+            resume_embeddings.append(get_HF_embeddings(resume_text))
+
+        if JD_embeddings is not None and resume_embeddings is not None:
+            cos_scores = cosine(resume_embeddings, JD_embeddings)
+            return cos_scores
+
+    # Add logic for other flags like 'Doc2Vec' if necessary
+    else:
+        # Handle other cases
+        pass

application.py

@@ -0,0 +1,72 @@
+import sys
+import streamlit as st
+import pdfplumber
+from Resume_scanner import compare
+
+
+def extract_pdf_data(file_path):
+    data = ""
+    with pdfplumber.open(file_path) as pdf:
+        for page in pdf.pages:
+            text = page.extract_text()
+            if text:
+                data += text
+    return data
+
+
+def extract_text_data(file_path):
+    with open(file_path, 'r') as file:
+        data = file.read()
+    return data
+
+
+# Command-line argument processing
+if len(sys.argv) > 1:
+
+    if len(sys.argv) == 3:
+        resume_path = sys.argv[1]
+        jd_path = sys.argv[2]
+
+        resume_data = extract_pdf_data(resume_path)
+        jd_data = extract_text_data(jd_path)
+
+        result = compare([resume_data], jd_data, flag='HuggingFace-BERT')
+
+    sys.exit()
+
+# Sidebar
+flag = 'HuggingFace-BERT'
+with st.sidebar:
+    st.markdown('**Which embedding do you want to use**')
+    options = st.selectbox('Which embedding do you want to use',
+                           ['HuggingFace-BERT', 'Doc2Vec'],
+                           label_visibility="collapsed")
+    flag = options
+
+# Main content
+tab1, tab2 = st.tabs(["**Home**", "**Results**"])
+
+# Tab Home
+with tab1:
+    st.title("Applicant Tracking System")
+    uploaded_files = st.file_uploader(
+        '**Choose your resume.pdf file:** ', type="pdf", accept_multiple_files=True)
+    JD = st.text_area("**Enter the job description:**")
+    comp_pressed = st.button("Compare!")
+    if comp_pressed and uploaded_files:
+        # Streamlit file_uploader gives file-like objects, not paths
+        uploaded_file_paths = [extract_pdf_data(
+            file) for file in uploaded_files]
+        score = compare(uploaded_file_paths, JD, flag)
+
+# Tab Results
+with tab2:
+    st.header("Results")
+    my_dict = {}
+    if comp_pressed and uploaded_files:
+        for i in range(len(score)):
+            my_dict[uploaded_files[i].name] = score[i]
+        sorted_dict = dict(sorted(my_dict.items()))
+        for i in sorted_dict.items():
+            with st.expander(str(i[0])):
+                st.write("Score is: ", i[1])

requirements.txt

@@ -0,0 +1,7 @@
+streamlit
+transformers
+torch
+pdfplumber
+nltk
+gensim
+scikit-learn