Tutorial: Melatih model deteksi objek (pratinjau) dengan AutoML dan Python (v1)

BERLAKU UNTUK: Python SDK azureml v1

Penting

Fitur yang disajikan dalam artikel ini berada dalam pratinjau. Fitur tersebut harus dianggap sebagai fitur pratinjau eksperimental yang mungkin berubah kapan saja.

Dalam tutorial ini, Anda mempelajari cara melatih model deteksi objek dengan Phyton SDK Azure Machine Learning menggunakan ML otomatis Azure Machine Learning. Model deteksi objek ini mengidentifikasi apakah citra berisi objek, seperti kaleng, karton, botol susu, atau botol air.

ML otomatis menerima data dan konfigurasi pengaturan latihan, dan secara otomatis melakukan iterasi melalui kombinasi metode normalisasi/standarisasi fitur, model, dan pengaturan hyperparameter yang berbeda untuk menemukan model terbaik.

Anda akan menulis kode menggunakan Python SDK dalam tutorial ini dan mempelajari tugas-tugas berikut:

• Mengunduh dan mengubah data
• Melatih model deteksi objek pembelajaran mesin otomatis
• Menentukan nilai hyperparameter untuk model Anda
• Melakukan sapuan hyperparameter
• Sebarkan model anda
• Memvisualisasikan deteksi

Prasyarat

• Jika Anda tidak memiliki langganan Azure, buat akun gratis sebelum Anda memulai. Coba versi gratis atau berbayar Azure Machine Learning sekarang.

• Python 3.7 atau 3.8 didukung untuk fitur ini

• Selesaikan Mulai Cepat: Memulai Azure Machine Learning jika Anda belum memiliki ruang kerja Azure Machine Learning.

• Unduh dan ekstrak file data *odFridgeObjects.zip. Himpunan data dianotasi dalam format Pascal VOC, di mana setiap gambar sesuai dengan file xml. Setiap file xml berisi informasi letak file gambar yang sesuai berada dan juga berisi informasi tentang kotak batas dan label objek. Untuk menggunakan data ini, pertama Anda harus mengonversinya ke format JSONL yang diperlukan seperti yang terlihat di bagian Konversi data yang diunduh ke JSONL buku catatan.

Tutorial ini juga tersedia di repositori azureml-examples di GitHub jika Anda ingin menjalankannya di lingkungan lokal Anda sendiri. Untuk mendapatkan paket yang diperlukan,

• Jalankan pip install azureml
• Pasang klien automl lengkap

Penyiapan target komputasi

Anda harus terlebih dahulu menyiapkan target komputasi untuk digunakan pada pelatihan model ML otomatis Anda. Model ML otomatis untuk tugas citra memerlukan SKU GPU.

Tutorial ini menggunakan seri NCsv3 (dengan GPU V100) karena jenis target komputasi ini memanfaatkan beberapa GPU untuk mempercepat pelatihan. Selain itu, Anda dapat menyiapkan beberapa simpul untuk memanfaatkan paralelisme saat menyetel hyperparameter untuk model Anda.

Kode berikut membuat komputasi GPU ukuran Standard _NC24s_v3 dengan empat simpul yang terlampir pada ruang kerja ws.

Peringatan

Pastikan langganan Anda memiliki kuota yang cukup untuk target komputasi yang ingin Anda gunakan.

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)

Penyiapan eksperimen

Selanjutnya, buat Experiment di ruang kerja Anda untuk melacak eksekusi pelatihan model Anda.

from azureml.core import Experiment

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

Visualisasikan data input

Setelah Anda memiliki data citra input yang disiapkan dalam format JSONL (JSON Lines), Anda dapat memvisualisasikan kotak pembatas kebenaran dasar untuk citra. Untuk melakukannya, pastikan Anda telah memasang 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))

Dengan menggunakan fungsi pembantu di atas, untuk citra apa pun, Anda dapat menjalankan kode berikut untuk menampilkan kotak pembatas.

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

plot_ground_truth_boxes_jsonl(image_file, jsonl_file)

