Samouczek: trenowanie modelu wykrywania obiektów (wersja zapoznawcza) przy użyciu rozwiązania AutoML i języka Python (wersja 1)

DOTYCZY: Zestaw SDK języka Python w wersji 1

Ważne

Funkcje przedstawione w tym artykule są dostępne w wersji zapoznawczej. Należy je traktować jako eksperymentalne funkcje w wersji zapoznawczej, które mogą ulec zmianie w dowolnym momencie.

Z tego samouczka dowiesz się, jak wytrenować model wykrywania obiektów przy użyciu zautomatyzowanego uczenia maszynowego usługi Azure Machine Learning przy użyciu zestawu SDK języka Python usługi Azure Machine Learning. Ten model wykrywania obiektów określa, czy obraz zawiera obiekty, takie jak can, karton, butelka mleka lub butelka wody.

Zautomatyzowane uczenie maszynowe akceptuje dane treningowe i ustawienia konfiguracji i automatycznie iteruje za pomocą kombinacji różnych metod normalizacji/standaryzacji funkcji, modeli i ustawień hiperparametrów, aby uzyskać najlepszy model.

W tym samouczku napiszesz kod przy użyciu zestawu SDK języka Python i poznasz następujące zadania:

• Pobieranie i przekształcanie danych
• Trenowanie modelu wykrywania obiektów zautomatyzowanego uczenia maszynowego
• Określanie wartości hiperparametrów dla modelu
• Wykonywanie zamiatania hiperparametrów
• Wdrażanie modelu
• Wizualizowanie wykrywania

Wymagania wstępne

• Jeśli nie masz subskrypcji platformy Azure, przed rozpoczęciem utwórz bezpłatne konto. Wypróbuj bezpłatną lub płatną wersję usługi Azure Machine Learning już dziś.

• Obsługa języka Python w wersji 3.7 lub 3.8 dla tej funkcji

• Ukończ przewodnik Szybki start: rozpoczynanie pracy z usługą Azure Machine Learning, jeśli nie masz jeszcze obszaru roboczego usługi Azure Machine Learning.

• Pobierz i rozpakuj plik danych odFridgeObjects.zip.* Zestaw danych jest oznaczony adnotacją w formacie Pascal VOC, gdzie każdy obraz odpowiada plikowi XML. Każdy plik XML zawiera informacje o tym, gdzie znajduje się odpowiedni plik obrazu, a także zawiera informacje o polach ograniczenia i etykietach obiektów. Aby użyć tych danych, należy najpierw przekonwertować je na wymagany format JSONL, jak pokazano w sekcji Konwertowanie pobranych danych na format JSONL notesu.

Ten samouczek jest również dostępny w repozytorium azureml-examples w witrynie GitHub , jeśli chcesz uruchomić go we własnym środowisku lokalnym. Aby uzyskać wymagane pakiety,

• Uruchom polecenie pip install azureml
• Instalowanie pełnego automl klienta

Konfiguracja docelowego obiektu obliczeniowego

Najpierw należy skonfigurować docelowy obiekt obliczeniowy do użycia na potrzeby zautomatyzowanego trenowania modelu uczenia maszynowego. Zautomatyzowane modele uczenia maszynowego dla zadań obrazów wymagają jednostek SKU procesora GPU.

W tym samouczku użyto serii NCsv3 (z procesorami GPU V100), ponieważ ten typ celu obliczeniowego wykorzystuje wiele procesorów GPU w celu przyspieszenia trenowania. Ponadto można skonfigurować wiele węzłów, aby korzystać z równoległości podczas dostrajania hiperparametrów dla modelu.

Poniższy kod tworzy obliczenia procesora GPU o rozmiarze Standard _NC24s_v3 z czterema węzłami dołączonymi do obszaru roboczego ws.

Ostrzeżenie

Upewnij się, że twoja subskrypcja ma wystarczający limit przydziału dla docelowego obiektu obliczeniowego, którego chcesz użyć.

