Udostępnij za pośrednictwem

Co to jest zestaw Azure Machine Learning SDK w wersji 1 dla języka Python?

  • Artykuł

Ważny

Ten artykuł dotyczy zestawu AZURE Machine Learning SDK w wersji 1, który nie jest bieżącym zestawem SDK. Bieżąca wersja zestawu SDK to zestawu SDK języka Python usługi Azure Machine Learning w wersji 2. Aby uzyskać informacje na temat różnic między wersjami zestawu SDK, przeczytaj artykuł Upgrade to v2.

Analitycy danych i deweloperzy sztucznej inteligencji używają zestawu SDK usługi Azure Machine Learning w wersji 1 dla języka Python do tworzenia i uruchamiania przepływów pracy uczenia maszynowego za pomocą usługi Azure Machine Learning Service. Możesz korzystać z usługi w dowolnym środowisku języka Python, w tym notesach Jupyter Notebook, visual Studio Codelub ulubionym środowisku IDE języka Python.

Najważniejsze obszary zestawu SDK obejmują:

  • 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 modelu przyspieszonego przez procesor GPU.
  • Użyj zautomatyzowanego uczenia maszynowego, które akceptuje parametry konfiguracji i dane szkoleniowe. Automatycznie wykonuje iterację za pomocą algorytmów i ustawień hiperparametrów, aby znaleźć najlepszy model do uruchamiania przewidywań.
  • Wdróż usługi internetowe, aby przekonwertować wytrenowane modele na usługi RESTful, które mogą być używane w dowolnej aplikacji.

Aby zapoznać się z przewodnikiem krok po kroku dotyczącym rozpoczynania pracy, wypróbuj samouczek .

W poniższych sekcjach omówiono niektóre z najważniejszych klas w zestawie SDK oraz typowe wzorce projektowe do ich używania. Aby uzyskać zestaw SDK, zobacz przewodnik instalacji .

Stabilne a eksperymentalne

Zestaw SDK usługi 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
Funkcje stabilne Gotowe do produkcji

Te funkcje są zalecane w przypadku większości przypadków użycia i środowisk produkcyjnych. Są one aktualizowane rzadziej, a następnie funkcje eksperymentalne.
Funkcje eksperymentalne deweloperskie

Te funkcje to nowo opracowane funkcje & aktualizacji, które mogą nie być gotowe lub w pełni przetestowane pod kątem użycia produkcyjnego. 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 okres 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ą uznawane 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 przez sekcję notatek w dokumentacji zestawu SDK i oznaczone tekstem, takim jak (wersja zapoznawcza) w dokumentacji usługi Azure Machine Learning .

Obszar roboczy

przestrzeni nazw: azureml.core.workspace.Workspace

Klasa Workspace to podstawowy zasób w chmurze używany do eksperymentowania, trenowania i wdrażania modeli uczenia maszynowego. Łączy subskrypcję platformy Azure i grupę zasobów z łatwo używanym obiektem.

Wyświetl wszystkich parametrów metody create Workspace do ponownego użycia istniejących wystąpień (Storage, Key Vault, App-Insights i Azure Container Registry-ACR), a także zmodyfikuj dodatkowe ustawienia, takie jak konfiguracja prywatnego punktu końcowego i docelowy obiekt obliczeniowy.

Zaimportuj klasę i utwórz nowy obszar roboczy przy użyciu następującego kodu. Ustaw create_resource_group na False, jeśli masz wcześniej istniejącą grupę zasobów platformy Azure, której chcesz użyć dla obszaru roboczego. Niektóre funkcje mogą monitowania 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'
                     )

Użyj tego samego obszaru roboczego w wielu środowiskach, zapisując go najpierw w pliku JSON konfiguracji. Spowoduje to zapisanie danych nazw subskrypcji, zasobów i obszaru roboczego.

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

Załaduj obszar roboczy, odczytując plik konfiguracji.

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

Alternatywnie użyj metody statycznej 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')

Zmienna ws reprezentuje obiekt Workspace w poniższych przykładach kodu.

Eksperyment

przestrzeni nazw: azureml.core.experiment.Experiment

