Modell hiperparaméter-finomhangolása az Azure Machine Tanulás (v1) használatával

A KÖVETKEZŐre vonatkozik: Azure CLI ml-bővítmény 1-es verzió

Fontos

A cikkben szereplő Azure CLI-parancsok némelyike az azure-cli-mlAzure Machine Tanulás vagy v1 bővítményét használja. A v1-bővítmény támogatása 2025. szeptember 30-án megszűnik. Addig a dátumig telepítheti és használhatja a v1-bővítményt.

Javasoljuk, hogy 2025. szeptember 30-a előtt váltsa át a ml(vagy v2) bővítményt. További információ a v2-es bővítményről: Azure ML CLI-bővítmény és Python SDK v2.

Az Azure Machine Tanulás (v1) HyperDrive-csomaggal automatizálhatja a hatékony hiperparaméter-finomhangolást. Megtudhatja, hogyan hajthatja végre a hiperparaméterek Azure Machine Tanulás SDK-val való finomhangolásához szükséges lépéseket:

1. A paraméter keresési helyének meghatározása
2. Az optimalizálandó elsődleges metrika megadása
3. Korai leállítási szabályzat megadása alacsony teljesítményű futtatásokhoz
4. Erőforrások létrehozása és hozzárendelése
5. Kísérlet indítása a megadott konfigurációval
6. A betanítási futtatások vizualizációja
7. Válassza ki a modellhez legjobb konfigurációt

Mi a hiperparaméter finomhangolása?

A hiperparaméterek állítható paraméterek, amelyek lehetővé teszik a modell betanítási folyamatának szabályozását. Neurális hálózatok esetén például ön dönti el a rejtett rétegek számát és az egyes rétegek csomópontjainak számát. A modell teljesítménye nagymértékben függ a hiperparamétertől.

A hiperparaméter-finomhangolás, más néven hiperparaméter-optimalizálás a legjobb teljesítményt eredményező hiperparaméterek konfigurációjának megkeresése. A folyamat általában számítási szempontból költséges és manuális.

Az Azure Machine Tanulás lehetővé teszi a hiperparaméterek hangolásának automatizálását és kísérletek párhuzamos futtatását a hiperparaméterek hatékony optimalizálása érdekében.

A keresési terület meghatározása

A hiperparaméterek finomhangolása az egyes hiperparaméterekhez definiált értékek tartományának feltárásával.

A hiperparaméterek lehetnek különállóak vagy folyamatosak, és egy paraméterkifejezés által leírt értékek eloszlásával rendelkezik.

Diszkrét hiperparaméterek

A különálló hiperparaméterek a különálló értékek között vannak megadva choice . choice lehet:

• egy vagy több vesszővel tagolt érték
• objektum range
• list tetszőleges objektum

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

Ebben az esetben batch_size az egyik érték [16, 32, 64, 128] és number_of_hidden_layers az egyik érték [1, 2, 3, 4].

A következő speciális diszkrét hiperparaméterek is megadhatóak eloszlás használatával:

• quniform(low, high, q) - Olyan értéket ad vissza, mint a kerek(egységes(alacsony, magas) / q) * q
• qloguniform(low, high, q) - Olyan értéket ad vissza, mint a round(exp(uniform(low, high)) / q) * q
• qnormal(mu, sigma, q) - Olyan értéket ad vissza, mint a round(normal(mu, sigma) / q) * q
• qlognormal(mu, sigma, q) - Olyan értéket ad vissza, mint a round(exp(normal(mu, sigma)) / q) * q

Folyamatos hiperparaméterek

A folyamatos hiperparaméterek eloszlásként vannak megadva folyamatos értéktartományon keresztül:

• uniform(low, high) - Az alacsony és a magas között egyenletesen elosztott értéket ad vissza
• loguniform(low, high) - Exp(uniform(low, high)) szerint rajzolt értéket ad vissza, hogy a visszatérési érték logaritmusa egységesen el legyen osztva
• normal(mu, sigma) - Olyan valós értéket ad vissza, amely normál esetben a középértékkel és a szórási szigmával van elosztva
• lognormal(mu, sigma) - Az exp(normal(mu, sigma)) szerint rajzolt értéket ad vissza, hogy a visszatérési érték logaritmusa normálisan el legyen osztva

