Bolsa 4.0: Predicción de acciones con IA¶

%%capture
!pip install lightgbm

import pandas as pd
import numpy as np
import matplotlib as mpl
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.ensemble import RandomForestRegressor
from sklearn.model_selection import GridSearchCV
from sklearn.neighbors import KNeighborsRegressor
from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score
from sklearn.model_selection import cross_val_score
from sklearn.preprocessing import MinMaxScaler
from sklearn.tree import DecisionTreeRegressor
from sklearn.tree import plot_tree
from lightgbm import LGBMRegressor
from sklearn.model_selection import GridSearchCV
from sklearn.metrics import mean_squared_error, mean_absolute_error, root_mean_squared_error
from sklearn.inspection import permutation_importance
import scipy.stats as stats

#Importar Datos
df= pd.read_csv(r"C:\\Users\\Abraham\\OneDrive\\Desktop\\NO ENTRAR - Abraham - Personal\\PERSONAL - NO ENTRAR\\Proyecto SP500\\PEPConsolidated_202502.csv")

#Convertir el objeto "Date" a fecha
df["Date"] = pd.to_datetime(df["Date"],format='%m/%d/%Y')

#Ordenar datos por fecha
df.sort_values('Date',inplace=True)
df.reset_index(drop=True,inplace=True)

%%capture

#Quitar vacios
df_M = df.dropna(subset=['Close_M'])
df_M.reset_index(drop=True, inplace=True)

ema_12_M = df_M['Close_M'].ewm(span=12, adjust=False).mean()
ema_26_M = df_M['Close_M'].ewm(span=26, adjust=False).mean()
# Calculamos la línea MACD
macd_line_M = ema_12_M - ema_26_M
# Calculamos la línea de señal
signal_line_M = macd_line_M.ewm(span=9, adjust=False).mean()
# Calculamos las variables derivadas
df_M['MACD_M'] = macd_line_M
df_M['Signal Line_M'] = signal_line_M
df_M['MACD-Signal Diff_M'] = df_M['MACD_M'] - df_M['Signal Line_M']
df_M['MACD Crossover_M'] = np.where(
    (df_M['MACD_M'] > df_M['Signal Line_M']) & (df_M['MACD_M'].shift(1) <= df_M['Signal Line_M'].shift(1)), 1, 0)
df_M['MACD Slope_M'] = df_M['MACD_M'] - df_M['MACD_M'].shift(1)
df_M['Signal Line Slope_M'] = df_M['Signal Line_M'] - df_M['Signal Line_M'].shift(1)
df_M['MACD Above Zero_M'] = np.where(df_M['MACD_M'] > 0, 1, 0)
df_M['MACD Below Zero_M'] = np.where(df_M['MACD_M'] < 0, 1, 0)

conditions_M = [
    (df_M['MACD_M'] > df_M['Signal Line_M']) & (df_M['MACD_M'].shift(1) <= df_M['Signal Line_M'].shift(1)),  # Cruce alcista
    (df_M['MACD_M'] < df_M['Signal Line_M']) & (df_M['MACD_M'].shift(1) >= df_M['Signal Line_M'].shift(1))   # Cruce bajista
]
choices_M = ['1', '-1']
# Crear una nueva columna con la señal actual
df_M['Trend Signal_M'] = np.select(conditions_M, choices_M, default=0)
df_M.drop(['MACD_M','Signal Line_M','MACD-Signal Diff_M','MACD Slope_M','Signal Line Slope_M','MACD Crossover_M'],axis=1,inplace=True)





#RSI_Q
def calculate_rsi(df_M, window=14):
    # Calculate daily price changes
    delta = df_M['Close_M'].diff()
    gains = (delta.where(delta > 0, 0)).fillna(0)
    losses = (-delta.where(delta < 0, 0)).fillna(0)
    avg_gain = gains.rolling(window=window, min_periods=1).mean()
    avg_loss = losses.rolling(window=window, min_periods=1).mean()
    rs = avg_gain / avg_loss
    rsi = 100 - (100 / (1 + rs))
    df_M['RSI_M'] = rsi
    return df_M
df_M = calculate_rsi(df_M)

