Hyperparameter een model afstemmen met Azure Machine Learning (v1)

VAN TOEPASSING OP:Azure CLI ml-extensie v1

Belangrijk

Sommige Azure CLI-opdrachten in dit artikel gebruiken de azure-cli-mlextensie (of v1) voor Azure Machine Learning. Ondersteuning voor de v1-extensie eindigt op 30 september 2025. U kunt de v1-extensie tot die datum installeren en gebruiken.

U wordt aangeraden vóór 30 september 2025 over te stappen op de mlextensie of v2. Zie de Azure ML CLI-extensie en Python SDK v2 voor meer informatie over de v2-extensie.

Automatiseer efficiënte afstemming van hyperparameters met behulp van het HyperDrive-pakket van Azure Machine Learning (v1). Meer informatie over het voltooien van de stappen die nodig zijn om hyperparameters af te stemmen met de Azure Machine Learning SDK:

1. De zoekruimte voor parameters definiëren
2. Een primaire metrische waarde opgeven om te optimaliseren
3. Beleid voor vroegtijdige beëindiging opgeven voor laag presterende uitvoeringen
4. Resources maken en toewijzen
5. Een experiment starten met de gedefinieerde configuratie
6. De trainingsuitvoeringen visualiseren
7. Selecteer de beste configuratie voor uw model

Wat is hyperparameterafstemming?

Hyperparameters zijn aanpasbare parameters waarmee u het modeltrainingsproces kunt beheren. Met neurale netwerken bepaalt u bijvoorbeeld het aantal verborgen lagen en het aantal knooppunten in elke laag. Modelprestaties zijn sterk afhankelijk van hyperparameters.

Hyperparameterafstemming, ook wel hyperparameteroptimalisatie genoemd, is het proces van het vinden van de configuratie van hyperparameters die de beste prestaties opleveren. Het proces is doorgaans kostbaar en handmatig.

Met Azure Machine Learning kunt u hyperparameterafstemming automatiseren en experimenten parallel uitvoeren om hyperparameters efficiënt te optimaliseren.

De zoekruimte definiëren

Hyperparameters afstemmen door het bereik van waarden te verkennen dat is gedefinieerd voor elke hyperparameter.

Hyperparameters kunnen discreet of doorlopend zijn en hebben een verdeling van waarden die worden beschreven door een parameterexpressie.

Discrete hyperparameters

Discrete hyperparameters worden opgegeven als een tussen choice discrete waarden. choice kan het volgende zijn:

• een of meer door komma's gescheiden waarden
• een range object
• list willekeurig object

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

In dit geval batch_size gebruikt een van de waarden [16, 32, 64, 128] en number_of_hidden_layers een van de waarden [1, 2, 3, 4].

De volgende geavanceerde discrete hyperparameters kunnen ook worden opgegeven met behulp van een distributie:

• quniform(low, high, q) - Retourneert een waarde zoals rond(uniform(laag, hoog) / q) * q
• qloguniform(low, high, q) - Retourneert een waarde zoals round(exp(uniform(low, high)) / q) * q
• qnormal(mu, sigma, q) - Retourneert een waarde zoals round(normal(mu, sigma) / q) * q
• qlognormal(mu, sigma, q) - Retourneert een waarde zoals round(exp(normal(mu, sigma)) / q) * q

Continue hyperparameters

De continue hyperparameters worden opgegeven als een verdeling over een doorlopend bereik van waarden:

• uniform(low, high) - Retourneert een waarde die uniform is verdeeld tussen laag en hoog
• loguniform(low, high) - Geeft als resultaat een waarde die is getekend op basis van exp(uniform(laag, hoog)) zodat de logaritme van de retourwaarde uniform wordt verdeeld
• normal(mu, sigma) - Retourneert een echte waarde die normaal wordt verdeeld met gemiddelde mu en standaarddeviatie sigma
• lognormal(mu, sigma) - Retourneert een waarde die is getekend op basis van exp(normal(mu, sigma)) zodat de logaritme van de retourwaarde normaal wordt verdeeld

