AutoML Hiermee kunt u snelle, algemene inzichten uit uw gegevens halen, direct aan het begin van de levenscyclus van een Machine Learning (ML)-project. Als u vooraf begrijpt welke voorverwerkingstechnieken en algoritmetypen de beste resultaten opleveren, verkort u de tijd die nodig is om het juiste model te ontwikkelen, trainen en implementeren. Het speelt een cruciale rol in het ontwikkelingsproces van elk model en stelt datawetenschappers in staat zich te concentreren op de meest veelbelovende ML-technieken. Bovendien biedt AutoML basismodelprestaties die als referentiepunt kunnen dienen voor het datawetenschapsteam.

Een AutoML-tool past een combinatie van verschillende algoritmen en verschillende voorbewerkingstechnieken toe op uw gegevens. Het kan bijvoorbeeld de gegevens schalen, univariate kenmerkselectie uitvoeren, PCA uitvoeren op verschillende variantiedrempelniveaus en clustering toepassen. Dergelijke voorbewerkingstechnieken kunnen afzonderlijk worden toegepast of in een pijplijn worden gecombineerd. Vervolgens traint een AutoML-tool verschillende modeltypen, zoals lineaire regressie, Elastic-Net of Random Forest, op verschillende versies van uw voorverwerkte dataset en voert hyperparameteroptimalisatie (HPO) uit. Amazon SageMaker-stuurautomaat elimineert het zware werk van het bouwen van ML-modellen. Na het aanleveren van de dataset onderzoekt SageMaker Autopilot automatisch verschillende oplossingen om het beste model te vinden. Maar wat als u uw op maat gemaakte versie van een AutoML-workflow wilt implementeren?

Dit bericht laat zien hoe u een op maat gemaakte AutoML-workflow kunt maken Amazon Sage Maker gebruik Amazon SageMaker automatische modelafstemming met voorbeeldcode beschikbaar in a GitHub-opslagplaats.

Overzicht oplossingen

Laten we voor dit gebruiksscenario aannemen dat u deel uitmaakt van een data science-team dat modellen ontwikkelt in een gespecialiseerd domein. U heeft een reeks aangepaste voorverwerkingstechnieken ontwikkeld en een aantal algoritmen geselecteerd waarvan u doorgaans verwacht dat ze goed zullen werken met uw ML-probleem. Wanneer u aan nieuwe ML-gebruiksscenario's werkt, wilt u eerst een AutoML-run uitvoeren met behulp van uw voorverwerkingstechnieken en algoritmen om de reikwijdte van mogelijke oplossingen te beperken.

Voor dit voorbeeld gebruikt u geen gespecialiseerde dataset; in plaats daarvan werkt u met de California Housing-gegevensset waaruit u importeert Amazon eenvoudige opslagservice (Amazone S3). De focus ligt op het demonstreren van de technische implementatie van de oplossing met behulp van SageMaker HPO, die later op elke dataset en domein kan worden toegepast.

Het volgende diagram toont de algemene oplossingsworkflow.

Voorwaarden

Het volgende zijn vereisten voor het voltooien van de walkthrough in dit bericht:

Implementeer de oplossing

De volledige code is beschikbaar in de GitHub repo.

De stappen om de oplossing te implementeren (zoals vermeld in het workflowdiagram) zijn als volgt:

1. Maak een notebookinstantie en specificeer het volgende:
   1. Voor Type exemplaar van notebook, kiezen ml.t3.medium.
   2. Voor Elastische gevolgtrekking, kiezen geen.
   3. Voor Platform-ID, kiezen Amazon Linux 2, Jupyter Lab 3.
   4. Voor IAM-rol, kies de standaard AmazonSageMaker-ExecutionRole. Als het niet bestaat, maak dan een nieuw AWS Identiteits- en toegangsbeheer (IAM) rol en voeg de AmazonSageMakerFullAccess IAM-beleid.

Houd er rekening mee dat u in de productie een uitvoeringsrol en -beleid met een minimaal bereik moet maken.

