Cree un flujo de trabajo de MLOps entre cuentas con el registro modelo de Amazon SageMaker

Una canalización de CI/CD bien diseñada es esencial para escalar cualquier flujo de trabajo de desarrollo de software de manera efectiva. Al diseñar canalizaciones de CI/CD de producción, AWS recomienda aprovechar varias cuentas para aislar recursos, contener amenazas de seguridad y simplificar la facturación, y las canalizaciones de ciencia de datos no son diferentes. En AWS, seguimos innovando para simplificar el flujo de trabajo de MLOps.

En esta publicación, discutimos algunas de las características más nuevas de varias cuentas para Amazon SageMaker que le permiten compartir y administrar mejor los grupos de modelos, así como también administrar las versiones de modelos. Para ver un ejemplo de estructura de cuenta a seguir prácticas recomendadas de la unidad organizativa para alojar modelos que usan terminales de SageMaker entre cuentas, consulte Orquestador de carga de trabajo de MLOps.

Resumen de la solución

El siguiente diagrama ilustra nuestra arquitectura de registro modelo compartido.

Algunas cosas a tener en cuenta en la arquitectura anterior:

Los siguientes pasos corresponden al diagrama:

1. Un científico de datos registra un modelo de la cuenta de ciencia de datos en el registro de modelos de SageMaker de servicios compartidos en un PendingManualApproval estado. El artefacto del modelo se crea en la cuenta de servicios compartidos. Servicio de almacenamiento simple de Amazon (Amazon S3) cubo.
2. Tras el registro de una nueva versión del modelo, alguien con la autoridad para aprobar el modelo en función de las métricas debe aprobar o rechazar el modelo.
3. Una vez que se aprueba el modelo, la canalización de CI/CD en la cuenta de implementación se activado para desplegar los detalles del modelo actualizado en la cuenta de control de calidad y actualizar la etapa como control de calidad.
4. Al pasar el proceso de prueba, puede optar por tener un paso de aprobación manual dentro de su proceso de CI/CD o hacer que su canalización de CI/CD implemente directamente el modelo en producción y actualice la etapa como Prod.
5. El entorno de producción hace referencia al modelo y código aprobados, tal vez haciendo un Prueba A/B en producción. En caso de una auditoría o cualquier problema con el modelo, puede utilizar Seguimiento de linaje de Amazon SageMaker ML. Crea y almacena información sobre los pasos de un flujo de trabajo de aprendizaje automático (ML) desde la preparación de datos hasta la implementación del modelo. Con la información de seguimiento, puede reproducir los pasos del flujo de trabajo, realizar un seguimiento del modelo y el linaje del conjunto de datos, y establecer estándares de auditoría y gobernanza del modelo.

A lo largo de todo el proceso, el registro del modelo compartido conserva las versiones anteriores del modelo. Esto permite que el equipo revierta los cambios, o incluso aloje variantes de producción.

Requisitos previos

Asegúrese de tener los siguientes requisitos previos:

• Una estructura multicuenta aprovisionada – Para obtener instrucciones, consulte Prácticas recomendadas para unidades organizativas con AWS Organizations. Para los propósitos de este blog, estamos aprovechando las siguientes cuentas:
  • cuenta de ciencia de datos – Una cuenta donde los científicos de datos tienen acceso a los datos de entrenamiento y crean los modelos.
  • cuenta de servicios compartidos – Una cuenta central para almacenar los artefactos del modelo (como se muestra en el diagrama de arquitectura) para acceder a través de las diferentes cuentas de carga de trabajo.
  • Cuenta de implementación – Una cuenta responsable de implementar los cambios en las distintas cuentas.
  • Cuentas de carga de trabajo – Por lo general, se trata de entornos de control de calidad y producción en los que los ingenieros de software pueden crear aplicaciones para consumir el modelo de aprendizaje automático.
• Una cuenta de implementación con los permisos adecuados – Para obtener más información sobre las mejores prácticas con una estructura de unidad organizativa de varias cuentas, consulte Unidad organizativa de implementaciones. Esta cuenta es responsable de apuntar las cuentas de carga de trabajo al modelo deseado en el registro del modelo de la cuenta de servicios compartidos.

