Installer PyTorch

Ce que vous saurez faire

Faites fonctionner PyTorch, dans Colab ou sur votre ordinateur. Puis vérifiez-le avec une première exécution : vous pouvez comparer chaque nombre affiché avec cette page. Chaque leçon suivante commence ainsi avec une configuration que vous savez fonctionnelle.

Carnet JupyterLa première exécution dans un carnet Jupyter (avec Colab)Colab · Kaggle · GitHub · en anglais

Le carnet (notebook) Jupyter vérifie PyTorch, exécute le code de première exécution de cette leçon et télécharge les billets de soutien avec leurs sommes de contrôle. Il ne nécessite aucune installation. Environ 10 minutes.

Ouvrir dans ColabOuvrir dans KaggleVoir sur GitHub

Le carnet est en anglais. Colab et Kaggle ouvrent votre propre copie. Il faut un compte Google ou Kaggle gratuit. Vous êtes bloqué ? Consultez le carnet de solution.

Avant de commencerCe qu’il faut savoir et avoir sous la mainEnviron 40 minutes

Ce que vous devez savoir

• Les tenseurs, les formes et le type de données float32, présentés dans Tenseurs et formes.
• Pour l’option locale : le terminal et le répertoire de travail, présentés dans Les fichiers et le terminal, et les environnements virtuels, dans Isoler les dépendances du cours Python.

Ce qu’il vous faut sur votre ordinateur

• Pour l’option carnet : un navigateur et un compte Google gratuit (Colab) ou un compte Kaggle.
• Pour l’option locale : Python 3.12 ou plus récent (PyTorch 2.14.1 nécessite la version 3.10 ou plus récente) et VS Code. Il vous faut aussi une connexion Internet et environ 1 Go d’espace disque libre. Le téléchargement fait environ 130 Mo sur macOS et Windows, et environ 200 Mo sur Linux.

Testé avec PyTorch 2.14.1 sur macOS (Apple silicon), avec Python 3.14.6 et 3.12.13. Aussi testé sur Linux (Debian 13, ARM, dans un conteneur) avec Python 3.12.15 et la version pour processeur. Non testés par nous : Windows, Linux sur un processeur Intel ou AMD, et le carnet dans Colab et Kaggle. Nous avons exécuté le carnet dans Jupyter sur macOS. Les commandes pour ces systèmes suivent les instructions de PyTorch.

Vérifier le four avant de cuisiner

Une cuisinière dans une nouvelle cuisine ne commence pas par un souper pour douze invités. D’abord, elle chauffe le four et prépare un plat simple qu’elle connaît bien. Si le résultat est comme d’habitude, le four fonctionne. Sinon, elle le découvre maintenant et a le temps de régler le problème, sans faire attendre les invités.

Le problème : une configuration qui ne fonctionne qu’à moitié

Une configuration PyTorch peut échouer sans signe évident. Python trouve une ancienne version, ou un autre Python que celui où vous avez fait l’installation. Sur Linux, un simple pip install torch télécharge la version pour les cartes graphiques NVIDIA. Le paquet torch seul fait 555 Mo, et ses bibliothèques graphiques ajoutent plus de 1 Go. Même une configuration parfaite affiche des nombres aléatoires différents à chaque exécution. Vous ne pouvez donc pas comparer votre sortie avec cette page :

import torch
print(torch.rand(3))
print(torch.rand(3))

La sortie (vos nombres diffèrent) :

tensor([0.8203, 0.2212, 0.8055])
tensor([0.1816, 0.2661, 0.1560])

torch.rand(3) produit 3 nombres aléatoires entre 0 et 1. Chaque appel donne de nouveaux nombres. Un réseau commence avec des poids aléatoires. Un réseau non entraîné sur votre ordinateur donnerait donc d’autres scores que celui de La propagation avant. Vous ne pourriez pas distinguer un problème de configuration du hasard.

L’idée : une première exécution au résultat connu, avec une graine

Une première exécution au résultat connu utilise un petit programme dont on connaît la sortie exacte à l’avance. Vous l’exécutez une fois, juste après la configuration, et comparez chaque ligne. Si toutes les lignes correspondent, la configuration fonctionne. Si une ligne diffère, vous savez quelle partie corriger avant de commencer le vrai travail.

