Организуйте рабочие процессы машинного обучения на основе Ray с помощью Amazon SageMaker | Веб-сервисы Amazon

Машинное обучение (МО) становится все более сложным, поскольку клиенты пытаются решать все более сложные задачи. Эта сложность часто приводит к необходимости распределенного машинного обучения, когда для обучения одной модели используется несколько машин. Хотя это позволяет распараллеливать задачи на нескольких узлах, что приводит к ускорению времени обучения, повышению масштабируемости и производительности, при эффективном использовании распределенного оборудования возникают серьезные проблемы. Специалистам по данным приходится решать такие проблемы, как разделение данных, балансировка нагрузки, отказоустойчивость и масштабируемость. Инженерам машинного обучения приходится вручную обрабатывать распараллеливание, планирование, ошибки и повторные попытки, что требует сложного инфраструктурного кода.

В этой статье мы обсудим преимущества использования луч и Создатель мудреца Амазонки для распределенного машинного обучения и предоставить пошаговое руководство по использованию этих платформ для создания и развертывания масштабируемого рабочего процесса машинного обучения.

Ray, среда распределенных вычислений с открытым исходным кодом, предоставляет гибкую основу для распределенного обучения и обслуживания моделей машинного обучения. Он абстрагирует низкоуровневые детали распределенной системы с помощью простых масштабируемых библиотек для общих задач машинного обучения, таких как предварительная обработка данных, распределенное обучение, настройка гиперпараметров, обучение с подкреплением и обслуживание моделей.

SageMaker — это полностью управляемый сервис для создания, обучения и развертывания моделей машинного обучения. Ray легко интегрируется с функциями SageMaker для создания и развертывания сложных рабочих нагрузок машинного обучения, которые являются одновременно эффективными и надежными. Комбинация Ray и SageMaker обеспечивает комплексные возможности для масштабируемых рабочих процессов машинного обучения и имеет следующие основные функции:

• Распределенные актеры и конструкции параллелизма в Ray упрощают разработку распределенных приложений.
• Ray AI Runtime (AIR) упрощает переход от разработки к производству. С помощью Ray и AIR один и тот же код Python можно легко масштабировать с ноутбука на большой кластер.
• Управляемая инфраструктура SageMaker и такие функции, как задания обработки, задания обучения и задания настройки гиперпараметров, могут использовать библиотеки Ray для распределенных вычислений.
• Эксперименты с Amazon SageMaker позволяет быстро повторять и отслеживать испытания.
• Магазин функций Amazon SageMaker предоставляет масштабируемый репозиторий для хранения, извлечения и совместного использования функций машинного обучения для обучения моделей.
• Обученные модели можно хранить, управлять их версиями и отслеживать в Реестр моделей Amazon SageMaker для руководства и управления.

• Конвейеры Amazon SageMaker позволяет организовать сквозной жизненный цикл машинного обучения, от подготовки данных и обучения до моделирования развертывания в виде автоматизированных рабочих процессов.

Обзор решения

В этом посте основное внимание уделяется преимуществам совместного использования Ray и SageMaker. Мы настроили сквозной рабочий процесс машинного обучения на основе Ray, организованный с помощью SageMaker Pipelines. Рабочий процесс включает в себя параллельную загрузку данных в хранилище объектов с помощью актеров Ray, предварительную обработку данных с помощью Ray Data, обучение моделей и масштабную настройку гиперпараметров с помощью Ray Train и заданий по настройке оптимизации гиперпараметров (HPO), а также, наконец, оценку модели и регистрацию модели в реестр моделей.

Для наших данных мы используем набор данных о синтетическом жилье который состоит из восьми функций (YEAR_BUILT, SQUARE_FEET, NUM_BEDROOM, NUM_BATHROOMS, LOT_ACRES, GARAGE_SPACES, FRONT_PORCHи DECK), и наша модель предскажет PRICE дома.

Каждый этап рабочего процесса машинного обучения разбит на отдельные этапы с собственным сценарием, принимающим входные и выходные параметры. В следующем разделе мы выделим ключевые фрагменты кода каждого шага. Полный код можно найти на сайте Репозиторий aws-samples-for-ray на GitHub.

