CLı (v2) ile modelleri eğitme (Önizleme)

Azure Machine Learning clı (v2) bir azure clı uzantısıdır ve azure işlem sırasında genişleme ve denetlenebilir model yaşam döngüsü ile model eğitimi sürecini hızlandırmanıza olanak tanır.

Makine öğrenimi modeli eğitimi genellikle yinelemeli bir işlemdir. Modern araçlar daha fazla veri üzerinde daha hızlı bir şekilde daha fazla eğitim yapmayı her zamankinden daha kolay hale getirir. Daha önce, hiper parametre ayarlama ve hatta algoritma seçimi gibi daha önce daha fazla sıkıcı süreçler genellikle otomatikleştirilmiştir. Azure Machine Learning clı (v2) ile, hiper parametre sweeps ile iş bir çalışma alanında işlerinizi (ve modelleri) izleyebilir, yüksek performanslı Azure işlem üzerine ölçeklenebilir ve dağıtılmış eğitimin ölçeğini değiştirebilirsiniz.

Önkoşullar

• CLı 'yı (v2) kullanmak için bir Azure aboneliğinizin olması gerekir. Azure aboneliğiniz yoksa başlamadan önce ücretsiz bir hesap oluşturun. Azure Machine Learning ücretsiz veya ücretli sürümünü bugün deneyin.
• CLI 'yı (v2) yükleyipkurun.

Örnek deposunu Kopyala

Eğitim örneklerini çalıştırmak için, önce örnek depoyu kopyalayın ve şu cli dizine geçin:

git clone --depth 1 https://github.com/Azure/azureml-examples
cd azureml-examples/cli

Kullanımı, --depth 1 yalnızca depoya en son yürütmeyi klonlar, bu da işlemin tamamlanma süresini azaltır.

İşlem oluştur

komut satırından bir Azure Machine Learning işlem kümesi oluşturabilirsiniz. Örneğin, aşağıdaki komutlar adlı bir küme cpu-cluster ve bir adı olarak oluşturulur gpu-cluster .

az ml compute create -n cpu-cluster --type amlcompute --min-instances 0 --max-instances 8
az ml compute create -n gpu-cluster --type amlcompute --min-instances 0 --max-instances 4 --size Standard_NC12

Bu noktada işlem için ücret ödemeniz cpu-cluster ve gpu-cluster bir iş gönderilene kadar sıfır düğümde kalacaksınız. AmlCompute için maliyeti yönetme ve iyileştirmehakkında daha fazla bilgi edinin.

Bu makaledeki aşağıdaki örnek işler veya ' den birini kullanır cpu-cluster gpu-cluster . Bu adları, bu makalenin tamamında, Kümenizin adı için gereken örnek işlere ayarlayın. az ml compute create -hİşlem oluşturma seçenekleri hakkında daha fazla bilgi için kullanın.

Merhaba dünya

Azure Machine Learning clı (v2) için işler yaml biçiminde yazılır. Bir iş toplamaları:

• Çalışmak için gerekenler
• Nasıl çalıştırılır?
• Nerede çalıştırılacağı

"Hello World" işinin üçü de vardır:

$schema: https://azuremlschemas.azureedge.net/latest/commandJob.schema.json
command: echo "hello world"
environment:
  image: python:latest
compute: azureml:cpu-cluster

Şunları yapabilirsiniz:

az ml job create -f jobs/basics/hello-world.yml --web

Oluşturma veya güncelleştirme sırasında değerleri geçersiz kılma

YAML iş belirtim değerleri, --set iş oluşturma veya güncelleştirme sırasında kullanılarak geçersiz kılınabilir. Örneğin:

az ml job create -f jobs/basics/hello-world.yml \
  --set environment.image="python:3.8" \
  --web

İş adları

az ml job create Ve ' ın dışındaki komutların list çoğu --name/-n , Studio 'da bir Işin adı veya "Run ID" dır. nameÇalışma alanı başına benzersiz olması gerektiği için, oluşturma sırasında bir işin özelliğini doğrudan ayarlayamazsınız. Azure Machine Learning, clı 'de iş oluşturma çıktısından elde edilebilir veya studio ve mlflow apı 'lerinde "Run ıd" özelliği kopyalanarak iş adı için rastgele bir guıd oluşturur.