Mengunggah data dan membuat himpunan data

Untuk menggunakan data untuk pelatihan, unggah data ke ruang kerja Anda melalui datastore. Datastore menyediakan mekanisme bagi Anda untuk mengunggah atau mengunduh data, dan berinteraksi dengan data dari target komputasi jarak jauh Anda.

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

Setelah diunggah ke datastore, Anda dapat membuat himpunan data Azure Machine Learning dari data. Himpunan data mengemas data Anda menjadi objek yang dapat digunakan untuk latihan.

Kode berikut membuat himpunan data untuk latihan. Karena tidak ada himpunan data validasi yang ditentukan, secara default 20% dari data pelatihan Anda digunakan untuk validasi.

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)

Memvisualisasikan himpunan data

Anda juga dapat memvisualisasikan kotak pembatas kebenaran dasar untuk citra dari himpunan data ini.

Muat data ke dalam dataframe panda.

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)

Untuk setiap gambar yang diberikan, Anda dapat menjalankan kode berikut untuk menampilkan kotak pembatas.

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

Mengonfigurasi eksperimen deteksi objek Anda

Untuk mengonfigurasi eksekusi ML otomatis untuk tugas terkait citra, gunakan objek AutoMLImageConfig. Pada AutoMLImageConfig, Anda dapat menentukan algoritma model dengan parameter model_name dan mengonfigurasi pengaturan untuk melakukan sapuan hyperparameter pada ruang parameter yang ditentukan untuk menemukan model yang optimal.

Dalam contoh ini, kita menggunakan AutoMLImageConfig untuk melatih model deteksi objek dengan yolov5 dan fasterrcnn_resnet50_fpn, keduanya telah dilatih pada COCO, deteksi objek skala besar, segmentasi, dan himpunan data keterangan yang berisi ribuan citra berlabel dengan lebih dari 80 kategori label.

Sapuan hyperparameter untuk tugas citra

Anda dapat melakukan sapuan hyperparameter pada ruang parameter yang ditentukan untuk menemukan model yang optimal.

Kode berikut mendefinisikan ruang parameter dalam persiapan untuk sapuan hyperparameter untuk setiap algoritma yang ditentukan, yolov5 dan fasterrcnn_resnet50_fpn. Dalam ruang parameter, tentukan rentang nilai untuk learning_rate, optimizer, lr_scheduler, dll, untuk dipilih oleh AutoML saat mencoba untuk menghasilkan model dengan metrik primer yang optimal. Jika nilai hyperparameter tidak ditentukan, maka nilai default digunakan untuk setiap algoritma.

Untuk pengaturan penyetelan, gunakan pengambilan sampel acak untuk memilih sampel dari ruang parameter ini dengan mengimpor kelas GridParameterSampling, RandomParameterSampling dan BayesianParameterSampling. Melakukan hal itu akan memberi tahu ML otomatis untuk mencoba total 20 iterasi dengan sampel yang berbeda ini, menjalankan empat iterasi sekaligus pada target komputasi kami yang disiapkan menggunakan empat node. Semakin banyak parameter ruang, semakin banyak pula iterasi yang Anda butuhkan untuk menemukan model yang optimal.

Kebijakan penghentian awal Bandit juga digunakan. Kebijakan ini menghentikan konfigurasi berperforma buruk yaitu; konfigurasi yang tidak dalam kelonggaran 20% dari konfigurasi berperforma terbaik yang secara signifikan menghemat sumber daya komputasi.

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

Setelah ruang parameter dan pengaturan penyetelan ditentukan, Anda dapat meneruskannya ke objek AutoMLImageConfig Anda dan kemudian mengirimkan eksperimen untuk melatih model citra menggunakan himpunan data pelatihan Anda.

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)

