[PYTHON] _ 3. Tag bis eine gute Genauigkeit durch Blattklassifizierung erreicht wird
Ich werde es endlich umsetzen. Dieses Mal ist es in Chainer implementiert. ** Ketten verwendet 2.0.0 **. Die Version von Chainer ist
import chainer
chainer.__version__
Sie können dies überprüfen.
Bauen
Überprüfung der Vorbehandlung
Zunächst werde ich kurz darauf eingehen. Für Bilddaten usw. habe ich Kaggles Blattklassifikation so wie sie ist heruntergeladen und den Ordner mit dem Namen images in images2 umbenannt.
Größe ändern
Bei der Vorverarbeitung des folgenden Codes werden 1584 Bilddaten im Ordner images2 auf die Bildgröße 32x32 geändert und dann im Ordner images gespeichert.
images=[]
for i in range(1, 1585):
image = cv2.imread("images2/%d.jpg "%i) #Auszug aus images2
grayed = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
images.append(grayed) #In Bildern speichern
def resize_image(img):
end_size = 32
max_ = np.maximum(img.shape[0], img.shape[1])
scale = end_size / max_
height, width = img.shape
size = (int(width*scale), int(height*scale))
rescale_image = cv2.resize(img, size, interpolation=cv2.INTER_CUBIC)
height, width = rescale_image.shape
if width > height:
z_pad = np.zeros([int((width-height)/2), width], dtype=np.uint8)
end_image = np.vstack((z_pad, rescale_image, z_pad))
else:
z_pad = np.zeros([height, int((height - width)/2)], dtype=np.uint8)
end_image = np.hstack((z_pad, rescale_image, z_pad))
end_image = cv2.resize(end_image, (end_size, end_size))
return end_image
for i,img in enumerate(images):
cv2.imwrite("images/%d.jpg "%(i+1), resize_image(img)) #Speichern Sie Bilder in einem Ordner namens images
Erstellen eines Datensatzes
Erstellen wir nun aus den Trainingsdaten einen Datensatz, der für das Training verwendet werden kann.
dataset.py
import numpy as np
import pandas as pd
import cv2
#Zug in Kaggle.Laden Sie csv herunter und laden Sie es
#(train.csv hat nur ein label)
train = pd.read_csv("train.csv")
labels=train["species"].values
#Die Beschriftungen enthalten jetzt eine Zeichenfolge-Verwenden Sie die Lernfunktion, um in eine Nummernbezeichnung zu konvertieren
from sklearn import preprocessing
le = preprocessing.LabelEncoder()
le.fit(labels)
labels = le.transform(labels)
labels = labels.astype(np.int32)
#Trainieren Sie im Bilderordner.Bringen Sie das verkleinerte Bild aus der ID-Spalte von CSV.
resized_images = []
for i in train.id:
image = cv2.imread("images/%d.jpg "%i)
grayed = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
resized_images.append(grayed)
#In einen Typ konvertieren, der von Chainer gelesen werden kann.
resized_images = np.array([resized_images])
resized_images = resized_images.reshape(-1, 1024).astype(np.float32)
resized_images /=255 #0~255 Daten 0~Wechseln Sie zu 1 Daten
#train_test_Split ist Scikit-Wenn die Version von learn neu ist, kreuzen Sie_Modell statt Validierung_Es ist in der Auswahl.
#Erstellen Sie einen Trainingsdatensatz aus den Bildmatrixdaten und den Etikettendaten.
from sklearn.cross_validation import train_test_split
X_train, X_test, y_train, y_test = train_test_split(resized_images, labels, test_size=0.2, random_state=0)
#Geben Sie die Nummer an, die später verwendet werden soll.
N_train = y_train.size
N_test = y_test.size
Auf diese Weise konnte ich einen Datensatz erstellen.
Klassifizieren nach NN
Machen wir es zuerst mit NN anstelle von CNN.
NN_class.py
class MLP(chainer.Chain):
def __init__(self):
super().__init__(
l1 = L.Linear(1024, 1000),
l2 = L.Linear(1000, 900),
l3 = L.Linear(900, 500),
l4 = L.Linear(500, 99),
)
def __call__(self, x):
h1 = F.relu(self.l1(x))
h2 = F.relu(self.l2(h1))
h3 = F.relu(self.l3(h2))
return self.l4(h3)
Hier,
__call__
Eine Beschreibung des Teils finden Sie unter Verwendung der call-Methode in Python-Klassen.
Derzeit beträgt die Eingabe 1024 (32 x 32), die Ausgabe 99 (99 Klassenklassifizierung). Es fühlt sich also so an, als würde man NN (neuronales Netz) verbinden und die Relu-Funktion als Aktivierungsfunktion verwenden.
Ein Modell bauen
model.py
model = L.Classifier(MLP())
from chainer import optimizers
optimizer = optimizers.Adam()
optimizer.setup(model)
Sie haben jetzt ein Modell erstellt. Auf meinem PC ** ist aus irgendeinem Grund ein Fehler aufgetreten, als ich optimizer = chainer.optimizers.Adam () ** gesetzt habe. In diesem Fall denke ich, dass es in Ordnung ist, so zu schreiben.
Lauf
NN_Lauf.py
batchsize = 99 #Einmalige Chargengröße
n_epoch = 8 #Anzahl der Wiederholungen des Lernens
train_loss = []
train_accuracy = []
test_loss = []
test_accuracy = []
for epoch in range(n_epoch):
print("epoch", epoch+1)
perm = np.random.permutation(N_train)
sum_accuracy, sum_loss = 0,0
for i in range(0, N_train, batchsize):
X_batch = X_train[perm[i:i+batchsize]]
y_batch = y_train[perm[i:i+batchsize]]
optimizer.update(model, X_batch, y_batch)
sum_loss += float(model.loss.data)
sum_accuracy += float(model.accuracy.data)
mean_loss = sum_loss/(N_train/batchsize)
mean_accuracy = sum_accuracy/(N_train/batchsize)
print("train_mean_loss={:.3f}, train_mean_accuracy={:.3f}".format(mean_loss, mean_accuracy))
train_loss.append(model.loss.data)
train_accuracy.append(model.accuracy.data)
#Es gibt nur wenige, also lasst uns alles testen
sum_loss, sum_accuracy= 0,0
for i in range(0, N_test, batchsize):
X_batch = X_test[i:i+batchsize]
y_batch = y_test[i:i+batchsize]
loss = model(X_batch, y_batch)
sum_loss += float(model.loss.data)
sum_accuracy += float(model.accuracy.data)
mean_loss = sum_loss/(N_test/batchsize)
mean_accuracy = sum_accuracy/(N_test/batchsize)
print("test_mean_loss={:.3f}, test_mean_accuracy={:.3f}".format(mean_loss, mean_accuracy))
test_loss.append(model.loss.data)
test_accuracy.append(model.accuracy.data)
Die ausführliche Erläuterung des Codeteils dieses Teils wird auf der Referenzseite auf sehr leicht verständliche Weise erläutert, daher werde ich darauf verzichten.
Der umgeschriebene Teil war N_train.size = 792, also habe ich batchsize = 99 und n_epoch = 8 gesetzt.
Das Ausführungsergebnis ist also so.
Nun, ich würde gerne verstehen, dass es unmöglich war, eine ** 99-Klassifizierung mit Daten für jeweils 10 durchzuführen. ** ** ** Ich werde versuchen, es vorerst mit CNN umzusetzen.
CNN
Ein Modell bauen
model_CNN.py
class CNN(chainer.Chain):
def __init__(self):
super(CNN, self).__init__(
conv1 = L.Convolution2D(1, 32, 5),
conv2 = L.Convolution2D(32, 64, 5),
conv3 = L.Convolution2D(64, 64, 5),
l1 = L.Linear(None, 500),
l2 = L.Linear(500, 99)
)
def __call__(self, x):
x = x.reshape((len(x.data), 1, 32, 32))
h = F.relu(self.conv1(x))
h = F.max_pooling_2d(h, 2)
h = F.relu(self.conv2(h))
h = F.max_pooling_2d(h, 2)
h = F.relu(self.conv3(h))
h = F.max_pooling_2d(h, 2)
h = F.dropout(F.relu(self.l1(h)))
y = self.l2(h)
return y
model = L.Classifier(CNN())
from chainer import optimizers
optimizer = optimizers.Adam()
optimizer.setup(model)
Dies ist auch leichter zu verstehen, wenn Sie sich die Site ansehen, auf die Sie verwiesen haben. Daher werde ich die Erklärung weglassen. Und ** der Ausführungscode ist genau der gleiche wie NN **, daher werde ich nur das Ergebnis veröffentlichen.
** ,,, Das? ** ** ** Ich war beeindruckt, dass der Prozentsatz der richtigen Antworten so niedrig sein würde **. Immerhin scheint es, dass ** wir die Anzahl der Datensätze erhöhen müssen **. Deshalb geht es am 4. Tag weiter.
Referenzierte Site
Maschinelles Lernen Ich werde es erklären, während ich das Deep Learning Framework Chainer ausprobiere. ](Http://qiita.com/kenmatsu4/items/7b8d24d4c5144a686412) Es ist sehr leicht zu verstehen. Da FunctionSet usw. nicht in 2.0.0 enthalten sind, sollten Sie dies tun, während Sie sich andere Websites ansehen, aber die Erklärung der Relu-Funktion usw. ist sehr höflich. Ich habe den Trainingscode von hier ausgeliehen.
Probieren Sie das MNIST-Beispiel von Chainer aus Diese Person schreibt, um die Modellkonstruktion als Anfangswert des Arguments anzugeben, sodass ich irgendwie verstehen konnte, was ich tat. Ich habe mir einen Teil davon geliehen, wie man den Modellbau von CNN von hier aus schreibt.
Fehlerbehebung für verschiedene Kettenliebhaber Dies ist die Site, die ich gefunden habe, als ich nach Datenfehlercodes gesucht habe.