Instructions to use hitrohitro/ResumeScreener with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Libraries

How to use hitrohitro/ResumeScreener with PEFT:

from peft import PeftModel
from transformers import AutoModelForCausalLM

base_model = AutoModelForCausalLM.from_pretrained("unsloth/qwen3-4b-instruct-2507-unsloth-bnb-4bit")
model = PeftModel.from_pretrained(base_model, "hitrohitro/ResumeScreener")

Transformers

How to use hitrohitro/ResumeScreener with Transformers:

# Use a pipeline as a high-level helper
from transformers import pipeline

pipe = pipeline("text-generation", model="hitrohitro/ResumeScreener")
messages = [
    {"role": "user", "content": "Who are you?"},
]
pipe(messages)

# Load model directly
from transformers import AutoModel
model = AutoModel.from_pretrained("hitrohitro/ResumeScreener", dtype="auto")

Notebooks
Google Colab
Kaggle
Local Apps

vLLM

How to use hitrohitro/ResumeScreener with vLLM:

Install from pip and serve model

# Install vLLM from pip:
pip install vllm
# Start the vLLM server:
vllm serve "hitrohitro/ResumeScreener"
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:8000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "hitrohitro/ResumeScreener",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Use Docker

docker model run hf.co/hitrohitro/ResumeScreener

SGLang

How to use hitrohitro/ResumeScreener with SGLang:

Install from pip and serve model

# Install SGLang from pip:
pip install sglang
# Start the SGLang server:
python3 -m sglang.launch_server \
    --model-path "hitrohitro/ResumeScreener" \
    --host 0.0.0.0 \
    --port 30000
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:30000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "hitrohitro/ResumeScreener",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Use Docker images

docker run --gpus all \
    --shm-size 32g \
    -p 30000:30000 \
    -v ~/.cache/huggingface:/root/.cache/huggingface \
    --env "HF_TOKEN=<secret>" \
    --ipc=host \
    lmsysorg/sglang:latest \
    python3 -m sglang.launch_server \
        --model-path "hitrohitro/ResumeScreener" \
        --host 0.0.0.0 \
        --port 30000
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:30000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "hitrohitro/ResumeScreener",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Unsloth Studio new

How to use hitrohitro/ResumeScreener with Unsloth Studio:

Install Unsloth Studio (macOS, Linux, WSL)

curl -fsSL https://unsloth.ai/install.sh | sh
# Run unsloth studio
unsloth studio -H 0.0.0.0 -p 8888
# Then open http://localhost:8888 in your browser
# Search for hitrohitro/ResumeScreener to start chatting

Install Unsloth Studio (Windows)

irm https://unsloth.ai/install.ps1 | iex
# Run unsloth studio
unsloth studio -H 0.0.0.0 -p 8888
# Then open http://localhost:8888 in your browser
# Search for hitrohitro/ResumeScreener to start chatting

Using HuggingFace Spaces for Unsloth

# No setup required
# Open https://huggingface.co/spaces/unsloth/studio in your browser
# Search for hitrohitro/ResumeScreener to start chatting

Load model with FastModel

pip install unsloth
from unsloth import FastModel
model, tokenizer = FastModel.from_pretrained(
    model_name="hitrohitro/ResumeScreener",
    max_seq_length=2048,
)

Docker Model Runner
How to use hitrohitro/ResumeScreener with Docker Model Runner:
```
docker model run hf.co/hitrohitro/ResumeScreener
```

Model Card for HireSense Resume Parser LoRA

Model Details

Model Description

HireSense Resume Parser LoRA is a fine-tuned adapter model built on top of Qwen3-4B-Instruct using QLoRA and supervised fine-tuning (SFT). The model is designed to extract structured JSON information from resumes for downstream recruitment and candidate-job matching workflows.

The model converts raw resume text into a consistent structured schema containing:

Personal information
Skills
Education
Work experience
Projects
Certifications

This model is intended to be used as a component in AI-powered hiring pipelines and resume analysis systems.

Developed by: Rohit BK
Model type: Causal Language Model (LoRA Adapter)
Language(s): English
License: Apache-2.0
Finetuned from model: unsloth/qwen3-4b-instruct-2507-unsloth-bnb-4bit

