Реализуйте автоматическую настройку модели Amazon SageMaker с использованием выбранных заранее алгоритмов

Улучшите модель Amazon SageMaker с помощью автоматической настройки и выбранных алгоритмов

Автоматический машинный обучение (AutoML) позволяет получать быстрые и общие выводы из данных прямо на начальном этапе жизненного цикла проекта по машинному обучению (ML). Понимание того, какие методы предварительной обработки и типы алгоритмов дадут наилучшие результаты, сокращает время разработки, обучения и развертывания подходящей модели. Он играет важную роль в процессе разработки каждой модели и позволяет научным работникам данных сосредоточиться на наиболее многообещающих методах ML. Кроме того, AutoML предоставляет базовую производительность модели, которая может служить эталоном для команды по научному исследованию данных.

Инструмент AutoML применяет комбинацию разных алгоритмов и различных методов предварительной обработки к ваши данным. Например, он может масштабировать данные, выполнять унивариативный отбор признаков, проводить PCA на разных уровнях порога дисперсии и применять кластеризацию. Такие методы предварительной обработки могут быть применены как отдельно, так и в комбинации в конвейере. Затем инструмент AutoML будет обучать различные типы моделей, такие как линейная регрессия, эластичная сеть или случайный лес, на различных версиях ваших препроцессированных данных и выполнять оптимизацию гиперпараметров (HPO). Сервис Amazon SageMaker Autopilot устраняет тяжелую работу по созданию моделей ML. После предоставления набора данных, SageMaker Autopilot автоматически исследует различные решения, чтобы найти наилучшую модель. Но что, если вы хотите развернуть настроенную версию рабочего цикла AutoML?

В этой статье показано, как создать индивидуальный рабочий цикл AutoML на Amazon SageMaker с использованием Amazon SageMaker Automatic Model Tuning с доступным в репозитории GitHub примером кода.

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

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

• Principal Financial Group использует решение AWS Post Call Analytics для извлечения полноценных многоуровневых источников информации о клиентах
• Что такое Retrieval-Augmented Generation?
• Возжигая будущее релиз TensorRT-LLM ускоряет производительность инференции ИИ и добавляет поддержку новых моделей на компьютерах под управлением Windows 11, работающих на основе RTX.

Для этого примера вы не используете специализированный набор данных; вместо этого вы работаете с набором данных California Housing, который будет импортирован из сервиса Amazon Simple Storage Service (Amazon S3). Основное внимание в данном случае уделяется демонстрации технической реализации решения с использованием SageMaker HPO, которое позже можно применять к любому набору данных и области.

Следующая диаграмма представляет общий рабочий процесс решения.

Необходимые условия

Перед выполнением руководства по данному посту, вам понадобится:

• Быть пользователем AWS-аккаунта
• Знать концепции SageMaker, такие как Estimator, тренировочная задача и задача HPO
• Знакомство с Python SDK Amazon SageMaker
• Наличие знаний программирования на Python

Реализация решения

Полный код доступен в репозитории GitHub.

Шаги для реализации решения (как указано на диаграмме рабочего процесса) следующие:

1. Создайте экземпляр блокнота и укажите следующее:
   1. Для параметра Тип экземпляра блокнота выберите значение ml.t3.medium.
   2. Для параметра Упругая интерференция выберите значение none.
   3. Для параметра Идентификатор платформы выберите значение Amazon Linux 2, Jupyter Lab 3.
   4. Для параметра Роль IAM выберите значение по умолчанию AmazonSageMaker-ExecutionRole. Если такой роли не существует, создайте новую роль IAM для управления доступом в Amazon Web Services (AWS) Identity and Access Management (IAM) и прикрепите политику IAM AmazonSageMakerFullAccess.

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

1. Откройте интерфейс JupyterLab для вашего экземпляра блокнота и склонируйте репозиторий GitHub.

