0Pricing
Learn AI with Python · Leçon

Tenseurs PyTorch et Autograd

torch.Tensor, requires_grad, backward(), calcul des gradients, opérations sur les tenseurs.

Tenseurs PyTorch et Autograd est une leçon Learn AI with Python gratuite sur CoddyKit. Ceci est la leçon 1 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Learn AI with Python, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Learn AI with Python comprend 4 leçons au total.

Qu'est-ce que PyTorch ?

PyTorch est un cadre d'apprentissage profond conçu autour des tenseurs, des tableaux multidimensionnels bénéficiant de l'accélération GPU et de la différentiation automatique. Les deux piliers que vous devez maîtriser en premier sont les tenseurs et la différentiation automatique.

pip install torch

import torch

Créer des tenseurs

Un tenseur ressemble à un tableau NumPy, mais il peut résider sur un GPU et suivre les gradients. Créez-en un avec torch.tensor. Les tenseurs possèdent une shape et un dtype.

x = torch.tensor([1.0, 2.0, 3.0])
print(x.shape)   # torch.Size([3])
print(x.dtype)   # torch.float32

Opérations sur les tenseurs

Les tenseurs prennent en charge les calculs terme à terme, la multiplication matricielle et le redimensionnement. Les opérations sont vectorisées et s'exécutent rapidement sur le matériel. C'est la base de calcul de tout réseau neuronal.

a = torch.tensor([[1.0, 2.0], [3.0, 4.0]])
b = torch.tensor([[5.0, 6.0], [7.0, 8.0]])
print(a + b)
print(a @ b)  # matrix multiply

requires_grad : suivi des gradients

Pour calculer les gradients, créez un tenseur avec requires_grad=True. PyTorch enregistre alors chaque opération effectuée sur celui-ci et construit un graphe de calcul qu'il pourra différencier ultérieurement.

x = torch.tensor([2.0, 3.0], requires_grad=True)
print(x.requires_grad)  # True

Construire un calcul

Appliquez des opérations à un tenseur qui suit les gradients pour obtenir un résultat scalaire. Ici, nous élevons chaque élément au carré et les additionnons, ce qui donne un nombre unique par rapport auquel nous pouvons calculer la dérivée de x.

x = torch.tensor([2.0, 3.0], requires_grad=True)
y = x.pow(2).sum()   # y = x0^2 + x1^2
print(y)             # tensor(13., grad_fn=...)

Appeler backward()

Appelez .backward() sur un scalaire pour calculer les gradients par rétropropagation. PyTorch parcourt à l'envers le graphe enregistré et renseigne automatiquement les dérivées.

y.backward()

Lire .grad

Après backward(), chaque tenseur d'entrée contient son gradient dans .grad. Pour y = sum(x^2), la dérivée est 2x, donc le gradient vaut [4, 6].

print(x.grad)  # tensor([4., 6.])

Les gradients s'accumulent

Un piège subtil : les gradients s'additionnent lors de plusieurs appels à backward(). Dans une boucle d'entraînement, vous devez les mettre à zéro à chaque étape avec x.grad.zero_() ou avec zero_grad() de l'optimiseur.

x.grad.zero_()  # reset before the next backward()

torch.no_grad() pour l'inférence

Pendant l'inférence, les gradients ne sont pas nécessaires et leur suivi gaspille de la mémoire. Encadrez le code de prédiction avec with torch.no_grad(): pour désactiver la construction du graphe et accélérer l'exécution.

with torch.no_grad():
    preds = x.pow(2).sum()
    print(preds.requires_grad)  # False

detach() pour arrêter la propagation des gradients

.detach() renvoie un tenseur qui partage les données, mais qui est retiré du graphe de calcul. Utilisez-le pour exploiter une valeur sans laisser les gradients y remonter, par exemple pour la journalisation ou pour geler une partie du réseau.

z = x.detach()
print(z.requires_grad)  # False

Pourquoi la différentiation automatique est importante

La différentiation automatique est ce qui rend l'apprentissage profond pratique : vous définissez le calcul direct, et PyTorch dérive automatiquement les gradients pour la rétropropagation. Chaque boucle d'entraînement que vous écrivez repose sur requires_grad, backward et .grad.

Vérification rapide

Vérifiez votre compréhension de la différentiation automatique.

Récapitulatif : tenseurs et différentiation automatique

Vous avez créé des tenseurs avec torch.tensor et activé le suivi des gradients via requires_grad=True. Vous avez calculé un résultat, exécuté .backward() et lu les dérivées dans .grad. Vous avez appris que les gradients s'accumulent, utilisé torch.no_grad() pour l'inférence et .detach() pour interrompre la propagation des gradients.

Questions Fréquemment Posées

La leçon « Tenseurs PyTorch et Autograd » est-elle gratuite ?

Oui — le texte complet de « Tenseurs PyTorch et Autograd » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Learn AI with Python, passe à CoddyKit PRO. Le cours Learn AI with Python comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Tenseurs PyTorch et Autograd » ?

torch.Tensor, requires_grad, backward(), calcul des gradients, opérations sur les tenseurs. Tu pratiques Learn AI with Python avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Learn AI with Python ?

Aucune expérience préalable n'est requise. Learn AI with Python sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 4.

Combien de temps prend la leçon « Tenseurs PyTorch et Autograd » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Learn AI with Python ?

Oui. Chaque leçon Learn AI with Python inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Tenseurs PyTorch et Autograd
  2. Jeux de données et DataLoaders personnalisés
  3. Créer et entraîner des CNN avec PyTorch
  4. Détection d’objets avec YOLOv8
← Retour à Learn AI with Python