Zorganizuj swoją podróż do uczenia maszynowego dzięki eksperymentom Amazon SageMaker i Amazon SageMaker Pipelines

Proces tworzenia modelu uczenia maszynowego (ML) jest iteracyjny, dopóki nie znajdziesz modelu kandydata, który działa dobrze i jest gotowy do wdrożenia. Gdy analitycy danych przechodzą przez ten proces, potrzebują niezawodnej metody łatwego śledzenia eksperymentów, aby zrozumieć, w jaki sposób została zbudowana każda wersja modelu i jak działała.

Amazon Sage Maker umożliwia zespołom korzystanie z szerokiej gamy funkcji do szybkiego przygotowywania, budowania, trenowania, wdrażania i monitorowania modeli ML. Rurociągi Amazon SageMaker zapewnia powtarzalny proces iteracji przez czynności budowania modelu i jest zintegrowany z Eksperymenty Amazon SageMaker. Domyślnie każdy potok programu SageMaker jest powiązany z eksperymentem, a każdy przebieg tego potoku jest śledzony jako próba w tym eksperymencie. Następnie Twoje iteracje są automatycznie śledzone bez żadnych dodatkowych kroków.

W tym poście przyjrzymy się bliżej motywacji stosowania zautomatyzowanego procesu śledzenia eksperymentów z eksperymentami i natywnych możliwości wbudowanych w Pipelines.

Dlaczego ważne jest organizowanie eksperymentów?

Cofnijmy się na chwilę i spróbujmy zrozumieć, dlaczego organizowanie eksperymentów pod kątem uczenia maszynowego jest ważne. Gdy analitycy danych podchodzą do nowego problemu z ML, muszą odpowiedzieć na wiele różnych pytań, od dostępności danych po sposób pomiaru wydajności modelu.

Na początku proces jest pełen niepewności i jest wysoce iteracyjny. W rezultacie ta faza eksperymentowania może generować wiele modeli, z których każdy jest tworzony na podstawie własnych danych wejściowych (zestawów danych, skryptów szkoleniowych i hiperparametrów) i wytwarzać własne dane wyjściowe (artefakty modeli i metryki oceny). Wyzwaniem jest zatem śledzenie wszystkich tych danych wejściowych i wyjściowych każdej iteracji.

Analitycy danych zazwyczaj szkolą wiele różnych wersji modelu, dopóki nie znajdą kombinacji transformacji danych, algorytmu i hiperparametrów, która skutkuje najlepszą wydajną wersją modelu. Każda z tych unikalnych kombinacji to pojedynczy eksperyment. Dzięki możliwemu do prześledzenia zapisowi danych wejściowych, algorytmów i hiperparametrów użytych w tej próbie zespół analityków danych może z łatwością odtworzyć swoje kroki.

Posiadanie zautomatyzowanego procesu śledzenia eksperymentów poprawia możliwość odtwarzania, a także wdrażania określonych, dobrze działających wersji modeli. Natywna integracja Pipelines z Experiments ułatwia automatyczne śledzenie eksperymentów i zarządzanie nimi w przebiegu potoku.

Korzyści z eksperymentów SageMaker

SageMaker Experiments pozwala analitykom danych organizować, śledzić, porównywać i oceniać ich iteracje szkoleniowe.

Zacznijmy najpierw od przeglądu tego, co możesz zrobić za pomocą eksperymentów:

• Organizuj eksperymenty – Eksperymenty strukturyzują eksperymentowanie z encją najwyższego poziomu o nazwie an eksperyment który zawiera zestaw Próby. Każda próba zawiera zestaw kroków zwanych komponenty próbne. Każdy komponent próbny jest kombinacją zbiorów danych, algorytmów i parametrów. Eksperymenty można zobrazować jako folder najwyższego poziomu do organizowania hipotez, próby jako podfoldery dla każdego przebiegu testu grupowego, a składniki próbne jako pliki dla każdego wystąpienia przebiegu testowego.
• Śledź eksperymenty – Eksperymenty umożliwiają analitykom danych śledzenie eksperymentów. Oferuje możliwość automatycznego przypisywania zadań SageMaker do wersji próbnej za pomocą prostych konfiguracji i śledzenia SDK.
• Porównaj i oceń eksperymenty – Integracja Eksperymentów z Studio Amazon SageMaker ułatwia tworzenie wizualizacji danych i porównywanie różnych prób. Możesz również uzyskać dostęp do danych próbnych za pośrednictwem pakietu Python SDK, aby wygenerować własną wizualizację przy użyciu preferowanych bibliotek kreślenia.