Saat melakukan sapuan hyperparameter, dapat berguna untuk memvisualisasikan konfigurasi berbeda yang dicoba menggunakan antarmuka pengguna HyperDrive. Anda dapat menavigasi ke antarmuka pengguna ini dengan masuk ke tab 'Eksekusi anak' di antarmuka pengguna automl_image_run utama dari atas, yang dijalankan induk HyperDrive. Kemudian Anda dapat masuk ke tab 'Eksekusi anak' yang satu ini. Sebagai alternatif, di bawah ini Anda dapat melihat langsung eksekusi induk HyperDrive dan masuk ke tab 'Eksekusi anak':

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

Mendaftarkan model terbaik

Setelah eksekusi selesai, kita dapat mendaftarkan model yang dibuat dari eksekusi terbaik.

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

Menyebarkan model sebagai layanan web

Setelah memiliki model terlatih, Anda dapat menyebarkan model di Azure. Anda dapat menyebarkan model terlatih Anda sebagai layanan web pada Azure Container Instances (ACI) atau Azure Kubernetes Service (AKS). ACI adalah pilihan tepat untuk menguji penyebaran, sementara AKS lebih cocok untuk penggunaan produksi berskala tinggi.

Dalam tutorial ini, kita menyebarkan model sebagai layanan web di AKS.

1. Membuat kluster komputasi AKS. Dalam contoh ini, SKU mesin virtual GPU digunakan untuk kluster penyebaran

   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. Tentukan konfigurasi inferensi yang menjelaskan cara menyiapkan layanan web yang berisi model Anda. Anda dapat menggunakan skrip penilaian dan lingkungan dari pelatihan yang berjalan dalam konfigurasi inferensi Anda.

   Catatan

   Untuk mengubah pengaturan model, buka skrip penilaian yang telah diunduh dan ubah variabel model_settings sebelum menyebarkan model.

   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. Kemudian Anda dapat menyebarkan model tersebut sebagai layanan web 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)
   

Menguji aplikasi web

Anda dapat menguji layanan web yang disebarkan untuk memprediksi citra baru. Untuk tutorial ini, teruskan citra acak dari himpunan dan teruskan ke URI penilaian.

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)

Memvisualisasikan deteksi

Sekarang setelah Anda menilai citra uji, Anda dapat memvisualisasikan kotak pembatas untuk citra ini. Untuk melakukannya, pastikan Anda telah memasang 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()

Membersihkan sumber daya

Jangan selesaikan bagian ini jika Anda berencana menjalankan tutorial Azure Machine Learning lainnya.

Jika Anda tidak berencana menggunakan sumber daya yang Anda buat, hapus sehingga Anda tidak dikenakan biaya apa pun.

1. Dari portal Microsoft Azure, pilih Grup sumber daya dari sisi sebelah kiri.
2. Dari daftar, pilih grup sumber daya yang Anda buat.
3. Pilih Hapus grup sumber daya.
4. Masukkan nama grup sumber daya. Kemudian pilih Hapus.

Anda juga dapat menyimpan grup sumber daya tetapi menghapus satu ruang kerja. Tampilkan properti ruang kerja dan pilih Hapus.

Langkah berikutnya

Dalam tutorial pembelajaran mesin otomatis ini, Anda telah melakukan tugas-tugas berikut:

• Mengonfigurasi ruang kerja dan menyiapkan data untuk eksperimen.
• Melatih model deteksi objek otomatis
• Menentukan nilai hyperparameter untuk model Anda
• Melakukan sapuan hyperparameter
• Menyebarkan model Anda
• Memvisualisasikan deteksi

• Pelajari selengkapnya tentang visi komputer di ML otomatis.
• Pelajari cara menyiapkan AutoML untuk melatih model visi komputer dengan Python.
• Pelajari cara mengonfigurasi pelatihan bertambah bertahap pada model visi komputer.
• Lihat hyperparameter apa yang tersedia untuk tugas visi komputer.
• Tinjau contoh kode terperinci dan kasus penggunaan di repositori buku catatan GitHub untuk sampel pembelajaran mesin otomatis. Silakan periksa folder dengan awalan 'image-' untuk sampel khusus untuk membangun model visi komputer.

Catatan

Penggunaan himpunan data objek kulkas tersedia melalui lisensi di bawah Lisensi MIT.