Phase-2/
├── unified_dataset.csv      # 75,000 synthetic records
├── generate_synthetic_dataset.py  # Dataset generator
├── train_model.py           # ML training pipeline
│
├── model/
│   ├── model.pkl            # Trained GradientBoostingRegressor
│   ├── scaler.pkl           # StandardScaler for normalization
│   ├── label_encoders.pkl   # Categorical encoders (Crop, State, etc.)
│   ├── feature_list.pkl     # 22 feature names for inference
│   └── model_info.pkl       # Model metadata and metrics
│
├── api/
│   └── app.py               # Flask REST API
│
└── dashboard/
    ├── index.html           # User-facing prediction UI
    ├── technical.html       # This documentation
    └── style.css, script.js

COLUMN_MAPPING = {
    # Soil Nutrients
    'N_SOIL': 'Nitrogen',
    'P_SOIL': 'Phosphorus', 
    'K_SOIL': 'Potassium',
    'Nitrogen (N)': 'Nitrogen',
    
    # Temperature variations
    'TEMPERATURE': 'Temperature_C',
    'Air temperature (C)': 'Temperature_C',
    'Temperatue': 'Temperature_C',  # typo in source
    'Mean Temp': 'Temperature_C',
    
    # Humidity variations
    'HUMIDITY': 'Humidity',
    'Air humidity (%)': 'Humidity',
    'Average Humidity': 'Humidity',
    
    # Target variable mappings
    'Yield_kg_per_hectare': 'Yield_kg_per_hectare',
    'Crop Yield': 'Yield_kg_per_hectare',
    'Yeild (Q/acre)': 'Yield_kg_per_hectare',
    'millet yield': 'Yield_kg_per_hectare',
}

from sklearn.preprocessing import StandardScaler, LabelEncoder

# 1. Handle categorical features
label_encoders = {}
for col in ['Crop', 'State', 'Irrigation_Type', 'Seed_Variety']:
    le = LabelEncoder()
    df[f'{col}_Encoded'] = le.fit_transform(df[col])
    label_encoders[col] = le

# 2. Standardize numerical features (no imputation needed - synthetic data is complete)
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# 3. Train-test split (80/20)
X_train, X_test, y_train, y_test = train_test_split(
    X_scaled, y, test_size=0.2, random_state=42
)

from sklearn.ensemble import GradientBoostingRegressor

# Best Model Configuration
model = GradientBoostingRegressor(
    n_estimators=100,      # Number of boosting stages
    learning_rate=0.1,     # Shrinks contribution of each tree
    max_depth=3,           # Maximum depth of individual trees
    min_samples_split=2,   # Min samples to split internal node
    min_samples_leaf=1,    # Min samples at leaf node
    subsample=1.0,         # Fraction of samples for fitting trees
    random_state=42        # Reproducibility seed
)

# Training
model.fit(X_train, y_train)

# Save model
import joblib
joblib.dump(model, 'model/model.pkl')

from sklearn.metrics import r2_score, mean_absolute_error, mean_squared_error
import numpy as np

# Predictions on test set
y_pred = model.predict(X_test)

# Calculate metrics
r2 = r2_score(y_test, y_pred)
mae = mean_absolute_error(y_test, y_pred)
rmse = np.sqrt(mean_squared_error(y_test, y_pred))

print(f"R² Score: {r2:.4f}")   # 0.9627
print(f"MAE: {mae:.2f}")       # 1610.29
print(f"RMSE: {rmse:.2f}")     # 3573.78

http://localhost:5000

curl -X POST http://localhost:5000/predict \
  -H "Content-Type: application/json" \
  -d '{
    "Crop": "Rice",
    "State": "Punjab",
    "Year": 2024,
    "Rainfall_mm": 1200,
    "Temperature_C": 28,
    "Humidity": 70,
    "Soil_Quality": 75,
    "Nitrogen": 45,
    "Phosphorus": 35,
    "Potassium": 42,
    "Fertilizer_Amount": 180,
    "Irrigation_Type": "Canal",
    "Seed_Variety": "Hybrid",
    "Pesticide_Usage": 8.5
  }'

