Öğretici: AutoML ve Python (v1) ile nesne algılama modelini eğitma (önizleme)

ŞUNLAR IÇIN GEÇERLIDIR:Python SDK azureml v1

Önemli

Bu makalede sunulan özellikler önizleme aşamasındadır. Bunlar, herhangi bir zamanda değişebilecek deneysel önizleme özellikleri olarak kabul edilmelidir.

Bu öğreticide, Azure Machine Learning Python SDK'sı ile Azure Machine Learning otomatik ML kullanarak nesne algılama modelini eğitmeyi öğreneceksiniz. Bu nesne algılama modeli görüntünün kutu, karton, süt şişesi veya su şişesi gibi nesneler içerip içermediğini belirler.

Otomatik ML eğitim verilerini ve yapılandırma ayarlarını kabul eder ve en iyi modele ulaşmak için farklı özellik normalleştirme/standartlaştırma yöntemleri, modelleri ve hiper parametre ayarlarının birleşimleri aracılığıyla otomatik olarak yinelenir.

Bu öğreticide Python SDK'sını kullanarak kod yazacak ve aşağıdaki görevleri öğreneceksiniz:

• Verileri indirme ve dönüştürme
• Otomatik makine öğrenmesi nesne algılama modelini eğitin
• Modeliniz için hiper parametre değerlerini belirtme
• Hiper parametre süpürme işlemi gerçekleştirme
• Modelinizi dağıtma
• Algılamaları görselleştirme

Önkoşullar

• Azure aboneliğiniz yoksa başlamadan önce ücretsiz bir hesap oluşturun. Azure Machine Learning'in ücretsiz veya ücretli sürümünü bugün deneyin.

• Bu özellik için Python 3.7 veya 3.8 desteklenir

• Azure Machine Learning çalışma alanınız yoksa Hızlı Başlangıç: Azure Machine Learning'i kullanmaya başlama bölümünü tamamlayın.

• odFridgeObjects.zipveri dosyasını indirin ve sıkıştırmasını * açın. Veri kümesine Pascal VOC biçiminde açıklama eklenir ve burada her görüntü bir xml dosyasına karşılık gelir. Her xml dosyası, karşılık gelen görüntü dosyasının bulunduğu yere ilişkin bilgileri ve ayrıca sınırlayıcı kutular ve nesne etiketleri hakkındaki bilgileri içerir. Bu verileri kullanmak için, önce not defterinin İndirilen verileri JSONL'ye dönüştürme bölümünde görüldüğü gibi gerekli JSONL biçimine dönüştürmeniz gerekir.

Bu öğreticiyi kendi yerel ortamınızda çalıştırmak istiyorsanız GitHub'daki azureml-examples deposunda da bulabilirsiniz. Gerekli paketleri almak için

• pip install azureml komutunu çalıştırın
• Tam automl istemciyi yükleme

İşlem hedefi kurulumu

Öncelikle otomatik ML modeli eğitiminiz için kullanılacak bir işlem hedefi ayarlamanız gerekir. Görüntü görevleri için otomatik ML modelleri IÇIN GPU SKU'ları gerekir.

Bu tür bir işlem hedefi, eğitimi hızlandırmak için birden çok GPU'yu kullandığından bu öğreticide NCsv3 serisi (V100 GPU'lar ile) kullanılır. Ayrıca, modeliniz için hiper parametreleri ayarlarken paralellikten yararlanmak için birden çok düğüm ayarlayabilirsiniz.

Aşağıdaki kod, çalışma alanına wsbağlı dört düğüme sahip Standart _NC24s_v3 boyutunda bir GPU hesaplaması oluşturur.

Uyarı

Aboneliğinizin kullanmak istediğiniz işlem hedefi için yeterli kotaya sahip olduğundan emin olun.

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)

Deneme kurulumu

Ardından, model eğitim çalıştırmalarınızı izlemek için çalışma alanınızda bir Experiment oluşturun.

from azureml.core import Experiment

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

Giriş verilerini görselleştirme

Giriş görüntüsü verilerini JSONL (JSON Çizgileri) biçiminde hazırladıktan sonra, bir görüntü için temel gerçeklik sınırlayıcı kutularını görselleştirebilirsiniz. Bunu yapmak için yüklediğinizden matplotlib emin olun.

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

