Train een tracker classifier
Waarom dit ertoe doet Blocklists worden geschreven door mensen en lopen altijd achter: er verschijnen elke week nieuwe trackers. Een classifier leert hoe trackers behave en kan die markeren die nog niet op een lijst staan. Het zelf bouwen van een kleine classifier laat zien wat zulke tools kunnen doen en hoe je ze eerlijk beoordeelt.
Denk aan een ervaren uitsmijter. Niemand gaf hen een lijst van elke probleemmaker, maar ze hebben de signalen geleerd en ze wegen ze samen af: één teken betekent weinig, drie samen betekenen veel. Een classifier doet hetzelfde met getallen.
De data
tracker_dataset(seed) in watched.leg7b_web doorzoekt een gesimuleerd web en meet zes gedragingen voor elke derde partij die het ziet, elk geschaald van 0 tot 1: hoeveel sites het erop is, hoe vaak het cookies zet, hoe vaak het kleine afbeeldingen (pixels) verzendt, hoe vaak de URLs lange ID-achtige waarden bevatten, hoe vaak ze het paginadres bevatten, en hoe vaak de responsen klein zijn. Elke rij heeft ook een label y: 1 als de blocklist het een tracker noemt, 0 zo niet.
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 regressie in drie ideeën
Weight: een getal dat aangeeft hoeveel een kenmerk telt als bewijs. Positief betekent "meer van dit, meer zoals een tracker".
1. Weeg het bewijs. Vermenigvuldig elke feature met zijn gewicht, tel ze bij elkaar op en voeg een bias (een beginneiging) toe: z = w1*x1 + w2*x2 + ... + bias.
2. Maak er een kans van. De sigmoid functie 1 / (1 + math.exp(-z)) zet elk getal om naar een waarde tussen 0 en 1. Een grote positieve z geeft bijna 1, een grote negatieve bijna 0, nul geeft 0.5.
3. Leer van fouten. Begin met alle weights op 0. Bereken voor elke trainingsrij error = prediction - y. Verander dan elke weight een beetje: w = w - lr * error * x, en de bias door bias - lr * error. lr (de learning rate) bepaalt de grootte van de verandering. Alle rijen één keer doorlopen is een epoch; herhaal dit voor veel 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.018Het beoordelen: precisie en recall
Je kwam deze tegen in Etappe 2. Zeg "tracker" wanneer de kans minstens 0.5 is. Dan:
- Precision = true trackers gemarkeerd / alles gemarkeerd. Lage precisie breekt onschadelijke sites.
- Recall = true trackers flagged / all true trackers. Lage recall laat trackers door.
Meet altijd op held-out rijen, rijen waarop het model nooit heeft getraind. Scoren op de trainingsrijen flatteert het. De tests gaan verder en scoren je model op een crawl van een web dat het nooit heeft gezien.
Een veelvoorkomende misvatting: "Het model heeft geleerd wat een tracker is." Het heeft geleerd om het onderscheid te volgen van de blocklist die de data labelde, inclusief fouten. Als de lijst onjuist is over een site, wordt het model ook onjuist geleerd. Les 149 komt hierop terug.
In andere talen
De voorspelling en één 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));
}Samenvatting
- A classifier leert het gedrag van trackers, zodat het trackers kan markeren die nog geen namen in de list hebben.
- Logistische regressie: weeg de features, druk ze plat met de sigmoid, pas de weights aan door de error.
- Beoordeel het op basis van precisie en recall op rijen waar het nooit op heeft getraind.
- Het leert het wereldbeeld van de labels, inclusief fouten.
Schrijf drie functies, in gewoon Python:
predict(weights, bias, x): de sigmoid1 / (1 + math.exp(-z))vanz = sum(weights[i] * x[i]) + bias.train(rows, epochs=100, lr=0.5): begin met nul gewichten (één per feature) en bias 0.0; voor elke epoch, voor elke rij in volgorde, berekenerror = predict(...) - row["y"], dan update elk gewicht door- lr * error * x[i]en de bias door- lr * error. Geef(weights, bias). terug.precision_recall(weights, bias, rows, threshold=0.5): markeer een rij wanneer de voorspelling minstens de drempelwaarde is; retourneer(precision, recall), gebruik 0.0 wanneer een deling door nul zou plaatsvinden. (Conventies verschillen: een blocker die niets markeerde maakte geen valse alarmen, en sommige scorers tellen die precisie als 1.0. Beide zijn verdedigbaar; een rapport moet zeggen welke ze gebruikt.)
weights, bias in vanaf data["train"] en test_precision, test_recall op data["test"]. Tests scoren je model op een gesimuleerde web die het nooit heeft gezien: ten minste 0.80 voor beide.
Een probleem ontdekt in deze les? Meld het · Vraag naar deze les
Deze oefening opent binnenkort
Maak de les ervoor af voordat deze wordt ontgrendeld. De hele cursus is gratis, geen account nodig, en je kunt deze les nu lezen.
Deze browser blokkeert cookies voor learn.floati.life, dus lessen die je hier hebt afgerond kunnen niet in de juiste volgorde worden geopend. Sta cookies toe voor deze site en laad de pagina opnieuw.