pytorch toolbelt
Pytorch Toolbelt 0.8.0
Am 24. Februar 2022 erklärte Russland den Krieg und drang in die friedliche Ukraine ein. Nach der Annexion der Krim und der Besetzung der Regime von Donbas beschloss das Regime von Putin, die ukrainische Staatsangehörigkeit zu zerstören. Die Ukrainer zeigen heftigen Widerstand und demonstrieren der ganzen Welt, wie es ist, für die Unabhängigkeit der Nation zu kämpfen.
Die ukrainische Regierung startete eine Website, auf der russische Mütter, Frauen und Schwestern ihre geliebten in der Ukraine getöteten oder gefangen genommenen - https://200rf.com & https://t.me/rf200_now (Telegrammkanal) getötet oder gefangen genommen haben. Unser Ziel ist es, die noch in Russland und in Belarus zu informieren, damit sie sich weigern, die Ukraine anzugreifen.
Helfen Sie uns, maximal das zu erhalten, was in der Ukraine, Gewalt und unmenschlichen Terrorakten geschieht, die die "russische Welt" in die Ukraine gebracht hat. Dies ist ein umfassendes Wiki darüber, wie Sie diesen Krieg beenden können: https://how-to-help-ukraine-now.super.site/
Offizielle Kanäle
Ruhm der Ukraine!
Ein pytorch-toolbelt ist eine Python-Bibliothek mit einem Satz Glocken und Pfeifen für Pytorch für schnelle F & E-Prototypen und Kaggle Farming:
Showcase: Catalyst, Albumentations, Pytorch Toolbelt Beispiel: Semantische Segmentierung @ camvid
Ehrliche Antwort lautet: "Ich brauchte eine bequeme Möglichkeit, Code für meine Kaggle-Karriere wieder zu verwenden." Im Jahr 2018 habe ich ein Kaggle Master -Abzeichen erreicht und dies war ein langer Weg. Sehr oft verwendete ich immer wieder die meisten alten Pipelines. Irgendwann kristallisierte es in dieses Repository.
Diese LIB soll Catalyst / Ignite / Fast.ai hochrangige Rahmenbedingungen nicht ersetzen. Stattdessen soll es sie ergänzen.
pip install pytorch_toolbelt
Unter einem Code-Snippet, das Vanille-U-NET-Modell für die binäre Segmentierung erstellt. Für das Design erzeugt sowohl Encoder als auch Decoder eine Liste von Tensoren, von feiner (hochauflösender, indizierter 0 ) bis grober Merkmalskarten (niedrige Auflösung). Der Zugriff auf alle Zwischenfunktionskarten ist von Vorteil, wenn Sie tiefe Überwachungsverluste auf diese oder Encoder-Decoder der Objekterkennungsaufgabe anwenden möchten, wobei der Zugriff auf Intermediate-Feature-Karten erforderlich ist.
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 ])Ähnlich wie bei früheren Beispielen können Sie den Decoder in FPN um kontaktiert wechseln.
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 ]) Alle Encoder von pytorch_toolbelt unterstützt die Änderung der Anzahl der Eingabedanäle. Rufen Sie einfach encoder.change_input_channels(num_channels) auf und die erste Faltungsschicht wird geändert. Wenn möglich, werden vorhandene Gewichte der Faltungsschicht wiederverwendet (falls die neue Anzahl von Kanälen größer als Standard ist, wird der neue Gewichtstensor mit zufällig initialisierten Weigen gepolstert). Die Klassenmethode gibt self zurück, sodass dieser Anruf angekettet werden kann.
from pytorch_toolbelt . modules import encoders as E
encoder = E . SEResnet101Encoder ()
encoder = encoder . change_input_channels ( 6 ) Bei der Gestaltung eines Modells und der Optimierung der Anzahl der Funktionen im neuronalen Netzwerk stellte ich fest, dass es sehr nützlich ist, die Anzahl von Parametern in hochrangigen Blöcken (wie encoder und decoder ) zu drucken. Hier erfahren Sie, wie man es mit pytorch_toolbelt macht:
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}Es gibt mehrere Möglichkeiten, mehrere Verluste zu kombinieren, und hochrangige DL-Frameworks wie Catalyst bieten viel flexiblere Möglichkeit, dies zu erreichen.
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 )Die Testzeit-Augmetnation (TTA) kann sowohl in Trainings- als auch in Testphasen verwendet werden.
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 )Sehr oft besteht die Notwendigkeit, eine Bildsegmentierung für enorm großes Bild (5000px und mehr) durchzuführen. Es gibt einige Probleme mit solch großen Pixel -Arrays:
Eine der Lösungen besteht darin, das Eingabebild in Fliesen zu schneiden (optional überlappend) und jedes Modell zu füttern und die Ergebnisse zurückzuschließen. Auf diese Weise können Sie die Obergrenze der GPU-RAM-Verwendung garantieren und gleichzeitig die Fähigkeit zur Verarbeitung beliebiger Bilder von GPU beibehalten.
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 ) @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}
}