from azureml.core.compute import AmlCompute, ComputeTarget

cluster_name = "gpu-nc24sv3"

try:
    compute_target = ComputeTarget(workspace=ws, name=cluster_name)
    print('Found existing compute target.')
except KeyError:
    print('Creating a new compute target...')
    compute_config = AmlCompute.provisioning_configuration(vm_size='Standard_NC24s_v3',
                                                           idle_seconds_before_scaledown=1800,
                                                           min_nodes=0,
                                                           max_nodes=4)

    compute_target = ComputeTarget.create(ws, cluster_name, compute_config)

#If no min_node_count is provided, the scale settings are used for the cluster.
compute_target.wait_for_completion(show_output=True, min_node_count=None, timeout_in_minutes=20)

Konfiguracja eksperymentu

Następnie utwórz element Experiment w obszarze roboczym, aby śledzić przebiegi trenowania modelu.

from azureml.core import Experiment

experiment_name = 'automl-image-object-detection'
experiment = Experiment(ws, name=experiment_name)

Wizualizowanie danych wejściowych

Po przygotowaniu danych obrazu wejściowego w formacie JSONL (JSON Lines) można zwizualizować pola ograniczenia podstawy prawdy dla obrazu. W tym celu upewnij się, że zainstalowano matplotlib .

%pip install --upgrade matplotlib

%matplotlib inline
import matplotlib.pyplot as plt
import matplotlib.image as mpimg
import matplotlib.patches as patches
from PIL import Image as pil_image
import numpy as np
import json
import os

def plot_ground_truth_boxes(image_file, ground_truth_boxes):
    # Display the image
    plt.figure()
    img_np = mpimg.imread(image_file)
    img = pil_image.fromarray(img_np.astype("uint8"), "RGB")
    img_w, img_h = img.size

    fig,ax = plt.subplots(figsize=(12, 16))
    ax.imshow(img_np)
    ax.axis("off")

    label_to_color_mapping = {}

    for gt in ground_truth_boxes:
        label = gt["label"]

        xmin, ymin, xmax, ymax =  gt["topX"], gt["topY"], gt["bottomX"], gt["bottomY"]
        topleft_x, topleft_y = img_w * xmin, img_h * ymin
        width, height = img_w * (xmax - xmin), img_h * (ymax - ymin)

        if label in label_to_color_mapping:
            color = label_to_color_mapping[label]
        else:
            # Generate a random color. If you want to use a specific color, you can use something like "red".
            color = np.random.rand(3)
            label_to_color_mapping[label] = color

        # Display bounding box
        rect = patches.Rectangle((topleft_x, topleft_y), width, height,
                                 linewidth=2, edgecolor=color, facecolor="none")
        ax.add_patch(rect)

        # Display label
        ax.text(topleft_x, topleft_y - 10, label, color=color, fontsize=20)

    plt.show()

def plot_ground_truth_boxes_jsonl(image_file, jsonl_file):
    image_base_name = os.path.basename(image_file)
    ground_truth_data_found = False
    with open(jsonl_file) as fp:
        for line in fp.readlines():
            line_json = json.loads(line)
            filename = line_json["image_url"]
            if image_base_name in filename:
                ground_truth_data_found = True
                plot_ground_truth_boxes(image_file, line_json["label"])
                break
    if not ground_truth_data_found:
        print("Unable to find ground truth information for image: {}".format(image_file))

def plot_ground_truth_boxes_dataset(image_file, dataset_pd):
    image_base_name = os.path.basename(image_file)
    image_pd = dataset_pd[dataset_pd['portable_path'].str.contains(image_base_name)]
    if not image_pd.empty:
        ground_truth_boxes = image_pd.iloc[0]["label"]
        plot_ground_truth_boxes(image_file, ground_truth_boxes)
    else:
        print("Unable to find ground truth information for image: {}".format(image_file))

Korzystając z powyższych funkcji pomocnika, dla dowolnego obrazu, można uruchomić następujący kod, aby wyświetlić pola ograniczenia.

