Programme Leçon 148 sur 156 · Mesurer le web comme un chercheur
Mesurer le web comme un chercheur

Entraîner un classifieur de traqueurs

Pourquoi c'est important Les listes de blocage sont écrites par des gens et sont toujours en retard : de nouveaux traqueurs apparaissent chaque semaine. Un classifieur apprend à quoi ressemble le comportement des traqueurs et peut signaler ceux qu'aucune liste n'a encore nommés. En construire un petit toi-même montre ce que ces outils peuvent faire, et comment les juger honnêtement.

Pense à un videur expérimenté. Personne ne lui a donné la liste de tous les fauteurs de troubles, mais il a appris les signes, et il les pèse ensemble : un signe veut dire peu, trois ensemble veulent dire beaucoup. Un classifieur fait la même chose avec des nombres.

Les données

tracker_dataset(seed) de watched.leg7b_web explore un web simulé et mesure six comportements pour chaque tiers qu'il a vu, chacun ramené entre 0 et 1 : sur combien de sites il est, à quelle fréquence il pose des cookies, à quelle fréquence il envoie de minuscules images (des pixels), à quelle fréquence ses URL portent de longues valeurs qui ressemblent à des identifiants, à quelle fréquence elles portent l'adresse de la page, et à quelle fréquence ses réponses sont petites. Chaque ligne a aussi une étiquette y : 1 si la liste de blocage le dit traqueur, 0 sinon.

from watched.leg7b_web import tracker_dataset
data = tracker_dataset(seed=2)
print(data["features"])
row = data["train"][0]
print(row["site"], row["x"], row["y"])

La régression logistique en trois idées

Poids : un nombre qui dit combien une caractéristique compte comme indice. Positif veut dire « plus il y en a, plus ça ressemble à un traqueur ».

1. Peser les indices. Multiplie chaque caractéristique par son poids, additionne, et ajoute un biais (un penchant de départ) : z = w1*x1 + w2*x2 + ... + bias.

2. L'écraser en probabilité. La fonction sigmoïde 1 / (1 + math.exp(-z)) transforme n'importe quel nombre en un nombre entre 0 et 1. Un z très positif donne presque 1, très négatif presque 0, zéro donne 0,5.

3. Apprendre de ses erreurs. Commence avec tous les poids à 0. Pour chaque ligne d'entraînement, calcule error = prediction - y. Puis ajuste chaque poids : w = w - lr * error * x, et le biais par bias - lr * error. lr (le taux d'apprentissage) fixe la taille de l'ajustement. Passer une fois sur toutes les lignes, c'est une époque ; répète pendant beaucoup d'époques.

import math
def sigmoid(z):
    return 1 / (1 + math.exp(-z))
print(sigmoid(0), round(sigmoid(4), 3), round(sigmoid(-4), 3))   # 0.5 0.982 0.018

Le juger : précision et rappel

Tu les as vus à l'étape 2. Dis « traqueur » quand la probabilité est d'au moins 0,5. Alors :

  • Précision = vrais traqueurs signalés / tout ce qui est signalé. Une faible précision casse des sites inoffensifs.
  • Rappel = vrais traqueurs signalés / tous les vrais traqueurs. Un faible rappel laisse passer des traqueurs.

Mesure toujours sur des lignes mises de côté, que le modèle n'a jamais vues à l'entraînement. Noter sur les lignes d'entraînement le flatte. Les tests vont plus loin et notent ton modèle sur l'exploration d'un web qu'il n'a jamais vu.

Une idée reçue : « Le modèle a appris ce qu'est un traqueur. » Il a appris à être d'accord avec la liste de blocage qui a étiqueté les données, erreurs comprises. Si la liste se trompe sur un site, on apprend au modèle à se tromper aussi. La leçon 149 y revient.

Dans d'autres langages

La prédiction et une étape d'apprentissage, ailleurs :

// JavaScript
const predict = (w, b, x) => 1 / (1 + Math.exp(-(x.reduce((s, v, i) => s + v * w[i], 0) + b)));
function step(w, b, row, lr) {
  const err = predict(w, b, row.x) - row.y;
  return [w.map((wi, i) => wi - lr * err * row.x[i]), b - lr * err];
}
// C#
double Predict(double[] w, double b, double[] x) {
    double z = b;
    for (int i = 0; i < x.Length; i++) z += w[i] * x[i];
    return 1.0 / (1.0 + Math.Exp(-z));
}

Récap

  • Un classifieur apprend le comportement des traqueurs, donc il peut signaler des traqueurs qu'aucune liste ne nomme encore.
  • La régression logistique : pèse les caractéristiques, écrase avec la sigmoïde, ajuste les poids selon l'erreur.
  • Juge-le par la précision et le rappel sur des lignes qu'il n'a jamais vues à l'entraînement.
  • Il apprend la vision du monde des étiquettes, erreurs comprises.
À ton tour

Écris trois fonctions, en Python simple :

  1. predict(weights, bias, x) : la sigmoïde 1 / (1 + math.exp(-z)) de z = sum(weights[i] * x[i]) + bias.
  2. train(rows, epochs=100, lr=0.5) : commence avec des poids à zéro (un par caractéristique) et un biais à 0.0 ; pour chaque époque, pour chaque ligne dans l'ordre, calcule error = predict(...) - row["y"], puis mets à jour chaque poids de - lr * error * x[i] et le biais de - lr * error. Renvoie (weights, bias).
  3. precision_recall(weights, bias, rows, threshold=0.5) : signale une ligne quand la prédiction est au moins égale au seuil ; renvoie (precision, recall), avec 0.0 quand une division se ferait par zéro. (Les conventions diffèrent : un bloqueur qui n'a rien signalé n'a fait aucune fausse alerte, et certains correcteurs comptent cette précision comme 1.0. Les deux se défendent ; un rapport doit dire laquelle il utilise.)
Puis définis weights, bias à partir de data["train"] et test_precision, test_recall sur data["test"]. Les tests notent ton modèle sur un web simulé qu'il n'a jamais vu : au moins 0.80 pour les deux.

Tu as repéré un problème dans cette leçon ? Signale-le · Pose une question sur cette leçon

Cet exercice s'ouvre bientôt

Termine la leçon précédente pour débloquer celle-ci. Tout le cours est gratuit, aucun compte n'est requis, et tu peux lire cette leçon dès maintenant.