AutoML-betanítás beállítása Pythonnal

Ebből az útmutatóból megtudhatja, hogyan állíthat be AutoML-betanítás futtatását a Azure Machine Learning Python SDK-val Azure Machine Learning automatizált ML. Az ML kiválaszt önnek egy algoritmust és hiperparamétereket, és létrehoz egy üzembe helyezésre kész modellt. Az ilyen típusú kísérletek többféle módon konfigurálhatóak.

A végpontok között példa: Oktatóanyag: AutoML- betanítási regressziós modell.

Az automatizált konfigurációkban elérhető konfigurációs ML:

  • Válassza ki a kísérlet típusát: Besorolás, Regresszió vagy Idősorozat-előrejelzés
  • Adatforrások, formátumok és adatok beolvasása
  • Válassza ki a számítási célt: helyi vagy távoli
  • Automatizált gépi tanulási kísérlet beállításai
  • Automatizált ML futtatása
  • Modellmetrikák megismerés
  • Modell regisztrálása és üzembe helyezése

Ha előnyben részesíti a kód nélkül való felhasználói élményt, a Kód nélkül autoML betanítás beállítását is használhatja a Azure Machine Learning Studióban.

Előfeltételek

Ehhez a cikkhez a következőre lesz szüksége:

A kísérlet típusának kiválasztása

A kísérlet megkezdése előtt meg kell határoznia a megoldott gépi tanulási problémát. Az automatizált gépi tanulás támogatja a classification , regression és feladattípusokat. forecasting További információ a feladattípusokról:.

A következő kód a konstruktor paraméterét használja a kísérlet task AutoMLConfig típusának classification megadásához.

from azureml.train.automl import AutoMLConfig

# task can be one of classification, regression, forecasting
automl_config = AutoMLConfig(task = "classification")

Adatforrás és formátum

Az automatizált gépi tanulás támogatja a helyi számítógépen vagy a felhőben, például az Azure Blob Storage-ban található adatokat. Az adatok beolvashatóak egy Pandas DataFrame-be vagy egy Azure Machine Learning Dataset adatkészletbe. További információ az adathalmazokról.

A gépi tanulás betanítás adataira vonatkozó követelmények:

  • Az adatoknak táblázatos formában kell lennie.
  • Az előrejelezni szükséges céloszlopnak az adatokban kell lennie.

Távoli kísérletekhez a betanítás adatainak elérhetőknek kell lenniük a távoli számításból. Az automatizált ML csak akkor fogad Azure Machine Learning TabularDatasets-t, ha távoli számításon dolgozik.

Az Azure Machine Learning-adathalmazok a következő funkciókat biztosítják:

  • Könnyedén továbbíthat adatokat statikus fájlokból vagy URL-forrásokból a munkaterületre.
  • Az adatok elérhetővé tétele a betanítási szkriptek számára a felhőbeli számítási erőforrásokon való futtatáskor. Az adatok távoli számítási célhoz való csatlakoztatására a osztály használatával az adatkészletekkel való betanítás példáját itt láthatja: How to train with datasets Dataset (Betanítás adatkészletekkel).

Az alábbi kód egy TabularDataset adatkészletet hoz létre egy webes URL-címből. Az adatkészletek más forrásokból, például helyi fájlokból és adattárolókból való létrehozásáról a Create a TabularDataset (Táblázatos adatkészlet létrehozása) oldalon talál példákat.

from azureml.core.dataset import Dataset
data = "https://automlsamplenotebookdata.blob.core.windows.net/automl-sample-notebook-data/creditcard.csv"
dataset = Dataset.Tabular.from_delimited_files(data)

Helyi számítási kísérletekhez a pandas-adatkeretek használatát javasoljuk a gyorsabb feldolgozási idő érdekében.

import pandas as pd
from sklearn.model_selection import train_test_split

df = pd.read_csv("your-local-file.csv")
train_data, test_data = train_test_split(df, test_size=0.1, random_state=42)
label = "label-col-name"

Betanítési, ellenőrzési és tesztelési adatok

