Upload 3 files

README.md

@@ -1,14 +1,19 @@
----
-title: Gen Ai
-emoji: 🐠
-colorFrom: red
-colorTo: blue
-sdk: gradio
-sdk_version: 5.29.0
-app_file: app.py
-pinned: false
-license: mit
-short_description: Resume analyzer
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+Resume Analyzer and Job Recommender
+This application uses BERT to analyze resumes and recommend suitable jobs based on the content. It also allows users to match their resume against specific job descriptions.
+
+Features
+Resume Analysis: Extract skills and key information from PDF resumes
+Job Recommendations: Get personalized job recommendations based on your resume
+Job Matching: See how well your resume matches a specific job posting and get improvement suggestions
+How to Use
+Upload your resume (PDF format) to get an analysis and job recommendations
+To match against a specific job, paste the job title and description in the second tab
+Review recommendations and suggestions to improve your job applications
+Technical Details
+Built with Gradio for the user interface
+Uses BERT for natural language understanding
+Implements cosine similarity for resume-job matching
+Provides actionable feedback for resume improvement
+Requirements
+See requirements.txt for a full list of dependencies.
+

app.py

@@ -0,0 +1,535 @@
+import os
+import re
+import numpy as np
+import pandas as pd
+import PyPDF2
+import torch
+from transformers import BertTokenizer, BertModel
+from sklearn.metrics.pairwise import cosine_similarity
+import gradio as gr
+
+# Load pre-trained BERT model
+tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
+model = BertModel.from_pretrained('bert-base-uncased')
+
+# Job database
+jobs_data = [
+    # Entry-Level Positions
+    {
+        "job_id": 1,
+        "title": "Junior Software Developer",
+        "company": "Tech Solutions Inc.",
+        "description": "Join our dynamic team in developing web applications and software solutions. You'll work on real projects using modern development practices and collaborate with senior developers who will mentor you in your growth journey.",
+        "requirements": "Bachelor's degree in Computer Science or related field. 0-1 years of experience. Knowledge of Python and web technologies (HTML, CSS, JavaScript). Familiarity with Git version control and basic database concepts."
+    },
+    {
+        "job_id": 2,
+        "title": "Data Analyst",
+        "company": "Data Insights Co.",
+        "description": "Help transform raw data into actionable insights. You'll create visualizations, prepare reports, and assist in building dashboards that drive business decisions. Perfect position for someone who loves finding patterns in data.",
+        "requirements": "Bachelor's degree in Statistics, Mathematics, or related field. 0-2 years of experience with data analysis. Proficiency in SQL, Excel, and basic Python. Knowledge of data visualization tools like Tableau or Power BI is a plus."
+    },
+    {
+        "job_id": 3,
+        "title": "Frontend Developer",
+        "company": "WebCreate Studios",
+        "description": "Create responsive, intuitive user interfaces for web applications. You'll implement designs using modern frameworks and collaborate with designers to ensure optimal user experience and accessibility.",
+        "requirements": "Portfolio demonstrating frontend projects. Strong knowledge of HTML, CSS, JavaScript, and React. Understanding of responsive design principles. Eye for detail and ability to translate designs into functional interfaces."
+    },
+    {
+        "job_id": 4,
+        "title": "Junior Machine Learning Engineer",
+        "company": "AI Innovations",
+        "description": "Implement and optimize machine learning models under the guidance of senior ML engineers. You'll work with datasets, train models, and help deploy solutions that solve real-world problems.",
+        "requirements": "Bachelor's degree in Computer Science, Mathematics, or related field. Strong understanding of Python, data structures, and algorithms. Knowledge of ML libraries like TensorFlow or PyTorch. Solid foundation in statistics and linear algebra."
+    },
+    {
+        "job_id": 5,
+        "title": "DevOps Engineer (Junior)",
+        "company": "CloudTech Solutions",
+        "description": "Help build and maintain CI/CD pipelines and cloud infrastructure. You'll learn to automate deployment processes, monitor systems, and optimize infrastructure for performance and security.",
+        "requirements": "Understanding of Linux systems and cloud platforms (AWS, Azure, GCP). Basic knowledge of containerization (Docker) and automation. Familiarity with scripting languages. Strong problem-solving abilities."
+    },
+    {
+        "job_id": 6,
+        "title": "Cybersecurity Analyst",
+        "company": "SecureTech",
+        "description": "Assist in protecting organizational assets by monitoring security systems, analyzing threats, and conducting vulnerability assessments. You'll help implement security measures and respond to incidents.",
+        "requirements": "Bachelor's in Cybersecurity, Computer Science, or related field. Understanding of network security, encryption, and authentication protocols. Knowledge of security tools and basic penetration testing concepts."
+    },
+    
+    # Experienced Positions
+    {
+        "job_id": 7,
+        "title": "Senior Backend Developer",
+        "company": "CloudPeak Technologies",
+        "description": "Design and implement robust, scalable backend systems that power our applications. You'll architect microservices, optimize database performance, and ensure system reliability under high load conditions.",
+        "requirements": "3+ years of experience in backend development with Python, Node.js, or Java. Strong knowledge of SQL and NoSQL databases. Experience with API design, microservices architecture, and cloud infrastructure."
+    },
+    {
+        "job_id": 8,
+        "title": "Data Scientist",
+        "company": "Insight Labs",
+        "description": "Extract valuable insights from complex datasets and develop predictive models that drive business strategy. You'll collaborate with stakeholders to understand requirements and communicate findings effectively.",
+        "requirements": "Master's degree in Data Science, Statistics, or related field. 2+ years of experience in data analysis or machine learning. Proficiency in Python, R, and SQL. Experience with statistical modeling, machine learning algorithms, and data visualization."
+    },
+    {
+        "job_id": 9,
+        "title": "Senior Full Stack Developer",
+        "company": "TechX Solutions",
+        "description": "Lead development of web applications from concept to deployment. You'll work across the stack to create seamless user experiences while ensuring application performance, security, and scalability.",
+        "requirements": "4+ years of experience in web development. Strong proficiency in React or Angular, Node.js, and database technologies. Experience with DevOps practices, containerization, and cloud deployment."
+    },
+    {
+        "job_id": 10,
+        "title": "Lead Data Engineer",
+        "company": "DataStream Innovations",
+        "description": "Design and implement data infrastructure that enables analytics and machine learning at scale. You'll lead a team in building ETL pipelines, data warehouses, and ensuring data quality and accessibility.",
+        "requirements": "5+ years of experience in data engineering. Expertise in big data technologies like Hadoop, Spark, and data warehouse solutions. Strong programming skills and experience with cloud-based data solutions."
+    },
+    {
+        "job_id": 11,
+        "title": "Machine Learning Architect",
+        "company": "IntelliAI",
+        "description": "Design cutting-edge machine learning systems and lead ML implementation strategies. You'll guide teams in developing and deploying sophisticated models that solve complex business problems.",
+        "requirements": "5+ years of experience in machine learning/AI. Advanced knowledge of deep learning frameworks, model optimization, and ML deployment. Experience leading ML projects and mentoring junior data scientists."
+    },
+    {
+        "job_id": 12,
+        "title": "Cloud Solutions Architect",
+        "company": "Cloudify Corp.",
+        "description": "Design resilient, cost-effective cloud architectures that meet business requirements. You'll create migration strategies, optimize cloud resources, and implement security best practices.",
+        "requirements": "4+ years of experience in cloud computing and architecture. Certifications in AWS, Azure, or GCP. Experience with infrastructure as code, containerization, and microservices deployment."
+    },
+    {
+        "job_id": 13,
+        "title": "Senior DevOps Engineer",
+        "company": "DevOps Works",
+        "description": "Lead the implementation of DevOps practices that enable continuous delivery and operational excellence. You'll automate processes, optimize infrastructure, and enhance monitoring and alerting systems.",
+        "requirements": "5+ years of experience in DevOps. Strong understanding of CI/CD tools, containerization, and infrastructure as code. Experience with cloud platforms and system reliability engineering principles."
+    },
+    {
+        "job_id": 14,
+        "title": "AI Research Scientist",
+        "company": "AI Frontier",
+        "description": "Push the boundaries of AI technology through innovative research. You'll develop novel algorithms, publish findings, and translate research into practical applications that drive product development.",
+        "requirements": "PhD or Master's degree in AI/ML. 3+ years of research experience in AI with publications in reputed journals. Deep expertise in machine learning theory and implementation. Ability to translate complex research into practical solutions."
+    }
+]
+
+jobs_df = pd.DataFrame(jobs_data)
+
+# Functions for resume processing and analysis
+
+def extract_text_from_pdf(pdf_file):
+    """Extract text from uploaded PDF resume."""
+    try:
+        pdf_reader = PyPDF2.PdfReader(pdf_file)
+        text = ""
+        for page in pdf_reader.pages:
+            extracted = page.extract_text()
+            if extracted:
+                text += extracted
+        
+        # If no text was extracted, the PDF might be image-based
+        if not text.strip():
+            return "The PDF appears to be image-based. Try using a text-based PDF resume."
+            
+        return text
+    except Exception as e:
+        print(f"PDF extraction error: {str(e)}")
+        return f"Error extracting text from PDF: {str(e)}"
+
+def clean_resume_text(text):
+    """Clean and preprocess resume text."""
+    # Remove special characters and extra whitespace
+    text = re.sub(r'\s+', ' ', text)
+    text = re.sub(r'[^\w\s]', ' ', text)
+    return text.lower().strip()
+
+def extract_skills(text):
+    """Extract potential skills from resume text."""
+    # Enhanced skills list with more technologies and soft skills
+    common_skills = [
+        # Programming Languages
+        "python", "java", "javascript", "typescript", "c++", "c#", "ruby", "php", "swift", "kotlin", "go", "rust", 
+        
+        # Web Technologies
+        "html", "css", "sass", "bootstrap", "tailwind", "jquery", "json", "xml", "rest", "graphql", "ajax",
+        
+        # Frontend Frameworks/Libraries
+        "react", "angular", "vue", "svelte", "next.js", "gatsby", "redux", "webpack", "babel",
+        
+        # Backend Technologies
+        "node", "express", "django", "flask", "spring", "rails", "laravel", "asp.net", "fastapi",
+        
+        # Databases
+        "sql", "mysql", "postgresql", "mongodb", "sqlite", "oracle", "nosql", "firebase", "dynamodb", "cassandra", "redis",
+        
+        # Cloud & DevOps
+        "aws", "azure", "gcp", "docker", "kubernetes", "jenkins", "circleci", "travis", "terraform", "ansible", "cicd",
+        
+        # Data Science & ML
+        "machine learning", "deep learning", "data analysis", "data science", "natural language processing", "computer vision",
+        "tensorflow", "pytorch", "keras", "scikit-learn", "pandas", "numpy", "matplotlib", "seaborn", "jupyter", 
+        "r", "spss", "tableau", "power bi", "data visualization", "statistics", "big data", "hadoop", "spark",
+        
+        # Mobile Development
+        "android", "ios", "react native", "flutter", "xamarin", "mobile development", "app development",
+        
+        # Version Control
+        "git", "github", "gitlab", "bitbucket", "version control",
+        
+        # Testing
+        "unit testing", "integration testing", "jest", "mocha", "selenium", "pytest", "junit", "tdd", "bdd",
+        
+        # Office & Productivity
+        "excel", "word", "powerpoint", "sharepoint", "microsoft office", "g suite", "jira", "confluence", "trello",
+        
+        # Soft Skills
+        "communication", "teamwork", "leadership", "problem solving", "critical thinking", "time management",
+        "project management", "agile", "scrum", "kanban", "customer service", "presentation", "negotiation",
+        
+        # Certifications (common ones)
+        "aws certified", "microsoft certified", "google certified", "comptia", "cisco certified", "pmp", "scrum master",
+        "itil", "security+", "cka", "ckad"
+    ]
+    
+    found_skills = []
+    text_lower = text.lower()
+    for skill in common_skills:
+        if skill in text_lower:
+            found_skills.append(skill)
+    
+    return found_skills
+
+def get_bert_embedding(text):
+    """Get BERT embedding for a text."""
+    # Use the tokenizer's encoding method which handles truncation properly
+    encoded_input = tokenizer(
+        text,
+        return_tensors="pt",
+        truncation=True,
+        max_length=512,
+        padding="max_length"
+    )
+    
+    # Get embeddings
+    with torch.no_grad():
+        outputs = model(**encoded_input)
+        # Use the CLS token embedding (first token) as the sentence embedding
+        sentence_embedding = outputs.last_hidden_state[0][0].numpy()
+    
+    return sentence_embedding
+
+def analyze_resume(resume_text):
+    """Analyze resume and extract key information."""
+    clean_text = clean_resume_text(resume_text)
+    skills = extract_skills(clean_text)
+    embedding = get_bert_embedding(clean_text)
+    
+    return {
+        "skills": skills,
+        "embedding": embedding
+    }
+
+def get_job_embeddings():
+    """Get BERT embeddings for all jobs."""
+    job_embeddings = []
+    
+    for _, job in jobs_df.iterrows():
+        job_text = f"{job['title']} {job['description']} {job['requirements']}"
+        job_embedding = get_bert_embedding(job_text)
+        job_embeddings.append(job_embedding)
+    
+    return job_embeddings
+
+def recommend_jobs(resume_analysis, top_n=3):
+    """Recommend jobs based on resume analysis."""
+    resume_embedding = resume_analysis["embedding"]
+    job_embeddings = get_job_embeddings()
+    
+    # Calculate similarities
+    similarities = []
+    for i, job_embedding in enumerate(job_embeddings):
+        similarity = cosine_similarity([resume_embedding], [job_embedding])[0][0]
+        similarities.append((i, similarity))
+    
+    # Sort by similarity (highest first)
+    similarities.sort(key=lambda x: x[1], reverse=True)
+    
+    # Get top N recommendations
+    recommendations = []
+    for i in range(min(top_n, len(similarities))):
+        job_idx, similarity_score = similarities[i]
+        job = jobs_df.iloc[job_idx]
+        recommendations.append({
+            "job_id": job["job_id"],
+            "title": job["title"],
+            "company": job["company"],
+            "similarity": round(similarity_score * 100, 2),
+            "description": job["description"],
+            "requirements": job["requirements"]
+        })
+    
+    return recommendations
+
+def match_resume_to_job(resume_text, job_title, job_description):
+    """Match a resume to a custom job description and provide suggestions for improvement."""
+    if not resume_text or not job_description:
+        return "Please provide both a resume and a job description.", ""
+    
+    # Analyze resume
+    resume_analysis = analyze_resume(resume_text)
+    resume_skills = set(resume_analysis["skills"])
+    
+    # Get embedding for the job description
+    job_text = f"{job_title} {job_description}"
+    job_embedding = get_bert_embedding(job_text)
+    
+    # Calculate similarity
+    resume_embedding = resume_analysis["embedding"]
+    similarity = cosine_similarity([resume_embedding], [job_embedding])[0][0]
+    match_score = round(similarity * 100, 2)
+    
+    # Extract skills from job description
+    job_skills = set(extract_skills(job_description))
+    
+    # Find skills that match and skills that are missing
+    matching_skills = resume_skills.intersection(job_skills)
+    missing_skills = job_skills - resume_skills
+    
+    # Generate improvement suggestions
+    suggestions = []
+    
+    if match_score < 50:
+        suggestions.append("Your resume shows low alignment with this job. Consider tailoring it specifically for this position.")
+    
+    if missing_skills:
+        suggestions.append(f"The job requires skills you haven't highlighted: {', '.join(missing_skills)}. If you have these skills, add them to your resume.")
+    
+    if len(matching_skills) < 3:
+        suggestions.append("Try to emphasize more relevant skills and experiences that align with the job requirements.")
+    
+    # Check if the resume is possibly too generic
+    if match_score < 60 and len(resume_skills) > 15:
+        suggestions.append("Your resume may be too broad. Focus on highlighting experiences and skills most relevant to this specific position.")
+    
+    # For entry-level positions
+    if "junior" in job_title.lower() or "entry" in job_title.lower():
+        if "project" not in resume_text.lower() and "project" not in suggestions:
+            suggestions.append("For entry-level positions, consider adding academic or personal projects that demonstrate your skills.")
+        
+        if "internship" not in resume_text.lower() and "coursework" not in resume_text.lower() and "education" not in suggestions:
+            suggestions.append("Highlight relevant coursework, certifications, or internships to compensate for limited work experience.")
+    
+    # For technical positions
+    if any(tech in job_title.lower() for tech in ["developer", "engineer", "programmer", "data", "analyst"]):
+        if len([s for s in resume_skills if s in ["github", "gitlab", "bitbucket"]]) == 0:
+            suggestions.append("Consider adding a link to your GitHub/GitLab profile to showcase your technical projects.")
+    
+    # Prepare output
+    analysis_result = f"Match Score: {match_score}%\n"
+    analysis_result += f"Matching Skills: {', '.join(matching_skills) if matching_skills else 'None detected'}\n"
+    analysis_result += f"Skills to Add: {', '.join(missing_skills) if missing_skills else 'None'}"
+    
+    improvement_suggestions = "### Suggestions for Improvement\n\n"
+    if suggestions:
+        for i, suggestion in enumerate(suggestions, 1):
+            improvement_suggestions += f"{i}. {suggestion}\n\n"
+    else:
+        improvement_suggestions += "Your resume appears to be well-aligned with this job posting. Consider customizing your cover letter to further highlight your relevant experiences."
+    
+    return analysis_result, improvement_suggestions
+
+def process_resume(pdf_file):
+    """Process the uploaded resume and return analysis and recommendations."""
+    if pdf_file is None:
+        return "Please upload a PDF resume.", "No recommendations yet. Upload your resume first."
+    
+    try:
+        # Extract text from PDF
+        resume_text = extract_text_from_pdf(pdf_file)
+        
+        # Check if we got a string error message instead of actual content
+        if isinstance(resume_text, str) and (resume_text.startswith("Error") or resume_text.startswith("The PDF appears")):
+            return resume_text, "No recommendations available. Please check the PDF file."
+            
+        # Check if we have enough text to analyze
+        if not resume_text or len(resume_text) < 50:
+            return "Warning: Could not extract sufficient text from the PDF. Please ensure it's a text-based PDF, not a scanned image.", "No recommendations available."
+            
+        print(f"Extracted {len(resume_text)} characters from resume")
+        
+        # Analyze the resume
+        resume_analysis = analyze_resume(resume_text)
+        
+        # Get job recommendations
+        recommendations = recommend_jobs(resume_analysis)
+        
+        # Prepare output
+        skills_found = ", ".join(resume_analysis["skills"]) if resume_analysis["skills"] else "No common skills detected"
+        analysis_result = f"Skills found: {skills_found}"
+        
+        # Format recommendations as markdown
+        formatted_recommendations = "### Top Job Recommendations\n\n"
+        if not recommendations:
+            formatted_recommendations += "No strong job matches found. Consider adding more skills and experiences to your resume."
+        else:
+            for i, rec in enumerate(recommendations, 1):
+                formatted_recommendations += f"#### {i}. {rec['title']} at {rec['company']}\n"
+                formatted_recommendations += f"*Match Score:* {rec['similarity']}%\n\n"
+                formatted_recommendations += f"*Description:* {rec['description']}\n\n"
+                formatted_recommendations += f"*Requirements:* {rec['requirements']}\n\n"
+                if i < len(recommendations):
+                    formatted_recommendations += "---\n\n"
+        
+        return analysis_result, formatted_recommendations, resume_text
+    
+    except Exception as e:
+        import traceback
+        error_details = traceback.format_exc()
+        print(f"Error details: {error_details}")
+        return f"Error processing resume: {str(e)}", "An error occurred. Please try again with a different PDF.", ""
+
+def process_job_match(resume_text, job_title, job_description):
+    """Process the match between resume and job description."""
+    if not resume_text:
+        return "No resume available. Please upload your resume first.", ""
+    
+    if not job_title or not job_description:
+        return "Please provide both job title and description.", ""
+    
+    try:
+        # Match resume to the job
+        analysis, suggestions = match_resume_to_job(resume_text, job_title, job_description)
+        return analysis, suggestions
+    
+    except Exception as e:
+        import traceback
+        error_details = traceback.format_exc()
+        print(f"Error details: {error_details}")
+        return f"Error matching resume to job: {str(e)}", "An error occurred. Please try again."
+
+# Create Gradio interface with tabs
+with gr.Blocks(title="Resume Analyzer & Job Recommender") as app:
+    # Storage for resume text between tabs
+    resume_text_state = gr.State("")
+    
+    # Title and description styling
+    gr.Markdown("""
+    <h1 style="text-align: center; color: #e35117;">Resume Analyzer and Job Recommender</h1>
+    <p style="text-align: center; color: #6C757D;">Upload your resume to get an analysis, job recommendations, or match with specific job descriptions</p>
+    """)
+    
+    # Tabs for different functionalities
+    with gr.Tabs():
+        # Tab 1: Resume Analysis and Recommendations
+        with gr.TabItem("Resume Analysis & Recommendations"):
+            with gr.Row():
+                # First Column for file upload and tips
+                with gr.Column(scale=2):
+                    resume_input = gr.File(label="Upload Resume (PDF)", elem_id="resume_input")
+                    submit_btn = gr.Button("Analyze Resume", elem_id="submit_btn")
+                    
+                    gr.Markdown("""
+                    ### Tips for best results:
+                    - Use a text-based PDF (not a scanned image)
+                    - Make sure your resume is properly formatted
+                    - Include key skills in your resume
+                    """)
+                
+                # Second Column for outputs
+                with gr.Column(scale=3):
+                    analysis_output = gr.Textbox(label="Resume Analysis", lines=6, placeholder="Your resume analysis will appear here...", elem_id="analysis_output")
+                    recommendations_output = gr.Markdown(label="Job Recommendations", elem_id="recommendations_output")
+        
+        # Tab 2: Job Match Analysis
+        with gr.TabItem("Match with Job Description"):
+            with gr.Row():
+                # First Column for job description input
+                with gr.Column(scale=2):
+                    job_title_input = gr.Textbox(label="Job Title", placeholder="Enter the job title here...", elem_id="job_title_input")
+                    job_description_input = gr.Textbox(label="Job Description", placeholder="Paste the full job description here...", lines=10, elem_id="job_description_input")
+                    job_match_btn = gr.Button("Match with Resume", elem_id="job_match_btn")
+                    
+                    gr.Markdown("""
+                    ### How to use this feature:
+                    1. Upload your resume in the "Resume Analysis" tab first
+                    2. Paste a job description you're interested in
+                    3. Click "Match with Resume" to see how well your resume matches
+                    4. Review suggestions to improve your application
+                    """)
+                
+                # Second Column for outputs
+                with gr.Column(scale=3):
+                    job_match_output = gr.Textbox(label="Match Analysis", lines=6, placeholder="Your job match analysis will appear here...", elem_id="job_match_output")
+                    improvement_suggestions = gr.Markdown(label="Improvement Suggestions", elem_id="improvement_suggestions")
+    
+    # Button click actions
+    submit_btn.click(
+        process_resume,
+        inputs=[resume_input],
+        outputs=[analysis_output, recommendations_output, resume_text_state]
+    )
+    
+    job_match_btn.click(
+        process_job_match,
+        inputs=[resume_text_state, job_title_input, job_description_input],
+        outputs=[job_match_output, improvement_suggestions]
+    )
+
+# Add custom CSS for better styling
+css = """
+#submit_btn, #job_match_btn {
+    background-color:#e35117; 
+    color: white; 
+    font-weight: bold;
+    border-radius: 5px;
+    padding: 10px;
+}
+
+#submit_btn:hover, #job_match_btn:hover {
+    background-color: #e35117;
+}
+
+#resume_input input[type="file"] {
+    padding: 8px;
+    border: 1px solid #ddd;
+    border-radius: 5px;
+     background-color: #ffffff;
+    transition: border-color 0.3s ease;
+}
+
+#resume_input input[type="file"]:hover {
+    border-color: #e35117;
+}
+
+#analysis_output, #job_match_output {
+    background-color: #030000;
+    border-radius: 5px;
+    padding: 10px;
+    font-size: 14px;
+    border: 1px solid #ddd;
+      box-shadow: 0 1px 3px rgba(0,0,0,0.05);
+}
+
+#recommendations_output, #improvement_suggestions {
+    background-color:#030000;
+    border-radius: 5px;
+    padding: 10px;
+    font-size: 14px;
+    border: 1px solid #ddd;
+}
+
+.tabs {
+    margin-top: 20px;
+}
+"""
+
+# Apply custom CSS
+app.css = css
+
+# Launch the app
+if __name__ == "__main__":
+    app.launch()

requirements.txt

@@ -0,0 +1,7 @@
+transformers==4.34.0
+pandas==2.1.1
+numpy==1.26.0
+PyPDF2==3.0.1
+scikit-learn==1.3.1
+gradio==4.5.0
+torch==2.1.0