Pour que les nombres correspondent, les nombres aléatoires doivent se répéter. Les nombres aléatoires d’un ordinateur proviennent d’une recette fixe qui commence par un nombre, la graine. Le nom convient : la même graine donne toujours la même plante. torch.manual_seed(0) fixe la graine à 0. Les nombres aléatoires suivants sont donc toujours les mêmes :

torch.manual_seed(0)
print(torch.rand(3))
torch.manual_seed(0)
print(torch.rand(3))

La sortie :

tensor([0.4963, 0.7682, 0.0885])
tensor([0.4963, 0.7682, 0.0885])

Le même code sans graine et avec une graine. Les nombres sans graine proviennent d'une exécution réelle; les vôtres seront différents.

Description textuelle du diagramme

Le diagramme a deux panneaux. Le panneau de gauche, « No seed » (sans graine), exécute print(torch.rand(3)) deux fois. La première fois donne 0,8203, 0,2212 et 0,8055. La deuxième fois donne 0,1816, 0,2661 et 0,1560. Les nombres sont différents chaque fois. Le panneau de droite, « With a seed » (avec une graine), fixe torch.manual_seed(0) avant chaque print(torch.rand(3)). Les deux fois donnent 0,4963, 0,7682 et 0,0885 : les mêmes nombres chaque fois.

La graine fixe aussi les poids de départ d’un réseau. nn.Linear(3, 2) crée une couche avec 3 entrées et 2 sorties, comme dans Neurones et couches. Ses 6 poids sont aléatoires au départ. Avec la graine 0, ils sont toujours les suivants :

from torch import nn

torch.manual_seed(0)
layer = nn.Linear(3, 2)     # a new layer: 3 inputs, 2 outputs, random starting weights
print(layer.weight)

La sortie :

Parameter containing:
tensor([[-0.0043,  0.3097, -0.4752],
        [-0.4249, -0.2224,  0.1548]], requires_grad=True)

Une graine ne rend pas un résultat meilleur. Elle le rend reproductible, pour vous permettre de comparer et de trouver des bogues. Chaque leçon de ce cours fixe la graine. PyTorch prévient que les nombres aléatoires peuvent tout de même différer selon les versions et le matériel. Nous avons obtenu les mêmes nombres avec la même graine dans PyTorch 2.14.1 sur macOS et Linux.

Deux options permettent d’obtenir une configuration fonctionnelle. Les deux se terminent par la même première exécution.

Deux options, une vérification. Quelle que soit votre option, la première exécution doit afficher les nombres de cette page.

Description textuelle du diagramme

Le diagramme commence par deux cases. La première est un carnet dans Colab ou Kaggle, où PyTorch est déjà installé. La deuxième est votre ordinateur, avec le dossier de projet ticket-router, un environnement virtuel .venv et pip install torch. Les deux cases mènent à une seule case : exécuter le code de première exécution. Ensuite, une question : la sortie est-elle la même que dans la leçon? Si oui, vous êtes prêt pour la prochaine leçon. Sinon, lisez l’erreur, ou réinitialisez la configuration et réessayez; une flèche pointillée revient à la première exécution.

Le programme de première exécution

Voici le programme. Chaque étape suivante l’exécute. Il affiche les versions, un tenseur de forme (2, 3) généré avec une graine et sa somme. Il cherche aussi une carte graphique. torch.cuda.is_available() est vrai quand PyTorch peut utiliser une carte graphique NVIDIA. torch.backends.mps.is_available() est vrai sur un Mac avec Apple silicon.

first_run.py

"""The known-good first run of the deep learning course: versions, device and a seeded tensor."""
import platform

import torch

print("Python ", platform.python_version())
print("PyTorch", torch.__version__)

torch.manual_seed(0)              # the same seed gives the same random numbers
x = torch.rand(2, 3)              # 2 rows, 3 columns, numbers between 0 and 1
print(x)
print("shape", tuple(x.shape), "| dtype", x.dtype, "| device", x.device)
print("sum", round(x.sum().item(), 4))

if torch.cuda.is_available():
    accelerator = "cuda (an NVIDIA graphics card)"
elif torch.backends.mps.is_available():
    accelerator = "mps (an Apple silicon graphics unit)"
else:
    accelerator = "none"
print("accelerator:", accelerator, "| this course uses the CPU")

La sortie, sur un Mac avec Python 3.14.6 :

