deepsu commited on
Commit
f9a6bac
·
1 Parent(s): 1412979

update-fix/Fixed major issues of code, api, and models. Model were updated with proper formatiing, FastAPI code is simpler and cleaner, finally the api is optimized by removing pdf parsings

Browse files
main.py CHANGED
@@ -1,53 +1,38 @@
1
- from fastapi import FastAPI, UploadFile, File, Form
2
- from typing import List
3
- import json, time, os, uuid
4
  from pathlib import Path
 
 
 
5
 
6
- from modules.pdf_to_json import PDFToJSON
7
- from modules.comparison import CompareData
8
-
9
  from transformers import AutoTokenizer, AutoModelForCausalLM
10
  from peft import PeftModel
11
- from sentence_transformers import SentenceTransformer
12
 
13
- app = FastAPI()
14
-
15
- THRESHOLD = 0.675
16
-
17
-
18
- # ---------------------------------------------
19
- # 🧠 RESUME STEP LOGGER
20
- # ---------------------------------------------
21
- def log_resume_steps(filename: str, steps: list):
22
- print("\n" + "=" * 60)
23
- print(f"📄 RESUME: {filename}")
24
- print("=" * 60)
25
-
26
- for i, step in enumerate(steps, 1):
27
- print(f"{i}. {step}")
28
 
29
- print("=" * 60 + "\n")
 
 
30
 
 
31
 
32
- # ---------------------------------------------
33
- # 🚀 STARTUP: LOAD ALL MODELS ONCE
34
- # ---------------------------------------------
35
  @app.on_event("startup")
36
  def load_models():
37
- print("📦 Loading ALL models...")
38
-
39
  BASE_DIR = Path(__file__).resolve().parent
40
 
41
  # ===== QWEN =====
42
  base_model_name = "Qwen/Qwen2.5-0.5B-Instruct"
43
- adapter_path = BASE_DIR / "models/qwen-2.5-v2/checkpoint-1010"
44
 
45
  tokenizer = AutoTokenizer.from_pretrained(base_model_name)
46
  tokenizer.pad_token = tokenizer.eos_token
47
 
48
  base_model = AutoModelForCausalLM.from_pretrained(
49
  base_model_name,
50
- torch_dtype="float32",
51
  device_map="cpu"
52
  )
53
 
@@ -58,8 +43,8 @@ def load_models():
58
  minilm_model = SentenceTransformer(str(BASE_DIR / "models/mnr_1"))
59
 
60
  # ===== Inject =====
61
- app.state.pdf_to_json = PDFToJSON(qwen_model, tokenizer)
62
- app.state.compare = CompareData(minilm_model)
63
 
64
  print("✅ All models loaded once")
65
 
@@ -75,112 +60,44 @@ def home():
75
  # ---------------------------------------------
76
  # MAIN ENDPOINT
77
  # ---------------------------------------------
 
 
 
 
78
  @app.post("/match-resumes/")
