“AI Based Resume Parser”

A
Project Report
submitted in partial fulfillment of the
requirements for the award of the degree of

BACHELOR OF COMPUTER APPLICATIONS

by

Akshay Kakkar R25223093

Archie Chawla R25223096
Bhumi Saraswat R25223092
Devika Singh R25223102
Pranjal Rawat R25223099

under the guidance of

Mr. Varun Sapra

School of Computer Science

University of Petroleum & Energy Studies
Bidholi, Via Prem Nagar, Dehradun, Uttarakhand
Month – 20XX
 CANDIDATE’S DECLARATION

I/We hereby certify that the project work entitled “AI BASED RESUME PARSER” in
partial fulfilment of the requirements for the award of the Degree of BACHELOR OF
COMPUTER APPLICATIONS and submitted to the Department of Systemics, School of
Computer Science, University of Petroleum & Energy Studies, Dehradun, is an authentic record
of my/ our work carried out during a period from June, 2025 to July, 2025 under the supervision
of Mr. Varun Sapra

The matter presented in this project has not been submitted by me/ us for the award of any
other degree of this or any other University.

Akshay Kakkar Archie Chawla Bhumi Saraswat Devika Singh Pranjal Rawat
R252223093 R252223096 R252223092 R252223102 R252223099

This is to certify that the above statement made by the candidate is correct to the
best of my knowledge.

Date: _____________2025 Mr. Varun Sapra

Project Guide
 ACKNOWLEDGEMENT

We wish to express our deep gratitude to our guide Mr. Varun Sapra, for all advice,
encouragement and constant support he has given us throughout our project work. This work
would not have been possible without his support and valuable suggestions.

We sincerely thanks to our respected Name of HoD, Head Department of _____________, for
his great support in doing our project in _____________________.

We are also grateful to Dean SoCS UPES for giving us the necessary facilities to carry out our
project work successfully. We also thanks to our Course Coordinator, (NAME) and our Activity
Coordinator (NAME) for providing timely support and information during the completion of this
project.

We would like to thank all our friends for their help and constructive criticism during our project
work. Finally, we have no words to express our sincere gratitude to our parents who have shown
us this world and for every support they have given us.

Akshay Kakkar Archie Chawla Bhumi Saraswat Devika Singh Pranjal Rawat
R252223093 R252223096 R252223092 R252223102 R252223099
 ABSTRACT

The “AI-ResumeParser” project aims to address the complexity of automated resume screening,
skill matching, contextual analysis, and compatibility scoring for specific job roles.
An AI-based resume parser is an intelligent system designed to read, interpret, and analyze
resumes without requiring human intervention, enabling fast and accurate candidate
shortlisting. These systems can work with unstructured resume formats and extract relevant
data to determine job suitability without continuous manual guidance.
The primary goal of this project is to design and build a low-cost, efficient AI-based resume
parsing and compatibility evaluation system. The system must be able to read various resume
formats (PDF, DOCX, etc.), extract key information such as skills, experience, and education,
and match these with the requirements of a given job description. The parser will also provide a
compatibility score to indicate how closely the candidate meets the job requirements.
The demonstrator system uses Natural Language Processing (NLP) and Machine Learning
(ML) techniques. Resumes are uploaded (referred to as Candidate Input hereafter) and a job
description is provided (Job Role Input hereafter). The system then processes the input, extracts
and structures the data, and performs skill-to-requirement matching.
The AI-Resume Parser is designed to recognize keywords, assess context, and evaluate
experience relevance to ensure precise compatibility scoring. This is achieved using advanced
NLP algorithms and a trained ML model. In cases where the resume contains missing or
unclear information, the system highlights the gaps, providing suggestions for improvement to
increase job compatibility.
One possible task of the AI-based Resume Parser is to automate candidate shortlisting while
improving the quality of hires. This functionality is highly useful in applications such as:
 HR Recruitment Automation
 Talent Acquisition Systems
 Career Counseling Tools
 Job Portals and ATS (Applicant Tracking Systems)
 TABLE OF CONTENTS

[Link]. Contents

1. Introduction
1.1. History
1.2. Requirement Analysis
1.3. Main Objective
1.4. Sub Objectives
2. System Analysis
2.1. Existing System
2.2. Motivations
2.3. Proposed System
2.4. Modules
2.4.1. Reume Data Extraction and Parsing
2.4.2. Job Description Analysis
2.4.3. Compatibility Matching and Scoring
3. Design
3.1. Modelling in AI Based Systems
3.1.1. Behaviour-based Sustem Design
3.1.2. Use Case model for Requirement Analysis
3.1.3. The design model
3.1.4. Object and Class Design
3.1.5. State Transition
3.1.6. Activity Diagram
4. AI BASED REUSME PARSER
4.1. Resume Parser Overview
4.2. NLP Engine- Core Analysis
[Link] Specifications
4.2.2 Features
4.2.3 Architecture-memory organization
4.3. Programming the Resume Parser
4.3.1. Quick Start Guide
[Link] Engine
[Link] and Semantic Analysis Module
[Link] Learning Scoring Model
5. Implementation
5.1. Resume Parsing using an Information Extraction System
5.2. Scenarios
5.3. Algorithms
[Link] -1Semantic Similarity Matchings
[Link] -2 Keyword and Weight-Based Matching
[Link] -3 Section-wise Scoring
6. Output screens
7. Conclusion
1. Introduction

