Share via

Migrowanie z usługi Batch AI do usługi Azure Machine Learning

  • Artykuł

Usługa Azure Batch AI zostanie wycofana w marcu. Możliwości usługi Batch AI związane z trenowaniem i ocenianiem na dużą skalę są teraz dostępne w usłudze Azure Machine Learning, która stanie się ogólnodostępna 4 grudnia 2018 r.

Wśród wielu możliwości dotyczących uczenia maszynowego usługa Azure Machine Learning obejmuje chmurowy, zarządzany docelowy obiekt obliczeniowy do trenowania, wdrażania i oceniania modeli uczenia maszynowego. Ten docelowy obiekt obliczeniowy jest nazywany środowiskiem obliczeniowym usługi Azure Machine Learning. Migrację i korzystanie z tego obiektu warto zacząć już dziś. Interakcja z usługą Azure Machine Learning jest możliwa za pomocą wbudowanych zestawów Python SDK, interfejsu wiersza polecenia i witryny Azure portal.

Uaktualnianie z wersji zapoznawczej usługi Batch AI do ogólnie dostępnej usługi Azure Machine Learning service zapewnia lepsze środowisko dzięki pojęciom, które są łatwiejsze do użycia, takie jak narzędzia do szacowania i magazyny danych. Gwarantuje to również podleganie umowom SLA oraz pomoc techniczną na poziomie ogólnie dostępnych usług platformy Azure.

Usługa Azure Machine Learning Service oferuje również nowe funkcje, takie jak zautomatyzowane uczenie maszynowe, dostrajanie hiperparametrów i potoki uczenia maszynowego, które są przydatne w przypadku większości obciążeń sztucznej inteligencji na dużą skalę. Możliwość wdrożenia wytrenowanego modelu bez przełączania się do oddzielnej usługi pomaga ukończyć pętlę nauki o danych z przygotowywania danych (przy użyciu zestawu SDK przygotowywania danych) przez cały sposób na operacjonalizacja i monitorowanie modelu.

Rozpoczynanie migracji

Aby uniknąć przerw w działaniu aplikacji i móc korzystać z najnowszych funkcji, przed 31 marca 2019 r. wykonaj następujące kroki:

  1. Utwórz obszar roboczy usługi Azure Machine Learning i rozpocznij pracę:

  2. Zainstaluj zestaw SDK usługi Azure Machine Learning i zestaw SDK przygotowywania danych.

  3. Skonfiguruj środowisko obliczeniowe usługi Azure Machine Learning do trenowania modelu.

  4. Zaktualizuj swoje skrypty pod kątem korzystania ze środowiska obliczeniowego usługi Azure Machine Learning. W poniższych sekcjach pokazano, jak typowy kod używany dla usługi Batch AI mapuje na kod dla usługi Azure Machine Learning.

Tworzenie obszarów roboczych

Koncepcja inicjowania obszaru roboczego przy użyciu pliku configuration.json w usłudze Azure Batch AI mapuje się podobnie do używania pliku konfiguracji w usłudze Azure Machine Learning.

W usłudze Batch AI wykonywano to w następujący sposób:

sys.path.append('../../..')
import utilities as utils

cfg = utils.config.Configuration('../../configuration.json')
client = utils.config.create_batchai_client(cfg)

utils.config.create_resource_group(cfg)
_ = client.workspaces.create(cfg.resource_group, cfg.workspace, cfg.location).result()

W usłudzeAzure Machine Learning Service wypróbuj:

from azureml.core.workspace import Workspace

ws = Workspace.from_config()
print('Workspace name: ' + ws.name, 
      'Azure region: ' + ws.location, 
      'Subscription id: ' + ws.subscription_id, 
      'Resource group: ' + ws.resource_group, sep = '\n')

Ponadto można również utworzyć obszar roboczy bezpośrednio, określając następujące parametry konfiguracji

from azureml.core import Workspace
# Create the workspace using the specified parameters
ws = Workspace.create(name = workspace_name,
                      subscription_id = subscription_id,
                      resource_group = resource_group, 
                      location = workspace_region,
                      create_resource_group = True,
                      exist_ok = True)
