Ταξινόμηση, cross-entropy και πώς να μην κοροϊδεύετε τον εαυτό σας

Το ίδιο εργοστάσιο όπως στο Κεφάλαιο 1, πιο δύσκολη ερώτηση. Αντί για αποδοχή ή απόρριψη, η ερώτηση είναι είναι αυτό το εξάρτημα ελαττωματικό — και τα ελαττώματα είναι σπάνια, κάτι που κάνει το μισό της μέτρησης σε αυτό το κεφάλαιο δύσκολο και το μισό της μοντελοποίησης απατηλά εύκολο.

import numpy as np

rng = np.random.default_rng(4)
N = 20_000
width  = rng.normal(22.0, 0.9, N)      # millimetres
weight = rng.normal(57.0, 3.0, N)      # grams

z_true = -5.90 + 1.90 * (width - 22.0) + 0.42 * (weight - 57.0)
y = (rng.random(N) < 1 / (1 + np.exp(-z_true))).astype(float)

perm = rng.permutation(N)
train, val, test = perm[:12_000], perm[12_000:16_000], perm[16_000:]

N = 20000  defects = 337  base rate = 0.0169
defects per split = 203 60 74

Τρεις διαχωρισμοί, όχι δύο. Ο λόγος αξίζει δική του ενότητα και την έχει παρακάτω· προς το παρόν, εκπαιδεύστε στο πρώτο, ρυθμίστε στο δεύτερο και μην κοιτάξετε το τρίτο.

Τα χαρακτηριστικά είναι τυποποιημένα — αφαιρείται ο μέσος όρος, διαιρούνται με την τυπική απόκλιση — χρησιμοποιώντας μόνο τα στατιστικά του συνόλου εκπαίδευσης, για τον λόγο που έδειξε το Κεφάλαιο 1 με το όριο σύγκλισης του perceptron: τα μη κεντραρισμένα δεδομένα κάνουν τη γεωμετρία εχθρική. Από ποιες γραμμές επιτρέπεται να υπολογίσετε αυτόν τον μέσο όρο γίνεται ζωντανό ζήτημα αργότερα σε αυτό το κεφάλαιο.

Το perceptron επέστρεφε πρόσημο. Ένα πρόσημο δεν μπορεί να ξεχωρίσει το απόρριψη από το απόρριψη, αλλά οριακά, και αυτή η διαφορά είναι ακριβώς αυτό που χρειάζεται ένα εργοστάσιο για να αποφασίσει ποια εξαρτήματα πρέπει να επανελέγξει πρώτα ένας άνθρωπος.

Άρα ακολουθήστε κυριολεκτικά τη συνταγή του Κεφαλαίου 2. Γράψτε τι ισχυρίζεστε για το πώς παράγεται μια ετικέτα, πάρτε την πιθανοφάνεια, πάρτε τον λογάριθμο, αλλάξτε πρόσημο, και έχετε μια απώλεια. Για ένα αποτέλεσμα ναι/όχι ο ισχυρισμός είναι μια κατανομή Bernoulli: υπάρχει μια πιθανότητα $p$ ότι το εξάρτημα είναι ελαττωματικό, και

που είναι απλώς ένας συμπαγής τρόπος να γράψετε «$p$ αν $y = 1$, και $1-p$ αν $y = 0$». Πάρτε τον λογάριθμο αυτού και αλλάξτε πρόσημο, και η απώλεια για ένα παράδειγμα είναι

Αυτό είναι binary cross-entropy. Δεν επιλέχθηκε επειδή είναι βολικό· είναι η αρνητική log-likelihood της μοναδικής κατανομής που μπορεί να έχει μια ρίψη νομίσματος. Δεν υπήρχε κάτι άλλο διαθέσιμο.

Αυτό που λείπει ακόμα είναι από πού έρχεται το $p$. Το μοντέλο υπολογίζει ένα σταθμισμένο άθροισμα $s = \mathbf{w}\cdot\mathbf{x} + b$, που είναι πραγματικός αριθμός και εκτείνεται σε ολόκληρη την ευθεία, ενώ μια πιθανότητα πρέπει να ζει στο $(0,1)$. Η συνάρτηση που μετακινεί το ένα στο άλλο είναι η logistic sigmoid:

logit -4.0  ->  p = 0.0180        loss when y=1 and p=0.9  : 0.1054
logit -1.0  ->  p = 0.2689        loss when y=1 and p=0.5  : 0.6931
logit  0.0  ->  p = 0.5000        loss when y=1 and p=0.01 : 4.6052
logit  4.0  ->  p = 0.9820