79
- async def match_resumes(
80
- jd: str = Form(...),
81
- files: List[UploadFile] = File(...)
82
- ):
83
- start_time = time.time()
84
-
85
- pdf_to_json = app.state.pdf_to_json
86
- compare = app.state.compare
87
-
88
- jd = json.loads(jd)
89
-
90
- results = []
91
- temp_dir = "./temp"
92
- os.makedirs(temp_dir, exist_ok=True)
93
-
94
- # ---------------------------------
95
- # JD PROCESSING (ONCE)
96
- # ---------------------------------
97
- processed_jd = compare.process_jd(jd)
98
- jd_emb = compare.encode(processed_jd)
99
-
100
- print("📌 JD processed + embedded successfully")
101
-
102
- # ---------------------------------
103
- # LOOP EACH RESUME
104
- # ---------------------------------
105
- for file in files:
106
- steps = []
107
- file_path = os.path.join(temp_dir, f"{uuid.uuid4()}.pdf")
108
-
109
- steps.append(f"Received file: {file.filename}")
110
-
111
- try:
112
- # -------------------------
113
- # SAVE FILE
114
- # -------------------------
115
- with open(file_path, "wb") as f:
116
- content = await file.read()
117
- f.write(content)
118
-
119
- steps.append("PDF saved to temp storage")
120
-
121
- # -------------------------
122
- # EXTRACT TEXT
123
- # -------------------------
124
- resume_texts = pdf_to_json.extract_text([file_path])
125
- steps.append(f"Text extracted (size={len(resume_texts)})")
126
-
127
- # -------------------------
128
- # JSON GENERATION
129
- # -------------------------
130
- resume_json = pdf_to_json.generate_json(resume_texts)[0]
131
-
132
- if "error" in resume_json:
133
- steps.append("❌ JSON generation failed — skipping resume")
134
- log_resume_steps(file.filename, steps)
135
- continue
136
-
137
- steps.append("Structured JSON generated from resume")
138
-
139
- # -------------------------
140
- # PROCESS RESUME
141
- # -------------------------
142
- processed_resume = compare.process_resume(resume_json)
143
- steps.append("Resume text processed/normalized")
144
-
145
- # -------------------------
146
- # ENCODING
147
- # -------------------------
148
- resume_emb = compare.encode(processed_resume)
149
- steps.append("Resume embedding created")
150
-
151
- # -------------------------
152
- # SIMILARITY
153
- # -------------------------
154
- score = compare.compare(resume_emb, jd_emb)
155
- steps.append(f"Similarity score computed: {score:.4f}")
156
-
157
- # -------------------------
158
- # DECISION
159
- # -------------------------
160
- if score >= THRESHOLD:
161
- steps.append(f"✅ MATCHED (threshold={THRESHOLD})")
162
-
163
- results.append({
164
- "name": resume_json.get("name", "Unknown"),
165
- "score": float(score),
166
- "resume": resume_json
167
- })
168
- else:
169
- steps.append(f"❌ REJECTED (below threshold {THRESHOLD})")
170
-
171
- # FINAL LOG FOR THIS RESUME
172
- log_resume_steps(file.filename, steps)
173
-
174
- finally:
175
- if os.path.exists(file_path):
176
- os.remove(file_path)
177
- steps.append("Temp file deleted")
178
-
179
- # ---------------------------------
180
- # RESPONSE
181
- # ---------------------------------
182
  return {
183
- "total_matched": len(results),
184
- "processing_time": round(time.time() - start_time, 2),
185
- "candidates": results
 
 
186
  }
 
1
+ #import torch and fast api
2
+ import torch
3
+ from fastapi import FastAPI
4
  from pathlib import Path
5
+ from pydantic import BaseModel
6
+ from typing import List
7
+ import time
8
 
9
+ #import transformer modules
 
 
10
  from transformers import AutoTokenizer, AutoModelForCausalLM
11
  from peft import PeftModel
 
12
 
13
+ #import sentence_transformers
14
+ from sentence_transformers import SentenceTransformer
 
 
 
 
 
 
 
 
 
 
 
 
 
15
 
16
+ # import modules
17
+ from modules.resume_parser import ResumeParser
18
+ from modules.comparison import Comparison
19
 
20
+ app = FastAPI()
21
 
 
 
 
22
  @app.on_event("startup")
23
  def load_models():
 
 
24
  BASE_DIR = Path(__file__).resolve().parent
25
 
26
  # ===== QWEN =====
27
  base_model_name = "Qwen/Qwen2.5-0.5B-Instruct"
28
+ adapter_path = BASE_DIR / "models/qwen_final"
29
 
30
  tokenizer = AutoTokenizer.from_pretrained(base_model_name)
31
  tokenizer.pad_token = tokenizer.eos_token
32
 
33
  base_model = AutoModelForCausalLM.from_pretrained(
34
  base_model_name,
35
+ dtype=torch.float32,
36
  device_map="cpu"
37
  )
38
 
 
43
  minilm_model = SentenceTransformer(str(BASE_DIR / "models/mnr_1"))
44
 
45
  # ===== Inject =====
46
+ app.state.resume_parser = ResumeParser(qwen_model, tokenizer)
47
+ app.state.comparison = Comparison(minilm_model)
48
 
49
  print("✅ All models loaded once")
50
 
 
60
  # ---------------------------------------------
61
  # MAIN ENDPOINT
62
  # ---------------------------------------------
63
+ class ResumeMatchRequest(BaseModel):
64
+ job_description:str
65
+ resume: str
66
+
67
  @app.post("/match-resumes/")