Вы можете сделать это, запустив новую сеансовую командную оболочку и выполнив команду git clone <REPO>, либо воспользовавшись функциональностью пользовательского интерфейса, как показано на следующем скриншоте.

1. Откройте файл блокнота automl.ipynb, выберите ядро conda_python3 и следуйте инструкциям для запуска набора HPO-заданий.

Для запуска кода без изменений вам необходимо увеличить квоту для ml.m5.large для использования заданий обучения и Количество экземпляров для всех заданий обучения. По умолчанию в AWS допускается использование только 20 параллельных заданий обучения SageMaker для обеих квот. Вам необходимо запросить увеличение квоты до значения 30 для обоих параметров. Оба запроса на изменение квоты обычно утверждаются в течение нескольких минут. Дополнительную информацию можно найти в разделе Запрос на увеличение квоты.

Если вы не хотите изменять квоту, вы можете просто изменить значение переменной MAX_PARALLEL_JOBS в скрипте (например, на 5).

1. Каждое HPO-задание завершит набор испытаний заданий обучения и определит модель с оптимальными гиперпараметрами.
2. Проанализируйте результаты и разверните модель с лучшей производительностью.

Это решение приведет к затратам в вашей учетной записи AWS. Стоимость этого решения будет зависеть от количества и продолжительности заданий HPO. С увеличением этих значений будут увеличиваться и затраты. Вы можете снизить затраты, ограничив время обучения и настройку TuningJobCompletionCriteriaConfig в соответствии с инструкциями, которые будут рассмотрены позднее в этом сообщении. Дополнительную информацию о ценообразовании можно найти на странице Цены Amazon SageMaker.

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

Начальная настройка

Начнем с запуска раздела Imports & Setup в записной книжке custom-automl.ipynb. Он устанавливает и импортирует все необходимые зависимости, создает сеанс и клиент SageMaker, устанавливает регион по умолчанию и S3-ведро для хранения данных.

Подготовка данных

Загрузите набор данных California Housing и подготовьте его, запустив раздел Download Data в тетрадке. Набор данных разделен на обучающий и тестовый наборы данных и загружен в S3-ведро по умолчанию сеанса SageMaker.

Весь набор данных состоит из 20 640 записей и 9 столбцов, включая целевую переменную. Цель состоит в прогнозировании медианной стоимости дома (medianHouseValue). Ниже приведен снимок экрана с верхними строками набора данных.

Шаблон обучающего скрипта

Автоматический рабочий процесс в этом посте основан на предварительной обработке и алгоритмах scikit-learn. Цель состоит в порождении большого количества различных комбинаций предварительных работы и алгоритмов для поиска наилучшей настройки. Начнем с создания общего обучающего скрипта, который сохраняется локально на инстанции записной книжки. В этом скрипте есть два пустых комментария: один для внедрения гиперпараметров и другой для объекта конвейера предварительной обработки и моделирования. Они будут внедрены динамически для каждого кандидата модели предварительной обработки. Целью наличия одного общего скрипта является сохранение реализации в состоянии DRY (не повторяйтесь).