Definir políticas entre cuentas

Al seguir el principio de privilegio mínimo, primero debemos agregar políticas de recursos entre cuentas a los recursos de servicios compartidos para otorgar acceso desde las otras cuentas.

Debido a que los artefactos del modelo se almacenan en el depósito de S3 de la cuenta de servicios compartidos, la cuenta de ciencia de datos necesita acceso de lectura/escritura de Amazon S3 para enviar modelos entrenados a Amazon S3. El siguiente código ilustra esta política, pero aún no la agregue a la cuenta de servicios compartidos:

#Data Science account's policy to access Shared Services' S3 bucket
 {
    'Version': '2012-10-17',
    'Statement': [{
        'Sid': 'AddPerm',
        'Effect': 'Allow',
        'Principal': {
            'AWS': 'arn:aws:iam:::root'
        }, 
        "Action": [ 
            's3:PutObject', 
            's3:PutObjectAcl',
            's3:GetObject', 
            's3:GetObjectVersion'
        ], #read/write
        'Resource': 'arn:aws:s3:::/*'
    }]
}

La cuenta de implementación solo necesita tener acceso de lectura al depósito S3, de modo que pueda usar los artefactos del modelo para implementar en los puntos finales de SageMaker. También debemos adjuntar la siguiente política al depósito S3 de servicios compartidos:

#Deployment account's policy to access Shared Services' S3 bucket
 {
    'Version': '2012-10-17',
    'Statement': [{
        'Sid': 'AddPerm',
        'Effect': 'Allow',
        'Principal': {
            'AWS': 'arn:aws:iam:::root'
        },
        'Action': [ 
            's3:GetObject', 
            's3:GetObjectVersion'
        ], #read
        'Resource': 'arn:aws:s3:::/*'
    }]
}

Combinamos ambas políticas para obtener la siguiente política final. Cree esta política en la cuenta de servicios compartidos después de reemplazar los ID de cuenta correspondientes:

{
  "Version": "2012-10-17",
  "Statement": [{
    "Sid": "AddPerm",
    "Effect": "Allow",
    "Principal": {
      "AWS": "arn:aws:iam:::root"    
    },
    "Action": [
      "s3:PutObject",
      "s3:PutObjectAcl",
      "s3:GetObject",
      "s3:GetObjectVersion"    ],
    "Resource": "arn:aws:s3:::/*"  
    },
    {
      "Sid": "AddPermDeployment",
      "Effect": "Allow",
      "Principal": {
        "AWS": "arn:aws:iam:::root"      
      },
      "Action": [
        "s3:GetObject",
        "s3:GetObjectVersion"      ], 
      "Resource": "arn:aws:s3:::/*"    
    }
  ]
}

Para poder implementar un modelo creado en una cuenta diferente, el usuario debe tener un rol que tenga acceso a las acciones de SageMaker, como un rol con el AmazonSageMakerFullAccess política administrada. Referirse a Implementar una versión de modelo desde una cuenta diferente para obtener detalles adicionales.

Necesitamos definir el grupo de modelos que contiene las versiones de modelos que queremos implementar. Además, queremos otorgar permisos a la cuenta de ciencia de datos. Esto se puede lograr en los siguientes pasos. Nos referimos a las cuentas de la siguiente manera:

• id_de_cuenta_de_servicios_compartidos – La cuenta donde está el registro del modelo y donde queremos que esté el modelo
• data_science_account_id – La cuenta donde estaremos entrenando y, por lo tanto, creando el artefacto del modelo real
• id_cuenta_despliegue – La cuenta donde queremos alojar el punto final para este modelo

Primero, debemos asegurarnos de que existan los grupos de paquetes modelo. Puede usar las API de Boto3 como se muestra en el siguiente ejemplo, o puede usar el Consola de administración de AWS para crear el paquete modelo. Referirse a Crear grupo de paquetes modelo para más detalles. Esto supone que tiene instalado el Boto3.

