Update modelLoanAPI.py

modelLoanAPI.py

@@ -1,4 +1,6 @@
-from fastapi import FastAPI, HTTPException, Query
+# ```python
+from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel
 import pandas as pd
 import numpy as np
 from sklearn.ensemble import RandomForestClassifier, RandomForestRegressor
@@ -14,9 +16,13 @@ warnings.filterwarnings("ignore")
 
 app = FastAPI()
 
+class WorkerIdRequest(BaseModel):
+    worker_id: int
+
 @app.post("/predict_worker_earnings/")
-async def predict_worker_earnings(worker_id: int = Query(...)):
+async def predict_worker_earnings(request: WorkerIdRequest):
     try:
+        worker_id = request.worker_id
         # Initialize result dictionary
         results = {
             'worker_id': worker_id,
@@ -26,7 +32,12 @@ async def predict_worker_earnings(worker_id: int = Query(...)):
         }
 
         # Load data
-        df = pd.read_csv('/app/data/extended_worker_dataset.csv')
+        try:
+            df = pd.read_csv('/app/data/extended_worker_dataset.csv')
+        except FileNotFoundError:
+            raise HTTPException(status_code=500, detail="CSV file not found at /app/data/extended_worker_dataset.csv")
+        except Exception as e:
+            raise HTTPException(status_code=500, detail=f"Error reading CSV file: {str(e)}")
 
         # Filter for one worker_id
         df = df[df['worker_id'] == worker_id].copy()
@@ -34,31 +45,48 @@ async def predict_worker_earnings(worker_id: int = Query(...)):
             raise HTTPException(status_code=404, detail=f"No data found for worker_id {worker_id}")
 
         # Data preprocessing
-        df['timestamp'] = pd.to_datetime(df['timestamp'])
+        try:
+            df['timestamp'] = pd.to_datetime(df['timestamp'])
+        except Exception as e:
+            raise HTTPException(status_code=500, detail=f"Error converting timestamp: {str(e)}")
+
         df['has_job'] = (df['job_type'] != "No Job").astype(int)
 
-        wage_cap = df[df['contracted_wage'] > 0]['contracted_wage'].quantile(0.90)
-        df['contracted_wage'] = df['contracted_wage'].clip(lower=500, upper=wage_cap)
+        try:
+            wage_cap = df[df['contracted_wage'] > 0]['contracted_wage'].quantile(0.90)
+            if np.isnan(wage_cap) or wage_cap <= 500:
+                raise ValueError("Invalid wage cap calculated")
+            df['contracted_wage'] = df['contracted_wage'].clip(lower=500, upper=wage_cap)
+        except Exception as e:
+            raise HTTPException(status_code=500, detail=f"Error processing wage data: {str(e)}")
 
         # Encode job_type
         le = LabelEncoder()
-        df['job_type_encoded'] = le.fit_transform(df['job_type'])
-
+        try:
+            df['job_type_encoded'] = le.fit_transform(df['job_type'])
+        except Exception as e:
+            raise HTTPException(status_code=500, detail=f"Error encoding job_type: {str(e)}")
+
+        # Split data
+        if len(df) < 2:
+            raise HTTPException(status_code=400, detail="Insufficient data points for training and testing")
         split_point = int(len(df) * 0.8)
         train_df = df.iloc[:split_point].copy()
         test_df = df.iloc[split_point:].copy()
 
         # Scale features
         scaler = StandardScaler()
-        train_df[['job_type_scaled', 'years_exp_scaled']] = scaler.fit_transform(
-            train_df[['job_type_encoded', 'years_of_experience']]
-        )
-        train_df['job_exp_interaction'] = train_df['job_type_scaled'] * train_df['years_exp_scaled']
+        try:
+            train_df[['job_type_scaled', 'years_exp_scaled']] = scaler.fit_transform(
+                train_df[['job_type_encoded', 'years_of_experience']]
+            )
+            train_df['job_exp_interaction'] = train_df['job_type_scaled'] * train_df['years_exp_scaled']
+        except Exception as e:
+            raise HTTPException(status_code=500, detail=f"Error scaling features: {str(e)}")
 
         for subset in [train_df, test_df]:
             subset['dayofweek'] = subset['timestamp'].dt.dayofweek
             subset['month'] = subset['timestamp'].dt.month
-           Pin to content
             subset['year'] = subset['timestamp'].dt.year
             subset['dayofyear'] = subset['timestamp'].dt.dayofyear
             subset['is_weekend'] = subset['dayofweek'].isin([5, 6]).astype(int)
@@ -69,22 +97,31 @@ async def predict_worker_earnings(worker_id: int = Query(...)):
                                  'years_of_experience']]
         y_train_class = train_df['has_job']
 
