

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.

# Cadres et langages de machine learning
<a name="frameworks"></a>

Amazon SageMaker AI fournit un support natif pour les langages de programmation et les frameworks d'apprentissage automatique les plus courants, permettant aux développeurs et aux data scientists de tirer parti de leurs outils et technologies préférés. Cette section propose des références pour travailler avec Python et R, ainsi que leurs kits de développement logiciel respectifs (SDKs) dans le cadre de l' SageMaker IA. En outre, il couvre un large éventail de frameworks d'apprentissage automatique et d'apprentissage profond, notamment Apache MXNet, PyTorch, TensorFlow. 

Vous pouvez utiliser Python et R de manière native dans les noyaux des SageMaker blocs-notes Amazon. Il existe également des noyaux qui prennent en charge des frameworks spécifiques. Une méthode très populaire pour démarrer avec l' SageMaker IA consiste à utiliser le [SDK Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable). Il fournit du Python open source APIs et des conteneurs qui facilitent la formation et le déploiement de modèles dans le domaine de l' SageMaker IA, ainsi que des exemples à utiliser avec différents frameworks d'apprentissage automatique et d'apprentissage profond.

Pour plus d'informations sur l'utilisation de frameworks spécifiques ou sur l'utilisation de R dans l' SageMaker IA, consultez les rubriques suivantes.

Langues SDKs et guides d'utilisation :
+ [Kit de développement logiciel Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable)
+ [R](r-guide.md)
+ [Référence d’API](api-and-sdk-reference.md)

Guides des frameworks de machine learning et de deep learning :
+ [Apache MXNet](mxnet.md)
+ [Apache Spark](apache-spark.md)
+ [Chainer](chainer.md)
+ [Hugging Face](hugging-face.md)
+ [PyTorch](pytorch.md)
+ [Scikit-learn](sklearn.md)
+ [SparkML Serving](sparkml-serving.md)
+ [TensorFlow](tf.md)
+ [Serveur d’inférence Triton](triton.md)

# Ressources pour utiliser Apache MXNet avec Amazon SageMaker AI
<a name="mxnet"></a>

Les MXNet estimateurs et modèles du [SDK Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable) ainsi que le MXNet conteneur open source SageMaker AI facilitent l'écriture d'un MXNet script et son exécution dans l'IA. SageMaker La section suivante fournit des documents de référence que vous pouvez utiliser pour apprendre à utiliser l' SageMaker IA pour entraîner et déployer un modèle à l'aide d'un MXNet code personnalisé. 

## Que souhaitez-vous faire ?
<a name="mxnet-intent"></a>

