Kurrikulum Leson 148 van 156 · Meet die web soos 'n navorser
Meet die web soos 'n navorser

Train 'n tracker classifier

Waarom dit saak maak Blokkies word deur mense geskryf en is altyd agterlopend: nuwe trackers verskyn elke week. 'n Klassifiseerder leer hoe trackers optree en kan dae wat nog nie op 'n lys is nie, aandui. Bou 'n klein een self wys wat sulke gereedskap kan doen, en hoe om hulle eerlik te beoordeel.

Dink aan 'n ervarende deurwagter. Niemand het vir hulle 'n lys van elke berman gegee nie, maar hulle het die tekens geleer en hulle weeg dit saam: een teken beteken min, drie saam beteken baie. 'n Classifier doen dieselfde met nommers.

Die data

tracker_dataset(seed) in watched.leg7b_web kruip deur 'n gesimuleerde web en meet ses gedraginge vir elke derde party wat dit sien, elk geskaal van 0 tot 1: hoeveel webwerwe dit op is, hoe gereeld dit cookies stel, hoe gereeld dit klein prente (pixels) stuur, hoe gereeld sy URLs lang ID-agtige waardes dra, hoe gereeld hulle die bladsyadres dra, en hoe gereeld sy reaksies klein is. Elke ry het ook 'n etiket y: 1 as die bloklys dit 'n tracker noem, 0 as nie.

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

Logistiese regressie in drie idees

Weight: 'n getal wat sê hoeveel een kenmerk as bewys tel. Positief beteken "meer van hier, meer soos 'n tracker".

1. Weeg die bewyse. Vermenigvuldig elke kenmerk met sy gewig, tel hulle bymekaar op, en voeg 'n bias ('n beginneiging) by: z = w1*x1 + w2*x2 + ... + bias.

2. Druk dit in 'n waarskynlikheid saam. Die sigmoid funksie 1 / (1 + math.exp(-z)) verander enige getal in een tussen 0 en 1. 'n Groot positiewe z gee byna 1, 'n groot negatiewe byna 0, nul gee 0.5.

3. Leer uit foute. Begin met alle wegte op 0. Bereken vir elke traingingsry error = prediction - y. Skuif dan elke gewig: w = w - lr * error * x, en die bias by bias - lr * error. lr (die learning rate) bepaal die grootte van die skuif. Om deur alle rye een keer te gaan is 'n epoch; herhaal dit vir baie epochs.

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

Beoordeel dit: presisie en herroeping

Jy het hierdie in Leg 2 ontmoet. Sê "tracker" wanneer die waarskynlikheid ten minste 0.5 is. Dan:

  • Precision = true trackers gemerk / alles gemerk. Lae presisie breek onskadelike webwerwe.
  • Recall = true trackers wat gemerk is / alle true trackers. Lae recall laat trackers deurgaan.

Meetel altyd op held-out rye, die een waarop die model nooit getoëi het nie. As jy op die opleidingsrye tel, flater jy dit. Die toetse gaan verder en tel jou model op 'n kruip van 'n web wat dit nog nooit gesien het nie.

'n algemene wanbelewing: "Die model het geleer wat 'n tracker is." Dit het geleer om saam te stem met die blocklist wat die data geetik het, insluitend van foute. As die lys verkeerd is oor 'n webwerf, word die model ook geleer om verkeerd te wees. Les 149 kom terug na hierdie.

In ander tale

Die voorspelling en een leerstap, elders:

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

Opsomming

  • A-klassifiseerder leer tracker-gedrag, sodat dit trackers kan aandui wat nog nie lysname het nie.
  • Logistiese regressie: weeg die kenmerke, druk dit plat met die sigmoid, skuif gewigte aan by die fout.
  • Beoordeel dit op presisie en herroeping op rye wat dit nooit opgelei het nie.
  • Dit leer die labels se sien van die wêreld, insluitend foute.
Jou beurt

Skryf drie funksies, in eenvoudige Python:

  1. predict(weights, bias, x): die sigmoid 1 / (1 + math.exp(-z)) van z = sum(weights[i] * x[i]) + bias.
  2. train(rows, epochs=100, lr=0.5): begin met nul gewigte (een per kenmerk) en bias 0.0; vir elke epoch, vir elke ry in volgorde, bereken error = predict(...) - row["y"], dan opdateer elke gewig met - lr * error * x[i] en die bias met - lr * error. Gee (weights, bias).
  3. terug.
  4. precision_recall(weights, bias, rows, threshold=0.5): merk 'n ry as die voorspelling ten minste die drempel is; gee (precision, recall) terug, en gebruik 0.0 wanneer 'n deling deur nul sou gebeur. (Konvensies verskil: 'n blokkeerder wat niks gemerk het, het geen vals alarms veroorsaak nie, en sommige tellers tel daardie presisie as 1.0. Albei is verdedigbaar; 'n verslag moet sê watter een dit gebruik.)
Stel dan weights, bias in vanaf data["train"] en test_precision, test_recall op data["test"]. Toetse tel jou model op 'n gesimuleerde web wat dit nog nooit gesien het: ten minste 0.80 vir albei.

Sien jy 'n probleem in hierdie les? Rapporteer dit · Vra oor hierdie les

Hierdie oefening open binnekort

Voltooi die lesie voor dit en hierdie een sal ontvanklik wees. Die hele kursus is gratis, geen rekening nodig nie, en jy kan hierdie les nou lees.