AutoML-training instellen met Python

In deze handleiding leert u hoe u een geautomatiseerde machine learning, AutoML, training kunt instellen met de Azure Machine Learning Python SDK met behulp van Azure Machine Learning geautomatiseerde ML. Geautomatiseerde ML kiest een algoritme en hyperparameters voor u en genereert een model dat gereed is voor implementatie. Deze handleiding bevat details van de verschillende opties die u kunt gebruiken om geautomatiseerde ML configureren.

Zie Zelfstudie: AutoML- regressiemodel trainen voor een end-to-end-voorbeeld.

Als u liever geen code gebruikt, kunt u ook AutoML-trainingzonder code instellen in Azure Machine Learning studio.

Vereisten

Voor dit artikel hebt u het volgende nodig:

Het type experimenten selecteren

Voordat u met uw experiment begint, moet u bepalen wat voor soort probleem machine learning u oplost. Geautomatiseerde machine learning ondersteunt taaktypen classification van , en regression forecasting . Meer informatie over taaktypen.

De volgende code gebruikt de task parameter in de AutoMLConfig constructor om het experimenttype op te geven als classification .

from azureml.train.automl import AutoMLConfig

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

Gegevensbron en -indeling

Geautomatiseerde machine learning biedt ondersteuning voor gegevens die zich bevinden op de lokale desktop of in de cloud, zoals Azure Blob Storage. De gegevens kunnen worden gelezen in een Pandas DataFrame of een Azure Machine Learning TabularDataset. Meer informatie over gegevenssets.

Vereisten voor trainingsgegevens in machine learning:

  • Gegevens moeten in tabelvorm zijn.
  • De waarde die moet worden voorspeld, de doelkolom, moet in de gegevens zijn.

Voor externe experimenten moeten trainingsgegevens toegankelijk zijn vanaf de externe berekening. Geautomatiseerde ML accepteert alleen Azure Machine Learning TabularDatasets wanneer u op een externe berekening werkt.

Azure Machine Learning-gegevenssets bieden functionaliteit voor:

  • U kunt eenvoudig gegevens overdragen van statische bestanden of URL-bronnen naar uw werkruimte.
  • Het beschikbaar maken van uw gegevens voor trainingsscripts bij uitvoering in computeresources in de cloud. Zie Trainen met gegevenssets voor een voorbeeld van het gebruik van de klasse om gegevens te Dataset mounten aan uw externe rekendoel.

Met de volgende code maakt u een TabularDataset op basis van een web-URL. Zie Een TabularDataset maken voor codevoorbeelden over het maken van gegevenssets van andere bronnen, zoals lokale bestanden en gegevensstores.

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)

Voor lokale rekenexperimenten raden we pandas-gegevensframes aan voor snellere verwerkingstijden.

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"

Trainings-, validatie- en testgegevens

U kunt afzonderlijke trainingsgegevens en validatiegegevenssets rechtstreeks in de AutoMLConfig constructor opgeven. Meer informatie over het configureren van gegevenssplitsingen en kruisvalidatie voor uw AutoML-experimenten.

Als u niet expliciet een parameter of opgeeft, worden met geautomatiseerde ML technieken toegepast om te bepalen hoe validation_data n_cross_validation validatie wordt uitgevoerd. Deze beslissing is afhankelijk van het aantal rijen in de gegevensset die is toegewezen aan uw training_data parameter.

Grootte   van   trainingsgegevens Validatietechniek
Groter   dan   20.000   rijen Gegevenssplitsing voor trainen/validatie wordt toegepast. De standaardwaarde is om 10% van de eerste trainingsgegevensset als validatieset te gebruiken. Die validatieset wordt op zijn beurt gebruikt voor het berekenen van metrische gegevens.
Kleiner   dan   20.000   rijen Er wordt een benadering voor kruisvalidatie toegepast. Het standaard aantal vouwen is afhankelijk van het aantal rijen.
Als de gegevensset minder dan 1000 rijen is, worden er 10 gevouwen.
Als de rijen tussen 1000 en 20.000 zijn, worden er drie keer gebruikt.

Op dit moment moet u uw eigen testgegevens voor modelevaluatie verstrekken. Zie de sectie Testen van dit Jupyter-notebookvoor een codevoorbeeld van het meenemen van uw eigen testgegevens voor modelevaluatie.