In today’s competitive job market, the recruitment process is not only about finding
qualified candidates but also about doing so in an efficient, unbiased, and timely manner.
With hundreds or even thousands of resumes received for a single job opening, manual
shortlisting becomes a tedious, error-prone, and resource-intensive task for HR teams.
This has created the need for advanced technological solutions that can automate the
initial screening process while maintaining accuracy and fairness. An AI-based Resume
Parser is one such solution that uses Artificial Intelligence (AI) and Natural Language
Processing (NLP) to read, interpret, and evaluate resumes in a manner that is both
systematic and intelligent.

1.1 History
The roots of automated resume processing trace back to the early 1990s, when Applicant
Tracking Systems (ATS) were first introduced to help recruiters manage high volumes
of applications. These early systems were primarily keyword-driven, capable of only
identifying exact matches between job descriptions and candidate resumes. Over the
years, with rapid advancements in AI, NLP, and Machine Learning (ML), resume
parsers have evolved significantly. Modern AI-driven parsers now possess the ability to
understand context, assess skill relevance, detect synonyms, and even gauge experience
quality rather than just quantity. This shift from simple keyword filtering to intelligent
contextual analysis has transformed resume screening into a far more reliable and
insightful process.

1.2 Requirement Analysis

Recruiters and HR departments face several challenges when shortlisting candidates,
such as:
 Managing resumes in multiple formats (PDF, DOCX, TXT, etc.) with varying
structures.
 Quickly extracting essential information like skills, work experience, education,
and certifications.
 Matching candidate qualifications with detailed job requirements in real time.
 Providing a clear compatibility or suitability score for faster decision-making.
 Minimizing human bias and ensuring fair evaluation for all applicants.
 An AI-based Resume Parser addresses these needs by automating the extraction
and comparison process, thus saving time, reducing workload, and improving the
quality of hires.
1.3 Main Objective
The main objective of this project is to design and develop a low-cost, intelligent resume
parsing and compatibility evaluation system that can analyze resumes and determine
their suitability for a specific job role. The system will leverage AI, NLP, and ML
algorithms to ensure accurate extraction, meaningful comparison, and objective scoring.

1.4 Sub Objectives

To achieve the main objective, the project will focus on the following sub-goals:
1. Develop a robust input-processing module capable of handling various resume
formats.
2. Implement NLP algorithms to extract and structure key candidate information
accurately.
3. Build a matching engine that compares extracted skills and experience with job
requirements.
4. Generate a compatibility score indicating how well a candidate fits the role.
5. Highlight missing skills or experience to help candidates improve their resumes.
6. Ensure adaptability so the system can be used across different industries and job
profiles.

By meeting these objectives, the AI-based Resume Parser aims to revolutionize the
initial stages of recruitment, providing recruiters with a fast, efficient, and unbiased
method of candidate evaluation.
 2. System Analysis

2.1 Existing System

Traditional recruitment processes rely heavily on manual resume screening or basic Applicant
Tracking Systems (ATS) that filter candidates based on keyword matching. While ATS software
helps reduce the workload, it often fails to capture the true relevance of a candidate’s profile.
Keyword-dependent systems can overlook qualified candidates whose resumes use different
wording and can also wrongly shortlist irrelevant applicants due to keyword stuffing.
Additionally, existing parsers may struggle with unstructured resume formats, inconsistent data
layouts, and context-based skill evaluation. This limits the efficiency, fairness, and accuracy of
the hiring process.

2.2 Motivations
With the increasing number of job applications, recruiters need an intelligent system that can
process resumes quickly, accurately, and fairly. AI-powered Resume Parsers can provide
contextual understanding of candidate skills, match them with job descriptions, and generate
compatibility scores to assist HR decision-making. The motivation behind developing this project
includes:
 Reducing manual effort and time in screening resumes.
 Improving matching accuracy by using AI and NLP instead of only keyword searches.
 Providing unbiased candidate evaluations.
 Helping candidates identify skill gaps and improve their resumes for better job
opportunities.

2.3 Proposed System