Python  3.14.6
PyTorch 2.14.1
tensor([[0.4963, 0.7682, 0.0885],
        [0.1320, 0.3074, 0.6341]])
shape (2, 3) | dtype torch.float32 | device cpu
sum 2.4265
accelerator: mps (an Apple silicon graphics unit) | this course uses the CPU

La sortie, sur Linux avec la version pour processeur :

Python  3.12.15
PyTorch 2.14.1+cpu
tensor([[0.4963, 0.7682, 0.0885],
        [0.1320, 0.3074, 0.6341]])
shape (2, 3) | dtype torch.float32 | device cpu
sum 2.4265
accelerator: none | this course uses the CPU

Les lignes 3 à 6 doivent correspondre exactement : le tenseur, sa forme, son type de données, son périphérique et la somme 2,4265. Les autres lignes peuvent différer. Votre version de Python peut être une autre version 3.12 ou plus récente. La version de PyTorch se termine par +cpu sur Windows et Linux. Colab peut avoir une version 2.x plus récente. La ligne de l’accélérateur dépend de votre matériel.

Option 1 : un carnet dans Colab ou Kaggle

Colab et Kaggle exécutent les carnets sur leurs propres ordinateurs, où PyTorch est déjà installé. C’est l’option la plus rapide, et tous les carnets du cours y fonctionnent.

1. Dans l’encadré La première exécution dans un carnet Jupyter en haut de cette page, sélectionnez Open in Colab (ouvrir dans Colab). Connectez-vous avec votre compte Google si Colab le demande.
2. Vérifiez l’environnement d’exécution : Runtime › Change runtime type (exécution › modifier le type d’environnement d’exécution) affiche CPU (processeur). Gardez ce réglage. Le cours ne nécessite pas de carte graphique.
3. Exécutez la première cellule de code avec Shift+Enter (Maj+Entrée). Vous voyez une ligne qui commence par PyTorch 2. et se termine par device cpu (périphérique processeur).
4. Exécutez les deux cellules de configuration suivantes. La cellule de données se termine par Ready: train 4696 tickets, valid 600, test 600. (prêt : 4 696 billets d’entraînement, 600 de validation, 600 de test). La cellule des fonctions auxiliaires n’affiche rien.
5. Exécutez la cellule de première exécution dans la section 1. Comparez les lignes 3 à 6 avec la sortie ci-dessus. La cellule de vérification en dessous affiche Check passed (vérification réussie).

Dans Kaggle, sélectionnez plutôt Open in Kaggle (ouvrir dans Kaggle). Activez Internet dans les paramètres du carnet avant l’étape 4; Kaggle exige un numéro de téléphone vérifié pour cela. Votre copie du carnet est privée, et vos modifications restent dans votre compte.

Option 2 : votre ordinateur

Travaillez sur votre ordinateur pour conserver les fichiers entre les sessions ou travailler sans navigateur. Le code du cours fonctionne sur tout ordinateur portable ordinaire.

Créer le dossier de projet et l’environnement

1. Ouvrez un terminal. Vérifiez la version de Python :

   macOS

   python3 --version

   Windows

   python --version

   Linux

   python3 --version

   Vous voyez Python 3.12 ou un numéro plus élevé. Si vous voyez 3.11 ou moins, ou « command not found » (commande introuvable), installez Python selon Installer et vérifier Python.

2. Créez le dossier ticket-router et placez-vous dedans :

   macOS

   mkdir -p ~/projects/ticket-router
   cd ~/projects/ticket-router

   Windows

   mkdir ~\projects\ticket-router
   cd ~\projects\ticket-router

   Linux

   mkdir -p ~/projects/ticket-router
   cd ~/projects/ticket-router

3. Créez l’environnement virtuel, puis activez-le :

   macOS

   python3 -m venv .venv
   source .venv/bin/activate

   Windows

   python -m venv .venv
   .venv\Scripts\Activate.ps1

   Si PowerShell indique que l’exécution des scripts est désactivée, consultez l’erreur courante sur Windows dans Isoler les dépendances.

   Linux

   python3 -m venv .venv
   source .venv/bin/activate

   Si la sortie indique que ensurepip n’est pas disponible, exécutez d’abord sudo apt install python3-venv.

4. Vérifiez que l’invite de commande commence par (.venv). Désormais, tapez python sur tous les systèmes.

Exécutez toutes les commandes de ce cours dans ce dossier, avec l’environnement actif.

