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)), die Sie verwenden können, um Ihre Apache Spark-Anwendungen mit SageMaker KI zu integrieren. 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 AI SageMaker](apache-spark.md). **Laden Sie Spark für Scala herunter** Sie können den Quellcode und die Beispiele für Python Spark (PySpark) - und Scala-Bibliotheken aus dem [ SageMaker AI ](https://github.com/aws/sagemaker-spark) GitHub Spark-Repository 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 das Modelltraining und das Hosting auf Amazon AI mit Apache Spark SageMaker](apache-spark-example1-cust-algo.md) und[Verwenden Sie das SageMakerEstimator in einer Spark-Pipeline](apache-spark-example1-extend-pipeline.md). Das folgende Beispiel hostet die resultierenden Modellartefakte mithilfe von SageMaker AI-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) Konkret bewirkt dieses Beispiel Folgendes: + Verwenden von `KMeansSageMakerEstimator` zum Training eines Modells für Daten Da im Beispiel der von SageMaker KI bereitgestellte K-Means-Algorithmus zum Trainieren eines Modells verwendet wird, 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-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 AI gehosteten Modell zu erhalten, 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.) + Erzeugt einen SageMaker AI-Schätzer () `KMeansSageMakerEstimator` Die `fit` Methode dieses Schätzers verwendet den von SageMaker KI bereitgestellten K-Means-Algorithmus, um Modelle anhand 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`, wodurch der Apache Spark erweitert wird. `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 liefern Informationen, die für das Training eines Modells und dessen Bereitstellung 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-Instance-Typ, der beim Hosten des Modells in SageMaker AI verwendet werden soll. Standardmäßig wird von einer ML-Compute-Instance ausgegangen. + `endpointInitialInstanceCount`— Identifiziert die Anzahl der ML-Recheninstanzen, die ursprünglich den Endpunkt unterstützen, der das Modell in SageMaker AI hostet. + `sagemakerRole`— SageMaker AI ü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 AI-Client erstellt. Zum Erstellen dieses Clients müssen Sie Ihre Anmeldeinformationen angeben. Die API verwendet diese Anmeldeinformationen, um Anfragen an AI zu SageMaker authentifizieren. Beispielsweise verwendet sie die Anmeldeinformationen, um Anfragen zur Erstellung eines Trainingsauftrags und API-Aufrufe für die Bereitstellung des Modells mithilfe von SageMaker KI-Hosting-Diensten zu authentifizieren. + 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 die 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, das Sie verwenden können, um Rückschlüsse aus Ihrem in SageMaker KI bereitgestellten Modell zu ziehen. 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 AI bereitgestellten Modell abzurufen. 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 AI-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 das Modelltraining und das Hosting auf Amazon AI mit Apache Spark SageMaker](apache-spark-example1-cust-algo.md) + [Verwenden Sie das SageMakerEstimator in einer Spark-Pipeline](apache-spark-example1-extend-pipeline.md)