Co to jest zestaw SDK usługi Azure Machine Learning dla języka Python?

Analitycy danych i deweloperzy AI używają zestawu SDK usługi Azure Machine Learning dla języka Python do kompilowania i uruchamiania przepływów pracy uczenia maszynowego za pomocą usługi Azure Machine Learning. Z tej usługi można korzystać w dowolnym środowisku języka Python, takim jak notesy programu Jupyter, program Visual Studio Code lub ulubione środowisko IDE języka Python.

Kluczowe obszary zestawu SDK są następujące:

  • Eksplorowanie i przygotowywanie cyklu życia zestawów danych używanych w eksperymentach uczenia maszynowego i zarządzanie nimi.
  • Zarządzanie zasobami w chmurze na potrzeby monitorowania, rejestrowania i organizowania eksperymentów uczenia maszynowego.
  • Trenowanie modeli lokalnie lub przy użyciu zasobów w chmurze, w tym trenowanie modeli przyśpieszone za pomocą procesora GPU.
  • Użyj zautomatyzowanego uczenia maszynowego, które akceptuje parametry konfiguracji i dane treningowe. Automatycznie wykonuje ono iterację po algorytmach i ustawieniach hiperparametrów, aby znaleźć najlepszy model do uruchamiania przewidywań.
  • Wdrażanie usług internetowych w celu konwertowania wytrenowanych modeli na usługi RESTful, które mogą być wykorzystywane w dowolnych aplikacjach.

Aby zapoznać się z przewodnikiem krok po kroku ułatwiającym rozpoczęcie pracy, skorzystaj z samouczka.

Poniższe sekcje zawierają omówienie najważniejszych klas w zestawie SDK oraz typowe wzorce projektowe na potrzeby ich używania. Aby uzyskać zestaw SDK, zobacz przewodnik po instalacji.

Stabilny w porównaniu z eksperymentalnym

Zestaw SDK Azure Machine Learning dla języka Python zapewnia zarówno stabilne, jak i eksperymentalne funkcje w tym samym zestawie SDK.

Stan funkcji/możliwości Opis
Stabilne funkcje Gotowe do produkcji

Te funkcje są zalecane w przypadku większości przypadków użycia i środowisk produkcyjnych. Są one aktualizowane rzadziej niż funkcje eksperymentalne.
Funkcje eksperymentalne Rozwoju

Te funkcje to nowo opracowane aktualizacje funkcji & , które mogą nie być gotowe lub w pełni przetestowane pod kątem użycia w środowisku produkcyjnym. Chociaż funkcje są zwykle funkcjonalne, mogą zawierać pewne zmiany powodujące niezgodność. Funkcje eksperymentalne są używane do wyprasowania błędów powodujących niezgodność zestawu SDK i będą otrzymywać aktualizacje tylko przez czas trwania okresu testowania. Funkcje eksperymentalne są również określane jako funkcje dostępne w wersji zapoznawczej.

Jak wskazuje nazwa, funkcje eksperymentalne (wersja zapoznawcza) służą do eksperymentowania i nie są uważane za wolne od błędów lub stabilne. Z tego powodu zalecamy tylko funkcje eksperymentalne dla zaawansowanych użytkowników, którzy chcą wypróbować wczesne wersje funkcji i aktualizacji, i zamierzają uczestniczyć w raportowaniu usterek i usterek.

Funkcje eksperymentalne są oznaczone etykietą sekcji notatki w dokumentacji zestawu SDK i oznaczone tekstem, takim jak (wersja zapoznawcza) w dokumentacji Azure Machine Learning.

Workspace

Przestrzeń nazw: azureml.core.workspace.Workspace

Klasa Workspace to podstawowy zasób w chmurze umożliwiający eksperymentowanie z modelami uczenia maszynowego, ich trenowanie oraz wdrażanie. Łączy ona Twoją subskrypcję i grupę zasobów platformy Azure z łatwym w użyciu obiektem.

Wyświetl wszystkie parametry metody tworzenia obszaru roboczego, aby ponownie używać istniejących wystąpień (Storage, Key Vault, App-Szczegółowe informacje i Azure Container Registry-ACR), a także zmodyfikować dodatkowe ustawienia, takie jak konfiguracja prywatnego punktu końcowego i cel obliczeniowy.