#создать базовый скрипт_script = """import argparseimport joblibimport osimport numpy as npimport pandas as pdfrom sklearn.metrics import mean_squared_errorfrom sklearn.pipeline import Pipeline, FeatureUnionfrom sklearn.preprocessing import StandardScalerfrom sklearn.decomposition import PCAfrom sklearn.impute import SimpleImputerfrom sklearn.cluster import KMeansfrom sklearn.linear_model import ElasticNetfrom sklearn.ensemble import RandomForestRegressorfrom sklearn.ensemble import GradientBoostingRegressor############################## Функции вывода ##############################def model_fn(model_dir):clf = joblib.load(os.path.join(model_dir, "model.joblib"))return clfif __name__ == "__main__":print("Извлечение аргументов")parser = argparse.ArgumentParser()# Гиперпараметры##### БУДУТ ДИНАМИЧЕСКИ ВСТАВЛЕНЫ #####{}############################# Директории данных, модели и выводапарсер.add_argument("--model-dir", type=str, default=os.environ.get("SM_MODEL_DIR"))parser.add_argument("--train", type=str, default=os.environ.get("SM_CHANNEL_TRAIN"))parser.add_argument("--test", type=str, default=os.environ.get("SM_CHANNEL_TEST"))parser.add_argument("--train-file", type=str, default="train.parquet")parser.add_argument("--test-file", type=str, default="test.parquet")parser.add_argument("--features", type=str)parser.add_argument("--target", type=str)args, _ = parser.parse_known_args()# Загрузка и подготовка данныхtrain_df = pd.read_parquet(os.path.join(args.train, args.train_file))test_df = pd.read_parquet(os.path.join(args.test, args.test_file))X_train = train_df[args.features.split()]X_test = test_df[args.features.split()]y_train = train_df[args.target]y_test = test_df[args.target]# Обучение модели##### БУДУТ ДИНАМИЧЕСКИ ВСТАВЛЕНЫ #####{}{}############################pipeline = Pipeline([('preprocessor', preprocessor), ('model', model)])pipeline.fit(X_train, y_train)# Валидация модели и вывод метрикrmse = mean_squared_error(y_test, pipeline.predict(X_test), squared=False)print("RMSE: " + str(rmse))# Сохранение моделиpath = os.path.join(args.model_dir, "model.joblib")joblib.dump(pipeline, path)"""# записать _script в файл, чтобы иметь его под рукойwith open("script_draft.py", "w") as f:print(_script, file=f)

Создание предварительной обработки и комбинаций моделей

Словарь preprocessors содержит спецификацию методов предварительной обработки, применяемых к всем входным признакам модели. Каждый рецепт определяется с использованием объекта Pipeline или FeatureUnion из scikit-learn, который объединяет индивидуальные преобразования данных и стекает их вместе. Например, mean-imp-scale – это простой рецепт, который гарантирует, что пропущенные значения заменяются с использованием средних значений соответствующих столбцов, и что все признаки масштабируются с помощью StandardScaler. В отличие от этого, рецепт mean-imp-scale-pca объединяет несколько операций:

1. Заполните отсутствующие значения в столбцах средним значением.
2. Примените шкалирование признаков с использованием среднего значения и стандартного отклонения.
3. Вычислите метод главных компонент на основе входных данных с заданным значением границы дисперсии и объедините его с заполненными и масштабированными входными признаками.

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

предварительные_обработчики = {    
    "mean-imp-scale": "preprocessor = Pipeline([('imputer', SimpleImputer(strategy='mean')), ('scaler', StandardScaler())])\n",    
    "mean-imp-scale-knn": "preprocessor = FeatureUnion([('base-features', Pipeline([('imputer', SimpleImputer(strategy='mean')), ('scaler', StandardScaler())])), ('knn', Pipeline([('imputer', SimpleImputer(strategy='mean')), ('scaler', StandardScaler()), ('knn', KMeans(n_clusters=10))]))])\n",    
    "mean-imp-scale-pca": "preprocessor = FeatureUnion([('base-features', Pipeline([('imputer', SimpleImputer(strategy='mean')), ('scaler', StandardScaler())])), ('pca', Pipeline([('imputer', SimpleImputer(strategy='mean')), ('scaler', StandardScaler()), ('pca', PCA(n_components=0.9))]))])\n"   
}

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

• script_output – указывает на расположение обучающего скрипта, используемого оценщиком. Это поле заполняется динамически при объединении словаря models со словарем preprocessors.
• insertions – определяет код, который будет вставлен в script_draft.py и последующим образом сохранен в script_output. Ключ "preprocessor" оставлен пустым намеренно, поскольку это место заполняется одним из предварительных обработчиков для создания нескольких комбинаций моделей и предварительных обработчиков.
• hyperparameters – набор гиперпараметров, оптимизируемых заданием с поиском гиперпараметров.
• include_cls_metadata – Более подробные сведения, требуемые классом SageMaker Tuner.

