Dostrajanie hiperparametrów modelu za pomocą usługi Azure Machine Learning (wersja 1)

DOTYCZY: Rozszerzenie interfejsu wiersza polecenia platformy Azure w wersji 1

Ważne

Niektóre polecenia interfejsu wiersza polecenia platformy Azure w tym artykule używają azure-cli-mlrozszerzenia , lub w wersji 1 dla usługi Azure Machine Learning. Obsługa rozszerzenia w wersji 1 zakończy się 30 września 2025 r. Będzie można zainstalować rozszerzenie v1 i używać go do tej daty.

Zalecamy przejście do mlrozszerzenia , lub w wersji 2 przed 30 września 2025 r. Aby uzyskać więcej informacji na temat rozszerzenia w wersji 2, zobacz Rozszerzenie interfejsu wiersza polecenia usługi Azure ML i zestaw Python SDK w wersji 2.

Automatyzowanie wydajnego dostrajania hiperparametrów przy użyciu pakietu HyperDrive usługi Azure Machine Learning (wersja 1). Dowiedz się, jak wykonać kroki wymagane do dostosowania hiperparametrów za pomocą zestawu AZURE Machine Learning SDK:

1. Definiowanie przestrzeni wyszukiwania parametrów
2. Określanie podstawowej metryki do optymalizacji
3. Określanie zasad wczesnego zakończenia dla przebiegów o niskiej wydajności
4. Tworzenie i przypisywanie zasobów
5. Uruchamianie eksperymentu ze zdefiniowaną konfiguracją
6. Wizualizowanie przebiegów trenowania
7. Wybierz najlepszą konfigurację modelu

Co to jest dostrajanie hiperparametrów?

Hiperparametry są regulowanymi parametrami , które umożliwiają sterowanie procesem trenowania modelu. Na przykład w przypadku sieci neuronowych decydujesz o liczbie ukrytych warstw i liczbie węzłów w każdej warstwie. Wydajność modelu zależy w dużym stopniu od hiperparametrów.

Dostrajanie hiperparametryczne, nazywane również optymalizacją hiperparametrów, jest procesem znajdowania konfiguracji hiperparametrów, które zapewniają najlepszą wydajność. Proces jest zazwyczaj kosztowny obliczeniowo i ręczny.

Usługa Azure Machine Learning umożliwia automatyzowanie dostrajania hiperparametrów i równoległe uruchamianie eksperymentów w celu wydajnego optymalizowania hiperparametrów.

Definiowanie przestrzeni wyszukiwania

Dostrajanie hiperparametrów przez eksplorowanie zakresu wartości zdefiniowanych dla każdego hiperparametru.

Hiperparametry mogą być dyskretne lub ciągłe i mają rozkład wartości opisanych przez wyrażenie parametru.

Dyskretne hiperparametry

Dyskretne hiperparametry są określane jako wartości choice dyskretne. choice może to być:

• co najmniej jedna wartość rozdzielona przecinkami
• range obiekt
• list dowolny obiekt

    {
        "batch_size": choice(16, 32, 64, 128)
        "number_of_hidden_layers": choice(range(1,5))
    }

W tym przypadku jedna batch_size z wartości [16, 32, 64, 128] i number_of_hidden_layers przyjmuje jedną z wartości [1, 2, 3, 4].

Następujące zaawansowane hiperparametry dyskretne można również określić przy użyciu rozkładu:

• quniform(low, high, q) - Zwraca wartość, na przykład round(uniform(low, high) / q) * q
• qloguniform(low, high, q) - Zwraca wartość, na przykład round(exp(uniform(low, high)) / q) * q
• qnormal(mu, sigma, q) - Zwraca wartość podobną do round(normal(mu, sigma) / q) * q
• qlognormal(mu, sigma, q) - Zwraca wartość, na przykład round(exp(normal(mu, sigma)) / q) * q

Hiperparametry ciągłe

Hiperparametry ciągłe są określane jako rozkład na ciągły zakres wartości:

• uniform(low, high) - Zwraca wartość równomiernie rozłożoną między niską i wysoką
• loguniform(low, high) - Zwraca wartość rysowaną zgodnie z exp(uniform(low, high)), tak aby logarytm wartości zwracanej był równomiernie rozłożony
• normal(mu, sigma) - Zwraca wartość rzeczywistą, która jest zwykle rozłożona ze średnią mu i odchylenie standardowe sigma
• lognormal(mu, sigma) - Zwraca wartość narysowaną zgodnie z exp(normal(mu, sigma)), tak aby logarytm wartości zwracanej był zwykle dystrybuowany

Przykład definicji przestrzeni parametrów:

    {    
        "learning_rate": normal(10, 3),
        "keep_probability": uniform(0.05, 0.1)
    }

Ten kod definiuje przestrzeń wyszukiwania z dwoma parametrami — learning_rate i keep_probability. learning_rate ma rozkład normalny o średniej wartości 10 i odchylenie standardowe 3. keep_probability ma jednolity rozkład z minimalną wartością 0,05 i maksymalną wartością 0,1.

Próbkowanie przestrzeni hiperparametrów

Określ metodę próbkowania parametrów do użycia w przestrzeni hiperparametrów. Usługa Azure Machine Learning obsługuje następujące metody:

• Losowe próbkowanie
• Próbkowanie siatki
• Próbkowanie Bayesowskie

Losowe próbkowanie

Losowe próbkowanie obsługuje dyskretne i ciągłe hiperparametry. Obsługuje wczesne zakończenie przebiegów o niskiej wydajności. Niektórzy użytkownicy wykonują wstępne wyszukiwanie przy użyciu losowego próbkowania, a następnie uściśliją przestrzeń wyszukiwania, aby poprawić wyniki.

W losowym próbkowaniu wartości hiperparametryczne są losowo wybierane ze zdefiniowanej przestrzeni wyszukiwania.

from azureml.train.hyperdrive import RandomParameterSampling
from azureml.train.hyperdrive import normal, uniform, choice
param_sampling = RandomParameterSampling( {
        "learning_rate": normal(10, 3),
        "keep_probability": uniform(0.05, 0.1),
        "batch_size": choice(16, 32, 64, 128)
    }
)

Próbkowanie siatki

Próbkowanie siatki obsługuje dyskretne hiperparametry. Użyj próbkowania siatki, jeśli możesz zastosować budżet, aby wyczerpująco przeszukiwać miejsce wyszukiwania. Obsługuje wczesne zakończenie przebiegów o niskiej wydajności.

Próbkowanie siatki wykonuje proste wyszukiwanie siatki na wszystkich możliwych wartościach. Próbkowanie siatki może być używane tylko z choice hiperparametrami. Na przykład następująca przestrzeń zawiera sześć przykładów:

from azureml.train.hyperdrive import GridParameterSampling
from azureml.train.hyperdrive import choice
param_sampling = GridParameterSampling( {
        "num_hidden_layers": choice(1, 2, 3),
        "batch_size": choice(16, 32)
    }
)

Próbkowanie Bayesowskie

Próbkowanie bayesowskie opiera się na algorytmie optymalizacji Bayesa. Wybiera próbki na podstawie sposobu, w jaki były poprzednie próbki, aby nowe próbki ulepszały metryki podstawowe.

Próbkowanie bayesowskie jest zalecane, jeśli masz wystarczający budżet, aby zbadać przestrzeń hiperparametrów. Aby uzyskać najlepsze wyniki, zalecamy maksymalną liczbę przebiegów większą lub równą 20-krotnej liczbie dostrojonych hiperparametrów.

Liczba współbieżnych przebiegów ma wpływ na skuteczność procesu dostrajania. Mniejsza liczba współbieżnych przebiegów może prowadzić do lepszej zbieżności próbkowania, ponieważ mniejszy stopień równoległości zwiększa liczbę przebiegów, które korzystają z poprzednio ukończonych przebiegów.

Próbkowanie bayesowskie obsługuje choicetylko dystrybucje , uniformi quniform w przestrzeni wyszukiwania.

from azureml.train.hyperdrive import BayesianParameterSampling
from azureml.train.hyperdrive import uniform, choice
param_sampling = BayesianParameterSampling( {
        "learning_rate": uniform(0.05, 0.1),
        "batch_size": choice(16, 32, 64, 128)
    }
)

Określanie podstawowej metryki