{
  "status": "success",
  "predicted_yield_kg_per_hectare": 4256.78,
  "crop": "Rice",
  "state": "Punjab"
}

# Activate virtual environment
source .venv/Scripts/activate  # Windows
# source .venv/bin/activate    # Linux/Mac

# Install dependencies
pip install -r api/requirements.txt

# Run Flask development server
cd Phase-2/api
python app.py

# Server runs on http://localhost:5000

# Install gunicorn
pip install gunicorn

# Run with gunicorn (4 workers)
cd Phase-2/api
gunicorn -w 4 -b 0.0.0.0:5000 app:app

FROM python:3.11-slim

WORKDIR /app

COPY api/requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY api/ ./api/
COPY model/ ./model/

EXPOSE 5000

CMD ["gunicorn", "-w", "4", "-b", "0.0.0.0:5000", "api.app:app"]

import requests

API_URL = "http://localhost:5000"

def predict_yield(features: dict) -> float:
    """
    Make a yield prediction via the API.
    
    Args:
        features: Dictionary of input features
        
    Returns:
        Predicted yield in kg/hectare
    """
    response = requests.post(
        f"{API_URL}/predict",
        json=features
    )
    result = response.json()
    
    if result['status'] == 'success':
        return result['predicted_yield_kg_per_hectare']
    else:
        raise Exception(result.get('error', 'Unknown error'))

# Example usage
features = {
    "Crop": "Rice",
    "State": "Punjab",
    "Year": 2024,
    "Rainfall_mm": 1200,
    "Temperature_C": 28,
    "Humidity": 70,
    "Soil_Quality": 75,
    "Fertilizer_Amount": 180,
    "Irrigation_Type": "Canal",
    "Seed_Variety": "Hybrid"
}

predicted_yield = predict_yield(features)
print(f"Predicted Yield: {predicted_yield:.2f} kg/ha")

async function predictYield(features) {
    const response = await fetch('http://localhost:5000/predict', {
        method: 'POST',
        headers: {
            'Content-Type': 'application/json',
        },
        body: JSON.stringify(features)
    });
    
    const result = await response.json();
    
    if (result.status === 'success') {
        return result.predicted_yield_kg_per_hectare;
    } else {
        throw new Error(result.error || 'Unknown error');
    }
}

// Usage
const features = {
    Crop: "Rice",
    State: "Punjab",
    Year: 2024,
    Rainfall_mm: 1200,
    Temperature_C: 28,
    Humidity: 70,
    Soil_Quality: 75,
    Irrigation_Type: "Canal",
    Seed_Variety: "Hybrid"
};

predictYield(features)
    .then(yieldValue => console.log(`Predicted: ${yieldValue} kg/ha`))
    .catch(err => console.error(err));

import joblib
import numpy as np

# Load artifacts
model = joblib.load('model/model.pkl')
scaler = joblib.load('model/scaler.pkl')
label_encoders = joblib.load('model/label_encoders.pkl')
features = joblib.load('model/feature_list.pkl')

def predict(input_dict):
    """Make prediction without API"""
    # Encode categorical features
    for col in ['Crop', 'State', 'Irrigation_Type', 'Seed_Variety']:
        if col in input_dict:
            input_dict[f'{col}_Encoded'] = label_encoders[col].transform([input_dict[col]])[0]
    
    # Build feature vector
    X = np.array([[input_dict.get(f, 0) for f in features]])
    
    # Preprocess and predict
    X_scaled = scaler.transform(X)
    return max(0, model.predict(X_scaled)[0])

# Usage
result = predict({
    "Crop": "Rice", "State": "Punjab", "Year": 2024,
    "Rainfall_mm": 1200, "Temperature_C": 28,
    "Humidity": 70, "Soil_Quality": 75
})
print(f"Yield: {result:.2f} kg/ha")