Közvetlenül a konstruktorban külön betanítési adatokat és ellenőrzési adatkészleteket AutoMLConfig is megadhat. További információ az adatfedés és keresztellenőrzés konfigurálásról az AutoML-kísérletekhez.

Ha nem ad meg explicit módon egy vagy paramétert, az automatikus ML az alapértelmezett technikákat alkalmazva határozzák meg az validation_data n_cross_validation érvényesítést. Ez a meghatározás a paraméterhez rendelt adathalmaz sorai számától training_data függ.

Betanítás   adatainak   mérete Ellenőrzési technika
Nagyobb,     mint 20 000   sor A rendszer alkalmazza a betanítás/ellenőrzés adatfelosztóját. Az alapértelmezett beállítás a kezdeti betanítás adatkészletének 10%-a az ellenőrzési készlet. Ezt az ellenőrzési készletet használja a rendszer a metrikák kiszámításához.
**    20 000 sornál kisebb  ** A rendszer keresztellenőrzési megközelítést alkalmaz. Az összecsukott értékek alapértelmezett száma a sorok számától függ.
Ha az adathalmaz kevesebb, mint 1000 sor, a rendszer 10-et használ.
Ha a sorok 1000 és 20 000 közé esnek, akkor három összecsukás lesz használva.

Jelenleg meg kell adnia a saját tesztadatát a modell kiértékelése céljából. A saját tesztadatok modellértékeléshez való behozása kódpára a Jupyternotebook Tesztelés szakaszában található.

Nagy méretű adatok

Az ML rendszerek korlátozott számú algoritmust támogatnak a nagy méretű adatok betanítása érdekében, amelyek sikeresen építenek big data virtuális gépeken való betanításhoz. Az ML heurisztika olyan tulajdonságoktól függ, mint az adatok mérete, a virtuális gép memóriamérete, a kísérletek időtúllépése és a jellemzőkre vonatkozó beállítások annak meghatározásához, hogy érdemes-e alkalmazni ezeket a nagyméretű adat algoritmusokat. További információ arról, hogy milyen modellek támogatottak az automatizált ML.

Ha felül szeretné bírálni ezeket a heurisztikákat, alkalmazza a következő beállításokat:

Feladat Beállítás Jegyzetek
 Adatstreamelési algoritmusok blokkolása blocked_models a objektumban, és listába sorolja a nem használni AutoMLConfig kívánt modellt/modelleket. Futtatási hibát vagy hosszú futási időt ad vissza
    Adatstreamelési   algoritmusok használata allowed_models a AutoMLConfig objektumban, és listába sorolja a használni kívánt modellt/modelleket.
    Adatstreamelési   algoritmusok használata
(Studio felhasználói felületi kísérletek)
A használni kívánt big data kivételével tiltsa le az összes modellt.

Számítás a kísérlet futtatásához

Következő lépésként határozza meg, hogy a modell hol lesz betanítva. Az automatizált ML betanítás kísérlete a következő számítási lehetőségeken futtatható. Ismerje meg a helyi és távoli számítási lehetőségek előnyeit és hátrányait.

  • Helyi gépe, például egy helyi asztali számítógép vagy laptop – Általában akkor, ha kis adatkészlete van, és még a feltárási szakaszban van. A helyi számításra ebben a jegyzetfüzetben tekinthet meg egy példát.

  • A felhőben található távoli gép – Azure Machine Learning Managed Compute egy felügyelt szolgáltatás, amely lehetővé teszi a gépi tanulási modellek betanítási képességét Azure-beli virtuális gépek fürtjére.

    Az Azure Machine Learning Managed Compute-tal történő távoli számításra ebben a jegyzetfüzetben tekinthet meg egy példát.

  • Egy Azure Databricks az Azure-előfizetésben. További részleteket a Fürtfürt beállítása automatikus Azure Databricks való beállítását ML. Tekintse meg ezt GitHub webhelyet, amely példákat tartalmaz az Azure Databricks.

Kísérlet beállításainak konfigurálása