Een voorbeeld van een parameterruimtedefinitie:

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

Deze code definieert een zoekruimte met twee parameters en learning_ratekeep_probability. learning_rate heeft een normale verdeling met gemiddelde waarde 10 en een standaarddeviatie van 3. keep_probability heeft een uniforme verdeling met een minimumwaarde van 0,05 en een maximumwaarde van 0,1.

Steekproeven nemen in de hyperparameterruimte

Geef de parametersamplingsmethode op die moet worden gebruikt voor de hyperparameterruimte. Azure Machine Learning ondersteunt de volgende methoden:

• Willekeurige steekproeven
• Rastersampling
• Bayesiaanse steekproeven

Willekeurige steekproeven

Willekeurige steekproeven ondersteunen discrete en continue hyperparameters. Het biedt ondersteuning voor vroegtijdige beëindiging van uitvoeringen met lage prestaties. Sommige gebruikers voeren een eerste zoekopdracht uit met willekeurige steekproeven en verfijnen vervolgens de zoekruimte om de resultaten te verbeteren.

Bij willekeurige steekproeven worden hyperparameterwaarden willekeurig geselecteerd uit de gedefinieerde zoekruimte.

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

Rastersampling

Rastersampling ondersteunt discrete hyperparameters. Gebruik rastersampling als u het budget kunt gebruiken om volledig over de zoekruimte te zoeken. Ondersteunt vroegtijdige beëindiging van uitvoeringen met lage prestaties.

Rastersampling voert een eenvoudige rasterzoekopdracht uit op alle mogelijke waarden. Rastersampling kan alleen worden gebruikt met choice hyperparameters. De volgende ruimte heeft bijvoorbeeld zes voorbeelden:

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

Bayesiaanse steekproeven

Bayesiaanse steekproeven zijn gebaseerd op het Bayesiaanse optimalisatie-algoritme. Er worden voorbeelden gekozen op basis van de wijze waarop eerdere voorbeelden zijn gedaan, zodat nieuwe voorbeelden de primaire metrische gegevens verbeteren.

Bayesiaanse steekproeven worden aanbevolen als u voldoende budget hebt om de hyperparameterruimte te verkennen. Voor de beste resultaten raden we een maximum aantal uitvoeringen aan dat groter is dan of gelijk is aan 20 keer het aantal hyperparameters dat wordt afgestemd.

Het aantal gelijktijdige uitvoeringen heeft invloed op de effectiviteit van het afstemmingsproces. Een kleiner aantal gelijktijdige uitvoeringen kan leiden tot betere convergentie van steekproeven, omdat de kleinere mate van parallelle uitvoeringen het aantal uitvoeringen verhoogt dat profiteert van eerder voltooide uitvoeringen.

Bayesiaanse steekproeven ondersteunen choicealleen , uniformen quniform distributies over de zoekruimte.

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

Primaire metrische gegevens opgeven

Geef de primaire metrische gegevens op die u wilt optimaliseren voor hyperparameters. Elke trainingsuitvoering wordt geëvalueerd voor de primaire metrische gegevens. Het beleid voor vroegtijdige beëindiging maakt gebruik van de primaire metrische gegevens om uitvoeringen met lage prestaties te identificeren.

Geef de volgende kenmerken op voor uw primaire metrische gegevens:

• primary_metric_name: De naam van de primaire metrische gegevens moet exact overeenkomen met de naam van de metrische gegevens die zijn vastgelegd door het trainingsscript
• primary_metric_goal: dit kan of PrimaryMetricGoal.MAXIMIZEPrimaryMetricGoal.MINIMIZE of bepaalt of de primaire metriek wordt gemaximaliseerd of geminimaliseerd bij het evalueren van de uitvoeringen.

primary_metric_name="accuracy",
primary_metric_goal=PrimaryMetricGoal.MAXIMIZE

In dit voorbeeld wordt de nauwkeurigheid gemaximaliseerd.

