Organizați-vă călătoria de învățare automată cu Amazon SageMaker Experiments și Amazon SageMaker Pipelines

Procesul de construire a unui model de învățare automată (ML) este iterativ până când găsiți modelul candidat care funcționează bine și este gata să fie implementat. Pe măsură ce oamenii de știință de date repetă acest proces, au nevoie de o metodă fiabilă pentru a urmări cu ușurință experimentele pentru a înțelege cum a fost construită fiecare versiune de model și cum a funcționat.

Amazon SageMaker permite echipelor să profite de o gamă largă de funcții pentru a pregăti, construi, antrena, implementa și monitoriza rapid modelele ML. Pipelines Amazon SageMaker oferă un proces repetabil pentru iterare prin activitățile de construire a modelului și este integrat cu Experimente Amazon SageMaker. În mod implicit, fiecare conductă SageMaker este asociată cu un experiment și fiecare rulare a acelei conducte este urmărită ca o încercare în acel experiment. Apoi iterațiile dvs. sunt urmărite automat fără pași suplimentari.

În această postare, aruncăm o privire mai atentă asupra motivației din spatele unui proces automatizat de urmărire a experimentelor cu Experimente și a capabilităților native încorporate în Pipelines.

De ce este important să vă mențineți experimentele organizate?

Să facem un pas înapoi pentru un moment și să încercăm să înțelegem de ce este important să avem experimente organizate pentru învățarea automată. Când oamenii de știință de date abordează o nouă problemă ML, ei trebuie să răspundă la multe întrebări diferite, de la disponibilitatea datelor până la modul în care vor măsura performanța modelului.

La început, procesul este plin de incertitudine și este foarte iterativ. Ca rezultat, această fază de experimentare poate produce mai multe modele, fiecare creat din propriile intrări (seturi de date, scripturi de antrenament și hiperparametri) și producând propriile rezultate (artefacte de model și metrici de evaluare). Provocarea este atunci de a urmări toate aceste intrări și ieșiri ale fiecărei iterații.

Oamenii de știință de date antrenează de obicei multe versiuni diferite de model până când găsesc combinația de transformare a datelor, algoritm și hiperparametri care rezultă în cea mai performantă versiune a unui model. Fiecare dintre aceste combinații unice este un singur experiment. Cu o înregistrare urmăribilă a intrărilor, algoritmilor și hiperparametrilor care au fost utilizați de acel studiu, echipa de știință a datelor poate găsi ușor să-și reproducă pașii.

Având un proces automatizat pentru a urmări experimentele, îmbunătățește capacitatea de a reproduce și de a implementa versiuni de model specifice care au performanțe bune. Integrarea nativă a Pipelines cu Experimente facilitează urmărirea și gestionarea automată a experimentelor pe parcursul întregului pipeline.

Beneficiile experimentelor SageMaker

SageMaker Experiments le permite oamenilor de știință să organizeze, să urmărească, să compare și să evalueze iterațiile lor de instruire.

Să începem mai întâi cu o prezentare generală a ceea ce puteți face cu Experimente:

• Organizarea experimentelor - Experimentele structurează experimentarea cu o entitate de nivel superior numită an experiment care contine un set de studii. Fiecare încercare conține un set de pași numiti componentele de probă. Fiecare componentă de încercare este o combinație de seturi de date, algoritmi și parametri. Puteți imagina experimentele ca dosarul de nivel superior pentru organizarea ipotezelor dvs., încercările dvs. ca subdosare pentru fiecare test de grup și componentele dvs. de încercare ca fișiere pentru fiecare instanță a unei rulări de testare.
• Urmăriți experimentele – Experimentele le permit oamenilor de știință de date să urmărească experimentele. Oferă posibilitatea de a atribui automat job-urile SageMaker la o probă prin configurații simple și prin intermediul SDK-urilor de urmărire.
• Comparați și evaluați experimentele - Integrarea Experimentelor cu Amazon SageMaker Studio facilitează producerea de vizualizări de date și compararea diferitelor încercări. De asemenea, puteți accesa datele de încercare prin intermediul SDK-ului Python pentru a vă genera propria vizualizare folosind bibliotecile de plotare preferate.