Zaimportuj klasę i utwórz nowy obszar roboczy przy użyciu następującego kodu. Dla elementu create_resource_group ustaw wartość False, jeśli masz już istniejącą grupę zasobów platformy Azure, której chcesz użyć dla tego obszaru roboczego. Niektóre funkcje mogą monitować o poświadczenia uwierzytelniania platformy Azure.

from azureml.core import Workspace
ws = Workspace.create(name='myworkspace',
                      subscription_id='<azure-subscription-id>',
                      resource_group='myresourcegroup',
                      create_resource_group=True,
                      location='eastus2'
                     )

Aby użyć tego samego obszaru roboczego w wielu środowiskach, należy najpierw zapisać go w pliku JSON z konfiguracją. Spowoduje to zapisanie danych dotyczących subskrypcji, zasobu i nazwy obszaru roboczego.

ws.write_config(path="./file-path", file_name="ws_config.json")

Aby załadować obszar roboczy, odczytaj plik konfiguracji.

from azureml.core import Workspace
ws_other_environment = Workspace.from_config(path="./file-path/ws_config.json")

Alternatywnie możesz użyć statycznej metody get(), aby załadować istniejący obszar roboczy bez używania plików konfiguracji.

from azureml.core import Workspace
ws = Workspace.get(name="myworkspace", subscription_id='<azure-subscription-id>', resource_group='myresourcegroup')

W poniższych przykładach kodu zmienna ws reprezentuje obiekt Workspace.

Experiment

Przestrzeń nazw: azureml.core.experiment.Experiment

Klasa Experiment jest kolejnym podstawowym zasobem w chmurze, który reprezentuje kolekcję prób (poszczególne przebiegi modeli). Poniższy kod pobiera obiekt Experiment z klasy Workspace według nazwy lub tworzy nowy obiekt Experiment, jeśli nazwa nie istnieje.

from azureml.core.experiment import Experiment
experiment = Experiment(workspace=ws, name='test-experiment')

Uruchom poniższy kod, aby uzyskać listę wszystkich obiektów Experiment zawartych w klasie Workspace.

list_experiments = Experiment.list(ws)

Użyj funkcji get_runs, aby pobrać listę obiektów Run (prób) z klasy Experiment. Poniższy kod pobiera przebiegi i drukuje identyfikator każdego przebiegu.

list_runs = experiment.get_runs()
for run in list_runs:
    print(run.id)

Istnieją dwa sposoby wykonania próby eksperymentu. Jeśli eksperymentujesz interaktywnie w notesie programu Jupyter, użyj funkcji start_logging. Jeśli przesyłasz eksperyment ze standardowego środowiska języka Python, użyj funkcji submit. Obie funkcje zwracają obiekt Run. W poniższych przykładach kodu zmienna experiment reprezentuje obiekt Experiment.

Uruchom

Przestrzeń nazw: azureml.core.run.Run

Przebieg reprezentuje pojedynczą próbę eksperymentu. Run jest obiektem, który służy do monitorowania asynchronicznego wykonywania próby, przechowywania danych wyjściowych próby, analizowania wyników i uzyskiwania dostępu do wygenerowanych artefaktów. Użyj obiektu Run w kodzie eksperymentu, aby rejestrować metryki i artefakty w usłudze Run History (Historia przebiegu). Oferuje ona m.in. następujące funkcje:

  • Przechowywanie i pobieranie metryk i danych.
  • Używanie tagów i hierarchii podrzędnej w celu łatwego wyszukiwania przeszłych przebiegów.
  • Rejestrowanie przechowywanych plików modeli na potrzeby wdrożenia.
  • Przechowywanie, modyfikowanie i pobieranie właściwości przebiegu.

Utwórz obiekt Run, przesyłając obiekt Experiment za pomocą obiektu konfiguracji przebiegu. Użyj parametru tags, aby dołączyć do przebiegów niestandardowe kategorie i etykiety. Możesz je potem łatwo znaleźć i pobrać z klasy Experiment.