df_M['High_M%'] = df_M['High_M'].pct_change()*100
df_M['High_Q%'] = df_M['High_Q'].pct_change()*100
df_M['Close_M%'] = df_M['Close_M'].pct_change()*100
df_M['Close_Q%'] = df_M['Close_Q'].pct_change()*100
df_M['Low_M%'] = df_M['Low_M'].pct_change()*100
df_M['Low_Q%'] = df_M['Low_Q'].pct_change()*100
df_M['Volume_M%'] = df_M['Volume_M'].pct_change()*100
df_M['Volume_Q%'] = df_M['Volume_Q'].pct_change()*100
df_M['High_M%'] = df_M['High_M%'].shift(+1)
df_M['High_Q%'] = df_M['High_Q%'].shift(+3)
df_M['Close_M%'] = df_M['Close_M%'].shift(+1)
df_M['Close_Q%'] = df_M['Close_Q%'].shift(+3)
df_M['Low_M%'] = df_M['Low_M%'].shift(+1)
df_M['Low_Q%'] = df_M['Low_Q%'].shift(+3)
df_M['Volume_M%'] = df_M['Volume_M%'].shift(+1)
df_M['Volume_Q%'] = df_M['Volume_Q%'].shift(+3)
df_M['High_Q%'].replace(0, np.nan, inplace=True)
df_M['Close_Q%'].replace(0, np.nan, inplace=True)
df_M['Low_Q%'].replace(0, np.nan, inplace=True)
df_M['Volume_Q%'].replace(0, np.nan, inplace=True)
df_M['MACD Above Zero_M'] = df_M['MACD Above Zero_M'].shift(+1)
df_M['Trend Signal_M'] = df_M['Trend Signal_M'].shift(+1)
df_M['RSI_M'] = df_M['RSI_M'].shift(+1)


df_M.fillna(method='ffill', inplace=True)
df.reset_index(drop=True, inplace=True)
df = pd.merge(df, df_M[['Date','MACD Above Zero_M','Trend Signal_M','RSI_M','High_M%','High_Q%','Close_M%','Close_Q%','Low_M%','Low_Q%','Volume_M%','Volume_Q%']], on='Date', how='left')
df['Trend Signal_M'].replace(np.nan,0,inplace=True)
columna_excluida = df['High_D']
df = df.drop(columns=['High_D']).fillna(method='ffill')
df['High_D'] = columna_excluida
df.reset_index(drop=True, inplace=True)
df = df.dropna(subset=['High_D'])

df['High_D%'] = df['High_D'].pct_change()*100
df['Close_D%'] = df['Close_D'].pct_change()*100
df['Low_D%'] = df['Low_D'].pct_change()*100
df['Volume_D%'] = df['Volume_D'].pct_change()*100
df['High_D%'] = df['High_D%'].shift(+1)
df['Close_D%'] = df['Close_D%'].shift(+1)
df['Low_D%'] = df['Low_D%'].shift(+1)
df['Volume_D%'] = df['Volume_D%'].shift(+1)
df['High_D'] = df['High_D'].shift(+1)
df['Close_D'] = df['Close_D'].shift(+1)
df['Low_D'] = df['Low_D'].shift(+1)
df['Volume_D'] = df['Volume_D'].shift(+1)


#Fechas de entrenamiento
Start_date = '2000-06-30'
End_date = '2025-02-09'
df = df[(df['Date'] >= Start_date) & (df['Date'] <= End_date)]
df.reset_index(drop=True,inplace=True)
max_close_so_far = df['Close_D'].iloc[0]
last_max_close_date = df['Date'].iloc[0]
for i in range(len(df)):
    if df['Close_D'].iloc[i] > max_close_so_far:
        max_close_so_far = df['Close_D'].iloc[i]
        last_max_close_date = df['Date'].iloc[i]

    timedelta = df['Date'].iloc[i] - last_max_close_date
    df.at[i, 'Months Since Last Max Close'] = timedelta.days
    df.at[i, 'Current Drawdown % from Past Close'] = 1 - ((df['Low_D'].iloc[i]) / max_close_so_far)




#Variable Objetivo
df['Future Drawdown % from Close'] = float('NaN')

for i in range(len(df) - 1):  # -1 because we can't calculate drawdown for the last year
    # Get the HIGH price for the current year
    current_high = df.loc[i, 'Close_D']
    future_lows = df.loc[i + 1:, 'Low_D']
    if not future_lows.empty:
        future_min_low = future_lows.min()
        drawdown_percentage = 1 - ((future_min_low / current_high))
        df.at[i, 'Future Drawdown % from Close'] = drawdown_percentage

df['Price_To_Equity_Daily'] = df['Close_D']/df['normalized_epsdiluted']