Określ podstawową metryę , którą chcesz dostrajać hiperparametrów do optymalizacji. Każdy przebieg trenowania jest oceniany dla metryki podstawowej. Zasady wczesnego zakończenia używają podstawowej metryki do identyfikowania przebiegów o niskiej wydajności.

Określ następujące atrybuty podstawowej metryki:

• primary_metric_name: Nazwa metryki podstawowej musi dokładnie odpowiadać nazwie metryki zarejestrowanej przez skrypt trenowania
• primary_metric_goal: Może to być PrimaryMetricGoal.MAXIMIZE wartość lub PrimaryMetricGoal.MINIMIZE i określa, czy metryka podstawowa zostanie zmaksymalizowana, czy zminimalizowana podczas oceniania przebiegów.

primary_metric_name="accuracy",
primary_metric_goal=PrimaryMetricGoal.MAXIMIZE

Ten przykład maksymalizuje "dokładność".

Metryki dziennika na potrzeby dostrajania hiperparametrów

Skrypt trenowania dla modelu musi rejestrować metrykę podstawową podczas trenowania modelu, aby funkcja HyperDrive mogła uzyskać do niego dostęp w celu dostrajania hiperparametrów.

Zarejestruj metrykę podstawową w skrypcie trenowania przy użyciu następującego przykładowego fragmentu kodu:

from azureml.core.run import Run
run_logger = Run.get_context()
run_logger.log("accuracy", float(val_accuracy))

Skrypt trenowania oblicza val_accuracy i rejestruje go jako podstawową metryki "dokładność". Za każdym razem, gdy metryka jest rejestrowana, jest odbierana przez usługę dostrajania hiperparametrów. Zależy to od ciebie, aby określić częstotliwość raportowania.

Aby uzyskać więcej informacji na temat rejestrowania wartości w przebiegach trenowania modelu, zobacz Włączanie rejestrowania w przebiegach trenowania usługi Azure Machine Learning.

Określanie zasad wczesnego kończenia

Automatyczne kończenie przebiegów o niskiej wydajności z zasadami wczesnego kończenia. Wczesne zakończenie poprawia wydajność obliczeniową.

Można skonfigurować następujące parametry, które kontrolują zastosowanie zasad:

• evaluation_interval: częstotliwość stosowania zasad. Za każdym razem, gdy skrypt trenowania rejestruje metryki podstawowe są liczone jako jeden interwał. Wartość evaluation_interval 1 będzie stosować zasady za każdym razem, gdy skrypt trenowania zgłasza metryki podstawowej. Wartość evaluation_interval 2 będzie stosować zasady za każdym razem. Jeśli nie zostanie określony, evaluation_interval jest domyślnie ustawiona wartość 1.
• delay_evaluation: opóźnia pierwszą ocenę zasad dla określonej liczby interwałów. Jest to opcjonalny parametr, który pozwala uniknąć przedwczesnego zakończenia przebiegów trenowania, umożliwiając uruchamianie wszystkich konfiguracji dla minimalnej liczby interwałów. W przypadku określenia zasady stosują każdą wielokrotność evaluation_interval, która jest większa lub równa delay_evaluation.

Usługa Azure Machine Learning obsługuje następujące zasady wczesnego zakończenia:

• Zasady bandytu
• Mediana zatrzymywania zasad
• Zasady wyboru obcięcia
• Brak zasad zakończenia

Zasady bandytu

Zasady bandytu są oparte na współczynniku slack/slack ilość i interwał oceny. Element Bandit kończy przebiegi, gdy metryka podstawowa nie znajduje się w określonym współczynniku slack/slack najbardziej udanego przebiegu.

Uwaga

Próbkowanie bayesowskie nie obsługuje wcześniejszego zakończenia. W przypadku korzystania z próbkowania Bayesian ustaw wartość early_termination_policy = None.

Określ następujące parametry konfiguracji:

• slack_factor lub slack_amount: luz dozwolony w odniesieniu do najlepszego przebiegu treningowego. slack_factor określa dozwolony luz jako stosunek. slack_amount określa dozwolony luz jako bezwzględną kwotę zamiast współczynnika.

  Rozważmy na przykład zastosowanie zasad bandytu w interwale 10. Załóżmy, że najlepszy przebieg w interwale 10 zgłosił metrykę podstawową wynosi 0,8, a celem jest zmaksymalizowanie podstawowej metryki. Jeśli zasady określają slack_factor wartość 0,2, wszystkie przebiegi trenowania, których najlepsza metryka w interwale 10 jest mniejsza niż 0,66 (0,8/(1+slack_factor)) zostanie zakończona.