Metrische logboekgegevens voor het afstemmen van hyperparameters

Het trainingsscript voor uw model moet de primaire metriek registreren tijdens de modeltraining, zodat HyperDrive er toegang toe heeft voor het afstemmen van hyperparameters.

Registreer de primaire metrische gegevens in uw trainingsscript met het volgende voorbeeldfragment:

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

Het trainingsscript berekent het val_accuracy en registreert het als de primaire metrische waarde 'nauwkeurigheid'. Telkens wanneer de metrische waarde wordt geregistreerd, wordt deze ontvangen door de hyperparameterafstemmingsservice. Het is aan u om de frequentie van rapportage te bepalen.

Zie Logboekregistratie in azure Machine Learning-trainingsuitvoeringen inschakelen voor meer informatie over logboekregistratiewaarden in modeltrainingsuitvoeringen.

Beleid voor vroegtijdige beëindiging opgeven

Automatisch slecht presterende uitvoeringen beëindigen met een beleid voor vroegtijdige beëindiging. Vroegtijdige beëindiging verbetert de rekenefficiëntie.

U kunt de volgende parameters configureren die bepalen wanneer een beleid wordt toegepast:

• evaluation_interval: de frequentie van het toepassen van het beleid. Telkens wanneer het trainingsscript de primaire metrische gegevens registreert als één interval. Een evaluation_interval van 1 past het beleid toe telkens wanneer het trainingsscript de primaire metrische gegevens rapporteert. Een evaluation_interval van 2 past het beleid elke keer toe. Als dit niet is opgegeven, evaluation_interval is deze standaard ingesteld op 1.
• delay_evaluation: vertraagt de eerste beleidsevaluatie voor een opgegeven aantal intervallen. Dit is een optionele parameter die voortijdige beëindiging van trainingsuitvoeringen voorkomt door alle configuraties gedurende een minimum aantal intervallen uit te voeren. Indien opgegeven, wordt elk veelvoud van evaluation_interval toegepast dat groter is dan of gelijk is aan delay_evaluation.

Azure Machine Learning ondersteunt het volgende beleid voor vroegtijdige beëindiging:

• Bandit-beleid
• Beleid voor het stoppen van mediaan
• Selectiebeleid afkappen
• Geen beëindigingsbeleid

Bandit-beleid

Bandit-beleid is gebaseerd op margefactor/margehoeveelheid en evaluatie-interval. Bandit eindigt op uitvoeringen wanneer de primaire metriek zich niet binnen de opgegeven margefactor/slack-hoeveelheid van de meest geslaagde uitvoering bevindt.

Notitie

Bayesiaanse steekproeven bieden geen ondersteuning voor vroegtijdige beëindiging. Wanneer u Bayesian-steekproeven gebruikt, stelt u deze in early_termination_policy = None.

Geef de volgende configuratieparameters op:

• slack_factor of slack_amount: de marge die is toegestaan met betrekking tot de best presterende trainingsuitvoering. slack_factor geeft de toegestane marge op als een verhouding. slack_amount geeft de toegestane marge op als een absolute hoeveelheid, in plaats van een verhouding.

  Denk bijvoorbeeld aan een Bandit-beleid dat is toegepast op interval 10. Stel dat de best presterende uitvoering met interval 10 een primaire metriek is 0,8 met een doel om de primaire metrische waarde te maximaliseren. Als het beleid een slack_factor van 0,2 opgeeft, worden alle trainingsuitvoeringen waarvan de beste meetwaarde voor interval 10 kleiner is dan 0,66 (0,8/(1+slack_factor)) worden beëindigd.

• evaluation_interval: (optioneel) de frequentie voor het toepassen van het beleid

• delay_evaluation: (optioneel) vertraagt de eerste beleidsevaluatie voor een opgegeven aantal intervallen

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

