Giriş

Nesne algılama, bilgisayarla görü alanında geniş bir alandır ve bilgisayarlı görünün “vahşi doğada” en önemli uygulamalarından biridir. Bundan, örnek segmentasyonu çıkarıldı ve modellerin yalnızca bir nesnenin etiketini ve sınırlayıcı kutusunu değil, aynı zamanda kapsadığı "alanı" da tahmin etmesiyle görevlendirildi - o nesneye ait her pikseli sınıflandırdı.

Semantik Segmentasyon, bir görüntüdeki tüm pikselleri kendi özelliklerine göre sınıflandırır. anlamsal etiket (araba, kaldırım, bina). Örnek Segmentasyonu sınıflandırır algılanan her nesnenin tüm pikselleri bireysel olarak ve Car1 farklıdır Car2.

Kavramsal olarak - benzerler, ancak örnek segmentasyonu, anlamsal segmentasyon ve nesne algılamayı birleştirir. Neyse ki, nesne algılama, anlamsal bölümleme ve uzantıyla örnek bölümleme, kavramsal olarak benzer bir görevle görevlendirildiklerinden, ağın farklı kafalarıyla ortak bir arka uç ile yapılabilir ve böylece bu bilginin hesaplamalı temsillerini paylaşırlar.

Nesne algılama, anlamsal bölümleme, örnek bölümleme ve anahtar nokta algılama, görüntü sınıflandırma kadar standartlaştırılmamıştır, çünkü yeni gelişmelerin çoğu tipik olarak büyük kütüphaneler ve çerçeveler yerine bireysel araştırmacılar, bakımcılar ve geliştiriciler tarafından yapılır. Gerekli yardımcı program komut dosyalarını TensorFlow veya PyTorch gibi bir çerçevede paketlemek ve şimdiye kadar geliştirmeyi yönlendiren API yönergelerini sürdürmek zordur.

Neyse ki kitleler için - Ultralytics, diğer araştırma ve geliştirme ekipleri tarafından YOLOv5 gibi daha yeni sürümlere genişletilen YOLOv7'leri etrafında basit, çok güçlü ve güzel bir nesne algılama API'si geliştirdi.

Bu kısa kılavuzda, son teknoloji YOLOv7 ile Python'da Örnek Segmentasyonu gerçekleştireceğiz.

YOLO ve Örnek Segmentasyonu

YOLO (Sadece Bir Kez Bakarsınız) nesne algılama için oluşturulmuş bir model ailesi olduğu kadar bir metodolojidir. 2015'teki başlangıcından bu yana, YOLOv1, YOLOv2 (YOLOv9000 (YOLO3) ve YOLOvXNUMX aynı yazar(lar) tarafından önerildi - ve derin öğrenme topluluğu, devam eden yıllarda açık kaynaklı gelişmelerle devam etti.

Ultralytics'in YOLOv5'i devasa bir depodur ve YOLO'nun PyTorch'ta endüstride büyük kullanım görmüş ilk üretim düzeyinde uygulamasıdır. PyTorch uygulaması, onu her zamankinden daha erişilebilir hale getirdi ve bu genellikle C++'da yapıldı, ancak bu kadar popüler olmasının ana nedeni, etrafına inşa edilmiş, herkesin birkaç satır Python çalıştırmasına izin veren güzel, basit ve güçlü API'dir. nesne dedektörleri oluşturabilen kod.

YOLOv5, YOLO yöntemini geliştirmeyi amaçlayan çoğu deponun onu temel olarak kullandığı ve Ultralytics'ten devralınan benzer bir API sunduğu bir temel haline geldi. YOLOR (Yalnızca Bir Temsil Öğrenirsiniz) tam olarak bunu yaptı ve YOLOv7, aynı yazarlar tarafından YOLOR'un üzerine inşa edildi.