Klasa Experiment to kolejny podstawowy zasób w chmurze, który reprezentuje kolekcję prób (poszczególne uruchomienia modelu). Poniższy kod pobiera obiekt Experiment z 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 następujący kod, aby uzyskać listę wszystkich obiektów Experiment zawartych w Workspace.

list_experiments = Experiment.list(ws)

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

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

Istnieją dwa sposoby wykonywania wersji próbnej eksperymentu. Jeśli eksperymentujesz interaktywnie w notesie 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. Zmienna experiment reprezentuje obiekt Experiment w poniższych przykładach kodu.

Biegać

przestrzeni nazw: azureml.core.run.Run

Przebieg reprezentuje pojedynczą wersję próbną eksperymentu. Run jest obiektem używanym do monitorowania asynchronicznego wykonywania wersji próbnej, przechowywania danych wyjściowych wersji próbnej, analizowania wyników i uzyskiwania dostępu do wygenerowanych artefaktów. Używasz Run wewnątrz kodu eksperymentowania, aby rejestrować metryki i artefakty w usłudze Historia uruchamiania. Funkcje obejmują:

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

Utwórz obiekt Run, przesyłając obiekt Experiment przy użyciu obiektu uruchamiania konfiguracji. Użyj parametru tags, aby dołączyć niestandardowe kategorie i etykiety do przebiegów. Można je łatwo znaleźć i pobrać później z Experiment.

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

Użyj funkcji static list, aby uzyskać listę wszystkich obiektów Run z Experiment. Określ parametr tags do filtrowania 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 dla tej funkcji to słownik zawierający:

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

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

Model

przestrzeni nazw: azureml.core.model.Model

Klasa Model służy do pracy z reprezentacjami w chmurze modeli uczenia maszynowego. Metody ułatwiają transfer modeli między lokalnymi środowiskami projektowymi a obiektem Workspace w chmurze.

Rejestrację modelu można użyć do przechowywania i przechowywania wersji modeli w chmurze platformy Azure w obszarze roboczym. Zarejestrowane modele są identyfikowane według nazwy i wersji. Za każdym razem, gdy rejestrujesz model o takiej samej nazwie jak istniejący, rejestr zwiększa wersję. Usługa Azure Machine Learning obsługuje dowolny model, który można załadować za pośrednictwem języka Python 3, a nie tylko modeli usługi Azure Machine Learning.

W poniższym przykładzie pokazano, jak utworzyć prosty lokalny model klasyfikacji przy użyciu scikit-learn, zarejestrować model w Workspacei pobrać model z chmury.

Utwórz prosty klasyfikator, clf, aby przewidzieć współczynnik zmian 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 lokalną ścieżkę modelu 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")

Po zarejestrowaniu modelu w obszarze roboczym można łatwo zarządzać, pobierać i organizować modele. Aby pobrać model (na przykład w innym środowisku) z Workspace, użyj konstruktora klasy i określ nazwę modelu i wszelkie parametry opcjonalne. Następnie użyj funkcji download, aby pobrać model, w tym 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 Workspace.

model.delete()

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

ComputeTarget, RunConfiguration i ScriptRunConfig

przestrzeni nazw: azureml.core.compute.ComputeTarget
przestrzeni nazw: azureml.core.runconfig.RunConfiguration
przestrzeni nazw: azureml.core.script_run_config.ScriptRunConfig

Klasa ComputeTarget jest abstrakcyjną klasą nadrzędną do tworzenia obiektów docelowych obliczeniowych i zarządzania nimi. Docelowy obiekt obliczeniowy reprezentuje różne zasoby, w których można trenować modele uczenia maszynowego. Obiektem docelowym obliczeń może być maszyna lokalna lub zasób w chmurze, taki jak obliczenia usługi Azure Machine Learning, usługa Azure HDInsight lub zdalna maszyna wirtualna.

Użyj docelowych obiektów obliczeniowych, aby skorzystać z zaawansowanych maszyn wirtualnych na potrzeby trenowania modelu i skonfigurować trwałe cele obliczeniowe lub tymczasowe obiekty docelowe wywoływane przez środowisko uruchomieniowe. Aby zapoznać się z kompleksowym przewodnikiem dotyczącym konfigurowania celów obliczeniowych i zarządzania nimi, zobacz instrukcje.

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