Az automatizált adatkísérlet konfigurálásán számos ML használhatja. Ezek a paraméterek egy objektum példányosodása alapján vannak AutoMLConfig beállítva. A paraméterek teljes listájáért tekintse meg az AutoMLConfig osztályt.

Néhány példa:

  1. Besorolási kísérlet, amely az AUC-t használja elsődleges metrikaként, és a kísérlet időtúllépési percei 30 percre és 2 keresztellenőrzési kísérletre vannak beállítva.

        automl_classifier=AutoMLConfig(task='classification',
                                       primary_metric='AUC_weighted',
                                       experiment_timeout_minutes=30,
                                       blocked_models=['XGBoostClassifier'],
                                       training_data=train_data,
                                       label_column_name=label,
                                       n_cross_validations=2)
    
  2. Az alábbi példa egy 60 perc után véget érő regressziós kísérlet öt ellenőrző keresztdedálással.

       automl_regressor = AutoMLConfig(task='regression',
                                       experiment_timeout_minutes=60,
                                       allowed_models=['KNN'],
                                       primary_metric='r2_score',
                                       training_data=train_data,
                                       label_column_name=label,
                                       n_cross_validations=5)
    
  3. Az előrejelzési feladatokhoz további beállításokra van szükség. További részletekért tekintse meg az AutoML idősorozat-előrejelzéshez való beállítását.

    time_series_settings = {
        'time_column_name': time_column_name,
        'time_series_id_column_names': time_series_id_column_names,
        'forecast_horizon': n_test_periods
    }
    
    automl_config = AutoMLConfig(task = 'forecasting',
                                 debug_log='automl_oj_sales_errors.log',
                                 primary_metric='normalized_root_mean_squared_error',
                                 experiment_timeout_minutes=20,
                                 training_data=train_data,
                                 label_column_name=label,
                                 n_cross_validations=5,
                                 path=project_folder,
                                 verbosity=logging.INFO,
                                 **time_series_settings)
    

Támogatott modellek

Az automatizált gépi tanulás különböző modelleket és algoritmusokat próbál meg használni az automatizálási és finomhangolási folyamat során. Felhasználóként nincs szükség az algoritmus megadására.

A három különböző paraméterérték határozza meg az alkalmazandó algoritmusok vagy task modellek listáját. A vagy a paraméter használatával további iterációkat módosíthat az elérhető modellekkel, hogy tartalmazza vagy allowed_models blocked_models kizárja őket.

Az alábbi táblázat a támogatott modelleket foglalja össze feladattípus szerint.

Megjegyzés

Ha automatizált, ML létrehozott modelleket tervez exportálni egy ONNX-modellbe,csak a * (csillag) jelű algoritmusok konvertálhatók ONNX formátumra. További információ a modellek ONNX-gé konvertálásával kapcsolatban.

Azt is vegye figyelembe, hogy az ONNX jelenleg csak a besorolási és regressziós feladatokat támogatja.

Osztályozás Regresszió Idősoros előrejelzés
Logisztikai regresszió* Elastic Net* AutoARIMA
Világos GBM* Világos GBM* Próféta
Színátmenet-növelés* Színátmenet-növelés* Rugalmas háló
Döntési fa* Döntési fa* Világos GBM
K legközelebbi szomszédok* K legközelebbi szomszédok* Színátmenet-növelés
Lineáris SVC* LARS-lasszó* Döntési fa
Támogatóvektor-besorolás (SVC)* Sztochasztikus gradiens gradiens (SGD)* Döntési fa
Véletlenszerű erdő* Véletlenszerű erdő LARS-lasszó
Rendkívül véletlenszerű fák* Rendkívül véletlenszerű fák* Sztochasztikus gradiens gradiens (SGD)
Xgboost* Xgboost* Véletlenszerű erdő
Averaged Perceptron Classifier Online gradiens gradiens regressor Xgboost
Naive Bayes* Gyors lineáris regresszió ForecastTCN
Sztochasztikus gradiens gradiens (SGD)* Naiv
Lineáris SVM-osztályozó* SzezonálisNaive
Átlag
Szezonális takarékos
ExponentialSmomoding (Exponenciális elazás)

Elsődleges metrika