tags = {"prod": "phase-1-model-tests"}
run = experiment.submit(config=your_config_object, tags=tags)

Użyj statycznej funkcji list, aby uzyskać listę wszystkich obiektów Run z klasy Experiment. Określ parametr tags, aby filtrować według utworzonego wcześniej tagu.

from azureml.core.run import Run
filtered_list_runs = Run.list(experiment, tags=tags)

Użyj funkcji get_details, aby pobrać szczegółowe dane wyjściowe dla przebiegu.

run_details = run.get_details()

Dane wyjściowe tej funkcji to słownik zawierający następujące elementy:

  • Identyfikator przebiegu
  • Stan
  • Godzina rozpoczęcia i zakończenia
  • Docelowy obiekt obliczeniowy (lokalny i w chmurze)
  • Zależności i wersje użyte w przebiegu
  • Dane specyficzne dla trenowania (różnią się w zależności od typu modelu)

Aby uzyskać więcej przykładów dotyczących konfigurowania i monitorowania przebiegów, zobacz instrukcje.

Model

Przestrzeń nazw: azureml.core.model.Model

Klasa Model jest używana do pracy z reprezentacją w chmurze modeli uczenia maszynowego. Metody ułatwiają transferowanie modeli między lokalnymi środowiskami deweloperskimi a obiektem Workspace w chmurze.

Rejestracja modelu umożliwia przechowywanie modeli i ich wersji w chmurze platformy Azure, w swoim obszarze roboczym. Zarejestrowane modele są identyfikowane za pomocą nazwy i wersji. Za każdym razem, gdy rejestrujesz model o takiej samej nazwie, jaką ma już istniejący model, rejestr zwiększa wersję. Azure Machine Learning obsługuje dowolny model, który można załadować za pośrednictwem języka Python 3, a nie tylko Azure Machine Learning modeli.

Poniższy przykład pokazuje, jak utworzyć prosty lokalny model klasyfikacji za pomocą funkcji scikit-learn, zarejestrować model w klasie Workspace i pobrać ten model z chmury.

Utwórz prosty klasyfikator, clf, aby przewidzieć rezygnacje klientów na podstawie ich wieku. Następnie zrzuć model do pliku .pkl w tym samym katalogu.

from sklearn import svm
import joblib
import numpy as np

# customer ages
X_train = np.array([50, 17, 35, 23, 28, 40, 31, 29, 19, 62])
X_train = X_train.reshape(-1, 1)
# churn y/n
y_train = ["yes", "no", "no", "no", "yes", "yes", "yes", "no", "no", "yes"]

clf = svm.SVC(gamma=0.001, C=100.)
clf.fit(X_train, y_train)

joblib.dump(value=clf, filename="churn-model.pkl")

Użyj funkcji register, aby zarejestrować model w obszarze roboczym. Określ ścieżkę modelu lokalnego i nazwę modelu. Zarejestrowanie tej samej nazwy więcej niż raz spowoduje utworzenie nowej wersji.

from azureml.core.model import Model

model = Model.register(workspace=ws, model_path="churn-model.pkl", model_name="churn-model-test")

Teraz, gdy model został zarejestrowany w obszarze roboczym, można łatwo zarządzać modelami oraz pobierać je i organizować. Aby pobrać obiekt modelu (na przykład w innym środowisku) z klasy Workspace, należy użyć konstruktora klasy i określić nazwę modelu oraz wszelkie parametry opcjonalne. Następnie należy użyć funkcji download, aby pobrać model wraz ze strukturą folderów w chmurze.

from azureml.core.model import Model
import os

model = Model(workspace=ws, name="churn-model-test")
model.download(target_dir=os.getcwd())

Użyj funkcji delete, aby usunąć model z klasy Workspace.

model.delete()

Po zarejestrowaniu modelu wdrożenie go jako usługi internetowej jest prostym procesem. Najpierw należy utworzyć i zarejestrować obraz. Ten krok umożliwia skonfigurowanie środowiska języka Python wraz z jego zależnościami oraz skryptu do definiowania formatów żądań i odpowiedzi usługi internetowej. Po utworzeniu obrazu należy utworzyć konfigurację wdrożenia, która określa rdzenie procesora CPU i parametry pamięci dla docelowego obiektu obliczeniowego. Następnie należy dołączyć obraz.