Pentru a afla mai multe despre API-urile și SDK-urile Experiments, vă recomandăm următoarea documentație: CreateExperiment și Amazon SageMaker Experiments Python SDK.

Dacă doriți să vă scufundați mai adânc, vă recomandăm să vă uitați în amazon-sagemaker-examples/sagemaker-experiments depozitul GitHub pentru alte exemple.

Integrare între conducte și experimente

Conductele de construire a modelelor care fac parte din Pipelines sunt create special pentru ML și vă permit să vă orchestrați sarcinile de construire a modelului folosind un instrument pipeline care include integrări native cu alte caracteristici SageMaker, precum și flexibilitatea de a vă extinde conducta cu pași rulați în afara SageMaker. . Fiecare pas definește o acțiune pe care o întreprinde conducta. Dependența dintre pași sunt definite de un grafic aciclic direct (DAG) construit folosind SDK-ul Pipelines Python. Puteți construi o conductă SageMaker în mod programatic prin același SDK. După ce o conductă este implementată, puteți opțional să-i vizualizați fluxul de lucru în Studio.

Conductele se integrează automat cu Experimente, creând automat un experiment și o încercare pentru fiecare rulare. Conductele creează automat un experiment și o încercare pentru fiecare rulare a conductei înainte de a rula pașii, cu excepția cazului în care una sau ambele intrări sunt specificate. În timp ce rulează jobul SageMaker al pipelinei, pipeline asociază proba cu experimentul și asociază testului fiecare componentă de încercare creată de job. Specificarea propriului experiment sau încercare în mod programatic vă permite să reglați fin modul de organizare a experimentelor.

Fluxul de lucru pe care îl prezentăm în acest exemplu constă dintr-o serie de pași: un pas de preprocesare pentru a împărți setul de date de intrare în seturi de date de antrenare, de testare și de validare; un pas de reglare pentru a ne regla hiperparametrii și a începe lucrările de antrenament pentru a antrena un model folosind Algoritmul încorporat XGBoost; și, în sfârșit, un pas de model pentru a crea un model SageMaker din cel mai bine antrenat artefact model. Pipelines oferă, de asemenea, mai multe suportate nativ tipuri de trepte în afara celor discutate în această postare. De asemenea, ilustrăm modul în care vă puteți urmări fluxul de lucru în conductă și puteți genera valori și diagrame de comparație. În plus, arătăm cum să asociem noul proces generat cu un experiment existent care ar fi putut fi creat înainte de definirea conductei.

Codul SageMaker Pipelines

Puteți revizui și descărca blocnotesul din GitHub depozit asociat cu această postare. Ne uităm la codul specific Pipelines pentru a-l înțelege mai bine.

Pipelines vă permite să transmiteți parametri în timpul rulării. Aici definim tipurile de instanțe de procesare și antrenare și numărători în timpul rulării cu valori prestabilite:

base_job_prefix = "pipeline-experiment-sample"
model_package_group_name = "pipeline-experiment-model-package"

processing_instance_count = ParameterInteger(
  name="ProcessingInstanceCount", default_value=1
)

training_instance_count = ParameterInteger(
  name="TrainingInstanceCount", default_value=1
)

processing_instance_type = ParameterString(
  name="ProcessingInstanceType", default_value="ml.m5.xlarge"
)
training_instance_type = ParameterString(
  name="TrainingInstanceType", default_value="ml.m5.xlarge"
)

Apoi, am configurat un script de procesare care descarcă și împarte setul de date de intrare în părți de tren, testare și validare. Folosim SKLearnProcessor pentru rularea acestui pas de preprocesare. Pentru a face acest lucru, definim un obiect procesor cu tipul de instanță și numărul necesar pentru a rula jobul de procesare.

