[PYTHON] Ich habe keine GPU, aber ich werde Deep Learning ausprobieren

Vorwort

Mit dem Konzept "Sie können Deep-Learning-Tutorials durchführen, ohne eine komplizierte Umgebung zu erstellen" können Sie es versuchen, indem Sie einfach den Code in diesem Artikel kopieren und einfügen. (Ich meine, klone es einfach von GitHub und starte es)

Umgebung macOS Mojave version 10.14.6 python3.6.5

• Zielgruppe der Leser dieses Artikels Wie der Titel schon sagt, ist es für diejenigen gedacht, die keine GPU haben, aber Deep Learning ausprobieren möchten. Wenn Sie ernsthaft tief lernen möchten, benötigen Sie immer noch eine GPU, aber ich denke, es ist am besten, sie tatsächlich zu verschieben, um intuitiv zu verstehen, "was Sie tun können" und "wie es funktioniert". Wir gehen davon aus, dass die Umgebung von Python selbst erstellt wurde.
  

• Definition des tiefen Lernens Die Definition kann je nach Informationsquelle leicht abweichen, aber ich bin der Meinung, dass Algorithmen, die als Deep Learning und Deep Learning bezeichnet werden, häufig aus drei oder mehr verborgenen Ebenen aufgerufen werden. (Entschuldigung für die Mehrdeutigkeit) Dieser Artikel befasst sich auch mit Modellen mit weniger versteckten Ebenen, aber ich werde keinen Unterschied machen. Der Algorithmus wird jedoch als neuronales Netzwerk bezeichnet, und das Gewichtslernen wird als tiefes Lernen bezeichnet.
  

• Bewertungsfunktion, Verlustfunktion Die Bewertungsfunktion verwendet R ^ 2 score und die Verlustfunktion verwendet MSE. ..

Einfach ausgedrückt ist der R ^ 2-Score eine Bewertungsfunktion, die ausdrückt, wie nahe die Regressionskurve (vorhergesagt) an der korrekten Kurve um 0 zu 1 liegt. MSE wird als durchschnittliche Summe der Fehlerquadrate bezeichnet. Dies ist der Durchschnittswert der Summe der Fehlerquadrate des korrekten Antwortwerts und des vorhergesagten Werts.

Problemstellung

Vorhersage der SinCos-Kurve aus zwei Eingabewerten (x1, x2)

Das Bild sieht so aus. Wir werden überprüfen, wie sich die Genauigkeit in Abhängigkeit von der Anzahl der ausgeblendeten Ebenen und der Anzahl der Einheiten in jeder Ebene ändert.

Umgebung

#Führen Sie zur Vereinfachung die folgenden Schritte aus, um das Repository zu klonen, an dem ich gearbeitet habe.

$ git clone https://github.com/keroido/DNN-learning-Sin-Cos-wave.git
$ cd DNN-learning-Sin-Cos-wave

#Erstellen Sie eine virtuelle Umgebung und betreten Sie die virtuelle Umgebung. (Irgendein)
$ pip install virtualenv
$ virtualenv venv
$ . venv/bin/activate

#Installieren Sie alle für die virtuelle Umgebung erforderlichen Bibliotheken.
(venv)$ pip install -r requirements.txt

#Beim Verlassen der virtuellen Umgebung venv$ deactivate

Trainingsdaten erstellen

Führen Sie die folgenden Schritte aus, um ein Dataset zu erstellen. Erzeugt Daten von 4 Spalten mit Sin- und Cos x 1000-Zeilen, wenn die Eingabewerte x0, x1 und die beiden hinzugefügt werden.
Sagen Sie Sin und Cos aus diesen x0 und x1 voraus.

Bild

(0 <= x1, x2 <= 180)

Führen Sie das Programm, das das Dataset generiert, im folgenden Verzeichnis aus. Erstellen Sie hier auch eine Speichereingabe für den Trainingsdatensatz und eine Ausgabe für das Ausgabeergebnis.

#Überprüfen Sie das aktuelle Verzeichnis.
$ pwd
　[out]: .../DNN-learning-Sin-Cos-wave/code

#Erstellen Sie einen Ort für Eingabedaten und einen Ort für Ausgabedaten.
$ mkdir ../input ../output

#Führen Sie das Programm aus, das das Dataset generiert
$ python make_dataset.py

# make_dataset.py

import numpy as np
import pandas as pd
import math

x0 = np.random.rand(1000) * 180
x1 = np.random.rand(1000) * 180
s = [math.sin(math.radians(i+s)) for i, s in zip(x0, x1)]
c = [math.cos(math.radians(i+s)) for i, s in zip(x0, x1)]

df = pd.DataFrame({'x0':x0, 'x1':x1, 'sin':s, 'cos':c})
df.to_csv('../input/data.csv')

Dann wird data.csv im Eingabeverzeichnis generiert.

