Hyperparameterjustering av en modell med Azure Machine Learning

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

1. Definiera parametersökutrymmet
2. Ange ett primärt mått som ska optimeras
3. Ange princip för tidig avslutning för körningar med låg 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 justering av hyperparametrar?

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. Modellens prestanda är kraftigt beroende av hyperparametrar.

Justering av hyperparameter, även kallat optimering av hyperparameter, är en process för att hitta konfigurationen av hyperparametrar som ger bästa möjliga prestanda. Processen är vanligtvis beräkningsmässigt dyr och manuell.

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

Definiera sökutrymmet

Finjustera 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 tar ett av värdena batch_size [16, 32, 64, 128] och ett av number_of_hidden_layers 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 distribution över ett kontinuerligt värdeintervall:

• uniform(low, high) – Returnerar ett värde som är enhetligt distribuerat 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 är enhetligt distribuerat
• normal(mu, sigma) – Returnerar ett verkligt värde som normalt distribueras med medelvärdet mu och standardavvikelsen sigma
• lognormal(mu, sigma) – Returnerar ett värde som ritats enligt exp(normal(mu, sigma)) så att logaritmen för returvärdet normalt distribueras

Ett exempel på en definition av ett parameterutrymme:

    {    
        "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 normalfördelning med medelvärdet 10 och en standardavvikelse på 3. keep_probability har en enhetlig fördelning med ett minsta värde på 0,05 och ett maxvärde på 0,1.

Sampling av hyperparameterutrymmet

Ange vilken 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åg prestanda. Vissa användare gör en inledande 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 budgetera för att göra en fullständig sökning i sökutrymmet. Stöder tidig avslutning av körningar med låg prestanda.

Rutnätssampling gör en enkel rutnätssökning över alla möjliga värden. Rutnätssampling kan bara användas choice med hyperparametrar. Följande utrymme har 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 finjusteras.

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

Bayesiansk sampling stöder choice endast uniform distributioner av , quniform och över sökrymden.

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åg 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 PrimaryMetricGoal.MAXIMIZE antingen PrimaryMetricGoal.MINIMIZE eller och avgöra om det primära måttet ska maximeras eller minimeras vid utvärdering av körningarna.

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 justering av hyperparametrar.

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 och val_accuracy loggar det som det primära måttet "precision". Varje gång måttet loggas tas det emot av hyperparameterjusteringstjänsten. Det är upp till dig att fastställa rapporteringsfrekvensen.

Mer information om loggningsvärden i modellträningskörningar finns i Aktivera loggning i Azure ML för träningskörningar.

Ange princip för tidig avslutning

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: frekvensen för att tillämpa principen. Varje gång träningsskriptet loggar det primära måttet räknas 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 2 tillämpar principen varannan gång. Om inget anges anges evaluation_interval till 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 förhindrar förtidsavslut av träningskörningar genom att tillåta att alla konfigurationer körs under ett minsta antal intervall. Om det anges tillämpas 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:

• Princip för et
• Median för stoppprincip
• Princip för val av trunkering
• Ingen avslutningsprincip

Så här fungerar principen

Principen baseras på Slack-faktor/slack-belopp och utvärderingsintervall. Vid körningen avslutas körningen när det primära måttet inte ligger inom den angivna slack-faktorn/slack-mängden för den mest lyckade körningen.

Ange följande konfigurationsparametrar:

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

  Tänk dig till exempel att en Princip tillämpas med intervall 10. Anta att körningen med bäst prestanda vid intervall 10 rapporterade ett primärt mått är 0,8 med målet att maximera det primära måttet. Om principen anger 0,2 avslutas alla träningskörningar vars bästa mått med intervall 10 är mindre än slack_factor 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ärderingsintervallet 5. Körningar vars bästa mått är mindre än (1/(1+0,1) eller 91 % av den bäst presterande körningen avslutas.

Median för stoppprincip

Medianstopp är en princip för tidig avslutning som baseras på löpande medelvärden av primära mått som rapporteras av körningarna. Den här principen beräknar medelvärden för alla träningskörningar och stoppar kö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 med början vid utvärderingsintervallet 5. En körning stoppas med intervall 5 om det bästa primära måttet är sämre än medianvärdet för de löpande medelvärdena över intervallen 1:5 för alla träningskörningar.

Princip för val av trunkering

Trunkeringsval avbryter en procentandel av de lägst presterande körningarna 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 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

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

I det här exemplet tillämpas principen för tidig avslutning vid varje intervall med början vid utvärderingsintervallet 5. En körning avslutas med intervall 5 om dess prestanda vid intervall 5 är lägst 20 % av prestandan för alla körningar med intervall 5.

Ingen avslutningsprincip (standard)

Om ingen princip anges låter hyperparameterjusteringstjänsten alla träningskörningar köras tills de har slutförts.

policy=None

Välja en princip för tidig avslutning

• För en försiktig policy som ger besparingar utan att avsluta utlovade jobb bör du överväga en medianstoppsprincip evaluation_interval med 1 och delay_evaluation 5. Det här är en försiktig inställning som kan ge besparingar på cirka 25–35 % utan förlust av primärt mått (baserat på våra utvärderingsdata).
• Om du vill spara mer aggressivt använder du Grupprincip med en mindre tillåtna slack- eller trunkeringsvalsprincip 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örs efter att den här varaktigheten har avbrutits.

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

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

max_total_runs=20,
max_concurrent_runs=4

Den här koden konfigurerar experimentet för justering av hyperparametrar till att använda högst 20 körningar, vilket kör fyra konfigurationer i taget.

Konfigurera experimentet för justering av hyperparameter

Ange följande för att konfigurera ditt experiment för justering av hyperparametrar:

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

ScriptRunConfig är det träningsskript som körs med de exempelindelade hyperparametrarna. Den definierar resurserna per jobb (en eller flera noder) och beräkningsmålet som ska användas.

Konfigurera ditt experiment för justering av hyperparametrar:

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)

anger HyperDriveConfig de parametrar som skickas till ScriptRunConfig script_run_config . skickar script_run_config i sin tur parametrar till träningsskriptet. Kodfragmentet ovan kommer från exempelanteckningsboken Train (Träna) och hyperparameter tune (finjustera hyperparametern) och distribuera med PyTorch. I det här exemplet learning_rate momentum finjusteras parametrarna och . Tidig stopp av körningar bestäms av en , som stoppar en körning vars primära mått ligger BanditPolicy utanför slack_factor (se Klassreferens förPolicy).

Följande kod från exemplet visar hur de finjusterade värdena tas emot, parsas och skickas till träningsskriptens 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'))

Skicka experiment för justering av hyperparameter

När du har definierat konfigurationen av hyperparameterjusteringen 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 tidigare körningarna för att påskynda finjustering av hyperparametrar.

Varm start hanteras på olika sätt beroende på samplingsmetoden:

• Bayesiansk sampling: Studier från föregående körning används som tidigare kunskaper 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 körningar med dåligt prestanda.

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 experiment med hyperparameterjustering 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 monterade utdatamapparna. Träningsskriptet måste acceptera argumentet som innehåller kontrollpunkten eller modellfilerna resume-from 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 hyperparameterjusteringsexperimentet så att det startar om från ett tidigare experiment eller återupptar enskilda träningskörningar med hjälp av de valfria parametrarna resume_from resume_child_runs och i -konfiguration:

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 körningar av finjustering av hyperparametrar

Du kan visualisera dina hyperparameterjusteringskörningar i Azure Machine Learning Studio, eller så kan du 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 studio.

• Måttdiagram: Den här visualiseringen spårar de mått som loggas för varje underordnad hyperdrive-körning under hyperparameterjusteringens varaktighet. 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ärmåttsprestanda och enskilda hyperparametervärden. Diagrammet är interaktivt via förflyttning av axlar (klicka och dra vid axeletiketten) och genom att markera värden över en enda axel (klicka och dra lodrätt längs en enda axel för att markera ett intervall med önskade värden). Diagrammet med parallella koordinater innehåller en axel på den högra delen av 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 diagrammets toningsförklaring till data på ett mer läsbart sätt.

  

• 2-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 samma som 2D men tillåter tre hyperparameterdimensioner för 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-utrymme.

  

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å en plats i en Jupyter Notebook:

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 pågår.

Hitta den bästa modellen

När alla hyperparameterjusteringskörningar har slutförts identifierar du de konfigurations- och hyperparametervärden som presterar bäst:

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

Exempelanteckningsbok

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