Śledź swoje eksperymenty ML od początku do końca dzięki kontroli wersji danych i eksperymentom Amazon SageMaker

Naukowcy zajmujący się danymi często pracują nad zrozumieniem skutków różnych strategii wstępnego przetwarzania danych i inżynierii funkcji w połączeniu z różnymi architekturami modeli i hiperparametrami. Wymaga to iteracyjnego pokrywania dużych przestrzeni parametrów, a śledzenie wcześniej uruchomionych konfiguracji i wyników przy jednoczesnym zachowaniu powtarzalności eksperymentów może być przytłaczające.

W tym poście przedstawiono przykład śledzenia eksperymentów w kodzie, danych, artefaktach i wskaźnikach przy użyciu Eksperymenty Amazon SageMaker w połączeniu z Kontrola wersji danych (DVC). Pokazujemy, jak możesz używać DVC obok Amazon Sage Maker prace związane z przetwarzaniem i szkoleniem. Szkolimy różne modele CatBoost na zbiorze danych dotyczących domów w Kalifornii od Repozytorium StatLibi zmieniaj strategie wstrzymania, śledząc wersję danych za pomocą DVC. W każdym indywidualnym eksperymencie śledzimy artefakty wejściowe i wyjściowe, kod i metryki za pomocą eksperymentów SageMaker.

Eksperymenty SageMakera

SageMaker Experiments to usługa AWS do śledzenia eksperymentów uczenia maszynowego (ML). The SageMaker Eksperymenty Python SDK to wysokopoziomowy interfejs do tej usługi, który pomaga śledzić informacje o eksperymencie za pomocą języka Python.

Celem programu SageMaker Experiments jest maksymalne uproszczenie tworzenia eksperymentów, wypełnianie ich próbami, dodawanie informacji o śledzeniu i pochodzeniu oraz przeprowadzanie analiz w ramach prób i eksperymentów.

Omawiając eksperymenty SageMaker, odwołujemy się do następujących pojęć:

• Eksperyment – Zbiór powiązanych prób. Dodajesz próby do eksperymentu, który chcesz ze sobą porównać.
• Trial – Opis wieloetapowego przepływu pracy ML. Każdy etap przepływu pracy jest opisany przez komponent próbny.
• Komponent próbny – Opis pojedynczego kroku w przepływie pracy ML, takiego jak czyszczenie danych, wyodrębnianie funkcji, uczenie modelu lub ocena modelu.
• Tracker – Menedżer kontekstu Pythona do rejestrowania informacji o pojedynczym komponencie próbnym (na przykład parametry, metryki lub artefakty).

Kontrola wersji danych

Kontrola wersji danych (DVC) to nowy rodzaj oprogramowania do wersjonowania danych, przepływu pracy i zarządzania eksperymentami, które opiera się na git (chociaż może działać samodzielnie). DVC zmniejsza lukę między ustalonymi zestawami narzędzi inżynierskich a potrzebami w zakresie analizy danych, umożliwiając korzystanie z nowych cechy przy ponownym wykorzystaniu posiadanych umiejętności i intuicji.

Udostępnianie i współpraca w ramach eksperymentów związanych z nauką o danych może odbywać się za pośrednictwem zwykłego przepływu Git (zatwierdzanie, rozgałęzianie, tagowanie, pull requesty) w taki sam sposób, w jaki działa to dla inżynierów oprogramowania. Dzięki Git i DVC zespoły zajmujące się analizą danych i ML mogą wersjonować eksperymenty, zarządzać dużymi zestawami danych i odtwarzać projekty.

DVC ma następujące funkcje:

• DVC to za darmo, otwarte źródło linii poleceń narzędziem.
• DVC działa na repozytoriach Git i ma podobny interfejs wiersza poleceń i przepływ jak Git. DVC może również działać samodzielnie, ale bez wersjonowanie możliwości.
• Wersjonowanie danych jest możliwe poprzez zastąpienie dużych plików, katalogów zestawów danych, modeli ML itd. małymi metapliki (łatwy w obsłudze z Git). Te symbole zastępcze wskazują oryginalne dane, które są oddzielone od zarządzania kodem źródłowym.
• Możesz użyć magazynu lokalnego lub w chmurze, aby przechowywać dane projektu oddzielnie od jego bazy kodu. W ten sposób analitycy danych mogą przesyłać duże zestawy danych lub udostępniać innym model wytrenowany przez procesor GPU.
• DVC sprawia, że ​​projekty analizy danych są odtwarzalne, tworząc lekkie rurociągi przy użyciu niejawnych grafów zależności oraz przez kodyfikację danych i artefaktów.
• DVC jest niezależny od platformy. Działa na wszystkich głównych systemach operacyjnych (Linux, macOS i Windows) i działa niezależnie od języków programowania (Python, R, Julia, skrypty powłoki itp.) lub bibliotek ML (Keras, TensorFlow, PyTorch, Scipy i więcej) wykorzystanych w projekcie.
• DVC jest szybki do zainstalować i nie wymaga specjalnej infrastruktury ani nie zależy od interfejsów API ani usług zewnętrznych. Jest to samodzielne narzędzie CLI.

Eksperymenty SageMaker i próbka DVC

Poniższy Próbka GitHub pokazuje, jak korzystać z DVC w środowisku SageMaker. W szczególności przyjrzymy się, jak zbudować niestandardowy obraz z domyślnie zainstalowanymi bibliotekami DVC, aby zapewnić spójne środowisko programistyczne dla analityków danych w Studio Amazon SageMakeroraz jak uruchomić DVC wraz z infrastrukturą zarządzaną przez SageMaker na potrzeby przetwarzania i szkolenia. Ponadto pokazujemy, jak wzbogacić informacje o śledzeniu SageMaker o informacje o wersji danych z DVC i zwizualizować je w konsoli Studio.

Poniższy diagram ilustruje architekturę rozwiązania i przepływ pracy.

Utwórz niestandardowy obraz Studio z już zainstalowanym DVC

W tym Repozytorium GitHub, wyjaśniamy, jak utworzyć niestandardowy obraz dla programu Studio, w którym zainstalowano już DVC. Zaletą tworzenia obrazu i udostępniania go wszystkim użytkownikom Studio jest to, że tworzy spójne środowisko dla użytkowników Studio, które mogą również uruchamiać lokalnie. Chociaż próbka jest oparta na Chmura AWS9, możesz również zbudować kontener na komputerze lokalnym, o ile masz zainstalowany i uruchomiony Docker. Ta próbka jest oparta na następujących Dockerfile i środowisko.yml. Wynikowy obraz Dockera jest przechowywany w Rejestr elastycznego pojemnika Amazon (Amazon EMR) na Twoim koncie AWS. Zobacz następujący kod:

# Login to ECR
aws --region ${REGION} ecr get-login-password | docker login --username AWS --password-stdin ${ACCOUNT_ID}.dkr.ecr.${REGION}.amazonaws.com/smstudio-custom

# Create the ECR repository
aws --region ${REGION} ecr create-repository --repository-name smstudio-custom

# Build the image - it might take a few minutes to complete this step
docker build . -t ${IMAGE_NAME} -t ${ACCOUNT_ID}.dkr.ecr.${REGION}.amazonaws.com/smstudio-custom:${IMAGE_NAME}

# Push the image to ECR
docker push ${ACCOUNT_ID}.dkr.ecr.${REGION}.amazonaws.com/smstudio-custom:${IMAGE_NAME}

Możesz teraz utwórz nową domenę Studio or zaktualizować istniejącą domenę Studio który ma dostęp do nowo utworzonego obrazu Docker.

Używamy pliki Zestaw programistyczny AWS Cloud (AWS CDK), aby utworzyć następujące zasoby za pomocą Tworzenie chmury AWS:

• Rola wykonawcza SageMaker z odpowiednimi uprawnieniami do nowej lub istniejącej domeny Studio
• Obraz SageMaker i wersja obrazu SageMaker z obrazu Docker conda-env-dvc-kernel które stworzyliśmy wcześniej
• An AppImageConfig która określa, jak powinna być skonfigurowana brama jądra
• Użytkownik Studio (data-scientist-dvc) z odpowiednią rolą wykonawczą SageMaker i dostępnym dla niej niestandardowym obrazem Studio

Aby uzyskać szczegółowe instrukcje, zobacz Powiąż niestandardowy obraz z SageMaker Studio.

Uruchom laboratorium

Aby uruchomić laboratorium, wykonaj następujące czynności:

1. W domenie Studio uruchom Studio dla data-scientist-dvc użytkownika.
2. Wybierz ikonę Git, a następnie wybierz Sklonuj repozytorium.
   
3. Wprowadź adres URL repozytorium (https://github.com/aws-samples/amazon-sagemaker-experiments-dvc-demo) i wybierz Clone.
4. W przeglądarce plików wybierz amazon-sagemaker-experiments-dvc-demo magazyn.
5. Otwórz dvc_sagemaker_script_mode.ipynb notatnik.
6. W razie zamówieenia projektu Obraz niestandardowy, wybierz obraz conda-env-dvc-kernel.
7. Dodaj Wybierz.
   

Skonfiguruj DVC do przechowywania wersji danych

Tworzymy podkatalog, w którym przygotowujemy dane: sagemaker-dvc-sample. W ramach tego podkatalogu inicjujemy nowe repozytorium Git i ustawiamy pilota na repozytorium, które tworzymy w Zatwierdzenie kodu AWS. Celem jest posiadanie w tym repozytorium wersji konfiguracji i plików DVC do śledzenia danych. Jednak Git oferuje natywne możliwości zarządzania podprojektami za pomocą, na przykład, podmodułów git i poddrzew git, a ten przykład można rozszerzyć, aby używać dowolnego z wyżej wymienionych narzędzi, które najlepiej pasują do Twojego przepływu pracy.

Główną zaletą korzystania z CodeCommit z SageMaker w naszym przypadku jest jego integracja z AWS Zarządzanie tożsamością i dostępem (IAM) do uwierzytelniania i autoryzacji, co oznacza, że ​​możemy używać ról uprawnień do wypychania i pobierania danych bez konieczności pobierania poświadczeń (lub kluczy SSH). Ustawienie odpowiednich uprawnień w roli wykonawczej SageMaker umożliwia również bezpieczną interakcję z notatnikiem Studio oraz zadaniem szkolenia i przetwarzania SageMaker z CodeCommit.

Chociaż możesz zastąpić CodeCommit dowolną inną usługą kontroli źródła, taką jak GitHub, Gitlab lub Bitbucket, musisz rozważyć, jak obsługiwać poświadczenia dla swojego systemu. Jedną z możliwości jest przechowywanie tych danych uwierzytelniających na Menedżer tajemnic AWS i pobierać je w czasie wykonywania z notatnika Studio, a także z zadań przetwarzania i szkolenia programu SageMaker.

Przetwarzaj i trenuj z DVC i SageMaker

W tej sekcji omówimy dwa różne podejścia do rozwiązania naszego problemu oraz sposób, w jaki możemy śledzić dwa testy przy użyciu eksperymentów SageMaker zgodnie z architekturą koncepcyjną wysokiego poziomu, którą pokazaliśmy wcześniej.

Skonfiguruj eksperyment SageMaker

Aby śledzić ten test w SageMaker, musimy stworzyć eksperyment. Musimy również zdefiniować próbę w eksperymencie. Dla uproszczenia rozważamy tylko jedną próbę w eksperymencie, ale możesz mieć dowolną liczbę prób w eksperymencie, na przykład, jeśli chcesz przetestować różne algorytmy.

Tworzymy eksperyment o nazwie DEMO-sagemaker-experiments-dvc z dwoma próbami, dvc-trial-single-file i dvc-trial-multi-files, z których każdy reprezentuje inną wersję zestawu danych.

Stwórzmy DEMO-sagemaker-experiments-dvc eksperyment:

from smexperiments.experiment import Experiment
from smexperiments.trial import Trial
from smexperiments.trial_component import TrialComponent
from smexperiments.tracker import Tracker

experiment_name = 'DEMO-sagemaker-experiments-dvc'

# create the experiment if it doesn't exist
try:
    my_experiment = Experiment.load(experiment_name=experiment_name)
    print("existing experiment loaded")
except Exception as ex:
    if "ResourceNotFound" in str(ex):
        my_experiment = Experiment.create(
            experiment_name = experiment_name,
            description = "How to integrate DVC"
        )
        print("new experiment created")
    else:
        print(f"Unexpected {ex}=, {type(ex)}")
        print("Dont go forward!")
        raise

Test 1: Generuj pojedyncze pliki do szkolenia i walidacji

W tej sekcji tworzymy skrypt przetwarzania, który pobiera surowe dane bezpośrednio z Usługa Amazon Simple Storage (Amazon S3) jako wejście; przetwarza je w celu utworzenia zestawów danych dotyczących pociągów, walidacji i testów; i przechowuje wyniki z powrotem w Amazon S3 za pomocą DVC. Ponadto pokazujemy, w jaki sposób można śledzić artefakty wyjściowe generowane przez DVC za pomocą programu SageMaker podczas wykonywania zadań przetwarzania i szkolenia oraz za pomocą eksperymentów SageMaker.

Najpierw tworzymy dvc-trial-single-file próbny i dodaj go do DEMO-sagemaker-experiments-dvc eksperyment. Dzięki temu wszystkie elementy próbne związane z tym testem są zorganizowane w sensowny sposób.

first_trial_name = "dvc-trial-single-file"

try:
    my_first_trial = Trial.load(trial_name=first_trial_name)
    print("existing trial loaded")
except Exception as ex:
    if "ResourceNotFound" in str(ex):
        my_first_trial = Trial.create(
            experiment_name=experiment_name,
            trial_name=first_trial_name,
        )
        print("new trial created")
    else:
        print(f"Unexpected {ex}=, {type(ex)}")
        print("Dont go forward!")
        raise

Użyj DVC w zadaniu przetwarzania SageMaker, aby utworzyć wersję pojedynczego pliku

W tej sekcji tworzymy skrypt przetwarzania, który pobiera nieprzetworzone dane bezpośrednio z Amazon S3 jako dane wejściowe, korzystając z możliwości zarządzania danymi ładowania programu SageMaker; przetwarza je w celu utworzenia zestawów danych dotyczących pociągów, walidacji i testów; i przechowuje wyniki z powrotem w Amazon S3 za pomocą DVC. Bardzo ważne jest, aby zrozumieć, że używając DVC do przechowywania danych w Amazon S3 (lub pobierania danych z Amazon S3), tracimy możliwości ładowania danych zarządzanych przez SageMaker, co może potencjalnie mieć wpływ na wydajność i koszty naszych zadań przetwarzania i szkolenia , zwłaszcza podczas pracy z bardzo dużymi zestawami danych. Aby uzyskać więcej informacji na temat różnych funkcji natywnych trybów wprowadzania programu SageMaker, zobacz Dostęp do danych treningowych.

Wreszcie, ujednolicamy możliwości śledzenia DVC z funkcjami śledzenia SageMaker podczas przetwarzania zadań za pośrednictwem SageMaker Experiments.

Skrypt przetwarzania oczekuje adresu repozytorium Git i gałęzi, którą chcemy utworzyć do przechowywania metadanych DVC przekazywanych przez zmienne środowiskowe. Same zestawy danych są przechowywane w Amazon S3 przez DVC. Chociaż zmienne środowiskowe są automatycznie śledzone w programie SageMaker Experiments i widoczne w parametrach komponentu próbnego, możemy wzbogacić komponenty próbne o dodatkowe informacje, które następnie staną się dostępne do wizualizacji w interfejsie użytkownika Studio za pomocą obiektu śledzenia. W naszym przypadku parametry komponentów próbnych obejmują:

• DVC_REPO_URL
• DVC_BRANCH
• USER
• data_commit_hash
• train_test_split_ratio

Skrypt przetwarzania wstępnego klonuje repozytorium Git; generuje zestawy danych o pociągu, walidacji i testach; i synchronizuje go za pomocą DVC. Jak wspomniano wcześniej, podczas korzystania z DVC nie możemy korzystać z natywnych możliwości ładowania danych programu SageMaker. Oprócz obniżenia wydajności, które możemy ponieść w przypadku dużych zestawów danych, tracimy również możliwości automatycznego śledzenia artefaktów wyjściowych. Jednak dzięki trackerowi i DVC Python API możemy zrekompensować te niedociągnięcia, pobrać takie informacje w czasie wykonywania i przechowywać je w komponencie próbnym przy niewielkim wysiłku. Wartością dodaną w ten sposób jest posiadanie w jednym widoku artefaktów wejściowych i wyjściowych, które należą do tego konkretnego zadania przetwarzania.

Pełny skrypt Pythona do wstępnego przetwarzania jest dostępny w GitHub repo.

with Tracker.load() as tracker:
    tracker.log_parameters({"data_commit_hash": commit_hash})
    for file_type in file_types:
        path = dvc.api.get_url(
            f"{data_path}/{file_type}/california_{file_type}.csv",
            repo=dvc_repo_url,
            rev=dvc_branch
        )
        tracker.log_output(name=f"california_{file_type}",value=path)

SageMaker daje nam możliwość uruchomienia naszego skryptu przetwarzania na obrazach kontenerów zarządzanych przez AWS, które są zoptymalizowane do działania w infrastrukturze AWS. Jeśli nasz skrypt wymaga dodatkowych zależności, możemy dostarczyć a requirements.txt plik. Kiedy rozpoczynamy zadanie przetwarzania, SageMaker używa pip-install zainstalować wszystkie potrzebne nam biblioteki (na przykład biblioteki związane z DVC). Jeśli potrzebujesz ściślejszej kontroli nad wszystkimi bibliotekami zainstalowanymi w kontenerach, możesz wprowadzić własny kontener w SageMaker, na przykład dla przetwarzanie i trening.

Mamy teraz wszystkie składniki potrzebne do wykonania naszej pracy związanej z przetwarzaniem SageMaker:

• Skrypt przetwarzający, który może przetwarzać kilka argumentów (--train-test-split-ratio) i dwie zmienne środowiskowe (DVC_REPO_URL i DVC_BRANCH)
• A requiremets.txt filet
• Repozytorium Git (w CodeCommit)
• Eksperyment i próba SageMakera

from sagemaker.processing import FrameworkProcessor, ProcessingInput
from sagemaker.sklearn.estimator import SKLearn

dvc_repo_url = "codecommit::{}://sagemaker-dvc-sample".format(region)
dvc_branch = my_first_trial.trial_name

script_processor = FrameworkProcessor(
    estimator_cls=SKLearn,
    framework_version='0.23-1',
    instance_count=1,
    instance_type='ml.m5.xlarge',
    env={
        "DVC_REPO_URL": dvc_repo_url,
        "DVC_BRANCH": dvc_branch,
        "USER": "sagemaker"
    },
    role=role
)

experiment_config={
    "ExperimentName": my_experiment.experiment_name,
    "TrialName": my_first_trial.trial_name
}

Następnie uruchamiamy zadanie przetwarzania za pomocą preprocessing-experiment.py scenariusz, experiment_config, dvc_repo_url, dvc_branch zdefiniowaliśmy wcześniej.

%%time

script_processor.run(
    code='./source_dir/preprocessing-experiment.py',
    dependencies=['./source_dir/requirements.txt'],
    inputs=[ProcessingInput(source=s3_data_path, destination="/opt/ml/processing/input")],
    experiment_config=experiment_config,
    arguments=["--train-test-split-ratio", "0.2"]
)

Zadanie przetwarzania trwa około 5 minut. Teraz możesz wyświetlić szczegóły wersji próbnej dla pojedynczego zbioru danych.

Poniższy zrzut ekranu pokazuje, gdzie można znaleźć przechowywane informacje w Studio. Zanotuj wartości dla dvc-trial-single-file in DVC_BRANCH, DVC_REPO_URL, data_commit_hash na parametry patka.

Zwróć także uwagę na szczegóły wejścia i wyjścia na Artefakty patka.

Utwórz estymator i dopasuj model do wersji danych z jednego pliku

Aby skorzystać z integracji DVC w ramach pracy szkoleniowej SageMaker, przekazujemy dvc_repo_url i dvc_branch jako zmienne środowiskowe podczas tworzenia obiektu Estimator.

Trenujemy na dvc-trial-single-file oddział pierwszy.

Podczas pobierania danych za pomocą DVC używamy następującej struktury zbioru danych:

dataset
    |-- train
    |   |-- california_train.csv
    |-- test
    |   |-- california_test.csv
    |-- validation
    |   |-- california_validation.csv

Teraz tworzymy estymator Scikit-learn za pomocą SageMaker SDK dla Pythona. Pozwala nam to określić:

• Ścieżka do pliku źródłowego Pythona, który powinien być uruchamiany jako punkt wejścia do szkolenia.
• Rola uprawnień, która kontroluje uprawnienia dostępu do danych Amazon S3 i CodeCommit oraz uruchamiania funkcji SageMaker.
• Lista słowników definiujących metryki używane do oceny zadań szkoleniowych.
• Liczba i typ instancji szkoleniowych. Używamy jednej instancji ml.m5.large.
• Hiperparametry używane do trenowania.
• Zmienne środowiskowe do wykorzystania podczas pracy szkoleniowej. Używamy DVC_REPO_URL, DVC_BRANCH, USER.

metric_definitions = [{'Name': 'median-AE', 'Regex': "AE-at-50th-percentile: ([0-9.]+).*$"}]

hyperparameters={ 
        "learning_rate" : 1,
        "depth": 6
    }
estimator = SKLearn(
    entry_point='train.py',
    source_dir='source_dir',
    role=role,
    metric_definitions=metric_definitions,
    hyperparameters=hyperparameters,
    instance_count=1,
    instance_type='ml.m5.large',
    framework_version='0.23-1',
    base_job_name='training-with-dvc-data',
    environment={
        "DVC_REPO_URL": dvc_repo_url,
        "DVC_BRANCH": dvc_branch,
        "USER": "sagemaker"
    }
)

experiment_config={
    "ExperimentName": my_experiment.experiment_name,
    "TrialName": my_first_trial.trial_name
}

Metodę fit Estimatora wywołujemy z wcześniej zdefiniowaną konfiguracją eksperymentu, aby rozpocząć szkolenie.

%%time
estimator.fit(experiment_config=experiment_config)

Zadanie szkoleniowe zajmuje około 5 minut. Dzienniki pokazują te wiersze, wskazujące pliki ściągnięte przez DVC:

Running dvc pull command
A       train/california_train.csv
A       test/california_test.csv
A       validation/california_validation.csv
3 files added and 3 files fetched
Starting the training.
Found train files: ['/opt/ml/input/data/dataset/train/california_train.csv']
Found validation files: ['/opt/ml/input/data/dataset/train/california_train.csv']

Test 2: Generuj wiele plików do szkolenia i walidacji

Tworzymy nowy dvc-trial-multi-files próbny i dodaj go do prądu DEMO-sagemaker-experiments-dvc eksperyment.

second_trial_name = "dvc-trial-multi-files"
try:
    my_second_trial = Trial.load(trial_name=second_trial_name)
    print("existing trial loaded")
except Exception as ex:
    if "ResourceNotFound" in str(ex):
        my_second_trial = Trial.create(
            experiment_name=experiment_name,
            trial_name=second_trial_name,
        )
        print("new trial created")
    else:
        print(f"Unexpected {ex}=, {type(ex)}")
        print("Dont go forward!")
        raise

W odróżnieniu od pierwszego skryptu przetwarzania, teraz tworzymy z oryginalnego zestawu danych wiele plików do trenowania i walidacji oraz przechowujemy metadane DVC w innej gałęzi.

Możesz zapoznać się z drugim wstępnie przetwarzającym skryptem Pythona na GitHub.

%%time

script_processor.run(
    code='./source_dir/preprocessing-experiment-multifiles.py',
    dependencies=['./source_dir/requirements.txt'],
    inputs=[ProcessingInput(source=s3_data_path, destination="/opt/ml/processing/input")],
    experiment_config=experiment_config,
    arguments=["--train-test-split-ratio", "0.1"]
)

Zadanie przetwarzania trwa około 5 minut. Teraz możesz wyświetlić szczegóły wersji próbnej dla wieloplikowego zbioru danych.

Poniższe zrzuty ekranu pokazują, gdzie można znaleźć informacje przechowywane w Eksperymentach SageMaker w Komponenty próbne sekcji w interfejsie użytkownika Studio. Zanotuj wartości dla dvc-trial-multi-files in DVC_BRANCH, DVC_REPO_URL, data_commit_hash na parametry patka.

Możesz również przejrzeć szczegóły wejścia i wyjścia na Artefakty patka.

Teraz trenujemy na dvc-trial-multi-files oddział. Podczas pobierania danych za pomocą DVC używamy następującej struktury zbioru danych:

dataset
    |-- train
    |   |-- california_train_1.csv
    |   |-- california_train_2.csv
    |   |-- california_train_3.csv
    |   |-- california_train_4.csv
    |   |-- california_train_5.csv
    |-- test
    |   |-- california_test.csv
    |-- validation
    |   |-- california_validation_1.csv
    |   |-- california_validation_2.csv
    |   |-- california_validation_3.csv

Podobnie jak wcześniej, tworzymy nowy estymator Scikit-learn o nazwie próbnej dvc-trial-multi-files i rozpocząć pracę szkoleniową.

%%time

estimator.fit(experiment_config=experiment_config)

Zadanie szkoleniowe zajmuje około 5 minut. W dziennikach zadań szkoleniowych wyprowadzanych do notebooka można zobaczyć te wiersze, wskazujące pliki pobrane przez DVC:

Running dvc pull command
A       validation/california_validation_2.csv
A       validation/california_validation_1.csv
A       validation/california_validation_3.csv
A       train/california_train_4.csv
A       train/california_train_5.csv
A       train/california_train_2.csv
A       train/california_train_3.csv
A       train/california_train_1.csv
A       test/california_test.csv
9 files added and 9 files fetched
Starting the training.
Found train files: ['/opt/ml/input/data/dataset/train/california_train_2.csv', '/opt/ml/input/data/dataset/train/california_train_5.csv', '/opt/ml/input/data/dataset/train/california_train_4.csv', '/opt/ml/input/data/dataset/train/california_train_1.csv', '/opt/ml/input/data/dataset/train/california_train_3.csv']
Found validation files: ['/opt/ml/input/data/dataset/validation/california_validation_2.csv', '/opt/ml/input/data/dataset/validation/california_validation_1.csv', '/opt/ml/input/data/dataset/validation/california_validation_3.csv']

Hostuj swój model w SageMaker

Po wytrenowaniu modelu ML możesz go wdrożyć za pomocą programu SageMaker. Aby wdrożyć trwały punkt końcowy działający w czasie rzeczywistym, który tworzy jedną prognozę na raz, używamy Usługi hostingu w czasie rzeczywistym SageMaker.

from sagemaker.serializers import CSVSerializer

predictor = estimator.deploy(1, "ml.t2.medium", serializer=CSVSerializer())

Najpierw otrzymujemy najnowszy testowy zestaw danych lokalnie w notatniku programistycznym w Studio. W tym celu możemy użyć dvc.api.read() aby załadować surowe dane, które były przechowywane w Amazon S3 przez zadanie przetwarzania SageMaker.

import io
import dvc.api

raw = dvc.api.read(
    "dataset/test/california_test.csv",
    repo=dvc_repo_url,
    rev=dvc_branch
)

Następnie przygotowujemy dane za pomocą Pand, ładujemy testowy plik CSV i dzwonimy predictor.predict wywołać wcześniej utworzony punkt końcowy SageMaker z danymi i uzyskać prognozy.

test = pd.read_csv(io.StringIO(raw), sep=",", header=None)
X_test = test.iloc[:, 1:].values
y_test = test.iloc[:, 0:1].values

predicted = predictor.predict(X_test)
for i in range(len(predicted)-1):
    print(f"predicted: {predicted[i]}, actual: {y_test[i][0]}")

Usuń punkt końcowy

Punkty końcowe należy usuwać, gdy nie są już używane, ponieważ są rozliczane według czasu wdrożenia (aby uzyskać więcej informacji, zobacz Cennik Amazon SageMaker). Pamiętaj, aby usunąć punkt końcowy, aby uniknąć nieoczekiwanych kosztów.

predictor.delete_endpoint()

Sprzątać

Zanim usuniesz wszystkie utworzone zasoby, upewnij się, że wszystkie aplikacje zostały usunięte z data-scientist-dvc użytkownika, w tym wszystkie aplikacje KernelGateway, a także domyślną aplikację JupiterServer.

Następnie możesz zniszczyć stos AWS CDK, uruchamiając następujące polecenie:

cdk destroy

Jeśli korzystasz z istniejącej domeny, uruchom również następujące polecenia:

# inject your DOMAIN_ID into the configuration file
sed -i 's/<your-sagemaker-studio-domain-id>/'"$DOMAIN_ID"'/' ../update-domain-no-custom-images.json
# update the sagemaker studio domain
aws --region ${REGION} sagemaker update-domain --cli-input-json file://../update-domain-no-custom-images.json

Wnioski

W tym poście zapoznałeś się z przykładem śledzenia eksperymentów w kodzie, danych, artefaktach i metrykach za pomocą eksperymentów SageMaker oraz zadań przetwarzania i szkolenia SageMaker w połączeniu z DVC. Stworzyliśmy obraz platformy Docker zawierający DVC, który był wymagany w programie Studio jako notatnik programistyczny, i pokazaliśmy, jak można używać zadań przetwarzania i szkolenia za pomocą DVC. Przygotowaliśmy dwie wersje danych i wykorzystaliśmy DVC do zarządzania nimi za pomocą Git. Następnie skorzystałeś z programu SageMaker Experiments do śledzenia przetwarzania i uczenia się za pomocą dwóch wersji danych, aby uzyskać ujednolicony widok parametrów, artefaktów i metryk w jednym okienku. Na koniec wdrożyłeś model w punkcie końcowym SageMaker i użyłeś testowego zestawu danych z drugiej wersji zestawu danych do wywołania punktu końcowego SageMaker i uzyskania prognoz.

W następnym kroku możesz rozszerzyć istniejący notatnik i wprowadzić własną strategię inżynierii funkcji oraz używać DVC i SageMaker do przeprowadzania eksperymentów. Chodźmy budować!

Więcej informacji można znaleźć w następujących zasobach:

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ć.

Eitana Seli jest specjalistą ds. rozwiązań w zakresie uczenia maszynowego w Amazon Web Services. Współpracuje z klientami AWS, zapewniając wskazówki i pomoc techniczną, pomagając im budować i obsługiwać rozwiązania uczenia maszynowego w AWS. W wolnym czasie Eitan lubi biegać i czytać najnowsze artykuły o uczeniu maszynowym.