image_file = "./odFridgeObjects/images/31.jpg"
jsonl_file = "./odFridgeObjects/train_annotations.jsonl"

plot_ground_truth_boxes_jsonl(image_file, jsonl_file)

Przekazywanie danych i tworzenie zestawu danych

Aby użyć danych do trenowania, przekaż je do obszaru roboczego za pośrednictwem magazynu danych. Magazyn danych udostępnia mechanizm przekazywania lub pobierania danych oraz interakcji z nimi ze zdalnymi obiektami docelowymi obliczeniowymi.

ds = ws.get_default_datastore()
ds.upload(src_dir='./odFridgeObjects', target_path='odFridgeObjects')

Po przekazaniu do magazynu danych możesz utworzyć zestaw danych usługi Azure Machine Learning na podstawie danych. Zestawy danych pakują dane do obiektu eksploatacyjnego na potrzeby trenowania.

Poniższy kod tworzy zestaw danych na potrzeby trenowania. Ponieważ nie określono zestawu danych sprawdzania poprawności, domyślnie 20% danych szkoleniowych jest używany do walidacji.

from azureml.core import Dataset
from azureml.data import DataType

training_dataset_name = 'odFridgeObjectsTrainingDataset'
if training_dataset_name in ws.datasets:
    training_dataset = ws.datasets.get(training_dataset_name)
    print('Found the training dataset', training_dataset_name)
else:
    # create training dataset
        # create training dataset
    training_dataset = Dataset.Tabular.from_json_lines_files(
        path=ds.path('odFridgeObjects/train_annotations.jsonl'),
        set_column_types={"image_url": DataType.to_stream(ds.workspace)},
    )
    training_dataset = training_dataset.register(workspace=ws, name=training_dataset_name)

print("Training dataset name: " + training_dataset.name)

Wizualizowanie zestawu danych

Można również wizualizować pola ograniczenia podstawy prawdy dla obrazu z tego zestawu danych.

Załaduj zestaw danych do ramki danych biblioteki pandas.

import azureml.dataprep as dprep

from azureml.dataprep.api.functions import get_portable_path

# Get pandas dataframe from the dataset
dflow = training_dataset._dataflow.add_column(get_portable_path(dprep.col("image_url")),
                                              "portable_path", "image_url")
dataset_pd = dflow.to_pandas_dataframe(extended_types=True)

Dla dowolnego obrazu można uruchomić następujący kod, aby wyświetlić pola ograniczenia.

image_file = "./odFridgeObjects/images/31.jpg"
plot_ground_truth_boxes_dataset(image_file, dataset_pd)

Konfigurowanie eksperymentu wykrywania obiektów

Aby skonfigurować zautomatyzowane uruchomienia uczenia maszynowego dla zadań związanych z obrazem, użyj AutoMLImageConfig obiektu . W systemie AutoMLImageConfigmożna określić algorytmy modelu za pomocą parametru model_name i skonfigurować ustawienia w celu przeprowadzenia zamiatania hiperparametrów przez zdefiniowaną przestrzeń parametrów w celu znalezienia optymalnego modelu.

W tym przykładzie używamy klasy , AutoMLImageConfig aby wytrenować model wykrywania obiektów za pomocą yolov5 elementów i fasterrcnn_resnet50_fpn, z których oba są wstępnie wytrenowane na platformie COCO, czyli zestaw danych wykrywania obiektów na dużą skalę, segmentacji i podpisów zawierający ponad tysiące oznaczonych obrazów z ponad 80 kategoriami etykiet.

Zamiatanie hiperparametrów dla zadań obrazu

Aby znaleźć optymalny model, można wykonać zamiatanie hiperparametrów przez zdefiniowaną przestrzeń parametrów.

