Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
# Marcos y lenguajes de machine learning
Amazon SageMaker AI proporciona soporte nativo para lenguajes de programación y marcos de aprendizaje automático populares, lo que permite a los desarrolladores y científicos de datos aprovechar sus herramientas y tecnologías preferidas. Esta sección ofrece referencias para trabajar con Python y R, así como sus respectivos kits de desarrollo de software (SDKs) dentro de la SageMaker IA. Además, cubre una amplia gama de marcos de aprendizaje automático y aprendizaje profundo, incluidos Apache MXNet, PyTorch, TensorFlow.
Puedes usar Python y R de forma nativa en los núcleos de Amazon SageMaker Notebook. También hay kernels que admiten marcos específicos. Una forma muy popular de empezar con la SageMaker IA es utilizar el [SDK de Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable). Proporciona Python de código abierto APIs y contenedores que facilitan el entrenamiento y la implementación de modelos en SageMaker IA, así como ejemplos para su uso con varios marcos diferentes de aprendizaje automático y aprendizaje profundo.
Para obtener información sobre el uso de marcos específicos o cómo usar R en la SageMaker IA, consulte los siguientes temas.
Idiomas SDKs y guías de usuario:
+ [SDK de Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable)
+ [R](r-guide.md)
+ [referencia de la API](api-and-sdk-reference.md)
Guías de marcos de aprendizaje profundo y machine learning:
+ [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)
+ [Servidor de inferencia Triton](triton.md)
# Recursos para usar Apache MXNet con Amazon SageMaker AI
Los MXNet estimadores y modelos [del SDK de Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable) y el MXNet contenedor de código abierto de SageMaker IA facilitan la escritura de un MXNet script y su ejecución en SageMaker IA. En la siguiente sección, se proporciona material de referencia que puede utilizar para aprender a utilizar la SageMaker IA para entrenar e implementar un modelo mediante código personalizado. MXNet
## ¿Qué quiere hacer?
Quiero entrenar un MXNet modelo personalizado en SageMaker IA.
Para obtener documentación, consulte [Entrenar un modelo con MXNet](https://sagemaker.readthedocs.io/en/stable/using_mxnet.html#train-a-model-with-mxnet).
Tengo un MXNet modelo que he formado en SageMaker IA y quiero implementarlo en un punto final alojado.
Para obtener más información, consulte [Implementar MXNet modelos](https://sagemaker.readthedocs.io/en/stable/using_mxnet.html#deploy-mxnet-models).
Tengo un MXNet modelo que he entrenado fuera de la SageMaker IA y quiero implementarlo en un punto final de SageMaker IA
Para obtener más información, consulte [Deploy Endpoints from Model Data](https://sagemaker.readthedocs.io/en/stable/using_mxnet.html#deploy-endpoints-from-model-data).
Quiero ver la documentación de la API para las MXNet clases [del SDK de Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable).
Para obtener más información, consulte [MXNet Clases](https://sagemaker.readthedocs.io/en/stable/frameworks/mxnet/sagemaker.mxnet.html).
Quiero encontrar el repositorio de MXNet contenedores de SageMaker IA.
Para obtener más información, consulta el [ GitHub repositorio de SageMaker AI MXNet Container](https://github.com/aws/sagemaker-mxnet-container).
Deseo obtener información sobre MXNet las versiones compatibles con AWS Deep Learning Containers.
Para obtener más información, consulte [Available Deep Learning Container Images](https://github.com/aws/deep-learning-containers/blob/master/available_images.md).
Para obtener información general sobre cómo escribir guiones de entrenamiento en modo MXNet MXNet script y usar estimadores y modelos en modo script con SageMaker IA, consulte [Uso MXNet con el SDK de SageMaker Python](https://sagemaker.readthedocs.io/en/stable/using_mxnet.html).
# Apache Spark con Amazon SageMaker AI
Amazon SageMaker AI Spark es una biblioteca de Spark de código abierto que te ayuda a crear canalizaciones de aprendizaje automático (ML) de Spark con SageMaker IA. Esto simplifica la integración de las etapas de ML de Spark con las etapas de SageMaker IA, como la formación de modelos y el alojamiento. Para obtener información sobre SageMaker AI Spark, consulta el GitHub repositorio de [SageMaker AI Spark](https://github.com/aws/sagemaker-spark). En los siguientes temas se proporciona información para aprender a usar Apache Spark con SageMaker IA.
La biblioteca SageMaker AI Spark está disponible en Python y Scala. Puedes usar SageMaker AI Spark para entrenar modelos en SageMaker IA utilizando marcos de `org.apache.spark.sql.DataFrame` datos en tus clústeres de Spark. Tras el entrenamiento del modelo, también puedes alojar el modelo mediante los servicios de alojamiento de SageMaker IA.
La biblioteca SageMaker AI Spark proporciona`com.amazonaws.services.sagemaker.sparksdk`, entre otras, las siguientes clases:
+ `SageMakerEstimator`: amplía la interfaz `org.apache.spark.ml.Estimator`. Puedes usar este estimador para el entrenamiento de modelos en SageMaker IA.
+ `KMeansSageMakerEstimator`, `PCASageMakerEstimator` y `XGBoostSageMakerEstimator`: amplía la clase `SageMakerEstimator`.
+ `SageMakerModel`: amplía la clase `org.apache.spark.ml.Model`. Puedes usarlo `SageMakerModel` para alojar modelos y obtener inferencias en IA. SageMaker
Puedes descargar el código fuente de las bibliotecas Python Spark (PySpark) y Scala desde el GitHub repositorio de [SageMaker AI Spark](https://github.com/aws/sagemaker-spark).
Para ver la instalación y ver ejemplos de la biblioteca SageMaker AI Spark, consulta [SageMaker Ejemplos de AI Spark para Scala](apache-spark-example1.md) o[Ejemplos de recursos para usar SageMaker AI Spark para Python (PySpark)](apache-spark-additional-examples.md).
Si usa Amazon EMR AWS para administrar los clústeres de Spark, consulte [Apache](https://aws.amazon.com/emr/features/spark/) Spark. Para obtener más información sobre el uso de Amazon EMR en la SageMaker IA, consulte. [Preparación de datos con Amazon EMR](studio-notebooks-emr-cluster.md)
**Topics**
+ [
## Integre su aplicación Apache Spark con la IA SageMaker
](#spark-sdk-common-process)
+ [
# SageMaker Ejemplos de AI Spark para Scala
](apache-spark-example1.md)
+ [
# Ejemplos de recursos para usar SageMaker AI Spark para Python (PySpark)
](apache-spark-additional-examples.md)
## Integre su aplicación Apache Spark con la IA SageMaker
El siguiente es un resumen de alto nivel de los pasos para integrar su aplicación Apache Spark con la SageMaker IA.
1. Siga con el preprocesamiento de datos mediante la biblioteca de Apache Spark con la que está familiarizado. Su conjunto de datos sigue siendo un `DataFrame` en el clúster de Spark. Cargue sus datos en un `DataFrame`. Preprocéselos de manera que disponga de una columna `features` con `org.apache.spark.ml.linalg.Vector` de `Doubles` y una columna `label` opcional con valores de tipo `Double`.
1. Usa el estimador de la biblioteca SageMaker AI Spark para entrenar tu modelo. Por ejemplo, si eliges el algoritmo k-means que proporciona la SageMaker IA para el entrenamiento de modelos, llama al método. `KMeansSageMakerEstimator.fit`
Proporcione `DataFrame` como entrada. El estimador devuelve un objeto `SageMakerModel`.
**nota**
`SageMakerModel` amplía `org.apache.spark.ml.Model`.
El método `fit` realiza lo siguiente:
1. Convierte la entrada `DataFrame` al formato protobuf. Para ello, se seleccionan las columnas `features` y `label` de la entrada `DataFrame`. A continuación, se cargan los datos del protobuf en un bucket de Amazon S3. El formato protobuf es eficaz para el entrenamiento de modelos en IA. SageMaker
1. Inicia el entrenamiento de modelos en SageMaker IA enviando una solicitud de SageMaker IA [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html). Una vez finalizado el entrenamiento del modelo, la SageMaker IA guarda los artefactos del modelo en un depósito de S3.
SageMaker La IA asume la función de IAM que especificó para el entrenamiento de modelos para realizar tareas en su nombre. Por ejemplo, usa el rol para leer los datos de capacitación desde un bucket de S3 y escribir artefactos de modelos en un bucket.
1. Crea y devuelve un objeto `SageMakerModel`. El constructor realiza las siguientes tareas, relacionadas con la implementación del modelo en la SageMaker IA.
1. Envía una [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html)solicitud a SageMaker AI.
1. Envía una [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpointConfig.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpointConfig.html)solicitud a SageMaker AI.
1. Envía una [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpoint.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpoint.html)solicitud a la SageMaker IA, que, a continuación, lanza los recursos especificados y aloja el modelo en ellos.
1. Puede obtener inferencias de su modelo alojado en SageMaker IA con el`SageMakerModel.transform`.
Proporcione una entrada `DataFrame` con características como entrada. El método `transform` lo transforma en un `DataFrame` que contiene inferencias. Internamente, el `transform` método envía una solicitud a la [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 obtener inferencias. El método `transform` anexa las inferencias a la entrada `DataFrame`.
# SageMaker Ejemplos de AI Spark para Scala
Amazon SageMaker AI proporciona una biblioteca de Apache Spark ([SageMaker AI Spark](https://github.com/aws/sagemaker-spark/tree/master/sagemaker-spark-sdk)) que puede utilizar para integrar sus aplicaciones de Apache Spark con SageMaker IA. Este tema contiene ejemplos que le ayudarán a empezar a utilizar SageMaker AI Spark con Scala. Para obtener información sobre la biblioteca SageMaker AI Apache Spark, consulte[Apache Spark con Amazon SageMaker AI](apache-spark.md).
**Descargar Spark para Scala**
Puedes descargar el código fuente y los ejemplos de las bibliotecas Python Spark (PySpark) y Scala desde el GitHub repositorio de [SageMaker AI Spark](https://github.com/aws/sagemaker-spark).
Para obtener instrucciones detalladas sobre cómo instalar la biblioteca SageMaker AI Spark, consulta [SageMaker AI Spark](https://github.com/aws/sagemaker-spark/tree/master/sagemaker-spark-sdk).
SageMaker El SDK de AI Spark para Scala está disponible en el repositorio central de Maven. Añada la biblioteca de Spark a su proyecto añadiendo la siguiente dependencia a su archivo `pom.xml`:
+ Si el proyecto se ha creado con Maven, añada lo siguiente al archivo pom.xml:
```
com.amazonaws
sagemaker-spark_2.11
spark_2.2.0-1.0
```
+ Si su proyecto depende de Spark 2.1, añada lo siguiente a su archivo pom.xml:
```
com.amazonaws
sagemaker-spark_2.11
spark_2.1.1-1.0
```
**Ejemplo de Spark para Scala**
En esta sección, se proporciona un ejemplo de código que utiliza la biblioteca Apache Spark Scala proporcionada por SageMaker AI para entrenar un modelo de SageMaker IA con `DataFrame` s en tu clúster de Spark. A esto le siguen ejemplos sobre [Utilice algoritmos personalizados para el entrenamiento y el alojamiento de modelos en Amazon SageMaker AI con Apache Spark](apache-spark-example1-cust-algo.md) y [Utilízalo SageMakerEstimator en un Spark Pipeline](apache-spark-example1-extend-pipeline.md).
El siguiente ejemplo aloja los artefactos del modelo resultantes mediante servicios de alojamiento de SageMaker IA. Para obtener más información sobre este ejemplo, consulta [Cómo empezar: agrupamiento de K-Means en SageMaker IA con el SDK de SageMaker AI Spark](https://github.com/aws/sagemaker-spark?tab=readme-ov-file#getting-started-k-means-clustering-on-sagemaker-with-sagemaker-spark-sdk). En concreto, este ejemplo hace lo siguiente:
+ Utiliza `KMeansSageMakerEstimator` para adaptar un modelo en datos o realizar una capacitación.
Como en el ejemplo se utiliza el algoritmo k-means proporcionado por la SageMaker IA para entrenar un modelo, se utiliza el. `KMeansSageMakerEstimator` Puede realizar una capacitación del modelo mediante imágenes de números de un solo dígito escritas a mano (desde el conjunto de datos MNIST). Proporcione las imágenes como una entrada `DataFrame`. Para su comodidad, la SageMaker IA proporciona este conjunto de datos en un bucket de Amazon S3.
Como respuesta, el estimador devuelve un objeto `SageMakerModel`.
+ Obtiene las inferencias mediante el `SageMakerModel` de capacitación.
Para obtener inferencias a partir de un modelo alojado en SageMaker IA, se llama al `SageMakerModel.transform` método. Pase un `DataFrame` como entrada. El método transforma la entrada `DataFrame` en otro `DataFrame` que contiene inferencias obtenidas a partir del modelo.
Para una imagen de entrada determinada de un número de un solo dígito escrito a mano, la inferencia identifica un clúster al que pertenece la imagen. Para obtener más información, 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
```
Este ejemplo de código hace lo siguiente:
+ Carga el conjunto de datos MNIST de un depósito de S3 proporcionado por SageMaker AI (`awsai-sparksdk-dataset`) en un Spark `DataFrame` (`mnistTrainingDataFrame`):
```
// Get a Spark session.
val spark = SparkSession.builder.getOrCreate
// load mnist data as a dataframe from libsvm
val region = "us-east-1"
val trainingData = spark.read.format("libsvm")
.option("numFeatures", "784")
.load(s"s3://sagemaker-sample-data-$region/spark/mnist/train/")
val testData = spark.read.format("libsvm")
.option("numFeatures", "784")
.load(s"s3://sagemaker-sample-data-$region/spark/mnist/test/")
val roleArn = "arn:aws:iam::account-id:role/rolename"
trainingData.show()
```
El método `show` muestra las primeras 20 filas en el marco de datos:
```
+-----+--------------------+
|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
```
En cada fila:
+ La columna `label` identifica la etiqueta de la imagen. Por ejemplo, si la imagen del número escrito a mano es el dígito 5, el valor de etiqueta es 5.
+ La columna `features` almacena un vector (`org.apache.spark.ml.linalg.Vector`) de valores `Double`. Estas son las 784 características del número escrito a mano. (Los números escritos a manos son imágenes de 28 x 28 píxeles, que conforman las 784 características).
+ Crea un estimador de SageMaker IA () `KMeansSageMakerEstimator`
El `fit` método de este estimador utiliza el algoritmo k-means proporcionado por la SageMaker IA para entrenar los modelos mediante una entrada. `DataFrame` Como respuesta, devuelve un objeto `SageMakerModel` que puede utilizar para obtener inferencias.
**nota**
Esto `KMeansSageMakerEstimator` amplía la SageMaker IA`SageMakerEstimator`, lo que amplía el Apache Spark. `Estimator`
```
val estimator = new KMeansSageMakerEstimator(
sagemakerRole = IAMRole(roleArn),
trainingInstanceType = "ml.p2.xlarge",
trainingInstanceCount = 1,
endpointInstanceType = "ml.c4.xlarge",
endpointInitialInstanceCount = 1)
.setK(10).setFeatureDim(784)
```
Los parámetros del constructor proporcionan información que se utiliza para entrenar un modelo e implementarlo en la SageMaker IA:
+ `trainingInstanceType` y `trainingInstanceCount`: identifican el tipo y el número de instancias de computación de ML para usarlos en el entrenamiento del modelo.
+ `endpointInstanceType`—Identifica el tipo de instancia de procesamiento de aprendizaje automático que se utilizará al alojar el modelo en SageMaker AI. De forma predeterminada, se presupone una instancia de computación de machine learning.
+ `endpointInitialInstanceCount`—Identifica el número de instancias de procesamiento de aprendizaje automático que inicialmente respaldan el punto final que aloja el modelo en SageMaker AI.
+ `sagemakerRole`— SageMaker La IA asume esta función de IAM para realizar tareas en su nombre. Por ejemplo, para la capacitación de modelos, lee los datos a partir de S3 y escribe resultados de capacitación (artefactos de modelo) en S3.
**nota**
Este ejemplo crea implícitamente un cliente de SageMaker IA. Para crear este cliente, debe proporcionar sus credenciales. La API usa estas credenciales para autenticar las solicitudes a SageMaker la IA. Por ejemplo, utiliza las credenciales para autenticar las solicitudes de creación de un trabajo de formación y las llamadas a la API para implementar el modelo mediante servicios de alojamiento de SageMaker IA.
+ Una vez que creado el objeto `KMeansSageMakerEstimator`, establezca los siguientes parámetros, que se usan en la capacitación de modelos:
+ El número de clústeres que el algoritmo k-means debe crear durante la capacitación de modelos. Especifique 10 clústeres, uno para cada dígito, 0 a 9.
+ Identifica que cada imagen de entrada dispone de 784 características (cada número escrito a mano es una imagen de 28 x 28 píxeles, que conforma las 784 características).
+ Llama al método `fit` del estimador.
```
// train
val model = estimator.fit(trainingData)
```
Pase la entrada `DataFrame`como un parámetro. El modelo hace todo el trabajo de entrenarlo e implementarlo en la SageMaker IA. Para obtener más información, consulte, [Integre su aplicación Apache Spark con la IA SageMaker](apache-spark.md#spark-sdk-common-process). Como respuesta, obtienes un `SageMakerModel` objeto, que puedes usar para obtener inferencias a partir del modelo implementado en la SageMaker IA.
Proporcione solo la entrada `DataFrame`. No tiene que especificar la ruta de registro en el algoritmo k-means utilizado para la capacitación de modelos, ya que `KMeansSageMakerEstimator` la conoce.
+ Utiliza el `SageMakerModel.transform` método para obtener inferencias a partir del modelo implementado en SageMaker la IA.
El método `transform` realiza un `DataFrame` como entrada, lo transforma y devuelve otro `DataFrame` que contiene inferencias obtenidas a partir del modelo.
```
val transformedData = model.transform(testData)
transformedData.show
```
Para simplificar, utilizamos el mismo `DataFrame` como entrada para el método `transform` que utilizamos para la capacitación de modelos en este ejemplo. El método `transform` realiza lo siguiente:
+ Serializa la `features` columna de la entrada `DataFrame` a protobuf y la envía al punto final de la SageMaker IA para su inferencia.
+ Deserializa la respuesta protobuf en dos columnas adicionales (`distance_to_cluster` y `closest_cluster`) en el `DataFrame` transformado.
El método `show` obtiene inferencias en las primeras 20 filas de la 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|
+-----+--------------------+-------------------+---------------+
```
Puede interpretar los datos de la siguiente forma:
+ Un número escrito a mano con `label` 5 pertenece al clúster 4 (`closest_cluster`).
+ Un número escrito a mano con `label` 0 pertenece al clúster 5.
+ Un número escrito a mano con `label` 4 pertenece al clúster 9.
+ Un número escrito a mano con `label` 1 pertenece al clúster 6.
**Topics**
+ [
# Utilice algoritmos personalizados para el entrenamiento y el alojamiento de modelos en Amazon SageMaker AI con Apache Spark
](apache-spark-example1-cust-algo.md)
+ [
# Utilízalo SageMakerEstimator en un Spark Pipeline
](apache-spark-example1-extend-pipeline.md)
# Utilice algoritmos personalizados para el entrenamiento y el alojamiento de modelos en Amazon SageMaker AI con Apache Spark
En[SageMaker Ejemplos de AI Spark para Scala](apache-spark-example1.md), se utiliza `kMeansSageMakerEstimator` porque en el ejemplo se utiliza el algoritmo k-means proporcionado por Amazon SageMaker AI para el entrenamiento de modelos. Puede optar por usar su propio algoritmo personalizado para la capacitación de modelos en su lugar. Suponiendo que ya haya creado una imagen de Docker, puede crear su propio `SageMakerEstimator` y especificar la ruta de Amazon Elastic Container Registry para su imagen personalizada.
En el siguiente ejemplo se muestra cómo crear un nuevo `KMeansSageMakerEstimator` desde `SageMakerEstimator`. En el nuevo estimador, especifique de forma explícita la ruta de registro de Docker en las imágenes de código de inferencia y capacitación.
```
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")
```
En el código, los parámetros del constructor `SageMakerEstimator` incluyen:
+ `trainingImage`: identifica la ruta de registro de Docker en la imagen de entrenamiento que contiene el código personalizado.
+ `modelImage`: identifica la ruta de registro de Docker en la imagen que contiene el código de inferencia.
+ `requestRowSerializer`: implementa `com.amazonaws.services.sagemaker.sparksdk.transformation.RequestRowSerializer`.
Este parámetro serializa las filas de la entrada `DataFrame` para enviarlas al modelo alojado en SageMaker AI para su inferencia.
+ `responseRowDeserializer`: implementa
`com.amazonaws.services.sagemaker.sparksdk.transformation.ResponseRowDeserializer`.
Este parámetro deserializa las respuestas del modelo, alojadas en la SageMaker IA, para convertirlas en un. `DataFrame`
+ `trainingSparkDataFormat`: especifica el formato de datos que utiliza Spark cuando se cargan datos de entrenamiento desde `DataFrame` a S3. Por ejemplo, `"sagemaker"` para el formato protobuf, `"csv"` para valores separados por comas y `"libsvm"` para el formato LibSVM.
Puede implementar su propio `RequestRowSerializer` y `ResponseRowDeserializer` para serializar y deserializar filas desde un formato de datos que admite su código de inferencia, como .libsvm o .csv.
# Utilízalo SageMakerEstimator en un Spark Pipeline
Puede utilizar estimadores `org.apache.spark.ml.Estimator` y modelos `org.apache.spark.ml.Model` y estimadores `SageMakerEstimator` y modelos `SageMakerModel` en canalizaciones `org.apache.spark.ml.Pipeline`, como se muestra en el siguiente ejemplo:
```
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()
```
El parámetro `trainingSparkDataFormatOptions` configura Spark para serializar en protobuf la columna "projectedFeatures" para la capacitación de modelos. Además, Spark realiza la serialización en protobuf de la columna de "etiqueta" de forma predeterminada.
Puesto que queremos realizar inferencias mediante la columna "projectedFeatures", pasamos el nombre de columna en `ProtobufRequestRowSerializer`.
El siguiente ejemplo muestra un `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|
+-----+--------------------+--------------------+-------------------+---------------+
```
# Ejemplos de recursos para usar SageMaker AI Spark para Python (PySpark)
Amazon SageMaker AI proporciona una biblioteca Python ([SageMaker AI PySpark](https://github.com/aws/sagemaker-spark/tree/master/sagemaker-pyspark-sdk)) de Apache Spark que puede utilizar para integrar las aplicaciones de Apache Spark con la SageMaker IA. Este tema contiene ejemplos que le ayudarán a empezar PySpark. Para obtener información sobre la biblioteca SageMaker AI Apache Spark, consulte[Apache Spark con Amazon SageMaker AI](apache-spark.md).
**Download PySpark**
Puedes descargar el código fuente de las bibliotecas Python Spark (PySpark) y Scala desde el GitHub repositorio de [SageMaker AI Spark](https://github.com/aws/sagemaker-spark).
Para obtener instrucciones sobre cómo instalar la biblioteca SageMaker AI Spark, usa cualquiera de las siguientes opciones o visita [SageMaker AI PySpark](https://github.com/aws/sagemaker-spark/tree/master/sagemaker-pyspark-sdk).
+ Instalación con pip:
```
pip install sagemaker_pyspark
```
+ Instalación desde el origen:
```
git clone git@github.com:aws/sagemaker-spark.git
cd sagemaker-pyspark-sdk
python setup.py install
```
+ También puede crear un nuevo cuaderno en una instancia de cuaderno que utilice `Sparkmagic (PySpark)` o el kernel de `Sparkmagic (PySpark3)` y conectarse a un clúster remoto de Amazon EMR.
**nota**
El clúster de Amazon EMR debe configurarse con un rol de IAM que tenga asociada la política `AmazonSageMakerFullAccess`. Para obtener información sobre cómo configurar roles para un clúster de EMR, consulte [Configure IAM Roles for Amazon EMR Permissions to AWS Services](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-iam-roles.html) en la *Guía de administración de Amazon EMR*.
**PySpark ejemplos**
Para ver ejemplos sobre el uso de la SageMaker IA PySpark, consulte:
+ [Uso de Amazon SageMaker AI con Apache Spark](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-spark/index.html) en Read the Docs.
+ SageMaker GitHubRepositorio [AI Spark](https://github.com/aws/sagemaker-spark).
# Recursos para usar Chainer con Amazon AI SageMaker
Puede usar la SageMaker IA para entrenar e implementar un modelo mediante el código Chainer personalizado. Los estimadores y modelos Chainer del SDK de Python para SageMaker IA y el contenedor Chainer de código abierto de SageMaker IA facilitan la escritura de un script de Chainer y su ejecución en IA. SageMaker En la siguiente sección, se proporciona material de referencia que puede utilizar para aprender a utilizar Chainer con la IA. SageMaker
## ¿Qué quiere hacer?
Quiero entrenar un modelo de Chainer personalizado en SageMaker IA.
Para ver un ejemplo de cuaderno de Jupyter, consulta los [cuadernos de ejemplo de Chainer en el repositorio](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/sagemaker-python-sdk/mxnet_mnist) Amazon SageMaker AI Examples. GitHub
Para ver la documentación, consulte [Train a Model with Chainer](https://sagemaker.readthedocs.io/en/stable/using_chainer.html#train-a-model-with-chainer).
Tengo un modelo de Chainer que he formado en SageMaker IA y quiero implementarlo en un punto final alojado.
Para obtener más información, consulte [Deploy Chainer models](https://sagemaker.readthedocs.io/en/stable/using_chainer.html#deploy-chainer-models).
Tengo un modelo de Chainer que he entrenado fuera de la SageMaker IA y quiero implementarlo en un SageMaker punto final de IA
Para obtener más información, consulte [Deploy Endpoints from Model Data](https://sagemaker.readthedocs.io/en/stable/using_chainer.html#deploy-endpoints-from-model-data).
Quiero ver la documentación de la API para las clases de [Amazon SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable) Chainer.
Para obtener más información, consulte [Chainer Classes](https://sagemaker.readthedocs.io/en/stable/sagemaker.chainer.html).
Deseo obtener información sobre los contenedores de SageMaker AI Chainer.
Para obtener más información, consulta el repositorio de [SageMaker AI Chainer GitHub Container](https://github.com/aws/sagemaker-chainer-container).
Para obtener información sobre las versiones de Chainer compatibles y para obtener información general sobre la redacción de scripts de entrenamiento de Chainer y el uso de estimadores y modelos de Chainer con SageMaker IA, consulte Uso de [Chainer](https://sagemaker.readthedocs.io/en/stable/using_chainer.html) con el SDK de Python. SageMaker
# Recursos para usar Hugging Face con Amazon AI SageMaker
Amazon SageMaker AI permite a los clientes entrenar, ajustar y ejecutar inferencias mediante modelos Hugging Face para el procesamiento del lenguaje natural (NLP) en IA. SageMaker Puede usar Hugging Face tanto para el entrenamiento como para la inferencia. La siguiente sección proporciona información sobre los modelos de Hugging Face e incluye material de referencia que puede utilizar para aprender a utilizar Hugging SageMaker Face con IA.
Esta funcionalidad está disponible a través del desarrollo de [Contenedores de aprendizaje profundo de AWS](https://docs.aws.amazon.com/deep-learning-containers/latest/devguide/what-is-dlc.html) de Hugging Face. Estos contenedores incluyen Transformers, Tokenizers y la biblioteca Datasets de Hugging Face, que le permiten utilizar estos recursos para sus trabajos de entrenamiento e inferencia. Para ver una lista completa de las imágenes disponibles de contenedores de aprendizaje profundo, consulte [Available Deep Learning Containers Images](https://github.com/aws/deep-learning-containers/blob/master/available_images.md). Estas imágenes de contenedores de aprendizaje profundo se mantienen y actualizan periódicamente con parches de seguridad.
Para utilizar los contenedores de aprendizaje profundo Hugging Face con el SDK de SageMaker Python con fines de formación, consulta [el estimador de IA SageMaker Hugging Face](https://sagemaker.readthedocs.io/en/stable/frameworks/huggingface/index.html). Con el Hugging Face Estimator, puedes usar los modelos Hugging Face como lo harías con cualquier otro estimador de IA. SageMaker Sin embargo, el uso del SDK de SageMaker Python es opcional. También puede organizar el uso de los Hugging Face Deep Learning Containers con y. AWS CLI AWS SDK para Python (Boto3)
Para obtener más información sobre Hugging Face y los modelos disponibles en él, consulte la [documentación de Hugging Face](https://huggingface.co/).
## Formación
Para el entrenamiento, puede usar cualquiera de los miles de modelos disponibles en Hugging Face y afinarlos para su caso de uso con entrenamiento adicional. Con la SageMaker IA, puede utilizar la formación estándar o aprovechar la formación paralela [sobre datos distribuidos y modelos paralelos de SageMaker IA](https://docs.aws.amazon.com/sagemaker/latest/dg/distributed-training.html).
Al igual que otros trabajos de SageMaker formación que utilizan código personalizado, puedes capturar tus propias métricas pasando una definición de métricas al SDK de SageMaker Python. Para ver un ejemplo, consulte [Definir métricas de entrenamiento (SDK de SageMaker Python)](https://docs.aws.amazon.com/sagemaker/latest/dg/training-metrics.html#define-train-metrics-sdk). Puedes acceder a las métricas capturadas usando el método [CloudWatch](https://docs.aws.amazon.com/sagemaker/latest/dg/monitoring-cloudwatch.html)y como Pandas `DataFrame` usando [TrainingJobAnalytics](https://sagemaker.readthedocs.io/en/stable/api/training/analytics.html#sagemaker.analytics.TrainingJobAnalytics)este método. Una vez que el modelo esté entrenado y afinado, podrá usarlo como cualquier otro modelo para ejecutar trabajos de inferencia.
### Entrenamiento con el estimador de Hugging Face
Puedes implementar el Hugging Face Estimator para trabajos de entrenamiento con el SDK de Python para SageMaker IA. El SDK de SageMaker Python es una biblioteca de código abierto para entrenar e implementar modelos de aprendizaje automático en SageMaker IA. Para obtener más información sobre el estimador Hugging Face, consulta la documentación del SDK de [Python para SageMaker IA](https://sagemaker.readthedocs.io/en/stable/frameworks/huggingface/index.html).
Con el SDK de SageMaker Python, puedes ejecutar trabajos de entrenamiento con el Hugging Face Estimator en los siguientes entornos:
+ [Amazon SageMaker Studio Classic](https://docs.aws.amazon.com/sagemaker/latest/dg/studio.html): Studio Classic es el primer entorno de desarrollo (IDE) totalmente integrado para el aprendizaje automático (ML). Studio Classic proporciona una única interfaz visual basada en web en la que puede realizar todos los pasos de desarrollo de ML necesarios para:
+ preparación
+ build
+ entrenar y afinar
+ implementar y administrar modelos
Para obtener más información sobre el uso de los cuadernos de Jupyter en Studio Classic, consulte [Usa las libretas clásicas de Amazon SageMaker Studio](notebooks.md).
+ [SageMakerInstancias de Notebook](https://docs.aws.amazon.com/sagemaker/latest/dg/nbi.html): una instancia de Amazon SageMaker Notebook es una instancia de cómputo de aprendizaje automático (ML) que ejecuta la aplicación Jupyter Notebook. Esta aplicación le permite ejecutar cuadernos de Jupyter en su instancia de cuaderno para:
+ preparar y procesar datos
+ escribir código para entrenar modelos
+ implementar modelos en el alojamiento de SageMaker IA
+ pruebe o valide sus modelos sin las funciones de SageMaker Studio, como el depurador, la supervisión de modelos y un IDE basado en la web
+ Localmente: si tienes conectividad AWS y los permisos de SageMaker IA adecuados, puedes usar el SDK de SageMaker Python localmente. Con el uso local, puedes iniciar trabajos de formación e inferencia a distancia para Hugging Face in SageMaker AI on. AWS Esto funciona en tu máquina local, así como en otros AWS servicios con un SDK de SageMaker Python conectado y los permisos adecuados.
## Inferencia
A modo de inferencia, puedes usar tu modelo Hugging Face entrenado o uno de los modelos Hugging Face previamente entrenados para implementar un trabajo de inferencia con IA. SageMaker Con esta colaboración, solo necesitarás una línea de código para implementar tanto tus modelos entrenados como los modelos previamente entrenados con IA. SageMaker También puede ejecutar trabajos de inferencia sin tener que escribir ningún código de inferencia personalizado. Con el código de inferencia personalizado, puede personalizar la lógica de inferencia si proporciona su propio script de Python.
### Cómo implementar un trabajo de inferencia con los contenderos de aprendizaje profundo de Hugging Face
Dispone de dos opciones para realizar inferencias con SageMaker la IA. Puede realizar inferencias con un modelo que haya entrenado o implementar un modelo de Hugging Face previamente entrenado.
+ **Ejecute la inferencia con su modelo entrenado:** tiene dos opciones para ejecutar la inferencia con su propio modelo entrenado:
+ Realice inferencias con un modelo que haya entrenado utilizando un modelo Hugging Face existente con los contenedores de aprendizaje profundo AI SageMaker Hugging Face.
+ Traiga su propio modelo de Hugging Face existente e impleméntelo SageMaker mediante IA.
Cuando realizas inferencias con un modelo que has entrenado con el calculador Hugging Face de SageMaker IA, puedes implementar el modelo inmediatamente después de completar el entrenamiento. También puede cargar el modelo entrenado en un bucket de Amazon S3 e ingerirlo cuando ejecute la inferencia más adelante.
Si trae su propio modelo de Hugging Face existente, debe cargar el modelo entrenado en un bucket de Amazon S3. A continuación, ingiera ese bucket al ejecutar la inferencia, como se muestra en el [ejemplo Deploy your Hugging Face Transformers for inference](https://github.com/huggingface/notebooks/blob/main/sagemaker/10_deploy_model_from_s3/deploy_transformer_model_from_s3.ipynb).
+ **Realiza inferencias con un HuggingFace modelo previamente entrenado:** puedes usar uno de los miles de modelos de Hugging Face previamente entrenados para ejecutar tus trabajos de inferencia sin necesidad de capacitación adicional. Para realizar una inferencia, seleccione el modelo previamente entrenado de la lista de [modelos de Hugging Face](https://huggingface.co/models), como se describe en el [ejemplo Deploy pre-trained Hugging Face Transformers for inference](https://github.com/huggingface/notebooks/blob/main/sagemaker/11_deploy_model_from_hf_hub/deploy_transformer_model_from_hf_hub.ipynb).
## ¿Qué quiere hacer?
Los siguientes cuadernos del repositorio de libretas Hugging Face muestran cómo utilizar los contenedores de Deep Learning Hugging Face SageMaker con IA en varios casos de uso.
Quiero entrenar e implementar un modelo de clasificación de textos utilizando Hugging Face SageMaker in AI PyTorch con.
Para ver un ejemplo de Jupyter Notebook, consulta la demostración de [PyTorch introducción](https://github.com/huggingface/notebooks/blob/main/sagemaker/01_getting_started_pytorch/sagemaker-notebook.ipynb).
Quiero entrenar e implementar un modelo de clasificación de textos utilizando Hugging Face SageMaker in AI TensorFlow con.
Para ver un ejemplo de Jupyter Notebook, consulta el ejemplo de [TensorFlow introducción](https://github.com/huggingface/notebooks/blob/main/sagemaker/02_getting_started_tensorflow/sagemaker-notebook.ipynb).
Quiero realizar un entrenamiento distribuido con paralelismo de datos utilizando Hugging Face y AI Distributed. SageMaker
Para ver un ejemplo de cuaderno de Jupyter, consulte el [ejemplo de entrenamiento distribuido](https://github.com/huggingface/notebooks/blob/main/sagemaker/03_distributed_training_data_parallelism/sagemaker-notebook.ipynb).
Quiero realizar un entrenamiento distribuido con paralelismo de modelos utilizando Hugging Face y AI Distributed. SageMaker
Para ver un ejemplo de cuaderno de Jupyter, consulte el [ejemplo de paralelismo de modelos](https://github.com/huggingface/notebooks/blob/main/sagemaker/04_distributed_training_model_parallelism/sagemaker-notebook.ipynb).
Quiero usar una instancia puntual para entrenar e implementar un modelo con Hugging Face SageMaker en IA.
Para ver un ejemplo de cuaderno de Jupyter, consulte el [ejemplo de instancias de spot](https://github.com/huggingface/notebooks/blob/main/sagemaker/05_spot_instances/sagemaker-notebook.ipynb).
Quiero capturar métricas personalizadas y usar SageMaker AI Checkpoints cuando entreno un modelo de clasificación de textos con Hugging Face en IA. SageMaker
Para ver un ejemplo de cuaderno de Jupyter, consulte el [ejemplo de entrenamiento con métricas personalizadas](https://github.com/huggingface/notebooks/blob/main/sagemaker/06_sagemaker_metrics/sagemaker-notebook.ipynb).
Quiero entrenar un TensorFlow modelo distribuido de preguntas y respuestas utilizando Hugging Face en IA. SageMaker
[Para ver un ejemplo de Jupyter Notebook, consulta el ejemplo de formación distribuida. TensorFlow ](https://github.com/huggingface/notebooks/blob/main/sagemaker/07_tensorflow_distributed_training_data_parallelism/sagemaker-notebook.ipynb)
Quiero entrenar un modelo de resumen distribuido usando Hugging Face en IA. SageMaker
Para ver un ejemplo de cuaderno de Jupyter, consulte el [ejemplo de entrenamiento de resumen distribuido](https://github.com/huggingface/notebooks/blob/main/sagemaker/08_distributed_summarization_bart_t5/sagemaker-notebook.ipynb).
Quiero entrenar un modelo de clasificación de imágenes usando Hugging Face SageMaker en IA.
Para ver un ejemplo de cuaderno de Jupyter, consulte el [ejemplo de entrenamiento de transformadores de visión](https://github.com/huggingface/notebooks/blob/main/sagemaker/09_image_classification_vision_transformer/sagemaker-notebook.ipynb).
Quiero implementar mi modelo de Hugging Face entrenado SageMaker en IA.
Para ver un ejemplo de cuaderno de Jupyter, consulte el [ejemplo de implementación de transformadores de Hugging Face para inferencia](https://github.com/huggingface/notebooks/blob/main/sagemaker/10_deploy_model_from_s3/deploy_transformer_model_from_s3.ipynb).
Quiero implementar un modelo de Hugging Face previamente entrenado en IA. SageMaker
Para ver un ejemplo de cuaderno de Jupyter, consulte el [ejemplo de implementación de transformadores de Hugging Face previamente entrenados para inferencia](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 con Amazon SageMaker AI
Puede usar Amazon SageMaker AI para entrenar e implementar un modelo mediante PyTorch código personalizado. Los PyTorch estimadores y modelos del SDK de Python para SageMaker IA y el PyTorch contenedor de código abierto de SageMaker IA facilitan la escritura de un PyTorch script y su ejecución en SageMaker IA. En la siguiente sección, se proporciona material de referencia que puede utilizar para aprender a utilizar PyTorch la IA. SageMaker
## ¿Qué quiere hacer?
Quiero entrenar un PyTorch modelo personalizado en SageMaker IA.
Para ver un ejemplo de cuaderno de Jupyter, consulta el [cuaderno de PyTorch ejemplo](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/sagemaker-python-sdk/pytorch_mnist) en el repositorio Amazon SageMaker AI Examples GitHub.
Para obtener documentación, consulte [Entrenar un modelo con](https://sagemaker.readthedocs.io/en/stable/using_pytorch.html#train-a-model-with-pytorch). PyTorch
Tengo un PyTorch modelo que he formado en SageMaker IA y quiero implementarlo en un punto final alojado.
Para obtener más información, consulte [Implementar PyTorch modelos](https://sagemaker.readthedocs.io/en/stable/using_pytorch.html#deploy-pytorch-models).
Tengo un PyTorch modelo que he entrenado fuera de la SageMaker IA y quiero implementarlo en un punto final de SageMaker IA
Para obtener más información, consulte [Implemente su propio PyTorch modelo](https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/using_pytorch.html#bring-your-own-model).
Quiero ver la documentación de la API para las PyTorch clases [del SDK de Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable).
Para obtener más información, consulte [PyTorch Clases](https://sagemaker.readthedocs.io/en/stable/sagemaker.pytorch.html).
Quiero encontrar el repositorio de PyTorch contenedores de SageMaker IA.
Para obtener más información, consulta el [ GitHub repositorio de SageMaker AI PyTorch Container](https://github.com/aws/deep-learning-containers/tree/master/pytorch).
Deseo obtener información sobre PyTorch las versiones compatibles con AWS Deep Learning Containers.
Para obtener más información, consulte [Available Deep Learning Container Images](https://github.com/aws/deep-learning-containers/blob/master/available_images.md).
Para obtener información general sobre la redacción de guiones de PyTorch entrenamiento y el uso de PyTorch estimadores y modelos con SageMaker IA, consulte [Uso PyTorch con el SDK de SageMaker Python](https://sagemaker.readthedocs.io/en/stable/using_pytorch.html).
# Recursos para usar R con Amazon SageMaker AI
En este documento se enumeran los recursos que pueden ayudarle a aprender a utilizar las funciones de Amazon SageMaker AI con el entorno de software R. En las siguientes secciones se presenta el núcleo R integrado en la SageMaker IA, se explica cómo empezar a utilizar R en la SageMaker IA y se proporcionan varios ejemplos de cuadernos.
Los ejemplos están organizados en tres niveles: principiante, intermedio y avanzado. Empiezan con [Primeros pasos con R en la SageMaker IA](https://sagemaker-examples.readthedocs.io/en/latest/r_examples/r_sagemaker_hello_world/r_sagemaker_hello_world.html), continúan con el aprendizaje end-to-end automático con R en la SageMaker IA y, luego, terminan con temas más avanzados, como el SageMaker procesamiento con el script R y el algoritmo bring-your-own R para la SageMaker IA.
Para obtener información sobre cómo incorporar su propia imagen de R personalizada a Studio, consulte [Imágenes personalizadas en Amazon SageMaker Studio Classic](studio-byoi.md). Para ver un artículo de blog similar, consulte [Cómo incorporar su propio entorno R a Amazon SageMaker Studio](https://aws.amazon.com/blogs/machine-learning/bringing-your-own-r-environment-to-amazon-sagemaker-studio/).
**Topics**
+ [
## RStudio soporte en SageMaker IA
](#rstudio-for-r)
+ [
## Núcleo R en SageMaker IA
](#r-sagemaker-kernel-ni)
+ [
## Cuadernos de ejemplo
](#r-sagemaker-example-notebooks)
+ [
# Comience con R en SageMaker IA
](r-sagemaker-get-started.md)
## RStudio soporte en SageMaker IA
Amazon SageMaker AI es compatible con RStudio un entorno de desarrollo integrado (IDE) totalmente gestionado e integrado con el dominio Amazon SageMaker AI. Con RStudio la integración, puede lanzar un RStudio entorno en el dominio para ejecutar sus RStudio flujos de trabajo con recursos de SageMaker IA. Para obtener más información, consulte [RStudio en Amazon SageMaker AI](rstudio.md).
## Núcleo R en SageMaker IA
SageMaker las instancias de notebook admiten R mediante un núcleo R preinstalado. Además, el núcleo R tiene la biblioteca reticulate, una interfaz de R a Python, por lo que puede utilizar las funciones del SageMaker AI Python SDK desde un script de R.
+ [reticulatelibrary:](https://rstudio.github.io/reticulate/) [proporciona una interfaz R para el SDK de Amazon Python. SageMaker ](https://sagemaker.readthedocs.io/en/stable) El paquete reticular traduce entre objetos R y Python.
## Cuadernos de ejemplo
**Requisitos previos**
+ [Introducción a R en la SageMaker IA](https://sagemaker-examples.readthedocs.io/en/latest/r_examples/r_sagemaker_hello_world/r_sagemaker_hello_world.html): este cuaderno de muestra describe cómo puede desarrollar scripts de R con el kernel R de Amazon SageMaker AI. En este cuaderno, configura su entorno y permisos de SageMaker IA, descarga el [conjunto de datos abalone](https://archive.ics.uci.edu/ml/datasets/abalone) del [UCI Machine Learning Repository, realiza](https://archive.ics.uci.edu/datasets) algunos procesos básicos de procesamiento y visualización de los datos y, a continuación, guarda los datos en formato.csv en S3.
**Nivel de principiante**
+ [SageMaker Transformación por lotes mediante IA Kernel R](https://sagemaker-examples.readthedocs.io/en/latest/r_examples/r_batch_transform/r_xgboost_batch_transform.html): este ejemplo de cuaderno describe cómo realizar un trabajo de transformación por lotes utilizando la API Transformer de SageMaker IA y el [XGBoostalgoritmo](https://docs.aws.amazon.com/sagemaker/latest/dg/xgboost.html). El cuaderno también usa el conjunto de datos Abalone.
**Nivel intermedio**
+ [Optimización de hiperparámetros para XGBoost en R](https://sagemaker-examples.readthedocs.io/en/latest/r_examples/r_xgboost_hpo_batch_transform/r_xgboost_hpo_batch_transform.html): este cuaderno de muestra amplía los cuadernos anteriores para principiantes que utilizaban el conjunto de datos abulón y. XGBoost Describe cómo ajustar el modelo con la [optimización de hiperparámetros](https://sagemaker.readthedocs.io/en/stable/tuner.html). También aprenderá a usar la transformación por lotes para hacer predicciones por lotes y cómo crear un punto de conexión del modelo para hacer predicciones en tiempo 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/) le permite preprocesar, posprocesar y ejecutar cargas de trabajo de evaluación de modelos. En este ejemplo se muestra cómo crear un script de R para organizar un trabajo de procesamiento.
**Nivel avanzado**
+ [Entrene e implemente su propio algoritmo R en SageMaker IA](https://sagemaker-examples.readthedocs.io/en/latest/r_examples/r_byo_r_algo_hpo/tune_r_bring_your_own.html): ¿ya tiene un algoritmo R y desea incorporarlo a la SageMaker IA para ajustarlo, entrenarlo o implementarlo? En este ejemplo, se explica cómo personalizar los contenedores de SageMaker IA con paquetes R personalizados, hasta el uso de un punto final alojado para realizar inferencias en su modelo de origen R.
# Comience con R en SageMaker IA
En este tema se explica cómo empezar a utilizar el entorno de software R en la SageMaker IA. Para obtener más información sobre el uso de R con SageMaker IA, consulte[Recursos para usar R con Amazon SageMaker AI](r-guide.md).
**Para empezar a usar R en la consola de SageMaker IA**
1. [Cree una instancia del cuaderno](https://docs.aws.amazon.com/sagemaker/latest/dg/howitworks-create-ws.html) con el tipo de instancia t2.medium y el tamaño de almacenamiento predeterminado. Puede elegir una instancia más rápida y más almacenamiento, si tiene previsto continuar utilizando la instancia en ejemplos más avanzados, o bien puede crear una instancia más grande más adelante.
1. Espere hasta que el estado del cuaderno sea **En servicio** y, a continuación, elija **Abrir Jupyter**.
![\[Ubicación del InServiceestado y del enlace Abrir Jupyter en la consola.\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/images/An-R-User-Guide-to-SageMaker/An-R-User-Guide-to-SageMaker-1.png)
1. Cree un nuevo bloc de notas con el kernel R de la lista de entornos disponibles.
![\[Ubicación del kernel de R en la lista de entornos disponibles.\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/images/An-R-User-Guide-to-SageMaker/An-R-User-Guide-to-SageMaker-2.png)
1. Cuando se crea el nuevo bloc de notas, debe ver el logotipo R en la esquina superior derecha del entorno del bloc de notas y también debe ver R como el kernel debajo de ese logotipo. Esto indica que SageMaker AI ha lanzado correctamente el kernel R para este portátil.
![\[Ubicación del logotipo de R y del kernel de R del entorno del cuaderno.\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/images/An-R-User-Guide-to-SageMaker/An-R-User-Guide-to-SageMaker-3.png)
Alternativamente, cuando esté en un cuaderno de Jupyter, puede utilizar el menú **Kernel** y, a continuación, seleccionar **R** en el submenú **Cambiar kernel**.
![\[Ubicación en la que cambiar el kernel de su cuaderno a R.\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/images/An-R-User-Guide-to-SageMaker/An-R-User-Guide-to-SageMaker-4.png)
# Recursos para usar Scikit-learn con Amazon AI SageMaker
Puede usar Amazon SageMaker AI para entrenar e implementar un modelo mediante el código Scikit-learn personalizado. Los estimadores y modelos Scikit-learn del SDK de Python para SageMaker IA y los contenedores Scikit-learn de código abierto de SageMaker IA facilitan la escritura de un script de Scikit-learn y su ejecución en IA. SageMaker En la siguiente sección se proporciona material de referencia que puede utilizar para aprender a utilizar Scikit-learn con la IA. SageMaker
**Requisitos**
Scikit-learn 1.4 tiene las siguientes dependencias.
| Dependencia | Versión mínima |
| --- | --- |
| Python | 3.10 |
| NumPy | 2.1.0 |
| SciPy | 1.15.3 |
| joblib | 1.5.2 |
| threadpoolctl | 3.6.0 |
El contenedor SageMaker AI Scikit-learn es compatible con las siguientes versiones de Scikit-learn.
| Versión compatible de Scikit-learn | Versión mínima de 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 o 3.4 |
[Para obtener información general sobre cómo escribir guiones de entrenamiento de Scikit-learn y usar estimadores y modelos de Scikit-learn con IA SageMaker , consulte Uso de Scikit-learn con el SDK de Python. SageMaker ](https://sagemaker.readthedocs.io/en/stable/using_sklearn.html)
## ¿Qué quiere hacer?
**nota**
Se necesita Matplotlib v2.2.3 o posterior para ejecutar los cuadernos de ejemplo de AI Scikit-learn. SageMaker
Quiero usar Scikit-learn para el procesamiento de datos, la ingeniería de características o la evaluación de modelos en IA. SageMaker
[Para ver un ejemplo de cuaderno de Jupyter, consulta /\$1learn\$1data\$1processing\$1and\$1model\$1evaluation. 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)
Para ver una entrada de blog sobre el entrenamiento y la implementación de un modelo de Scikit-Learn, consulte [Amazon SageMaker AI añade](https://aws.amazon.com/blogs/machine-learning/amazon-sagemaker-adds-scikit-learn-support/) compatibilidad con Scikit-Learn.
Para obtener la documentación, consulte [ReadTheDocs](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_processing.html#data-pre-processing-and-model-evaluation-with-scikit-learn).
Quiero entrenar un modelo Scikit-learn personalizado en IA. SageMaker
[Para ver un ejemplo de cuaderno de Jupyter, consulta/\$1learn\$1iris. 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)
Para obtener documentación, consulte [Train a Model with Scikit-learn](https://sagemaker.readthedocs.io/en/stable/using_sklearn.html#train-a-model-with-sklearn).
Tengo un modelo Scikit-learn que he formado en SageMaker IA y quiero implementarlo en un terminal alojado.
Para obtener más información, consulte [Deploy Scikit-learn models](https://sagemaker.readthedocs.io/en/stable/using_sklearn.html#deploy-sklearn-models).
Tengo un modelo Scikit-learn que he entrenado fuera de la SageMaker IA y quiero implementarlo en un punto final de IA SageMaker
Para obtener más información, consulte [Deploy Endpoints from Model Data](https://sagemaker.readthedocs.io/en/stable/using_sklearn.html#deploy-endpoints-from-model-data).
Quiero ver la documentación de la API para las clases de [ SageMaker Scikit-learn del SDK de Amazon Python](https://sagemaker.readthedocs.io/en/stable).
Para obtener más información, consulte [Scikit-learn Classes](https://sagemaker.readthedocs.io/en/stable/sagemaker.sklearn.html).
Quiero ver información sobre los contenedores Scikit-learn de SageMaker IA.
Para obtener más información, consulta el repositorio [SageMaker Scikit-learn](https://github.com/aws/sagemaker-scikit-learn-container) Container. GitHub
# Recursos para usar SparkML Serving con Amazon AI SageMaker
El modelo y el predictor SparkML Serving del [SDK de Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable) y el contenedor SparkML Serving de SageMaker código abierto de Amazon AI admiten el despliegue de canalizaciones de Apache Spark ML serializadas con IA para obtener inferencias. MLeap SageMaker Utilice los siguientes recursos para aprender a utilizar SparkML Serving con SageMaker IA.
Para obtener información sobre el uso del contenedor SparkML Serving para implementar modelos en SageMaker IA, consulta el repositorio de [SageMaker Spark ML Container GitHub ](https://github.com/aws/sagemaker-sparkml-serving-container). Para obtener información sobre el modelo y los predictores de SparkML Serving del [SDK de Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable), consulte la documentación de la API Predictor y [SparkML Serving Model](https://sagemaker.readthedocs.io/en/stable/sagemaker.sparkml.html).
# Recursos para usar TensorFlow con Amazon SageMaker AI
Puede usar Amazon SageMaker AI para entrenar e implementar un modelo mediante TensorFlow código personalizado. Los TensorFlow estimadores y modelos del SDK de Python para SageMaker IA y los TensorFlow contenedores de código abierto de SageMaker IA pueden ayudar. Usa la siguiente lista de recursos para obtener más información, en función de la versión que TensorFlow utilices y de lo que desees hacer.
## TensorFlow Versión 1.11 y posteriores
Para TensorFlow las versiones 1.11 y posteriores, el [SDK de Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable) admite scripts de entrenamiento en modo script.
### ¿Qué quiere hacer?
Quiero entrenar un TensorFlow modelo personalizado en SageMaker IA.
Para ver un ejemplo de cuaderno de Jupyter, consulta [Entrenamiento y servicio en 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 obtener documentación, consulte [Entrenar un modelo con](https://sagemaker.readthedocs.io/en/stable/using_tf.html#train-a-model-with-tensorflow). TensorFlow
Tengo un TensorFlow modelo que he formado en SageMaker IA y quiero implementarlo en un punto final alojado.
Para obtener más información, consulte [Implementación de modelos de TensorFlow servicio](https://sagemaker.readthedocs.io/en/stable/using_tf.html#deploy-tensorflow-serving-models).
Tengo un TensorFlow modelo que he entrenado fuera de la SageMaker IA y quiero implementarlo en un punto final de SageMaker IA.
Para obtener más información, consulte [Deploying directly from model artifacts](https://sagemaker.readthedocs.io/en/stable/using_tf.html#deploying-directly-from-model-artifacts).
Quiero ver la documentación de la API para las TensorFlow clases [del SDK de Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable).
Para obtener más información, consulte [TensorFlow Estimator](https://sagemaker.readthedocs.io/en/stable/sagemaker.tensorflow.html).
Quiero encontrar el repositorio de TensorFlow contenedores de SageMaker IA.
Para obtener más información, consulte [ GitHub Repositorio de SageMaker TensorFlow contenedores](https://github.com/aws/sagemaker-tensorflow-container).
Deseo obtener información sobre TensorFlow las versiones compatibles con AWS Deep Learning Containers.
Para obtener más información, consulte [Available Deep Learning Container Images](https://github.com/aws/deep-learning-containers/blob/master/available_images.md).
Para obtener información general sobre cómo escribir guiones de entrenamiento en modo TensorFlow TensorFlow script y usar estimadores y modelos en modo script con SageMaker IA, consulte [Uso TensorFlow con el SDK de SageMaker Python](https://sagemaker.readthedocs.io/en/stable/using_tf.html).
## TensorFlow Modo heredado para las versiones 1.11 y anteriores
El [SDK de Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable) proporciona un modo heredado que admite TensorFlow las versiones 1.11 y anteriores. Utilice scripts de TensorFlow entrenamiento en modo tradicional para ejecutar TensorFlow tareas en SageMaker IA si:
+ Dispone de scripts existentes en el modo heredado que no desea convertir al modo de script.
+ Quieres usar una TensorFlow versión anterior a la 1.11.
Para obtener información sobre cómo escribir TensorFlow scripts en modo heredado para usarlos con el SDK de Python para SageMaker IA, consulte [TensorFlow SageMaker Estimadores y modelos](https://github.com/aws/sagemaker-python-sdk/tree/v1.12.0/src/sagemaker/tensorflow#tensorflow-sagemaker-estimators-and-models).
# Recursos para usar el servidor de inferencia Triton con Amazon AI SageMaker
SageMaker La IA permite a los clientes implementar un modelo mediante código personalizado con el servidor de inferencias Triton de NVIDIA. Utilice los siguientes recursos para aprender a utilizar el servidor de inferencia Triton con IA. SageMaker
Esta funcionalidad está disponible mediante el desarrollo de [contenedores del servidor de inferencia Triton](https://docs.aws.amazon.com/deep-learning-containers/latest/devguide/what-is-dlc.html). Estos contenedores incluyen el servidor de inferencia NVIDIA Triton, la compatibilidad con los marcos de aprendizaje automático más comunes y variables de entorno útiles que permiten optimizar el rendimiento en la IA. SageMaker Para ver una lista completa de todas las imágenes disponibles de contenedores de aprendizaje profundo, consulte [Available Deep Learning Containers Images](https://github.com/aws/deep-learning-containers/blob/master/available_images.md). Las imágenes de contenedores de aprendizaje profundo se mantienen y actualizan periódicamente con parches de seguridad.
Puede utilizar el contenedor del servidor de inferencia Triton con el SDK de SageMaker Python como lo haría con cualquier otro contenedor de sus modelos de SageMaker IA. Sin embargo, el uso del SDK de SageMaker Python es opcional. Puede utilizar los contenedores del servidor de inferencia Triton con las AWS CLI teclas y. AWS SDK para Python (Boto3)
Para obtener más información sobre el servidor de inferencia NVIDIA Triton, consulte la [documentación de Triton](https://docs.nvidia.com/deeplearning/triton-inference-server/#).
## Inferencia
**nota**
El backend Python de Triton usa memoria compartida (SHMEM) para conectar el código a Triton. SageMaker AI Inference proporciona hasta la mitad de la memoria de la instancia que proporciona SHMEM, por lo que puedes usar una instancia con más memoria para un SHMEM de mayor tamaño.
Para realizar inferencias, puede usar sus modelos de aprendizaje automático entrenados con Triton Inference Server para implementar un trabajo de inferencia con IA. SageMaker
Algunas de las características clave del contenedor del servicios de inferencia Triton son:
+ **Compatibilidad con varios marcos**: Triton se puede usar para implementar modelos de todos los principales marcos de ML. Triton admite los formatos de SavedModel modelo Python/C\$1\$1 personalizados TensorFlow GraphDef y ONNX, PyTorch TorchScript TensorRT.
+ **Canalizaciones de modelos**: el conjunto de modelos Triton representa una canalización de un modelo con lógica de pre/post procesamiento y la conexión de los tensores de entrada y salida entre ellos. Una sola solicitud de inferencia a un conjunto desencadena la ejecución de toda la canalización.
+ **Ejecución simultánea del modelo**: se pueden ejecutar varias instancias del mismo modelo simultáneamente en la misma GPU o en varias. GPUs
+ **Procesamiento dinámico por lotes**: para los modelos que admiten el procesamiento por lotes, Triton tiene varios algoritmos integrados de programación y procesamiento por lotes que combinan las solicitudes de inferencia individuales para mejorar el rendimiento de las inferencias. Estas decisiones de programación y procesamiento por lotes son transparentes para el cliente que solicita la inferencia.
+ **Compatibilidad diversa con CPU y GPU**: los modelos se pueden ejecutar en CPUs o GPUs para lograr la máxima flexibilidad y para satisfacer requisitos informáticos heterogéneos.
## ¿Qué quiere hacer?
Quiero implementar mi PyTorch modelo entrenado en SageMaker IA.
Para ver un ejemplo de Jupyter Notebook, consulte el ejemplo [Implementación del modelo PyTorch Resnet50 con el servidor de inferencia Triton](https://github.com/aws/amazon-sagemaker-examples/blob/master/sagemaker-triton/resnet50/triton_resnet50.ipynb).
Quiero implementar mi modelo de Hugging Face entrenado SageMaker en IA.
Para ver un ejemplo de Jupyter Notebook, consulte el ejemplo [Implementación de un modelo PyTorch BERT con el servidor de inferencia Triton](https://github.com/aws/amazon-sagemaker-examples/blob/master/sagemaker-triton/nlp_bert/triton_nlp_bert.ipynb).