Példa egy paramétertérdefinícióra:

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

Ez a kód egy keresési területet határoz meg két paraméterrel – learning_rate és keep_probability. learning_rate normális eloszlása 10 középértékkel és 3 szórással rendelkezik. keep_probability egységes eloszlása legalább 0,05 értékkel és 0,1 maximális értékkel rendelkezik.

A hiperparaméter helyének mintavételezése

Adja meg a hiperparaméter-térben használandó paraméter-mintavételezési módszert. Az Azure Machine Tanulás a következő módszereket támogatja:

• Véletlenszerű mintavételezés
• Rácsos mintavételezés
• Bayes-féle mintavételezés

Véletlenszerű mintavételezés

A véletlenszerű mintavételezés támogatja a különálló és folyamatos hiperparamétereket. Támogatja az alacsony teljesítményű futtatások korai leállítását. Egyes felhasználók véletlenszerű mintavételezéssel végeznek kezdeti keresést, majd finomítják a keresési területet a találatok javítása érdekében.

Véletlenszerű mintavételezés esetén a rendszer véletlenszerűen választja ki a hiperparaméter-értékeket a megadott keresési területről.

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

Rácsos mintavételezés

A rácsos mintavételezés támogatja a különálló hiperparamétereket. Használjon rácsos mintavételezést, ha költségvetéssel teljes mértékben kereshet a keresési területen. Támogatja az alacsony teljesítményű futtatások korai leállítását.

A rács mintavételezése egyszerű rácskeresést végez az összes lehetséges értéken. A rácsos mintavételezés csak hiperparaméterekkel choice használható. A következő tér például hat mintával rendelkezik:

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

Bayes-féle mintavételezés

A Bayes-mintavételezés a bayesi optimalizálási algoritmuson alapul. A korábbi minták alapján választja ki a mintákat, így az új minták javítják az elsődleges metrikát.

A Bayes-mintavételezést akkor javasoljuk, ha elegendő költségvetése van a hiperparaméter-tér felfedezéséhez. A legjobb eredmény érdekében a hangolt hiperparaméterek számának 20-szorosánál nagyobb vagy egyenlő futások maximális számát javasoljuk.

Az egyidejű futtatások száma hatással van a finomhangolási folyamat hatékonyságára. Az egyidejű futtatások kisebb száma jobb mintavételezési konvergenciához vezethet, mivel a kisebb párhuzamosság növeli a korábban befejezett futtatások előnyeit élvező futtatások számát.

A Bayes-mintavételezés csak a keresési területen belüli eloszlásokat támogatjachoiceuniformquniform.

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

Elsődleges metrika megadása

Adja meg azt az elsődleges metrikát, amelyet optimalizálni szeretne a hiperparaméter-finomhangoláshoz. Minden betanítási futtatás kiértékelése az elsődleges metrika alapján történik. A korai megszüntetési szabályzat az elsődleges metrikával azonosítja az alacsony teljesítményű futtatásokat.

Adja meg az elsődleges metrika alábbi attribútumait:

• primary_metric_name: Az elsődleges metrika nevének pontosan meg kell egyeznie a betanítási szkript által naplózott metrika nevével
• primary_metric_goal: A futtatások kiértékelésekor az elsődleges metrika teljes vagy kis méretű lehet PrimaryMetricGoal.MAXIMIZE , vagy PrimaryMetricGoal.MINIMIZE meghatározható.

primary_metric_name="accuracy",
primary_metric_goal=PrimaryMetricGoal.MAXIMIZE

Ez a minta maximalizálja a "pontosságot".

Naplómetrikák hiperparaméter-finomhangoláshoz

A modell betanítási szkriptjének naplóznia kell az elsődleges metrikát a modell betanítása során, hogy a HyperDrive hozzáférhessen a hiperparaméter-finomhangoláshoz.