Διαβάστε τη δεξιά στήλη σαν τιμοκατάλογο. Το να έχετε δίκιο με 90 % σιγουριά κοστίζει 0,105. Το να αρνείστε να δεσμευτείτε κοστίζει 0,693 — που είναι $\log 2$, η τιμή ενός σηκώματος ώμων. Το να είστε με σιγουριά λάθος κοστίζει 4,6, σαράντα τέσσερις φορές περισσότερο, και η τιμή ανεβαίνει χωρίς όριο όσο το μοντέλο γίνεται πιο βέβαιο για ένα λάθος. Το cross-entropy δεν μετρά απλώς σφάλματα: χρεώνει την αλαζονεία.

Το Κεφάλαιο 3 είπε: για να εκπαιδεύσετε οτιδήποτε, βρείτε την παράγωγο της απώλειας ως προς κάθε παράμετρο. Κάντε το για ένα παράδειγμα. Με $s = \mathbf{w}\cdot\mathbf{x} + b$ και $p = \sigma(s)$:

Άρα η ενημέρωση είναι πρόβλεψη μείον αλήθεια, επί την είσοδο. Τίποτα άλλο. Εδώ είναι ολόκληρος ο εκπαιδευτής, που είναι η κάθοδος του Κεφαλαίου 3 με μία γραμμή αλλαγμένη:

def sigmoid(z):
    return np.where(z >= 0, 1.0 / (1.0 + np.exp(-z)),
                    np.exp(np.minimum(z, 0)) / (1.0 + np.exp(np.minimum(z, 0))))


def fit_logistic(X, y, lr=0.5, epochs=4000):
    w, b = np.zeros(X.shape[1]), 0.0
    for _ in range(epochs):
        p = sigmoid(X @ w + b)
        g = p - y                        
        w -= lr * (X.T @ g) / len(y)     
        b -= lr * g.sum() / len(y)       
    return w, b

Το np.where στο sigmoid δεν είναι διακοσμητικό. Ο απευθείας υπολογισμός του $1/(1+e^{-s})$ υπερχειλίζει για μεγάλα αρνητικά $s$· ο κλάδος επιλέγει όποια αλγεβρικά ισοδύναμη μορφή κρατά τον εκθέτη αρνητικό. Αυτό είναι το κουτί κινητής υποδιαστολής του Κεφαλαίου 2 που εισπράττει το πρώτο του χρέος, και θα εισπράξει μεγαλύτερο δύο ενότητες παρακάτω.

Η τυπική εξήγηση για την προτίμηση του cross-entropy έναντι του τετραγωνικού σφάλματος είναι το επιχείρημα πιθανοφάνειας παραπάνω: το τετραγωνικό σφάλμα είναι αυτό που παίρνετε αν υποθέσετε γκαουσιανό θόρυβο, οι ετικέτες δεν είναι γκαουσιανές, άρα μην το κάνετε. Είναι σωστό και δεν πείθει κανέναν, επειδή μπορείτε να γράψετε $L = (p - y)^2$ πάνω από μια sigmoid και θα εκπαιδευτεί.

Το επιχείρημα που πιάνει είναι για το gradient. Βάλτε τετραγωνικό σφάλμα πάνω από μια sigmoid και ο κανόνας της αλυσίδας δίνει

Αυτό το επιπλέον $p(1-p)$ είναι εκείνο που ακυρώθηκε πριν. Τώρα δεν ακυρώνεται, και πηγαίνει στο μηδέν όποτε το μοντέλο είναι σίγουρο — συμπεριλαμβανομένων των περιπτώσεων όπου το μοντέλο είναι με σιγουριά λάθος. Αξιολογήστε και τα δύο σε μερικά σκορ, για ένα παράδειγμα του οποίου η αληθινή ετικέτα είναι 1:

Στο $s = -8$ το μοντέλο είναι όσο λάθος γίνεται να είναι, και το τετραγωνικό σφάλμα απαντά με gradient 1.491 φορές μικρότερο από του cross-entropy. Όσο χειρότερο το λάθος, τόσο λιγότερα μαθαίνει το μοντέλο από αυτό. Το gradient του cross-entropy, στο μεταξύ, κορέννυται στο $-1$: το μέγιστα λάθος παράγει μέγιστα μεγάλο σήμα, και όχι μεγαλύτερο.