Installer PyTorch

Attention

Sur Windows et Linux, utilisez la commande avec --index-url. Elle récupère la version pour processeur de PyTorch sur le serveur de paquets de PyTorch. Sans cette option, pip sur Linux télécharge la version pour cartes graphiques NVIDIA : plus de 1,5 Go plutôt qu’environ 200 Mo.

1. Installez PyTorch :

   macOS

   python -m pip install torch==2.14.1

   Windows

   python -m pip install torch==2.14.1 --index-url https://download.pytorch.org/whl/cpu

   Linux

   python -m pip install torch==2.14.1 --index-url https://download.pytorch.org/whl/cpu

   Cela prend une ou deux minutes. ==2.14.1 demande la version exacte testée pour le cours.

2. Installez NumPy, pandas et ipykernel pour les carnets dans VS Code. Les cellules de vérification des carnets du cours utilisent pandas.

   python -m pip install numpy==2.5.3 pandas==3.0.6 ipykernel

3. Enregistrez les versions, comme dans Isoler les dépendances :

   python -m pip freeze > requirements-lock.txt

   Le fichier liste environ 40 paquets, dont torch==2.14.1 (torch==2.14.1+cpu sur Windows et Linux) et numpy==2.5.3.

Faire la première exécution

1. Dans VS Code, ouvrez le dossier ticket-router (File › Open Folder, fichier › ouvrir un dossier).

2. Créez un fichier first_run.py et copiez-y le programme ci-dessus. Enregistrez-le.

3. Dans le terminal, exécutez-le :

   python first_run.py

4. Comparez les lignes 3 à 6 avec la sortie ci-dessus : le tenseur, shape (2, 3) | dtype torch.float32 | device cpu (forme, type de données et périphérique) et sum 2.4265 (somme).

Récupérer les billets

La prochaine leçon lit les billets de Larkfield. Le script get_data.py les télécharge avec le fichier ticketnet.py du cours et vérifie la somme de contrôle de chaque fichier. Il utilise seulement la bibliothèque standard de Python.

1. Téléchargez le script dans le dossier de projet :

   macOS

   curl -fsSL -O https://raw.githubusercontent.com/Nextia-Intelligence/nextia-learning-labs/main/C06/get_data.py

   Windows

   curl.exe -fsSL -O https://raw.githubusercontent.com/Nextia-Intelligence/nextia-learning-labs/main/C06/get_data.py

   Tapez curl.exe, pas curl. Dans Windows PowerShell, curl est une autre commande.

   Linux

   curl -fsSL -O https://raw.githubusercontent.com/Nextia-Intelligence/nextia-learning-labs/main/C06/get_data.py

2. Exécutez-le :

   python get_data.py

   La sortie :

   Downloaded data/train.csv
   Downloaded data/valid.csv
   Downloaded data/test.csv
   Downloaded data/split_manifest.json
   Downloaded ticketnet.py
   Ready: train 4696 tickets, valid 600, test 600.

3. Exécutez-le une deuxième fois. Il affiche seulement la ligne Ready: (prêt), car tous les fichiers sont présents et corrects.

Le dossier contient maintenant .venv/, requirements-lock.txt, first_run.py, get_data.py, ticketnet.py et data/ avec trois fichiers CSV et split_manifest.json. Pour utiliser les carnets dans VS Code, sélectionnez le noyau .venv, comme dans Ouvrir un carnet dans VS Code du cours d’apprentissage automatique.

Facultatif : une carte graphique

Une carte graphique effectue de nombreuses multiplications en même temps. Elle entraîne donc les grands réseaux beaucoup plus vite. Les réseaux de ce cours sont petits et s’entraînent en quelques secondes ou minutes sur un processeur. Tous les nombres de ce cours proviennent donc d’un processeur, et vous n’avez pas besoin de carte graphique. Une carte graphique donne aussi des décimales légèrement différentes. Vos résultats ne correspondraient donc pas exactement à cette page.

Pour en essayer une plus tard, la méthode habituelle choisit le périphérique une fois. Elle y déplace ensuite les tenseurs (et le réseau) avec .to(device) :

device = "cuda" if torch.cuda.is_available() else "cpu"
x = torch.rand(2, 3).to(device)
print(x.device)

La sortie, sur un ordinateur sans carte graphique NVIDIA :

cpu