-        classifier = RandomForestClassifier(
-            n_estimators=500, max_depth=12, min_samples_split=5, random_state=42
-        )
-        classifier.fit(X_train_class, y_train_class)
+        try:
+            classifier = RandomForestClassifier(
+                n_estimators=500, max_depth=12, min_samples_split=5, random_state=42
+            )
+            classifier.fit(X_train_class, y_train_class)
+        except Exception as e:
+            raise HTTPException(status_code=500, detail=f"Error training classifier: {str(e)}")
 
         # Train regressor
         train_df_reg = train_df[train_df['has_job'] == 1].copy()
+        if train_df_reg.empty:
+            raise HTTPException(status_code=404, detail="No data available for regression (all has_job == 0)")
+
         X_train_reg = train_df_reg[['dayofweek', 'month', 'year', 'dayofyear',
                                    'is_weekend', 'job_type_scaled', 'feedback_score',
                                    'years_exp_scaled', 'job_exp_interaction']]
         y_train_reg = train_df_reg['contracted_wage']
 
-        regressor = RandomForestRegressor(
-            n_estimators=300, max_depth=10, min_samples_split=4, random_state=42
-        )
-        regressor.fit(X_train_reg, y_train_reg)
+        try:
+            regressor = RandomForestRegressor(
+                n_estimators=300, max_depth=10, min_samples_split=4, random_state=42
+            )
+            regressor.fit(X_train_reg, y_train_reg)
+        except Exception as e:
+            raise HTTPException(status_code=500, detail=f"Error training regressor: {str(e)}")
 
         # Prepare future dataframe
         future_df = test_df[['timestamp', 'job_type', 'job_type_encoded',
@@ -96,29 +133,41 @@ async def predict_worker_earnings(worker_id: int = Query(...)):
         future_df['dayofyear'] = future_df['ds'].dt.dayofyear
         future_df['is_weekend'] = future_df['dayofweek'].isin([5, 6]).astype(int)
 
-        future_df[['job_type_scaled', 'years_exp_scaled']] = scaler.transform(
-            future_df[['job_type_encoded', 'years_of_experience']]
-        )
-        future_df['job_exp_interaction'] = future_df['job_type_scaled'] * future_df['years_exp_scaled']
+        try:
+            future_df[['job_type_scaled', 'years_exp_scaled']] = scaler.transform(
+                future_df[['job_type_encoded', 'years_of_experience']]
+            )
+            future_df['job_exp_interaction'] = future_df['job_type_scaled'] * future_df['years_exp_scaled']
+        except Exception as e:
+            raise HTTPException(status_code=500, detail=f"Error transforming future dataframe: {str(e)}")
 
         # Predict job/no-job
-        future_df['has_job_predicted'] = classifier.predict(
-            future_df[['dayofweek', 'month', 'year', 'dayofyear',
-                      'is_weekend', 'job_type_encoded', 'feedback_score',
-                      'years_of_experience']]
-        )
+        try:
+            future_df['has_job_predicted'] = classifier.predict(
+                future_df[['dayofweek', 'month', 'year', 'dayofyear',
+                          'is_weekend', 'job_type_encoded', 'feedback_score',
+                          'years_of_experience']]
+            )
+        except Exception as e:
+            raise HTTPException(status_code=500, detail=f"Error predicting has_job: {str(e)}")
 
         # Evaluate classifier accuracy
         test_df['has_job'] = (test_df['job_type'] != "No Job").astype(int)
-        acc = accuracy_score(test_df['has_job'], future_df['has_job_predicted'])
-        results['classification_metrics']['accuracy'] = round(acc * 100, 2)
+        try:
+            acc = accuracy_score(test_df['has_job'], future_df['has_job_predicted'])
+            results['classification_metrics']['accuracy'] = round(acc * 100, 2)
+        except Exception as e:
+            raise HTTPException(status_code=500, detail=f"Error calculating accuracy: {str(e)}")
 
         # Predict wages
-        future_df['yhat'] = regressor.predict(
-            future_df[['dayofweek', 'month', 'year', 'dayofyear',
-                      'is_weekend', 'job_type_scaled', 'feedback_score',
-                      'years_exp_scaled', 'job_exp_interaction']]
-        )
+        try:
+            future_df['yhat'] = regressor.predict(
+                future_df[['dayofweek', 'month', 'year', 'dayofyear',
+                          'is_weekend', 'job_type_scaled', 'feedback_score',
+                          'years_exp_scaled', 'job_exp_interaction']]
+            )
+        except Exception as e:
+            raise HTTPException(status_code=500, detail=f"Error predicting wages: {str(e)}")
 
         # Apply job prediction mask
         final_forecast_df = future_df.copy()
@@ -126,77 +175,89 @@ async def predict_worker_earnings(worker_id: int = Query(...)):
         final_forecast_df['yhat'] = np.minimum(final_forecast_df['yhat'], wage_cap)
 
         # Uncertainty intervals
-        predictions = regressor.predict(X_train_reg)
-        std_dev = np.std([tree.predict(X_train_reg) for tree in regressor.estimators_], axis=0)
-        future_df['yhat_lower'] = np.maximum(final_forecast_df['yhat'] - 1.96 * std_dev.mean(), 0)
-        future_df['yhat_upper'] = final_forecast_df['yhat'] + 1.96 * std_dev.mean()
-        final_forecast_df['yhat_lower'] = np.where(final_forecast_df['has_job_predicted'] == 0, 0, future_df['yhat_lower'])
-        final_forecast_df['yhat_upper'] = np.where(final_forecast_df['has_job_predicted'] == 0, 0, future_df['yhat_upper'])
+        try:
+            predictions = regressor.predict(X_train_reg)
+            std_dev = np.std([tree.predict(X_train_reg) for tree in regressor.estimators_], axis=0)
+            future_df['yhat_lower'] = np.maximum(final_forecast_df['yhat'] - 1.96 * std_dev.mean(), 0)
+            future_df['yhat_upper'] = final_forecast_df['yhat'] + 1.96 * std_dev.mean()
+            final_forecast_df['yhat_lower'] = np.where(final_forecast_df['has_job_predicted'] == 0, 0, future_df['yhat_lower'])
+            final_forecast_df['yhat_upper'] = np.where(final_forecast_df['has_job_predicted'] == 0, 0, future_df['yhat_upper'])
+        except Exception as e:
+            raise HTTPException(status_code=500, detail=f"Error calculating uncertainty intervals: {str(e)}")
 
         # Evaluation
-        comparison_df = pd.merge(
-            test_df[['timestamp', 'contracted_wage']].rename(columns={'timestamp': 'ds', 'contracted_wage': 'y'}),
-            final_forecast_df[['ds', 'yhat', 'yhat_lower', 'yhat_upper']], on='ds'
-        )
-
-        valid_comparison_df = comparison_df[comparison_df['y'] > 0]
-        if not valid_comparison_df.empty:
-            weights = valid_comparison_df['y'] / valid_comparison_df['y'].mean()
-            mae = np.average([abs(a - p) for a, p in zip(valid_comparison_df['y'], valid_comparison_df['yhat'])], weights=weights)
-            mape = np.average([abs((a - p) / a) * 100 for a, p in zip(valid_comparison_df['y'], valid_comparison_df['yhat'])], weights=weights)
-        else:
-            mae = np.nan
-            mape = np.nan
-
-        results['classification_metrics']['mae'] = round(mae, 2) if not np.isnan(mae) else None
-        results['classification_metrics']['mape'] = round(mape, 2) if not np.isnan(mape) else None
+        try:
+            comparison_df = pd.merge(
+                test_df[['timestamp', 'contracted_wage']].rename(columns={'timestamp': 'ds', 'contracted_wage': 'y'}),
+                final_forecast_df[['ds', 'yhat', 'yhat_lower', 'yhat_upper']], on='ds'
+            )
+
+            valid_comparison_df = comparison_df[comparison_df['y'] > 0]
+            if not valid_comparison_df.empty:
+                weights = valid_comparison_df['y'] / valid_comparison_df['y'].mean()
+                mae = np.average([abs(a - p) for a, p in zip(valid_comparison_df['y'], valid_comparison_df['yhat'])], weights=weights)
+                mape = np.average([abs((a - p) / a) * 100 for a, p in zip(valid_comparison_df['y'], valid_comparison_df['yhat'])], weights=weights)
+            else:
+                mae = np.nan
+                mape = np.nan
+
+            results['classification_metrics']['mae'] = round(mae, 2) if not np.isnan(mae) else None
+            results['classification_metrics']['mape'] = round(mape, 2) if not np.isnan(mape) else None
+        except Exception as e:
+            raise HTTPException(status_code=500, detail=f"Error evaluating predictions: {str(e)}")
 
         # Plot results
-        plt.figure(figsize=(12, 6))
-        plt.plot(comparison_df['ds'], comparison_df['y'], 'o-', label='Actual Values', markersize=4)
-        plt.plot(comparison_df['ds'], comparison_df['yhat'], '-', label='Forecasted Values')
-        plt.fill_between(comparison_df['ds'], comparison_df['yhat_lower'], comparison_df['yhat_upper'],
-                        color='gray', alpha=0.2, label='Uncertainty Interval')
-        plt.title('Actual vs. Forecasted Daily Earnings (Last 20% of Dataset)')
-        plt.xlabel('Date')
-        plt.ylabel('Contracted Wage')
-        plt.legend()
-        plt.grid(True)
-        plt.xticks(rotation=45)
-        plt.tight_layout()
-
-        buffer = BytesIO()
-        plt.savefig(buffer, format='png')
-        buffer.seek(0)
-        plot_base64 = base64.b64encode(buffer.getvalue()).decode('utf-8')
-        results['plot'] = f'data:image/png;base64,{plot_base64}'
-        plt.close()
+        try:
+            plt.figure(figsize=(12, 6))
+            plt.plot(comparison_df['ds'], comparison_df['y'], 'o-', label='Actual Values', markersize=4)
+            plt.plot(comparison_df['ds'], comparison_df['yhat'], '-', label='Forecasted Values')
+            plt.fill_between(comparison_df['ds'], comparison_df['yhat_lower'], comparison_df['yhat_upper'],
+                            color='gray', alpha=0.2, label='Uncertainty Interval')
+            plt.title('Actual vs. Forecasted Daily Earnings (Last 20% of Dataset)')
+            plt.xlabel('Date')
+            plt.ylabel('Contracted Wage')
+            plt.legend()
+            plt.grid(True)
+            plt.xticks(rotation=45)
+            plt.tight_layout()
+
+            buffer = BytesIO()
+            plt.savefig(buffer, format='png')
+            buffer.seek(0)
+            plot_base64 = base64.b64encode(buffer.getvalue()).decode('utf-8')
+            results['plot'] = f'data:image/png;base64,{plot_base64}'
+            plt.close()
+        except Exception as e:
+            raise HTTPException(status_code=500, detail=f"Error generating plot: {str(e)}")
 
         # Worker Profile for Microfinance
-        worker_data = df.copy()
+        try:
+            worker_data = df.copy()
 
-        avg_daily_earning = worker_data[worker_data['contracted_wage'] > 0]['contracted_wage'].mean()
-        avg_monthly_earning = avg_daily_earning * 30 if not np.isnan(avg_daily_earning) else 0
+            avg_daily_earning = worker_data[worker_data['contracted_wage'] > 0]['contracted_wage'].mean()
+            avg_monthly_earning = avg_daily_earning * 30 if not np.isnan(avg_daily_earning) else 0
 
-        job_distribution = worker_data['job_type'].value_counts(normalize=True) * 100
+            job_distribution = worker_data['job_type'].value_counts(normalize=True) * 100
 
-        avg_feedback = worker_data['feedback_score'].mean()
+            avg_feedback = worker_data['feedback_score'].mean()
 
-        workholic_index = job_distribution.drop(labels=['No Job'], errors='ignore').sum() / 100
+            workholic_index = job_distribution.drop(labels=['No Job'], errors='ignore').sum() / 100
 
-        if avg_daily_earning > 0:
-            earning_stability = worker_data[worker_data['contracted_wage'] > 0]['contracted_wage'].std() / avg_daily_earning
-        else:
-            earning_stability = np.nan
+            if avg_daily_earning > 0:
+                earning_stability = worker_data[worker_data['contracted_wage'] > 0]['contracted_wage'].std() / avg_daily_earning
+            else:
+                earning_stability = np.nan
 
-        results['worker_profile'] = {
-            'average_daily_earning': round(avg_daily_earning, 2) if not np.isnan(avg_daily_earning) else None,
-            'estimated_monthly_earning': round(avg_monthly_earning, 2) if not np.isnan(avg_monthly_earning) else None,
-            'job_distribution': job_distribution.round(2).to_dict(),
-            'average_feedback_score': round(avg_feedback, 2) if not np.isnan(avg_feedback) else None,
-            'workholic_index': round(workholic_index, 2) if not np.isnan(workholic_index) else None,
-            'earning_stability': round(earning_stability, 2) if not np.isnan(earning_stability) else None
-        }
+            results['worker_profile'] = {
+                'average_daily_earning': round(avg_daily_earning, 2) if not np.isnan(avg_daily_earning) else None,
+                'estimated_monthly_earning': round(avg_monthly_earning, 2) if not np.isnan(avg_monthly_earning) else None,
+                'job_distribution': job_distribution.round(2).to_dict(),
+                'average_feedback_score': round(avg_feedback, 2) if not np.isnan(avg_feedback) else None,
+                'workholic_index': round(workholic_index, 2) if not np.isnan(workholic_index) else None,
+                'earning_stability': round(earning_stability, 2) if not np.isnan(earning_stability) else None
+            }
+        except Exception as e:
+            raise HTTPException(status_code=500, detail=f"Error generating worker profile: {str(e)}")
 
         def convert_to_serializable(obj):
             if isinstance(obj, np.floating):
@@ -214,4 +275,4 @@ async def predict_worker_earnings(worker_id: int = Query(...)):
 
 if __name__ == "__main__":
     import uvicorn
-    uvicorn.run(app, host="0.0.0.0", port=8000)
+    uvicorn.run(app, host="0.0.0.0", port=8000)