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. # 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 cómputo 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)