YOLOv7, anahtar noktalara, örnek segmentasyonuna ve nesne algılamaya olanak tanıyan yeni model kafalarıyla birlikte gelen ilk YOLO modelidir ve bu çok mantıklı bir eklemedir. Umarım ileriye dönük olarak, kutudan çıktığı gibi benzer yetenekler sunan artan sayıda YOLO tabanlı model göreceğiz.

Bu, iki aşamalı dedektörlerden daha basit bir mimariyle, örnek segmentasyonu ve anahtar nokta algılamanın her zamankinden daha hızlı gerçekleştirilmesini sağlar.

Modelin kendisi, mimari değişikliklerin yanı sıra, çıkarım maliyetini artırmadan doğruluğu artıran “ücretsiz çanta” olarak adlandırılan eğitim yönlerini optimize ederek oluşturuldu.

YOLOv7 ile Örnek Segmentasyonu

Python'da örnek segmentasyon, nesne algılama ve anahtar nokta tahmini için kullanılan standart bir kitaplık, Meta AI tarafından oluşturulan Detectron2'dir.

Kitaplık, sonuçları güzel bir şekilde görselleştirmeye yardımcı olmak için çeşitli ikna yöntemleri ve sınıfları sunar, ancak algılama için temel uygulama bir Maske R-CNN'dir. YOLO'nun genel olarak R-CNN tabanlı modellerden daha iyi performans gösterdiği görülmüştür. YOLOv7 deposu, Detectron2 uyumludur ve API ve görselleştirme araçlarıyla uyumludur, yeni bir API öğrenmek zorunda kalmadan hızlı ve doğru örnek segmentasyonu çalıştırmayı kolaylaştırır. Aslında Mask R-CNN omurgasını değiştirebilir ve YOLOv7 ile değiştirebilirsiniz.

Bağımlılıkları Yükleme – YOLOv7 ve Detectron2

Önce devam edelim ve bağımlılıkları yükleyelim. YOLOv7 projesi için GitHub deposunu klonlayacağız ve en son Detectron2 sürümünü şuradan yükleyeceğiz: pip:

! git clone -b mask https://github.com/WongKinYiu/yolov7.git
! pip install pyyaml==5.1
! pip install 'git+https://github.com/facebookresearch/detectron2.git'

Detectron2 gerektirir pyyaml ilave olarak. Uyumluluğu sağlamak için, çalışan torch versiyon:

! pip install torch==1.10.1+cu111 torchvision==0.11.2+cu111 torchaudio==0.10.1 -f https://download.pytorch.org/whl/torch_stable.html

YOLOv7'nin ana dalı, üçüncü taraf bir projeye bağımlı olduğu için örnek segmentasyonunu desteklemez. Ancak mask şube tam olarak bu destek için yapıldı, bu yüzden mask projenin şubesi. Son olarak, örnek segmentasyon modeli için önceden eğitilmiş ağırlıkları manuel olarak veya aşağıdakilerle indirmek isteyeceksiniz:

%cd yolov7
! curl -L https://github.com/WongKinYiu/yolov7/releases/download/v0.1/yolov7-mask.pt -o yolov7-mask.pt

İlk önce taşındık yolov7 dizin (projeyi içeren indirilen dizin) ve ardından ağırlıklar dosyasını buraya indirin. Bununla – bağımlılıklarımız kurulur! Kullanacağımız paketleri ve sınıfları içe aktaralım:

import matplotlib.pyplot as plt
import torch
import cv2
import yaml
from torchvision import transforms
import numpy as np

from utils.datasets import letterbox
from utils.general import non_max_suppression_mask_conf

from detectron2.modeling.poolers import ROIPooler
from detectron2.structures import Boxes
from detectron2.utils.memory import retry_if_cuda_oom
from detectron2.layers import paste_masks_in_image

YOLOv7 ile Örnek Segmentasyonu Çıkarımı

Önce segmentlere ayıracağımız resme bir göz atalım:

street_img = cv2.imread('../street.png')
street_img = cv2.cvtColor(street_img, cv2.COLOR_BGR2RGB)

fig = plt.figure(figsize=(12, 6))
plt.imshow(street_img)