A paraméter határozza meg a modell optimalizáláshoz való betanítása primary metric során használt metrikát. A kiválasztható metrikákat a kiválasztott feladattípus határozza meg, és az alábbi táblázatban az egyes feladattípusokkal kapcsolatos érvényes elsődleges metrikák érhetők el.

Az optimalizálás elsődleges metrika ML számos tényezőtől függ. Javasoljuk, hogy elsősorban olyan metrikát válasszon, amely a legjobban megfelelő az üzleti igényeinek. Ezután fontolja meg, hogy a metrika megfelelő-e az adatkészlet-profilhoz (adatméret, tartomány, osztályelosztás stb.).

A metrikák konkrét definícióit az Automatizált gépi tanulási eredmények megismerése cikkből megismerheti.

Osztályozás Regresszió Idősoros előrejelzés
accuracy spearman_correlation normalized_root_mean_squared_error
AUC_weighted normalized_root_mean_squared_error r2_score
average_precision_score_weighted r2_score normalized_mean_absolute_error
norm_macro_recall normalized_mean_absolute_error
precision_score_weighted

Metrikák besorolási forgatókönyvekhez

A küszöbértékeket követő metrikák, például a , a , a és a nem optimalizálhatóak olyan adatkészletek esetében, amelyek kis méretűek, nagyon nagy osztály-eltérésekkel (osztályegyensúlyos), vagy ha a várt metrikaérték nagyon közel áll accuracy average_precision_score_weighted a norm_macro_recall precision_score_weighted 0,0-hoz vagy az 1.0-hoz. Ilyen esetekben a AUC_weighted jobb választás lehet az elsődleges metrikákhoz. Az automatizált ML befejezése után az üzleti igényeinek leginkább megfelelő metrika alapján kiválaszthatja a nyerési modellt.

Metric Példahasználati eset(nek)
accuracy Képbesorolás, hangulatelemzés, adatváltozás-előrejelzés
AUC_weighted Csalásészlelés, képbesorolás, anomáliadetektálás/levélszemét észlelése
average_precision_score_weighted Hangulatelemzés
norm_macro_recall Adatváltozás-előrejelzés
precision_score_weighted

Regressziós forgatókönyvek metrikai

Az olyan metrikák, mint a és a jobban ábrázolják a modell minőségét, ha az előrejelzhető érték nagyságrendje sok r2_score spearman_correlation nagyságrendet fed le. Például fizetésbecslés, ahol sokak fizetése 20 000 és 100 000 USD között van, de a skála nagyon magas, és néhány fizetés a 100 milliós tartományban van.

normalized_mean_absolute_error A és ebben az esetben a 20 000 USD-s előrejelzési hibát ugyanúgy kezeli egy 30 000 USD-s fizetéssel dolgozó alkalmazott esetében, mint normalized_root_mean_squared_error a 20 M USD-t dolgozó dolgozó. Bár a valóságban csak 20 000 USD-s eltérést jósolunk meg egy 20 millió dolláros fizetéstől, nagyon közeli (kicsi, 0,1%-os relatív különbség), míg a 30 000 USD-hez képest 20 000 USD-től való eltérés nem közel van (nagy, 67%-os relatív különbség). normalized_mean_absolute_error A normalized_root_mean_squared_error és a akkor hasznosak, ha az előrejelezni nem megfelelő értékek hasonló léptékben vannak.

Metric Példahasználati eset(nek)
spearman_correlation
normalized_root_mean_squared_error Ár-előrejelzés (ház/termék/tipp), pontszám-előrejelzés áttekintése
r2_score Légitársaság késése, bérbecslés, hibafeloldási idő
normalized_mean_absolute_error

Metrikák idősor-előrejelzési forgatókönyvekhez

A javaslatok hasonlóak a regressziós forgatókönyveknél feljegyzett javaslatokhoz.

Metric Példahasználati eset(nek)
normalized_root_mean_squared_error Ár-előrejelzés (előrejelzés), leltároptimalizálás, igény-előrejelzés
r2_score Ár-előrejelzés (előrejelzés), leltároptimalizálás, igény-előrejelzés
normalized_mean_absolute_error