Yukarıdaki yardımcı işlevleri kullanarak, belirli bir görüntü için sınırlayıcı kutuları görüntülemek için aşağıdaki kodu çalıştırabilirsiniz.

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

plot_ground_truth_boxes_jsonl(image_file, jsonl_file)

Verileri karşıya yükleme ve veri kümesi oluşturma

Verileri eğitim için kullanmak için bir veri deposu aracılığıyla çalışma alanınıza yükleyin. Veri deposu, verileri karşıya yüklemeniz veya indirmeniz ve uzak işlem hedeflerinizden veri deposuyla etkileşim kurmanız için bir mekanizma sağlar.

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

Veri deposuna yüklendikten sonra verilerden bir Azure Machine Learning veri kümesi oluşturabilirsiniz. Veri kümeleri, verilerinizi eğitim için tüketilebilir bir nesneye paketler.

Aşağıdaki kod eğitim için bir veri kümesi oluşturur. Doğrulama veri kümesi belirtilmediğinden, eğitim verilerinizin %20'si doğrulama için varsayılan olarak kullanılır.

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)

Veri kümesini görselleştirme

Ayrıca bu veri kümesindeki bir görüntü için temel gerçeklik sınırlayıcı kutularını da görselleştirebilirsiniz.

Veri kümesini bir pandas veri çerçevesine yükleyin.

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)

Belirli bir görüntü için sınırlayıcı kutuları görüntülemek için aşağıdaki kodu çalıştırabilirsiniz.

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

Nesne algılama denemenizi yapılandırma

Görüntüyle ilgili görevler için otomatik ML çalıştırmalarını yapılandırmak için nesnesini kullanın AutoMLImageConfig . içinde AutoMLImageConfig, parametresiyle model_name model algoritmalarını belirtebilir ve en uygun modeli bulmak için tanımlı parametre alanı üzerinde hiper parametre taraması gerçekleştirmek için ayarları yapılandırabilirsiniz.

Bu örnekte, her ikisi de 80'den fazla etiket kategorisine sahip binlerce etiketli görüntü içeren büyük ölçekli nesne algılama, segmentasyon ve açıklamalı alt yazı veri kümesi olan VE ile bir nesne algılama modelini yolov5fasterrcnn_resnet50_fpneğitmek için kullanırızAutoMLImageConfig.

Görüntü görevleri için hiper parametre süpürme

En uygun modeli bulmak için tanımlı parametre alanı üzerinde hiper parametre süpürme işlemi gerçekleştirebilirsiniz.

Aşağıdaki kod, tanımlanan her algoritma yolov5fasterrcnn_resnet50_fpnve için hiper parametre süpürme hazırlığında parametre alanını tanımlar. Parametre alanında, AutoML'nin en uygun birincil ölçüme sahip bir model oluşturmaya çalışırken aralarından seçim yapmak için , optimizer, lr_scheduler, vb. için değer learning_ratearalığını belirtin. Hiper parametre değerleri belirtilmezse, her algoritma için varsayılan değerler kullanılır.

Ayarlama ayarları için, ve BayesianParameterSampling sınıflarını içeri aktararak GridParameterSampling, RandomParameterSampling bu parametre alanından örnekler seçmek için rastgele örnekleme kullanın. Bunu yaptığınızda, otomatik ML'ye bu farklı örneklerle toplam 20 yineleme denemesini ve dört düğüm kullanılarak ayarlanan işlem hedefimizde aynı anda dört yineleme çalıştırmasını söyler. Alanda ne kadar çok parametre varsa, en uygun modelleri bulmak için o kadar fazla yineleme gerekir.

Eşkıya erken sonlandırma ilkesi de kullanılır. Bu ilke düşük performanslı yapılandırmaları sonlandırır; yani işlem kaynaklarını önemli ölçüde kaydeden en iyi performansa sahip yapılandırmanın %20'si içinde olmayan yapılandırmalar.

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

Parametre alanı ve ayarlama ayarları tanımlandıktan sonra bunları nesnenize AutoMLImageConfig geçirebilir ve ardından denemeyi göndererek eğitim veri kümenizi kullanarak bir görüntü modelini eğitebilirsiniz.

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)