Grote gegevens

Geautomatiseerde ML ondersteunt een beperkt aantal algoritmen voor training op grote gegevens waarmee modellen voor big data kleine virtuele machines kunnen worden gebouwd. Geautomatiseerde ML zijn afhankelijk van eigenschappen zoals gegevensgrootte, geheugengrootte van virtuele machines, time-out van experimenten en featurization-instellingen om te bepalen of deze grote gegevensalgoritmen moeten worden toegepast. Meer informatie over welke modellen worden ondersteund in geautomatiseerde ML.

Als u deze heuristieken wilt overschrijven, moet u de volgende instellingen toepassen:

Taak Instelling Notities
Algoritmen   voor gegevensstreaming blokkeren blocked_models in uw AutoMLConfig -object en vermeld de modellen die u niet wilt gebruiken. Resulteert in een mislukte of lange run time
Algoritmen   voor     gegevensstreaming gebruiken allowed_models in uw AutoMLConfig -object en vermeld de modellen die u wilt gebruiken.
Algoritmen   voor     gegevensstreaming gebruiken
(Studio UI-experimenten)
Blokkeer alle modellen behalve de big data algoritmen die u wilt gebruiken.

Compute en uitvoering van het experiment instellen

Bepaal vervolgens waar het model wordt getraind. Een geautomatiseerd ML trainingsexperiment kan worden uitgevoerd op de volgende rekenopties. Meer informatie over de voordelen en nadelen van lokale en externe compute-opties.

  • Uw lokale computer, zoals een lokale desktop of laptop: doorgaans wanneer u een kleine gegevensset hebt en u nog in de verkenningsfase bent. Bekijk dit notebook voor een lokaal compute-voorbeeld.

  • Een externe machine in de cloud: Azure Machine Learning Managed Compute is een beheerde service waarmee u de machine learning kunt trainen op clusters van virtuele Azure-machines. Rekenkracht wordt ook ondersteund als rekendoel.

    Raadpleeg dit notebook voor een extern voorbeeld met behulp van beheerde compute van Azure Machine Learning.

  • Een Azure Databricks cluster in uw Azure-abonnement. Meer informatie vindt u in Set up an Azure Databricks cluster for automated ML. Zie deze GitHub voor voorbeelden van notebooks met Azure Databricks.

Uw experimentinstellingen configureren

Er zijn verschillende opties die u kunt gebruiken om uw geautomatiseerde ML configureren. Deze parameters worden ingesteld door een -object te AutoMLConfig instantiëren. Zie de klasse AutoMLConfig voor een volledige lijst met parameters.

Het volgende voorbeeld is voor een classificatietaak. Het experiment maakt gebruik van AUC gewogen als primaire metriek en heeft een time-out voor het experiment ingesteld op 30 minuten en 2 kruisvalidatie-vouwen.

    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)

U kunt ook prognosetaken configureren, waarvoor extra installatie is vereist. Zie het artikel AutoML instellen voor prognoses voor tijdreeksen voor meer informatie.

    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
                                )

Ondersteunde modellen

Geautomatiseerde machine learning verschillende modellen en algoritmen tijdens het automatiserings- en afstemmingsproces. Als gebruiker hoeft u het algoritme niet op te geven.

De drie verschillende task parameterwaarden bepalen de lijst met algoritmen of modellen die moeten worden toegepast. Gebruik de allowed_models parameters of blocked_models om iteraties verder te wijzigen met de beschikbare modellen die moeten worden opgesloten of uitgesloten.

De volgende tabel bevat een overzicht van de ondersteunde modellen op taaktype.

Notitie

Als u van plan bent om uw geautomatiseerde ML gemaakte modellen te exporteren naar een ONNX-model,kunnen alleen de algoritmen die worden aangegeven met een * (sterretje) worden geconverteerd naar de ONNX-indeling. Meer informatie over het converteren van modellen naar ONNX.

Houd er ook rekening mee dat ONNX op dit moment alleen classificatie- en regressietaken ondersteunt.