Τρέξτε τον αγώνα. Δύο χιλιάδες ισορροπημένα σημεία, ίδια αρχικά βάρη επιλεγμένα ώστε να είναι με σιγουριά λάθος ($\mathbf{w} = [-6, -6]$), ίδιος ρυθμός μάθησης, διαφέρει μόνο η απώλεια. Και οι δύο εκτελέσεις βαθμολογούνται με cross-entropy ώστε οι στήλες να είναι συγκρίσιμες.

Το cross-entropy έχει τελειώσει μέχρι το epoch 50. Το τετραγωνικό σφάλμα είναι ακόμα στο 24 % ακρίβεια στο epoch 100 — και δεν είχε μετακινηθεί από το 23 % στο epoch 10 — χειρότερα από εικασία, επειδή ξεκίνησε με σιγουριά λάθος και το gradient που θα το έσωζε έχει πολλαπλασιαστεί με 0,0007. Ξεφεύγει γύρω στο epoch 500 και καταλήγει στο ίδιο μέρος. Άρα η ειλικρινής σύνοψη είναι ότι το τετραγωνικό σφάλμα πάνω από μια sigmoid δεν είναι λανθασμένο· είναι αργό ακριβώς εκεί όπου η ταχύτητα έχει τη μεγαλύτερη σημασία. Σε ένα μοντέλο δύο παραμέτρων χάνετε 450 epochs. Σε ένα δίκτυο με εκατό layers, όπου κάποια μονάδα κάπου είναι πάντα με σιγουριά λάθος, χάνετε την εκτέλεση εκπαίδευσης.

Τρεις ποσότητες, που χρειάζονται σωστά στο Κεφάλαιο 8 για perplexity και στο Κεφάλαιο 11 για την ποινή που κρατά μια fine-tuned πολιτική κοντά στην αναφορά της. Είναι ευκολότερες από τη φήμη τους.²

Εντροπία είναι ο μέσος αριθμός bit που πρέπει να ξοδέψετε για να επικοινωνήσετε μια δειγματοληψία από μια κατανομή, αν χρησιμοποιείτε τον καλύτερο δυνατό κώδικα για αυτήν:

Cross-entropy είναι αυτό που ξοδεύετε όταν χρησιμοποιείτε έναν κώδικα φτιαγμένο για $q$ σε δεδομένα που στην πραγματικότητα έρχονται από $p$:

KL divergence είναι το πλεόνασμα — η σπατάλη, σε bit, που προκαλείται επειδή πιστεύετε το $q$ όταν η αλήθεια είναι $p$:

Ελέγξτε και τα τρία στον ιμάντα:

test defect rate                                = 0.0185
entropy of that coin                            = 0.1329 bits
cross-entropy of the constant predictor on test = 0.1330 bits
KL(test coin || fair coin)                      = 0.8671 bits
H + KL                                          = 1.0000 bits
cross-entropy of the p=0.5 predictor on test    = 1.0000 bits

Δύο πράγματα φαίνονται εκεί. Πρώτον, ένα μοντέλο που απλώς αναφέρει τον βασικό ρυθμό του συνόλου εκπαίδευσης, 1,69 %, πετυχαίνει cross-entropy 0,1330 bit, σχεδόν ακριβώς την εντροπία των ετικετών δοκιμής — όπως πρέπει, αφού έχει τη σωστή κατανομή και καμία άλλη πληροφορία. Η εντροπία είναι το πάτωμα που σας αγοράζει η άγνοια για το άτομο. Δεύτερον, ένα μοντέλο που σηκώνει τους ώμους και λέει 0,5 πληρώνει ακριβώς 1 bit, και το χάσμα ανάμεσα στα δύο, 0,8671 bit, είναι ακριβώς το KL divergence. Το $H + D_{\mathrm{KL}} = H(p,q)$ δεν είναι ταυτότητα για απομνημόνευση· είναι λογαριασμός που μπορείτε να δείτε να αθροίζεται.

Και η σύνδεση πίσω στην εκπαίδευση: όταν η ετικέτα είναι μία γνωστή κλάση, η «αληθινή» κατανομή είναι one-hot, η εντροπία της είναι μηδέν, και το cross-entropy ισούται με το KL divergence. Η ελαχιστοποίηση του cross-entropy και το τράβηγμα της κατανομής του μοντέλου προς την αλήθεια είναι η ίδια πράξη.

