As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# SageMaker Exemplos do AI Spark para Scala
A Amazon SageMaker AI fornece uma biblioteca Apache Spark ([SageMaker AI Spark](https://github.com/aws/sagemaker-spark/tree/master/sagemaker-spark-sdk)) que você pode usar para integrar seus aplicativos Apache Spark à IA. SageMaker Este tópico contém exemplos para ajudar você a começar a usar o SageMaker AI Spark com Scala. Para obter informações sobre a biblioteca SageMaker AI Apache Spark, consulte. [Apache Spark com Amazon AI SageMaker](apache-spark.md)
**Baixe o Spark para Scala**
[Você pode baixar o código-fonte e os exemplos das bibliotecas Python Spark (PySpark) e Scala no SageMaker repositório AI Spark.](https://github.com/aws/sagemaker-spark) GitHub
Para obter instruções detalhadas sobre a instalação da biblioteca SageMaker AI Spark, consulte [SageMaker AI Spark](https://github.com/aws/sagemaker-spark/tree/master/sagemaker-spark-sdk).
SageMaker O SDK do AI Spark para Scala está disponível no repositório central do Maven. Para adicionar a biblioteca Spark ao seu projeto, adicione a seguinte dependência ao arquivo `pom.xml`:
+ Se o projeto for criado com Maven, adicione o seguinte ao arquivo pom.xml:
```
com.amazonaws
sagemaker-spark_2.11
spark_2.2.0-1.0
```
+ Se seu projeto depende do Spark 2.1, adicione o seguinte ao seu arquivo pom.xml:
```
com.amazonaws
sagemaker-spark_2.11
spark_2.1.1-1.0
```
**Spark para exemplo de Scala**
Esta seção fornece um exemplo de código que usa a biblioteca Apache Spark Scala fornecida pela SageMaker AI para treinar um modelo em SageMaker IA usando `DataFrame` s em seu cluster Spark. Em seguida, há exemplos de como [Use algoritmos personalizados para treinamento e hospedagem de modelos na Amazon SageMaker AI com o Apache Spark](apache-spark-example1-cust-algo.md) e [Use o SageMakerEstimator em um Spark Pipeline](apache-spark-example1-extend-pipeline.md).
O exemplo a seguir hospeda os artefatos do modelo resultante usando serviços de hospedagem de SageMaker IA. Para obter mais detalhes sobre esse exemplo, consulte [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) Especificamente, este exemplo faz o seguinte:
+ Usa o `KMeansSageMakerEstimator` para ajustar (ou treinar) um modelo nos dados
Como o exemplo usa o algoritmo k-means fornecido pela SageMaker IA para treinar um modelo, você usa o. `KMeansSageMakerEstimator` Treine o modelo usando imagens de números manuscritos de um dígito (do conjunto de dados do MNIST). As imagens são fornecidas como uma entrada `DataFrame`. Para sua conveniência, a SageMaker IA fornece esse conjunto de dados em um bucket do Amazon S3.
Em resposta, o estimador retorna um objeto `SageMakerModel`.
+ Obtém inferências usando o `SageMakerModel` treinado
Para obter inferências de um modelo hospedado na SageMaker IA, você chama o `SageMakerModel.transform` método. Um `DataFrame` é passado como entrada. O método transforma a entrada `DataFrame` em outro `DataFrame` que contém inferências obtidas do modelo.
Para uma determinada imagem de entrada de um número manuscrito de um dígito, a inferência identifica um cluster ao qual a imagem pertence. Para obter mais informações, consulte [Algoritmo 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
```
O código de exemplo faz o seguinte:
+ Carrega o conjunto de dados MNIST de um bucket S3 fornecido pelo SageMaker AI (`awsai-sparksdk-dataset`) em um `DataFrame` Spark (): `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()
```
O método `show` exibe as primeiras 20 linhas no quadro de dados:
```
+-----+--------------------+
|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
```
Em cada linha:
+ A coluna `label` identifica o rótulo da imagem. Por exemplo, se a imagem do número manuscrito for o dígito 5, o valor do rótulo será 5.
+ A coluna `features` armazena um vetor (`org.apache.spark.ml.linalg.Vector`) de valores `Double`. Esses são os 784 atributos do número manuscrito. (Cada número manuscrito é uma imagem de 28 x 28 pixels, o que forma os 784 atributos.)
+ Cria um estimador de SageMaker IA () `KMeansSageMakerEstimator`
O `fit` método desse estimador usa o algoritmo k-means fornecido pela SageMaker IA para treinar modelos usando uma entrada. `DataFrame` Em resposta, ele retorna um objeto `SageMakerModel` que você pode usar para obter inferências.
**nota**
Isso `KMeansSageMakerEstimator` estende a SageMaker IA`SageMakerEstimator`, que estende o Apache `Estimator` Spark.
```
val estimator = new KMeansSageMakerEstimator(
sagemakerRole = IAMRole(roleArn),
trainingInstanceType = "ml.p2.xlarge",
trainingInstanceCount = 1,
endpointInstanceType = "ml.c4.xlarge",
endpointInitialInstanceCount = 1)
.setK(10).setFeatureDim(784)
```
Os parâmetros do construtor fornecem informações que são usadas para treinar um modelo e implantá-lo na SageMaker IA:
+ `trainingInstanceType` e `trainingInstanceCount`: Identificam o tipo e o número de instâncias de computação de ML a serem iniciados para o treinamento de modelo.
+ `endpointInstanceType`—Identifica o tipo de instância de computação de ML a ser usado ao hospedar o modelo na IA. SageMaker Por padrão, é assumida uma instância de cálculo de ML.
+ `endpointInitialInstanceCount`—Identifica o número de instâncias de computação de ML que inicialmente apoiam o endpoint que hospeda o modelo na IA. SageMaker
+ `sagemakerRole`— A SageMaker IA assume essa função do IAM para realizar tarefas em seu nome. Por exemplo, para treinamento de modelo, ele lê dados do S3 e grava os resultados do treinamento (artefatos de modelo) no S3.
**nota**
Esse exemplo cria implicitamente um cliente de SageMaker IA. Para criar esse cliente, você deve fornecer suas credenciais. A API usa essas credenciais para autenticar solicitações para a SageMaker IA. Por exemplo, ele usa as credenciais para autenticar solicitações para criar um trabalho de treinamento e chamadas de API para implantar o modelo usando serviços de hospedagem de SageMaker IA.
+ Depois que o objeto `KMeansSageMakerEstimator` estiver criado, defina os seguintes parâmetros, que são usados no treinamento de modelo:
+ O número de clusters que o algoritmo k-means deve criar durante o treinamento de modelo. Você especifica 10 clusters, um para cada dígito, de 0 a 9.
+ O vetor que identifica que cada imagem de entrada tem 784 atributos. Cada número manuscrito é uma imagem de 28 x 28 pixels, o que forma os 784 atributos.
+ Chama o método estimador `fit`
```
// train
val model = estimator.fit(trainingData)
```
A entrada `DataFrame` é passada como parâmetro. O modelo faz todo o trabalho de treinar o modelo e implantá-lo na SageMaker IA. Para obter mais informações, consulte, [Integre seu aplicativo Apache Spark com a IA SageMaker](apache-spark.md#spark-sdk-common-process). Em resposta, você obtém um `SageMakerModel` objeto, que pode ser usado para obter inferências do seu modelo implantado na SageMaker IA.
Apenas a entrada `DataFrame` é fornecida. Como o `KMeansSageMakerEstimator` já conhece o caminho do registro para o algoritmo k-means usado para treinamento de modelo, não é necessário especificá-lo.
+ Chama o `SageMakerModel.transform` método para obter inferências do modelo implantado na SageMaker IA.
O método `transform` assume um `DataFrame` como entrada. Em seguida, transforma essa entrada e retorna outro `DataFrame` que contém inferências obtidas do modelo.
```
val transformedData = model.transform(testData)
transformedData.show
```
Para simplificar, usaremos o mesmo `DataFrame` como entrada do método `transform` usado para treinamento de modelo nesse exemplo. O método `transform` faz o seguinte:
+ Serializa a `features` coluna na entrada `DataFrame` para protobuf e a envia para o endpoint de SageMaker IA para inferência.
+ Desserializa a resposta protobuf para as duas colunas adicionais (`distance_to_cluster` e `closest_cluster`) no `DataFrame` transformado.
O método `show` obtém inferências para as primeiras 20 linhas da entrada `DataFrame`:
```
+-----+--------------------+-------------------+---------------+
|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|
+-----+--------------------+-------------------+---------------+
```
Os dados podem ser interpretados da seguinte forma:
+ Um número manuscrito com `label` 5 pertence ao cluster 4 (`closest_cluster`).
+ Um número manuscrito com `label` 0 pertence ao cluster 5.
+ Um número manuscrito com `label` 4 pertence ao cluster 9.
+ Um número manuscrito com `label` 1 pertence ao cluster 6.
**Topics**
+ [Use algoritmos personalizados para treinamento e hospedagem de modelos na Amazon SageMaker AI com o Apache Spark](apache-spark-example1-cust-algo.md)
+ [Use o SageMakerEstimator em um Spark Pipeline](apache-spark-example1-extend-pipeline.md)
# Use algoritmos personalizados para treinamento e hospedagem de modelos na Amazon SageMaker AI com o Apache Spark
Em[SageMaker Exemplos do AI Spark para Scala](apache-spark-example1.md), você usa o `kMeansSageMakerEstimator` porque o exemplo usa o algoritmo k-means fornecido pela Amazon SageMaker AI para treinamento de modelos. Mas você pode optar por usar seu próprio algoritmo personalizado para treinamento de modelo. Supondo que você já criou uma imagem do Docker, é possível criar o seu próprio `SageMakerEstimator` e especificar o caminho do Amazon Elastic Container Registry para a imagem personalizada.
O exemplo a seguir mostra como criar um `KMeansSageMakerEstimator` a partir do `SageMakerEstimator`. No novo estimador, especifique explicitamente o caminho do registro do Docker para as imagens de código do treinamento e da inferência.
```
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")
```
No código, os parâmetros no construtor `SageMakerEstimator` contêm:
+ `trainingImage` : Identifica o caminho de registro do Docker para a imagem de treinamento que contém seu código personalizado.
+ `modelImage` : Identifica o caminho do registro do Docker para a imagem que contém o código de inferência.
+ `requestRowSerializer` : Implementa `com.amazonaws.services.sagemaker.sparksdk.transformation.RequestRowSerializer`.
Esse parâmetro serializa as linhas na entrada `DataFrame` para enviá-las ao modelo hospedado na SageMaker IA para inferência.
+ `responseRowDeserializer` : Implementa
`com.amazonaws.services.sagemaker.sparksdk.transformation.ResponseRowDeserializer`.
Esse parâmetro desserializa as respostas do modelo, hospedado na SageMaker IA, de volta para um. `DataFrame`
+ `trainingSparkDataFormat` : Especifica o formato de dados que o Spark usa ao fazer upload de dados de treinamento de um `DataFrame` no S3. Por exemplo, `"sagemaker"` para o formato protobuf, `"csv"` para valores separados por vírgula e `"libsvm"` para o formato LibSVM.
Você pode implementar seus próprios `RequestRowSerializer` e `ResponseRowDeserializer` para serializar e desserializar linhas de um formato de dados compatível com seu código de inferência, como .libsvm ou .csv.
# Use o SageMakerEstimator em um Spark Pipeline
Você pode usar estimadores `org.apache.spark.ml.Estimator` e modelos `org.apache.spark.ml.Model`, bem como estimadores `SageMakerEstimator` e modelos `SageMakerModel` em pipelines `org.apache.spark.ml.Pipeline`, conforme mostrado no seguinte exemplo:
```
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()
```
O parâmetro `trainingSparkDataFormatOptions` configura o Spark para serializar para protobuf a coluna "projectedFeatures" de treinamento de modelo. Além disso, o Spark serializa para protobuf a coluna "label" por padrão.
Como queremos fazer inferências usando a coluna "projectedFeatures", passaremos o nome da coluna para o `ProtobufRequestRowSerializer`.
O seguinte exemplo mostra um `DataFrame` transformado:
```
+-----+--------------------+--------------------+-------------------+---------------+
|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|
+-----+--------------------+--------------------+-------------------+---------------+
```