[PYTHON] Auswirkungen von Bildrotation, -vergrößerung, -farbe usw. auf das Faltungsnetzwerk (CNN)

Die Klassifizierungsleistung wird verbessert, wenn das Bild gedreht, vergrößert, in der Farbe geändert usw. wird, um die Eigenschaften des Faltungs-Neuronalen Netzwerks (CNN) und anderer Methoden des maschinellen Lernens (Gradientenverstärkung, mehrschichtiges Perzeptron) zu verstehen. Ich habe versucht, wie es sich ändern würde.

Das Bild wurde mit der Methode Bild von Koala und Bär automatisch generieren erstellt. Kannst du Koala und Kuma anhand der Silhouette unterscheiden?

Code

Lesen von Bilddaten

from PIL import Image

koalas = []
for i in range(num_data):
    koala = Image.open("koala_or_bear/koala_{}.jpg ".format(i))
    koalas.append(koala)

bears = []
for i in range(num_data):
    bear = Image.open("koala_or_bear/bear_{}.jpg ".format(i))
    bears.append(bear)

Erste Datenanzeige

%matplotlib inline
import matplotlib.pyplot as plt

fig = plt.figure(figsize=(10,10))
for i in range(16):
    ax = fig.add_subplot(4, 4, i+1)
    ax.axis('off')
    if i < 8:
        ax.set_title('koala_{}'.format(i))
        ax.imshow(koalas[i],cmap=plt.cm.gray, interpolation='none')
    else:
        ax.set_title('bear_{}'.format(i - 8))
        ax.imshow(bears[i - 8],cmap=plt.cm.gray, interpolation='none')
plt.show()

Erklärende Variable / Zielvariable

import numpy as np

X = [] #Erklärende Variable
Y = [] #Objektive Variable

index = 0
for koala in koalas:
    resize_img = koala.resize((128, 128))
    r, g, b = resize_img.split()
    r_resize_img = np.asarray(np.float32(r)/255.0)
    g_resize_img = np.asarray(np.float32(g)/255.0)
    b_resize_img = np.asarray(np.float32(b)/255.0)
    rgb_resize_img = np.asarray([r_resize_img, g_resize_img, b_resize_img])
    X.append(rgb_resize_img)
    Y.append(0)
    index += 1
    if index >= num_data:
        break

index = 0
for bear in bears:
    resize_img = bear.resize((128, 128))
    r, g, b = resize_img.split()
    r_resize_img = np.asarray(np.float32(r)/255.0)
    g_resize_img = np.asarray(np.float32(g)/255.0)
    b_resize_img = np.asarray(np.float32(b)/255.0)
    rgb_resize_img = np.asarray([r_resize_img, g_resize_img, b_resize_img])
    X.append(rgb_resize_img)
    Y.append(1)
    index += 1
    if index >= num_data:
        break

X = np.array(X, dtype='float32')
Y = np.array(Y, dtype='int64')

Getrennt in Lehrerset und Testset

from sklearn import model_selection
X_train, X_test, Y_train, Y_test = model_selection.train_test_split(
    X, Y, test_size=0.1
)

Datentypkonvertierung für Scikit-Learn

d1, d2, d3, d4 = X_train.shape
X_train_a = X_train.reshape((d1, d2 * d3 * d4))
Y_train_onehot = np.identity(2)[Y_train]
d1, d2, d3, d4 = X_test.shape
X_test_a = X_test.reshape((d1, d2 * d3 * d4))
Y_test_onehot = np.identity(2)[Y_test]

Datentypkonvertierung für PyTorch

import torch
from torch.utils.data import TensorDataset
from torch.utils.data import DataLoader

X_train_t = torch.from_numpy(X_train).float()
Y_train_t = torch.from_numpy(Y_train).long()

X_train_v = torch.autograd.Variable(X_train_t)
Y_train_v = torch.autograd.Variable(Y_train_t)

X_test_t = torch.from_numpy(X_test).float()
Y_test_t = torch.from_numpy(Y_test).long()