Betiklerin ve CI/CD akışlardaki işleri otomatikleştirmek için, bir işin adını ekleyerek ve yazarak çıktıyı ayırarak yakalayabilirsiniz --query name -o tsv . Bu bilgiler kabuğa göre farklılık gösterir, ancak bash için:

run_id=$(az ml job create -f jobs/basics/hello-world.yml --query name -o tsv)

Daha sonra $run_id , veya gibi sonraki komutlarda kullanın update show stream :

az ml job show -n $run_id --web

İşleri düzenleme

İşleri düzenlemek için bir görünen ad, deneme adı, açıklama ve etiket ayarlayabilirsiniz. Açıklamalar Studio 'daki markaşağı sözdizimini destekler. Bu özellikler bir iş oluşturulduktan sonra değiştirilebilir. Tam bir örnek:

$schema: https://azuremlschemas.azureedge.net/latest/commandJob.schema.json
command: echo "hello world"
environment:
  image: python:latest
compute: azureml:cpu-cluster
tags:
  hello: world
display_name: hello-world-example
experiment_name: hello-world-example
description: |
  # Azure Machine Learning "hello world" job

  This is a "hello world" job running in the cloud via Azure Machine Learning!

  ## Description

  Markdown is supported in the studio for job descriptions! You can edit the description there or via CLI.

Bu işi, bu özelliklerin doğrudan Studio 'da görünür olacağı bir şekilde çalıştırabilirsiniz:

az ml job create -f jobs/basics/hello-world-org.yml --web

Kullanarak, --set iş oluşturulduktan sonra kesilebilir değerleri güncelleştirebilirsiniz:

az ml job update -n $run_id --set \
  display_name="updated display name" \
  experiment_name="updated experiment name" \
  description="updated description"  \
  tags.hello="updated tag"

Ortam değişkenleri

İşte kullanım için ortam değişkenlerini ayarlayabilirsiniz:

$schema: https://azuremlschemas.azureedge.net/latest/commandJob.schema.json
command: echo $hello_env_var
environment:
  image: python:latest
compute: azureml:cpu-cluster
environment_variables:
  hello_env_var: "hello world"

Bu işi çalıştırabilirsiniz:

az ml job create -f jobs/basics/hello-world-env-var.yml --web

Modelleri ve kaynak kodu izleme

Üretim makinesi öğrenme modellerinin denetlenebilir olması gerekir (tekrarlanabilir değilse). Belirli bir modelin kaynak kodunu izlemek çok önemlidir. Azure Machine Learning kaynak kodunuzun anlık görüntüsünü alır ve işle birlikte tutar. Ayrıca, bir git deposundan iş çalıştırıyorsanız kaynak depo ve kayıt tutulur.

code.local_pathAnahtarı, kaynak kodu dizininin yolu olarak değeriyle belirtebilirsiniz. Dizinin bir anlık görüntüsü alınır ve işle birlikte karşıya yüklenir. Dizinin içeriği, işin çalışma dizininden doğrudan kullanılabilir.

Kodu belirten bir işe bakalım:

$schema: https://azuremlschemas.azureedge.net/latest/commandJob.schema.json
command: >-
  pip install mlflow azureml-mlflow
  &&
  python hello-mlflow.py
code:
  local_path: src
environment:
  image: python:3.8
compute: azureml:cpu-cluster

Python betiği yerel kaynak kodu dizininde bulunur. Komut, komut python dosyasını çalıştırmak için çağırır. Aynı model diğer programlama dilleri için de uygulanabilir.

MLflow ile model izleme