model_package_group_name = "cross-account-example-model"
sm_client = boto3.Session().client("sagemaker")

create_model_package_group_response = sm_client.create_model_package_group(
    ModelPackageGroupName=model_package_group_name,
    ModelPackageGroupDescription="Cross account model package group",
    Tags=[
          {
              'Key': 'Name',
              'Value': 'cross_account_test'
          },
      ]

)

print('ModelPackageGroup Arn : {}'.format(create_model_package_group_response['ModelPackageGroupArn']))

Para los permisos para este grupo de paquetes modelo, puede crear un documento JSON similar al siguiente código. Reemplace los ID de cuenta reales y el nombre del grupo de paquetes modelo con sus propios valores.

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "AddPermModelPackageGroupCrossAccount",
      "Effect": "Allow",
      "Principal": {
        "AWS": "arn:aws:iam:::root"      
      },
      "Action": [
        "sagemaker:DescribeModelPackageGroup"      
        ],
      "Resource": "arn:aws:sagemaker:::model-package-group/"    
    },
    {
      "Sid": "AddPermModelPackageVersionCrossAccount",
      "Effect": "Allow",
      "Principal": {
        "AWS": "arn:aws:iam:::root"      
      },
      "Action": [
        "sagemaker:DescribeModelPackage",
        "sagemaker:ListModelPackages",
        "sagemaker:UpdateModelPackage",
        "sagemaker:CreateModelPackage",
        "sagemaker:CreateModel"      
      ],
      "Resource": "arn:aws:sagemaker:::model-package//*"    
    }
  ]
}

Finalmente, aplique la política al grupo de paquetes modelo. No puede asociar esta política con el grupo de paquetes a través de la consola. Necesita el SDK o Interfaz de línea de comandos de AWS (AWS CLI) acceso. Por ejemplo, el siguiente código usa Boto3:

# Convert the policy from JSON dict to string
model_package_group_policy = dict( )
model_package_group_policy = json.dumps(model_package_group_policy)

# Set the new policy
sm_client = boto3.Session().client("sagemaker")
response = sm_client.put_model_package_group_policy(
    ModelPackageGroupName = model_package_group_name,
    ResourcePolicy = model_package_group_policy)

También necesitamos una costumbre Servicio de administración de claves de AWS (AWS KMS) para cifrar el modelo mientras lo almacena en Amazon S3. Esto debe hacerse usando la cuenta de ciencia de datos. En la consola de AWS KMS, vaya a la Definir permisos de uso de claves página. En el Otras cuentas de AWS sección, elija Agregar otra cuenta de AWS. Ingrese el número de cuenta de AWS para la cuenta de implementación. Utilice esta clave KMS para el trabajo de capacitación de SageMaker. Si no especifica una clave KMS para el trabajo de capacitación, SageMaker utiliza de forma predeterminada una clave de cifrado del lado del servidor de Amazon S3. Una clave de cifrado predeterminada del lado del servidor de Amazon S3 no se puede compartir ni utilizar con otra cuenta de AWS.

La política y los permisos siguen este patrón:

• La política de Amazon S3 especificada en shared_services_account otorga permisos a la cuenta de ciencia de datos y la cuenta de implementaciones
• La política de claves de KMS especificada en shared_services_account otorga permisos a la cuenta de ciencia de datos y la cuenta de implementaciones

Necesitamos asegurarnos de que la cuenta de servicios compartidos y la cuenta de implementación tengan acceso a las imágenes de Docker que se usaron para entrenar el modelo. Estas imágenes generalmente se alojan en cuentas de AWS, y el administrador de su cuenta puede ayudarlo a obtener acceso, si aún no tiene acceso. Para esta publicación, no creamos ninguna imagen de Docker personalizada después de entrenar el modelo y, por lo tanto, no necesitamos políticas específicas de Amazon ECR para las imágenes.

En las cuentas de carga de trabajo (QA o prod), necesitamos crear dos Gestión de identidades y accesos de AWS (IAM) políticas similares a las siguientes. Estos son políticas en línea, lo que significa que están integrados en una identidad de IAM. Esto le da a estas cuentas acceso al registro modelo.