ComputeTarget, RunConfiguration i ScriptRunConfig

Przestrzeń nazw: azureml.core.compute.ComputeTarget
Przestrzeń nazw: azureml.core.runconfig.RunConfiguration
Przestrzeń nazw: azureml.core.script_run_config.ScriptRunConfig

Klasa ComputeTarget jest abstrakcyjną klasą nadrzędną do tworzenia docelowych obiektów obliczeniowych i zarządzania nimi. Docelowy obiekt obliczeniowy reprezentuje różnorodne zasoby, w których można trenować modele uczenia maszynowego. Docelowym obiektem obliczeniowym może być komputer lokalny lub zasób w chmurze, taki jak środowisko obliczeniowe usługi Azure Machine Learning, usługa Azure HDInsight lub zdalna maszyna wirtualna.

Użyj docelowych obiektów obliczeniowych, aby wykorzystać zalety zaawansowanych maszyn wirtualnych do trenowania modeli, i skonfiguruj trwałe docelowe obiekty obliczeniowe lub tymczasowe docelowe obiekty obliczeniowe wywoływane przez środowisko uruchomieniowe. Aby zapoznać się z kompleksowym przewodnikiem po konfigurowaniu docelowych obiektów obliczeniowych i zarządzaniu nimi, zobacz instrukcje.

Poniższy kod przedstawia prosty przykład konfigurowania obiektu docelowego AmlCompute (klasa podrzędna klasy ComputeTarget). Ten obiekt docelowy tworzy zasób obliczeniowy zdalnego środowiska uruchomieniowego w obiekcie Workspace. Zasób jest skalowany automatycznie po przesłaniu zadania. Jest on usuwany automatycznie po zakończeniu przebiegu.

Użyj ponownie prostego modelu rezygnacji scikit-learn i skompiluj go w jego własnym pliku, train.py, w bieżącym katalogu. Na końcu pliku utwórz nowy katalog o nazwie outputs. Ten krok powoduje utworzenie katalogu w chmurze (Twój obszar roboczy) do przechowywania wytrenowanego modelu serializowanego za pomocą funkcji joblib.dump().

# train.py

from sklearn import svm
import numpy as np
import joblib
import os

# customer ages
X_train = np.array([50, 17, 35, 23, 28, 40, 31, 29, 19, 62])
X_train = X_train.reshape(-1, 1)
# churn y/n
y_train = ["yes", "no", "no", "no", "yes", "yes", "yes", "no", "no", "yes"]

clf = svm.SVC(gamma=0.001, C=100.)
clf.fit(X_train, y_train)

os.makedirs("outputs", exist_ok=True)
joblib.dump(value=clf, filename="outputs/churn-model.pkl")

Następnie utwórz docelowy obiekt obliczeniowy, tworząc wystąpienie obiektu RunConfiguration i ustawiając typ oraz rozmiar. W tym przykładzie użyto najmniejszego rozmiaru zasobu (1 rdzeń procesora CPU, 3,5 GB pamięci). Zmienna list_vms zawiera listę obsługiwanych maszyn wirtualnych i ich rozmiarów.

from azureml.core.runconfig import RunConfiguration
from azureml.core.compute import AmlCompute
list_vms = AmlCompute.supported_vmsizes(workspace=ws)

compute_config = RunConfiguration()
compute_config.target = "amlcompute"
compute_config.amlcompute.vm_size = "STANDARD_D1_V2"

Utwórz zależności dla środowiska Python zdalnego zasobu obliczeniowego, używając klasy CondaDependencies. Plik train.py używa narzędzi scikit-learn i numpy, które należy zainstalować w środowisku. Możesz również określić wersje zależności. Użyj obiektu dependencies, aby ustawić środowisko w elemencie compute_config.

from azureml.core.conda_dependencies import CondaDependencies

dependencies = CondaDependencies()
dependencies.add_pip_package("scikit-learn")
dependencies.add_pip_package("numpy==1.15.4")
compute_config.environment.python.conda_dependencies = dependencies