Sur un Mac, le périphérique "mps" fonctionne de la même façon. Tous les tenseurs d’une opération doivent se trouver sur le même périphérique. Voici ce qui arrive sur un Mac lorsqu’un tenseur sur l’unité graphique rencontre un tenseur sur le processeur :

on_gpu = torch.ones(3, device="mps")
on_cpu = torch.ones(3)
print(on_gpu + on_cpu)

La sortie :

RuntimeError: Expected all tensors to be on the same device, but found at least two devices, mps:0 and cpu!

on_gpu.to("cpu") + on_cpu fonctionne et donne tensor([2., 2., 2.]). Dans Colab, Runtime › Change runtime type propose une carte graphique, gratuite avec des limites de temps. Nous n’avons pas testé le cours dessus.

Réinitialiser la configuration

Pour revenir à un état connu :

• Colab ou Kaggle : dans Colab, sélectionnez Runtime › Disconnect and delete runtime (exécution › déconnecter et supprimer l’environnement d’exécution). Dans Kaggle, arrêtez la session et redémarrez-la. Puis exécutez de nouveau les cellules depuis le début.
• L’environnement : exécutez deactivate, supprimez le dossier .venv, puis reprenez Créer le dossier de projet et l’environnement à l’étape 3, et refaites Installer PyTorch.
• Les données et ticketnet.py : exécutez python get_data.py --reset. Cette commande supprime data/ et ticketnet.py et les télécharge de nouveau. La dernière ligne est la ligne Ready:.

Après une réinitialisation, exécutez de nouveau python first_run.py et comparez.

Exercice guidé : votre première exécution

1. Choisissez votre option : le carnet ou votre ordinateur.
2. Faites toutes les étapes de cette option.
3. Faites la première exécution. Notez la somme affichée.
4. Notez votre version de Python, votre version de PyTorch et la ligne de l’accélérateur.
5. Récupérez les billets. Vérifiez la ligne Ready:.

Afficher un exemple de résultat correct

La somme est sum 2.4265, et le tenseur est exactement [[0.4963, 0.7682, 0.0885], [0.1320, 0.3074, 0.6341]]. La version de Python est 3.12 ou plus récente, et celle de PyTorch commence par 2. (2.14.1 sur votre ordinateur). La ligne de l’accélérateur indique none (aucun) sur la plupart des portables Windows et Linux et dans un environnement Colab pour processeur. Elle indique mps sur un Mac avec Apple silicon. La ligne des données est Ready: train 4696 tickets, valid 600, test 600. Si tout correspond, votre configuration est bonne.

À vous de jouer : une autre graine

Changez une seule chose dans first_run.py : torch.manual_seed(0) devient torch.manual_seed(1). Avant de l’exécuter, prédisez : le tenseur sera-t-il le même qu’avant? Deux exécutions avec la graine 1 donneront-elles les mêmes nombres? Puis exécutez-le deux fois.

Afficher la réponse

tensor([[0.7576, 0.2793, 0.4031],
        [0.7347, 0.0293, 0.7999]])
shape (2, 3) | dtype torch.float32 | device cpu
sum 3.0038

Les nombres diffèrent de ceux de la graine 0. Ils sont identiques dans les deux exécutions avec la graine 1. Chaque graine démarre sa propre séquence fixe de nombres aléatoires. Donc, « fixer une graine » ne suffit pas dans un rapport : précisez laquelle. Ce cours utilise toujours la graine 0. Remettez-la avant la prochaine leçon.

Erreur courante

No module named 'torch' (aucun module nommé 'torch')

Symptôme : vous avez installé PyTorch, mais first_run.py s’arrête à sa première importation :

Traceback (most recent call last):
  File "/Users/amira/projects/ticket-router/first_run.py", line 4, in <module>
    import torch
ModuleNotFoundError: No module named 'torch'

Cause : le script utilise un Python qui n’a pas PyTorch. Généralement, l’environnement n’est pas actif dans ce terminal. Un nouveau terminal démarre sans lui, et l’invite de commande n’affiche pas (.venv). Dans VS Code, le bouton Run (exécuter) peut aussi utiliser un autre interpréteur que le terminal.

Solution :