Adatsematurizálás

Minden automatizált ML kísérlet során a rendszer automatikusan méretezi és normalizálja az adatokat, hogy segítsen bizonyos algoritmusok számára, amelyek érzékenyek a különböző léptéken található jellemzőkre. Ezt a skálázást és normalizálást featurizálásnak nevezzük. További részletekért és példákért tekintse meg a Featurization in AutoML (Az AutoML-nek a featurization in AutoML) részleteit.

A kísérletek objektumban való konfigurálásakor engedélyezheti vagy letilthatja a AutoMLConfig featurization beállítást. Az alábbi táblázatban az AutoMLConfigobjektumban elfogadott featurizálási beállításokat mutatjuk be.

A featurizálás konfigurációja Description
"featurization": 'auto' Azt jelzi, hogy az előfeldolgozás részeként az adatkorlátok és a featurizálási lépések automatikusan végre vannak hajtva. Alapértelmezett beállítás:.
"featurization": 'off' Azt jelzi, hogy a featurizálási lépést nem szabad automatikusan tenni.
"featurization": 'FeaturizationConfig' Azt jelzi, hogy testreszabott featurizálási lépést kell használni. Megtudhatja, hogyan szabhatja testre a featurizálást.

Megjegyzés

A gépi tanulás jellemzősítésének automatizált lépései (a funkciók normalizálása, a hiányzó adatok kezelése, a szöveg numerikus formátumra konvertálása stb.) az alapul szolgáló modell részét képezi. Ha a modellt előrejelzésekhez használja, a rendszer automatikusan alkalmazza a betanítás során alkalmazott modellezési lépéseket a bemeneti adatokra.

Együttes konfigurációja

Az együttes modellek alapértelmezés szerint engedélyezve vannak, és az AutoML-futtatás utolsó futtatási iterációiként jelennek meg. Jelenleg a VotingEnsemble és a StackEnsemble támogatott.

A szavazás a soft-votingot valósítja meg, amely súlyozott átlagokat használ. A halmozási implementáció kétrétegű implementációt használ, ahol az első rétegben ugyanazok a modellek vannak, mint a szavazási együttes, a második rétegben pedig az első réteg modelljeinek optimális kombinációját találják meg.

Ha ONNX-modelleket használ, vagy ha engedélyezve van a modell elmagyarázhatósága, a halmozás le van tiltva, és csak a szavazást használja.

Az együttes betanítás a és logikai paraméterekkel enable_voting_ensemble enable_stack_ensemble tiltható le.

automl_classifier = AutoMLConfig(
        task='classification',
        primary_metric='AUC_weighted',
        experiment_timeout_minutes=30,
        training_data=data_train,
        label_column_name=label,
        n_cross_validations=5,
        enable_voting_ensemble=False,
        enable_stack_ensemble=False
        )

Az együttes működés alapértelmezett viselkedésének megváltoztatásához több alapértelmezett argumentumot is meg lehet adni, mint egy kwargs AutoMLConfig objektumban.

Fontos

Az alábbi paraméterek nem az AutoMLConfig osztály explicit paraméterei.

  • ensemble_download_models_timeout_sec: A VotingEnsemble és a StackEnsemble modell létrehozása során a korábbi gyermekfuttatások több illesztett modellje lesz letöltve. Ha a következő hibával találkozik: , akkor előfordulhat, hogy több időt kell adnia a modellek AutoMLEnsembleException: Could not find any models for running ensembling letöltéséhez. Az alapértelmezett érték 300 másodperc a modellek párhuzamos letöltéséhez, és nincs maximális időkorlát. Ha több időre van szüksége, konfigurálja ezt a paramétert 300 másodpercnél nagyobb értékre.

    Megjegyzés

    Ha eléri az időkorlátot, és letölti a modelleket, az ensemembling annyi modellt tartalmaz, amennyit letöltött. Nem szükséges, hogy az időtúllépés után az összes modellt le kell tölteni a befejezéshez.

