Orquestre fluxos de trabalho de machine learning baseados em Ray usando Amazon SageMaker | Amazon Web Services

O aprendizado de máquina (ML) está se tornando cada vez mais complexo à medida que os clientes tentam resolver problemas cada vez mais desafiadores. Essa complexidade muitas vezes leva à necessidade de ML distribuído, onde várias máquinas são usadas para treinar um único modelo. Embora isso permita a paralelização de tarefas em vários nós, levando a tempos de treinamento acelerados, maior escalabilidade e melhor desempenho, existem desafios significativos no uso eficaz de hardware distribuído. Os cientistas de dados precisam enfrentar desafios como particionamento de dados, balanceamento de carga, tolerância a falhas e escalabilidade. Os engenheiros de ML devem lidar com paralelização, agendamento, falhas e novas tentativas manualmente, exigindo código de infraestrutura complexo.

Neste post, discutimos os benefícios de usar Raio e Amazon Sage Maker para ML distribuído e fornece um guia passo a passo sobre como usar essas estruturas para criar e implantar um fluxo de trabalho de ML escalonável.

Ray, uma estrutura de computação distribuída de código aberto, fornece uma estrutura flexível para treinamento distribuído e serviço de modelos de ML. Ele abstrai detalhes de sistema distribuído de baixo nível por meio de bibliotecas simples e escalonáveis ​​para tarefas comuns de ML, como pré-processamento de dados, treinamento distribuído, ajuste de hiperparâmetros, aprendizado por reforço e serviço de modelo.

SageMaker é um serviço totalmente gerenciado para construção, treinamento e implantação de modelos de ML. Ray se integra perfeitamente aos recursos do SageMaker para criar e implantar cargas de trabalho complexas de ML que sejam eficientes e confiáveis. A combinação de Ray e SageMaker fornece recursos completos para fluxos de trabalho de ML escalonáveis ​​e possui os seguintes recursos destacados:

• Atores distribuídos e construções de paralelismo no Ray simplificam o desenvolvimento de aplicativos distribuídos.
• Ray AI Runtime (AIR) reduz o atrito entre o desenvolvimento e a produção. Com Ray e AIR, o mesmo código Python pode ser dimensionado perfeitamente de um laptop para um grande cluster.
• A infraestrutura gerenciada do SageMaker e recursos como trabalhos de processamento, trabalhos de treinamento e trabalhos de ajuste de hiperparâmetros podem usar bibliotecas Ray subjacentes para computação distribuída.
• Experimentos Amazon SageMaker permite iterar rapidamente e acompanhar os testes.
• Loja de recursos Amazon SageMaker fornece um repositório escalonável para armazenar, recuperar e compartilhar recursos de ML para treinamento de modelo.
• Os modelos treinados podem ser armazenados, versionados e rastreados em Registro de modelos do Amazon SageMaker para governança e gestão.

• Pipelines Amazon SageMaker permite orquestrar o ciclo de vida de ML de ponta a ponta, desde a preparação e treinamento de dados até a implantação de modelos como fluxos de trabalho automatizados.

Visão geral da solução

Esta postagem enfoca os benefícios de usar Ray e SageMaker juntos. Configuramos um fluxo de trabalho de ML baseado em Ray de ponta a ponta, orquestrado usando SageMaker Pipelines. O fluxo de trabalho inclui ingestão paralela de dados no armazenamento de recursos usando atores Ray, pré-processamento de dados com Ray Data, modelos de treinamento e ajuste de hiperparâmetros em escala usando Ray Train e trabalhos de ajuste de otimização de hiperparâmetros (HPO) e, finalmente, avaliação do modelo e registro do modelo em um registro de modelo.

Para nossos dados, usamos um conjunto de dados de habitação sintético que consiste em oito recursos (YEAR_BUILT, SQUARE_FEET, NUM_BEDROOM, NUM_BATHROOMS, LOT_ACRES, GARAGE_SPACES, FRONT_PORCH e DECK) e nosso modelo irá prever o PRICE da casa.

