Ich habe mit dem Backend und dem Frontend herumgespielt, aber ich habe noch nicht versucht, maschinell zu lernen. Dies ist mein erster Versuch, daher werde ich ihn als Denkmal festhalten. Ich benutze Python, Numpy, Tf.keras.

Meine Spezifikation

Siehe diese Qiita.
Kommunikationssystem von c und go ~ Backend-Entwicklung, Frontend-Entwicklung von Flatter / Dart ist möglich.
Ich berühre auch Python ziemlich oft.
Ich habe maschinelles Lernen mit GUI-Tools berührt.
Maschinelles Lernen mit Python ist meine erste Herausforderung. Ein Level, das ich noch nie benutzt habe.

Um die Theorie des maschinellen Lernens gemeinsam zu studieren: "Deep Learning von Grund auf - die Theorie und Implementierung des mit Python erlernten Deep Learning Ich habe "dp / 4873117585 /)" gelesen. Es war ein sehr gutes Buch.

Die Entwicklungsumgebung ist PyCharm Community 2019.3. Ich benutze PyCharm, indem ich die erforderlichen Bibliotheken lade, ohne Anaconda zu verwenden.

1. Einstellung der Aufgabe für maschinelles Lernen

Wir wollen die folgende korrekte Logik maschinell lernen.

Dies ist ein binäres Klassifizierungsproblem bei einem Lehrer.
Stellen Sie den einzugebenden Merkmalsbetrag als zwei zufällige Werte ein (0 oder mehr und weniger als 1) und setzen Sie 0 oder 1 als richtige Antwortbezeichnung, indem Sie die beiden Größen vergleichen.
In seltenen Fällen wird Rauschen auf dem richtigen Etikett gemischt. (Beseitigen Sie zuerst Lärm)

2. Code

Ich habe beim Betrachten einiger Webartikel einen typischen Code für das Problem der binären Klassifizierung erstellt. Ich fand es ziemlich kompakt und intuitiv zu schreiben. Keras ist unglaublich.

#!/usr/bin/env python3

import tensorflow as tf
import numpy as np
from tensorflow_core.python.keras.metrics import binary_accuracy
import matplotlib.pyplot as plt

#Datensatzvorbereitung
ds_features = np.random.rand(10000, 2)  #Funktionsdaten
NOISE_RATE = 0
ds_noise = (np.random.rand(10000) > NOISE_RATE).astype(np.int) * 2 - 1  #Kein Geräusch: 1,Ja: -1
ds_labels = (np.sign(ds_features[:, 0] - ds_features[:, 1]) * ds_noise + 1) / 2  #Richtiges Antwortetikett

#Teilen Sie den Datensatz für Training und Validierung
SPLIT_RATE = 0.8   #Teilungsverhältnis
training_features, validation_features = np.split(ds_features, [int(len(ds_features) * SPLIT_RATE)])
training_labels, validation_labels = np.split(ds_labels, [int(len(ds_labels) * SPLIT_RATE)])

#Modellvorbereitung
INPUT_FEATURES = ds_features.shape[1]   #Feature-Dimension
LAYER1_NEURONS = int(INPUT_FEATURES * 1.2 + 1)   #Etwas breiter als die Eingangsdimension
LAYER2_NEURONS = LAYER1_NEURONS
LAYER3_NEURONS = LAYER1_NEURONS  #3 versteckte Schichten
OUTPUT_RESULTS = 1  #Die Ausgabe ist eindimensional
ACTIVATION = 'tanh'
model = tf.keras.models.Sequential([
    tf.keras.layers.Dense(input_shape=(INPUT_FEATURES,), units=LAYER1_NEURONS, activation=ACTIVATION),
    tf.keras.layers.Dense(units=LAYER2_NEURONS, activation=ACTIVATION),
    tf.keras.layers.Dense(units=LAYER3_NEURONS, activation=ACTIVATION),
    tf.keras.layers.Dense(units=OUTPUT_RESULTS, activation='sigmoid'),
])
LOSS = 'binary_crossentropy'
OPTIMIZER = tf.keras.optimizers.Adam   #Typische Optimierungsmethode
LEARNING_RATE = 0.03   #Gemeinsame Anfangswerte des Lernkoeffizienten
model.compile(optimizer=OPTIMIZER(lr=LEARNING_RATE), loss=LOSS, metrics=[binary_accuracy])

#Lernen
BATCH_SIZE = 30
EPOCHS = 100
result = model.fit(x=training_features, y=training_labels,
                   validation_data=(validation_features, validation_labels),
                   batch_size=BATCH_SIZE, epochs=EPOCHS, verbose=1)

#Anzeige
plt.plot(range(1, EPOCHS+1), result.history['binary_accuracy'], label="training")
plt.plot(range(1, EPOCHS+1), result.history['val_binary_accuracy'], label="validation")
plt.xlabel('Epochs')
plt.ylabel('Accuracy')
plt.ylim(0.5, 1)
plt.legend()
plt.show()

3. Ergebnis

Dies ist das Lernergebnis. Es erreichte schnell eine Genauigkeit von etwa 99% und es scheint, dass es nicht überlernt hat.

4. Überlegung

4.1. Verhalten beim Hinzufügen von Rauschen

Ich habe versucht, NOISE_RATE = 0.2 zu setzen. Die Genauigkeit wird durch die Menge des Rauschens verringert, aber das Ergebnis ist angemessen.

4.2. Verhalten beim Hinzufügen irrelevanter Dummy-Funktionen

Lassen Sie uns das Rauschen zurückgeben und den Funktionsumfang auf 5 Typen erhöhen. Finden Sie das richtige Etikett mit derselben Logik, indem Sie nur 2 von 5 Typen verwenden. Mit anderen Worten, die verbleibenden 3 Arten von Merkmalsgrößen sind Dummies, die nichts mit der richtigen Antwort zu tun haben.

Das Ergebnis ist hier, und obwohl die Unschärfebreite etwas größer ist, kann man sagen, dass Sie lernen können, ohne vom Dummy getäuscht zu werden.

4.3. Verhalten, wenn die Normalisierung der Merkmalsmenge unterbrochen ist

Ich werde den Funktionsbetrag auf 2 Typen zurückgeben, aber ich habe versucht, den Zufallswert von 0 oder mehr und weniger als 1 mit 1000 zu multiplizieren. Die Ergebnisse scheinen nicht gleichmäßig zu konvergieren und sind in der Nähe der letzten Epoche weniger genau.

Ich habe die Epoche verlängert und überprüft. Immerhin scheint das Lernen nicht stabil zu sein.

Andererseits habe ich den Durchschnitt der Merkmale verschoben und versucht, den Zufallswert von 0 oder mehr und weniger als 1 um +1000 zu erhöhen. Die Ergebnisse zeigen, dass die Genauigkeit fast 0,5 beträgt, das heißt, sie wird überhaupt nicht als binäre Klassifikation trainiert.

Insgesamt können wir sehen, dass die Normalisierung der Merkmalsmengen wichtig ist.

[PYTHON] Aufzeichnung der ersten Herausforderung des maschinellen Lernens mit Keras