Modellerde yineleme yaparken, veri bilimcilerinin model parametrelerini ve eğitim ölçümlerini izleyebilmesi gerekir. Azure Machine Learning, bir iş için model, yapıt, ölçüm ve parametrelerin günlüğe kaydedilmesini sağlamak üzere mlflow izleme ile tümleşir. Python betiklerinizde MLflow 'u kullanmak için import mlflow eğitim kodunuzda ekleme ve çağrı mlflow.log_* ya da mlflow.autolog() API 'ler ekleyin.

mlflowBir parametre, ölçüm ve yapıtı günlüğe kaydetmek için, yukarıdaki işte çağrılan Python betiğine göz atalım:

# imports
import os
import mlflow

from random import random

# define functions
def main():
    mlflow.log_param("hello_param", "world")
    mlflow.log_metric("hello_metric", random())
    os.system(f"echo 'hello world' > helloworld.txt")
    mlflow.log_artifact("helloworld.txt")


# run functions
if __name__ == "__main__":
    # run main function
    main()

bu işi bulutta, izlenen ve denetlenebilir olan Azure Machine Learning aracılığıyla çalıştırabilirsiniz:

az ml job create -f jobs/basics/hello-mlflow.yml --web

MLflow ile sorgu ölçümleri

İşleri çalıştırdıktan sonra, işlerin çalışma sonuçlarını ve günlüğe kaydedilen ölçümlerini sorgulamak isteyebilirsiniz. Python, bu görev için CLı 'dan daha uygundur. Çalıştırmaları ve bunların ölçümlerini, mlflow analiz Için Pandas veri çerçeveleri gibi tanıdık nesneler aracılığıyla sorgulayabilirsiniz ve bunlara yükleyebilirsiniz.

ilk olarak, Azure Machine Learning çalışma alanınız için mlflow izleme urı 'sini alın:

az ml workspace show --query mlflow_tracking_uri -o tsv

mlflow.set_tracking_uri(<YOUR_TRACKING_URI>)MLflow içeri aktarılan bir Python ortamında bu komutun çıktısını kullanın. mlflow çağrıları artık Azure Machine Learning çalışma alanınızdaki işlere karşılık gelir.

Girişler ve çıkışlar

İşler genellikle girişler ve çıkışlar vardır. Girişler, hiper parametre iyileştirmesi veya işlem hedefine bağlanmış veya indirilen bulut veri girişleri için bir model parametresi olabilir. Çıktılar (ölçümler yok sayılıyor) varsayılan çıkışlara veya adlandırılmış bir veri çıkışına yazılabilen veya kopyalanabilen yapılardır.

Değişmez girişler

Değişmez girişler komutunda doğrudan çözümlenir. "Hello world" işlerimizi değişmez girişleri kullanmak için değiştirebilirsiniz:

$schema: https://azuremlschemas.azureedge.net/latest/commandJob.schema.json
command: >-
  echo ${{inputs.hello_string}}
  &&
  echo ${{inputs.hello_number}}
environment:
  image: python:latest
inputs:
  hello_string: "hello world"
  hello_number: 42
compute: azureml:cpu-cluster

Bu işi çalıştırarak:

az ml job create -f jobs/basics/hello-world-input.yml --web

Girişleri geçersiz kılmak --set için kullanabilirsiniz:

az ml job create -f jobs/basics/hello-world-input.yml --set \
  inputs.hello_string="hello there" \
  inputs.hello_number=24 \
  --web

İşlere yapılan değişmez girişler, model eğitimlerinde hiperparametre taramaları için arama alanı girişine dönüştürülür.

Arama alanı girişleri

Bir tarama işi için, seçilecek sabit girişler için bir arama alanı belirtabilirsiniz. Arama alanı girişlerinin tüm seçenekleri için, tarama işi YAML söz dizimi başvurusuna bakın.

Şimdi bağımsız değişkenleri alan ve rastgele bir ölçümü günlüğe kaydeden basit bir Python betiğiyle kavramı göster bakalım:

# imports
import os
import mlflow
import argparse

from random import random