La primera política en línea permite que un rol acceda al recurso de Amazon S3 en la cuenta de servicios compartidos que contiene el artefacto del modelo. Proporcione el nombre del depósito S3 y su modelo:

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": "s3:GetObject",
            "Resource": "arn:aws:s3:::/sagemaker//output/model.tar.gz"
        }
    ]
}

La segunda política en línea permite que un rol, que creamos más adelante, use la clave KMS en la cuenta de servicios compartidos. Especifique el ID de cuenta para la cuenta de servicios compartidos y el ID de clave de KMS:

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Sid": "AllowUseOfTheKey",
            "Effect": "Allow",
            "Action": [
                "kms:Decrypt"
            ],
            "Resource": [
                "arn:aws:kms:us-east-1::key/{xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx}"
            ]
        }
    ]
}

Finalmente, necesitamos crear un rol de IAM para SageMaker. Este rol tiene la AmazonSageMakerFullAccess póliza adjunta. Luego adjuntamos estas dos políticas en línea al rol que creamos. Si utiliza una función de ejecución de SageMaker existente, adjunte estas dos políticas a esa función. Para obtener instrucciones, consulte Crear roles y adjuntar políticas (consola).

Ahora que hemos definido las políticas de cada cuenta, usemos un ejemplo para verlo en acción.

Cree y entrene un modelo mediante una canalización de SageMaker

Primero creamos una canalización de SageMaker en la cuenta de ciencia de datos para llevar a cabo el procesamiento de datos, el entrenamiento de modelos y la evaluación. Usamos el conjunto de datos de vivienda de California obtenido de la biblioteca StatLib. En el siguiente fragmento de código, usamos un script de preprocesamiento personalizado preprocess.py para realizar una transformación de características simple, como el escalado de características, que se puede generar usando lo siguiente cuaderno. Este script también divide el conjunto de datos en conjuntos de datos de entrenamiento y de prueba.

Creamos un SKLearnProcessor objeto para ejecutar este script de preprocesamiento. En la canalización de SageMaker, creamos un paso de procesamiento (ProcessingStep) para ejecutar el código de procesamiento usando SKLearnProcessor. Este código de procesamiento se llama cuando se inicializa la canalización de SageMaker. El código que crea el SKLearnProcessor y ProcessingStep se muestran en el siguiente código. Tenga en cuenta que todo el código de esta sección se ejecuta en la cuenta de ciencia de datos.

# Useful SageMaker variables - Create a Pipeline session which will lazy init resources
session = PipelineSession()

framework_version = "0.23-1"

# Create SKlearn processor object,
# The object contains information about what instance type to use, the IAM role to use etc.
# A managed processor comes with a preconfigured container, so only specifying version is required.
sklearn_processor = SKLearnProcessor(
    framework_version=framework_version,
    role=role,
    instance_type=processing_instance_type,
    instance_count=1,
    base_job_name="tf2-california-housing-processing-job",
    sagemaker_session=session
)

# Use the sklearn_processor in a SageMaker pipelines ProcessingStep
step_preprocess_data = ProcessingStep(
    name="Preprocess-California-Housing-Data",
    processor=sklearn_processor,
    inputs=[
        ProcessingInput(source=input_data, destination="/opt/ml/processing/input"),
    ],
    outputs=[
        ProcessingOutput(output_name="train", source="/opt/ml/processing/train"),
        ProcessingOutput(output_name="test", source="/opt/ml/processing/test"),
    ],
    code="preprocess.py",
)

Necesitamos una clave KMS personalizada para cifrar el modelo mientras lo almacena en Amazon S3. Ver el siguiente código:

kms_client = boto3.client('kms')
response = kms_client.describe_key(
    KeyId='alias/sagemaker/outkey',
)
key_id = response['KeyMetadata']['KeyId']

