Update app.py

app.py

@@ -1,50 +1,169 @@
 import sys
+import joblib
+import pandas as pd
+import numpy as np
+from fastapi import FastAPI
+from pydantic import BaseModel
+from sklearn.preprocessing import FunctionTransformer, OrdinalEncoder, StandardScaler
+from sklearn.impute import SimpleImputer
+from sklearn.pipeline import make_pipeline
+from sklearn.base import BaseEstimator, TransformerMixin
+from sklearn.utils.validation import check_X_y, check_array, check_is_fitted
+
+# ========== 1️⃣ Define Custom Preprocessing Functions ==========
+
+def temp_cat(X):
+    if isinstance(X, pd.DataFrame):
+        X['avg_temp_cat'] = pd.cut(
+            X['avg_temp'],
+            bins=[0, 5, 10, 20, 30, np.inf],
+            labels=['very_cold', 'cold', 'warm', 'hot', 'very_hot']
+        )
+        return X
+    else:
+        X = pd.DataFrame(X)
+        X['avg_temp_cat'] = pd.cut(
+            X['avg_temp'],
+            bins=[0, 5, 10, 20, 30, np.inf],
+            labels=['very_cold', 'cold', 'warm', 'hot', 'very_hot']
+        )
+        return X
+
+def proxy_humidity(X):
+    if isinstance(X, pd.DataFrame):
+        X["proxy_humidity"] = X["average_rain_fall_mm_per_year"] / (X["avg_temp"] + 1)
+        return X
+    else:
+        X = pd.DataFrame(X)
+        X["proxy_humidity"] = X["average_rain_fall_mm_per_year"] / (X["avg_temp"] + 1)
+        return X
+
+# ========== 2️⃣ Define Custom Transformer Class ==========
+
+class CorrelationThresholdSelector(BaseEstimator, TransformerMixin):
+    def __init__(self, threshold=0.9, target_threshold=0.0, method="pearson", min_variance=0.0):
+        self.threshold = threshold
+        self.target_threshold = target_threshold
+        self.method = method
+        self.min_variance = min_variance
+
+    def fit(self, X, y):
+        X_original = X
+        X_arr, y_arr = check_X_y(X, y, accept_sparse=False, dtype=np.float64)
+        n_features = X_arr.shape[1]
+        self.n_features_in_ = n_features
+
+        if hasattr(X_original, "columns"):
+            self.feature_names_in_ = np.asarray(X_original.columns)
+        else:
+            self.feature_names_in_ = np.array([f"f{i}" for i in range(n_features)])
+
+        if n_features <= 1:
+            self.features_to_drop_ = np.array([], dtype=int)
+            self.selected_features_ = np.arange(n_features, dtype=int)
+            return self
+
+        X_df = pd.DataFrame(X_arr, columns=self.feature_names_in_)
+        variances = X_df.var(numeric_only=True)
+        low_var_mask = variances <= self.min_variance
+        low_var_idx = np.where(low_var_mask)[0].tolist()
+
+        corr_mat = X_df.corr(method=self.method).abs().values
+        np.fill_diagonal(corr_mat, 0.0)
+
+        y_series = pd.Series(y_arr)
+        target_corr_series = X_df.corrwith(y_series, method=self.method).abs().fillna(0.0)
+        target_corr = target_corr_series.values
+
+        visited = set()
+        drops = set()
+
+        for i in range(n_features):
+            if i in visited or i in low_var_idx:
+                continue
+
+            correlated_idx = set(np.where(corr_mat[i] > self.threshold)[0].tolist())
+            cluster = {i} | correlated_idx
+            visited |= cluster
+
+            if len(cluster) == 1:
+                continue
+
+            best = max(cluster, key=lambda idx: (target_corr[idx], X_df.iloc[:, idx].var()))
+
+            if self.target_threshold > 0 and target_corr[best] < self.target_threshold:
+                drops |= cluster
+            else:
+                cluster.remove(best)
+                drops |= cluster
+
+        drops |= set(low_var_idx)
+        self.features_to_drop_ = np.array(sorted(drops), dtype=int)
+        retained = sorted(set(range(n_features)) - set(self.features_to_drop_))
+        self.selected_features_ = np.array(retained, dtype=int)
+        self.selected_feature_names_ = self.feature_names_in_[self.selected_features_].tolist()
+        self.dropped_feature_names_ = self.feature_names_in_[self.features_to_drop_].tolist()
+        return self
+
+    def transform(self, X):
+        check_is_fitted(self, "selected_features_")
+        X_arr = check_array(X, accept_sparse=False, dtype=np.float64)
+        if self.selected_features_.size == 0:
+            return np.empty((X_arr.shape[0], 0), dtype=X_arr.dtype)
+        sel = np.asarray(self.selected_features_, dtype=int)
+        return X_arr[:, sel]
+
+
+# ========== 3️⃣ Register them for joblib to find ==========
 sys.modules['__main__'].temp_cat = temp_cat
 sys.modules['__main__'].proxy_humidity = proxy_humidity
 sys.modules['__main__'].CorrelationThresholdSelector = CorrelationThresholdSelector
 
