Pengubah Penglihatan (ViTs): Penglihatan Komputer dengan Model Pengubah

Sejak beberapa tahun lalu, transformer telah mengubah domain NLP dalam pembelajaran mesin. Model seperti GPT dan BERT telah menetapkan penanda aras baharu dalam memahami dan menjana bahasa manusia. Kini prinsip yang sama telah digunakan untuk domain penglihatan komputer. Perkembangan terkini dalam bidang penglihatan komputer ialah penglihatan transformer atau ViT. Seperti yang diperincikan dalam makalah "Imej Bernilai 16x16 Perkataan: Transformer untuk Pengecaman Imej pada Skala", ViT dan model berasaskan pengubah direka untuk menggantikan konvolusi rangkaian saraf (CNN). Vision Transformers adalah pandangan baru dalam menyelesaikan masalah dalam komputer penglihatan. Daripada bergantung pada rangkaian neural convolutional tradisional (CNN), yang telah menjadi tulang belakang tugas berkaitan imej selama beberapa dekad, ViT menggunakan seni bina transformer untuk memproses imej. Mereka merawat tampalan imej seperti perkataan dalam ayat, membolehkan model mempelajari perhubungan antara patch ini, sama seperti ia mempelajari konteks dalam a perenggan teks.

Tidak seperti CNN, ViT membahagikan imej input kepada tampalan, bersirikannya menjadi vektor, dan mengurangkan dimensinya menggunakan matriks pendaraban. Pengekod pengubah kemudian memproses vektor ini sebagai benam token. Dalam artikel ini, kami akan meneroka pengubah penglihatan dan perbezaan utama mereka daripada rangkaian neural convolutional. Apa yang membuat mereka amat menarik ialah keupayaan mereka untuk memahami global corak dalam imej, yang merupakan sesuatu yang boleh dihadapi oleh CNN.

Apakah itu pengubah penglihatan?

Pengubah penglihatan menggunakan konsep perhatian dan pengubah untuk proses imej—ini serupa dengan transformer dalam bahasa semula jadi konteks pemprosesan (NLP). Walau bagaimanapun, daripada menggunakan token, imej itu adalah berpecah kepada tompok dan disediakan sebagai urutan tertanam linear. Ini patch dilayan dengan cara yang sama token atau perkataan dirawat dalam NLP.

Daripada melihat keseluruhan gambar secara serentak, ViT memotong imej menjadi kepingan kecil seperti jigsaw puzzle. Setiap bahagian dipusing ke dalam senarai nombor (vektor) yang menerangkan ciri-cirinya, dan kemudian model melihat semua bahagian dan memikirkan bagaimana ia berkaitan satu sama lain menggunakan mekanisme pengubah.

Tidak seperti CNN, ViT berfungsi dengan menggunakan penapis atau kernel tertentu di atas imej untuk mengesan ciri tertentu, seperti corak tepi. Ini adalah proses lilitan yang hampir sama dengan pengimbasan pencetak an imej. Penapis ini meluncur ke seluruh imej dan menyerlahkan ciri penting. Rangkaian kemudian menyusun berbilang lapisan penapis ini, mengenal pasti corak yang lebih kompleks secara beransur-ansur.
Dengan CNN, lapisan pengumpulan mengurangkan saiz peta ciri. Ini lapisan menganalisis ciri yang diekstrak untuk membuat ramalan berguna untuk pengecaman imej, pengesanan objek, dll. Walau bagaimanapun, CNN mempunyai tetap medan penerimaan, dengan itu mengehadkan keupayaan untuk memodelkan jarak jauh kebergantungan.

Bagaimana CNN melihat imej?

ViT, walaupun mempunyai lebih banyak parameter, gunakan mekanisme perhatian diri untuk perwakilan ciri yang lebih baik dan mengurangkan keperluan untuk lapisan yang lebih dalam. CNN memerlukan seni bina yang lebih mendalam untuk mencapai yang serupa kuasa perwakilan, yang membawa kepada peningkatan kos pengiraan.

Selain itu, CNN tidak boleh menangkap corak imej peringkat global kerana penapis mereka memfokuskan pada kawasan setempat imej. Untuk memahami keseluruhan imej atau hubungan jauh, CNN bergantung pada menyusun banyak lapisan dan penyatuan, meluaskan bidang pandangan. Walau bagaimanapun, proses ini boleh kehilangan maklumat global kerana ia mengagregatkan butiran langkah demi langkah.

ViT, sebaliknya, membahagikan imej kepada tompok yang dianggap sebagai token input individu. Menggunakan perhatian diri, ViT membandingkan semua tampalan serentak dan pelajari cara ia berkait. Ini membolehkan mereka untuk menangkap corak dan kebergantungan merentas keseluruhan imej tanpa membinanya selapis demi selapis.

Apakah itu Induktif Bias?

