Update app.py

app.py

@@ -1,152 +1,132 @@
 import gradio as gr
 import pandas as pd
-import numpy as np
-import re
-import warnings
+import random
 from typing import List, Dict
+from sentence_transformers import SentenceTransformer, util
 
-# Import ML libraries from scikit-learn
-from sklearn.feature_extraction.text import TfidfVectorizer
-from sklearn.metrics.pairwise import cosine_similarity
+# -----------------------------
+# Job Database Generation
+# -----------------------------
+class JobDatabase:
+    def __init__(self):
+        self.jobs = self._generate_job_database()
+        self.df_jobs = pd.DataFrame(self.jobs)
+        # Prepare a textual representation of skills for embeddings
+        self.df_jobs['skills_text'] = self.df_jobs['requirements'].apply(lambda x: ", ".join(x))
+        # Load lightweight embedding model
+        self.model = SentenceTransformer('all-MiniLM-L6-v2')
+        # Encode all job skills in advance
+        self.job_embeddings = self.model.encode(self.df_jobs['skills_text'].tolist(), convert_to_tensor=True)
 
-# --- MODIFIED: Import the dataset from the separate file ---
-from jobs_dataset import JOBS_DATABASE
+    def _generate_job_database(self) -> List[Dict]:
+        """Generate a minimal example database; replace with your full database"""
+        job_templates = {
+            "Technology": [
+                {"title": "Software Engineer", "desc": "Design and develop software applications",
+                 "skills": ["Python", "Java", "JavaScript", "Git", "Agile", "Problem Solving"]},
+                {"title": "Data Scientist", "desc": "Analyze complex data to extract business insights",
+                 "skills": ["Python", "R", "Machine Learning", "SQL", "Statistics", "Pandas"]}
+            ],
+            "Finance": [
+                {"title": "Financial Analyst", "desc": "Analyze financial data and market trends",
+                 "skills": ["Financial Modeling", "Excel", "Data Analysis", "Financial Reporting", "Market Research"]}
+            ]
+        }
 
-# Suppress warnings for a cleaner output
-warnings.filterwarnings('ignore')
+        experience_levels = ["Entry-level", "Mid-level", "Senior", "Lead/Principal"]
+        salary_ranges = {
+            "Entry-level": ["$35k-$50k", "$40k-$55k"],
+            "Mid-level": ["$55k-$75k", "$60k-$80k"],
+            "Senior": ["$80k-$110k", "$90k-$120k"],
+            "Lead/Principal": ["$120k-$150k", "$130k-$160k"]
+        }
+        additional_skills = {
+            "Technology": ["Debugging", "Code Review", "System Design"],
+            "Finance": ["Financial Regulations", "Risk Management", "Excel Advanced"]
+        }
 
-# --- The `generate_job_database` function has been REMOVED from this file ---
+        jobs = []
+        job_id = 1
+        categories = list(job_templates.keys())
+        jobs_per_category = 1000 // len(categories)
+        remaining_jobs = 1000 % len(categories)
 
+        for i, category in enumerate(categories):
+            templates = job_templates[category]
+            jobs_for_this_category = jobs_per_category + (1 if i < remaining_jobs else 0)
 
-# --- MACHINE LEARNING MODEL CLASS (This code is the same) ---
-class MLJobRecommendationSystem:
-    def __init__(self, jobs_database: List[Dict]):
-        print("🤖 Initializing ML-powered Job Recommendation System...")
-        self.df = pd.DataFrame(jobs_database)
-        self.vectorizer = TfidfVectorizer(max_features=500, stop_words='english', ngram_range=(1, 2))
-        self._train_model()
-        print("✅ ML models trained successfully!")
+            for j in range(jobs_for_this_category):
+                template = templates[j % len(templates)]
+                title_variations = [
+                    template["title"],
+                    f"Senior {template['title']}",
+                    f"Junior {template['title']}",
+                    f"Lead {template['title']}",
+                    f"{template['title']} Specialist"
+                ]
+                title = title_variations[j % len(title_variations)]
+                exp_level = random.choice(experience_levels)
+                salary = random.choice(salary_ranges[exp_level])
+                base_skills = template["skills"].copy()
+                extra_skills = random.sample(additional_skills[category],
+                                             random.randint(1, min(3, len(additional_skills[category]))))
+                all_skills = base_skills + extra_skills
+                unique_skills = list(dict.fromkeys(all_skills))[:8]
 