2. Open de JupyterLab-interface voor uw notebookinstantie en kloon de GitHub-opslagplaats.

U kunt dat doen door een nieuwe terminalsessie te starten en de git clone <REPO> opdracht of door de UI-functionaliteit te gebruiken, zoals weergegeven in de volgende schermafbeelding.

3. Open de automl.ipynb notebook-bestand, selecteert u het conda_python3 kernel en volg de instructies om een reeks HPO-banen.

Als u de code zonder wijzigingen wilt uitvoeren, moet u het servicequotum verhogen voor ml.m5.large voor gebruik van trainingstaken en Aantal instanties voor alle trainingstaken. AWS staat standaard slechts 20 parallelle SageMaker-trainingstaken toe voor beide quota. Voor beide moet u een quotumverhoging naar 30 aanvragen. Beide quotawijzigingen moeten doorgaans binnen enkele minuten worden goedgekeurd. Verwijzen naar Verzoek om een ​​verhoging van het quotum voor meer informatie.

Als u het quotum niet wilt wijzigen, kunt u eenvoudigweg de waarde van de MAX_PARALLEL_JOBS variabele in het script (bijvoorbeeld naar 5).

4. Elke HPO-taak voltooit een reeks opleiding baan proeven en geef het model aan met optimale hyperparameters.
5. Analyseer de resultaten en het best presterende model inzetten.

Deze oplossing brengt kosten met zich mee in uw AWS-account. De kosten van deze oplossing zijn afhankelijk van het aantal en de duur van de HPO-opleidingsbanen. Naarmate deze stijgen, zullen ook de kosten stijgen. U kunt de kosten verlagen door de trainingstijd en configuratie te beperken TuningJobCompletionCriteriaConfig volgens de instructies die later in dit bericht worden besproken. Voor prijsinformatie, zie Amazon SageMaker-prijzen.

In de volgende secties bespreken we de notebook in meer detail met codevoorbeelden en de stappen om de resultaten te analyseren en het beste model te selecteren.

Initiële setup

Laten we beginnen met het uitvoeren van de Importeren en instellen sectie in de custom-automl.ipynb notitieboekje. Het installeert en importeert alle vereiste afhankelijkheden, instantiëert een SageMaker-sessie en -client en stelt de standaardregio en S3-bucket in voor het opslaan van gegevens.

Data voorbereiding

Download de California Housing-gegevensset en bereid deze voor door de Download Data gedeelte van het notitieboekje. De dataset wordt opgesplitst in trainings- en testdataframes en geüpload naar de standaard S3-bucket van de SageMaker-sessie.

De volledige dataset bevat in totaal 20,640 records en 9 kolommen, inclusief het doel. Het doel is om de mediaanwaarde van een huis te voorspellen (medianHouseValue kolom). De volgende schermafbeelding toont de bovenste rijen van de gegevensset.

Sjabloon voor trainingsscript

De AutoML-workflow in dit bericht is gebaseerd op scikit-leren pijpleidingen en algoritmen voorbewerken. Het doel is om een ​​grote combinatie van verschillende voorverwerkingspijplijnen en algoritmen te genereren om de best presterende opstelling te vinden. Laten we beginnen met het maken van een algemeen trainingsscript, dat lokaal op de notebookinstantie wordt bewaard. In dit script zijn er twee lege commentaarblokken: één voor het injecteren van hyperparameters en de andere voor het pijplijnobject voor het preprocessing-model. Ze zullen dynamisch worden geïnjecteerd voor elk kandidaat-voorverwerkingsmodel. Het doel van één generiek script is om de implementatie DROOG te houden (herhaal jezelf niet).