Naplózza az elsődleges metrikát a betanítási szkriptben a következő mintarészlettel:

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

A betanítási szkript kiszámítja és val_accuracy naplózza a "pontosság" elsődleges metrikaként. Minden alkalommal, amikor a metrikát naplózza, a hiperparaméter-finomhangolási szolgáltatás fogadja. Ön határozza meg a jelentés gyakoriságát.

A modellbetanítási futtatások naplózási értékeiről további információt az Azure Machine Tanulás betanítási futtatások naplózásának engedélyezése című témakörben talál.

Korai megszüntetési szabályzat megadása

Automatikusan befejezi a rosszul teljesítő futtatásokat egy korai megszüntetési szabályzattal. A korai megszüntetés javítja a számítási hatékonyságot.

A szabályzat alkalmazásakor a következő paramétereket konfigurálhatja:

• evaluation_interval: a szabályzat alkalmazásának gyakorisága. Minden alkalommal, amikor a betanítási szkript naplózza az elsődleges metrikák számát egy intervallumként. Az evaluation_interval 1-ből egy minden alkalommal alkalmazza a szabályzatot, amikor a betanítási szkript az elsődleges metrikát jelenti. A 2-ből egy evaluation_interval minden második alkalommal alkalmazza a szabályzatot. Ha nincs megadva, evaluation_interval alapértelmezés szerint 1 értékre van állítva.
• delay_evaluation: késlelteti az első szabályzat kiértékelését egy megadott számú időköz esetén. Ez egy opcionális paraméter, amely elkerüli a betanítási futtatások idő előtti leállítását azáltal, hogy lehetővé teszi az összes konfiguráció minimális számú időköz futtatását. Ha meg van adva, a szabályzat a delay_evaluation nagyobb vagy egyenlő evaluation_interval minden többszörösét alkalmazza.

Az Azure Machine Tanulás a következő korai megszüntetési szabályzatokat támogatja:

• Bandit szabályzat
• Medián-leállítási szabályzat
• Csonkítás kiválasztási szabályzata
• Nincs felmondási szabályzat

Bandit szabályzat

A bandit szabályzat a tartalékidő-tényezőn/tartalékidőn és a kiértékelési időközön alapul. A bandit akkor zárja le a futtatásokat, ha az elsődleges metrika nem a sikeres futtatás megadott tartalékidő-/tartalékidő-mennyiségén belül van.

Feljegyzés

A Bayes-mintavételezés nem támogatja a korai megszüntetést. Bayes-mintavételezés használatakor állítsa be a .early_termination_policy = None

Adja meg a következő konfigurációs paramétereket:

• slack_factor vagy slack_amount: a legjobban teljesítő betanítási futtatás tekintetében engedélyezett tartalékidő. slack_factor a megengedett tartalékidőt adja meg arányként. slack_amount a megengedett tartalékidőt abszolút összegként adja meg az arány helyett.

  Vegyük például a 10. intervallumban alkalmazott Bandit-szabályzatot. Tegyük fel, hogy az elsődleges metrika 10- intervallumban történő legjobban teljesítő futtatása 0,8, amelynek célja az elsődleges metrika maximalizálása. Ha a szabályzat 0,2-es értéket ad meg slack_factor , a rendszer leáll minden olyan betanítást, amelynek a legjobb metrikája 10-es időközönként kisebb, mint 0,66 (0,8/(1+slack_factor)).

• evaluation_interval: (nem kötelező) a szabályzat alkalmazásának gyakorisága

• delay_evaluation: (nem kötelező) késlelteti az első szabályzat kiértékelését egy megadott számú időköz esetén

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

