Web Scraping pour le Machine LearningConstruire de vrais jeux de données

Un modèle de machine learning ne vaut que les données qui le sous-tendent, et la plupart des données dignes d'être apprises se trouvent sur le web public plutôt que dans un fichier CSV bien rangé que quelqu'un vous remet. Les fiches produits, les prix, les avis, les offres d'emploi, les actualités et les conversations sociales sont tous générés en continu et à volume, ce qui est exactement le type de signal frais et ancré dans le réel dont un modèle a besoin. Ce guide vous montre comment utiliser le web scraping pour le machine learning : pourquoi les données web alimentent le ML, comment les collecter de façon fiable à grande échelle, comment les étiqueter et les structurer, et comment les injecter dans un pipeline d'entraînement, avec du Python exécutable à chaque étape.

Le tutoriel est limité aux données publiques : des pages que n'importe qui peut consulter sans se connecter. Le Python collecte du HTML via la Crawling API de Crawlbase, le transforme en dataframe pandas, nettoie et étiquette les lignes, et effectue une passe de préparation de features de base pour que le résultat soit prêt pour un modèle. L'objectif est une étape de collecte répétable que vous pouvez relancer sur un calendrier, parce qu'un jeu de données qui vieillit est un modèle qui se dégrade silencieusement.

Pourquoi les données web alimentent le machine learning

Les modèles supervisés apprennent à partir d'exemples, et le web est la plus grande source d'exemples qui soit. Trois propriétés le rendent particulièrement précieux pour le ML. Il est diversifié : scraper de nombreux sites donne à un modèle la variété dont il a besoin pour généraliser plutôt que de mémoriser les particularités d'une seule source. Il est frais : relancer un collecteur maintient votre jeu d'entraînement aligné sur l'état actuel du monde, ce qui compte le plus dans les domaines qui évoluent rapidement comme la tarification, la demande et le sentiment. Et il est abondant : là où un jeu étiqueté manuellement pourrait atteindre quelques milliers de lignes, un scraper peut assembler des centaines de milliers d'enregistrements publics.

Le problème est la fiabilité. Un script ponctuel qui fonctionne sur votre ordinateur aujourd'hui n'est pas une source de données sur laquelle vous pouvez construire un modèle. Les sites rendent le contenu côté client, font tourner leur balisage et bloquent le trafic automatisé, donc la couche de collecte doit être robuste avant que quoi que ce soit en aval compte. C'est la partie qui fait échouer les projets ML en pratique, et là où ce guide passe le plus clair de son temps.

Où les données scrapées s'intègrent dans un pipeline ML

Les données web scrapées apparaissent à plusieurs points dans un projet, et il est utile de clarifier lequel vous résolvez.

• Données d'entraînement. Les lignes scrapées deviennent le jeu de données dont votre modèle apprend directement, qu'il soit supervisé, non supervisé ou semi-supervisé.
• Ingénierie de features. Les champs que vous extrayez (longueur de texte, sentiment, deltas de prix, comptages de catégories) deviennent des features d'entrée qui augmentent la puissance prédictive d'un modèle entraîné sur d'autres données.
• Augmentation de données. Quand un jeu étiqueté manuellement est trop petit, les enregistrements scrapés en élargissent la taille et la diversité pour que le modèle voie plus de l'espace.
• Évaluation. Une tranche fraîchement scrapée mise de côté depuis l'entraînement est un jeu de test réaliste pour vérifier comment un modèle se comporte sur des données actuelles et in-the-wild.

Le reste de ce guide construit un petit pipeline mais complet de la collecte aux features que vous pouvez adapter à n'importe lequel de ces usages. Pour le fonctionnement de l'entraînement lui-même une fois que les données sont prêtes, l'entraînement des modèles d'IA expliqué est une bonne lecture complémentaire.

Pourquoi une simple requête ne suffit pas à l'échelle

Collecter une seule page avec requests est facile. Collecter cent mille pages, de façon fiable, depuis des sites qui se défendent contre les bots, c'est là que la plupart des collecteurs maison s'effondrent. Deux problèmes apparaissent rapidement. D'abord, beaucoup de pages rendent leur contenu dans le navigateur avec JavaScript, donc le HTML brut que vous récupérez est une coquille vide. Ensuite, les sites commerciaux signalent rapidement le trafic automatisé : les IP de datacenters et les schémas de requêtes mécaniques se font bloquer bien avant que vous n'ayez assez de lignes pour entraîner.