Pipelines ne permite să realizăm versiunea datelor într-un mod programatic, folosind variabile specifice execuției, cum ar fi ExecutionVariables.PIPELINE_EXECUTION_ID, care este ID-ul unic al rulării unei conducte. Putem, de exemplu, să creăm o cheie unică pentru stocarea setului de date de ieșire Serviciul Amazon de stocare simplă (Amazon S3) care le leagă de o anumită conductă. Pentru lista completă a variabilelor, consultați Variabile de execuție.

framework_version = "0.23-1"

sklearn_processor = SKLearnProcessor(
    framework_version=framework_version,
    instance_type=processing_instance_type,
    instance_count=processing_instance_count,
    base_job_name="sklearn-ca-housing",
    role=role,
)

process_step = ProcessingStep(
    name="ca-housing-preprocessing",
    processor=sklearn_processor,
    outputs=[
        ProcessingOutput(
            output_name="train",
            source="/opt/ml/processing/train",
            destination=Join(
                on="/",
                values=[
                    "s3://{}".format(bucket),
                    prefix,
                    ExecutionVariables.PIPELINE_EXECUTION_ID,
                    "train",
                ],
            ),
        ),
        ProcessingOutput(
            output_name="validation",
            source="/opt/ml/processing/validation",
            destination=Join(
                on="/",
                values=[
                    "s3://{}".format(bucket),
                    prefix,
                    ExecutionVariables.PIPELINE_EXECUTION_ID,
                    "validation",
                ],
            )
        ),
        ProcessingOutput(
            output_name="test",
            source="/opt/ml/processing/test",
            destination=Join(
                on="/",
                values=[
                    "s3://{}".format(bucket),
                    prefix,
                    ExecutionVariables.PIPELINE_EXECUTION_ID,
                    "test",
                ],
            )
        ),
    ],
    code="california-housing-preprocessing.py",
)

Apoi trecem la crearea unui obiect estimator pentru a antrena un model XGBoost. Setăm niște hiperparametri statici care sunt utilizați în mod obișnuit cu XGBoost:

model_path = f"s3://{default_bucket}/{base_job_prefix}/ca-housing-experiment-pipeline"

image_uri = sagemaker.image_uris.retrieve(
    framework="xgboost",
    region=region,
    version="1.2-2",
    py_version="py3",
    instance_type=training_instance_type,
)

xgb_train = Estimator(
    image_uri=image_uri,
    instance_type=training_instance_type,
    instance_count=training_instance_count,
    output_path=model_path,
    base_job_name=f"{base_job_prefix}/ca-housing-train",
    sagemaker_session=sagemaker_session,
    role=role,
)

xgb_train.set_hyperparameters(
    eval_metric="rmse",
    objective="reg:squarederror",  # Define the object metric for the training job
    num_round=50,
    max_depth=5,
    eta=0.2,
    gamma=4,
    min_child_weight=6,
    subsample=0.7
)

Facem reglajul hiperparametric al modelelor pe care le creăm folosind a ContinuousParameter interval pentru lambda. Alegerea unei metrici care să fie metrica obiectivă îi spune tunerului (instanța care rulează joburile de ajustare a hiperparametrilor) că vei evalua jobul de antrenament pe baza acestei metrici specifice. Tunerul returnează cea mai bună combinație pe baza celei mai bune valori pentru această metrică obiectivă, adică cea mai bună combinație care minimizează cea mai bună eroare pătratică medie (RMSE).

objective_metric_name = "validation:rmse"

hyperparameter_ranges = {
    "lambda": ContinuousParameter(0.01, 10, scaling_type="Logarithmic")
}

tuner = HyperparameterTuner(estimator,
                            objective_metric_name,
                            hyperparameter_ranges,
                            objective_type=objective_type,
                            strategy="Bayesian",
                            max_jobs=10,
                            max_parallel_jobs=3)

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

Etapa de reglare rulează mai multe încercări cu scopul de a determina cel mai bun model dintre intervalele de parametri testate. Cu metoda get_top_model_s3_uri, clasăm primele 50 de versiuni performante ale artefactului model S3 URI și extragem doar versiunea cea mai performantă (specificăm k=0 pentru cel mai bun) pentru a crea un model SageMaker.

