pytorch toolbelt

Pembaruan penting

Pada 24 Februari 2022, Rusia menyatakan perang dan menyerbu Ukraina yang damai. Setelah aneksasi Krimea dan pendudukan wilayah Donbas, rezim Putin memutuskan untuk menghancurkan kewarganegaraan Ukraina. Ukraina menunjukkan perlawanan sengit dan menunjukkan kepada seluruh dunia seperti apa rasanya memperjuangkan kemerdekaan bangsa.

Pemerintah Ukraina meluncurkan situs web untuk membantu ibu, istri & saudara perempuan Rusia menemukan orang -orang tercinta mereka terbunuh atau ditangkap di Ukraina - https://200rf.com & https://t.me/rf200_now (saluran telegram). Tujuan kami adalah untuk memberi tahu mereka yang masih di Rusia & Belarus, jadi mereka menolak untuk menyerang Ukraina.

Bantu kami mendapatkan paparan maksimal terhadap apa yang terjadi di Ukraina, kekerasan, dan tindakan teror yang tidak manusiawi yang dibawa oleh "dunia Rusia" ke Ukraina. Ini adalah wiki yang komprehensif tentang bagaimana Anda dapat membantu mengakhiri perang ini: https://how-to-help-ukraine-now.super.site/

Saluran resmi

• Akun Resmi Parlemen Ukraina
• Kementerian Pertahanan
• Kantor Presiden
• Kabinet Menteri Ukraina
• Pusat Komunikasi Strategis
• Menteri Luar Negeri Ukraina

Kemuliaan untuk Ukraina!

Pytorch-Toolbelt

A pytorch-toolbelt adalah perpustakaan Python dengan satu set lonceng dan peluit untuk Pytorch untuk prototipe R&D cepat dan pertanian kaggle:

Apa yang ada di dalamnya

• Bangunan Model Mudah Menggunakan Arsitektur Encoder-Decoder yang fleksibel.
• Modul: coordconv, scse, hypercolumn, konvolusi yang dapat dipisahkan secara mendalam dan banyak lagi.
• Augmentasi tta test-friendly-friendly TTA untuk segmentasi dan klasifikasi
• Inferensi ramah-GPU pada gambar besar (5000x5000)
• Rutinitas umum setiap hari (memperbaiki/mengembalikan benih acak, util sistem file, metrik)
• Kerugian: Binerfocalloss, Focal, RedangeFocal, Lovasz, Jaccard dan Dice Loss, Loss Wing dan banyak lagi.
• Ekstra untuk Perpustakaan Catalyst (Visualisasi Prediksi Batch, Metrik Tambahan)

Showcase: Catalyst, albumentation, pytorch toolbelt Contoh: segmentasi semantik @ camvid

Mengapa

Jawaban yang jujur adalah "Saya membutuhkan cara yang nyaman untuk menggunakan kembali kode untuk karier Kaggle saya". Selama 2018 saya mencapai lencana Kaggle Master dan ini merupakan jalan yang panjang. Sangat sering saya mendapati diri saya menggunakan kembali sebagian besar pipa lama berulang kali. Pada titik tertentu itu mengkristal ke dalam repositori ini.

LIB ini tidak dimaksudkan untuk menggantikan Catalyst / Ignite / Fast.AI kerangka kerja tingkat tinggi. Sebaliknya itu dirancang untuk melengkapi mereka.

Instalasi

pip install pytorch_toolbelt

Bagaimana saya ...

Penciptaan model

Buat model u-net encoder-decoder

Di bawah cuplikan kode yang membuat model Vanilla U-Net untuk segmentasi biner. Dengan desain, Encoder dan Decoder menghasilkan daftar tensor, dari Fine (resolusi tinggi, indeks 0 ) hingga peta fitur kasar (resolusi rendah). Akses ke semua peta fitur menengah bermanfaat jika Anda ingin menerapkan kerugian pengawasan yang mendalam pada mereka atau pengkode-dekoder tugas deteksi objek, di mana akses ke peta fitur menengah diperlukan.

 from torch import nn
