1
00:00:05,430 --> 00:00:07,240
Écrivez votre propre boucle d'entraînement dans PyTorch.

2
00:00:07,240 --> 00:00:11,759
Dans cette vidéo, nous verrons comment nous pouvons faire le même finetuning que dans la

3
00:00:11,759 --> 00:00:14,120
vidéo sur l'API Trainer, mais sans compter sur cette classe.

4
00:00:14,120 --> 00:00:20,369
De cette façon, vous pourrez facilement personnaliser chaque étape de la boucle d'entraînement en fonction de vos besoins.

5
00:00:20,369 --> 00:00:23,859
Ceci est également très utile pour déboguer manuellement quelque chose qui n'allait pas avec l'

6
00:00:23,859 --> 00:00:26,189
API Trainer.

7
00:00:26,189 --> 00:00:31,200
Avant de nous plonger dans le code, voici une esquisse d'une boucle d'entraînement : nous prenons un batch de

8
00:00:31,200 --> 00:00:33,469
données d'entraînement et le transmettons au modèle.

9
00:00:33,469 --> 00:00:36,600
Avec les étiquettes, nous pouvons alors calculer une perte.

10
00:00:36,600 --> 00:00:41,130
Ce nombre n'est pas utile en soi, mais est utilisé pour calculer les gradients de nos

11
00:00:41,130 --> 00:00:46,750
poids de modèle, c'est-à-dire la dérivée de la perte par rapport à chaque poids de modèle.

12
00:00:46,750 --> 00:00:51,920
Ces gradients sont ensuite utilisés par l'optimiseur pour mettre à jour les poids du modèle et les

13
00:00:51,920 --> 00:00:53,360
améliorer un peu.

14
00:00:53,360 --> 00:00:56,170
Nous répétons ensuite le processus avec un nouveau batch de données d'apprentissage.

15
00:00:56,170 --> 00:01:00,969
Si tout cela n'est pas clair, n'hésitez pas à reprendre votre

16
00:01:00,969 --> 00:01:02,240
cours d'apprentissage profond préféré.

17
00:01:02,240 --> 00:01:07,560
Nous utiliserons à nouveau le jeu de données GLUE MRPC, et nous avons vu comment prétraiter les données

18
00:01:07,560 --> 00:01:10,439
à l'aide de la bibliothèque Datasets avec le rembourrage dynamique.

19
00:01:10,439 --> 00:01:15,549
Découvrez les vidéos liées ci-dessous si vous ne les avez pas déjà vues.

20
00:01:15,549 --> 00:01:20,060
Cela fait, nous n'avons plus qu'à définir les DataLoaders PyTorch, qui seront chargés de

21
00:01:20,060 --> 00:01:24,480
convertir les éléments de notre jeu de données en batchs.

22
00:01:24,480 --> 00:01:33,890
Nous utilisons notre `DataCollatorForPadding` comme fonction d'assemblement et mélangeons l'ensemble d'entraînementpour s'assurer que nous voyons pas tous les échantillons dans le même ordre.

23
00:01:33,890 --> 00:01:39,460
Pour vérifier que tout fonctionne comme prévu, nous essayons de récupérer un batch de données et de l'

24
00:01:39,460 --> 00:01:40,460
inspecter.

25
00:01:40,460 --> 00:01:44,790
Comme nos éléments de jeu de données, c'est un dictionnaire, mais cette fois les valeurs ne sont pas une seule

26
00:01:44,790 --> 00:01:50,460
liste d'entiers, mais un tenseur de forme de taille de batch par longueur de séquence.

27
00:01:50,460 --> 00:01:52,869
L'étape suivante consiste à envoyer les données d'entraînement dans notre modèle.

28
00:01:52,869 --> 00:01:56,790
Pour cela, nous devrons créer notre modèle.

29
00:01:56,790 --> 00:02:01,240
Comme on l'a vu dans la vidéo sur l'API des modèles, nous utilisons la méthode `from_pretrained` et ajustons le nombre

30
00:02:01,240 --> 00:02:06,159
d'étiquettes au nombre de classes que nous avons sur cet jeu de données, ici deux.

31
00:02:06,159 --> 00:02:11,020
Encore une fois, pour être sûr que tout se passe bien, nous passons le batch que nous avons saisi à notre modèle

32
00:02:11,020 --> 00:02:12,640
et vérifions qu'il n'y a pas d'erreur.

33
00:02:12,640 --> 00:02:17,780
Si les étiquettes sont fournies, les modèles de la bibliothèque Transformers renvoient toujours

34
00:02:17,780 --> 00:02:18,840
directement la perte.

35
00:02:18,840 --> 00:02:24,129
Nous pourrons faire `loss.backward()` pour calculer tous les gradients, et nous aurons alors besoin d'un optimiseur

36
00:02:24,129 --> 00:02:26,480
pour faire l'étape d'apprentissage.

