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)
# Utilisez des algorithmes personnalisés pour la formation et l'hébergement de modèles sur Amazon SageMaker AI avec Apache Spark
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
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|
+-----+--------------------+--------------------+-------------------+---------------+
```