Para entrenar el modelo, creamos un objeto estimador de TensorFlow. Le pasamos el ID de la clave KMS junto con nuestro script de entrenamiento train.py, tipo de instancia de entrenamiento y recuento. También creamos un TrainingStep para agregar a nuestra canalización y agregarle el estimador TensorFlow. Ver el siguiente código:

model_path = f"s3://{bucket}/{prefix}/model/"

hyperparameters = {"epochs": training_epochs}
tensorflow_version = "2.4.1"
python_version = "py37"

tf2_estimator = TensorFlow(
    source_dir="code",
    entry_point="train.py",
    instance_type=training_instance_type,
    instance_count=1,
    framework_version=tensorflow_version,
    role=role,
    base_job_name="tf2-california-housing-train",
    output_path=model_path,
    output_kms_key=key_id,
    hyperparameters=hyperparameters,
    py_version=python_version,
    sagemaker_session=session
)

# Use the tf2_estimator in a SageMaker pipelines ProcessingStep.
# NOTE how the input to the training job directly references the output of the previous step.
step_train_model = TrainingStep(
    name="Train-California-Housing-Model",
    estimator=tf2_estimator,
    inputs={
        "train": TrainingInput(
            s3_data=step_preprocess_data.properties.ProcessingOutputConfig.Outputs[
                "train"
            ].S3Output.S3Uri,
            content_type="text/csv",
        ),
        "test": TrainingInput(
            s3_data=step_preprocess_data.properties.ProcessingOutputConfig.Outputs[
                "test"
            ].S3Output.S3Uri,
            content_type="text/csv",
        ),
    },
)

Además del entrenamiento, necesitamos llevar a cabo una evaluación del modelo, para lo cual usamos el error cuadrático medio (MSE) como métrica en este ejemplo. los cuaderno anterior también genera evaluate.py, que usamos para evaluar nuestro modelo usando MSE. También creamos un ProcessingStep para inicializar el script de evaluación del modelo utilizando un SKLearnProcessor objeto. El siguiente código crea este paso:

from sagemaker.workflow.properties import PropertyFile

# Create SKLearnProcessor object.
# The object contains information about what container to use, what instance type etc.
evaluate_model_processor = SKLearnProcessor(
    framework_version=framework_version,
    instance_type=processing_instance_type,
    instance_count=1,
    base_job_name="tf2-california-housing-evaluate",
    role=role,
    sagemaker_session=session
)

# Create a PropertyFile
# A PropertyFile is used to be able to reference outputs from a processing step, for instance to use in a condition step.
# For more information, visit https://docs.aws.amazon.com/sagemaker/latest/dg/build-and-manage-propertyfile.html
evaluation_report = PropertyFile(
    name="EvaluationReport", output_name="evaluation", path="evaluation.json"
)

# Use the evaluate_model_processor in a SageMaker pipelines ProcessingStep.
step_evaluate_model = ProcessingStep(
    name="Evaluate-California-Housing-Model",
    processor=evaluate_model_processor,
    inputs=[
        ProcessingInput(
            source=step_train_model.properties.ModelArtifacts.S3ModelArtifacts,
            destination="/opt/ml/processing/model",
        ),
        ProcessingInput(
            source=step_preprocess_data.properties.ProcessingOutputConfig.Outputs[
                "test"
            ].S3Output.S3Uri,
            destination="/opt/ml/processing/test",
        ),
    ],
    outputs=[
        ProcessingOutput(output_name="evaluation", source="/opt/ml/processing/evaluation"),
    ],
    code="evaluate.py",
    property_files=[evaluation_report],
)

Después de la evaluación del modelo, también necesitamos un paso para registrar nuestro modelo con el registro de modelos, si el rendimiento del modelo cumple con los requisitos. Esto se muestra en el siguiente código usando el RegisterModel paso. Aquí necesitamos especificar el paquete modelo que habíamos declarado en la cuenta de servicios compartidos. Reemplace el paquete Región, cuenta y modelo con sus valores. El nombre del modelo utilizado aquí es modeltest, pero puede usar cualquier nombre de su elección.