Ponownie użyj prostego modelu zmian scikit-learn i skompiluj go do własnego pliku, train.py, w bieżącym katalogu. Na końcu pliku utwórz nowy katalog o nazwie outputs. Ten krok tworzy katalog w chmurze (obszar roboczy) do przechowywania wytrenowanego modelu, który joblib.dump() serializowany.

# 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 utworzysz docelowy obiekt obliczeniowy, tworząc wystąpienie obiektu RunConfiguration i ustawiając typ i 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 języka Python zasobu obliczeniowego zdalnego przy użyciu klasy CondaDependencies. Plik train.py używa scikit-learn i numpy, które należy zainstalować w środowisku. Można również określić wersje zależności. Użyj obiektu dependencies, aby ustawić środowisko w 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 przystąpić do przesyłania eksperymentu. Użyj klasy ScriptRunConfig, aby dołączyć konfigurację docelowego obiektu obliczeniowego i określić ścieżkę/plik do skryptu trenowania train.py. Prześlij eksperyment, określając parametr config funkcji submit(). Wywołaj wait_for_completion na wynikowym przebiegu, aby zobaczyć asynchroniczne dane wyjściowe przebiegu, gdy środowisko jest inicjowane, a model jest trenowany.

Ostrzeżenie

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

  • Znaki ", $, ;i \ są uniknięci przez zaplecze, ponieważ są uważane za zastrzeżone znaki do oddzielania poleceń powłoki Bash.
  • Znaki (, ), %, !, ^, <, >, &i | są znaki ucieczki dla lokalnych przebiegów w systemie 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 wytrenowany plik modelu churn-model.pkl jest dostępny w obszarze roboczym.

Środowisko

przestrzeni nazw: azureml.core.environment

Środowiska usługi Azure Machine Learning 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. Wewnętrznie środowiska powodują obrazy platformy Docker używane do uruchamiania procesów trenowania i oceniania na docelowym obiekcie obliczeniowym. Środowiska są zarządzane i wersjonowane jednostki w obszarze roboczym usługi Machine Learning, które umożliwiają odtwarzanie, inspekcję i przenośne przepływy pracy uczenia maszynowego w różnych celach obliczeniowych i typach obliczeniowych.

Możesz użyć obiektu Environment do:

  • Opracowywanie skryptu szkoleniowego.
  • Ponowne użycie tego samego środowiska w usłudze Azure Machine Learning Compute na potrzeby trenowania modeli 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, lub private wheel. Określ każdą zależność pakietu przy użyciu klasy CondaDependency, aby dodać ją do PythonSectionśrodowiska .

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

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, należy połączyć środowisko, docelowy obiekt obliczeniowyi skrypt trenowania języka Python w konfiguracji 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ę Model wdrażania, aby wdrożyć usługę internetową przy użyciu środowisk.

Pipeline, PythonScriptStep

przestrzeni nazw: azureml.pipeline.core.pipeline.Pipeline
przestrzeni 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ą hermetyzowane jako seria 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 obejmują następujące funkcje:

  • Przygotowywanie danych, w tym importowanie, weryfikowanie i czyszczenie, munging i przekształcanie, normalizacja i przemieszczanie
  • Konfiguracja trenowania obejmująca parametryzowanie argumentów, ścieżek plików i konfiguracji rejestrowania/raportowania
  • Trenowanie i weryfikowanie wydajnie i powtarzanie, które mogą obejmować określanie określonych podzestawów danych, różne zasoby obliczeniowe sprzętu, rozproszone przetwarzanie 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

PythonScriptStep jest podstawowym, wbudowanym krokiem uruchamiania skryptu języka Python na docelowym obiekcie obliczeniowym. Przyjmuje 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 PythonScriptStep. Aby zapoznać się z przykładem skryptu train.py, zobacz samouczek podsieci.

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 kroki można połączyć i opublikować jako prosty zautomatyzowany potok.

from azureml.pipeline.core import Pipeline

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

Aby uzyskać kompleksowy przykład tworzenia przepływu pracy potoku, postępuj zgodnie z zaawansowanym samouczkiem.

Wzorzec tworzenia i używania potoków