Classificatie Regressie Tijdreeksvoorspelling
Logistieke regressie* Elastisch net* AutoARIMA
Lichte GBM* Lichte GBM* Profeet
Gradient Boosting* Gradient Boosting* Elastic Net
Beslissingsstructuur* Beslissingsstructuur* Lichte GBM
K dichtstbijzijnde buren* K dichtstbijzijnde buren* Gradient Boosting
Lineaire SVC* JET Lasso* Beslissingsstructuur
Support Vector Classification (SVC)* Stochastische gradiëntafdaling (SGD)* Beslissingsstructuur
Willekeurig forest* Willekeurig forest LARS Lasso
Zeer willekeurige bomen* Zeer willekeurige bomen* Stochastische gradiëntafdaling (SGD)
Xgboost* Xgboost* Willekeurig forest
Gemiddelde Perceptron-classificatie Online Gradient Descent Regressor Xgboost
Naive Bayes* Fast Linear Regressor ForecastTCN
Stochastische gradiëntafdaling (SGD)* Naive
Lineaire SVM-classificatie* SeasonalNaive
Gemiddeld
SeasonalAverage
ExponentialSmoothing
Arimax

Primaire metrische gegevens

De primary_metric parameter bepaalt de metrische waarde die moet worden gebruikt tijdens het trainen van het model voor optimalisatie. De beschikbare metrische gegevens die u kunt selecteren, worden bepaald door het taaktype dat u kiest.

Het kiezen van een primaire metrische gegevens voor geautomatiseerde ML optimaliseren is afhankelijk van veel factoren. We raden u aan om een metrische gegevens te kiezen die het beste bij uw bedrijfsbehoeften past. Overweeg vervolgens of de metrische gegevens geschikt zijn voor uw gegevenssetprofiel (gegevensgrootte, bereik, klassendistributie, enzovoort). In de volgende secties worden de aanbevolen primaire metrische gegevens samengevat op basis van taaktype en bedrijfsscenario.

Meer informatie over de specifieke definities van deze metrische gegevens in Inzicht in geautomatiseerde machine learning resultaten.

Metrische gegevens voor classificatiescenario's

Metrische gegevens na een drempelwaarde, zoals , , en zijn mogelijk niet zo goed geoptimaliseerd voor gegevenssets die klein zijn, zeer grote klassenverschil hebben (ongelijke klasse) of wanneer de verwachte metrische waarde zeer dicht bij accuracy average_precision_score_weighted norm_macro_recall precision_score_weighted 0,0 of 1,0 ligt. In dergelijke gevallen AUC_weighted kan een betere keuze zijn voor de primaire metrische gegevens. Nadat geautomatiseerde ML voltooid, kunt u het prijsmodel kiezen op basis van de metrische gegevens die het meest geschikt zijn voor uw bedrijfsbehoeften.

Metrisch Voorbeeld van use case(s)
accuracy Afbeeldingsclassificatie, sentimentanalyse, verloopvoorspelling
AUC_weighted Fraudedetectie, afbeeldingsclassificatie, anomaliedetectie/spamdetectie
average_precision_score_weighted Sentimentanalyse
norm_macro_recall Verloopvoorspelling
precision_score_weighted

Metrische gegevens voor regressiescenario's

Metrische gegevens zoals en kunnen de kwaliteit van het model beter vertegenwoordigen wanneer de schaal van de te voorspellen waarde vele r2_score spearman_correlation ordes van grootte dekt. Bijvoorbeeld salarisschatting, waarbij veel mensen een salaris van $ 20.000 tot $ 100.000 hebben, maar de schaal zeer hoog gaat bij sommige salarissen in het bereik van $ 100 miljoen.

normalized_mean_absolute_error en zou in dit geval een voorspellingsfout van $ 20.000 op dezelfde manier behandelen voor een werker met een salaris van $ 30.000 als een werker die normalized_root_mean_squared_error $ 20 miljoen maakt. In werkelijkheid is het voorspellen van slechts $ 20.000 van een salaris van $ 20 miljoen heel dichtbij (een klein relatief verschil van 0,1%), terwijl $ 20.000 van $ 30.000 niet dicht bij elkaar ligt (een groot relatief verschil van 67%). normalized_mean_absolute_error en normalized_root_mean_squared_error zijn handig wanneer de te voorspellen waarden zich in een vergelijkbare schaal hebben.

Metrisch Voorbeeld van use case(s)
spearman_correlation
normalized_root_mean_squared_error Prijsvoorspelling (huis/product/tip), beoordelingsscorevoorspelling
r2_score Vertraging luchtvaartmaatschappij, salarisschatting, oplossingstijd van fouten
normalized_mean_absolute_error