In dit voorbeeld wordt het beleid voor vroegtijdige beëindiging toegepast op elk interval wanneer metrische gegevens worden gerapporteerd, beginnend bij evaluatieinterval 5. Elke uitvoering waarvan de beste meetwaarde kleiner is dan (1/(1+0.1) of 91% van de best presterende uitvoering wordt beëindigd.

Beleid voor het stoppen van mediaan

Mediaan stoppen is een beleid voor vroegtijdige beëindiging op basis van het uitvoeren van gemiddelden van primaire metrische gegevens die door de uitvoeringen worden gerapporteerd. Met dit beleid worden lopende gemiddelden berekend voor alle trainingsuitvoeringen en worden de uitvoeringen gestopt waarvan de primaire metrische waarde slechter is dan de mediaan van de gemiddelden.

Dit beleid gebruikt de volgende configuratieparameters:

• evaluation_interval: de frequentie voor het toepassen van het beleid (optionele parameter).
• delay_evaluation: vertraagt de eerste beleidsevaluatie voor een opgegeven aantal intervallen (optionele parameter).

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

In dit voorbeeld wordt het beleid voor vroegtijdige beëindiging toegepast bij elk interval vanaf evaluatieinterval 5. Een uitvoering wordt gestopt met interval 5 als de beste primaire metriek slechter is dan de mediaan van de lopende gemiddelden met intervallen 1:5 voor alle trainingsuitvoeringen.

Selectiebeleid afkappen

Selectie voor afkappen annuleert een percentage van de laagst presterende uitvoeringen bij elk evaluatie-interval. Uitvoeringen worden vergeleken met behulp van de primaire metriek.

Dit beleid gebruikt de volgende configuratieparameters:

• truncation_percentage: het percentage van de laagst presterende uitvoeringen die bij elk evaluatie-interval moeten worden beëindigd. Een geheel getal tussen 1 en 99.
• evaluation_interval: (optioneel) de frequentie voor het toepassen van het beleid
• delay_evaluation: (optioneel) vertraagt de eerste beleidsevaluatie voor een opgegeven aantal intervallen
• exclude_finished_jobs: geeft aan of voltooide taken moeten worden uitgesloten bij het toepassen van het beleid

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

In dit voorbeeld wordt het beleid voor vroegtijdige beëindiging toegepast bij elk interval vanaf evaluatieinterval 5. Een uitvoering wordt beëindigd op interval 5 als de prestaties bij interval 5 de laagste 20% van de prestaties van alle uitvoeringen met interval 5 hebben en voltooide taken uitsluiten bij het toepassen van het beleid.

Geen beëindigingsbeleid (standaard)

Als er geen beleid is opgegeven, kan de hyperparameterafstemmingsservice alle trainingsuitvoeringen uitvoeren tot voltooiing.

policy=None

Een beleid voor vroegtijdige beëindiging kiezen

• Voor een conservatief beleid dat besparingen biedt zonder veelbelovende banen te beëindigen, kunt u een mediaan stoppen beleid overwegen met evaluation_interval 1 en delay_evaluation 5. Dit zijn conservatieve instellingen, die ongeveer 25%-35% kunnen besparen zonder verlies van primaire metrische gegevens (op basis van onze evaluatiegegevens).
• Voor agressievere besparingen gebruikt u Bandit-beleid met een kleinere toegestane marge of selectiebeleid voor afkapping met een groter afkappingspercentage.

Resources maken en toewijzen

Beheer uw resourcebudget door het maximum aantal trainingsuitvoeringen op te geven.

• max_total_runs: Maximum aantal trainingsuitvoeringen. Moet een geheel getal tussen 1 en 1000 zijn.
• max_duration_minutes: (optioneel) Maximale duur, in minuten, van het hyperparameterafstemmingsexperiment. Uitvoeringen na deze duur worden geannuleerd.

Notitie

Als beide max_total_runs en max_duration_minutes zijn opgegeven, wordt het hyperparameter-afstemmingsexperiment beëindigd wanneer de eerste van deze twee drempelwaarden wordt bereikt.

Geef bovendien het maximum aantal trainingsuitvoeringen op dat gelijktijdig moet worden uitgevoerd tijdens het afstemmen van hyperparameters.

• max_concurrent_runs: (optioneel) Maximum aantal uitvoeringen dat gelijktijdig kan worden uitgevoerd. Als dit niet is opgegeven, worden alle uitvoeringen parallel gestart. Indien opgegeven, moet een geheel getal tussen 1 en 100 zijn.

Notitie

Het aantal gelijktijdige uitvoeringen wordt beperkt tot de resources die beschikbaar zijn in het opgegeven rekendoel. Zorg ervoor dat het rekendoel de beschikbare resources heeft voor de gewenste gelijktijdigheid.

max_total_runs=20,
max_concurrent_runs=4

Met deze code configureert u het hyperparameter-afstemmingsexperiment voor het gebruik van maximaal 20 uitvoeringen, met vier configuraties tegelijk.

Hyperparameter-afstemmingsexperiment configureren

Als u uw hyperparameterafstemmingsexperiment wilt configureren, geeft u het volgende op:

• De gedefinieerde zoekruimte voor hyperparameters
• Uw beleid voor vroegtijdige beëindiging
• De primaire metrische waarde
• Resourcetoewijzingsinstellingen
• ScriptRunConfig script_run_config

ScriptRunConfig is het trainingsscript dat wordt uitgevoerd met de gesamplede hyperparameters. Het definieert de resources per taak (één of meerdere knooppunten) en het rekendoel dat moet worden gebruikt.

Notitie

Het rekendoel dat wordt gebruikt, script_run_config moet voldoende resources hebben om aan uw gelijktijdigheidsniveau te voldoen. Zie Trainingsuitvoeringen configureren voor meer informatie over ScriptRunConfig.

Configureer uw hyperparameterafstemmingsexperiment:

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)

