[PYTHON] Verwendung der PyTorch-basierten Bildverarbeitungsbibliothek "Kornia"

Einführung

Ich benutze PyTorch oft als Framework für tiefes Lernen, habe aber kürzlich etwas über eine Bildverarbeitungsbibliothek namens "Kornia" gelernt, die auf PyTorch basiert. Also habe ich die Grundfunktionen und die Verwendung untersucht und werde sie als Memorandum belassen.

Was ist Kornia?

Kornia ist eine Open-Source-Computer-Vision-Bibliothek, die mit PyTorch als Backend implementiert wurde. (Kornia GitHub)

It consists of a set of routines and differentiable modules to solve generic computer vision problems. At its core, the package uses PyTorch as its main backend both for efficiency and to take advantage of the reverse-mode auto-differentiation to define and compute the gradient of complex functions.

Es implementiert Bildverarbeitungsvorgänge auf niedriger Ebene, die OpenCV ähneln, wie z. B. Filtern, Farbkonvertierung und geometrische Konvertierung. Und da PyTorch das Backend ist, hat es den Vorteil, dass es anfälliger für die Vorteile der GPU-Unterstützung und der automatischen Differenzierung ist.

Installation und Grundnutzung

Die Installation kann mit Pip usw. erfolgen, wie in README beschrieben. (In diesem Fall wird PyTorch automatisch eingegeben.) pip install kornia

• Ab dem 20.06.2020 wurde kornia 0.3.1 / pytorch 1.5.1 installiert.

Sie benötigen außerdem OpenCV, matplotlib und torchvision, um die verschiedenen Tutorials auszuführen (https://kornia.readthedocs.io/en/latest/tutorials/index.html).

Als Beispiel für die grundlegende Verwendung wird wie folgt vorgegangen, um Gaußsche Unschärfe auf ein Bild anzuwenden.

import kornia
import cv2

#Bildlesung mit OpenCV
img_src = cv2.imread('./data/lena.jpg')
img_src = cv2.cvtColor(img_src, cv2.COLOR_BGR2RGB)

# torch.In Tensor konvertieren
tensor_src = kornia.image_to_tensor(img_src, keepdim=False).float() # 1xCxHxW

# Gaussian Blur
gauss = kornia.filters.GaussianBlur2d((11, 11), (10.5, 10.5))
tensor_blur = gauss(tensor_src)

# OpenCV(numpy.ndarray)Zurück zum Bild
img_blur = kornia.tensor_to_image(tensor_blur.byte())

# --> show [img_src | img_blur]

Andere Bildverarbeitungsbeispiele

Ein anderes Beispiel für Unschärfe und Farbänderung als oben ist unten gezeigt.

# Box Blur
tensor_blur = kornia.box_blur(tensor_src, (9, 9))

# Median Blur
tensor_blur = kornia.median_blur(tensor_src, (5, 5))

# Adjust Brightness
tensor_brightness = kornia.adjust_brightness(tensor_src, 0.6)

# Adjust Contrast
tensor_contrast = kornia.adjust_contrast(tensor_src, 0.2)

# Adjust Gamma
tensor_gamma = kornia.adjust_gamma(tensor_src, gamma=3., gain=1.5)

# Adjust Saturation
tensor_saturated = kornia.adjust_saturation(tensor_src, 0.2)

# Adjust Hue
tensor_hue = kornia.adjust_hue(tensor_src, 0.5)

Kombination mit Fackel.nn.Sequential

Wenn Sie die oben beschriebene Verarbeitung mit nn.Sequential zusammenfassen, können Sie die Vorverarbeitung des Bildes sauber schreiben. Das Folgende ist ein Beispiel. Darüber hinaus wird hier die Verarbeitung auf der GPU unter der Voraussetzung einer Umgebung durchgeführt, in der die GPU verwendet werden kann.

import torch
import torch.nn as nn
from torch.utils.data import Dataset, DataLoader
import kornia

class DummyDataset(Dataset):
    def __init__(self):
        self.data_index = range(100)

    def __len__(self):
        return len(self.data_index)

    def __getitem__(self, idx):
        # generate dummy image and label
        image = torch.rand(3, 240, 320)
        label = torch.randint(5, (1,))
        return image, label

device = torch.device('cuda')

dataset = DummyDataset()
loader = DataLoader(dataset, batch_size=16, shuffle=True)

transform = nn.Sequential(
    kornia.color.AdjustSaturation(0.2),
    kornia.color.AdjustBrightness(0.5),
    kornia.color.AdjustContrast(0.7),
)

for i, (images, labels) in enumerate(loader):
    print(f'iter: {i}, images: {images.shape}, labels: {labels.shape}')

    images = images.to(device) # -->Zur GPU
    images_tr = transform(images) #Wenden Sie die Transformation auf das Bild an

    # training etc ...

Beispiel für die Verwendung der automatischen Differenzierung

Als Beispiel für die Verwendung der automatischen Differenzierung von PyTorch werde ich am Tutorial total_variation_denoising.py (Total Fluktuation Noise Removal) teilnehmen.

# read the image with OpenCV
img: np.ndarray = cv2.imread('./data/doraemon.png')
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) / 255.0
img = img + np.random.normal(loc=0.0, scale=0.1, size=img.shape)
img = np.clip(img, 0.0, 1.0)

