Update app.py

app.py

@@ -5,8 +5,10 @@ import pandas as pd
 from sentence_transformers import SentenceTransformer
 from collections import OrderedDict
 
+
 class RiasecPredictor:
-    def __init__(self, regressor_path='riasec_regressor.pkl', 
+    def __init__(self, regressor_path='riasec_regressor_v1.pkl', 
+                 scaler_path='riasec_scaler.pkl',  
                  embedding_model_path='all-MiniLM-L6-v2'):
         """
         Load saved models for RIASEC prediction
@@ -14,21 +16,21 @@ class RiasecPredictor:
         print("Loading models...")
         self.embedding_model = SentenceTransformer(embedding_model_path)
         self.regressor = joblib.load(regressor_path)
+        try:
+            self.scaler = joblib.load(scaler_path)  # 👈 Load scaler
+        except FileNotFoundError:
+            raise FileNotFoundError(f"Scaler file not found at {scaler_path}. "
+                                    "Did you save it during training?")
         self.riasec_labels = ['R', 'I', 'A', 'S', 'E', 'C']
-        print("✅ Models loaded successfully!")
+        self.code_to_name = {
+            'R': 'Realistic', 'I': 'Investigative', 'A': 'Artistic',
+            'S': 'Social', 'E': 'Enterprising', 'C': 'Conventional'
+        }
+        print("✅ Models and scaler loaded successfully!")
     
     def predict(self, job_title=None, job_description=None, full_text=None, sort_by_score=True):
         """
-        Predict RIASEC scores for a job
-        
-        Args:
-            job_title (str): Job title
-            job_description (str): Job description  
-            full_text (str): Complete job text (alternative to title + description)
-            sort_by_score (bool): If True, return results sorted by score (highest to lowest)
-            
-        Returns:
-            dict or OrderedDict: RIASEC scores clamped to [1.0, 7.0]
+        Predict RIASEC scores for a job (in original 1-7 scale)
         """
         # Handle input
         if full_text is not None:
@@ -41,109 +43,73 @@ class RiasecPredictor:
         # Generate embedding
         embedding = self.embedding_model.encode([text], convert_to_numpy=True)
         
-        # Make prediction
-        prediction = self.regressor.predict(embedding)[0]
-        prediction = np.clip(prediction, 1.0, 7.0)
+        # Make prediction in scaled space
+        prediction_scaled = self.regressor.predict(embedding)[0]
+        
+        # Convert back to original scale
+        prediction = self.scaler.inverse_transform(prediction_scaled.reshape(1, -1))[0]
+        prediction = np.clip(prediction, 1.0, 7.0)  # Enforce valid range
         
         # Create dictionary
         riasec_dict = dict(zip(self.riasec_labels, prediction.tolist()))
         
-        # Sort by score if requested
         if sort_by_score:
-            # Sort by value (score) in descending order
-            sorted_riasec = OrderedDict(
-                sorted(riasec_dict.items(), key=lambda x: x[1], reverse=True)
-            )
-            return sorted_riasec
+            return OrderedDict(sorted(riasec_dict.items(), key=lambda x: x[1], reverse=True))
         else:
             return riasec_dict
     
     def predict_with_names(self, job_title=None, job_description=None, full_text=None):
-        """
-        Predict RIASEC scores with full names in R-I-A-S-E-C order
-        
-        Returns:
-            OrderedDict: Full RIASEC names with scores, in R-I-A-S-E-C order
-        """
-        # Get results with codes (not sorted by score)
+        """Predict with full names in R-I-A-S-E-C order"""
         results = self.predict(job_title, job_description, full_text, sort_by_score=False)
-        
-        # Map codes to full names in R-I-A-S-E-C order
-        code_to_name = {
-            'R': 'Realistic',
-            'I': 'Investigative',
-            'A': 'Artistic',
-            'S': 'Social',
-            'E': 'Enterprising',
-            'C': 'Conventional'
-        }
-        
-        # Create ordered dict with full names in R-I-A-S-E-C order
         ordered_with_names = OrderedDict()
-        riasec_order = ['R', 'I', 'A', 'S', 'E', 'C']
-        
-        for code in riasec_order:
-            if code in results:
-                ordered_with_names[code_to_name[code]] = results[code]
-            
+        for code in ['R', 'I', 'A', 'S', 'E', 'C']:
+            ordered_with_names[self.code_to_name[code]] = results[code]
         return ordered_with_names
 
-# Initialize predictor once when the script runs
+
+# Initialize predictor
 predictor = RiasecPredictor()
 
+
 def predict_riasec(job_title, job_description):
-    """
-    Wrapper function for Gradio interface
-    """
+    """Wrapper for Gradio"""
     try:
-        if job_title.strip() and job_description.strip():
-            # Use job_title and job_description
-            # Always use abbreviations (R, I, A, S, E, C) as default
-            # Use sort_by_score=False to maintain R-I-A-S-E-C order for the bar chart
-            result = predictor.predict(job_title=job_title, job_description=job_description, sort_by_score=False)
-        else:
+        if not job_title.strip() or not job_description.strip():
             return None, "Please provide both job title and job description."
         
-        # Skip text formatting since we're removing the text output
+        result = predictor.predict(
+            job_title=job_title,
+            job_description=job_description,
+            sort_by_score=False  # Don't sort by score, maintain R-I-A-S-E-C order
+        )
         
-        # Prepare data for gr.BarPlot
-        # Convert to the format expected by gr.BarPlot (pandas DataFrame)
-        # Maintain R-I-A-S-E-C order regardless of scores
+        # Prepare bar chart data in R-I-A-S-E-C order with abbreviations
         riasec_order = ['R', 'I', 'A', 'S', 'E', 'C']
-        
-        # Get the scores in the correct order
         ordered_labels = []
-        ordered_values = []
+        ordered_scores = []
         
-        for riasec_type in riasec_order:
-            if riasec_type in result:
-                ordered_labels.append(riasec_type)
-                ordered_values.append(result[riasec_type])
+        for code in riasec_order:
+            ordered_labels.append(code)  # Use abbreviations
+            ordered_scores.append(result[code])
         
-        # Create pandas DataFrame for BarPlot
         bar_data = pd.DataFrame({
-            "RIASEC": ordered_labels,
-            "Score": ordered_values
+            "Category": ordered_labels,
+            "Score": ordered_scores
         })
         
-        # Prepare data for Top 3 RIASEC panel - only codes without scores, formatted as markdown
-        # Sort results by score for the top 3 display
-        sorted_result = OrderedDict(sorted(result.items(), key=lambda x: x[1], reverse=True))
-        
+        # Prepare top 3 (sorted by score)
+        sorted_result = sorted(result.items(), key=lambda x: x[1], reverse=True)
         top_3_result = "### Top 3 RIASEC Types\n\n"
-        for i, (key, value) in enumerate(sorted_result.items()):
-            if i < 3:  # Only take top 3
-                # Add some styling to make each RIASEC code more prominent with better contrast
-                top_3_result += f"<div style='font-size: 1.5em; font-weight: bold; margin: 5px 0; padding: 10px; background-color: #f0f0f0; color: #000000; border-radius: 5px; text-align: center; border: 1px solid #cccccc;'>{key}</div>\n"
-            else:
-                break
+        for key, _ in sorted_result[:3]:
+            top_3_result += f"<div style='font-size: 1.5em; font-weight: bold; margin: 5px 0; padding: 10px; background-color: #f0f0f0; color: #000000; border-radius: 5px; text-align: center; border: 1px solid #cccccc;'>{key}</div>\n"
         
         return bar_data, top_3_result
+        
     except Exception as e:
-        print(f"Error in predict_riasec: {str(e)}")  # Add debug output
         return None, f"Error: {str(e)}"
 
-# Create Gradio interface
+
+# Updated Gradio UI
 with gr.Blocks(title="RIASEC Predictor") as demo:
     gr.Markdown("# RIASEC Predictor")
     gr.Markdown("Predict RIASEC personality type scores for job descriptions")
@@ -156,11 +122,11 @@ with gr.Blocks(title="RIASEC Predictor") as demo:
         
         with gr.Column():
             output_chart = gr.BarPlot(
-                x="RIASEC",
+                x="Category",
                 y="Score",
                 title="RIASEC Scores",
-                orientation="h",  # horizontal orientation
-                color="RIASEC",
+                vertical=False,  # Horizontal bars
+                tooltip=["Category", "Score"],
                 show_legend=False,
                 height=400
             )
@@ -177,7 +143,6 @@ with gr.Blocks(title="RIASEC Predictor") as demo:
         show_progress=True
     )
     
-    # Example inputs
     gr.Examples(
         examples=[
             ["Data Scientist", "Analyze large datasets and build machine learning models"],
@@ -190,5 +155,6 @@ with gr.Blocks(title="RIASEC Predictor") as demo:
         cache_examples=False,
     )
 
+
 if __name__ == "__main__":
-    demo.queue().launch(share=True)
+    demo.queue().launch(share=True)