Teraz możesz przesłać eksperyment. Użyj klasy ScriptRunConfig, aby dołączyć konfigurację docelowego obiektu obliczeniowego i określić ścieżkę/plik do skryptu treningowego train.py. Prześlij eksperyment, określając parametr config funkcji submit(). Wywołaj funkcję wait_for_completion w wynikowym przebiegu, aby wyświetlić dane wyjściowe przebiegu asynchronicznego po zainicjowaniu środowiska i wytrenowaniu modelu.

Ostrzeżenie

Poniżej przedstawiono ograniczenia dotyczące określonych znaków w przypadku użycia w ScriptRunConfig parametrach:

  • Znaki ", $, i ;\ są uciekane przez zaplecze, ponieważ są uważane za zastrzeżone znaki do oddzielania poleceń powłoki bash.
  • Znaki (, )<%^>!&i | są ucieczki dla uruchamiania lokalnego w Windows.
from azureml.core.experiment import Experiment
from azureml.core import ScriptRunConfig

script_run_config = ScriptRunConfig(source_directory=os.getcwd(), script="train.py", run_config=compute_config)
experiment = Experiment(workspace=ws, name="compute_target_test")
run = experiment.submit(config=script_run_config)
run.wait_for_completion(show_output=True)

Po zakończeniu przebiegu plik wytrenowanego modelu churn-model.pkl będzie dostępny w obszarze roboczym.

Środowisko

Przestrzeń nazw: azureml.core.environment

Azure Machine Learning środowiska określają pakiety języka Python, zmienne środowiskowe i ustawienia oprogramowania wokół skryptów trenowania i oceniania. Oprócz języka Python można również skonfigurować środowisko PySpark, Docker i R dla środowisk. Środowiska wewnętrznie powodują, że obrazy platformy Docker używane do uruchamiania procesów trenowania i oceniania w obiekcie docelowym obliczeniowym. Środowiska są zarządzane i wersjonowane jednostki w obszarze roboczym Machine Learning, które umożliwiają odtwarzanie, inspekcję i przenośne przepływy pracy uczenia maszynowego w różnych celach obliczeniowych i typach obliczeniowych.

Obiekt można użyć Environment do:

  • Opracowywanie skryptu szkoleniowego.
  • Ponownie użyj tego samego środowiska w usłudze Azure Machine Learning Compute na potrzeby trenowania modelu na dużą skalę.
  • Wdróż model przy użyciu tego samego środowiska bez powiązania z określonym typem obliczeniowym.

Poniższy kod importuje klasę Environment z zestawu SDK i tworzy wystąpienie obiektu środowiska.

from azureml.core.environment import Environment
Environment(name="myenv")

Dodaj pakiety do środowiska przy użyciu plików Conda, pip lub private wheel. Określ każdą zależność pakietu przy użyciu CondaDependency klasy , aby dodać ją do środowiska PythonSection.

Poniższy przykład dodaje do środowiska. Dodaje wersję 1.17.0 z numpy. Dodaje również pillow pakiet do środowiska . myenv W przykładzie add_conda_package() użyto metody i add_pip_package() metody odpowiednio.

from azureml.core.environment import Environment
from azureml.core.conda_dependencies import CondaDependencies

myenv = Environment(name="myenv")
conda_dep = CondaDependencies()

# Installs numpy version 1.17.0 conda package
conda_dep.add_conda_package("numpy==1.17.0")

# Installs pillow package
conda_dep.add_pip_package("pillow")

# Adds dependencies to PythonSection of myenv
myenv.python.conda_dependencies=conda_dep

Aby przesłać przebieg trenowania, musisz połączyć środowisko, docelowy obiekt obliczeniowy i skrypt trenowania języka Python w konfigurację uruchamiania. Ta konfiguracja jest obiektem otoki używanym do przesyłania przebiegów.

Po przesłaniu przebiegu trenowania tworzenie nowego środowiska może potrwać kilka minut. Czas trwania zależy od rozmiaru wymaganych zależności. Środowiska są buforowane przez usługę. Tak długo, jak definicja środowiska pozostaje niezmieniona, poniesiesz pełny czas instalacji tylko raz.

