Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Classification du texte - TensorFlow
L'algorithme Amazon SageMaker AI Text Classification est un TensorFlow algorithme d'apprentissage supervisé qui prend en charge l'apprentissage par transfert avec de nombreux modèles préentraînés issus du [TensorFlow Hub](https://tfhub.dev/). Utilisez l'apprentissage par transfert pour affiner l'un des modèles pré-entraînés disponibles sur votre propre jeu de données, même si une grande quantité de données de texte n'est pas disponible. L'algorithme de classification de texte prend une image en entrée et génère en sortie une probabilité pour chaque étiquette de classe fournie. Les jeux de données de formation doivent être au format CSV. Cette page contient des informations sur les recommandations relatives aux instances Amazon EC2 et des exemples de blocs-notes pour la classification de texte -. TensorFlow
**Topics**
+ [Comment utiliser l' TensorFlow algorithme de classification de texte SageMaker AI](text-classification-tensorflow-how-to-use.md)
+ [Interface d'entrée et de sortie pour l' TensorFlow algorithme de classification de texte](text-classification-tensorflow-inputoutput.md)
+ [Recommandation d'instance Amazon EC2 pour l'algorithme de classification de texte TensorFlow](#text-classification-tensorflow-instances)
+ [Classification du texte - TensorFlow exemples de carnets](#text-classification-tensorflow-sample-notebooks)
+ [Comment TensorFlow fonctionne la classification du texte](text-classification-tensorflow-HowItWorks.md)
+ [TensorFlow Modèles de hub](text-classification-tensorflow-Models.md)
+ [Classification du texte - TensorFlow Hyperparamètres](text-classification-tensorflow-Hyperparameter.md)
+ [Régler une classification de texte - TensorFlow modèle](text-classification-tensorflow-tuning.md)
# Comment utiliser l' TensorFlow algorithme de classification de texte SageMaker AI
Vous pouvez utiliser la classification de texte TensorFlow en tant qu'algorithme intégré d'Amazon SageMaker AI. La section suivante décrit comment utiliser la classification de texte TensorFlow avec le SDK SageMaker AI Python. Pour plus d'informations sur l'utilisation de la classification de texte, TensorFlow depuis l'interface utilisateur Amazon SageMaker Studio Classic, consultez[SageMaker JumpStart modèles préentraînés](studio-jumpstart.md).
L' TensorFlow algorithme de classification du texte prend en charge l'apprentissage par transfert à l'aide de l'un des TensorFlow modèles préentraînés compatibles. Pour obtenir la liste de tous les modèles pré-entraînés disponibles, consultez [TensorFlow Modèles de hub](text-classification-tensorflow-Models.md). Chaque modèle pré-entraîné possède un `model_id` unique. L'exemple suivant utilise BERT Base Uncased (`model_id` : `tensorflow-tc-bert-en-uncased-L-12-H-768-A-12-2`) pour l'affinage sur un jeu de données personnalisé. Les modèles préentraînés sont tous prétéléchargés depuis le TensorFlow Hub et stockés dans des compartiments Amazon S3 afin que les tâches de formation puissent être exécutées de manière isolée sur le réseau. Utilisez ces artefacts d'entraînement de modèles prégénérés pour créer un estimateur d' SageMaker IA.
Tout d'abord, récupérez l'URI de l'image Docker, l'URI du script d'entraînement et l'URI du modèle pré-entraîné. Ensuite, modifiez les hyperparamètres comme bon vous semble. Vous pouvez consulter un dictionnaire Python de tous les hyperparamètres disponibles et de leurs valeurs par défaut avec `hyperparameters.retrieve_default`. Pour de plus amples informations, veuillez consulter [Classification du texte - TensorFlow Hyperparamètres](text-classification-tensorflow-Hyperparameter.md). Utilisez ces valeurs pour créer un estimateur SageMaker AI.
**Note**
Les valeurs par défaut des hyperparamètres sont différentes selon les modèles. Par exemple, pour les modèles plus grands, la taille de lot par défaut est inférieure.
Cet exemple utilise le jeu de données [https://www.tensorflow.org/datasets/catalog/glue#gluesst2](https://www.tensorflow.org/datasets/catalog/glue#gluesst2), qui contient des critiques de films positives et négatives. Nous avons pré-téléchargé le jeu de données et l'avons mis à disposition avec Amazon S3. Pour affiner votre modèle, appelez `.fit` à l'aide de l'emplacement Amazon S3 de votre jeu de données d'entraînement. Tout compartiment S3 utilisé dans un bloc-notes doit se trouver dans la même AWS région que l'instance de bloc-notes qui y accède.
```
from sagemaker import image_uris, model_uris, script_uris, hyperparameters
from sagemaker.estimator import Estimator
model_id, model_version = "tensorflow-tc-bert-en-uncased-L-12-H-768-A-12-2", "*"
training_instance_type = "ml.p3.2xlarge"
# Retrieve the Docker image
train_image_uri = image_uris.retrieve(model_id=model_id,model_version=model_version,image_scope="training",instance_type=training_instance_type,region=None,framework=None)
# Retrieve the training script
train_source_uri = script_uris.retrieve(model_id=model_id, model_version=model_version, script_scope="training")
# Retrieve the pretrained model tarball for transfer learning
train_model_uri = model_uris.retrieve(model_id=model_id, model_version=model_version, model_scope="training")
# Retrieve the default hyperparameters for fine-tuning the model
hyperparameters = hyperparameters.retrieve_default(model_id=model_id, model_version=model_version)
# [Optional] Override default hyperparameters with custom values
hyperparameters["epochs"] = "5"
# Sample training data is available in this bucket
training_data_bucket = f"jumpstart-cache-prod-{aws_region}"
training_data_prefix = "training-datasets/SST2/"
training_dataset_s3_path = f"s3://{training_data_bucket}/{training_data_prefix}"
output_bucket = sess.default_bucket()
output_prefix = "jumpstart-example-tc-training"
s3_output_location = f"s3://{output_bucket}/{output_prefix}/output"
# Create an Estimator instance
tf_tc_estimator = Estimator(
role=aws_role,
image_uri=train_image_uri,
source_dir=train_source_uri,
model_uri=train_model_uri,
entry_point="transfer_learning.py",
instance_count=1,
instance_type=training_instance_type,
max_run=360000,
hyperparameters=hyperparameters,
output_path=s3_output_location,
)
# Launch a training job
tf_tc_estimator.fit({"training": training_dataset_s3_path}, logs=True)
```
Pour plus d'informations sur l'utilisation de l' TensorFlowalgorithme de classification de SageMaker texte pour l'apprentissage par transfert sur un ensemble de données personnalisé, consultez le bloc-notes [Introduction à JumpStart la classification de texte](https://github.com/aws/amazon-sagemaker-examples/blob/main/introduction_to_amazon_algorithms/jumpstart_text_classification/Amazon_JumpStart_Text_Classification.ipynb).
# Interface d'entrée et de sortie pour l' TensorFlow algorithme de classification de texte
Chacun des modèles préentraînés répertoriés dans TensorFlow Hub Models peut être affiné pour n'importe quel ensemble de données composé de phrases de texte comportant un nombre quelconque de classes. Le modèle pré-entraîné associe une couche de classification au modèle d'intégration de texte et initialise les paramètres de la couche sur des valeurs aléatoires. La dimension de sortie de la couche de classification est déterminée en fonction du nombre de classes détectées dans les données d'entrée.
Sachez comment formater vos données d'entraînement pour les saisir dans le TensorFlow modèle de classification de texte.
+ **Format d'entrée des données d'entraînement :** répertoire contenant un fichier `data.csv`. Chaque ligne de la première colonne doit comporter des étiquettes de classe entières comprises entre 0 et le nombre de classes. Chaque ligne de la seconde colonne doit contenir les données de type correspondant.
Voici un exemple de fichier CSV d'entrée. Notez que le fichier ne doit pas avoir d'en-tête. Le fichier doit être hébergé dans un compartiment Amazon S3 avec un chemin similaire au suivant : `s3://bucket_name/input_directory/`. Notez que le `/` de fin est obligatoire.
```
| | |
|---|---|
|0 |hide new secretions from the parental units|
|0 |contains no wit , only labored gags|
|1 |that loves its characters and communicates something rather beautiful about human nature|
|...|...|
```
## Entraînement incrémentiel
Vous pouvez amorcer l'entraînement d'un nouveau modèle avec des artefacts provenant d'un modèle que vous avez déjà entraîné avec l' SageMaker IA. L'entraînement incrémentiel permet de gagner du temps lorsque vous souhaitez entraîner un nouveau modèle avec des données identiques ou similaires.
**Note**
Vous ne pouvez créer qu'un modèle de classification de texte basé sur l' SageMaker IA ( TensorFlow modèle avec un autre TensorFlow modèle de classification de texte) entraîné par l' SageMaker IA.
Vous pouvez utiliser n'importe quel jeu de données pour l'entraînement incrémentiel, à condition que l'ensemble de classes reste le même. L'étape d'entraînement incrémentiel est similaire à l'étape d'affinage, mais au lieu de commencer par un modèle pré-entraîné, vous commencez par un modèle affiné existant.
Pour plus d'informations sur l'utilisation de l'entraînement incrémentiel avec l' TensorFlow algorithme de classification de texte SageMaker AI, consultez le bloc-notes d'exemple [Introduction à JumpStart la classification de texte](https://github.com/aws/amazon-sagemaker-examples/blob/main/introduction_to_amazon_algorithms/jumpstart_text_classification/Amazon_JumpStart_Text_Classification.ipynb).
## Inférence avec l'algorithme de classification de texte TensorFlow
Vous pouvez héberger le modèle affiné issu de votre formation en classification de TensorFlow texte à des fins d'inférence. Tous les formats de texte brut pour l'inférence doivent avoir le type de contenu `application/x-text`.
L'exécution de l'inférence permet d'obtenir des valeurs de probabilité, des étiquettes de classe pour toutes les classes et l'étiquette prédite correspondant à l'indice de classe présentant la probabilité la plus élevée, codé au format JSON. Le TensorFlow modèle Classification de texte traite une seule chaîne par demande et ne produit qu'une seule ligne. Voici un exemple de réponse au format JSON :
```
accept: application/json;verbose
{"probabilities": [prob_0, prob_1, prob_2, ...],
"labels": [label_0, label_1, label_2, ...],
"predicted_label": predicted_label}
```
Si `accept` a pour valeur `application/json`, le modèle génère en sortie uniquement des probabilités.
## Recommandation d'instance Amazon EC2 pour l'algorithme de classification de texte TensorFlow
L' TensorFlow algorithme Text Classification prend en charge toutes les instances de CPU et de GPU pour l'entraînement, notamment :
+ `ml.p2.xlarge`
+ `ml.p2.16xlarge`
+ `ml.p3.2xlarge`
+ `ml.p3.16xlarge`
+ `ml.g4dn.xlarge`
+ `ml.g4dn.16.xlarge`
+ `ml.g5.xlarge`
+ `ml.g5.48xlarge`
Nous recommandons d'utiliser les instances de GPU avec davantage de mémoire pour l'entraînement avec de grandes tailles de lot. Les instances de CPU (telles que M5) et de GPU (P2, P3, G4dn ou G5) peuvent être utilisées pour l'inférence. Pour obtenir une liste complète des instances de SageMaker formation et d'inférence dans toutes AWS les régions, consultez [Amazon SageMaker Pricing](https://aws.amazon.com/sagemaker/pricing/).
## Classification du texte - TensorFlow exemples de carnets
Pour plus d'informations sur l'utilisation de l' TensorFlow algorithme de classification de texte SageMaker AI pour l'apprentissage par transfert sur un ensemble de données personnalisé, consultez le bloc-notes [Introduction to JumpStart - Classification de texte](https://github.com/aws/amazon-sagemaker-examples/blob/main/introduction_to_amazon_algorithms/jumpstart_text_classification/Amazon_JumpStart_Text_Classification.ipynb).
Pour savoir comment créer et accéder à des instances de bloc-notes Jupyter que vous pouvez utiliser pour exécuter l'exemple dans SageMaker AI, consultez. [Instances de SageMaker blocs-notes Amazon](nbi.md) Après avoir créé une instance de bloc-notes et l'avoir ouverte, sélectionnez l'onglet **Exemples d'SageMaker IA** pour voir la liste de tous les exemples d' SageMaker IA. Pour ouvrir un bloc-notes, choisissez son onglet **Use** (Utiliser), puis **Create copy** (Créer une copie).
# Comment TensorFlow fonctionne la classification du texte
L' TensorFlow algorithme Classification du texte prend le texte tel qu'il le classe dans l'une des étiquettes de classe de sortie. Les réseaux de deep learning tels que [BERT](https://arxiv.org/pdf/1810.04805.pdf) sont très précis pour la classification textuelle. Il existe également des réseaux d'apprentissage en profondeur formés sur de grands ensembles de données textuels TextNet, tels que ceux qui contiennent plus de 11 millions de textes avec environ 11 000 catégories. Une fois qu'un réseau a été entraîné avec TextNet des données, vous pouvez affiner le réseau sur un jeu de données en mettant un accent particulier sur l'exécution de tâches de classification de texte plus spécifiques. L' TensorFlow algorithme Amazon SageMaker AI Text Classification prend en charge l'apprentissage par transfert sur de nombreux modèles préentraînés disponibles dans le TensorFlow Hub.
En fonction du nombre d'étiquettes de cours figurant dans vos données d'entraînement, une couche de classification de texte est attachée au TensorFlow modèle préentraîné de votre choix. La couche de classification se compose d'une couche d'abandon, d'une couche dense et d'une couche entièrement connectée avec une régularisation à 2 normes, et est initialisé avec des pondérations aléatoires. Vous pouvez modifier les valeurs d'hyperparamètre pour le taux d'abandon de la couche d'abandon et le facteur de régularisation L2 pour la couche dense.
Vous pouvez affiner le réseau entier (y compris le modèle pré-entraîné) ou uniquement la couche de classification supérieure sur les nouvelles données d'entraînement. Avec cette méthode d'apprentissage par transfert, un entraînement avec des jeux de données plus petits est possible.
# TensorFlow Modèles de hub
Les modèles préentraînés suivants peuvent être utilisés pour l'apprentissage par transfert avec l' TensorFlow algorithme de classification de texte.
Les modèles suivants varient de manière significative par leur taille, le nombre de paramètres de modèle, la durée d'entraînement et la latence d'inférence pour n'importe quel jeu de données. Le meilleur modèle pour votre cas d'utilisation dépend de la complexité de l'affinage du jeu de données et de toutes vos exigences en matière de durée d'entraînement, de latence d'inférence ou de précision du modèle.
| Nom du modèle | `model_id` | Source |
| --- | --- | --- |
| BERT Base Uncased | `tensorflow-tc-bert-en-uncased-L-12-H-768-A-12-2` | [TensorFlow Lien vers le hub](https://tfhub.dev/tensorflow/bert_en_uncased_L-12_H-768_A-12/3) |
| BERT Base Cased | `tensorflow-tc-bert-en-cased-L-12-H-768-A-12-2` | [TensorFlow Lien vers le hub](https://tfhub.dev/tensorflow/bert_en_cased_L-12_H-768_A-12/3) |
| BERT Base Multilingual Cased | `tensorflow-tc-bert-multi-cased-L-12-H-768-A-12-2` | [TensorFlow Lien vers le hub](https://tfhub.dev/tensorflow/bert_multi_cased_L-12_H-768_A-12/3) |
| Small BERT L-2\$1H-128\$1A-2 | `tensorflow-tc-small-bert-bert-en-uncased-L-2-H-128-A-2` | [TensorFlow Lien vers le hub](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-2_H-128_A-2/1) |
| Small BERT L-2\$1H-256\$1A-4 | `tensorflow-tc-small-bert-bert-en-uncased-L-2-H-256-A-4` | [TensorFlow Lien vers le hub](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-2_H-256_A-4/1) |
| Small BERT L-2\$1H-512\$1A-8 | `tensorflow-tc-small-bert-bert-en-uncased-L-2-H-512-A-8` | [TensorFlow Lien vers le hub](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-2_H-512_A-8/1) |
| Small BERT L-2\$1H-768\$1A-12 | `tensorflow-tc-small-bert-bert-en-uncased-L-2-H-768-A-12` | [TensorFlow Lien vers le hub](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-2_H-768_A-12/1) |
| Small BERT L-4\$1H-128\$1A-2 | `tensorflow-tc-small-bert-bert-en-uncased-L-4-H-128-A-2` | [TensorFlow Lien vers le hub](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-4_H-128_A-2/1) |
| Small BERT L-4\$1H-256\$1A-4 | `tensorflow-tc-small-bert-bert-en-uncased-L-4-H-256-A-4` | [TensorFlow Lien vers le hub](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-4_H-256_A-4/1) |
| Small BERT L-4\$1H-512\$1A-8 | `tensorflow-tc-small-bert-bert-en-uncased-L-4-H-512-A-8` | [TensorFlow Lien vers le hub](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-4_H-512_A-8/1) |
| Small BERT L-4\$1H-768\$1A-12 | `tensorflow-tc-small-bert-bert-en-uncased-L-4-H-768-A-12` | [TensorFlow Lien vers le hub](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-4_H-768_A-12/1) |
| Small BERT L-6\$1H-128\$1A-2 | `tensorflow-tc-small-bert-bert-en-uncased-L-6-H-128-A-2` | [TensorFlow Lien vers le hub](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-6_H-128_A-2/1) |
| Small BERT L-6\$1H-256\$1A-4 | `tensorflow-tc-small-bert-bert-en-uncased-L-6-H-256-A-4` | [TensorFlow Lien vers le hub](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-6_H-256_A-4/1) |
| Small BERT L-6\$1H-512\$1A-8 | `tensorflow-tc-small-bert-bert-en-uncased-L-6-H-512-A-8` | [TensorFlow Lien vers le hub](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-6_H-512_A-8/1) |
| Small BERT L-6\$1H-768\$1A-12 | `tensorflow-tc-small-bert-bert-en-uncased-L-6-H-768-A-12` | [TensorFlow Lien vers le hub](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-6_H-768_A-12/1) |
| Small BERT L-8\$1H-128\$1A-2 | `tensorflow-tc-small-bert-bert-en-uncased-L-8-H-128-A-2` | [TensorFlow Lien vers le hub](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-8_H-128_A-2/1) |
| Small BERT L-8\$1H-256\$1A-4 | `tensorflow-tc-small-bert-bert-en-uncased-L-8-H-256-A-4` | [TensorFlow Lien vers le hub](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-8_H-256_A-4/1) |
| Small BERT L-8\$1H-512\$1A-8 | `tensorflow-tc-small-bert-bert-en-uncased-L-8-H-512-A-8` | [TensorFlow Lien vers le hub](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-8_H-512_A-8/1) |
| Small BERT L-8\$1H-768\$1A-12 | `tensorflow-tc-small-bert-bert-en-uncased-L-8-H-768-A-12` | [TensorFlow Lien vers le hub](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-8_H-768_A-12/1) |
| Small BERT L-10\$1H-128\$1A-2 | `tensorflow-tc-small-bert-bert-en-uncased-L-10-H-128-A-2` | [TensorFlow Lien vers le hub](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-10_H-128_A-2/1) |
| Small BERT L-10\$1H-256\$1A-4 | `tensorflow-tc-small-bert-bert-en-uncased-L-10-H-256-A-4` | [TensorFlow Lien vers le hub](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-10_H-256_A-4/1) |
| Small BERT L-10\$1H-512\$1A-8 | `tensorflow-tc-small-bert-bert-en-uncased-L-10-H-512-A-8` | [TensorFlow Lien vers le hub](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-10_H-512_A-8/1) |
| Small BERT L-10\$1H-768\$1A-12 | `tensorflow-tc-small-bert-bert-en-uncased-L-10-H-768-A-12` | [TensorFlow Lien vers le hub](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-10_H-768_A-12/1) |
| Small BERT L-12\$1H-128\$1A-2 | `tensorflow-tc-small-bert-bert-en-uncased-L-12-H-128-A-2` | [TensorFlow Lien vers le hub](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-12_H-128_A-2/1) |
| Small BERT L-12\$1H-256\$1A-4 | `tensorflow-tc-small-bert-bert-en-uncased-L-12-H-256-A-4` | [TensorFlow Lien vers le hub](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-12_H-256_A-4/1) |
| Small BERT L-12\$1H-512\$1A-8 | `tensorflow-tc-small-bert-bert-en-uncased-L-12-H-512-A-8` | [TensorFlow Lien vers le hub](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-12_H-512_A-8/1) |
| Small BERT L-12\$1H-768\$1A-12 | `tensorflow-tc-small-bert-bert-en-uncased-L-12-H-768-A-12` | [TensorFlow Lien vers le hub](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-12_H-768_A-12/1) |
| BERT Large Uncased | `tensorflow-tc-bert-en-uncased-L-24-H-1024-A-16-2` | [TensorFlow Lien vers le hub](https://tfhub.dev/tensorflow/bert_en_uncased_L-24_H-1024_A-16/3) |
| BERT Large Cased | `tensorflow-tc-bert-en-cased-L-24-H-1024-A-16-2` | [TensorFlow Lien vers le hub](https://tfhub.dev/tensorflow/bert_en_cased_L-24_H-1024_A-16/3) |
| BERT Large Uncased Whole Word Masking | `tensorflow-tc-bert-en-wwm-uncased-L-24-H-1024-A-16-2` | [TensorFlow Lien vers le hub](https://tfhub.dev/tensorflow/bert_en_wwm_uncased_L-24_H-1024_A-16/3) |
| BERT Large Cased Whole Word Masking | `tensorflow-tc-bert-en-wwm-cased-L-24-H-1024-A-16-2` | [TensorFlow Lien vers le hub](https://tfhub.dev/tensorflow/bert_en_wwm_cased_L-24_H-1024_A-16/3) |
| ALBERT Base | `tensorflow-tc-albert-en-base` | [TensorFlow Lien vers le hub](https://tfhub.dev/tensorflow/albert_en_base/2) |
| ELECTRA Small\$1\$1 | `tensorflow-tc-electra-small-1` | [TensorFlow Lien vers le hub](https://tfhub.dev/google/electra_small/2) |
| ELECTRA Base | `tensorflow-tc-electra-base-1` | [TensorFlow Lien vers le hub](https://tfhub.dev/google/electra_base/2) |
| BERT Base Wikipedia et BooksCorpus | `tensorflow-tc-experts-bert-wiki-books-1` | [TensorFlow Lien vers le hub](https://tfhub.dev/google/experts/bert/wiki_books/2) |
| BERT Base MEDLINE/ PubMed | `tensorflow-tc-experts-bert-pubmed-1` | [TensorFlow Lien vers le hub](https://tfhub.dev/google/experts/bert/pubmed/2) |
| Talking Heads Base | `tensorflow-tc-talking-heads-base` | [TensorFlow Lien vers le hub](https://tfhub.dev/tensorflow/talkheads_ggelu_bert_en_base/1) |
| Talking Heads Large | `tensorflow-tc-talking-heads-large` | [TensorFlow Lien vers le hub](https://tfhub.dev/tensorflow/talkheads_ggelu_bert_en_large/1) |
# Classification du texte - TensorFlow Hyperparamètres
Les hyperparamètres sont des paramètres définis avant qu'un modèle de machine learning ne commence à apprendre. Les hyperparamètres suivants sont pris en charge par l' TensorFlow algorithme intégré de détection d'objets d'Amazon SageMaker AI. Consultez [Régler une classification de texte - TensorFlow modèle](text-classification-tensorflow-tuning.md) pour obtenir des informations sur le réglage des hyperparamètres.
| Nom du paramètre | Description |
| --- | --- |
| batch\$1size | Taille de lot pour l'entraînement. Pour la formation sur des instances comportant plusieurs instances GPUs, cette taille de lot est utilisée sur l'ensemble du GPUs. Valeurs valides : nombre entier positif. Valeur par défaut : `32`. |
| beta\$11 | Version beta1 des optimiseurs `"adam"` et `"adamw"`. Représente le taux de dégradation exponentielle pour les estimations du premier moment. Ignoré pour les autres optimiseurs. Valeurs valides : valeur à virgule flottante, plage : [`0.0`, `1.0`]. Valeur par défaut : `0.9`. |
| beta\$12 | Version beta2 des optimiseurs `"adam"` et `"adamw"`. Représente le taux de dégradation exponentielle pour les estimations du second moment. Ignoré pour les autres optimiseurs. Valeurs valides : valeur à virgule flottante, plage : [`0.0`, `1.0`]. Valeur par défaut : `0.999`. |
| dropout\$1rate | Taux d'abandon pour la couche d'abandon au niveau de la couche de classification supérieure. Utilisé uniquement quand `reinitialize_top_layer` a pour valeur `"True"`. Valeurs valides : valeur à virgule flottante, plage : [`0.0`, `1.0`]. Valeur par défaut : `0.2` |
| early\$1stopping | Définissez ce paramètre sur `"True"` pour utiliser une logique d'arrêt anticipé au cours de l'entraînement. S'il a pour valeur `"False"`, l'arrêt anticipé n'est pas utilisé. Valeurs valides : chaîne, valeur : (`"True"` ou `"False"`). Valeur par défaut : `"False"`. |
| early\$1stopping\$1min\$1delta | Modification minimale requise pour être considérée comme une amélioration. Une modification absolue inférieure à la valeur de early\$1stopping\$1min\$1delta ne constitue pas une amélioration. Utilisé uniquement quand early\$1stopping a pour valeur "True".Valeurs valides : valeur à virgule flottante, plage : [`0.0`, `1.0`].Valeur par défaut : `0.0`. |
| early\$1stopping\$1patience | Nombre d'époques pour continuer l'entraînement sans amélioration. Utilisé uniquement quand `early_stopping` a pour valeur `"True"`. Valeurs valides : nombre entier positif. Valeur par défaut : `5`. |
| epochs | Nombre de dates epoch d'entraînement. Valeurs valides : nombre entier positif. Valeur par défaut : `10`. |
| epsilon | Epsilon des optimiseurs `"adam"`, `"rmsprop"`, `"adadelta"` et `"adagrad"`. Généralement défini sur une petite valeur pour éviter la division par 0. Ignoré pour les autres optimiseurs. Valeurs valides : valeur à virgule flottante, plage : [`0.0`, `1.0`]. Valeur par défaut : `1e-7`. |
| initial\$1accumulator\$1value | Valeur de départ pour les accumulateurs, ou valeurs de moment par paramètre, pour l'optimiseur `"adagrad"`. Ignoré pour les autres optimiseurs. Valeurs valides : valeur à virgule flottante, plage : [`0.0`, `1.0`]. Valeur par défaut : `0.0001`. |
| learning\$1rate | Taux d'apprentissage de l'optimiseur. Valeurs valides : valeur à virgule flottante, plage : [`0.0`, `1.0`].Valeur par défaut : `0.001`. |
| momentum | Moment pour les optimiseurs `"sgd"` et `"nesterov"`. Ignoré pour les autres optimiseurs. Valeurs valides : valeur à virgule flottante, plage : [`0.0`, `1.0`]. Valeur par défaut : `0.9`. |
| optimizer | Type d'optimiseur. Pour plus d'informations, consultez la section [Optimiseurs](https://www.tensorflow.org/api_docs/python/tf/keras/optimizers) dans la TensorFlow documentation. Valeurs valides : chaîne, l'une des valeurs suivantes : (`"adamw"`, `"adam"`, `"sgd"`, `"nesterov"`, `"rmsprop"`, ` "adagrad"`, `"adadelta"`). Valeur par défaut : `"adam"`. |
| regularizers\$1l2 | Facteur de régularisation L2 pour la couche dense au niveau de la couche de classification. Utilisé uniquement quand `reinitialize_top_layer` a pour valeur `"True"`. Valeurs valides : valeur à virgule flottante, plage : [`0.0`, `1.0`]. Valeur par défaut : `0.0001`. |
| reinitialize\$1top\$1layer | Si ce paramètre a pour valeur `"Auto"`, les paramètres de la couche de classification supérieure sont réinitialisés au cours de l'affinage. Pour l'entraînement incrémentiel, les paramètres de la couche de classification supérieure ne sont pas réinitialisés à moins d'être définis sur `"True"`. Valeurs valides : chaîne, l'une des valeurs suivantes : (`"Auto"`, `"True"` ou `"False"`). Valeur par défaut : `"Auto"`. |
| rho | Facteur de déduction pour le gradient des optimiseurs `"adadelta"` et `"rmsprop"`. Ignoré pour les autres optimiseurs. Valeurs valides : valeur à virgule flottante, plage : [`0.0`, `1.0`]. Valeur par défaut : `0.95`. |
| train\$1only\$1on\$1top\$1layer | S'il a pour valeur `"True"`, seuls les paramètres de la couche de classification supérieure sont ajustés. S'il a pour valeur `"False"`, tous les paramètres du modèle sont affinés. Valeurs valides : chaîne, valeur : (`"True"` ou `"False"`). Valeur par défaut : `"False"`. |
| validation\$1split\$1ratio | Fraction des données d'entraînement à diviser de manière aléatoire pour créer des données de validation. Utilisé uniquement si les données de validation ne sont pas fournies via le canal `validation`. Valeurs valides : valeur à virgule flottante, plage : [`0.0`, `1.0`]. Valeur par défaut : `0.2`. |
| warmup\$1steps\$1fraction | Fraction du nombre total d'étapes de mise à jour du gradient, au cours de laquelle le taux d'apprentissage passe de 0 au taux d'apprentissage initial en guise d'échauffement. Utilisé uniquement avec l'optimiseur `adamw`. Valeurs valides : valeur à virgule flottante, plage : [`0.0`, `1.0`]. Valeur par défaut : `0.1`. |
# Régler une classification de texte - TensorFlow modèle
Le *réglage de modèle automatique*, ou réglage d'hyperparamètre, détecte la meilleure version d'un modèle en exécutant plusieurs tâches qui testent une plage d'hyperparamètres sur votre jeu de données. Vous choisissez les hyperparamètres réglables, une plage de valeurs pour chacun d'eux et une métrique d'objectif. Vous choisissez la métrique d'objectif parmi les métriques que calcule l'algorithme. Le réglage de modèle automatique recherche parmi les hyperparamètres choisis la combinaison de valeurs qui produira un modèle permettant d'optimiser la métrique d'objectif.
Pour plus d'informations sur le réglage de modèle, consultez [Réglage automatique du modèle grâce à l' SageMaker IA](automatic-model-tuning.md).
## Métriques calculées par l' TensorFlow algorithme de classification du texte
Reportez-vous au tableau suivant pour savoir quelles mesures sont calculées par l' TensorFlow algorithme de classification de texte.
| Nom de la métrique | Description | Orientation de l'optimisation | Motif Regex |
| --- | --- | --- | --- |
| validation:accuracy | Rapport entre le nombre de prédictions correctes et le nombre total de prédictions effectuées. | Agrandir | `val_accuracy=([0-9\\.]+)` |
## Classification de texte réglable - hyperparamètres TensorFlow
Réglez un modèle de classification de texte à l'aide des hyperparamètres ci-dessous. Les hyperparamètres ayant le plus grand impact sur les métriques d'objectif de la classification de texte sont les suivants : `batch_size`, `learning_rate` et `optimizer`. Réglez les hyperparamètres associés à l'optimiseur, tels que `momentum`, `regularizers_l2`, `beta_1`, `beta_2` et `eps`, en fonction de l'`optimizer` sélectionné. Par exemple, utilisez `beta_1` et `beta_2` uniquement si `adamw` ou `adam` est le `optimizer`.
Pour plus d'informations sur les hyperparamètres qui sont utilisés pour chaque `optimizer`, consultez [Classification du texte - TensorFlow Hyperparamètres](text-classification-tensorflow-Hyperparameter.md).
| Nom du paramètre | Type de paramètre | Plages recommandées |
| --- | --- | --- |
| batch\$1size | IntegerParameterRanges | MinValue: 4, MaxValue 128 |
| beta\$11 | ContinuousParameterRanges | MinValue: 1e-6, 0,99 MaxValue |
| beta\$12 | ContinuousParameterRanges | MinValue: 1e-6, 0,99 MaxValue |
| eps | ContinuousParameterRanges | MinValue: 1e-8, MaxValue : 1,0 |
| learning\$1rate | ContinuousParameterRanges | MinValue: 1e-6, MaxValue : 0,5 |
| momentum | ContinuousParameterRanges | MinValue: 0,0, MaxValue 0,99 |
| optimizer | CategoricalParameterRanges | ['adamw', 'adam', 'sgd', 'rmsprop', 'nesterov', 'adagrad', 'adadelta'] |
| regularizers\$1l2 | ContinuousParameterRanges | MinValue: 0,0, MaxValue 0,99 |
| train\$1only\$1on\$1top\$1layer | CategoricalParameterRanges | ['True', 'False'] |