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.
# SageMaker Exemples d'AI Spark pour Scala
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 :
```
com.amazonaws
sagemaker-spark_2.11
spark_2.2.0-1.0
```
+ Si votre projet dépend de Spark 2.1, ajoutez ce qui suit à votre fichier pom.xml :
```
com.amazonaws
sagemaker-spark_2.11
spark_2.1.1-1.0
```
**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
Étant donné que 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 soutenant 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)