ws.get_details()

# write the details of the workspace to a configuration file to the notebook library
ws.write_config()

Dowiedz się więcej o klasie Obszar roboczy usługi Azure Machine Learning w dokumentacji referencyjnej zestawu SDK.

Tworzenie klastrów obliczeniowych

Usługa Azure Machine Learning obsługuje wiele docelowych obiektów obliczeniowych, z których część jest zarządzana przez usługę, a inne mogą być dołączone do obszaru roboczego (np. klaster usługi HDInsight lub zdalna maszyna wirtualna). Dowiedz się więcej o różnych docelowych obiektach obliczeniowych. Koncepcja tworzenia klastra obliczeniowego sztucznej inteligencji Azure Batch mapuje się na tworzenie klastra AmlCompute w usłudze Azure Machine Learning. Tworzenie Amlcompute odbywa się w konfiguracji obliczeniowej podobnej do sposobu przekazywania parametrów w Azure Batch sztucznej inteligencji. Należy pamiętać, że skalowanie automatyczne jest domyślnie włączone w klastrze AmlCompute, podczas gdy jest domyślnie wyłączone w Azure Batch sztucznej inteligencji.

W usłudze Batch AI wykonywano to w następujący sposób:

nodes_count = 2
cluster_name = 'nc6'

parameters = models.ClusterCreateParameters(
    vm_size='STANDARD_NC6',
    scale_settings=models.ScaleSettings(
        manual=models.ManualScaleSettings(target_node_count=nodes_count)
    ),
    user_account_settings=models.UserAccountSettings(
        admin_user_name=cfg.admin,
        admin_user_password=cfg.admin_password or None,
        admin_user_ssh_public_key=cfg.admin_ssh_key or None,
    )
)
_ = client.clusters.create(cfg.resource_group, cfg.workspace, cluster_name, parameters).result()

W usłudze Azure Machine Learning Service wypróbuj:

from azureml.core.compute import ComputeTarget, AmlCompute
from azureml.core.compute_target import ComputeTargetException

# Choose a name for your CPU cluster
gpu_cluster_name = "nc6"

# Verify that cluster does not exist already
try:
    gpu_cluster = ComputeTarget(workspace=ws, name=gpu_cluster_name)
    print('Found existing cluster, use it.')
except ComputeTargetException:
    compute_config = AmlCompute.provisioning_configuration(vm_size='STANDARD_NC6',
                                                           vm_priority='lowpriority',
                                                           min_nodes=1,
                                                           max_nodes=2,
                                                           idle_seconds_before_scaledown='300',
                                                           vnet_resourcegroup_name='<my-resource-group>',
                                                           vnet_name='<my-vnet-name>',
                                                           subnet_name='<my-subnet-name>')
    gpu_cluster = ComputeTarget.create(ws, gpu_cluster_name, compute_config)

gpu_cluster.wait_for_completion(show_output=True)

Więcej informacji na temat klasy AMLCompute znajduje się w dokumentacji referencyjnej zestawu SDK. Należy pamiętać, że w powyższej konfiguracji tylko właściwości vm_size i max_nodes są obowiązkowe, a pozostałe właściwości, takie jak vnet, są przeznaczone tylko dla konfiguracji zaawansowanej klastra.

Monitorowanie stanu klastra

Jest to bardziej proste w usłudze Azure Machine Learning, jak pokazano poniżej.

W usłudze Batch AI wykonywano to w następujący sposób:

cluster = client.clusters.get(cfg.resource_group, cfg.workspace, cluster_name)
utils.cluster.print_cluster_status(cluster)

W usłudze Azure Machine Learning Service wypróbuj:

gpu_cluster.get_status().serialize()

Uzyskiwanie odwołania do konta usługi Storage

Koncepcja magazynu danych, takiego jak obiekt blob, jest uproszczona w usłudze Azure Machine Learning przy użyciu obiektu DataStore. Domyślnie obszar roboczy usługi Azure Machine Learning service tworzy konto magazynu, ale możesz dołączyć własny magazyn również w ramach tworzenia obszaru roboczego.