Το ελαττωματικό δεν είναι ένα πράγμα. Στη χύτευση, ένα εξάρτημα μπορεί να βγει ως short shot (όχι αρκετό υλικό), flash (υπερβολικό υλικό, που πιέζεται έξω από το καλούπι), ή burn. Τέσσερα αποτελέσματα, άρα τέσσερα logits, και πρέπει να γίνουν τέσσερις πιθανότητες που αθροίζονται σε ένα. Αυτό είναι το softmax:

Έχει μια ιδιότητα που μοιάζει με ατύχημα και στην πραγματικότητα είναι ολόκληρη η υλοποίηση:

για οποιαδήποτε σταθερά $c$, επειδή το $e^{z_i + c} = e^{c} e^{z_i}$ και το $e^c$ ακυρώνονται πάνω και κάτω. Μόνο οι διαφορές ανάμεσα στα logits σημαίνουν κάτι. Το απόλυτο επίπεδο δεν είναι πληροφορία.

Ευτυχώς, γιατί το απόλυτο επίπεδο είναι αυτό που χαλάει τον υπολογιστή:

logits            = [800. 801. 799.]
naive softmax     = [nan nan nan]
shifted by -max   = [0.2447 0.6652 0.09  ]
same softmax after adding 1000 to every logit: True

Το $e^{800}$ υπερχειλίζει έναν 64-bit float, το άθροισμα γίνεται άπειρο, και το άπειρο διαιρεμένο με άπειρο είναι nan — όχι σφάλμα, όχι crash, απλώς μια σιωπηλή τρύπα εκεί όπου υπήρχαν τρεις πιθανότητες. Η αφαίρεση του μέγιστου logit δεν αλλάζει τίποτα μαθηματικά και αλλάζει τα πάντα αριθμητικά, επειδή ο μεγαλύτερος εκθέτης γίνεται ακριβώς $e^0 = 1$. Αυτό είναι το κόλπο logsumexp του Κεφαλαίου 2 με ρούχα δουλειάς, και κάθε σοβαρή υλοποίηση το κάνει:

def softmax(Z):
    Z = Z - Z.max(axis=1, keepdims=True)   
    E = np.exp(Z)
    return E / E.sum(axis=1, keepdims=True)


def fit_softmax(X, Y, lr=1.0, epochs=6000):
    W, b = np.zeros((X.shape[1], Y.shape[1])), np.zeros(Y.shape[1])
    for _ in range(epochs):
        G = (softmax(X @ W + b) - Y) / len(X)   
        W -= lr * (X.T @ G)
        b -= lr * G.sum(0)
    return W, b

Το gradient είναι ξανά πρόβλεψη μείον αλήθεια, τώρα με $Y$ one-hot. Η δυαδική περίπτωση ήταν ειδική περίπτωση εξαρχής.

Εκπαιδευμένο σε 3.000 εξαρτήματα και δοκιμασμένο σε 1.000, με τρεις μετρήσεις το καθένα (πλάτος, βάρος, θερμοκρασία τήγματος), φτάνει σε 94,00 % ακρίβεια. Να τι κρύβει αυτός ο αριθμός:

Το μοντέλο βρίσκει λιγότερα από τα μισά short shots. Η ακρίβεια δεν μπορεί να το δει, επειδή το 86 % των εξαρτημάτων είναι εντάξει και το να τα πετυχαίνει αυτά αρκεί για να σηκώσει τον μέσο όρο. Το macro F1 — ο μέσος όρος των F1 scores ανά κλάση, που ζυγίζει μια σπάνια κλάση το ίδιο με μια συνηθισμένη — είναι 0,7983, έναντι micro F1 0,9400 που εξ ορισμού είναι ταυτόσημο με την ακρίβεια. Όποτε κάποιος αναφέρει έναν αριθμό F1, ρωτήστε ποιον.

Αυτό είναι το τέλος της μοντελοποίησης. Το υπόλοιπο κεφάλαιο αφορά τους αριθμούς.

Πάρτε το εκπαιδευμένο δυαδικό μοντέλο και φτιάξτε δύο παραλλαγές πολλαπλασιάζοντας κάθε logit με μια σταθερά: 0,35 για μια διστακτική έκδοση, 4 για μια υπερσίγουρη. Ο πολλαπλασιασμός με θετικό αριθμό δεν μπορεί να αλλάξει κανένα πρόσημο, άρα και τα τρία μοντέλα προβλέπουν ακριβώς την ίδια ετικέτα για όλα τα 4.000 εξαρτήματα δοκιμής. Η ακρίβεια δεν μπορεί να τα ξεχωρίσει. Το cross-entropy δεν έχει κανένα πρόβλημα:

Το διστακτικό μοντέλο πληρώνει έναν μικρό φόρο σε κάθε εξάρτημα, συμπεριλαμβανομένων των χιλιάδων που πετυχαίνει. Το υπερσίγουρο είναι σχεδόν δωρεάν όταν έχει δίκιο και καταστροφικό όταν κάνει λάθος — ένα εξάρτημα σε εκείνο το σύνολο δοκιμής του κοστίζει 27,63 nats μόνο του. Τα δύο καταλήγουν σχεδόν στο ίδιο σύνολο από αντίθετες διαδρομές, και το εκπαιδευμένο μοντέλο, του οποίου οι πιθανότητες είναι βαθμονομημένες στα δεδομένα, κάθεται τρεις φορές χαμηλότερα και από τα δύο.

Αυτός είναι ο πιο αιχμηρός τρόπος να δηλώσετε τη διαφορά ανάμεσα σε μια απώλεια και ένα metric. Η απώλεια είναι αυτό που βελτιστοποιείτε: πρέπει να είναι παραγωγίσιμη, και βλέπει όλα όσα είπε το μοντέλο, μαζί με το πόσο σίγουρο ήταν. Το metric είναι αυτό με βάση το οποίο κρίνεστε: μπορεί να είναι βηματική συνάρτηση, επιχειρησιακός κανόνας, μέτρηση χαμένων ελαττωμάτων. Δεν είναι το ίδιο αντικείμενο και δεν συμφωνούν πάντα — γι’ αυτό ορίζετε και τα δύο πριν ξεκινήσετε, και δεν αφήνετε ποτέ την απώλεια να σταθεί στη θέση του metric επειδή τυχαίνει να βρίσκεται στην οθόνη.

Πριν από οποιοδήποτε μοντέλο, η απαίτηση: τι σκορ παίρνει η πιο τεμπέλικη δυνατή απάντηση; Σε αυτόν τον ιμάντα, λέτε πάντα εντάξει:

always-say-fine baseline: accuracy = 0.9815
confusion (tn, fp, fn, tp) = (3926, 0, 74, 0)

98,15 %. Τώρα το εκπαιδευμένο λογιστικό μοντέλο, στο προεπιλεγμένο κατώφλι 0,5:

logistic @0.5: accuracy=0.9830 precision=0.8000 recall=0.1081 F1=0.1905
confusion (tn, fp, fn, tp) = (3924, 2, 66, 8)

98,30 %. Κέρδισε το baseline κατά 0,15 ποσοστιαίες μονάδες, και οποιαδήποτε αναφορά σταματήσει στην ακρίβεια θα το πει νίκη. Ο πίνακας σύγχυσης λέει τι συνέβη πραγματικά:

Τρεις αριθμοί ονομάζουν τους τρεις τρόπους ανάγνωσης αυτού του πίνακα:

• Precision $= \mathrm{TP}/(\mathrm{TP}+\mathrm{FP}) = 8/10 = 0.800$. Από τα εξαρτήματα που επισήμανε, πόσα ήταν πραγματικά ελαττωματικά. Αυτό είναι το κόστος των χαμένων επιθεωρήσεων.
• Recall $= \mathrm{TP}/(\mathrm{TP}+\mathrm{FN}) = 8/74 = 0.108$. Από τα ελαττωματικά εξαρτήματα, πόσα έπιασε. Αυτό είναι το κόστος αποστολής ενός κακού εξαρτήματος σε πελάτη.
• F1 $= 2PR/(P+R) = 0.190$, ο αρμονικός μέσος τους, που μένει κοντά στο μικρότερο από τα δύο και επομένως αρνείται να κολακευτεί από το ένα μόνο του.

Το ποιο έχει σημασία εξαρτάται από το εργοστάσιο, όχι από τα μαθηματικά: μια επιθεώρηση κοστίζει μερικά δευτερόλεπτα και ένα ελάττωμα που αποστέλλεται κοστίζει ειδοποίηση ανάκλησης, άρα εδώ κυριαρχεί το recall και το 0,108 είναι αποτυχία.

Αλλά το πρόβλημα δεν είναι το μοντέλο. Είναι το κατώφλι, και το κατώφλι δεν είναι μέρος του μοντέλου — είναι επιχειρησιακή απόφαση που εφαρμόζεται μετά σε μια πιθανότητα. Σαρώστε το:

Διαβάστε τη στήλη ακρίβειας προς τα κάτω. Πέφτει σε όλη τη διαδρομή — από 98,30 % σε 65,93 % — ενώ το μοντέλο πηγαίνει από το να πιάνει 8 ελαττώματα στο να πιάνει 71 από 74. Κάθε χρήσιμο πράγμα που μπορεί να κάνει αυτό το μοντέλο χειροτερεύει την ακρίβειά του. Μια ομάδα που βελτιστοποιεί τον τίτλο του αριθμού θα έστελνε την έκδοση που δεν βρίσκει τίποτα.

Γιατί τρεις διαχωρισμοί και όχι δύο; Επειδή τη στιγμή που χρησιμοποιείτε ένα σύνολο παραδειγμάτων για να επιλέξετε οτιδήποτε — ένα κατώφλι, έναν ρυθμό μάθησης, ποιο από έξι μοντέλα να στείλετε — αυτό το σύνολο έχει χρησιμοποιηθεί για fitting, και το σκορ του παύει να είναι αμερόληπτο.³ Μετρημένο σε αυτόν τον ιμάντα: η σάρωση του κατωφλιού στο σύνολο validation επιλέγει 0,196, και το μοντέλο μετά πετυχαίνει F1 = 0,4122 στο ανέγγιχτο σύνολο δοκιμής. Αν η σάρωση είχε γίνει απευθείας στο σύνολο δοκιμής, το καλύτερο εφικτό εκεί ήταν 0,4186 — ένας αριθμός που κανείς δεν δικαιούται να αναφέρει.

Το χάσμα είναι μικρό εδώ, 0,006, επειδή είναι μία hyperparameter που σαρώθηκε μία φορά απέναντι σε 4.000 παραδείγματα validation. Μεγαλώνει με κάθε επιπλέον απόφαση και κάθε συρρίκνωση του συνόλου validation. Σημειώστε επίσης ότι η κατεύθυνση δεν είναι εγγυημένη σε μία εκτέλεση: το επιλεγμένο κατώφλι πέτυχε 0,3902 στο validation και 0,4122 στο test, άρα το validation το υποτίμησε αυτή τη φορά. Η μεροληψία είναι συστηματική σε πολλές αποφάσεις, όχι ορατή σε μία.⁴

Τώρα η άσκηση. Το αρχείο καταγραφής του ιμάντα φτάνει με τρίτη στήλη, station_seconds: πόσο χρόνο πέρασε κάθε εξάρτημα στον σταθμό επιθεώρησης. Η προσθήκη της είναι αλλαγή μίας γραμμής στην προεπεξεργασία. Να τι κάνει:

Το recall πηγαίνει από 10,8 % σε 77,0 %. Το F1 υπερτετραπλασιάζεται. Και προσέξτε τι έκανε η ακρίβεια: 98,30 % → 99,20 %, ένα κέρδος εννέα δεκάτων της μονάδας, δηλαδή το είδος αριθμού που στρογγυλοποιείται σε «περίπου 99 % έτσι κι αλλιώς» σε μια συνοπτική διαφάνεια. Η ακρίβεια απέτυχε να δει την αποτυχία νωρίτερα και τώρα αποτυγχάνει να δει την απάτη.

Πριν συνεχίσετε: το μοντέλο κλέβει. Βρείτε πώς.

station = 1.8 + rng.exponential(0.35, N)                     # a part just passing through
audited = rng.random(N) < 0.006                              # random spot checks
station[audited] += rng.uniform(6.0, 26.0, audited.sum())
station[y == 1] = 9.0 + rng.exponential(7.0, (y == 1).sum())  

Η επισημασμένη γραμμή είναι η διαρροή: ο χρόνος παραμονής ενός ελαττωματικού εξαρτήματος αντλείται από διαφορετική κατανομή, επειδή ένας άνθρωπος το έβγαλε από τον ιμάντα. Αυτό είναι το πιο συνηθισμένο σοβαρό bug στην εφαρμοσμένη μηχανική μάθηση, και έχει όνομα: target leakage — πληροφορία στα χαρακτηριστικά εκπαίδευσης που δεν θα ήταν διαθέσιμη τη στιγμή που πρέπει να γίνει η πρόβλεψη.⁵ Δεν πετά exception. Παράγει καλύτερο αριθμό. Κάθε κίνητρο σε ένα project δείχνει προς το να τη διατηρήσετε.

Η άμυνα είναι μία ερώτηση, που τίθεται σε κάθε στήλη: τη στιγμή που χρειάζομαι αυτή την πρόβλεψη, υπάρχει ήδη αυτή η τιμή; Σε έναν ζωντανό ιμάντα, το station_seconds είναι άγνωστο μέχρι αφού επιθεωρηθεί το εξάρτημα — που είναι αυτό που υποτίθεται ότι θα αντικαθιστούσε το μοντέλο.