Hiermee HyperDriveConfig worden de parameters ingesteld die worden doorgegeven aan de ScriptRunConfig script_run_config. De script_run_configparameters worden vervolgens doorgegeven aan het trainingsscript. Het bovenstaande codefragment wordt genomen uit de voorbeeldnotitieblok Trainen, hyperparameter afstemmen en implementeren met PyTorch. In dit voorbeeld worden de learning_rate en momentum parameters afgestemd. Vroege stop van uitvoeringen wordt bepaald door een BanditPolicy, die een uitvoering stopt waarvan de primaire metrische waarde buiten de slack_factor klassereferentie van BanditPolicy valt.

De volgende code uit het voorbeeld laat zien hoe de waarden worden ontvangen, geparseerd en doorgegeven aan de functie van fine_tune_model het trainingsscript:

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

Belangrijk

Elke hyperparameteruitvoering start de training helemaal opnieuw, inclusief het herbouwen van het model en alle gegevenslazers. U kunt deze kosten minimaliseren met behulp van een Azure Machine Learning-pijplijn of handmatig proces om zoveel mogelijk gegevensvoorbereiding uit te voeren voordat u de training uitvoert.

Hyperparameterafstemmingsexperiment verzenden

Nadat u de configuratie voor het afstemmen van hyperparameters hebt gedefinieerd, dient u het experiment in:

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

Warm starten hyperparameterafstemming (optioneel)

Het vinden van de beste hyperparameterwaarden voor uw model kan een iteratief proces zijn. U kunt kennis van de vijf vorige uitvoeringen hergebruiken om hyperparameterafstemming te versnellen.

Warm starten wordt anders verwerkt, afhankelijk van de steekproefmethode:

• Bayesian-steekproeven: experimenten uit de vorige uitvoering worden gebruikt als voorafgaande kennis om nieuwe steekproeven te kiezen en om de primaire metrische gegevens te verbeteren.
• Willekeurige steekproeven of rastersampling: Vroegtijdige beëindiging maakt gebruik van kennis van eerdere uitvoeringen om slecht presterende uitvoeringen te bepalen.

Geef de lijst met bovenliggende uitvoeringen op waaruit u het warme begin wilt instellen.

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]