W usłudze Batch AI wykonywano to w następujący sposób:

azure_blob_container_name = 'batchaisample'
blob_service = BlockBlobService(cfg.storage_account_name, cfg.storage_account_key)
blob_service.create_container(azure_blob_container_name, fail_on_exist=False)

W usłudze Azure Machine Learning Service wypróbuj:

ds = ws.get_default_datastore()
print(ds.datastore_type, ds.account_name, ds.container_name)

Dowiedz się więcej na temat rejestrowania dodatkowych kont magazynu lub uzyskiwania odwołania do innego zarejestrowanego magazynu danych w dokumentacji usługi Azure Machine Learning.

Pobieranie i przekazywanie danych

Przy użyciu którejkolwiek z tych usług możesz łatwo przekazać dane na konto magazynu za pomocą odwołania do magazynu danych przedstawionego powyżej. W przypadku Azure Batch sztucznej inteligencji wdrożymy również skrypt trenowania w ramach udziału plików, chociaż zobaczysz, jak można określić go jako część konfiguracji zadania w przypadku usługi Azure Machine Learning.

W usłudze Batch AI wykonywano to w następujący sposób:

mnist_dataset_directory = 'mnist_dataset'
utils.dataset.download_and_upload_mnist_dataset_to_blob(
    blob_service, azure_blob_container_name, mnist_dataset_directory)

script_directory = 'tensorflow_samples'
script_to_deploy = 'mnist_replica.py'

blob_service.create_blob_from_path(azure_blob_container_name,
                                   script_directory + '/' + script_to_deploy, 
                                   script_to_deploy)

W usłudze Azure Machine Learning Service wypróbuj:

import os
import urllib
os.makedirs('./data', exist_ok=True)
download_url = 'https://s3.amazonaws.com/img-datasets/mnist.npz'
urllib.request.urlretrieve(download_url, filename='data/mnist.npz')

ds.upload(src_dir='data', target_path='mnist_dataset', overwrite=True, show_progress=True)

path_on_datastore = ' mnist_dataset/mnist.npz' ds_data = ds.path(path_on_datastore) print(ds_data)

Tworzenie eksperymentów

Jak wspomniano powyżej, usługa Azure Machine Learning Service ma koncepcję eksperymentu podobnego do Azure Batch sztucznej inteligencji. Każdy eksperyment może mieć poszczególne przebiegi, podobnie jak w przypadku zadań w Azure Batch sztucznej inteligencji. Usługa Azure Machine Learning Service umożliwia również posiadanie hierarchii w ramach każdego uruchomienia nadrzędnego dla poszczególnych przebiegów podrzędnych.

W usłudze Batch AI wykonywano to w następujący sposób:

experiment_name = 'tensorflow_experiment'
experiment = client.experiments.create(cfg.resource_group, cfg.workspace, experiment_name).result()

W usłudze Azure Machine Learning Service wypróbuj:

from azureml.core import Experiment

experiment_name = 'tensorflow_experiment'
experiment = Experiment(ws, name=experiment_name)

Przesyłanie zadań

Po utworzeniu eksperymentu istnieje kilka różnych sposobów na przesłanie przebiegu. W tym przykładzie próbujemy utworzyć model uczenia głębokiego przy użyciu biblioteki TensorFlow i użyjemy narzędzia do szacowania usługi Azure Machine Learning, aby to zrobić. Narzędzie do szacowania to po prostu funkcja otoki dla podstawowej konfiguracji przebiegu, która ułatwia przesyłanie przebiegów i jest obecnie obsługiwana tylko dla bibliotek PyTorch i TensorFlow. Dzięki pojęciu magazynów danych zobaczysz również, jakie proste jest określanie ścieżek instalacji.

W usłudze Batch AI wykonywano to w następujący sposób:

azure_file_share = 'afs'
azure_blob = 'bfs'
args_fmt = '--job_name={0} --num_gpus=1 --train_steps 10000 --checkpoint_dir=$AZ_BATCHAI_OUTPUT_MODEL --log_dir=$AZ_BATCHAI_OUTPUT_TENSORBOARD --data_dir=$AZ_BATCHAI_INPUT_DATASET --ps_hosts=$AZ_BATCHAI_PS_HOSTS --worker_hosts=$AZ_BATCHAI_WORKER_HOSTS --task_index=$AZ_BATCHAI_TASK_INDEX'

parameters = models.JobCreateParameters(
     cluster=models.ResourceId(id=cluster.id),
     node_count=2,
     input_directories=[
        models.InputDirectory(
            id='SCRIPT',
            path='$AZ_BATCHAI_JOB_MOUNT_ROOT/{0}/{1}'.format(azure_blob, script_directory)),
        models.InputDirectory(
            id='DATASET',
            path='$AZ_BATCHAI_JOB_MOUNT_ROOT/{0}/{1}'.format(azure_blob, mnist_dataset_directory))],
     std_out_err_path_prefix='$AZ_BATCHAI_JOB_MOUNT_ROOT/{0}'.format(azure_file_share),
     output_directories=[
        models.OutputDirectory(
            id='MODEL',
            path_prefix='$AZ_BATCHAI_JOB_MOUNT_ROOT/{0}'.format(azure_file_share),
            path_suffix='Models'),
        models.OutputDirectory(
            id='TENSORBOARD',
            path_prefix='$AZ_BATCHAI_JOB_MOUNT_ROOT/{0}'.format(azure_file_share),
            path_suffix='Logs')
     ],
     mount_volumes=models.MountVolumes(
            azure_file_shares=[
                models.AzureFileShareReference(
                    account_name=cfg.storage_account_name,
                    credentials=models.AzureStorageCredentialsInfo(
                        account_key=cfg.storage_account_key),
                    azure_file_url='https://{0}.file.core.windows.net/{1}'.format(
                        cfg.storage_account_name, azure_file_share_name),
                    relative_mount_path=azure_file_share)
            ],
            azure_blob_file_systems=[
                models.AzureBlobFileSystemReference(
                    account_name=cfg.storage_account_name,
                    credentials=models.AzureStorageCredentialsInfo(
                        account_key=cfg.storage_account_key),
                    container_name=azure_blob_container_name,
                    relative_mount_path=azure_blob)
            ]
        ),
     container_settings=models.ContainerSettings(
         image_source_registry=models.ImageSourceRegistry(image='tensorflow/tensorflow:1.8.0-gpu')),
     tensor_flow_settings=models.TensorFlowSettings(
         parameter_server_count=1,
         worker_count=nodes_count,
         python_script_file_path='$AZ_BATCHAI_INPUT_SCRIPT/'+ script_to_deploy,
         master_command_line_args=args_fmt.format('worker'),
         worker_command_line_args=args_fmt.format('worker'),
         parameter_server_command_line_args=args_fmt.format('ps'),
     )
)

Przesyłanie samego zadania w usłudze Azure Batch sztucznej inteligencji odbywa się za pomocą funkcji create.

job_name = datetime.utcnow().strftime('tf_%m_%d_%Y_%H%M%S')
job = client.jobs.create(cfg.resource_group, cfg.workspace, experiment_name, job_name, parameters).result()
print('Created Job {0} in Experiment {1}'.format(job.name, experiment.name))

Pełne informacje o tym fragmencie kodu trenowania (w tym pliku mnist_replica.py przekazanym do udziału plików powyżej) można znaleźć w repozytorium github przykładowym notesu sztucznej inteligencji Azure Batch.

W usłudze Azure Machine Learning Service wypróbuj:

from azureml.train.dnn import TensorFlow

script_params={
    '--num_gpus': 1,
    '--train_steps': 500,
    '--input_data': ds_data.as_mount()

}

estimator = TensorFlow(source_directory=project_folder,
                       compute_target=gpu_cluster,
                       script_params=script_params,
                       entry_script='tf_mnist_replica.py',
                       node_count=2,
                       worker_count=2,
                       parameter_server_count=1,   
                       distributed_backend='ps',
                       use_gpu=True)