X_test_v = torch.autograd.Variable(X_test_t)
Y_test_v = torch.autograd.Variable(Y_test_t)

train = TensorDataset(X_train_t, Y_train_t)
train_loader = DataLoader(train, batch_size=32, shuffle=True)

Gradientenverstärkung

%%time
from sklearn.ensemble import GradientBoostingClassifier

classifier = GradientBoostingClassifier()
classifier.fit(X_train_a, Y_train)
print("Accuracy score (train): ", classifier.score(X_train_a, Y_train))
print("Accuracy score (test): ", classifier.score(X_test_a, Y_test))

Mehrschichtiges Perceptron (1 Zwischenschicht)

%%time
from sklearn.neural_network import MLPClassifier

classifier = MLPClassifier(max_iter=10000, early_stopping=True)
classifier.fit(X_train_a, Y_train)
print("Accuracy score (train): ", classifier.score(X_train_a, Y_train))
print("Accuracy score (test): ", classifier.score(X_test_a, Y_test))

Mehrschichtiges Perceptron (2 Zwischenschichten)

%%time
from sklearn.neural_network import MLPClassifier
classifier = MLPClassifier(max_iter=10000, early_stopping=True,
                           hidden_layer_sizes=(100, 100))
classifier.fit(X_train_a, Y_train)
print("Accuracy score (train): ", classifier.score(X_train_a, Y_train))
print("Accuracy score (test): ", classifier.score(X_test_a, Y_test))

Faltungs-Neuronales Netz (CNN)

Netzwerkdefinition

class CNN(torch.nn.Module):
    def __init__(self):
        super(CNN, self).__init__()
        self.conv1 = torch.nn.Conv2d(3, 10, 5)
        self.conv2 = torch.nn.Conv2d(10, 20, 5)
        self.fc1 = torch.nn.Linear(20 * 29 * 29, 50)
        self.fc2 = torch.nn.Linear(50, 2)
    
    def forward(self, x):
        x = torch.nn.functional.relu(self.conv1(x))
        x = torch.nn.functional.max_pool2d(x, 2)
        x = torch.nn.functional.relu(self.conv2(x))
        x = torch.nn.functional.max_pool2d(x, 2)
        x = x.view(-1, 20 * 29 * 29)
        x = torch.nn.functional.relu(self.fc1(x))
        x = torch.nn.functional.log_softmax(self.fc2(x), 1)
        return x

Überprüfen der Netzwerkstruktur

from torchsummary import summary
model = CNN()
summary(model, X[0].shape)

----------------------------------------------------------------
        Layer (type)               Output Shape         Param #
================================================================
            Conv2d-1         [-1, 10, 124, 124]             760
            Conv2d-2           [-1, 20, 58, 58]           5,020
            Linear-3                   [-1, 50]         841,050
            Linear-4                    [-1, 2]             102
================================================================
Total params: 846,932
Trainable params: 846,932
Non-trainable params: 0
----------------------------------------------------------------
Input size (MB): 0.19
Forward/backward pass size (MB): 1.69
Params size (MB): 3.23
Estimated Total Size (MB): 5.11
----------------------------------------------------------------

Funktion zur Ausführung

def learn(model, criterion, optimizer, n_iteration):
    for epoch in range(n_iteration):
        total_loss = np.array(0, dtype='float64')
        for x, y in train_loader:
            x = torch.autograd.Variable(x)
            y = torch.autograd.Variable(y)
            optimizer.zero_grad()
            y_pred = model(x)
            loss = criterion(y_pred, y)
            loss.backward()
            optimizer.step()
            total_loss += loss.data.numpy()
        
        if (epoch + 1) % 10 == 0:
            print(epoch + 1, total_loss)
        
        if total_loss == np.array(0, dtype='float64'):
            break
        
        loss_history.append(total_loss)
    
    return model

Ausführungscode

#%%time
model = CNN()
criterion = torch.nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.01)
loss_history = []
model = learn(model, criterion, optimizer, 300)

Verlustverlaufsanzeige