# define functions
def main(args):
    # print inputs
    print(f"A: {args.A}")
    print(f"B: {args.B}")
    print(f"C: {args.C}")

    # log inputs as parameters
    mlflow.log_param("A", args.A)
    mlflow.log_param("B", args.B)
    mlflow.log_param("C", args.C)

    # log a random metric
    mlflow.log_metric("random_metric", random())


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

    # add arguments
    parser.add_argument("--A", type=float, default=0.5)
    parser.add_argument("--B", type=str, default="hello world")
    parser.add_argument("--C", type=float, default=1.0)

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

Ve karşılık gelen bir tarama işi oluşturun:

$schema: https://azuremlschemas.azureedge.net/latest/sweepJob.schema.json
type: sweep
trial:
  command: >-
    pip install mlflow azureml-mlflow
    &&
    python hello-sweep.py
    --A ${{inputs.A}}
    --B ${{search_space.B}}
    --C ${{search_space.C}}
  code:
    local_path: src
  environment:
    image: python:3.8
inputs:
  A: 0.5
compute: azureml:cpu-cluster
sampling_algorithm: random
search_space:
  B:
    type: choice
    values: ["hello", "world", "hello world"]
  C:
    type: uniform
    min_value: 0.1
    max_value: 1.0
objective:
  goal: minimize
  primary_metric: random_metric
limits:
  max_total_trials: 4
  max_concurrent_trials: 2
  timeout: 3600
display_name: hello-sweep-example
experiment_name: hello-sweep-example
description: Hello sweep job example.

Ve çalıştırın:

az ml job create -f jobs/basics/hello-sweep.yml --web

Veri girişleri

Veri girişleri, işin yerel dosya sistemi üzerinde bir yola çözümlenir. Şimdi de bir blob kapsayıcısı içinde genel olarak barındırılan klasik Iris veri kümesiyle göster https://azuremlexamples.blob.core.windows.net/datasets/iris.csv bakalım.

Iris CSV dosyasının yolunu bağımsız değişken olarak alan, bir veri çerçevesine yazan, ilk 5 satırı yazdıran ve dizine kaydeden bir Python betiği outputs yazabilirsiniz.

# imports
import os
import argparse

import pandas as pd

# define functions
def main(args):
    # read in data
    df = pd.read_csv(args.iris_csv)

    # print first 5 lines
    print(df.head())

    # ensure outputs directory exists
    os.makedirs("outputs", exist_ok=True)

    # save data to outputs
    df.to_csv("outputs/iris.csv", index=False)


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

    # add arguments
    parser.add_argument("--iris-csv", type=str)

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

Azure depolama URI'sı girişleri belirtilebilir ve bu girişler verileri yerel dosya sistemine bağlar veya indirir. Tek bir dosya belirtebilirsiniz:

$schema: https://azuremlschemas.azureedge.net/latest/commandJob.schema.json
command: >-
  echo "--iris-csv: ${{inputs.iris_csv}}"
  &&
  pip install pandas
  &&
  python hello-iris.py
  --iris-csv ${{inputs.iris_csv}}
code:
  local_path: src
inputs:
  iris_csv: 
    file: https://azuremlexamples.blob.core.windows.net/datasets/iris.csv
environment:
  image: python:latest
compute: azureml:cpu-cluster

Ve şu çalıştırmayı çalıştırın:

az ml job create -f jobs/basics/hello-iris-file.yml --web

Veya bir klasörün tamamını belirtin:

$schema: https://azuremlschemas.azureedge.net/latest/commandJob.schema.json
command: >-
  ls ${{inputs.data_dir}}
  &&
  echo "--iris-csv: ${{inputs.data_dir}}/iris.csv"
  &&
  pip install pandas
  &&
  python hello-iris.py
  --iris-csv ${{inputs.data_dir}}/iris.csv
code:
  local_path: src
inputs:
  data_dir: 
    folder: wasbs://datasets@azuremlexamples.blob.core.windows.net/
environment:
  image: python:latest
compute: azureml:cpu-cluster

Ve şu çalıştırmayı çalıştırın:

az ml job create -f jobs/basics/hello-iris-folder.yml --web

Özel veriler

