Treine um classificador de rastreadores
Por que isso importa As listas de bloqueio são escritas por pessoas e estão sempre atrasadas: rastreadores novos aparecem toda semana. Um classificador aprende como os rastreadores se comportam e consegue sinalizar os que nenhuma lista nomeou ainda. Construir um pequeno você mesmo mostra o que essas ferramentas conseguem fazer, e como julgá-las com honestidade.
Pense em um porteiro experiente. Ninguém deu a ele uma lista de todo encrenqueiro, mas ele aprendeu os sinais e os pesa juntos: um sinal significa pouco, três juntos significam muito. Um classificador faz o mesmo com números.
Os dados
tracker_dataset(seed) em watched.leg7b_web faz o crawl de uma web simulada e mede seis comportamentos de todo terceiro que viu, cada um em uma escala de 0 a 1: em quantos sites ele está, com que frequência define cookies, com que frequência envia imagens minúsculas (pixels), com que frequência as URLs dele carregam valores longos com cara de ID, com que frequência carregam o endereço da página e com que frequência as respostas dele são pequenas. Cada linha também tem um rótulo y: 1 se a lista de bloqueio o chama de rastreador, 0 se não.
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"])Regressão logística em três ideias
Peso: um número que diz o quanto uma feature conta como evidência. Positivo significa "mais disto, mais cara de rastreador".
1. Pese a evidência. Multiplique cada feature pelo seu peso, some tudo e acrescente um bias (uma inclinação inicial): z = w1*x1 + w2*x2 + ... + bias.
2. Esprema em uma probabilidade. A função sigmoide 1 / (1 + math.exp(-z)) transforma qualquer número em um entre 0 e 1. Um z positivo grande dá quase 1, um negativo grande quase 0, e zero dá 0.5.
3. Aprenda com os erros. Comece com todos os pesos em 0. Para cada linha de treino, calcule error = prediction - y. Depois ajuste cada peso um pouco: w = w - lr * error * x, e o bias com bias - lr * error. O lr (a taxa de aprendizado) define o tamanho do ajuste. Passar por todas as linhas uma vez é uma época; repita por muitas épocas.
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.018Julgando o modelo: precision e recall
Você os conheceu na Etapa 2. Diga "rastreador" quando a probabilidade for pelo menos 0.5. Então:
- Precision = rastreadores verdadeiros sinalizados / tudo o que foi sinalizado. Precision baixa quebra sites inofensivos.
- Recall = rastreadores verdadeiros sinalizados / todos os rastreadores verdadeiros. Recall baixo deixa rastreadores passarem.
Sempre meça em linhas separadas, que o modelo nunca usou no treino. Pontuar nas linhas de treino o favorece. Os testes vão além e pontuam seu modelo no crawl de uma web que ele nunca viu.
Um equívoco comum: "o modelo aprendeu o que é um rastreador." Ele aprendeu a concordar com a lista de bloqueio que rotulou os dados, com erros e tudo. Se a lista estiver errada sobre um site, o modelo é ensinado a errar também. A lição 149 volta a isso.
Em outras linguagens
A previsão e um passo de aprendizado, em outras linguagens:
// 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));
}Resumo
- Um classificador aprende o comportamento dos rastreadores, então consegue sinalizar rastreadores que nenhuma lista nomeia ainda.
- Regressão logística: pese as features, esprema com a sigmoide, ajuste os pesos pelo erro.
- Julgue-o pela precision e pelo recall em linhas que ele nunca usou no treino.
- Ele aprende a visão de mundo dos rótulos, com erros e tudo.
Escreva três funções, em Python puro:
predict(weights, bias, x): a sigmoide1 / (1 + math.exp(-z))dez = sum(weights[i] * x[i]) + bias.train(rows, epochs=100, lr=0.5): comece com pesos zerados (um por feature) e bias 0.0; para cada época, para cada linha em ordem, calculeerror = predict(...) - row["y"]e depois atualize cada peso com- lr * error * x[i]e o bias com- lr * error. Retorne(weights, bias).precision_recall(weights, bias, rows, threshold=0.5): sinalize uma linha quando a previsão for pelo menos o limite; retorne(precision, recall), usando 0.0 quando uma divisão seria por zero. (As convenções variam: um bloqueador que não sinalizou nada não deu alarmes falsos, e alguns avaliadores contam essa precision como 1.0. As duas são defensáveis; um relatório deve dizer qual usa.)
weights, bias a partir de data["train"] e test_precision, test_recall em data["test"]. Os testes pontuam seu modelo em uma web simulada que ele nunca viu: pelo menos 0.80 nos dois.
Viu um problema nesta lição? Reporte-o · Pergunte sobre esta lição
Este exercício abre em breve
Termine a lição anterior para que esta seja desbloqueada. O curso inteiro é gratuito, não precisa de conta, e você pode ler esta lição agora mesmo.
Este navegador está bloqueando cookies para learn.floati.life, então as lições que você terminou aqui não podem abrir em ordem. Permita cookies para este site e recarregue.