Versuchen Sie es mit tiefem Lernen

Lassen Sie uns endlich tiefes Lernen machen. Das Thema dieses Artikels ist Deep Learning ohne Verwendung einer GPU, daher werden wir es mit Scicit-Learn implementieren.
Obwohl train.py steht, bewerten wir jedes Modell gleichzeitig.

$ pwd
　[out]: .../DNN-learning-Sin-Cos-wave/code

$ python train.py

# train.py
import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split #Teilen Sie die Daten in Trainingssätze und Testsätze ein.
from sklearn.neural_network import MLPRegressor #Es ist eine Funktion eines neuronalen Netzwerks, das auf sklearn ausgeführt wird.
from sklearn.metrics import mean_squared_error # MSE(Durchschnittliche Summe der Fehlerquadrate)

#Liest die Daten im Eingabeverzeichnis.
df = pd.read_csv('../input/data.csv')
df = df.drop('Unnamed: 0', axis=1)

#X für x0 und x1, y für SinCos
X = df.iloc[:, :2]
y = df.iloc[:, 2:]

#Teilen Sie in ein Trainingsset und ein Testset.
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=0)

#2 versteckte Schichten,３,4 Die Anzahl der Einheiten beträgt 10,50,100,150,200 Probieren Sie alle Kombinationen aus.
hidden_layer_sizes = [(10, 10,), (50, 50,), (100, 100,), (150, 150,), (200, 200,),
                      (10, 10, 10,), (50, 50, 50,), (100, 100, 100,), (150, 150, 150,), (200, 200, 200,),
                      (10, 10, 10, 10,), (50, 50, 50, 50,), (100, 100, 100, 100,), (150, 150, 150, 150,), (200, 200, 200, 200,)]
ln = list(range(len(hidden_layer_sizes))) 

# Sin,Cos MSE bzw. R.^2 Erstellen Sie einen Datenrahmen, um die Partitur zu schreiben
score_df = pd.DataFrame(columns={'sin_mse', 'cos_mse', 'r^2_score'})

for i, hidden_layer_size in zip(ln, hidden_layer_sizes):
    #Modelldetails(https://scikit-learn.org/stable/modules/generated/sklearn.neural_network.MLPRegressor.html)
    #Wenn Sie ausführlich in True ändern und es ausführen, können Sie den Lernfortschritt sehen.
    model = MLPRegressor(activation='relu', alpha=0, batch_size=100,
                         hidden_layer_sizes=hidden_layer_size, learning_rate_init=0.03,
                         random_state=0, verbose=False, solver='adam')
    #Füttere das Modell mit einem Trainingsdatensatz.
    model.fit(X_train, y_train)
    #Testsatz x0,x1 zu Sin,Cos vorhersagen.
    pred = model.predict(X_test)
    #Ab hier ist die Formatierung des Datenrahmens, der das vorhergesagte Ergebnis in das Ausgabeverzeichnis usw. ausgibt, abwärts.
    pred = pd.DataFrame(pred)
    x = pd.DataFrame({'x':(X_test['x0'] + X_test['x1']).tolist()})
    tes = y_test.rename(columns={'sin': 'sin(label)', 'cos': 'cos(label)'}).reset_index(drop=True)
    pre = pred.rename(columns={0: 'sin(prediction)', 1: 'cos(prediction)'}).reset_index(drop=True)
    ans_df = pd.concat([x, tes, pre], axis=1)
    ans_df = ans_df[['x', 'sin(label)', 'sin(prediction)', 'cos(label)', 'cos(prediction)']]
    ans_df.to_csv('../output/result_{}_{}_{}.csv'.format(str(i).zfill(2), len(hidden_layer_size), hidden_layer_size[0]))
    sin_mse = mean_squared_error(tes['sin(label)'].tolist(), pre['sin(prediction)'].tolist())
    cos_mse = mean_squared_error(tes['cos(label)'].tolist(), pre['cos(prediction)'].tolist())
    r2 = model.score(X_test, y_test)
    score_df.loc['{}'.format(i), 'sin_mse'] = sin_mse
    score_df.loc['{}'.format(i), 'cos_mse'] = cos_mse
    score_df.loc['{}'.format(i), 'r^2_score'] = r2

col = ['sin_mse', 'cos_mse', 'r^2_score']
score_df = score_df[col]
#Ausgabe in das Ausgabeverzeichnis
score_df.to_csv('../output/score.csv')

Kommentar

(Entschuldigung für den schmutzigen Code ...) Schauen Sie sich hidden_layer_sizes an. Hier werden die Anzahl der Schichten (Anzahl der verborgenen Schichten) und die Anzahl der Einheiten des neuronalen Netzwerks auf verschiedene Arten geändert, wie unten gezeigt, damit Sie versuchen können, Fehler zu machen, welche Kombination eine gute Genauigkeit erzeugen kann.

