Spaces:
Sleeping
Sleeping
| import gradio as gr | |
| import torch | |
| from transformers import AutoTokenizer, AutoModelForCausalLM, pipeline | |
| import PyPDF2 | |
| import docx | |
| import io | |
| import re | |
| import numpy as np | |
| from sklearn.feature_extraction.text import TfidfVectorizer | |
| from sklearn.metrics.pairwise import cosine_similarity | |
| import nltk | |
| from collections import Counter | |
| import warnings | |
| import time | |
| import json | |
| warnings.filterwarnings("ignore") | |
| # Download required NLTK data | |
| try: | |
| nltk.data.find('tokenizers/punkt') | |
| except LookupError: | |
| try: | |
| nltk.download('punkt') | |
| except: | |
| nltk.download('punkt_tab') | |
| try: | |
| nltk.data.find('tokenizers/punkt_tab') | |
| except LookupError: | |
| nltk.download('punkt_tab') | |
| try: | |
| nltk.data.find('corpora/stopwords') | |
| except LookupError: | |
| nltk.download('stopwords') | |
| from nltk.corpus import stopwords | |
| from nltk.tokenize import word_tokenize, sent_tokenize | |
| class ModernATSAnalyzer: | |
| def __init__(self): | |
| self.progress_callback = None | |
| self.llm_pipeline = None | |
| self.embedding_model = None | |
| self.update_progress("🚀 Initializing AI models...", 5) | |
| # Initialize embedding model for semantic analysis | |
| try: | |
| from sentence_transformers import SentenceTransformer | |
| # Use latest 2025 optimized model for better understanding | |
| self.embedding_model = SentenceTransformer('all-MiniLM-L6-v2') | |
| self.update_progress("✅ Embedding model loaded", 15) | |
| except Exception as e: | |
| self.update_progress(f"❌ Embedding model failed: {str(e)}", 15) | |
| # Initialize LLM for intelligent analysis (using 2025 small models) | |
| try: | |
| # Try to load a small but capable 2025 model | |
| model_options = [ | |
| "microsoft/DialoGPT-small", # Fallback option | |
| "HuggingFaceTB/SmolLM2-135M", # 2025 efficient model | |
| "Qwen/Qwen2.5-0.5B" # 2025 small but powerful | |
| ] | |
| for model_name in model_options: | |
| try: | |
| self.llm_pipeline = pipeline( | |
| "text-generation", | |
| model=model_name, | |
| tokenizer=model_name, | |
| device=-1, # CPU | |
| max_length=512, | |
| do_sample=True, | |
| temperature=0.7, | |
| pad_token_id=50256 | |
| ) | |
| self.update_progress(f"✅ LLM loaded: {model_name}", 25) | |
| break | |
| except: | |
| continue | |
| if not self.llm_pipeline: | |
| self.update_progress("⚠️ Using rule-based analysis (LLM unavailable)", 25) | |
| except Exception as e: | |
| self.update_progress(f"⚠️ LLM initialization failed, using backup methods", 25) | |
| self.stop_words = set(stopwords.words('english')) | |
| self.tfidf_vectorizer = TfidfVectorizer(stop_words='english', max_features=1000) | |
| self.update_progress("🎯 System ready for analysis!", 30) | |
| def set_progress_callback(self, callback): | |
| self.progress_callback = callback | |
| def update_progress(self, message, progress): | |
| if self.progress_callback: | |
| self.progress_callback(message, progress) | |
| time.sleep(0.05) | |
| def extract_text_from_pdf(self, file_path): | |
| """Extract text from PDF file""" | |
| try: | |
| with open(file_path, 'rb') as file: | |
| pdf_reader = PyPDF2.PdfReader(file) | |
| text = "" | |
| for page in pdf_reader.pages: | |
| text += page.extract_text() + "\n" | |
| return text | |
| except Exception as e: | |
| return f"Error reading PDF: {str(e)}" | |
| def extract_text_from_docx(self, file_path): | |
| """Extract text from DOCX file""" | |
| try: | |
| doc = docx.Document(file_path) | |
| text = "" | |
| for paragraph in doc.paragraphs: | |
| text += paragraph.text + "\n" | |
| return text | |
| except Exception as e: | |
| return f"Error reading DOCX: {str(e)}" | |
| def clean_text(self, text): | |
| """Clean and normalize text""" | |
| text = re.sub(r'\s+', ' ', text) | |
| text = re.sub(r'[^\w\s.,()-]', ' ', text) | |
| return text.strip() | |
| def extract_dynamic_keywords(self, text, top_n=30): | |
| """Dynamically extract important keywords using NLP techniques""" | |
| # Clean text | |
| clean_text = self.clean_text(text.lower()) | |
| # Tokenize and filter | |
| words = word_tokenize(clean_text) | |
| words = [word for word in words if ( | |
| word.isalpha() and | |
| len(word) > 2 and | |
| word not in self.stop_words | |
| )] | |
| # Get word frequencies | |
| word_freq = Counter(words) | |
| # Extract phrases (bigrams and trigrams) | |
| sentences = sent_tokenize(text) | |
| phrases = [] | |
| for sentence in sentences: | |
| sentence_words = word_tokenize(sentence.lower()) | |
| sentence_words = [w for w in sentence_words if w.isalpha()] | |
| # Bigrams | |
| for i in range(len(sentence_words) - 1): | |
| bigram = f"{sentence_words[i]} {sentence_words[i+1]}" | |
| if len(bigram) > 6: # Avoid very short phrases | |
| phrases.append(bigram) | |
| # Trigrams for technical terms | |
| for i in range(len(sentence_words) - 2): | |
| trigram = f"{sentence_words[i]} {sentence_words[i+1]} {sentence_words[i+2]}" | |
| if len(trigram) > 10: | |
| phrases.append(trigram) | |
| phrase_freq = Counter(phrases) | |
| # Combine words and phrases | |
| keywords = [] | |
| # Add top words | |
| for word, freq in word_freq.most_common(top_n//2): | |
| keywords.append((word, freq, 'word')) | |
| # Add top phrases | |
| for phrase, freq in phrase_freq.most_common(top_n//2): | |
| if freq >= 2: # Only include phrases that appear multiple times | |
| keywords.append((phrase, freq, 'phrase')) | |
| return keywords | |
| def analyze_with_llm(self, resume_text, job_text): | |
| """Use LLM for intelligent analysis""" | |
| if not self.llm_pipeline: | |
| return self.fallback_analysis(resume_text, job_text) | |
| try: | |
| prompt = f"""Analyze this resume against the job description and provide a compatibility score out of 100. | |
| Job Description: | |
| {job_text[:500]}... | |
| Resume: | |
| {resume_text[:500]}... | |
| Provide analysis in this format: | |
| Score: [0-100] | |
| Skills Match: [description] | |
| Experience Match: [description] | |
| Key Gaps: [description] | |
| """ | |
| response = self.llm_pipeline(prompt, max_new_tokens=200, num_return_sequences=1) | |
| analysis_text = response[0]['generated_text'].split(prompt)[-1].strip() | |
| # Parse the response | |
| score_match = re.search(r'Score:\s*(\d+)', analysis_text) | |
| score = int(score_match.group(1)) if score_match else 50 | |
| return { | |
| 'overall_score': min(100, max(0, score)), | |
| 'analysis_text': analysis_text, | |
| 'method': 'LLM' | |
| } | |
| except Exception as e: | |
| return self.fallback_analysis(resume_text, job_text) | |
| def fallback_analysis(self, resume_text, job_text): | |
| """Sophisticated rule-based analysis as fallback""" | |
| # Extract keywords from both texts | |
| resume_keywords = self.extract_dynamic_keywords(resume_text) | |
| job_keywords = self.extract_dynamic_keywords(job_text) | |
| # Create keyword sets for comparison | |
| resume_terms = set([kw[0] for kw in resume_keywords]) | |
| job_terms = set([kw[0] for kw in job_keywords]) | |
| # Calculate various similarity metrics | |
| # 1. Keyword overlap | |
| overlap = len(resume_terms.intersection(job_terms)) | |
| keyword_score = (overlap / len(job_terms)) * 100 if job_terms else 0 | |
| # 2. TF-IDF Similarity | |
| try: | |
| tfidf_matrix = self.tfidf_vectorizer.fit_transform([resume_text, job_text]) | |
| tfidf_similarity = cosine_similarity(tfidf_matrix[0:1], tfidf_matrix[1:2])[0][0] * 100 | |
| except: | |
| tfidf_similarity = 0 | |
| # 3. Semantic similarity using embeddings | |
| semantic_score = 0 | |
| if self.embedding_model: | |
| try: | |
| resume_embedding = self.embedding_model.encode(resume_text[:512]) | |
| job_embedding = self.embedding_model.encode(job_text[:512]) | |
| semantic_score = cosine_similarity([resume_embedding], [job_embedding])[0][0] * 100 | |
| except: | |
| semantic_score = 0 | |
| # 4. Structure and length analysis | |
| structure_score = self.analyze_resume_structure(resume_text) | |
| # Weighted combination | |
| overall_score = ( | |
| keyword_score * 0.3 + | |
| tfidf_similarity * 0.25 + | |
| semantic_score * 0.25 + | |
| structure_score * 0.2 | |
| ) | |
| return { | |
| 'overall_score': min(100, max(0, overall_score)), | |
| 'keyword_score': keyword_score, | |
| 'tfidf_score': tfidf_similarity, | |
| 'semantic_score': semantic_score, | |
| 'structure_score': structure_score, | |
| 'resume_keywords': resume_keywords[:10], | |
| 'job_keywords': job_keywords[:10], | |
| 'common_keywords': list(resume_terms.intersection(job_terms))[:10], | |
| 'method': 'Advanced Rule-based' | |
| } | |
| def analyze_resume_structure(self, resume_text): | |
| """Analyze resume structure and formatting""" | |
| score = 100 | |
| # Check for essential sections | |
| sections = { | |
| 'contact': r'(email|phone|@|linkedin|github)', | |
| 'experience': r'(experience|work|employment|career|job)', | |
| 'education': r'(education|degree|university|college|school)', | |
| 'skills': r'(skills|technical|technologies|competencies|tools)' | |
| } | |
| sections_found = 0 | |
| for section, pattern in sections.items(): | |
| if re.search(pattern, resume_text, re.IGNORECASE): | |
| sections_found += 1 | |
| # Penalize missing sections | |
| section_penalty = (4 - sections_found) * 15 | |
| score -= section_penalty | |
| # Check word count | |
| word_count = len(resume_text.split()) | |
| if word_count < 150: | |
| score -= 30 | |
| elif word_count > 1200: | |
| score -= 10 | |
| # Check for bullet points or structure | |
| if '•' in resume_text or '-' in resume_text or '*' in resume_text: | |
| score += 5 | |
| # Check for years/dates (experience indicators) | |
| years_pattern = r'(20\d{2}|19\d{2})' | |
| if re.search(years_pattern, resume_text): | |
| score += 10 | |
| return max(0, min(100, score)) | |
| def generate_intelligent_suggestions(self, analysis_result): | |
| """Generate intelligent suggestions based on analysis""" | |
| suggestions = [] | |
| if analysis_result['method'] == 'LLM' and 'analysis_text' in analysis_result: | |
| # Extract suggestions from LLM response | |
| if 'Key Gaps:' in analysis_result['analysis_text']: | |
| gaps = analysis_result['analysis_text'].split('Key Gaps:')[-1].strip() | |
| suggestions.append(f"🎯 **Key Areas to Improve**: {gaps}") | |
| # Add rule-based suggestions | |
| score = analysis_result['overall_score'] | |
| if score < 40: | |
| suggestions.append("🚨 **Critical**: Your resume needs major optimization. Consider professional resume writing services.") | |
| elif score < 60: | |
| suggestions.append("⚠️ **Moderate Compatibility**: Your resume shows potential but needs significant keyword optimization.") | |
| elif score < 80: | |
| suggestions.append("👍 **Good Foundation**: You're on the right track. Focus on fine-tuning keywords and formatting.") | |
| else: | |
| suggestions.append("✅ **Excellent**: Your resume shows strong compatibility with this job!") | |
| # Specific suggestions based on analysis components | |
| if 'keyword_score' in analysis_result and analysis_result['keyword_score'] < 40: | |
| suggestions.append("🔑 **Keywords**: Incorporate more relevant keywords from the job description naturally into your resume content.") | |
| if 'structure_score' in analysis_result and analysis_result['structure_score'] < 70: | |
| suggestions.append("📋 **Structure**: Improve resume formatting with clear sections: Contact, Experience, Education, Skills.") | |
| if 'semantic_score' in analysis_result and analysis_result['semantic_score'] < 50: | |
| suggestions.append("🎨 **Content Alignment**: Rewrite your experience descriptions to better match the job's language and requirements.") | |
| # Add common ATS tips | |
| suggestions.append("💡 **ATS Tips**: Use standard fonts, avoid images/graphics, save as PDF, and use keywords in context rather than just listing them.") | |
| return suggestions | |
| def process_resume_analysis(self, resume_file, job_description, progress=gr.Progress()): | |
| """Main analysis function""" | |
| try: | |
| def update_progress_ui(message, prog): | |
| progress(prog/100, desc=message) | |
| self.set_progress_callback(update_progress_ui) | |
| # Validation | |
| if resume_file is None: | |
| return "❌ Please upload a resume file.", "", "", "" | |
| if not job_description or len(job_description.strip()) < 50: | |
| return "❌ Please provide a detailed job description (at least 50 characters).", "", "", "" | |
| self.update_progress("📄 Extracting text from resume...", 35) | |
| # Extract resume text | |
| filename = str(resume_file).lower() | |
| if filename.endswith('.pdf'): | |
| resume_text = self.extract_text_from_pdf(resume_file) | |
| elif filename.endswith('.docx'): | |
| resume_text = self.extract_text_from_docx(resume_file) | |
| else: | |
| return f"❌ Unsupported file format. Please upload PDF or DOCX files.", "", "", "" | |
| if "Error reading" in resume_text: | |
| return resume_text, "", "", "" | |
| if len(resume_text.strip()) < 100: | |
| return "❌ Resume text is too short or couldn't be extracted. Please ensure your file contains readable text.", "", "", "" | |
| self.update_progress("🧠 Analyzing with AI...", 50) | |
| # Perform AI analysis | |
| analysis_result = self.analyze_with_llm(resume_text, job_description) | |
| self.update_progress("💡 Generating suggestions...", 80) | |
| # Generate suggestions | |
| suggestions = self.generate_intelligent_suggestions(analysis_result) | |
| self.update_progress("✅ Analysis complete!", 100) | |
| # Format results | |
| score = analysis_result['overall_score'] | |
| if score >= 85: | |
| emoji = "🟢" | |
| status = "Excellent Match" | |
| elif score >= 70: | |
| emoji = "🟡" | |
| status = "Good Compatibility" | |
| elif score >= 50: | |
| emoji = "🟠" | |
| status = "Moderate Match" | |
| else: | |
| emoji = "🔴" | |
| status = "Needs Improvement" | |
| score_text = f"# 🎯 ATS Compatibility Score: {score:.0f}/100\n\n{emoji} **{status}**" | |
| # Detailed breakdown | |
| details = f"""## 📊 Analysis Breakdown | |
| **Analysis Method**: {analysis_result['method']} | |
| **Overall Score**: {score:.1f}/100 | |
| """ | |
| if 'keyword_score' in analysis_result: | |
| details += f""" | |
| **Keyword Match**: {analysis_result['keyword_score']:.1f}/100 | |
| **Content Similarity**: {analysis_result.get('tfidf_score', 0):.1f}/100 | |
| **Semantic Match**: {analysis_result.get('semantic_score', 0):.1f}/100 | |
| **Structure Quality**: {analysis_result.get('structure_score', 0):.1f}/100 | |
| """ | |
| suggestions_text = "## 💡 Improvement Recommendations\n\n" + "\n\n".join(suggestions) | |
| # Keywords analysis | |
| keywords_text = "## 🔍 Keyword Analysis\n\n" | |
| if 'resume_keywords' in analysis_result: | |
| resume_kw = [kw[0] for kw in analysis_result['resume_keywords']] | |
| job_kw = [kw[0] for kw in analysis_result['job_keywords']] | |
| common_kw = analysis_result.get('common_keywords', []) | |
| keywords_text += f"""**Resume Keywords**: {', '.join(resume_kw)} | |
| **Job Keywords**: {', '.join(job_kw)} | |
| **Matching Keywords**: {', '.join(common_kw) if common_kw else 'Limited overlap detected'} | |
| **Recommendation**: Focus on incorporating more job-specific keywords naturally into your resume content. | |
| """ | |
| else: | |
| keywords_text += "**Dynamic keyword extraction completed.** The analysis considered context and semantic meaning rather than simple keyword matching." | |
| return score_text, details, suggestions_text, keywords_text | |
| except Exception as e: | |
| return f"❌ Analysis error: {str(e)}\n\nPlease try again or contact support.", "", "", "" | |
| # Initialize analyzer | |
| analyzer = ModernATSAnalyzer() | |
| def create_interface(): | |
| with gr.Blocks(title="Modern ATS Analyzer 2025", theme=gr.themes.Soft()) as interface: | |
| gr.HTML(""" | |
| <div style='text-align: center; padding: 20px; background: linear-gradient(90deg, #667eea 0%, #764ba2 100%); color: white; border-radius: 10px; margin-bottom: 20px;'> | |
| <h1>🤖 Modern ATS Resume Analyzer 2025</h1> | |
| <p style='font-size: 16px; margin: 10px 0;'>Powered by Latest AI Models | Dynamic Keyword Extraction | Intelligent Analysis</p> | |
| <p style='font-size: 14px; opacity: 0.9;'>No predefined keywords - Real ATS-like analysis using 2025 AI technology</p> | |
| </div> | |
| """) | |
| with gr.Row(): | |
| with gr.Column(scale=1): | |
| gr.HTML("<h3>📄 Upload Resume</h3>") | |
| resume_file = gr.File( | |
| label="Upload Resume (PDF/DOCX)", | |
| file_types=[".pdf", ".docx"], | |
| type="filepath" | |
| ) | |
| gr.HTML("<h3>📋 Job Description</h3>") | |
| job_description = gr.Textbox( | |
| label="Paste Complete Job Description", | |
| placeholder="Paste the full job posting including requirements, responsibilities, qualifications, and company information...", | |
| lines=15, | |
| max_lines=25 | |
| ) | |
| analyze_btn = gr.Button("🚀 Analyze with Modern AI", variant="primary", size="lg") | |
| gr.HTML(""" | |
| <div style='margin-top: 15px; padding: 15px; background: #f0f8ff; border-radius: 8px; border-left: 4px solid #4CAF50;'> | |
| <h4 style='margin: 0 0 10px 0; color: #2E7D32;'>🎯 What makes this different:</h4> | |
| <ul style='margin: 0; padding-left: 20px; color: #424242;'> | |
| <li><strong>No predefined keywords</strong> - Dynamically extracts relevant terms</li> | |
| <li><strong>2025 AI models</strong> - Uses latest language understanding</li> | |
| <li><strong>Context-aware</strong> - Understands meaning, not just word matching</li> | |
| <li><strong>Real ATS simulation</strong> - Mimics actual hiring systems</li> | |
| </ul> | |
| </div> | |
| """) | |
| with gr.Column(scale=1): | |
| score_output = gr.Markdown(label="🎯 Compatibility Score") | |
| details_output = gr.Markdown(label="📊 Detailed Analysis") | |
| suggestions_output = gr.Markdown(label="💡 AI Recommendations") | |
| keywords_output = gr.Markdown(label="🔍 Keyword Intelligence") | |
| analyze_btn.click( | |
| fn=analyzer.process_resume_analysis, | |
| inputs=[resume_file, job_description], | |
| outputs=[score_output, details_output, suggestions_output, keywords_output] | |
| ) | |
| gr.HTML(""" | |
| <div style='text-align: center; padding: 20px; margin-top: 30px; border-top: 2px solid #e0e0e0; background: #fafafa; border-radius: 8px;'> | |
| <h4 style='color: #333; margin-bottom: 15px;'>🧠 AI-Powered Analysis Engine</h4> | |
| <div style='display: flex; justify-content: space-around; flex-wrap: wrap;'> | |
| <div style='margin: 10px; text-align: center;'> | |
| <strong style='color: #1976D2;'>🎯 Dynamic Keywords</strong><br> | |
| <span style='font-size: 12px; color: #666;'>Extracts context-relevant terms</span> | |
| </div> | |
| <div style='margin: 10px; text-align: center;'> | |
| <strong style='color: #388E3C;'>🧠 Semantic Analysis</strong><br> | |
| <span style='font-size: 12px; color: #666;'>Understands meaning & context</span> | |
| </div> | |
| <div style='margin: 10px; text-align: center;'> | |
| <strong style='color: #F57C00;'>📊 Multi-metric Scoring</strong><br> | |
| <span style='font-size: 12px; color: #666;'>Comprehensive compatibility analysis</span> | |
| </div> | |
| <div style='margin: 10px; text-align: center;'> | |
| <strong style='color: #7B1FA2;'>💡 AI Suggestions</strong><br> | |
| <span style='font-size: 12px; color: #666;'>Personalized improvement tips</span> | |
| </div> | |
| </div> | |
| <p style='margin-top: 15px; font-size: 13px; color: #777;'> | |
| <em>Optimized for CPU inference • 2025 Model Architecture • Enterprise-grade Analysis</em> | |
| </p> | |
| </div> | |
| """) | |
| return interface | |
| if __name__ == "__main__": | |
| app = create_interface() | |
| app.launch( | |
| server_name="0.0.0.0", | |
| server_port=7860, | |
| share=True | |
| ) |