import numpy as np
import pandas as pd
from sklearn.preprocessing import MinMaxScaler
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import LSTM, Dense, Dropout

# Load stock data
df = pd.read_csv('AAPL_historical.csv')
prices = df['Close'].values.reshape(-1, 1)

# Normalize data (0-1 range)
scaler = MinMaxScaler()
scaled_prices = scaler.fit_transform(prices)

# Create sequences (60 days → predict day 61)
def create_sequences(data, seq_length=60):
    X, y = [], []
    for i in range(seq_length, len(data)):
        X.append(data[i-seq_length:i, 0])
        y.append(data[i, 0])
    return np.array(X), np.array(y)

X, y = create_sequences(scaled_prices)
X = X.reshape(X.shape[0], X.shape[1], 1)  # (samples, timesteps, features)

# Split train/test (80/20)
split = int(0.8 * len(X))
X_train, X_test = X[:split], X[split:]
y_train, y_test = y[:split], y[split:]

# Build LSTM model
model = Sequential([
    LSTM(50, return_sequences=True, input_shape=(60, 1)),
    Dropout(0.2),
    LSTM(50, return_sequences=False),
    Dropout(0.2),
    Dense(25),
    Dense(1)  # Output: predicted price
])

model.compile(optimizer='adam', loss='mean_squared_error')

# Train model
history = model.fit(
    X_train, y_train,
    batch_size=32,
    epochs=50,
    validation_data=(X_test, y_test),
    verbose=1
)

# Make predictions
predictions = model.predict(X_test)
predictions = scaler.inverse_transform(predictions)  # De-normalize

print(f"Predicted Price: ${predictions[-1][0]:.2f}")
                                    

import pandas as pd
import numpy as np
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report, confusion_matrix

# Load data with features
df = pd.read_csv('stock_features.csv')

# Features
features = [
    'P/E', 'P/B', 'ROE', 'Debt/Equity',  # Fundamentals
    'RSI', 'MACD', 'Volume_Ratio',        # Technical
    'Sentiment_Score', 'Insider_Buy'      # Alternative
]

X = df[features]
y = df['Direction']  # 1 = Up, 0 = Down

# Split data
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

# Build Random Forest
rf_model = RandomForestClassifier(
    n_estimators=300,        # 300 trees
    max_depth=15,            # Prevent overfitting
    min_samples_split=20,
    min_samples_leaf=10,
    max_features='sqrt',     # √9 ≈ 3 features per split
    random_state=42
)

# Train model
rf_model.fit(X_train, y_train)

# Predictions
y_pred = rf_model.predict(X_test)
y_proba = rf_model.predict_proba(X_test)[:, 1]  # Probability of Up

# Evaluation
print(classification_report(y_test, y_pred))
print("\nConfusion Matrix:")
print(confusion_matrix(y_test, y_pred))

# Feature Importance
feature_importance = pd.DataFrame({
    'Feature': features,
    'Importance': rf_model.feature_importances_
}).sort_values('Importance', ascending=False)

print("\nTop 5 Features:")
print(feature_importance.head())
                                    

import xgboost as xgb
from sklearn.model_selection import TimeSeriesSplit
from sklearn.metrics import mean_squared_error, r2_score
import numpy as np

# Load features and target
X = df[features]
y = df['Next_Day_Return']  # Continuous target (% return)

# Time-series cross-validation
tscv = TimeSeriesSplit(n_splits=5)

# XGBoost parameters
params = {
    'objective': 'reg:squarederror',  # Regression task
    'max_depth': 6,                   # Tree depth
    'learning_rate': 0.05,            # Eta (slower = better generalization)
    'n_estimators': 500,              # Number of trees
    'subsample': 0.8,                 # Row sampling (prevents overfitting)
    'colsample_bytree': 0.8,          # Column sampling
    'gamma': 1,                       # Minimum loss reduction
    'reg_alpha': 0.1,                 # L1 regularization
    'reg_lambda': 1,                  # L2 regularization
    'random_state': 42
}

# Train with early stopping
for train_idx, val_idx in tscv.split(X):
    X_train, X_val = X.iloc[train_idx], X.iloc[val_idx]
    y_train, y_val = y.iloc[train_idx], y.iloc[val_idx]
    
    model = xgb.XGBRegressor(**params)
    model.fit(
        X_train, y_train,
        eval_set=[(X_val, y_val)],
        early_stopping_rounds=50,
        verbose=False
    )
    
    # Predictions
    y_pred = model.predict(X_val)
    
    # Metrics
    rmse = np.sqrt(mean_squared_error(y_val, y_pred))
    r2 = r2_score(y_val, y_pred)
    
    print(f"Fold RMSE: {rmse:.4f} | R²: {r2:.4f}")