Bu, Google Haritalar'ın canlı görünümünden bir ekran görüntüsü! Model birçok sınıfta önceden eğitilmediğinden, muhtemelen sadece şu sınıflar için anlamsal bölümleme göreceğiz: 'kişi', 'araba', vb. "ince taneli" sınıflar olmadan 'trafik ışığı'.

Artık modeli yüklemeye ve çıkarım için hazırlamaya geçebiliriz. bu hyp.scratch.mask.yaml dosyası hiperparametreler için konfigürasyonlar içerir, bu yüzden ilk olarak onu yükleyeceğiz, aktif cihazı (GPU veya CPU) kontrol edeceğiz ve modeli az önce indirdiğimiz ağırlıklar dosyasından yükleyeceğiz:

with open('data/hyp.scratch.mask.yaml') as f:
    hyp = yaml.load(f, Loader=yaml.FullLoader)

device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")

def load_model():
    model = torch.load('yolov7-mask.pt', map_location=device)['model']
    
    model.eval()

    if torch.cuda.is_available():
        
        
        model.half().to(device)
    return model

model = load_model()

Ardından, çıkarımı çalıştırmak için bir yardımcı yöntem oluşturalım! Bir görüntüyü okumasını, yeniden şekillendirmesini ve beklenen girdi boyutuna doldurmasını, dönüşümler uygulamasını, toplulaştırmasını ve modele geçirmesini isteyeceğiz:

def run_inference(url):
    image = cv2.imread(url) 
    
    image = letterbox(image, 640, stride=64, auto=True)[0] 
    
    image = transforms.ToTensor()(image) 
    
    image = image.half().to(device)
    
    image = image.unsqueeze(0) 
    output = model(image) 
    return output, image

output, image = run_inference('../street.png')

İşlev, modelin çıktısının yanı sıra görüntünün kendisini (yüklü, dolgulu ve başka şekilde işlenmiş) döndürür. Çıktı bir sözlüktür:

output.keys()

Modelin yaptığı tahminler ham - onları geçmemiz gerekecek non_max_supression()ve Detectron2'den ROIPooler'ı kullanın.

Not: “ROI Havuzu” için kısa “Bölge Faiz Havuzlaması” ve nesneleri içerebilecek bölgelerde nesne algılama ve segmentasyon görevleri için küçük özellik haritaları çıkarmak için kullanılır.

inf_out = output['test']
attn = output['attn']
bases = output['bases']
sem_output = output['sem']

bases = torch.cat([bases, sem_output], dim=1)
nb, _, height, width = image.shape
names = model.names
pooler_scale = model.pooler_scale

pooler = ROIPooler(output_size=hyp['mask_resolution'], 
                   scales=(pooler_scale,), 
                   sampling_ratio=1, 
                   pooler_type='ROIAlignV2', 
                   canonical_level=2)
                   

output, output_mask, _, _, _ = non_max_suppression_mask_conf(inf_out, 
                                                             attn, 
                                                             bases, 
                                                             pooler, 
                                                             hyp, 
                                                             conf_thres=0.25, 
                                                             iou_thres=0.65, 
                                                             merge=False, 
                                                             mask_iou=None)                 

Burada - nesneler ve etiketleri için tahminleri elde ettik. output ve bu nesneleri örtmesi gereken maskeler output_mask:

output[0].shape 
output_mask[0].shape 

Model, görüntüde her biri kendileriyle ilişkili bir etikete sahip 30 örnek buldu. Detectron2'lerin yardımıyla instance'larımız için kutular oluşturalım. Boxes sınıflandırın ve yoğunlaştırın pred_masks (bir boole maskesi içeren) orijinal görüntü üzerine uygulayabileceğimiz bir piksel kümesine:

pred, pred_masks = output[0], output_mask[0]
base = bases[0]
bboxes = Boxes(pred[:, :4])

original_pred_masks = pred_masks.view(-1, 
                                      hyp['mask_resolution'], 
                                      hyp['mask_resolution'])