#create base script
_script = """
import argparse
import joblib
import os
import numpy as np
import pandas as pd
from sklearn.metrics import mean_squared_error
from sklearn.pipeline import Pipeline, FeatureUnion
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA
from sklearn.impute import SimpleImputer
from sklearn.cluster import KMeans
from sklearn.linear_model import ElasticNet
from sklearn.ensemble import RandomForestRegressor
from sklearn.ensemble import GradientBoostingRegressor
###########################
### Inference functions ###
###########################
def model_fn(model_dir):
clf = joblib.load(os.path.join(model_dir, "model.joblib"))
return clf
if __name__ == "__main__":
print("Extracting arguments")
parser = argparse.ArgumentParser()
# Hyperparameters
##### WILL BE INSERTED DYNAMICALLY #####
{}
############################
# Data, model, and output directories
parser.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()
# Load and prepare data
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]
# Train model
##### WILL BE INSERTED DYNAMICALLY #####
{}
{}
############################
pipeline = Pipeline([('preprocessor', preprocessor), ('model', model)])
pipeline.fit(X_train, y_train)
# Validate model and print metrics
rmse = mean_squared_error(y_test, pipeline.predict(X_test), squared=False)
print("RMSE: " + str(rmse))
# Persist model
path = os.path.join(args.model_dir, "model.joblib")
joblib.dump(pipeline, path) """
# write _script to file just to have it in hand
with open("script_draft.py", "w") as f:
print(_script, file=f)

Maak voorbewerkings- en modelcombinaties

De preprocessors woordenboek bevat een specificatie van voorverwerkingstechnieken die worden toegepast op alle invoerkenmerken van het model. Elk recept wordt gedefinieerd met behulp van een Pipeline of FeatureUnion object van scikit-learn, dat individuele gegevenstransformaties aan elkaar koppelt en op elkaar stapelt. Bijvoorbeeld, mean-imp-scale is een eenvoudig recept dat ervoor zorgt dat ontbrekende waarden worden geïmputeerd met behulp van gemiddelde waarden van de respectievelijke kolommen en dat alle objecten worden geschaald met behulp van de Standaardscaler. De mean-imp-scale-pca Receptketens brengen nog een paar bewerkingen samen:

1. Vul ontbrekende waarden in kolommen toe met het gemiddelde ervan.
2. Pas functieschaling toe met behulp van gemiddelde en standaarddeviatie.
3. Bereken PCA bovenop de invoergegevens bij een gespecificeerde variantiedrempelwaarde en voeg deze samen met de toegerekende en geschaalde invoerkenmerken.

In dit bericht zijn alle invoerfuncties numeriek. Als uw invoergegevensset meer gegevenstypen bevat, moet u een ingewikkeldere pijplijn opgeven waarin verschillende voorverwerkingstakken worden toegepast op verschillende sets met functietypen.

preprocessors = { "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" }

De models woordenboek bevat specificaties van verschillende algoritmen waaraan u de dataset kunt aanpassen. Elk modeltype wordt geleverd met de volgende specificatie in het woordenboek:

• script_uitvoer – Verwijst naar de locatie van het trainingsscript dat door de schatter wordt gebruikt. Dit veld wordt dynamisch gevuld wanneer de models woordenboek wordt gecombineerd met de preprocessors woordenboek.
• inserties – Definieert code die in het bestand wordt ingevoegd script_draft.py en vervolgens opgeslagen onder script_output. De sleutel “preprocessor” is opzettelijk leeg gelaten omdat deze locatie is gevuld met een van de preprocessors om meerdere model-preprocessorcombinaties te creëren.
• hyperparameters – Een set hyperparameters die zijn geoptimaliseerd door de HPO-taak.
• include_cls_metadata – Meer configuratiedetails vereist door de SageMaker Tuner klasse.

Een volledig voorbeeld van de models woordenboek is beschikbaar in de GitHub-repository.