W poniższym przykładzie pokazano, gdzie można użyć ScriptRunConfig jako obiektu otoki.

from azureml.core import ScriptRunConfig, Experiment
from azureml.core.environment import Environment

exp = Experiment(name="myexp", workspace = ws)
# Instantiate environment
myenv = Environment(name="myenv")

# Add training script to run config
runconfig = ScriptRunConfig(source_directory=".", script="train.py")

# Attach compute target to run config
runconfig.run_config.target = "local"

# Attach environment to run config
runconfig.run_config.environment = myenv

# Submit run 
run = exp.submit(runconfig)

Jeśli nie określisz środowiska w konfiguracji przebiegu przed przesłaniem przebiegu, zostanie utworzone domyślne środowisko.

Zobacz sekcję Wdrażanie modelu , aby używać środowisk do wdrażania usługi internetowej.

Pipeline, PythonScriptStep

Przestrzeń nazw: azureml.pipeline.core.pipeline.Pipeline
Przestrzeń nazw: azureml.pipeline.steps.python_script_step.PythonScriptStep

Potok usługi Azure Machine Learning to zautomatyzowany przepływ pracy kompletnego zadania uczenia maszynowego. Podzadania są zamknięte jako serie kroków w potoku. Potok usługi Azure Machine Learning może być tak prosty, jak jeden krok, który wywołuje skrypt języka Python. Potoki zawierają następujące funkcje:

  • Przygotowywanie danych, takie jak importowanie, weryfikowanie i czyszczenie, zniekształcanie i przekształcanie, normalizacja i przemieszczanie
  • Konfigurowanie trenowania obejmujące parametryzację argumentów, ścieżki plików i konfiguracje rejestrowania/raportowania
  • Wydajne i wielokrotne trenowanie i weryfikowanie, które może obejmować określanie konkretnych podzestawów danych, różne sprzętowe zasoby obliczeniowe, przetwarzanie rozproszone i monitorowanie postępu
  • Wdrażanie, w tym przechowywanie wersji, skalowanie, aprowizowanie i kontrola dostępu
  • Publikowanie potoku w punkcie końcowym REST w celu ponownego uruchomienia z dowolnej biblioteki HTTP

Klasa PythonScriptStep to podstawowy, wbudowany krok umożliwiający uruchomienie skryptu języka Python na docelowym obiekcie obliczeniowym. Pobiera ona nazwę skryptu i inne parametry opcjonalne, takie jak argumenty dla skryptu, docelowy obiekt obliczeniowy, dane wejściowe i wyjściowe. Poniższy kod jest prostym przykładem klasy PythonScriptStep. Aby zapoznać się z przykładem skryptu train.py, zobacz podsekcję samouczek.

from azureml.pipeline.steps import PythonScriptStep

train_step = PythonScriptStep(
    script_name="train.py",
    arguments=["--input", blob_input_data, "--output", output_data1],
    inputs=[blob_input_data],
    outputs=[output_data1],
    compute_target=compute_target,
    source_directory=project_folder
)

Po utworzeniu co najmniej jednego kroku można połączyć ze sobą kroki i opublikować je jako prosty, zautomatyzowany potok.

from azureml.pipeline.core import Pipeline

pipeline = Pipeline(workspace=ws, steps=[train_step])
pipeline_run = experiment.submit(pipeline)

Aby zapoznać się z kompleksowym przykładem tworzenia przepływu pracy potoku, zobacz zaawansowany samouczek.

Wzorzec tworzenia i używania potoków

Potok Azure Machine Learning jest skojarzony z obszarem roboczym Azure Machine Learning, a krok potoku jest skojarzony z obiektem docelowym obliczeniowym dostępnym w tym obszarze roboczym. Aby uzyskać więcej informacji, zobacz ten artykuł dotyczący obszarów roboczych lub to objaśnienie docelowych obiektów obliczeniowych.