68
+ async def match_resumes(request:ResumeMatchRequest):
69
+ start = time.time()
70
+ resume = request.resume
71
+ job_description = request.job_description
72
+
73
+ #load parser
74
+ parser = app.state.resume_parser
75
+
76
+ #resumes in parsed format
77
+ resume = parser.format_data(resume)
78
+
79
+ #resumes after generated
80
+ resume = parser.parse(resume)
81
+ splitted = resume.split("\n")
82
+ name = splitted[0].split("name: ").pop()
83
+ parsed_resume = "\n".join(splitted[1:])
84
+
85
+
86
+ #load comparison
87
+ comparison = app.state.comparison
88
+
89
+ # use all mini lm to encode
90
+ with torch.no_grad():
91
+ jd = comparison.encode(job_description)
92
+ res = comparison.encode(parsed_resume)
93
+ score = comparison.compare(res, jd)
94
+
95
+ end = time.time()
96
+
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
97
  return {
98
+ "scores":score,
99
+ "resume":{"name": name, "resume":parsed_resume},
100
+ "threshold":0.670,
101
+ "process_time": f"{end-start} seconds",
102
+ "message": "Candidate Accepted" if score>=0.670 else "Candidate Rejected"
103
  }
models/mnr_1/README.md CHANGED
@@ -1,3 +1,3 @@
1
  version https://git-lfs.github.com/spec/v1
2
- oid sha256:033d5318e3d7d204f46d47b7418bf5ab8b22f0d4ea0228fdf447887dcfedb827
3
- size 34954
 
1
  version https://git-lfs.github.com/spec/v1
2
+ oid sha256:7dee2fd076b7c08ea50f40e7671b64e7d0eeef3941772ab7276d7c910e617fef
3
+ size 34755
models/mnr_1/model.safetensors CHANGED
@@ -1,3 +1,3 @@
1
  version https://git-lfs.github.com/spec/v1
2
- oid sha256:b4676b573b8c272d1383fee4b0aa61ed07c91f0208250e8e5ef0e3ed1ecbaf79
3
  size 90864192
 
1
  version https://git-lfs.github.com/spec/v1
2
+ oid sha256:324b8a60d2ac42d9df4fc7501daf734df6bb24fb05613f3fc0032f39659c6f0e
3
  size 90864192
models/qwen-2.5-v2/checkpoint-1010/adapter_model.safetensors DELETED
@@ -1,3 +0,0 @@
1
- version https://git-lfs.github.com/spec/v1
2
- oid sha256:8ba09c8697ba3535b4c56bb91d91acd5eb572bc0cc86c8013a8044b7150ec026
3
- size 17640136
 
 
 
 
models/{qwen-2.5-v2/checkpoint-1010 → qwen_final}/README.md RENAMED
File without changes
models/{qwen-2.5-v2/checkpoint-1010 → qwen_final}/adapter_config.json RENAMED
@@ -1,3 +1,3 @@
1
  version https://git-lfs.github.com/spec/v1
2
- oid sha256:43a3c15cc9bfdc8c64fb67bd97850c0587a5e014c5b761f9c01eaba09e9482f0
3
- size 1311
 
1
  version https://git-lfs.github.com/spec/v1
2
+ oid sha256:d704aad32dec0f1d225c2b00c6be7ee72578e9c1402c7e6ab09ea7c57c694f31
3
+ size 1260
models/{qwen-2.5-v2/README.md → qwen_final/adapter_model.safetensors} RENAMED
@@ -1,3 +1,3 @@
1
  version https://git-lfs.github.com/spec/v1
2
- oid sha256:fd061e0e548c4f35c292a198bbf8b94ff5e571c568474aa4fc08b8b806de09c7
3
- size 1518
 
1
  version https://git-lfs.github.com/spec/v1
2
+ oid sha256:4eac848e319ef60c95caddca849d132d1d960a9f587d38a8f447c6b2a191d70e
3
+ size 8676008
models/{qwen-2.5-v2/checkpoint-1010 → qwen_final}/chat_template.jinja RENAMED
File without changes
models/{qwen-2.5-v2/checkpoint-1010 → qwen_final}/optimizer.pt RENAMED
@@ -1,3 +1,3 @@
1
  version https://git-lfs.github.com/spec/v1
2
- oid sha256:a4e5e181469198b65485d25184ebfb1e51b34c4de79c3a93ce332df2521d62d0
3
- size 35479763
 
1
  version https://git-lfs.github.com/spec/v1
