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

  • Artykuł

Analitycy danych i deweloperzy sztucznej inteligencji używają zestawu SDK usługi Azure Machine Learning 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 Code lub ulubionym środowisku 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óry akceptuje parametry konfiguracji i dane szkoleniowe. 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 usługi Azure Machine Learning dla języka Python udostępnia 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, a następnie funkcje eksperymentalne.
Funkcje eksperymentalne Rozwoju

Te funkcje to nowo opracowane funkcje & aktualizacji, 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 w wersji zapoznawczej.

Jak wskazuje nazwa, funkcje eksperymentalne (wersja zapoznawcza) są przeznaczone do eksperymentowania i nie są uznawane za wolne od usterek ani stabilne. Z tego powodu zalecamy tylko funkcje eksperymentalne dla zaawansowanych użytkowników, którzy chcą wypróbować wczesne wersje możliwości i aktualizacji, oraz 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.

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 create Workspace w celu 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. 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ę. 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.

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ą ucieczki przez zaplecze, ponieważ są uważane za zastrzeżone znaki do oddzielania poleceń powłoki bash.
  • Znaki (, , %<)^>!&, i | są używane w przypadku uruchamiania lokalnego 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 plik wytrenowanego modelu churn-model.pkl będzie dostępny w obszarze roboczym.

Środowisko

Przestrzeń 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 dla środowisk. Środowiska wewnętrznie powodują, że obrazy platformy Docker są 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ą powtarzalne, możliwe do inspekcji i przenośne przepływy pracy uczenia maszynowego w różnych celach obliczeniowych i typach obliczeniowych.

Możesz użyć Environment obiektu 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 w tym samym środowisku 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 użyto add_conda_package() odpowiednio metody i add_pip_package() metody .

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 obliczeniowy i skrypt języka Python do konfiguracji przebiegu. 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 długo 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 środowisko domyślne.

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 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ł 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 listy blokowej/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 jest przeznaczona InferenceConfig dla ustawień konfiguracji, które opisują środowisko wymagane 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 zapoznać się ze szczegółowym przewodnikiem dotyczącym przygotowywania do wdrażania modelu i wdrażania usług internetowych, zobacz ten przewodnik.

Ś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. Środowiska są implementowane wewnętrznie 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 ContainerImage klasy dla wdrożenia, zobacz DockerSection klasę 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 deploy()wdrożenia.

W poniższym przykładzie założono, że przebieg trenowania został już ukończony 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łanie 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.