Upload 29 files

.gitattributes

@@ -33,3 +33,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+static/models/class_balancing_comparison.png filter=lfs diff=lfs merge=lfs -text
+static/models/final_results_visualization.png filter=lfs diff=lfs merge=lfs -text

app.py

@@ -0,0 +1,927 @@
+import os
+import json
+import math
+from typing import List, Dict, Any, Optional
+import warnings
+warnings.filterwarnings('ignore', category=RuntimeWarning)
+
+try:
+    from dotenv import load_dotenv
+    load_dotenv()
+except ImportError:
+    pass
+
+from flask import Flask, request, jsonify
+from flask_cors import CORS
+
+try:
+    import joblib
+except Exception:
+    joblib = None
+import pickle
+
+try:
+    import numpy as np
+    import pandas as pd
+except Exception as e:
+    print(f"Warning: NumPy/Pandas import issue: {e}")
+    import sys
+    sys.exit(1)
+
+try:
+    import torch
+    import torch.nn as nn
+    TORCH_AVAILABLE = True
+except ImportError:
+    TORCH_AVAILABLE = False
+    print("Warning: PyTorch not available. Deep learning models will not load.")
+
+# Import PyTorch model architectures
+if TORCH_AVAILABLE:
+    try:
+        from models import LSTMModel, GRUModel, FeedForwardNN, BiLSTMModel, CNN1DModel
+    except ImportError as e:
+        print(f"Warning: Could not import model architectures: {e}")
+        TORCH_AVAILABLE = False
+
+from datetime import datetime, timedelta
+import requests
+from sklearn.base import BaseEstimator, TransformerMixin
+from sklearn.pipeline import Pipeline
+
+
+API_TITLE = "ELC-V Prediction API"
+API_VERSION = "0.3.0"
+
+RAW_FEATURES = ["Open", "High", "Low", "Close", "Volume"]
+
+MARKETSTACK_API_KEY = os.environ.get("MARKETSTACK_API_KEY")
+print("\n\n\n\n\n", MARKETSTACK_API_KEY, "\n\n\n\n\n")
+MARKETSTACK_BASE_URL = "http://api.marketstack.com/v1"
+
+
+def load_artifact(path: str):
+    # Handle PyTorch models
+    if path.endswith('.pth'):
+        if not TORCH_AVAILABLE:
+            raise ImportError("PyTorch is required to load .pth files")
+        # Use weights_only=False for trusted model files
+        return torch.load(path, map_location=torch.device('cpu'), weights_only=False)
+    
+    # Handle sklearn/joblib models
+    if joblib is not None:
+        try:
+            return joblib.load(path)
+        except Exception:
+            pass
+    with open(path, "rb") as f:
+        return pickle.load(f)
+
+
+class FeatureEngineer(BaseEstimator, TransformerMixin):
+    """Sklearn-compatible feature engineering transformer."""
+    def __init__(self, lookback: int = 7):
+        self.lookback = lookback
+        self.feature_names_ = None
+
+    def fit(self, X, y=None):
+        return self
+
+    def transform(self, X):
+        if not isinstance(X, pd.DataFrame):
+            X = pd.DataFrame(X, columns=RAW_FEATURES)
+        else:
+            X = X.copy()
+
+        for col in RAW_FEATURES:
+            if col not in X.columns:
+                raise ValueError(f"Missing column: {col}")
+
+        for i in range(1, self.lookback + 1):
+            X[f'Close_lag_{i}'] = X['Close'].shift(i).fillna(X['Close'].mean())
+            X[f'Volume_lag_{i}'] = X['Volume'].shift(i).fillna(X['Volume'].mean())
+            X[f'Open_lag_{i}'] = X['Open'].shift(i).fillna(X['Open'].mean())
+            X[f'High_lag_{i}'] = X['High'].shift(i).fillna(X['High'].mean())
+            X[f'Low_lag_{i}'] = X['Low'].shift(i).fillna(X['Low'].mean())
+
+        X['returns'] = X['Close'].pct_change()
+        X['log_returns'] = np.log(X['Close'] / X['Close'].shift(1))
+
+        X['ma_7'] = X['Close'].rolling(window=7, min_periods=1).mean()
+        X['ma_14'] = X['Close'].rolling(window=14, min_periods=1).mean()
+        X['ma_30'] = X['Close'].rolling(window=30, min_periods=1).mean()
+
+        X['volatility_7'] = X['returns'].rolling(window=7, min_periods=1).std()
+        X['volatility_14'] = X['returns'].rolling(window=14, min_periods=1).std()
+
+        X['momentum_7'] = X['Close'] - X['Close'].shift(7).fillna(X['Close'].iloc[0] if len(X) > 0 else X['Close'].mean())
+        X['momentum_14'] = X['Close'] - X['Close'].shift(14).fillna(X['Close'].iloc[0] if len(X) > 0 else X['Close'].mean())
+
+        delta = X['Close'].diff()
+        gain = (delta.where(delta > 0, 0)).rolling(window=14, min_periods=1).mean()
+        loss = (-delta.where(delta < 0, 0)).rolling(window=14, min_periods=1).mean()
+        rs = gain / loss
+        X['rsi_14'] = 100 - (100 / (1 + rs))
+
+        X['bb_upper'] = X['ma_7'] + (X['volatility_7'] * 2)
+        X['bb_Lower'] = X['ma_7'] - (X['volatility_7'] * 2)
+        X['bb_width'] = X['bb_upper'] - X['bb_Lower']
+
+        X = X.bfill().ffill()
+        for col in X.columns:
+            if X[col].isna().any():
+                X[col] = X[col].fillna(X[col].mean() if X[col].notna().any() else 0)
+        X = X.fillna(0)
+
+        expected_order = [
+            'Close', 'Volume', 'Open', 'High', 'Low',
+            'Close_lag_1', 'Volume_lag_1', 'Open_lag_1', 'High_lag_1', 'Low_lag_1',
+            'Close_lag_2', 'Volume_lag_2', 'Open_lag_2', 'High_lag_2', 'Low_lag_2',
+            'Close_lag_3', 'Volume_lag_3', 'Open_lag_3', 'High_lag_3', 'Low_lag_3',
+            'Close_lag_4', 'Volume_lag_4', 'Open_lag_4', 'High_lag_4', 'Low_lag_4',
+            'Close_lag_5', 'Volume_lag_5', 'Open_lag_5', 'High_lag_5', 'Low_lag_5',
+            'Close_lag_6', 'Volume_lag_6', 'Open_lag_6', 'High_lag_6', 'Low_lag_6',
+            'Close_lag_7', 'Volume_lag_7', 'Open_lag_7', 'High_lag_7', 'Low_lag_7',
+            'returns', 'log_returns', 'ma_7', 'ma_14', 'ma_30',
+            'volatility_7', 'volatility_14', 'momentum_7', 'momentum_14',
+            'rsi_14', 'bb_upper', 'bb_Lower', 'bb_width'
+        ]
+        
+        for col in expected_order:
+            if col not in X.columns:
+                X[col] = 0
+        
+        X = X[expected_order]
+
+        if self.feature_names_ is None:
+            self.feature_names_ = list(X.columns)
+
+        X.columns.name = None
+        return X
+
+    def get_feature_names_out(self, input_features=None):
+        if self.feature_names_ is None:
+            dummy = pd.DataFrame(
+                np.random.randn(30, 5),
+                columns=RAW_FEATURES
+            )
+            self.transform(dummy)
+        return np.array(self.feature_names_)
+
+
+class PyTorchModelWrapper:
+    """Wrapper to make PyTorch models compatible with sklearn pipeline API."""
+    def __init__(self, model):
+        self.model = model
+        if TORCH_AVAILABLE:
+            self.model.eval()  # Set to evaluation mode
+    
+    def predict(self, X):
+        if not TORCH_AVAILABLE:
+            raise ImportError("PyTorch is required for this model")
+        
+        # Convert to numpy if DataFrame
+        if isinstance(X, pd.DataFrame):
+            X = X.values
+        
+        # Convert to torch tensor
+        X_tensor = torch.FloatTensor(X)
+        
+        # Make prediction
+        with torch.no_grad():
+            output = self.model(X_tensor)
+            # Handle different output formats
+            if isinstance(output, torch.Tensor):
+                predictions = output.cpu().numpy()
+                # If output is probabilities (2 classes), take class with higher prob
+                if predictions.shape[-1] == 2:
+                    predictions = predictions.argmax(axis=-1)
+                # Flatten if needed
+                if len(predictions.shape) > 1 and predictions.shape[-1] == 1:
+                    predictions = predictions.flatten()
+            else:
+                predictions = output
+        
+        return predictions
+
+
+BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+MODELS_DIR = os.path.join(BASE_DIR, "static", "models")
+
+
+def create_app() -> Flask:
+    app = Flask(__name__)
+    CORS(app, resources={
+        r"/*": {
+            "origins": ["http://localhost:3000", "http://127.0.0.1:3000"],
+            "methods": ["GET", "POST", "OPTIONS"],
+            "allow_headers": ["Content-Type"],
+        }
+    })
+
+    app.config["ARTIFACTS"] = {
+        "pipeline": None,
+        "models": {
+            # Tree/linear/boosting models
+            "random_forest": None,
+            "adaboost": None,
+            "extra_trees": None,
+            "gradient_boosting": None,
+            "xgboost": None,
+            "lightgbm": None,
+            "catboost": None,
+            "svm": None,
+            "logistic_regression": None,
+            "knn": None,
+            "best_ensemble": None,
+            "best_individual": None,
+
+            # Deep learning models (can remain unavailable if PyTorch not installed)
+            "lstm": None,
+            "bilstm": None,
+            "gru": None,
+            "1d_cnn": None,
+            "feed_forward_nn": None,
+
+            # Convenience entries for API defaults
+            "ensemble": None,
+            "individual": None,
+        },
+        "summary": None,
+        "scaler": None,
+        "available_models": [],
+    }
+
+    def _artifact_path(name: str) -> str:
+        return os.path.join(MODELS_DIR, name)
+
+    def _load_artifacts() -> Dict[str, Any]:
+        artifacts = app.config["ARTIFACTS"]
+        try:
+            engineer = FeatureEngineer(lookback=7)
+
+            # Load the pipeline with scaler
+            pipeline_path = _artifact_path("random_forest_pipeline.joblib")
+            if os.path.exists(pipeline_path):
+                saved_pipeline = load_artifact(pipeline_path)
+                artifacts["pipeline"] = Pipeline([
+                    ('features', engineer),
+                    ('saved_pipeline', saved_pipeline),
+                ])
+            else:
+                scaler_path = _artifact_path("random_forest_scaler.joblib")
+                scaler = None
+                if os.path.exists(scaler_path):
+                    scaler = load_artifact(scaler_path)
+
+                if scaler is not None:
+                    artifacts["pipeline"] = Pipeline([
+                        ('features', engineer),
+                        ('scaler', scaler),
+                    ])
+                else:
+                    artifacts["pipeline"] = Pipeline([
+                        ('features', engineer),
+                    ])
+
+            # Load individual models (ML first, DL optional)
+            model_mappings = {
+                # Primary models
+                "random_forest": "random_forest.pkl",
+                "adaboost": "adaboost.pkl",
+                "extra_trees": "extra_trees.pkl",
+                "gradient_boosting": "gradient_boosting.pkl",
+                "xgboost": "xgboost.pkl",
+                "lightgbm": "lightgbm.pkl",
+                "catboost": "catboost.pkl",
+                "svm": "svm.pkl",
+                "logistic_regression": "logistic_regression.pkl",
+                "knn": "knn.pkl",
+                "best_ensemble": "best_ensemble_package.pkl",  # Fixed filename
+                "best_individual": "best_individual_model.pkl",
+
+                # Deep learning models (load only if PyTorch available)
+                "lstm": "lstm.pth",
+                "bilstm": "bilstm.pth",
+                "gru": "gru.pth",
+                "1d_cnn": "1d-cnn.pth",
+                "feed_forward_nn": "feed-forward_nn.pth",
+            }
+
+            loaded_models = []
+            for model_name, model_file in model_mappings.items():
+                model_path = _artifact_path(model_file)
+                if os.path.exists(model_path):
+                    try:
+                        loaded = load_artifact(model_path)
+                        # Skip if it's a dict (training metadata) or doesn't have predict method
+                        if isinstance(loaded, dict):
+                            print(f"Skipped {model_name}: loaded as dict (metadata)")
+                            continue
+                        if not hasattr(loaded, 'predict'):
+                            print(f"Skipped {model_name}: no predict method")
+                            continue
+                        # Wrap PyTorch models
+                        if model_file.endswith('.pth') and TORCH_AVAILABLE:
+                            loaded = PyTorchModelWrapper(loaded)
+                        artifacts["models"][model_name] = loaded
+                        loaded_models.append(model_name)
+                        print(f"Loaded model: {model_name}")
+                    except Exception as e:
+                        print(f"Failed to load {model_name}: {e}")
+                else:
+                    print(f"Model file not found: {model_file}")
+
+            artifacts["available_models"] = loaded_models
+
+            # Set defaults: prefer saved best ensemble/individual, then random forest, then first available
+            ensemble_default = artifacts["models"].get("best_ensemble") or artifacts["models"].get("random_forest")
+            individual_default = artifacts["models"].get("best_individual") or artifacts["models"].get("random_forest")
+
+            if ensemble_default is None and loaded_models:
+                ensemble_default = artifacts["models"].get(loaded_models[0])
+            if individual_default is None and loaded_models:
+                individual_default = artifacts["models"].get(loaded_models[0])
+
+            artifacts["models"]["ensemble"] = ensemble_default
+            artifacts["models"]["individual"] = individual_default
+
+            summary_path = _artifact_path("results_summary.pkl")
+            if os.path.exists(summary_path):
+                artifacts["summary"] = load_artifact(summary_path)
+        except Exception as e:
+            artifacts["summary"] = {"error": f"Failed to load artifacts: {e}"}
+
+        return artifacts
+
+    def _validate_instance(instance: Dict[str, Any]) -> List[str]:
+        return [k for k in RAW_FEATURES if k not in instance]
+
+    def _prepare_pipeline_input(instances: List[Dict[str, Any]]) -> pd.DataFrame:
+        data = []
+        for inst in instances:
+            row = {col: inst[col] for col in RAW_FEATURES}
+            data.append(row)
+        return pd.DataFrame(data)
+
+    @app.route("/health", methods=["GET"])
+    def health():
+        artifacts = app.config["ARTIFACTS"]
+        status = {
+            "title": API_TITLE,
+            "version": API_VERSION,
+            "pipeline": artifacts["pipeline"] is not None,
+            "available_models": artifacts["available_models"],
+            "models": {k: artifacts["models"][k] is not None for k in artifacts["models"]},
+            "model_count": len([m for m in artifacts["models"].values() if m is not None]),
+        }
+        has_models = any([m for m in artifacts["models"].values() if m is not None])
+        http_code = 200 if has_models else 503
+        return jsonify(status), http_code
+
+    @app.route("/metadata", methods=["GET"])
+    def metadata():
+        artifacts = app.config["ARTIFACTS"]
+        summary = artifacts.get("summary")
+        try:
+            def _to_jsonable(obj):
+                try:
+                    json.dumps(obj)
+                    return obj
+                except TypeError:
+                    return str(obj)
+
+            if isinstance(summary, dict):
+                return jsonify({k: _to_jsonable(v) for k, v in summary.items()})
+            return jsonify({"summary": _to_jsonable(summary)})
+        except Exception:
+            return jsonify({"summary": "unavailable"})
+
+    @app.route("/predict", methods=["POST"])
+    def predict():
+        artifacts = app.config["ARTIFACTS"]
+        pipeline = artifacts["pipeline"]
+        if pipeline is None:
+            return jsonify({"error": "Pipeline not loaded"}), 503
+
+        models_loaded = any(artifacts["models"].values())
+        pipeline_can_predict = hasattr(pipeline, "predict")
+        if not models_loaded and not pipeline_can_predict:
+            return jsonify({"error": "Models not loaded"}), 503
+
+        payload = request.get_json(silent=True) or {}
+        model_choice = (payload.get("model") or "random_forest").lower()
+        return_all = bool(payload.get("all_models"))
+        
+        # Try to get the requested model
+        model = artifacts["models"].get(model_choice)
+        
+        # Fallback to ensemble, then individual, then first available
+        if model is None:
+            if artifacts["models"].get("ensemble"):
+                model = artifacts["models"]["ensemble"]
+            elif artifacts["models"].get("individual"):
+                model = artifacts["models"]["individual"]
+            elif artifacts["available_models"]:
+                model = artifacts["models"][artifacts["available_models"][0]]
+
+        if model is None:
+            return jsonify({
+                "error": f"Requested model '{model_choice}' not available",
+                "available_models": artifacts["available_models"]
+            }), 400
+
+        instances = []
+        if isinstance(payload.get("instances"), list):
+            instances = payload["instances"]
+        elif all(k in payload for k in RAW_FEATURES):
+            instances = [payload]
+
+        if not instances:
+            return jsonify({
+                "error": "No instances provided",
+                "expected_format": {
+                    "single": {c: "<number>" for c in RAW_FEATURES},
+                    "batch": {"instances": [{c: "<number>" for c in RAW_FEATURES}]},
+                },
+                "input_columns": RAW_FEATURES,
+                "available_models": artifacts["available_models"],
+                "note": "For best results, provide at least 7 rows of history for lagged features"
+            }), 400
+
+        for i, inst in enumerate(instances):
+            missing = _validate_instance(inst)
+            if missing:
+                return jsonify({
+                    "error": f"Instance {i} missing features: {missing}",
+                    "input_columns": RAW_FEATURES
+                }), 400
+
+        try:
+            X_input = _prepare_pipeline_input(instances)
+            pipeline_can_transform = hasattr(pipeline, "transform")
+
+            # Prepare transformed features once
+            if pipeline_can_transform:
+                X_transformed = pipeline.transform(X_input)
+                X_to_predict = X_transformed[-1:, :] if len(X_transformed) > 1 else X_transformed
+            else:
+                X_to_predict = X_input[-1:, :]
+
+            # Main prediction using requested/fallback model
+            if pipeline_can_predict:
+                y_all = pipeline.predict(X_input)
+                y_pred = y_all[-1:] if len(y_all) > 1 else y_all
+            elif model is not None:
+                y_pred = model.predict(X_to_predict)
+            else:
+                return jsonify({"error": "Pipeline cannot process data"}), 503
+
+            # Optional per-model predictions
+            predictions_by_model = None
+            if return_all:
+                predictions_by_model = {}
+                for m_name in artifacts["available_models"]:
+                    m = artifacts["models"].get(m_name)
+                    if m is None:
+                        continue
+                    try:
+                        y_m = m.predict(X_to_predict)
+                        pred_val = float(y_m[0].item() if hasattr(y_m[0], "item") else y_m[0])
+                        predictions_by_model[m_name] = pred_val
+                    except Exception as e:
+                        predictions_by_model[m_name] = {"error": str(e)}
+
+            response = {
+                "model": model_choice,
+                "input_columns": RAW_FEATURES,
+                "predictions": [float(v.item() if hasattr(v, "item") else v) for v in y_pred],
+                "count": len(y_pred),
+                "available_models": artifacts["available_models"],
+                "note": f"Processed {len(instances)} input row(s), predicted on last row"
+            }
+
+            if predictions_by_model is not None:
+                response["predictions_by_model"] = predictions_by_model
+
+            return jsonify(response)
+        except Exception as e:
+            return jsonify({"error": f"Pipeline failed: {str(e)}"}), 400
+
+    @app.route("/predict/symbol", methods=["POST"])
+    def predict_symbol():
+        artifacts = app.config["ARTIFACTS"]
+        pipeline = artifacts["pipeline"]
+        if pipeline is None:
+            return jsonify({"error": "Pipeline not loaded"}), 503
+
+        pipeline_can_transform = hasattr(pipeline, "transform")
+        pipeline_can_predict = hasattr(pipeline, "predict")
+
+        payload = request.get_json(silent=True) or {}
+        symbol = (payload.get("symbol") or "").upper()
+        days = int(payload.get("days", 30))
+        model_choice = (payload.get("model") or "random_forest").lower()
+
+        model = artifacts["models"].get(model_choice)
+        if model is None:
+            if artifacts["models"].get("ensemble"):
+                model = artifacts["models"]["ensemble"]
+            elif artifacts["models"].get("individual"):
+                model = artifacts["models"]["individual"]
+            elif artifacts["available_models"]:
+                model = artifacts["models"][artifacts["available_models"][0]]
+
+        if not symbol:
+            return jsonify({"error": "Symbol required"}), 400
+
+        df = fetch_market_data(symbol, days)
+        if df is None or len(df) == 0:
+            return jsonify({"error": f"Could not fetch market data for symbol: {symbol}", "symbol": symbol}), 404
+
+        try:
+            if pipeline_can_predict:
+                y_all = pipeline.predict(df)
+                y_pred = y_all[-1:] if len(y_all) > 1 else y_all
+            elif pipeline_can_transform and model is not None:
+                # Create feature engineer to transform raw OHLCV data
+                engineer = FeatureEngineer(lookback=7)
+                print(f"[DEBUG] Input df shape: {df.shape}")
+                X_engineered = engineer.fit_transform(df)
+                print(f"[DEBUG] Engineered shape: {X_engineered.shape}, type: {type(X_engineered)}")
+                
+                # Get the last row for prediction
+                if isinstance(X_engineered, pd.DataFrame):
+                    X_last_row = X_engineered.iloc[-1:].values
+                else:
+                    # Ensure it's a numpy array and 2D
+                    X_engineered = np.array(X_engineered)
+                    if X_engineered.ndim == 1:
+                        X_last_row = X_engineered.reshape(1, -1)
+                    else:
+                        X_last_row = X_engineered[-1:]
+                
+                # Apply scaler if available
+                if hasattr(pipeline, "named_steps") and pipeline.named_steps.get("scaler"):
+                    X_to_predict = pipeline.named_steps["scaler"].transform(X_last_row)
+                else:
+                    X_to_predict = X_last_row
+                    
+                y_pred = model.predict(X_to_predict)
+            else:
+                return jsonify({"error": "Pipeline cannot process data"}), 503
+        except Exception as e:
+            import traceback
+            return jsonify({
+                "error": f"Prediction failed: {str(e)}",
+                "traceback": traceback.format_exc()
+            }), 500
+
+        pred_scalar = y_pred[-1] if hasattr(y_pred, "__len__") else y_pred
+        try:
+            pred_scalar = float(getattr(pred_scalar, "item", lambda: pred_scalar)())
+        except Exception:
+            pred_scalar = float(pred_scalar)
+
+        proba_val = None
+        if hasattr(pipeline, "predict_proba"):
+            try:
+                p_all = pipeline.predict_proba(df)
+                p_last = p_all[-1] if len(p_all) > 1 else p_all[0]
+                proba_val = float(max(p_last))
+            except Exception:
+                pass
+        elif model is not None and hasattr(model, "predict_proba"):
+            try:
+                X_transformed = pipeline.transform(df) if pipeline_can_transform else df
+                X_to_predict = X_transformed[-1:, :] if len(X_transformed) > 1 else X_transformed
+                p = model.predict_proba(X_to_predict)
+                proba_val = float(max(p[0]))
+            except Exception:
+                pass
+
+        if proba_val is None or (isinstance(proba_val, float) and math.isnan(proba_val)):
+            proba_val = 1.0 if pred_scalar in (0.0, 1.0) else 0.5
+
+        latest = df.iloc[-1].to_dict()
+        return jsonify({
+            "symbol": symbol,
+            "data_points": len(df),
+            "latest_data": latest,
+            "predictions": [float(v.item() if hasattr(v, "item") else v) for v in y_pred],
+            "count": len(y_pred),
+            "predicted_price": pred_scalar,
+            "confidence": proba_val,
+            "model": model_choice,
+            "available_models": artifacts["available_models"],
+            "note": "Prediction based on Marketstack historical data"
+        })
+
+    @app.route("/predict/consensus", methods=["POST"])
+    def predict_consensus():
+        """Get consensus (mode) prediction from all models with individual model details for a symbol"""
+        artifacts = app.config["ARTIFACTS"]
+        pipeline = artifacts["pipeline"]
+        if pipeline is None:
+            return jsonify({"error": "Pipeline not loaded"}), 503
+
+        payload = request.get_json(silent=True) or {}
+        symbol = (payload.get("symbol") or "").upper()
+        days = int(payload.get("days", 30))
+
+        if not symbol:
+            return jsonify({"error": "Symbol required"}), 400
+
+        # Fetch market data for the symbol
+        df = fetch_market_data(symbol, days)
+        if df is None or len(df) == 0:
+            return jsonify({"error": f"Could not fetch market data for symbol: {symbol}", "symbol": symbol}), 404
+
+        try:
+            # Create feature engineer to transform raw OHLCV data
+            engineer = FeatureEngineer(lookback=7)
+            
+            # Transform raw market data to engineered features
+            X_engineered = engineer.fit_transform(df)
+            print(f"Engineered features shape (before conversion): {X_engineered.shape}")
+            
+            # Get the last row for prediction
+            if isinstance(X_engineered, pd.DataFrame):
+                X_last_row = X_engineered.iloc[-1:].values
+            else:
+                # Ensure it's a numpy array and 2D
+                X_engineered = np.array(X_engineered)
+                if X_engineered.ndim == 1:
+                    X_last_row = X_engineered.reshape(1, -1)
+                else:
+                    X_last_row = X_engineered[-1:]
+            
+            print(f"Last row shape for prediction: {X_last_row.shape}")
+            
+            # Then apply scaler from pipeline if available
+            pipeline_can_transform = hasattr(pipeline, "transform")
+            if pipeline_can_transform:
+                # Use the scaler/preprocessing from the pipeline
+                try:
+                    # Get the scaler step from pipeline
+                    scaler = None
+                    if hasattr(pipeline, "named_steps"):
+                        scaler = pipeline.named_steps.get("scaler")
+                    
+                    if scaler is not None:
+                        X_to_predict = scaler.transform(X_last_row)
+                    else:
+                        X_to_predict = X_last_row
+                except Exception as e:
+                    print(f"Scaler error: {e}")
+                    X_to_predict = X_last_row
+            else:
+                X_to_predict = X_last_row
+
+            # Get predictions from all available models with confidence
+            predictions_by_model = {}
+            valid_predictions = []
+            
+            if not artifacts["available_models"]:
+                return jsonify({
+                    "error": "No models available for prediction",
+                    "debug": "available_models is empty"
+                }), 503
+            
+            for model_name in artifacts["available_models"]:
+                model = artifacts["models"].get(model_name)
+                if model is None:
+                    predictions_by_model[model_name] = {"error": "Model not found"}
+                    continue
+                    
+                try:
+                    y_pred = model.predict(X_to_predict)
+                    pred_value = float(y_pred[0].item() if hasattr(y_pred[0], "item") else y_pred[0])
+                    valid_predictions.append(pred_value)
+                    
+                    # Try to get confidence/probability
+                    confidence = None
+                    if hasattr(model, "predict_proba"):
+                        try:
+                            proba = model.predict_proba(X_to_predict)
+                            confidence = float(np.max(proba[0]))
+                        except Exception as conf_err:
+                            pass
+                    
+                    predictions_by_model[model_name] = {
+                        "prediction": pred_value,
+                        "confidence": confidence
+                    }
+                except Exception as e:
+                    predictions_by_model[model_name] = {"error": str(e)}
+                    print(f"Error predicting with {model_name}: {e}")
+
+            if not valid_predictions:
+                return jsonify({
+                    "error": "No models could make predictions",
+                    "available_models": artifacts["available_models"],
+                    "predictions_by_model": predictions_by_model,
+                    "data_shape": str(X_to_predict.shape) if hasattr(X_to_predict, "shape") else "unknown"
+                }), 503
+
+            # Calculate mode (most common prediction)
+            from collections import Counter
+            # Round to nearest integer for mode calculation (for classification)
+            rounded_preds = [round(p) for p in valid_predictions]
+            pred_counts = Counter(rounded_preds)
+            mode_prediction = pred_counts.most_common(1)[0][0]
+            
+            # Calculate confidence: how many models agree with the mode
+            agreeing_models = sum(1 for p in rounded_preds if p == mode_prediction)
+            confidence_score = agreeing_models / len(valid_predictions)
+            
+            # Map prediction to human-readable label if 0/1 classification
+            pred_label = "HIGH" if mode_prediction == 1 else "LOW"
+            
+            return jsonify({
+                "symbol": symbol,
+                "mode_prediction": mode_prediction,
+                "prediction_label": pred_label,
+                "confidence": round(confidence_score, 2),
+                "agreeing_models": agreeing_models,
+                "total_models": len(valid_predictions),
+                "predictions_by_model": predictions_by_model,
+                "note": "Consensus prediction based on Marketstack historical data"
+            })
+
+        except Exception as e:
+            import traceback
+            return jsonify({
+                "error": f"Consensus prediction failed: {str(e)}",
+                "traceback": traceback.format_exc(),
+                "symbol": symbol if 'symbol' in locals() else "unknown",
+                "data_fetched": len(df) if 'df' in locals() and df is not None else 0
+            }), 400
+
+    @app.route("/predict/ensemble", methods=["POST"])
+    def predict_ensemble():
+        """Make predictions using all available models and return ensemble results"""
+        artifacts = app.config["ARTIFACTS"]
+        pipeline = artifacts["pipeline"]
+        if pipeline is None:
+            return jsonify({"error": "Pipeline not loaded"}), 503
+
+        payload = request.get_json(silent=True) or {}
+        
+        instances = []
+        if isinstance(payload.get("instances"), list):
+            instances = payload["instances"]
+        elif all(k in payload for k in RAW_FEATURES):
+            instances = [payload]
+
+        if not instances:
+            return jsonify({
+                "error": "No instances provided",
+                "expected_format": {
+                    "single": {c: "<number>" for c in RAW_FEATURES},
+                    "batch": {"instances": [{c: "<number>" for c in RAW_FEATURES}]},
+                },
+                "input_columns": RAW_FEATURES,
+                "available_models": artifacts["available_models"],
+            }), 400
+
+        for i, inst in enumerate(instances):
+            missing = _validate_instance(inst)
+            if missing:
+                return jsonify({
+                    "error": f"Instance {i} missing features: {missing}",
+                    "input_columns": RAW_FEATURES
+                }), 400
+
+        try:
+            X_input = _prepare_pipeline_input(instances)
+            pipeline_can_transform = hasattr(pipeline, "transform")
+            
+            if pipeline_can_transform:
+                X_transformed = pipeline.transform(X_input)
+                X_to_predict = X_transformed[-1:, :] if len(X_transformed) > 1 else X_transformed
+            else:
+                X_to_predict = X_input[-1:, :]
+
+            # Get predictions from all available models
+            predictions_by_model = {}
+            for model_name in artifacts["available_models"]:
+                model = artifacts["models"].get(model_name)
+                if model is not None:
+                    try:
+                        y_pred = model.predict(X_to_predict)
+                        pred_value = float(y_pred[0].item() if hasattr(y_pred[0], "item") else y_pred[0])
+                        predictions_by_model[model_name] = pred_value
+                    except Exception as e:
+                        predictions_by_model[model_name] = {"error": str(e)}
+
+            if not predictions_by_model:
+                return jsonify({"error": "No models available for prediction"}), 503
+
+            # Calculate ensemble average (exclude errors)
+            valid_predictions = [v for v in predictions_by_model.values() if isinstance(v, (int, float))]
+            ensemble_prediction = float(np.mean(valid_predictions)) if valid_predictions else None
+
+            return jsonify({
+                "model": "ensemble",
+                "input_columns": RAW_FEATURES,
+                "ensemble_prediction": ensemble_prediction,
+                "predictions_by_model": predictions_by_model,
+                "model_count": len(artifacts["available_models"]),
+                "successful_models": len([v for v in predictions_by_model.values() if isinstance(v, (int, float))]),
+                "count": 1,
+                "note": f"Ensemble prediction based on {len([v for v in predictions_by_model.values() if isinstance(v, (int, float))])} models"
+            })
+
+        except Exception as e:
+            return jsonify({"error": f"Ensemble prediction failed: {str(e)}"}), 400
+
+    @app.route("/market/data", methods=["GET"])
+    def market_data():
+        symbol = (request.args.get("symbol") or "").upper()
+        days = int(request.args.get("days", 30))
+
+        if not symbol:
+            return jsonify({"error": "Symbol required"}), 400
+
+        df = fetch_market_data(symbol, days)
+        if df is None or len(df) == 0:
+            return jsonify({"error": f"Could not fetch market data for symbol: {symbol}", "symbol": symbol}), 404
+
+        data = df.to_dict(orient="records")
+        return jsonify({
+            "symbol": symbol,
+            "days": days,
+            "data_points": len(data),
+            "data": data,
+        })
+
+    def _startup():
+        try:
+            _load_artifacts()
+        except Exception as e:
+            print(f"Warning: Artifact loading failed: {e}")
+
+    with app.app_context():
+        _startup()
+
+    return app
+
+
+def fetch_market_data(symbol: str, days: int = 30) -> Optional[pd.DataFrame]:
+    try:
+        end_date = datetime.now()
+        start_date = end_date - timedelta(days=days)
+
+        url = f"{MARKETSTACK_BASE_URL}/eod"
+        params = {
+            "access_key": MARKETSTACK_API_KEY,
+            "symbols": symbol,
+            "date_from": start_date.strftime("%Y-%m-%d"),
+            "date_to": end_date.strftime("%Y-%m-%d"),
+            "limit": days,
+        }
+
+        response = requests.get(url, params=params, timeout=10)
+        if response.status_code != 200:
+            print(f"API Error: {response.status_code} - {response.text}")
+            return None
+
+        data = response.json()
+        if "data" not in data or not data["data"]:
+            print(f"No data returned for symbol: {symbol}")
+            return None
+
+        df = pd.DataFrame(data["data"])
+        df = df.rename(columns={
+            "open": "Open",
+            "high": "High",
+            "low": "Low",
+            "close": "Close",
+            "volume": "Volume",
+        })
+
+        if "date" in df.columns:
+            df["date"] = pd.to_datetime(df["date"])
+            df = df.sort_values("date")
+
+        df = df[RAW_FEATURES]
+        return df
+    except Exception as exc:
+        print(f"Error fetching market data: {exc}")
+        return None
+
+
+app = create_app()
+@app.route("/", methods=["GET"])
+def root():
+    return jsonify({
+        "status": "ok",
+        "service": API_TITLE,
+        "version": API_VERSION
+    }), 200
+
+# if __name__ == "__main__":
+#     port = int(os.environ.get("PORT", "5000"))
+#     app.run(host="0.0.0.0", port=port)
+