Cada estágio do fluxo de trabalho de ML é dividido em etapas distintas, com seu próprio script que usa parâmetros de entrada e saída. Na próxima seção, destacamos trechos de código-chave de cada etapa. O código completo pode ser encontrado no repositório GitHub aws-samples-for-ray.

Pré-requisitos

Para usar o SageMaker Python SDK e executar o código associado a esta postagem, você precisa dos seguintes pré-requisitos:

Ingerir dados no SageMaker Feature Store

A primeira etapa no fluxo de trabalho de ML é ler o arquivo de dados de origem do Serviço de armazenamento simples da Amazon (Amazon S3) em formato CSV e ingeri-lo no SageMaker Feature Store. SageMaker Feature Store é um repositório desenvolvido especificamente que facilita para as equipes criar, compartilhar e gerenciar recursos de ML. Ele simplifica a descoberta, reutilização e compartilhamento de recursos, levando a um desenvolvimento mais rápido, maior colaboração entre as equipes dos clientes e custos reduzidos.

A ingestão de recursos no feature store contém as seguintes etapas:

1. Defina um grupo de recursos e crie o grupo de recursos no feature store.
2. Prepare os dados de origem para o feature store adicionando um horário de evento e um ID de registro para cada linha de dados.
3. Ingira os dados preparados no grupo de recursos usando o Boto3 SDK.

Nesta seção destacamos apenas a Etapa 3, pois esta é a parte que envolve o processamento paralelo da tarefa de ingestão usando Ray. Você pode revisar o código completo deste processo no GitHub repo.

A ingest_features método é definido dentro de uma classe chamada Featurestore. Observe que o Featurestore a aula é decorada com @ray.remote. Isso indica que uma instância desta classe é um ator Ray, uma unidade computacional simultânea e com estado dentro do Ray. É um modelo de programação que permite criar objetos distribuídos que mantêm um estado interno e podem ser acessados ​​simultaneamente por múltiplas tarefas executadas em diferentes nós em um cluster Ray. Os atores fornecem uma maneira de gerenciar e encapsular o estado mutável, tornando-os valiosos para a construção de aplicações complexas e com estado em um ambiente distribuído. Você também pode especificar requisitos de recursos em atores. Neste caso, cada instância do FeatureStore classe exigirá 0.5 CPUs. Veja o seguinte código:

@ray.remote(num_cpus=0.5)
class Featurestore: def ingest_features(self,feature_group_name, df, region): """ Ingest features to Feature Store Group Args: feature_group_name (str): Feature Group Name data_path (str): Path to the train/validation/test data in CSV format. """ ...

Você pode interagir com o ator ligando para o remote operador. No código a seguir, o número desejado de atores é passado como argumento de entrada para o script. Os dados são então particionados com base no número de atores e passados ​​para os processos paralelos remotos para serem ingeridos no feature store. Você pode ligar get no objeto ref para bloquear a execução da tarefa atual até que o cálculo remoto seja concluído e o resultado esteja disponível. Quando o resultado estiver disponível, ray.get retornará o resultado e a execução da tarefa atual continuará.

import modin.pandas as pd
import ray df = pd.read_csv(s3_path)
data = prepare_df_for_feature_store(df)
# Split into partitions
partitions = [ray.put(part) for part in np.array_split(data, num_actors)]
# Start actors and assign partitions in a loop
actors = [Featurestore.remote() for _ in range(args.num_actors)]
results = [] for actor, partition in zip(actors, input_partitions): results.append(actor.ingest_features.remote( args.feature_group_name, partition, args.region ) ) ray.get(results)

Preparar dados para treinamento, validação e teste