models = { "rf": { "script_output": None, "insertions": { # Arguments "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", # Model call "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, }
}

Laten we vervolgens de preprocessors en models woordenboeken en maak alle mogelijke combinaties. Als uw preprocessors woordenboek bevat 10 recepten en je hebt 5 modeldefinities in de models woordenboek bevat het nieuw gemaakte pijplijnwoordenboek 50 preprocessormodelpijplijnen die worden geëvalueerd tijdens HPO. Houd er rekening mee dat er op dit moment nog geen afzonderlijke pijplijnscripts zijn gemaakt. Het volgende codeblok (cel 9) van het Jupyter-notebook doorloopt alle preprocessor-modelobjecten in de pipelines woordenboek, voegt alle relevante codestukken in en bewaart een pijplijnspecifieke versie van het script lokaal in het notitieblok. Deze scripts worden gebruikt in de volgende stappen bij het maken van individuele schatters die u in de HPO-taak aansluit.

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"

Definieer schatters

U kunt nu werken aan het definiëren van SageMaker Estimators die de HPO-taak gebruikt nadat de scripts gereed zijn. Laten we beginnen met het maken van een wrapper-klasse die enkele gemeenschappelijke eigenschappen voor alle schatters definieert. Het erft van de SKLearn class en specificeert de rol, het aantal exemplaren en het type, evenals welke kolommen door het script worden gebruikt als functies en het doel.

class SKLearnBase(SKLearn): def __init__( self, entry_point=".", # intentionally left blank, will be overwritten in the next function 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 )

Laten we de . bouwen estimators woordenboek door alle scripts te doorlopen die eerder zijn gegenereerd en zich in de scripts map. U instantiëert een nieuwe schatter met behulp van de SKLearnBase klasse, met een unieke schatternaam, en een van de scripts. Merk op dat de estimators woordenboek heeft twee niveaus: het hoogste niveau definieert a pipeline_family. Dit is een logische groepering op basis van het type modellen dat moet worden geëvalueerd en is gelijk aan de lengte van de models woordenboek. Het tweede niveau bevat individuele preprocessortypen gecombineerd met de gegeven pipeline_family. Deze logische groepering is vereist bij het aanmaken van de HPO-functie.

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

Definieer HPO-tunerargumenten

Om het doorgeven van argumenten aan de HPO te optimaliseren Tuner klasse, de HyperparameterTunerArgs dataklasse wordt geïnitialiseerd met argumenten vereist door de HPO-klasse. Het wordt geleverd met een reeks functies die ervoor zorgen dat HPO-argumenten worden geretourneerd in een formaat dat wordt verwacht bij het tegelijk implementeren van meerdere modeldefinities.

@dataclass
class 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)}

Het volgende codeblok maakt gebruik van het eerder geïntroduceerde HyperparameterTunerArgs gegevensklasse. Je maakt een ander woordenboek genaamd hp_args en genereer een set invoerparameters die specifiek zijn voor elk estimator_family van het estimators woordenboek. Deze argumenten worden in de volgende stap gebruikt bij het initialiseren van HPO-taken voor elke modelfamilie.

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

Maak HPO-tunerobjecten

In deze stap maakt u voor elk afzonderlijk stemapparaat aan estimator_family. Waarom creëer je drie afzonderlijke HPO-banen in plaats van er maar één in alle schatters te lanceren? De HyperparameterTuner klasse is beperkt tot 10 daaraan gekoppelde modeldefinities. Daarom is elke HPO verantwoordelijk voor het vinden van de best presterende preprocessor voor een bepaalde modelfamilie en het afstemmen van de hyperparameters van die modelfamilie.

Hieronder volgen nog enkele punten met betrekking tot de opstelling:

• De optimalisatiestrategie is Bayesiaans, wat betekent dat de HPO actief de prestaties van alle onderzoeken monitort en de optimalisatie navigeert naar meer veelbelovende hyperparametercombinaties. Vroegtijdig stoppen moet worden ingesteld af or automobiel bij het werken met een Bayesiaanse strategie, die die logica zelf afhandelt.
• Elke HPO-taak heeft een capaciteit van maximaal 100 banen en voert 10 banen parallel uit. Als u met grotere gegevenssets te maken heeft, wilt u wellicht het totale aantal taken verhogen.
• Daarnaast wilt u mogelijk instellingen gebruiken die bepalen hoe lang een taak wordt uitgevoerd en hoeveel taken uw HPO activeert. Eén manier om dat te doen is door de maximale looptijd in seconden in te stellen (voor dit bericht stellen we deze in op 1 uur). Een andere is om de onlangs uitgebrachte te gebruiken TuningJobCompletionCriteriaConfig. Het biedt een reeks instellingen die de voortgang van uw opdrachten monitoren en beslissen of het waarschijnlijk is dat meer opdrachten het resultaat zullen verbeteren. In dit bericht hebben we het maximale aantal trainingstaken die niet verbeteren ingesteld op 20. Op die manier hoef je, als de score niet verbetert (bijvoorbeeld vanaf de veertigste proef), pas voor de resterende proeven te betalen max_jobs is bereikt.

STRATEGY = "Bayesian"
OBJECTIVE_TYPE = "Minimize"
MAX_JOBS = 100
MAX_PARALLEL_JOBS = 10
MAX_RUNTIME_IN_SECONDS = 3600
EARLY_STOPPING_TYPE = "Off"
# RANDOM_SEED = 42 # uncomment if you require reproducibility across runs
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, # early stopping of training jobs is not currently supported when multiple training job definitions are used # random_seed=RANDOM_SEED, )

Laten we nu de tuners en hp_args woordenboeken en activeer alle HPO-taken in SageMaker. Let op het gebruik van het wait-argument ingesteld op False, wat betekent dat de kernel niet wacht tot de resultaten compleet zijn en dat je alle taken in één keer kunt activeren.

Het is waarschijnlijk dat niet alle trainingstaken zullen worden voltooid en dat sommige ervan door de HPO-taak kunnen worden stopgezet. De reden hiervoor is de TuningJobCompletionCriteriaConfig—de optimalisatie eindigt als aan een van de gespecificeerde criteria wordt voldaan. In dit geval, wanneer de optimalisatiecriteria gedurende 20 opeenvolgende banen niet verbeteren.

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

Analyseer resultaten

Cel 15 van het notebook controleert of alle HPO-taken zijn voltooid en combineert alle resultaten in de vorm van een panda-dataframe voor verdere analyse. Laten we, voordat we de resultaten in detail analyseren, eens op hoog niveau naar de SageMaker-console kijken.

Bovenaan de Taken voor het afstemmen van hyperparameters pagina kunt u uw drie gelanceerde HPO-banen zien. Ze waren allemaal vroeg klaar en voerden niet alle 100 trainingsopdrachten uit. In de volgende schermafbeelding kunt u zien dat de Elastic-Net-modelfamilie het grootste aantal tests heeft voltooid, terwijl andere niet zoveel trainingstaken nodig hadden om het beste resultaat te vinden.

U kunt de HPO-taak openen voor toegang tot meer details, zoals individuele trainingstaken, taakconfiguratie en de informatie en prestaties van de beste trainingsfunctie.

Laten we een visualisatie maken op basis van de resultaten om meer inzicht te krijgen in de prestaties van de AutoML-workflow voor alle modelfamilies.

Uit de volgende grafiek kun je concluderen dat de Elastic-Net De prestaties van het model schommelden tussen de 70,000 en 80,000 RMSE en liepen uiteindelijk vast, omdat het algoritme de prestaties niet kon verbeteren ondanks het uitproberen van verschillende voorverwerkingstechnieken en hyperparameterwaarden. Daar lijkt het ook op RandomForest De prestaties varieerden sterk, afhankelijk van de hyperparameterset die door HPO werd onderzocht, maar ondanks vele pogingen konden ze niet onder de 50,000 RMSE-fout komen. GradientBoosting behaalde al vanaf het begin de beste prestaties en ging onder de 50,000 RMSE. HPO probeerde dat resultaat verder te verbeteren, maar slaagde er niet in om betere prestaties te behalen bij andere hyperparametercombinaties. Een algemene conclusie voor alle HPO-taken is dat er niet zo veel taken nodig waren om de best presterende set hyperparameters voor elk algoritme te vinden. Om het resultaat verder te verbeteren, zou u moeten experimenteren met het creëren van meer functies en het uitvoeren van aanvullende functie-engineering.

U kunt ook een gedetailleerder beeld van de model-preprocessorcombinatie bekijken om conclusies te trekken over de meest veelbelovende combinaties.

Selecteer het beste model en implementeer het

Het volgende codefragment selecteert het beste model op basis van de laagst behaalde objectieve waarde. U kunt het model vervolgens implementeren als een SageMaker-eindpunt.

df_best_job = df_tuner_results.loc[df_tuner_results["FinalObjectiveValue"] == df_tuner_results["FinalObjectiveValue"].min()]
df_best_job
BEST_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}",
)

