Oggetti che ricordano (classi e closure)
Perché è importante Nel Modulo 4 costruirai un motore di autograd. È una classe i cui oggetti si sommano e si moltiplicano con i normali + e @, e ogni risultato tiene una piccola funzione che ricorda come è stato creato. Questa lezione è il Python che c'è dietro.
Una classe è una ricetta per oggetti
class Box:
def __init__(self, value): # runs when you write Box(3)
self.value = value # self is the object being made
def doubled(self): # a method: a function that belongs to the object
return Box(self.value * 2)
b = Box(3)
b.value # 3
b.doubled().value # 6
Far funzionare + e @
Quando Python vede a + b sui tuoi oggetti, chiama a.__add__(b). Per a @ b chiama a.__matmul__(b). Scrivi quei metodi e i tuoi oggetti funzionano con i simboli normali. I nomi con due trattini bassi da ogni lato si chiamano metodi dunder.
def __add__(self, other):
return Box(self.value + other.value)
Un valore calcolato quando lo chiedi (@property)
Metti @property sopra un metodo e lo leggi come un valore conservato, senza parentesi: b.size invece di b.size(). Viene calcolato da capo ogni volta.
Piccole funzioni: lambda
square = lambda x: x * x è una funzione di una riga senza un nome suo. È uguale a def square(x): return x * x.
Funzioni che ricordano (closure)
def make_scaler(k):
def scale(x):
return k * x # k comes from the call to make_scaler
return scale
triple = make_scaler(3)
triple(5) # 15: scale still remembers k = 3
Leggere una variabile ricordata funziona e basta. Cambiarla richiede attenzione: count += 1 dentro la funzione interna fa trattare a Python count come una variabile locale nuova di zecca, e ottieni UnboundLocalError. Due soluzioni: scrivi nonlocal count come prima riga della funzione interna, che dice "il count di fuori", oppure tieni il numero dentro una lista, count = [0], e cambia count[0], che modifica la lista invece di riassegnare il nome.
def make_total():
total = 0
def add(x):
nonlocal total # without this line: UnboundLocalError
total += x
return total
return add
La funzione interna tiene le variabili che usava dalla funzione che l'ha creata, anche dopo che quella funzione è finita. L'autograd usa esattamente questo: ogni risultato di + o * conserva una minuscola closure che ricorda i suoi input, pronta a rimandare loro i gradienti più tardi.
Classe: una ricetta per oggetti. Metodo: una funzione che appartiene a un oggetto e lo riceve come self. Closure: una funzione interna che ricorda variabili del posto in cui è stata creata.
Riepilogo __init__ prepara un oggetto, __add__ e __matmul__ gli danno + e @, @property si legge come un valore, e una closure porta con sé la propria memoria.
Parole e simboli di questa lezione
- a @ b
- moltiplicazione di matrici (anche il prodotto scalare per due liste di numeri)
Finisci la classe Vec, una lista di numeri che fa calcoli. Vec([1, 2]) + Vec([3, 4]) deve dare un nuovo Vec che contiene [4, 6] (somma elemento per elemento); Vec([1, 2]) @ Vec([3, 4]) deve dare il numero 11 (moltiplica elemento per elemento e somma); Vec([3, 4]).size deve valere 5.0 (la lunghezza, la radice quadrata della somma dei quadrati), letta come proprietà. Nessuno dei due input deve cambiare. Poi scrivi make_counter(): restituisce una funzione che, ogni volta che viene chiamata, restituisce 1, poi 2, poi 3 e così via, con ogni contatore che conta per conto suo.
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.