[ad_1]
Dernière mise à jour le 8 février 2022
Les dérivés sont l’un des concepts les plus fondamentaux du calcul. Ils décrivent comment les modifications des entrées variables affectent les sorties de la fonction. L’objectif de cet article est de fournir une introduction de haut niveau au calcul des dérivés dans PyTorch pour ceux qui découvrent le framework. PyTorch offre un moyen pratique de calculer les dérivées pour les fonctions définies par l’utilisateur.
Alors que nous devons toujours faire face à la rétropropagation (un algorithme connu pour être l’épine dorsale d’un réseau de neurones) dans les réseaux de neurones, qui optimise les paramètres pour minimiser l’erreur afin d’obtenir une plus grande précision de classification ; les concepts appris dans cet article seront utilisés dans des articles ultérieurs sur l’apprentissage en profondeur pour le traitement d’image et d’autres problèmes de vision par ordinateur.
Après avoir suivi ce didacticiel, vous apprendrez :
- Comment calculer les dérivées dans PyTorch.
- Comment utiliser autograd dans PyTorch pour effectuer une différenciation automatique sur les tenseurs.
- À propos du graphe de calcul qui implique différents nœuds et feuilles, vous permettant de calculer les gradients de la manière la plus simple possible (en utilisant la règle de la chaîne).
- Comment calculer les dérivées partielles dans PyTorch.
- Comment implémenter la dérivée de fonctions par rapport à plusieurs valeurs.
Commençons.