Hiper parametre süpürme işlemi yaparken, HyperDrive kullanıcı arabirimi kullanılarak denenen farklı yapılandırmaları görselleştirmek yararlı olabilir. HyperDrive üst çalıştırması olan yukarıdan ana automl_image_run kullanıcı arabirimindeki 'Alt çalıştırmalar' sekmesine giderek bu kullanıcı arabirimine gidebilirsiniz. Ardından bunun "Alt çalıştırmalar" sekmesine gidebilirsiniz. Alternatif olarak, burada doğrudan HyperDrive üst çalıştırmasını görebilir ve 'Alt çalıştırmalar' sekmesine gidebilirsiniz:

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

En iyi modeli kaydetme

Çalıştırma tamamlandıktan sonra en iyi çalıştırmadan oluşturulan modeli kaydedebiliriz.

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

Modeli web hizmeti olarak dağıtma

Eğitilmiş modelinizi aldıktan sonra modeli Azure'da dağıtabilirsiniz. Eğitilen modelinizi Azure Container Instances (ACI) veya Azure Kubernetes Service (AKS) üzerinde bir web hizmeti olarak dağıtabilirsiniz. ACI, dağıtımları test etme için mükemmel bir seçenekken AKS, yüksek ölçekli üretim kullanımı için daha uygundur.

Bu öğreticide modeli AKS'de bir web hizmeti olarak dağıtacağız.

1. AKS işlem kümesi oluşturma. Bu örnekte, dağıtım kümesi için bir GPU sanal makine SKU'su kullanılır

   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. Modelinizi içeren web hizmetini ayarlamayı açıklayan çıkarım yapılandırmasını tanımlayın. Puanlama betiğini ve eğitim çalıştırmasından ortamı çıkarım yapılandırmanızda kullanabilirsiniz.

   Not

   Modelin ayarlarını değiştirmek için indirilen puanlama betiğini açın ve modeli dağıtmadan önce model_settings değişkenini değiştirin.

   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. Ardından modeli aks web hizmeti olarak dağıtabilirsiniz.

   
   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)
   

Web hizmetini test etme

Yeni görüntüleri tahmin etmek için dağıtılan web hizmetini test edebilirsiniz. Bu öğretici için veri kümesinden rastgele bir görüntü geçirin ve bunu puanlama URI'sine geçirin.

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)

Algılamaları görselleştirme

Artık bir test görüntüsü puanladığınıza göre, bu görüntü için sınırlayıcı kutuları görselleştirebilirsiniz. Bunu yapmak için matplotlib'in yüklü olduğundan emin olun.

%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()

Kaynakları temizleme

Diğer Azure Machine Learning öğreticilerini çalıştırmayı planlıyorsanız bu bölümü tamamlamayın.

Oluşturduğunuz kaynakları kullanmayı planlamıyorsanız, herhangi bir ücret ödememek için bunları silin.

1. Azure portalının en sol tarafındaki Kaynak gruplarını seçin.
2. Listeden oluşturduğunuz kaynak grubunu seçin.
3. Kaynak grubunu sil'i seçin.
4. Kaynak grubu adını girin. Ardından Sil’i seçin.

Ayrıca kaynak grubunu koruyabilir ancak tek bir çalışma alanını silebilirsiniz. Çalışma alanı özelliklerini görüntüleyin ve Sil'i seçin.

Sonraki adımlar

Bu otomatik makine öğrenmesi öğreticisinde aşağıdaki görevleri gerçekleştirdiniz:

• Çalışma alanı yapılandırıldı ve bir deneme için veriler hazırlandı.
• Otomatik nesne algılama modeli eğitildi
• Modeliniz için belirtilen hiper parametre değerleri
• Hiper parametre süpürme işlemi gerçekleştirildi
• Modelinizi dağıttı
• Görselleştirilmiş algılamalar

• Otomatik ML'de görüntü işleme hakkında daha fazla bilgi edinin.
• Python ile görüntü işleme modellerini eğitmek için AutoML'yi ayarlamayı öğrenin.
• Görüntü işleme modellerinde artımlı eğitimi yapılandırmayı öğrenin.
• Görüntü işleme görevleri için hangi hiper parametrelerin kullanılabilir olduğunu görün.
• Otomatik makine öğrenimi örnekleri için GitHub not defteri deposundaki ayrıntılı kod örneklerini ve kullanım örneklerini inceleyin. Görüntü işleme modelleri oluşturmaya özgü örnekler için lütfen 'image-' ön ekine sahip klasörleri denetleyin.

Not

Buzdolabı nesneleri veri kümesinin kullanımı , MIT Lisansı altındaki lisans aracılığıyla kullanılabilir.