Zweck

Überlegen Sie, wie Sie die Genauigkeit verbessern können, auch wenn nur wenige Daten verwendet werden

Zwang

Behalten Sie die Modellstruktur vor der Verbesserung bei
Endtoend-Training zulassen (Autoencoder und CNN als ein Modell erstellen)
Führen Sie keine Gan- oder andere Datenerweiterung durch.
Verwenden Sie mnist für Daten, 100 Blatt für jedes Etikett, 1000 Blatt mit 100 * 10

Da wir nicht beschreiben, wie Daten abgerufen oder Modellanpassungen geschrieben werden, finden Sie hier Informationen zum Abrufen von Daten. Die Kompilierung erfolgt [hier](https :: Siehe //qiita.com/kzrn3318/items/d792cdd42d485662037c).

Der gesamte Code ist [hier](https://github.com/kzrn3318/Comparison-of-a-simple-cnn-model-and-a-model-with-cnn-in-the-middle-layer-of-autoencoder /blob/master/git%E7%94%A8.ipynb)

Vorverarbeitung von Daten

Teilen Sie einfach durch 255 und skalieren Sie, was auch als Vorverarbeitung üblich ist.

x_train = x_train / 255
x_test = x_test / 255

Vor der Verbesserung

Das Klassifizierungsmodell vor der Verbesserung war leicht zu optimieren, aber ich denke, es gibt eine Möglichkeit, mehr Genauigkeit zu erzielen.

Modellstruktur

Modellnummer

`Mnist-Klassifizierungsmodell vor der Verbesserung`


inp = Input(shape=(28,28,1),name="inp2")
p3 = Conv2D(32,2,2,padding="same")(inp)
p3 = Conv2D(16,2,2,padding="same")(p3)
p3 = MaxPooling2D(2,2,padding="same")(p3)
p3 = Conv2D(8,2,2,padding="same")(p3)
p3 = MaxPooling2D(2,2,padding="same")(p3)
p3 = Conv2D(8,2,2,padding="same")(p3)
p3 = MaxPooling2D(2,2,padding="same")(p3)
p3 = Flatten()(p3)
p3 = Dense(128,activation="relu")(p3)
p3 = Dense(64,activation="relu")(p3)
out = Dense(10,activation="softmax")(p3)

Die Namen und Variablennamen sind dieselben wie nachher, so dass später leicht bestätigt werden kann, dass die Struktur dieselbe ist.

Vorverarbeitung von Daten

Vor der Verbesserung können Sie die Größe 28 * 28 so eingeben, wie sie ist. Es gibt also nichts Besonderes zu tun.

Ich habe die Bedingungen wie folgt gelernt.

optimizer : adam
loss : categorical crossentropy
metrics : acc
earlystoping : { monitor : val loss , min delta : 0.00001 , patience : 10 , mode : auto }
batch size : 8
val size : 0.2

Dieser Zustand bleibt nach der Verbesserung gleich.

Lernen

Epoch 1/10000
100/100 [==============================] - 0s 4ms/step - loss: 2.2860 - acc: 0.1250 - val_loss: 2.2386 - val_acc: 0.1500
Epoch 2/10000
100/100 [==============================] - 0s 2ms/step - loss: 1.9977 - acc: 0.2575 - val_loss: 1.7996 - val_acc: 0.3200
Epoch 3/10000
100/100 [==============================] - 0s 3ms/step - loss: 1.6415 - acc: 0.3825 - val_loss: 1.6337 - val_acc: 0.3650
Epoch 4/10000
100/100 [==============================] - 0s 2ms/step - loss: 1.4488 - acc: 0.4475 - val_loss: 1.4533 - val_acc: 0.4500
Epoch 5/10000
100/100 [==============================] - 0s 2ms/step - loss: 1.2776 - acc: 0.5325 - val_loss: 1.3028 - val_acc: 0.5000
Epoch 6/10000
100/100 [==============================] - 0s 2ms/step - loss: 1.1254 - acc: 0.5863 - val_loss: 1.2225 - val_acc: 0.5450
Epoch 7/10000
100/100 [==============================] - 0s 2ms/step - loss: 0.9990 - acc: 0.6275 - val_loss: 1.1432 - val_acc: 0.6000
Epoch 8/10000
100/100 [==============================] - 0s 2ms/step - loss: 0.8964 - acc: 0.6812 - val_loss: 1.1002 - val_acc: 0.6600
Epoch 9/10000
100/100 [==============================] - 0s 2ms/step - loss: 0.8101 - acc: 0.7237 - val_loss: 1.0833 - val_acc: 0.6550
Epoch 10/10000
100/100 [==============================] - 0s 2ms/step - loss: 0.7583 - acc: 0.7300 - val_loss: 1.0636 - val_acc: 0.6700
Epoch 11/10000
100/100 [==============================] - 0s 2ms/step - loss: 0.6986 - acc: 0.7625 - val_loss: 1.0313 - val_acc: 0.6450
Epoch 12/10000
100/100 [==============================] - 0s 2ms/step - loss: 0.6530 - acc: 0.7650 - val_loss: 1.0362 - val_acc: 0.6800
Epoch 13/10000
100/100 [==============================] - 0s 2ms/step - loss: 0.5929 - acc: 0.7962 - val_loss: 1.0390 - val_acc: 0.6850
Epoch 14/10000
100/100 [==============================] - 0s 2ms/step - loss: 0.5830 - acc: 0.7887 - val_loss: 1.0353 - val_acc: 0.6700
Epoch 15/10000
100/100 [==============================] - 0s 2ms/step - loss: 0.5379 - acc: 0.8163 - val_loss: 1.0150 - val_acc: 0.6900
Epoch 16/10000
100/100 [==============================] - 0s 2ms/step - loss: 0.5073 - acc: 0.8288 - val_loss: 1.0049 - val_acc: 0.6750
Epoch 17/10000
100/100 [==============================] - 0s 2ms/step - loss: 0.4809 - acc: 0.8325 - val_loss: 1.0357 - val_acc: 0.7100
Epoch 18/10000
100/100 [==============================] - 0s 3ms/step - loss: 0.4510 - acc: 0.8438 - val_loss: 1.0232 - val_acc: 0.6900
Epoch 19/10000
100/100 [==============================] - 0s 2ms/step - loss: 0.4356 - acc: 0.8438 - val_loss: 1.0402 - val_acc: 0.6700
Epoch 20/10000
100/100 [==============================] - 0s 2ms/step - loss: 0.4083 - acc: 0.8625 - val_loss: 1.0361 - val_acc: 0.7000
Epoch 21/10000
100/100 [==============================] - 0s 2ms/step - loss: 0.4188 - acc: 0.8537 - val_loss: 0.9956 - val_acc: 0.6900
Epoch 22/10000
100/100 [==============================] - 0s 2ms/step - loss: 0.3855 - acc: 0.8675 - val_loss: 1.0222 - val_acc: 0.7050
Epoch 23/10000
100/100 [==============================] - 0s 2ms/step - loss: 0.3491 - acc: 0.8863 - val_loss: 1.0171 - val_acc: 0.7000
Epoch 24/10000
100/100 [==============================] - 0s 2ms/step - loss: 0.3160 - acc: 0.8900 - val_loss: 1.0814 - val_acc: 0.7050
Epoch 25/10000
100/100 [==============================] - 0s 2ms/step - loss: 0.3231 - acc: 0.8813 - val_loss: 1.0660 - val_acc: 0.7000
Epoch 26/10000
100/100 [==============================] - 0s 2ms/step - loss: 0.3102 - acc: 0.8813 - val_loss: 1.1023 - val_acc: 0.7150
Epoch 27/10000
100/100 [==============================] - 0s 2ms/step - loss: 0.2892 - acc: 0.8988 - val_loss: 1.0896 - val_acc: 0.7100
Epoch 28/10000
100/100 [==============================] - 0s 2ms/step - loss: 0.2597 - acc: 0.9087 - val_loss: 1.1387 - val_acc: 0.6900
Epoch 29/10000
100/100 [==============================] - 0s 2ms/step - loss: 0.2442 - acc: 0.9175 - val_loss: 1.1421 - val_acc: 0.7250
Epoch 30/10000
100/100 [==============================] - 0s 2ms/step - loss: 0.2295 - acc: 0.9162 - val_loss: 1.1753 - val_acc: 0.7100
Epoch 31/10000
100/100 [==============================] - 0s 2ms/step - loss: 0.2035 - acc: 0.9287 - val_loss: 1.2142 - val_acc: 0.7300

Vorhersage für Testdaten

pred_labels = model.predict(x_test)
pred = []
for label in pred_labels:
    idx = label.argmax()
    pred.append(idx)

from sklearn.metrics import accuracy_score
print(accuracy_score(y_test,pred))

0.7464

Die acc-Punktzahl für die Testgröße betrug 0,7464. Als nächstes werde ich versuchen, es durch Einbau eines Autoencoders zu verbessern.

Nach der Verbesserung

Modellstruktur

Modellnummer

`Verbessertes mnist-Klassifizierungsmodell`


#Autoencoder Teil
input_img = Input(shape=(784,),name="inp1")
x= Dense(256, activation="relu")(input_img)
x = Dense(128,activation="relu")(x)
encoded = Dense(128, activation="relu")(x)

z = Dense(128, activation="relu")(encoded)
decoded = Dense(784, activation="sigmoid",name="decoded")(z)

#Empfängt die Ausgabe von der mittleren Schicht des Autoencoders und koppelt vollständig
p2 = Dense(128,activation="relu")(encoded)
p2 = Dense(64,activation="relu")(p2)

#Ziel cnn Modell verglichen werden, Struktur ist die gleiche wie vor der Verbesserung
inp = Input(shape=(28,28,1),name="inp2")
p3 = Conv2D(32,2,2,padding="same")(inp)
p3 = Conv2D(16,2,2,padding="same")(p3)
p3 = MaxPooling2D(2,2,padding="same")(p3)
p3 = Conv2D(8,2,2,padding="same")(p3)
p3 = MaxPooling2D(2,2,padding="same")(p3)
p3 = Conv2D(8,2,2,padding="same")(p3)
p3 = MaxPooling2D(2,2,padding="same")(p3)
p3 = Flatten()(p3)
p3 = Dense(128,activation="relu")(p3)
p3 = Dense(64,activation="relu")(p3)

p = Add()([p2,p3])
p = Dense(32,activation="relu")(p)
predictor = Dense(10,activation="softmax",name="predictor")(p)

Denkweise

Es gab viele Dinge im Web, die den Autoencoder separat trainierten und die Ausgabe des Encoders als Funktion zur Verbesserung der Genauigkeit des Modells verwendeten.

Es ist besser, sowohl das Bild selbst als auch die Codierung vom Autoencoder einzugeben.
Warum implementieren Sie es nicht als ein Modell mit End-to-End?

Ich habe es mit dieser Idee geschaffen.

Vorverarbeitung von Daten

Die Vorbehandlung verändert nur die Struktur der Sequenz und bläst sie nicht auf. Vor der Verbesserung konnte der geladene Mnist in derselben Größe eingegeben werden, aber bei der Eingabe in den Autoencoder wird er abgeflacht. Da es zwei Eingabeebenen gibt, bereiten Sie zwei vor. Bereiten Sie für die Beschriftung in ähnlicher Weise zwei Klassifizierungsbeschriftungen für die Klassifizierung und dasselbe Bild wie das Eingabebild für den Autoencoder vor.

x_train_1 = x_train.reshape(len(x_train),784,1)
x_train_2 = x_train.reshape(len(x_train),28,28,1)

x_val_1 = x_val.reshape(len(x_val),784,1)
x_val_2 = x_val.reshape(len(x_val),28,28,1)

Geben Sie x und y zum Zeitpunkt der Anpassung wie folgt an.

x = {"inp1":x_train_1,"inp2":x_train_2}
y={"decoded":x_train_1,"predictor":y_train}

Die Bedingungen sind die gleichen wie vor der Verbesserung.

Lernen

Epoch 1/10000
100/100 [==============================] - 0s 5ms/step - loss: 1.5771 - decoded_loss: 0.0945 - predictor_loss: 1.4826 - predictor_acc: 0.5038 - val_loss: 1.1179 - val_decoded_loss: 0.0599 - val_predictor_loss: 1.0580 - val_predictor_acc: 0.6600
Epoch 2/10000
100/100 [==============================] - 0s 3ms/step - loss: 0.6398 - decoded_loss: 0.0569 - predictor_loss: 0.5829 - predictor_acc: 0.8200 - val_loss: 0.8113 - val_decoded_loss: 0.0530 - val_predictor_loss: 0.7583 - val_predictor_acc: 0.7650
Epoch 3/10000
100/100 [==============================] - 0s 3ms/step - loss: 0.4338 - decoded_loss: 0.0524 - predictor_loss: 0.3814 - predictor_acc: 0.8700 - val_loss: 0.7595 - val_decoded_loss: 0.0507 - val_predictor_loss: 0.7088 - val_predictor_acc: 0.7500
Epoch 4/10000
100/100 [==============================] - 0s 3ms/step - loss: 0.3216 - decoded_loss: 0.0505 - predictor_loss: 0.2710 - predictor_acc: 0.9225 - val_loss: 0.5286 - val_decoded_loss: 0.0489 - val_predictor_loss: 0.4797 - val_predictor_acc: 0.8250
Epoch 5/10000
100/100 [==============================] - 0s 3ms/step - loss: 0.2043 - decoded_loss: 0.0491 - predictor_loss: 0.1551 - predictor_acc: 0.9588 - val_loss: 0.4416 - val_decoded_loss: 0.0473 - val_predictor_loss: 0.3943 - val_predictor_acc: 0.8600
Epoch 6/10000
100/100 [==============================] - 0s 3ms/step - loss: 0.1560 - decoded_loss: 0.0477 - predictor_loss: 0.1083 - predictor_acc: 0.9650 - val_loss: 0.6524 - val_decoded_loss: 0.0464 - val_predictor_loss: 0.6061 - val_predictor_acc: 0.8350
Epoch 7/10000
100/100 [==============================] - 0s 3ms/step - loss: 0.1374 - decoded_loss: 0.0463 - predictor_loss: 0.0911 - predictor_acc: 0.9737 - val_loss: 0.6657 - val_decoded_loss: 0.0461 - val_predictor_loss: 0.6197 - val_predictor_acc: 0.8450
Epoch 8/10000
100/100 [==============================] - 0s 3ms/step - loss: 0.1535 - decoded_loss: 0.0456 - predictor_loss: 0.1079 - predictor_acc: 0.9675 - val_loss: 0.5291 - val_decoded_loss: 0.0432 - val_predictor_loss: 0.4860 - val_predictor_acc: 0.8600
Epoch 9/10000
100/100 [==============================] - 0s 3ms/step - loss: 0.1218 - decoded_loss: 0.0440 - predictor_loss: 0.0779 - predictor_acc: 0.9737 - val_loss: 0.7133 - val_decoded_loss: 0.0428 - val_predictor_loss: 0.6705 - val_predictor_acc: 0.8600
Epoch 10/10000
100/100 [==============================] - 0s 3ms/step - loss: 0.0800 - decoded_loss: 0.0428 - predictor_loss: 0.0372 - predictor_acc: 0.9900 - val_loss: 0.6788 - val_decoded_loss: 0.0414 - val_predictor_loss: 0.6374 - val_predictor_acc: 0.8550
Epoch 11/10000
100/100 [==============================] - 0s 3ms/step - loss: 0.0590 - decoded_loss: 0.0409 - predictor_loss: 0.0181 - predictor_acc: 0.9962 - val_loss: 0.4702 - val_decoded_loss: 0.0396 - val_predictor_loss: 0.4306 - val_predictor_acc: 0.8850
Epoch 12/10000
100/100 [==============================] - 0s 3ms/step - loss: 0.0586 - decoded_loss: 0.0398 - predictor_loss: 0.0188 - predictor_acc: 0.9962 - val_loss: 0.5544 - val_decoded_loss: 0.0392 - val_predictor_loss: 0.5152 - val_predictor_acc: 0.8600
Epoch 13/10000
100/100 [==============================] - 0s 3ms/step - loss: 0.0398 - decoded_loss: 0.0383 - predictor_loss: 0.0014 - predictor_acc: 1.0000 - val_loss: 0.5413 - val_decoded_loss: 0.0376 - val_predictor_loss: 0.5037 - val_predictor_acc: 0.8800
Epoch 14/10000
100/100 [==============================] - 0s 3ms/step - loss: 0.0376 - decoded_loss: 0.0371 - predictor_loss: 5.6022e-04 - predictor_acc: 1.0000 - val_loss: 0.5456 - val_decoded_loss: 0.0371 - val_predictor_loss: 0.5085 - val_predictor_acc: 0.8750
Epoch 15/10000
100/100 [==============================] - 0s 3ms/step - loss: 0.0362 - decoded_loss: 0.0359 - predictor_loss: 3.1317e-04 - predictor_acc: 1.0000 - val_loss: 0.5563 - val_decoded_loss: 0.0361 - val_predictor_loss: 0.5202 - val_predictor_acc: 0.8700

Vorhersage für Testdaten

pred_img ,pred_labels = model.predict({"inp1":x_test_1,"inp2":x_test_2})

pred = []
for label in pred_labels:
    idx = label.argmax()
    pred.append(idx)

from sklearn.metrics import accuracy_score
print(accuracy_score(y_test,pred))

0.9055

Codierung der Ausgabe des Autoencoders



#Autoencoder-Ausgabe
for i in range(5):
    fig , ax = plt.subplots()
    x_test = x_test.reshape(len(x_test),28,28)
    ax.imshow(x_test[i])
    
    fig , ax = plt.subplots()
    pred_img = pred_img.reshape(len(pred_img),28,28)
    ax.imshow(pred_img[i])

    plt.show()

ダウンロード.png ダウンロード(1).png ダウンロード (2).png ダウンロード(3).png ダウンロード (6).png ダウンロード(7).png ダウンロード (8).png ダウンロード(9).png ダウンロード (4).png ダウンロード(5).png

Der acc-Score für die Testdaten betrug 0,9055. Es scheint, dass der Autoencoder selbst irgendwie (sehr subtil) reproduziert werden kann. Die Reproduktion des Autoencoders selbst kann jedoch besser reproduziert werden, ohne das cnn-Modell anzuhängen (obwohl ich es diesmal nicht beschreiben werde).

Zusammenfassung

Ich habe beide Acc Scores zusammengefasst.

Vor der Verbesserung: 0,7464
Nach Verbesserung: 0,9055

Vor der Verbesserung wurde eine Präzisionsverbesserung von fast 0,2 beobachtet. Durch Hinzufügen eines Autoencoders kann gesagt werden, dass Mnist die Genauigkeit verbessern kann (abhängig von der Aufgabe).

letzte

Ich habe ein Modell verwendet, das diesmal keine Bacth-Normalisierung verwendet, aber ich denke, Sie können eine bessere Genauigkeit erzielen, indem Sie eine Ebene der Batch-Normalisierung hinzufügen. Auch diesmal haben wir eine Verbesserung der Genauigkeit mit mnist festgestellt, aber wenn wir uns mit Bildern mit einer großen Menge an Informationen wie cifar-10 befassen, werden wir es wahrscheinlich erst wissen, wenn wir versuchen, die Genauigkeit zu verbessern.

[PYTHON] Fügen Sie unter Beibehaltung der Modellstruktur der Bildklassifizierung (mnist) einen Autoencoder hinzu, um die Genauigkeit von Ende zu Ende zu verbessern. [Tensorflow, Keras, Mnist, Autoencder]

Zweck

Zwang

Der gesamte Code ist [hier](https://github.com/kzrn3318/Comparison-of-a-simple-cnn-model-and-a-model-with-cnn-in-the-middle-layer-of-autoencoder /blob/master/git%E7%94%A8.ipynb)

Vorverarbeitung von Daten

Vor der Verbesserung

Modellstruktur

Modellnummer

Mnist-Klassifizierungsmodell vor der Verbesserung

Vorverarbeitung von Daten

Lernen

Vorhersage für Testdaten

Nach der Verbesserung

Modellstruktur

Modellnummer

Verbessertes mnist-Klassifizierungsmodell

Denkweise

Vorverarbeitung von Daten

Lernen

Vorhersage für Testdaten

Codierung der Ausgabe des Autoencoders

Zusammenfassung

letzte

`Mnist-Klassifizierungsmodell vor der Verbesserung`

`Verbessertes mnist-Klassifizierungsmodell`