Metrische gegevens voor scenario's voor tijdreeksprognoses

De aanbevelingen zijn vergelijkbaar met die voor regressiescenario's.

Metrisch Voorbeeld van use case(s)
normalized_root_mean_squared_error Prijsvoorspelling (prognose), inventarisoptimalisatie, Vraagprognose
r2_score Prijsvoorspelling (prognose), inventarisoptimalisatie, Vraagprognose
normalized_mean_absolute_error

Kenmerken van gegevens

In elk geautomatiseerd ML experiment worden uw gegevens automatisch geschaald en genormaliseerd om bepaalde algoritmen te helpen die gevoelig zijn voor functies op verschillende schaal. Deze schaalbaarheid en normalisatie wordt ook wel featurization genoemd. Zie Featurization in AutoML (Featurization in AutoML) voor meer informatie en codevoorbeelden.

Wanneer u uw experimenten in uw AutoMLConfig -object configureert, kunt u de instelling in- of featurization uitschakelen. In de volgende tabel ziet u de geaccepteerde instellingen voor featurization in het AutoMLConfig-object.

Featurization-configuratie Description
"featurization": 'auto' Geeft aan dat gegevensbescherming en featurization-stappen automatisch worden uitgevoerd als onderdeel van voorverwerking. Standaardinstelling.
"featurization": 'off' Geeft aan dat de featurization-stap niet automatisch moet worden uitgevoerd.
"featurization": 'FeaturizationConfig' Geeft aan dat de aangepaste featurization-stap moet worden gebruikt. Meer informatie over het aanpassen van featurization.

Notitie

Geautomatiseerde machine learning functienormalisatie (functienormalisatie, verwerking van ontbrekende gegevens, het converteren van tekst naar numerieke gegevens, enzovoort) worden onderdeel van het onderliggende model. Wanneer u het model voor voorspellingen gebruikt, worden dezelfde featurization-stappen die tijdens de training worden toegepast, automatisch toegepast op uw invoergegevens.

Ensembleconfiguratie

Ensemblemodellen zijn standaard ingeschakeld en worden weergegeven als de laatste uitvoerings iteraties in een AutoML-uitvoering. Momenteel worden VotingEnsemble en StackEnsemble ondersteund.

Met stemmen wordt een zachte stem geïmplementeerd, waarbij gebruik wordt gemaakt van gewogen gemiddelden. De stacking-implementatie maakt gebruik van een implementatie met twee lagen, waarbij de eerste laag dezelfde modellen heeft als het stemmende ensemble, en het tweede laagmodel wordt gebruikt om de optimale combinatie van de modellen van de eerste laag te vinden.

Als u ONNX-modellen gebruikt of als model verklaarbaarheid is ingeschakeld, wordt stapelen uitgeschakeld en wordt alleen stemmen gebruikt.

De ensembletraining kan worden uitgeschakeld met behulp van de enable_voting_ensemble enable_stack_ensemble Booleaanse parameters en .

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
                                )

Als u het standaardgedrag van het ensemble wilt wijzigen, zijn er meerdere standaardargumenten die kunnen worden opgegeven als kwargs in een AutoMLConfig -object.

Belangrijk

De volgende parameters zijn geen expliciete parameters van de klasse AutoMLConfig.

  • ensemble_download_models_timeout_sec: Tijdens het genereren van votingEnsemble- en StackEnsemble-modellen worden meerdere passende modellen van de vorige onderliggende uitvoeringen gedownload. Als u deze fout tegenkomt: , moet u mogelijk meer tijd geven om de AutoMLEnsembleException: Could not find any models for running ensembling modellen te downloaden. De standaardwaarde is 300 seconden voor het parallel downloaden van deze modellen en er is geen maximale time-outlimiet. Configureer deze parameter met een hogere waarde dan 300 seconden, als er meer tijd nodig is.

    Notitie

    Als de time-out is bereikt en er modellen zijn gedownload, gaat de ensembling verder met het aantal modellen dat is gedownload. Het is niet vereist dat alle modellen moeten worden gedownload om deze time-out te voltooien.