Ας πούμε ότι βαθμολογείτε ένα μοντέλο σε 20 παραδείγματα και πετυχαίνει 17. Αναφέρετε 85 %.

17 correct out of 20 -> accuracy 0.8500
  Wilson    95% CI : [0.6396, 0.9476]
  bootstrap 95% CI : [0.7000, 1.0000]
  P(a 65% model scores 17 or more out of 20) = 0.0444
  P(an 85% model scores 17 or more out of 20) = 0.6477

Η ειλικρινής ανάγνωση του 17/20 είναι κάπου μεταξύ 64 % και 95 %. Ένα πραγματικά 65 % μοντέλο παράγει αυτό το αποτέλεσμα στο 4,4 % των περιπτώσεων — μία εκτέλεση στις είκοσι τρεις — και αν δοκιμάσατε μια χούφτα prompts και αναφέρατε το καλύτερο, κατασκευάσατε αυτή την εκτέλεση μόνοι σας. Δεκαεπτά στα είκοσι δεν μπορούν να ξεχωρίσουν ένα 85 % μοντέλο από ένα 65 %.

Δύο τρόποι να βάλετε διάστημα σε έναν ρυθμό, και και οι δύο ανήκουν στην εργαλειοθήκη σας:

def wilson(k, n, z=1.959963985):
    """95% interval for k successes in n trials. Correct at small n; no simulation."""
    ph, d = k / n, 1 + z * z / n
    centre = (ph + z * z / (2 * n)) / d
    half = z * (ph * (1 - ph) / n + z * z / (4 * n * n)) ** 0.5 / d
    return centre - half, centre + half


def bootstrap_ci(correct, n_resamples=10_000, alpha=0.05, seed=0):
    """95% interval for the mean of any per-example score array. Works on F1 too."""
    rng = np.random.default_rng(seed)
    correct = np.asarray(correct, dtype=float)
    draws = correct[rng.integers(0, len(correct), size=(n_resamples, len(correct)))]
    lo, hi = np.quantile(draws.mean(axis=1), [alpha / 2, 1 - alpha / 2])
    return float(correct.mean()), float(lo), float(hi)

Χρησιμοποιήστε Wilson⁶ για έναν απλό ρυθμό επιτυχίας· παραμένει καλά συμπεριφερόμενο σε οποιοδήποτε $n$ και δεν χρειάζεται τυχαιότητα. Σημειώστε παραπάνω ότι στο $n = 20$ το πάνω άκρο του bootstrap είναι 1,0000 — η επαναδειγματοληψία 20 σημείων μπορεί εύκολα να τραβήξει 20 σωστά, άρα δεν μπορεί να αναπαραστήσει διάστημα στενότερο από τη δική της κοκκώδη ανάλυση. Χρησιμοποιήστε το bootstrap⁷ όπου δεν υπάρχει τύπος, δηλαδή στις περισσότερες ενδιαφέρουσες περιπτώσεις: F1, macro-averages, BLEU, pass@1, το σκορ ενός judge βασισμένου σε rubric. Σε αυτόν τον ιμάντα, το F1 0,4122 του ρυθμισμένου μοντέλου κουβαλά bootstrap διάστημα [0.3009, 0.5156] — που είναι ο αριθμός που πρέπει να εμφανιστεί στην αναφορά, επειδή η σημειακή εκτίμηση μόνη της προσκαλεί μια σύγκριση που δεν μπορεί να στηρίξει.

Μία ακόμα μέτρηση, επειδή αλλάζει το πώς πρέπει να συγκρίνετε δύο μοντέλα. Δύο μοντέλα βαθμολογημένα στα ίδια 500 παραδείγματα:

model A: 0.8580  95% CI [0.8260, 0.8880]
model B: 0.8120  95% CI [0.7780, 0.8460]
the two intervals overlap: True
paired difference A-B: 0.0460  95% CI [0.0260, 0.0680]
they disagree on 31 of 500 examples (A right 27, B right 4)