Nesta etapa, usamos Ray Dataset para dividir, transformar e dimensionar com eficiência nosso conjunto de dados em preparação para o aprendizado de máquina. Ray Dataset fornece uma maneira padrão de carregar dados distribuídos no Ray, suportando vários sistemas de armazenamento e formatos de arquivo. Possui APIs para operações comuns de pré-processamento de dados de ML, como transformações paralelas, embaralhamento, agrupamento e agregações. Ray Dataset também lida com operações que necessitam de configuração com estado e aceleração de GPU. Ele se integra perfeitamente com outras bibliotecas de processamento de dados como Spark, Pandas, NumPy e muito mais, bem como estruturas de ML como TensorFlow e PyTorch. Isso permite construir pipelines de dados completos e fluxos de trabalho de ML com base no Ray. O objetivo é facilitar o processamento distribuído de dados e o ML para profissionais e pesquisadores.

Vejamos seções dos scripts que realizam esse pré-processamento de dados. Começamos carregando os dados do feature store:

def load_dataset(feature_group_name, region): """ Loads the data as a ray dataset from the offline featurestore S3 location Args: feature_group_name (str): name of the feature group Returns: ds (ray.data.dataset): Ray dataset the contains the requested dat from the feature store """ session = sagemaker.Session(boto3.Session(region_name=region)) fs_group = FeatureGroup( name=feature_group_name, sagemaker_session=session ) fs_data_loc = fs_group.describe().get("OfflineStoreConfig").get("S3StorageConfig").get("ResolvedOutputS3Uri") # Drop columns added by the feature store # Since these are not related to the ML problem at hand cols_to_drop = ["record_id", "event_time","write_time", "api_invocation_time", "is_deleted", "year", "month", "day", "hour"] ds = ray.data.read_parquet(fs_data_loc) ds = ds.drop_columns(cols_to_drop) print(f"{fs_data_loc} count is {ds.count()}") return ds

Em seguida, dividimos e dimensionamos os dados usando as abstrações de nível superior disponíveis no ray.data biblioteca:

def split_dataset(dataset, train_size, val_size, test_size, random_state=None): """ Split dataset into train, validation and test samples Args: dataset (ray.data.Dataset): input data train_size (float): ratio of data to use as training dataset val_size (float): ratio of data to use as validation dataset test_size (float): ratio of data to use as test dataset random_state (int): Pass an int for reproducible output across multiple function calls. Returns: train_set (ray.data.Dataset): train dataset val_set (ray.data.Dataset): validation dataset test_set (ray.data.Dataset): test dataset """ # Shuffle this dataset with a fixed random seed. shuffled_ds = dataset.random_shuffle(seed=random_state) # Split the data into train, validation and test datasets train_set, val_set, test_set = shuffled_ds.split_proportionately([train_size, val_size]) return train_set, val_set, test_set def scale_dataset(train_set, val_set, test_set, target_col): """ Fit StandardScaler to train_set and apply it to val_set and test_set Args: train_set (ray.data.Dataset): train dataset val_set (ray.data.Dataset): validation dataset test_set (ray.data.Dataset): test dataset target_col (str): target col Returns: train_transformed (ray.data.Dataset): train data scaled val_transformed (ray.data.Dataset): val data scaled test_transformed (ray.data.Dataset): test data scaled """ tranform_cols = dataset.columns() # Remove the target columns from being scaled tranform_cols.remove(target_col) # set up a standard scaler standard_scaler = StandardScaler(tranform_cols) # fit scaler to training dataset print("Fitting scaling to training data and transforming dataset...") train_set_transformed = standard_scaler.fit_transform(train_set) # apply scaler to validation and test datasets print("Transforming validation and test datasets...") val_set_transformed = standard_scaler.transform(val_set) test_set_transformed = standard_scaler.transform(test_set) return train_set_transformed, val_set_transformed, test_set_transformed

Os conjuntos de dados de treinamento, validação e teste processados ​​são armazenados no Amazon S3 e serão transmitidos como parâmetros de entrada para etapas subsequentes.

Execute treinamento de modelo e otimização de hiperparâmetros

