Upload 4 files

Dockerfile

@@ -0,0 +1,29 @@
+# Use an official Python runtime as a parent image
+FROM python:3.10-slim
+
+# Set working directory in the container
+WORKDIR /app
+
+# Copy the FastAPI application file
+COPY modelLoanAPI.py /app/modelLoanAPI.py
+
+# Copy requirements file (created below)
+COPY requirements.txt /app/requirements.txt
+
+COPY requirements.txt /app/extended_worker_dataset.csv
+
+# Install system dependencies required for matplotlib and other libraries
+RUN apt-get update && apt-get install -y \
+    gcc \
+    python3-dev \
+    libpq-dev \
+    && rm -rf /var/lib/apt/lists/*
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Expose the port the app runs on
+EXPOSE 7860
+
+# Command to run the FastAPI application
+CMD ["uvicorn", "modelLoanAPI:app", "--host", "0.0.0.0", "--port", "7860"]

modelLoanAPI.py

@@ -0,0 +1,220 @@
+# -*- coding: utf-8 -*-
+from fastapi import FastAPI, HTTPException
+from fastapi.responses import JSONResponse
+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()
+
+@app.post("/predict_worker_earnings/")
+async def predict_worker_earnings(worker_id: int):
+    try:
+        # Initialize result dictionary
+        results = {
+            'worker_id': worker_id,
+            'classification_metrics': {},
+            'worker_profile': {},
+            'plot': ''
+        }
+
+        # Load data
+        df = pd.read_csv('/content/drive/MyDrive/30_year_crop_data/extended_worker_dataset.csv')
+
+        # 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
+        df['timestamp'] = pd.to_datetime(df['timestamp'])
+        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)
+
+        # Encode job_type
+        le = LabelEncoder()
+        df['job_type_encoded'] = le.fit_transform(df['job_type'])
+
+        # Split data
+        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']
+
+        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']
+
+        classifier = RandomForestClassifier(
+            n_estimators=500, max_depth=12, min_samples_split=5, random_state=42
+        )
+        classifier.fit(X_train_class, y_train_class)
+
+        # Train regressor
+        train_df_reg = train_df[train_df['has_job'] == 1].copy()
+        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)
+
+        # 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)
+
+        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']
+
+        # 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']]
+        )
+
+        # 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)
+
+        # 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']]
+        )
+
+        # 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
+        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'])
+
+        # 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
+
+        # 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()
+
+        # Worker Profile for Microfinance
+        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
+        }
+
+        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 JSONResponse(content=json.loads(json.dumps(results, default=convert_to_serializable)))
+
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8000)

requirements.txt

@@ -0,0 +1,6 @@
+fastapi==0.115.0
+uvicorn==0.30.6
+pandas==2.2.2
+numpy==1.26.4
+scikit-learn==1.5.1
+matplotlib==3.9.2