Bir veri deposu aracılığıyla Azure Machine Learning Azure Blob Depolama veya Azure Data Lake Depolama'daki özel veriler için giriş verileri Azure Machine Learning biçimindeki Azure Machine Learning URL'lerini azureml://datastores/<DATASTORE_NAME>/paths/<PATH_TO_DATA> kullanabilirsiniz. Örneğin, Iris CSV dosyasını adlı veri deposuna karşılık gelen Blob kapsayıcısı içinde adlı bir dizine yüklersiniz, veri deposundaki dosyayı kullanmak için önceki /example-data/ workspaceblobstore işi değiştirebilirsiniz:

$schema: https://azuremlschemas.azureedge.net/latest/commandJob.schema.json
command: >-
  echo "--iris-csv: ${{inputs.iris_csv}}"
  &&
  pip install pandas
  &&
  python hello-iris.py
  --iris-csv ${{inputs.iris_csv}}
code:
  local_path: src
inputs:
  iris_csv: 
    file: azureml://datastores/workspaceblobstore/paths/example-data/iris.csv
environment:
  image: python:latest
compute: azureml:cpu-cluster

Veya dizinin tamamı:

$schema: https://azuremlschemas.azureedge.net/latest/commandJob.schema.json
command: >-
  ls ${{inputs.data_dir}}
  &&
  echo "--iris-csv: ${{inputs.data_dir}}/iris.csv"
  &&
  pip install pandas
  &&
  python hello-iris.py
  --iris-csv ${{inputs.data_dir}}/iris.csv
code:
  local_path: src
inputs:
  data_dir: 
    folder: azureml://datastores/workspaceblobstore/paths/example-data/
    mode: rw_mount
environment:
  image: python:latest
compute: azureml:cpu-cluster

Varsayılan çıkışlar

ve ./outputs ./logs dizinleri, dizinler tarafından özel Azure Machine Learning. İş sırasında bu dizinlere herhangi bir dosya yazarsanız, bu dosyalar iş tamamlandıktan sonra erişmeye devam etmek için işe karşıya yükler. Klasör işin sonunda karşıya, yazılan ./outputs dosyalar ise gerçek ./logs zamanlı olarak karşıya yüklendi. İş sırasında TensorBoard günlükleri gibi günlük akışı yapmak için ikincisini kullanın.

"Hello world" işini, 'a yazdırmak yerine varsayılan outputs dizininde bir dosyaya çıktı olarak stdout değiştirebilirsiniz:

$schema: https://azuremlschemas.azureedge.net/latest/commandJob.schema.json
command: echo "hello world" > ./outputs/helloworld.txt
environment:
  image: python:latest
compute: azureml:cpu-cluster

Bu işi çalıştırarak:

az ml job create -f jobs/basics/hello-world-output.yml --web

Dizininde yer alan helloworld.txt günlükleri de <RUN_ID>/outputs/ indirin:

az ml job download -n $run_id

Veri çıkışları

Adlandırılmış veri çıkışları belirtebilirsiniz. Bu, varsayılan olarak okunacak/yazacak varsayılan veri deposu içinde bir dizin oluşturacak.

Daha önceki "merhaba dünya" işini adlandırılmış bir veri çıkışına yazacak şekilde değiştirebilirsiniz:

$schema: https://azuremlschemas.azureedge.net/latest/commandJob.schema.json
command: echo "hello world" > ${{outputs.hello_output}}/helloworld.txt
outputs:
  hello_output:
environment:
  image: python
compute: azureml:cpu-cluster

Hello işlem hatları

İşlem hattı işleri birden çok işi paralel veya sıralı olarak çalıştırarak. İşlem hattında adımlar arasında giriş/çıkış bağımlılıkları varsa, bağımlı adım diğer tamamlandıktan sonra çalıştırılacaktır.

"Merhaba dünya" işini iki işe bölüyoruz:

$schema: https://azuremlschemas.azureedge.net/latest/pipelineJob.schema.json
type: pipeline
jobs:
  hello_job:
    command: echo "hello"
    environment:
      image: python:latest
    compute: azureml:cpu-cluster
  world_job:
    command: echo "world"
    environment:
      image: python
    compute: azureml:cpu-cluster