# convert to torch tensor
noisy_image: torch.tensor = kornia.image_to_tensor(img).squeeze()  # CxHxW

# define the total variation denoising network
class TVDenoise(torch.nn.Module):
   def __init__(self, noisy_image):
       super(TVDenoise, self).__init__()
       self.l2_term = torch.nn.MSELoss(reduction='mean')
       self.regularization_term = kornia.losses.TotalVariation()
       # create the variable which will be optimized to produce the noise free image
       self.clean_image = torch.nn.Parameter(data=noisy_image.clone(), requires_grad=True)
       self.noisy_image = noisy_image

   def forward(self):
       return self.l2_term(self.clean_image, self.noisy_image) + 0.0001 * self.regularization_term(self.clean_image)

   def get_clean_image(self):
       return self.clean_image

tv_denoiser = TVDenoise(noisy_image)

# define the optimizer to optimize the 1 parameter of tv_denoiser
optimizer = torch.optim.SGD(tv_denoiser.parameters(), lr=0.1, momentum=0.9)

# run the optimization loop
num_iters = 500
for i in range(num_iters):
   optimizer.zero_grad()
   loss = tv_denoiser()
   if i % 25 == 0:
       print("Loss in iteration {} of {}: {:.3f}".format(i, num_iters, loss.item()))
   loss.backward()
   optimizer.step()

# convert back to numpy
img_clean: np.ndarray = kornia.tensor_to_image(tv_denoiser.get_clean_image())

Hier wird noisy_image an torch.nn.Parameter () übergeben, um clean_image zum Ausgangszustand zu machen. (Dies ist das Update-Ziel des Optimierers) Darüber hinaus wird kornias TotalVariation () als Regularisierungsbegriff verwendet.

• Der Total Variation-Regularisierungsterm ist ein Strafterm, wenn der Unterschied zwischen benachbarten Pixeln groß ist. Er entfernt Rauschkomponenten und glättet das Bild.

Zusammenfassung

Wir untersuchten die Verwendung der Pytorch-basierten Bildverarbeitungsbibliothek Kornia und konzentrierten uns dabei auf Tutorials. Es gibt wahrscheinlich verschiedene nützliche Funktionen außer denen, die ich dieses Mal geschrieben habe. Es kann nicht nur zur Bildvorbereitung, sondern auch zur Weiterleitung des neuronalen Netzwerks verwendet werden. Daher dachte ich, dass es nützlich sein könnte, wenn Sie eine Verarbeitung hinzufügen möchten, die von gewöhnlichen Fackeln / Fackeln nicht allein verarbeitet werden kann.