2
+ oid sha256:3b0fc672dfc6df371804814f346759d0fe3ac9f9fed155e9c8480070fe308bda
3
+ size 17465739
models/{qwen-2.5-v2/checkpoint-1010 → qwen_final}/rng_state.pth RENAMED
@@ -1,3 +1,3 @@
1
  version https://git-lfs.github.com/spec/v1
2
- oid sha256:1bf37342a4e2004e2b59ecd956410c6d91e61253e6fd30356e13956f4c914499
3
  size 14645
 
1
  version https://git-lfs.github.com/spec/v1
2
+ oid sha256:dee670dbbb7f9ae79334dd2a96a883c819ee2429d4cad998dcb558b1b2923cb8
3
  size 14645
models/{qwen-2.5-v2/checkpoint-1010 → qwen_final}/scheduler.pt RENAMED
@@ -1,3 +1,3 @@
1
  version https://git-lfs.github.com/spec/v1
2
- oid sha256:ca3c880af772c4eb36603de9b9924cc5e93c3999fa5c27fa211190ead91c940d
3
  size 1465
 
1
  version https://git-lfs.github.com/spec/v1
2
+ oid sha256:3af8416f59a652f82564cd7a9c900059bc941731a17bd7ebfd118c6f498f6c5f
3
  size 1465
models/{qwen-2.5-v2/checkpoint-1010 → qwen_final}/tokenizer.json RENAMED
File without changes
models/{qwen-2.5-v2/checkpoint-1010 → qwen_final}/tokenizer_config.json RENAMED
File without changes
models/{qwen-2.5-v2/checkpoint-1010 → qwen_final}/trainer_state.json RENAMED
@@ -1,3 +1,3 @@
1
  version https://git-lfs.github.com/spec/v1
2
- oid sha256:00464c5228b2d6f8ae37eda5bfe7225c8d4ec39df826d8b6f5bb14f28de43b32
3
- size 19475
 
1
  version https://git-lfs.github.com/spec/v1
2
+ oid sha256:5801cb328e9f74599a1f9b59084068f82357990cda00ad58dd602ca9853415ab
3
+ size 19095
models/{qwen-2.5-v2/checkpoint-1010 → qwen_final}/training_args.bin RENAMED
@@ -1,3 +1,3 @@
1
  version https://git-lfs.github.com/spec/v1
2
- oid sha256:43f28af2137e96a50c528960dfb51cc8bb17eb7510646a7d6e556c54bb882ce2
3
  size 5585
 
1
  version https://git-lfs.github.com/spec/v1
2
+ oid sha256:abd69ce1cc8803e63919dc90432c3635c95ef64f5de7b931f16e916397248fea
3
  size 5585
modules/comparison.py CHANGED
@@ -1,93 +1,11 @@
1
- from sentence_transformers import SentenceTransformer
2
- from pathlib import Path
3
- import torch
4
  import torch.nn.functional as F
5
 
6
-
7
-
8
- class CompareData:
9
- """
10
- Converts resume and job description JSON into embeddings
11
- and compares them using PyTorch cosine similarity.
12
- """
13
-
14
  def __init__(self, model):
15
-
16
  self.model = model
17
 
18
- # ---------------------------------------------
19
- # RESUME PROCESSING
20
- # ---------------------------------------------
21
- def process_resume(self, resume_json):
22
- resume_text = f"""
23
- [RESUME]
24
- Role: {resume_json.get("role", "")}
25
-
26
- Key Skills: {", ".join(resume_json.get("skills", []))}
27
- Skills: {", ".join(resume_json.get("skills", []))}
28
-
29
- Experience: {resume_json.get("years_of_experience", 0)} years
30
-
31
- Work Experience:
32
- {" . ".join(resume_json.get("work_experience", []))}
33
-
34
- Education:
35
- {", ".join(resume_json.get("education", []))}
36
- """
37
- return resume_text.strip()
38
-
39
- # ---------------------------------------------
40
- # JOB DESCRIPTION PROCESSING
41
- # ---------------------------------------------
42
- def process_jd(self, jd_json):
43
- jd_text = f"""
44
- [JOB]
45
- Role: {jd_json.get("job_title", "")}
46
-
47
- Key Skills: {", ".join(jd_json.get("required_skills", []))}
48
- Skills: {", ".join(jd_json.get("required_skills", []))}
49
-
50
- Requirements:
51
- {" . ".join(jd_json.get("requirements", []))}
52
-
53
- Responsibilities:
54
- {" . ".join(jd_json.get("responsibilities", []))}
55
-
56
- Education:
57
- {", ".join(jd_json.get("education", []))}
58
- """
59
- return jd_text.strip()
60
-
61
- # ---------------------------------------------
62
- # EMBEDDING GENERATION
63
- # ---------------------------------------------
64
- def encode(self, text):
65
- """
66
- Convert text into embedding tensor.
67
- """
68
- return (
69
- self.model.encode(
70
- text,
71
- convert_to_tensor=True,
72
- normalize_embeddings=True
73
- )
74
- )
75
-
76
- # ---------------------------------------------
77
- # SIMILARITY CHECK (PYTORCH)
78
- # ---------------------------------------------
79
- def compare(self, resume_embedding, jd_embedding):
80
- """
81
- Compute cosine similarity using PyTorch.
82
- """
83
-
84
- # Ensure correct shape: [1, dim]
85
- resume_embedding = resume_embedding.unsqueeze(0) if resume_embedding.dim() == 1 else resume_embedding
86
- jd_embedding = jd_embedding.unsqueeze(0) if jd_embedding.dim() == 1 else jd_embedding
87
-
88
- similarity = F.cosine_similarity(
89
- resume_embedding,
90
- jd_embedding
91
- )
92
 