Aby dowiedzieć się więcej o interfejsach Experiments API i SDK, zalecamy zapoznanie się z następującą dokumentacją: Utwórz eksperyment i Amazon SageMaker Eksperymenty Python SDK.

Jeśli chcesz zanurkować głębiej, zalecamy zapoznanie się z amazon-sagemaker-examples/sagemaker-experiments repozytorium GitHub dla dalszych przykładów.

Integracja między rurociągami a eksperymentami

Potoki budowania modeli, które są częścią Pipelines, są specjalnie zbudowane dla ML i umożliwiają organizowanie zadań budowania modelu za pomocą narzędzia potoku, które obejmuje natywne integracje z innymi funkcjami SageMaker, a także elastyczność w rozszerzaniu potoku o kroki uruchamiane poza SageMaker . Każdy krok definiuje akcję podejmowaną przez potok. Zależności między krokami są definiowane przez bezpośredni wykres acykliczny (DAG) zbudowany przy użyciu pakietu Pipelines Python SDK. Możesz zbudować potok SageMaker programowo za pomocą tego samego zestawu SDK. Po wdrożeniu potoku możesz opcjonalnie zwizualizować jego przepływ pracy w Studio.

Pipelines automatycznie integruje się z eksperymentami, automatycznie tworząc eksperyment i próbę dla każdego uruchomienia. Potoki automatycznie tworzą eksperyment i próbę dla każdego uruchomienia potoku przed uruchomieniem kroków, chyba że określono jeden lub oba z tych danych wejściowych. Podczas uruchamiania zadania SageMaker potoku potok kojarzy wersję próbną z eksperymentem i kojarzy z wersją próbną każdy składnik próbny utworzony przez zadanie. Programowe określenie własnego eksperymentu lub wersji próbnej umożliwia precyzyjne dostosowanie sposobu organizacji eksperymentów.

Przepływ pracy, który przedstawiamy w tym przykładzie, składa się z szeregu kroków: kroku wstępnego przetwarzania, który dzieli nasz wejściowy zestaw danych na zestawy danych do trenowania, testowania i walidacji; krok dostrajania, aby dostroić nasze hiperparametry i rozpocząć zadania szkoleniowe, aby trenować model za pomocą Wbudowany algorytm XGBoost; i wreszcie krok modelu, aby utworzyć model SageMaker z najlepiej wytrenowanego artefaktu modelu. Pipelines oferuje również kilka obsługiwanych natywnie typy kroków poza tym, co omówiono w tym poście. Przedstawiamy również, w jaki sposób można śledzić przepływ pracy w potoku i generować metryki oraz wykresy porównawcze. Ponadto pokazujemy, jak powiązać nową wygenerowaną wersję próbną z istniejącym eksperymentem, który mógł zostać utworzony przed zdefiniowaniem potoku.

Kod potoków SageMaker

Notatnik możesz przejrzeć i pobrać z Repozytorium GitHub powiązane z tym postem. Przyglądamy się kodowi specyficznemu dla Pipelines, aby lepiej go zrozumieć.

Pipelines umożliwia przekazywanie parametrów w czasie wykonywania. Tutaj definiujemy typy instancji przetwarzania i trenowania oraz ich liczbę w czasie wykonywania z wstępnie ustawionymi wartościami domyślnymi:

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

Następnie konfigurujemy skrypt przetwarzania, który pobiera i dzieli wejściowy zestaw danych na części do trenowania, testowania i walidacji. Używamy SKLearnProcessor do uruchomienia tego etapu wstępnego przetwarzania. W tym celu definiujemy obiekt procesora z typem instancji i liczbą potrzebną do uruchomienia zadania przetwarzania.