from pytorch_toolbelt . modules import encoders as E
from pytorch_toolbelt . modules import decoders as D

class UNet ( nn . Module ):
    def __init__ ( self , input_channels , num_classes ):
        super (). __init__ ()
        self . encoder = E . UnetEncoder ( in_channels = input_channels , out_channels = 32 , growth_factor = 2 )
        self . decoder = D . UNetDecoder ( self . encoder . channels , decoder_features = 32 )
        self . logits = nn . Conv2d ( self . decoder . channels [ 0 ], num_classes , kernel_size = 1 )

    def forward ( self , x ):
        x = self . encoder ( x )
        x = self . decoder ( x )
        return self . logits ( x [ 0 ])

Buat model FPN encoder-decoder dengan encoder pretrained

Demikian pula dengan contoh sebelumnya, Anda dapat mengubah decoder menjadi FPN dengan kontatenasi.

 from torch import nn
from pytorch_toolbelt . modules import encoders as E
from pytorch_toolbelt . modules import decoders as D

class SEResNeXt50FPN ( nn . Module ):
   def __init__ ( self , num_classes , fpn_channels ):
       super (). __init__ ()
       self . encoder = E . SEResNeXt50Encoder ()
       self . decoder = D . FPNCatDecoder ( self . encoder . channels , fpn_channels )
       self . logits = nn . Conv2d ( self . decoder . channels [ 0 ], num_classes , kernel_size = 1 )

   def forward ( self , x ):
       x = self . encoder ( x )
       x = self . decoder ( x )
       return self . logits ( x [ 0 ])

Ubah Jumlah Saluran Input untuk Encoder

Semua encoder dari pytorch_toolbelt mendukung perubahan jumlah saluran input. Cukup hubungi encoder.change_input_channels(num_channels) dan lapisan konvolusi pertama akan diubah. Kapan pun memungkinkan, bobot lapisan konvolusional yang ada akan digunakan kembali (jika jumlah saluran baru lebih besar dari default, tensor berat baru akan di-empuk dengan kelonggaran yang diinisialisasi secara acak). Metode kelas mengembalikan self , jadi panggilan ini dapat dirantai.

 from pytorch_toolbelt . modules import encoders as E

encoder = E . SEResnet101Encoder ()
encoder = encoder . change_input_channels ( 6 )

Misc

Hitung Jumlah Parameter dalam Encoder/Decoder dan Modul Lainnya

Saat merancang model dan mengoptimalkan jumlah fitur dalam jaringan saraf, saya menemukan itu cukup berguna untuk mencetak jumlah parameter dalam blok tingkat tinggi (seperti encoder dan decoder ). Inilah cara melakukannya dengan pytorch_toolbelt :

 from torch import nn
from pytorch_toolbelt . modules import encoders as E
from pytorch_toolbelt . modules import decoders as D
from pytorch_toolbelt . utils import count_parameters

class SEResNeXt50FPN ( nn . Module ):
    def __init__ ( self , num_classes , fpn_channels ):
        super (). __init__ ()
        self . encoder = E . SEResNeXt50Encoder ()
        self . decoder = D . FPNCatDecoder ( self . encoder . channels , fpn_channels )
        self . logits = nn . Conv2d ( self . decoder . channels [ 0 ], num_classes , kernel_size = 1 )

    def forward ( self , x ):
        x = self . encoder ( x )
        x = self . decoder ( x )
        return self . logits ( x [ 0 ])

net = SEResNeXt50FPN ( 1 , 128 )
print ( count_parameters ( net ))
# Prints {'total': 34232561, 'trainable': 34232561, 'encoder': 25510896, 'decoder': 8721536, 'logits': 129}

Menyusun beberapa kerugian