Poniższy kod definiuje przestrzeń parametrów w ramach przygotowań do zamiatania hiperparametrów dla każdego zdefiniowanego algorytmu yolov5 i fasterrcnn_resnet50_fpn. W obszarze parametrów określ zakres wartości dla learning_rate, optimizerlr_scheduler, itp. dla rozwiązania AutoML do wyboru podczas próby wygenerowania modelu z optymalną metryką podstawową. Jeśli wartości hiperparametryczne nie są określone, wartości domyślne są używane dla każdego algorytmu.

W przypadku ustawień dostrajania użyj losowego próbkowania, aby wybrać próbki z tej przestrzeni parametrów, importując GridParameterSampling, RandomParameterSampling klasy i BayesianParameterSampling . W ten sposób program informuje zautomatyzowane uczenie maszynowe o wypróbowaniu łącznie 20 iteracji z tymi różnymi przykładami, uruchamiając cztery iteracji w czasie na naszym docelowym obiekcie obliczeniowym, który został skonfigurowany przy użyciu czterech węzłów. Tym więcej parametrów ma miejsce, tym więcej iteracji trzeba znaleźć optymalne modele.

Używane są również zasady wczesnego zakończenia działania bandytu. Te zasady kończą konfiguracje o niskiej wydajności; oznacza to, że te konfiguracje, które nie znajdują się w ramach 20% slack najlepszej konfiguracji, co znacznie oszczędza zasoby obliczeniowe.

from azureml.train.hyperdrive import RandomParameterSampling
from azureml.train.hyperdrive import BanditPolicy, HyperDriveConfig
from azureml.train.hyperdrive import choice, uniform

parameter_space = {
    'model': choice(
        {
            'model_name': choice('yolov5'),
            'learning_rate': uniform(0.0001, 0.01),
            #'model_size': choice('small', 'medium'), # model-specific
            'img_size': choice(640, 704, 768), # model-specific
        },
        {
            'model_name': choice('fasterrcnn_resnet50_fpn'),
            'learning_rate': uniform(0.0001, 0.001),
            #'warmup_cosine_lr_warmup_epochs': choice(0, 3),
            'optimizer': choice('sgd', 'adam', 'adamw'),
            'min_size': choice(600, 800), # model-specific
        }
    )
}

tuning_settings = {
    'iterations': 20,
    'max_concurrent_iterations': 4,
    'hyperparameter_sampling': RandomParameterSampling(parameter_space),
    'policy': BanditPolicy(evaluation_interval=2, slack_factor=0.2, delay_evaluation=6)
}

Po zdefiniowaniu obszaru parametrów i ustawień dostrajania można przekazać je do AutoMLImageConfig obiektu, a następnie przesłać eksperyment, aby wytrenować model obrazu przy użyciu zestawu danych trenowania.

from azureml.train.automl import AutoMLImageConfig
automl_image_config = AutoMLImageConfig(task='image-object-detection',
                                        compute_target=compute_target,
                                        training_data=training_dataset,
                                        validation_data=validation_dataset,
                                        primary_metric='mean_average_precision',
                                        **tuning_settings)

automl_image_run = experiment.submit(automl_image_config)
automl_image_run.wait_for_completion(wait_post_processing=True)

Podczas wykonywania zamiatania hiperparametrów może być przydatne wizualizowanie różnych konfiguracji, które zostały wypróbowane przy użyciu interfejsu użytkownika funkcji HyperDrive. Możesz przejść do tego interfejsu użytkownika, przechodząc do karty "Przebiegi podrzędne" w interfejsie użytkownika głównego automl_image_run z góry, czyli do uruchomienia nadrzędnego funkcji HyperDrive. Następnie możesz przejść do karty "Przebiegi podrzędne" tego. Możesz też zobaczyć bezpośrednio uruchomienie nadrzędne funkcji HyperDrive i przejść do karty "Przebiegi podrzędne":

from azureml.core import Run
hyperdrive_run = Run(experiment=experiment, run_id=automl_image_run.id + '_HD')
hyperdrive_run

Rejestrowanie najlepszego modelu

