Hyperparameterjustering av en modell med Azure Machine Learning (v1)

GÄLLER FÖR:Azure CLI ml-tillägget v1

Viktigt!

Några av Azure CLI-kommandona i den här artikeln använder azure-cli-mltillägget , eller v1, för Azure Machine Learning. Stödet för v1-tillägget upphör den 30 september 2025. Du kommer att kunna installera och använda v1-tillägget fram till det datumet.

Vi rekommenderar att du övergår till mltillägget , eller v2, före den 30 september 2025. Mer information om v2-tillägget finns i Azure ML CLI-tillägget och Python SDK v2.

Automatisera effektiv hyperparameterjustering med hjälp av Azure Machine Learning (v1) HyperDrive-paket. Lär dig hur du utför de steg som krävs för att finjustera hyperparametrar med Azure Machine Learning SDK:

1. Definiera parameterns sökutrymme
2. Ange ett primärt mått som ska optimeras
3. Ange en princip för tidig avslutning för körningar med låga prestanda
4. Skapa och tilldela resurser
5. Starta ett experiment med den definierade konfigurationen
6. Visualisera träningskörningarna
7. Välj den bästa konfigurationen för din modell

Vad är hyperparameterjustering?

Hyperparametrar är justerbara parametrar som gör att du kan styra modellträningsprocessen. Med neurala nätverk bestämmer du till exempel antalet dolda lager och antalet noder i varje lager. Modellprestanda är starkt beroende av hyperparametrar.

Hyperparameterjustering, även kallat optimering av hyperparametrar, är processen att hitta konfigurationen av hyperparametrar som ger bästa prestanda. Processen är vanligtvis beräkningsmässigt dyr och manuell.

Med Azure Machine Learning kan du automatisera hyperparameterjustering och köra experiment parallellt för att effektivt optimera hyperparametrar.

Definiera sökutrymmet

Justera hyperparametrar genom att utforska intervallet med värden som definierats för varje hyperparameter.

Hyperparametrar kan vara diskreta eller kontinuerliga och har en fördelning av värden som beskrivs av ett parameteruttryck.

Diskreta hyperparametrar

Diskreta hyperparametrar anges som en choice bland diskreta värden. choice kan vara:

• ett eller flera kommaavgränsade värden
• ett range objekt
• godtyckliga list objekt

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

I det här fallet batch_size tar ett av värdena [16, 32, 64, 128] och number_of_hidden_layers ett av värdena [1, 2, 3, 4].

Följande avancerade diskreta hyperparametrar kan också anges med hjälp av en distribution:

• quniform(low, high, q) - Returnerar ett värde som round(uniform(low, high) / q) * q
• qloguniform(low, high, q) - Returnerar ett värde som round(exp(uniform(low, high)) / q) * q
• qnormal(mu, sigma, q) - Returnerar ett värde som round(normal(mu, sigma) / q) * q
• qlognormal(mu, sigma, q) - Returnerar ett värde som round(exp(normal(mu, sigma)) / q) * q

Kontinuerliga hyperparametrar

Kontinuerliga hyperparametrar anges som en fördelning över ett kontinuerligt värdeintervall:

• uniform(low, high) – Returnerar ett värde som är jämnt fördelat mellan låg och hög
• loguniform(low, high) - Returnerar ett värde som ritas enligt exp(uniform(low, high)) så att logaritmen för returvärdet fördelas jämnt
• normal(mu, sigma) – Returnerar ett reellt värde som normalt distribueras med medelvärdet mu och standardavvikelse sigma
• lognormal(mu, sigma) - Returnerar ett värde som dras enligt exp(normal(mu, sigma)) så att logaritmen för returvärdet normalt distribueras

Ett exempel på en parameterutrymmesdefinition:

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

Den här koden definierar ett sökutrymme med två parametrar – learning_rate och keep_probability. learning_rate har en normal fördelning med medelvärdet 10 och en standardavvikelse på 3. keep_probability har en enhetlig fördelning med ett minimivärde på 0,05 och ett maximalt värde på 0,1.

