Analyseur et prédicteur boursier propulsé par l'IA

Voici un script Python optimisé qui scrape les données boursières en temps réel de Yahoo Finance, applique un apprentissage automatique pour prédire les tendances à court terme, et visualise les résultats avec Matplotlib. ```python import yfinance as yf import pandas as pd import numpy as np from sklearn.ensemble import RandomForestRegressor from sklearn.preprocessing import StandardScaler from sklearn.model_selection import train_test_split import matplotlib.pyplot as plt import matplotlib.dates as mdates from datetime import datetime, timedelta import warnings warnings.filterwarnings('ignore') # Configuration TICKER = 'AAPL' PERIOD = '1mo' INTERVAL = '1h' PREDICTION_HORIZON = 5 # Nombre de pas de temps à prédire def fetch_stock_data(ticker, period, interval): """Récupère les données boursières en temps réel depuis Yahoo Finance.""" stock = yf.Ticker(ticker) data = stock.history(period=period, interval=interval) if data.empty: raise ValueError(f"Aucune donnée trouvée pour {ticker}") return data def create_features(data): """Crée des caractéristiques techniques pour l'apprentissage automatique.""" df = data.copy() # Moyennes mobiles df['MA_5'] = df['Close'].rolling(window=5).mean() df['MA_10'] = df['Close'].rolling(window=10).mean() df['MA_20'] = df['Close'].rolling(window=20).mean() # RSI (Relative Strength Index) delta = df['Close'].diff() gain = delta.where(delta > 0, 0) loss = -delta.where(delta < 0, 0) avg_gain = gain.rolling(window=14).mean() avg_loss = loss.rolling(window=14).mean() rs = avg_gain / avg_loss df['RSI'] = 100 - (100 / (1 + rs)) # Volatilité df['Volatility'] = df['Close'].pct_change().rolling(window=10).std() # Volume relatif df['Volume_MA'] = df['Volume'].rolling(window=5).mean() df['Volume_Ratio'] = df['Volume'] / df['Volume_MA'] # Retour sur prix df['Return_1'] = df['Close'].pct_change(periods=1) df['Return_3'] = df['Close'].pct_change(periods=3) # Prix futurs (cible) df['Target'] = df['Close'].shift(-PREDICTION_HORIZON) # Supprimer les lignes avec NaN df = df.dropna() return df def prepare_data(df): """Prépare les données pour l'entraînement du modèle.""" feature_columns = ['MA_5', 'MA_10', 'MA_20', 'RSI', 'Volatility', 'Volume_Ratio', 'Return_1', 'Return_3'] X = df[feature_columns].values y = df['Target'].values # Normalisation scaler = StandardScaler() X_scaled = scaler.fit_transform(X) return X_scaled, y, feature_columns, scaler def train_model(X, y): """Entraîne un modèle de forêt aléatoire pour prédire les prix.""" X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42) model = RandomForestRegressor( n_estimators=100, max_depth=10, min_samples_split=5, min_samples_leaf=2, random_state=42, n_jobs=-1 ) model.fit(X_train, y_train) # Évaluation train_score = model.score(X_train, y_train) test_score = model.score(X_test, y_test) return model, train_score, test_score def predict_future(model, scaler, latest_data, feature_columns, n_steps): """Prédit les prix futurs en utilisant une approche itérative.""" predictions = [] current_features = latest_data[feature_columns].values.reshape(1, -1) for _ in range(n_steps): # Normaliser les caractéristiques actuelles current_scaled = scaler.transform(current_features) # Prédire le prochain prix next_price = model.predict(current_scaled)[0] predictions.append(next_price) # Mettre à jour les caractéristiques pour la prochaine itération # (approximation simple - dans un cas réel, il faudrait recalculer toutes les métriques) current_features[0, -2] = (next_price - current_features[0, -1]) / current_features[0, -1] # Return_1 current_features[0, -1] = next_price # Mettre à jour le prix de base return predictions def visualize_results(df, predictions, ticker): """Visualise les données historiques et les prédictions.""" fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(14, 10), sharex=True) # Graphique des prix ax1.plot(df.index, df['Close'], label='Prix réel', color='blue', linewidth=2) ax1.plot(df.index, df['MA_20'], label='Moyenne mobile 20', color='orange', linestyle='--', alpha=0.7) # Prédictions futures last_date = df.index[-1] future_dates = pd.date_range(start=last_date + timedelta(hours=1), periods=len(predictions), freq='h') ax1.plot(future_dates, predictions, label='Prédictions', color='red', marker='o', linestyle='--', linewidth=2) ax1.set_title(f'Analyse et prédiction des prix pour {ticker}', fontsize=14, fontweight='bold') ax1.set_ylabel('Prix (USD)', fontsize=12) ax1.legend(loc='upper left') ax1.grid(True, alpha=0.3) # Graphique du volume ax2.bar(df.index, df['Volume'], color='gray', alpha=0.6, label='Volume') ax2.set_ylabel('Volume', fontsize=12) ax2.set_xlabel('Date', fontsize=12) ax2.legend(loc='upper left') ax2.grid(True, alpha=0.3) # Formatage des dates ax1.xaxis.set_major_formatter(mdates.DateFormatter('%Y-%m-%d %H:%M')) ax1.xaxis.set_major_locator(mdates.AutoDateLocator()) plt.xticks(rotation=45) plt.tight_layout() plt.show() def main(): """Fonction principale du script.""" try: print(f"Récupération des données pour {TICKER}...") data = fetch_stock_data(TICKER, PERIOD, INTERVAL) print(f"Données récupérées : {len(data)} points") print("Création des caractéristiques...") df = create_features(data) print("Préparation des données...") X, y, feature_columns, scaler = prepare_data(df) print("Entraînement du modèle...") model, train_score, test_score = train_model(X, y) print(f"Score d'entraînement : {train_score:.4f}") print(f"Score de test : {test_score:.4f}") print("Prédiction des tendances futures...") latest_data = df.iloc[-1:] predictions = predict_future(model, scaler, latest_data, feature_columns, PREDICTION_HORIZON) print(f"Prédictions pour les {PREDICTION_HORIZON} prochaines heures :") for i, pred in enumerate(predictions, 1): print(f" Heure {i} : ${pred:.2f}") print("Visualisation des résultats...") visualize_results(df, predictions, TICKER) except Exception as e: print(f"Erreur : {e}") return if __name__ == "__main__": main() ``` Ce script optimisé comprend : 1. **Récupération des données** : Utilise `yfinance` pour obtenir des données en temps réel avec une gestion d'erreurs robuste. 2. **Ingénierie des caractéristiques** : Crée des indicateurs techniques (moyennes mobiles, RSI, volatilité, volume relatif) pour améliorer la précision du modèle. 3. **Modèle ML** : Utilise une forêt aléatoire optimisée avec des hyperparamètres réglés pour la prédiction de séries temporelles. 4. **Prédiction itérative** : Prédit plusieurs pas de temps futurs en mettant à jour les caractéristiques à chaque itération. 5. **Visualisation complète** : Affiche les prix historiques, les moyennes mobiles, les prédictions futures et le volume des transactions. 6. **Optimisations** : - Utilisation de `n_jobs=-1` pour le parallélisme - Normalisation des données avec `StandardScaler` - Gestion des valeurs manquantes - Suppression des avertissements inutiles Pour exécuter ce script, installez les dépendances : ```bash pip install yfinance pandas numpy scikit-learn matplotlib ``` Le script est configuré pour analyser AAPL sur une période d'un mois avec des intervalles horaires, mais vous pouvez facilement modifier les variables de configuration en haut du script.