Vous pouvez résoudre les deux vous-même avec un navigateur sans tête plus un pool de proxies résidentiels rotatifs, mais maintenir cette flotte en bonne santé représente l'essentiel de l'ingénierie. La Crawling API le regroupe en un seul appel : vous envoyez une URL, elle rend la page derrière une IP de confiance, alterne les adresses côté serveur et renvoie du HTML finalisé. Si une cible sert du balisage statique propre et que vous ne voulez que des champs analysés, la Crawling API renvoie directement du JSON structuré ; pour du transport brut avec rotation que vous contrôlez, le Smart AI Proxy est l'option de niveau inférieur. Ce guide utilise la Crawling API parce que la collecte de jeux de données couvre généralement des sites mixtes et défendus.

Configurer le projet

Vous avez besoin de Python 3 et pip installés. Confirmez les deux, puis créez un projet et installez les bibliothèques que le pipeline utilise.

python --version
pip --version

mkdir ml-dataset && cd ml-dataset
python -m venv .venv && source .venv/bin/activate
pip install crawlbase beautifulsoup4 pandas scikit-learn

Quatre dépendances font le travail : crawlbase est le client pour la Crawling API, beautifulsoup4 analyse le HTML renvoyé, pandas contient le jeu de données en tant que dataframe, et scikit-learn gère la préparation des features à la fin. Vous avez aussi besoin d'un compte Crawlbase et d'un token, que vous obtenez depuis le tableau de bord après inscription. Gardez-le dans une variable d'environnement plutôt que de le coder en dur.

Étape 1 : collecter les pages via la Crawling API

Commencez par la couche de collecte, parce que tout ce qui vient après dépend de son renvoi de HTML propre. Le client Python enveloppe l'API dans un seul appel get. Deux options comptent pour les sites défendus et rendus côté client : ajax_wait indique à l'API d'attendre le contenu asynchrone, et page_wait maintient un nombre fixe de millisecondes après le chargement pour que le contenu à rendu tardif apparaisse. Le collecteur vérifie le code de statut pour qu'une page bloquée ne devienne jamais silencieusement une ligne vide dans votre jeu de données.

import os
import time
from crawlbase import CrawlingAPI

# JS token renders the page in a real browser before returning HTML
api = CrawlingAPI({"token": os.environ["CRAWLBASE_JS_TOKEN"]})

options = {
    "ajax_wait": "true",
    "page_wait": 5000,
}

def fetch_html(url):
    response = api.get(url, options)
    if response["status_code"] != 200:
        raise RuntimeError(f"fetch failed: {response['status_code']}")
    return response["body"].decode("utf-8")

def collect(urls):
    pages = []
    for url in urls:
        try:
            pages.append({"url": url, "html": fetch_html(url)})
        except RuntimeError as err:
            print(f"skipping {url}: {err}")
        time.sleep(1)  # pace requests so you stay unblocked
    return pages

La Crawling API alterne les IP et rend la page pour vous, donc le collecteur reste petit. Le time.sleep entre les requêtes est délibéré : le rythme maintient un long run en bonne santé. Pour un jeu de données de toute taille réelle vous aurez besoin de milliers d'URLs, d'une logique de nouvelles tentatives et de la concurrence, qui est un sujet distinct couvert dans le web scraping à grande échelle.

Étape 2 : analyser les pages en enregistrements structurés

Le HTML brut n'est pas un jeu de données. L'étape suivante transforme chaque page en un enregistrement plat avec les champs que vous voulez apprendre. Cet exemple traite une page de listing de produits comme source et extrait le nom, le prix, la note et le texte d'avis, mais la forme s'applique partout : choisissez les champs, mappez chacun sur un sélecteur, retournez un dictionnaire. Un petit assistant fait d'un élément manquant une chaîne vide plutôt qu'un plantage.

from bs4 import BeautifulSoup

def text_or_empty(node, selector):
    el = node.select_one(selector)
    return el.get_text(strip=True) if el else ""

def parse_products(page):
    soup = BeautifulSoup(page["html"], "html.parser")
    rows = []
    for card in soup.select(".product-card"):
        rows.append({
            "name": text_or_empty(card, ".title"),
            "price": text_or_empty(card, ".price"),
            "rating": text_or_empty(card, ".rating"),
            "review": text_or_empty(card, ".review-snippet"),
            "source": page["url"],
        })
    return rows

Traitez les sélecteurs ci-dessus comme un modèle de départ, pas comme un contrat : les noms de classes et les attributs de données changent sans préavis, donc quand l'extraction renvoie des champs vides, réinspectez la page en direct dans les outils de développement de votre navigateur et mettez-les à jour. C'est une maintenance normale pour tout scraper de production.

Étape 3 : construire un dataframe pandas

Avec une liste d'enregistrements, pandas vous donne un dataframe en une ligne et une boîte à outils pour tout ce qui suit. Collectez, analysez et chargez toutes les lignes, puis regardez ce que vous avez avant de lui faire confiance. Les étapes dedup et dropna comptent plus qu'elles n'y paraissent : un jeu de données plein de lignes dupliquées ou à moitié vides apprend quelque chose de faux à un modèle.

import pandas as pd