Ebben a példában a korai megszüntetési szabályzatot a rendszer minden időközönként alkalmazza a metrikák jelentésekor, az 5. kiértékelési időköztől kezdve. Minden olyan futtatás leáll, amelynek legjobb metrikája kisebb, mint (1/(1+0,1) vagy a legjobban teljesítő futtatás 91%-a.

Medián-leállítási szabályzat

A medián-leállítás egy korai leállítási szabályzat, amely a futtatások által jelentett elsődleges metrikák futási átlagán alapul. Ez a szabályzat az összes betanítási futtatás átlagát számítja ki, és leállítja azokat a futtatásokat, amelyek elsődleges metrikaértéke rosszabb, mint az átlagok mediánja.

Ez a szabályzat a következő konfigurációs paramétereket használja:

• evaluation_interval: a szabályzat alkalmazásának gyakorisága (opcionális paraméter).
• delay_evaluation: késlelteti az első szabályzat kiértékelését egy megadott számú intervallumra (nem kötelező paraméter).

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

Ebben a példában a korai megszüntetési szabályzat minden 5. kiértékelési időköztől kezdve minden intervallumban érvényesül. A futtatás 5-ös időközönként leáll, ha a legjobb elsődleges metrika rosszabb, mint a futási átlag mediánja az összes betanítási futtatás 1:5-ös időközeinél.

Csonkítás kiválasztási szabályzata

A csonkolás kiválasztása az egyes kiértékelési időközökben a legalacsonyabb teljesítményt nyújtó futtatások százalékos arányát törli. A futtatások az elsődleges metrika használatával vannak összehasonlítva.

Ez a szabályzat a következő konfigurációs paramétereket használja:

• truncation_percentage: a legalacsonyabb teljesítményt nyújtó futtatások százalékos aránya az egyes kiértékelési időközöknél. 1 és 99 közötti egész szám.
• evaluation_interval: (nem kötelező) a szabályzat alkalmazásának gyakorisága
• delay_evaluation: (nem kötelező) késlelteti az első szabályzat kiértékelését egy megadott számú időköz esetén
• exclude_finished_jobs: megadja, hogy kizárja-e a befejezett feladatokat a szabályzat alkalmazásakor

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

Ebben a példában a korai megszüntetési szabályzat minden 5. kiértékelési időköztől kezdve minden intervallumban érvényesül. A futtatás 5- időközzel fejeződik be, ha az 5. időközi teljesítmény az 5. intervallumban az összes futtatás teljesítményének legalacsonyabb 20%-ában van, és kizárja a befejezett feladatokat a szabályzat alkalmazásakor.

Nincs felmondási szabályzat (alapértelmezett)

Ha nincs megadva szabályzat, a hiperparaméter-finomhangolási szolgáltatás lehetővé teszi, hogy az összes betanítási futtatás befejeződjön.

policy=None

Korai felmondási szabályzat kiválasztása

• Az ígéretes feladatok megszüntetése nélkül megtakarítást biztosító konzervatív szabályzatok esetében fontolja meg az 1-5-ös evaluation_intervaldelay_evaluation medián leállási szabályzatot. Ezek konzervatív beállítások, amelyek körülbelül 25–35%-os megtakarítást biztosítanak az elsődleges metrika vesztesége nélkül (a kiértékelési adatok alapján).
• Az agresszívebb megtakarítás érdekében használja a Bandit Policyt kisebb engedélyezett tartalékidővel vagy csonkolási kijelölési szabályzattal nagyobb csonkítási százalékkal.

Erőforrások létrehozása és hozzárendelése

A betanítási futtatások maximális számának megadásával szabályozhatja az erőforrás-költségvetést.

• max_total_runs: A betanítási futtatások maximális száma. 1 és 1000 közötti egész számnak kell lennie.
• max_duration_minutes: (nem kötelező) A hiperparaméter finomhangolási kísérletének maximális időtartama percekben. Az időtartam megszakítása után fut.

Feljegyzés

Ha mindkettő max_total_runsmax_duration_minutes meg van adva, a hiperparaméter-finomhangolási kísérlet akkor fejeződik be, amikor a két küszöbérték közül az elsőt eléri.

Emellett adja meg az egyidejűleg futtatandó betanítási futtatások maximális számát a hiperparaméter-finomhangolási keresés során.

• max_concurrent_runs: (nem kötelező) Az egyidejűleg futtatható futtatások maximális száma. Ha nincs megadva, az összes futtatás párhuzamosan indul el. Ha meg van adva, 1 és 100 közötti egész számnak kell lennie.

Feljegyzés

Az egyidejű futtatások száma a megadott számítási célban elérhető erőforrásokon van meghatározva. Győződjön meg arról, hogy a számítási cél rendelkezik a kívánt egyidejűséghez elérhető erőforrásokkal.

max_total_runs=20,
max_concurrent_runs=4

Ez a kód úgy konfigurálja a hiperparaméter-finomhangolási kísérletet, hogy összesen legfeljebb 20 futtatást használjon, és egyszerre négy konfigurációt futtasson.

Hiperparaméter-finomhangolási kísérlet konfigurálása

A hiperparaméter-finomhangolási kísérlet konfigurálásához adja meg a következőket:

• A definiált hiperparaméter keresési területe
• A korai felmondási szabályzat
• Az elsődleges metrika
• Erőforrás-foglalási beállítások
• ScriptRunConfig script_run_config

A ScriptRunConfig a minta hiperparaméterekkel futtatott betanítási szkript. Meghatározza a feladatonkénti erőforrásokat (egy- vagy többcsomópontos), valamint a használni kívánt számítási célt.

Feljegyzés

A használt script_run_config számítási célnak elegendő erőforrással kell rendelkeznie az egyidejűségi szint kielégítéséhez. További információ a ScriptRunConfigról: Betanítási futtatások konfigurálása.

Konfigurálja a hiperparaméter finomhangolási kísérletét:

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)

