Hyperparameters afstemmen in pijplijnen

VAN TOEPASSING OP:Azure CLI ml extension v2 (current)Python SDK azure-ai-ml v2 (current)

In dit artikel leert u hoe u hyperparameterafstemming in Azure Machine Learning-pijplijnen automatiseert met behulp van Azure Machine Learning CLI v2 of Azure Machine Learning SDK voor Python v2.

Hyperparameters zijn aanpasbare parameters waarmee u het modeltrainingsproces kunt beheren. Hyperparameterafstemming is het proces voor het vinden van de configuratie van hyperparameters die de beste prestaties opleveren. Met Azure Machine Learning kunt u hyperparameterafstemming automatiseren en experimenten parallel uitvoeren om hyperparameters efficiënt te optimaliseren.

Vereisten

• Een Azure Machine Learning-account en werkruimte hebben.
• Meer informatie over Azure Machine Learning-pijplijnen en het afstemmen van een model met hyperparameters.

Een pijplijn voor het afstemmen van hyperparameters maken en uitvoeren

Azure-CLI

De volgende voorbeelden zijn afkomstig van een pijplijntaak uitvoeren met behulp van opruimen (hyperdrive) in de opslagplaats met Azure Machine Learning-voorbeelden . Zie Machine Learning-pijplijnen maken en uitvoeren met behulp van onderdelen met de Azure Machine Learning CLI voor meer informatie over het maken van pijplijnen met onderdelen.

Python SDK

De volgende voorbeelden zijn afkomstig uit de build-pijplijn met een notebook voor het opruimen van knooppunten in de opslagplaats met Voorbeelden van Azure Machine Learning . Zie Machine Learning-pijplijnen maken en uitvoeren met behulp van onderdelen met de Azure Machine Learning SDK v2 voor meer informatie over het maken van pijplijnen met onderdelen.

Zie Hyperparameter opruimen uitvoeren voor een opdrachttaak voor een gerelateerd notebook.

Een opdrachtonderdeel maken met hyperparameterinvoer

De Azure Machine Learning-pijplijn moet een opdrachtonderdeel met hyperparameterinvoer hebben. Het volgende train.yml bestand uit de voorbeeldprojecten definieert een trial onderdeel met de c_valueinvoer en kernelcoef hyperparameterinvoer en voert de broncode uit die zich in de map ./train-src bevindt.

$schema: https://azuremlschemas.azureedge.net/latest/commandComponent.schema.json
type: command

name: train_model
display_name: train_model
version: 1

inputs: 
  data:
    type: uri_folder
  c_value:
    type: number
    default: 1.0
  kernel:
    type: string
    default: rbf
  degree:
    type: integer
    default: 3
  gamma:
    type: string
    default: scale
  coef0: 
    type: number
    default: 0
  shrinking:
    type: boolean
    default: false
  probability:
    type: boolean
    default: false
  tol:
    type: number
    default: 1e-3
  cache_size:
    type: number
    default: 1024
  verbose:
    type: boolean
    default: false
  max_iter:
    type: integer
    default: -1
  decision_function_shape:
    type: string
    default: ovr
  break_ties:
    type: boolean
    default: false
  random_state:
    type: integer
    default: 42

outputs:
  model_output:
    type: mlflow_model
  test_data:
    type: uri_folder
  
code: ./train-src

environment: azureml://registries/azureml/environments/sklearn-1.5/labels/latest

command: >-
  python train.py 
  --data ${{inputs.data}}
  --C ${{inputs.c_value}}
  --kernel ${{inputs.kernel}}
  --degree ${{inputs.degree}}
  --gamma ${{inputs.gamma}}
  --coef0 ${{inputs.coef0}}
  --shrinking ${{inputs.shrinking}}
  --probability ${{inputs.probability}}
  --tol ${{inputs.tol}}
  --cache_size ${{inputs.cache_size}}
  --verbose ${{inputs.verbose}}
  --max_iter ${{inputs.max_iter}}
  --decision_function_shape ${{inputs.decision_function_shape}}
  --break_ties ${{inputs.break_ties}}
  --random_state ${{inputs.random_state}}
  --model_output ${{outputs.model_output}}
  --test_data ${{outputs.test_data}}

De broncode van het proefonderdeel maken

De broncode voor dit voorbeeld is één train.py bestand. Deze code wordt uitgevoerd in elke proefversie van de sweep-taak.

# imports
import os
import mlflow
import argparse

import pandas as pd
from pathlib import Path

from sklearn.svm import SVC
from sklearn.model_selection import train_test_split