Sampling av hyperparameterutrymmet

Ange den parametersamplingsmetod som ska användas över hyperparameterutrymmet. Azure Machine Learning stöder följande metoder:

• Stickprov
• Rutnätssampling
• Bayesiansk sampling

Stickprov

Slumpmässig sampling stöder diskreta och kontinuerliga hyperparametrar. Den stöder tidig avslutning av körningar med låga prestanda. Vissa användare gör en första sökning med slumpmässig sampling och förfinar sedan sökutrymmet för att förbättra resultaten.

Vid slumpmässig sampling väljs hyperparametervärden slumpmässigt från det definierade sökutrymmet.

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

Rutnätssampling

Rutnätssampling stöder diskreta hyperparametrar. Använd rutnätssampling om du kan budgeta för att fullständigt söka över sökutrymmet. Stöder tidig avslutning av körningar med låga prestanda.

Rutnätssampling gör en enkel rutnätssökning över alla möjliga värden. Rutnätssampling kan endast användas med choice hyperparametrar. Följande blanksteg innehåller till exempel sex exempel:

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

Bayesiansk sampling

Bayesiansk sampling baseras på Bayesiansk optimeringsalgoritm. Den väljer exempel baserat på hur tidigare exempel gjorde, så att nya exempel förbättrar det primära måttet.

Bayesiansk sampling rekommenderas om du har tillräckligt med budget för att utforska hyperparameterutrymmet. För bästa resultat rekommenderar vi ett maximalt antal körningar som är större än eller lika med 20 gånger antalet hyperparametrar som justeras.

Antalet samtidiga körningar påverkar justeringsprocessens effektivitet. Ett mindre antal samtidiga körningar kan leda till bättre samplingskonvergens, eftersom den mindre graden av parallellitet ökar antalet körningar som drar nytta av tidigare slutförda körningar.

Bayesiansk sampling stöder choiceendast , uniformoch quniform distributioner över sökutrymmet.

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

Ange primärt mått

Ange det primära mått som du vill att hyperparameterjusteringen ska optimera. Varje träningskörning utvärderas för det primära måttet. Principen för tidig avslutning använder det primära måttet för att identifiera körningar med låga prestanda.

Ange följande attribut för ditt primära mått:

• primary_metric_name: Namnet på det primära måttet måste exakt matcha namnet på måttet som loggas av träningsskriptet
• primary_metric_goal: Det kan vara antingen PrimaryMetricGoal.MAXIMIZE eller PrimaryMetricGoal.MINIMIZE och avgör om det primära måttet ska maximeras eller minimeras när körningarna utvärderas.

primary_metric_name="accuracy",
primary_metric_goal=PrimaryMetricGoal.MAXIMIZE

Det här exemplet maximerar "noggrannheten".

Loggmått för justering av hyperparametrar

Träningsskriptet för din modell måste logga det primära måttet under modellträningen så att HyperDrive kan komma åt det för hyperparameterjustering.

Logga det primära måttet i träningsskriptet med följande exempelfragment:

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

Träningsskriptet beräknar val_accuracy och loggar det som det primära måttet "noggrannhet". Varje gång måttet loggas tas det emot av hyperparameterns justeringstjänst. Det är upp till dig att fastställa rapporteringsfrekvensen.

Mer information om loggningsvärden i modellträningskörningar finns i Aktivera loggning i Azure Machine Learning-träningskörningar.

Ange princip för tidig uppsägning

Avsluta automatiskt dåligt presterande körningar med en princip för tidig avslutning. Tidig avslutning förbättrar beräkningseffektiviteten.

Du kan konfigurera följande parametrar som styr när en princip tillämpas:

