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.018Le 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.
Écris trois fonctions, en Python simple :
predict(weights, bias, x): la sigmoïde1 / (1 + math.exp(-z))dez = sum(weights[i] * x[i]) + bias.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, calculeerror = predict(...) - row["y"], puis mets à jour chaque poids de- lr * error * x[i]et le biais de- lr * error. Renvoie(weights, bias).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.)
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.
Ce navigateur bloque les cookies pour learn.floati.life, donc les leçons que tu as terminées ici ne peuvent pas s'ouvrir dans l'ordre. Autorise les cookies pour ce site et recharge la page.