ax = plt.subplot(2, 1, 1)
ax.plot(loss_history)
ax.grid()
ax = plt.subplot(2, 1, 2)
ax.plot(loss_history)
ax.set_yscale('log')
ax.grid()

Richtige Antwortrate

Richtige Antwortrate (Lehrer eingestellt)

Y_pred = torch.max(model(X_train_v).data, 1)[1]
accuracy = sum(Y_train == Y_pred.numpy()) / len(Y_train)
print(accuracy)

Richtige Antwortrate (Testsatz)

Y_pred = torch.max(model(X_test_v).data, 1)[1]
accuracy = sum(Y_test == Y_pred.numpy()) / len(Y_test)
print(accuracy)

Ergebnis

Erstens die einfachste Frage, um zwischen Koala und Kuma zu unterscheiden.

Alle Vorhersagemethoden konnten perfekt antworten.

Erweiterung

Vergrößern wir Koala und Kuma mit zufälligen Vergrößerungen. Zu diesem Zeitpunkt werde ich versuchen, es leicht vertikal und horizontal zu verschieben.

Der Prozentsatz der richtigen Antworten für die Gradientenverstärkung ist leicht gesunken. Das Convolution Neural Network (CNN) hat den perfekten Prozentsatz an richtigen Antworten.

Es gibt ein Hindernis

Zeichnen Sie etwas, das im Hintergrund stören könnte.

Es scheint fast keine Wirkung zu haben.

Färben Sie nur den Hintergrund

Lassen Sie uns den Hintergrund bunt machen.

Dies scheint auch wenig Wirkung zu haben.

Nur Tiere färben

Lassen Sie uns Koala und Kuma bunt machen.

Die Vorhersagegenauigkeit ist erheblich gesunken. Die Leistung des Convolutional Neural Network (CNN) ist gesunken. Das? Überraschenderweise geht es dem mehrschichtigen Perceptron (mittlere zwei Schichten) gut. Und die Leistung der Gradientenverstärkung hat sich kaum verschlechtert. Es ist wunderbar.

Vergrößert / farbig / mit Hindernissen

Der Schwierigkeitsgrad hat zugenommen, aber die Gradientenverstärkung ist ziemlich gut. Das Convolutional Neural Network (CNN) ist völlig nutzlos.

Vergrößerung / Färbung / nur Tiere sind schwarz / es gibt Hindernisse

Alle Vorhersageleistungen wurden wiederhergestellt, indem die Farben von Koala und Kuma zu Schwarz vereinigt wurden. Das ist schließlich das Kriterium.

Drehung

Es dreht sich um Koala dreht sich um Bären drehen sich auch um

Das mehrschichtige Perceptron (mittlere 1 Schicht) hat nicht funktioniert, aber alle anderen scheinen es in Bezug auf die Rotation getan zu haben. Die Gradientenverstärkung scheint in der Rotation etwas schwach zu sein.

Drehen / vergrößern

Lassen Sie uns beim Drehen erweitern.

Es ist in Ordnung, wenn es nur Rotation ist, es ist in Ordnung, wenn es nur Expansion ist. Es scheint jedoch, dass jeder verwirrt ist, wenn er sich beim Drehen ausdehnt. Trotzdem gebe ich mein Bestes.

Drehung / Vergrößerung / Färbung / Schwarz nur für Tiere / mit Hindernissen

Wenn verschiedene Faktoren (Rotation, Vergrößerung, Hindernisse, Farben) einzeln angegriffen werden, scheint es schwierig zu sein, wenn diese Faktoren gemischt und angegriffen werden, auch wenn dies kein großes Problem darstellt.

All die verschiedenen Faktoren

Ich konnte all die verschiedenen Faktoren fahren. Dies scheint in keiner Weise ein Chaos zu sein.

Zusammenfassung

Ich wollte ein Gefühl für das Convolutional Neural Network (CNN) bekommen, also wollte ich ein "CNN gewinnt allein !!!" </ b> Ergebnis erhalten, aber die Schlussfolgerung ist "Gradientenverstärkung". Großartig, ja, ja! "</ B>. (ヽ ´ω`)