• evaluation_interval: hur ofta principen tillämpas. Varje gång träningsskriptet loggar räknas det primära måttet som ett intervall. En evaluation_interval av 1 tillämpar principen varje gång träningsskriptet rapporterar det primära måttet. En evaluation_interval av två tillämpar principen varannan gång. Om det inte anges evaluation_interval anges är det inställt på 1 som standard.
• delay_evaluation: fördröjer den första principutvärderingen för ett angivet antal intervall. Det här är en valfri parameter som undviker för tidig avslutning av träningskörningar genom att tillåta att alla konfigurationer körs under ett minsta antal intervall. Om det anges tillämpar principen varje multipel av evaluation_interval som är större än eller lika med delay_evaluation.

Azure Machine Learning stöder följande principer för tidig avslutning:

• Bandit-princip
• Princip för medianstopp
• Princip för markering av trunkering
• Ingen uppsägningsprincip

Bandit-princip

Bandit-principen baseras på slackfaktor/slack-belopp och utvärderingsintervall. Bandit slutar köras när det primära måttet inte är inom den angivna slackfaktorn/slack-mängden av den mest lyckade körningen.

Kommentar

Bayesiansk sampling stöder inte tidig avslutning. När du använder Bayesiansk sampling anger du early_termination_policy = None.

Ange följande konfigurationsparametrar:

• slack_factor eller slack_amount: det slack som tillåts med hänsyn till den bäst presterande träningskörningen. slack_factor anger det tillåtna slacket som ett förhållande. slack_amount anger det tillåtna slacket som en absolut mängd i stället för ett förhållande.

  Anta till exempel att en Bandit-princip tillämpas med intervall 10. Anta att den bäst presterande körningen med intervall 10 rapporterade att ett primärt mått är 0,8 med målet att maximera det primära måttet. Om principen anger slack_factor 0,2 avslutas alla träningskörningar vars bästa mått med intervall 10 är mindre än 0,66 (0,8/(1+slack_factor).).

• evaluation_interval: (valfritt) frekvensen för att tillämpa principen

• delay_evaluation: (valfritt) fördröjer den första principutvärderingen för ett angivet antal intervall

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

