[PYTHON] Ich wollte die Klassifizierung von CIFAR-10 mit dem Chainer-Trainer in Frage stellen

Einführung

Neulich hier habe ich gelernt, dass Chainer sehr präzise geschrieben werden kann, und habe daher die Bildklassifizierung von CIFAR-10 in Frage gestellt, die ich zuvor ausprobieren wollte. Ich habe es versucht Ich wollte schreiben ..., aber ich habe nur eine schlechte CPU-Umgebung, daher konnte ich die Ausführung nicht bestätigen. Ich habe es den ganzen Tag verschoben und bin ungefähr 2 Epochen weitergekommen, also ist es wahrscheinlich richtig ... ^^; In Bezug auf die Implementierung habe ich auf den Blog von [hier] verwiesen (http://ai-programming.hatenablog.jp/entry/2016/03/04/160243).

Implementierung

Laden Sie das Bild von CIFAR-10

Laden Sie die CIFAR-10-Daten von [hier] herunter und laden Sie sie (http://www.cs.toronto.edu/~kriz/cifar.html). Da es wie Gurke ist, wird es von der folgenden Funktion gelesen.

def unpickle(file):
    fp = open(file, 'rb')
    if sys.version_info.major == 2:
        data = pickle.load(fp)
    elif sys.version_info.major == 3:
        data = pickle.load(fp, encoding='latin-1')                                                                                    
    fp.close()

    return data

neurales Netzwerk

Ich habe auf den Blog verwiesen, den ich zuvor vorgestellt habe. Ich bin mir immer noch nicht sicher, wie ich diesen Bereich gestalten soll ...

class Cifar10Model(chainer.Chain):

    def __init__(self):
        super(Cifar10Model,self).__init__(
                conv1 = F.Convolution2D(3, 32, 3, pad=1),
                conv2 = F.Convolution2D(32, 32, 3, pad=1),
                conv3 = F.Convolution2D(32, 32, 3, pad=1),
                conv4 = F.Convolution2D(32, 32, 3, pad=1),
                conv5 = F.Convolution2D(32, 32, 3, pad=1),
                conv6 = F.Convolution2D(32, 32, 3, pad=1),
                l1 = L.Linear(512, 512),
                l2 = L.Linear(512,10))

    def __call__(self, x, train=True):
        h = F.relu(self.conv1(x))
        h = F.max_pooling_2d(F.relu(self.conv2(h)), 2)
        h = F.relu(self.conv3(h))
        h = F.max_pooling_2d(F.relu(self.conv4(h)), 2)
        h = F.relu(self.conv5(h))
        h = F.max_pooling_2d(F.relu(self.conv6(h)), 2)
        h = F.dropout(F.relu(self.l1(h)), train=train)
        return self.l2(h)

Daten gelesen

Ich bin hier etwas verstopft. Bei Verwendung des neuen Funktionstrainers von Chainer übergebe ich die Daten, die ich lernen möchte, an den Iterator, jedoch in Tutorials usw.

train_iter = chainer.iterators.SerialIterator(train, 100)
test_iter = chainer.iterators.SerialIterator(test, 100,repeat=False, shuffle=False)

Ich wusste nicht, wie ich das Etikett usw. weitergeben sollte. Nach vielen Recherchen fand ich heraus, dass ich Tuple_dataset verwenden sollte.

train = chainer.tuple_dataset.TupleDataset(train_data, train_label)

Es scheint gut zu sein, dies zu tun.

Unten finden Sie den gesamten Code für den gelesenen Teil.

x_train = None
y_train = []
for i in range(1,6):
    data_dic = unpickle("cifar-10-batches-py/data_batch_{}".format(i))
    if i == 1:
        x_train = data_dic['data']
    else:
        x_train = np.vstack((x_train, data_dic['data']))
    y_train += data_dic['labels']

test_data_dic = unpickle("cifar-10-batches-py/test_batch")
x_test = test_data_dic['data']
x_test = x_test.reshape(len(x_test),3,32,32)
y_test = np.array(test_data_dic['labels'])
x_train = x_train.reshape((len(x_train),3, 32, 32))
y_train = np.array(y_train)
x_train = x_train.astype(np.float32)
x_test = x_test.astype(np.float32)
x_train /= 255
x_test/=255                                                                                                                     
y_train = y_train.astype(np.int32)
y_test = y_test.astype(np.int32)

train = tuple_dataset.TupleDataset(x_train, y_train)
test = tuple_dataset.TupleDataset(x_test, y_test)

Lernteil

Ich lerne mit dem neuronalen Netzwerk, das ich zuvor definiert habe. Der Code ist nur eine kleine Änderung des Tutorials MNIST. Ich bin überrascht, es wahnsinnig präzise schreiben zu können.

model = L.Classifier(Cifar10Model())
optimizer = chainer.optimizers.Adam()
optimizer.setup(model)

train_iter = chainer.iterators.SerialIterator(train, 100)
test_iter = chainer.iterators.SerialIterator(test, 100,repeat=False, shuffle=False)

updater = training.StandardUpdater(train_iter, optimizer, device=-1)
trainer = training.Trainer(updater, (40, 'epoch'), out="logs")
trainer.extend(extensions.Evaluator(test_iter, model, device=-1))
trainer.extend(extensions.LogReport())
trainer.extend(extensions.PrintReport( ['epoch', 'main/loss', 'validation/main/loss', 'main/accuracy', 'validation/main/accuracy']))
trainer.extend(extensions.ProgressBar())                                                                                          
trainer.run()

Ergebnis

Wenn Sie es ausführen, wird ein Fortschrittsbalken angezeigt, der Ihnen anzeigt, wie viel Sie lernen.

Estimated time to finish: 6 days

~~ Ich habe aufgegeben ~~ (Festgelegt am 15.08.2016) ich habe mein Bestes gegeben

Ich habe das Ausgabeprotokoll in das Wörterbuch eingelesen und es mit matplotlib grafisch dargestellt

abschließend

~~ Ich konnte nicht bestätigen, dass das Ergebnis korrekt war, aber ich habe gelernt, wie man ~~ Trainer benutzt. Schließlich ist GPU unverzichtbar, um Deep Learning zu studieren.