pred_masks = retry_if_cuda_oom(paste_masks_in_image)(original_pred_masks, 
                                                     bboxes, 
                                                     (height, width), 
                                                     threshold=0.5)
                                                     

pred_masks_np = pred_masks.detach().cpu().numpy()
pred_cls = pred[:, 5].detach().cpu().numpy()
pred_conf = pred[:, 4].detach().cpu().numpy()
nimg = image[0].permute(1, 2, 0) * 255
nimg = nimg.cpu().numpy().astype(np.uint8)
nimg = cv2.cvtColor(nimg, cv2.COLOR_RGB2BGR)
nbboxes = bboxes.tensor.detach().cpu().numpy().astype(np.int)

The original_pred_masks orijinal görüntü için öngörülen maskeleri belirtir:

original_pred_masks.shape 

Ve son olarak, sonuçları şu şekilde çizebiliriz:

def plot_results(original_image, pred_img, pred_masks_np, nbboxes, pred_cls, pred_conf, plot_labels=True):
  for one_mask, bbox, cls, conf in zip(pred_masks_np, nbboxes, pred_cls, pred_conf):
    if conf < 0.25:
        continue
    color = [np.random.randint(255), np.random.randint(255), np.random.randint(255)]

    pred_img = pred_img.copy()
                             
    
    pred_img[one_mask] = pred_img[one_mask] * 0.5 + np.array(color, dtype=np.uint8) * 0.5
    
    pred_img = cv2.rectangle(pred_img, (bbox[0], bbox[1]), (bbox[2], bbox[3]), color, 2)

    if plot_labels:
      label = '%s %.3f' % (names[int(cls)], conf)
      t_size = cv2.getTextSize(label, 0, fontScale=0.1, thickness=1)[0]
      c2 = bbox[0] + t_size[0], bbox[1] - t_size[1] - 3
      pred_img = cv2.rectangle(pred_img, (bbox[0], bbox[1]), c2, color, -1, cv2.LINE_AA)
      pred_img = cv2.putText(pred_img, label, (bbox[0], bbox[1] - 2), 0, 0.5, [255, 255, 255], thickness=1, lineType=cv2.LINE_AA)  

  fig, ax = plt.subplots(1, 2, figsize=(pred_img.shape[0]/10, pred_img.shape[1]/10), dpi=150)

  original_image = np.moveaxis(image.cpu().numpy().squeeze(), 0, 2).astype('float32')
  original_image = cv2.cvtColor(original_image, cv2.COLOR_RGB2BGR)
  
  ax[0].imshow(original_image)
  ax[0].axis("off")
  ax[1].imshow(pred_img)
  ax[1].axis("off")

Görüntü kopyalanır, bu nedenle görüntüye yerinde değil, bir kopyada dönüşüm uygularız. Girdi görüntüsü ile tahmin edilen maskeler arasında eşleşen her piksel için opaklığa sahip bir renk uygularız. 0.5 ve her nesne için bir cv2.Rectangle() onu sınırlayıcı kutulardan kapsayan (bbox). Önemli örtüşme olabilecek etiketleri çizmek isterseniz, plot_labels içinde bayrak plot_results() yöntem imzası. Daha önce çalışmaya başladığımız görüntüyü etiketli ve etiketsiz olarak çizmeyi deneyelim:

%matplotlib inline
plot_results(image, nimg, pred_masks_np, nbboxes, pred_cls, pred_conf, plot_labels=False)

%matplotlib inline
plot_results(image, nimg, pred_masks_np, nbboxes, pred_cls, pred_conf, plot_labels=True)

Her iki görüntüyü de çizdik – orijinal ve bölümlere ayrılmış görüntü tek bir çizimde. Daha yüksek çözünürlük için, dpi (inç başına nokta) bağımsız değişkeni subplots() çağırın ve şekli bütünüyle kaplayacak şekilde tahmini segmentasyon haritası/etiketleri ile sadece görüntüyü çizin.