Calcul des dérivées dans PyTorch
Photo de Jossuha Théophile. Certains droits réservés.
Différenciation dans Autograd
L’autograd – un module de différenciation automatique dans PyTorch – est utilisé pour calculer les dérivées et optimiser les paramètres dans les réseaux de neurones. Il est destiné principalement aux calculs de gradient.
Avant de commencer, chargeons quelques bibliothèques nécessaires que nous utiliserons dans ce didacticiel.
importer matplotlib.pyplot en tant que torche d’importation plt
importer matplotlib.pyplot comme plt importer torche |
Maintenant, utilisons un simple tenseur et définissons le requires_grad
paramètre à vrai. Cela nous permet d’effectuer une différenciation automatique et permet à PyTorch d’évaluer les dérivées en utilisant la valeur donnée qui, dans ce cas, est 3,0.
x = torch.tensor(3.0, requirements_grad = True) print(“création d’un tenseur x : “, x)
X = torche.tenseur(3.0, exige_grad = Vrai) imprimer(“création d’un tenseur x : “, X) |
création d’un tenseur x : tenseur(3., requirements_grad=True)
création d’un tenseur x : tenseur(3., requirements_grad=True) |
Nous utiliserons une équation simple $y=3x^2$ comme exemple et prendrons la dérivée par rapport à la variable x
. Alors, créons un autre tenseur selon l’équation donnée. De plus, nous appliquerons une méthode soignée .backward
sur la variable y
qui forme un graphe acyclique stockant l’historique des calculs et évalue le résultat avec .grad
pour la valeur donnée.
y = 3 * x ** 2 print(“Le résultat de l’équation est : “, y) y.backward() print(“La dérivée de l’équation en x = 3 est : “, x.grad)
y = 3 * X ** 2 imprimer(“Le résultat de l’équation est : “, y) y.en arrière() imprimer(“La dérivée de l’équation en x = 3 est : “, X.diplômé) |
Le résultat de l’équation est : tensor(27., grad_fn=
Le résultat de l’équation est : tensor(27., grad_fn= La dérivée de l’équation à x = 3 est : tenseur(18.) |
Comme vous pouvez le voir, nous avons obtenu une valeur de 18, ce qui est correct.
Graphe de calcul
PyTorch génère des dérivées en construisant un graphe inversé dans les coulisses, tandis que les tenseurs et les fonctions inversées sont les nœuds du graphe. Dans un graphe, PyTorch calcule la dérivée d’un tenseur selon qu’il s’agit d’une feuille ou non.
PyTorch n’évaluera pas la dérivée d’un tenseur si son attribut feuille est défini sur True. Nous n’entrerons pas dans les détails sur la création et l’utilisation du graphe inversé, car le but ici est de vous donner une connaissance de haut niveau de la façon dont PyTorch utilise le graphe pour calculer les dérivées.
Alors, vérifions comment les tenseurs x
et y
regarder en interne une fois qu’ils sont créés. Pour x
:
print(‘attribut data du tenseur :’,x.data) print(‘attribut grad du tenseur : :’,x.grad) print(‘attribut grad_fn du tenseur : :’,x.grad_fn) print(” is_leaf attribut du tenseur ::”,x.is_leaf) print(“requires_grad attribut du tenseur ::”,x.requires_grad)
imprimer(‘attribut de données du tenseur :’,X.Les données) imprimer(‘attribut grad du tenseur ::’,X.diplômé) imprimer(‘attribut grad_fn du tenseur ::’,X.grad_fn) imprimer(“attribut is_leaf du tenseur ::”,X.est_feuille) imprimer(“attribut requires_grad du tenseur ::”,X.exige_grad) |
data attribut du tenseur : tensor(3.) grad attribut du tenseur :: tensor(18.) grad_fn attribut du tenseur :: None is_leaf attribut du tenseur :: True requires_grad attribut du tenseur :: True
attribut de données du tenseur : tenseur(3.) attribut grad du tenseur :: tenseur(18.) attribut grad_fn du tenseur :: Aucun attribut is_leaf du tenseur :: True attribut requirements_grad du tenseur :: True |
et pour y
:
print(‘attribut data du tenseur :’,y.data) print(‘attribut grad du tenseur :’,y.grad) print(‘attribut grad_fn du tenseur :’,y.grad_fn) print(“attribut is_leaf du tenseur :”,y.is_leaf) print(“requires_grad attribut du tenseur :”,y.requires_grad)
imprimer(‘attribut de données du tenseur :’,y.Les données) imprimer(‘attribut grad du tenseur :’,y.diplômé) imprimer(‘attribut grad_fn du tenseur :’,y.grad_fn) imprimer(“attribut is_leaf du tenseur :”,y.est_feuille) imprimer(“attribut de requêtes_grad du tenseur :”,y.exige_grad) |
print(‘attribut data du tenseur :’,y.data) print(‘attribut grad du tenseur :’,y.grad) print(‘attribut grad_fn du tenseur :’,y.grad_fn) print(“attribut is_leaf du tenseur :”,y.is_leaf) print(“requires_grad attribut du tenseur :”,y.requires_grad)
print(‘attribut data du tenseur :’,y.data) print(‘attribut grad du tenseur :’,y.grad) print(‘attribut grad_fn du tenseur :’,y.grad_fn) print(“attribut is_leaf du tenseur :”,y.is_leaf) print(“requires_grad attribut du tenseur :”,y.requires_grad) |
Comme vous pouvez le voir, chaque tenseur s’est vu attribuer un ensemble particulier d’attributs.
le data
l’attribut stocke les données du tenseur tandis que l’attribut grad_fn
L’attribut indique le nœud dans le graphique. De même, le .grad
L’attribut contient le résultat de la dérivée. Maintenant que vous avez appris quelques bases sur l’autograd et le graphe de calcul dans PyTorch, prenons une équation un peu plus compliquée $y=6x^2+2x+4$ et calculons la dérivée. La dérivée de l’équation est donnée par :
$$\frac{dy}{dx} = 12x+2$$
En évaluant la dérivée à $x = 3$,
$$\left.\frac{dy}{dx}\right\vert_{x=3} = 12\times 3+2 = 38$$
Voyons maintenant comment PyTorch fait cela,
x = torch.tensor(3.0, requirements_grad = True) y = 6 * x ** 2 + 2 * x + 4 print(“Le résultat de l’équation est : “, y) y.backward() print(“Dérivée du l’équation à x = 3 est : “, x.grad)
X = torche.tenseur(3.0, exige_grad = Vrai) y = 6 * X ** 2 + 2 * X + 4 imprimer(“Le résultat de l’équation est : “, y) y.en arrière() imprimer(“La dérivée de l’équation en x = 3 est : “, X.diplômé) |
Le résultat de l’équation est : tensor(64., grad_fn=
Le résultat de l’équation est : tensor(64., grad_fn= La dérivée de l’équation à x = 3 est : tenseur(38.) |
La dérivée de l’équation est 38, ce qui est correct.
Implémentation des dérivées partielles de fonctions
PyTorch nous permet également de calculer des dérivées partielles de fonctions. Par exemple, si nous devons appliquer une dérivation partielle à la fonction suivante,
$$f(u,v) = u^3+v^2+4uv$$
Sa dérivée par rapport à $u$ est,
$$\frac{\partial f}{\partial u} = 3u^2 + 4v$$
De même, la dérivée par rapport à $v$ sera,
$$\frac{\partial f}{\partial v} = 2v + 4u$$
Maintenant, faisons-le à la manière de PyTorch, où $u = 3$ et $v = 4$.
Nous créerons u
, v
et f
tenseurs et appliquer les .backward
attribut sur f
pour calculer la dérivée. Enfin, nous évaluerons la dérivée à l’aide de la .grad
par rapport aux valeurs de u
et v
.
u = torch.tensor(3., requirements_grad=True) v = torch.tensor(4., requirements_grad=True) f = u**3 + v**2 + 4*u*v print(u) print(v ) print(f) f.backward() print(“Dérivée partielle par rapport à u : “, u.grad) print(“Dérivée partielle par rapport à u : “, v.grad)
tu = torche.tenseur(3., exige_grad=Vrai) v = torche.tenseur(4., exige_grad=Vrai) F = tu **3 + v**2 + 4*tu *v imprimer(tu) imprimer(v) imprimer(F) F.en arrière() imprimer(« Dérivée partielle par rapport à u : », tu.diplômé) imprimer(« Dérivée partielle par rapport à u : », v.diplômé) |
tensor(3., requirements_grad=True) tensor(4., requirements_grad=True) tensor(91., grad_fn=
tenseur(3., requirements_grad=True) tenseur(4., requirements_grad=True) tenseur(91., grad_fn= Dérivée partielle par rapport à u : tenseur(43.) Dérivée partielle par rapport à u : tenseur(20.) |
Dérivée de fonctions à valeurs multiples
Que se passe-t-il si nous avons une fonction à plusieurs valeurs et que nous devons calculer la dérivée par rapport à ses multiples valeurs ? Pour cela, nous utiliserons l’attribut sum pour (1) produire une fonction à valeur scalaire, puis (2) prendre la dérivée. Voici comment nous pouvons voir le graphique “fonction vs dérivée”:
# calcule la dérivée de la fonction avec plusieurs valeurs x = torch.linspace(-20, 20, 20, requirements_grad = True) Y = x ** 2 y = torch.sum(Y) y.backward() # tracer la fonction et dérivée function_line, = plt.plot(x.detach().numpy(), Y.detach().numpy(), label=”Function”) function_line.set_color(“red”) dérivée_line, = plt.plot( x.detach().numpy(), x.grad.detach().numpy(), label=”Derivative”) derive_line.set_color(“vert”) plt.xlabel(‘x’) plt.legend() plt .Afficher()
# calcule la dérivée de la fonction avec plusieurs valeurs X = torche.espace lin(–20, 20, 20, exige_grad = Vrai) Oui = X ** 2 y = torche.somme(Oui) y.en arrière() # tracer la fonction et la dérivée function_line, = plt.parcelle(X.détacher().numpy(), Oui.détacher().numpy(), étiqueter = ‘Une fonction’) function_line.set_color(“rouge”) ligne_dérivé, = plt.parcelle(X.détacher().numpy(), X.diplômé.détacher().numpy(), étiqueter = ‘Dérivé’) ligne_dérivé.set_color(“vert”) plt.xétiquette(‘X’) plt.Légende() plt.Afficher() |
Dans les deux plot()
fonction ci-dessus, nous extrayons les valeurs des tenseurs PyTorch afin de pouvoir les visualiser. le .detach
La méthode ne permet pas au graphique de suivre davantage les opérations. Cela nous permet de convertir facilement un tenseur en un tableau numpy.
Résumé
Dans ce didacticiel, vous avez appris à implémenter des dérivées sur diverses fonctions dans PyTorch.
En particulier, vous avez appris :
- Comment calculer les dérivées dans PyTorch.
- Comment utiliser autograd dans PyTorch pour effectuer une différenciation automatique sur les tenseurs.
- À propos du graphe de calcul qui implique différents nœuds et feuilles, vous permettant de calculer les gradients de la manière la plus simple possible (en utilisant la règle de la chaîne).
- Comment calculer les dérivées partielles dans PyTorch.
- Comment implémenter la dérivée de fonctions par rapport à plusieurs valeurs.