Τα διαστήματά τους επικαλύπτονται, και ο λαϊκός κανόνας — επικαλυπτόμενες μπάρες σφάλματος σημαίνουν καμία σημαντική διαφορά — θα χαρακτήριζε τη σύγκριση ασαφή. Δεν είναι. Τα δύο μοντέλα έτρεξαν στα ίδια παραδείγματα, άρα η σωστή ποσότητα είναι η διαφορά ανά παράδειγμα, της οποίας το διάστημα είναι [0.0260, 0.0680], άνετα πάνω από το μηδέν. Διαφωνούν μόνο σε 31 από 500 στοιχεία, και το A κερδίζει 27 από αυτές τις διαφωνίες· τα κοινά παραδείγματα, εύκολα και δύσκολα μαζί, ακυρώνονται αντί να προσθέτουν θόρυβο. Συγκρίνετε μοντέλα paired, και φτάνετε στο ίδιο συμπέρασμα με κλάσμα των δεδομένων.

Τώρα έχετε ένα μοντέλο που εξάγει βαθμονομημένες πιθανότητες, μια απώλεια παραγμένη από έναν ισχυρισμό για τα δεδομένα αντί επιλεγμένη για ευκολία, ένα gradient που είναι κυριολεκτικά πρόβλεψη μείον αλήθεια, και — πιο σημαντικό — τον μηχανισμό για να μάθετε αν οποιοδήποτε από αυτά λειτουργεί. Το δεκάγραμμο διάστημα Wilson παραπάνω επαναχρησιμοποιείται αυτολεξεί: κουβαλά τις παραλλαγές prompt στο Κεφάλαιο 15, τους πίνακες retrieval στο Κεφάλαιο 19, και το golden set στο Κεφάλαιο 29. Το bootstrap είναι αυτό που πιάνετε όταν δεν υπάρχει τύπος.

Αλλά το μοντέλο εξακολουθεί να είναι ένα layer. Σχεδιάζει μια γραμμή, και το Κεφάλαιο 1 απέδειξε με τέσσερις γραμμές XOR ότι μια γραμμή δεν αρκεί. Η διόρθωση είναι να στοιβάξετε: ένα πρώτο layer που λυγίζει τον χώρο, ένα δεύτερο που σχεδιάζει τη γραμμή στον λυγισμένο χώρο.

Εκεί τελειώνει το καθαρό gradient αυτού του κεφαλαίου. Όλα τα παραπάνω λειτούργησαν επειδή το $\partial L/\partial s = p - y$ μπορούσε να γραφτεί με το χέρι, μία φορά, για ένα μοντέλο με ένα layer ανάμεσα στην είσοδο και την απώλεια. Βάλτε ένα δεύτερο layer στη μέση και η ερώτηση αλλάζει σχήμα: ποια είναι η παράγωγος της απώλειας ως προς ένα βάρος που δεν αγγίζει καθόλου την έξοδο — ένα βάρος του οποίου η επιρροή φτάνει μόνο μέσω ενός άλλου layer, πιθανώς κατά μήκος πολλών διαδρομών ταυτόχρονα;

Αυτή η παράγωγος υπάρχει. Ο υπολογισμός της με το χέρι είναι απελπιστικός για οτιδήποτε μεγαλύτερο από παιχνίδι, και ο υπολογισμός της μία παράμετρο τη φορά είναι απελπιστικός σε άλλη κλίμακα. Αυτό που χρειάζεται είναι μια διαδικασία που παίρνει κάθε παράγωγο στο δίκτυο από ένα μόνο backward pass πάνω στο ίδιο γράφημα που μόλις περπάτησε το forward pass.

Αυτό είναι το Κεφάλαιο 5, και είναι η μηχανή πάνω στην οποία τρέχει το υπόλοιπο μάθημα.

Αξίζει επίσης να διαβαστούν παράλληλα με αυτό το κεφάλαιο: Bishop, Pattern Recognition and Machine Learning §1.2, §1.5, §1.6 και §4.3, που καλύπτει πιθανότητα, θεωρία αποφάσεων, θεωρία πληροφορίας και γραμμική ταξινόμηση με τη σειρά που ακολουθεί αυτό το κεφάλαιο· Murphy, Probabilistic Machine Learning: An Introduction, κεφάλαια 6 και 10· Prince, Understanding Deep Learning §5.4–5.7· και Saito και Rehmsmeier, The Precision-Recall Plot Is More Informative than the ROC Plot When Evaluating Binary Classifiers on Imbalanced Datasets (PLOS ONE, 2015) — γιατί το AUC που παρατέθηκε παραπάνω δεν πρέπει να είναι ο μόνος ανεξάρτητος από κατώφλι αριθμός που κοιτάτε όταν το 1,7 % των εξαρτημάτων είναι ελαττωματικά.