A HyperDriveConfig megadott paraméterek beállítása a ScriptRunConfig script_run_config. A script_run_configparamétereket a betanítási szkriptnek adja át. A fenti kódrészlet a Train, hyperparameter tune és deploy in PyTorch mintajegyzetfüzetből származik. Ebben a mintában a rendszer hangolja a paramétereket és momentum a learning_rate paramétereket. A futtatások korai leállítását egy BanditPolicyolyan rendszer határozza meg, amely leállítja azokat a futtatásokat, amelyek elsődleges metrikái kívül esnek a slack_factor (lásd a BanditPolicy osztály referenciáját).

A minta alábbi kódja bemutatja, hogyan fogadják, elemzik és továbbítják a betanítási szkript függvényének fine_tune_model a hangolt értékeket:

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

Fontos

Minden hiperparaméter-futtatás teljesen újraindítja a betanítást, beleértve a modell és az összes adatbetöltő újraépítését. Ezt a költséget minimalizálhatja egy Azure Machine-Tanulás folyamat vagy manuális folyamat használatával, hogy a lehető legtöbb adatelőkészítést végezze el a betanítási futtatások előtt.

Hiperparaméter-finomhangolási kísérlet elküldése

A hiperparaméter finomhangolási konfigurációjának megadása után küldje el a kísérletet:

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

Melegindítási hiperparaméter finomhangolása (nem kötelező)

A modell legjobb hiperparaméter-értékeinek megkeresése iteratív folyamat lehet. A hiperparaméterek finomhangolásának felgyorsítása érdekében az előző öt futtatásból származó tudást újra felhasználhatja.

A meleg indítás kezelése a mintavételezési módszertől függően eltérően történik:

• Bayes-mintavételezés: Az előző futtatásból származó kísérleteket előzetes tudásként használjuk az új minták kiválasztásához és az elsődleges metrika javításához.
• Véletlenszerű mintavételezés vagy rácsos mintavételezés: A korai megszakítás a korábbi futtatásokból származó ismereteket használja a rosszul teljesítő futtatások meghatározásához.

Adja meg azoknak a szülőfuttatásoknak a listáját, amelyeket be szeretne melegíteni.

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]

Ha egy hiperparaméter-finomhangolási kísérlet megszakad, folytathatja a betanítási futtatásokat az utolsó ellenőrzőpontról. A betanítási szkriptnek azonban kezelnie kell az ellenőrzőpont logikáját.

