Oktatóanyag: Objektumészlelési modell betanítása (előzetes verzió) az AutoML és a Python használatával (v1)

  • Cikk

A KÖVETKEZŐKRE VONATKOZIK:Python SDK azureml v1

Fontos

A cikkben bemutatott funkciók előzetes verzióban érhetők el. Ezeket kísérleti előzetes verziójú funkcióknak kell tekinteni, amelyek bármikor változhatnak.

Ebből az oktatóanyagból megtudhatja, hogyan taníthat be objektumészlelési modellt az Azure Machine Learning automatizált gépi tanulással az Azure Machine Learning Python SDK-val. Ez az objektumészlelési modell azonosítja, hogy a kép tartalmaz-e objektumokat, például dobozt, dobozt, tejes palackot vagy vízpalackot.

Az automatizált gépi tanulás elfogadja a betanítási adatokat és a konfigurációs beállításokat, és automatikusan iterálja a különböző funkció normalizálási/szabványosítási módszerek, modellek és hiperparaméter-beállítások kombinációit a legjobb modell eléréséhez.

Ebben az oktatóanyagban a Python SDK használatával fog kódot írni, és a következő feladatokat fogja megtanulni:

  • Adatok letöltése és átalakítása
  • Automatizált gépi tanulási objektumészlelési modell betanítása
  • Hiperparaméter-értékek megadása a modellhez
  • Hiperparaméter-takarítás végrehajtása
  • A modell üzembe helyezése
  • Észlelések vizualizációja

Előfeltételek

Ez az oktatóanyag a GitHub azureml-examples adattárában is elérhető, ha saját helyi környezetben szeretné futtatni. A szükséges csomagok beszerzéséhez

Számítási cél beállítása

Először be kell állítania egy számítási célt az automatizált gépi tanulási modell betanításához. A rendszerkép-feladatok automatizált gépi tanulási modelljei GPU-termékváltozatokat igényelnek.

Ez az oktatóanyag az NCsv3 sorozatot használja (V100 GPU-kkal), mivel az ilyen típusú számítási cél több GPU-t használ a betanítás felgyorsításához. Emellett több csomópontot is beállíthat, hogy kihasználhassa a párhuzamosságot a hiperparaméterek modellhez való hangolása során.

Az alábbi kód egy Standard _NC24s_v3 méretű GPU-számítást hoz létre, amely a munkaterülethez csatolt négy csomópontot tartalmazza( ws).

Figyelmeztetés

Győződjön meg arról, hogy az előfizetés elegendő kvótával rendelkezik a használni kívánt számítási célhoz.

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)

Kísérlet beállítása

Ezután hozzon létre egy újat Experiment a munkaterületen a modell betanítási futásának nyomon követéséhez.


from azureml.core import Experiment

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

Bemeneti adatok vizualizációja

Miután elkészítette a bemeneti képadatokat JSONL (JSON Lines) formátumban, megjelenítheti a kép alapigazság-határoló mezőinek megjelenítését. Ehhez győződjön meg arról, hogy telepítve van 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))

A fenti segédfüggvények használatával bármely képhez futtathatja az alábbi kódot a határolókeretek megjelenítéséhez.

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

plot_ground_truth_boxes_jsonl(image_file, jsonl_file)

Adatok feltöltése és adathalmaz létrehozása

Az adatok betanításhoz való használatához töltse fel a munkaterületre egy adattáron keresztül. Az adattár olyan mechanizmust biztosít, amellyel adatokat tölthet fel vagy tölthet le, és kezelheti azokat a távoli számítási célokból.

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

Miután feltöltötte az adattárba, létrehozhat egy Azure Machine Learning-adatkészletet az adatokból. Az adathalmazok betanítás céljából egy hasznosítható objektumba csomagolják az adatokat.

Az alábbi kód létrehoz egy adatkészletet a betanításhoz. Mivel nincs megadva érvényesítési adatkészlet, alapértelmezés szerint a betanítási adatok 20%-a lesz érvényesítésre használva.

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)

Adathalmaz vizualizációja

Az adathalmazból származó kép alapigazság-határoló mezőit is megjelenítheti.

Töltse be az adathalmazt egy pandas-adatkeretbe.

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)

A határolókeretek megjelenítéséhez futtassa az alábbi kódot egy adott képhez.

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

Az objektumészlelési kísérlet konfigurálása

Az automatikus gépi tanulási futtatások képpel kapcsolatos feladatokhoz való konfigurálásához használja az AutoMLImageConfig objektumot. AutoMLImageConfigA -ben megadhatja a paraméterrel rendelkező model_name modellalgoritmusokat, és konfigurálhatja a beállításokat úgy, hogy egy hiperparaméter-söprést hajtanak végre egy meghatározott paraméterterületen az optimális modell megtalálásához.

Ebben a példában egy AutoMLImageConfig objektumészlelési modell yolov5 betanítására használjuk a és fasterrcnn_resnet50_fpna , mindkettőt előre betanított COCO-val, egy nagyméretű objektumészlelési, szegmentálási és feliratozási adatkészlettel, amely több mint ezer címkézett képet tartalmaz több mint 80 címkekategóriával.

Hiperparaméter-takarítás képfeladatokhoz

Az optimális modell megkereséséhez hyperparaméter-átsöprést végezhet egy meghatározott paraméterterületen.