-from fastapi import FastAPI
-from pydantic import BaseModel
-import joblib
-import pandas as pd
-import uvicorn
-
-# ✅ Initialize FastAPI app
-app = FastAPI(title="Crop Yield Predictor API", version="1.0")
+# ========== 4️⃣ Initialize FastAPI ==========
+app = FastAPI(title="🌾 Crop Yield Predictor API", version="1.0")
 
-# ✅ Load your trained model
-model = joblib.load("CropYieldPredictor.pkl")
+# ========== 5️⃣ Load Trained Model ==========
+try:
+    model = joblib.load("CropYieldPredictor.pkl")
+    print("✅ Model loaded successfully!")
+except Exception as e:
+    print(f"❌ Error loading model: {e}")
+    model = None
 
-# ✅ Define the expected input schema
+# ========== 6️⃣ Define Input Schema ==========
 class CropInput(BaseModel):
-    country: str
-    crop_type: str
-    year: int
-    avg_rainfall: float
-    pesticides: float
+    Area: str
+    Item: str
+    Year: int
+    average_rain_fall_mm_per_year: float
+    pesticides_tonnes: float
+    avg_temp: float
 
-# ✅ Home route
+# ========== 7️⃣ Routes ==========
 @app.get("/")
 def home():
-    return {"message": "Crop Yield Predictor API is running successfully!"}
+    return {"message": "🌾 Crop Yield Predictor API is live and running!"}
 
-# ✅ Prediction route
 @app.post("/predict")
 def predict_yield(data: CropInput):
-    # Convert input to DataFrame (must match training features order)
-    input_df = pd.DataFrame([{
-        "Country": data.country,
-        "Crop": data.crop_type,
-        "Year": data.year,
-        "average_rain_fall_mm_per_year": data.avg_rainfall,
-        "pesticides_tonnes": data.pesticides
-    }])
+    if model is None:
+        return {"error": "Model not loaded properly!"}
+
+    try:
+        input_df = pd.DataFrame([data.dict()])
+        prediction = model.predict(input_df)[0]
+        predicted_yield_kg_ha = prediction * 0.1
 
-    # Make prediction
-    prediction = model.predict(input_df)[0]
+        return {
+            "predicted_yield_hg_per_ha": float(prediction),
+            "predicted_yield_kg_per_ha": float(predicted_yield_kg_ha),
+            "message": "✅ Prediction successful!"
+        }
 
-    return {"predicted_yield": float(prediction)}
+    except Exception as e:
+        return {"error": str(e), "message": "❌ Prediction failed due to preprocessing or feature mismatch."}
 
-# ✅ For local testing (won’t be used in HF)
+# ========== 8️⃣ Local Run ==========
 if __name__ == "__main__":
+    import uvicorn
     uvicorn.run(app, host="0.0.0.0", port=7860)