# Create ModelMetrics object using the evaluation report from the evaluation step
# A ModelMetrics object contains metrics captured from a model.
model_metrics = ModelMetrics(
    model_statistics=MetricsSource(
        s3_uri=evaluation_s3_uri,
        content_type="application/json",
    )
)

# Create a RegisterModel step, which registers the model with SageMaker Model Registry.
model = Model(
    image_uri=tf2_estimator.training_image_uri(),
    model_data=training_step.properties.ModelArtifacts.S3ModelArtifacts,
    source_dir=tf2_estimator.source_dir,
    entry_point=tf2_estimator.entry_point,
    role=role_arn,
    sagemaker_session=session
)

model_registry_args = model.register(
    content_types=['text/csv'],
    response_types=['application/json'],
    inference_instances=['ml.t2.medium', 'ml.m5.xlarge'],
    transform_instances=['ml.m5.xlarge'],
    model_package_group_name=model_package_group_name,
    approval_status='PendingManualApproval',
    model_metrics=model_metrics
)

 step_register_model= ModelStep(
    name='RegisterModel',
    step_args=model_registry_args
)

También necesitamos crear los artefactos del modelo para que se pueda implementar (usando la otra cuenta). Para crear el modelo, creamos un CreateModelStep, como se muestra en el siguiente código:

from sagemaker.inputs import CreateModelInput 
from sagemaker.workflow.model_step import ModelStep 
step_create_model = ModelStep( 
    name="Create-California-Housing-Model", 
    step_args=model.create(instance_type="ml.m5.large",accelerator_type="ml.eia1.medium"),
 )

La adición de condiciones a la canalización se realiza con un ConditionStep. En este caso, solo queremos registrar la nueva versión del modelo con el registro de modelos si el nuevo modelo cumple con una condición de precisión. Ver el siguiente código:

from sagemaker.workflow.conditions import ConditionLessThanOrEqualTo
from sagemaker.workflow.condition_step import (
    ConditionStep,
    JsonGet,
)

# Create accuracy condition to ensure the model meets performance requirements.
# Models with a test accuracy lower than the condition will not be registered with the model registry.
cond_lte = ConditionLessThanOrEqualTo(
    left=JsonGet(
        step=step_evaluate_model,
        property_file=evaluation_report,
        json_path="regression_metrics.mse.value",
    ),
    right=accuracy_mse_threshold,
)

# Create a SageMaker Pipelines ConditionStep, using the preceding condition.
# Enter the steps to perform if the condition returns True / False.
step_cond = ConditionStep(
    name="MSE-Lower-Than-Threshold-Condition",
    conditions=[cond_lte],
    if_steps=[step_register_model, step_create_model],
    else_steps=[step_higher_mse_send_email_lambda],
)

Finalmente, queremos orquestar todos los pasos de la canalización para que la canalización pueda inicializarse:

from sagemaker.workflow.pipeline import Pipeline

# Create a SageMaker Pipeline.
# Each parameter for the pipeline must be set as a parameter explicitly when the pipeline is created.
# Also pass in each of the preceding steps.
# Note that the order of execution is determined from each step's dependencies on other steps,
# not on the order they are passed in.
pipeline = Pipeline(
    name=pipeline_name,
    parameters=[
        processing_instance_type,
        training_instance_type,
        input_data,
        training_epochs,
        accuracy_mse_threshold,
        endpoint_instance_type,
    ],
    steps=[step_preprocess_data, step_train_model, step_evaluate_model, step_cond],
)

Implementar una versión del modelo desde una cuenta diferente

Ahora que el modelo se ha registrado en la cuenta de servicios compartidos, debemos implementarlo en nuestras cuentas de carga de trabajo mediante la canalización de CI/CD en la cuenta de implementación. Ya hemos configurado el rol y la política en un paso anterior. Usamos el ARN del paquete del modelo para implementar el modelo desde el registro del modelo. El siguiente código se ejecuta en la cuenta de implementación y se usa para implementar modelos aprobados para control de calidad y producción:

from sagemaker import ModelPackage
from time import gmtime, strftime

