Lehrplan Lektion 148 von 156 · Messe das Web wie ein Forscher
Messe das Web wie ein Forscher

Trainiere einen Tracker-Klassifikator

Warum das wichtig ist Blocklisten werden von Menschen geschrieben und hinken immer hinterher: Neue Tracker erscheinen jede Woche. Ein Klassifikator lernt, wie Tracker behave und kann solche markieren, die noch keine Liste benannt hat. Einen kleinen selbst zu bauen zeigt, was solche Tools können und wie man sie ehrlich beurteilt.

Stell dir einen erfahrenen Türsteher vor. Niemand gab ihm eine Liste jedes Unruhestifters, aber er hat die Anzeichen gelernt und sie wägt zusammen: ein Zeichen bedeutet wenig, drei zusammen bedeuten viel. Ein Klassifikator macht das Gleiche mit Zahlen.

Die Daten

tracker_dataset(seed) in watched.leg7b_web durchsucht ein simuliertes Web und misst sechs Verhaltensweisen für jede dritte Partei, die es sah, wobei jede von 0 bis 1 skaliert wird: wie viele Seiten es nutzt, wie oft es Cookies setzt, wie oft es winzige Bilder (Pixel) sendet, wie oft seine URLs lange ID-ähnliche Werte tragen, wie oft sie die Seitenadresse tragen, und wie oft seine Antworten klein sind. Jede Zeile hat auch ein Label y: 1, wenn die Blockliste es als Tracker bezeichnet, 0, wenn nicht.

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"])

Logistische Regression in drei Ideen

Weight: eine Zahl, die angibt, wie viel ein Merkmal als Beweis zählt. Positiv bedeutet "mehr davon, mehr tracker-ähnlich".

1. Woge die Beweise ab. Multipliziere jedes Feature mit seinem Gewicht, addiere sie und füge ein bias (eine anfängliche Neigung) hinzu: z = w1*x1 + w2*x2 + ... + bias.

2. Drücke es in eine Wahrscheinlichkeit. Die sigmoid Funktion 1 / (1 + math.exp(-z)) verwandelt jede Zahl in eine Zahl zwischen 0 und 1. Ein großer positiver z gibt fast 1, ein großer negativer fast 0, Null gibt 0.5.

3. Lerne aus Fehlern. Beginne mit allen Gewichten auf 0. Berechne für jede Trainingszeile error = prediction - y. Dann ändere jedes Gewicht leicht: w = w - lr * error * x, und den Bias um bias - lr * error. lr (die Lernrate) legt die Größe der Änderung fest. Alle Zeilen einmal zu durchlaufen ist eine epoch; wiederhole dies für viele Epochen.

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

Bewertung: Präzision und Recall

Du hast diese in Etappe 2 getroffen. Sage "tracker", wenn die Wahrscheinlichkeit mindestens 0.5 ist. Dann:

  • Precision = true tracker geflaggt / alles geflaggt. Niedrige Präzision beschädigt harmlose Seiten.
  • Recall = true tracker geflaggt / alle true tracker. Ein niedriger Recall lässt Tracker durch.

Messe immer auf held-out Zeilen, auf denen das Modell nie trainiert hat. Das Scoring auf den Trainingszeilen schmeichelt ihm. Die Tests gehen weiter und bewerten dein Modell auf einem Crawl einer Webseite, die es noch nie gesehen hat.

A häufiges Missverständnis: "Das Modell hat gelernt, was ein Tracker ist." Es hat gelernt, der Blockliste zuzustimmen, die die Daten markiert hat, inklusive der Fehler. Wenn die Liste bezüglich einer Seite falsch ist, wird dem Modell beigebracht, ebenfalls falsch zu sein. Lektion 149 kommt darauf zurück.

In anderen Sprachen

Die Vorhersage und ein Lernschritt, an anderer Stelle:

// 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));
}

Zusammenfassung

  • A classifier lernt das Verhalten von Trackern, sodass er Tracker markieren kann, die noch keine Namen in der Liste haben.
  • Logistische Regression: Merkmale gewichten, mit der Sigmoid-Funktion abflachen, Gewichte durch den Fehler anpassen.
  • Beurteile es nach Präzision und Recall auf Zeilen, an denen es nie trainiert hat.
  • Es lernt die Sicht der Labels auf die Welt, inklusive Fehler.
Du bist dran

Schreibe drei Funktionen in einfachem Python:

  1. predict(weights, bias, x): die Sigmoid 1 / (1 + math.exp(-z)) von z = sum(weights[i] * x[i]) + bias.
  2. train(rows, epochs=100, lr=0.5): beginne mit Null-Gewichten (eines pro Merkmal) und Bias 0.0; für jede epoche, für jede Zeile in der Reihenfolge, berechne error = predict(...) - row["y"], dann aktualisiere jedes Gewicht durch - lr * error * x[i] und den Bias durch - lr * error. Gib (weights, bias).
  3. zurück.
  4. precision_recall(weights, bias, rows, threshold=0.5): markiere eine Zeile, wenn die prediction mindestens den threshold erreicht; gib (precision, recall) zurück und verwende 0.0, wenn eine division durch null erfolgen würde. (Konventionen unterscheiden sich: ein blocker, der nichts markiert hat, verursachte keine falschen Alarme, und einige scorer zählen diese precision als 1.0. Beides ist vertretbar; ein report sollte sagen, welchen sie verwendet.)
Setze dann weights, bias aus data["train"] und test_precision, test_recall auf data["test"]. Tests bewerten dein Modell auf einem simulierten Web, das es nie gesehen hat: mindestens 0.80 für beide.

Ein Problem in dieser Lektion entdeckt? Melde es · Frage zu dieser Lektion

Diese Übung öffnet bald

Beende die vorherige Lektion, damit diese freigeschaltet wird. Der ganze Kurs ist kostenlos, kein Konto erforderlich, und du kannst diese Lektion jetzt direkt lesen.