Model Sources

Base Model: Qwen3-4B-Instruct
Frameworks: Transformers, PEFT, TRL, Unsloth

Uses

Direct Use

This model is intended for:

Resume parsing
Structured information extraction
Candidate profile generation
Resume-to-JSON conversion
Recruitment automation systems

Example output schema:

{
  "name": "John Doe",
  "email": "john@example.com",
  "phone": "9876543210",
  "skills": ["Python", "React", "SQL"],
  "education": [
    {
      "degree": "B.Tech",
      "institution": "XYZ University",
      "year": "2025"
    }
  ]
}

Downstream Use

The model can be integrated into:

Applicant Tracking Systems (ATS)
Resume ranking systems
Semantic candidate matching pipelines
Recruitment copilots
Hiring analytics dashboards

Out-of-Scope Use

This model is NOT intended for:

Final hiring decisions
Automated candidate rejection without human review
Personality assessment
Predicting candidate success
Sensitive demographic inference

Human oversight is strongly recommended.

Bias, Risks, and Limitations

The model may:

Produce incorrect or incomplete JSON
Miss information in poorly formatted resumes
Exhibit biases inherited from training data
Struggle with multilingual resumes
Perform inconsistently on highly creative resume layouts

The model should not be used as the sole decision-maker in hiring processes.

Recommendations

Users should:

Validate generated outputs before use
Use human review for hiring decisions
Combine the model with rule-based validation systems
Avoid relying solely on generated scores or rankings

How to Get Started with the Model

from transformers import AutoModelForCausalLM, AutoTokenizer
from peft import PeftModel

base_model_id = "Qwen/Qwen3-4B-Instruct"
adapter_id = "YOUR_USERNAME/HireSense-ResumeParser-LoRA"

tokenizer = AutoTokenizer.from_pretrained(base_model_id)

base_model = AutoModelForCausalLM.from_pretrained(
    base_model_id,
    device_map="auto"
)

model = PeftModel.from_pretrained(base_model, adapter_id)

prompt = """
Extract structured JSON information from the following resume.

Resume:
John Doe
Python Developer
Skills: Python, React, SQL
"""

inputs = tokenizer(prompt, return_tensors="pt").to(model.device)

outputs = model.generate(
    **inputs,
    max_new_tokens=256
)

print(tokenizer.decode(outputs[0], skip_special_tokens=True))

Training Details

Training Data

The model was trained on structured resume-to-JSON instruction pairs containing:

Resume text
Extraction prompts
Structured JSON outputs

Training data included synthetic and manually curated resume samples.

Training Procedure

The model was fine-tuned using:

QLoRA
Supervised Fine-Tuning (SFT)
4-bit quantization
PEFT adapters

Training Hyperparameters

Training regime: bf16 mixed precision
Fine-tuning method: QLoRA
Quantization: 4-bit NF4
Optimizer: AdamW
Frameworks: Transformers + TRL + Unsloth

Evaluation

Metrics

The model was evaluated qualitatively on:

JSON validity
Field extraction accuracy
Structural consistency
Hallucination frequency

Results

The model demonstrated:

Consistent JSON generation
Good extraction performance on structured resumes
Improved formatting consistency compared to the base model

Performance may degrade on:

Image-based resumes
Multi-column layouts
Highly unstructured resumes

Environmental Impact

Hardware Type: NVIDIA GPU
Training Framework: Unsloth
Quantization: 4-bit QLoRA

Technical Specifications

Model Architecture and Objective

This model uses:

Qwen3-4B-Instruct as the base model
LoRA adapters for parameter-efficient fine-tuning
Causal language modeling objective

Citation

BibTeX

@misc{hiresense2026,
  title={HireSense Resume Parser LoRA},
  author={Rohit BK},
  year={2026},
  publisher={Hugging Face}
}

Model Card Authors

Rohit BK

Model Card Contact

For questions or collaboration inquiries, please contact through Hugging Face or GitHub.

Framework versions

PEFT 0.19.1
Transformers
TRL
Unsloth

Downloads last month: 23