Daha İleri Gitmek – Bilgisayarla Görme için Pratik Derin Öğrenme

Meraklı doğanız daha ileri gitmek istemenizi sağlıyor mu? bizim kontrol etmenizi öneririz Kurs: “Python ile Bilgisayarla Görme için Pratik Derin Öğrenme”.

Başka Bir Bilgisayarla Görme Kursu mu?

MNIST rakamları veya MNIST modası sınıflandırması yapmayacağız. Uzun zaman önce rollerine hizmet ettiler. Çok fazla öğrenme kaynağı, gelişmiş kara kutu mimarilerinin performans yükünü omuzlamasına izin vermeden önce temel veri kümelerine ve temel mimarilere odaklanıyor.

odaklanmak istiyoruz gizemden arındırma, pratiklik, anlayış, sezgi ve gerçek projeler. Öğrenmek istemek Nasıl bir fark yaratabilirsin? Beynimizin görüntüleri işleme biçiminden meme kanseri için araştırma düzeyinde bir derin öğrenme sınıflandırıcısı yazmaya, “halüsinasyon” gören derin öğrenme ağlarına, size ilkeleri ve teoriyi pratik çalışmalarla öğreterek, sizi aşağıdaki bilgilerle donatmaya kadar bir yolculuğa çıkaracağız. bilgisayar vizyonunu çözmek için derin öğrenmeyi uygulamada uzman olmak için teknik bilgi ve araçlar.

İçinde ne var?

• Görmenin ilk ilkeleri ve bilgisayarlara “görmeyi” nasıl öğretebiliriz?
• Bilgisayarla görmenin farklı görevleri ve uygulamaları
• İşinizi kolaylaştıracak ticaret araçları
• Bilgisayarla görü için veri kümelerini bulma, oluşturma ve kullanma
• Evrişimli Sinir Ağlarının teorisi ve uygulaması
• Veri kümelerinde etki alanı kayması, birlikte oluşma ve diğer önyargıları işleme
• Öğrenimi aktarın ve başkalarının eğitim süresini ve hesaplama kaynaklarını kendi yararınıza kullanın
• Son teknoloji bir meme kanseri sınıflandırıcısı oluşturmak ve eğitmek
• Ana akım fikirlere sağlıklı bir şüphecilik dozu nasıl uygulanır ve yaygın olarak benimsenen tekniklerin sonuçları nasıl anlaşılır?
• t-SNE ve PCA kullanarak ConvNet'in “kavram uzayını” görselleştirme
• Şirketlerin daha iyi sonuçlar elde etmek için bilgisayarlı görme tekniklerini nasıl kullandıklarına dair vaka çalışmaları
• Uygun model değerlendirmesi, gizli uzay görselleştirmesi ve modelin dikkatinin belirlenmesi
• Alan araştırması yapmak, kendi veri kümelerinizi işlemek ve model testleri oluşturmak
• Son teknoloji mimariler, fikirlerin ilerlemesi, onları benzersiz kılan nedir ve nasıl uygulanacağı
• KerasCV – son teknoloji işlem hatları ve modeller oluşturmak için bir WIP kitaplığı
• Makaleleri nasıl ayrıştırıp okuyabilir ve bunları kendiniz uygulayabilirsiniz
• Uygulamanıza bağlı olarak model seçimi
• Uçtan uca bir makine öğrenimi ardışık düzeni oluşturma
• Daha Hızlı R-CNN'ler, RetinaNet'ler, SSD'ler ve YOLO ile nesne algılamada manzara ve sezgi
• Örnek ve anlamsal segmentasyon
• YOLOv5 ile Gerçek Zamanlı Nesne Tanıma
• YOLOv5 Nesne Dedektörlerinin Eğitimi
• KerasNLP (endüstri gücünde WIP kitaplığı) kullanarak Transformers ile çalışma
• Görüntülerin altyazılarını oluşturmak için Transformers'ı ConvNets ile entegre etme
• DeepDream
• Bilgisayarla görme için Derin Öğrenme modeli optimizasyonu