Po zakończeniu przebiegu możemy zarejestrować model utworzony na podstawie najlepszego przebiegu.

best_child_run = automl_image_run.get_best_child()
model_name = best_child_run.properties['model_name']
model = best_child_run.register_model(model_name = model_name, model_path='outputs/model.pt')

Wdrażanie modelu jako usługi internetowej

Po wytrenowanym modelu możesz wdrożyć model na platformie Azure. Wytrenowany model można wdrożyć jako usługę internetową w usłudze Azure Container Instances (ACI) lub Azure Kubernetes Service (AKS). Usługa ACI to idealna opcja testowania wdrożeń, a usługa AKS jest lepiej odpowiednia do użycia w środowisku produkcyjnym na dużą skalę.

W tym samouczku wdrożymy model jako usługę internetową w usłudze AKS.

1. Utwórz klaster obliczeniowy usługi AKS. W tym przykładzie jednostka SKU maszyny wirtualnej procesora GPU jest używana dla klastra wdrażania

   from azureml.core.compute import ComputeTarget, AksCompute
   from azureml.exceptions import ComputeTargetException
   
   # Choose a name for your cluster
   aks_name = "cluster-aks-gpu"
   
   # Check to see if the cluster already exists
   try:
       aks_target = ComputeTarget(workspace=ws, name=aks_name)
       print('Found existing compute target')
   except ComputeTargetException:
       print('Creating a new compute target...')
       # Provision AKS cluster with GPU machine
       prov_config = AksCompute.provisioning_configuration(vm_size="STANDARD_NC6",
                                                           location="eastus2")
       # Create the cluster
       aks_target = ComputeTarget.create(workspace=ws,
                                         name=aks_name,
                                         provisioning_configuration=prov_config)
       aks_target.wait_for_completion(show_output=True)
   

2. Zdefiniuj konfigurację wnioskowania, która opisuje sposób konfigurowania usługi internetowej zawierającej model. Możesz użyć skryptu oceniania i środowiska z przebiegu trenowania w konfiguracji wnioskowania.

   Uwaga

   Aby zmienić ustawienia modelu, otwórz pobrany skrypt oceniania i zmodyfikuj zmienną model_settings przed wdrożeniem modelu.

   from azureml.core.model import InferenceConfig
   
   best_child_run.download_file('outputs/scoring_file_v_1_0_0.py', output_file_path='score.py')
   environment = best_child_run.get_environment()
   inference_config = InferenceConfig(entry_script='score.py', environment=environment)
   

3. Następnie możesz wdrożyć model jako usługę internetową usługi AKS.

   
   from azureml.core.webservice import AksWebservice
   from azureml.core.webservice import Webservice
   from azureml.core.model import Model
   from azureml.core.environment import Environment
   
   aks_config = AksWebservice.deploy_configuration(autoscale_enabled=True,
                                                   cpu_cores=1,
                                                   memory_gb=50,
                                                   enable_app_insights=True)
   
   aks_service = Model.deploy(ws,
                              models=[model],
                              inference_config=inference_config,
                              deployment_config=aks_config,
                              deployment_target=aks_target,
                              name='automl-image-test',
                              overwrite=True)
   aks_service.wait_for_deployment(show_output=True)
   print(aks_service.state)
   

Testowanie usługi internetowej

Możesz przetestować wdrożona usługę internetową, aby przewidzieć nowe obrazy. W tym samouczku przekaż losowy obraz z zestawu danych i przekaż go do identyfikatora URI oceniania.

import requests

# URL for the web service
scoring_uri = aks_service.scoring_uri

# If the service is authenticated, set the key or token
key, _ = aks_service.get_keys()

sample_image = './test_image.jpg'

# Load image data
data = open(sample_image, 'rb').read()

# Set the content type
headers = {'Content-Type': 'application/octet-stream'}

# If authentication is enabled, set the authorization header
headers['Authorization'] = f'Bearer {key}'

