पाठ्यक्रम 156 में से पाठ 148 · एक शोधकर्ता की तरह वेब मापें
एक शोधकर्ता की तरह वेब मापें

एक tracker classifier train करें

यह क्यों मायने रखता है Blocklists लोग लिखते हैं और हमेशा पीछे रहती हैं: हर हफ़्ते नए trackers आते हैं। एक classifier सीखता है कि trackers कैसा बर्ताव करते हैं और उन्हें चिह्नित कर सकता है जिनका किसी सूची ने अभी नाम नहीं लिया। एक छोटा ख़ुद बनाना दिखाता है कि ऐसे औज़ार क्या कर सकते हैं, और उन्हें ईमानदारी से कैसे परखें।

एक अनुभवी दरबान की सोचें। किसी ने उन्हें हर उपद्रवी की सूची नहीं दी, पर उन्होंने संकेत सीख लिए हैं, और वे उन्हें साथ तौलते हैं: एक संकेत का मतलब कम है, तीन साथ का मतलब बहुत। एक classifier संख्याओं के साथ यही करता है।

डेटा

watched.leg7b_web में tracker_dataset(seed) एक simulated वेब crawl करता है और देखी हर third party के लिए छह बर्ताव मापता है, हर एक 0 से 1 तक scaled: वह कितनी साइटों पर है, कितनी बार cookies सेट करती है, कितनी बार छोटी तस्वीरें (pixels) भेजती है, कितनी बार उसके URLs लंबे ID-जैसे मान ले जाते हैं, कितनी बार पन्ने का पता ले जाते हैं, और कितनी बार उसके responses छोटे होते हैं। हर row का एक label y भी है: 1 अगर blocklist उसे tracker कहती है, नहीं तो 0।

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

तीन विचारों में logistic regression

Weight: एक संख्या जो बताती है कि एक feature सबूत के रूप में कितना गिनता है। धनात्मक का मतलब "इसका ज़्यादा, ज़्यादा tracker जैसा"।

1. सबूत तौलें। हर feature को उसके weight से गुणा करें, उन्हें जोड़ें, और एक bias (एक शुरुआती झुकाव) जोड़ें: z = w1*x1 + w2*x2 + ... + bias।

2. इसे एक संभावना में दबाएँ। sigmoid function 1 / (1 + math.exp(-z)) किसी भी संख्या को 0 और 1 के बीच की एक में बदलता है। बड़ा धनात्मक z लगभग 1 देता है, बड़ा ऋणात्मक लगभग 0, शून्य 0.5 देता है।

3. ग़लतियों से सीखें। सारे weights 0 से शुरू करें। हर training row के लिए error = prediction - y निकालें। फिर हर weight को धकेलें: w = w - lr * error * x, और bias को bias - lr * error से। lr (learning rate) धक्के का आकार तय करता है। सारी rows से एक बार गुज़रना एक epoch है; कई 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

इसे परखना: precision और recall

आप इनसे चरण 2 में मिले। जब संभावना कम से कम 0.5 हो तो "tracker" कहें। तब:

  • Precision = चिह्नित असली trackers / सब चिह्नित। कम precision हानिरहित साइटें तोड़ता है।
  • Recall = चिह्नित असली trackers / सारे असली trackers। कम recall trackers को गुज़रने देता है।

हमेशा held-out rows पर मापें, जिन पर model ने कभी train नहीं किया। training rows पर अंक देना उसकी चापलूसी करता है। Tests आगे जाते हैं और आपके model को एक ऐसे वेब के crawl पर अंक देते हैं जो उसने कभी नहीं देखा।

एक आम ग़लतफ़हमी: "model ने सीख लिया कि tracker क्या है।" उसने डेटा पर label लगाने वाली blocklist से सहमत होना सीखा, ग़लतियों समेत। अगर सूची एक साइट के बारे में ग़लत है, तो model को भी ग़लत होना सिखाया जाता है। पाठ 149 इस पर लौटता है।

दूसरी भाषाओं में

भविष्यवाणी और एक सीखने का क़दम, कहीं और:

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

सार

  • एक classifier tracker बर्ताव सीखता है, इसलिए वह उन trackers को चिह्नित कर सकता है जिनका कोई सूची नाम नहीं लेती।
  • Logistic regression: features तौलें, sigmoid से दबाएँ, error से weights धकेलें।
  • इसे उन rows पर precision और recall से परखें जिन पर इसने कभी train नहीं किया।
  • यह labels का दुनिया का नज़रिया सीखता है, ग़लतियों समेत।
आपकी बारी

सादे Python में तीन functions लिखें:

  1. predict(weights, bias, x): z = sum(weights[i] * x[i]) + bias का sigmoid 1 / (1 + math.exp(-z))।
  2. train(rows, epochs=100, lr=0.5): शून्य weights (हर feature का एक) और bias 0.0 से शुरू करें; हर epoch के लिए, क्रम में हर row के लिए, error = predict(...) - row["y"] निकालें, फिर हर weight को - lr * error * x[i] से और bias को - lr * error से update करें। (weights, bias) लौटाएँ।
  3. precision_recall(weights, bias, rows, threshold=0.5): जब भविष्यवाणी कम से कम threshold हो तो एक row चिह्नित करें; (precision, recall) लौटाएँ, जब भाग शून्य से हो तो 0.0 इस्तेमाल करते हुए। (परंपराएँ अलग हैं: जिस blocker ने कुछ चिह्नित नहीं किया उसने कोई झूठे अलार्म नहीं दिए, और कुछ scorers उस precision को 1.0 गिनते हैं। दोनों बचाव लायक हैं; एक report को बताना चाहिए कि वह कौन-सा इस्तेमाल करती है।)
फिर data["train"] से weights, bias और data["test"] पर test_precision, test_recall सेट करें। Tests आपके model को एक ऐसे simulated वेब पर अंक देते हैं जो उसने कभी नहीं देखा: दोनों के लिए कम से कम 0.80।

इस पाठ में कोई समस्या दिखी? बताएँ · इस पाठ के बारे में पूछें

यह अभ्यास जल्द खुलेगा

इससे पहले वाला पाठ पूरा करें और यह खुल जाएगा। पूरा कोर्स मुफ़्त है, कोई खाता नहीं चाहिए, और आप यह पाठ अभी पढ़ सकते हैं।