Az alábbi kód határozza meg az egyes definiált algoritmusok hiperparaméter-söpredékének előkészítéséhez szükséges paraméterterületet, yolov5 és fasterrcnn_resnet50_fpn. A paramétertérben adja meg a , optimizer, lr_schedulerstb. értéktartományátlearning_rate, hogy az AutoML válasszon az optimális elsődleges metrikával rendelkező modell létrehozásakor. Ha a hiperparaméter-értékek nincsenek megadva, akkor a rendszer minden algoritmushoz alapértelmezett értékeket használ.

A hangolási beállításokhoz véletlenszerű mintavételezéssel válasszon mintákat ebből a paraméterterületből a és BayesianParameterSampling osztályok GridParameterSampling, RandomParameterSampling importálásával. Ezzel arra utasítja az automatizált gépi tanulást, hogy próbáljon ki összesen 20 iterációt ezekkel a különböző mintákkal, és egyszerre négy iterációt futtasson a számítási célon, amelyet négy csomóponttal állítottunk be. Minél több paraméterrel rendelkezik a tér, annál több iterációra van szükség az optimális modellek megtalálásához.

A Bandit korai felmondási szabályzata is használatos. Ez a szabályzat leállítja a gyenge teljesítményű konfigurációkat; vagyis azok a konfigurációk, amelyek nem a legjobban teljesítő konfiguráció 20%-os tartalékidőn belül vannak, ami jelentősen megtakarítja a számítási erőforrásokat.

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)
}

A paramétertér és a finomhangolási beállítások megadása után átadhatja őket az AutoMLImageConfig objektumnak, majd elküldheti a kísérletet egy képmodell betanítására a betanítási adatkészlet használatával.

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)

A hiperparaméterek átvizsgálásakor hasznos lehet megjeleníteni a HyperDrive felhasználói felületén kipróbált különböző konfigurációkat. Ehhez a felhasználói felülethez a fenti fő automl_image_run "Gyermekfuttatások" lapjára léphet, amely a HyperDrive szülőfuttatása. Ezután a "Gyermekfuttatások" fülre léphet. Másik lehetőségként itt közvetlenül láthatja a HyperDrive szülőfuttatását, és a Gyermekfuttatások lapra léphet:

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

A legjobb modell regisztrálása

A futtatás befejezése után regisztrálhatjuk a legjobb futtatásból létrehozott modellt.

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')

Modell üzembe helyezése webszolgáltatásként

Miután elkészült a betanított modellel, üzembe helyezheti a modellt az Azure-ban. A betanított modellt webszolgáltatásként helyezheti üzembe Azure Container Instances (ACI) vagy Azure Kubernetes Service (AKS) rendszeren. Az ACI tökéletes választás az üzemelő példányok teszteléséhez, míg az AKS jobb választás a nagy léptékű, éles használathoz.

Ebben az oktatóanyagban a modellt webszolgáltatásként helyezzük üzembe az AKS-ben.

  1. Hozzon létre egy AKS számítási fürtöt. Ebben a példában egy GPU virtuálisgép-termékváltozatot használunk az üzembehelyezési fürthöz

    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. Határozza meg a következtetési konfigurációt, amely leírja, hogyan állíthatja be a modellt tartalmazó webszolgáltatást. A pontozási szkriptet és a környezetet a betanítási futtatásból használhatja a következtetési konfigurációban.

    Megjegyzés

    A modell beállításainak módosításához nyissa meg a letöltött pontozási szkriptet, és módosítsa a model_settings változót a modell üzembe helyezése előtt.

    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. Ezután üzembe helyezheti a modellt AKS-webszolgáltatásként.

    
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)

A webszolgáltatás tesztelése

Tesztelheti az üzembe helyezett webszolgáltatást az új rendszerképek előrejelzéséhez. Ebben az oktatóanyagban adjon át egy véletlenszerű képet az adathalmazból, és adja át a pontozási URI-nak.

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)

Észlelések vizualizációja

Most, hogy pontozott egy tesztképet, megjelenítheti a kép határolókeretét. Ehhez győződjön meg arról, hogy telepítve van a 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()

Az erőforrások eltávolítása

Ne fejezze be ezt a szakaszt, ha más Azure Machine Learning-oktatóanyagokat szeretne futtatni.

Ha nem tervezi használni a létrehozott erőforrásokat, törölje őket, így nem kell díjat fizetnie.

  1. Az Azure Portalon válassza az Erőforráscsoportok lehetőséget a bal szélen.
  2. Válassza ki a listában az Ön által létrehozott erőforráscsoportot.
  3. Válassza az Erőforráscsoport törlése elemet.
  4. Írja be az erőforráscsoport nevét. Ezután válassza a Törlés elemet.

Megtarthatja az erőforráscsoportot is, de egyetlen munkaterületet törölhet. Jelenítse meg a munkaterület tulajdonságait, és válassza a Törlés lehetőséget.

Következő lépések

Ebben az automatizált gépi tanulási oktatóanyagban a következő feladatokat végezte el:

  • Konfigurált egy munkaterületet, és előkészítette az adatokat egy kísérlethez.
  • Automatizált objektumészlelési modell betanítása
  • Megadott hiperparaméter-értékek a modellhez
  • Hiperparaméter-takarítást hajtott végre
  • A modell üzembe helyezése
  • Vizualizációs észlelések

Megjegyzés

A hűtőobjektum-adatkészlet használata az MIT-licenc alatt található licencen keresztül érhető el.