Bewerten und visualisieren

Das Jupyter-Notebook eignet sich zur Visualisierung. Verwenden wir es also.

$ pip install jupyter

$ pwd
　[out]: .../DNN-learning-Sin-Cos-wave/code

$ ls
　[out]: make_dataset.py train.py viewer.ipynb

$ jupyter notebook

Öffnen Sie viewer.ipynb, wenn das Jupiter-Notizbuch in Ihrem Browser gestartet wird. Mit diesem Notizbuch können Sie die Daten auswerten und visualisieren, indem Sie sie einfach von oben ausführen. https://github.com/keroido/DNN-learning-Sin-Cos-wave/blob/master/code/viewer.ipynb Das Folgende ist die Ausführung auf Jupiter. (Code, der keiner Erklärung bedarf, wird weggelassen)

Im Ausgabeverzeichnis gibt es 15 CSV-Dateien mit Namen wie "Ergebnis_00_2_10.csv". Am Beispiel von 'result_00_2_10.csv' lautet der Name dieser Datei 00, wobei 2 die Anzahl der Ebenen und 10 die Anzahl der Einheiten ist. Daher wird diese CSV-Datei als "Ergebnis des Lernens mit dem neuronalen Netzwerk der 0. 2-Schicht-10-Einheit" bezeichnet.

!ls ../output

[out]:
result_00_2_10.csv  result_04_2_200.csv result_08_3_150.csv result_12_4_100.csv
result_01_2_50.csv  result_05_3_10.csv  result_09_3_200.csv result_13_4_150.csv
result_02_2_100.csv result_06_3_50.csv  result_10_4_10.csv  result_14_4_200.csv
result_03_2_150.csv result_07_3_100.csv result_11_4_50.csv  score.csv

1, Überprüfen Sie die Punktzahl jedes neuronalen Netzwerks

score_df = pd.read_csv('../output/score.csv')
score_df = score_df.drop('Unnamed: 0', axis=1)
score_df

Lassen Sie uns überprüfen, unter welchen Bedingungen der R ^ 2-Score-Wert gut ist. Wenn man sich die Ergebnisse ansieht, liefert das 9. neuronale Netzwerk mit 3 Schichten und 200 Einheiten von result_09_3_200.csv das beste Ergebnis. (Kann sich je nach Einstellung ändern) Sie können sehen, dass es nicht nur darum geht, eine tiefe Schicht zu haben.

2, Überprüfen Sie die CSV-Datei, die die beste Punktzahl ergab

tmp = pd.read_csv('../output/result_09_3_200.csv')
tmp = tmp.drop('Unnamed: 0', axis=1)
tmp

(Label) ist das richtige Label und (Vorhersage) ist der vorhergesagte Wert des neuronalen Netzwerks. Sie können sehen, dass Sie einen Wert vorhersagen können, der relativ nahe ist.

• X ist hier die Summe von x0 und x1.

3, tatsächlich visualisieren

files = glob.glob('../output/result*.csv')
files.sort()
csvs = []
t = []
for i in range(1, 16):
    t.append(files[i-1])
    if i%5 == 0:
        csvs.append(t)
        t = []

Sin

fig, axes = plt.subplots(3, 5, figsize=(15, 10))
fig.subplots_adjust(hspace=0.3, wspace=0.3)
for i in range(3):
    for j in range(5):
        tmp = pd.read_csv(csvs[i][j])
        axes[i, j].scatter(tmp.loc[:, 'x'], tmp.loc[:, 'sin(label)'], c='b')
        axes[i, j].scatter(tmp.loc[:, 'x'], tmp.loc[:, 'sin(prediction)'], c='r', alpha=0.5)
        axes[i, j].set_title('layer:{}, unit:{}'.format(csvs[i][j][20], csvs[i][j][22:-4]))
        plt.xlim(-5, 365)

cos

fig, axes = plt.subplots(3, 5, figsize=(15, 10))
fig.subplots_adjust(hspace=0.3, wspace=0.3)
for i in range(3):
    for j in range(5):
        tmp = pd.read_csv(csvs[i][j])
        axes[i, j].scatter(tmp.loc[:, 'x'], tmp.loc[:, 'cos(label)'], c='b')
        axes[i, j].scatter(tmp.loc[:, 'x'], tmp.loc[:, 'cos(prediction)'], c='r', alpha=0.5)
        axes[i, j].set_title('layer:{}, unit:{}'.format(csvs[i][j][20], csvs[i][j][22:-4]))
        plt.xlim(-5, 365)

Es macht Spaß, auf einen Blick zu sehen, wie das neuronale Netzwerk vorausgesagt hat, wenn Sie es visualisieren. Dies ist das Ende von "Ich habe keine GPU, aber ich werde Deep Learning ausprobieren". Danke für deine harte Arbeit.