The proposed AI-based Resume Parser will use Natural Language Processing (NLP) and
Machine Learning (ML) to intelligently extract, process, and analyze resume data. The system
will:
1. Accept resumes in multiple formats (PDF, DOCX, TXT, etc.) along with a job description.
2. Parse and structure the resume data into key categories (skills, education, work experience,
certifications, etc.).
3. Match the extracted skills and experiences against the job requirements.
4. Calculate and display a compatibility score.
5. Highlight missing or less-relevant areas for improvement.
This approach overcomes the limitations of traditional keyword-based systems by using semantic
analysis, contextual understanding, and domain-specific knowledge to ensure a more accurate
and fair candidate evaluation.
 2.4 Modules

2.4.1 Resume Data Extraction and Parsing

This module is responsible for reading resumes in various formats and extracting relevant details
such as contact information, skills, work history, educational qualifications, certifications, and
achievements. NLP algorithms are applied to handle unstructured or irregularly formatted
resumes.

2.4.2 Job Description Analysis

This module analyzes the provided job description to identify essential skills, qualifications, and
experience requirements. It uses keyword extraction and semantic similarity algorithms to
understand the expectations of the role beyond literal keyword matching.

2.4.3 Compatibility Matching and Scoring

This module compares the parsed resume data with the analyzed job description to determine the
level of compatibility. It calculates a percentage score and highlights both matched and
unmatched criteria. The score serves as a quick reference for recruiters to shortlist candidates.

3. Design

The design of the AI-Based Resume Parser is centered around modular, scalable, and intelligent
architecture capable of handling unstructured resume data, performing semantic analysis, and
matching candidate profiles with job requirements efficiently. The design phase ensures that
both the functional and non-functional requirements are addressed, with a focus on accuracy,
speed, and adaptability.

3.1 Modelling in AI-based Systems

Modelling in AI-based systems, such as our resume parser, involves defining the architecture,
data flow, and interaction between software components to ensure seamless processing from
input to output. In this project, the modelling phase focuses on:
 Data Input Layer: Handles resumes in multiple formats and accepts a job description.
 Pre-processing Layer: Cleans and normalizes text, removes formatting inconsistencies,
and prepares data for analysis.
 NLP Processing Layer: Extracts key details using entity recognition, part-of-speech
tagging, and semantic parsing.
 Matching & Scoring Layer: Compares extracted candidate information with job
requirements.
 Output & Reporting Layer: Displays the compatibility score along with insights into
matched and unmatched areas.
This structured modelling ensures that the system works in a pipeline, where each stage builds
upon the output of the previous stage.

3.1.1 Behaviour-based System Design

In robotics, behavior-based design models focus on defining how a robot reacts to its
environment. Similarly, in our AI Resume Parser, behavior-based design determines how the
system reacts to different inputs and scenarios. For example:
 If a resume lacks certain key skills mentioned in the job description, the system must
highlight the missing areas.
 If a resume contains skills that match but uses different wording (synonyms), the system
should still recognize them using semantic similarity checks.
 If the job description is highly domain-specific, the system should adapt its matching
algorithm accordingly.
The “behaviour” here refers to how the parser processes data adaptively, ensuring robustness
against variations in input structure and terminology.

3.1.2 Use Case Model for Requirement Analysis

A use case model helps represent the interaction between the user (recruiter or HR professional)
and the AI Resume Parser.
Primary Actors:
 Recruiter / HR Executive (primary user)
 Candidate (indirectly involved)
Use Case Flow:
1. Upload Resume(s): The recruiter uploads one or multiple resumes in supported formats.
2. Provide Job Description: The recruiter inputs or uploads the job requirements.
3. System Processes Input: The parser extracts, analyzes, and structures data.
4. Matching & Compatibility Score: The system evaluates candidate-job fit and generates a
score.
5. Report Generation: The system provides a detailed analysis with improvement
suggestions.
The use case diagram visually depicts these interactions, ensuring clarity in system
functionality from a user’s perspective.

3.1.3 The Design Model

The design model focuses on the architectural blueprint of the AI Resume Parser. It consists of:
1. Input Module – Accepts resumes and job descriptions.
 2. Text Pre-processing Module – Converts documents into clean, structured text; removes
stop words, special characters, and irrelevant formatting.
3. NLP Engine – Performs Named Entity Recognition (NER) to detect skills, experience,
education, and certifications.
4. Matching Engine – Uses similarity algorithms (e.g., cosine similarity, word embeddings)
to compare resume data with job requirements.
5. Scoring & Reporting Module – Generates a compatibility percentage and identifies
strengths and weaknesses.
6. Data Storage Layer – Maintains structured candidate profiles for future analysis or
audits.
This layered approach ensures high modularity, making it easier to upgrade individual
components without affecting the whole system.

3.1.4 Object and Class Design

Object-oriented design plays a key role in building reusable and maintainable code for the AI
Resume Parser.
Core Classes:
 ResumeDocument – Attributes: file type, raw text, structured data. Methods:
extractText(), parseData().
 JobDescription – Attributes: required skills, required education, experience level.
Methods: analyzeRequirements().
 NLPProcessor – Attributes: tokenized text, entities, vectors. Methods: extractEntities(),
