Regressão avançada de processamento de linguagem natural 2024

1. Introduction: En quoi consiste exactement le traitement du langage naturel ? En termes simples, la PNL est un domaine de l' intelligence artificielle qui permet aux ordinateurs de comprendre, interpréter et de générer le langage humain Pensez à la PNL comme au processus de transformation du langage naturel en coordonnées Pour le dire plus simplement, cela nous permet de représenter le texte sous forme de points dans un espace de coordonnées. C'est un peu comme un emplacement sur une carte. Une fois que nous avons ces coordonnées, nous pouvons effectuer différents types de processus et d'analyses mathématiques. L'intelligence artificielle peut être divisée en deux grandes catégories. La première catégorie est la régression. La régression est une technique statistique utilisée pour modéliser et prévoir les relations entre les variables. En d'autres termes, la régression est un moyen de déterminer la distribution des données. Il s'agit de trouver la forme et modèle d'une grande quantité de données. La deuxième catégorie est la classification, qui est liée à la régression, mais implique la conversion valeurs numériques en types catégoriques Pour l'instant, concentrons-nous sur la régression. En NLP, la régression consiste transformer le texte en coordonnées, puis à identifier la distribution de ces coordonnées Il s'agit de convertir des données textuelles en valeurs numériques et d'analyser les tendances de ces chiffres. Maintenant, comment appliquer cette méthode dans le monde réel ? Nous pouvons l'utiliser pour prédire le succès des romans ou des scénarios de films. Analysez les paroles des chansons pour déterminer si elles seront des succès, trouvez les scores d'opinion issus des publications sur les réseaux sociaux, évaluez la satisfaction du produit à partir des données d'évaluation et identifiez même des articles de recherche similaires en fonction de leur contenu. Le thème commun de ces exemples est l'utilisation du texte pour trouver des valeurs numériques, et cette méthode peut être appliquée dans toutes les situations où nous devons dériver des nombres à partir de texte. Dans cette vidéo, nous allons démontrer cette technique à l'aide des données d'évaluation des restaurants. Nous trouverons les numéros souhaités dans les avis. Grâce aux progrès de l'intelligence artificielle, PNL a également réalisé des progrès importants Auparavant, la transformation du texte en valeurs numériques était une tâche difficile en raison des nombreuses combinaisons dans lesquelles le texte peut être formé. La même idée ou le même contenu peuvent être exprimés d'innombrables manières. Cependant, avec des modèles d'apprentissage profond tels que RNN, GRU, LSTM et le modèle de transformateur, nous avons commencé à quantifier le nous avons commencé à Grâce à ces modèles, le texte peut désormais être représenté sous forme de coordonnées. C'est là que le concept de régression devient crucial. En identifiant la distribution des données, nous pouvons déterminer des valeurs numériques même à partir de nouvelles données invisibles J'espère que cela vous permettra de bien comprendre comment la PNL et la régression fonctionnent ensemble Permettez-moi de vous montrer une démonstration avec ces données d' évaluation des restaurants. 2. Importer des paquets et des setups: Lorsque vous démarrez Jupiter lab, vous verrez cet écran. Cliquez sur ce bouton de bloc-notes en Python pour créer un nouveau bloc-notes. Maintenant, un nouveau bloc-notes a été créé. Définissons le nom de ce carnet en carnet d'entraînement. Le nom de l'onglet deviendra «   train notebook » en conséquence. Nous pouvons ensuite procéder à l'importation des packages nécessaires. Permettez-moi de vous expliquer brièvement les utilisations de ces packages. Le système d'exploitation est utilisé pour configurer le tokenizer. GC permet d'effacer la mémoire du GPU, et la date, l'heure et les mathématiques servent à créer des noms de fichiers Job lib est utilisé au cas où nous aurions besoin d'enregistrer des fichiers dans ce format. Le hasard est nécessaire pour définir une valeur initiale fixe pour les opérations aléatoires. Le temps est utilisé pour imprimer les journaux pendant l'entraînement du modèle, et les avertissements nous aident à supprimer messages d'avertissement qui n'ont pas impact significatif sur l'exécution normale. Ensuite, nous utiliserons spe num, Pi et Pandas pour les calculs de base et le traitement des données CSV TQ DM est un excellent outil pour montrer les progrès, nous allons donc également l'importer Nous utiliserons Psychic Learn pour gérer les fonctions nécessaires l'évaluation des métriques des données de test et à la validation croisée avec des plis. Ensuite, nous avons chargé les packages relatifs aux transformateurs de torche et aux tokeniseurs Ces bibliothèques sont très importantes pour exécuter le code Assurez-vous donc que les versions correspondent celles fournies dans le fichier Yamel Enfin, le codec, le text Unit Tuple et R sont des packages utilisés pour le prétraitement des données Les versions du transformateur et du tokenizer étant importantes, nous inclurons du code pour vérifier les De plus, nous allons définir une variable d'environnement pour activer le traitement parallèle pour le tokenizer, ce qui permettra au processus de tokenisation de s' Ensuite, nous allons écrire le code pour configurer les paramètres requis pour le modèle. L'utilisation d'un tel fichier de configuration présente de nombreux avantages. Le principal avantage est qu' il vous permet de modifier tous les paramètres nécessaires construction du modèle d'IA en un seul endroit. Lors du réglage du modèle, vous pouvez simplement ajuster cette partie et tester le modèle, c'est pourquoi il est avantageux d'écrire le code de cette manière. Les variables qui entrent dans ces paramètres de configuration doivent généralement être définies une par une dans la classe lorsque vous écrivez le code. Par conséquent, vous pouvez simplement revoir brièvement les valeurs de configuration et passer à autre chose. Il est pratique de gérer les résultats de l'entraînement du modèle s'ils sont stockés dans un dossier spécifique C'est pourquoi j'ai ajouté une valeur de configuration telle que S tier à présent. Comme le modèle est enregistré avec des horodatages, il devient plus facile de gérer les modèles enregistrés. De plus, les valeurs de configuration du train et du débogage sont utiles pour tester le code sans exécuter l'intégralité du processus et sont pratiques lors de l' écriture de code d'inférence Ensuite, nous configurons des paramètres tels que l'emplacement des données d'entraînement, l'emplacement des données de test, le modèle à entraîner et les paramètres associés. Dans cette vidéo, puisque nous allons utiliser des techniques de regroupement, nous allons spécifier la méthode de regroupement à utiliser ainsi que les paramètres associés. En outre, nous allons configurer des paramètres qui permettent gérer efficacement la mémoire pendant l'entraînement des modèles. Paramètres liés au taux d'apprentissage, au nom de la colonne cible, valeurs de départ pour la génération de nombres aléatoires, aux valeurs liées à la validation croisée, ainsi qu'à la taille du lot et à la configuration du GPU. Passons maintenant au code. Commençons par définir la graine. Sd est utilisé pour fixer des valeurs aléatoires. Créons une fonction pour corriger la graine. Nous appellerons cette fonction seed everything. Cette fonction prendra un paramètre appelé Sd et sa valeur par défaut est 42. Nous allons d'abord appliquer cette graine au module aléatoire. Ensuite, nous allons modifier la graine de hachage du système d'exploitation Python. Comme cela nécessite une entrée de chaîne, nous allons convertir la graine en chaîne avant de la définir. Ensuite, nous allons définir la graine aléatoire pour Numpi. Ensuite, nous traiterons les étuis pour la torche séparément. Nous allons écrire du code pour corriger le point de départ aléatoire pour Torch, Torch GPU et CU DNN. La raison de la fixation de ces valeurs aléatoires est d'obtenir des résultats cohérents lors de l'entraînement du modèle. Lors de l'entraînement d'un modèle, de nombreux facteurs aléatoires entrent en jeu, ce qui peut entraîner une fluctuation des indicateurs de performance Par exemple, si vous essayez d' améliorer le modèle à l'aide d'une certaine méthode, mais que les indicateurs d'évaluation ne cessent de changer, vous ne saurez pas si le changement est dû à votre méthode ou simplement au hasard. donc essentiel de fixer des valeurs aléatoires est donc essentiel de fixer des valeurs aléatoires pour éviter cette confusion. 3. Charger les données et le prétraitement: Nous allons charger le fichier CSV du train. Ensuite, nous imprimerons son contenu. Les données se composent de huit colonnes. Mais pour cette vidéo, nous allons nous concentrer sur les colonnes d'évaluation et de notation. La colonne d'évaluation contient des données textuelles rédigées par les utilisateurs, tandis que la colonne d' évaluation contient les valeurs numériques correspondantes. Nous pouvons également constater que les données du test ont la même structure que l'entraînement. Nous utiliserons le texte de ce test pour créer un modèle qui prédit la note. Lorsque vous utilisez du texte, des problèmes d'encodage peuvent parfois survenir. Pour traiter ces problèmes à l'avance, nous allons définir quelques fonctions. Créons une fonction pour gérer les erreurs d'encodage. Cette fonction prend comme argument une erreur Unicode, qui contient des informations sur l'erreur survenue lors du codage. L'essentiel est d'extraire la chaîne problématique de l'objet d'erreur Ensuite, il encode cette chaîne en UTF huit. Nous utiliserons cette fonction lorsque nous devrons convertir des caractères spécifiques en UTF huit pendant le processus de codage La deuxième fonction gérera les erreurs de décodage. De même, il prend également une erreur Unicode comme argument. Tout comme la fonction d'encodage, elle récupère la chaîne de l'objet d'erreur, mais cette fois, elle la décode à l'aide du CP 12 52 Cette fonction sera utilisée lorsque des caractères spécifiques doivent être interprétés comme CP 12 52 pendant le processus de décodage Voyons comment utiliser les deux fonctions dont nous venons de parler. Cette fois, nous utiliserons la fonction d' enregistrement des erreurs du module Code pour enregistrer les gestionnaires d'erreurs que nous avons définis Laisse-moi te le décomposer. Le package Codex est utilisé en Python pour gérer l' encodage et le décodage La fonction register error est utilisée pour enregistrer un nouveau gestionnaire d'erreurs et prend deux paramètres Le premier paramètre est une chaîne qui indique le nom du gestionnaire d'erreurs, et le second est la fonction à appeler en cas d'erreur Une fois que nous avons enregistré ces deux gestionnaires d'erreurs, nous pouvons appeler les fonctions que nous avons définies précédemment chaque fois qu'une erreur survient lors de l'encodage ou du décodage Il est temps d'examiner une fonction qui utilise réellement les gestionnaires d'erreurs que nous avons enregistrés Cette fonction s'appelle résoudre les encodages et normaliser. Son rôle est de normaliser le texte par le biais multiples processus d'encodage et de décodage Passons en revue le code ensemble pour voir ce qui se passe étape par étape. Tout d'abord, il convertit le texte en une séquence d'octets en utilisant le codage d'échappement Unicode brut. Raw Unicode Escape code les caractères Unicode sous forme de séquences d'échappement Ensuite, il décode les octets codés en UTF huit. Si une erreur se produit au cours de ce processus, notre gestionnaire d'erreurs enregistré utilise décodage remplacé par le CP 12 f two pour résoudre le problème Cela permet de résoudre les problèmes rencontrés lors du codage UTF huit en les décodant avec CP 12 f two. Ensuite, le texte maintenant décodé en UTF huit est réencodé en CP 252 Si une erreur se produit à ce stade, il utilise le codage de remplacement avec le gestionnaire d'erreurs UTF huit Ici, les caractères qui ne peuvent pas être codés en C deux sont convertis en UTF huit Enfin, les deux cent 52 octets codés par CP sont décodés en huit UTF. Dans la dernière étape, il utilise la fonction Uni Dcde pour générer la chaîne Lorsque vous utilisez du texte, des problèmes d'encodage peuvent parfois survenir. Pour résoudre ces problèmes à l'avance, nous allons définir quelques fonctions. La principale fonction que nous utiliserons est résoudre les encodages et de les normaliser Pour cette fonction, nous avons défini deux fonctions d'assistance. L'un change les parties problématiques en UTF huit, et l'autre convertit ces parties en CP 12 52 Tout d'abord, nous convertissons le texte en Unicode. Au cours de ce processus, il se peut que la conversion en nœud échoue dans certains cas . Pour gérer cela, nous convertissons toutes les erreurs en CP 12 52 lors de la retransformation du texte. Utilisez CP 12 52 car il s'agit de la méthode de codage utilisée par le système d'exploitation Windows. De nombreux textes sont écrits dans le CP 12 52. Ensuite, nous réencodons le texte entier en CP 12 52, puis nous le convertissons en UTF huit Cette étape permet de s'assurer que le texte est principalement aligné sur l'UTF huit Enfin, lorsque nous décodons le texte en Unicode, nous pouvons constater qu'il a été soigneusement prétraité Examinons un exemple de texte présentant des problèmes d' encodage pour voir comment fonctionne cette fonction. Tout d'abord, nous allons encoder ce texte à l'aide d' échappement Unicode brut et imprimer le résultat Vous devriez pouvoir voir le texte transformé en séquence d'octets. Nous allons décoder le texte transformé en UTF huit et l'imprimer En cas d'erreur, les caractères problématiques auraient été convertis en CP 12 52. Certains textes ont peut-être été décodés à l'aide CP 12 52 en raison d'une erreur Cette fois, nous allons l' encoder en utilisant CP et 12 sur deux, puis l'imprimer à nouveau. De cette façon, vous pourrez voir le texte encodé avec CP 12. Toutes les parties où des erreurs sont survenues seront recopées en UTF huit. Décodons à nouveau le texte codé en UTF huit et modifions-le ce processus, vous verrez comment le texte est progressivement corrigé. En appliquant la fonction de code unitaire pour décoder le texte. Nous pouvons obtenir la version finale du texte. Nous pouvons examiner comment le texte présentant des problèmes d'encodage est transformé à l'aide de la fonction que nous avons développée. De plus, nous allons créer une fonction qui simplifie le processus de tokenisation en définissant des jetons spéciaux Cette fonction renverra simplement des jetons spéciaux sous forme de dictionnaire, nous ne définirons donc aucun paramètre. Dans la fonction, nous allons créer un dictionnaire dans lequel le texte que nous voulons remplacer sert de clé et le texte de remplacement est la valeur. Je remplacerai les parties du texte écrites sous la forme n par le jeton BR. Si vous souhaitez effectuer des remplacements supplémentaires, vous pouvez simplement ajouter d'autres entrées au dictionnaire Enfin, la fonction renverra ce dictionnaire. Nous allons créer une fonction qui transforme le texte saisi à l'aide de la fonction que nous avons définie précédemment. Nous allons récupérer les jetons spéciaux , puis utiliser les paires clé-valeur pour modifier le texte en remplaçant toutes les occurrences de la clé par la valeur correspondante. La fonction renverra le texte modifié. En appliquant cette fonction, nous pouvons gérer les nouveaux caractères de ligne plus efficacement, regroupant et n en un seul jeton au lieu de les tokeniser séparément. Cette approche présente l'avantage de rendre le texte lisible lors l'analyse en remplaçant ces éléments par des jetons plus visibles. Créons la fonction de prétraitement finale. Cette fonction prendra le texte comme paramètre. Tout d'abord, les encodages de résolution et la fonction normalisée seront appliqués au texte pour résoudre éventuels problèmes d'encodage Ensuite, si des jetons spéciaux doivent être transformés, la fonction de remplacement des jetons spéciaux est appliquée pour effectuer ces modifications. Enfin, la fonction renverra le texte modifié. Passons en revue un exemple pour voir comment fonctionne la fonction que nous venons de créer. Vous remarquerez que dans le texte modifié, la barre oblique N a été remplacée par le jeton BR Nous allons maintenant configurer une variable appelée identifiant. Cette variable n'a pas de signification significative. Il est simplement utilisé pour nommer le processus de formation lorsque le modèle est en cours d'entraînement. Un identifiant sera créé en utilisant le nom du modèle et l' heure à laquelle le code a été exécuté. Cela permet de savoir quel modèle a été utilisé et quand il a été exécuté. L'instruction if sera utilisée pour extraire uniquement le nom du modèle. La plupart des noms de modèles sur le visage étreint sont séparés par une barre oblique, qui divise le nom de l'entreprise et le nom du modèle En divisant la chaîne au niveau de la barre oblique et en sélectionnant l'index approprié, le nom du modèle peut être récupéré S'il n'y a pas de nom de société, le nom du modèle est pris directement. L'heure actuelle stockée sous la forme S star now dans la configuration sera ensuite ajoutée au début du nom du modèle. Après l'impression, un identifiant unique composé de l'heure et du nom du modèle est généré. Cette variable sera utilisée lors de la sauvegarde du modèle. Étant donné que des fichiers spécifiques sont générés à chaque exécution du code, cet identifiant permet de distinguer ces fichiers afin d'éviter qu'ils ne soient écrasés Comme le cadre de données d'entraînement sera fréquemment utilisé, je vais l'ajouter à la configuration en tant que train DF variable. Lorsque vous imprimez le train DF, vous verrez qu'il s'agit du même bloc de données d' entraînement que celui que nous avons imprimé précédemment. Nous allons effectuer un prétraitement de base sur le bloc de données d'entraînement. Dans ce modèle, la colonne de notation, qui est définie comme valeur cible, ne peut pas contenir de valeurs NAN. Nous allons donc écrire un code pour supprimer toutes les lignes contenant des valeurs NAN. Nous utiliserons la fonction dropna de Pandas, en spécifiant le paramètre du sous-ensemble comme colonne de notation pour supprimer Imprimons le bloc de données pour vérifier les résultats. Heureusement, il n' y a aucune valeur NAN dans la colonne d'évaluation de ce bloc de données. S'il y avait eu des valeurs NAN, certaines lacunes seraient apparues dans l'indice. Pour gérer cela, nous allons écrire du code pour réinitialiser l'index. À l'aide de la fonction de réinitialisation de l'index de Pandas, nous allons définir le paramètre drop sur true pour supprimer l'ancien index et en générer un nouveau Ensuite, bien que la colonne de révision soit probablement déjà définie sur des chaînes, nous allons explicitement changer son type de données en chaîne avant de l'utiliser. De même, nous allons modifier le type de données de la colonne de notation. Parfois, lors du chargement d'un bloc de données, les données sont chargées sous forme de chaînes. La colonne de notation étant composée de données numériques sous forme d'entiers, nous allons convertir son type de données en int Nous utiliserons la méthode d'application dans la colonne de révision pour appliquer le texte préalable au traitement. Cela nous permettra d' obtenir les résultats de pré-traitement pour tout le texte de la colonne de révision. Enfin, nous n'extrairons que les colonnes d'évaluation et de notation du châssis du train DFC car ce sont les valeurs d'entrée nécessaires Une fois que nous avons vérifié le bloc de données, il s'affichera comme indiqué ci-dessous. Le prétraitement de base pour le train DF étant terminé, nous allons maintenant ajouter certaines variables fréquemment utilisées au. À l'aide de l'identifiant, nous allons définir le dossier dans lequel le modèle sera enregistré et également stocker le chemin pour enregistrer le fichier journal dans un v. Ajoutons la colonne de pliage au cadre de données du train DF. La raison de la configuration des plis est d' appliquer une validation croisée à K plis. Nous allons créer une colonne de pliage initialisée avec Nags one, une valeur d'espace réservé À l'aide du pli K stratifié, nous allons créer un objet de pliage basé sur la valeur d'enfold définie dans la Nous allons définir la valeur true et utiliser le CV de Config pour l'état aléatoire. Ensuite, nous allons modifier la colonne de pliage dans le train de partitions DF à l'aide de l'objet de pliage. Après avoir divisé les données avec le split par points, nous utiliserons enumerate pour attribuer le numéro de pli n aux lignes incluses dans l'index valide Ici, l'indice du train représente les indices restants qui ne figurent pas dans l'index valide. Ces indices seront utilisés pendant l'entraînement, tandis que l'indice valide est uniquement destiné à la validation. Bien que les valeurs de pliage soient naturellement des entiers, nous les convertirons explicitement en int dans le code Après avoir vérifié les données, vous constaterez que les valeurs de pliage ont été mises à jour en fonction de la division du pli. Nous utiliserons une instruction if pour vérifier la variable train dans la configuration. Comme la variable train est définie sur true dans la configuration, le code contenu dans le bloc I sera exécuté. Étant donné que ces codes gèrent le prétraitement de la trame de données d'entraînement et les opérations associées, leur conservation permettra de les modifier ou de les mettre à jour plus facilement à l'avenir. Ensuite, nous allons ajouter du code pour activer le mode de débogage. La variable de débogage nous permet de vérifier rapidement si le code fonctionne correctement ou si des erreurs se produisent L'utilisation d'une instruction if pour vérifier la valeur de débogage dans la configuration réduira le nombre d'époques, car elle est destinée aux tests De plus, comme il n'est pas nécessaire de tester tous les plis, les valeurs du pli TRN seront réduites à deux Comme précédemment, nous allons vérifier la variable train et, au lieu de tester l'ensemble de la trame de données, le code échantillonnera un sous-ensemble de données à des fins de test La fonction d'échantillonnage sera utilisée pour tester environ 1 000 points de données, et l'état aléatoire est défini sur la valeur initiale de la configuration. Comme les données d'échantillon ne comporteront pas d'indices séquentiels, nous appliquerons également une réinitialisation Enfin, l'utilisation de OS makes créera le dossier de sortie tel que spécifié dans la configuration. En définissant le paramètre exist k sur true, le code remplacera le dossier s'il existe déjà Nous imprimerons le chemin pour nous assurer qu'il a été correctement défini. Imprimons à nouveau le train DF pour confirmer que les valeurs de pliage ont été correctement générées. De plus, en vérifiant le chemin actuel, nous pouvons vérifier que le dossier de sortie a été créé avec succès. 4. Enregistreur et tokenizer: Définissons l'enregistreur. L'utilisation d'un enregistreur vous permet d' imprimer et de vérifier facilement les informations souhaitées, telles que les détails du modèle et les progrès de l'entraînement Tout d'abord, nous chargeons le package nécessaire à la création de l'enregistreur. Ensuite, nous utilisons Get logger pour créer l'enregistreur. Il faut une variable appelée name, mais pour l'instant, vous pouvez considérer cela comme un code de base nécessaire lors de la création d'un enregistreur Ensuite, nous définissons le niveau de l'enregistreur. Cela détermine la quantité de messages du journal qui sera affichée. Il existe différents niveaux : information, avertissement, erreur et critique. Ici, nous utiliserons le niveau d'information. Le gestionnaire décide où envoyer les messages du journal. Nous allons définir un gestionnaire pour la console et un autre pour un fichier Nous définissons également comment formater les messages du journal. Et dans ce cas, nous ne publierons que la partie message du journal. Après avoir ajouté ces gestionnaires à l'enregistreur. Nous définissons une fonction pour le renvoyer. Créons une variable appelée logger, en utilisant la fonction get logger En utilisant la méthode info de l'enregistreur, vous verrez les informations imprimées sur la console Lorsque vous utilisez cet enregistreur pour imprimer le répertoire de sortie, les informations sont affichées via l'enregistreur Maintenant, configurons le tokenizer. Nous avions auparavant une fonction qui stockait des jetons spéciaux dans un dictionnaire pendant le prétraitement. Nous utiliserons cette fonction pour nous assurer que ces jetons sont correctement tokenisés lors de la configuration du Nous allons attribuer la variable de remplacement des jetons spéciaux en appelant la fonction « obtenir des jetons spéciaux supplémentaires ». Cela stockera le dictionnaire des jetons que nous voulons remplacer. Comme la fonction tokenizer nécessite les jetons sous forme de liste, ne convertira que les valeurs du dictionnaire en liste Nous allons configurer le tokenizer à l' aide du tokenizer automatique, passant le modèle et tous les jetons spéciaux définis précédemment En configurant le tokenizer de cette façon, nous pouvons nous assurer que les jetons spéciaux sont reconnus comme des jetons uniques et ne sont pas divisés en plusieurs parties distinctes Puisque nous avons ajouté de nouveaux jetons au tokenizer, nous allons les enregistrer afin que le tokenizer puisse être chargé avec le modèle ultérieurement Vous devriez être en mesure de voir les tracés enregistrés en cours d'impression. Imprimons ensuite la longueur maximale. La longueur maximale représente la longueur maximale lors de la tokenisation du texte, et c'est un facteur crucial lors de l'entraînement du modèle L'avantage d'utiliser une longueur maximale plus élevée est qu'elle nous permet de conserver plus d' informations à partir de textes plus longs. Cependant, l'inconvénient est qu' une longueur maximale plus élevée augmente le coût de calcul Pour cet exemple, nous allons définir la longueur maximale à 128. Nous allons maintenant passer un exemple pour comprendre ce que fait le tokenizer abord, jetez un coup d'œil à un examen des données d'entraînement et tokenisez-le. Récupérons la première entrée de la colonne de révision dans le train DF. Vous pourrez voir le texte de pré-traitement. Ensuite, nous allons encoder ce texte à l'aide du tokenizer. À l'aide du tokenizer défini, nous passerons l'exemple précédent en paramètre et définirons des options telles que les tenseurs de retour, l' ajout de jetons spéciaux, la longueur, rembourrage et la troncature. Ensuite, nous exécuterons le code. Lorsque nous examinons la sortie tokenisée, nous pouvons voir qu'elle se compose d'identifiants d'entrée, d'identifiants type de jeton et de masques d' attention, qui sont des listes de nombres Les identifiants d'entrée représentent des mots qui ont été convertis en nombres entiers spécifiques Chaque modèle possède un vocabulaire qui fait correspondre les mots aux nombres, et ce mappage est utilisé pour convertir le texte en format numérique Les identifiants de type jeton sont utilisés pour distinguer les phrases. La plupart des modèles basés sur Bert peuvent traiter deux phrases simultanément. mots de la première phrase sont marqués d'un zéro et ceux de la deuxième phrase sont marqués d'un. Il existe des jetons spéciaux pour séparer les phrases. Mais dans cet exemple, nous n'en avons inclus aucune Toutes les valeurs sont donc nulles. Le masque d'attention indique quelles parties de l'entrée doivent être ignorées par le modèle. Après avoir défini la longueur maximale de la phrase d'entrée, modèles basés sur des transformateurs ajoutent zéro jeton à la fin de l'entrée pour qu'elle corresponde à cette longueur. Comme ce rembourrage est uniquement destiné à l'alignement, masque d' attention est utilisé pour s'assurer que ces pièces rembourrées ne sont pas prises en compte dans les calculs des modèles Étant donné que cette partie peut affecter formation des modèles, nous la commenterons. Nous allons créer une fonction appelée prepare input, qui fonctionnera de la même manière que dans l'exemple que nous avons vu. La fonction prendra et comme paramètres. Les entrées seront définies la même manière que nous avons appliqué le tokenizer au texte plus tôt, avec tous les paramètres définis exactement de la La seule étape supplémentaire consiste à convertir le type de données en to afin qu'il puisse être utilisé dans Torch. Ensuite, nous allons créer une fonction appelée colate. Les entrées sont les entrées groupées. La raison de la création de cette fonction est d'utiliser plus efficacement la mémoire du GPU, améliorant ainsi la vitesse d'entraînement du modèle dans les limites des ressources disponibles. Nous allons d'abord déterminer la longueur du masque, qui est la longueur du texte le plus long de chaque lot. Dans les entrées, nous allons additionner les valeurs du masque d' attention et trouver la longueur la plus longue. Ensuite, nous réduirons toutes les entrées du lot à cette longueur. Nous allons parcourir les paires de valeurs clés et les entrées et définir la longueur maximale comme longueur du masque. Ce processus permet de raccourcir les textes à une longueur spécifique, ce qui accélère le calcul Enfin, nous retournerons les entrées. 5. Créer un ensemble de données: Ici, nous allons transformer les données d'entraînement dans un format utilisable avec PyTorch Lors de la création de l'ensemble de données, nous définirons la configuration et le bloc de données en tant que paramètres. Après avoir configuré la configuration, nous utiliserons le bloc de données pour créer le texte et les étiquettes. Nous définirons le texte selon les valeurs de la colonne de révision du bloc de données, et les étiquettes seront définies sur la colonne cible, qui correspond aux valeurs d'évaluation. La fonction qui renvoie la longueur de l'ensemble de données sera basée sur la longueur du texte. Lorsque vous accédez à l' ensemble à l'aide d'un index, nous utiliserons la fonction définie précédemment pour renvoyer à la fois l' entrée et l'étiquette. 6. Définir les méthodes de mise en commun: Dans cette vidéo, nous allons examiner en détail le pool. Dans le traitement du langage naturel, regroupement est utilisé pour extraire des caractéristiques importantes du texte. La première technique de mise en commun que nous aborderons est la mise en commun CLS. Il s'agit de la méthode de regroupement la plus élémentaire du NLP car le jeton CLS lui-même contient des fonctionnalités importantes Le jeton CLS est placé au début d'une phrase lors de la tokenisation et est conçu pour représenter l' intégralité de la séquence de texte En d'autres termes, ce jeton porte le sens de la phrase entière. Les modèles basés sur des transformateurs utilisent le mécanisme d'attention, qui identifie les informations clés du texte. Le jeton CLS placé au début interagit avec les autres dans la phrase, ses informations Puis, en fin de compte, accumule et reflète le sens général de la phrase La première technique de regroupement que nous allons créer est une couche qui extrait ce jeton CLS. Le pooling CS sera implémenté à l'aide du module nn. Puisque nous créons une couche, nous allons définir la méthode init et créer la méthode forward La méthode directe suppose que les entrées ont été transmises au modèle. Lorsque les entrées sont introduites dans le modèle, les sorties nous indiquent le dernier état caché. Ce dernier état masqué sera considéré comme un paramètre et définira également le paramètre du masque d'attention avec une valeur par défaut nulle. Le dernier état masqué peut être considéré comme l' information récapitulative clé laissée fois que le modèle a traité toutes les données. À partir de là, nous allons extraire et renvoyer le premier jeton, connu sous le nom de jeton CLS. Dans cette vidéo, nous allons créer différentes techniques de mise en commun. Examinons d'abord comment l'entrée change à l'aide d'un exemple. Créez ensuite des méthodes de mise en commun basées sur cela. Nous allons commencer par configurer des exemples de données pour dernier état masqué et le masque d'attention. Dans le masque d'attention, un indique un jeton valide et zéro représente un jeton de rembourrage Nous allons définir une variable appelée masque de saisie expansé. Cette variable étend le masque pour qu'il corresponde à la taille du dernier état masqué, ce qui permet de prendre en compte de manière sélective certaines parties du dernier état masqué. Tout d'abord, appliquez le chiffre neuf est un sur le masque d'attention, en ajoutant une nouvelle dimension à la fin Cela changera un tenseur de taille 24 en 241. Ensuite, appliquez expand pour étendre le tenseur à 243 afin qu' il corresponde à la taille du dernier état caché La fonction d'extension se comporte comme si elle répétait des valeurs le long des dimensions étendues Enfin, remplacez le type de données par float. Au départ, les valeurs sont des entiers, mais nous les convertissons en nombres flottants pour les utiliser dans des opérations ultérieures Nous allons étendre ce masque pour appliquer des pondérations uniquement aux jetons valides dans chaque valeur du dernier état caché, ignorant les jetons rembourrés. Maintenant, nous multiplions le dernier état masqué par le masque de saisie développé pour ne conserver que les données valides. Ensuite, nous calculons la somme selon la dimension 1, qui correspond aux jetons de chaque séquence. Cette étape fait la somme des valeurs de tous les jetons valides de chaque séquence, combinant efficacement les vecteurs d'état cachés par jeton en un seul. Cela nous permet de condenser les informations de la séquence entière en une seule Ensuite, nous attribuons le résultat du masque de saisie de sommation étendu le long de la dimension 1 à une variable appelée masque de somme Cette somme représente le nombre de jetons valides dans chaque séquence. Nous utilisons ensuite la fonction de serrage pour limiter la valeur minimale du masque. Cela empêche la division par zéro, ce qui peut se produire si une séquence ne contient aucun jeton valide ou si elle consiste uniquement en un remplissage Enfin, nous divisons certaines intégrations par un masque pour calculer la moyenne Cela nous donne les intégrations moyennes, qui représentent le sens général de l'ensemble de la phrase Résumons les étapes précédentes et créons une couche de regroupement moyenne. Nous allons commencer par hériter du module N N et définir la méthode d'initialisation R. Nous allons ensuite créer un masque de saisie étendu et écrire le code de la même manière que dans l'exemple précédent. Nous ne conserverons que les jetons valides, les additionnerons et calculerons le masque de somme pour obtenir le nombre de jetons valides. Nous ne conserverons que les jetons valides, les additionnerons et calculerons le masque pour obtenir le nombre de jetons valides. Ensuite, nous nous assurerons que la valeur minimale du masque n'est pas nulle avant de procéder à la division. Ck. Enfin, nous créons une couche qui renvoie les intégrations moyennes Les prochaines méthodes de mise en commun que nous allons définir sont la mise en commun et la mise en commun. Ces méthodes représentent une phrase utilisant les valeurs maximale et minimale des jetons. Tout comme dans le cas de la mise en commun des moyennes, nous allons d'abord étendre le masque. L'intégration représente le dernier état masqué. En termes simples, une intégration est un vecteur qui représente la phrase Tout d'abord, nous remplaçons les jetons non valides dans l'intégration par une très petite valeur négative Ensuite, nous utilisons la fonction pour créer une intégration en utilisant les plus grandes valeurs parmi les jetons Ensuite, nous allons implémenter le pool minimal, qui est similaire au pool maximal. La différence est que nous remplaçons les jetons non valides par une valeur positive élevée. Comme dans Max Pooling, nous étendons le masque et créons l'intégration. Ensuite, nous remplaçons les valeurs non valides un grand nombre et appliquons la fonction pour créer l'intégration Cette méthode génère une intégration qui représente la phrase en utilisant les plus petites valeurs parmi les jetons La prochaine technique de mise en commun que nous créons utilise le concept d'attention Avant de renforcer la mise en commun de l' attention, nous devons organiser à l'avance certaines activités requises. La mise en commun de l'attention est plus complexe que les méthodes de regroupement CLS, Mean, Max et Min décrites précédemment méthodes de regroupement CLS, Mean, Max et Min préparons donc ces fonctions à l'avance pour améliorer la lisibilité Nous allons écrire le code en fonction de la sortie du modèle. Nous allons créer une fonction pour extraire le dernier état masqué. Cette fonction utilisera les sorties du backbone ou les sorties des modèles comme paramètre et utilisera l'indexation pour obtenir le dernier état caché, qu'elle retournera Ensuite, nous allons créer une fonction pour obtenir tous les états cachés. Comme pour la fonction précédente, nous utiliserons Index 1 pour obtenir tous les états cachés et les renvoyer. Enfin, nous allons créer une fonction pour extraire l'identifiant et le masque d'attention des entrées. À l'aide d'un tokenizer, des entrées seront générées, et cette fonction séparera et renverra l'identifiant d'entrée et le masque d'attention À l'aide des fonctions que nous avons créées précédemment, nous allons implémenter une méthode de regroupement basée sur le mécanisme d' attention. Regardons un exemple pour voir comment créer une intégration de représentation de phrases Nous allons importer le modèle automatique et tokenizer automatique depuis la bibliothèque des transformateurs Ensuite, nous allons charger le modèle et le tokenizer. Le modèle de base sera celui défini dans la configuration. Nous préparerons ensuite un exemple de texte. À l'aide du tokenizer, nous allons créer les entrées, où les paramètres incluront le texte et définirons les tenseurs de retour sur les tenseurs de torche Pi Nous ajouterons également un rembourrage et tronquerons le texte pour qu'il corresponde à la longueur maximale Comme nous ne nous entraînons pas pour le moment, nous n'utiliserons aucun grade pour générer les résultats. Lors de la saisie dans le modèle, nous transmettrons les entrées et définirons les états cachés de sortie sur true pour récupérer les états cachés de chaque couche À partir des sorties du modèle, nous utiliserons la fonction get all hidden states pour récupérer tous les états cachés. Maintenant, imprimons tous les états cachés et leur forme. La raison pour laquelle nous avons 13 états est que le premier inclut l'intégration des entrées La base De Berta comporte 12 couches au total. Nous allons extraire les jetons CLS de ces 12 états cachés et empiler les données Imprimons les encastrements CLS et vérifions leur forme. En extrayant les jetons CLS, nous avons obtenu des intégrations de représentation de phrases intégrations Enfin, nous allons réorganiser les données à l'aide de la fonction d'affichage. Ensuite, nous allons appliquer le concept d'attention. Pour ce faire, nous allons créer une requête. Ceci est basé sur le concept du mécanisme d' attention. Nous allons le définir comme un paramètre pouvant être appris et initialiser pour qu'il suive une Comme le vecteur sera utilisé dans cet exemple, nous allons le déplacer vers le processeur plutôt que vers le processeur graphique. Imprimons également la forme de Q. Puisque nous allons réaliser un produit par points entre ce vecteur et les états cachés, nous allons d'abord transposer Q. En utilisant le produit par points, nous calculons l' importance de chaque couche Pour convertir ces scores importants en valeurs de 0 à 1, nous appliquons soft max. De cette façon, nous pouvons comprendre l'importance relative de chaque couche. Ensuite, nous appliquerons la somme pondérée aux états cachés à l'aide de ces valeurs. abord, nous devons faire correspondre la taille des vecteurs dans les états cachés. Pour ce faire, nous allons utiliser la fonction seed pour modifier la forme de V , puis permuter les deux dernières dimensions afin garantir la forme correcte pour les opérations ultérieures. Le V résultant sera la somme pondérée des états cachés. Enfin, nous allons créer une matrice de pondération. Cette matrice effectuera une transformation linéaire sur V temp, convertissant la dimension d'entrée en dimension de sortie Cette transformation aide le modèle à apprendre et stocker des informations clés dans le vecteur pendant l'entraînement. En soulignant les caractéristiques importantes du vecteur d'entrée et en le convertissant en v de sortie, nous créons le vecteur final, qui peut être utilisé pour la tâche suivante, classification, dans ce cas. Créons une couche de mise en commun de l'attention en basant sur l'exemple que nous venons de passer en revue. Nous utiliserons le module N N do, et dans la méthode score it, les paramètres nécessaires incluront le nombre de couches cachées, taille cachée, le DMF C caché et le taux d'abandon Nous les définirons comme des variables de classe. De plus, nous définirons le périphérique de calcul, ainsi que le tenseur de requête, le tenseur poids et le résultat, comme Ensuite, nous allons écrire le reste du code. Dans le code, vous remarquerez que le processus de calcul de l'importance basé sur le concept de l'exemple précédent a été implémenté dans la méthode d'attention. Nous avons également appliqué le décrochage pour éviter le surajustement. Pour résumer ce code, cette couche implémente un mécanisme de mise en commun de l'attention qui extrait des informations importantes des états cachés calculés sur plusieurs couches d'un modèle de transformateur. Il utilise un vecteur de requête pour calculer les poids pour les états cachés de chaque couche, puis crée la représentation de phrase finale incorporée en faisant la moyenne pondérée des informations importantes des couches Examinons maintenant un exemple de couche de mise en commun pondérée. abord, nous définissons une variable appelée début de couche, qui détermine à partir de quelle couche la moyenne pondérée débutera. S'il existe une valeur initiale pour les pondérations des couches, nous la définirons. Dans le cas contraire, nous lui attribuerons la valeur none. Ensuite, nous définissons le nombre de couches cachées num, qui dépend du modèle utilisé. Puisque nous utilisons le modèle de base De Berta, nous allons le définir sur 12. Nous allons maintenant configurer les pondérations des couches. Si la valeur initiale n'est pas définie et est nulle, nous allons entrer un paramètre avec une pondération de un pour toutes les couches à partir du début des couches. Ce paramètre sera automatiquement optimisé lors de l'entraînement. Nous utilisons la fonction stack pour empiler les sorties de plusieurs couches en un seul tenseur Notez que les couches antérieures au début de la couche ne sont pas utilisées. T. Ensuite, nous utilisons la compression pour augmenter la dimension des tenseurs afin de pouvoir multiplier les sorties de chaque couche par les poids Ensuite, nous additionnons les sorties pondérées de chaque couche et les divisons par la somme des poids pour calculer la moyenne pondérée. En utilisant les méthodes que nous avons appliquées précédemment, nous allons créer un pool pondéré. Le résultat final sera le jeton CLS avec la moyenne pondérée appliquée Cette méthode de regroupement prend les résultats de plusieurs couches et en fait la moyenne en fonction de leur pondération Il est conçu pour refléter les informations des couches les plus importantes en leur attribuant une pondération plus élevée dans la moyenne. Ainsi, toutes les méthodes de mise en commun que je souhaitais partager sont désormais créées. Je pense que cette partie est la plus cruciale de cette vidéo d'apprentissage automatique. La raison en est que l'utilisation de ces techniques vous permet de créer une variété de modèles. Selon le modèle de base, vous pouvez générer six modèles différents. Quel est donc l'avantage de cette approche ? Il vous permet d'aborder le problème sous différents angles à l' aide d'un seul modèle. Si ces modèles sont bien entraînés, vous pouvez les assembler pour obtenir des résultats encore meilleurs. En fait, il vous permet de résoudre le problème de plusieurs manières en utilisant un seul 7. Créer un modèle personnalisé: Créons maintenant un modèle à l'aide de ces couches. De bonnes techniques de mise en commun étant déjà en place, la génération du modèle est relativement simple. Nous utiliserons ces méthodes de regroupement pour créer un modèle de régression. Nous utiliserons le module N N pour construire le modèle, avec des paramètres de configuration et de pré-entraînement. Ces variables indiquent la configuration et indiquent s'il faut utiliser un modèle préentraîné. Par défaut, nous nous entraînerons à partir de zéro Nous leur donnerons donc la valeur n et la valeur false. Et si une instruction sera écrite pour vérifier la présence de la configuration. S'il n'est pas présent, nous enregistrerons le fichier de configuration dans le répertoire de sortie. Pour enregistrer les détails de configuration au démarrage du modèle, nous utiliserons un enregistreur pour vérifier comment le modèle est initialisé Ensuite, nous allons configurer le modèle, selon qu'un modèle pré-entraîné est utilisé ou non. Ensuite, nous utiliserons la variable de point de contrôle du gradient définie dans Config L'avantage de ce code est qu'il permet d'économiser de la mémoire. C'est utile lorsque l'entraînement grands modèles est difficile en raison d'une mémoire limitée. Ce code n'enregistre pas toutes les sorties intermédiaires pendant l'entraînement. Il ne sauvegarde de manière sélective que les éléments importants. Les pièces qui ne sont pas enregistrées sont recalculées ultérieurement en cas Je préfère que le modèle soit intégré à la mémoire du GPU plutôt que de gagner du temps Je vais donc utiliser cette méthode. Ensuite, nous allons configurer la couche de regroupement à l'aide la méthode de regroupement définie dans Config. Avant de définir la méthode directe, nous allons créer une méthode pour la simplifier. Cette méthode renvoie les entités générées après avoir transmis l'entrée à la couche de regroupement. Ensuite, nous allons créer la méthode de transfert. Les entrées du modèle passeront par la méthode de regroupement , puis par une couche linéaire requise pour la régression. La sortie générée ici sera le résultat final après avoir parcouru le modèle. 8. Fonction de perte, mesures et fonctions d'aide: Nous allons créer une métrique pour évaluer le modèle. Nous utiliserons l'APA de Cohen comme métrique d'évaluation. Les valeurs des données de révision sont des nombres entiers, et plus les valeurs prédites sont proches de ces nombres entiers, meilleure est la prévision Par exemple, si un avis est noté trois, il est plus précis de le prévoir comme quatre que de le prédire comme Cette métrique prend en compte ces aspects et exprime les performances du modèle sur une échelle allant de 1 à 1 MG C'est un excellent indicateur lorsqu'il s'agit de données telles que les avis. Pour implémenter cet encodage, nous convertissons d'abord les prédictions du modèle en valeurs de 1 à 5 Ensuite, nous utilisons le CAPA de Cohen fourni par Psych Learn pour calculer le résultat Plus tôt, nous avons écrit une fonction pour calculer l'APA de Cohen. Préparons maintenant une fonction supplémentaire pour gérer plusieurs cas de régression dans lesquels il existe plusieurs valeurs cibles. Dans cette fonction, nous supposons que la cible y peut avoir plusieurs valeurs. Nous calculons l'APA de Cohen pour chaque cible, puis renvoyons à la fois la valeur métrique moyenne pour toutes les cibles et les valeurs métriques individuelles. Nous allons modifier le score GT pour utiliser le f de Cohen et afficher uniquement le résultat. De cette façon, si nous devons modifier la métrique dans un code similaire à l'avenir, cela peut être fait facilement. Nous allons écrire la fonction G score séparément à cette fin. Nous allons créer une classe appelée Average Meter. Ce cours est un utilitaire permettant accumuler des valeurs et de calculer leur moyenne, couramment utilisé pour suivre des indicateurs tels que la perte ou précision pendant le processus de formation des modèles de deep learning. Le cours est mis à jour périodiquement pour gérer la valeur actuelle, la valeur cumulée et la moyenne, ce qui permet de suivre l'évolution des pertes tout au long de l'entraînement. Dans la méthode init, lorsque cette classe est appelée, elle réinitialise toutes les valeurs initiales La méthode de réinitialisation mettra toutes les valeurs à zéro. Ici, Val représente la valeur actuelle. AVG est la valeur moyenne, somme est la somme cumulée des valeurs et le nombre est le nombre de valeurs saisies La méthode de mise à jour prend une nouvelle valeur et elle est prise en compte pour mettre à jour l'état actuel. Cette méthode peut être appelée à chaque itération pour mettre à jour la valeur de perte ou d'autres mesures Ce cours fournit un moyen pratique de suivre la valeur des pertes ou d'autres indicateurs pendant l'entraînement. Le temps est un facteur crucial pour comprendre le processus de formation du modèle. Il est important de savoir dans quelle mesure l'entraînement a progressé et combien de temps il reste Pour y remédier, nous allons créer des fonctions permettant de suivre le temps. Créons d'abord une fonction qui convertit le temps de quelques secondes en minutes. Nous allons créer une fonction pour afficher le temps consacré à la formation des modèles et le temps restant. Tout d'abord, l' heure actuelle sera enregistrée. Ensuite, en fonction de l'heure de début fournie, la fonction calculera le temps écoulé et le temps restant, renvoyant ces informations sous forme Représente maintenant l'heure actuelle tandis que S est la différence entre l'heure de début et l'heure actuelle en secondes. La valeur divisée par pourcentage indique la progression de l'entraînement, qui sera déterminée par la durée de ta. La valeur divisée par le pourcentage indique la progression de la formation, qui sera ensuite déterminée par la longueur du chargeur de train. Ainsi, en soustrayant S de ES, on obtient le temps restant et S indique le temps déjà consacré Formatons ces valeurs dans une chaîne pour la sortie. Définissons maintenant la fonction de perte. Dans l'analyse de régression, la fonction de perte la plus couramment utilisée est le RMSE, erreur quadratique moyenne Nous inclurons un paramètre de réduction pour déterminer le mode de calcul de la perte . Dans ce carnet de formation, nous utiliserons mean. Voici comment nous allons créer la classe de pertes RMSE. 9. Fonctions de formation et de validation: Créons ensuite une fonction pour entraîner le modèle. Les paramètres de cette fonction incluent le pliage, le chargeur de train, le modèle, le critère, l'optimiseur, l' EPOC, le planificateur Les paramètres de cette fonction incluent le pliage, le chargeur de train, le modèle, le critère, l'optimiseur, l' EPOC, le planificateur Pour expliquer chaque paramètre en détail, pli fait référence au pli utilisé pour l'entraînement. Train Loader est le chargeur de données d'entraînement. Le modèle est le modèle. Le critère est la fonction de perte. L'optimiseur est l'optimiseur. EPOC est le numéro d'EPOC. planificateur gère le taux d'apprentissage et l'appareil indique s'il faut utiliser le processeur ou le GPU pour Nous utilisons la classe moyenne des compteurs pour suivre les pertes et mettre le modèle en mode entraînement. Ensuite, nous créons un objet scalaire de grade pour optimiser la mémoire et la vitesse de calcul Si l'Apex de CFG est vrai, nous pouvons réduire la précision pour accélérer l'entraînement Comme mentionné précédemment, les méthodes que je partage sont conçues pour que le modèle soit entraîné principalement sur le GPU, c'est pourquoi nous utilisons ces techniques d'optimisation. Nous enregistrons le temps de formation et créons une variable pour suivre le nombre total d' étapes du processus de formation. Nous chargeons ensuite les données pour chaque lot , les entrées étant les données d'entrée et les étiquettes les valeurs cibles. Nous plaçons le masque d'attention à partir des données d'entrée sur le GPU ou le processeur. Comme les modèles sont généralement entraînés sur GPU, nous l'avons configuré de cette façon Nous appliquons ensuite la fonction Cate aux entrées et déplaçons l' entrée vers le GPU. Cela est nécessaire car le modèle et les entrées doivent se trouver sur le même appareil pour que les calculs puissent être effectués. Les étiquettes cibles sont également déplacées vers le GPU et la taille du lot actuel est stockée. À l'aide d'opérations de mémoire efficaces, nous transmettons les entrées au modèle pour obtenir des prédictions, puis nous calculons la perte en fonction de ces prédictions. Si le pas d'accumulation du gradient est supérieur à un, nous l'utilisons pour calculer la perte. L'utilisation de l' étape d'accumulation de gradient nous permet d'imiter fait d'avoir une plus grande mémoire GPU en accumulant des Lorsque la taille de la mémoire du GPU est petite, la taille du lot doit également être petite. Cependant, avec cette méthode, même si la taille du lot est petite, nous pouvons cumuler les calculs pour obtenir une taille de lot approximative plus grande. Récemment, grâce à ces paramètres variables, il est devenu possible d'utiliser de grands modèles même avec une mémoire limitée. Le point essentiel que je souligne est que si le modèle peut effectuer une seule boucle d'entraînement au sein du GPU, il peut être entraîné efficacement. Par conséquent, si vous ne pouvez pas entraîner le modèle en raison de limites de taille de lot, réduisez la taille du lot autant que possible et utilisez ces variables. Cela permet aux individus ou petites équipes de peaufiner les modèles. Ensuite, nous mettons à jour la perte l' aide de la valeur calculée et utilisons rétropropagation pour déterminer la direction dans laquelle le modèle doit être optimisé. Sur la base du réglage de l'échelle, nous appliquons le dédimensionnement pour éviter que les dégradés ne soient mal découpés Nous appliquons ensuite un code pour empêcher l'explosion du dégradé. Nous appliquons ensuite un code pour empêcher l'explosion du dégradé. Maintenant, une fois l'accumulation des dégradés terminée, nous mettons à jour l'optimiseur avec les dégradés mis à l'échelle. Nous mettons ensuite à jour le scaler et réinitialisons les dégradés accumulés Nous incrémentons l'étape globale, et si le planificateur par lots l'est, nous le mettons à jour à chaque Enfin, nous enregistrons l'heure de fin du lot. Nous imprimons régulièrement les informations de formation. Enfin, nous renvoyons la perte moyenne pour l'époque actuelle. Créons une fonction pour la validation. Cette fonction évaluera les performances du modèle sur l'ensemble valide et calculera la perte. Passons en revue le code en détail. Les paramètres d'entrée sont valides, modèle et appareil. Tout d'abord, un chargeur valide est nécessaire pour charger les données de validation, et le modèle est utilisé pour transmettre les données afin d' obtenir les résultats. Ensuite, le critère est utilisé pour calculer la perte, et le périphérique spécifie le périphérique, processeur ou le GPU, sur lequel le modèle sera exécuté. Nous commençons par configurer la fonction de perte à des fins validation et passons le modèle en mode évaluation. Ensuite, nous créons une liste pour stocker les prédictions et configurons les variables nécessaires pour calculer le temps écoulé. Nous chargeons maintenant les données lot par lot à partir d'un chargeur valide. Ici, les entrées sont les données d'entrée et les étiquettes sont les valeurs cibles. Nous chargeons maintenant les données lot par lot à partir d'un chargeur valide. Ici, les entrées sont les données d'entrée et les étiquettes sont les valeurs cibles. Ensuite, nous désactivons la rétropropagation, car le calcul du gradient n'est pas nécessaire pendant la phase de validation Nous transmettons ensuite les entrées au modèle pour obtenir des prévisions et calculer la perte. À l'aide de l'étape d'accumulation du gradient, nous mettons à jour la perte comme nous l'avons fait dans le train F N. Pour enregistrer les prédictions, nous les déplaçons vers le processeur et les ajoutons à la liste que nous avons créée précédemment. Cette étape est nécessaire car le code d'évaluation s'exécute sur le processeur. Ensuite, nous vérifions l'heure à la fin de la validation et imprimons régulièrement les informations de validation, notamment l'étape en cours, temps écoulé, le courant et les moyennes Enfin, nous renvoyons la perte moyenne pour l'ensemble de validation avec les prévisions. Écrivons maintenant le code permettant de créer le modèle tout en effectuant une validation croisée à l'aide des fonctions que nous avons définies précédemment. Dans ce processus de validation croisée, nous utiliserons des plis. Nous allons entraîner le modèle sur les données, excluant un pli spécifique, puis le valider à l'aide de ce pli. Les paramètres d'entrée pour cette fonction sont les plis et le pliage. plis contiennent toutes les informations de pliage de l'ensemble de données. Alors que le pli fait référence au numéro de pli spécifique que nous sommes en train d'entraîner. Tout d'abord, nous utilisons Lger pour imprimer quel pli est actuellement utilisé pour la formation L'utilisation de l'enregistreur affichera un message plus long pour vérifier facilement quel pli est utilisé pour l'entraînement À l'aide des plis et des valeurs de pliage, nous allons créer des plis en train et des plis valides. Pour les pliages en train, nous sélectionnons les données du jeu de données des plis pour lesquelles la valeur du pli ne correspond pas. Nous avons également réinitialisé l' index et défini dropes true pour empêcher que l'ancien index ne devienne une nouvelle colonne De même, pour les pliages valides, nous sélectionnons les données pour lesquelles la valeur du pli correspond pour créer l'ensemble de validation. Ensuite, nous allons attribuer les valeurs d'étiquette pour validation à la variable d'étiquettes valide. Ensuite, nous préparons les données d'entraînement et de validation ainsi que les valeurs cibles pour les données de validation et les attribuons à des variables. À l'aide de ces données, nous créons les ensembles de données d'entraînement et de validation avec un ensemble de données de train personnalisé. En convertissant le train et les données valides en ensembles, nous pouvons utiliser le chargeur pour activer le traitement par lots dans Pi Torch. En convertissant le train et les données valides en ensembles de données, nous pouvons utiliser le chargeur de données pour activer le traitement par lots dans Pi Torch. Lors de la configuration du chargeur de données, nous utilisons la taille de lot spécifiée dans la configuration, et pour le shuffle, il est recommandé de la définir sur true, car il s' agit de données d'entraînement En outre, le fait de définir le paramètre de mémoire des broches sur true accélérera le chargement des données. De même, nous avons configuré la valeur valide. Cependant, étant donné que la validation utilise moins de mémoire, nous allons doubler la taille du lot. De plus, nous avons défini la valeur false lors validation afin de garantir que l'ordre des données reste inchangé. Pendant la validation, le modèle passe en mode évaluation. Pour accélérer la validation, la taille du lot sera doublée. Ensuite, nous créons le modèle et le déplaçons également vers le GPU. Créons une fonction pour configurer l'optimiseur du modèle Dans cette fonction, nous trouvons la liste des paramètres pour configurer l'optimiseur et spécifiez la liste des paramètres qui ne doivent pas utiliser de poids Lorsque nous définissons les paramètres du modèle à entraîner, nous les divisons entre ceux qui utiliseront décroissance du poids et ceux qui n'en utiliseront pas. Cette étape est facultative, et les paramètres qui ne provoquent pas surajustement n' utiliseront pas de perte de poids. Si le modèle est relativement simple et que les données d'entraînement sont suffisantes, il peut fonctionner correctement sans perte de poids. L'application inutilement de la perte de poids peut avoir un impact négatif sur les performances d' entraînement Il est donc préférable de l'utiliser manière sélective en fonction des circonstances du modèle Cette fonction montre comment appliquer de manière sélective la réduction de poids. Ensuite, à l'aide de ces informations, nous définissons le taux d'apprentissage et diminution du poids pour l'optimiseur La fonction renvoie ces paramètres configurés. Comme LLRD est défini sur false dans la configuration, vous pouvez vous concentrer sur la partie s. Pour expliquer brièvement le LLRD, taux d'apprentissage par couche. Il s'agit d'une technique dans laquelle différents taux d'apprentissage sont appliqués à chaque couche, but d'une meilleure optimisation. Bien que le réglage précis des taux d'apprentissage puisse améliorer les performances du modèle, après mon expérience, la différence a été minime. Je pense que cela est dû au fait que les performances par défaut de la plupart des optimiseurs sont assez bonnes Ensuite, nous créons une fonction pour configurer le planificateur. Le planificateur décidera comment modifier le taux d'apprentissage Dans cette configuration, nous prenons en compte la fois les options linéaires et cosinusoïdales Les deux méthodes peuvent fonctionner, vous pouvez donc choisir celle qui donne les meilleurs résultats. Cette fonction configure le planificateur pour l'entraînement des modèles. Le planificateur ajuste le taux d'apprentissage pendant le pendant le Le code sera écrit pour permettre l'utilisation de l'un des deux planificateurs, le planificateur linéaire ou le planificateur La fonction prend trois paramètres : CFG, Optimizer et Num train steps. Le CFG contient les configurations définies précédemment. Optimizer fait référence à l' optimiseur que nous avons créé précédemment, et Num train steps représente le nombre total d'étapes d'entraînement Passons maintenant en revue les paramètres utilisés lors de la configuration du planificateur L'optimiseur est celui que nous avons défini précédemment, et num warm steps fait référence au nombre d'étapes d' échauffement au cours desquelles le taux d'apprentissage augmente progressivement d'étapes d'entraînement fait référence au nombre total d'étapes d'entraînement. Pour le planificateur en cosinus, le paramètre num cycles détermine dans quelle mesure le taux d'apprentissage oscille au cours d' Ce planificateur diminue le taux d'apprentissage dans un schéma d'onde cosinusoïdale. Ensuite, nous définirons la fonction de perte à l'aide de la perte RMSE que nous avons configurée précédemment Pour suivre les meilleures performances de validation et les meilleures pertes, nous initialisons certaines variables Nous créons également des listes pour suivre les pertes et les performances de chacun. Nous écrivons une boucle pour entraîner et valider le modèle pour chaque époque Pour chaque époque, nous calculons la perte de validation et les prédictions à l'aide du modèle Nous utilisons ensuite ces prédictions pour calculer les mesures d'évaluation. Si les performances du modèle sont meilleures que celles des versions précédentes, nous sauvegardons le modèle. Sinon, nous ne l'enregistrons pas. En effet, la sauvegarde de tous les modèles peut rapidement entraîner des problèmes de stockage. Le modèle que nous utilisons actuellement est relativement petit par rapport aux modèles récents, mais il sera utile de comprendre cette façon de sauvegarder les modèles lorsqu'il s'agit de modèles plus grands. Nous allons également écrire du code pour enregistrer le modèle pour chaque eo. Ensuite, nous chargeons le meilleur modèle et stockons les prédictions pour les données de validation dans un bloc de données. Nous résumons également les mesures de perte et d'évaluation pour chaque époque dans un cadre. Après chaque époque, nous effaçons la mémoire et appelons la collecte des déchets pour libérer de la mémoire Enfin, la fonction renvoie la meilleure perte d'apprentissage, la perte validation, les meilleurs résultats et le bloc de données contenant les informations pour chaque époque À l'aide de cette fonction, nous pouvons entraîner le modèle sur les données à l'exception d'un pli spécifique et le valider sur ce pli par validation croisée. Nous enregistrons également le meilleur modèle, optimisons à l'aide de diverses techniques d' entraînement, puis enregistrons et surveillons les performances tout au long du processus d'entraînement. 10. Formation sur les modèles et résultats: Créons maintenant une fonction utilisée pour évaluer le modèle et enregistrer les résultats. Cette fonction prendra comme paramètres OFDF, fold , best train loss et best val loss Laissez-moi vous expliquer chacun de ces paramètres. OFDF contient les informations de formation et de validation générées pour chaque époque par le biais de la boucle ferroviaire pli indique le pli actuel qui est utilisé pendant l'entraînement. meilleure perte de train et la meilleure perte de val sont les meilleures valeurs de perte d'entraînement et de validation obtenues à partir de la boucle du train. Cette fonction utilise ces valeurs pour calculer le score d'évaluation. Ensuite, il imprime le score à l'aide d'un enregistreur pour montrer les performances du modèle. Enfin, il extrait les colonnes nécessaires et les renvoie. Maintenant, nous allons enfin entraîner le modèle. Tout d'abord, nous créons un bloc de données vide pour stocker les résultats de l'entraînement. Nous créons également des listes pour enregistrer les pertes liées à la formation et à la validation. Ensuite, nous écrivons une boucle pour appliquer la boucle du train à chaque pli. Nous stockons les valeurs obtenues à l' aide de cette fonction dans les listes que nous avons créées précédemment, puis nous convertissons les parties nécessaires en un bloc de données pour le stockage. Nous enregistrons également les résultats sous de fichier CSV et stockons les données dans un fichier pickle Lorsque vous appliquez cette fonction, vous verrez le processus d'entraînement commencer. En outre, vous pouvez utiliser l' enregistreur pour vérifier quel modèle est entraîné, quelles configurations sont utilisées et comment les valeurs changent au cours du processus Je vais commenter l'exemple de code qui peut affecter la formation. Exécutons le code d'entraînement. Vous verrez les paramètres de configuration s'afficher. Et au fur et à mesure que le modèle s'entraîne, il contiendra les informations connexes. Vous verrez également qu'un dossier lié à la formation a été créé. Une fois l' apprentissage du modèle terminé, vous verrez que le modèle, le tokenizer, les modèles entraînés pour chaque pli, journaux et O OFDF ont été générés Au cours de cette session, nous avons construit un modèle de régression en nous entraînant sur les données d'examen. Tout au long de ce processus, nous avons écrit le code pour charger les données, effectué un prétraitement simple, créé un modèle avec des méthodes de regroupement et même développé diverses fonctions nécessaires à l'entraînement pour exécuter l'entraînement du modèle. Je pense que la plupart des méthodes et des processus utilisés pour créer le modèle étaient similaires à ceux que vous avez vus auparavant. Dans cette vidéo, certains des aspects utiles incluent l' organisation de la configuration en haut, ce qui nous permet de générer de nouveaux modèles en modifiant simplement cette section lors de l'entraînement. Une fois l' apprentissage du modèle terminé, vous verrez que le tokenizer du modèle de configuration, les modèles entraînés pour chaque pli, journaux et l'OOFDF Au cours de cette session, nous avons construit un modèle de régression en nous entraînant sur les données d'examen. Tout au long de ce processus, nous avons écrit le code pour charger les données, effectué un prétraitement simple, créé un modèle avec des méthodes de regroupement et même développé diverses fonctions nécessaires à l'entraînement pour exécuter l'entraînement du modèle. Je pense que la plupart des méthodes et des processus utilisés pour créer le modèle étaient similaires à ceux que vous avez vus auparavant. Dans cette vidéo, certains des aspects utiles incluent l' organisation et la configuration du haut, ce qui nous permet de générer de nouveaux modèles en modifiant simplement cette section lors de l'entraînement. Bien entendu, il existe de nombreuses façons d'améliorer ce modèle et ce code. Vous pourriez utiliser un modèle plus avancé, modifier le taux d'apprentissage pour chaque couche, bien que nous ne l'ayons pas utilisé ici. Utilisez de meilleures données ou appliquez techniques de prétraitement plus sophistiquées pour obtenir un texte plus clair pour la formation. J'espère que ce code aidera les individus ou les petites équipes à appliquer une analyse de régression en langage naturel. Nous concluons ainsi cette partie cruciale de la formation du modèle. 11. Inférence: Créons maintenant un bloc-notes pour utiliser le modèle entraîné. Créez d'abord un nouveau fichier de bloc-notes et renommez-le en bloc-notes d' inférence Le carnet d'inférence et carnet de train ont une structure presque identique Considérez donc cela comme une opportunité de passer en revue ce que nous avons abordé jusqu'à présent. Nous chargeons les packages nécessaires et définissons l'appareil sur lequel le code sera exécuté. Ensuite, à l'aide de la classe de configuration, nous rassemblons tous les paramètres de configuration en un seul endroit. Dans ce bloc-notes, nous n'avons pas besoin des variables requises pour l'entraînement nous suffit donc de configurer ce qui est nécessaire pour l'inférence Ensuite, nous configurons le tokenizer et correspondre la valeur initiale utilisée pendant Ensuite, nous créons le code de prétraitement et l'enregistreur. Nous utilisons l'enregistreur pour afficher les informations nécessaires lors de l'inférence Nous créons également la métrique d'évaluation et l'utilisons pour calculer le score. Comme pour les données d'entraînement, nous prétraitons les données de test, créons un ensemble de données, puis nous utilisons le chargeur de données pour créer le chargeur de test. Nous utilisons ensuite les mêmes techniques de mise en commun qui ont été cruciales lors de la construction du modèle. Après avoir créé un modèle qui applique ces techniques de regroupement, nous créons une inférence Lorsque nous exécutons cette fonction, nous pouvons voir le modèle effectuer une inférence Comme le modèle a été construit à l'aide de plis, nous effectuons une inférence pour chaque pli H. Comme le modèle a été construit à l'aide de plis, nous effectuons une inférence pour chaque pli Une fois l'inférence terminée, nous pouvons vérifier les résultats Vous verrez que les résultats des données de test sont similaires à ceux obtenus de l'entraînement sur les données d'entraînement. À l'aide de ce bloc-notes, vous pouvez utiliser le modèle entraîné. Enfin, créons un carnet d' ensemble. OK. 12. Ensemble: Ensemble fait référence à la combinaison de plusieurs modèles d'apprentissage automatique pour faire des prédictions. Dans ce cas, j' utilise les mêmes données pour entraîner en plus une petite version du modèle. Nous avons donc deux modèles de base et de petite taille. Dans ce carnet, nous combinerons ces deux modèles à l'aide d'une moyenne pondérée pour créer de nouvelles prédictions. Imaginez que ce bloc-notes exécute le bloc-notes d'inférence plusieurs fois. La différence ici est que nous agrégeons ces résultats pour créer de nouvelles prévisions. Tout d'abord, nous chargeons les packages nécessaires et configurons la configuration. Comme il existe deux modèles, nous aurons deux paramètres de configuration. Nous avons ensuite mis ces paramètres dans une liste. Nous faisons des prédictions pour les deux configurations, puis calculons la moyenne pondérée. Les paramètres de prétraitement et d'évaluation resteront les mêmes. Encore une fois, nous utilisons un enregistreur pour vérifier les modèles et examiner les performances des modèles que nous avons créés précédemment Sur la base des performances de ces modèles, nous attribuons des poids à chaque modèle. Ensuite, nous créons l'ensemble, introduisons les méthodes de regroupement et construisons les modèles de la même manière. À l'aide de la fonction d'inférence, nous générons et les résultats Lorsque vous comparez les résultats, vous remarquerez qu'ils sont différents des prédictions effectuées uniquement à l'aide du modèle de base. Il semble que l'ensemble avec la petite version ait entraîné une performance légèrement moins bonne. Si vous en avez l'occasion, associez-le à d'autres modèles ou à des modèles plus grands, vous obtiendrez peut-être des résultats encore meilleurs 13. Conclusion: Tout au long de ce cours, nous avons exploré le processus de création d' un modèle de régression basé sur les données d'examen et optimisation du modèle à l'aide de diverses techniques. Du prétraitement des données à l'apprentissage des modèles, en passant par l'inférence et l'assemblage. Nous avons abordé les concepts essentiels et les étapes de mise en œuvre à chaque étape. Nous avons notamment appris à interpréter efficacement les données textuelles grâce diverses méthodes de regroupement et à effectuer validation croisée lors de l'entraînement du modèle afin de sélectionner le modèle optimal. Nous avons également examiné comment utiliser les modèles entraînés pour les prévisions et améliorer les performances grâce à l'assemblage de plusieurs J'espère que ce cours vous a permis d'approfondir votre compréhension du traitement du langage naturel et de la construction de modèles de régression, en vous fournissant des connaissances pratiques que vous pourrez appliquer à des projets du monde réel. La clé pour travailler avec des modèles d'apprentissage automatique et d'apprentissage profond réside l'expérimentation et l'amélioration continues. Sur la base de ce que vous avez appris aujourd'hui, je vous encourage à poursuivre le développement vos propres modèles et à viser des performances encore meilleures. Merci d'avoir fait partie de ce voyage.