Comment utiliser le Web Scraping pour l’apprentissage automatique

Dans ce guide, vous allez découvrir :

• Qu’est-ce que l’apprentissage automatique ?
• Pourquoi le web scraping est utile pour l’apprentissage automatique
• Comment effectuer du scraping pour l’apprentissage automatique
• Comment utiliser l’apprentissage automatique sur des données extraites
• Détails sur le processus de formation de modèles d’apprentissage automatique avec des données récupérées
• Comment mettre en place des ETL lors de l’extraction de données pour l’apprentissage automatique

C’est parti !

Qu’est-ce que l’apprentissage automatique ?

L’apprentissage automatique également connu sous le nom de ML (ou AA), est une sous-section de l’intelligence artificielle (IA) qui se concentre sur la construction de systèmes capables d’apprendre à partir de données. En particulier, cette révolution qui découle de l’application de l’apprentissage automatique aux logiciels et aux systèmes informatiques est due au fait que les ordinateurs n’ont pas besoin d’être explicitement programmés pour résoudre un problème d’apprentissage automatique. Grâce aux systèmes d’apprentissage automatique qui apprennent à partir des données.

Comment les machines apprennent-elles à partir des données ? On peut considérer que l’apprentissage automatique n’est rien d’autre que des mathématiques appliquées. Les modèles d’apprentissage automatique peuvent en effet identifier les schémas des données sous-jacentes auxquelles ils sont exposés, ce qui leur permet de faire des prédictions sur les résultats lorsqu’ils sont exposés à de nouvelles données d’entrée.

Pourquoi le Web Scraping est utile pour l’apprentissage automatique

Les systèmes d’apprentissage automatique – mais, plus généralement, tout système d’IA –ont besoin de données pour former les modèles, et c’est là que le web scraping devient une opportunité pour les professionnels de données.

Voici donc quelques raisons pour lesquelles le web scraping est important pour l’apprentissage automatique :

