Download backend/enterprise_models.py from PROSTLE/AarthiAI: direct link, hf CLI and curl.
- Browser
- Download file 11.6 kB
-
https://huggingface.co/spaces/PROSTLE/AarthiAI/resolve/main/backend/enterprise_models.py
- Command line
-
hf download hf://spaces/PROSTLE/AarthiAI/backend/enterprise_models.py
-
curl -L -o enterprise_models.py https://huggingface.co/spaces/PROSTLE/AarthiAI/resolve/main/backend/enterprise_models.py
11.6 kB
| """ | |
| Enterprise ML ensemble: H2O.ai, DataRobot-style, Alteryx-style. | |
| Provides 75% of final prediction blend (dominant signal source). | |
| Quality-weighted: H2O 40% + DataRobot 40% + Alteryx 20%. | |
| """ | |
| from __future__ import annotations | |
| import os | |
| import numpy as np | |
| import pandas as pd | |
| from sklearn.ensemble import ExtraTreesRegressor | |
| from sklearn.linear_model import Ridge | |
| from sklearn.preprocessing import StandardScaler | |
| # Optional: H2O AutoML (pip install h2o) | |
| H2O_AVAILABLE = False | |
| try: | |
| import h2o | |
| from h2o.automl import H2OAutoML | |
| H2O_AVAILABLE = True | |
| except ImportError: | |
| pass | |
| # Optional: DataRobot API (pip install datarobot) | |
| DATAROBOT_AVAILABLE = False | |
| try: | |
| import datarobot as dr | |
| DATAROBOT_AVAILABLE = True | |
| except ImportError: | |
| pass | |
| FEATURE_COLS = ["Close", "SMA_20", "EMA_20", "RSI", "MACD", "Volume", | |
| "BB_Upper", "BB_Lower", "BB_Width", "ATR"] | |
| PREDICT_DAYS = 5 | |
| def _build_tabular_dataset(df: pd.DataFrame, target_shift: int = PREDICT_DAYS): | |
| """Build tabular X, y for regression. Target = close at t+target_shift.""" | |
| available = [c for c in FEATURE_COLS if c in df.columns] | |
| if len(available) < 2: | |
| available = ["Close"] | |
| df = df.dropna(subset=available) | |
| if len(df) < 80: | |
| return None, None, None | |
| # Add returns and volatility features | |
| df = df.copy() | |
| df["ret_1d"] = df["Close"].pct_change(1) | |
| df["ret_3d"] = df["Close"].pct_change(3) | |
| df["ret_5d"] = df["Close"].pct_change(5) | |
| df["ret_10d"] = df["Close"].pct_change(10) | |
| df["vol_5d"] = df["ret_1d"].rolling(5).std() | |
| df["vol_10d"] = df["ret_1d"].rolling(10).std() | |
| df["momentum_5d"] = df["Close"] / df["Close"].shift(5) - 1 | |
| if "SMA_20" in df.columns: | |
| df["dist_sma20"] = (df["Close"] - df["SMA_20"]) / df["SMA_20"].replace(0, np.nan) | |
| if "SMA_50" in df.columns: | |
| df["dist_sma50"] = (df["Close"] - df["SMA_50"]) / df["SMA_50"].replace(0, np.nan) | |
| if "EMA_20" in df.columns: | |
| df["dist_ema20"] = (df["Close"] - df["EMA_20"]) / df["EMA_20"].replace(0, np.nan) | |
| feature_cols = [c for c in available + [ | |
| "ret_1d", "ret_3d", "ret_5d", "ret_10d", "vol_5d", "vol_10d", | |
| "momentum_5d", "dist_sma20", "dist_sma50", "dist_ema20", | |
| ] if c in df.columns] | |
| df = df.dropna(subset=feature_cols) | |
| # Extract the very latest row (today's features) BEFORE shifting target | |
| if len(df) < 50 + target_shift: | |
| return None, None, None, None | |
| X_latest = df[feature_cols].values[-1:].astype(np.float64) | |
| # Target: percentage return at t+target_shift for training (prevents tree extrapolation limits) | |
| df_train = df.copy() | |
| df_train["target"] = (df_train["Close"].shift(-target_shift) / df_train["Close"]) - 1 | |
| df_train = df_train.dropna(subset=["target"]) | |
| if len(df_train) < 50: | |
| return None, None, None, None | |
| X_train = df_train[feature_cols].values.astype(np.float64) | |
| y_train = df_train["target"].values.astype(np.float64) | |
| return X_train, y_train, X_latest, df_train[feature_cols] | |
| def _quadratic_interpolate(current_price: float, pred_day3: float, pred_day5: float) -> list[float]: | |
| """ | |
| Generate a 5-day curve using quadratic interpolation through | |
| (day0=current, day3=pred_day3, day5=pred_day5). | |
| Produces realistic acceleration instead of straight lines. | |
| """ | |
| # Fit quadratic: p(t) = at^2 + bt + c through t=0,3,5 | |
| # p(0) = current, p(3) = pred_day3, p(5) = pred_day5 | |
| c = current_price | |
| # Solving: 9a + 3b = pred_day3 - c, 25a + 5b = pred_day5 - c | |
| d3 = pred_day3 - current_price | |
| d5 = pred_day5 - current_price | |
| # From linear algebra: a = (5*d3 - 3*d5) / (9*5 - 3*25) = (5*d3 - 3*d5) / (-30) | |
| denom = (9 * 5 - 3 * 25) # = -30 | |
| if denom == 0: | |
| denom = -30 # safety (always -30) | |
| a = (5 * d3 - 3 * d5) / denom | |
| b = (d3 - 9 * a) / 3 if abs(3) > 1e-9 else d5 / 5 | |
| prices = [] | |
| for t in range(1, PREDICT_DAYS + 1): | |
| p = a * t * t + b * t + c | |
| prices.append(round(p, 2)) | |
| return prices | |
| def _dual_target_predict(df, current_price, fit_fn): | |
| """ | |
| Predict day-3 and day-5 targets separately, then produce a | |
| quadratic interpolated 5-day curve. Much more realistic than linear. | |
| fit_fn(X_train, y_train) -> model with .predict(X) method. | |
| """ | |
| X3, y3, X3_latest, _ = _build_tabular_dataset(df, target_shift=3) | |
| X5, y5, X5_latest, _ = _build_tabular_dataset(df, target_shift=5) | |
| if X3 is None or X5 is None or len(X3) < 50 or len(X5) < 50: | |
| return None | |
| split3 = int(len(X3) * 0.85) | |
| split5 = int(len(X5) * 0.85) | |
| model3 = fit_fn(X3[:split3], y3[:split3]) | |
| model5 = fit_fn(X5[:split5], y5[:split5]) | |
| pred_day3_return = float(model3.predict(X3_latest)[0]) | |
| pred_day5_return = float(model5.predict(X5_latest)[0]) | |
| pred_day3 = current_price * (1 + pred_day3_return) | |
| pred_day5 = current_price * (1 + pred_day5_return) | |
| return _quadratic_interpolate(current_price, pred_day3, pred_day5) | |
| def _predict_h2o_local(df: pd.DataFrame, current_price: float) -> list[float] | None: | |
| """H2O AutoML local prediction (fallback if h2o not installed uses sklearn).""" | |
| from sklearn.ensemble import GradientBoostingRegressor | |
| def make_model(X_train, y_train): | |
| m = GradientBoostingRegressor( | |
| n_estimators=120, max_depth=5, learning_rate=0.04, | |
| subsample=0.85, random_state=42, | |
| ) | |
| m.fit(X_train, y_train) | |
| return m | |
| return _dual_target_predict(df, current_price, make_model) | |
| def predict_h2o(df: pd.DataFrame, current_price: float) -> list[float] | None: | |
| """H2O.ai AutoML prediction. Uses H2O if available, else sklearn fallback.""" | |
| if H2O_AVAILABLE: | |
| try: | |
| X, y, X_latest, frame = _build_tabular_dataset(df) | |
| if X is None or len(X) < 80: | |
| return _predict_h2o_local(df, current_price) | |
| h2o.init(verbose=False) | |
| train_df = pd.DataFrame(X, columns=frame.columns) | |
| train_df["target"] = y | |
| hf = h2o.H2OFrame(train_df) | |
| x_cols = list(frame.columns) | |
| aml = H2OAutoML(max_models=5, max_runtime_secs=60, seed=42) | |
| aml.train(x=x_cols, y="target", training_frame=hf) | |
| last_row = pd.DataFrame(X_latest, columns=x_cols) | |
| hf_pred = h2o.H2OFrame(last_row) | |
| pred = aml.predict(hf_pred) | |
| pred_day5_return = float(pred.as_data_frame().iloc[0, 0]) | |
| pred_day5 = current_price * (1 + pred_day5_return) | |
| h2o.shutdown(prompt=False) | |
| # H2O only predicts day-5, so we use linear interpolation for now. | |
| # TODO: Implement dual-target for H2O if possible. | |
| return [round(current_price + (i / PREDICT_DAYS) * (pred_day5 - current_price), 2) | |
| for i in range(1, PREDICT_DAYS + 1)] | |
| except Exception: | |
| pass | |
| return _predict_h2o_local(df, current_price) | |
| def predict_datarobot(df: pd.DataFrame, current_price: float) -> list[float] | None: | |
| """ | |
| DataRobot-style prediction. Uses DataRobot API if configured, | |
| else local XGBoost/RandomForest ensemble. | |
| """ | |
| dr_url = os.environ.get("DATAROBOT_API_URL") | |
| dr_key = os.environ.get("DATAROBOT_API_TOKEN") | |
| deployment_id = os.environ.get("DATAROBOT_DEPLOYMENT_ID") | |
| if DATAROBOT_AVAILABLE and dr_url and dr_key and deployment_id: | |
| try: | |
| dr.Client(token=dr_key, endpoint=dr_url) | |
| X, y, X_latest, frame = _build_tabular_dataset(df) | |
| if X is None: | |
| return None | |
| last_row = pd.DataFrame(X_latest, columns=frame.columns) | |
| pred = dr.PredictionEndpoint.predict(deployment_id, last_row) | |
| pred_day5_return = float(pred.loc[0, "prediction"]) | |
| pred_day5 = current_price * (1 + pred_day5_return) | |
| return [round(current_price + (i / PREDICT_DAYS) * (pred_day5 - current_price), 2) | |
| for i in range(1, PREDICT_DAYS + 1)] | |
| except Exception: | |
| pass | |
| # Local DataRobot-style: diverse 3-model ensemble (RF + GBM + HistGBM) | |
| from sklearn.ensemble import RandomForestRegressor, GradientBoostingRegressor | |
| from sklearn.ensemble import HistGradientBoostingRegressor | |
| def make_model(X_train, y_train): | |
| rf = RandomForestRegressor(n_estimators=150, max_depth=7, random_state=43) | |
| gbm = GradientBoostingRegressor(n_estimators=100, max_depth=5, learning_rate=0.04, random_state=44) | |
| hgbm = HistGradientBoostingRegressor(max_iter=120, max_depth=6, learning_rate=0.05, random_state=47) | |
| rf.fit(X_train, y_train) | |
| gbm.fit(X_train, y_train) | |
| hgbm.fit(X_train, y_train) | |
| class TripleEnsemble: | |
| def predict(self, X): | |
| return 0.35 * rf.predict(X) + 0.35 * gbm.predict(X) + 0.30 * hgbm.predict(X) | |
| return TripleEnsemble() | |
| return _dual_target_predict(df, current_price, make_model) | |
| def predict_alteryx(df: pd.DataFrame, current_price: float) -> list[float] | None: | |
| """ | |
| Alteryx-style prediction. Blends ExtraTrees + Ridge regression | |
| with dual-target (day-3 + day-5) quadratic interpolation. | |
| """ | |
| _scaler = StandardScaler() | |
| def make_model(X_train, y_train): | |
| X_train_scaled = _scaler.fit_transform(X_train) | |
| et = ExtraTreesRegressor(n_estimators=120, max_depth=8, random_state=45) | |
| ridge = Ridge(alpha=1.0) | |
| et.fit(X_train, y_train) | |
| ridge.fit(X_train_scaled, y_train) | |
| class TreeLinearBlend: | |
| def predict(self, X): | |
| X_s = _scaler.transform(X) | |
| return 0.6 * et.predict(X) + 0.4 * ridge.predict(X_s) | |
| return TreeLinearBlend() | |
| return _dual_target_predict(df, current_price, make_model) | |
| def get_enterprise_predictions( | |
| df: pd.DataFrame, | |
| current_price: float, | |
| ) -> tuple[list[float] | None, list[float] | None, list[float] | None]: | |
| """Return (h2o_pred, datarobot_pred, alteryx_pred). Any may be None on failure.""" | |
| h2o_p = predict_h2o(df, current_price) | |
| dr_p = predict_datarobot(df, current_price) | |
| alt_p = predict_alteryx(df, current_price) | |
| return h2o_p, dr_p, alt_p | |
| # Quality weights: H2O and DataRobot are stronger models, Alteryx is supplementary | |
| _MODEL_WEIGHTS = { | |
| "h2o": 0.40, | |
| "datarobot": 0.40, | |
| "alteryx": 0.20, | |
| } | |
| def blend_enterprise_predictions( | |
| h2o_pred: list[float] | None, | |
| datarobot_pred: list[float] | None, | |
| alteryx_pred: list[float] | None, | |
| ) -> list[float] | None: | |
| """ | |
| Blend H2O, DataRobot, Alteryx with quality-based weights (40/40/20). | |
| If one model is missing, redistribute its weight proportionally. | |
| Returns None if no models succeeded. | |
| """ | |
| available = [] | |
| if h2o_pred is not None and len(h2o_pred) == PREDICT_DAYS: | |
| available.append(("h2o", h2o_pred)) | |
| if datarobot_pred is not None and len(datarobot_pred) == PREDICT_DAYS: | |
| available.append(("datarobot", datarobot_pred)) | |
| if alteryx_pred is not None and len(alteryx_pred) == PREDICT_DAYS: | |
| available.append(("alteryx", alteryx_pred)) | |
| if not available: | |
| return None | |
| if len(available) == 1: | |
| return available[0][1] | |
| # Normalize weights for available models | |
| raw_weights = {name: _MODEL_WEIGHTS[name] for name, _ in available} | |
| total_w = sum(raw_weights.values()) | |
| norm_weights = {name: w / total_w for name, w in raw_weights.items()} | |
| blended = [] | |
| for i in range(PREDICT_DAYS): | |
| val = sum(norm_weights[name] * pred[i] for name, pred in available) | |
| blended.append(round(val, 2)) | |
| return blended | |