Sebelum melangkah lebih jauh, adalah penting untuk memahami konsep bias induktif. Bias induktif merujuk kepada andaian yang dibuat oleh model tentang data struktur; semasa latihan, ini membantu model menjadi lebih umum dan mengurangkan berat sebelah. Dalam CNN, bias induktif termasuk:

1. Lokaliti: Ciri dalam imej (seperti tepi atau tekstur) disetempatkan dalam kawasan kecil.
2. Struktur kejiranan dua dimensi: Piksel berdekatan berkemungkinan besar berkaitan, jadi penapis beroperasi pada kawasan bersebelahan ruang.
3. Terjemahan kesetaraan: Ciri yang dikesan dalam satu bahagian imej, seperti tepi, mengekalkan makna yang sama jika ia muncul di bahagian lain.

Kecondongan ini menjadikan CNN sangat cekap untuk tugas imej, kerana ia adalah direka bentuk secara semula jadi untuk mengeksploitasi ruang dan struktur imej sifat.

Pengubah Penglihatan (ViT) mempunyai kecondongan induktif khusus imej yang kurang ketara berbanding CNN. Dalam ViT:

• Pemprosesan global: Lapisan perhatian kendiri beroperasi pada keseluruhan imej, menjadikan model menangkap hubungan global dan kebergantungan tanpa dihadkan oleh kawasan setempat.
• Struktur 2D minimum: Struktur 2D imej digunakan hanya pada permulaan (apabila imej dibahagikan kepada patch) dan semasa penalaan halus (untuk melaraskan benam kedudukan untuk berbeza resolusi). Tidak seperti CNN, ViT tidak menganggap bahawa piksel berdekatan adalah semestinya berkaitan.
• Hubungan ruang yang dipelajari: Pembenaman kedudukan dalam ViT tidak mengekodkan perhubungan spatial 2D tertentu pada permulaan. Sebaliknya, model mempelajari semua perhubungan spatial daripada data semasa latihan.

Cara Pengubah Penglihatan Berfungsi

Pengubah Penglihatan menggunakan seni bina Transformer standard dibangunkan untuk urutan teks 1D. Untuk memproses imej 2D, ia adalah dibahagikan kepada tompok kecil saiz tetap, seperti piksel P P, yang diratakan menjadi vektor. Jika imej mempunyai dimensi H  W dengan C saluran, jumlah bilangan tampalan ialah N = H  W / P  P yang berkesan panjang jujukan input untuk Transformer. Tompok leper ini adalah kemudian diunjurkan secara linear ke dalam ruang berdimensi tetap D, dipanggil tampalan embeddings.

Token khas yang boleh dipelajari, serupa dengan token [CLS] dalam BERT, ialah ditambah kepada urutan pembenaman tampalan. Token ini mempelajari a perwakilan imej global yang kemudiannya digunakan untuk pengelasan. Selain itu, benam kedudukan ditambah pada benam tampalan ke mengekod maklumat kedudukan, membantu model memahami spatial struktur imej.

Jujukan benam dilalui melalui pengekod Transformer, yang berselang-seli antara dua operasi utama: Perhatian Diri Berbilang Kepala (MSA) dan rangkaian neural suapan, juga dipanggil blok MLP. Setiap lapisan termasuk Normalisasi Lapisan (LN) digunakan sebelum operasi ini dan sambungan baki ditambah selepas itu untuk menstabilkan latihan. Keluaran pengekod Transformer, khususnya keadaan token [CLS], digunakan sebagai imej perwakilan.

Kepala ringkas ditambahkan pada token [CLS] akhir untuk pengelasan tugasan. Semasa pralatihan, kepala ini ialah perceptron berbilang lapisan kecil (MLP), manakala dalam penalaan halus, ia biasanya satu lapisan linear. ini seni bina membolehkan ViT memodelkan hubungan global dengan berkesan antara tampalan dan gunakan kuasa penuh perhatian diri untuk imej pemahaman.

Dalam model Pengubah Penglihatan hibrid, bukannya membahagikan secara langsung imej mentah menjadi tampalan, urutan input diperoleh daripada peta ciri dihasilkan oleh CNN. CNN memproses imej terlebih dahulu, mengekstrak ciri spatial yang bermakna, yang kemudiannya digunakan untuk membuat tampalan. Tompok ini diratakan dan ditayangkan ke dalam ruang dimensi tetap menggunakan unjuran linear yang boleh dilatih yang sama seperti dalam Visi standard Transformers. Satu kes khas pendekatan ini adalah menggunakan tompok saiz 1×1, di mana setiap tampalan sepadan dengan satu lokasi spatial dalam Peta ciri CNN.

Dalam kes ini, dimensi spatial peta ciri ialah diratakan, dan urutan yang terhasil diunjurkan ke dalam Dimensi input Transformer. Seperti ViT standard, a token klasifikasi dan benam kedudukan ditambah untuk mengekalkan maklumat kedudukan dan untuk membolehkan pemahaman imej global. ini pendekatan hibrid memanfaatkan kekuatan pengekstrakan ciri tempatan CNN sambil menggabungkannya dengan keupayaan pemodelan global bagi Transformers.