Opruimen

Om ongewenste afschrijvingen op uw AWS-account te voorkomen, raden we u aan de AWS-bronnen te verwijderen die u in dit bericht hebt gebruikt:

1. Leeg op de Amazon S3-console de gegevens uit de S3-bucket waarin de trainingsgegevens zijn opgeslagen.

2. Stop op de SageMaker-console de notebookinstantie.

3. Verwijder het modeleindpunt als u dit hebt geïmplementeerd. Eindpunten moeten worden verwijderd wanneer ze niet meer worden gebruikt, omdat ze worden gefactureerd op basis van de implementatietijd.

sm_client.delete_endpoint(EndpointName=predictor.endpoint)

Conclusie

In dit bericht hebben we laten zien hoe u een aangepaste HPO-taak kunt maken in SageMaker met behulp van een aangepaste selectie van algoritmen en voorverwerkingstechnieken. Dit voorbeeld demonstreert met name hoe u het proces van het genereren van veel trainingsscripts kunt automatiseren en hoe u Python-programmeerstructuren kunt gebruiken voor een efficiënte implementatie van meerdere parallelle optimalisatietaken. We hopen dat deze oplossing de basis zal vormen voor alle aangepaste modelafstemmingstaken die u met SageMaker gaat implementeren om hogere prestaties te bereiken en uw ML-workflows te versnellen.