Ve çalıştırın:

az ml job create -f jobs/basics/hello-pipeline.yml --web

İşlem hedefi bunu yapmak için kullanılabilir kaynaklara sahipse sırasıyla "hello" ve "world" işleri paralel olarak ecek.

İşlem hattındaki adımlar arasında veri geçişi yapmak için"hello" iş içinde bir veri çıkışı ve "world" iş içinde önceki çıkışına karşılık gelen bir giriş tanımlayın:

$schema: https://azuremlschemas.azureedge.net/latest/pipelineJob.schema.json
type: pipeline
jobs:
  hello_job:
    command: echo "hello" && echo "world" > ${{outputs.world_output}}/world.txt
    environment:
      image: python:latest
    compute: azureml:cpu-cluster
    outputs:
      world_output:
  world_job:
    command: cat ${{inputs.world_input}}/world.txt
    environment:
      image: python:latest
    compute: azureml:cpu-cluster
    inputs:
      world_input: ${{jobs.hello_job.outputs.world_output}}

Ve çalıştırın:

az ml job create -f jobs/basics/hello-pipeline-io.yml --web

Bu kez, "hello" işi tamamlandıktan sonra "dünya" işi çalıştıracak.

Ortak ayarların bir işlem hattında işlerde çoğaltılmasından kaçınmak için bunları işlerin dışında belirtebilirsiniz:

$schema: https://azuremlschemas.azureedge.net/latest/pipelineJob.schema.json
type: pipeline
compute: azureml:cpu-cluster
settings:
  environment:
    image: python:latest
jobs:
  hello_job:
    command: echo "hello"
  world_job:
    command: echo "world"

Bunu çalıştırarak:

az ml job create -f jobs/basics/hello-pipeline-settings.yml --web

Tek bir işteki ilgili ayar, bir işlem hattı işinin ortak ayarlarını geçersiz kılar. Şu ana kadarki kavramlar "A", "B" ve "C" işleri ile üç adımlı bir işlem hattı işi olarak bir araya geldi. "C" işinin "B" işi üzerinde bir veri bağımlılığı vardır, ancak "A" işi bağımsız olarak çalışabilir. "A" işi ayrıca tek tek ayarlanmış bir ortam kullanır ve girişlerinden birini üst düzey işlem hattı iş girişine bağlar:

$schema: https://azuremlschemas.azureedge.net/latest/pipelineJob.schema.json
type: pipeline
compute: azureml:cpu-cluster
settings:
  environment:
    image: python:latest
inputs:
  hello_string_top_level_input: "hello world"
jobs:
  A:
    command: echo hello ${{inputs.hello_string}}
    environment:
      image: python:3.9
    inputs:
      hello_string: ${{inputs.hello_string_top_level_input}}
  B:
    command: echo "world" >> ${{outputs.world_output}}/world.txt
    outputs:
      world_output:
  C:
    command: echo ${{inputs.world_input}}/world.txt
    inputs:
      world_input: ${{jobs.B.outputs.world_output}}

Bunu çalıştırarak:

az ml job create -f jobs/basics/hello-pipeline-abc.yml --web

Modeli eğitme

Bu noktada model henüz eğitilmamış durumdadır. Iris sklearn CSV'sine bir model eğitmek için MLflow izleme ile Python betiğine kod ek o zaman:

# imports
import os
import mlflow
import argparse

import pandas as pd

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.iris_csv)

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


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("--iris-csv", 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)

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

Scikit-learn çerçevesi otomatik günlüğe kaydı için MLflow tarafından de desteklenemesinde, bu nedenle betikte tek bir çağrı tüm model parametrelerini, eğitim ölçümlerini, model yapıtlarını ve bazı ek yapıtları (bu durumda karışıklık matrisi görüntüsü) günlüğe mlflow.autolog() kaydedilir.

Bunu bulutta çalıştırmak için iş olarak belirtin:

$schema: https://azuremlschemas.azureedge.net/latest/commandJob.schema.json
code: 
  local_path: src