Demo Kod

Berikut ialah blok kod tentang cara menggunakan pengubah penglihatan pada imej.

# Install the necessary libraries  pip install -q transformers

from transformers import ViTForImageClassification  
from PIL import Image  
from transformers import ViTImageProcessor

import requests  
import torch

# Load the model and move it to ‘GPU’  device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')model = ViTForImageClassification.from_pretrained('google/vit-base-patch16-224')  model.to(device)

# Load the Pengubah Penglihatan (ViTs): Penglihatan Komputer dengan Model Pengubah to perform predictions  url = 'link to your Pengubah Penglihatan (ViTs): Penglihatan Komputer dengan Model Pengubah'  Pengubah Penglihatan (ViTs): Penglihatan Komputer dengan Model Pengubah = Image.open(requests.get(url, stream=True).raw)processor = ViTImageProcessor.from_pretrained('google/vit-base-patch16-224')  inputs = processor(Pengubah Penglihatan (ViTs): Penglihatan Komputer dengan Model Pengubahs=Pengubah Penglihatan (ViTs): Penglihatan Komputer dengan Model Pengubah, return_tensors="pt").to(device)  pixel_values = inputs.pixel_values  
# print(pixel_values.shape)

Yang Model ViT memproses imej. Ia terdiri daripada pengekod seperti BERT dan a kepala pengelasan linear terletak di atas keadaan tersembunyi terakhir token [CLS].

with torch.no_grad():  
  outputs = model(pixel_values)  logits = outputs.logits# logits.shapeprediction = logits.argmax(-1)  print("Predicted class:", model.config.id2label[prediction.item()])

Ini pelaksanaan asas Vision Transformer (ViT) menggunakan PyTorch. ini kod termasuk komponen teras: pembenaman tampalan, pengekodan kedudukan, dan pengekod Transformer. Ini boleh digunakan untuk pengelasan mudah tugasan.

import torchimport torch.nn as nnimport torch.nn.functional as Fclass VisionTransformer(nn.Module):
    def __init__(self, img_size=224, patch_size=16, num_classes=1000, dim=768, depth=12, heads=12, mlp_dim=3072, dropout=0.1):
        super(VisionTransformer, self).__init__()
        
        # Image and patch dimensions
        assert img_size % patch_size == 0, "Image size must be divisible by patch size"
        self.num_patches = (img_size // patch_size) ** 2
        self.patch_dim = (3 * patch_size ** 2)  # Assuming 3 channels (RGB)
        
        # Layers
        self.patch_embeddings = nn.Linear(self.patch_dim, dim)
        self.position_embeddings = nn.Parameter(torch.randn(1, self.num_patches   1, dim))
        self.cls_token = nn.Parameter(torch.randn(1, 1, dim))
        self.dropout = nn.Dropout(dropout)
        
        # Transformer Encoder
        self.transformer = nn.TransformerEncoder(
            nn.TransformerEncoderLayer(d_model=dim, nhead=heads, dim_feedforward=mlp_dim, dropout=dropout),
            num_layers=depth        )
        
        # MLP Head for classification
        self.mlp_head = nn.Sequential(
            nn.LayerNorm(dim),
            nn.Linear(dim, num_classes)
        )
    
    def forward(self, x):
        # Flatten patches and embed
        batch_size, channels, height, width = x.shape
        patch_size = height // int(self.num_patches ** 0.5)

        x = x.unfold(2, patch_size, patch_size).unfold(3, patch_size, patch_size)
        x = x.contiguous().view(batch_size, 3, patch_size, patch_size, -1)
        x = x.permute(0, 4, 1, 2, 3).flatten(2).permute(0, 2, 1)
        x = self.patch_embeddings(x)
        
        # Add positional embeddings
        cls_tokens = self.cls_token.expand(batch_size, -1, -1)
        x = torch.cat((cls_tokens, x), dim=1)
        x = x   self.position_embeddings
        x = self.dropout(x)
        
        # Transformer Encoder
        x = self.transformer(x)
        
        # Classification Head
        x = x[:, 0]  # CLS token
        return self.mlp_head(x)# Example usageif __name__ == "__main__":
    model = VisionTransformer(img_size=224, patch_size=16, num_classes=10, dim=768, depth=12, heads=12, mlp_dim=3072)
    print(model)
    
    dummy_img = torch.randn(8, 3, 224, 224)  # Batch of 8 Pengubah Penglihatan (ViTs): Penglihatan Komputer dengan Model Pengubahs, 3 channels, 224x224 size
    preds = model(dummy_img)
    print(preds.shape)  # Output: [8, 10] (Batch size, Number of classes)

Atas ialah kandungan terperinci Pengubah Penglihatan (ViTs): Penglihatan Komputer dengan Model Pengubah. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!