Com nossos dados pré-processados ​​e prontos para modelagem, é hora de treinar alguns modelos de ML e ajustar seus hiperparâmetros para maximizar o desempenho preditivo. Nós usamos XGBoost-RayName, um back-end distribuído para XGBoost baseado em Ray que permite treinar modelos XGBoost em grandes conjuntos de dados usando vários nós e GPUs. Ele fornece substituições simples para APIs de treinamento e previsão do XGBoost, ao mesmo tempo que lida com as complexidades do gerenciamento e treinamento de dados distribuídos nos bastidores.

Para permitir a distribuição do treinamento em vários nós, utilizamos uma classe auxiliar chamada RayHelper. Conforme mostrado no código a seguir, usamos a configuração de recursos do trabalho de treinamento e escolhemos o primeiro host como nó principal:

class RayHelper(): def __init__(self, ray_port:str="9339", redis_pass:str="redis_password"): .... self.resource_config = self.get_resource_config() self.head_host = self.resource_config["hosts"][0] self.n_hosts = len(self.resource_config["hosts"])

Podemos usar as informações do host para decidir como inicializar o Ray em cada uma das instâncias do trabalho de treinamento:

def start_ray(self): head_ip = self._get_ip_from_host() # If the current host is the host choosen as the head node # run `ray start` with specifying the --head flag making this is the head node if self.resource_config["current_host"] == self.head_host: output = subprocess.run(['ray', 'start', '--head', '-vvv', '--port', self.ray_port, '--redis-password', self.redis_pass, '--include-dashboard', 'false'], stdout=subprocess.PIPE) print(output.stdout.decode("utf-8")) ray.init(address="auto", include_dashboard=False) self._wait_for_workers() print("All workers present and accounted for") print(ray.cluster_resources()) else: # If the current host is not the head node, # run `ray start` with specifying ip address as the head_host as the head node time.sleep(10) output = subprocess.run(['ray', 'start', f"--address={head_ip}:{self.ray_port}", '--redis-password', self.redis_pass, "--block"], stdout=subprocess.PIPE) print(output.stdout.decode("utf-8")) sys.exit(0)

Quando um trabalho de treinamento é iniciado, um cluster Ray pode ser inicializado chamando o método start_ray() método em uma instância de RayHelper:

if __name__ == '__main__': ray_helper = RayHelper() ray_helper.start_ray() args = read_parameters() sess = sagemaker.Session(boto3.Session(region_name=args.region))

Em seguida, usamos o treinador XGBoost do XGBoost-Ray para treinamento:

def train_xgboost(ds_train, ds_val, params, num_workers, target_col = "price") -> Result: """ Creates a XGBoost trainer, train it, and return the result. Args: ds_train (ray.data.dataset): Training dataset ds_val (ray.data.dataset): Validation dataset params (dict): Hyperparameters num_workers (int): number of workers to distribute the training across target_col (str): target column Returns: result (ray.air.result.Result): Result of the training job """ train_set = RayDMatrix(ds_train, 'PRICE') val_set = RayDMatrix(ds_val, 'PRICE') evals_result = {} trainer = train( params=params, dtrain=train_set, evals_result=evals_result, evals=[(val_set, "validation")], verbose_eval=False, num_boost_round=100, ray_params=RayParams(num_actors=num_workers, cpus_per_actor=1), ) output_path=os.path.join(args.model_dir, 'model.xgb') trainer.save_model(output_path) valMAE = evals_result["validation"]["mae"][-1] valRMSE = evals_result["validation"]["rmse"][-1] print('[3] #011validation-mae:{}'.format(valMAE)) print('[4] #011validation-rmse:{}'.format(valRMSE)) local_testing = False try: load_run(sagemaker_session=sess) except: local_testing = True if not local_testing: # Track experiment if using SageMaker Training with load_run(sagemaker_session=sess) as run: run.log_metric('validation-mae', valMAE) run.log_metric('validation-rmse', valRMSE)