Potok usługi Azure Machine Learning jest skojarzony z obszarem roboczym usługi Azure Machine Learning, a krok potoku jest skojarzony z docelowym obiektem obliczeniowym dostępnym w tym obszarze roboczym. Aby uzyskać więcej informacji, zobacz ten artykuł na temat obszarów roboczych lub tego wyjaśnienia docelowych obiektów obliczeniowych.

Typowym wzorcem kroków potoku jest:

  1. Określanie obszaru roboczego, zasobów obliczeniowych i magazynu
  2. Konfigurowanie danych wejściowych i wyjściowych przy użyciu polecenia
    1. Dataset, który udostępnia istniejący magazyn danych platformy Azure
    2. PipelineDataset, które hermetyzują dane tabelaryczne
    3. PipelineData, która jest używana na potrzeby danych plików pośrednich lub katalogów zapisanych przez jeden krok i przeznaczonych do użycia przez inny
  3. Definiowanie co najmniej jednego kroku potoku
  4. Tworzenie wystąpienia potoku przy użyciu obszaru roboczego i kroków
  5. Tworzenie eksperymentu, do którego przesyłasz potok
  6. Monitorowanie wyników eksperymentu

Ten notes jest dobrym przykładem tego wzorca. zadanie

Aby uzyskać więcej informacji o potokach 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

przestrzeni nazw: azureml.train.automl.automlconfig.AutoMLConfig

Użyj klasy AutoMLConfig, aby skonfigurować parametry do trenowania zautomatyzowanego uczenia maszynowego. Zautomatyzowane uczenie maszynowe iteruje wiele kombinacji algorytmów uczenia maszynowego i ustawień hiperparametrów. Następnie znajduje model najlepiej dopasowany na podstawie wybranej metryki dokładności. Konfiguracja umożliwia określenie:

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

Nuta

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

Aby uzyskać szczegółowe przewodniki i przykłady konfigurowania eksperymentów zautomatyzowanego uczenia maszynowego, zobacz samouczka i instrukcje.

Poniższy kod ilustruje tworzenie 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 zakończeniu. Po zakończeniu przebiegu zwracany jest obiekt AutoMLRun (który rozszerza klasę Run). Uzyskaj najlepszy model przy użyciu funkcji get_output(), aby zwrócić obiekt Model.

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

Wdrażanie modelu

przestrzeni nazw: azureml.core.model.InferenceConfig
przestrzeni nazw: azureml.core.webservice.webservice.Webservice

Klasa InferenceConfig dotyczy ustawień konfiguracji, które opisują środowisko wymagane do hostowania modelu i usługi internetowej.

Webservice to abstrakcyjna klasa nadrzędna do tworzenia i wdrażania usług internetowych dla modeli. Aby uzyskać szczegółowy przewodnik dotyczący przygotowywania do wdrażania modeli i wdrażania usług internetowych, zobacz ten instrukcje.

Podczas wdrażania modelu jako usługi internetowej można użyć środowisk. Ś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 dostarczonych przez firmę Microsoft lub użyć własnych niestandardowych obrazów platformy Docker. Jeśli wcześniej używano klasy ContainerImage dla wdrożenia, zobacz klasę DockerSection w celu wykonania podobnego przepływu pracy ze środowiskami.

Aby wdrożyć usługę internetową, połącz środowisko, wnioskowanie obliczeń, 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 usłudze 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 jest tworzona usługa internetowa usługi Azure Container Instances, która jest najlepsza w przypadku 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 AksCompute, klasa.

Dataset

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

Klasa Dataset to podstawowy zasób do eksplorowania danych i zarządzania nimi w usłudze Azure Machine Learning. Możesz eksplorować dane za pomocą statystyk podsumowania i zapisać zestaw danych w obszarze roboczym usługi AML, aby uzyskać możliwości przechowywania wersji i odtwarzania. Zestawy danych są łatwo używane przez modele 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.
  • FileDataset odwołuje się do pojedynczych lub wielu plików w magazynach danych lub z publicznych adresów URL.

W poniższym przykładzie pokazano, 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łującą się 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

Spróbuj wykonać następujące następne kroki, aby dowiedzieć się, jak używać zestawu Azure Machine Learning SDK dla języka Python:

  • Postępuj zgodnie z samouczkiem, 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 przy użyciu spisu treści po lewej stronie.