1. Vérifiez quel Python s’exécute : python -c "import sys; print(sys.executable)".
2. Si le chemin n’est pas dans ticket-router/.venv, activez l’environnement et exécutez de nouveau le script.
3. Si le chemin est correct, PyTorch n’est pas dans cet environnement. Refaites Installer PyTorch.
4. Dans VS Code, sélectionnez l’interpréteur .venv, comme dans Isoler les dépendances.

Ce que cela signifie pour le travail réel en IA : la plupart des problèmes « ça ne fonctionne pas sur mon ordinateur » viennent d’un autre interpréteur ou d’une autre version de paquet. Une première exécution qui affiche les versions les repère en quelques secondes.

Vérification des connaissances

Vérifiez votre compréhension

Pourquoi chaque leçon de ce cours fixe-t-elle une graine aléatoire? Que ne fait pas une graine?

Afficher la réponse

Un réseau commence avec des poids aléatoires, et d’autres étapes utilisent aussi des nombres aléatoires. Avec une graine, les nombres aléatoires se répètent. Votre exécution donne donc les mêmes nombres que la leçon. Une différence indique alors une différence réelle, comme un bogue ou une autre configuration, et non le hasard. Une graine ne rend pas un résultat meilleur ni plus juste. Elle le rend seulement reproductible. C’est aussi un choix parmi plusieurs : une autre graine donne d’autres nombres. Un rapport devrait donc préciser la graine.

Vérifiez votre compréhension

Votre première exécution affiche PyTorch 2.14.1+cpu et accelerator : none, mais une somme de 2,4265 et le même tenseur que cette page. L'exécution d'un ami affiche PyTorch 2.14.1 et accelerator : mps. Une des configurations est-elle incorrecte?

Afficher la réponse

Non. Les deux conviennent. Les éléments qui doivent correspondre sont le tenseur produit avec la graine, sa forme, son type et son périphérique. La somme doit aussi être 2,4265. +cpu indique seulement que vous avez installé la version pour processeur depuis le serveur de PyTorch. C’est le bon choix sur Windows et Linux. La ligne de l’accélérateur dépend du matériel : votre ami utilise un Mac avec une puce Apple. Le cours utilise le processeur sur les deux ordinateurs. Les deux obtiennent donc les mêmes nombres.

Vérifiez votre compréhension

Tomás exécute pip install torch sur un portable Linux. Le téléchargement dépasse 1,5 Go et prend beaucoup de temps. Que s'est-il passé, et que devrait-il exécuter à la place?

Afficher la réponse

Sur Linux, le paquet standard de PyTorch est conçu pour les cartes graphiques NVIDIA. pip télécharge le paquet torch (555 Mo) et les bibliothèques graphiques nécessaires, soit plus de 1,5 Go au total. Le cours utilise le processeur, donc il n’en a pas besoin. Il devrait supprimer l’environnement, le recréer, puis exécuter python -m pip install torch==2.14.1 --index-url https://download.pytorch.org/whl/cpu. Cette commande télécharge la version pour processeur, soit environ 200 Mo.

Récapitulatif

• Une première exécution au résultat vérifié utilise un petit programme dont on connaît la sortie. Exécutez-le après chaque installation et chaque réinitialisation, puis comparez les résultats ligne par ligne.
• Une graine aléatoire fait se répéter les nombres aléatoires. torch.manual_seed(0) suivi de torch.rand(2, 3) donne un tenseur dont la somme est 2,4265. La graine fixe aussi les poids de départ d’un nouveau réseau.
• Colab ou Kaggle : PyTorch est déjà installé; ouvrez le carnet (notebook) Jupyter et exécutez-le. Votre ordinateur : ticket-router avec .venv, puis pip install torch==2.14.1 (avec le --index-url pour processeur sur Windows et Linux), numpy==2.5.3, pandas==3.0.6 et ipykernel.
• get_data.py télécharge les billets de soutien et ticketnet.py, les vérifie, puis termine avec Ready: train 4696 tickets, valid 600, test 600. (prêt : 4 696 billets d’entraînement, 600 de validation, 600 de test).
• Une carte graphique est facultative. Détectez-la avec torch.cuda.is_available() ou torch.backends.mps.is_available(); tous les nombres de ce cours sont obtenus avec le processeur.
• Réinitialisation : supprimez .venv et recréez-le, ou exécutez python get_data.py --reset, puis relancez la première exécution.

Ensuite, vous transformerez les billets de Larkfield en tenseurs et les ferez passer dans un premier réseau.

Leçon suivante : La propagation avant