models.py

@@ -0,0 +1,138 @@
+"""
+PyTorch model architectures for stock prediction.
+These classes must match the architectures used during training.
+"""
+import torch
+import torch.nn as nn
+
+
+class LSTMModel(nn.Module):
+    """LSTM model for sequence prediction"""
+    def __init__(self, input_size, hidden_size=128, num_layers=2, dropout=0.2):
+        super(LSTMModel, self).__init__()
+        self.hidden_size = hidden_size
+        self.num_layers = num_layers
+        self.lstm = nn.LSTM(input_size, hidden_size, num_layers, 
+                           batch_first=True, dropout=dropout if num_layers > 1 else 0)
+        self.fc1 = nn.Linear(hidden_size, 64)
+        self.relu = nn.ReLU()
+        self.dropout = nn.Dropout(dropout)
+        self.fc2 = nn.Linear(64, 2)
+
+    def forward(self, x):
+        x = x.unsqueeze(1)  # Add sequence dimension
+        h0 = torch.zeros(self.num_layers, x.size(0), self.hidden_size).to(x.device)
+        c0 = torch.zeros(self.num_layers, x.size(0), self.hidden_size).to(x.device)
+        out, _ = self.lstm(x, (h0, c0))
+        out = self.fc1(out[:, -1, :])
+        out = self.relu(out)
+        out = self.dropout(out)
+        out = self.fc2(out)
+        return out
+
+
+class GRUModel(nn.Module):
+    """GRU model for sequence prediction"""
+    def __init__(self, input_size, hidden_size=128, num_layers=2, dropout=0.2):
+        super(GRUModel, self).__init__()
+        self.hidden_size = hidden_size
+        self.num_layers = num_layers
+        self.gru = nn.GRU(input_size, hidden_size, num_layers, 
+                         batch_first=True, dropout=dropout if num_layers > 1 else 0)
+        self.fc1 = nn.Linear(hidden_size, 64)
+        self.relu = nn.ReLU()
+        self.dropout = nn.Dropout(dropout)
+        self.fc2 = nn.Linear(64, 2)
+
+    def forward(self, x):
+        x = x.unsqueeze(1)
+        h0 = torch.zeros(self.num_layers, x.size(0), self.hidden_size).to(x.device)
+        out, _ = self.gru(x, h0)
+        out = self.fc1(out[:, -1, :])
+        out = self.relu(out)
+        out = self.dropout(out)
+        out = self.fc2(out)
+        return out
+
+
+class FeedForwardNN(nn.Module):
+    """Feed-forward neural network"""
+    def __init__(self, input_size, hidden_sizes=[256, 128, 64], dropout=0.3):
+        super(FeedForwardNN, self).__init__()
+        layers = []
+        prev_size = input_size
+        for hidden_size in hidden_sizes:
+            layers.append(nn.Linear(prev_size, hidden_size))
+            layers.append(nn.BatchNorm1d(hidden_size))
+            layers.append(nn.ReLU())
+            layers.append(nn.Dropout(dropout))
+            prev_size = hidden_size
+        layers.append(nn.Linear(prev_size, 2))
+        self.network = nn.Sequential(*layers)
+
+    def forward(self, x):
+        return self.network(x)
+
+
+class BiLSTMModel(nn.Module):
+    """Bidirectional LSTM model"""
+    def __init__(self, input_size, hidden_size=64, num_layers=2, dropout=0.2):
+        super(BiLSTMModel, self).__init__()
+        self.hidden_size = hidden_size
+        self.num_layers = num_layers
+        self.lstm = nn.LSTM(input_size, hidden_size, num_layers, 
+                           batch_first=True, dropout=dropout if num_layers > 1 else 0, 
+                           bidirectional=True)
+        self.fc1 = nn.Linear(hidden_size * 2, 128)
+        self.relu = nn.ReLU()
+        self.dropout = nn.Dropout(dropout)
+        self.fc2 = nn.Linear(128, 64)
+        self.fc3 = nn.Linear(64, 2)
+
+    def forward(self, x):
+        x = x.unsqueeze(1)
+        h0 = torch.zeros(self.num_layers * 2, x.size(0), self.hidden_size).to(x.device)
+        c0 = torch.zeros(self.num_layers * 2, x.size(0), self.hidden_size).to(x.device)
+        out, _ = self.lstm(x, (h0, c0))
+        out = self.fc1(out[:, -1, :])
+        out = self.relu(out)
+        out = self.dropout(out)
+        out = self.fc2(out)
+        out = self.relu(out)
+        out = self.dropout(out)
+        out = self.fc3(out)
+        return out
+
+
+class CNN1DModel(nn.Module):
+    """1D Convolutional Neural Network"""
+    def __init__(self, input_size, num_filters=64, dropout=0.3):
+        super(CNN1DModel, self).__init__()
+        self.conv1 = nn.Conv1d(1, num_filters, kernel_size=3, padding=1)
+        self.conv2 = nn.Conv1d(num_filters, num_filters * 2, kernel_size=3, padding=1)
+        self.pool = nn.MaxPool1d(2)
+        self.relu = nn.ReLU()
+        self.dropout = nn.Dropout(dropout)
+        self.batch_norm1 = nn.BatchNorm1d(num_filters)
+        self.batch_norm2 = nn.BatchNorm1d(num_filters * 2)
+        self.flatten = nn.Flatten()
+        # Calculate flattened size
+        self.fc1 = nn.Linear(num_filters * 2 * (input_size // 4), 128)
+        self.fc2 = nn.Linear(128, 2)
+
+    def forward(self, x):
+        x = x.unsqueeze(1)  # Add channel dimension
+        x = self.conv1(x)
+        x = self.batch_norm1(x)
+        x = self.relu(x)
+        x = self.pool(x)
+        x = self.conv2(x)
+        x = self.batch_norm2(x)
+        x = self.relu(x)
+        x = self.pool(x)
+        x = self.flatten(x)
+        x = self.fc1(x)
+        x = self.relu(x)
+        x = self.dropout(x)
+        x = self.fc2(x)
+        return x

procfile

@@ -0,0 +1 @@
+web: gunicorn app:app --bind 0.0.0.0:$PORT --workers 1 --timeout 120 --preload

static/models/1d-cnn.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2676e9bba6d82c4f5094e719b97994b2a7c31f1bfb0e3a03a87c8e39d38c2d90
+size 967509

static/models/README.md

@@ -0,0 +1,62 @@
+# AAPL Stock Prediction Models
+
+## Training Summary
+- **Date**: 2025-12-29 03:26:07
+- **Dataset**: AAPL_dataset.csv
+- **Total Samples**: 2,614
+- **Features**: 53
+- **Train/Val/Test Split**: 1830/391/393
+
+## Best Models
+
+### Best Individual Model: SVM
+- Validation F1-Score: 0.5696
+- Test F1-Score: 0.6288
+- Test Accuracy: 0.5344
+
+### Best Ensemble: Simple Voting
+- Validation F1-Score: 0.5545
+- Test F1-Score: 0.5330
+- Test Accuracy: 0.4962
+
+## Top 5 Models
+1. SVM - F1: 0.5696
+2. Extra Trees - F1: 0.5509
+3. CatBoost - F1: 0.5445
+4. GRU - F1: 0.5306
+5. KNN - F1: 0.5175
+
+## Saved Files
+
+### Models
+- Individual model files: `*.pkl` (sklearn) or `*.pth` (PyTorch)
+- Best ensemble package: `best_ensemble_package.pkl`
+
+### Data & Configuration
+- Feature scaler: `feature_scaler.pkl`
+- Results summary: `results_summary.pkl`
+- Configuration: `config_metadata.json`
+- Results CSV: `model_results.csv`
+
+### Visualizations
+- Model comparison: `model_comparison.png`
+- Final results: `final_results_visualization.png`
+
+## Usage
+
+```python
+import joblib
+import pickle
+
+# Load scaler
+scaler = joblib.load('saved_models/feature_scaler.pkl')
+
+# Load best individual model
+best_model = joblib.load('saved_models/svm.pkl')
+
+# Load ensemble package
+with open('saved_models/best_ensemble_package.pkl', 'rb') as f:
+    ensemble = pickle.load(f)
+```
+
+## Total Models Trained: 15

static/models/adaboost.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:76ad9bba718f661773bf510eb1ac59795aa1347f4cfa8d44e95d5ee61c670cd2
+size 129444

static/models/best_ensemble_package.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:41d08537839fcc509c07c67518aa44780bbc6c2d6c26a65fb75f9e6273267665
+size 4444669

static/models/bilstm.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3fe0dabaf7d923721eb5cf815fb4e0fb3061d05660f102d857f9244bf9fd41a6
+size 752261

static/models/catboost.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a70b5af14b166df9b021a009522c0be4dbee5d6fe2826af77a70b9510d3b25fd
+size 77128

static/models/config_metadata.json

@@ -0,0 +1,9 @@
+{
+  "random_state": 42,
+  "batch_size": 64,
+  "device": "cpu",
+  "pytorch_version": "2.9.0+cpu",
+  "training_date": "2025-12-29 03:26:07",
+  "data_path": "AAPL_dataset.csv",
+  "lookback_days": 7
+}

static/models/extra_trees.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:57fd812796dec9b3de9dfc62f58ef85f77c9cefa4e119e61b13960700e7dfdc3
+size 2075209

static/models/feature_scaler.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d8841eafc764259d4e920358b6058a04a5011689840e2508f9efdf5b6b9d6d20
+size 2767

static/models/feed-forward_nn.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:38cbecc0bc99196484f3aa8bdf952b6680f4754e0c2a7886f23b38645aa829eb
+size 242438

static/models/gradient_boosting.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b3c968921605ce6858b57a233247496fb6a97a84888013d24b43615134038c1b
+size 419831

static/models/gru.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e0865ead03acf7d04444d22df0eaed2c27b4de7312c037a6d59d0f9e16830ff5
+size 718647

static/models/knn.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6ef7c8a6717b6f3fc903e5854d0ad8ee24f4a53c80e1cb526de23d65428a52c8
+size 791364

static/models/lightgbm.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3054d00141b8d840c98aa33ab76486c72e131283d3d7bd4bf05cb4d865ad7a34
+size 1053396

static/models/logistic_regression.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1850805b4faff53da83d7942a7fce2e8bc81ceb78822b4b84188c94071f839cc
+size 1323

static/models/lstm.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0ac90a779c073d8db6733766bb1c3e684949627532422d6c8f60264d220f1f00
+size 944329

static/models/model_results.csv

@@ -0,0 +1,16 @@
+Model,Train Accuracy,Val Accuracy,Val Precision,Val Recall,Val F1-Score,Val AUC
+SVM,0.521311475409836,0.4859335038363171,0.4907749077490775,0.6785714285714286,0.569593147751606,0.5096284667713239
+Extra Trees,0.9109289617486339,0.5370843989769821,0.5362318840579711,0.5663265306122449,0.5508684863523573,0.552668759811617
+CatBoost,0.8765027322404372,0.5549872122762148,0.5591397849462365,0.5306122448979592,0.5445026178010471,0.5470434327577185
+GRU,0.5448087431693989,0.5294117647058824,0.5306122448979592,0.5306122448979592,0.5306122448979592,0.5184720041862899
+KNN,1.0,0.5421994884910486,0.5485714285714286,0.4897959183673469,0.5175202156334232,0.5459445316588174
+LSTM,0.5497267759562842,0.5140664961636828,0.5153061224489796,0.5153061224489796,0.5153061224489796,0.527498691784406
+AdaBoost,0.587431693989071,0.4936061381074169,0.49528301886792453,0.5357142857142857,0.5147058823529411,0.4947278911564625
+LightGBM,0.9322404371584699,0.5217391304347826,0.5243243243243243,0.49489795918367346,0.5091863517060368,0.5209314495028782
+Gradient Boosting,0.9808743169398907,0.5345268542199488,0.5402298850574713,0.47959183673469385,0.5081081081081081,0.5361329147043433
+1D-CNN,0.5617486338797815,0.5294117647058824,0.5337078651685393,0.4846938775510204,0.5080213903743316,0.5179225536368394
+Logistic Regression,0.546448087431694,0.47058823529411764,0.4751131221719457,0.5357142857142857,0.5035971223021583,0.4817634746206175
+Random Forest,1.0,0.5115089514066496,0.5135135135135135,0.4846938775510204,0.49868766404199477,0.5381998953427525
+BiLSTM,0.5502732240437158,0.5140664961636828,0.5172413793103449,0.45918367346938777,0.4864864864864865,0.5289638932496076
+Feed-Forward NN,0.5819672131147541,0.5038363171355499,0.5055555555555555,0.4642857142857143,0.48404255319148937,0.5037414965986395
+XGBoost,0.6710382513661202,0.4961636828644501,0.4971751412429379,0.4489795918367347,0.4718498659517426,0.5119178440607012

static/models/random_forest.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a6da8873838ce35c832e45d9957e9b8ff6fd0226255980fca14634f329325642
+size 3807849

static/models/results_summary.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a478fad3f72f73d454e60f281b70f0bdec6ee491970502ac7ee9d57ec62f45cd
+size 12836673

static/models/svm.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8869b1dcd921170b5907fd9ef7629d7bfb764e89523fa8e7b84d0bd102821c06
+size 791083

static/models/xgboost.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ca550283c6edeaad2fc5ba673d3f155b09888316d5877d95a42c1d04238575b9
+size 116943