computeSimilarity().
 Matcher – Attributes: resume profile, job profile. Methods: matchSkills(),
calculateScore().
 ReportGenerator – Attributes: compatibility score, recommendations. Methods:
generatePDFReport(), displayInsights().
By organizing the design in classes, the system ensures reusability, scalability, and separation
of concerns.

3.1.5 State Transition

The state transition model describes how the system moves from one stage of processing to
another:
1. Idle State: Waiting for input (resume + job description).
2. Processing State: Converting resumes into structured data.
3. Analysis State: Extracting and comparing skills, education, and experience.
4. Scoring State: Generating compatibility percentage and insights.
5. Output State: Delivering results to the recruiter.
For example, if a resume is unreadable or in an unsupported format, the system transitions to an
Error State, prompting the user to re-upload the file.
3.1.6 Activity Diagram
The activity diagram outlines the operational flow of the AI Resume Parser:
 Start → Upload Resume(s) → Upload Job Description → Pre-processing → NLP
Extraction → Job Requirement Analysis → Compatibility Matching → Score
Calculation → Generate Report → End
Decision nodes handle scenarios such as:
 Missing skills → Highlight gaps.
 High match score → Recommend for shortlisting.
 Low match score → Suggest skill improvement.
 4. AI-BASED RESUME PARSER

4.1 Resume Parser Overview

The AI-Based Resume Parser is an advanced intelligent system designed to automate the
process of reading, analyzing, and evaluating resumes with high accuracy and speed. Unlike
traditional keyword-based systems, this parser utilizes Natural Language Processing (NLP),
Machine Learning (ML), and semantic similarity algorithms to assess candidate qualifications
in context rather than relying solely on exact keyword matches.
The parser is capable of handling large-scale recruitment processes by streamlining candidate
screening and ranking. It ensures that hiring decisions are made based on both technical and
contextual suitability, reducing manual workload and improving the quality of shortlisting.
The system operates in several stages:
1. Document Acquisition – Accepts resumes in multiple formats such as PDF, DOCX,
TXT, and ODT, along with corresponding job descriptions in text or document format.
2. Text Extraction – Converts resumes into raw text, handling both structured formats
(well-organized resumes) and unstructured formats (free-form resumes).
3. Pre-processing – Cleans, normalizes, and tokenizes extracted text to prepare it for
machine analysis.
4. Information Extraction – Identifies and structures essential data such as personal details,
education, work history, skills, certifications, and achievements.
5. Matching & Scoring – Compares extracted candidate information with the job
description to compute a compatibility score.
6. Reporting – Generates a comprehensive report highlighting matched skills, missing
skills, and recommendations for improvement.
This multi-layered approach ensures adaptability across industries, minimizes recruiter bias,
and increases efficiency in candidate evaluation.

4.2 NLP Engine – Core Intelligence

The NLP Engine serves as the intelligent core of the AI Resume Parser. It is responsible for
understanding human language, detecting patterns, and transforming unstructured resume data
into structured, machine-readable information.
The NLP Engine performs the following key operations:
 Tokenization – Splits the text into meaningful words or phrases.
 Part-of-Speech (POS) Tagging – Identifies the grammatical role of each word to provide
context.
 Named Entity Recognition (NER) – Extracts entities such as names, organizations,
qualifications, and skill sets.
 Dependency Parsing – Analyzes the relationships between words to interpret context.
 Semantic Similarity Analysis – Measures the closeness between a candidate’s
experiences and the job description requirements.

4.2.1 Technical Specifications

 Programming Language: Python 3.10+
 Core NLP Libraries:
o spaCy – Advanced entity recognition, dependency parsing, and linguistic
analysis.
 o NLTK – Text pre-processing, tokenization, and linguistic utilities.
o Gensim – Word embeddings, topic modeling, and similarity scoring.
o scikit-learn – Machine learning models for classification and clustering.
 Document Parsing Tools:
o PyPDF2 – Extracts text from PDF resumes.
o docx2txt – Extracts text from DOCX resumes.
 Machine Learning Models:
o TF-IDF Vectorization with Cosine Similarity.
o Pre-trained transformer-based models like BERT for contextual semantic
matching.
 Supported File Formats: PDF, DOCX, TXT, ODT.
 Processing Capacity:
o Single resume parsing time: ~2–3 seconds.
o Bulk processing: 100+ resumes in under 5 minutes on a standard quad-core
processor.

4.2.2 Features
 Multi-format Input Support – Reads multiple file types without data loss.
 Context-aware Matching – Evaluates skills and experience relevance beyond exact
keyword matches.
 Synonym & Acronym Recognition – Detects equivalences such as “ML” and “Machine
Learning.”
 Weighted Scoring System – Assigns greater importance to essential job requirements.
 Automated Gap Analysis – Identifies missing or underrepresented skills.
 Customizable Matching Profiles – Enables configuration for different industries and job