sagemaker_session = sagemaker.Session(boto_session=sess)

model_package_arn = 'arn:aws:sagemaker:::/modeltest/version_number'
model = ModelPackage(role=role, 
                     model_package_arn=model_package_arn, 
                     sagemaker_session=sagemaker_session)
model.deploy(initial_instance_count=1, instance_type='ml.m5.xlarge')

Conclusión

En esta publicación, demostramos cómo configurar las políticas necesarias para una configuración de múltiples cuentas para ML según el principio de privilegio mínimo. Luego mostramos el proceso de construcción y entrenamiento de los modelos en la cuenta de ciencia de datos. Finalmente, usamos la canalización de CI/CD en la cuenta de implementación para implementar la última versión de los modelos aprobados en las cuentas de control de calidad y producción. Además, puede ver el historial de implementación de los modelos y construir disparadores in Construcción de código AWS.

Puede escalar los conceptos en esta publicación para alojar modelos en Nube informática elástica de Amazon (Amazon EC2) o Servicio Amazon Elastic Kubernetes (Amazon EKS), así como construir una canalización de inferencia por lotes.

Para obtener más información sobre cómo tener cuentas separadas que crean modelos ML en AWS, consulte Prácticas recomendadas para unidades organizativas con AWS Organizations y Actualice de forma segura los modelos en producción.

Acerca de los autores

Sandeep Verma es Arquitecto sénior de creación de prototipos en AWS. Le gusta profundizar en los desafíos de los clientes y crear prototipos para que los clientes aceleren la innovación. Tiene experiencia en IA/ML, es fundador de New Knowledge y, en general, es un apasionado de la tecnología. En su tiempo libre le encanta viajar y esquiar con su familia.

 Mani Januja es un especialista en inteligencia artificial y aprendizaje automático SA en Amazon Web Services (AWS). Ayuda a los clientes a utilizar el aprendizaje automático para resolver sus desafíos comerciales mediante AWS. Pasa la mayor parte de su tiempo profundizando y enseñando a los clientes sobre proyectos de IA / ML relacionados con la visión por computadora, el procesamiento del lenguaje natural, la previsión, el aprendizaje automático en el borde y más. Le apasiona el aprendizaje automático en el borde, por lo que ha creado su propio laboratorio con un kit de conducción autónoma y una línea de producción de fabricación de prototipos, donde pasa gran parte de su tiempo libre.

saumitra vikram es desarrollador de software en el equipo de Amazon SageMaker y tiene su sede en Chennai, India. Fuera del trabajo, le encanta correr, hacer senderismo y andar en moto por el Himalaya.

Sredevi Srinivasan es líder en ingeniería en AWS SageMaker. Le apasiona y emociona habilitar ML como una plataforma que está configurada para transformar la vida cotidiana. Actualmente se enfoca en SageMaker Feature Store. En su tiempo libre le gusta pasar tiempo con su familia.

Rupinder Grewal es un Arquitecto de Soluciones Sr. Ai/ML Especialista con AWS. Actualmente se enfoca en servir modelos y MLOps en SageMaker. Antes de este cargo, trabajó como ingeniero de aprendizaje automático creando y alojando modelos. Fuera del trabajo, le gusta jugar tenis y andar en bicicleta por senderos de montaña.

Farooq Sabir es arquitecto sénior de soluciones especialista en inteligencia artificial y aprendizaje automático en AWS. Tiene un doctorado y una maestría en ingeniería eléctrica de la Universidad de Texas en Austin y una maestría en informática del Instituto de Tecnología de Georgia. En AWS, ayuda a los clientes a formular y resolver sus problemas comerciales en ciencia de datos, aprendizaje automático, visión artificial, inteligencia artificial, optimización numérica y dominios relacionados. Tiene más de 16 años de experiencia laboral y también es miembro adjunto de la facultad en la Universidad de Texas en Dallas, donde imparte un curso de posgrado sobre aprendizaje automático aplicado. Con sede en Dallas, Texas, a él y a su familia les encanta viajar y hacer viajes largos por carretera.