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)