# Feature importance
xgb.plot_importance(model, max_num_features=10)
                                    

import pandas as pd
import numpy as np
import ta  # Technical Analysis library

def engineer_features(df):
    """
    Create ML features from stock OHLCV data
    """
    
    # 1. PRICE-BASED FEATURES
    df['Return_1d'] = df['Close'].pct_change()
    df['Return_5d'] = df['Close'].pct_change(5)
    df['Return_20d'] = df['Close'].pct_change(20)
    df['Volatility_20d'] = df['Return_1d'].rolling(20).std()
    df['HL_Spread'] = (df['High'] - df['Low']) / df['Close']
    
    # 2. TECHNICAL INDICATORS
    df['RSI'] = ta.momentum.RSIIndicator(df['Close']).rsi()
    df['MACD'] = ta.trend.MACD(df['Close']).macd()
    df['MACD_Signal'] = ta.trend.MACD(df['Close']).macd_signal()
    df['BB_Upper'] = ta.volatility.BollingerBands(df['Close']).bollinger_hband()
    df['BB_Lower'] = ta.volatility.BollingerBands(df['Close']).bollinger_lband()
    df['ATR'] = ta.volatility.AverageTrueRange(df['High'], df['Low'], df['Close']).average_true_range()
    
    # 3. VOLUME FEATURES
    df['Volume_Ratio'] = df['Volume'] / df['Volume'].rolling(20).mean()
    df['OBV'] = ta.volume.OnBalanceVolumeIndicator(df['Close'], df['Volume']).on_balance_volume()
    
    # 4. MOVING AVERAGES
    df['SMA_20'] = df['Close'].rolling(20).mean()
    df['SMA_50'] = df['Close'].rolling(50).mean()
    df['EMA_12'] = df['Close'].ewm(span=12).mean()
    df['Price_to_SMA20'] = df['Close'] / df['SMA_20']
    
    # 5. MOMENTUM FEATURES
    df['Price_Momentum'] = df['Close'] - df['Close'].shift(10)
    df['Volume_Momentum'] = df['Volume'] - df['Volume'].shift(10)
    
    # 6. LAGGED FEATURES (past values as features)
    for lag in [1, 2, 3, 5, 10]:
        df[f'Close_Lag_{lag}'] = df['Close'].shift(lag)
        df[f'Volume_Lag_{lag}'] = df['Volume'].shift(lag)
    
    # 7. TARGET (Next day return)
    df['Target_Return'] = df['Close'].shift(-1) / df['Close'] - 1
    df['Target_Direction'] = (df['Target_Return'] > 0).astype(int)
    
    return df.dropna()

# Apply feature engineering
df_features = engineer_features(df)
print(f"Total Features Created: {len(df_features.columns)}")
                                    

import pandas as pd
from sklearn.ensemble import RandomForestClassifier

def walk_forward_backtest(df, features, target, train_periods=252, test_period=21):
    """
    Walk-forward validation for time series
    
    train_periods: Days in training window (252 = 1 year)
    test_period: Days in test window (21 = 1 month)
    """
    
    results = []
    
    for i in range(train_periods, len(df) - test_period, test_period):
        # Define windows
        train_start = i - train_periods
        train_end = i
        test_start = i
        test_end = i + test_period
        
        # Split data
        X_train = df[features].iloc[train_start:train_end]
        y_train = df[target].iloc[train_start:train_end]
        X_test = df[features].iloc[test_start:test_end]
        y_test = df[target].iloc[test_start:test_end]
        
        # Train model
        model = RandomForestClassifier(n_estimators=100, random_state=42)
        model.fit(X_train, y_train)
        
        # Predict
        y_pred = model.predict(X_test)
        
        # Calculate returns (assumes 1 = Buy, 0 = Sell)
        strategy_returns = df['Return_1d'].iloc[test_start:test_end] * y_pred
        
        # Store results
        results.append({
            'Period_Start': df.index[test_start],
            'Period_End': df.index[test_end-1],
            'Total_Return': strategy_returns.sum(),
            'Sharpe_Ratio': strategy_returns.mean() / strategy_returns.std() * np.sqrt(252),
            'Win_Rate': (y_pred == y_test).mean()
        })
    
    return pd.DataFrame(results)

# Run backtest
backtest_results = walk_forward_backtest(df, features, 'Target_Direction')

print(backtest_results)
print(f"\nAverage Sharpe Ratio: {backtest_results['Sharpe_Ratio'].mean():.2f}")
print(f"Average Win Rate: {backtest_results['Win_Rate'].mean():.2%}")