Pełne informacje o tym fragmencie kodu trenowania (w tym pliku tf_mnist_replica.py) można znaleźć w repozytorium github przykładowego notesu usługi Azure Machine Learning Service. Sam magazyn danych można instalować na pojedynczych węzłach lub dane treningowe można pobrać w samym węźle. Więcej informacji na temat odwoływania się do magazynu danych w narzędziu do szacowania znajduje się w dokumentacji usługi Azure Machine Learning Service.

Przesyłanie przebiegu w usłudze Azure Machine Learning service odbywa się za pośrednictwem funkcji submit.

run = experiment.submit(estimator)
print(run)

Innym sposobem na określanie parametrów przebiegu jest użycie konfiguracji przebiegu — szczególnie przydatnej podczas definiowania niestandardowego środowiska treningowego. Więcej szczegółów można znaleźć w tym przykładowym notesie AmlCompute.

Monitorowanie przebiegów

Po przesłaniu przebiegu możesz poczekać na ukończenie lub monitorować go w usłudze Azure Machine Learning przy użyciu schludnych widżetów Jupyter, które można wywołać bezpośrednio z poziomu kodu. Można również uzyskać kontekst dowolnego poprzedniego przebiegu, wykonując pętlę względem różnych eksperymentów w obszarze roboczym i pojedynczych przebiegów w ramach każdego eksperymentu.

W usłudze Batch AI wykonywano to w następujący sposób:

utils.job.wait_for_job_completion(client, cfg.resource_group, cfg.workspace, 
                                  experiment_name, job_name, cluster_name, 'stdouterr', 'stdout-wk-0.txt')

files = client.jobs.list_output_files(cfg.resource_group, cfg.workspace, experiment_name, job_name,
                                      models.JobsListOutputFilesOptions(outputdirectoryid='stdouterr')) 
for f in list(files):
    print(f.name, f.download_url or 'directory')

W usłudze Azure Machine Learning Service wypróbuj:

run.wait_for_completion(show_output=True)

from azureml.widgets import RunDetails
RunDetails(run).show()

Oto migawka sposobu ładowania widżetu w notesie do przeglądania dzienników w czasie rzeczywistym: diagram monitorowania widżetu

Edytowanie klastrów

Usuwanie klastra jest bardzo proste. Ponadto usługa Azure Machine Learning Service umożliwia również aktualizowanie klastra z poziomu notesu w przypadku skalowania go do większej liczby węzłów lub zwiększenia czasu oczekiwania bezczynności przed skalowaniem klastra w dół. Nie można zmienić rozmiaru maszyny wirtualnej samego klastra, ponieważ wymaga to nowego, efektywnego wdrożenia w zapleczu.

W usłudze Batch AI wykonywano to w następujący sposób:

_ = client.clusters.delete(cfg.resource_group, cfg.workspace, cluster_name)

W usłudze Azure Machine Learning Service wypróbuj:

gpu_cluster.delete()

gpu_cluster.update(min_nodes=2, max_nodes=4, idle_seconds_before_scaledown=600)

Uzyskiwanie pomocy technicznej

Usługa Batch AI ma zostać wycofana 31 marca i już blokuje rejestrację nowych subskrypcji w usłudze, chyba że jest ona dozwolona, zgłaszając wyjątek za pośrednictwem pomocy technicznej. Jeśli masz jakiekolwiek pytania lub chcesz przesłać opinię na temat migracji do usługi Azure Machine Learning Service, wyślij wiadomość na adres Azure Batch AI Training Preview.

Usługa Azure Machine Learning jest usługą ogólnie dostępną. Oznacza to, że towarzyszy jej zatwierdzona umowa SLA i różne plany pomocy technicznej do wyboru.

Ceny korzystania z infrastruktury platformy Azure za pośrednictwem usługi Azure Batch sztucznej inteligencji lub usługi Azure Machine Learning service nie powinny się różnić, ponieważ opłaty są naliczane tylko za bazowe obliczenia w obu przypadkach. Aby uzyskać więcej informacji, zobacz kalkulator cen.

Wyświetl dostępność regionalną obu usług w witrynie Azure Portal.

Następne kroki