# define functions
def main(args):
    # enable auto logging
    mlflow.autolog()

    # setup parameters
    params = {
        "C": args.C,
        "kernel": args.kernel,
        "degree": args.degree,
        "gamma": args.gamma,
        "coef0": args.coef0,
        "shrinking": args.shrinking,
        "probability": args.probability,
        "tol": args.tol,
        "cache_size": args.cache_size,
        "class_weight": args.class_weight,
        "verbose": args.verbose,
        "max_iter": args.max_iter,
        "decision_function_shape": args.decision_function_shape,
        "break_ties": args.break_ties,
        "random_state": args.random_state,
    }

    # read in data
    df = pd.read_csv(args.data)

    # process data
    X_train, X_test, y_train, y_test = process_data(df, args.random_state)

    # train model
    model = train_model(params, X_train, X_test, y_train, y_test)
    # Output the model and test data
    # write to local folder first, then copy to output folder

    mlflow.sklearn.save_model(model, "model")

    from distutils.dir_util import copy_tree

    # copy subdirectory example
    from_directory = "model"
    to_directory = args.model_output

    copy_tree(from_directory, to_directory)

    X_test.to_csv(Path(args.test_data) / "X_test.csv", index=False)
    y_test.to_csv(Path(args.test_data) / "y_test.csv", index=False)


def process_data(df, random_state):
    # split dataframe into X and y
    X = df.drop(["species"], axis=1)
    y = df["species"]

    # train/test split
    X_train, X_test, y_train, y_test = train_test_split(
        X, y, test_size=0.2, random_state=random_state
    )

    # return split data
    return X_train, X_test, y_train, y_test


def train_model(params, X_train, X_test, y_train, y_test):
    # train model
    model = SVC(**params)
    model = model.fit(X_train, y_train)

    # return model
    return model


def parse_args():
    # setup arg parser
    parser = argparse.ArgumentParser()

    # add arguments
    parser.add_argument("--data", type=str)
    parser.add_argument("--C", type=float, default=1.0)
    parser.add_argument("--kernel", type=str, default="rbf")
    parser.add_argument("--degree", type=int, default=3)
    parser.add_argument("--gamma", type=str, default="scale")
    parser.add_argument("--coef0", type=float, default=0)
    parser.add_argument("--shrinking", type=bool, default=False)
    parser.add_argument("--probability", type=bool, default=False)
    parser.add_argument("--tol", type=float, default=1e-3)
    parser.add_argument("--cache_size", type=float, default=1024)
    parser.add_argument("--class_weight", type=dict, default=None)
    parser.add_argument("--verbose", type=bool, default=False)
    parser.add_argument("--max_iter", type=int, default=-1)
    parser.add_argument("--decision_function_shape", type=str, default="ovr")
    parser.add_argument("--break_ties", type=bool, default=False)
    parser.add_argument("--random_state", type=int, default=42)
    parser.add_argument("--model_output", type=str, help="Path of output model")
    parser.add_argument("--test_data", type=str, help="Path of output model")

    # parse args
    args = parser.parse_args()

    # return args
    return args


# run script
if __name__ == "__main__":
    # parse args
    args = parse_args()

    # run main function
    main(args)

Notitie

Zorg ervoor dat u de metrische gegevens in de broncode van het proefonderdeel met exact dezelfde naam als de primary_metric waarde in het pijplijnbestand aanmeldt. In dit voorbeeld wordt mlflow.autolog()gebruikgemaakt van de aanbevolen manier om machine learning-experimenten bij te houden. Zie Ml-experimenten en -modellen bijhouden met MLflow voor meer informatie over MLflow.

Een pijplijn maken met een stap voor hyperparameter opruimen

Azure-CLI

Gezien het opdrachtonderdeel dat is gedefinieerd in train.yml, maakt de volgende code een definitiebestand in twee stappen train en predict pijplijndefinities. In de sweep_step, het vereiste staptype is sweep, en de c_value, kernelen coef hyperparameter-invoer voor het trial onderdeel worden toegevoegd aan de search_space.

In het volgende voorbeeld wordt de afstemming van hyperparameters sweep_stepgemarkeerd.

$schema: https://azuremlschemas.azureedge.net/latest/pipelineJob.schema.json
type: pipeline
display_name: pipeline_with_hyperparameter_sweep
description: Tune hyperparameters using TF component
settings:
    default_compute: azureml:cpu-cluster