urls = [
    "https://www.example.com/category/page/1",
    "https://www.example.com/category/page/2",
]

records = []
for page in collect(urls):
    records.extend(parse_products(page))

df = pd.DataFrame(records)
df = df.drop_duplicates(subset=["name", "source"])
df = df.dropna(subset=["name"])

print(df.shape)
print(df.head())
df.to_csv("dataset_raw.csv", index=False)

Écrire dataset_raw.csv à ce stade vous donne un point de contrôle : la collecte est lente et limitée en débit, donc vous ne voulez jamais re-scraper juste parce qu'une étape de nettoyage ultérieure avait un bug. Chargez le CSV pour le reste du pipeline et gardez le collecteur comme un travail séparé et occasionnel.

Étape 4 : nettoyer et étiqueter les lignes

Les champs scrapés arrivent comme des chaînes désordonnées : un prix est "$118", une note est "4.5 out of 5", un avis est du texte libre. Un modèle a besoin de nombres et d'une colonne cible, donc cette étape normalise les champs bruts et dérive une étiquette. Ici l'étiquette est un simple proxy de sentiment depuis la note, ce qui transforme un scrape non étiqueté en jeu de données de classification supervisée.

import re
import pandas as pd

df = pd.read_csv("dataset_raw.csv")

def to_float(value):
    match = re.search(r"(\d+(?:\.\d+)?)", str(value))
    return float(match.group(1)) if match else None

df["price"] = df["price"].apply(to_float)
df["rating"] = df["rating"].apply(to_float)
df["review"] = df["review"].fillna("").str.strip()

# derive a supervised label from the rating
df = df.dropna(subset=["rating"])
df["label"] = (df["rating"] >= 4.0).astype(int)

print(df["label"].value_counts())
df.to_csv("dataset_clean.csv", index=False)

Vérifier value_counts sur l'étiquette n'est pas optionnel. Les données scrapées sont rarement équilibrées, et une cible qui est à 95 % d'une seule classe produira un modèle qui semble précis tout en n'apprenant rien. Si la répartition est déséquilibrée, rééquilibrez avant l'entraînement, par rééchantillonnage ou par pondération des classes. Pour un traitement plus approfondi de la normalisation des champs scrapés pour le ML, voir structurer et nettoyer les données web scrapées pour l'IA et le ML.

Étape 5 : préparer les features pour un modèle

La dernière étape transforme le dataframe propre en la matrice numérique sur laquelle un modèle s'entraîne. Le texte a besoin d'être vectorisé et les colonnes numériques bénéficient d'une mise à l'échelle, donc un ColumnTransformer de scikit-learn applique la bonne transformation à chaque colonne en une seule passe. La sortie est une matrice de features X et un vecteur d'étiquettes y, divisés en jeux d'entraînement et de test, prêts à être remis à n'importe quel estimateur.

import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.compose import ColumnTransformer
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.preprocessing import StandardScaler

df = pd.read_csv("dataset_clean.csv").fillna({"review": ""})

features = df[["review", "price"]]
y = df["label"]

pre = ColumnTransformer([
    ("text", TfidfVectorizer(max_features=5000), "review"),
    ("num", StandardScaler(), ["price"]),
])

X = pre.fit_transform(features)
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)

print(f"train: {X_train.shape}, test: {X_test.shape}")

À partir d'ici, X_train et y_train s'insèrent directement dans la méthode fit de n'importe quel estimateur scikit-learn, et le jeu de test mis de côté vous donne une lecture honnête de la précision. L'argument stratify=y maintient l'équilibre des classes cohérent à travers la division, ce qui compte le plus quand votre étiquette est déséquilibrée. La chaîne de la collecte aux features est la partie réutilisable : remplacez les sélecteurs et la règle d'étiquetage et les mêmes cinq étapes construisent un jeu de données pour un problème différent.

Maintenir la couche de collecte en bonne santé

Un jeu de données que vous pouvez reconstruire à la demande vaut bien plus qu'une extraction ponctuelle, donc le collecteur doit continuer à fonctionner à mesure que les cibles changent. Quelques habitudes maintiennent un long run en bonne santé.

• Cadencez et alternez. Répartissez les requêtes et routez via des IP résidentielles rotatives pour qu'aucune adresse ne déclenche une limite de débit. La Crawling API gère la rotation pour vous ; si vous construisez votre propre pile, c'est la partie à bien faire.
• Lisez les codes de statut. Un run qui commence à retourner des challenges vous indique que le débit ou le niveau d'IP actuel n'est plus suffisant. Traitez ça comme un signal et reculez, plutôt que de réessayer en vous heurtant à un blocage.
• Sauvegardez le HTML brut. Sauvegardez ce que vous récupérez avant de l'analyser, pour qu'un bug d'analyseur ne vous coûte jamais un re-scrape.