Pipelines pozwala nam uzyskać wersjonowanie danych w sposób programistyczny przy użyciu zmiennych specyficznych dla wykonania, takich jak ExecutionVariables.PIPELINE_EXECUTION_ID, który jest unikalnym identyfikatorem uruchomienia potoku. Możemy na przykład stworzyć unikalny klucz do przechowywania wyjściowych zbiorów danych w Usługa Amazon Simple Storage (Amazon S3), który wiąże je z określonym przebiegiem rurociągu. Pełna lista zmiennych znajduje się w Zmienne wykonania.

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

Następnie przechodzimy do utworzenia obiektu estymatora, aby wytrenować model XGBoost. Ustawiamy kilka statycznych hiperparametrów, które są powszechnie używane w 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
)

Wykonujemy strojenie hiperparametrów tworzonych przez nas modeli za pomocą a ContinuousParameter zakres dla lambda. Wybranie jednej metryki jako metryki obiektywnej informuje tuner (instancję, która uruchamia zadania dostrajania hiperparametrów), że ocenisz zadanie uczenia na podstawie tej konkretnej metryki. Tuner zwraca najlepszą kombinację w oparciu o najlepszą wartość dla tej obiektywnej metryki, co oznacza najlepszą kombinację, która minimalizuje najlepszy błąd średniokwadratowy (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",
        ),
    } 
)

Na etapie strojenia przeprowadza się wiele prób w celu określenia najlepszego modelu spośród testowanych zakresów parametrów. Metodą get_top_model_s3_uri, klasyfikujemy 50 najskuteczniejszych wersji artefaktu modelu S3 URI i wyodrębniamy tylko wersję o największej skuteczności (określamy k=0 najlepiej), aby stworzyć 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"),
)

Po uruchomieniu potoku tworzy komponenty próbne dla każdego zadania dostrajania hiperparametrów i każdego zadania programu SageMaker utworzonego przez kroki potoku.

Możesz dalej skonfigurować integrację potoków z eksperymentami, tworząc PipelineExperimentConfig obiektu i przekaż go do obiektu potoku. Te dwa parametry definiują nazwę eksperymentu, który zostanie utworzony, oraz próbę, która będzie odnosić się do całego przebiegu potoku.

Jeśli chcesz skojarzyć przebieg potoku z istniejącym eksperymentem, możesz przekazać jego nazwę, a Pipelines skojarzy z nim nową wersję próbną. Możesz zapobiec tworzeniu eksperymentu i wersji próbnej dla potoku uruchamianego przez ustawienie pipeline_experiment_config do None.

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

Przekazujemy typy wystąpień i liczniki jako parametry i łączymy poprzednie kroki w następującej kolejności. Przepływ pracy potoku jest niejawnie definiowany przez dane wyjściowe kroku będące danymi wejściowymi innego kroku.

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

Pełnoprawny potok jest teraz utworzony i gotowy do pracy. Dodajemy rolę wykonania do potoku i uruchamiamy go. Stąd możemy przejść do konsoli SageMaker Studio Pipelines i wizualnie śledzić każdy krok. Możesz również uzyskać dostęp do połączonych dzienników z konsoli, aby debugować potok.

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

Powyższy zrzut ekranu pokazuje na zielono pomyślnie uruchomiony potok. Metryki jednej próby uzyskujemy z przebiegu potoku z następującym kodem:

# 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()

Porównaj metryki dla każdego komponentu próbnego

Wyniki dostrajania hiperparametrów można wykreślić w programie Studio lub za pośrednictwem innych bibliotek kreślenia języka Python. Pokazujemy oba sposoby robienia tego.

Poznaj dane treningowe i ewaluacyjne w Studio

Studio udostępnia interaktywny interfejs użytkownika, w którym można generować interaktywne wykresy. Kroki są następujące:

1. Dodaj Eksperymenty i próby z Zasoby SageMaker ikona na lewym pasku bocznym.
2. Wybierz eksperyment, aby go otworzyć.
3. Wybierz (kliknij prawym przyciskiem myszy) interesującą Cię wersję próbną.
4. Dodaj Otwórz na liście komponentów próbnych.
5. Naciśnij przycisk Shift aby wybrać komponenty próbne reprezentujące zadania szkoleniowe.
6. Dodaj Dodaj wykres.
7. Dodaj Nowy wykres i dostosuj go, aby wykreślić zebrane metryki, które chcesz przeanalizować. W naszym przypadku zastosowania wybierz:
   1. W razie zamówieenia projektu Typ danychWybierz Statystyki podsumowujące.
   2. W razie zamówieenia projektu typ wykresuWybierz Wykres punktowy.
   3. W razie zamówieenia projektu Oś Xwybierz lambda.
   4. W razie zamówieenia projektu Oś Ywybierz validation:rmse_last.