• evaluation_interval: (opcjonalnie) częstotliwość stosowania zasad

• delay_evaluation: (opcjonalnie) opóźnia pierwszą ocenę zasad dla określonej liczby interwałów

from azureml.train.hyperdrive import BanditPolicy
early_termination_policy = BanditPolicy(slack_factor = 0.1, evaluation_interval=1, delay_evaluation=5)

W tym przykładzie zasady wczesnego zakończenia są stosowane w każdym interwale, gdy są zgłaszane metryki, począwszy od interwału oceny 5. Każdy przebieg, którego najlepsza metryka jest mniejsza niż (1/(1+0,1) lub 91% najlepszego przebiegu zostanie zakończone.

Mediana zatrzymywania zasad

Mediana zatrzymywania to zasady wczesnego zakończenia oparte na średnich uruchamiania podstawowych metryk zgłaszanych przez przebiegi. Ta zasada oblicza średnie uruchomione we wszystkich przebiegach trenowania i zatrzymuje przebiegi, których podstawowa wartość metryki jest gorsza niż mediana średnich.

Te zasady mają następujące parametry konfiguracji:

• evaluation_interval: częstotliwość stosowania zasad (opcjonalny parametr).
• delay_evaluation: opóźnia pierwszą ocenę zasad dla określonej liczby interwałów (parametr opcjonalny).

from azureml.train.hyperdrive import MedianStoppingPolicy
early_termination_policy = MedianStoppingPolicy(evaluation_interval=1, delay_evaluation=5)

W tym przykładzie zasady wczesnego zakończenia są stosowane w każdym interwale rozpoczynającym się od interwału oceny 5. Przebieg jest zatrzymywany w interwale 5, jeśli jego najlepsza podstawowa metryka jest gorsza niż mediana średnich przebiegów w odstępach 1:5 we wszystkich przebiegach trenowania.

Zasady wyboru obcięcia

Zaznaczenie obcinania anuluje procent najniższych przebiegów wydajności w każdym interwale oceny. Przebiegi są porównywane przy użyciu metryki podstawowej.

Te zasady mają następujące parametry konfiguracji:

• truncation_percentage: wartość procentowa przebiegów o najniższej wydajności do zakończenia w każdym interwale oceny. Wartość całkowita z zakresu od 1 do 99.
• evaluation_interval: (opcjonalnie) częstotliwość stosowania zasad
• delay_evaluation: (opcjonalnie) opóźnia pierwszą ocenę zasad dla określonej liczby interwałów
• exclude_finished_jobs: określa, czy należy wykluczyć ukończone zadania podczas stosowania zasad

from azureml.train.hyperdrive import TruncationSelectionPolicy
early_termination_policy = TruncationSelectionPolicy(evaluation_interval=1, truncation_percentage=20, delay_evaluation=5, exclude_finished_jobs=true)

W tym przykładzie zasady wczesnego zakończenia są stosowane w każdym interwale rozpoczynającym się od interwału oceny 5. Uruchomienie kończy się w interwale 5, jeśli jego wydajność w interwale 5 mieści się w najniższym 20% wydajności wszystkich przebiegów w interwale 5 i wykluczy ukończone zadania podczas stosowania zasad.

Brak zasad zakończenia (ustawienie domyślne)

Jeśli nie określono żadnych zasad, usługa dostrajania hiperparametrów umożliwia wykonanie wszystkich przebiegów trenowania w celu ukończenia.

policy=None

Wybieranie zasad wczesnego kończenia

• W przypadku konserwatywnej polityki, która zapewnia oszczędności bez kończenia obiecujących miejsc pracy, rozważ medianę zatrzymywania zasad z wartością evaluation_interval 1 i delay_evaluation 5. Są to konserwatywne ustawienia, które mogą zapewnić około 25%-35% oszczędności bez utraty na podstawowej metryce (na podstawie naszych danych oceny).
• Aby uzyskać bardziej agresywne oszczędności, użyj zasad bandytu z mniejszym dozwolonym luzem lub obcinanymi zasadami wyboru z większą wartością procentową obcięcia.

Tworzenie i przypisywanie zasobów

Kontroluj budżet zasobów, określając maksymalną liczbę przebiegów trenowania.

• max_total_runs: Maksymalna liczba przebiegów treningowych. Musi być liczbą całkowitą z zakresu od 1 do 1000.
• max_duration_minutes: (opcjonalnie) Maksymalny czas trwania w minutach eksperymentu dostrajania hiperparametrów. Przebiegi po upływie tego czasu trwania zostaną anulowane.

Uwaga

Jeśli zostanie określony zarówno, jak max_total_runs i max_duration_minutes , eksperyment dostrajania hiperparametrów zakończy się po osiągnięciu pierwszego z tych dwóch progów.

Ponadto określ maksymalną liczbę przebiegów trenowania, które będą uruchamiane współbieżnie podczas wyszukiwania dostrajania hiperparametrów.

• max_concurrent_runs: (opcjonalnie) Maksymalna liczba przebiegów, które mogą być uruchamiane współbieżnie. Jeśli nie zostanie określony, wszystkie uruchomienia są uruchamiane równolegle. W przypadku określenia musi być liczbą całkowitą z zakresu od 1 do 100.

Uwaga

Liczba współbieżnych przebiegów jest bramowana dla zasobów dostępnych w określonym obiekcie docelowym obliczeniowym. Upewnij się, że docelowy obiekt obliczeniowy ma dostępne zasoby dla żądanej współbieżności.

max_total_runs=20,
max_concurrent_runs=4

Ten kod umożliwia skonfigurowanie eksperymentu dostrajania hiperparametrów w celu użycia maksymalnie 20 łącznych przebiegów, uruchamiając jednocześnie cztery konfiguracje.

Konfigurowanie eksperymentu dostrajania hiperparametrów

Aby skonfigurować eksperyment dostrajania hiperparametrów, podaj następujące informacje:

• Zdefiniowana przestrzeń wyszukiwania hiperparametrów
• Zasady wczesnego zakończenia
• Metryka podstawowa
• Ustawienia alokacji zasobów
• ScriptRunConfig script_run_config

ScriptRunConfig to skrypt trenowania uruchamiany za pomocą przykładowych hiperparametrów. Definiuje zasoby na zadanie (pojedynczy lub wielowęźle) oraz docelowy obiekt obliczeniowy do użycia.

Uwaga

Docelowy obiekt obliczeniowy używany w programie script_run_config musi mieć wystarczającą ilość zasobów, aby spełnić poziom współbieżności. Aby uzyskać więcej informacji na temat skryptuRunConfig, zobacz Konfigurowanie przebiegów trenowania.

Skonfiguruj eksperyment dostrajania hiperparametrów:

from azureml.train.hyperdrive import HyperDriveConfig
from azureml.train.hyperdrive import RandomParameterSampling, BanditPolicy, uniform, PrimaryMetricGoal

param_sampling = RandomParameterSampling( {
        'learning_rate': uniform(0.0005, 0.005),
        'momentum': uniform(0.9, 0.99)
    }
)

early_termination_policy = BanditPolicy(slack_factor=0.15, evaluation_interval=1, delay_evaluation=10)

hd_config = HyperDriveConfig(run_config=script_run_config,
                             hyperparameter_sampling=param_sampling,
                             policy=early_termination_policy,
                             primary_metric_name="accuracy",
                             primary_metric_goal=PrimaryMetricGoal.MAXIMIZE,
                             max_total_runs=100,
                             max_concurrent_runs=4)

Ustawia HyperDriveConfig parametry przekazane do .ScriptRunConfig script_run_config Z kolei parametr script_run_configprzekazuje parametry do skryptu trenowania. Powyższy fragment kodu jest pobierany z przykładowego notesu Train, hyperparameter tune i deploy with PyTorch (Trenowanie przykładu, dostrajanie hiperparametrów i wdrażanie za pomocą narzędzia PyTorch). W tym przykładzie learning_rate parametry i momentum zostaną dostrojone. Wczesne zatrzymywanie przebiegów zostanie określone przez BanditPolicyelement , który zatrzymuje przebieg, którego metryka podstawowa znajduje się poza slack_factor elementem (zobacz Odwołanie do klasy BanditPolicy).

Poniższy kod z przykładu przedstawia sposób odbierania, analizowania i przekazywania wartości do funkcji skryptu szkoleniowego fine_tune_model :

# from pytorch_train.py
def main():
    print("Torch version:", torch.__version__)

    # get command-line arguments
    parser = argparse.ArgumentParser()
    parser.add_argument('--num_epochs', type=int, default=25,
                        help='number of epochs to train')
    parser.add_argument('--output_dir', type=str, help='output directory')
    parser.add_argument('--learning_rate', type=float,
                        default=0.001, help='learning rate')
    parser.add_argument('--momentum', type=float, default=0.9, help='momentum')
    args = parser.parse_args()

    data_dir = download_data()
    print("data directory is: " + data_dir)
    model = fine_tune_model(args.num_epochs, data_dir,
                            args.learning_rate, args.momentum)
    os.makedirs(args.output_dir, exist_ok=True)
    torch.save(model, os.path.join(args.output_dir, 'model.pt'))

Ważne

Każde uruchomienie hiperparametru powoduje ponowne uruchomienie trenowania od podstaw, w tym ponowne skompilowanie modelu i wszystkich modułów ładujących dane. Ten koszt można zminimalizować przy użyciu potoku usługi Azure Machine Learning lub procesu ręcznego, aby wykonać jak najwięcej przygotowań danych przed przebiegami trenowania.

Przesyłanie eksperymentu dostrajania hiperparametrów

Po zdefiniowaniu konfiguracji dostrajania hiperparametrów prześlij eksperyment:

from azureml.core.experiment import Experiment
experiment = Experiment(workspace, experiment_name)
hyperdrive_run = experiment.submit(hd_config)

Dostrajanie hiperparametryczne rozgrzewki (opcjonalnie)

Znalezienie najlepszych wartości hiperparametrów dla modelu może być procesem iteracyjnym. Możesz ponownie użyć wiedzy z pięciu poprzednich przebiegów, aby przyspieszyć dostrajanie hiperparametrów.

Ciepły początek jest obsługiwany inaczej w zależności od metody próbkowania:

• Próbkowanie bayesowskie: próby z poprzedniego przebiegu są używane jako wcześniejsze informacje dotyczące wybierania nowych próbek i ulepszania podstawowej metryki.
• Losowe próbkowanie lub próbkowanie siatki: wczesne zakończenie korzysta z wiedzy z poprzednich przebiegów w celu określenia przebiegów o niskiej wydajności.

Określ listę przebiegów nadrzędnych, od których chcesz rozgrzać początek.

from azureml.train.hyperdrive import HyperDriveRun

warmstart_parent_1 = HyperDriveRun(experiment, "warmstart_parent_run_ID_1")
warmstart_parent_2 = HyperDriveRun(experiment, "warmstart_parent_run_ID_2")
warmstart_parents_to_resume_from = [warmstart_parent_1, warmstart_parent_2]

Jeśli eksperyment dostrajania hiperparametrów zostanie anulowany, możesz wznowić przebiegi trenowania z ostatniego punktu kontrolnego. Skrypt trenowania musi jednak obsługiwać logikę punktu kontrolnego.

Przebieg trenowania musi używać tej samej konfiguracji hiperparametru i instalować foldery wyjściowe. Skrypt trenowania resume-from musi zaakceptować argument zawierający pliki punktu kontrolnego lub modelu, z których ma zostać wznowione uruchomienie trenowania. Poszczególne przebiegi trenowania można wznowić przy użyciu następującego fragmentu kodu:

from azureml.core.run import Run

resume_child_run_1 = Run(experiment, "resume_child_run_ID_1")
resume_child_run_2 = Run(experiment, "resume_child_run_ID_2")
child_runs_to_resume = [resume_child_run_1, resume_child_run_2]

Eksperyment dostrajania hiperparametrów można skonfigurować tak, aby rozpocząć od poprzedniego eksperymentu lub wznowić poszczególne przebiegi trenowania przy użyciu parametrów resume_from opcjonalnych i resume_child_runs w konfiguracji:

from azureml.train.hyperdrive import HyperDriveConfig

hd_config = HyperDriveConfig(run_config=script_run_config,
                             hyperparameter_sampling=param_sampling,
                             policy=early_termination_policy,
                             resume_from=warmstart_parents_to_resume_from,
                             resume_child_runs=child_runs_to_resume,
                             primary_metric_name="accuracy",
                             primary_metric_goal=PrimaryMetricGoal.MAXIMIZE,
                             max_total_runs=100,
                             max_concurrent_runs=4)

Wizualizowanie przebiegów dostrajania hiperparametrów

Możesz wizualizować przebiegi dostrajania hiperparametrów w usłudze Azure Machine Learning Studio lub użyć widżetu notesu.

Studio

Wszystkie uruchomienia dostrajania hiperparametrów można wizualizować w usłudze Azure Machine Learning Studio. Aby uzyskać więcej informacji na temat wyświetlania eksperymentu w portalu, zobacz Wyświetlanie rekordów uruchamiania w programie Studio.

• Wykres metryk: ta wizualizacja śledzi metryki rejestrowane dla każdego działania podrzędnego hyperdrive w czasie trwania dostrajania hiperparametrów. Każdy wiersz reprezentuje przebieg podrzędny, a każdy punkt mierzy podstawową wartość metryki w tej iteracji środowiska uruchomieniowego.

  

• Wykres współrzędnych równoległych: ta wizualizacja pokazuje korelację między wydajnością podstawowej metryki a poszczególnymi wartościami hiperparametrów. Wykres jest interaktywny przez ruch osi (zaznacz i przeciągnij według etykiety osi), a następnie wyróżniając wartości na jednej osi (zaznacz i przeciągnij pionowo wzdłuż pojedynczej osi, aby wyróżnić zakres żądanych wartości). Wykres współrzędnych równoległych zawiera oś na najbardziej prawej części wykresu, która kreśli najlepszą wartość metryki odpowiadającą hiperparametrom ustawionym dla tego wystąpienia przebiegu. Ta oś jest udostępniana w celu projekcji legendy gradientu wykresu na dane w bardziej czytelny sposób.

  

• 2-wymiarowy wykres punktowy: ta wizualizacja pokazuje korelację między dwoma poszczególnymi hiperparametrami wraz ze skojarzona z nimi podstawową wartością metryki.

  

• Wykres punktowy 3-wymiarowy: ta wizualizacja jest taka sama jak 2D, ale umożliwia trzy wymiary hiperparametru korelacji z podstawową wartością metryki. Możesz również wybrać i przeciągnąć, aby ponownie zorientować się na wykres, aby wyświetlić różne korelacje w przestrzeni 3D.

  

Widżet notesu

Użyj widżetu Notes, aby zwizualizować postęp przebiegów trenowania. Poniższy fragment kodu wizualizuje wszystkie przebiegi dostrajania hiperparametrów w jednym miejscu w notesie Jupyter:

from azureml.widgets import RunDetails
RunDetails(hyperdrive_run).show()

Ten kod wyświetla tabelę ze szczegółowymi informacjami na temat przebiegów trenowania dla każdej konfiguracji hiperparametru.

Możesz również wizualizować wydajność każdego z przebiegów w miarę postępu trenowania.

Znajdowanie najlepszego modelu

Po zakończeniu wszystkich przebiegów dostrajania hiperparametrów zidentyfikuj najlepsze wyniki konfiguracji i wartości hiperparametrów:

best_run = hyperdrive_run.get_best_run_by_primary_metric()
best_run_metrics = best_run.get_metrics()
parameter_values = best_run.get_details()['runDefinition']['arguments']

print('Best Run Id: ', best_run.id)
print('\n Accuracy:', best_run_metrics['accuracy'])
print('\n learning rate:',parameter_values[3])
print('\n keep probability:',parameter_values[5])
print('\n batch size:',parameter_values[7])

Przykładowy notes

Zapoznaj się z notesami train-hyperparameter-* w tym folderze:

• how-to-use-azureml/ml-frameworks

Instrukcję uruchamiania notesów znajdziesz w artykule Use Jupyter notebooks to explore this service (Eksplorowanie tej usługi za pomocą notesów Jupyter).

Następne kroki

• Śledzenie eksperymentu
• Wdrażanie wytrenowanego modelu