Полный пример словаря models доступен в репозитории GitHub.

модели = {    
    "rf": {        
        "script_output": None,        
        "insertions": {            
            # Аргументы            
            "arguments" :             
            "parser.add_argument('--n_estimators', type=int, default=100)\n"+            
            "    parser.add_argument('--max_depth', type=int, default=None)\n"+                        
            "    parser.add_argument('--min_samples_leaf', type=int, default=1)\n"+            
            "    parser.add_argument('--min_samples_split', type=int, default=2)\n"+                        
            "    parser.add_argument('--max_features', type=str, default='auto')\n",            
            # Вызов модели            
            "preprocessor": None,            
            "model_call" : "model = RandomForestRegressor(n_estimators=args.n_estimators,max_depth=args.max_depth,min_samples_leaf=args.min_samples_leaf,min_samples_split=args.min_samples_split,max_features=args.max_features)\n"        
        },        
        "hyperparameters": {            
            "n_estimators": IntegerParameter(100, 2000, "Linear"),            
            "max_depth": IntegerParameter(1, 100, "Logarithmic"),            
            "min_samples_leaf": IntegerParameter(1, 6, "Linear"),            
            "min_samples_split": IntegerParameter(2, 20, "Linear"),            
            "max_features": CategoricalParameter(["auto", "sqrt", "log2"]),        
        },        
        "include_cls_metadata": False,    
    }
}

Затем перейдем к итерации через словари preprocessors и models и создадим все возможные комбинации. Например, если словарь preprocessors содержит 10 рецептов, а словарь models содержит 5 определений моделей, в словаре pipelines будет содержаться 50 конвейеров предварительной обработки-модель, которые оцениваются во время поиска гиперпараметров. Обратите внимание, что индивидуальные сценарии конвейеров еще не созданы на этом этапе. Следующий кодовый блок (ячейка 9) в блокноте Jupyter перебирает все объекты предобработчиков-моделей pipelines, вставляет все соответствующие части кода и сохраняет конкретную для конвейера версию скрипта локально в блокноте. Эти сценарии используются на следующих этапах при создании отдельных оценщиков, которые вы подключаете к поиску гиперпараметров.

pipelines = {}for model_name, model_spec in models.items():    pipelines[model_name] = {}    for preprocessor_name, preprocessor_spec in preprocessors.items():        pipeline_name = f"{model_name}-{preprocessor_name}"        pipelines[model_name][pipeline_name] = {}        pipelines[model_name][pipeline_name]["insertions"] = {}        pipelines[model_name][pipeline_name]["insertions"]["preprocessor"] = preprocessor_spec        pipelines[model_name][pipeline_name]["hyperparameters"] = model_spec["hyperparameters"]        pipelines[model_name][pipeline_name]["include_cls_metadata"] = model_spec["include_cls_metadata"]                pipelines[model_name][pipeline_name]["insertions"]["arguments"] = model_spec["insertions"]["arguments"]        pipelines[model_name][pipeline_name]["insertions"]["model_call"] = model_spec["insertions"]["model_call"]        pipelines[model_name][pipeline_name]["script_output"] = f"scripts/{model_name}/script-{pipeline_name}.py"

Определите оценщиков

Теперь вы можете начать работать над определением Estimators SageMaker, которые используются после подготовки скриптов HPO job. Давайте начнем с создания обертывающего класса, который определяет некоторые общие свойства для всех оценщиков. Он наследуется от класса SKLearn и определяет роль, количество экземпляров и тип, а также то, какие столбцы используются скриптом в качестве функций и целевой переменной.