A betanítási futtatásnak ugyanazt a hiperparaméter-konfigurációt kell használnia, és csatlakoztatnia kell a kimeneti mappákat. A betanítási szkriptnek el kell fogadnia az resume-from argumentumot, amely tartalmazza azokat az ellenőrzőpontokat vagy modellfájlokat, amelyekből folytatni szeretné a betanítási futtatásokat. Az egyéni betanítási futtatásokat a következő kódrészlet használatával folytathatja:

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]

A hiperparaméter finomhangolási kísérletét úgy konfigurálhatja, hogy egy korábbi kísérlettől induljon, vagy folytassa az egyéni betanítási futtatásokat resume_from az opcionális paraméterekkel és resume_child_runs a konfigurációban:

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)

Hiperparaméter-finomhangolási futtatások vizualizációja

A hiperparaméter-finomhangolási futtatásokat az Azure Machine Tanulás Studióban jelenítheti meg, vagy jegyzetfüzet-vezérlőt is használhat.

Stúdió

Az Azure Machine Tanulás Studióban megjelenítheti az összes hiperparaméter-hangolási futtatást. A kísérletek portálon való megtekintéséről további információt a Rekordok futtatása a stúdióban című témakörben talál.

• Metrikák diagramja: Ez a vizualizáció nyomon követi az egyes hyperdrive-gyermekekkel naplózott metrikákat a hiperparaméter finomhangolásának időtartama alatt. Minden sor egy gyermekfuttatást jelöl, és minden pont a futtatókörnyezet adott iterációjában méri az elsődleges metrikaértéket.

  

• Párhuzamos koordináták diagramja: Ez a vizualizáció az elsődleges metrika teljesítménye és az egyes hiperparaméter-értékek közötti korrelációt mutatja be. A diagram interaktív a tengelyek mozgásával (a tengelyfelirat kijelölésével és húzásával), valamint az értékek egyetlen tengelyen való kiemelésével (egyetlen tengelyen függőlegesen húzva kiemelheti a kívánt értékek tartományát). A párhuzamos koordináták diagramja a diagram jobb szélső részén található tengelyt tartalmazza, amely az adott futtató példányhoz beállított hiperparamétereknek megfelelő legjobb metrikaértéket ábrázolja. Ez a tengely azért van megadva, hogy a diagram színátmeneti jelmagyarázatát olvashatóbb módon kivetítse az adatokra.

  

• Kétdimenziós pontdiagram: Ez a vizualizáció a két egyedi hiperparaméter és a hozzájuk tartozó elsődleges metrikaérték közötti korrelációt jeleníti meg.

  

• Háromdimenziós pontdiagram: Ez a vizualizáció megegyezik a 2D-vel, de lehetővé teszi a korreláció három hiperparaméter-dimenzióját az elsődleges metrikaértékkel. A diagramot úgy is kijelölheti és húzhatja át, hogy a térközön belül különböző korrelációkat jelenítsen meg.

  

Notebook widget

A Jegyzetfüzet vezérlő használatával megjelenítheti a betanítási futtatások előrehaladását. Az alábbi kódrészlet egy Jupyter-jegyzetfüzetben egy helyen jeleníti meg az összes hiperparaméter-hangolást:

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

Ez a kód egy táblázatot jelenít meg, amely részletesen ismerteti az egyes hiperparaméter-konfigurációk betanítási futásait.

Az egyes futtatások teljesítményét a betanítás előrehaladtával is megjelenítheti.

A legjobb modell megkeresése

Miután az összes hiperparaméter-finomhangolási futtatás befejeződött, azonosítsa a legjobban teljesítő konfigurációt és hiperparaméter-értékeket:

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

Mintajegyzetfüzet

Ebben a mappában tekintse meg a train-hyperparameter-* jegyzetfüzeteket:

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

A szolgáltatás megismerése Jupyter-notebookok használatával cikk útmutatását követve megtanulhatja, hogyan futtathat notebookokat.

Következő lépések

• Kísérlet nyomon követése
• Betanított modell üzembe helyezése