93
- return similarity.item()
 
 
 
 
 
1
  import torch.nn.functional as F
2
 
3
+ class Comparison:
 
 
 
 
 
 
 
4
  def __init__(self, model):
 
5
  self.model = model
6
 
7
+ def encode(self, texts):
8
+ return self.model.encode(texts, convert_to_tensor=True, normalize_embeddings=True)
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
9
 
10
+ def compare(self, resume, jd):
11
+ return F.cosine_similarity(jd, resume, dim=-1).tolist()
modules/pdf_to_json.py DELETED
@@ -1,162 +0,0 @@
1
- import os
2
- import re
3
- import json
4
- import torch
5
- from pathlib import Path
6
- from pypdf import PdfReader
7
- from transformers import AutoTokenizer, AutoModelForCausalLM
8
- from peft import PeftModel
9
-
10
- # =========================================================
11
- # ⚙️ CPU OPTIMIZATION (IMPORTANT for HF Spaces)
12
- # =========================================================
13
- torch.set_num_threads(max(1, os.cpu_count() - 1))
14
- os.environ["TOKENIZERS_PARALLELISM"] = "false"
15
-
16
-
17
- # =========================================================
18
- # 🧼 TEXT CLEANING
19
- # =========================================================
20
- def clean_resume_text(text: str) -> str:
21
- text = re.sub(r"[\x00-\x1F\x7F]", " ", text)
22
- text = text.replace("•", "-").replace("●", "-").replace("▪", "-")
23
- text = re.sub(r"[ \t]+", " ", text)
24
- text = re.sub(r"\n{3,}", "\n\n", text)
25
- return text.strip()
26
-
27
-
28
- # =========================================================
29
- # 🧠 STRUCTURE ENFORCEMENT
30
- # =========================================================
31
- def enforce_structure(text: str) -> str:
32
- sections = ["ABOUT", "EXPERIENCE", "EDUCATION", "SKILLS", "PROJECTS", "CERTIFICATIONS"]
33
-
34
- for s in sections:
35
- text = re.sub(
36
- rf"\b{s}\b",
37
- f"\n\n===== {s} =====\n",
38
- text,
39
- flags=re.I
40
- )
41
-
42
- return text
43
-
44
-
45
- # =========================================================
46
- # 🧾 PROMPT BUILDER
47
- # =========================================================
48
- def build_prompt(input_text: str) -> str:
49
- schema = {
50
- "name": None,
51
- "email": None,
52
- "location": None,
53
- "phone": None,
54
- "linkedin": None,
55
- "github": None,
56
- "work_experience": [],
57
- "skills": [],
58
- "projects": [],
59
- "education": [],
60
- "certifications": []
61
- }
62
-
63
- return f"""<|im_start|>system
64
- You are a strict JSON extraction engine for resumes.
65
-
66
- RULES:
67
- - Output ONLY valid JSON
68
- - No explanation
69
- - No markdown
70
- - Follow schema exactly
71
- - Use null if missing
72
- - Use [] for missing lists
73
- <|im_end|>
74
-
75
- <|im_start|>user
76
- Extract resume data strictly.
77
-
78
- Schema:
79
- {json.dumps(schema, indent=2)}
80
-
81
- RESUME:
82
- {input_text}
83
- <|im_end|>
84
- """
85
-
86
-
87
-
88
- # =========================================================
89
- # 📄 MAIN PIPELINE CLASS
90
- # =========================================================
91
- class PDFToJSON:
92
-
93
- def __init__(self, model, tokenizer):
94
- self.model = model
95
- self.tokenizer = tokenizer
96
-
97
- # -----------------------------------------------------
98
- # 📄 PDF → TEXT
99
- # -----------------------------------------------------
100
- def extract_text(self, resume_pdfs):
101
- cleaned_resumes = []
102
-
103
- for pdf in resume_pdfs:
104
- reader = PdfReader(pdf)
105
- text_pages = []
106
-
107
- for page in reader.pages:
108
- text = page.extract_text() or ""
109
- if text.strip():
110
- text_pages.append(text)
111
-
112
- full_text = "\n".join(text_pages)
113
- cleaned = clean_resume_text(full_text)
114
- structured = enforce_structure(cleaned)
115
-
116
- cleaned_resumes.append(structured)
117
-
118
- return cleaned_resumes
119
-
120
- # -----------------------------------------------------
121
- # 🧠 TEXT → JSON
122
- # -----------------------------------------------------
123
- def generate_json(self, resumes):
124
- results = []
125
-
126
- for resume in resumes:
127
-
128
- prompt = build_prompt(resume)
129
-
130
- inputs = self.tokenizer(
131
- prompt,
132
- return_tensors="pt",
133
- truncation=True,
134
- max_length=1800,
135
- padding=True
136
- )
137
-
138
- with torch.no_grad():
139
- output = self.model.generate(
140
- **inputs,
141
- max_new_tokens=500,
142
- do_sample=False,
143
- eos_token_id=self.tokenizer.eos_token_id,
144
- repetition_penalty=1.05,
145
- )
146
-
147
- input_len = inputs["input_ids"].shape[1]
148
- output = output[0][input_len:]
149
-
150
- response = self.tokenizer.decode(output, skip_special_tokens=True)
151
-
152
- try:
153
- match = re.search(r"\{[\s\S]*\}", response)
154
- parsed = json.loads(match.group())
155
- results.append(parsed)
156
- except:
157
- results.append({
158
- "error": "parse error",
159
- "raw_output": response[:300]
160
- })
161
-
162
- return results
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
modules/resume_parser.py ADDED
@@ -0,0 +1,41 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ import torch
2
+
3
+ class ResumeParser:
4
+ def __init__(self, model, tokenizer):
5
+ self.model = model
6
+ self.tokenizer = tokenizer
7
+
8
+ def format_data(self, txt):
9
+ prompt = f"""<|im_start|>system
10
+ Extract and format resume: name | role | years | skills | core skills | experiences | education | certifications.
11
+ Extract ONLY from input. NO inference or additions.
12
+ <|im_end|>
13
+
14
+ <|im_start|>user
15
+ {txt}
16
+ <|im_end|>
17
+
18
+ <|im_start|>assistant
19
+ """
20
+ return prompt
21
+
22
+
23
+ def parse(self, resume):
24
+
25
+ inputs = self.tokenizer(resume, return_tensors="pt", padding=False, truncation=True)
26
+
27
+ with torch.no_grad():
28
+ # Mixed precision for faster CPU inference
29
+ with torch.cpu.amp.autocast():
30
+ output = self.model.generate(
31
+ **inputs,
32
+ max_new_tokens=300,
33
+ do_sample=False,
34
+ use_cache=True # KV cache speeds up token generation
35
+ )
36
+
37
+ decoded = self.tokenizer.decode(output[0], skip_special_tokens=False)
38
+ decoded = decoded.split("<|im_start|>assistant\n")[1].split("\n<|im_end|>")[0]
39
+
40
+ return decoded
41
+
requirements.txt CHANGED
@@ -1,10 +1,7 @@
1
  fastapi
2
  uvicorn
3
- python-multipart
4
 
5
- pandas
6
  scikit-learn
7
- pypdf
8
 
9
  torch --index-url https://download.pytorch.org/whl/cpu
10
 
 
1
  fastapi
2
  uvicorn
 
3
 
 
4
  scikit-learn
 
5
 
6
  torch --index-url https://download.pytorch.org/whl/cpu
7