Ada banyak cara untuk menggabungkan beberapa kerugian, dan kerangka kerja DL tingkat tinggi seperti Catalyst menawarkan cara yang lebih fleksibel untuk mencapai hal ini, tetapi inilah 100%-Pytorch implementasi saya:

 from pytorch_toolbelt import losses as L

# Creates a loss function that is a weighted sum of focal loss 
# and lovasz loss with weigths 1.0 and 0.5 accordingly.
loss = L . JointLoss ( L . FocalLoss (), L . LovaszLoss (), 1.0 , 0.5 )

Tta / inferensi

Terapkan augmentasi waktu tes (TTA) untuk model

Test-time augmetnation (TTA) dapat digunakan dalam fase pelatihan dan pengujian.

 from pytorch_toolbelt . inference import tta

model = UNet ()

# Truly functional TTA for image classification using horizontal flips:
logits = tta . fliplr_image2label ( model , input )

# Truly functional TTA for image segmentation using D4 augmentation:
logits = tta . d4_image2mask ( model , input )

Inferensi pada gambar besar:

Cukup sering, ada kebutuhan untuk melakukan segmentasi gambar untuk gambar yang sangat besar (5000px dan banyak lagi). Ada beberapa masalah dengan array piksel yang begitu besar:

1. Ada batasan ukuran pada ukuran maksimum tensor CUDA (nomor beton tergantung pada versi driver dan GPU)
2. Arsitektur CNNS berat dapat memakan semua memori GPU yang tersedia dengan mudah saat menyimpulkan gambar 1024x1024 yang relatif kecil, tidak meninggalkan ruang untuk resolusi gambar yang lebih besar.

Salah satu solusinya adalah mengiris gambar input ke dalam ubin (secara opsional tumpang tindih) dan memberi makan masing -masing melalui model dan menggabungkan hasilnya kembali. Dengan cara ini Anda dapat menjamin batas atas penggunaan RAM GPU, sambil menjaga kemampuan untuk memproses gambar berukuran sewenang-wenang pada GPU.

 import numpy as np
from torch . utils . data import DataLoader
import cv2

from pytorch_toolbelt . inference . tiles import ImageSlicer , CudaTileMerger
from pytorch_toolbelt . utils . torch_utils import tensor_from_rgb_image , to_numpy


image = cv2 . imread ( 'really_huge_image.jpg' )
model = get_model (...)

# Cut large image into overlapping tiles
tiler = ImageSlicer ( image . shape , tile_size = ( 512 , 512 ), tile_step = ( 256 , 256 ))

# HCW -> CHW. Optionally, do normalization here
tiles = [ tensor_from_rgb_image ( tile ) for tile in tiler . split ( image )]

# Allocate a CUDA buffer for holding entire mask
merger = CudaTileMerger ( tiler . target_shape , 1 , tiler . weight )

# Run predictions for tiles and accumulate them
for tiles_batch , coords_batch in DataLoader ( list ( zip ( tiles , tiler . crops )), batch_size = 8 , pin_memory = True ):
    tiles_batch = tiles_batch . float (). cuda ()
    pred_batch = model ( tiles_batch )

    merger . integrate_batch ( pred_batch , coords_batch )

# Normalize accumulated mask and convert back to numpy
merged_mask = np . moveaxis ( to_numpy ( merger . merge ()), 0 , - 1 ). astype ( np . uint8 )
merged_mask = tiler . crop_to_orignal_size ( merged_mask )

Contoh lanjutan

1. Segmentasi Sattelite Inria
2. Segmentasi semantik Camvid

Kutipan

 @misc{Khvedchenya_Eugene_2019_PyTorch_Toolbelt,
  author = {Khvedchenya, Eugene},
  title = {PyTorch Toolbelt},
  year = {2019},
  publisher = {GitHub},
  journal = {GitHub repository},
  howpublished = {url{https://github.com/BloodAxe/pytorch-toolbelt}},
  commit = {cc5e9973cdb0dcbf1c6b6e1401bf44b9c69e13f3}
}