Observe que ao instanciar o trainer, nós passamos RayParams, que considera o número de atores e o número de CPUs por atores. O XGBoost-Ray usa essas informações para distribuir o treinamento por todos os nós anexados ao cluster Ray.

Agora criamos um objeto estimador XGBoost baseado no SageMaker Python SDK e o usamos para o trabalho HPO.

Orquestre as etapas anteriores usando SageMaker Pipelines

Para construir um fluxo de trabalho de ML escalonável e reutilizável de ponta a ponta, precisamos usar uma ferramenta de CI/CD para orquestrar as etapas anteriores em um pipeline. SageMaker Pipelines tem integração direta com SageMaker, SageMaker Python SDK e SageMaker Studio. Essa integração permite criar fluxos de trabalho de ML com um Python SDK fácil de usar e, em seguida, visualizar e gerenciar seu fluxo de trabalho usando o SageMaker Studio. Você também pode rastrear o histórico de seus dados na execução do pipeline e designar etapas para armazenamento em cache.

O SageMaker Pipelines cria um gráfico acíclico direcionado (DAG) que inclui as etapas necessárias para construir um fluxo de trabalho de ML. Cada pipeline é uma série de etapas interconectadas orquestradas por dependências de dados entre etapas e pode ser parametrizado, permitindo fornecer variáveis ​​de entrada como parâmetros para cada execução do pipeline. O SageMaker Pipelines possui quatro tipos de parâmetros de pipeline: ParameterString, ParameterInteger, ParameterFloat e ParameterBoolean. Nesta seção, parametrizamos algumas das variáveis ​​de entrada e definimos a configuração do cache da etapa:

processing_instance_count = ParameterInteger( name='ProcessingInstanceCount', default_value=1
)
feature_group_name = ParameterString( name='FeatureGroupName', default_value='fs-ray-synthetic-housing-data'
)
bucket_prefix = ParameterString( name='Bucket_Prefix', default_value='aws-ray-mlops-workshop/feature-store'
)
rmse_threshold = ParameterFloat(name="RMSEThreshold", default_value=15000.0) train_size = ParameterString( name='TrainSize', default_value="0.6"
)
val_size = ParameterString( name='ValidationSize', default_value="0.2"
)
test_size = ParameterString( name='TestSize', default_value="0.2"
) cache_config = CacheConfig(enable_caching=True, expire_after="PT12H")

Definimos duas etapas de processamento: uma para ingestão do SageMaker Feature Store e outra para preparação de dados. Isso deve ser muito semelhante às etapas anteriores descritas anteriormente. A única nova linha de código é a ProcessingStep após a definição das etapas, o que nos permite pegar a configuração do trabalho de processamento e incluí-la como etapa do pipeline. Especificamos ainda a dependência da etapa de preparação de dados na etapa de ingestão do SageMaker Feature Store. Veja o seguinte código:

feature_store_ingestion_step = ProcessingStep( name='FeatureStoreIngestion', step_args=fs_processor_args, cache_config=cache_config
) preprocess_dataset_step = ProcessingStep( name='PreprocessData', step_args=processor_args, cache_config=cache_config
)
preprocess_dataset_step.add_depends_on([feature_store_ingestion_step])

Da mesma forma, para construir uma etapa de treinamento e ajuste de modelo, precisamos adicionar uma definição de TuningStep após o código da etapa de treinamento do modelo para nos permitir executar o ajuste de hiperparâmetros do SageMaker como uma etapa do pipeline:

tuning_step = TuningStep( name="HPTuning", tuner=tuner, inputs={ "train": TrainingInput( s3_data=preprocess_dataset_step.properties.ProcessingOutputConfig.Outputs[ "train" ].S3Output.S3Uri, content_type="text/csv" ), "validation": TrainingInput( s3_data=preprocess_dataset_step.properties.ProcessingOutputConfig.Outputs[ "validation" ].S3Output.S3Uri, content_type="text/csv" ) }, cache_config=cache_config,
)
tuning_step.add_depends_on([preprocess_dataset_step])