roles.
 Bulk Resume Processing – Efficiently handles high-volume recruitment needs.

4.2.3 Architecture – Memory Organization

The AI Resume Parser uses a layered modular architecture:
1. Input Layer – Accepts resumes and job descriptions in raw file form.
2. Preprocessing Layer – Performs text cleaning, normalization, and tokenization.
3. NLP Layer – Extracts structured data using entity recognition and dependency parsing.
4. Matching Layer – Compares extracted information with job requirements using
similarity algorithms.
5. Scoring Layer – Calculates compatibility scores and ranks candidates.
6. Storage Layer – Saves structured profiles for analytics, reporting, and future retrieval.
Data may be stored temporarily during processing and permanently in databases for long-term
use, depending on application requirements.
4.3 Programming the Resume Parser
The AI Resume Parser is programmed to carry out text extraction, NLP processing, and
candidate-job matching in an automated and efficient manner.

4.3.1 Quick Start Guide

Step 1 – Install Dependencies
pip install spacy nltk scikit-learn PyPDF2 python-docx gensim
python -m spacy download en_core_web_sm
Step 2 – Load and Process Resume
import spacy
nlp = [Link]("en_core_web_sm")

from PyPDF2 import PdfReader

reader = PdfReader("[Link]")
text = " ".join([page.extract_text() for page in [Link]])
Step 3 – Extract Entities
doc = nlp(text)
for ent in [Link]:
print([Link], ent.label_)
Step 4 – Match with Job Description
 Convert extracted data into TF-IDF vectors.
 Calculate cosine similarity between resume data and job description.
Step 5 – Generate Compatibility Report
The parser produces a report containing:
 Compatibility percentage.
 Skills matched.
 Skills missing.
 Recommendations for improvement.

4.4 Matching Engine

The Matching Engine determines how well a candidate aligns with a job role by applying
similarity computation algorithms.
Functions include:
 Exact Match Scoring – Identifies identical skills from the job description.
 Synonym Match Scoring – Detects equivalent or related skills via semantic analysis.
 Weight Distribution – Assigns more weight to critical skills and qualifications.

4.5 Keyword & Semantic Analysis Module

This module ensures that both keyword presence and contextual relevance are considered in
candidate evaluation.
It performs:
 Keyword Presence Check – Ensures essential terms from the job description appear in
the resume.
 Semantic Similarity Matching – Recognizes related concepts (e.g., “Agile Scrum” and
“Project Management”).
 Context Verification – Ensures that listed skills are tied to relevant work experience.
4.6 Machine Learning Scoring Model
The ML Scoring Model enhances evaluation accuracy by using predictive algorithms to
calculate candidate suitability.
 Input: Vectorized form of the resume and job description.
 Processing: Uses models such as Logistic Regression, SVM, or neural networks to
predict candidate-job fit.
 Output: Generates a compatibility score (0–100%) and classifies candidates into:
o High Fit
o Moderate Fit
o Low Fit
This enables fast, accurate, and bias-reduced shortlisting for recruitment processes.
 5. Implementation

The AI-based Resume Parser has been implemented with the goal of automating resume
analysis, improving recruitment efficiency, and providing actionable feedback to both
employers and job seekers. The system integrates Natural Language Processing (NLP),
Machine Learning (ML), and rule-based parsing techniques to extract structured information
from resumes and match it against job requirements. This section describes the core
implementation, the different scenarios in which the system can operate, and the algorithms that
power its matching logic.
The implementation follows a modular approach, where each stage of processing—document
ingestion, preprocessing, parsing, data structuring, and matching—is handled by separate
components. This modularity allows the system to be easily adapted for new industries, resume
formats, or job types.

5.1. Resume Parsing using an Information Extraction System

The resume parser is built around an Information Extraction (IE) engine capable of handling
resumes in various formats, including PDF, DOCX, and TXT. The parsing process is divided
into the following stages:
1. Document Ingestion and Preprocessing
o Convert all input files into raw text while preserving structural cues like headings
and bullet points.
o Normalize text by removing unnecessary characters, fixing encoding errors, and
standardizing date formats.
o Tokenize text into sentences and words for further analysis.
2. Section Detection and Classification
o Apply rule-based patterns and machine learning classifiers to detect common
resume sections such as:
 Personal Details: Name, Email, Phone
 Professional Summary: Short profile description
 Education: Degrees, Universities, Years
 Experience: Roles, Companies, Durations, Responsibilities
 Skills: Technical and soft skills
 Projects and Certifications
o This stage uses Named Entity Recognition (NER) to identify key entities (e.g.,
organizations, job titles, skill names).
3. Structured Data Creation
o All identified information is stored in a structured JSON format or a relational
database.
o Example JSON output:
o {
o "name": "Rahul Mehta",
o "email": "[Link]@[Link]",
o "skills": ["Python", "Data Analysis", "Machine Learning"],
o "experience": [
o {
o "company": "TechCorp",
 o "role": "Data Analyst",
o "duration": "Jan 2021 - Dec 2023"
o }
o ]
o }
4. Job Description Vector Creation
o The job description provided by the employer is also processed using the same
NLP pipeline.
o Skills, qualifications, and responsibilities are extracted and represented as vectors
for compatibility matching.