Typowy wzorzec dla kroków potoku jest następujący:

  1. Określenie obszaru roboczego, zasobów obliczeniowych i magazynu
  2. Skonfigurowanie danych wejściowych i wyjściowych przy użyciu następujących klas:
    1. Zestaw danych , który udostępnia istniejący magazyn danych platformy Azure
    2. PipelineDataset, która zawiera typizowane dane tabelaryczne
    3. PipelineData, która jest używana na potrzeby pośrednich danych pliku lub katalogu zapisywanych w jednym kroku i przeznaczonych do użycia w innym
  3. Zdefiniowanie co najmniej jednego kroku potoku
  4. Utworzenie wystąpienia potoku przy użyciu obszaru roboczego i kroków
  5. Utworzenie eksperymentu, do którego zostanie przesłany potok
  6. Monitorowanie wyników eksperymentu

Ten notes jest dobrym przykładem takiego wzorca. zadanie

Aby uzyskać więcej informacji na temat potoków usługi Azure Machine Learning, a w szczególności o tym, jak różnią się one od innych typów potoków, zobacz ten artykuł.

AutoMLConfig

Przestrzeń nazw: azureml.train.automl.automlconfig.AutoMLConfig

Użyj klasy AutoMLConfig, aby skonfigurować parametry automatycznego trenowania uczenia maszynowego. Zautomatyzowane uczenie maszynowe iteruje po wielu kombinacjach algorytmów uczenia maszynowego i ustawieniach hiperparametrów. Następnie znajduje najlepiej dopasowany model na podstawie wybranej metryki dokładności. Konfiguracja umożliwia określenie następujących elementów:

  • Typ zadania (klasyfikacja, regresja, prognozowanie)
  • Liczba iteracji algorytmu i maksymalny czas na iterację
  • Metryka dokładności na potrzeby optymalizacji
  • Algorytmy do blokowania/listy dozwolonych
  • Liczba weryfikacji krzyżowych
  • Docelowe obiekty obliczeniowe
  • Dane szkoleniowe

Uwaga

Użyj dodatkowej funkcji automl w swojej instalacji, aby użyć zautomatyzowanego uczenia maszynowego.

Aby zapoznać się z szczegółowymi wskazówkami i przykładami konfigurowania eksperymentów zautomatyzowanego uczenia maszynowego, zapoznaj się z samouczkiem i instrukcjami.

Poniższy kod ilustruje kompilowanie obiektu konfiguracji zautomatyzowanego uczenia maszynowego dla modelu klasyfikacji i używanie go podczas przesyłania eksperymentu.

from azureml.train.automl import AutoMLConfig

automl_config = AutoMLConfig(task="classification",
                             X=your_training_features,
                             y=your_training_labels,
                             iterations=30,
                             iteration_timeout_minutes=5,
                             primary_metric="AUC_weighted",
                             n_cross_validations=5
                            )

Użyj obiektu automl_config, aby przesłać eksperyment.

from azureml.core.experiment import Experiment

experiment = Experiment(ws, "automl_test_experiment")
run = experiment.submit(config=automl_config, show_output=True)

Po przesłaniu eksperymentu dane wyjściowe pokazują dokładność trenowania dla każdej iteracji po jej zakończeniu. Po zakończeniu przebiegu zostanie zwrócony obiekt AutoMLRun (rozszerzający klasę Run). Uzyskaj optymalny model, używając funkcji get_output() w celu zwrócenia obiektu Model.

best_model = run.get_output()
y_predict = best_model.predict(X_test)

Wdrażanie modelu

Przestrzeń nazw: azureml.core.model.InferenceConfig
Przestrzeń nazw: azureml.core.webservice.webservice.Webservice

Klasa InferenceConfig służy do ustawień konfiguracji, które opisują środowisko potrzebne do hostowania modelu i usługi internetowej.

Webservice jest abstrakcyjną klasą nadrzędną na potrzeby tworzenia i wdrażania usług internetowych dla modeli. Aby uzyskać szczegółowy przewodnik dotyczący przygotowywania do wdrażania modelu i wdrażania usług internetowych, zobacz ten instrukcje.