A következő paraméterek csak a StackEnsemble-modellekre vonatkoznak:

  • stack_meta_learner_type: a meta tanuló az egyes heterogén modellek kimenetével betanított modell. Az alapértelmezett metafizikusok besorolási feladatokhoz (vagy ha a keresztellenőrzés engedélyezve van) és LogisticRegression LogisticRegressionCV ElasticNet regressziós/előrejelzési feladatokhoz (vagy ha engedélyezve van a ElasticNetCV keresztellenőrzés). Ez a paraméter a következő sztringek egyike lehet: LogisticRegression , , , , , vagy LogisticRegressionCV LightGBMClassifier ElasticNet ElasticNetCV LightGBMRegressor LinearRegression .

  • stack_meta_learner_train_percentage: megadja a betanítás halmazának azon részét (a betanítás és az ellenőrzési típus kiválasztásakor), amely a metafizikus betanítás számára lesz fenntartva. Az alapértelmezett érték 0.2.

  • stack_meta_learner_kwargs: nem kötelező paraméterek, amelyek a meta tanuló inicializálója számára átadhatóak. Ezek a paraméterek és paramétertípusok tükrözik a megfelelő modell konstruktor paramétereit és paramétertípusát, és továbbítják őket a modell konstruktorának.

Az alábbi kód egy példát mutat be az egyéni együttes viselkedés megadására egy AutoMLConfig objektumban.

ensemble_settings = {
    "ensemble_download_models_timeout_sec": 600
    "stack_meta_learner_type": "LogisticRegressionCV",
    "stack_meta_learner_train_percentage": 0.3,
    "stack_meta_learner_kwargs": {
        "refit": True,
        "fit_intercept": False,
        "class_weight": "balanced",
        "multi_class": "auto",
        "n_jobs": -1
    }
}

automl_classifier = AutoMLConfig(
        task='classification',
        primary_metric='AUC_weighted',
        experiment_timeout_minutes=30,
        training_data=train_data,
        label_column_name=label,
        n_cross_validations=5,
        **ensemble_settings
        )

Kilépési feltételek

Az AutoMLConfigben több lehetőséget is meghatározhat a kísérlet végére.

Feltételek leírás
Nincsenek   feltételek Ha nem határoz meg kilépési paramétereket, a kísérlet addig folytatódik, amíg nem történik további előrehaladás az elsődleges metrikán.
Hosszú     idő     után A beállításokban megadhatja, hogy a kísérlet mennyi ideig fusson (percben). experiment_timeout_minutes

A kísérlet időkorét túllépő hibák elkerülése érdekében legalább 15 perc, vagy 60 perc szükséges, ha a sor oszlopmérete meghaladja a 10 milliót.
A   pontszám el lett       érve A experiment_exit_score használata befejezi a kísérletet a megadott elsődleges metrikapontszám elérése után.

Kísérlet futtatása

Figyelmeztetés

Ha többször is futtat egy kísérletet ugyanazokkal a konfigurációs beállításokkal és elsődleges metrikával, valószínűleg minden kísérletben ingadozást fog látni a végső metrikapontszámban és a létrehozott modellekben. Az automatizált ML algoritmusok eredendő véletlenszerűséggel rendelkezik, amely a kísérlet által a modellek kimenetében és az ajánlott modell végső metrikapontszámában, például a pontosságban némi eltérést okozhat. Valószínűleg ugyanazokkal a modellnévvel fog eredményeket látni, de különböző hiperparamétereket használ.

Az automatizált ML létrehoz egy objektumot, amely egy nevestűs objektum Experiment a kísérletek Workspace futtatásához.

from azureml.core.experiment import Experiment

ws = Workspace.from_config()

# Choose a name for the experiment and specify the project folder.
experiment_name = 'Tutorial-automl'
project_folder = './sample_projects/automl-classification'

experiment = Experiment(ws, experiment_name)

Küldje el a kísérletet futtatásra, és hozzon létre egy modellt. Adja át a AutoMLConfig metódusnak submit a modellt generáló metódust.

run = experiment.submit(automl_config, show_output=True)

Megjegyzés