Предпосылки

Чтобы использовать SageMaker Python SDK и запустить код, связанный с этой публикацией, вам необходимы следующие предварительные условия:

Загрузка данных в хранилище функций SageMaker

Первым шагом в рабочем процессе ML является чтение файла исходных данных из Простой сервис хранения Amazon (Amazon S3) в формате CSV и вставьте его в хранилище функций SageMaker. SageMaker Feature Store — это специально созданный репозиторий, который позволяет командам легко создавать, совместно использовать и управлять функциями машинного обучения. Это упрощает обнаружение, повторное использование и совместное использование функций, что приводит к ускорению разработки, расширению сотрудничества внутри команд клиентов и снижению затрат.

Вставка функций в хранилище функций состоит из следующих шагов:

1. Определите группу функций и создайте ее в хранилище функций.
2. Подготовьте исходные данные для хранилища объектов, добавив время события и идентификатор записи для каждой строки данных.
3. Вставьте подготовленные данные в группу функций с помощью Boto3 SDK.

В этом разделе мы выделяем только Шаг 3, поскольку именно эта часть включает параллельную обработку задачи приема с использованием Ray. Полный код этого процесса можно просмотреть в разделе Репо GitHub.

Ассоциация ingest_features метод определен внутри класса с именем Featurestore, Обратите внимание, что Featurestore класс украшен @ray.remote. Это указывает на то, что экземпляр этого класса является актером Ray, параллельной вычислительной единицей с отслеживанием состояния внутри Ray. Это модель программирования, которая позволяет создавать распределенные объекты, которые поддерживают внутреннее состояние и к которым могут одновременно обращаться несколько задач, выполняющихся на разных узлах кластера Ray. Актеры предоставляют способ управления и инкапсуляции изменяемого состояния, что делает их ценными для создания сложных приложений с отслеживанием состояния в распределенной среде. Вы также можете указать требования к ресурсам в актерах. В этом случае каждый экземпляр FeatureStore для класса потребуется 0.5 процессора. См. следующий код:

@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. """ ...

Вы можете взаимодействовать с актером, вызвав remote оператор. В следующем коде желаемое количество актеров передается в качестве входного аргумента сценария. Затем данные секционируются в зависимости от количества участников и передаются удаленным параллельным процессам для загрузки в хранилище функций. Вы можете позвонить get по ссылке на объект, чтобы заблокировать выполнение текущей задачи до тех пор, пока удаленное вычисление не будет завершено и результат не станет доступен. Когда результат будет доступен, ray.get вернет результат, и выполнение текущей задачи продолжится.

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)

Подготовьте данные для обучения, проверки и тестирования.

На этом этапе мы используем Ray Dataset для эффективного разделения, преобразования и масштабирования нашего набора данных при подготовке к машинному обучению. Ray Dataset предоставляет стандартный способ загрузки распределенных данных в Ray, поддерживая различные системы хранения и форматы файлов. Он имеет API для распространенных операций предварительной обработки данных ML, таких как параллельные преобразования, перетасовка, группировка и агрегирование. Ray Dataset также обрабатывает операции, требующие настройки с отслеживанием состояния и ускорения графического процессора. Он легко интегрируется с другими библиотеками обработки данных, такими как Spark, Pandas, NumPy и другими, а также с платформами машинного обучения, такими как TensorFlow и PyTorch. Это позволяет создавать сквозные конвейеры данных и рабочие процессы машинного обучения поверх Ray. Цель — упростить распределенную обработку данных и машинное обучение для практиков и исследователей.

Давайте рассмотрим разделы скриптов, выполняющих эту предварительную обработку данных. Начнем с загрузки данных из хранилища объектов:

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

Затем мы разделяем и масштабируем данные, используя абстракции более высокого уровня, доступные в ray.data библиотека:

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

Обработанные наборы данных поезда, проверки и тестирования хранятся в Amazon S3 и будут передаваться в качестве входных параметров на последующие этапы.

Выполнение обучения модели и оптимизации гиперпараметров.

Когда наши данные предварительно обработаны и готовы к моделированию, пришло время обучить некоторые модели машинного обучения и точно настроить их гиперпараметры, чтобы максимизировать эффективность прогнозирования. Мы используем XGBoost-Ray, распределенный бэкэнд для XGBoost, созданный на основе Ray, который позволяет обучать модели XGBoost на больших наборах данных с использованием нескольких узлов и графических процессоров. Он обеспечивает простую замену API-интерфейсов XGBoost для обучения и прогнозирования, одновременно справляясь со сложностями управления распределенными данными и обучения под капотом.

Чтобы обеспечить распределение обучения по нескольким узлам, мы используем вспомогательный класс с именем РэйХелпер. Как показано в следующем коде, мы используем конфигурацию ресурсов задания обучения и выбираем первый хост в качестве головного узла:

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"])

Мы можем использовать информацию о хосте, чтобы решить, как инициализировать Ray в каждом экземпляре обучающего задания:

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)

Когда запускается задание обучения, кластер Ray можно инициализировать, вызвав метод start_ray() метод на экземпляре RayHelper:

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

Затем мы используем для обучения трейнер XGBoost от XGBoost-Ray:

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)

Обратите внимание, что при создании экземпляра trainer, мы проходим RayParams, который принимает количество актеров и количество процессоров на каждого актера. XGBoost-Ray использует эту информацию для распределения обучения по всем узлам, подключенным к кластеру Ray.

Теперь мы создаем объект оценки XGBoost на основе SageMaker Python SDK и используем его для задания HPO.

Организуйте предыдущие шаги с помощью конвейеров SageMaker.

Чтобы построить сквозной масштабируемый и многократно используемый рабочий процесс машинного обучения, нам нужно использовать инструмент CI/CD для организации предыдущих шагов в конвейер. SageMaker Pipelines напрямую интегрируется с SageMaker, SageMaker Python SDK и SageMaker Studio. Эта интеграция позволяет создавать рабочие процессы машинного обучения с помощью простого в использовании Python SDK, а затем визуализировать рабочий процесс и управлять им с помощью SageMaker Studio. Вы также можете отслеживать историю ваших данных в ходе выполнения конвейера и назначать шаги для кэширования.

SageMaker Pipelines создает направленный ациклический граф (DAG), который включает шаги, необходимые для построения рабочего процесса машинного обучения. Каждый конвейер представляет собой серию взаимосвязанных шагов, организованных зависимостями данных между шагами, и может быть параметризован, что позволяет вам предоставлять входные переменные в качестве параметров для каждого запуска конвейера. SageMaker Pipelines имеет четыре типа параметров конвейера: ParameterString, ParameterInteger, ParameterFloatи ParameterBoolean. В этом разделе мы параметризуем некоторые входные переменные и настраиваем конфигурацию кэширования шагов:

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")

Мы определяем два этапа обработки: один для приема данных из хранилища функций SageMaker, другой для подготовки данных. Это должно выглядеть очень похоже на предыдущие шаги, описанные ранее. Единственная новая строка кода — это ProcessingStep после определения шагов, что позволяет нам взять конфигурацию задания обработки и включить ее в качестве шага конвейера. Далее мы указываем зависимость этапа подготовки данных от этапа приема SageMaker Feature Store. См. следующий код:

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])

Аналогично, чтобы построить этап обучения и настройки модели, нам нужно добавить определение TuningStep после кода шага обучения модели, чтобы мы могли запустить настройку гиперпараметров SageMaker в качестве шага конвейера:

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])

После этапа настройки мы решаем зарегистрировать лучшую модель в реестре моделей SageMaker. Чтобы контролировать качество модели, мы реализуем минимальный шлюз качества, который сравнивает объективную метрику лучшей модели (RMSE) с порогом, определенным как входной параметр конвейера. rmse_threshold. Чтобы выполнить эту оценку, мы создаем еще один этап обработки для запуска сценарий оценки. Результат оценки модели будет сохранен в виде файла свойств. Файлы свойств особенно полезны при анализе результатов шага обработки, чтобы решить, как следует выполнять другие шаги. См. следующий код:

# 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],
)

Мы определяем ModelStep зарегистрировать лучшую модель в реестре моделей SageMaker в нашем конвейере. В случае, если лучшая модель не проходит заданную нами проверку качества, мы дополнительно указываем FailStep для вывода сообщения об ошибке:

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]),
)

Далее мы используем ConditionStep чтобы оценить, следует ли предпринять следующий шаг в конвейере: шаг регистрации модели или шаг отказа. В нашем случае лучшая модель будет зарегистрирована, если ее показатель RMSE ниже порогового значения.

# 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],
)

Наконец, мы объединяем все определенные шаги в конвейер:

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)

Предыдущий конвейер можно визуализировать и выполнить непосредственно в SageMaker Studio или выполнить, вызвав execution = training_pipeline.start(). На следующем рисунке показан поток конвейера.

Кроме того, мы можем просмотреть происхождение артефактов, созданных при выполнении конвейера.

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)

Развернуть модель

После того как лучшая модель зарегистрирована в реестре моделей SageMaker посредством запуска конвейера, мы развертываем модель на конечной точке в реальном времени, используя полностью управляемые возможности развертывания модели SageMaker. В SageMaker есть другие варианты развертывания моделей для удовлетворения потребностей различных сценариев использования. Подробности см. Развертывание моделей для вывода при выборе правильного варианта для вашего случая использования. Сначала давайте зарегистрируем модель в реестре моделей SageMaker:

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

Текущий статус модели PendingApproval. Нам нужно установить его статус Approved до развертывания:

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
)

Убирать

После завершения экспериментов не забудьте очистить ресурсы, чтобы избежать ненужных расходов. Чтобы очистить, удалите конечную точку реального времени, группу моделей, конвейер и группу функций, вызвав API. Удалить конечную точку, УдалитьМодельПакажеГрупп, Удалить конвейери Удалить группу объектовсоответственно, и завершите работу всех экземпляров блокнотов SageMaker Studio.

Заключение

В этом посте продемонстрировано пошаговое руководство по использованию конвейеров SageMaker для организации рабочих процессов машинного обучения на основе Ray. Мы также продемонстрировали возможность интеграции SageMaker Pipelines со сторонними инструментами машинного обучения. Существуют различные сервисы AWS, которые поддерживают рабочие нагрузки Ray масштабируемым и безопасным способом, обеспечивая превосходную производительность и эффективность работы. Теперь ваша очередь изучить эти мощные возможности и начать оптимизировать рабочие процессы машинного обучения с помощью Amazon SageMaker Pipelines и Ray. Примите меры сегодня и раскройте весь потенциал своих проектов машинного обучения!

---

Об авторе

Раджу Ранган — старший архитектор решений в Amazon Web Services (AWS). Он работает с организациями, спонсируемыми государством, помогая им создавать решения AI/ML с использованием AWS. Когда он не возится с облачными решениями, вы застанете его гуляющим с семьей или разбивающим птичек в оживленной игре в бадминтон с друзьями.

Шерри Дин является старшим архитектором решений AI/ML в Amazon Web Services (AWS). Она имеет большой опыт в области машинного обучения и имеет степень доктора компьютерных наук. В основном она работает с клиентами из государственного сектора над различными бизнес-задачами, связанными с искусственным интеллектом и машинным обучением, помогая им ускорить процесс машинного обучения в облаке AWS. Когда она не помогает клиентам, она любит активный отдых.

• SEO-контент и PR-распределение. Получите усиление сегодня.
• PlatoData.Network Вертикальный генеративный ИИ. Расширьте возможности себя. Доступ здесь.
• ПлатонАйСтрим. Интеллект Web3. Расширение знаний. Доступ здесь.
• ПлатонЭСГ. Углерод, чистые технологии, Энергия, Окружающая среда, Солнечная, Управление отходами. Доступ здесь.
• ПлатонЗдоровье. Биотехнологии и клинические исследования. Доступ здесь.
• Смещения блоков. Модернизация права собственности на экологические компенсации. Доступ здесь.
• Источник: https://aws.amazon.com/blogs/machine-learning/orchestrate-ray-based-machine-learning-workflows-using-amazon-sagemaker/