37
00:02:26,480 --> 00:02:30,800
Nous utilisons ici l'optimiseur AdamW, qui est une variante d'Adam avec une décroissance de poids appropriée,

38
00:02:30,800 --> 00:02:35,040
mais vous pouvez choisir n'importe quel optimiseur PyTorch que vous aimez.

39
00:02:35,040 --> 00:02:39,519
En utilisant la perte précédente et en calculant les gradients avec `loss.backward()`, nous vérifions que

40
00:02:39,519 --> 00:02:43,510
nous pouvons faire l'étape d'optimisation sans aucune erreur.

41
00:02:43,510 --> 00:02:47,580
N'oubliez pas de mettre `zero_grad()` par la suite, sinon à l'étape suivante, ils seront ajoutés

42
00:02:47,580 --> 00:02:49,659
aux gradients que vous calculez !

43
00:02:49,659 --> 00:02:53,620
Nous pourrions déjà écrire notre boucle d'entraînement, mais nous ajouterons deux autres choses pour la rendre

44
00:02:53,620 --> 00:02:55,590
aussi bonne que possible.

45
00:02:55,590 --> 00:03:01,150
Le premier est un planificateur de taux d'apprentissage, pour réduire progressivement notre taux d'apprentissage à

46
00:03:01,150 --> 00:03:02,150
0.

47
00:03:02,150 --> 00:03:06,180
La fonction `get_scheduler` de la bibliothèque Transformers n'est qu'une fonction pratique pour

48
00:03:06,180 --> 00:03:12,760
créer facilement un tel planificateur0 Vous pouvez à nouveau utiliser n'importe quel planificateur de taux d'apprentissage PyTorch à la place.

49
00:03:12,760 --> 00:03:17,299
Enfin, si nous voulons que notre entraînement prenne quelques minutes au lieu de quelques heures,

50
00:03:17,299 --> 00:03:19,580
nous devrons utiliser un GPU.

51
00:03:19,580 --> 00:03:24,340
La première étape consiste à en obtenir un, par exemple en utilisant un notebook Colab.

52
00:03:24,340 --> 00:03:29,090
Ensuite, vous devez réellement envoyer votre modèle et les données d'entraînement à l'aide d'un appareil Torch.

53
00:03:29,090 --> 00:03:35,659
Vérifiez les lignes suivantes pour avoir un appareil CUDA ou préparez vous à ce que votre entraînement dure plus d'une heure.

54
00:03:35,659 --> 00:03:38,450
Nous pouvons maintenant tout assembler !

55
00:03:38,450 --> 00:03:42,470
Nous mettons d'abord notre modèle en mode d'entraînement (ce qui activera le comportement d'entraînement pour certaines

56
00:03:42,470 --> 00:03:47,900
couches comme la Dropout), puis parcourons le nombre d'époques que nous avons sélectionnées et toutes les données dans

57
00:03:47,900 --> 00:03:50,130
notre chargeur de données d'entraînement.

58
00:03:50,130 --> 00:03:54,560
Ensuite, nous passons par toutes les étapes que nous avons déjà vues : envoyer les données au GPU, calculer

59
00:03:54,560 --> 00:03:57,870
les sorties du modèle, et en particulier la perte.

60
00:03:57,870 --> 00:04:02,040
Utilisez la perte pour calculer les gradients, puis effectuez une étape d'apprentissage avec l'optimiseur.

61
00:04:02,040 --> 00:04:06,760
Mettez à jour le taux d'apprentissage dans notre planificateur pour la prochaine itération et mettez à 0 les gradients

62
00:04:06,760 --> 00:04:09,340
de l'optimiseur.

63
00:04:09,340 --> 00:04:13,590
Une fois cela terminé, nous pouvons évaluer notre modèle très facilement avec une métrique de la

64
00:04:13,590 --> 00:04:14,730
bibliothèque Datasets.

65
00:04:14,730 --> 00:04:22,470
Nous mettons d'abord notre modèle en mode d'évaluation, puis parcourons toutes les données dans le

66
00:04:22,470 --> 00:04:23,900
chargeur de données d'évaluation.

67
00:04:23,900 --> 00:04:27,480
Comme nous l'avons vu dans la vidéo sur l'API Trainer, le modèle génère des logits et nous devons appliquer

68
00:04:27,480 --> 00:04:31,350
la fonction argmax pour les convertir en prédictions.

69
00:04:31,350 --> 00:04:36,910
L'objet `metric` a alors une méthode `add_batch` que nous pouvons utiliser pour lui envoyer ces prédictions intermédiaires.

70
00:04:36,910 --> 00:04:40,590
Une fois la boucle d'évaluation terminée, nous n'avons plus qu'à appeler la méthode de calcul pour obtenir nos

71
00:04:40,590 --> 00:04:41,620
résultats finaux !

72
00:04:41,620 --> 00:04:50,760
Félicitations, vous avez maintenant finetuné un modèle tout seul !