5.2. Scenarios
The AI Resume Parser supports multiple operational scenarios to serve both recruitment and
career improvement needs:
Scenario 1 – Recruitment Automation
Recruiters upload bulk resumes and a target job description. The system parses each resume,
calculates a compatibility score, and ranks candidates. This drastically reduces manual
screening time.
Scenario 2 – Job Seeker Career Guidance
Job seekers upload their resume and the job description they aim for. The parser highlights
gaps, such as missing skills or insufficient experience, and recommends improvements (e.g.,
"Add experience with SQL to improve your match score").
Scenario 3 – Resume Database Search
HR teams with large candidate databases can search for specific skills or qualifications. The
parser filters and returns only the most relevant candidates based on set thresholds.
Scenario 4 – Skill Gap Analysis for Upskilling Platforms
Training platforms can integrate the parser to analyze a user’s resume and suggest targeted
courses to bridge skill gaps for a specific job role.
Scenario 5 – Automated Job Matching Portals
Job portals can use the parser to automatically recommend jobs that match a candidate’s
existing skills and experience profile.

5.3. Algorithms
The system uses a hybrid approach combining semantic similarity, keyword matching, and
section-based scoring.
5.3.1. Scenario-1: Semantic Similarity Matching
 Vector Embedding Creation: Both resume and job description are converted into vector
embeddings using models such as BERT, RoBERTa, or Sentence Transformers.
 Cosine Similarity Calculation: The similarity between vectors determines the closeness
of candidate skills and experience to job requirements.
 Example: A resume with strong NLP skills scores higher for an AI Engineer role than a
resume focusing on web development.

5.3.2. Scenario-2: Keyword and Weight-Based Matching

  Extract key terms from the job description, including required skills, certifications, and
tools.
 Assign weights to each keyword based on importance (e.g., “AWS” for a cloud engineer
might have 1.5x weight).
 Match resume keywords against these weighted requirements to compute a percentage
match.
5.3.3. Scenario-3: Section-Wise Scoring
 Each section of the resume (Skills, Experience, Education) is scored separately.
 Example Scoring: Skills (40%), Experience (40%), Education (20%).
 This breakdown helps identify which section needs the most improvement to increase
compatibility.
6. Output screens
 Implementation of AI-based Resume Screening and Analysis System

import os
import re
import docx2txt
import pdfplumber
import [Link]
from tkinter import Tk, Label, Button, filedialog, StringVar, Canvas, OptionMenu
from rapidfuzz import fuzz
import numpy as np
import math
from [Link] import RandomForestRegressor
from sklearn.model_selection import train_test_split

# ========== 1. Resume Text Extraction ==========

def extract_text_from_pdf(path):
text = ""
with [Link](path) as pdf:
for page in [Link]:
text += page.extract_text() or ""
return text

def extract_text_from_docx(path):
return [Link](path)

# ========== 2. Fetch Skills ==========

def fetch_all_skills():
try:
db = [Link](
host="localhost", user="root", password="devika", database="project"
)
cursor = [Link]()
[Link]("SELECT skill_name FROM skills")
skills = [row[0].strip().lower() for row in [Link]()]
return skills
except [Link] as err:
print(f"DB Error (all skills): {err}")
return []

def fetch_skills_by_job(job_title):
try:
db = [Link](
host="localhost", user="root", password="devika", database="project1"
)
cursor = [Link]()
 query = "SELECT skills FROM job_roles WHERE job_title = %s"
[Link](query, (job_title,))
result = [Link]()
return [[Link]().lower() for skill in result[0].split(',')] if result else []
except [Link] as err:
print(f"DB Error (job skills): {err}")
return []

def fetch_all_job_titles():
try:
db = [Link](
host="localhost", user="root", password="devika", database="project1"
)
cursor = [Link]()
[Link]("SELECT job_title FROM job_roles")
return [row[0] for row in [Link]()]
except [Link] as err:
print(f"DB Error (job titles): {err}")
return []

# ========== 3. Feature Extraction ==========

def extract_features(resume_text, job_skills):
resume_text = resume_text.lower()
matched_skills = []
for skill in job_skills:
if fuzz.partial_ratio([Link](), resume_text) > 80:
matched_skills.append(skill)