model_bucket_key = f"{default_bucket}/{base_job_prefix}/ca-housing-experiment-pipeline"
model_candidate = Model(
    image_uri=image_uri,
    model_data=tune_step.get_top_model_s3_uri(top_k=0, s3_bucket=model_bucket_key),
    sagemaker_session=sagemaker_session,
    role=role,
    predictor_cls=XGBoostPredictor,
)

create_model_step = CreateModelStep(
    name="CreateTopModel",
    model=model_candidate,
    inputs=sagemaker.inputs.CreateModelInput(instance_type="ml.m4.large"),
)

Când rulează pipeline, creează componente de probă pentru fiecare job de ajustare a hiperparametrului și fiecare job SageMaker creat de pașii pipeline.

Puteți configura în continuare integrarea conductelor cu Experimente prin crearea unui PipelineExperimentConfig obiect și transmiteți-l obiectului conductei. Cei doi parametri definesc numele experimentului care va fi creat și proba care se va referi la întreaga rulare a conductei.

Dacă doriți să asociați o rulare pipeline unui experiment existent, îi puteți transmite numele și Pipelines îi va asocia noua încercare. Puteți împiedica crearea unui experiment și a unei încercări pentru o conductă rulată prin setare pipeline_experiment_config la None.

#Pipeline experiment config
ca_housing_experiment_config = PipelineExperimentConfig(
    experiment_name,
    Join(
        on="-",
        values=[
            "pipeline-execution",
            ExecutionVariables.PIPELINE_EXECUTION_ID
        ],
    )
)

Transmitem tipurile de instanțe și contorizează ca parametri și lanțăm pașii precedenți în ordinea următoare. Fluxul de lucru pipeline este implicit definit de ieșirile unui pas fiind intrările unui alt pas.

pipeline_name = f"CAHousingExperimentsPipeline"

pipeline = Pipeline(
    name=pipeline_name,
    pipeline_experiment_config=ca_housing_experiment_config,
    parameters=[
        processing_instance_count,
        processing_instance_type,
        training_instance_count,
        training_instance_type
    ],
    steps=[process_step,tune_step,create_model_step],
)

Conducta cu drepturi depline este acum creată și gata de funcționare. Adăugăm un rol de execuție la conductă și îl pornim. De aici, putem merge la consola SageMaker Studio Pipelines și putem urmări vizual fiecare pas. De asemenea, puteți accesa jurnalele conectate din consolă pentru a depana o conductă.

pipeline.upsert(role_arn=sagemaker.get_execution_role())
execution = pipeline.start()

Captura de ecran precedentă arată cu verde o conductă rulată cu succes. Obținem valorile unei încercări dintr-o rulare a conductei cu următorul cod:

# SM Pipeline injects the Execution ID into trial component names
execution_id = execution.describe()['PipelineExecutionArn'].split('/')[-1]
source_arn_filter = Filter(
    name="TrialComponentName", operator=Operator.CONTAINS, value=execution_id
)

source_type_filter = Filter(
    name="Source.SourceType", operator=Operator.EQUALS, value="SageMakerTrainingJob"
)

search_expression = SearchExpression(
    filters=[source_arn_filter, source_type_filter]
)

trial_component_analytics = ExperimentAnalytics(
    sagemaker_session=sagemaker_session,
    experiment_name=experiment_name,
    search_expression=search_expression.to_boto()
)

analytic_table = trial_component_analytics.dataframe()
analytic_table.head()

Comparați valorile pentru fiecare componentă de probă

Puteți reprezenta rezultatele reglajului hiperparametrului în Studio sau prin alte biblioteci de trasare Python. Vă arătăm ambele moduri de a face acest lucru.

Explorați valorile de instruire și evaluare în Studio

Studio oferă o interfață de utilizator interactivă unde puteți genera diagrame interactive. Pașii sunt următorii:

1. Alege Experimente și încercări de la Resurse SageMaker pictogramă din bara laterală stângă.
2. Alegeți experimentul pentru a-l deschide.
3. Alegeți (clic dreapta) proba de interes.
4. Alege Deschide în lista de componente de probă.
5. Anunturi Schimba pentru a selecta componentele de probă reprezentând locurile de muncă de formare.
6. Alege Adăugați diagramă.
7. Alege Grafic nou și personalizați-l pentru a trasa valorile colectate pe care doriți să le analizați. Pentru cazul nostru de utilizare, alegeți următoarele:
   1. Pentru Tip de dateSelectați Statistici rezumate.
   2. Pentru Tipul graficuluiSelectați Graficul de dispersie.
   3. Pentru Axa X., alege lambda.
   4. Pentru Axa Y., alege validation:rmse_last.

Noua diagramă apare în partea de jos a ferestrei, etichetată ca „8”.

Puteți include mai multe sau mai puține locuri de muncă de formare apăsând Schimba și alegerea pictogramei ochi pentru o experiență mai interactivă.

Analytics cu SageMaker Experiments

Când rularea conductei este completă, putem vizualiza rapid cum se compară diferitele variații ale modelului în ceea ce privește valorile colectate în timpul antrenamentului. Anterior, am exportat toate valorile de încercare în a ursi panda DataFrame folosind ExperimentAnalytics. Putem reproduce diagrama obținută în Studio utilizând biblioteca Matplotlib.

analytic_table.plot.scatter("lambda", "validation:rmse - Last", grid=True)

Concluzie

Integrarea nativă dintre SageMaker Pipelines și SageMaker Experiments permite oamenilor de știință să organizeze, să urmărească și să vizualizeze automat experimentele în timpul activităților de dezvoltare a modelelor. Puteți crea experimente pentru a vă organiza întreaga activitate de dezvoltare a modelului, cum ar fi următoarele:

• Un caz de utilizare în afaceri pe care îl abordați, cum ar fi crearea unui experiment pentru a prezice retragerea clienților
• Un experiment deținut de echipa de știință a datelor cu privire la analiza de marketing, de exemplu
• Un proiect specific de știință a datelor și ML

În această postare, ne-am introdus în Pipelines pentru a arăta cum îl puteți folosi în tandem cu Experimente pentru a organiza un flux de lucru complet automatizat de la capăt la capăt.

Ca pas următor, puteți utiliza aceste trei caracteristici SageMaker – Studio, Experimente și Conducte – pentru următorul dvs. proiect ML.

Lecturi sugerate

Despre autori

Paolo Di Francesco este arhitect de soluții la AWS. Are experiență în telecomunicații și inginerie software. Este pasionat de machine learning și se concentrează în prezent pe utilizarea experienței sale pentru a ajuta clienții să-și atingă obiectivele pe AWS, în special în discuțiile despre MLOps. În afara serviciului, îi place să joace fotbal și să citească.

Mario Bourgoin este un Senior Partner Solutions Architect pentru AWS, un specialist AI/ML și lider tehnologic global pentru MLOps. Lucrează cu clienți și parteneri întreprinderi care implementează soluții AI în cloud. Are peste 30 de ani de experiență în învățarea automată și AI la startup-uri și în întreprinderi, începând cu crearea unuia dintre primele sisteme comerciale de învățare automată pentru date mari. Mario își petrece timpul liber jucându-se cu cei trei Tervuren belgieni ai săi, gătind cina pentru familia sa și învățând despre matematică și cosmologie.

Ganapathi Krishnamoorthi este arhitect senior de soluții ML la AWS. Ganapathi oferă îndrumări prescriptive clienților startup și companiilor, ajutându-i să proiecteze și să implementeze aplicații cloud la scară. El este specializat în învățarea automată și se concentrează pe a ajuta clienții să folosească AI/ML pentru rezultatele lor de afaceri. Când nu este la serviciu, îi place să exploreze în aer liber și să asculte muzică.

Valerie Sounthakith este arhitect de soluții pentru AWS, care lucrează în industria jocurilor de noroc și cu parteneri care implementează soluții AI. Ea își propune să-și construiască cariera în jurul Computer Vision. În timpul liber, Valerie îl petrece pentru a călători, pentru a descoperi noi locuri de mâncare și pentru a-și schimba interiorul casei.