Samouczek: trenowanie modelu wykrywania obiektów (wersja zapoznawcza) przy użyciu języka 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 platformy Azure 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 kan, karton, butelka mleka lub butelka wody.

Zautomatyzowane uczenie maszynowe akceptuje dane treningowe i ustawienia konfiguracji i automatycznie wykonuje iterację za pomocą kombinacji różnych metod normalizacji/standaryzacji cech, 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 dzisiaj.

• W przypadku tej funkcji obsługiwane są języki Python 3.7 lub 3.8

• 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 danychodFridgeObjects.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żywać tych danych, należy najpierw przekonwertować go na wymagany format JSONL, jak pokazano w sekcji Konwertowanie pobranych danych na 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 docelowa zasobów obliczeniowych

Najpierw należy skonfigurować docelowy obiekt obliczeniowy do użycia na potrzeby zautomatyzowanego trenowania modelu uczenia maszynowego. Zautomatyzowane modele uczenia maszynowego na potrzeby 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 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 wejściowych obrazu w formacie JSONL (JSON Lines) można wizualizować pola granic prawdy podstawowej dla obrazu. Aby to zrobić, 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żywać danych do trenowania, przekaż je do obszaru roboczego za pośrednictwem magazynu danych. Magazyn danych zapewnia mechanizm przekazywania lub pobierania danych oraz interakcji z nimi z zdalnych celów obliczeniowych.

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 do trenowania. Ponieważ nie określono zestawu danych sprawdzania poprawności, domyślnie do weryfikacji jest używane 20% danych treningowych.

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żesz również wizualizować pola granic prawdy podstawowej 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 przebiegi 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 na zdefiniowanej przestrzeni parametrów w celu znalezienia optymalnego modelu.

W tym przykładzie używamy AutoMLImageConfig elementu do trenowania modelu wykrywania obiektów z elementami yolov5 i fasterrcnn_resnet50_fpn, z których oba są wstępnie wytrenowane w środowisku COCO, wykrywania obiektów na dużą skalę, segmentacji i zestawu danych podpisów zawierającego ponad tysiące oznaczonych obrazów z ponad 80 kategoriami etykiet.

Hiperparametr zamiatanie pod kątem zadań obrazów

Aby znaleźć optymalny model, możesz wykonać zamiatanie hiperparametrów na zdefiniowanej przestrzeni parametrów.

Poniższy kod definiuje przestrzeń parametrów w przygotowaniu do zamiatania hiperparametrów dla każdego zdefiniowanego algorytmu yolov5 i fasterrcnn_resnet50_fpn. W obszarze parametrów określ zakres wartości , , lr_scheduleritp. dla optimizerlearning_raterozwiązania AutoML do wyboru podczas próby wygenerowania modelu przy użyciu optymalnej metryki podstawowej. Jeśli nie określono wartości hiperparametrów, 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 tego obszaru parametrów, importując GridParameterSampling, RandomParameterSampling klasy i BayesianParameterSampling . Dzięki temu zautomatyzowane uczenie maszynowe spróbuje wykonać łącznie 20 iteracji z tymi różnymi przykładami, uruchamiając cztery iteracji w czasie w naszym docelowym obiekcie obliczeniowym, który został skonfigurowany przy użyciu czterech węzłów. Tym więcej parametrów ma przestrzeń, tym więcej iteracji trzeba znaleźć optymalne modele.

Stosowane są również zasady wczesnego zakończenia bandyty. Te zasady kończą konfiguracje o niskiej wydajności; oznacza to, że te konfiguracje, które nie są w 20% slack najlepszej wydajności 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 w celu wytrenowania modelu 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 powyższego, co jest uruchomieniem nadrzędnym funkcji HyperDrive. Następnie możesz przejść do karty "Przebiegi podrzędne" tego elementu. Alternatywnie poniżej widać bezpośrednio uruchomienie nadrzędne funkcji HyperDrive i przejście 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 z procesorem 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żna 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ługa sieci Web, aby przewidzieć nowe obrazy. Na potrzeby tego samouczka 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

Po zdobyciu wyniku obrazu testowego możesz zwizualizować pola ograniczenia dla tego obrazu. W tym celu upewnij się, że zainstalowano 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 wykonywać 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 pozycję 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
• Wykonano zamiatanie 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-", aby uzyskać przykłady specyficzne dla tworzenia modeli przetwarzania obrazów.

Uwaga

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