#Selecciono solo los features que tienen relevancia (ya los estudie con anàlisis exploratorio)
selected_columns = [
    "Date",
    "Revenue_Growth%_12M", "Net_Income_Growth%_3M",
    "Net_Income_Growth%_6M", "Net_Income_Growth%_12M", "grossProfitRatio", "debt_to_equity", "return_on_equity"
    , "Current_Ratio", "Cash_To_Debt_Ratio", "Unemployment_Rate", "CAPE",
    "Price_To_Equity_Daily",
    "Months Since Last Max Close","Current Drawdown % from Past Close", "Future Drawdown % from Close", "Operating_Income_Ratio", "RSI_M", "Close_M%", "Revenue_Growth%_6M"
]

# Filtrar el DataFrame
df = df[selected_columns]

%%capture
#Divido la data en entrenamiento y prueba, no lo hago azar porque quiero ver que tal se comporta el modelo en los datos màs actuales.
df.replace(np.nan,0,inplace=True)
train_df = df[df['Date']< '2021-01-01']
train_df.reset_index(drop=True,inplace=True)
train_df.drop(['Date'],axis=1,inplace=True)
test_df = df[(df['Date'] >= '2021-01-01')]
test_df.reset_index(drop=True,inplace=True)
test_df.drop(['Date'],axis=1,inplace=True)

# Dividir dataframes en uno con los features y otro con la variable objetivo
X = train_df.drop(['Future Drawdown % from Close'], axis=1)
y = train_df['Future Drawdown % from Close']

#Normalizaciòn de datos para poder entrenar el KNN
X_Normalized = (X-X.min())/(X.max()-X.min())
X_Normalized

X_test = test_df.drop(['Future Drawdown % from Close'],axis=1)
y_test = test_df['Future Drawdown % from Close']
scaler = MinMaxScaler()
X_normalized = scaler.fit_transform(X)
X_test_normalized = scaler.transform(X_test)

# Convierte los arrays normalizados de vuelta a DataFrames
X_normalized_df = pd.DataFrame(X_normalized, columns=X.columns)
X_test_normalized_df = pd.DataFrame(X_test_normalized, columns=X_test.columns)

# Hacer predicciones en data de prueba y validaciòn
y_pred = knn.predict(X_Normalized)
y_pred2 = knn.predict(X_test_normalized_df)

# Cálculo de residuos
residuos = y_test - y_pred2
residuos_abs = np.abs(residuos)

%%capture
#Grid search para encontrar mejores hiperparametros para LGBM
"""
param_grid = {
    'n_estimators': [100, 200, 300],
    'max_depth': [-1, 10, 20, 30],  
    'num_leaves': [31, 50, 100],  
    'min_child_samples': [20, 50, 100], 
    'learning_rate': [0.01, 0.05, 0.1], 
    'colsample_bytree': [0.6, 0.8, 1.0]  
}

lgbm = LGBMRegressor()

grid_search = GridSearchCV(estimator=lgbm, param_grid=param_grid, cv=5,n_jobs=-1,verbose=2, scoring='neg_mean_absolute_error')

grid_search.fit(X_normalized, y)

print("Best Parameters:", grid_search.best_params_)
print("Best Score:", -grid_search.best_score_)
"""

# Hacer predicciones en el dataset de entrenamiento y prueba
y_pred = lgbm.predict(X_test_normalized_df)
y_pred3 = lgbm.predict(X_normalized)

# Cálculo de residuos
residuos = y_test - y_pred
residuos_abs = np.abs(residuos)

%%capture
#Esconder resultados con capture para proteger el contenido del modelo

# Importancia de las características
feature_importances = lgbm.feature_importances_
feature_names = X.columns

# Crear un DataFrame para las importancias
importance_df = pd.DataFrame({
    'Feature': feature_names,
    'Importance': feature_importances
}).sort_values(by='Importance', ascending=False)
print(importance_df)

# Graficar la importancia de las características
plt.figure(figsize=(10, 8))
sns.barplot(x='Importance', y='Feature', data=importance_df, palette='viridis')
plt.title('Importancia de las Características - LightGBM')
plt.xlabel('Importancia')
plt.ylabel('Características')
plt.tight_layout()
plt.show()
plt.close()

%%capture
#Esconder resultados con capture para proteger el contenido del modelo

# Calcular las importancias en porcentaje
importance_df['Importance (%)'] = (importance_df['Importance'] / importance_df['Importance'].sum()) * 100
print(importance_df)

# Graficar las importancias en porcentaje
plt.figure(figsize=(10, 8))
sns.barplot(x='Importance (%)', y='Feature', data=importance_df, palette='viridis')
plt.title('Importancia de las Características (Porcentaje) - LightGBM')
plt.xlabel('Importancia (%)')
plt.ylabel('Características')
plt.tight_layout()