modelLoanAPI.py

# ```python
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import pandas as pd
import numpy as np
from sklearn.ensemble import RandomForestClassifier, RandomForestRegressor
from sklearn.preprocessing import LabelEncoder, StandardScaler
from sklearn.metrics import accuracy_score
import matplotlib.pyplot as plt
import json
import base64
from io import BytesIO
import warnings

warnings.filterwarnings("ignore")

app = FastAPI()

class WorkerIdRequest(BaseModel):
    worker_id: int

@app.post("/predict_worker_earnings/")
async def predict_worker_earnings(request: WorkerIdRequest):
    try:
        worker_id = request.worker_id
        # Initialize result dictionary
        results = {
            'worker_id': worker_id,
            'classification_metrics': {},
            'worker_profile': {},
            'plot': ''
        }

        # Load data
        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()
        if df.empty:
            raise HTTPException(status_code=404, detail=f"No data found for worker_id {worker_id}")

        # Data preprocessing
        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)

        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()
        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()
        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
            subset['year'] = subset['timestamp'].dt.year
            subset['dayofyear'] = subset['timestamp'].dt.dayofyear
            subset['is_weekend'] = subset['dayofweek'].isin([5, 6]).astype(int)

        # Train classifier
        X_train_class = train_df[['dayofweek', 'month', 'year', 'dayofyear',
                                 'is_weekend', 'job_type_encoded', 'feedback_score',
                                 'years_of_experience']]
        y_train_class = train_df['has_job']

        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']

        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',
                            'feedback_score', 'years_of_experience']].rename(columns={'timestamp': 'ds'})

        future_df['dayofweek'] = future_df['ds'].dt.dayofweek
        future_df['month'] = future_df['ds'].dt.month
        future_df['year'] = future_df['ds'].dt.year
        future_df['dayofyear'] = future_df['ds'].dt.dayofyear
        future_df['is_weekend'] = future_df['dayofweek'].isin([5, 6]).astype(int)

        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
        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)
        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
        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()
        final_forecast_df['yhat'] = np.where(final_forecast_df['has_job_predicted'] == 0, 0, final_forecast_df['yhat'])
        final_forecast_df['yhat'] = np.minimum(final_forecast_df['yhat'], wage_cap)

        # Uncertainty intervals
        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
        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
        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
        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

            job_distribution = worker_data['job_type'].value_counts(normalize=True) * 100

            avg_feedback = worker_data['feedback_score'].mean()

            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

            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):
                return float(obj)
            if isinstance(obj, np.integer):
                return int(obj)
            if isinstance(obj, np.ndarray):
                return obj.tolist()
            return obj

        return json.loads(json.dumps(results, default=convert_to_serializable))

    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Error processing request: {str(e)}")

if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8000)