has_education = int(bool([Link](r"(btech|b\.?e\.?|bachelor|mtech|m\.?e\.?|master|ph\.?d)",
resume_text)))
has_experience = int(bool([Link](r"(experience|internship|worked
at|project|professional)", resume_text)))
num_projects = len([Link](r"project", resume_text))
num_skills = len(matched_skills)

return [has_education, has_experience, num_projects, num_skills], matched_skills

# ========== 4. ML Model ==========

def train_resume_model(all_skills):
# Create dummy training data (can be replaced with real labeled resume dataset)
X = []
y = []
for _ in range(100):
edu = [Link](0, 2)
exp = [Link](0, 2)
proj = [Link](0, 3)
skl = [Link](0, len(all_skills))
 score = edu * 20 + exp * 20 + proj * 10 + skl * 0.5
score = min(100, score)
[Link]([edu, exp, proj, skl])
[Link](score)

model = RandomForestRegressor()
[Link](X, y)
return model

# ========== 5. Scoring ==========

def calculate_ml_score(model, features, all_skills, matched_skills):
prediction = [Link]([features])[0]
skill_score = len(matched_skills) / len(all_skills) * 20 if all_skills else 0
bonus = (features[0] + features[1]) * 10 + features[2] * 5
final_score = min(100, round(prediction + skill_score + bonus, 2))
return final_score, skill_score, bonus

# ========== 6. Progress Ring ==========

def draw_progress_ring(canvas, score):
[Link]("all")
canvas.create_oval(20, 20, 180, 180, outline="lightgray", width=20)
angle = int(score / 100 * 360)
canvas.create_arc(20, 20, 180, 180, start=90, extent=-angle, outline="green", style="arc",
width=20)
canvas.create_text(100, 100, text=f"{score:.0f}%", font=("Helvetica", 18))

# ========== 7. Analyze Button Action ==========

def browse_and_analyze(model, job_var, canvas, result_var):
job_title = job_var.get()
if not job_title or job_title == "Select Job Role":
result_var.set("❗ Please select a job role first.")
return

file_path = [Link](filetypes=[("Resume Files", "*.pdf *.docx")])

if not file_path:
return

text = extract_text_from_pdf(file_path) if file_path.endswith('.pdf') else

extract_text_from_docx(file_path)
if not [Link]():
result_var.set("⚠ Empty or unreadable resume.")
return

all_skills = fetch_all_skills()
job_skills = fetch_skills_by_job(job_title)
features, matched_skills = extract_features(text, job_skills)
 final_score, skill_score, bonus = calculate_ml_score(model, features, all_skills,
matched_skills)

result = f"""
📌 Job Role: {job_title}
✅ Matched Skills: {', '.join(matched_skills) if matched_skills else 'None'}
⭐ Skill Score (out of 20): {round(skill_score, 2)}
🎁 Bonus (Education, Internship, Experience, Projects): {bonus}
📊 ML-Based Resume Score: {final_score}/100
"""
result_var.set([Link]())
draw_progress_ring(canvas, final_score)

# ========== 8. GUI ==========

def main():
root = Tk()
[Link]("AI Resume Analyzer (ML + Job Role Matching)")
[Link]("600x800")
[Link](bg="#f0f2f5")
[Link](False, False)

# Title
Label(root, text="AI IT Resume Analyzer", font=("Bellamy Bold", 26, "bold"),
bg="#f0f2f5", fg="#1e3a8a").pack(pady=(30, 5))

# Subtitle
Label(root, text="Upload Your Resume (.pdf or .docx)",
font=("Segoe UI", 14), bg="#f0f2f5", fg="#374151").pack(pady=(0, 20))

# Job Role Dropdown

job_titles = fetch_all_job_titles()
job_var = StringVar(value="Select Job Role")
Label(root, text="Select Job Role", font=("Segoe UI", 12),
bg="#f0f2f5").pack()
OptionMenu(root, job_var, *job_titles).pack(pady=10)

# Browse Button
Button(root, text="📂 Browse Resume",
command=lambda: browse_and_analyze(model, job_var, canvas, result_var),
bg="#22c55e", fg="white", font=("Segoe UI", 12, "bold"),
padx=20, pady=8, bd=0, activebackground="#16a34a").pack(pady=20)

# Progress Ring
canvas = Canvas(root, width=200, height=200, bg="#f0f2f5", highlightthickness=0)
[Link](pady=10)
 # Result Text
result_var = StringVar()
Label(root, textvariable=result_var,
wraplength=700, justify="left", font=("Segoe UI", 11),
bg="#f0f2f5", fg="#111827").pack(pady=20)

# ML model training
all_skills = fetch_all_skills()
global model
model = train_resume_model(all_skills)

[Link]()
# ========== 9. Entry Point ==========
if _name_ == "_main_":
main()

Database Schema for Resume Analysis System

CREATE DATABASE project1;

USE project1;

-- Create job_roles table

CREATE TABLE job_roles (
id INT AUTO_INCREMENT PRIMARY KEY,
job_title VARCHAR(100),
required_background TEXT,
skills TEXT
);

INSERT INTO job_roles (job_title, required_background, skills) VALUES

('Professor (Computer Science)', 'Ph.D., Teaching Experience, Research Publications', 'Python,
Machine Learning, Data Science, Research, Communication'),
('Software Developer', '[Link]/BCA/MCA in CSE, Project Experience, Internship', 'Java,
Python, HTML, CSS, JavaScript, Git, DSA, Problem Solving, SQL'),
('Data Analyst', 'BCA/BSc in Statistics/CS, Internship/Project Experience', 'Excel, SQL,
Python, Power BI, Data Cleaning, Visualization, Pandas, NumPy, Statistics'),
('Cybersecurity Analyst', '[Link]/BCA with Cybersecurity Course/Internship', 'Networking,
Security Tools, Ethical Hacking, Python, Risk Assessment, SIEM, Linux, Firewall'),
('AI/ML Engineer', '[Link]/BCA with AI/ML Specialization, Projects in ML', 'Python,
TensorFlow, Scikit-learn, NLP, Deep Learning, Data Preprocessing, ML Models');

SELECT * FROM job_roles;

 Resume Analyzer – Model Training Pipeline

# train_model.py

import [Link]
import numpy as np
from [Link] import RandomForestClassifier
import joblib
from rapidfuzz import fuzz

def fetch_all_skills():
try:
db = [Link](
host="localhost",
user="root",
password="devika",
database="project"
)
cursor = [Link]()
[Link]("SELECT skill_name FROM skills")
results = [Link]()
skills = [row[0] for row in results]
[Link]()
[Link]()
return skills
except [Link] as err:
print(f"Error fetching skills: {err}")
return []

def generate_synthetic_resume_job_data(all_skills, num_samples=100):

if not all_skills:
return [Link]([]), [Link]([])

[Link](42)
X = []
y = []
for _ in range(num_samples):
resume_skills_count = [Link](0, len(all_skills))
resume_skills = [Link](all_skills, resume_skills_count, replace=False).tolist()
resume_education = [Link]([0, 1])
resume_internship = [Link]([0, 1])
resume_experience = [Link]([0, 1])
resume_projects = [Link]([0, 1])

job_skills_count = [Link](1, len(all_skills))

job_skills = [Link](all_skills, job_skills_count, replace=False).tolist()
job_education = [Link]([0, 1])
job_experience = [Link]([0, 1])
 skill_overlap = len(set(resume_skills) & set(job_skills))
skill_match_ratio = skill_overlap / job_skills_count if job_skills_count > 0 else 0
education_match = 1 if resume_education >= job_education else 0
experience_match = 1 if resume_experience >= job_experience else 0

features = [skill_match_ratio, education_match, experience_match, resume_internship,

resume_projects]

score = (skill_match_ratio * 0.5 + education_match * 0.2 + experience_match * 0.2 +

resume_internship * 0.05 + resume_projects * 0.05)
[Link](1 if score >= 0.7 else 0)
[Link](features)

return [Link](X), [Link](y)

def main():
print("[*]
 7. Conclusion

The project AI-Based Resume Parser has been successfully developed with the primary
objective of simplifying the recruitment process by automating the extraction of relevant
information from resumes. Traditional recruitment methods require manual effort to read
and sort resumes, which is both time-consuming and prone to human error. Our parser
addresses these challenges by using Natural Language Processing (NLP) techniques to
identify and categorize key details such as personal information, educational
background, skills, and work experience.
During the development of this project, we explored the use of Python libraries such as
NLTK, Spacy, and PyPDF2 for text processing and extraction. The system demonstrated
its ability to parse resumes in various formats like PDF and DOCX, ensuring flexibility
for recruiters. Through a structured and systematic approach, the parser enhances
efficiency, reduces hiring time, and assists recruiters in shortlisting suitable candidates
with minimal manual intervention.
Thus, the project stands as a practical and scalable solution for small, medium, and large
organizations looking to integrate AI-driven tools into their HR processes.

Future Scope

Although the AI-based resume parser meets its current objectives, there remains vast
scope for enhancement and further development:
1. Enhanced Accuracy with Machine Learning Models – Future versions can incorporate
advanced machine learning algorithms and deep learning models (like BERT or GPT-
based models) to improve parsing accuracy and handle complex resumes with
unconventional structures.
2. Integration with Applicant Tracking Systems (ATS) – The parser can be directly
integrated into popular ATS platforms, enabling recruiters to automatically store and
filter resumes within their existing workflows.
3. Multilingual Support – Extending the system to parse resumes written in different
languages will increase its usability across global recruitment markets.
4. Skill Matching and Ranking – Instead of just extracting information, the system can be
enhanced to match candidate profiles with job descriptions and rank them based on
suitability.
5. Data Visualization – Dashboards with graphical representation of candidate data (skills
distribution, experience levels, etc.) can provide recruiters with better insights for
decision-making.
6. Cloud Deployment – Deploying the parser on a cloud platform can make it accessible to
recruiters from anywhere, allowing multiple users to collaborate in real time.