class SKLearnBase(SKLearn):    def __init__(        self,         entry_point=".", # специально оставлен пустым, будет перезаписан в следующей функции        framework_version="1.2-1",        role=sm_role,        instance_count=1,        instance_type="ml.c5.xlarge",        hyperparameters={           "features": "medianIncome housingMedianAge totalRooms totalBedrooms population households latitude longitude",            "target": "medianHouseValue",        },          **kwargs,        ):        super(SKLearnBase, self).__init__(            entry_point=entry_point,            framework_version=framework_version,            role=role,            instance_count=instance_count,            instance_type=instance_type,            hyperparameters=hyperparameters,            **kwargs        )

Построим словарь estimators, перебирая все созданные ранее скрипты, которые находятся в директории scripts. Вы создаете новый оценщик, используя класс SKLearnBase, с уникальным именем оценщика и одним из скриптов. Обратите внимание, что словарь estimators имеет два уровня: верхний уровень определяет pipeline_family. Это логическая группировка на основе типа моделей для оценки и она равна длине словаря models. Второй уровень содержит отдельные типы препроцессоров в сочетании с заданной pipeline_family. Эта логическая группировка необходима при создании HPO job.

estimators = {}for pipeline_family in pipelines.keys():    estimators[pipeline_family] = {}    scripts = os.listdir(f"scripts/{pipeline_family}")    for script in scripts:        if script.endswith(".py"):            estimator_name = script.split(".")[0].replace("_", "-").replace("script", "estimator")            estimators[pipeline_family][estimator_name] = SKLearnBase(                entry_point=f"scripts/{pipeline_family}/{script}",                base_job_name=estimator_name,            )

Определите аргументы HPO тюнера

Чтобы оптимизировать передачу аргументов в класс HPO Tuner, создается экземпляр класса данных HyperparameterTunerArgs, который инициализируется аргументами, необходимыми для класса HPO. Он содержит набор функций, которые обеспечивают возвращение аргументов HPO в формате, ожидаемом при развертывании нескольких определений моделей одновременно.

@dataclassclass HyperparameterTunerArgs:    base_job_names: list[str]    estimators: list[object]    inputs: dict[str]    objective_metric_name: str    hyperparameter_ranges: list[dict]    metric_definition: dict[str]    include_cls_metadata: list[bool]    def get_estimator_dict(self) -> dict:        return {k:v for (k, v) in zip(self.base_job_names, self.estimators)}    def get_inputs_dict(self) -> dict:        return {k:v for (k, v) in zip(self.base_job_names, [self.inputs]*len(self.base_job_names))}    def get_objective_metric_name_dict(self) -> dict:        return {k:v for (k, v) in zip(self.base_job_names, [self.objective_metric_name]*len(self.base_job_names))}    def get_hyperparameter_ranges_dict(self) -> dict:        return {k:v for (k, v) in zip(self.base_job_names, self.hyperparameter_ranges)}    def get_metric_definition_dict(self) -> dict:        return {k:[v] for (k, v) in zip(self.base_job_names, [self.metric_definition]*len(self.base_job_names))}    def get_include_cls_metadata_dict(self) -> dict:        return {k:v for (k, v) in zip(self.base_job_names, self.include_cls_metadata)}

Следующий блок кода использует ранее представленный класс данных HyperparameterTunerArgs. Вы создаете другой словарь с именем hp_args и генерируете набор входных параметров, специфичных для каждого estimator_family из словаря estimators. Эти аргументы используются на следующем шаге при инициализации HPO-заданий для каждой семьи моделей.

hp_args = {}for estimator_family, estimators in estimators.items():    hp_args[estimator_family] = HyperparameterTunerArgs(        base_job_names=list(estimators.keys()),        estimators=list(estimators.values()),        inputs={"train": s3_data_train.uri, "test": s3_data_test.uri},        objective_metric_name="RMSE",        hyperparameter_ranges=[pipeline.get("hyperparameters") for pipeline in pipelines[estimator_family].values()],        metric_definition={"Name": "RMSE", "Regex": "RMSE: ([0-9.]+).*$"},        include_cls_metadata=[pipeline.get("include_cls_metadata") for pipeline in pipelines[estimator_family].values()],    )

Создание объектов HPO-тюнера

На этом шаге вы создаете отдельные тюнеры для каждой estimator_family. Почему вы создаете три отдельных задачи HPO вместо запуска одной на все оценщики? Класс HyperparameterTuner ограничен 10 прикрепленными к нему определениями моделей. Поэтому каждый HPO отвечает за поиск лучшего предварительного обработчика для данной семьи моделей и настройку гиперпараметров этой семьи моделей.

Вот несколько дополнительных моментов, касающихся настройки:

• Стратегия оптимизации – байесовская, что означает, что HPO активно отслеживает производительность всех испытаний и направляет оптимизацию на более перспективные комбинации гиперпараметров. Ранний останов должен быть включен Off или Auto, когда используется байесовская стратегия, которая обрабатывает эту логику самостоятельно.
• Каждая задача HPO выполняется максимум для 100 задач и запускает 10 задач параллельно. Если вы имеете дело с большими наборами данных, возможно, захотите увеличить общее количество задач.
• Кроме того, возможно, вам захочется использовать настройки, которые контролируют время выполнения задачи и количество задач, которые запускает ваш HPO. Одним из способом сделать это является задание максимального времени выполнения в секундах (в этом посте мы установили его на 1 час). Другим способом является использование недавно выпущенного класса TuningJobCompletionCriteriaConfig. Он предлагает набор настроек, которые отслеживают прогресс ваших задач и определяют, вероятно, что дополнительные задачи улучшат результат. В этом посте мы установили максимальное количество тренировочных задач, не улучшающихся, равное 20. Таким образом, если оценка не улучшается (например, с сорокового испытания), вам не придется платить за оставшиеся испытания до достижения значения max_jobs.

STRATEGY = "Bayesian"OBJECTIVE_TYPE = "Minimize"MAX_JOBS = 100MAX_PARALLEL_JOBS = 10MAX_RUNTIME_IN_SECONDS = 3600EARLY_STOPPING_TYPE = "Off"# RANDOM_SEED = 42 # раскомментируйте, если вам требуется воспроизводимость между запускамиTUNING_JOB_COMPLETION_CRITERIA_CONFIG = TuningJobCompletionCriteriaConfig(    max_number_of_training_jobs_not_improving=20,    )tuners = {}for estimator_family, hp in hp_args.items():    tuners[estimator_family] = HyperparameterTuner.create(        estimator_dict=hp.get_estimator_dict(),        objective_metric_name_dict=hp.get_objective_metric_name_dict(),        hyperparameter_ranges_dict=hp.get_hyperparameter_ranges_dict(),        metric_definitions_dict=hp.get_metric_definition_dict(),        strategy=STRATEGY,        completion_criteria_config=TUNING_JOB_COMPLETION_CRITERIA_CONFIG,        objective_type=OBJECTIVE_TYPE,        max_jobs=MAX_JOBS,        max_parallel_jobs=MAX_PARALLEL_JOBS,        max_runtime_in_seconds=MAX_RUNTIME_IN_SECONDS,        base_tuning_job_name=f"custom-automl-{estimator_family}",        early_stopping_type=EARLY_STOPPING_TYPE, # ранний останов тренировочных задач на данный момент не поддерживается при использовании нескольких определений тренировочных задач        # random_seed=RANDOM_SEED,    )

Теперь давайте пройдем через словари tuners и hp_args и запустим все задачи HPO в SageMaker. Обратите внимание на использование аргумента ожидания, установленного на False, что означает, что ядро не будет ожидать завершения результатов и вы можете запустить все задачи сразу.

Вероятно, что не все обучающиеся работы будут завершены, и некоторые из них могут быть остановлены рабочей задачей HPO. Причина заключается в TuningJobCompletionCriteriaConfig – оптимизация завершается, если будут соблюдены любые из указанных критериев. В данном случае, когда критерии оптимизации не улучшаются в течение 20 последовательных задач.

for tuner, hpo in zip(tuners.values(), hp_args.values()):    tuner.fit(        inputs=hpo.get_inputs_dict(),        include_cls_metadata=hpo.get_include_cls_metadata_dict(),        wait=False,        )

Анализ результатов

В ячейке 15 блокнота проверяется, завершены ли все задачи HPO, и все результаты объединяются в виде фрейма данных pandas для последующего анализа. Прежде чем подробно изучать результаты, давайте взглянем на SageMaker консоль общим взглядом.

Вверху страницы Hyperparameter tuning jobs вы можете увидеть три запущенные задачи HPO. Все они закончились раньше и не выполнили все 100 обучающихся работ. На следующем скриншоте вы можете увидеть, что модель Elastic-Net завершила наибольшее количество испытаний, в то время как другие не требовали столь большого количества обучающихся работ для достижения лучшего результата.

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

Давайте создадим визуализацию на основе результатов, чтобы получить больше информации о производительности рабочего процесса AutoML по всему семейству моделей.

Из следующего графика можно заключить, что производительность модели Elastic-Net колебалась между 70 000 и 80 000 RMSE, и в конечном итоге застопорилась, поскольку алгоритм не смог улучшить свою производительность, несмотря на попытки различных методов предварительной обработки и значений гиперпараметров. Также кажется, что производительность RandomForest сильно варьировалась в зависимости от набора гиперпараметров, и несмотря на множество попыток, она не смогла опуститься ниже ошибки RMSE в 50 000. GradientBoosting достигла лучшей производительности уже с самого начала, опустившись ниже 50 000 RMSE. Затем HPO попыталась улучшить этот результат, но не смогла достичь лучшей производительности с использованием других комбинаций гиперпараметров. Общий вывод для всех задач HPO заключается в том, что для каждого алгоритма не требовалось много задач для поиска набора гиперпараметров, демонстрирующего наилучшую производительность. Для дальнейшего улучшения результата необходимо экспериментировать с созданием дополнительных признаков и выполнением дополнительной инженерии признаков.

Вы также можете рассмотреть более подробный просмотр сочетания моделей и предобработчиков, чтобы сделать выводы о наиболее перспективных комбинациях.

Выбор лучшей модели и развертывание

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

df_best_job = df_tuner_results.loc[df_tuner_results["FinalObjectiveValue"] == df_tuner_results["FinalObjectiveValue"].min()]df_best_jobBEST_MODEL_FAMILY = df_best_job["TrainingJobFamily"].values[0]tuners.get(BEST_MODEL_FAMILY).best_training_job()tuners.get(BEST_MODEL_FAMILY).best_estimator()predictor = tuners.get(BEST_MODEL_FAMILY).deploy(    initial_instance_count=1,    instance_type="ml.c4.large",    endpoint_name=f"custom-automl-endpoint-{BEST_MODEL_FAMILY}",)

Очистка

Чтобы избежать нежелательных оплат со стороны вашей учетной записи AWS, рекомендуется удалить ресурсы AWS, которые вы использовали в этом сообщении:

1. На консоли Amazon S3 очистите данные из объектов S3, в которых были сохранены данные для обучения.

1. На консоли SageMaker остановите экземпляр блокнота.

1. Удалите конечную точку модели, если вы ее развернули. Точки конечного доступа следует удалять, когда они больше не используются, так как их оплата взимается за время развертывания.

sm_client.delete_endpoint(EndpointName=predictor.endpoint)

Заключение

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

Используйте следующие ресурсы, чтобы углубить свои знания по использованию SageMaker HPO:

• Лучшие практики настройки гиперпараметров
• Amazon SageMaker Automatic Model Tuning теперь поддерживает три новых критерия завершения для оптимизации гиперпараметров
• Использование Scikit-learn с помощью SageMaker Python SDK
• Разработка, обучение, оптимизация и развертывание Scikit-Learn Random Forest