Após a etapa de ajuste, optamos por registrar o melhor modelo no SageMaker Model Registry. Para controlar a qualidade do modelo, implementamos uma porta de qualidade mínima que compara a métrica objetiva do melhor modelo (RMSE) com um limite definido como parâmetro de entrada do pipeline rmse_threshold. Para fazer esta avaliação, criamos outra etapa de processamento para executar um roteiro de avaliação. O resultado da avaliação do modelo será armazenado como um arquivo de propriedades. Os arquivos de propriedades são particularmente úteis ao analisar os resultados de uma etapa de processamento para decidir como outras etapas devem ser executadas. Veja o seguinte código:

# Specify where we'll store the model evaluation results so that other steps can access those results
evaluation_report = PropertyFile( name='EvaluationReport', output_name='evaluation', path='evaluation.json',
) # A ProcessingStep is used to evaluate the performance of a selected model from the HPO step. # In this case, the top performing model is evaluated. evaluation_step = ProcessingStep( name='EvaluateModel', processor=evaluation_processor, inputs=[ ProcessingInput( source=tuning_step.get_top_model_s3_uri( top_k=0, s3_bucket=bucket, prefix=s3_prefix ), destination='/opt/ml/processing/model', ), ProcessingInput( source=preprocess_dataset_step.properties.ProcessingOutputConfig.Outputs['test'].S3Output.S3Uri, destination='/opt/ml/processing/test', ), ], outputs=[ ProcessingOutput( output_name='evaluation', source='/opt/ml/processing/evaluation' ), ], code='./pipeline_scripts/evaluate/script.py', property_files=[evaluation_report],
)

Nós definimos um ModelStep para registrar o melhor modelo no SageMaker Model Registry em nosso pipeline. Caso o melhor modelo não passe em nossa verificação de qualidade pré-determinada, especificamos adicionalmente um FailStep para gerar uma mensagem de erro:

register_step = ModelStep( name='RegisterTrainedModel', step_args=model_registry_args
) metrics_fail_step = FailStep( name="RMSEFail", error_message=Join(on=" ", values=["Execution failed due to RMSE >", rmse_threshold]),
)

A seguir, usamos um ConditionStep para avaliar se a etapa de registro do modelo ou a etapa de falha deve ser executada a seguir no pipeline. No nosso caso, o melhor modelo será registrado se sua pontuação RMSE for inferior ao limite.

# Condition step for evaluating model quality and branching execution
cond_lte = ConditionLessThanOrEqualTo( left=JsonGet( step_name=evaluation_step.name, property_file=evaluation_report, json_path='regression_metrics.rmse.value', ), right=rmse_threshold,
)
condition_step = ConditionStep( name='CheckEvaluation', conditions=[cond_lte], if_steps=[register_step], else_steps=[metrics_fail_step],
)

Finalmente, orquestramos todas as etapas definidas em um pipeline:

pipeline_name = 'synthetic-housing-training-sm-pipeline-ray'
step_list = [ feature_store_ingestion_step, preprocess_dataset_step, tuning_step, evaluation_step, condition_step ] training_pipeline = Pipeline( name=pipeline_name, parameters=[ processing_instance_count, feature_group_name, train_size, val_size, test_size, bucket_prefix, rmse_threshold ], steps=step_list
) # Note: If an existing pipeline has the same name it will be overwritten.
training_pipeline.upsert(role_arn=role_arn)

O pipeline anterior pode ser visualizado e executado diretamente no SageMaker Studio ou executado chamando execution = training_pipeline.start(). A figura a seguir ilustra o fluxo do pipeline.

Além disso, podemos revisar a linhagem de artefatos gerados pela execução do pipeline.

