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á.
# Linguagens e frameworks de Machine Learning
A Amazon SageMaker AI fornece suporte nativo para linguagens de programação e estruturas de aprendizado de máquina populares, capacitando desenvolvedores e cientistas de dados a aproveitar suas ferramentas e tecnologias preferidas. Esta seção oferece referências para trabalhar com Python e R, bem como seus respectivos kits de desenvolvimento de software (SDKs) dentro da SageMaker IA. Além disso, abrange uma ampla variedade de estruturas de aprendizado de máquina e aprendizado profundo, incluindo Apache MXNet,, PyTorch. TensorFlow
Você pode usar Python e R nativamente nos kernels de notebooks da Amazon SageMaker . Também há kernels que oferecem apoio a frameworks específicos. Uma forma muito popular de começar a usar a SageMaker IA é usar o [Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable) SDK. Ele fornece Python APIs e contêineres de código aberto que facilitam o treinamento e a implantação de modelos em SageMaker IA, além de exemplos para uso com várias estruturas diferentes de aprendizado de máquina e aprendizado profundo.
Para obter informações sobre como usar estruturas específicas ou como usar R na SageMaker IA, consulte os tópicos a seguir.
Idiomas SDKs e guias do usuário:
+ [SDK para Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable)
+ [R](r-guide.md)
+ [Referência da API](api-and-sdk-reference.md)
Guias de frameworks de machine learning e de aprendizado profundo:
+ [Apache MXNet](mxnet.md)
+ [Apache Spark](apache-spark.md)
+ [Chainer](chainer.md)
+ [Hugging Face](hugging-face.md)
+ [PyTorch](pytorch.md)
+ [Scikit-learn](sklearn.md)
+ [SparkML Serving](sparkml-serving.md)
+ [TensorFlow](tf.md)
+ [Triton Inference Server](triton.md)
# Recursos para usar o Apache MXNet com a Amazon AI SageMaker
Os MXNet estimadores e modelos do [Amazon SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable) e o MXNet contêiner de código aberto de SageMaker IA facilitam a criação de um MXNet script e sua execução na IA. SageMaker A seção a seguir fornece material de referência que você pode usar para aprender a usar a SageMaker IA para treinar e implantar um modelo usando MXNet código personalizado.
## O que você deseja fazer?
Quero treinar um MXNet modelo personalizado em SageMaker IA.
Para obter a documentação, consulte [Treinar um modelo com MXNet](https://sagemaker.readthedocs.io/en/stable/using_mxnet.html#train-a-model-with-mxnet).
Eu tenho um MXNet modelo que treinei em SageMaker IA e quero implantá-lo em um endpoint hospedado.
Para obter mais informações, consulte [Implantar MXNet modelos](https://sagemaker.readthedocs.io/en/stable/using_mxnet.html#deploy-mxnet-models).
Tenho um MXNet modelo que treinei fora da SageMaker IA e quero implantá-lo em um endpoint de SageMaker IA
Para mais informações, consulte [Implantar Endpoints de dados do modelo](https://sagemaker.readthedocs.io/en/stable/using_mxnet.html#deploy-endpoints-from-model-data).
Quero ver a documentação da API para as classes do [Amazon SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable) MXNet.
Para obter mais informações, consulte [MXNet Classes](https://sagemaker.readthedocs.io/en/stable/frameworks/mxnet/sagemaker.mxnet.html).
Quero encontrar o repositório de MXNet contêineres de SageMaker IA.
Para obter mais informações, consulte [ GitHub Repositório SageMaker AI MXNet Container](https://github.com/aws/sagemaker-mxnet-container).
Quero encontrar informações sobre as MXNet versões suportadas pelo AWS Deep Learning Containers.
Para obter mais informações, consulte as [Imagens de contêiner de aprendizado profundo disponíveis](https://github.com/aws/deep-learning-containers/blob/master/available_images.md).
Para obter informações gerais sobre como escrever scripts de treinamento no modo MXNet MXNet script e usar estimadores e modelos do modo script com SageMaker IA, consulte [Usando MXNet com o SDK do Python SageMaker ](https://sagemaker.readthedocs.io/en/stable/using_mxnet.html).
# Apache Spark com Amazon AI SageMaker
O Amazon SageMaker AI Spark é uma biblioteca Spark de código aberto que ajuda você a criar pipelines de aprendizado de máquina (ML) do Spark com IA. SageMaker Isso simplifica a integração dos estágios do Spark ML com os estágios de SageMaker IA, como treinamento e hospedagem de modelos. Para obter informações sobre o SageMaker AI Spark, consulte o repositório do [SageMaker AI Spark](https://github.com/aws/sagemaker-spark) GitHub . Os tópicos a seguir fornecem informações para aprender a usar o Apache Spark com SageMaker IA.
A biblioteca SageMaker AI Spark está disponível em Python e Scala. Você pode usar o SageMaker AI Spark para treinar modelos em SageMaker IA usando quadros de `org.apache.spark.sql.DataFrame` dados em seus clusters do Spark. Após o treinamento do modelo, você também pode hospedar o modelo usando serviços de hospedagem de SageMaker IA.
A biblioteca SageMaker AI Spark,`com.amazonaws.services.sagemaker.sparksdk`, fornece as seguintes classes, entre outras:
+ `SageMakerEstimator`: Estende a interface `org.apache.spark.ml.Estimator`. Você pode usar esse estimador para treinamento de modelos em SageMaker IA.
+ `KMeansSageMakerEstimator`, `PCASageMakerEstimator` e `XGBoostSageMakerEstimator`: Estendem a classe `SageMakerEstimator`.
+ `SageMakerModel`: Estende a classe `org.apache.spark.ml.Model`. Você pode usar isso `SageMakerModel` para hospedar modelos e obter inferências em SageMaker IA.
[Você pode baixar o código-fonte das bibliotecas Python Spark (PySpark) e Scala no repositório AI Spark. SageMaker ](https://github.com/aws/sagemaker-spark) GitHub
Para instalação e exemplos da biblioteca SageMaker AI Spark, consulte [SageMaker Exemplos do AI Spark para Scala](apache-spark-example1.md) ou[Recursos para usar exemplos do SageMaker AI Spark para Python (PySpark)](apache-spark-additional-examples.md).
[Se você usa o Amazon EMR AWS para gerenciar clusters do Spark, consulte Apache Spark.](https://aws.amazon.com/emr/features/spark/) Para obter mais informações sobre o uso do Amazon EMR em SageMaker IA, consulte. [Preparação de dados usando o Amazon EMR](studio-notebooks-emr-cluster.md)
**Topics**
+ [
## Integre seu aplicativo Apache Spark com a IA SageMaker
](#spark-sdk-common-process)
+ [
# SageMaker Exemplos do AI Spark para Scala
](apache-spark-example1.md)
+ [
# Recursos para usar exemplos do SageMaker AI Spark para Python (PySpark)
](apache-spark-additional-examples.md)
## Integre seu aplicativo Apache Spark com a IA SageMaker
A seguir, um resumo de alto nível das etapas para integrar seu aplicativo Apache Spark com a IA. SageMaker
1. Continue o pré-processamento de dados usando a biblioteca Apache Spark que você já conhece. O conjunto de dados permanece como um `DataFrame` no seu cluster do Spark. Carregue seus dados em um `DataFrame`. Faça o pré-processamento deles para ter uma coluna `features` com `org.apache.spark.ml.linalg.Vector` de `Doubles` e uma coluna `label` opcional com valores do tipo `Double`.
1. Use o estimador na biblioteca do SageMaker AI Spark para treinar seu modelo. Por exemplo, se você escolher o algoritmo k-means fornecido pela SageMaker IA para treinamento de modelos, chame o `KMeansSageMakerEstimator.fit` método.
Forneça seu `DataFrame` como entrada. O estimador retorna um objeto `SageMakerModel`.
**nota**
`SageMakerModel` estende o `org.apache.spark.ml.Model`.
O método `fit` faz o seguinte:
1. Converte a entrada `DataFrame` para o formato protobuf. Isso é feito selecionando as colunas `features` e `label` da entrada `DataFrame`. Em seguida, ele carrega upload dos dados do protobuf em um bucket do Amazon S3. O formato protobuf é eficiente para treinamento de modelos em SageMaker IA.
1. Inicia o treinamento de modelos em SageMaker IA enviando uma [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html)solicitação de SageMaker IA. Após a conclusão do treinamento do modelo, a SageMaker IA salva os artefatos do modelo em um bucket S3.
SageMaker A IA assume a função do IAM que você especificou para o treinamento de modelos para realizar tarefas em seu nome. Por exemplo, para ler dados de treinamento de um bucket do S3 e gravar artefatos de modelo em um bucket.
1. Cria e retorna um objeto `SageMakerModel`. O construtor executa as tarefas a seguir, relacionadas à implantação do seu modelo na IA. SageMaker
1. Envia uma [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html)solicitação para a SageMaker IA.
1. Envia uma [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpointConfig.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpointConfig.html)solicitação para a SageMaker IA.
1. Envia uma [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpoint.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpoint.html)solicitação para a SageMaker IA, que então inicia os recursos especificados e hospeda o modelo neles.
1. Você pode obter inferências do seu modelo hospedado na SageMaker IA com o. `SageMakerModel.transform`
Forneça uma entrada `DataFrame` com atributos como entrada. O método `transform` transforma-a em um `DataFrame` que contém inferências. Internamente, o `transform` método envia uma solicitação à [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_runtime_InvokeEndpoint.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_runtime_InvokeEndpoint.html) SageMaker API para obter inferências. O método `transform` anexa as inferências à entrada `DataFrame`.
# 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|
+-----+--------------------+--------------------+-------------------+---------------+
```
# Recursos para usar exemplos do SageMaker AI Spark para Python (PySpark)
A Amazon SageMaker AI fornece uma biblioteca Apache Spark Python ([SageMaker AI PySpark](https://github.com/aws/sagemaker-spark/tree/master/sagemaker-pyspark-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 PySpark. Para obter informações sobre a biblioteca SageMaker AI Apache Spark, consulte. [Apache Spark com Amazon AI SageMaker](apache-spark.md)
**Baixar PySpark**
[Você pode baixar o código-fonte das bibliotecas Python Spark (PySpark) e Scala no repositório AI Spark. SageMaker ](https://github.com/aws/sagemaker-spark) GitHub
Para obter instruções sobre como instalar a biblioteca do SageMaker AI Spark, use qualquer uma das opções a seguir ou visite o [SageMaker AI PySpark](https://github.com/aws/sagemaker-spark/tree/master/sagemaker-pyspark-sdk).
+ Instale usando pip:
```
pip install sagemaker_pyspark
```
+ Instale a partir da fonte:
```
git clone git@github.com:aws/sagemaker-spark.git
cd sagemaker-pyspark-sdk
python setup.py install
```
+ Você também pode criar um novo caderno em uma instância de caderno que use o kernel `Sparkmagic (PySpark)` ou `Sparkmagic (PySpark3)` para se conectar a um cluster remoto do Amazon EMR.
**nota**
O cluster do Amazon EMR deve ser configurado com um perfil do IAM que tenha a política `AmazonSageMakerFullAccess` anexada. Para obter informações sobre a configuração de funções para um cluster do EMR, consulte [Configurar funções do IAM para permissões do Amazon EMR em serviços da AWS](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-iam-roles.html) no *Guia de Gerenciamento do Amazon EMR*.
**PySpark exemplos**
Para exemplos sobre o uso da SageMaker IA PySpark, consulte:
+ [Usando o Amazon SageMaker AI com o Apache Spark](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-spark/index.html) em Read the Docs.
+ SageMaker GitHubRepositório [AI Spark](https://github.com/aws/sagemaker-spark).
# Recursos para usar o Chainer com a Amazon AI SageMaker
Você pode usar a SageMaker IA para treinar e implantar um modelo usando o código Chainer personalizado. Os estimadores e modelos do SageMaker AI Python SDK Chainer e o contêiner Chainer de código aberto SageMaker AI facilitam a criação de um script do Chainer e sua execução na IA. SageMaker A seção a seguir fornece material de referência que você pode usar para aprender a usar o Chainer com SageMaker IA.
## O que você deseja fazer?
Quero treinar um modelo Chainer personalizado em SageMaker IA.
Para ver uma amostra do caderno Jupyter, consulte os cadernos de [exemplo do Chainer no repositório](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/sagemaker-python-sdk/mxnet_mnist) Amazon SageMaker AI Examples. GitHub
Para obter a documentação, consulte [Treinar um modelo com o Chainer](https://sagemaker.readthedocs.io/en/stable/using_chainer.html#train-a-model-with-chainer).
Eu tenho um modelo Chainer que treinei em SageMaker IA e quero implantá-lo em um endpoint hospedado.
Para obter mais informações, consulte [Implantar modelos do Chainer](https://sagemaker.readthedocs.io/en/stable/using_chainer.html#deploy-chainer-models).
Tenho um modelo Chainer que treinei fora da SageMaker IA e quero implantá-lo em um SageMaker endpoint de IA
Para mais informações, consulte [Implantar Endpoints de dados do modelo](https://sagemaker.readthedocs.io/en/stable/using_chainer.html#deploy-endpoints-from-model-data).
Quero ver a documentação da API para as classes do [Amazon SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable) Chainer.
Para obter mais informações, consulte [Classes do Chainer](https://sagemaker.readthedocs.io/en/stable/sagemaker.chainer.html).
Quero encontrar informações sobre os contêineres SageMaker AI Chainer.
Para obter mais informações, consulte o repositório [SageMaker AI Chainer GitHub Container](https://github.com/aws/sagemaker-chainer-container).
[Para obter informações sobre as versões suportadas do Chainer e informações gerais sobre como escrever scripts de treinamento do Chainer e usar estimadores e modelos do Chainer com IA SageMaker , consulte Usando o Chainer com o SDK do Python. SageMaker ](https://sagemaker.readthedocs.io/en/stable/using_chainer.html)
# Recursos para usar o Hugging Face com a Amazon AI SageMaker
A Amazon SageMaker AI permite que os clientes treinem, ajustem e executem inferências usando modelos Hugging Face para processamento de linguagem natural (NLP) em IA. SageMaker Você pode usar Hugging Face tanto para treinamento como para inferência. A seção a seguir fornece informações sobre os modelos Hugging Face e inclui material de referência que você pode usar para aprender a usar o Hugging Face com IA. SageMaker
Essa funcionalidade está disponível por meio do desenvolvimento dos [AWS Contêiner de Aprendizado Profundo](https://docs.aws.amazon.com/deep-learning-containers/latest/devguide/what-is-dlc.html) do Hugging Face. Esses contêineres incluem Transformadores, Tokenizers e a biblioteca de banco de dados do Hugging Face, que permite que você use esses recursos para seus trabalhos de treinamento e inferência. Para obter uma lista completa das imagens dos Contêiner de Aprendizado Profundo disponíveis, consulte [Imagens dos Contêiner de Aprendizado Profundo disponíveis](https://github.com/aws/deep-learning-containers/blob/master/available_images.md). Essas imagens dos Contêiner de Aprendizado Profundo são mantidas e atualizadas regularmente com patches de segurança.
[Para usar os Hugging Face Deep Learning Containers com o SageMaker Python SDK para treinamento, consulte o Hugging Face AI Estimator. SageMaker ](https://sagemaker.readthedocs.io/en/stable/frameworks/huggingface/index.html) Com o Hugging Face Estimator, você pode usar os modelos Hugging Face como faria com qualquer outro Estimador de IA. SageMaker No entanto, usar o SDK do SageMaker Python é opcional. Você também pode orquestrar o uso dos Hugging Face Deep Learning Containers com e. AWS CLI AWS SDK para Python (Boto3)
Para obter mais informações sobre o Hugging Face e os modelos disponíveis nele, consulte a [documentação do Hugging Face.](https://huggingface.co/)
## Treinamento
Para realizar o treinamento, use qualquer um dos milhares de modelos disponíveis no Hugging Face e ajuste-os para seu caso de uso com treinamento adicional. Com a SageMaker IA, você pode usar o treinamento padrão ou aproveitar as vantagens do [treinamento em SageMaker IA Distributed Data e Model Parallel](https://docs.aws.amazon.com/sagemaker/latest/dg/distributed-training.html).
Como outros trabalhos de SageMaker treinamento usando código personalizado, você pode capturar suas próprias métricas passando uma definição de métricas para o SDK do SageMaker Python. Para ver um exemplo, consulte [Definição de métricas de treinamento (SageMaker Python SDK](https://docs.aws.amazon.com/sagemaker/latest/dg/training-metrics.html#define-train-metrics-sdk)). Você pode acessar as métricas capturadas usando [CloudWatch](https://docs.aws.amazon.com/sagemaker/latest/dg/monitoring-cloudwatch.html)e como Pandas `DataFrame` usando o [TrainingJobAnalytics](https://sagemaker.readthedocs.io/en/stable/api/training/analytics.html#sagemaker.analytics.TrainingJobAnalytics)método. Depois que seu modelo for treinado e ajustado, você poderá usá-lo como qualquer outro modelo para executar trabalhos de inferência.
### Como executar o treinamento com o estimador do Hugging Face
Você pode implementar o Hugging Face Estimator para trabalhos de treinamento usando o SDK AI Python. SageMaker O SageMaker Python SDK é uma biblioteca de código aberto para treinar e implantar modelos de aprendizado de máquina em IA. SageMaker [Para obter mais informações sobre o Hugging Face Estimator, consulte a documentação do AI Python SDK. SageMaker ](https://sagemaker.readthedocs.io/en/stable/frameworks/huggingface/index.html)
Com o SDK do SageMaker Python, você pode executar trabalhos de treinamento usando o Hugging Face Estimator nos seguintes ambientes:
+ [Amazon SageMaker Studio Classic](https://docs.aws.amazon.com/sagemaker/latest/dg/studio.html): O Studio Classic é o primeiro ambiente de desenvolvimento (IDE) totalmente integrado para aprendizado de máquina (ML). O Studio Classic fornece uma interface visual única, baseada na web, na qual você pode realizar todas as etapas de desenvolvimento de ML necessárias para:
+ preparar
+ build
+ treinar e ajustar;
+ implantar e gerenciar modelos.
Para obter informações sobre como usar os cadernos Jupyter no Studio Classic, consulte [Use notebooks Amazon SageMaker Studio Classic](notebooks.md).
+ [SageMakerInstâncias de notebook](https://docs.aws.amazon.com/sagemaker/latest/dg/nbi.html): uma instância de SageMaker notebook da Amazon é uma instância de computação de aprendizado de máquina (ML) que executa o aplicativo Jupyter Notebook. Esse aplicação permite que você execute cadernos Jupyter em sua instância de caderno para:
+ preparar e processar dados;
+ escrever código para treinar modelos;
+ implante modelos na hospedagem de SageMaker IA
+ teste ou valide seus modelos sem os recursos do SageMaker Studio, como depurador, monitoramento de modelos e um IDE baseado na web
+ Localmente: se você tiver conectividade AWS e tiver as permissões de SageMaker IA apropriadas, poderá usar o SDK do SageMaker Python localmente. Com o uso local, você pode iniciar trabalhos remotos de treinamento e inferência para Hugging Face in AI on. SageMaker AWS Isso funciona em sua máquina local, bem como em outros AWS serviços com um SDK SageMaker Python conectado e as permissões apropriadas.
## Inferência
Para inferência, você pode usar seu modelo treinado do Hugging Face ou um dos modelos pré-treinados do Hugging Face para implantar um trabalho de inferência com IA. SageMaker Com essa colaboração, você só precisa de uma linha de código para implantar seus modelos treinados e modelos pré-treinados com SageMaker IA. Você também pode executar trabalhos de inferência sem precisar escrever nenhum código de inferência personalizado. Com o código de inferência personalizado, você pode personalizar a lógica de inferência fornecendo seu próprio script Python.
### Como implantar um trabalho de inferência usando os Contêiner de Aprendizado Profundo do Hugging Face
Você tem duas opções para executar inferência com SageMaker IA. Você pode executar inferências usando um modelo que você treinou ou implantar um modelo pré-treinado do Hugging Face.
+ **Executar inferências com seu modelo treinado:** você tem duas opções para executar inferências com seu próprio modelo treinado.
+ Execute inferências com um modelo que você treinou usando um modelo existente do Hugging Face com os AI SageMaker Hugging Face Deep Learning Containers.
+ Traga seu próprio modelo existente do Hugging Face e implante-o usando IA. SageMaker
Ao executar a inferência com um modelo que você treinou com o SageMaker AI Hugging Face Estimator, você pode implantar o modelo imediatamente após a conclusão do treinamento. Você também pode carregar o modelo treinado em um bucket do Amazon S3 e ingeri-lo ao executar a inferência posteriormente.
Se você trouxer seu próprio modelo existente do Hugging Face, deverá carregar o modelo treinado em um bucket do Amazon S3. Em seguida, ingira o bucket ao executar a inferência, conforme mostrado em [Exemplo de como implementar seus transformadores do Hugging Face para inferência](https://github.com/huggingface/notebooks/blob/main/sagemaker/10_deploy_model_from_s3/deploy_transformer_model_from_s3.ipynb).
+ **Execute inferência com um HuggingFace modelo pré-treinado:** você pode usar um dos milhares de modelos pré-treinados do Hugging Face para executar seus trabalhos de inferência sem a necessidade de treinamento adicional. Para executar a inferência, selecione o modelo pré-treinado na lista de [modelos do Hugging Face](https://huggingface.co/models), conforme descrito em [Exemplo de como implantar transformadores pré-treinados do Hugging Face](https://github.com/huggingface/notebooks/blob/main/sagemaker/11_deploy_model_from_hf_hub/deploy_transformer_model_from_hf_hub.ipynb).
## O que você deseja fazer?
Os cadernos a seguir no repositório de cadernos Hugging Face mostram como usar os Hugging Face Deep Learning Containers com IA em vários casos de uso. SageMaker
Quero treinar e implantar um modelo de classificação de texto usando Hugging Face em IA com. SageMaker PyTorch
Para ver uma amostra do Jupyter Notebook, consulte a demonstração de [PyTorch introdução](https://github.com/huggingface/notebooks/blob/main/sagemaker/01_getting_started_pytorch/sagemaker-notebook.ipynb).
Quero treinar e implantar um modelo de classificação de texto usando Hugging Face em IA com. SageMaker TensorFlow
Para ver uma amostra do Jupyter Notebook, consulte o exemplo de [TensorFlow introdução](https://github.com/huggingface/notebooks/blob/main/sagemaker/02_getting_started_tensorflow/sagemaker-notebook.ipynb).
Quero realizar um treinamento distribuído com paralelismo de dados usando Hugging Face e AI Distributed. SageMaker
Para obter uma amostra do Caderno Jupyter, consulte o [exemplo de treinamento distribuído](https://github.com/huggingface/notebooks/blob/main/sagemaker/03_distributed_training_data_parallelism/sagemaker-notebook.ipynb).
Quero realizar um treinamento distribuído com paralelismo de modelos usando Hugging Face e AI Distributed. SageMaker
Para obter uma amostra do Caderno Jupyter, consulte o [exemplo de paralelismo de modelos](https://github.com/huggingface/notebooks/blob/main/sagemaker/04_distributed_training_model_parallelism/sagemaker-notebook.ipynb).
Quero usar uma instância spot para treinar e implantar um modelo usando Hugging Face na IA. SageMaker
Para obter uma amostra do Caderno Jupyter, consulte o [exemplo de instâncias spot](https://github.com/huggingface/notebooks/blob/main/sagemaker/05_spot_instances/sagemaker-notebook.ipynb).
Quero capturar métricas personalizadas e usar o SageMaker AI Checkpointing ao treinar um modelo de classificação de texto usando Hugging Face na IA. SageMaker
Para obter uma amostra do Caderno Jupyter, consulte o [exemplo de treinamento com métricas personalizadas](https://github.com/huggingface/notebooks/blob/main/sagemaker/06_sagemaker_metrics/sagemaker-notebook.ipynb).
Quero treinar um TensorFlow modelo distribuído de respostas a perguntas usando Hugging Face na IA. SageMaker
Para obter uma amostra do Jupyter Notebook, consulte o exemplo de [ TensorFlow treinamento distribuído](https://github.com/huggingface/notebooks/blob/main/sagemaker/07_tensorflow_distributed_training_data_parallelism/sagemaker-notebook.ipynb).
Quero treinar um modelo de resumo distribuído usando Hugging Face na IA. SageMaker
Para obter uma amostra do Caderno Jupyter, consulte o [exemplo distribuído de treinamento de sumarização](https://github.com/huggingface/notebooks/blob/main/sagemaker/08_distributed_summarization_bart_t5/sagemaker-notebook.ipynb).
Quero treinar um modelo de classificação de imagens usando Hugging Face em IA. SageMaker
Para obter uma amostra do Caderno Jupyter, consulte o [exemplo de treinamento do Transformador de visão](https://github.com/huggingface/notebooks/blob/main/sagemaker/09_image_classification_vision_transformer/sagemaker-notebook.ipynb).
Quero implantar meu modelo treinado de Hugging Face em IA. SageMaker
Para obter uma amostra do Caderno Jupyter, consulte o [exemplo de implantação dos seus Transformadores do Hugging Face para inferência](https://github.com/huggingface/notebooks/blob/main/sagemaker/10_deploy_model_from_s3/deploy_transformer_model_from_s3.ipynb).
Quero implantar um modelo pré-treinado de Hugging Face em IA. SageMaker
Para obter uma amostra do Caderno Jupyter, consulte o [exemplo de implantação dos seus Transformadores pré-treinados do Hugging Face para inferência](https://github.com/huggingface/notebooks/blob/main/sagemaker/11_deploy_model_from_hf_hub/deploy_transformer_model_from_hf_hub.ipynb).
# Recursos para usar PyTorch com a Amazon SageMaker AI
Você pode usar o Amazon SageMaker AI para treinar e implantar um modelo usando PyTorch código personalizado. Os PyTorch estimadores e modelos do SageMaker AI Python SDK e o PyTorch contêiner de código aberto de SageMaker IA facilitam a criação de um PyTorch script e sua execução na IA. SageMaker A seção a seguir fornece material de referência que você pode usar para aprender a usar PyTorch com a SageMaker IA.
## O que você deseja fazer?
Quero treinar um PyTorch modelo personalizado em SageMaker IA.
Para ver um exemplo de caderno Jupyter, consulte o [caderno de PyTorch exemplo](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/sagemaker-python-sdk/pytorch_mnist) no repositório Amazon SageMaker AI Examples GitHub.
Para obter a documentação, consulte [Treinar um modelo com PyTorch](https://sagemaker.readthedocs.io/en/stable/using_pytorch.html#train-a-model-with-pytorch).
Eu tenho um PyTorch modelo que treinei em SageMaker IA e quero implantá-lo em um endpoint hospedado.
Para obter mais informações, consulte [Implantar PyTorch modelos](https://sagemaker.readthedocs.io/en/stable/using_pytorch.html#deploy-pytorch-models).
Tenho um PyTorch modelo que treinei fora da SageMaker IA e quero implantá-lo em um endpoint de SageMaker IA
Para obter mais informações, consulte [Implantar seu próprio PyTorch modelo](https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/using_pytorch.html#bring-your-own-model).
Quero ver a documentação da API para as classes do [Amazon SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable) PyTorch.
Para obter mais informações, consulte [PyTorch Classes](https://sagemaker.readthedocs.io/en/stable/sagemaker.pytorch.html).
Quero encontrar o repositório de PyTorch contêineres de SageMaker IA.
Para obter mais informações, consulte [ GitHub Repositório SageMaker AI PyTorch Container](https://github.com/aws/deep-learning-containers/tree/master/pytorch).
Quero encontrar informações sobre as PyTorch versões suportadas pelo AWS Deep Learning Containers.
Para obter mais informações, consulte as [Imagens de contêiner de aprendizado profundo disponíveis](https://github.com/aws/deep-learning-containers/blob/master/available_images.md).
Para obter informações gerais sobre como escrever scripts de PyTorch treinamento e usar PyTorch estimadores e modelos com SageMaker IA, consulte [Usando PyTorch com o SDK do Python SageMaker ](https://sagemaker.readthedocs.io/en/stable/using_pytorch.html).
# Recursos para usar R com Amazon SageMaker AI
Este documento lista recursos que podem ajudar você a aprender como usar os recursos de SageMaker IA da Amazon com o ambiente de software R. As seções a seguir apresentam o kernel R integrado da SageMaker IA, explicam como começar a usar o R na SageMaker IA e fornecem vários exemplos de notebooks.
Os exemplos estão organizados em três níveis: iniciante, intermediário e avançado. Eles começam com [Getting Started with R on SageMaker AI](https://sagemaker-examples.readthedocs.io/en/latest/r_examples/r_sagemaker_hello_world/r_sagemaker_hello_world.html), continuam com o aprendizado de end-to-end máquina com R on SageMaker AI e terminam com tópicos mais avançados, como SageMaker Processamento com script R e algoritmo bring-your-own R para SageMaker IA.
Para obter informações sobre como trazer sua própria imagem R personalizada para o Studio, consulte [Imagens personalizadas no Amazon SageMaker Studio Classic](studio-byoi.md). Para um artigo de blog semelhante, consulte [Trazendo seu próprio ambiente de R para o Amazon SageMaker Studio](https://aws.amazon.com/blogs/machine-learning/bringing-your-own-r-environment-to-amazon-sagemaker-studio/).
**Topics**
+ [
## RStudio suporte em SageMaker IA
](#rstudio-for-r)
+ [
## Kernel R em IA SageMaker
](#r-sagemaker-kernel-ni)
+ [
## Cadernos de exemplo
](#r-sagemaker-example-notebooks)
+ [
# Comece a usar R na SageMaker IA
](r-sagemaker-get-started.md)
## RStudio suporte em SageMaker IA
O Amazon SageMaker AI oferece suporte RStudio como um ambiente de desenvolvimento integrado (IDE) totalmente gerenciado e integrado ao domínio do Amazon SageMaker AI. Com a RStudio integração, você pode iniciar um RStudio ambiente no domínio para executar seus RStudio fluxos de trabalho em recursos de SageMaker IA. Para obter mais informações, consulte [RStudio na Amazon SageMaker AI](rstudio.md).
## Kernel R em IA SageMaker
SageMaker instâncias de notebook suportam R usando um kernel R pré-instalado. Além disso, o kernel R tem a biblioteca reticulada, uma interface de R para Python, para que você possa usar os recursos do AI SageMaker Python SDK de dentro de um script R.
+ [reticulatelibrary:](https://rstudio.github.io/reticulate/) [fornece uma interface R para o SDK do Amazon Python. SageMaker ](https://sagemaker.readthedocs.io/en/stable) O pacote reticulado é convertido entre objetos de R e de Python.
## Cadernos de exemplo
**Pré-requisitos**
+ [Introdução ao R na SageMaker IA](https://sagemaker-examples.readthedocs.io/en/latest/r_examples/r_sagemaker_hello_world/r_sagemaker_hello_world.html) — Este exemplo de caderno descreve como você pode desenvolver scripts R usando o kernel R da Amazon SageMaker AI. Neste caderno, você configura seu ambiente e permissões de SageMaker IA, baixa o [conjunto de dados abalone](https://archive.ics.uci.edu/ml/datasets/abalone) do [UCI Machine Learning Repository](https://archive.ics.uci.edu/datasets), faz alguns processamentos e visualizações básicos dos dados e salva os dados no formato.csv no S3.
**Nível Iniciante**
+ [SageMaker AI Batch Transform usando R Kernel](https://sagemaker-examples.readthedocs.io/en/latest/r_examples/r_batch_transform/r_xgboost_batch_transform.html) [— Este exemplo de notebook descreve como realizar um trabalho de transformação em lote usando a API Transformer da SageMaker AI e o XGBoost algoritmo.](https://docs.aws.amazon.com/sagemaker/latest/dg/xgboost.html) O notebook também usa o conjunto de dados Abalone.
**Nível Intermediário**
+ [Otimização de hiperparâmetros para XGBoost em R](https://sagemaker-examples.readthedocs.io/en/latest/r_examples/r_xgboost_hpo_batch_transform/r_xgboost_hpo_batch_transform.html) — Este exemplo de caderno estende os cadernos anteriores para iniciantes que usam o conjunto de dados abalone e. XGBoost Ele descreve como ajustar o modelo com a [otimização de hiperparâmetros](https://sagemaker.readthedocs.io/en/stable/tuner.html). Você também aprenderá como usar a transformação em lote para predições em lote, além de como criar um endpoint de modelo para fazer predições em tempo real.
+ [Amazon SageMaker Processing with R](https://sagemaker-examples.readthedocs.io/en/latest/r_examples/r_in_sagemaker_processing/r_in_sagemaker_processing.html) — [SageMaker Processing](https://aws.amazon.com/blogs/aws/amazon-sagemaker-processing-fully-managed-data-processing-and-model-evaluation/) permite pré-processar, pós-processar e executar cargas de trabalho de avaliação de modelos. Esse exemplo mostra como criar um script R para orquestrar um trabalho do Processing.
**Nível avançado**
+ [Treine e implante seu próprio algoritmo R em SageMaker IA](https://sagemaker-examples.readthedocs.io/en/latest/r_examples/r_byo_r_algo_hpo/tune_r_bring_your_own.html) — Você já tem um algoritmo R e quer trazê-lo para a SageMaker IA para ajustá-lo, treiná-lo ou implantá-lo? Este exemplo mostra como personalizar contêineres de SageMaker IA com pacotes R personalizados, até o uso de um endpoint hospedado para inferência em seu modelo de origem R.
# Comece a usar R na SageMaker IA
Este tópico explica como começar a usar o ambiente de software R na SageMaker IA. Para obter mais informações sobre como usar R com SageMaker IA, consulte[Recursos para usar R com Amazon SageMaker AI](r-guide.md).
**Para começar a usar o R no console de SageMaker IA**
1. [Crie uma instância de caderno](https://docs.aws.amazon.com/sagemaker/latest/dg/howitworks-create-ws.html) usando o tipo de instância t2.medium e o tamanho de armazenamento padrão. É possível escolher uma instância mais rápida e mais armazenamento, se planejar continuar usando a instância para exemplos mais avançados, ou você pode criar uma instância maior posteriormente.
1. Aguarde até que o status do caderno mostre **Em serviço** e clique em **Abrir o Jupyter**.
![\[Localização do InServicestatus e do link Open Jupyter no console.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/An-R-User-Guide-to-SageMaker/An-R-User-Guide-to-SageMaker-1.png)
1. Crie um caderno com o kernel do R pela lista de ambientes disponíveis.
![\[Localização do kernel R na lista de ambientes disponíveis.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/An-R-User-Guide-to-SageMaker/An-R-User-Guide-to-SageMaker-2.png)
1. Quando o novo caderno for criado, você deverá ver um logotipo do R no canto superior direito do ambiente do caderno, além de R como o kernel abaixo desse logotipo. Isso indica que a SageMaker IA lançou com sucesso o kernel R para este notebook.
![\[Localização do logotipo R e do kernel R do ambiente do caderno.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/An-R-User-Guide-to-SageMaker/An-R-User-Guide-to-SageMaker-3.png)
Se preferir, quando estiver em um caderno Jupyter, você pode usar o menu **Kernel** e selecionar **R** na no submenu **Alterar kernel**.
![\[Localização de onde alterar o kernel do seu caderno para R.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/An-R-User-Guide-to-SageMaker/An-R-User-Guide-to-SageMaker-4.png)
# Recursos para usar o Scikit-learn com a Amazon AI SageMaker
Você pode usar o Amazon SageMaker AI para treinar e implantar um modelo usando o código personalizado do Scikit-learn. Os estimadores e modelos Scikit-learn do SageMaker AI Python SDK e os contêineres Scikit-learn de código aberto de SageMaker IA facilitam a criação de um script Scikit-learn e sua execução na IA. SageMaker A seção a seguir fornece material de referência que você pode usar para aprender a usar o Scikit-learn com IA. SageMaker
**Requisitos**
O Scikit-learn 1.4 tem as seguintes dependências.
| Dependência | Versão mínima |
| --- | --- |
| Python | 3.10 |
| NumPy | 2.1.0 |
| SciPy | 1.15.3 |
| joblib | 1.5.2 |
| threadpoolctl | 3.6.0 |
O contêiner SageMaker AI Scikit-learn é compatível com as seguintes versões do Scikit-learn.
| Versão compatível do Scikit-learn | Versão mínima do Python |
| --- | --- |
| 1.4-2 | 3.10 |
| 1.2-1 | 3.8 |
| 1.0-1 | 3.7 |
| 0.23-1 | 3.6 |
| 0.20.0 | 2.7 ou 3.4 |
[Para obter informações gerais sobre como escrever scripts de treinamento do Scikit-learn e usar estimadores e modelos do Scikit-learn com IA SageMaker , consulte Usando o Scikit-learn com o SDK do Python. SageMaker ](https://sagemaker.readthedocs.io/en/stable/using_sklearn.html)
## O que você deseja fazer?
**nota**
O Matplotlib v2.2.3 ou mais recente é necessário para executar os notebooks de exemplo AI Scikit-learn. SageMaker
Quero usar o Scikit-learn para processamento de dados, engenharia de recursos ou avaliação de modelos em IA. SageMaker
Para obter um exemplo de caderno Jupyter, consulte [https://github.com/awslabs/amazon-sagemaker-examples/tree/master/sagemaker\$1processing/scikit](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/sagemaker_processing/scikit_learn_data_processing_and_model_evaluation)\$1learn\$1data\$1processing\$1and\$1model\$1evaluation.
Para uma postagem no blog sobre treinamento e implantação de um modelo Scikit-Learn, consulte [Amazon SageMaker AI](https://aws.amazon.com/blogs/machine-learning/amazon-sagemaker-adds-scikit-learn-support/) adiciona suporte ao Scikit-Learn.
Para obter a documentação, consulte [ReadTheDocs](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_processing.html#data-pre-processing-and-model-evaluation-with-scikit-learn).
Quero treinar um modelo personalizado do Scikit-learn em IA. SageMaker
Para um exemplo de caderno Jupyter, consulte [https://github.com/awslabs/amazon-sagemaker-examples/tree/master/sagemaker-python-sdk/scikit](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/sagemaker-python-sdk/scikit_learn_iris)\$1learn\$1iris.
Para obter a documentação, consulte [Treinar um modelo com o Scikit-learn](https://sagemaker.readthedocs.io/en/stable/using_sklearn.html#train-a-model-with-sklearn).
Tenho um modelo Scikit-learn que treinei em SageMaker IA e quero implantá-lo em um endpoint hospedado.
Para obter mais informações, consulte [Implantar modelos do Scikit-learn](https://sagemaker.readthedocs.io/en/stable/using_sklearn.html#deploy-sklearn-models).
Tenho um modelo Scikit-learn que treinei fora da SageMaker IA e quero implantá-lo em um endpoint de IA SageMaker
Para mais informações, consulte [Implantar Endpoints de dados do modelo](https://sagemaker.readthedocs.io/en/stable/using_sklearn.html#deploy-endpoints-from-model-data).
Quero ver a documentação da API para as aulas Scikit-learn do [SDK do Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable).
Para obter mais informações, consulte [Classes do Scikit-learn](https://sagemaker.readthedocs.io/en/stable/sagemaker.sklearn.html).
Quero ver informações sobre os contêineres SageMaker AI Scikit-learn.
Para obter mais informações, consulte o repositório [SageMaker Scikit-learn Container](https://github.com/aws/sagemaker-scikit-learn-container). GitHub
# Recursos para usar o SparkML Serving com a Amazon AI SageMaker
O modelo e preditor do [Amazon SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable) SparkML Serving e o contêiner SparkML Serving de código aberto Amazon SageMaker AI oferecem suporte à implantação de pipelines de ML do Apache Spark serializados com IA para obter inferências. MLeap SageMaker Use os recursos a seguir para aprender a usar o SparkML Serving com IA. SageMaker
Para obter informações sobre como usar o contêiner SparkML Serving para implantar modelos SageMaker na IA, [SageMaker consulte o repositório de contêineres do Spark](https://github.com/aws/sagemaker-sparkml-serving-container) ML. GitHub [Para obter informações sobre o modelo e os preditores do [Amazon SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable) SparkML Serving, consulte a documentação do SparkML Serving Model and Predictor API.](https://sagemaker.readthedocs.io/en/stable/sagemaker.sparkml.html)
# Recursos para usar TensorFlow com a Amazon SageMaker AI
Você pode usar o Amazon SageMaker AI para treinar e implantar um modelo usando TensorFlow código personalizado. Os TensorFlow estimadores e modelos do SageMaker AI Python SDK e os contêineres de código aberto de SageMaker IA podem ajudar. TensorFlow Use a lista de recursos a seguir para encontrar mais informações, com base na versão que TensorFlow você está usando e no que deseja fazer.
## TensorFlow Versão 1.11 e posterior
Para TensorFlow as versões 1.11 e posteriores, o [Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable) SDK oferece suporte a scripts de treinamento no modo script.
### O que você deseja fazer?
Quero treinar um TensorFlow modelo personalizado em SageMaker IA.
Para ver um exemplo de caderno Jupyter, consulte [Treinamento e exibição do modo TensorFlow script](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-python-sdk/tensorflow_script_mode_training_and_serving/tensorflow_script_mode_training_and_serving.html).
Para obter a documentação, consulte [Treinar um modelo com TensorFlow](https://sagemaker.readthedocs.io/en/stable/using_tf.html#train-a-model-with-tensorflow).
Eu tenho um TensorFlow modelo que treinei em SageMaker IA e quero implantá-lo em um endpoint hospedado.
Para obter mais informações, consulte [Implantar modelos de TensorFlow serviço](https://sagemaker.readthedocs.io/en/stable/using_tf.html#deploy-tensorflow-serving-models).
Tenho um TensorFlow modelo que treinei fora da SageMaker IA e quero implantá-lo em um endpoint de SageMaker IA.
Para obter mais informações, consulte [Implantação diretamente dos artefatos do modelo](https://sagemaker.readthedocs.io/en/stable/using_tf.html#deploying-directly-from-model-artifacts).
Quero ver a documentação da API para as classes do [Amazon SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable) TensorFlow.
Para obter mais informações, consulte [TensorFlow Estimador](https://sagemaker.readthedocs.io/en/stable/sagemaker.tensorflow.html).
Quero encontrar o repositório de TensorFlow contêineres de SageMaker IA.
Para obter mais informações, consulte [ GitHub Repositório de SageMaker TensorFlow contêineres](https://github.com/aws/sagemaker-tensorflow-container).
Quero encontrar informações sobre as TensorFlow versões suportadas pelo AWS Deep Learning Containers.
Para obter mais informações, consulte as [Imagens de contêiner de aprendizado profundo disponíveis](https://github.com/aws/deep-learning-containers/blob/master/available_images.md).
Para obter informações gerais sobre como escrever scripts de treinamento no modo TensorFlow TensorFlow script e usar estimadores e modelos do modo script com SageMaker IA, consulte [Usando TensorFlow com o SDK do Python SageMaker ](https://sagemaker.readthedocs.io/en/stable/using_tf.html).
## TensorFlow Modo legado para versões 1.11 e anteriores
O [Amazon SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable) fornece um modo legado compatível com TensorFlow as versões 1.11 e anteriores. Use scripts de TensorFlow treinamento do modo legado para executar TensorFlow trabalhos em SageMaker IA se:
+ Você tiver scripts no modo legado que não deseja converter em modo script.
+ Você deseja usar uma TensorFlow versão anterior à 1.11.
Para obter informações sobre como escrever TensorFlow scripts de modo legado para usar com o SDK do SageMaker AI Python, consulte [TensorFlow SageMaker Estimators](https://github.com/aws/sagemaker-python-sdk/tree/v1.12.0/src/sagemaker/tensorflow#tensorflow-sagemaker-estimators-and-models) and Models.
# Recursos para usar o Triton Inference Server com a Amazon AI SageMaker
SageMaker A IA permite que os clientes implantem um modelo usando código personalizado com o NVIDIA Triton Inference Server. Use os recursos a seguir para aprender a usar o Triton Inference Server com SageMaker IA.
Essa funcionalidade está disponível por meio do desenvolvimento dos [Contêineres do Triton Inference Server](https://docs.aws.amazon.com/deep-learning-containers/latest/devguide/what-is-dlc.html). Esses contêineres incluem o NVIDIA Triton Inference Server, suporte para estruturas comuns de ML e variáveis de ambiente úteis que permitem otimizar o desempenho na IA. SageMaker Para obter uma lista completa de todas as imagens dos Contêiner de Aprendizado Profundo disponíveis, consulte [Imagens dos Contêiner de Aprendizado Profundo disponíveis](https://github.com/aws/deep-learning-containers/blob/master/available_images.md). As imagens dos Contêiner de Aprendizado Profundo são mantidas e atualizadas regularmente com patches de segurança.
Você pode usar o Triton Inference Server Container com SageMaker Python SDK como faria com qualquer outro contêiner em seus modelos de IA. SageMaker No entanto, usar o SDK do SageMaker Python é opcional. Você pode usar os contêineres do Triton Inference Server com e. AWS CLI AWS SDK para Python (Boto3)
Para obter mais informações sobre o NVIDIA Triton Inference Server, consulte a [documentação do Triton](https://docs.nvidia.com/deeplearning/triton-inference-server/#).
## Inferência
**nota**
O back-end Triton Python usa memória compartilhada (SHMEM) para conectar seu código ao Triton. SageMaker O AI Inference fornece até metade da memória da instância como SHMEM para que você possa usar uma instância com mais memória para um tamanho maior de SHMEM.
Para inferência, você pode usar seus modelos de ML treinados com o Triton Inference Server para implantar um trabalho de inferência com IA. SageMaker
Alguns dos principais atributos do contêiner do Triton Inference Server são:
+ **Compatível com vários frameworks**: o Triton pode ser usado para implantar modelos de todos os principais frameworks de ML. O Triton suporta TensorFlow GraphDef e SavedModel, ONX, PyTorch TorchScript TensorRT e formatos de modelo Python/C\$1\$1 personalizados.
+ **Pipelines de modelos**: o conjunto de modelos Triton representa um pipeline de um modelo com lógica de pre/post processamento e a conexão de tensores de entrada e saída entre eles. Uma única solicitação de inferência para um conjunto aciona a execução de todo o pipeline.
+ **Execução simultânea do modelo**: várias instâncias do mesmo modelo podem ser executadas simultaneamente na mesma GPU ou em várias. GPUs
+ **Lotes dinâmicos**: para modelos que compatíveis com os lotes, o Triton tem vários algoritmos integrados de agendamento e agrupamento em lotes que combinam solicitações de inferência individuais para melhorar a throughput da inferência. Essas decisões de agendamento e agrupamento em lotes são transparentes para o cliente que solicita a inferência.
+ **Suporte diversificado para CPU e GPU**: os modelos podem ser executados com CPUs ou GPUs para máxima flexibilidade e para suportar requisitos de computação heterogêneos.
## O que você deseja fazer?
Quero implantar meu PyTorch modelo treinado em SageMaker IA.
Para ver uma amostra do Jupyter Notebook, consulte o exemplo [Implante seu modelo PyTorch Resnet50 com o Triton](https://github.com/aws/amazon-sagemaker-examples/blob/master/sagemaker-triton/resnet50/triton_resnet50.ipynb) Inference Server.
Quero implantar meu modelo treinado de Hugging Face em IA. SageMaker
Para ver uma amostra do Jupyter Notebook, consulte o exemplo [Implante seu modelo PyTorch BERT com o Triton Inference Server](https://github.com/aws/amazon-sagemaker-examples/blob/master/sagemaker-triton/nlp_bert/triton_nlp_bert.ipynb).