Addestra un classificatore di tracker
Perché è importante Le blocklist sono scritte da persone e restano sempre indietro: nuovi tracker compaiono ogni settimana. Un classificatore impara come si comportano i tracker e può segnalarne alcuni che nessun elenco ha ancora nominato. Costruirne uno piccolo tu stesso mostra che cosa possono fare strumenti del genere, e come giudicarli con onestà.
Pensa a un buttafuori esperto. Nessuno gli ha dato un elenco di ogni attaccabrighe, ma ha imparato i segnali, e li pesa insieme: un segnale significa poco, tre insieme significano molto. Un classificatore fa lo stesso con i numeri.
I dati
tracker_dataset(seed) in watched.leg7b_web esplora un web simulato e misura sei comportamenti per ogni terza parte che ha visto, ciascuno scalato da 0 a 1: su quanti siti si trova, quanto spesso imposta cookie, quanto spesso invia immagini minuscole (pixel), quanto spesso i suoi URL portano lunghi valori simili a ID, quanto spesso portano l'indirizzo della pagina, e quanto spesso le sue risposte sono piccole. Ogni riga ha anche un'etichetta y: 1 se la blocklist lo chiama tracker, 0 se no.
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 regressione logistica in tre idee
Peso: un numero che dice quanto conta una feature come prova. Positivo significa "più ce n'è, più sembra un tracker".
1. Pesa le prove. Moltiplica ogni feature per il suo peso, sommale, e aggiungi un bias (una tendenza di partenza): z = w1*x1 + w2*x2 + ... + bias.
2. Schiaccialo in una probabilità. La funzione sigmoide 1 / (1 + math.exp(-z)) trasforma qualsiasi numero in uno tra 0 e 1. Uno z grande e positivo dà quasi 1, grande e negativo quasi 0, zero dà 0,5.
3. Impara dagli errori. Parti con tutti i pesi a 0. Per ogni riga di addestramento, calcola error = prediction - y. Poi sposta un po' ogni peso: w = w - lr * error * x, e il bias con bias - lr * error. lr (il tasso di apprendimento) decide quanto è grande lo spostamento. Passare una volta per tutte le righe è un'epoca; ripeti per molte epoche.
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.018Giudicarlo: precisione e richiamo
Li hai incontrati nella Tappa 2. Di' "tracker" quando la probabilità è almeno 0,5. Poi:
- Precisione = tracker veri segnalati / tutto ciò che è stato segnalato. Una precisione bassa rompe siti innocui.
- Richiamo = tracker veri segnalati / tutti i tracker veri. Un richiamo basso lascia passare i tracker.
Misura sempre su righe tenute da parte, che il modello non ha mai usato per addestrarsi. Valutarlo sulle righe di addestramento lo lusinga. I test vanno oltre e valutano il tuo modello sull'esplorazione di un web che non ha mai visto.
Un equivoco comune: "Il modello ha imparato che cos'è un tracker." Ha imparato ad andare d'accordo con la blocklist che ha etichettato i dati, errori compresi. Se l'elenco sbaglia su un sito, al modello si insegna a sbagliare anche lui. La lezione 149 ci torna.
In altri linguaggi
La previsione e un passo di apprendimento, altrove:
// 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));
}Riepilogo
- Un classificatore impara il comportamento dei tracker, quindi può segnalarne alcuni che nessun elenco nomina ancora.
- Regressione logistica: pesa le feature, schiaccia con la sigmoide, sposta i pesi in base all'errore.
- Giudicalo con precisione e richiamo su righe che non ha mai usato per addestrarsi.
- Impara la visione del mondo delle etichette, errori compresi.
Scrivi tre funzioni, in Python semplice:
predict(weights, bias, x): la sigmoide1 / (1 + math.exp(-z))diz = sum(weights[i] * x[i]) + bias.train(rows, epochs=100, lr=0.5): parti con pesi a zero (uno per feature) e bias 0.0; per ogni epoca, per ogni riga in ordine, calcolaerror = predict(...) - row["y"], poi aggiorna ogni peso con- lr * error * x[i]e il bias con- lr * error. Restituisci(weights, bias).precision_recall(weights, bias, rows, threshold=0.5): segnala una riga quando la previsione è almeno la soglia; restituisci(precision, recall), usando 0.0 quando una divisione sarebbe per zero. (Le convenzioni cambiano: un blocker che non ha segnalato niente non ha fatto falsi allarmi, e alcuni correttori contano quella precisione come 1.0. Sono entrambe difendibili; un rapporto dovrebbe dire quale usa.)
weights, bias da data["train"] e test_precision, test_recall su data["test"]. I test valutano il tuo modello su un web simulato che non ha mai visto: almeno 0.80 per entrambi.
Hai notato un problema in questa lezione? Segnalalo · Chiedi qualcosa su questa lezione
Questo esercizio si apre presto
Finisci la lezione precedente e questa si sblocca. L'intero corso è gratuito, senza account, e puoi leggere questa lezione subito.
Questo browser blocca i cookie per learn.floati.life, quindi le lezioni che hai finito qui non si possono aprire in ordine. Consenti i cookie per questo sito e ricarica.