Pour le manuel complet, voir comment scraper des sites web sans être bloqué. Et une fois le jeu de données existant, l'extraction de données IA et son fonctionnement couvre la transformation de pages désordonnées en champs structurés de façon plus automatique.

La partie honnête : éthique et légalité

Construire un jeu de données ML comporte les mêmes responsabilités que tout scrape, et que ce soit autorisé dépend des conditions d'utilisation de chaque site, de votre juridiction et de ce que vous faites avec les données. Collectez uniquement des données publiques, respectez le robots.txt de chaque site et ses attentes déclarées en matière de débit, et gardez le volume des requêtes assez bas pour ne pas surcharger les serveurs de quiconque.

Deux points comptent davantage pour le ML spécifiquement. Ne collectez jamais de données personnelles ou quoi que ce soit lié à des individus identifiables, et faites attention qu'une étiquette ou une feature dérivée ne le reconstituise pas. Et rappelez-vous qu'un modèle hérite des biais de ses données d'entraînement : un jeu scrapé depuis une seule région, langue ou plateforme produit un modèle qui généralise mal en dehors. Pour la réutilisation commerciale, obtenez une permission ou un accord de données officiel plutôt que de supposer que le silence est un consentement.

Foire aux questions

Le web scraping est-il utilisé dans le machine learning ?

Oui, extensivement. La capacité à collecter de grandes quantités de données publiques depuis de nombreuses sources vous permet de construire des jeux d'entraînement plus grands et plus diversifiés que les données étiquetées manuellement seules, ce qui est exactement ce qui aide un modèle à généraliser. Le scraping maintient aussi un jeu de données frais, pour que les modèles dans des domaines qui évoluent rapidement comme la tarification ou le sentiment restent alignés avec les conditions actuelles plutôt que d'apprendre à partir de captures périmées.

Comment collecter des données web pour un jeu de données ML à grande échelle ?

Le goulot d'étranglement est la fiabilité, pas l'analyse. Beaucoup de pages se rendent côté client et la plupart des sites commerciaux bloquent le trafic automatisé, donc vous avez besoin du rendu et d'un pool d'IP rotatif de confiance pour récupérer des milliers de pages sans être coupé. La Crawling API gère les deux en un seul appel : envoyez une URL, récupérez du HTML finalisé, et analysez-le en enregistrements. Cadencez vos requêtes, sauvegardez le HTML brut, et gardez le collecteur comme un travail séparé du reste du pipeline.

Ai-je besoin du token normal ou du token JS ?

Cela dépend de la source. Le token normal récupère du HTML statique et est plus rapide et moins coûteux, donc utilisez-le quand la page contient déjà les données que vous voulez. Le token JS rend d'abord la page dans un vrai navigateur, ce dont vous avez besoin pour les sites rendus côté client où une simple requête renvoie une coquille vide. Choisissez par source plutôt que d'en choisir un pour tout le travail.

Comment transformer des pages scrapées en jeu de données étiqueté ?

Analysez chaque page en enregistrements plats, chargez-les dans un dataframe pandas, puis nettoyez et étiquetez. Normalisez les champs désordonnés en nombres (supprimez les symboles monétaires, extrayez les notes), supprimez les doublons et les lignes vides, et dérivez une colonne cible depuis un champ de confiance, par exemple en mappant une note élevée sur une étiquette positive. Vérifiez toujours l'équilibre des classes avant l'entraînement, parce que les données scrapées sont rarement équilibrées.

Comment préparer des données scrapées comme features pour un modèle ?

Convertissez chaque colonne en une forme numérique que le modèle peut lire. Vectorisez les champs texte avec quelque chose comme TF-IDF, mettez à l'échelle les colonnes numériques pour qu'aucune feature ne domine, et appliquez les deux en une seule passe avec un ColumnTransformer scikit-learn. Divisez le résultat en jeux d'entraînement et de test, en stratifiant sur l'étiquette pour que l'équilibre des classes soit préservé, et la matrice de features est prête à ajuster n'importe quel estimateur.

Est-il légal de scraper des données pour le machine learning ?

Cela dépend des conditions d'utilisation de chaque site, de votre juridiction et de votre objectif. Restez strictement sur les données publiques, respectez robots.txt et les attentes de débit, et ne collectez jamais de données personnelles ou quoi que ce soit lié à des individus identifiables. Soyez attentif au fait qu'un modèle hérite des biais de son jeu d'entraînement. Pour la réutilisation commerciale, obtenez une permission ou un accord de données officiel plutôt que de vous fier à un scraper.

FA

Farwa Anees

Rédactrice technique · Crawlbase

Rédactrice technique ayant couvert les proxys, le web scraping et l'infrastructure de données sur le blog Crawlbase, transformant des sujets réseau denses en guides que les ingénieurs terminent vraiment.