Entrenar un clasificador de rastreadores
Por qué importa Las listas de bloqueo las escriben personas y siempre van por detrás: cada semana aparecen rastreadores nuevos. Un clasificador aprende cómo se comportan los rastreadores y puede marcar algunos que ninguna lista ha nombrado todavía. Construir uno pequeño tú mismo muestra lo que pueden hacer esas herramientas, y cómo juzgarlas con honestidad.
Piensa en un portero con experiencia. Nadie le dio una lista de todos los alborotadores, pero ha aprendido las señales, y las sopesa juntas: una señal significa poco, tres juntas significan mucho. Un clasificador hace lo mismo con números.
Los datos
tracker_dataset(seed) de watched.leg7b_web rastrea una web simulada y mide seis comportamientos de cada tercero que vio, cada uno en una escala de 0 a 1: en cuántos sitios está, con qué frecuencia pone cookies, con qué frecuencia envía imágenes diminutas (píxeles), con qué frecuencia sus URL llevan valores largos con aspecto de ID, con qué frecuencia llevan la dirección de la página y con qué frecuencia sus respuestas son pequeñas. Cada fila también tiene una etiqueta y: 1 si la lista de bloqueo lo considera un rastreador, 0 si 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 regresión logística en tres ideas
Peso: un número que dice cuánto cuenta un rasgo como prueba. Positivo significa "cuanto más de esto, más parecido a un rastreador".
1. Sopesar las pruebas. Multiplica cada rasgo por su peso, súmalos y añade un sesgo (bias, una inclinación de partida): z = w1*x1 + w2*x2 + ... + bias.
2. Comprimirlo en una probabilidad. La función sigmoide 1 / (1 + math.exp(-z)) convierte cualquier número en uno entre 0 y 1. Un z positivo grande da casi 1, uno negativo grande casi 0, y cero da 0.5.
3. Aprender de los errores. Empieza con todos los pesos a 0. Para cada fila de entrenamiento, calcula error = prediction - y. Luego ajusta un poco cada peso: w = w - lr * error * x, y el sesgo con bias - lr * error. lr (la tasa de aprendizaje) fija el tamaño del ajuste. Recorrer todas las filas una vez es una época; repítelo durante muchas é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.018Juzgarlo: precisión y exhaustividad
Las viste en la etapa 2. Di "rastreador" cuando la probabilidad sea al menos 0.5. Entonces:
- Precisión = rastreadores reales marcados / todo lo marcado. Una precisión baja rompe sitios inofensivos.
- Exhaustividad (recall) = rastreadores reales marcados / todos los rastreadores reales. Una exhaustividad baja deja pasar rastreadores.
Mide siempre con filas apartadas, con las que el modelo nunca entrenó. Puntuar con las filas de entrenamiento lo favorece. Las pruebas van más allá y puntúan tu modelo con un rastreo de una web que nunca ha visto.
Una idea equivocada muy común: "El modelo aprendió qué es un rastreador." Aprendió a estar de acuerdo con la lista de bloqueo que etiquetó los datos, errores incluidos. Si la lista se equivoca con un sitio, al modelo se le enseña a equivocarse también. La lección 149 vuelve sobre esto.
En otros lenguajes
La predicción y un paso de aprendizaje, en otros lenguajes:
// 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));
}Resumen
- Un clasificador aprende el comportamiento de los rastreadores, así que puede marcar rastreadores que todavía no nombra ninguna lista.
- Regresión logística: sopesa los rasgos, comprime con la sigmoide y ajusta los pesos según el error.
- Júzgalo por la precisión y la exhaustividad con filas con las que nunca entrenó.
- Aprende la visión del mundo de las etiquetas, errores incluidos.
Escribe tres funciones, en Python puro:
predict(weights, bias, x): la sigmoide1 / (1 + math.exp(-z))dez = sum(weights[i] * x[i]) + bias.train(rows, epochs=100, lr=0.5): empieza con pesos a cero (uno por rasgo) y sesgo 0.0; en cada época, para cada fila en orden, calculaerror = predict(...) - row["y"], y luego actualiza cada peso con- lr * error * x[i]y el sesgo con- lr * error. Devuelve(weights, bias).precision_recall(weights, bias, rows, threshold=0.5): marca una fila cuando la predicción es al menos el umbral; devuelve(precision, recall), usando 0.0 cuando una división sería entre cero. (Las convenciones varían: un bloqueador que no marcó nada no dio falsas alarmas, y algunos puntúan esa precisión como 1.0. Las dos se pueden defender; un informe debería decir cuál usa.)
weights, bias a partir de data["train"] y test_precision, test_recall con data["test"]. Las pruebas puntúan tu modelo con una web simulada que nunca vio: al menos 0.80 en las dos.
¿Has visto un problema en esta lección? Avísanos · Preguntar sobre esta lección
Este ejercicio se abre pronto
Termina la lección anterior y esta se desbloquea. Todo el curso es gratis, no hace falta cuenta, y puedes leer esta lección ahora mismo.
Este navegador está bloqueando las cookies de learn.floati.life, así que las lecciones que terminaste aquí no se pueden abrir en orden. Permite las cookies de este sitio y recarga.