Je souhaite entraîner un MXNet modèle personnalisé en SageMaker IA.  
Pour obtenir de la documentation, voir [Entraîner un modèle avec MXNet](https://sagemaker.readthedocs.io/en/stable/using_mxnet.html#train-a-model-with-mxnet).

J'ai un MXNet modèle que j'ai formé à l' SageMaker IA et je souhaite le déployer sur un terminal hébergé.  
Pour plus d'informations, consultez la section [Déployer MXNet des modèles](https://sagemaker.readthedocs.io/en/stable/using_mxnet.html#deploy-mxnet-models).

J'ai un MXNet modèle que j'ai formé en dehors de l' SageMaker IA et je souhaite le déployer sur un point de terminaison basé sur SageMaker l'IA  
Pour plus d’informations, consultez [Déploiement de points de terminaison à partir de données de modèle](https://sagemaker.readthedocs.io/en/stable/using_mxnet.html#deploy-endpoints-from-model-data).

Je souhaite consulter la documentation de l'API pour les MXNet classes du [SDK Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable).  
Pour plus d'informations, consultez la section [MXNet Classes](https://sagemaker.readthedocs.io/en/stable/frameworks/mxnet/sagemaker.mxnet.html). 

Je souhaite trouver le référentiel de MXNet conteneurs SageMaker AI.  
Pour plus d'informations, consultez le [ GitHub référentiel SageMaker AI MXNet Container](https://github.com/aws/sagemaker-mxnet-container).

Je souhaite obtenir des informations sur les MXNet versions prises en charge par AWS Deep Learning Containers.  
Pour plus d’informations, consultez [Images Deep Learning Containers disponibles](https://github.com/aws/deep-learning-containers/blob/master/available_images.md).

 Pour des informations générales sur l'écriture de scripts d'entraînement en mode MXNet MXNet script et l'utilisation d'estimateurs et de modèles en mode script avec l' SageMaker IA, consultez la section [Utilisation MXNet avec le SDK SageMaker Python](https://sagemaker.readthedocs.io/en/stable/using_mxnet.html).

# Apache Spark avec Amazon SageMaker AI
<a name="apache-spark"></a>

Amazon SageMaker AI Spark est une bibliothèque Spark open source qui vous aide à créer des pipelines d'apprentissage automatique (ML) Spark avec l' SageMaker IA. Cela simplifie l'intégration des stages Spark ML aux stages d' SageMaker IA, tels que la formation et l'hébergement des modèles. Pour plus d'informations sur SageMaker AI Spark, consultez le GitHub référentiel [SageMaker AI Spark](https://github.com/aws/sagemaker-spark). Les rubriques suivantes fournissent des informations pour apprendre à utiliser Apache Spark avec l' SageMaker IA.

La bibliothèque SageMaker AI Spark est disponible en Python et en Scala. Vous pouvez utiliser SageMaker AI Spark pour entraîner des modèles dans l' SageMaker IA à l'aide de trames de `org.apache.spark.sql.DataFrame` données dans vos clusters Spark. Après la formation du modèle, vous pouvez également héberger le modèle à l'aide des services d'hébergement SageMaker AI. 

La bibliothèque SageMaker AI Spark fournit`com.amazonaws.services.sagemaker.sparksdk`, entre autres, les classes suivantes :
+ `SageMakerEstimator` : étend l’interface `org.apache.spark.ml.Estimator`. Vous pouvez utiliser cet estimateur pour l'entraînement de modèles dans SageMaker le domaine de l'IA.
+ `KMeansSageMakerEstimator`, `PCASageMakerEstimator` et `XGBoostSageMakerEstimator` : étendent la classe `SageMakerEstimator`. 
+ `SageMakerModel` : étend la classe `org.apache.spark.ml.Model`. Vous pouvez l'utiliser `SageMakerModel` pour héberger des modèles et obtenir des inférences dans l' SageMaker IA.

Vous pouvez télécharger le code source des bibliothèques Python Spark (PySpark) et Scala depuis le GitHub référentiel [SageMaker AI Spark](https://github.com/aws/sagemaker-spark).

Pour l'installation et des exemples de la bibliothèque SageMaker AI Spark, consultez [SageMaker Exemples d'AI Spark pour Scala](apache-spark-example1.md) ou[Ressources pour utiliser les exemples d' SageMaker AI Spark pour Python (PySpark)](apache-spark-additional-examples.md).

Si vous utilisez Amazon EMR AWS pour gérer des clusters Spark, consultez [Apache](https://aws.amazon.com/emr/features/spark/) Spark. Pour plus d'informations sur l'utilisation d'Amazon EMR dans l' SageMaker IA, consultez. [Préparation des données à l’aide d’Amazon EMR](studio-notebooks-emr-cluster.md)

**Topics**
+ [Intégrez votre application Apache Spark à l' SageMaker IA](#spark-sdk-common-process)
+ [SageMaker Exemples d'AI Spark pour Scala](apache-spark-example1.md)
+ [Ressources pour utiliser les exemples d' SageMaker AI Spark pour Python (PySpark)](apache-spark-additional-examples.md)

## Intégrez votre application Apache Spark à l' SageMaker IA
<a name="spark-sdk-common-process"></a>

Voici un résumé détaillé des étapes d'intégration de votre application Apache Spark à l' SageMaker IA.

1. Poursuivez le prétraitement des données en utilisant la bibliothèque Apache Spark que vous connaissez. Votre ensemble de données demeure un `DataFrame` dans votre cluster Spark. Chargez vos données dans un `DataFrame`. Effectuez-en un prétraitement de manière à disposer d’une colonne `features` avec `org.apache.spark.ml.linalg.Vector` de `Doubles`, et une colonne `label` facultative avec des valeurs de type `Double`.

1. Utilisez l'estimateur de la bibliothèque SageMaker AI Spark pour entraîner votre modèle. Par exemple, si vous choisissez l'algorithme k-means fourni par l' SageMaker IA pour l'entraînement des modèles, appelez la `KMeansSageMakerEstimator.fit` méthode. 

   Fournissez votre `DataFrame` comme entrée. L’évaluateur renvoie un objet `SageMakerModel`. 
**Note**  
`SageMakerModel` étend le modèle `org.apache.spark.ml.Model`.

   La méthode `fit` effectue les opérations suivantes : 

   1. Elle convertit le `DataFrame` d’entrée au format protobuf. Pour ce faire, elle sélectionne les colonnes `features` et `label` à partir du `DataFrame` d’entrée. Elle charge ensuite les données protobuf dans un compartiment Amazon S3. Le format protobuf est efficace pour l'entraînement des modèles en SageMaker IA.

   1. Démarre la formation des modèles en SageMaker IA en envoyant une [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html)demande d' SageMaker IA. Une fois l'entraînement du modèle terminé, l' SageMaker IA enregistre les artefacts du modèle dans un compartiment S3. 

      SageMaker L'IA assume le rôle IAM que vous avez spécifié pour la formation des modèles afin qu'ils exécutent des tâches en votre nom. Par exemple, il utilise le rôle pour lire les données d’entraînement à partir d’un compartiment S3 et pour écrire des artefacts de modèle sur un compartiment. 

   1. Crée et renvoie un objet `SageMakerModel`. Le constructeur effectue les tâches suivantes, qui sont liées au déploiement de votre modèle sur l' SageMaker IA. 

      1. Envoie une [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html)demande à SageMaker AI. 

      1. Envoie une [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpointConfig.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpointConfig.html)demande à SageMaker AI.

      1. Envoie une [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpoint.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpoint.html)demande à SageMaker AI, qui lance ensuite les ressources spécifiées et y héberge le modèle. 

1. Vous pouvez obtenir des déductions à partir de votre modèle hébergé dans SageMaker AI avec le`SageMakerModel.transform`. 

   Fournissez un `DataFrame` d’entrée avec des fonctions comme entrée. La méthode `transform` le transforme en `DataFrame` contenant des inférences. En interne, la `transform` méthode envoie une demande à l'[https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_runtime_InvokeEndpoint.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_runtime_InvokeEndpoint.html) SageMaker API pour obtenir des déductions. La méthode `transform` ajoute les inférences au `DataFrame` d’entrée.

# SageMaker Exemples d'AI Spark pour Scala
<a name="apache-spark-example1"></a>

Amazon SageMaker AI fournit une bibliothèque Apache Spark ([SageMaker AI Spark](https://github.com/aws/sagemaker-spark/tree/master/sagemaker-spark-sdk)) que vous pouvez utiliser pour intégrer vos applications Apache Spark à l' SageMaker IA. Cette rubrique contient des exemples pour vous aider à démarrer avec SageMaker AI Spark with Scala. Pour plus d'informations sur la bibliothèque SageMaker AI Apache Spark, consultez[Apache Spark avec Amazon SageMaker AI](apache-spark.md).

**Téléchargement de Spark pour Scala**

Vous pouvez télécharger le code source et les exemples des bibliothèques Python Spark (PySpark) et Scala depuis le GitHub référentiel [SageMaker AI Spark](https://github.com/aws/sagemaker-spark).

Pour obtenir des instructions détaillées sur l'installation de la bibliothèque SageMaker AI Spark, consultez [SageMaker AI Spark](https://github.com/aws/sagemaker-spark/tree/master/sagemaker-spark-sdk).

SageMaker Le SDK AI Spark pour Scala est disponible dans le référentiel central de Maven. Ajoutez la bibliothèque Spark à votre projet en ajoutant la dépendance suivante à votre fichier `pom.xml` :
+  Si votre projet est généré avec Maven, ajoutez ce qui suit à votre fichier pom.xml :

  ```
  <dependency>
      <groupId>com.amazonaws</groupId>
      <artifactId>sagemaker-spark_2.11</artifactId>
      <version>spark_2.2.0-1.0</version>
  </dependency>
  ```
+ Si votre projet dépend de Spark 2.1, ajoutez ce qui suit à votre fichier pom.xml :

  ```
  <dependency>
      <groupId>com.amazonaws</groupId>
      <artifactId>sagemaker-spark_2.11</artifactId>
      <version>spark_2.1.1-1.0</version>
  </dependency>
  ```

**Exemple Spark pour Scala**

Cette section fournit un exemple de code qui utilise la bibliothèque Apache Spark Scala fournie par SageMaker AI pour entraîner un modèle en SageMaker IA à l'aide de `DataFrame` s dans votre cluster Spark. Elle est suivie d’exemples illustrant : [Utilisez des algorithmes personnalisés pour la formation et l'hébergement de modèles sur Amazon SageMaker AI avec Apache Spark](apache-spark-example1-cust-algo.md) et [Utilisez le SageMakerEstimator dans un pipeline Spark](apache-spark-example1-extend-pipeline.md).

L'exemple suivant héberge les artefacts du modèle qui en résultent à l'aide des services d'hébergement SageMaker AI. Pour plus de détails sur cet exemple, voir [Getting Started : K-Means Clustering on SageMaker AI with SageMaker AI Spark SDK](https://github.com/aws/sagemaker-spark?tab=readme-ov-file#getting-started-k-means-clustering-on-sagemaker-with-sagemaker-spark-sdk) Plus précisément, cet exemple permet d'effectuer les opérations suivantes :
+ Utilise `KMeansSageMakerEstimator` pour adapter (ou entraîner) un modèle sur des données

  Comme l'exemple utilise l'algorithme k-means fourni par l' SageMaker IA pour entraîner un modèle, vous utilisez le`KMeansSageMakerEstimator`. Vous entraînez le modèle à l’aide des images de chiffres manuscrits (extraits du jeu de données MNIST). Vous fournissez les images en tant que `DataFrame` d’entrée. Pour votre commodité, SageMaker AI fournit cet ensemble de données dans un compartiment Amazon S3.

  En réponse, l’évaluateur renvoie un objet `SageMakerModel`.
+ Obtient des inférences à l’aide du `SageMakerModel` entraîné

  Pour obtenir des déductions à partir d'un modèle hébergé dans l' SageMaker IA, vous appelez la `SageMakerModel.transform` méthode. Vous transmettez un `DataFrame` comme entrée. La méthode transforme le `DataFrame` d’entrée en un autre `DataFrame` contenant des inférences obtenues à partir du modèle. 

  Pour une image d’entrée donnée représentant un chiffre manuscrit, l’inférence identifie un cluster auquel l’image appartient. Pour de plus amples informations, veuillez consulter [Algorithme des k-moyennes (k-means)](k-means.md).

```
import org.apache.spark.sql.SparkSession
import com.amazonaws.services.sagemaker.sparksdk.IAMRole
import com.amazonaws.services.sagemaker.sparksdk.algorithms
import com.amazonaws.services.sagemaker.sparksdk.algorithms.KMeansSageMakerEstimator

val spark = SparkSession.builder.getOrCreate

// load mnist data as a dataframe from libsvm
val region = "us-east-1"
val trainingData = spark.read.format("libsvm")
  .option("numFeatures", "784")
  .load(s"s3://sagemaker-sample-data-$region/spark/mnist/train/")
val testData = spark.read.format("libsvm")
  .option("numFeatures", "784")
  .load(s"s3://sagemaker-sample-data-$region/spark/mnist/test/")

val roleArn = "arn:aws:iam::account-id:role/rolename"

val estimator = new KMeansSageMakerEstimator(
  sagemakerRole = IAMRole(roleArn),
  trainingInstanceType = "ml.p2.xlarge",
  trainingInstanceCount = 1,
  endpointInstanceType = "ml.c4.xlarge",
  endpointInitialInstanceCount = 1)
  .setK(10).setFeatureDim(784)

// train
val model = estimator.fit(trainingData)

val transformedData = model.transform(testData)
transformedData.show
```

L’exemple de code effectue ce qui suit :
+ Charge le jeu de données MNIST depuis un compartiment S3 fourni par SageMaker AI (`awsai-sparksdk-dataset`) dans un Spark `DataFrame` (`mnistTrainingDataFrame`) :

  ```
  // Get a Spark session.
  
  val spark = SparkSession.builder.getOrCreate
  
  // load mnist data as a dataframe from libsvm
  val region = "us-east-1"
  val trainingData = spark.read.format("libsvm")
    .option("numFeatures", "784")
    .load(s"s3://sagemaker-sample-data-$region/spark/mnist/train/")
  val testData = spark.read.format("libsvm")
    .option("numFeatures", "784")
    .load(s"s3://sagemaker-sample-data-$region/spark/mnist/test/")
  
  val roleArn = "arn:aws:iam::account-id:role/rolename"
  trainingData.show()
  ```

  La méthode `show` affiche les 20 premières lignes dans le cadre de données :

  ```
  +-----+--------------------+
  |label|            features|
  +-----+--------------------+
  |  5.0|(784,[152,153,154...|
  |  0.0|(784,[127,128,129...|
  |  4.0|(784,[160,161,162...|
  |  1.0|(784,[158,159,160...|
  |  9.0|(784,[208,209,210...|
  |  2.0|(784,[155,156,157...|
  |  1.0|(784,[124,125,126...|
  |  3.0|(784,[151,152,153...|
  |  1.0|(784,[152,153,154...|
  |  4.0|(784,[134,135,161...|
  |  3.0|(784,[123,124,125...|
  |  5.0|(784,[216,217,218...|
  |  3.0|(784,[143,144,145...|
  |  6.0|(784,[72,73,74,99...|
  |  1.0|(784,[151,152,153...|
  |  7.0|(784,[211,212,213...|
  |  2.0|(784,[151,152,153...|
  |  8.0|(784,[159,160,161...|
  |  6.0|(784,[100,101,102...|
  |  9.0|(784,[209,210,211...|
  +-----+--------------------+
  only showing top 20 rows
  ```

  Dans chaque ligne :
  + La colonne `label` identifie l’étiquette de l’image. Par exemple, si l’image du chiffre manuscrit est le chiffre 5, la valeur de l’étiquette est 5. 
  + La colonne `features` stocke un vecteur (`org.apache.spark.ml.linalg.Vector`) de valeurs `Double`. Il s’agit des 784 fonctions du chiffre manuscrit. (Chaque chiffre manuscrit est une image de 28 x 28 pixels, ce qui fait 784 fonctions.)
+ Crée un estimateur SageMaker AI () `KMeansSageMakerEstimator` 

  La `fit` méthode de cet estimateur utilise l'algorithme k-means fourni par l' SageMaker IA pour entraîner des modèles à l'aide d'une entrée. `DataFrame` En réponse, un objet `SageMakerModel` est renvoyé, que vous pouvez utiliser pour obtenir des inférences.
**Note**  
Cela `KMeansSageMakerEstimator` étend l' SageMaker IA`SageMakerEstimator`, qui étend Apache Spark`Estimator`. 

  ```
  val estimator = new KMeansSageMakerEstimator(
    sagemakerRole = IAMRole(roleArn),
    trainingInstanceType = "ml.p2.xlarge",
    trainingInstanceCount = 1,
    endpointInstanceType = "ml.c4.xlarge",
    endpointInitialInstanceCount = 1)
    .setK(10).setFeatureDim(784)
  ```

   

  Les paramètres du constructeur fournissent des informations qui sont utilisées pour entraîner un modèle et le déployer sur l' SageMaker IA :
  + `trainingInstanceType` et `trainingInstanceCount` : identifient le type et le nombre d’instances de calcul ML à utiliser pour l’entraînement des modèles.
  + `endpointInstanceType`—Identifie le type d'instance de calcul ML à utiliser lors de l'hébergement du modèle dans SageMaker AI. Par défaut, une instance de calcul ML est prévue.
  + `endpointInitialInstanceCount`—Identifie le nombre d'instances de calcul ML qui soutiennent initialement le point de terminaison hébergeant le modèle dans SageMaker AI.
  + `sagemakerRole`— SageMaker L'IA assume ce rôle IAM pour effectuer des tâches en votre nom. Par exemple, pour l’entraînement des modèles, il lit les données à partir de S3 et écrit les résultats de l’entraînement (artefacts de modèle) dans S3. 
**Note**  
Cet exemple crée implicitement un client SageMaker AI. Pour créer ce client, vous devez fournir vos informations d’identification. L'API utilise ces informations d'identification pour authentifier les demandes adressées à l' SageMaker IA. Par exemple, il utilise les informations d'identification pour authentifier les demandes de création d'une tâche de formation et les appels d'API pour déployer le modèle à l'aide des services d'hébergement SageMaker AI.
  + Une fois que l’objet `KMeansSageMakerEstimator` a été créé, les paramètres suivants sont utilisés dans l’entraînement des modèles : 
    + Le nombre de clusters que l’algorithme k-means doit créer au cours de l’entraînement des modèles. Vous spécifiez 10 clusters, un pour chaque chiffre de 0 à 9. 
    + Identifie que chaque image d’entrée a 784 fonctions (chaque chiffre manuscrit est une image de 28 x 28 pixels, soit 784 fonctions).
+ Appelle la méthode `fit` de l’évaluateur.

  ```
  // train
  val model = estimator.fit(trainingData)
  ```

  Vous transmettez le `DataFrame` d’entrée sous forme de paramètre. Le modèle effectue tout le travail de formation du modèle et de son déploiement dans l' SageMaker IA. Pour plus d'informations, voir,[Intégrez votre application Apache Spark à l' SageMaker IA](apache-spark.md#spark-sdk-common-process). En réponse, vous obtenez un `SageMakerModel` objet que vous pouvez utiliser pour obtenir des déductions à partir de votre modèle déployé dans l' SageMaker IA. 

  Vous fournissez uniquement le `DataFrame` d’entrée. Vous n’avez pas besoin de spécifier le chemin d’accès au registre de l’algorithme k-means utilisé pour l’entraînement des modèles, car `KMeansSageMakerEstimator` le connaît.
+ Appelle la `SageMakerModel.transform` méthode pour obtenir des déductions à partir du modèle déployé dans l' SageMaker IA.

  La méthode `transform` prend un `DataFrame` en entrée, le transforme et renvoie un autre `DataFrame` contenant des inférences obtenues à partir du modèle. 

  ```
  val transformedData = model.transform(testData)
  transformedData.show
  ```

  Dans cet exemple, et pour plus de simplicité, nous utilisons le même `DataFrame` d’entrée pour la méthode `transform` que celui que nous avons utilisé pour l’entraînement du modèle. La méthode `transform` effectue les opérations suivantes :
  + Sérialise la `features` colonne dans l'entrée `DataFrame` de protobuf et l'envoie au point de terminaison SageMaker AI pour inférence.
  + Désérialise la réponse protobuf dans les deux colonnes supplémentaires (`distance_to_cluster` et `closest_cluster`) dans le `DataFrame` transformé.

  La méthode `show` obtient des inférences pour les 20 premières lignes dans le `DataFrame` d’entrée : 

  ```
  +-----+--------------------+-------------------+---------------+
  |label|            features|distance_to_cluster|closest_cluster|
  +-----+--------------------+-------------------+---------------+
  |  5.0|(784,[152,153,154...|  1767.897705078125|            4.0|
  |  0.0|(784,[127,128,129...|  1392.157470703125|            5.0|
  |  4.0|(784,[160,161,162...| 1671.5711669921875|            9.0|
  |  1.0|(784,[158,159,160...| 1182.6082763671875|            6.0|
  |  9.0|(784,[208,209,210...| 1390.4002685546875|            0.0|
  |  2.0|(784,[155,156,157...|  1713.988037109375|            1.0|
  |  1.0|(784,[124,125,126...| 1246.3016357421875|            2.0|
  |  3.0|(784,[151,152,153...|  1753.229248046875|            4.0|
  |  1.0|(784,[152,153,154...|  978.8394165039062|            2.0|
  |  4.0|(784,[134,135,161...|  1623.176513671875|            3.0|
  |  3.0|(784,[123,124,125...|  1533.863525390625|            4.0|
  |  5.0|(784,[216,217,218...|  1469.357177734375|            6.0|
  |  3.0|(784,[143,144,145...|  1736.765869140625|            4.0|
  |  6.0|(784,[72,73,74,99...|   1473.69384765625|            8.0|
  |  1.0|(784,[151,152,153...|    944.88720703125|            2.0|
  |  7.0|(784,[211,212,213...| 1285.9071044921875|            3.0|
  |  2.0|(784,[151,152,153...| 1635.0125732421875|            1.0|
  |  8.0|(784,[159,160,161...| 1436.3162841796875|            6.0|
  |  6.0|(784,[100,101,102...| 1499.7366943359375|            7.0|
  |  9.0|(784,[209,210,211...| 1364.6319580078125|            6.0|
  +-----+--------------------+-------------------+---------------+
  ```

  Vous pouvez interpréter les données comme suit :
  + Un chiffre manuscrit avec le `label` 5 appartient au cluster 4 (`closest_cluster`).
  + Un chiffre manuscrit avec le `label` 0 appartient au cluster 5.
  + Un chiffre manuscrit avec le `label` 4 appartient au cluster 9.
  + Un chiffre manuscrit avec le `label` 1 appartient au cluster 6.

**Topics**
+ [Utilisez des algorithmes personnalisés pour la formation et l'hébergement de modèles sur Amazon SageMaker AI avec Apache Spark](apache-spark-example1-cust-algo.md)
+ [Utilisez le SageMakerEstimator dans un pipeline Spark](apache-spark-example1-extend-pipeline.md)

# Utilisez des algorithmes personnalisés pour la formation et l'hébergement de modèles sur Amazon SageMaker AI avec Apache Spark
<a name="apache-spark-example1-cust-algo"></a>

Dans[SageMaker Exemples d'AI Spark pour Scala](apache-spark-example1.md), vous utilisez le `kMeansSageMakerEstimator` car l'exemple utilise l'algorithme k-means fourni par Amazon SageMaker AI pour l'entraînement des modèles. Vous pouvez choisir d’utiliser à la place votre propre algorithme personnalisé pour l’entraînement des modèles. En supposant que vous ayez déjà créé une image Docker, vous pouvez créer votre propre `SageMakerEstimator` et spécifier le chemin d'accès à Amazon Elastic Container Registry pour votre image personnalisée. 

L’exemple suivant montre comment créer un `KMeansSageMakerEstimator` à partir de `SageMakerEstimator`. Dans le nouvel évaluateur, vous spécifiez explicitement le chemin de registre Docker vers vos images de code d’entraînement et d’inférence.

```
import com.amazonaws.services.sagemaker.sparksdk.IAMRole
import com.amazonaws.services.sagemaker.sparksdk.SageMakerEstimator
import com.amazonaws.services.sagemaker.sparksdk.transformation.serializers.ProtobufRequestRowSerializer
import com.amazonaws.services.sagemaker.sparksdk.transformation.deserializers.KMeansProtobufResponseRowDeserializer

val estimator = new SageMakerEstimator(
  trainingImage =
    "811284229777.dkr.ecr.us-east-1.amazonaws.com/kmeans:1",
  modelImage =
    "811284229777.dkr.ecr.us-east-1.amazonaws.com/kmeans:1",
  requestRowSerializer = new ProtobufRequestRowSerializer(),
  responseRowDeserializer = new KMeansProtobufResponseRowDeserializer(),
  hyperParameters = Map("k" -> "10", "feature_dim" -> "784"),
  sagemakerRole = IAMRole(roleArn),
  trainingInstanceType = "ml.p2.xlarge",
  trainingInstanceCount = 1,
  endpointInstanceType = "ml.c4.xlarge",
  endpointInitialInstanceCount = 1,
  trainingSparkDataFormat = "sagemaker")
```

Dans le code, les paramètres du constructeur `SageMakerEstimator` incluent :
+ `trainingImage` : identifie le chemin de registre Docker vers l'image d'entraînement contenant votre code personnalisé.
+ `modelImage` : identifie le chemin de registre Docker vers l'image contenant le code d'inférence.
+ `requestRowSerializer` — Implémente `com.amazonaws.services.sagemaker.sparksdk.transformation.RequestRowSerializer`.

  Ce paramètre sérialise les lignes dans l'entrée `DataFrame` pour les envoyer au modèle hébergé dans SageMaker AI à des fins d'inférence.
+ `responseRowDeserializer` : implémente 

  `com.amazonaws.services.sagemaker.sparksdk.transformation.ResponseRowDeserializer`.

  Ce paramètre désérialise les réponses du modèle, hébergé dans SageMaker AI, vers un. `DataFrame`
+ `trainingSparkDataFormat` : spécifie le format de données utilisé par Spark lors du téléchargement des données d’entraînement d’un `DataFrame` vers S3. Par exemple, `"sagemaker"` pour le format protobuf, `"csv"` pour les valeurs séparées par des virgules et `"libsvm"` pour le format LibSVM. 

Vous pouvez implémenter vos propres `RequestRowSerializer` et `ResponseRowDeserializer` pour sérialiser et désérialiser les lignes à partir d’un format de données pris en charge par votre code d’inférence, tel que .libsvm ou .csv.

# Utilisez le SageMakerEstimator dans un pipeline Spark
<a name="apache-spark-example1-extend-pipeline"></a>

Vous pouvez utiliser les évaluateurs `org.apache.spark.ml.Estimator` et les modèles `org.apache.spark.ml.Model`, mais aussi les évaluateurs `SageMakerEstimator` et les modèles `SageMakerModel` dans les pipelines `org.apache.spark.ml.Pipeline`, comme illustré dans l’exemple suivant :

```
import org.apache.spark.ml.Pipeline
import org.apache.spark.ml.feature.PCA
import org.apache.spark.sql.SparkSession
import com.amazonaws.services.sagemaker.sparksdk.IAMRole
import com.amazonaws.services.sagemaker.sparksdk.algorithms
import com.amazonaws.services.sagemaker.sparksdk.algorithms.KMeansSageMakerEstimator

val spark = SparkSession.builder.getOrCreate

// load mnist data as a dataframe from libsvm
val region = "us-east-1"
val trainingData = spark.read.format("libsvm")
  .option("numFeatures", "784")
  .load(s"s3://sagemaker-sample-data-$region/spark/mnist/train/")
val testData = spark.read.format("libsvm")
  .option("numFeatures", "784")
  .load(s"s3://sagemaker-sample-data-$region/spark/mnist/test/")

// substitute your SageMaker IAM role here
val roleArn = "arn:aws:iam::account-id:role/rolename"

val pcaEstimator = new PCA()
  .setInputCol("features")
  .setOutputCol("projectedFeatures")
  .setK(50)

val kMeansSageMakerEstimator = new KMeansSageMakerEstimator(
  sagemakerRole = IAMRole(integTestingRole),
  requestRowSerializer =
    new ProtobufRequestRowSerializer(featuresColumnName = "projectedFeatures"),
  trainingSparkDataFormatOptions = Map("featuresColumnName" -> "projectedFeatures"),
  trainingInstanceType = "ml.p2.xlarge",
  trainingInstanceCount = 1,
  endpointInstanceType = "ml.c4.xlarge",
  endpointInitialInstanceCount = 1)
  .setK(10).setFeatureDim(50)

val pipeline = new Pipeline().setStages(Array(pcaEstimator, kMeansSageMakerEstimator))

// train
val pipelineModel = pipeline.fit(trainingData)

val transformedData = pipelineModel.transform(testData)
transformedData.show()
```

Le paramètre `trainingSparkDataFormatOptions` configure Spark pour sérialiser au format protobuf la colonne « projectedFeatures » pour l’entraînement des modèles. En outre, Spark sérialise au format protobuf la colonne « label » par défaut.

Puisque nous souhaitons que les inférences utilisent la colonne « projectedFeatures », nous transmettons le nom de colonne dans le `ProtobufRequestRowSerializer`.

L’exemple suivant présente un `DataFrame` transformé :

```
+-----+--------------------+--------------------+-------------------+---------------+
|label|            features|   projectedFeatures|distance_to_cluster|closest_cluster|
+-----+--------------------+--------------------+-------------------+---------------+
|  5.0|(784,[152,153,154...|[880.731433034386...|     1500.470703125|            0.0|
|  0.0|(784,[127,128,129...|[1768.51722024166...|      1142.18359375|            4.0|
|  4.0|(784,[160,161,162...|[704.949236329314...|  1386.246826171875|            9.0|
|  1.0|(784,[158,159,160...|[-42.328192193771...| 1277.0736083984375|            5.0|
|  9.0|(784,[208,209,210...|[374.043902028333...|   1211.00927734375|            3.0|
|  2.0|(784,[155,156,157...|[941.267714528850...|  1496.157958984375|            8.0|
|  1.0|(784,[124,125,126...|[30.2848596410594...| 1327.6766357421875|            5.0|
|  3.0|(784,[151,152,153...|[1270.14374062052...| 1570.7674560546875|            0.0|
|  1.0|(784,[152,153,154...|[-112.10792566485...|     1037.568359375|            5.0|
|  4.0|(784,[134,135,161...|[452.068280676606...| 1165.1236572265625|            3.0|
|  3.0|(784,[123,124,125...|[610.596447285397...|  1325.953369140625|            7.0|
|  5.0|(784,[216,217,218...|[142.959601818422...| 1353.4930419921875|            5.0|
|  3.0|(784,[143,144,145...|[1036.71862533658...| 1460.4315185546875|            7.0|
|  6.0|(784,[72,73,74,99...|[996.740157435754...| 1159.8631591796875|            2.0|
|  1.0|(784,[151,152,153...|[-107.26076167417...|   960.963623046875|            5.0|
|  7.0|(784,[211,212,213...|[619.771820430940...|   1245.13623046875|            6.0|
|  2.0|(784,[151,152,153...|[850.152101817161...|  1304.437744140625|            8.0|
|  8.0|(784,[159,160,161...|[370.041887230547...| 1192.4781494140625|            0.0|
|  6.0|(784,[100,101,102...|[546.674328209335...|    1277.0908203125|            2.0|
|  9.0|(784,[209,210,211...|[-29.259112927426...| 1245.8182373046875|            6.0|
+-----+--------------------+--------------------+-------------------+---------------+
```

# Ressources pour utiliser les exemples d' SageMaker AI Spark pour Python (PySpark)
<a name="apache-spark-additional-examples"></a>

Amazon SageMaker AI fournit une bibliothèque Python ([SageMaker AI PySpark](https://github.com/aws/sagemaker-spark/tree/master/sagemaker-pyspark-sdk)) Apache Spark que vous pouvez utiliser pour intégrer vos applications Apache Spark à l' SageMaker IA. Cette rubrique contient des exemples pour vous aider à démarrer PySpark. Pour plus d'informations sur la bibliothèque SageMaker AI Apache Spark, consultez[Apache Spark avec Amazon SageMaker AI](apache-spark.md).

**Download PySpark**

Vous pouvez télécharger le code source des bibliothèques Python Spark (PySpark) et Scala depuis le GitHub référentiel [SageMaker AI Spark](https://github.com/aws/sagemaker-spark).

Pour obtenir des instructions sur l'installation de la bibliothèque SageMaker AI Spark, utilisez l'une des options suivantes ou consultez [SageMaker AI PySpark](https://github.com/aws/sagemaker-spark/tree/master/sagemaker-pyspark-sdk).
+ Installation avec pip :

  ```
  pip install sagemaker_pyspark
  ```
+ Installation à partir de la source :

  ```
  git clone git@github.com:aws/sagemaker-spark.git
  cd sagemaker-pyspark-sdk
  python setup.py install
  ```
+ Vous pouvez également créer un nouveau bloc-notes dans une instance de bloc-notes qui utilise le noyau `Sparkmagic (PySpark)` ou `Sparkmagic (PySpark3)`, et vous connecter à un cluster Amazon EMR distant.
**Note**  
Le cluster Amazon EMR doit être configuré avec un rôle IAM auquel la politique `AmazonSageMakerFullAccess` est attachée. Pour plus d’informations sur la configuration de rôles pour un cluster EMR, consultez [Configuration des rôles IAM pour les autorisations Amazon EMR aux services AWS](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-iam-roles.html) dans le *Guide de gestion Amazon EMR*.

**PySpark exemples**

Pour des exemples d'utilisation de l' SageMaker IA PySpark, voir :
+ [Utilisation d'Amazon SageMaker AI avec Apache Spark](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-spark/index.html) dans Read the Docs.
+ SageMaker GitHubRéférentiel [AI Spark](https://github.com/aws/sagemaker-spark).

# Ressources pour utiliser Chainer avec Amazon AI SageMaker
<a name="chainer"></a>

Vous pouvez utiliser l' SageMaker IA pour entraîner et déployer un modèle à l'aide d'un code Chainer personnalisé. Les estimateurs et modèles Chainer du SDK SageMaker AI Python et le conteneur Chainer open source SageMaker AI facilitent l'écriture d'un script Chainer et son exécution dans AI. SageMaker La section suivante fournit des documents de référence que vous pouvez utiliser pour apprendre à utiliser Chainer avec l' SageMaker IA.

## Que souhaitez-vous faire ?
<a name="chainer-intent"></a>

Je souhaite entraîner un modèle Chainer personnalisé en SageMaker IA.  
Pour un exemple de bloc-notes Jupyter, consultez les [exemples de blocs-notes Chainer dans le référentiel](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/sagemaker-python-sdk/mxnet_mnist) Amazon SageMaker AI Examples. GitHub  
Pour obtenir de la documentation, consultez [Entraînement d’un modèle avec Chainer](https://sagemaker.readthedocs.io/en/stable/using_chainer.html#train-a-model-with-chainer).

J'ai un modèle Chainer que j'ai formé à l' SageMaker IA et je souhaite le déployer sur un point de terminaison hébergé.  
Pour plus d’informations, consultez [Déploiement de modèles Chainer](https://sagemaker.readthedocs.io/en/stable/using_chainer.html#deploy-chainer-models).

J'ai un modèle Chainer que j'ai formé en dehors de l' SageMaker IA, et je souhaite le déployer sur un point de terminaison d' SageMaker IA  
Pour plus d’informations, consultez [Déploiement de points de terminaison à partir de données de modèle](https://sagemaker.readthedocs.io/en/stable/using_chainer.html#deploy-endpoints-from-model-data).

Je souhaite consulter la documentation de l'API pour les [classes Amazon SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable) Chainer.  
Pour plus d’informations, consultez [Classes Chainer](https://sagemaker.readthedocs.io/en/stable/sagemaker.chainer.html).

Je souhaite obtenir des informations sur les conteneurs SageMaker AI Chainer.  
Pour plus d'informations, consultez le [ GitHub référentiel SageMaker AI Chainer Container](https://github.com/aws/sagemaker-chainer-container).

 Pour plus d'informations sur les versions de Chainer prises en charge, ainsi que pour des informations générales sur l'écriture de scripts d'entraînement de Chainer et l'utilisation d'estimateurs et de modèles de Chainer avec l' SageMaker IA, consultez la section Utilisation de [Chainer](https://sagemaker.readthedocs.io/en/stable/using_chainer.html) avec le SDK Python. SageMaker 

# Ressources pour utiliser Hugging Face avec Amazon AI SageMaker
<a name="hugging-face"></a>

Amazon SageMaker AI permet aux clients de s'entraîner, de peaufiner et d'exécuter des inférences à l'aide des modèles Hugging Face pour le traitement du langage naturel (NLP) sur l'IA. SageMaker Vous pouvez utiliser Hugging Face tant pour l’entraînement que pour l’inférence. La section suivante fournit des informations sur les modèles Hugging Face et inclut du matériel de référence que vous pouvez utiliser pour apprendre à utiliser Hugging SageMaker Face avec l'IA.

Cette fonctionnalité est disponible via le développement de [AWS Deep Learning Containers](https://docs.aws.amazon.com/deep-learning-containers/latest/devguide/what-is-dlc.html) Hugging Face. Ces conteneurs incluent les transformateurs Hugging Face, les tokéniseurs et la bibliothèque de jeux de données, qui vous permet d'utiliser ces ressources pour vos tâches d'entraînement et d'inférence. Pour obtenir la liste des images Deep Learning Containers disponibles, consultez [Images Deep Learning Containers disponibles](https://github.com/aws/deep-learning-containers/blob/master/available_images.md). Ces images Deep Learning Containers sont conservées et régulièrement mises à jour avec des correctifs de sécurité.

Pour utiliser les conteneurs Hugging Face Deep Learning avec le SDK SageMaker Python à des fins de formation, consultez le [ SageMaker Hugging Face](https://sagemaker.readthedocs.io/en/stable/frameworks/huggingface/index.html) AI Estimator. Avec le Hugging Face Estimator, vous pouvez utiliser les modèles Hugging Face comme n'importe quel autre estimateur AI. SageMaker Cependant, l'utilisation du SDK SageMaker Python est facultative. Vous pouvez également orchestrer votre utilisation des Hugging Face Deep Learning Containers avec le et. AWS CLI AWS SDK pour Python (Boto3)

Pour plus d’informations sur Hugging Face et les modèles disponibles, consultez la [documentation Hugging Face](https://huggingface.co/). 

## Entraînement
<a name="hugging-face-training"></a>

Pour exécuter l’entraînement, utilisez l’un des milliers de modèles disponibles dans Hugging Face et optimisez-le pour votre cas d’utilisation avec un entraînement supplémentaire. Avec l' SageMaker IA, vous pouvez utiliser une formation standard ou tirer parti de la [formation parallèle basée sur les données distribuées et les modèles basés sur l'SageMaker IA](https://docs.aws.amazon.com/sagemaker/latest/dg/distributed-training.html). 

Comme pour les autres tâches de SageMaker formation utilisant du code personnalisé, vous pouvez capturer vos propres métriques en transmettant une définition de métriques au SDK SageMaker Python. Pour un exemple, voir [Définition des métriques d'entraînement (SDK SageMaker Python).](https://docs.aws.amazon.com/sagemaker/latest/dg/training-metrics.html#define-train-metrics-sdk) Vous pouvez accéder aux métriques capturées en utilisant [CloudWatch](https://docs.aws.amazon.com/sagemaker/latest/dg/monitoring-cloudwatch.html)et en tant que Pandas `DataFrame` en utilisant [TrainingJobAnalytics](https://sagemaker.readthedocs.io/en/stable/api/training/analytics.html#sagemaker.analytics.TrainingJobAnalytics)cette méthode. Une fois votre modèle entraîné et optimisé, vous pouvez l’utiliser comme n’importe quel autre modèle pour exécuter des tâches d’inférence.

### Comment exécuter l’entraînement avec l’estimateur Hugging Face
<a name="hugging-face-training-using"></a>

Vous pouvez implémenter le Hugging Face Estimator pour les tâches de formation à l'aide du SDK SageMaker AI Python. Le SDK SageMaker Python est une bibliothèque open source pour la formation et le déploiement de modèles d'apprentissage automatique sur l' SageMaker IA. Pour plus d'informations sur le Hugging Face Estimator, consultez la documentation du SDK [SageMaker AI Python](https://sagemaker.readthedocs.io/en/stable/frameworks/huggingface/index.html).

Avec le SDK SageMaker Python, vous pouvez exécuter des tâches de formation à l'aide de l'estimateur Hugging Face dans les environnements suivants : 
+ [Amazon SageMaker Studio Classic](https://docs.aws.amazon.com/sagemaker/latest/dg/studio.html) : Studio Classic est le premier environnement de développement (IDE) entièrement intégré pour l'apprentissage automatique (ML). Studio Classic fournit une interface visuelle Web unique où vous pouvez effectuer toutes les étapes de développement ML requises pour :
  + préparer
  + build
  + entraîner et régler ;
  + déployer et gérer des modèles.

  Pour en savoir plus sur l’utilisation des blocs-notes Jupyter dans Studio Classic, consultez [Utiliser les blocs-notes Amazon SageMaker Studio Classic](notebooks.md).
+ [SageMakerInstances de bloc-notes](https://docs.aws.amazon.com/sagemaker/latest/dg/nbi.html) : une instance de SageMaker bloc-notes Amazon est une instance de calcul d'apprentissage automatique (ML) exécutant l'application Jupyter Notebook. Cette application vous permet d’exécuter des blocs-notes Jupyter dans votre instance de bloc-notes pour :
  + préparer et traiter les données ;
  + écrire du code pour entraîner des modèles ;
  + déployer des modèles sur un hébergement SageMaker AI
  + testez ou validez vos modèles sans les fonctionnalités de SageMaker Studio telles que le débogueur, la surveillance des modèles et un IDE basé sur le Web
+ Localement : si vous êtes connecté AWS et que vous disposez des autorisations d' SageMaker IA appropriées, vous pouvez utiliser le SDK SageMaker Python localement. Avec une utilisation locale, vous pouvez lancer des tâches de formation et d'inférence à distance pour Hugging Face in SageMaker AI on. AWS Cela fonctionne sur votre machine locale, ainsi que sur d'autres AWS services dotés d'un SDK SageMaker Python connecté et des autorisations appropriées.

## Inférence
<a name="hugging-face-inference"></a>

À des fins d'inférence, vous pouvez utiliser votre modèle Hugging Face entraîné ou l'un des modèles Hugging Face préentraînés pour déployer une tâche d'inférence avec l'IA. SageMaker Grâce à cette collaboration, vous n'avez besoin que d'une seule ligne de code pour déployer à la fois vos modèles entraînés et vos modèles préentraînés avec l' SageMaker IA. Vous pouvez également exécuter des tâches d’inférence sans écrire aucun code d’inférence personnalisé. Avec un code d'inférence personnalisé, vous pouvez personnaliser la logique d'inférence en fournissant votre propre script Python.

### Déploiement d’une tâche d’inférence à l’aide des conteneurs de deep learning Hugging Face
<a name="hugging-face-inference-using"></a>

Deux options s'offrent à vous pour exécuter l'inférence avec l' SageMaker IA. Vous pouvez exécuter l’inférence à l’aide d’un modèle que vous avez entraîné ou déployer un modèle Hugging Face pré-entraîné. 
+ **Exécution de l’inférence avec votre modèle entraîné :** deux options s’offrent à vous pour exécuter l’inférence avec votre propre modèle entraîné :
  + Exécutez une inférence avec un modèle que vous avez entraîné à l'aide d'un modèle Hugging Face existant avec les AI SageMaker Hugging Face Deep Learning Containers.
  + Apportez votre propre modèle Hugging Face existant et déployez-le à SageMaker l'aide de l'IA.

  Lorsque vous exécutez une inférence avec un modèle que vous avez entraîné avec l' SageMaker AI Hugging Face Estimator, vous pouvez déployer le modèle immédiatement après la fin de l'entraînement. Vous pouvez également charger le modèle entraîné dans un compartiment Amazon S3 et l’ingérer lors d’une exécution ultérieure de l’inférence. 

  Si vous apportez votre propre modèle Hugging Face existant, vous devez charger le modèle entraîné dans un compartiment Amazon S3. Vous ingérez ensuite ce compartiment lors de l’exécution de l’inférence, comme indiqué dans l’[exemple de déploiement de vos transformeurs Hugging Face pour l’inférence](https://github.com/huggingface/notebooks/blob/main/sagemaker/10_deploy_model_from_s3/deploy_transformer_model_from_s3.ipynb).
+ **Exécutez l'inférence avec un HuggingFace modèle préentraîné :** vous pouvez utiliser l'un des milliers de modèles Hugging Face préentraînés pour exécuter vos tâches d'inférence sans formation supplémentaire. Pour exécuter l’inférence, sélectionnez le modèle pré-entraîné dans la liste des [modèles Hugging Face](https://huggingface.co/models), comme indiqué dans l’[exemple de déploiement des transformeurs Hugging Face pré-entraînés pour l’inférence](https://github.com/huggingface/notebooks/blob/main/sagemaker/11_deploy_model_from_hf_hub/deploy_transformer_model_from_hf_hub.ipynb).

## Que souhaitez-vous faire ?
<a name="hugging-face-do"></a>

Les blocs-notes suivants du référentiel Hugging Face Notebooks montrent comment utiliser les conteneurs Hugging Face Deep Learning SageMaker avec l'IA dans différents cas d'utilisation.

Je souhaite former et déployer un modèle de classification de texte à l'aide de Hugging Face SageMaker in AI PyTorch with.  
Pour un exemple de bloc-notes Jupyter, consultez la démo de [mise PyTorch en route](https://github.com/huggingface/notebooks/blob/main/sagemaker/01_getting_started_pytorch/sagemaker-notebook.ipynb).

Je souhaite former et déployer un modèle de classification de texte à l'aide de Hugging Face SageMaker in AI TensorFlow with.  
Pour un exemple de bloc-notes Jupyter, consultez l'exemple [TensorFlow Getting Started](https://github.com/huggingface/notebooks/blob/main/sagemaker/02_getting_started_tensorflow/sagemaker-notebook.ipynb).

Je souhaite organiser une formation distribuée avec le parallélisme des données à l'aide de Hugging Face SageMaker et AI Distributed.  
Pour obtenir un exemple de bloc-notes Jupyter, consultez l’[exemple Entraînement distribué](https://github.com/huggingface/notebooks/blob/main/sagemaker/03_distributed_training_data_parallelism/sagemaker-notebook.ipynb).

Je souhaite organiser une formation distribuée avec le parallélisme des modèles à l'aide de Hugging Face SageMaker et AI Distributed.  
Pour obtenir un exemple de bloc-notes Jupyter, consultez l’[exemple Parallélisme des modèles](https://github.com/huggingface/notebooks/blob/main/sagemaker/04_distributed_training_model_parallelism/sagemaker-notebook.ipynb).

Je souhaite utiliser une instance ponctuelle pour entraîner et déployer un modèle utilisant Hugging Face SageMaker dans l'IA.  
Pour obtenir un exemple de bloc-notes Jupyter, consultez l’[exemple Instances Spot](https://github.com/huggingface/notebooks/blob/main/sagemaker/05_spot_instances/sagemaker-notebook.ipynb).

Je souhaite capturer des métriques personnalisées et utiliser le point de contrôle SageMaker AI lors de l'entraînement d'un modèle de classification de texte à l'aide de Hugging Face in AI. SageMaker   
Pour obtenir un exemple de bloc-notes Jupyter, consultez l’[exemple Entraînement avec des métriques personnalisées](https://github.com/huggingface/notebooks/blob/main/sagemaker/06_sagemaker_metrics/sagemaker-notebook.ipynb).

Je souhaite former un TensorFlow modèle distribué de réponses aux questions à l'aide de Hugging Face en IA. SageMaker   
Pour un exemple de Jupyter Notebook, consultez l'exemple de [ TensorFlow formation distribuée](https://github.com/huggingface/notebooks/blob/main/sagemaker/07_tensorflow_distributed_training_data_parallelism/sagemaker-notebook.ipynb).

Je souhaite entraîner un modèle de synthèse distribué à l'aide de Hugging Face en IA. SageMaker   
Pour obtenir un exemple de bloc-notes Jupyter, consultez l’[exemple Entraînement avec synthèse distribuée](https://github.com/huggingface/notebooks/blob/main/sagemaker/08_distributed_summarization_bart_t5/sagemaker-notebook.ipynb).

Je souhaite entraîner un modèle de classification d'images à l'aide de Hugging Face SageMaker in AI.  
Pour obtenir un exemple de bloc-notes Jupyter, consultez l’[exemple d’entraînement de transformeur de vision](https://github.com/huggingface/notebooks/blob/main/sagemaker/09_image_classification_vision_transformer/sagemaker-notebook.ipynb).

Je souhaite déployer mon modèle Hugging Face entraîné SageMaker dans l'IA.  
Pour obtenir un exemple de bloc-notes Jupyter, consultez l’[exemple Déploiement de vos transformeurs Hugging Face pour l’inférence](https://github.com/huggingface/notebooks/blob/main/sagemaker/10_deploy_model_from_s3/deploy_transformer_model_from_s3.ipynb).

Je souhaite déployer un modèle Hugging Face pré-entraîné en IA. SageMaker   
Pour obtenir un exemple de bloc-notes Jupyter, consultez l’[exemple Déploiement de transformeurs Hugging Face pré-entraînés pour l’inférence](https://github.com/huggingface/notebooks/blob/main/sagemaker/11_deploy_model_from_hf_hub/deploy_transformer_model_from_hf_hub.ipynb).

# Ressources à utiliser PyTorch avec Amazon SageMaker AI
<a name="pytorch"></a>

Vous pouvez utiliser Amazon SageMaker AI pour entraîner et déployer un modèle à l'aide d'un PyTorch code personnalisé. Les PyTorch estimateurs et modèles du SDK SageMaker AI Python ainsi que le PyTorch conteneur open source SageMaker AI facilitent l'écriture d'un PyTorch script et son exécution dans AI. SageMaker La section suivante fournit des documents de référence que vous pouvez utiliser pour apprendre à utiliser PyTorch l' SageMaker IA.

## Que souhaitez-vous faire ?
<a name="pytorch-intent"></a>

Je souhaite entraîner un PyTorch modèle personnalisé en SageMaker IA.  
Pour un exemple de bloc-notes Jupyter, consultez le [carnet d'PyTorch exemple](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/sagemaker-python-sdk/pytorch_mnist) dans le référentiel Amazon SageMaker AI Examples GitHub.  
Pour obtenir de la documentation, voir [Entraîner un modèle avec PyTorch](https://sagemaker.readthedocs.io/en/stable/using_pytorch.html#train-a-model-with-pytorch).

J'ai un PyTorch modèle que j'ai formé à l' SageMaker IA et je souhaite le déployer sur un terminal hébergé.  
Pour plus d'informations, consultez la section [Déployer PyTorch des modèles](https://sagemaker.readthedocs.io/en/stable/using_pytorch.html#deploy-pytorch-models).

J'ai un PyTorch modèle que j'ai formé en dehors de l' SageMaker IA et je souhaite le déployer sur un point de terminaison basé sur SageMaker l'IA  
Pour plus d'informations, voir [Déployer votre propre PyTorch modèle](https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/using_pytorch.html#bring-your-own-model).

Je souhaite consulter la documentation de l'API pour les PyTorch classes du [SDK Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable).  
Pour plus d'informations, consultez la section [PyTorch Classes](https://sagemaker.readthedocs.io/en/stable/sagemaker.pytorch.html).

Je souhaite trouver le référentiel de PyTorch conteneurs SageMaker AI.  
Pour plus d'informations, consultez le [ GitHub référentiel SageMaker AI PyTorch Container](https://github.com/aws/deep-learning-containers/tree/master/pytorch).

Je souhaite obtenir des informations sur les PyTorch versions prises en charge par AWS Deep Learning Containers.  
Pour plus d’informations, consultez [Images Deep Learning Containers disponibles](https://github.com/aws/deep-learning-containers/blob/master/available_images.md).

 Pour des informations générales sur l'écriture de scripts d' PyTorch entraînement et l'utilisation d' PyTorchestimateurs et de modèles avec l' SageMaker IA, consultez la section [Utilisation PyTorch avec le SDK SageMaker Python](https://sagemaker.readthedocs.io/en/stable/using_pytorch.html).

# Ressources pour utiliser R avec Amazon SageMaker AI
<a name="r-guide"></a>

Ce document répertorie les ressources qui peuvent vous aider à apprendre à utiliser les fonctionnalités Amazon SageMaker AI avec l'environnement logiciel R. Les sections suivantes présentent le noyau R intégré à SageMaker AI, expliquent comment démarrer avec R on SageMaker AI et fournissent plusieurs exemples de blocs-notes.

Les exemples sont organisés en trois niveaux : débutant, intermédiaire et avancé. Ils commencent par [Getting Started with R on SageMaker AI](https://sagemaker-examples.readthedocs.io/en/latest/r_examples/r_sagemaker_hello_world/r_sagemaker_hello_world.html), se poursuivent par l'apprentissage end-to-end automatique avec R on SageMaker AI, puis se terminent par des sujets plus avancés tels que le SageMaker traitement avec le script R et l'algorithme bring-your-own R vers l' SageMaker IA.

Pour plus d’informations sur la façon d’importer votre propre image R personnalisée dans Studio, consultez [Images personnalisées dans Amazon SageMaker Studio Classic](studio-byoi.md). Pour un article de blog similaire, consultez l'article [Apporter votre propre environnement R à Amazon SageMaker Studio](https://aws.amazon.com/blogs/machine-learning/bringing-your-own-r-environment-to-amazon-sagemaker-studio/).

**Topics**
+ [RStudio support en SageMaker IA](#rstudio-for-r)
+ [Noyau R dans l' SageMaker IA](#r-sagemaker-kernel-ni)
+ [Exemples de blocs-notes](#r-sagemaker-example-notebooks)
+ [Commencez avec R in SageMaker AI](r-sagemaker-get-started.md)

## RStudio support en SageMaker IA
<a name="rstudio-for-r"></a>

Amazon SageMaker AI est pris en charge en RStudio tant qu'environnement de développement intégré (IDE) entièrement géré intégré au domaine Amazon SageMaker AI. Grâce à RStudio l'intégration, vous pouvez lancer un RStudio environnement dans le domaine pour exécuter vos RStudio flux de travail sur des ressources d' SageMaker IA. Pour de plus amples informations, veuillez consulter [RStudio sur Amazon SageMaker AI](rstudio.md).

## Noyau R dans l' SageMaker IA
<a name="r-sagemaker-kernel-ni"></a>

SageMaker les instances de notebook prennent en charge R à l'aide d'un noyau R préinstallé. De plus, le noyau R possède la bibliothèque réticulée, une interface R vers Python, ce qui vous permet d'utiliser les fonctionnalités du SDK SageMaker AI Python à partir d'un script R. 
+ [reticulatelibrary](https://rstudio.github.io/reticulate/) : fournit une interface R au SDK Amazon [Python SageMaker ](https://sagemaker.readthedocs.io/en/stable). Le paquet réticulé se convertit entre les objets R et Python.

## Exemples de blocs-notes
<a name="r-sagemaker-example-notebooks"></a>

**Conditions préalables**
+ [Getting Started with R on SageMaker AI](https://sagemaker-examples.readthedocs.io/en/latest/r_examples/r_sagemaker_hello_world/r_sagemaker_hello_world.html) — Cet exemple de bloc-notes décrit comment développer des scripts R à l'aide du noyau R d'Amazon SageMaker AI. Dans ce bloc-notes, vous pouvez configurer votre environnement d' SageMaker IA et vos autorisations, télécharger le [jeu de données abalone](https://archive.ics.uci.edu/ml/datasets/abalone) depuis le [référentiel UCI Machine Learning](https://archive.ics.uci.edu/datasets), effectuer un traitement et une visualisation de base sur les données, puis enregistrer les données au format .csv dans S3.

**Niveau Débutant**
+ [SageMaker Transformation par lots AI à l'aide du noyau R](https://sagemaker-examples.readthedocs.io/en/latest/r_examples/r_batch_transform/r_xgboost_batch_transform.html) — Cet exemple de bloc-notes décrit comment effectuer une tâche de transformation par lots à l'aide de l'API Transformer d' SageMaker AI et de l'[XGBoostalgorithme](https://docs.aws.amazon.com/sagemaker/latest/dg/xgboost.html). Le bloc-notes utilise également le jeu de données Abalone.

**Niveau intermédiaire**
+ [Optimisation des hyperparamètres pour XGBoost in R](https://sagemaker-examples.readthedocs.io/en/latest/r_examples/r_xgboost_hpo_batch_transform/r_xgboost_hpo_batch_transform.html) — Cet exemple de bloc-notes complète les précédents blocs-notes pour débutants qui utilisaient le jeu de données sur les ormeaux et. XGBoost Il explique comment peaufiner un modèle à l’aide de l’[optimisation des hyperparamètres](https://sagemaker.readthedocs.io/en/stable/tuner.html). Vous apprendrez également à utiliser la transformation par lots pour les prédictions de traitement par lots, ainsi qu’à créer un point de terminaison de modèle pour réaliser des prédictions en temps réel.
+ [Amazon SageMaker Processing with R](https://sagemaker-examples.readthedocs.io/en/latest/r_examples/r_in_sagemaker_processing/r_in_sagemaker_processing.html) — [SageMaker Processing](https://aws.amazon.com/blogs/aws/amazon-sagemaker-processing-fully-managed-data-processing-and-model-evaluation/) vous permet de prétraiter, de post-traiter et d'exécuter des charges de travail d'évaluation de modèles. Cet exemple montre comment créer un script R pour orchestrer une tâche de traitement (Processing).

**Niveau avancé**
+ [Entraînez et déployez votre propre algorithme R en SageMaker IA](https://sagemaker-examples.readthedocs.io/en/latest/r_examples/r_byo_r_algo_hpo/tune_r_bring_your_own.html) — Possédez-vous déjà un algorithme R et souhaitez-vous l'intégrer à l' SageMaker IA pour le régler, l'entraîner ou le déployer ? Cet exemple vous explique comment personnaliser les conteneurs SageMaker AI avec des packages R personnalisés, jusqu'à l'utilisation d'un point de terminaison hébergé à des fins d'inférence sur votre modèle R-origin.

# Commencez avec R in SageMaker AI
<a name="r-sagemaker-get-started"></a>

Cette rubrique explique comment commencer à utiliser l'environnement logiciel R dans l' SageMaker IA. Pour plus d'informations sur l'utilisation de R avec SageMaker l'IA, consultez[Ressources pour utiliser R avec Amazon SageMaker AI](r-guide.md).

**Pour commencer à utiliser R dans la console SageMaker AI**

1. [Créez une instance de bloc-notes](https://docs.aws.amazon.com/sagemaker/latest/dg/howitworks-create-ws.html) en utilisant le type d’instance t2.medium et la taille de stockage par défaut. Vous pouvez choisir une instance plus rapide et plus de stockage si vous prévoyez de continuer à utiliser l’instance pour des exemples plus avancés, ou vous pouvez créer une plus grande instance ultérieurement.

1. Attendez que le statut du bloc-notes soit **En service**, puis choisissez **Ouvrir Jupyter**.  
![\[Emplacement du InServicestatut et du lien Open Jupyter dans la console.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/An-R-User-Guide-to-SageMaker/An-R-User-Guide-to-SageMaker-1.png)

1. Créez une nouvelle instance de bloc-notes avec le noyau R à partir de la liste des environnements disponibles.  
![\[Emplacement du noyau R dans la liste des environnements disponibles.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/An-R-User-Guide-to-SageMaker/An-R-User-Guide-to-SageMaker-2.png)

1. Une fois l’instance de bloc-notes créée, vous devriez voir un logo R dans le coin supérieur droit de l’environnement de bloc-notes, ainsi que R comme noyau sous ce logo. Cela indique que SageMaker AI a lancé avec succès le noyau R pour cet ordinateur portable.  
![\[Emplacement du logo R et du noyau R de l’environnement de bloc-notes.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/An-R-User-Guide-to-SageMaker/An-R-User-Guide-to-SageMaker-3.png)

Alternativement, lorsque vous êtes dans un bloc-notes Jupyter, vous pouvez utiliser le menu **Noyau**, puis sélectionner **R** dans le sous-menu **Changer le noyau**.

![\[Emplacement de l’emplacement où remplacer le noyau de votre bloc-notes par R.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/An-R-User-Guide-to-SageMaker/An-R-User-Guide-to-SageMaker-4.png)


# Ressources pour utiliser Scikit-learn avec Amazon AI SageMaker
<a name="sklearn"></a>

Vous pouvez utiliser Amazon SageMaker AI pour entraîner et déployer un modèle à l'aide du code Scikit-learn personnalisé. Les estimateurs et modèles Scikit-learn du SDK SageMaker AI Python et les conteneurs open source Scikit-learn facilitent l'écriture d'un script Scikit-learn et son exécution dans SageMaker AI. SageMaker La section suivante fournit du matériel de référence que vous pouvez utiliser pour apprendre à utiliser Scikit-learn avec l'IA. SageMaker 

**Exigences**

Scikit-learn 1.4 possède les dépendances suivantes.


| Dépendance | Version minimale | 
| --- | --- | 
| Python | 3,10 | 
| NumPy | 2.1.0 | 
| SciPy | 1.15.3 | 
| joblib | 1.5.2 | 
| threadpoolctl | 3.6.0 | 

Le conteneur SageMaker AI Scikit-learn prend en charge les versions suivantes de Scikit-learn.


| Version Scikit-learn prise en charge | Version minimale de Python | 
| --- | --- | 
| 1.4-2 | 3.10 | 
| 1.2-1 | 3.8 | 
| 1.0-1 | 3.7 | 
| 0.23-1 | 3.6 | 
| 0.20.0 | 2.7 ou 3.4 | 

[Pour des informations générales sur l'écriture de scripts d'entraînement Scikit-learn et sur l'utilisation des estimateurs et modèles Scikit-learn avec l'IA SageMaker , voir Utilisation de Scikit-learn avec le SDK Python. SageMaker ](https://sagemaker.readthedocs.io/en/stable/using_sklearn.html)

## Que souhaitez-vous faire ?
<a name="sklearn-intent"></a>

**Note**  
Matplotlib v2.2.3 ou version ultérieure est nécessaire pour exécuter les exemples de blocs-notes AI Scikit-Learn. SageMaker 

Je souhaite utiliser Scikit-learn pour le traitement des données, l'ingénierie des fonctionnalités ou l'évaluation de modèles dans l'IA. SageMaker   
Pour un exemple de bloc-notes Jupyter, voir [https://github.com/awslabs/amazon-sagemaker-examples/tree/master/sagemaker\$1processing/scikit](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/sagemaker_processing/scikit_learn_data_processing_and_model_evaluation)\$1learn\$1data\$1processing\$1and\$1model\$1evaluation.  
Pour un article de blog sur la formation et le déploiement d'un modèle Scikit-Learn, consultez [Amazon SageMaker AI ajoute](https://aws.amazon.com/blogs/machine-learning/amazon-sagemaker-adds-scikit-learn-support/) le support Scikit-Learn.  
Pour obtenir la documentation, veuillez consulter [ReadTheDocs](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_processing.html#data-pre-processing-and-model-evaluation-with-scikit-learn).

Je souhaite entraîner un modèle Scikit-learn personnalisé en IA. SageMaker   
Pour un exemple de bloc-notes Jupyter, voir [https://github.com/awslabs/amazon-sagemaker-examples/tree/master/sagemaker-python-sdk/scikit](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/sagemaker-python-sdk/scikit_learn_iris)\$1learn\$1iris.  
Pour obtenir de la documentation, consultez [Former un modèle avec Scikit-learn](https://sagemaker.readthedocs.io/en/stable/using_sklearn.html#train-a-model-with-sklearn).

J'ai un modèle Scikit-learn que j'ai formé à l' SageMaker IA, et je souhaite le déployer sur un point de terminaison hébergé.  
Pour plus d’informations, consultez [Déploiement de modèles Scikit-learn](https://sagemaker.readthedocs.io/en/stable/using_sklearn.html#deploy-sklearn-models).

J'ai un modèle Scikit-learn que j'ai formé en dehors de l' SageMaker IA, et je souhaite le déployer sur un point de terminaison d'IA SageMaker   
Pour plus d’informations, consultez [Déploiement de points de terminaison à partir de données de modèle](https://sagemaker.readthedocs.io/en/stable/using_sklearn.html#deploy-endpoints-from-model-data).

Je souhaite consulter la documentation de l'API pour les classes Scikit-learn du [SDK Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable).  
Pour plus d’informations, consultez [Classes Scikit-learn](https://sagemaker.readthedocs.io/en/stable/sagemaker.sklearn.html).

Je souhaite obtenir des informations sur les conteneurs SageMaker AI Scikit-learn.  
Pour plus d'informations, consultez le référentiel [SageMaker Scikit-Learn](https://github.com/aws/sagemaker-scikit-learn-container) Container. GitHub 

# Ressources pour utiliser SparkML Serving avec Amazon AI SageMaker
<a name="sparkml-serving"></a>

Le modèle et le prédicteur SparkML Serving du [SDK Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable) et le conteneur SparkML Serving open source Amazon SageMaker AI prennent en charge le déploiement de pipelines Apache Spark ML sérialisés avec l'IA pour obtenir des inférences. MLeap SageMaker Utilisez les ressources suivantes pour apprendre à utiliser SparkML Serving avec l'IA. SageMaker 

Pour plus d'informations sur l'utilisation du conteneur SparkML Serving pour déployer des modèles sur l'IA, [SageMaker consultez le SageMaker référentiel de conteneurs Spark](https://github.com/aws/sagemaker-sparkml-serving-container) ML. GitHub Pour plus d'informations sur le modèle de service SparkML et les prédicteurs du [SDK Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable), consultez la documentation du modèle de service [SparkML et de l'API Predictor](https://sagemaker.readthedocs.io/en/stable/sagemaker.sparkml.html).

# Ressources à utiliser TensorFlow avec Amazon SageMaker AI
<a name="tf"></a>

Vous pouvez utiliser Amazon SageMaker AI pour entraîner et déployer un modèle à l'aide d'un TensorFlow code personnalisé. Les TensorFlow estimateurs et modèles du SDK SageMaker AI Python et les conteneurs open source d' SageMaker IA peuvent vous aider TensorFlow . Utilisez la liste de ressources suivante pour obtenir plus d'informations, en fonction de la version que TensorFlow vous utilisez et de ce que vous souhaitez faire.

## TensorFlow Version 1.11 et versions ultérieures
<a name="tf-script-mode"></a>

Pour TensorFlow les versions 1.11 et ultérieures, le [SDK Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable) prend en charge les scripts d'entraînement en mode script.

### Que souhaitez-vous faire ?
<a name="tf-intent"></a>

Je souhaite entraîner un TensorFlow modèle personnalisé en SageMaker IA.  
Pour un exemple de bloc-notes Jupyter, voir [entraînement et TensorFlow service en mode script](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-python-sdk/tensorflow_script_mode_training_and_serving/tensorflow_script_mode_training_and_serving.html).  
Pour obtenir de la documentation, voir [Entraîner un modèle avec TensorFlow](https://sagemaker.readthedocs.io/en/stable/using_tf.html#train-a-model-with-tensorflow).

J'ai un TensorFlow modèle que j'ai formé à l' SageMaker IA et je souhaite le déployer sur un terminal hébergé.  
Pour plus d'informations, voir [Déployer des modèles TensorFlow de service](https://sagemaker.readthedocs.io/en/stable/using_tf.html#deploy-tensorflow-serving-models).

J'ai un TensorFlow modèle que j'ai formé en dehors de l' SageMaker IA, et je souhaite le déployer sur un point de terminaison basé sur l' SageMaker IA.  
Pour plus d’informations, consultez [Déploiement direct à partir d’artefacts de modèle](https://sagemaker.readthedocs.io/en/stable/using_tf.html#deploying-directly-from-model-artifacts).

Je souhaite consulter la documentation de l'API pour les TensorFlow classes du [SDK Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable).  
Pour plus d'informations, consultez la section [TensorFlow Estimateur](https://sagemaker.readthedocs.io/en/stable/sagemaker.tensorflow.html).

Je souhaite trouver le référentiel de TensorFlow conteneurs SageMaker AI.  
Pour plus d'informations, consultez la section [ GitHub Référentiel de SageMaker TensorFlow conteneurs](https://github.com/aws/sagemaker-tensorflow-container).

Je souhaite obtenir des informations sur les TensorFlow versions prises en charge par AWS Deep Learning Containers.  
Pour plus d’informations, consultez [Images Deep Learning Containers disponibles](https://github.com/aws/deep-learning-containers/blob/master/available_images.md).

 Pour des informations générales sur l'écriture de scripts d'entraînement en mode TensorFlow TensorFlow script et l'utilisation d'estimateurs et de modèles en mode script avec l' SageMaker IA, consultez la section [Utilisation TensorFlow avec le SDK SageMaker Python](https://sagemaker.readthedocs.io/en/stable/using_tf.html).

## TensorFlow Mode Legacy pour les versions 1.11 et antérieures
<a name="tf-legacy-mode"></a>

Le [SDK Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable) fournit un ancien mode compatible avec les TensorFlow versions 1.11 et antérieures. Utilisez des scripts d' TensorFlow entraînement en mode ancien pour exécuter TensorFlow des tâches dans SageMaker l'IA si :
+ Vous avez des scripts en mode legacy que vous ne souhaitez pas convertir en mode script.
+ Vous souhaitez utiliser une TensorFlow version antérieure à la version 1.11.

Pour plus d'informations sur l'écriture de TensorFlow scripts en mode ancien à utiliser avec le SDK SageMaker AI Python, consultez [TensorFlow SageMaker Estimateurs et modèles.](https://github.com/aws/sagemaker-python-sdk/tree/v1.12.0/src/sagemaker/tensorflow#tensorflow-sagemaker-estimators-and-models)

# Ressources pour utiliser le serveur d'inférence Triton avec Amazon AI SageMaker
<a name="triton"></a>

SageMaker L'IA permet aux clients de déployer un modèle à l'aide d'un code personnalisé avec le serveur d'inférence NVIDIA Triton. Utilisez les ressources suivantes pour apprendre à utiliser le serveur d'inférence Triton avec SageMaker l'IA.

 Pour accéder à cette fonctionnalité, développez [Triton Inference Server Containers](https://docs.aws.amazon.com/deep-learning-containers/latest/devguide/what-is-dlc.html) (Conteneurs de serveur d’inférence Triton). Ces conteneurs incluent le serveur d'inférence NVIDIA Triton, la prise en charge des frameworks ML courants et des variables d'environnement utiles qui vous permettent d'optimiser les performances sur SageMaker l'IA. Pour obtenir la liste des images Deep Learning Containers disponibles, consultez [Images Deep Learning Containers disponibles](https://github.com/aws/deep-learning-containers/blob/master/available_images.md). Ces images de conteneurs Deep Learning Containers sont conservées et régulièrement mises à jour avec des correctifs de sécurité. 

Vous pouvez utiliser le conteneur Triton Inference Server avec le SDK SageMaker Python comme n'importe quel autre conteneur dans vos SageMaker modèles d'IA. Cependant, l'utilisation du SDK SageMaker Python est facultative. Vous pouvez utiliser les conteneurs du serveur d'inférence Triton avec et. AWS CLI AWS SDK pour Python (Boto3)

Pour plus d’informations sur le serveur d’inférence NVIDIA Triton, consultez la [documentation Triton](https://docs.nvidia.com/deeplearning/triton-inference-server/#).

## Inférence
<a name="triton-inference"></a>

**Note**  
Le backend Triton Python utilise la mémoire partagée (SHMEM) pour connecter votre code à Triton. SageMaker AI Inference fournit jusqu'à la moitié de la mémoire de l'instance sous forme de SHMEM, ce qui vous permet d'utiliser une instance avec plus de mémoire pour une taille SHMEM plus importante.

À des fins d'inférence, vous pouvez utiliser vos modèles de machine learning entraînés avec Triton Inference Server pour déployer une tâche d'inférence avec l'IA. SageMaker 

Voici quelques fonctions clés du conteneur de serveur d’inférence Triton :
+ **Prise en charge de plusieurs cadres** : Triton peut être utilisé pour déployer des modèles à partir de tous les principaux frameworks de ML. Triton prend en charge TensorFlow GraphDef et SavedModel, ONNX, PyTorch TorchScript TensorRT et les formats de modèles Python/C\$1\$1 personnalisés.
+ **Pipelines** de modèles : L'ensemble de modèles Triton représente un pipeline d'un modèle avec une logique de pre/post traitement et la connexion des tenseurs d'entrée et de sortie entre eux. Une seule demande d'inférence à un ensemble déclenche l'exécution du pipeline entier.
+ **Exécution simultanée du modèle** : plusieurs instances du même modèle peuvent s'exécuter simultanément sur le même GPU ou sur plusieurs GPUs.
+ **Traitement par lots dynamique** : pour les modèles qui prennent en charge le traitement par lots, Triton dispose de plusieurs algorithmes de planification et de traitement par lots intégrés qui combinent des demandes d'inférence individuelles pour améliorer le débit d'inférence. Ces décisions de planification et de traitement par lots sont transparentes pour le client qui demande l'inférence.
+ **Prise en charge de divers processeurs et GPU** : les modèles peuvent être exécutés sur CPUs ou GPUs pour une flexibilité maximale et pour répondre à des exigences informatiques hétérogènes.

## Que souhaitez-vous faire ?
<a name="triton-do"></a>

Je souhaite déployer mon PyTorch modèle entraîné dans le domaine de l' SageMaker IA.  
Pour un exemple de bloc-notes Jupyter, consultez l'exemple [Déployez votre modèle PyTorch Resnet50 avec le serveur d'inférence Triton](https://github.com/aws/amazon-sagemaker-examples/blob/master/sagemaker-triton/resnet50/triton_resnet50.ipynb).

Je souhaite déployer mon modèle Hugging Face entraîné SageMaker dans l'IA.  
Pour un exemple de bloc-notes Jupyter, consultez l'exemple [Déployez votre modèle PyTorch BERT avec le serveur d'inférence Triton](https://github.com/aws/amazon-sagemaker-examples/blob/master/sagemaker-triton/nlp_bert/triton_nlp_bert.ipynb).