Środowiska można używać podczas wdrażania modelu jako usługi internetowej. Środowiska umożliwiają powtarzalny, połączony przepływ pracy, w którym można wdrożyć model przy użyciu tych samych bibliotek zarówno w obliczeniach szkoleniowych, jak i obliczeniach wnioskowania. Wewnętrznie środowiska są implementowane jako obrazy platformy Docker. Możesz użyć obrazów dostarczanych przez firmę Microsoft lub użyć własnych niestandardowych obrazów platformy Docker. Jeśli wcześniej używano ContainerImage klasy dla wdrożenia, zobacz klasę DockerSection do wykonania podobnego przepływu pracy ze środowiskami.

Aby wdrożyć usługę internetową, połącz środowisko, wnioskowanie obliczeniowe, skrypt oceniania i zarejestrowany model w obiekcie wdrożenia. deploy()

W poniższym przykładzie przyjęto założenie, że ukończono już przebieg trenowania przy użyciu środowiska , myenvi chcesz wdrożyć ten model w Azure Container Instances.

from azureml.core.model import InferenceConfig, Model
from azureml.core.webservice import AciWebservice, Webservice

# Register the model to deploy
model = run.register_model(model_name = "mymodel", model_path = "outputs/model.pkl")

# Combine scoring script & environment in Inference configuration
inference_config = InferenceConfig(entry_script="score.py",
                                   environment=myenv)

# Set deployment configuration
deployment_config = AciWebservice.deploy_configuration(cpu_cores = 1,
                                                       memory_gb = 1)

# Define the model, inference, & deployment configuration and web service name and location to deploy
service = Model.deploy(workspace = ws,
                       name = "my_web_service",
                       models = [model],
                       inference_config = inference_config,
                       deployment_config = deployment_config)

W tym przykładzie tworzymy usługę internetową Azure Container Instances, która najlepiej nadaje się do testowania na małą skalę i szybkich wdrożeń. Aby wdrożyć model jako usługę internetową w skali produkcyjnej, użyj usługi Azure Kubernetes Service (AKS). Aby uzyskać więcej informacji, zobacz Klasa AksCompute.

Zestaw danych

Przestrzeń nazw: azureml.core.dataset.Dataset
Przestrzeń nazw: azureml.data.file_dataset.FileDataset
Przestrzeń nazw: azureml.data.tabular_dataset.TabularDataset

Klasa Dataset jest podstawowym zasobem na potrzeby eksplorowania danych i zarządzania nimi w usłudze Azure Machine Learning. Możesz eksplorować dane przy użyciu statystyk podsumowujących i zapisywać zestawy danych w obszarze roboczym usługi AML, aby uzyskać dostęp do funkcji przechowywania wersji i odtwarzania. Modele z łatwością wykorzystują zestawy danych podczas trenowania. Aby uzyskać szczegółowe przykłady użycia, zobacz przewodnik z instrukcjami.

  • TabularDataset reprezentuje dane w formacie tabelarycznym utworzonym przez analizowanie pliku lub listy plików.
  • Element FileDataset odwołuje się do jednego lub wielu plików w magazynach danych lub z publicznych adresów URL.

Poniższy przykład pokazuje, jak utworzyć element TabularDataset wskazujący pojedynczą ścieżkę w magazynie danych.

from azureml.core import Dataset

dataset = Dataset.Tabular.from_delimited_files(path = [(datastore, 'train-dataset/tabular/iris.csv')])
dataset.take(3).to_pandas_dataframe()

W poniższym przykładzie pokazano, jak utworzyć FileDataset odwołania do wielu adresów URL plików.

from azureml.core.dataset import Dataset

url_paths = [
            'http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz',
            'http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz',
            'http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz',
            'http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz'
            ]
dataset = Dataset.File.from_files(path=url_paths)

Następne kroki

Skorzystaj z poniższych następnych kroków, aby dowiedzieć się, jak używać zestawu SDK usługi Azure Machine Learning dla języka Python:

  • Wykonaj samouczek, aby dowiedzieć się, jak tworzyć, trenować i wdrażać model w języku Python.

  • Wyszukaj klasy i moduły w dokumentacji referencyjnej w tej witrynie, korzystając ze spisu treści po lewej stronie.