from sagemaker.lineage.visualizer import LineageTableVisualizer viz = LineageTableVisualizer(sagemaker.session.Session())
for execution_step in reversed(execution.list_steps()): print(execution_step) display(viz.show(pipeline_execution_step=execution_step)) time.sleep(5)

Implantar o modelo

Depois que o melhor modelo for registrado no SageMaker Model Registry por meio de uma execução de pipeline, implantamos o modelo em um endpoint em tempo real usando os recursos de implantação de modelo totalmente gerenciados do SageMaker. O SageMaker possui outras opções de implantação de modelo para atender às necessidades de diferentes casos de uso. Para obter detalhes, consulte Implantar modelos para inferência ao escolher a opção certa para seu caso de uso. Primeiro, vamos registrar o modelo no SageMaker Model Registry:

xgb_regressor_model = ModelPackage( role_arn, model_package_arn=model_package_arn, name=model_name
)

O status atual do modelo é PendingApproval. Precisamos definir seu status para Approved antes da implantação:

sagemaker_client.update_model_package( ModelPackageArn=xgb_regressor_model.model_package_arn, ModelApprovalStatus='Approved'
) xgb_regressor_model.deploy( initial_instance_count=1, instance_type='ml.m5.xlarge', endpoint_name=endpoint_name
)

limpar

Depois de terminar os experimentos, lembre-se de limpar os recursos para evitar cobranças desnecessárias. Para limpar, exclua o endpoint em tempo real, o grupo de modelos, o pipeline e o grupo de recursos chamando as APIs ExcluirEndpoint, ExcluirModelPackageGroup, ExcluirPipeline e ExcluirFeatureGroup, respectivamente, e desligue todas as instâncias de notebook do SageMaker Studio.

Conclusão

Esta postagem demonstrou um passo a passo sobre como usar o SageMaker Pipelines para orquestrar fluxos de trabalho de ML baseados em Ray. Também demonstramos a capacidade do SageMaker Pipelines de integração com ferramentas de ML de terceiros. Existem vários serviços da AWS que oferecem suporte a cargas de trabalho Ray de maneira escalonável e segura para garantir excelência de desempenho e eficiência operacional. Agora é sua vez de explorar esses recursos avançados e começar a otimizar seus fluxos de trabalho de machine learning com Amazon SageMaker Pipelines e Ray. Entre em ação hoje e libere todo o potencial de seus projetos de ML!

---

Sobre o autor

Raju Rangan é arquiteto de soluções sênior na Amazon Web Services (AWS). Ele trabalha com entidades patrocinadas pelo governo, ajudando-as a criar soluções de IA/ML usando AWS. Quando não estiver brincando com soluções em nuvem, você o verá saindo com a família ou quebrando passarinhos em uma animada partida de badminton com os amigos.

Sherry Ding é arquiteto sênior de soluções especializadas em IA/ML na Amazon Web Services (AWS). Ela tem vasta experiência em aprendizado de máquina com doutorado em ciência da computação. Ela trabalha principalmente com clientes do setor público em vários desafios de negócios relacionados à IA/ML, ajudando-os a acelerar sua jornada de aprendizado de máquina na Nuvem AWS. Quando não está atendendo os clientes, ela gosta de atividades ao ar livre.

• Conteúdo com tecnologia de SEO e distribuição de relações públicas. Seja amplificado hoje.
• PlatoData.Network Gerativa Vertical Ai. Capacite-se. Acesse aqui.
• PlatoAiStream. Inteligência Web3. Conhecimento Amplificado. Acesse aqui.
• PlatãoESG. Carbono Tecnologia Limpa, Energia, Ambiente, Solar, Gestão de resíduos. Acesse aqui.
• PlatoHealth. Inteligência em Biotecnologia e Ensaios Clínicos. Acesse aqui.
• BlockOffsets. Modernizando a Propriedade de Compensação Ambiental. Acesse aqui.
• Fonte: https://aws.amazon.com/blogs/machine-learning/orchestrate-ray-based-machine-learning-workflows-using-amazon-sagemaker/