De volgende parameters zijn alleen van toepassing op StackEnsemble-modellen:

  • stack_meta_learner_type: de meta-learner is een model dat is getraind op de uitvoer van de afzonderlijke heterogene modellen. Standaard meta-learners zijn voor classificatietaken (of als kruisvalidatie is ingeschakeld) en voor LogisticRegression LogisticRegressionCV ElasticNet regressie-/prognosetaken (of als kruisvalidatie ElasticNetCV is ingeschakeld). Deze parameter kan een van de volgende tekenreeksen zijn: LogisticRegression , , , , , of LogisticRegressionCV LightGBMClassifier ElasticNet ElasticNetCV LightGBMRegressor LinearRegression .

  • stack_meta_learner_train_percentage: geeft het aandeel aan van de trainingsset (bij het kiezen van het trainings- en validatietype) dat moet worden gereserveerd voor het trainen van de meta-learner. De standaardwaarde is 0.2.

  • stack_meta_learner_kwargs: optionele parameters om door te geven aan de initialisatie van de meta-learner. Deze parameters en parametertypen weerspiegelen de parameters en parametertypen van de bijbehorende model constructor en worden doorgestuurd naar de model constructor.

De volgende code toont een voorbeeld van het opgeven van aangepast ensemblegedrag in een AutoMLConfig object.

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
                                )

Criteria voor afsluiten

Er zijn enkele opties die u kunt definiëren in uw AutoMLConfig om uw experiment te beëindigen.

Criteria beschrijving
Geen   criteria Als u geen afsluitende parameters definieert, wordt het experiment voortgezet totdat er geen verdere voortgang wordt gemaakt met uw primaire metrische gegevens.
Na     een   periode   Gebruik experiment_timeout_minutes in uw instellingen om te definiëren hoe lang, in minuten, uw experiment moet worden uitgevoerd.

Om time-outfouten bij het experiment te voorkomen, is er minimaal 15 minuten of 60 minuten als uw rij per kolomgrootte groter is dan 10 miljoen.
Er     is een score     bereikt Met experiment_exit_score Gebruik wordt het experiment voltooid nadat een opgegeven primaire metrische score is bereikt.

Experiment uitvoeren

Waarschuwing

Als u meerdere keren een experiment met dezelfde configuratie-instellingen en primaire metrische gegevens hebt uitgevoerd, zult u waarschijnlijk variatie zien in de uiteindelijke score voor metrische gegevens van elke experimenten en de gegenereerde modellen. De geautomatiseerde algoritmen ML hebben inherente willekeurigheid die een kleine variatie kan veroorzaken in de modeluitvoer door het experiment en de uiteindelijke score voor metrische gegevens van het aanbevolen model, zoals nauwkeurigheid. Waarschijnlijk ziet u ook resultaten met dezelfde modelnaam, maar er worden verschillende hyperparameters gebruikt.

Voor geautomatiseerde ML maakt u een -object, een benoemd Experiment object in een dat wordt gebruikt om experimenten uit te Workspace voeren.

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)

Dien het experiment in om een model uit te voeren en te genereren. Geef de AutoMLConfig door aan de methode om het model te submit genereren.

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

Notitie

Afhankelijkheden worden eerst geïnstalleerd op een nieuwe computer. Het kan tot 10 minuten duren voordat de uitvoer wordt weergegeven. Instelling show_output op resulteert in uitvoer die wordt weergegeven op de True console.

Meerdere onderliggende runs op clusters

Automatische ML onderliggende experimenten kunnen worden uitgevoerd op een cluster dat al een ander experiment wordt uitgevoerd. De timing is echter afhankelijk van het aantal knooppunten dat het cluster heeft en of deze knooppunten beschikbaar zijn om een ander experiment uit te voeren.

Elk knooppunt in het cluster fungeert als een afzonderlijke virtuele machine (VM) die één trainingsrun kan uitvoeren; voor automatische ML betekent dit een onderliggende run. Als alle knooppunten bezet zijn, wordt het nieuwe experiment in de wachtrij geplaatst. Maar als er gratis knooppunten zijn, wordt het nieuwe experiment automatisch uitgevoerd ML onderliggende wordt parallel uitgevoerd in de beschikbare knooppunten/VM's.