# Make the request and display the response
resp = requests.post(scoring_uri, data, headers=headers)
print(resp.text)

Wizualizowanie wykrywania

Teraz, po badaniu obrazu, możesz zwizualizować pola ograniczenia dla tego obrazu. W tym celu upewnij się, że masz zainstalowaną bibliotekę matplotlib.

%pip install --upgrade matplotlib

%matplotlib inline
import matplotlib.pyplot as plt
import matplotlib.image as mpimg
import matplotlib.patches as patches
from PIL import Image
import numpy as np
import json

IMAGE_SIZE = (18,12)
plt.figure(figsize=IMAGE_SIZE)
img_np=mpimg.imread(sample_image)
img = Image.fromarray(img_np.astype('uint8'),'RGB')
x, y = img.size

fig,ax = plt.subplots(1, figsize=(15,15))
# Display the image
ax.imshow(img_np)

# draw box and label for each detection
detections = json.loads(resp.text)
for detect in detections['boxes']:
    label = detect['label']
    box = detect['box']
    conf_score = detect['score']
    if conf_score > 0.6:
        ymin, xmin, ymax, xmax =  box['topY'],box['topX'], box['bottomY'],box['bottomX']
        topleft_x, topleft_y = x * xmin, y * ymin
        width, height = x * (xmax - xmin), y * (ymax - ymin)
        print('{}: [{}, {}, {}, {}], {}'.format(detect['label'], round(topleft_x, 3),
                                                round(topleft_y, 3), round(width, 3),
                                                round(height, 3), round(conf_score, 3)))

        color = np.random.rand(3) #'red'
        rect = patches.Rectangle((topleft_x, topleft_y), width, height,
                                 linewidth=3, edgecolor=color,facecolor='none')

        ax.add_patch(rect)
        plt.text(topleft_x, topleft_y - 10, label, color=color, fontsize=20)

plt.show()

Czyszczenie zasobów

Nie należy ukończyć tej sekcji, jeśli planujesz uruchamianie innych samouczków usługi Azure Machine Learning.

Jeśli nie planujesz korzystać z utworzonych zasobów, usuń je, aby nie ponosić żadnych opłat.

1. W witrynie Azure Portal na końcu z lewej strony wybierz pozycję Grupy zasobów.
2. Wybierz utworzoną grupę zasobów z listy.
3. Wybierz pozycję Usuń grupę zasobów.
4. Wpisz nazwę grupy zasobów. Następnie wybierz Usuń.

Możesz też zachować grupę zasobów i usunąć jeden obszar roboczy. Wyświetl właściwości obszaru roboczego i wybierz pozycję Usuń.

Następne kroki

W tym samouczku zautomatyzowanego uczenia maszynowego wykonano następujące czynności:

• Skonfigurowano obszar roboczy i przygotowano dane do eksperymentu.
• Trenowanie modelu automatycznego wykrywania obiektów
• Określone wartości hiperparametrów dla modelu
• Wykonywanie zamiatania hiperparametrów
• Wdrożono model
• Zwizualizowane wykrycia

• Dowiedz się więcej o przetwarzaniu obrazów w zautomatyzowanym uczeniu maszynowym.
• Dowiedz się, jak skonfigurować rozwiązanie AutoML do trenowania modeli przetwarzania obrazów przy użyciu języka Python.
• Dowiedz się, jak skonfigurować trenowanie przyrostowe na modelach przetwarzania obrazów.
• Zobacz , jakie hiperparametry są dostępne dla zadań przetwarzania obrazów.
• Przejrzyj szczegółowe przykłady kodu i przypadki użycia w repozytorium notesów GitHub, aby zapoznać się z przykładami zautomatyzowanego uczenia maszynowego. Sprawdź foldery z prefiksem "image-" dla przykładów specyficznych dla tworzenia modeli przetwarzania obrazów.

Uwaga

Korzystanie z zestawu danych obiektów lodówki jest dostępne za pośrednictwem licencji licencji MIT.