A függőségek először egy új gépen vannak telepítve. Akár 10 percig is eltarthat, amíg a kimenet megjelenik. Ha show_output ezt True a beállítást, akkor a kimenet megjelenik a konzolon.

Több gyermekfutat a fürtökön

Automatizált ML a kísérlet gyermekfuttatása egy olyan fürtön is elvégezhető, amely már egy másik kísérletet futtat. Az időzítés azonban attól függ, hogy a fürt hány csomóponttal rendelkezik, és hogy ezek a csomópontok elérhetők-e egy másik kísérlet futtatásához.

A fürt minden csomópontja különálló virtuális gépként (VM) működik, amely képes egyetlen betanítás futtatására; az automatizált ML ez gyermekfutatot jelent. Ha az összes csomópont foglalt, az új kísérlet a várólistára kerül. Ha azonban vannak szabad csomópontok, az új kísérlet automatikusan ML a gyermek párhuzamosan fut a rendelkezésre álló csomópontokon/virtuális gépeken.

A gyermekfuttatások és azok elvégezhetők kezelése érdekében javasoljuk, hogy kísérletenként hozzon létre egy dedikált fürtöt, és egyezést hozzon létre a kísérlet számának és a fürtben található csomópontok max_concurrent_iterations számának. Így a fürt összes csomópontját egyidejűleg használhatja a kívánt egyidejű gyermekfuttetések/-iterációk számával.

Konfigurálja max_concurrent_iterations a AutoMLConfig objektumot. Ha nincs konfigurálva, akkor alapértelmezés szerint kísérletenként csak egy egyidejű gyermekfuttetés/-iteráció engedélyezett.

Modellek és metrikák megismerása

Az ML lehetőségeket kínál a betanítás eredményeinek figyeléséhez és értékeléséhez.

  • A betanítás eredményeit widgetben vagy beágyazottan is megtekintheti, ha jegyzetfüzetben van. További részletekért lásd: Automatizált gépi tanulási futtatás figyelése.

  • Az egyes futtatásokkal kapcsolatos teljesítménydiagramok és metrikák definícióit és példáit lásd: Automatizált gépi tanulási kísérlet eredményeinek kiértékelése.

  • A jellemzősítés összegzését és az adott modellhez hozzáadott funkciókkal kapcsolatos információkért lásd: Jellemzősítés átláthatósága.

Megtekintheti a hiperparamétereket, a méretezési és normalizálási technikákat, valamint az adott automatizált alkalmazásokra alkalmazott ML az alábbi egyéni kódmegoldással futtathatók.

Az alábbiakban az egyéni metódust () definiáljuk, amely az automatizált betanítás folyamatának minden lépésének print_model() hiperparaméterét ML ki.

from pprint import pprint

def print_model(model, prefix=""):
    for step in model.steps:
        print(prefix + step[0])
        if hasattr(step[1], 'estimators') and hasattr(step[1], 'weights'):
            pprint({'estimators': list(e[0] for e in step[1].estimators), 'weights': step[1].weights})
            print()
            for estimator in step[1].estimators:
                print_model(estimator[1], estimator[0]+ ' - ')
        elif hasattr(step[1], '_base_learners') and hasattr(step[1], '_meta_learner'):
            print("\nMeta Learner")
            pprint(step[1]._meta_learner)
            print()
            for estimator in step[1]._base_learners:
                print_model(estimator[1], estimator[0]+ ' - ')
        else:
            pprint(step[1].get_params())
            print()   

Helyi vagy távoli futtatás esetén, amely az előbb lett elküldve és betanítva ugyanazon a kísérleti jegyzetfüzeten belül, a legjobb modellt használhatja a get_output() metódussal.

best_run, fitted_model = run.get_output()
print(best_run)
         
print_model(fitted_model)

Az alábbi kimenet azt jelzi, hogy:

  • A StandardScalerWrapper technikával a betanítás előtt skálázhatja és normalizálhatja az adatokat.

  • A legjobb futtatásként azonosították az XGBoostClassifier algoritmust, és a hiperparaméter-értékeket is megjeleníti.