I det här exemplet tillämpas principen för tidig avslutning vid varje intervall när mått rapporteras, med början vid utvärderingsintervall 5. Alla körningar vars bästa mått är mindre än (1/(1+0,1) eller 91 % av den bästa körningen avslutas.

Princip för medianstopp

Medianstopp är en princip för tidig avslutning som baseras på löpande medelvärden av primära mått som rapporterats av körningarna. Den här principen beräknar löpande medelvärden för alla träningskörningar och stoppkörningar vars primära måttvärde är sämre än medianvärdet för medelvärdena.

Den här principen använder följande konfigurationsparametrar:

• evaluation_interval: frekvensen för att tillämpa principen (valfri parameter).
• delay_evaluation: fördröjer den första principutvärderingen för ett angivet antal intervall (valfri parameter).

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

I det här exemplet tillämpas principen för tidig avslutning vid varje intervall som börjar vid utvärderingsintervall 5. En körning stoppas med intervall 5 om dess bästa primära mått är sämre än medianen för de löpande medelvärdena över intervallen 1:5 för alla träningskörningar.

Princip för markering av trunkering

Truncation-markeringen avbryter en procentandel av körningar med lägst prestanda vid varje utvärderingsintervall. Körningar jämförs med det primära måttet.

Den här principen använder följande konfigurationsparametrar:

• truncation_percentage: procentandelen av körningar med lägst prestanda som ska avslutas vid varje utvärderingsintervall. Ett heltalsvärde mellan 1 och 99.
• evaluation_interval: (valfritt) frekvensen för att tillämpa principen
• delay_evaluation: (valfritt) fördröjer den första principutvärderingen för ett angivet antal intervall
• exclude_finished_jobs: anger om slutförda jobb ska undantas när principen tillämpas

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

I det här exemplet tillämpas principen för tidig avslutning vid varje intervall som börjar vid utvärderingsintervall 5. En körning avslutas med intervall 5 om dess prestanda vid intervall 5 har lägst 20 % av prestandan för alla körningar med intervall 5 och utesluter slutförda jobb när principen tillämpas.

Ingen avslutningsprincip (standard)

Om ingen princip anges låter tjänsten för hyperparameterjustering alla träningskörningar köras.

policy=None

Välja en princip för tidig avslutning

• För en konservativ politik som ger besparingar utan att avsluta lovande jobb, överväg en medianstopppolicy med evaluation_interval 1 och delay_evaluation 5. Det här är konservativa inställningar som kan ge ungefär 25–35 % besparingar utan förlust på primärmått (baserat på våra utvärderingsdata).
• Om du vill ha mer aggressiva besparingar använder du Bandit Policy med en mindre tillåten slack- eller truncation-markeringsprincip med en större trunkeringsprocent.

Skapa och tilldela resurser

Kontrollera resursbudgeten genom att ange det maximala antalet träningskörningar.

• max_total_runs: Maximalt antal träningskörningar. Måste vara ett heltal mellan 1 och 1000.
• max_duration_minutes: (valfritt) Maximal varaktighet i minuter för hyperparameterjusteringsexperimentet. Körningar efter den här varaktigheten avbryts.

Kommentar

Om både max_total_runs och max_duration_minutes anges avslutas hyperparameterjusteringsexperimentet när det första av dessa två tröskelvärden nås.

Ange dessutom det maximala antalet träningskörningar som ska köras samtidigt under hyperparameterjusteringssökningen.

• max_concurrent_runs: (valfritt) Maximalt antal körningar som kan köras samtidigt. Om det inte anges startas alla körningar parallellt. Om det anges måste det vara ett heltal mellan 1 och 100.

Kommentar

Antalet samtidiga körningar är gated på de resurser som är tillgängliga i det angivna beräkningsmålet. Kontrollera att beräkningsmålet har tillgängliga resurser för önskad samtidighet.

max_total_runs=20,
max_concurrent_runs=4

Den här koden konfigurerar hyperparameterjusteringsexperimentet till att använda högst 20 totala körningar och kör fyra konfigurationer åt gången.

Konfigurera hyperparameterjusteringsexperiment

Ange följande för att konfigurera hyperparameterjusteringsexperimentet :

• Det definierade sökutrymmet för hyperparametrar
• Din princip för tidig uppsägning
• Det primära måttet
• Inställningar för resursallokering
• ScriptRunConfig script_run_config

ScriptRunConfig är träningsskriptet som ska köras med de hyperparametrar som ingår i urvalet. Den definierar resurserna per jobb (en eller flera noder) och beräkningsmålet som ska användas.

Kommentar

Beräkningsmålet som används i script_run_config måste ha tillräckligt med resurser för att uppfylla samtidighetsnivån. Mer information om ScriptRunConfig finns i Konfigurera träningskörningar.

Konfigurera ditt hyperparameterjusteringsexperiment:

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)

HyperDriveConfig Anger parametrarna som skickas ScriptRunConfig script_run_configtill . I script_run_configsin tur skickar parametrarna till träningsskriptet. Kodfragmentet ovan hämtas från notebook-exempelfilen Train, hyperparameter tune och distribueras med PyTorch. I det här exemplet justeras parametrarna learning_rate och momentum . Tidigt stopp av körningar bestäms av en BanditPolicy, som stoppar en körning vars primära mått faller utanför (se Klassreferensen slack_factorför BanditPolicy).

Följande kod från exemplet visar hur de finjusterade värdena tas emot, parsas och skickas till träningsskriptets fine_tune_model funktion:

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

Viktigt!

Varje hyperparameterkörning startar om träningen från grunden, inklusive återskapande av modellen och alla datainläsare. Du kan minimera den här kostnaden genom att använda en Azure Machine Learning-pipeline eller manuell process för att göra så mycket dataförberedelser som möjligt innan dina träningskörningar.

Skicka hyperparameterjusteringsexperiment

När du har definierat justeringskonfigurationen för hyperparameter skickar du experimentet:

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

Justering av hyperparameter för varmstart (valfritt)