Nowy wykres pojawi się na dole okna, oznaczony jako „8”.

Możesz dodać więcej lub mniej zadań szkoleniowych, naciskając Shift i wybierając ikonę oka, aby uzyskać bardziej interaktywne wrażenia.

Analityka z eksperymentami SageMaker

Po zakończeniu przebiegu potoku możemy szybko zwizualizować porównanie różnych odmian modelu pod względem metryk zebranych podczas uczenia. Wcześniej wyeksportowaliśmy wszystkie metryki próbne do Pandy DataFrame za pomocą ExperimentAnalytics. Wykres uzyskany w Studio możemy odtworzyć za pomocą biblioteki Matplotlib.

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

Wnioski

Natywna integracja między SageMaker Pipelines i SageMaker Experiments umożliwia analitykom danych automatyczne organizowanie, śledzenie i wizualizację eksperymentów podczas działań związanych z opracowywaniem modeli. Możesz tworzyć eksperymenty, aby uporządkować wszystkie prace związane z rozwojem modelu, takie jak:

• Biznesowy przypadek użycia, którym się zajmujesz, np. tworzenie eksperymentu w celu przewidzenia rezygnacji klientów
• Na przykład eksperyment należący do zespołu data science dotyczący analityki marketingowej
• Konkretny projekt data science i ML

W tym poście zagłębiliśmy się w Pipelines, aby pokazać, jak można go używać w połączeniu z eksperymentami w celu zorganizowania w pełni zautomatyzowanego, kompleksowego przepływu pracy.

W następnym kroku możesz użyć tych trzech funkcji SageMaker – Studio, Eksperymenty i Potoki – w swoim następnym projekcie ML.

Sugerowane odczyty

O autorach

Paolo di Francesco jest architektem rozwiązań w AWS. Posiada doświadczenie w telekomunikacji i inżynierii oprogramowania. Pasjonuje się uczeniem maszynowym i obecnie koncentruje się na wykorzystaniu swojego doświadczenia, aby pomóc klientom osiągnąć ich cele w AWS, w szczególności w dyskusjach na temat MLOps. Poza pracą lubi grać w piłkę i czytać.

Mario Bourgoina jest Senior Partner Solutions Architect dla AWS, specjalistą AI/ML i globalnym liderem technologicznym dla MLOps. Współpracuje z klientami korporacyjnymi i partnerami wdrażającymi rozwiązania AI w chmurze. Ma ponad 30-letnie doświadczenie w uczeniu maszynowym i sztucznej inteligencji w startupach i przedsiębiorstwach, zaczynając od stworzenia jednego z pierwszych komercyjnych systemów uczenia maszynowego dla big data. Mario spędza wolny czas bawiąc się ze swoimi trzema belgijskimi tervurenami, gotując obiad dla swojej rodziny oraz ucząc się matematyki i kosmologii.

Ganapathi Krishnamoorthi jest starszym architektem rozwiązań ML w AWS. Ganapathi zapewnia nakazowe wskazówki klientom rozpoczynającym działalność i klientom korporacyjnym, pomagając im projektować i wdrażać aplikacje w chmurze na dużą skalę. Specjalizuje się w uczeniu maszynowym i koncentruje się na pomaganiu klientom w wykorzystywaniu AI/ML do osiągania wyników biznesowych. Kiedy nie jest w pracy, lubi zwiedzać plener i słuchać muzyki.

Valerie Sounthakith jest architektem rozwiązań dla AWS, pracującym w branży gier oraz z partnerami wdrażającymi rozwiązania AI. Swoją karierę zamierza budować wokół Computer Vision. W wolnym czasie Valerie spędza go na podróżach, odkrywaniu nowych miejsc do jedzenia i zmienianiu wnętrz swojego domu.