Come ti corregge il mondo nascosto
Perché è importante Se sai esattamente che cosa viene controllato, puoi indirizzare lì il tuo impegno invece di tirare a indovinare. Sapere come funziona il controllo ti dice anche perché è giusto: nessuno può superarlo copiando le risposte, quindi superarlo significa che hai davvero costruito la cosa.
Pensa a un esame di guida. Ti eserciti per le strade vicino a casa finché non conosci ogni curva. Il giorno dell'esame, l'esaminatore sceglie un percorso che non hai mai fatto. Le regole della strada sono le stesse, ma le strade sono nuove, quindi l'unico modo per superarlo è saper guidare davvero.
Diversi progetti delle tue tappe sono stati corretti esattamente così: il Tracker Lab della Tappa 2, il rapporto sui dispositivi della Tappa 5 e la serie di tracker nascosta della Tappa 6 hanno fatto girare il tuo codice su un mondo nascosto con le stesse regole ma siti, nomi, tracker e visitatori diversi. Quando porti un passo più in là il tuo progetto vetrina, metti alla prova quel passo allo stesso modo: su un mondo su cui non l'hai regolato.
Mondo nascosto: un mondo di esercitazione che non hai visto, costruito dallo stesso generatore di quello su cui ti sei esercitato, ma da un seme diverso. Si usa solo per correggere.
Seme: il numero di partenza di un generatore casuale. Lo stesso seme costruisce sempre lo stesso mondo, e un seme diverso ne costruisce uno diverso. È così che la correzione può essere giusta per tutti e allo stesso tempo nuova per te.
Due tipi di controllo
- Un rapporto controllato contro un mondo nascosto (i progetti delle Tappe 2 e 5). Il tuo codice guarda il mondo nascosto e scrive un rapporto JSON; il controllo lo confronta con ciò che sa esserci davvero.
- Test nascosti (la maggior parte dei laboratori, e i progetti delle Tappe 3, 4, 6 e 7). Il controllo chiama le tue funzioni con input che non hai visto e controlla i risultati.
La descrizione scritta del tuo progetto finale (prossima lezione) non viene corretta da una macchina: è la parte che mostri a una persona. Così i controlli automatici restano su cose che una macchina può giudicare in modo giusto.
JSON: un formato di testo semplice per i dati, fatto di liste tra parentesi quadre e valori con etichetta tra parentesi graffe. Un dict e una lista di Python diventano JSON quasi uno a uno.
Com'è il controllo di un rapporto
Un rapporto è solo un insieme di scoperte strutturate. Se porti il progetto della Tappa 3 un passo più in là, in un'analisi completa di un negozio di esercitazione, un rapporto potrebbe essere così:
{
"site": "shopa.example",
"third_parties": ["adco.example", "cdn.example"],
"trackers": ["adco.example"],
"cookies": [{"name": "uid", "domain": "adco.example", "third_party": true}],
"csp_present": false
}
Il correttore gli fa alcune domande semplici. È JSON valido? Ci sono i campi richiesti, con i tipi giusti? E per ogni scoperta: c'è davvero nel mondo nascosto?
Centri, mancati e falsi allarmi
Un allarme antincendio può avere ragione o torto in due modi diversi. Può restare in silenzio durante un incendio vero (un mancato), o può suonare quando hai solo fatto un toast (un falso allarme). Un buon allarme li tiene bassi entrambi. Le tue scoperte vengono giudicate allo stesso modo.
Vero positivo: hai segnalato qualcosa e c'è davvero. Falso positivo: hai segnalato qualcosa che non c'è (un falso allarme). Falso negativo: qualcosa c'è e non l'hai segnalato (un mancato).
Diciamo che il tuo blocker, sul mondo nascosto, vede 20 richieste di tracker e 80 normali. Blocca 19 dei tracker e anche, per errore, 1 richiesta normale di cui una pagina aveva bisogno. Sono 19 centri, 1 mancato e 1 falso allarme. Nella Tappa 2 hai trasformato conteggi come questi in precisione (quante delle cose che hai bloccato erano davvero tracker) e richiamo (quanti dei tracker veri hai preso).
Una regola di superamento per un progetto potrebbe essere come quella del piano del corso: "bloccato almeno il 95% delle richieste dei tracker, nessun falso positivo". Qui 19 su 20 è esattamente il 95%, ma l'unica richiesta bloccata per errore la fa comunque fallire. Negli strumenti per la privacy contano entrambi gli errori: un mancato lascia passare il tracciamento, e un falso allarme rompe la pagina e insegna alle persone a spegnere lo strumento.
Stesso codice, stesso punteggio
La correzione è deterministica: esegui lo stesso codice sullo stesso mondo nascosto e ottieni sempre lo stesso risultato. Dove un progetto controlla la velocità, conta le operazioni rispetto a un budget, mai il tempo dell'orologio, quindi un portatile lento non viene penalizzato.
Controlla il tuo rapporto prima di consegnarlo
La maggior parte delle consegne fallite non sono idee sbagliate; sono un campo mancante o un errore di battitura. Un piccolo controllo fatto da te li cattura:
import json
report = {"site": "shopa.example", "trackers": ["adco.example"], "csp_present": False}
def missing_fields(report, required):
# return the required field names that the report does not have
return [name for name in required if name not in report]
print(missing_fields(report, ["site", "third_parties", "trackers", "csp_present"]))
# ['third_parties'] -> add it before you submit
print(json.dumps(report, indent=2, sort_keys=True))
In altri linguaggi
Viene corretto il rapporto, non il codice, quindi va bene qualsiasi linguaggio che scrive JSON (così puoi riscrivere la tua vetrina nel linguaggio che usi al lavoro).
JavaScript:
const report = { site: "shopa.example", trackers: ["adco.example"], csp_present: false };
const required = ["site", "third_parties", "trackers", "csp_present"];
console.log(required.filter(name => !(name in report))); // [ 'third_parties' ]
console.log(JSON.stringify(report, null, 2));
Go:
type Report struct {
Site string `json:"site"`
Trackers []string `json:"trackers"`
CSPPresent bool `json:"csp_present"`
}
out, _ := json.MarshalIndent(Report{Site: "shopa.example", Trackers: []string{"adco.example"}}, "", " ")
fmt.Println(string(out))
C#:
var report = new { site = "shopa.example", trackers = new[] { "adco.example" }, csp_present = false };
Console.WriteLine(System.Text.Json.JsonSerializer.Serialize(report));
Un equivoco comune
"Il mio punteggio sul mondo di esercitazione è 100%, quindi lo sarà anche quello nascosto." Non sempre. Se il tuo codice dipende di nascosto da dettagli del mondo di esercitazione, come un elenco di nomi di tracker che hai copiato da lì, perderà i tracker nel mondo nascosto. Si chiama overfitting: adattarsi agli esempi che hai visto invece che alla regola che c'è dietro. Prima di consegnare, prova la tua logica su qualche mondo di esercitazione costruito da semi diversi (per esempio build_world(seed=2) oltre al solito).
Riepilogo
- La correzione sul mondo nascosto fa girare il tuo lavoro su un mondo con un seme che non hai visto, così le risposte copiate falliscono e la vera abilità passa.
- Alcuni progetti vengono corretti con un rapporto JSON su un mondo nascosto, la maggior parte con test nascosti; la descrizione scritta del progetto finale è per le persone, non per un correttore.
- Le scoperte vengono giudicate su centri, mancati e falsi allarmi; contano entrambi i tipi di errore.
- La correzione è deterministica e conta le operazioni, non il tempo dell'orologio. Controlla tu i campi del tuo rapporto prima di consegnarlo.
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.