-    def _train_model(self):
-        """Prepares the data and 'trains' the TF-IDF model."""
-        self.df['combined_text'] = (
-            self.df['title'] + ' ' + 
-            self.df['description'] + ' ' + 
-            self.df['requirements'].apply(lambda x: ' '.join(x))
-        ).str.lower()
-        self.job_vectors = self.vectorizer.fit_transform(self.df['combined_text'])
+                job = {
+                    "id": job_id,
+                    "title": title,
+                    "description": template["desc"],
+                    "requirements": unique_skills,
+                    "experience_level": exp_level,
+                    "salary_range": salary,
+                    "category": category,
+                    "location": random.choice([
+                        "Remote", "New York, NY", "San Francisco, CA", "Chicago, IL",
+                        "Austin, TX", "Seattle, WA", "Boston, MA", "Los Angeles, CA",
+                        "Denver, CO", "Atlanta, GA", "Miami, FL", "Portland, OR"
+                    ])
+                }
+                jobs.append(job)
+                job_id += 1
+        return jobs
 
-    def recommend_jobs(self, user_skills: str, num_recommendations: int = 10, 
-                      filter_category: str = "All Categories", filter_experience: str = "All Levels") -> str:
-        """Uses the trained model to find and recommend jobs."""
-        if not user_skills.strip():
-            return "🔍 Please enter your skills to get personalized AI-powered job recommendations!"
-        
-        try:
-            user_text = re.sub(r'[^\w\s,]', '', user_skills.lower())
-            user_vector = self.vectorizer.transform([user_text])
-            
-            filtered_df = self.df.copy()
-            if filter_category and filter_category != "All Categories":
-                filtered_df = filtered_df[filtered_df['category'] == filter_category]
-            if filter_experience and filter_experience != "All Levels":
-                filtered_df = filtered_df[filtered_df['experience_level'] == filter_experience]
-            
-            if filtered_df.empty:
-                return "❌ No jobs found matching your filter criteria. Please adjust your filters and try again."
-
-            filtered_indices = filtered_df.index
-            filtered_job_vectors = self.job_vectors[filtered_indices]
-            
-            similarity_scores = cosine_similarity(user_vector, filtered_job_vectors)[0]
-            
-            filtered_df['similarity_score'] = similarity_scores
-            sorted_jobs = filtered_df.sort_values(by='similarity_score', ascending=False)
-            
-            top_jobs = sorted_jobs.head(int(num_recommendations))
-            
-            recommendations = ["# 🎯 AI-Powered Job Recommendations\n*Based on semantic similarity between your skills and job descriptions.*\n---"]
-            for _, job in top_jobs.iterrows():
-                score = job['similarity_score']
-                if score < 0.05: continue
-                
-                match_quality = "🟢 Excellent Match" if score >= 0.5 else "🟡 Good Match" if score >= 0.25 else "🟠 Moderate Match"
-                
-                recommendation = f"""
-## {job['title']}
-**{match_quality}** | **AI Confidence: {score:.1%}**
-- **Category:** {job['category']}
-- **Experience:** {job['experience_level']}
-- **Location:** {job['location']}
-- **Salary:** {job['salary_range']}
-- **Description:** {job['description']}
-- **Core Skills:** {', '.join(job['requirements'])}
----
-"""
-                recommendations.append(recommendation)
-            
-            if len(recommendations) == 1:
-                 return "😔 No relevant jobs found with the current skills. Try being more descriptive or adjusting filters."
-            
-            return '\n'.join(recommendations)
-            
-        except Exception as e:
-            return f"❌ An unexpected error occurred: {str(e)}. Please try again."
+# -----------------------------
+# Job Matching Function
+# -----------------------------
+def match_jobs_embeddings(user_skills: List[str], db: JobDatabase, top_n=5):
+    # Convert user input into single string
+    skills_text = ", ".join([s.strip() for s in user_skills if s.strip()])
+    if not skills_text:
+        return pd.DataFrame([{"title":"No skills entered","description":"","requirements":"","experience_level":"","salary_range":"","location":""}])
+    
+    # Encode user skills
+    user_embedding = db.model.encode(skills_text, convert_to_tensor=True)
+    # Compute cosine similarity
+    cos_scores = util.cos_sim(user_embedding, db.job_embeddings)[0]
+    # Get top N matches
+    top_results = cos_scores.topk(top_n)
+    indices = top_results.indices.tolist()
+    
+    matched_jobs = db.df_jobs.iloc[indices]
+    return matched_jobs[['title', 'description', 'requirements', 'experience_level', 'salary_range', 'location']]
 