StandardScalerWrapper
{'class_name': 'StandardScaler',
 'copy': True,
 'module_name': 'sklearn.preprocessing.data',
 'with_mean': False,
 'with_std': False}

XGBoostClassifier
{'base_score': 0.5,
 'booster': 'gbtree',
 'colsample_bylevel': 1,
 'colsample_bynode': 1,
 'colsample_bytree': 0.6,
 'eta': 0.4,
 'gamma': 0,
 'learning_rate': 0.1,
 'max_delta_step': 0,
 'max_depth': 8,
 'max_leaves': 0,
 'min_child_weight': 1,
 'missing': nan,
 'n_estimators': 400,
 'n_jobs': 1,
 'nthread': None,
 'objective': 'multi:softprob',
 'random_state': 0,
 'reg_alpha': 0,
 'reg_lambda': 1.6666666666666667,
 'scale_pos_weight': 1,
 'seed': None,
 'silent': None,
 'subsample': 0.8,
 'tree_method': 'auto',
 'verbose': -10,
 'verbosity': 1}

Ha egy meglévő futtatás egy másik kísérletből fut a munkaterületen, szerezze be a vizsgálni kívánt futtatás azonosítóját, és adja át a print_model() metódusnak.

from azureml.train.automl.run import AutoMLRun

ws = Workspace.from_config()
experiment = ws.experiments['automl-classification']
automl_run = AutoMLRun(experiment, run_id = 'AutoML_xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxx')

automl_run
best_run, model_from_aml = automl_run.get_output()

print_model(model_from_aml)

Automatizált gépi tanulási futtatás figyelése

Az automatizált ML futtatásához az előző futtatás diagramjainak eléréséhez cserélje le a helyére a <<experiment_name>> megfelelő kísérlet nevét:

from azureml.widgets import RunDetails
from azureml.core.run import Run

experiment = Experiment (workspace, <<experiment_name>>)
run_id = 'autoML_my_runID' #replace with run_ID
run = Run(experiment, run_id)
RunDetails(run).show()

Jupyter Notebook-widget az automatizált Machine Learning

Modellek regisztrálása és üzembe helyezése

Regisztrálhat egy modellt, hogy később visszatérhet hozzá.

A modell automatizált gépről való ML a register_model() metódussal.


best_run = run.get_best_child()
print(fitted_model.steps)

model_name = best_run.properties['model_name']
description = 'AutoML forecast example'
tags = None

model = run.register_model(model_name = model_name, 
                                  description = description, 
                                  tags = tags)

Az üzembe helyezési konfigurációk létrehozásáról és a regisztrált modell webszolgáltatásban való üzembe helyezéséről további információt a modell üzembe helyezésének útmutatójában és helyében talál.

Tipp

Regisztrált modellek esetén az egykattintásos üzembe helyezés a Azure Machine Learning studióban érhető el. Tekintse meg, hogyan helyezhet üzembe regisztrált modelleket a Studióból.

Modell értelmezhetősége

A modell értelmezhetősége lehetővé teszi annak értelmezését, hogy a modellek miért készítettek előrejelzéseket, valamint a mögöttes jellemző fontossági értékeit. Az SDK különböző csomagokat tartalmaz a modell értelmezhetőségi funkcióinak a betanításkor és a következtetéskor való engedélyezéséhez a helyi és az üzembe helyezett modellekhez.

Tekintse meg a kódmintákat, amelyekből arra vonatkozó példákat láthat, hogyan engedélyezheti az értelmezhetőségi funkciókat kifejezetten az automatizált ML kísérletekben.

A modell magyarázatának és a funkciók fontosságának az automatizált gépi tanuláson kívüli más területein történő alkalmazásával kapcsolatos általános információkért tekintse meg az értelmezhetőséggel kapcsolatos cikket.

Megjegyzés

A Magyarázat ügyfél jelenleg nem támogatja az ForecastTCN modellt. Ez a modell nem ad vissza magyarázati irányítópultot, ha a rendszer a legjobb modellként adja vissza, és nem támogatja az igény szerinti magyarázatfuttatásokat.

Következő lépések