Als een hyperparameter-afstemmingsexperiment wordt geannuleerd, kunt u de trainingsuitvoeringen hervatten vanaf het laatste controlepunt. Uw trainingsscript moet echter controlepuntlogica verwerken.

De trainingsuitvoering moet dezelfde hyperparameterconfiguratie gebruiken en de uitvoermappen hebben gekoppeld. Het trainingsscript moet het resume-from argument accepteren, dat het controlepunt of de modelbestanden bevat waaruit de trainingsuitvoering moet worden hervat. U kunt afzonderlijke trainingsuitvoeringen hervatten met behulp van het volgende fragment:

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]

U kunt uw hyperparameterafstemmingsexperiment zo configureren dat deze warm begint vanaf een eerder experiment of afzonderlijke trainingsuitvoeringen hervatten met behulp van de optionele parameters resume_from en resume_child_runs in de configuratie:

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)

Hyperparameter-afstemmingsuitvoeringen visualiseren

U kunt de uitvoeringen van hyperparameters visualiseren in de Azure Machine Learning-studio of u kunt een notebookwidget gebruiken.

Studio

U kunt al uw hyperparameterafstemmingsuitvoeringen in de Azure Machine Learning-studio visualiseren. Zie Uitvoeringsrecords weergeven in de studio voor meer informatie over het weergeven van een experiment in de portal.

• Grafiek met metrische gegevens: Met deze visualisatie worden de metrische gegevens bijgehouden die zijn vastgelegd voor elke onderliggende hyperdrive-uitvoering gedurende de duur van het afstemmen van hyperparameters. Elke regel vertegenwoordigt een onderliggende uitvoering en elk punt meet de primaire metrische waarde bij die herhaling van runtime.

  

• Parallelcoördinatendiagram: Deze visualisatie toont de correlatie tussen de primaire metrische prestaties en afzonderlijke hyperparameterwaarden. De grafiek is interactief via het verplaatsen van assen (klik en sleep door het aslabel) en door waarden over één as te markeren (klik en sleep verticaal langs één as om een bereik met gewenste waarden te markeren). De grafiek met parallelle coördinaten bevat een as aan de rechterkant van de grafiek waarmee de beste metrische waarde wordt uitgezet die overeenkomt met de hyperparameters die zijn ingesteld voor dat uitvoeringsexemplaren. Deze as wordt verstrekt om de legenda met kleurovergang van de grafiek op de gegevens te projecteren op een beter leesbare manier.

  

• 2Dimensionaal spreidingsdiagram: Deze visualisatie toont de correlatie tussen twee afzonderlijke hyperparameters, samen met de bijbehorende primaire metrische waarde.

  

• 3Dimensionaal spreidingsdiagram: deze visualisatie is hetzelfde als 2D, maar biedt drie hyperparameterdimensies van correlatie met de primaire metrische waarde. U kunt ook klikken en slepen om de grafiek opnieuw te herstellen om verschillende correlaties in de 3D-ruimte weer te geven.

  

Notebook-widget

Gebruik de widget Notebook om de voortgang van uw trainingsuitvoeringen te visualiseren. Het volgende codefragment visualiseert al uw hyperparameterafstemmingen op één plaats in een Jupyter-notebook:

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

Deze code geeft een tabel weer met details over de trainingsuitvoeringen voor elk van de hyperparameterconfiguraties.

U kunt ook de prestaties van elk van de uitvoeringen visualiseren wanneer de training vordert.

Het beste model zoeken

Zodra alle hyperparameter-afstemmingsuitvoeringen zijn voltooid, identificeert u de best presterende configuratie- en hyperparameterwaarden:

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

Voorbeeldnotebook

Raadpleeg de notebooks train-hyperparameter-* in deze map:

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

Informatie over het uitvoeren van notebooks vindt u in het artikel Use Jupyter notebooks to explore this service (Jupyter Notebooks gebruiken om deze service te verkennen).

Volgende stappen

• Een experiment bijhouden
• Een getraind model implementeren