-# --- SETUP AND LAUNCH GRADIO INTERFACE ---
+# -----------------------------
+# Gradio Interface
+# -----------------------------
+db = JobDatabase()
 
-# --- MODIFIED: Initialize the system using the imported database ---
-print("🚀 Starting application...")
-# We use the JOBS_DATABASE variable we imported from the other file.
-ml_system = MLJobRecommendationSystem(JOBS_DATABASE)
+def find_jobs_ui(user_skills_text):
+    user_skills = [skill.strip() for skill in user_skills_text.split(",")]
+    return match_jobs_embeddings(user_skills, db)
 
-# Define the user interface using Gradio (This code is the same)
-with gr.Blocks(theme=gr.themes.Soft(), title="AI Job Recommender") as app:
-    gr.HTML("""
-    <div style="text-align: center; max-width: 800px; margin: auto;">
-        <h1>🤖 AI-Powered Job Recommendation System</h1>
-        <p>This app uses a Machine Learning model (TF-IDF and Cosine Similarity) to find jobs that are semantically similar to your skills, going beyond simple keyword matching.</p>
-    </div>
-    """)
-    
-    with gr.Row():
-        with gr.Column(scale=2):
-            skills_input = gr.Textbox(
-                label="Enter Your Skills and Experience",
-                placeholder="e.g., Python development with flask, data analysis, machine learning models, and aws...",
-                lines=4,
-            )
-            
-            num_jobs = gr.Slider(
-                minimum=5, maximum=20, value=10, step=1, label="Number of Recommendations"
-            )
-            
-            with gr.Row():
-                category_filter = gr.Dropdown(
-                    choices=["All Categories"] + sorted(list(ml_system.df['category'].unique())),
-                    value="All Categories",
-                    label="Filter by Industry"
-                )
-                
-                experience_filter = gr.Dropdown(
-                    choices=["All Levels"] + sorted(list(ml_system.df['experience_level'].unique())),
-                    value="All Levels",
-                    label="Filter by Experience"
-                )
-                
-            submit_btn = gr.Button("🚀 Get AI-Powered Recommendations", variant="primary")
-            
-        with gr.Column(scale=3):
-            output_markdown = gr.Markdown(
-                value="### Your personalized job recommendations will appear here.\nEnter your skills and click the button to start! ✨"
-            )
-            
-    submit_btn.click(
-        fn=ml_system.recommend_jobs,
-        inputs=[skills_input, num_jobs, category_filter, experience_filter],
-        outputs=output_markdown
-    )
+iface = gr.Interface(
+    fn=find_jobs_ui,
+    inputs=gr.Textbox(lines=2, placeholder="Enter skills separated by commas, e.g. Python, SQL, Excel"),
+    outputs=gr.Dataframe(headers=["Title","Description","Requirements","Experience Level","Salary","Location"]),
+    title="Job Finder with AI Embeddings",
+    description="Enter your skills and get top matching jobs using AI embeddings."
+)
 
-# Launch the Gradio app
 if __name__ == "__main__":
-    app.launch()
+    iface.launch()