jobs:
  sweep_step:
    type: sweep
    inputs:
      data: 
        type: uri_file
        path: wasbs://datasets@azuremlexamples.blob.core.windows.net/iris.csv
      degree: 3
      gamma: "scale"
      shrinking: False
      probability: False
      tol: 0.001
      cache_size: 1024
      verbose: False
      max_iter: -1
      decision_function_shape: "ovr"
      break_ties: False
      random_state: 42
    outputs:
      model_output:
      test_data:
    sampling_algorithm: random
    trial: ./train.yml
    search_space:
      c_value:
        type: uniform
        min_value: 0.5
        max_value: 0.9
      kernel:
        type: choice
        values: ["rbf", "linear", "poly"]
      coef0:
        type: uniform
        min_value: 0.1
        max_value: 1
    objective:
      goal: minimize
      primary_metric: training_f1_score
    limits:
      max_total_trials: 5
      max_concurrent_trials: 3
      timeout: 7200

  predict_step:
    type: command
    inputs:
      model: ${{parent.jobs.sweep_step.outputs.model_output}}
      test_data: ${{parent.jobs.sweep_step.outputs.test_data}}
    outputs:
      predict_result:
    component: ./predict.yml

Python SDK

In de v2 SDK kunt u hyperparameterafstemming inschakelen voor elk opdrachtonderdeel door de methode aan te .sweep() roepen. In de volgende pijplijndefinitie ziet u hoe u opruimen inschakelt voor train_model.

In het voorbeeld wordt eerst de train_component_func gedefinieerde in het train.yml-bestand geladen. Als u de train_modelcode wilt maken, worden de c_value, kernelen coef0 hyperparameters toegevoegd aan de zoekruimte. Hiermee sweep_step definieert u de primary_metric, sampling_algorithmen andere parameters.

train_component_func = load_component(source="./train.yml")
score_component_func = load_component(source="./predict.yml")

# define a pipeline
@pipeline()
def pipeline_with_hyperparameter_sweep():
    """Tune hyperparameters using sample components."""
    train_model = train_component_func(
        data=Input(
            type="uri_file",
            path="wasbs://datasets@azuremlexamples.blob.core.windows.net/iris.csv",
        ),
        c_value=Uniform(min_value=0.5, max_value=0.9),
        kernel=Choice(["rbf", "linear", "poly"]),
        coef0=Uniform(min_value=0.1, max_value=1),
        degree=3,
        gamma="scale",
        shrinking=False,
        probability=False,
        tol=0.001,
        cache_size=1024,
        verbose=False,
        max_iter=-1,
        decision_function_shape="ovr",
        break_ties=False,
        random_state=42,
    )
    sweep_step = train_model.sweep(
        primary_metric="training_f1_score",
        goal="minimize",
        sampling_algorithm="random",
        compute="cpu-cluster",
    )
    sweep_step.set_limits(max_total_trials=20, max_concurrent_trials=10, timeout=7200)

    score_data = score_component_func(
        model=sweep_step.outputs.model_output, test_data=sweep_step.outputs.test_data
    )


pipeline_job = pipeline_with_hyperparameter_sweep()

# set pipeline level compute
pipeline_job.settings.default_compute = "cpu-cluster"

Zie HET YAML-schema van de CLI -taak (v2) voor het volledige opruimen van taken.

De pijplijntaak voor hyperparameterafstemming verzenden

Nadat u deze pijplijntaak hebt verzonden, voert Azure Machine Learning het trial onderdeel meerdere keren uit om hyperparameters over te vegen, op basis van de zoekruimte en limieten die u hebt gedefinieerd in de sweep_step.

Resultaten van hyperparameterafstemming weergeven in studio

Nadat u een pijplijntaak hebt verzonden, krijgt u met de SDK- of CLI-widget een web-URL-koppeling naar de pijplijngrafiek in de Azure Machine Learning-studio-gebruikersinterface.

Als u resultaten voor het afstemmen van hyperparameters wilt weergeven, dubbelklikt u op de stap opruimen in de pijplijngrafiek, selecteert u het tabblad Onderliggende taken in het detailvenster en selecteert u vervolgens de onderliggende taak.

Selecteer op de pagina onderliggende taak het tabblad Proefversies om metrische gegevens voor alle onderliggende uitvoeringen weer te geven en te vergelijken. Selecteer een van de onderliggende uitvoeringen om de details voor die uitvoering weer te geven.

Als een onderliggende uitvoering is mislukt, kunt u het tabblad Uitvoer en logboeken op de onderliggende uitvoeringspagina selecteren om nuttige foutopsporingsgegevens weer te geven.

Gerelateerde inhoud

• Een experiment bijhouden
• Een getraind model implementeren