Des objets qui se souviennent (classes et closures)
Pourquoi c'est important Au module 4, tu construiras un moteur d'autograd. C'est une classe dont les objets s'additionnent et se multiplient avec les + et @ ordinaires, et chaque résultat garde une petite fonction qui se souvient de la façon dont il a été fabriqué. Cette leçon, c'est le Python qui est derrière.
Une classe est une recette pour des objets
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
Faire marcher + et @
Quand Python voit a + b sur tes objets, il appelle a.__add__(b). Pour a @ b, il appelle a.__matmul__(b). Écris ces méthodes et tes objets marchent avec les symboles normaux. Les noms avec deux tirets bas de chaque côté s'appellent des méthodes dunder.
def __add__(self, other):
return Box(self.value + other.value)
Une valeur calculée quand tu la demandes (@property)
Mets @property au-dessus d'une méthode et tu la lis comme une valeur stockée, sans parenthèses : b.size au lieu de b.size(). Elle est recalculée à chaque fois.
De petites fonctions : lambda
square = lambda x: x * x est une fonction d'une ligne qui n'a pas de nom à elle. C'est la même chose que def square(x): return x * x.
Des fonctions qui se souviennent (closures)
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
Lire une variable mémorisée marche tout simplement. En modifier une demande de l'attention : count += 1 dans la fonction intérieure fait traiter count par Python comme une toute nouvelle variable locale, et tu obtiens UnboundLocalError. Deux corrections : écrire nonlocal count comme première ligne de la fonction intérieure, ce qui veut dire « le count de l'extérieur », ou garder le nombre dans une liste, count = [0], et modifier count[0], ce qui change la liste au lieu de relier le nom.
def make_total():
total = 0
def add(x):
nonlocal total # without this line: UnboundLocalError
total += x
return total
return add
La fonction intérieure garde les variables qu'elle a utilisées de la fonction qui l'a créée, même après que cette fonction a terminé. L'autograd utilise exactement ça : chaque résultat de + ou * stocke une toute petite closure qui se souvient de ses entrées, prête à leur renvoyer des gradients plus tard.
Classe : une recette pour des objets. Méthode : une fonction qui appartient à un objet et le reçoit sous le nom self. Closure : une fonction intérieure qui se souvient des variables de l'endroit où elle a été créée.
Récap __init__ prépare un objet, __add__ et __matmul__ lui donnent + et @, @property se lit comme une valeur, et une closure porte sa propre mémoire.
Mots et symboles de cette leçon
- a @ b
- produit matriciel (aussi le produit scalaire pour deux listes de nombres)
Termine la classe Vec, une liste de nombres qui fait des maths. Vec([1, 2]) + Vec([3, 4]) doit donner un nouveau Vec qui contient [4, 6] (addition élément par élément) ; Vec([1, 2]) @ Vec([3, 4]) doit donner le nombre 11 (multiplication élément par élément puis somme) ; Vec([3, 4]).size doit valoir 5.0 (la longueur, la racine carrée de la somme des carrés), lue comme une propriété. Aucune des entrées ne doit changer. Puis écris make_counter() : elle renvoie une fonction qui, à chaque appel, renvoie 1, puis 2, puis 3 et ainsi de suite, chaque compteur comptant pour lui-même.
Tu as repéré un problème dans cette leçon ? Signale-le · Pose une question sur cette leçon
Cet exercice s'ouvre bientôt
Termine la leçon précédente pour débloquer celle-ci. Tout le cours est gratuit, aucun compte n'est requis, et tu peux lire cette leçon dès maintenant.
Ce navigateur bloque les cookies pour learn.floati.life, donc les leçons que tu as terminées ici ne peuvent pas s'ouvrir dans l'ordre. Autorise les cookies pour ce site et recharge la page.