Bekijk de volgende bronnen om uw kennis over het gebruik van SageMaker HPO verder te verdiepen:

Over de auteurs

Konrad Semsch is een Senior ML Solutions Architect bij het Amazon Web Services Data Lab Team. Hij helpt klanten machine learning te gebruiken om hun zakelijke uitdagingen met AWS op te lossen. Hij houdt ervan om te bedenken en te vereenvoudigen om klanten eenvoudige en pragmatische oplossingen te bieden voor hun AI/ML-projecten. Hij is het meest gepassioneerd door MlOps en traditionele datawetenschap. Buiten zijn werk is hij een groot fan van windsurfen en kitesurfen.

Tonijn Ersoy is een Senior Solutions Architect bij AWS. Haar primaire focus is het helpen van klanten uit de publieke sector bij het adopteren van cloudtechnologieën voor hun workloads. Ze heeft een achtergrond in applicatieontwikkeling, enterprise-architectuur en contactcentertechnologieën. Haar interesses omvatten serverloze architecturen en AI/ML.

• Door SEO aangedreven content en PR-distributie. Word vandaag nog versterkt.
• PlatoData.Network Verticale generatieve AI. Versterk jezelf. Toegang hier.
• PlatoAiStream. Web3-intelligentie. Kennis versterkt. Toegang hier.
• PlatoESG. carbon, CleanTech, Energie, Milieu, Zonne, Afvalbeheer. Toegang hier.
• Plato Gezondheid. Intelligentie op het gebied van biotech en klinische proeven. Toegang hier.
• Bron: https://aws.amazon.com/blogs/machine-learning/implement-a-custom-automl-job-using-pre-selected-algorithms-in-amazon-sagemaker-automatic-model-tuning/