Als u wilt helpen bij het beheren van onderliggende runs en wanneer deze kunnen worden uitgevoerd, raden we u aan per experiment een toegewezen cluster te maken en het aantal van uw experiment te laten overeenkomen met het aantal knooppunten max_concurrent_iterations in het cluster. Op deze manier gebruikt u alle knooppunten van het cluster tegelijkertijd met het aantal gelijktijdige onderliggende runs/iteraties dat u wilt.

Configureer max_concurrent_iterations in uw AutoMLConfig -object. Als deze niet is geconfigureerd, is standaard slechts één gelijktijdige onderliggende run/iteratie per experiment toegestaan. In het geval van een rekenin exemplaar kan worden ingesteld op hetzelfde aantal max_concurrent_iterations kernen op de VM van het rekenin exemplaar.

Modellen en metrische gegevens verkennen

Geautomatiseerde ML biedt opties voor het bewaken en evalueren van uw trainingsresultaten.

  • U kunt uw trainingsresultaten weergeven in een widget of inline als u zich in een notebook. Zie Geautomatiseerde machine learning bewaken voor meer informatie.

  • Zie Evaluate automated machine learning experiment results (Geautomatiseerde resultaten evalueren en uitvoeren) voor definities en voorbeelden van de prestatiegrafieken en metrische gegevens voor elke uitvoering.

  • Zie Featurization transparency (Transparantie van featurization) voor een samenvatting van featurization en inzicht te krijgen in welke functies zijn toegevoegd aan een bepaald model.

U kunt de hyperparameters, de schalings- en normalisatietechnieken en het algoritme die zijn toegepast op een specifieke geautomatiseerde ML met de volgende aangepaste codeoplossing uitvoeren.

Het volgende definieert de aangepaste methode, , waarmee de hyperparameters van elke stap van de geautomatiseerde ML print_model() trainingspijplijn worden afgedrukt.

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

Voor een lokale of externe uitvoering die is verzonden en getraind vanuit hetzelfde experimentnoteboek, kunt u het beste model doorgeven met behulp van de get_output() methode .

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

De volgende uitvoer geeft aan dat:

  • De techniek StandardScalerWrapper is gebruikt om de gegevens vóór de training te schalen en te normaliseren.

  • Het XGBoostClassifier-algoritme is geïdentificeerd als de beste run en toont ook de hyperparameterwaarden.

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}

Voor een bestaande run vanuit een ander experiment in uw werkruimte haalt u de specifieke run-id op die u wilt verkennen en geef deze door aan de print_model() methode .

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)

Geautomatiseerde machine learning bewaken

Voor geautomatiseerde ML kunt u de grafieken van een vorige run openen door de juiste experimentnaam te <<experiment_name>> vervangen:

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 voor Geautomatiseerde Machine Learning

Modellen registreren en implementeren

U kunt een model registreren, zodat u er later naar kunt teruggaan.

Als u een model wilt registreren vanuit een geautomatiseerde ML uitvoeren, gebruikt u de register_model() methode .


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)

Zie hoe en waar u een model implementeert voor meer informatie over het maken van een implementatieconfiguratie en het implementeren van een geregistreerd model in een webservice.

Tip

Voor geregistreerde modellen is implementatie met één klik beschikbaar via Azure Machine Learning studio. Zie hoe u geregistreerde modellen implementeert vanuit de studio.

Interpreteerbaarheid van modellen

Met de interpreteerbaarheid van modellen kunt u begrijpen waarom uw modellen voorspellingen hebben gedaan en de onderliggende waarden voor het belang van functies. De SDK bevat verschillende pakketten voor het inschakelen van model interpreteerbaarheidsfuncties, zowel tijdens de training als de deference time, voor lokale en geïmplementeerde modellen.

Zie hoe u interpreteerbaarheidsfuncties specifiek binnen geautomatiseerde ML inschakelen.

Zie het conceptartikel over interpreteerbaarheid voor algemene informatie over hoe modelverklaringen en het belang van functies kunnen worden ingeschakeld op andere gebieden van de SDK buiten geautomatiseerde machine learning.

Notitie

Het ForecastTCN-model wordt momenteel niet ondersteund door de Explanation Client. Dit model retourneerde geen uitlegdashboard als het wordt geretourneerd als het beste model en biedt geen ondersteuning voor uitvoeringen van uitleg op aanvraag.

Volgende stappen