Att hitta de bästa hyperparametervärdena för din modell kan vara en iterativ process. Du kan återanvända kunskap från de fem föregående körningarna för att påskynda hyperparameterjusteringen.

Varmstart hanteras på olika sätt beroende på samplingsmetoden:

• Bayesiansk sampling: Försök från föregående körning används som förhandskunskaper för att välja nya exempel och för att förbättra det primära måttet.
• Slumpmässig sampling eller rutnätssampling: Tidig avslutning använder kunskap från tidigare körningar för att fastställa dåligt presterande körningar.

Ange listan över överordnade körningar som du vill starta från.

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]

Om ett hyperparameterjusteringsexperiment avbryts kan du återuppta träningskörningar från den senaste kontrollpunkten. Träningsskriptet måste dock hantera kontrollpunktslogik.

Träningskörningen måste använda samma hyperparameterkonfiguration och montera utdatamapparna. Träningsskriptet måste acceptera resume-from argumentet, som innehåller kontrollpunkts- eller modellfilerna som träningskörningen ska återupptas från. Du kan återuppta enskilda träningskörningar med hjälp av följande kodfragment:

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]

Du kan konfigurera ditt hyperparameterjusteringsexperiment till varm start från ett tidigare experiment eller återuppta enskilda träningskörningar med hjälp av de valfria parametrarna resume_from och resume_child_runs i konfigurationen:

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)

Visualisera justeringskörningar för hyperparametrar

Du kan visualisera dina hyperparameterjusteringskörningar i Azure Machine Learning-studio eller använda en notebook-widget.

Studio

Du kan visualisera alla dina hyperparameterjusteringskörningar i Azure Machine Learning-studio. Mer information om hur du visar ett experiment i portalen finns i Visa körningsposter i studion.

• Måttdiagram: Den här visualiseringen spårar de mått som loggas för varje hyperdrive-underordnad körning under tiden som hyperparameterjusteringen pågår. Varje rad representerar en underordnad körning och varje punkt mäter det primära måttvärdet vid den iterationen av körningen.

  

• Diagram över parallella koordinater: Den här visualiseringen visar korrelationen mellan primära måttprestanda och enskilda hyperparametervärden. Diagrammet är interaktivt via förflyttning av axlar (klicka och dra efter axeletiketten) och genom att markera värden över en enskild axel (klicka och dra lodrätt längs en enskild axel för att markera ett intervall med önskade värden). Diagrammet med parallella koordinater innehåller en axel till höger i diagrammet som ritar det bästa måttvärdet som motsvarar de hyperparametrar som angetts för den körningsinstansen. Den här axeln tillhandahålls för att projicera diagramtoningsförklaringen på data på ett mer läsbart sätt.

  

• Tvådimensionellt punktdiagram: Den här visualiseringen visar korrelationen mellan två enskilda hyperparametrar tillsammans med deras associerade primära måttvärde.

  

• 3-dimensionellt punktdiagram: Den här visualiseringen är densamma som 2D men tillåter tre hyperparameterdimensioner av korrelation med det primära måttvärdet. Du kan också klicka och dra för att omorientera diagrammet för att visa olika korrelationer i 3D-blanksteg.

  

Anteckningsbok-widget

Använd notebook-widgeten för att visualisera förloppet för dina träningskörningar. Följande kodfragment visualiserar alla dina hyperparameterjusteringskörningar på ett ställe i en Jupyter-notebook-fil:

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

Den här koden visar en tabell med information om träningskörningarna för var och en av hyperparameterkonfigurationerna.

Du kan också visualisera prestanda för var och en av körningarna när träningen fortskrider.

Hitta den bästa modellen

När alla hyperparameterjusteringskörningar har slutförts identifierar du de bästa konfigurations- och hyperparametervärdena:

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

Exempel på notebook-fil

Se notebook-filer för train-hyperparameter-* i den här mappen:

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

Lär dig att köra notebook-filer genom att följa artikeln Använda Jupyter-notebooks till att utforska tjänsten.

Nästa steg

• Spåra ett experiment
• Distribuera en tränad modell