Megosztás a következőn keresztül:

Oktatóanyag: Objektumészlelési modell (előzetes verzió) betanítása 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.

Ebben az oktatóanyagban 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ók normalizálási/szabványosítási módszereinek, modelljeinek és hiperparaméter-beállításainak kombinációjával, hogy a legjobb modellt érje el.

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

  • 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, amelyet az automatizált ml-modell betanításához használ. 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 ez a számítási céltípus 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ág előnyeit a modell hiperparamétereinek finomhangolása során.

Az alábbi kód egy Standard _NC24s_v3 méretű GPU-számítást hoz létre a munkaterülethez wscsatolt négy csomóponttal.

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 munkaterületet Experiment 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 megjelenítése

Miután JSONL (JSON Lines) formátumban előkészítette a bemeneti képadatokat, 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 a következő 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%-át használja az ellenőrzéshez.

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 adatkészletbő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)

Bármely kép esetében futtathatja a következő kódot a határolókeretek megjelenítéséhez.

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

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

Ebben a példában egy AutoMLImageConfig objektumészlelési modell yolov5 fasterrcnn_resnet50_fpnbetanítására használjuk a COCO-n előre betanított objektumészlelési, szegmentálási és feliratozási adatkészletet, amely több mint több 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 hiperparaméter-átsöprést hajthat végre egy meghatározott paraméterterületen.

Az alábbi kód határozza meg a paraméterterületet az egyes definiált algoritmusok hiperparaméter-takarításának előkészítése során, yolov5 és fasterrcnn_resnet50_fpn. A paramétertérben adja meg, hogy az AutoML milyen értéktartományt learning_rateoptimizerlr_schedulervá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 szúrópróbaszerű mintavételezéssel válasszon mintákat ebből a paramétertérből az osztályok és BayesianParameterSampling az GridParameterSampling, RandomParameterSampling osztályok importálásával. Ez azt jelenti, hogy az automatizált gépi tanulás összesen 20 iterációt próbál ki ezekkel a különböző mintákkal, és egyszerre négy iterációt futtat a számítási célon, amelyet négy csomópont használatával állítottunk be. Minél több paramétere van a térnek, 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ékideje alatt 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 hangolási beállítások meghatározása után átadhatja őket az AutoMLImageConfig objektumnak, majd elküldheti a kísérletet egy képmodell betanításához 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)

Hiperparaméter-átvizsgáláskor hasznos lehet a HyperDrive felhasználói felületén kipróbált különböző konfigurációk megjelenítése. Ehhez a felhasználói felülethez a fő automl_image_run felhasználói felületén található "Gyermekfuttatások" lapra lépve, 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 a HyperDrive szülőfuttatását láthatja, és a Gyermekfuttatások lapra navigálhat:

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 elvégezte a betanított modellt, üzembe helyezheti a modellt az Azure-ban. A betanított modellt webszolgáltatásként üzembe helyezheti az Azure Container Instances (ACI) vagy az Azure Kubernetes Service (AKS) szolgáltatásban. Az ACI tökéletes megoldás az üzemelő példányok tesztelésére, míg az AKS jobban megfelel a nagy léptékű, éles használatnak.

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. Adja 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.

    Feljegyzé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

Az üzembe helyezett webszolgáltatást tesztelheti 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 elért 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 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. Adja meg 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éteres takarítást hajtott végre
  • A modell üzembe helyezése
  • Vizualizációs észlelések

Feljegyzés

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