Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# SageMaker Beispiele für AI Spark für Scala
Amazon SageMaker AI bietet eine Apache Spark-Bibliothek ([SageMaker AI Spark](https://github.com/aws/sagemaker-spark/tree/master/sagemaker-spark-sdk)), mit der Sie Ihre Apache Spark-Anwendungen mit SageMaker KI integrieren können. Dieses Thema enthält Beispiele, die Ihnen den Einstieg in SageMaker AI Spark mit Scala erleichtern sollen. Informationen zur SageMaker AI Apache Spark-Bibliothek finden Sie unter[Apache Spark mit Amazon SageMaker AI](apache-spark.md).
**Laden Sie Spark für Scala herunter**
Sie können den Quellcode und die Beispiele für die Bibliotheken Python Spark (PySpark) und Scala aus dem [SageMaker AI GitHub Spark-Repository](https://github.com/aws/sagemaker-spark) herunterladen.
Eine ausführliche Anleitung zur Installation der SageMaker AI Spark-Bibliothek finden Sie unter [SageMaker AI Spark](https://github.com/aws/sagemaker-spark/tree/master/sagemaker-spark-sdk).
SageMaker Das AI Spark SDK für Scala ist im zentralen Maven-Repository verfügbar. Fügen Sie die Spark-Bibliothek zum Projekt hinzu, indem Sie die Datei `pom.xml` um folgende Abhängigkeit ergänzen:
+ Wenn Ihr Projekt mit Maven-erstellt wurde, fügen Sie Folgendes zu Ihrer pom.xml -Datei hinzu:
```
com.amazonaws
sagemaker-spark_2.11
spark_2.2.0-1.0
```
+ Wenn Ihr Projekt von Spark 2.1 abhängt, fügen Sie Ihrer Datei pom.xml Folgendes hinzu:
```
com.amazonaws
sagemaker-spark_2.11
spark_2.1.1-1.0
```
**Beispiel für Spark für Scala**
Dieser Abschnitt enthält Beispielcode, der die von AI bereitgestellte Apache Spark-Scala-Bibliothek verwendet, um ein Modell in SageMaker SageMaker KI mithilfe von `DataFrame` s in Ihrem Spark-Cluster zu trainieren. Darauf folgen Beispiele zur Vorgehensweise [Verwenden Sie benutzerdefinierte Algorithmen für Modelltraining und Hosting auf Amazon SageMaker AI mit Apache Spark](apache-spark-example1-cust-algo.md) und[Verwenden Sie die SageMakerEstimator in einer Spark-Pipeline](apache-spark-example1-extend-pipeline.md).
Das folgende Beispiel hostet die resultierenden Modellartefakte mithilfe von SageMaker KI-Hosting-Diensten. Weitere Informationen zu diesem Beispiel finden Sie unter [Erste Schritte: K-Means-Clustering auf SageMaker KI mit dem 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). In diesem Beispiel wird insbesondere Folgendes ausgeführt:
+ Verwenden von `KMeansSageMakerEstimator` zum Training eines Modells für Daten
Da das Beispiel den von SageMaker KI bereitgestellten K-Means-Algorithmus verwendet, um ein Modell zu trainieren, verwenden Sie den. `KMeansSageMakerEstimator` Das Modell wird anhand von Bildern mit handschriftlichen einstelligen Zahlen (aus dem MNIST-Datensatz) trainiert. Sie stellen die Bilder als Eingabe-`DataFrame` bereit. Der Einfachheit halber stellt SageMaker AI diesen Datensatz in einem Amazon S3 S3-Bucket bereit.
Als Antwort wird von der Schätzfunktion ein `SageMakerModel`-Objekt zurückgegeben.
+ Abrufen von Inferenzen mithilfe des trainierten `SageMakerModel`-Objekts
Um Rückschlüsse aus einem in SageMaker KI gehosteten Modell zu ziehen, rufen Sie die `SageMakerModel.transform` Methode auf. Sie übergeben einen `DataFrame` als Eingabe. Von der Methode wird der `DataFrame` in einen anderen `DataFrame` transformiert, der die vom Modell abgerufenen Inferenzen enthält.
Für ein vorhandenes Eingabebild mit einer handschriftlichen einstelligen Zahl identifiziert die Inferenz den Cluster, dem das Bild angehört. Weitere Informationen finden Sie unter [k-Means-Algorithmus](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
```
Das Codebeispiel führt die folgenden Aufgaben durch:
+ Lädt den MNIST-Datensatz aus einem von SageMaker AI (`awsai-sparksdk-dataset`) bereitgestellten S3-Bucket in einen 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()
```
Die `show`-Methode zeigt die ersten 20 Zeilen im Datenframe an:
```
+-----+--------------------+
|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
```
Für jede Zeile gilt Folgendes:
+ Die `label`-Spalte identifiziert die Bildbezeichnung. Wenn beispielsweise das Bild mit der handschriftlichen Nummer die Ziffer 5 ist, lautet auch der Bezeichnungswert 5.
+ Die `features`-Spalte speichert einen Vektor (`org.apache.spark.ml.linalg.Vector`) des `Double`-Typs. Das sind die 784 Merkmale der handschriftlichen Zahl. (Jede handschriftliche Zahl ist ein Bild aus 28 x 28 Pixeln, was 784 Merkmale ergibt.)
+ Erstellt einen SageMaker AI-Schätzer () `KMeansSageMakerEstimator`
Die `fit` Methode dieses Schätzers verwendet den von SageMaker KI bereitgestellten K-Means-Algorithmus, um Modelle mithilfe einer Eingabe zu trainieren. `DataFrame` Als Antwort wird ein `SageMakerModel`-Objekt zurückgegeben, mit dem Sie Inferenzen abrufen können.
**Anmerkung**
Das `KMeansSageMakerEstimator` erweitert die SageMaker KI`SageMakerEstimator`, was den Apache Spark erweitert. `Estimator`
```
val estimator = new KMeansSageMakerEstimator(
sagemakerRole = IAMRole(roleArn),
trainingInstanceType = "ml.p2.xlarge",
trainingInstanceCount = 1,
endpointInstanceType = "ml.c4.xlarge",
endpointInitialInstanceCount = 1)
.setK(10).setFeatureDim(784)
```
Die Konstruktorparameter stellen Informationen bereit, die für das Training eines Modells und dessen Implementierung auf SageMaker KI verwendet werden:
+ `trainingInstanceType` und `trainingInstanceCount` – Geben den Typ und die Anzahl der für die Modelltraining zu verwendenden ML-Compute-Instances an.
+ `endpointInstanceType`— Identifiziert den ML-Compute-Instanztyp, der beim Hosten des Modells in SageMaker KI verwendet werden soll. Standardmäßig wird von einer ML-Compute-Instance ausgegangen.
+ `endpointInitialInstanceCount`— Identifiziert die Anzahl der ML-Compute-Instanzen, die ursprünglich den Endpunkt unterstützen, auf dem das Modell in SageMaker KI gehostet wird.
+ `sagemakerRole`— SageMaker KI übernimmt diese IAM-Rolle, um Aufgaben in Ihrem Namen auszuführen. Beispielsweise werden damit zum Zwecke der Modelltraining Daten aus S3 gelesen und das Trainingsergebnisse (Modellartefakte) in S3 geschrieben.
**Anmerkung**
In diesem Beispiel wird implizit ein SageMaker KI-Client erstellt. Zum Erstellen dieses Clients müssen Sie Ihre Anmeldeinformationen angeben. Die API verwendet diese Anmeldeinformationen, um Anfragen an KI zu authentifizieren. SageMaker Beispielsweise verwendet sie die Anmeldeinformationen zur Authentifizierung von Anfragen zur Erstellung eines Trainingsjobs und API-Aufrufe für die Bereitstellung des Modells mithilfe von SageMaker KI-Hosting-Diensten.
+ Nachdem das `KMeansSageMakerEstimator`-Objekt erstellt wurde, legen Sie die folgenden Parameter an, die in der Modelltraining verwendet werden:
+ Die Anzahl der Cluster, die der k-means-Algorithmus während der Modelltraining erstellen soll. Geben Sie zehn Cluster an, einen für jede Ziffer von null bis neun.
+ Gibt an, dass jedes Eingabebild 784 Merkmale hat (jede handschriftliche Zahl ist ein Bild aus 28 x 28 Pixeln, was 784 Funktionen ergibt).
+ Aufrufen der `fit`-Methode der Schätzfunktion
```
// train
val model = estimator.fit(trainingData)
```
Sie übergeben den Eingabe-`DataFrame` als Parameter. Das Modell übernimmt die gesamte Arbeit, das Modell zu trainieren und es für SageMaker KI bereitzustellen. Weitere Informationen finden Sie unter [Integrieren Sie Ihre Apache Spark-Anwendung mit KI SageMaker](apache-spark.md#spark-sdk-common-process). Als Antwort erhalten Sie ein `SageMakerModel` Objekt, mit dem Sie Rückschlüsse auf Ihr in SageMaker KI implementiertes Modell ziehen können.
Sie stellen nur den als Eingabe spezifizierten `DataFrame` bereit. Der Registry-Pfad zum k-means-Algorithmus, der für die Modelltraining verwendet wird, muss nicht angegeben werden, da `KMeansSageMakerEstimator` ihn kennt.
+ Ruft die `SageMakerModel.transform` Methode auf, um Rückschlüsse aus dem in SageMaker KI bereitgestellten Modell zu ziehen.
Die `transform`-Methode erhält einen `DataFrame`, transformiert diesen und gibt einen anderen `DataFrame` zurück, der die vom Modell abgerufenen Inferenzen enthält.
```
val transformedData = model.transform(testData)
transformedData.show
```
Der Einfachheit halber wird derselbe `DataFrame` als Eingabe für die `transform`-Methode verwendet, der bereits für die Modelltraining in diesem Beispiel herangezogen wurde. Von der `transform`-Methode werden folgende Schritte ausgeführt:
+ Serialisiert die `features` Spalte in der Eingabe `DataFrame` an protobuf und sendet sie zur Inferenz an den SageMaker KI-Endpunkt.
+ Die "protobuf"-Antwort wird in die beiden zusätzlichen Spalten (`distance_to_cluster` und `closest_cluster`) im transformierten `DataFrame` deserialisiert.
Die `show`-Methode ruft Inferenzen für die ersten 20 Zeilen im Eingabe-`DataFrame` ab:
```
+-----+--------------------+-------------------+---------------+
|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|
+-----+--------------------+-------------------+---------------+
```
Sie können die Daten folgendermaßen interpretieren:
+ Eine handschriftliche Zahl mit `label`5 gehört zu Cluster 4 (`closest_cluster`).
+ Eine handschriftliche Zahl mit `label`0 gehört zu Cluster 5.
+ Eine handschriftliche Zahl mit `label`4 gehört zu Cluster 9.
+ Eine handschriftliche Zahl mit `label`1 gehört zu Cluster 6.
**Topics**
+ [Verwenden Sie benutzerdefinierte Algorithmen für Modelltraining und Hosting auf Amazon SageMaker AI mit Apache Spark](apache-spark-example1-cust-algo.md)
+ [Verwenden Sie die SageMakerEstimator in einer Spark-Pipeline](apache-spark-example1-extend-pipeline.md)
# Verwenden Sie benutzerdefinierte Algorithmen für Modelltraining und Hosting auf Amazon SageMaker AI mit Apache Spark
In verwenden Sie den[SageMaker Beispiele für AI Spark für Scala](apache-spark-example1.md), `kMeansSageMakerEstimator` weil das Beispiel den von Amazon SageMaker AI bereitgestellten K-Means-Algorithmus für das Modelltraining verwendet. Stattdessen können Sie einen eigenen benutzerdefinierten Algorithmus zur Modelltraining einsetzen. Unter der Voraussetzung, dass Sie bereits ein Docker-Image erstellt haben, können Sie eine eigene `SageMakerEstimator` generieren und den Amazon-Elastic-Container-Registry-Pfad für das benutzerdefinierte Image angeben.
Im folgenden Beispiel wird gezeigt, wie ein `KMeansSageMakerEstimator`-Objekt aus `SageMakerEstimator` erstellt wird. Geben Sie in der neuen Schätzfunktion explizit den Docker-Registry-Pfad zu den Trainings- und Inferenzcode-Images an.
```
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")
```
Im Code sind folgende Parameter in den `SageMakerEstimator`-Konstruktor eingebunden:
+ `trainingImage` – Gibt den Docker-Registry-Pfad zum Trainings-Image mit Ihrem benutzerdefinierten Code an.
+ `modelImage` – Gibt den Docker-Registry-Pfad zum Image mit dem Inferenzcode an.
+ `requestRowSerializer` –Implementiert `com.amazonaws.services.sagemaker.sparksdk.transformation.RequestRowSerializer`.
Dieser Parameter serialisiert Zeilen in der Eingabe, um sie `DataFrame` zur Inferenz an das in SageMaker AI gehostete Modell zu senden.
+ `responseRowDeserializer` – Implementiert.
`com.amazonaws.services.sagemaker.sparksdk.transformation.ResponseRowDeserializer`.
Dieser Parameter deserialisiert Antworten aus dem Modell, das in AI gehostet wird, zurück in SageMaker ein. `DataFrame`
+ `trainingSparkDataFormat` – Gibt das von Spark verwendete Datenformat beim Upload der Trainingsdaten von einem `DataFrame` nach S3 an. Beispielsweise `"sagemaker"` für das protobuf-Format, `"csv"` für durch Komma getrennte Werte und `"libsvm"` für das LibSVM-Format.
Sie können Ihren eigenen `RequestRowSerializer` und `ResponseRowDeserializer` implementieren, um Zeilen aus einem Datenformat, das vom Inferenzcode unterstützt wird (z. B. LibSVM oder CSV), zu serialisieren und zu deserialisieren.
# Verwenden Sie die SageMakerEstimator in einer Spark-Pipeline
Sie können `org.apache.spark.ml.Estimator`-Schätzfunktionen und `org.apache.spark.ml.Model`-Modelle sowie `SageMakerEstimator`-Schätzfunktionen und `SageMakerModel`-Modelle in `org.apache.spark.ml.Pipeline`-Pipelines verwenden, wie in folgendem Beispiel dargestellt:
```
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()
```
Der Parameter `trainingSparkDataFormatOptions` konfiguriert Spark, damit die "protobuf"-Spalte "projectedFeatures" für die Modelltraining serialisiert wird. Zusätzlich wird die "label"-Spalte standardmäßig von Spark in "protobuf" serialisiert.
Da Inferenzen mithilfe der "projectedFeatures"-Spalte erstellt werden sollen, wird der Spaltenname an `ProtobufRequestRowSerializer` übergeben.
Das folgende Beispiel zeigt einen transformierten `DataFrame`:
```
+-----+--------------------+--------------------+-------------------+---------------+
|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|
+-----+--------------------+--------------------+-------------------+---------------+
```