• Collecte de données à grande échelle: Les modèles d’apprentissage automatique – et en particulier les modèles d’apprentissage profond – nécessitent de grandes quantités de données pour être entraînés efficacement. Le web scraping permet de collecter des ensembles de données à grande échelle qui pourraient ne pas être disponibles ailleurs.
• Sources de données diverses et riches: Si vous disposez déjà de données pour entraîner vos modèles d’apprentissage automatique, le web scraping est une opportunité d’élargir vos ensembles de données, dans la mesure où le web héberge une grande multitude de données.
• Informations actualisées: Parfois, les données dont vous disposez ne sont pas mises à jour en fonction des dernières tendances, et c’est là que le web scraping vous couvre. En fait, pour les modèles qui s’appuient sur les informations les plus récentes (ex. la prédiction du cours des actions, l’analyse du sentiment de l’actualité, etc.
• Améliorer la performance des modèles: Les données dont vous disposez peuvent ne jamais suffire, en fonction des modèles ou du projet sur lequel vous travaillez. C’est pourquoi l’extraction de données sur le web à l’aide du web scraping est un moyen d’obtenir davantage de données dans le but d’améliorer les performances de votre modèle et de le valider.
• Analyse du marché: L’analyse des avis, des commentaires et des évaluations permet de comprendre le sentiment des consommateurs, ce qui est précieux pour les entreprises. Elle peut également contribuer à la collecte de données sur des sujets émergents et aider à prévoir les tendances du marché ou l’opinion publique.

Prérequis

Dans cette section, vous apprendrez comment effectuer du web scraping pour l’apprentissage en ligne avec Python.

Pour reproduire le projet Python ci-dessous, votre système doit remplir les conditions préalables suivantes :

• Python (version 3.6 ou plus): Toute version de Python supérieure à 3.6 fera l’affaire. En particulier, nous installerons les dépendances via pip qui est déjà installé avec toute version de Python supérieure à 3.4.
• Jupyter Notebook 6.x: Nous utiliserons Jupyter Notebook pour analyser les données et faire des prédictions avec l’apprentissage automatique. Toute version supérieure à 6.x fera l’affaire.
• Un IDE: VS CODE ou tout autre IDE Python de votre choix fera l’affaire.

Comment effectuer du scraping pour l’apprentissage automatique

Dans cette section, vous apprendrez étape par étape à créer un projet de scraping web qui récupère des données pour les analyser plus en détail avec l’apprentissage automatique.

En détail, vous verrez comment récupérer Yahoo Finance pour obtenir les cours de l’action NVIDIA. Nous utiliserons ensuite ces données pour l’apprentissage automatique.

Étape n° 1 : Mise en place de l’environnement

Tout d’abord, créez un référentiel – appelé, par exemple, scraping_project– qui comporte des sous-dossiers appelés data, notebookset scripts , comme suit :

scraping_project/
├── data/
│   └── ...
├── notebooks/
│   └── analysis.ipynb
├── scripts/
│   └── data_retrieval.py
└── venv/

Où :

• data_retrieval.py contiendra votre logique de scraping.
• analysis.ipynb contiendra la logique d’apprentissage automatique.
• data/ contiendra les données scrappées à analyser via l’apprentissage automatique.

Le dossier venv/ contient l’environnement virtuel. Vous pouvez le créer comme suit :

python3 -m venv venv 

Pour l’activer, sous Windows, exécutez :

venv\Scripts\activate

Sous macOS/Linux, exécutez :

source venv/bin/activate

Vous pouvez maintenant installer toutes les bibliothèques nécessaires :

pip install selenium requests pandas matplotlib scikit-learn tensorflow notebook

Étape n° 2 : Définir la page cible

Pour obtenir les données historiques de NVIDIA, vous devez vous rendre à l’URL suivante :

https://finance.yahoo.com/quote/NVDA/history/

Cependant, la page présente des filtres qui vous permettent de définir la manière dont vous souhaitez que les données soient affichées :

Pour récupérer suffisamment de données pour l’apprentissage automatique, vous pouvez les filtrer par tranche de 5 ans. Pour vous faciliter la tâche, vous pouvez utiliser l’URL suivante qui filtre déjà les données sur 5 ans :

https://finance.yahoo.com/quote/NVDA/history/?frequency=1d&period1=1574082848&period2=1731931014

Dans cette page, vous devez cibler le tableau suivant et en extraire les données :

Le sélecteur CSS qui définit le tableau est .table , vous pouvez donc écrire le code suivant dans le fichier data_retrieval.py :

from selenium import webdriver
from selenium.webdriver.chrome.service import Service
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.common.by import By
from selenium.common import NoSuchElementException
import pandas as pd
import os

# Configure Selenium
driver = webdriver.Chrome(service=Service())

# Target URL
url = "https://finance.yahoo.com/quote/NVDA/history/?frequency=1d&period1=1574082848&period2=1731931014"
driver.get(url)

# Wait for the table to load
try:
    WebDriverWait(driver, 20).until(
        EC.presence_of_element_located((By.CSS_SELECTOR, ".table"))
    )
except NoSuchElementException:
    print("The table was not found, verify the HTML structure.")
    driver.quit()
    exit()

# Locate the table and extract its rows
table = driver.find_element(By.CSS_SELECTOR, ".table")
rows = table.find_elements(By.TAG_NAME, "tr")

Jusqu’à présent, ce code fait ce qui suit :

• Configure une instance de pilote Selenium Chrome
• Définit l’URL cible et demande à Selenium de la visiter
• Attend que la table soit chargée : Dans ce cas, la table cible est chargée par Javascript, donc le pilote web attend 20 secondes, juste pour être sûr que la table est chargée
• Intercepte l’ensemble du tableau en utilisant le sélecteur CSS dédié

Étape n° 3 : Récupérer les données et les enregistrer dans un fichier CSV

À ce stade, vous pouvez faire ce qui suit :

1. Extraire les en-têtes du tableau (ils seront ajoutés tels quels dans le fichier CSV)
2. Récupérer toutes les données de la table
3. Convertir les données en un  trame de données Numpy

Vous pouvez le faire avec le code suivant :

# Extract headers from the first row of the table
headers = [header.text for header in rows[0].find_elements(By.TAG_NAME, "th")]

# Extract data from the subsequent rows
data = []
for row in rows[1:]:
    cols = [col.text for col in row.find_elements(By.TAG_NAME, "td")]
    if cols:
        data.append(cols)

# Convert data into a pandas DataFrame
df = pd.DataFrame(data, columns=headers)

Étape n° 4 : Enregistrer le fichier CSV dans le dossier data/ 

Si vous regardez la structure des dossiers créée, vous devriez vous rappeler que le fichier data_retrieval.py se trouve dans le dossier scripts/ . Le fichier CVS, en revanche, doit être enregistré dans le dossier data/ , vous devez donc en tenir compte dans votre code :

# Determine the path to save the CSV file
current_dir = os.path.dirname(os.path.abspath(__file__))  

# Navigate to the "data/" directory
data_dir = os.path.join(current_dir, "../data") 

# Ensure the directory exists 
os.makedirs(data_dir, exist_ok=True)  

# Full path to the CSV file
csv_path = os.path.join(data_dir, "nvda_stock_data.csv")  

# Save the DataFrame to the CSV file
df.to_csv(csv_path, index=False)
print(f"Historical stock data saved to {csv_path}")

# Close the WebDriver
driver.quit()

Ce code détermine le chemin (absolu) actuel en utilisant la méthode os.path.dirname(), navigue vers le dossier  data/  avec la méthode os.path.join(), s’assure qu’il existe avec la méthode os.makedirs(data_dir, exist_ok=True), enregistre les données dans un fichier CSV avec la méthode df.to_csv()  de la bibliothèque Pandas, et enfin quitte le pilote.

Étape n° 5 : Assembler le tout

Voici le code complet du fichier data_retrieval.py :

from selenium import webdriver
from selenium.webdriver.chrome.service import Service
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.common.by import By
from selenium.common import NoSuchElementException
import pandas as pd
import os

# Configure Selenium
driver = webdriver.Chrome(service=Service())

# Target URL
url = "https://finance.yahoo.com/quote/NVDA/history/?frequency=1d&period1=1574082848&period2=1731931014"
driver.get(url)

# Wait for the table to load
try:
    WebDriverWait(driver, 5).until(
        EC.presence_of_element_located((By.CSS_SELECTOR, "table.table.yf-j5d1ld.noDl"))
    )
except NoSuchElementException:
    print("The table was not found, verify the HTML structure.")
    driver.quit()
    exit()

# Locate the table and extract its rows
table = driver.find_element(By.CSS_SELECTOR, ".table")
rows = table.find_elements(By.TAG_NAME, "tr")

# Extract headers from the first row of the table
headers = [header.text for header in rows[0].find_elements(By.TAG_NAME, "th")]

# Extract data from the subsequent rows
data = []
for row in rows[1:]:
    cols = [col.text for col in row.find_elements(By.TAG_NAME, "td")]
    if cols:
        data.append(cols)

# Convert data into a pandas DataFrame
df = pd.DataFrame(data, columns=headers)

# Determine the path to save the CSV file
current_dir = os.path.dirname(os.path.abspath(__file__))  

# Navigate to the "data/" directory
data_dir = os.path.join(current_dir, "../data") 

# Ensure the directory exists 
os.makedirs(data_dir, exist_ok=True)

# Full path to the CSV file  
csv_path = os.path.join(data_dir, "nvda_stock_data.csv")

# Save the DataFrame to the CSV file
df.to_csv(csv_path, index=False)
print(f"Historical stock data saved to {csv_path}")

# Close the WebDriver
driver.quit()

Ainsi, en quelques lignes de code, vous avez récupéré 5 ans de données historiques sur les actions NVIDIA et les avez sauvegardées dans un fichier CSV.

Sous Windows, lancez le script ci-dessus avec :

python data_retrieval.py

Ou de manière équivalente, sous Linux/macOS :

python3 data_retrieval.py

Voici comment apparaissent les données extraites en sortie :

Utilisation de l’apprentissage automatique sur des données extraites

Maintenant que les données sont enregistrées dans un fichier CSV, vous pouvez utiliser l’apprentissage automatique pour faire des prédictions.

Voyons comment procéder dans les étapes suivantes.

Étape n° 1 : Créer un nouveau fichier Jupyter Notebook

Pour créer un nouveau fichier Jupyter Notebook, naviguez vers le dossier notebooks/ à partir du dossier principal :

cd notebooks 

Ensuite, ouvrez un carnet de notes Jupyter comme suit :

jupyter notebook

Lorsque le navigateur est ouvert, cliquez sur New &gt ; Python3 (ipykernel) pour créer un nouveau fichier Jupyter Notebook :

Renommez le fichier, par exemple, en analysis.ipynb.

Étape n° 2 : Ouvrir le fichier CSV et afficher l’en-tête

Vous pouvez maintenant ouvrir le fichier CSV contenant les données et afficher la tête du cadre de données :

import pandas as pd

# Path to the CSV file
csv_path = "../data/nvda_stock_data.csv"

# Open the CVS file
df = pd.read_csv(csv_path)

# Show head
df.head()

Ce code va dans le dossier data/ avec csv_path = "../data/nvda_stock_data.csv". Ensuite, il ouvre le CSV avec la méthode pd.read_csv() en tant que cadre de données et affiche sa tête (les 5 premières lignes) avec la méthode df.head().

Voici le résultat attendu :

Étape n° 3 : Visualiser la tendance dans le temps de la** Adj Close valeur

Maintenant que le cadre de données est correctement chargé, vous pouvez visualiser la tendance de la valeur Adj Close , qui représente la valeur de clôture ajustée :

import matplotlib.pyplot as plt

# Ensure the "Date" column is in datetime forma
df["Date"] = pd.to_datetime(df["Date"])

# Sort the data by date (if not already sorted)
df = df.sort_values(by="Date")

# Plot the "Adj Close" values over time
plt.figure(figsize=(10, 6))
plt.plot(df["Date"], df["Adj Close"], label="Adj Close", linewidth=2)

# Customize the plot
plt.title("NVDA Stock Adjusted Close Prices Over Time", fontsize=16) # Sets title
plt.xlabel("Date", fontsize=12) # Sets x-axis label
plt.ylabel("Adjusted Close Price (USD)", fontsize=12) # Sets y-axis label
plt.grid(True, linestyle="--", alpha=0.6) # Defines styles of the line
plt.legend(fontsize=12) # Shows legend
plt.tight_layout()

# Show the plot
plt.show()

Cet extrait effectue les opérations suivantes :

• df["Date"] accède à la colonne Date du cadre de données et, avec la méthode pd.to_datetime(), s’assure que les dates sont dans le format de date
• La fonction df.sort_values() trie les dates de la colonne Date . Cela garantit que les données seront affichées dans l’ordre chronologique.
• plt.figure() définit les dimensions du graphique et plt.plot() l’affiche
• Les lignes de code sous le commentaire # Customize the plot comment sont utiles pour personnaliser le tracé en fournissant le titre, les étiquettes des axes, et en affichant la légende
• La méthode plt.show() est celle qui permet d’afficher le tracé

Le résultat attendu est à peu près le suivant :

Ce graphique montre la tendance actuelle des valeurs fermées ajustées au fil du temps des valeurs des actions NVIDIA. Le modèle d’apprentissage automatique que vous allez former devra les prédire au mieux.

Étape n° 3 : Préparer les données pour l’apprentissage automatique

Il est temps de préparer les données pour l’apprentissage automatique !

Vous pouvez tout d’abord procéder au nettoyage et à la préparation des données :

from sklearn.preprocessing import MinMaxScaler

# Convert data types
df["Volume"] = pd.to_numeric(df["Volume"].str.replace(",", ""), errors="coerce")
df["Open"] = pd.to_numeric(df["Open"].str.replace(",", ""), errors="coerce")

# Handle missing values 
df = df.infer_objects().interpolate() 

# Select the target variable ("Adj Close") and scale the data
scaler = MinMaxScaler(feature_range=(0, 1))  # Scale data between 0 and 1
data = scaler.fit_transform(df[["Adj Close"]])

Ce code fait ce qui suit :

• Convertit les valeurd Volume et Open avec la méthode to_numeric()
• Traite les valeurs manquantes en utilisant l’interpolation pour les remplir avec la méthode interpolate()
• Met les données à l’échelle avec la MinMaxScaler()
• Sélectionne et transforme (met à l’échelle) la variable cible Adj Close avec la méthode fit_transform()

Étape n° 4 : Créer les ensembles d’entraînement et de test

Le modèle utilisé pour ce tutoriel est un LSTM (Long Short-Term Memory), qui est un RNR (Réseau de neurones récurrents), créez donc une séquence d’étapes pour lui permettre d’apprendre les données :

import numpy as np

# Create sequences of 60 time steps for prediction
sequence_length = 60
X, y = [], []

for i in range(sequence_length, len(data)):
    X.append(data[i - sequence_length:i, 0])  # Last 60 days
    y.append(data[i, 0])  # Target value

X, y = np.array(X), np.array(y)

# Split into training and test sets
split_index = int(len(X) * 0.8)  # 80% training, 20% testing
X_train, X_test = X[:split_index], X[split_index:]
y_train, y_test = y[:split_index], y[split_index:]

Ce code :

• Crée une séquence de 60 pas de temps. X est le tableau des caractéristiques, y est le tableau de la valeur cible
• Divise la base de données initiale de la manière suivante : 80 % devient l’ensemble d’entraînement, 20 % l’ensemble de test

Étape n° 5 : Entraînement du modèle

Vous pouvez maintenant entraîner le RNN sur l’ensemble d’entraînement :

from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, LSTM

# Reshape X for LSTM [samples, time steps, features]
X_train = X_train.reshape((X_train.shape[0], X_train.shape[1], 1))
X_test = X_test.reshape((X_test.shape[0], X_test.shape[1], 1))

# Build the Sequential Neural Network
model = Sequential()
model.add(LSTM(32, activation="relu", return_sequences=False))
model.add(Dense(1))
model.compile(loss="mean_squared_error", optimizer="adam")

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

Ce code fait ce qui suit :

• Remanie le tableau des caractéristiques à préparer pour le réseau neuronal LSTM en utilisant la méthode reshape(), à la fois pour l’ensemble de formation et l’ensemble de test
• Construit le réseau neuronal LSTM en définissant ses paramètres
• Ajuste la LSTM à l’ensemble d’entraînement en utilisant la méthode fit()

Le modèle s’est donc adapté à la rame et il est prêt à faire des prédictions.

Étape n° 6 : Faire des prédictions et évaluer la performance du modèle

Le modèle est maintenant prêt à prédire les valeurs Adj Close et vous pouvez évaluer ses performances comme suit :

from sklearn.metrics import mean_squared_error, r2_score

# Make Predictions
y_pred = model.predict(X_test)

# Inverse scale predictions and actual values for comparison
y_test = scaler.inverse_transform(y_test.reshape(-1, 1))
y_pred = scaler.inverse_transform(y_pred)

# Evaluate the Model
mse = mean_squared_error(y_test, y_pred)
r2 = r2_score(y_test, y_pred)

# print results
print("\nLSTM Neural Network Results:")
print(f"Mean Squared Error: {mse:.2f}")
print(f"R-squared Score: {r2:.2f}")

Ce code fait ce qui suit :

• Inverse les valeurs sur l’axe horizontal afin que les données puissent être présentées dernièrement dans l’ordre chronologique. Cela se fait avec la méthode inverse_transform().
• Évalue le modèle en utilisant l’erreur quadratique moyenne  et le scoreR^2.

Compte tenu des erreurs statistiques qui peuvent se produire en raison de la nature stochastique des modèles ML, le résultat attendu est à peu près le suivant :

Ces valeurs sont assez bonnes, ce qui indique que le modèle choisi est un bon modèle pour prédire le Adj Closecompte tenu de ses caractéristiques.

Etape n° 7 : Comparer les valeurs réelles et les valeurs prédites à l’aide d’un graphique

En matière d’apprentissage automatique, la comparaison analytique des résultats – comme nous l’avons fait à l’étape précédente – peut parfois s’avérer insuffisante. Pour augmenter les chances que le modèle choisi soit bon, une solution typique consiste à créer également un graphique.

Par exemple, une solution courante consiste à créer un graphique qui compare les valeurs réelles des Adj Close avec celles prédites par le modèle LSTM :

# Visualize the Results
test_results = pd.DataFrame({
    "Date": df["Date"].iloc[len(df) - len(y_test):],  # Test set dates
    "Actual": y_test.flatten(),
    "Predicted": y_pred.flatten()
})

# Setting plot
plt.figure(figsize=(12, 6))
plt.plot(test_results["Date"], test_results["Actual"], label="Actual Adjusted Close", color="blue", linewidth=2)
plt.plot(test_results["Date"], test_results["Predicted"], label="Predicted Adjusted Close", color="orange", linestyle="--", linewidth=2)
plt.title("Actual vs Predicted Adjusted Close Prices (LSTM)", fontsize=16)
plt.xlabel("Date", fontsize=12)
plt.ylabel("Adjusted Close Price (USD)", fontsize=12)
plt.legend()
plt.grid(alpha=0.6)
plt.tight_layout()
plt.show()

Ce code :

• Définit la comparaison des valeurs réelles et prédites au niveau de l’ensemble de test, de sorte que les valeurs réelles doivent être adaptées à la forme de l’ensemble de test. Cela se fait avec les méthodes iloc() et flatten().
• Crée le graphique, ajoute des étiquettes aux axes et au titre, et gère d’autres paramètres pour améliorer la visualisation.

Le résultat attendu est à peu près le suivant :

Comme le montre le graphique, les valeurs prédites par le réseau neuronal LSTM (ligne jaune pointillés) prédisent assez bien les valeurs réelles (ligne bleue continue). Ce résultat est respectable car les résultats analytiques sont bons, mais le graphique permet de visualiser que le résultat est effectivement bon.

Étape n° 8 : Assembler le tout

Voici le code complet pour l’analyse analysis.ipynb notebook :

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.preprocessing import MinMaxScaler
from sklearn.metrics import mean_squared_error, r2_score
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, LSTM

# Path to the CSV file
csv_path = "../data/nvda_stock_data.csv"  
# Open CSV as data frame
df = pd.read_csv(csv_path)

# Convert "Date" to datetime format
df["Date"] = pd.to_datetime(df["Date"])

# Sort by date
df = df.sort_values(by="Date")

# Convert data types
df["Volume"] = pd.to_numeric(df["Volume"].str.replace(",", ""), errors="coerce")
df["Open"] = pd.to_numeric(df["Open"].str.replace(",", ""), errors="coerce")

# Handle missing values 
df = df.infer_objects().interpolate()

# Select the target variable ("Adj Close") and scale the data
scaler = MinMaxScaler(feature_range=(0, 1))  # Scale data between 0 and 1
data = scaler.fit_transform(df[["Adj Close"]])

# Prepare the Data for LSTM
# Create sequences of 60 time steps for prediction
sequence_length = 60
X, y = [], []

for i in range(sequence_length, len(data)):
    X.append(data[i - sequence_length:i, 0])  # Last 60 days
    y.append(data[i, 0])  # Target value

X, y = np.array(X), np.array(y)

# Split into training and test sets
split_index = int(len(X) * 0.8)  # 80% training, 20% testing
X_train, X_test = X[:split_index], X[split_index:]
y_train, y_test = y[:split_index], y[split_index:]

# Reshape X for LSTM [samples, time steps, features]
X_train = X_train.reshape((X_train.shape[0], X_train.shape[1], 1))
X_test = X_test.reshape((X_test.shape[0], X_test.shape[1], 1))

# Build the Sequential Neural Network
model = Sequential()
model.add(LSTM(32, activation="relu", return_sequences=False))
model.add(Dense(1))
model.compile(loss="mean_squared_error", optimizer="adam")

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

# Make Predictions
y_pred = model.predict(X_test)

# Inverse scale predictions and actual values for comparison
y_test = scaler.inverse_transform(y_test.reshape(-1, 1))
y_pred = scaler.inverse_transform(y_pred)

# Evaluate the Model
mse = mean_squared_error(y_test, y_pred)
r2 = r2_score(y_test, y_pred)

# Print results
print("\nLSTM Neural Network Results:")
print(f"Mean Squared Error: {mse:.2f}")
print(f"R-squared Score: {r2:.2f}")

# Visualize the Results
test_results = pd.DataFrame({
    "Date": df["Date"].iloc[len(df) - len(y_test):],  # Test set dates
    "Actual": y_test.flatten(),
    "Predicted": y_pred.flatten()
})

# Setting plot
plt.figure(figsize=(12, 6))
plt.plot(test_results["Date"], test_results["Actual"], label="Actual Adjusted Close", color="blue", linewidth=2)
plt.plot(test_results["Date"], test_results["Predicted"], label="Predicted Adjusted Close", color="orange", linestyle="--", linewidth=2)
plt.title("Actual vs Predicted Adjusted Close Prices (LSTM)", fontsize=16)
plt.xlabel("Date", fontsize=12)
plt.ylabel("Adjusted Close Price (USD)", fontsize=12)
plt.legend()
plt.grid(alpha=0.6)
plt.tight_layout()
plt.show()

Notez que tout ce code va directement à l’objectif, en sautant les parties montrant l’en-tête du cadre de données lors de son ouverture et en traçant uniquement les valeurs Adj Close valeurs réelles.

Ces étapes ont été mentionnées au début de ce paragraphe dans le cadre de l’analyse préliminaire des données et sont utiles pour comprendre ce que l’on fait avec les données avant d’entamer la formation d’un modèle de ML.

REMARQUE: Le code a été présenté morceau par morceau mais, compte tenu de la nature stochastique de la ML, il est suggéré d’exécuter l’ensemble du code afin d’entraîner et de valider correctement le modèle LSTM. Dans le cas inverse, le tracé final obtenu peut être sensiblement différent.

Notes sur le processus Entraînement de modèles ML à l’aide de données brutes

Par souci de simplicité, le guide étape par étape fourni dans cet article porte directement sur l’adaptation d’un réseau neuronal LSTM.

En réalité, ce n’est pas ce qui se passe avec les modèles ML. Ainsi, lorsque vous essayez de résoudre un problème qui nécessite un modèle ML, le processus est le suivant :

• Analyse préliminaire des données: Il s’agit de la partie la plus importante du processus, car c’est là que vous comprenez les données dont vous disposez, que vous nettoyez les données en supprimant les valeurs NaN, que vous gérez les éventuels doublons et que vous résolvez d’autres problèmes mathématiques liés aux données dont vous disposez.
• Entraînement des modèles ML: Vous ne savez jamais si le premier modèle que vous avez en tête sera le meilleur pour résoudre le problème auquel vous êtes confronté avec le ML. Une solution typique consiste à effectuer le contrôle ponctuel  , ce qui signifie :
  • Entraînement de 3 à 4 modèles ML sur l’ensemble d’entraînement et évaluation de leurs performances.
  • Obtenir les 2-3 modèles ML les plus performants sur l’ensemble d’entraînement, et régler leurs hyperparamètres.
  • Comparaison de la performance des meilleurs modèles avec des hyperparamètres ajustés sur l’ensemble de test.
  • Choisir celui qui donne les meilleurs résultats sur l’ensemble de test.
• Déploiement: Le modèle le plus performant est donc celui qui sera déployé en production.

Mise en place d’ETL lors de l’extraction de données pour l’apprentissage automatique

Au début de cet article, nous avons expliqué pourquoi le web scraping est utile pour l’apprentissage automatique. Cependant, vous avez peut-être remarqué une incohérence dans le projet développé qui repose sur le fait que les données récupérées via le web scraping ont été sauvegardées dans un fichier CSV.

Il s’agit d’une pratique courante en apprentissage automatique, mais il est préférable de le faire au début d’un projet d’apprentissage automatique, lorsque l’objectif est de trouver le meilleur modèle capable de prédire les valeurs futures des valeurs cibles.

Lorsque le meilleur modèle est trouvé, la pratique suivante consiste à mettre en place un ETL (Extract Transform Load) pour récupérer les nouvelles données sur le web, les nettoyer et les charger dans une base de données.

Le processus peut se dérouler comme suit :

• Extraire: Cette phase permet de récupérer les données à partir de diverses sources, y compris le web via le scaping
• Transformer: Les données collectées sont soumises à un processus de nettoyage et de préparation
• Charger: Les données récupérées et transformées sont traitées et enregistrées dans une base de données ou un entrepôt de données

Une fois les données stockées, la phase suivante assure l’intégration avec les flux de travail d’apprentissage automatique qui, entre autres, entraînent à nouveau le modèle sur de nouvelles données et le revalident.

Conclusion

Dans cet article, nous avons montré comment récupérer des données sur le web via le scraping et comment les utiliser à des fins d’apprentissage automatique. Nous avons également présenté l’importance du web scraping pour l’apprentissage automatique et nous avons discuté du processus d’entraînement et de structuration des ETL.

Bien que le projet proposé soit simple, il est compréhensible que les processus sous-jacents – en particulier ceux liés à la structuration des ETL pour extraire des données du web en continu afin d’améliorer le modèle ML – introduisent des complexités qui devraient être analysées de manière plus approfondie.

L’exploration de Yahoo Finance dans des scénarios réels peut être beaucoup plus complexe que ce qui a été montré ici. Le site utilise certaines technologies anti-scraping, ce qui nécessite une attention particulière. Pour une solution professionnelle, complète et tout-en-un, consultez Bright Data’s Yahoo Finance Scraper!

Si le scraping n’est pas votre fort mais que vous avez quand même besoin de données pour des projets d’apprentissage automatique, explorez nos solutions pour une récupération efficace des données adaptées aux besoins de l’IA et de l’apprentissage automatique.

Créez un compte Bright Data gratuit dès aujourd’hui pour essayer nos API de scraper ou explorer nos ensembles de données.