command: >-
  python main.py 
  --iris-csv ${{inputs.iris_csv}}
  --C ${{inputs.C}}
  --kernel ${{inputs.kernel}}
  --coef0 ${{inputs.coef0}}
inputs:
  iris_csv: 
    file: wasbs://datasets@azuremlexamples.blob.core.windows.net/iris.csv
  C: 0.8
  kernel: "rbf"
  coef0: 0.1
environment: azureml:AzureML-sklearn-0.24-ubuntu18.04-py37-cpu:9
compute: azureml:cpu-cluster
display_name: sklearn-iris-example
experiment_name: sklearn-iris-example
description: Train a scikit-learn SVM on the Iris dataset.

Ve çalıştırın:

az ml job create -f jobs/single-step/scikit-learn/iris/job.yml --web

Modeli kaydetmek için çıkışları indirebilir ve yerel dizinden bir model oluşturabilirsiniz:

az ml job download -n $run_id
az ml model create -n sklearn-iris-example -l $run_id/model/

Hiperparametreleri tarama

Hiperparametreleri taramak için önceki işi değiştirebilirsiniz:

$schema: https://azuremlschemas.azureedge.net/latest/sweepJob.schema.json
type: sweep
trial:
  code: 
    local_path: src
  command: >-
    python main.py 
    --iris-csv ${{inputs.iris_csv}}
    --C ${{search_space.C}}
    --kernel ${{search_space.kernel}}
    --coef0 ${{search_space.coef0}}
  environment: azureml:AzureML-sklearn-0.24-ubuntu18.04-py37-cpu:9
inputs:
  iris_csv: 
    file: wasbs://datasets@azuremlexamples.blob.core.windows.net/iris.csv
compute: azureml:cpu-cluster
sampling_algorithm: random
search_space:
  C:
    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: 20
  max_concurrent_trials: 10
  timeout: 7200
display_name: sklearn-iris-sweep-example
experiment_name: sklearn-iris-sweep-example
description: Sweep hyperparemeters for training a scikit-learn SVM on the Iris dataset.

Ve çalıştırın:

az ml job create -f jobs/single-step/scikit-learn/iris/job-sweep.yml --web

Daha fazla tarama seçeneği için, tarama işi YAML söz dizimi başvurusuna bakın.

Dağıtılmış eğitim

Azure Machine Learning PyTorch, TensorFlow ve MPI tabanlı dağıtılmış eğitimi destekler. Ayrıntılar için komut işi YAML söz dizimi başvurusu'na bakın.

Örneğin, dağıtılmış PyTorch kullanarak CIFAR-10 veri kümesi üzerinde birvolutional sinir ağı (CNN) eğitebilirsiniz. Tam betik, örnek deposunda mevcuttur.

içinde CIFAR-10 veri torchvision kümesi, dizini içeren bir dizin girişi cifar-10-batches-py olarak bekler. Sıkıştırılmış kaynağı indirebilir ve yerel bir dizine ayıkabilirsiniz:

mkdir data
wget "https://azuremlexamples.blob.core.windows.net/datasets/cifar-10-python.tar.gz"
tar -xvzf cifar-10-python.tar.gz -C data

Ardından yerel Azure Machine Learning varsayılan veri deposuna yük olacak bir veri kümesi oluşturun:

az ml dataset create --name cifar-10-example --version 1 --set local_path=data

İsteğe bağlı olarak, yerel dosyayı ve dizini kaldırın:

rm cifar-10-python.tar.gz
rm -r data

Veri kümeleri (yalnızca dosya) bir işte veri girişinin anahtarı dataset kullanılarak başvurul olabilir. azureml:<DATASET_NAME>:<DATASET_VERSION>biçimidir, dolayısıyla yeni oluşturulan CIFAR-10 veri kümesi için azureml:cifar-10-example:1 olur.

Veri kümesi hazır oldu, modelimizi eğitmek için dağıtılmış bir PyTorch işi yazmanız gerekir:

$schema: https://azuremlschemas.azureedge.net/latest/commandJob.schema.json
code: 
  local_path: src
command: >-
  python train.py 
  --epochs ${{inputs.epochs}}
  --learning-rate ${{inputs.learning_rate}}
  --data-dir ${{inputs.cifar}}
inputs:
  epochs: 1
  learning_rate: 0.2
  cifar:
    dataset: azureml:cifar-10-example:1
environment: azureml:AzureML-pytorch-1.9-ubuntu18.04-py37-cuda11-gpu:6
compute: azureml:gpu-cluster
distribution:
  type: pytorch 
  process_count_per_instance: 2
resources:
  instance_count: 2
display_name: pytorch-cifar-distributed-example
experiment_name: pytorch-cifar-distributed-example
description: Train a basic convolutional neural network (CNN) with PyTorch on the CIFAR-10 dataset, distributed via PyTorch.

Ve çalıştırın:

az ml job create -f jobs/single-step/pytorch/cifar-distributed/job.yml --web

Eğitim işlem hattı oluşturma

Yukarıdaki CIFAR-10 örneği bir işlem hattı işini iyi çevirir. Önceki iş, bir işlem hattında düzenleme için üç işe ayrıl olabilir:

• İndirmek ve ayıklamak için bir Bash betiği çalıştırmak için "get-data" cifar-10-batches-py
• Verileri almak ve dağıtılmış PyTorch ile modeli eğitmek için "train-model"
• Verileri ve eğitilen modeli almak ve doğruluğu değerlendirmek için "eval-model"

Hem "train-model" hem de "eval-model" "get-data" işinin çıkışına bağımlılık oluşturur. Ayrıca"eval-model", "train-model" işinin çıkışına bağımlıdır. Bu nedenle üç iş sırayla ecek.

Bu üç işi bir işlem hattı işi içinde düzenleme:

$schema: https://azuremlschemas.azureedge.net/latest/pipelineJob.schema.json
type: pipeline
display_name: cifar-10-pipeline-example
experiment_name: cifar-10-pipeline-example
jobs:
  get-data:
    command: bash main.sh ${{outputs.cifar}}
    code:
      local_path: src/get-data
    environment:
      image: python:latest
    compute: azureml:cpu-cluster
    outputs:
      cifar:
  train-model:
    command: >-
      python main.py
      --data-dir ${{inputs.cifar}}
      --epochs ${{inputs.epochs}}
      --model-dir ${{outputs.model_dir}}
    code:
      local_path: src/train-model
    inputs:
      epochs: 1
      cifar: ${{jobs.get-data.outputs.cifar}}
    outputs:
      model_dir:
    environment: azureml:AzureML-pytorch-1.9-ubuntu18.04-py37-cuda11-gpu:6
    compute: azureml:gpu-cluster
    distribution:
      type: pytorch
      process_count_per_instance: 2
    resources:
      instance_count: 2
  eval-model:
    command: >-
      python main.py
      --data-dir ${{inputs.cifar}}
      --model-dir ${{inputs.model_dir}}/model
    code:
      local_path: src/eval-model
    environment: azureml:AzureML-pytorch-1.9-ubuntu18.04-py37-cuda11-gpu:6
    compute: azureml:gpu-cluster
    distribution:
      type: pytorch
      process_count_per_instance: 2
    resources:
      instance_count: 1
    inputs:
      cifar: ${{jobs.get-data.outputs.cifar}}
      model_dir: ${{jobs.train-model.outputs.model_dir}}

Ve şu çalıştırmayı çalıştırın:

az ml job create -f jobs/pipelines/cifar-10/job.yml --web

Pipelines yeniden kullanılabilir bileşenler kullanılarak da yazılabilir. Daha fazla bilgi için bkz. Azure Machine Learning CLI (Önizleme)ile bileşen tabanlı makine öğrenmesi işlem hatları oluşturma ve çalıştırma.

Sonraki adımlar

• Yönetilen bir çevrimiçi uç noktayla makine öğrenmesi modelini dağıtma ve puanla (önizleme)