Fix: use git lfs for large model files

.gitattributes

@@ -33,3 +33,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+*.json filter=lfs diff=lfs merge=lfs -text
+models/** filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,12 @@
+FROM python:3.10
+
+WORKDIR /app
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+
+EXPOSE 7860
+
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -1,11 +1,31 @@
+# 🧠 HR Tool Backend (AI Resume Intelligence System)
+
+A production-ready AI-powered HR system that:
+- Extracts structured resume data using **Qwen2.5-0.5B + LoRA**
+- Matches resumes with job descriptions using **MiniLM embeddings**
+- Provides semantic ATS scoring via **FastAPI backend**
+- Designed for deployment on **Hugging Face Spaces / Docker**
+
 ---
-title: HR TOOL V2
-emoji: 📊
-colorFrom: gray
-colorTo: blue
-sdk: docker
-pinned: false
-short_description: HR tool to find best candidates for the role
+
+# 🚀 Features
+
+### 📄 Resume Intelligence
+- PDF → Clean text extraction
+- LLM-based structured JSON generation
+- Strict schema-based output (no hallucination design)
+
+### 🧠 Semantic Matching (ATS)
+- Resume ↔ Job Description similarity
+- Uses `sentence-transformers/all-MiniLM-L6-v2`
+- Cosine similarity scoring (0–100 ATS score)
+
+### ⚡ FastAPI Backend
+- Upload resume PDFs
+- Get structured JSON output
+- Compare with job descriptions
+- Get ranking score
+
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# 🏗️ System Architecture

main.py

@@ -0,0 +1,137 @@
+from fastapi import FastAPI, UploadFile, File, Form
+from typing import List
+import json
+import time
+import os
+import uuid
+
+from modules.pdf_to_json import PDFToJSON
+from modules.comparison import CompareData
+
+app = FastAPI()
+
+pdf_to_json = PDFToJSON()
+compare = CompareData()
+
+THRESHOLD = 0.675
+
+
+# ---------------------------------------------
+# HEALTH CHECK
+# ---------------------------------------------
+@app.get("/")
+def home():
+    return {"status": "ATS API Running 🚀"}
+
+
+# ---------------------------------------------
+# MAIN MATCHING ENDPOINT
+# ---------------------------------------------
+@app.post("/match-resumes/")
+async def match_resumes(
+    jd: str = Form(...),
+    files: List[UploadFile] = File(...)
+):
+    start_time = time.time()
+
+    print("\n================= NEW REQUEST =================\n")
+
+    # -----------------------------------------
+    # Parse JD
+    # -----------------------------------------
+    print("📌 Step 1: Parsing Job Description...")
+    try:
+        jd = json.loads(jd)
+        print("✅ JD parsed successfully\n")
+    except Exception as e:
+        print("❌ JD parsing failed")
+        return {"error": "Invalid JD format", "details": str(e)}
+
+    results = []
+
+    temp_dir = "./temp"
+    os.makedirs(temp_dir, exist_ok=True)
+
+    print(f"📥 Total resumes received: {len(files)}\n")
+
+    # -----------------------------------------
+    # PROCESS EACH RESUME
+    # -----------------------------------------
+    for idx, file in enumerate(files):
+
+        print(f"\n---------------------------------------------")
+        print(f"📄 Processing Resume {idx + 1}/{len(files)}: {file.filename}")
+        print(f"---------------------------------------------")
+
+        # ✅ UNIQUE FILE NAME (IMPORTANT FOR PUBLIC APIS)
+        file_path = os.path.join(temp_dir, f"{uuid.uuid4()}.pdf")
+
+        try:
+            # STEP 1: Save file
+            print("💾 Step 1: Saving file...")
+            with open(file_path, "wb") as f:
+                f.write(await file.read())
+            print("✅ File saved")
+
+            # STEP 2: Extract text
+            print("📄 Step 2: Extracting PDF text...")
+            resume_texts = pdf_to_json.extract_text([file_path])
+            print("✅ Text extracted")
+
+            # STEP 3: Convert to JSON
+            print("🧠 Step 3: Generating structured JSON...")
+            resume_json = pdf_to_json.generate_json(resume_texts)[0]
+            print("✅ JSON generated")
+
+            # STEP 4: Process text
+            print("⚙️ Step 4: Preparing embeddings input...")
+            processed_resume = compare.process_resume(resume_json)
+            processed_jd = compare.process_jd(jd)
+            print("✅ Text processed")
+
+            # STEP 5: Encoding
+            print("🔢 Step 5: Generating embeddings...")
+            resume_emb = compare.encode(processed_resume)
+            jd_emb = compare.encode(processed_jd)
+            print("✅ Embeddings created")
+
+            # STEP 6: Similarity
+            print("📊 Step 6: Calculating similarity score...")
+            score = compare.compare(resume_emb, jd_emb)
+            print(f"📊 Score: {score}")
+
+            # STEP 7: Name extraction
+            name = resume_json.get("name", "Unknown")
+
+            # STEP 8: Filter
+            if score >= THRESHOLD:
+                print("✅ Candidate QUALIFIED")
+                results.append({
+                    "name": name,
+                    "score": float(score),
+                    "resume": resume_json
+                })
+            else:
+                print("❌ Candidate rejected (below threshold)")
+
+        finally:
+            # -----------------------------------------
+            # 🧹 DELETE FILE AFTER PROCESSING
+            # -----------------------------------------
+            if os.path.exists(file_path):
+                os.remove(file_path)
+                print(f"🧹 Deleted temp file")
+
+    # ---------------------------------------------
+    # FINAL RESPONSE
+    # ---------------------------------------------
+    end_time = time.time()
+
+    print("\n================= PROCESS COMPLETE =================\n")
+
+    return {
+        "threshold": THRESHOLD,
+        "total_matched": len(results),
+        "processing_time_seconds": round(end_time - start_time, 2),
+        "candidates": results
+    }

models/mnr_1/1_Pooling/config.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bb80272f7adad76ce93073c25e18113ee66be1e91f60bcdd72aa41d05b28247e
+size 94

models/mnr_1/README.md

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:033d5318e3d7d204f46d47b7418bf5ab8b22f0d4ea0228fdf447887dcfedb827
+size 34954

models/mnr_1/config.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6e48034f60114d869b2a3e418d67af0220004a228e6db788af845503c4c14465
+size 774

models/mnr_1/config_sentence_transformers.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:70f27f0e7e4ba5617be48ae690066b2c237dad02474162b4c11bbcec1c6b7d9d
+size 296

models/mnr_1/model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b4676b573b8c272d1383fee4b0aa61ed07c91f0208250e8e5ef0e3ed1ecbaf79
+size 90864192

models/mnr_1/modules.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5286260f53f0f5d318eb02f1565fd30f7ec7c6d305f41ad29e2bb3ec974046a6
+size 448

models/mnr_1/sentence_bert_config.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5fee3fcdc4a727fad422f0fed0c867b0921eefa9051de221521956ed42eb4c19
+size 250

models/mnr_1/tokenizer.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:851ca67100d372ca3ae031a6abd168f53489eebfd7d89523f35c5c9b4d372c3c
+size 711649

models/mnr_1/tokenizer_config.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e9becfd25977397187a9f9359494ed9682d6f93bb58dda91da6cb36e02ef770e
+size 618

models/qwen-2.5-v2/README.md

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fd061e0e548c4f35c292a198bbf8b94ff5e571c568474aa4fc08b8b806de09c7
+size 1518

models/qwen-2.5-v2/checkpoint-1010/README.md

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e1f8400c63a37fa69b4a09c9e7053061e40b2fe3e8951e5a8a1767b375b791ea
+size 5268

models/qwen-2.5-v2/checkpoint-1010/adapter_config.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:43a3c15cc9bfdc8c64fb67bd97850c0587a5e014c5b761f9c01eaba09e9482f0
+size 1311

models/qwen-2.5-v2/checkpoint-1010/adapter_model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8ba09c8697ba3535b4c56bb91d91acd5eb572bc0cc86c8013a8044b7150ec026
+size 17640136

models/qwen-2.5-v2/checkpoint-1010/chat_template.jinja

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8aa40ce145adb73cb3a75194dc0224702a95850ec5275cabb728496bbd749fc6
+size 2561

models/qwen-2.5-v2/checkpoint-1010/optimizer.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a4e5e181469198b65485d25184ebfb1e51b34c4de79c3a93ce332df2521d62d0
+size 35479763

models/qwen-2.5-v2/checkpoint-1010/rng_state.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1bf37342a4e2004e2b59ecd956410c6d91e61253e6fd30356e13956f4c914499
+size 14645

models/qwen-2.5-v2/checkpoint-1010/scheduler.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ca3c880af772c4eb36603de9b9924cc5e93c3999fa5c27fa211190ead91c940d
+size 1465

models/qwen-2.5-v2/checkpoint-1010/tokenizer.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:01c060135db283a7f3530c39cddd55bbac96eeb2ba8a6da6c8a103f47c8be824
+size 11422455

models/qwen-2.5-v2/checkpoint-1010/tokenizer_config.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b2c7a957149820032339cd91546b9b919ef32f9dd1f36dfcb9c65526364a22b7
+size 4764

models/qwen-2.5-v2/checkpoint-1010/trainer_state.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:00464c5228b2d6f8ae37eda5bfe7225c8d4ec39df826d8b6f5bb14f28de43b32
+size 19475

models/qwen-2.5-v2/checkpoint-1010/training_args.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:43f28af2137e96a50c528960dfb51cc8bb17eb7510646a7d6e556c54bb882ce2
+size 5585

modules/comparison.py

@@ -0,0 +1,109 @@
+from sentence_transformers import SentenceTransformer
+from pathlib import Path
+import torch
+import torch.nn.functional as F
+
+
+model = None
+def get_model(base_path):
+    global model
+    if model is None:
+        from sentence_transformers import SentenceTransformer
+        model = SentenceTransformer(base_path)
+    return model
+
+class CompareData:
+    """
+    Converts resume and job description JSON into embeddings
+    and compares them using PyTorch cosine similarity.
+    """
+
+    def __init__(self, model_path="models/mnr_1"):
+        # ---------------------------------------------
+        # Resolve absolute path safely
+        # ---------------------------------------------
+        base_dir = Path(__file__).resolve().parents[1]
+        absolute_model_path = base_dir / model_path
+
+        print("📦 Loading model from:", absolute_model_path)
+
+        # Load SentenceTransformer model
+        self.model = get_model(str(absolute_model_path))
+
+    # ---------------------------------------------
+    # RESUME PROCESSING
+    # ---------------------------------------------
+    def process_resume(self, resume_json):
+        resume_text = f"""
+[RESUME]
+Role: {resume_json.get("role", "")}
+
+Key Skills: {", ".join(resume_json.get("skills", []))}
+Skills: {", ".join(resume_json.get("skills", []))}
+
+Experience: {resume_json.get("years_of_experience", 0)} years
+
+Work Experience:
+{" . ".join(resume_json.get("work_experience", []))}
+
+Education:
+{", ".join(resume_json.get("education", []))}
+"""
+        return resume_text.strip()
+
+    # ---------------------------------------------
+    # JOB DESCRIPTION PROCESSING
+    # ---------------------------------------------
+    def process_jd(self, jd_json):
+        jd_text = f"""
+[JOB]
+Role: {jd_json.get("job_title", "")}
+
+Key Skills: {", ".join(jd_json.get("required_skills", []))}
+Skills: {", ".join(jd_json.get("required_skills", []))}
+
+Requirements:
+{" . ".join(jd_json.get("requirements", []))}
+
+Responsibilities:
+{" . ".join(jd_json.get("responsibilities", []))}
+
+Education:
+{", ".join(jd_json.get("education", []))}
+"""
+        return jd_text.strip()
+
+    # ---------------------------------------------
+    # EMBEDDING GENERATION
+    # ---------------------------------------------
+    def encode(self, text):
+        """
+        Convert text into embedding tensor.
+        """
+        return torch.tensor(
+            self.model.encode(
+                text,
+                convert_to_numpy=True,
+                normalize_embeddings=True
+            ),
+            dtype=torch.float32
+        )
+
+    # ---------------------------------------------
+    # SIMILARITY CHECK (PYTORCH)
+    # ---------------------------------------------
+    def compare(self, resume_embedding, jd_embedding):
+        """
+        Compute cosine similarity using PyTorch.
+        """
+
+        # Ensure correct shape: [1, dim]
+        resume_embedding = resume_embedding.unsqueeze(0) if resume_embedding.dim() == 1 else resume_embedding
+        jd_embedding = jd_embedding.unsqueeze(0) if jd_embedding.dim() == 1 else jd_embedding
+
+        similarity = F.cosine_similarity(
+            resume_embedding,
+            jd_embedding
+        )
+
+        return similarity.item()

modules/pdf_to_json.py

@@ -0,0 +1,211 @@
+import os
+import re
+import json
+import torch
+from pathlib import Path
+from pypdf import PdfReader
+from transformers import AutoTokenizer, AutoModelForCausalLM
+from peft import PeftModel
+
+# =========================================================
+# ⚙️ CPU OPTIMIZATION (IMPORTANT for HF Spaces)
+# =========================================================
+torch.set_num_threads(max(1, os.cpu_count() - 1))
+os.environ["TOKENIZERS_PARALLELISM"] = "false"
+
+
+# =========================================================
+# 🧼 TEXT CLEANING
+# =========================================================
+def clean_resume_text(text: str) -> str:
+    text = re.sub(r"[\x00-\x1F\x7F]", " ", text)
+    text = text.replace("•", "-").replace("●", "-").replace("▪", "-")
+    text = re.sub(r"[ \t]+", " ", text)
+    text = re.sub(r"\n{3,}", "\n\n", text)
+    return text.strip()
+
+
+# =========================================================
+# 🧠 STRUCTURE ENFORCEMENT
+# =========================================================
+def enforce_structure(text: str) -> str:
+    sections = ["ABOUT", "EXPERIENCE", "EDUCATION", "SKILLS", "PROJECTS", "CERTIFICATIONS"]
+
+    for s in sections:
+        text = re.sub(
+            rf"\b{s}\b",
+            f"\n\n===== {s} =====\n",
+            text,
+            flags=re.I
+        )
+
+    return text
+
+
+# =========================================================
+# 🧾 PROMPT BUILDER
+# =========================================================
+def build_prompt(input_text: str) -> str:
+    schema = {
+        "name": None,
+        "email": None,
+        "location": None,
+        "phone": None,
+        "linkedin": None,
+        "github": None,
+        "work_experience": [],
+        "skills": [],
+        "projects": [],
+        "education": [],
+        "certifications": []
+    }
+
+    return f"""<|im_start|>system
+You are a strict JSON extraction engine for resumes.
+
+RULES:
+- Output ONLY valid JSON
+- No explanation
+- No markdown
+- Follow schema exactly
+- Use null if missing
+- Use [] for missing lists
+<|im_end|>
+
+<|im_start|>user
+Extract resume data strictly.
+
+Schema:
+{json.dumps(schema, indent=2)}
+
+RESUME:
+{input_text}
+<|im_end|>
+"""
+
+
+# =========================================================
+# 🤖 MODEL LOADER (SAFE + LAZY + HF FRIENDLY)
+# =========================================================
+class ModelLoader:
+    def __init__(self, base_model_name, adapter_path):
+        self.base_model_name = base_model_name
+        self.adapter_path = adapter_path
+        self.model = None
+        self.tokenizer = None
+
+    def load(self):
+        if self.model is None:
+
+            # Load tokenizer
+            self.tokenizer = AutoTokenizer.from_pretrained(self.base_model_name)
+            self.tokenizer.pad_token = self.tokenizer.eos_token
+
+            # Load base model
+            base_model = AutoModelForCausalLM.from_pretrained(
+                self.base_model_name,
+                torch_dtype=torch.float32,
+                device_map="cpu"
+            )
+
+            # Attach LoRA adapter
+            self.model = PeftModel.from_pretrained(base_model, self.adapter_path)
+            self.model.eval()
+
+            print("✅ Model Loaded Successfully")
+
+        return self.model, self.tokenizer
+
+
+# =========================================================
+# 📄 MAIN PIPELINE CLASS
+# =========================================================
+class PDFToJSON:
+
+    def __init__(self):
+        base_model_name = "Qwen/Qwen2.5-0.5B-Instruct"
+
+        adapter_path = os.path.abspath(
+            os.path.join(
+                os.path.dirname(__file__),
+                "../models/qwen-2.5-v2/checkpoint-1010"
+            )
+        )
+
+        self.loader = ModelLoader(base_model_name, adapter_path)
+
+    # -----------------------------------------------------
+    # 📄 PDF → TEXT
+    # -----------------------------------------------------
+    def extract_text(self, resume_pdfs):
+        cleaned_resumes = []
+
+        for pdf in resume_pdfs:
+            reader = PdfReader(pdf)
+            text_pages = []
+
+            for page in reader.pages:
+                text = page.extract_text() or ""
+                if text.strip():
+                    text_pages.append(text)
+
+            full_text = "\n".join(text_pages)
+            cleaned = clean_resume_text(full_text)
+            structured = enforce_structure(cleaned)
+
+            cleaned_resumes.append(structured)
+
+        return cleaned_resumes
+
+    # -----------------------------------------------------
+    # 🧠 TEXT → JSON
+    # -----------------------------------------------------
+    def generate_json(self, resumes):
+        model, tokenizer = self.loader.load()
+        results = []
+
+        for resume in resumes:
+
+            prompt = build_prompt(resume)
+
+            inputs = tokenizer(
+                prompt,
+                return_tensors="pt",
+                truncation=True,
+                max_length=1800,
+                padding=True
+            )
+
+            with torch.no_grad():
+                output = model.generate(
+                    **inputs,
+                    max_new_tokens=500,
+                    do_sample=False,
+                    eos_token_id=tokenizer.eos_token_id,
+                    repetition_penalty=1.05,
+                )
+
+            input_len = inputs["input_ids"].shape[1]
+            output = output[0][input_len:]
+
+            response = tokenizer.decode(output, skip_special_tokens=True)
+
+            # -------------------------------------------------
+            # 🧾 SAFE JSON PARSING
+            # -------------------------------------------------
+            try:
+                match = re.search(r"\{[\s\S]*\}", response)
+
+                if not match:
+                    raise ValueError("No JSON found in output")
+
+                parsed = json.loads(match.group())
+                results.append(parsed)
+
+            except Exception as e:
+                results.append({
+                    "error": str(e),
+                    "raw_output": response[:500]
+                })
+
+        return results

requirements.txt

@@ -0,0 +1,12 @@
+fastapi
+uvicorn
+python-multipart
+
+pandas
+scikit-learn
+pypdf
+
+torch
+transformers
+sentence-transformers
+peft