[PYTHON] Manabu NN mit App: Tensol Flow Playground mit Keras verstehen
Dieser Artikel wurde am 13. Oktober 2020 eingereicht, aber gelöscht und leicht umgeschrieben und am 14. Oktober 2020 um 15:12 Uhr erneut eingereicht.
Tensol Flow-Spielplatz (Neural Network Playground false & percTrainData = 50 & x = true & y = true & xTimesY = false & xSquared = false & ySquared = false & cosX = false & sinX = false & cosy = false & sinY = false & collectStats = false & problem = Klassifizierung & initZero = false & hideText = false)) ist eine Lernanwendung für ein neuronales Netzwerk, die im Browser ausgeführt wird. Damit kann jeder das neuronale Netzwerk in kurzer Zeit leicht verstehen.
Weitere Informationen finden Sie unter Manabu NN in App: Spielplatz für künstliche Intelligenz und Tensolfluss.
Um den Inhalt genauer zu verstehen, ist es jedoch eine Möglichkeit, dasselbe in einer anderen Programmiersprache zu machen. Dieser Artikel verwendet dazu Keras.
Kreis
Das obige Bild ist der Startbildschirm des Tensol Flow Playground. Für die Ausgabedaten wird ein Kreis ausgewählt, und für die Eingabedaten werden X1 und X2 ausgewählt. Ich werde es versuchen.
Eine Möglichkeit besteht darin, den gleichen Schritt mit Keras zu versuchen, um ein genaues Verständnis dessen zu erhalten, was dies tut. Also habe ich folgendes Programm gemacht.
#Initialisieren
%matplotlib inline
import pandas_datareader.data as web
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
import datetime
import keras
from keras.models import Sequential
from keras.layers import Dense, Activation
from keras.optimizers import SGD
from keras import models
from keras import layers
from keras import regularizers
from sklearn.metrics import mean_squared_error
from sklearn.model_selection import train_test_split
Datenkonstruktion
n=250
theta=np.random.uniform(0, 360, n)
x1=np.sin(theta)*np.random.uniform(3,5, n)
x2=np.cos(theta)*np.random.uniform(3,5, n)
y=np.ones(n)
plt.figure(figsize=(4, 4), dpi=50)
plt.scatter(x1,x2)
theta=np.random.uniform(0, 360, n)
x11=np.sin(theta)*np.random.uniform(-0, 2, n)
x22=np.cos(theta)*np.random.uniform(-0,2, n)
yy=np.zeros(n)
plt.scatter(x11,x22)
Ausführungsergebnis
#Erstellung von Trainingsdaten und Testdaten
x1=np.concatenate([x1,x11],axis=0)
x2=np.concatenate([x2,x22],axis=0)
y=np.concatenate([y,yy],axis=0)
X=np.stack([x1,x2],1)#.reshape(-1,2)
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.5, random_state=42)
Netzwerkaufbau und -optimierung
model = models.Sequential()
model.add(layers.Dense(8, activation='tanh', input_shape=(2,)))
model.add(layers.Dense(8, activation='tanh'))
model.add(layers.Dense(1, activation='sigmoid'))
model.compile(optimizer='rmsprop',
loss='binary_crossentropy',
metrics=['accuracy'])
model.fit(
X_train,
y_train,
batch_size=10,
epochs=500,
verbose=0)
#Auswertung der Ergebnisse
results = model.evaluate(X_train, y_train)
results
# 8/8 [==============================] - 0s 1ms/step - loss: 3.0139e-05 - accuracy: 1.0000
# [3.0139368391246535e-05, 1.0]
results = model.evaluate(X_test, y_test)
results
# 8/8 [==============================] - 0s 2ms/step - loss: 1.6788e-04 - accuracy: 1.0000
# [0.0001678814151091501, 1.0]
Beide Ergebnisse haben keinen Fehler. Alle Fragen waren richtig. Lassen Sie uns die Eingabedaten zum besseren Verständnis ändern.
Ich konnte die Daten mit einem einfachen Perceptron ordentlich klassifizieren. Machen wir das mit Keras.
X2=np.stack([x1**2,x2**2],1)#.reshape(-1,2)
X2_train, X2_test, y_train, y_test = train_test_split(
X2, y, test_size=0.33, random_state=42)
model = models.Sequential()
model.add(layers.Dense(1, activation='tanh', input_shape=(2,)))
model.add(layers.Dense(1, activation='sigmoid'))
model.compile(optimizer='rmsprop',
loss='binary_crossentropy',
metrics=['accuracy'])
model.fit(
X2_train,
y_train,
batch_size=10,
epochs=500,
verbose=0)
Das Ergebnis ist wie folgt.
results = model.evaluate(X2_train, y_train)
results
# 11/11 [==============================] - 0s 3ms/step - loss: 8.3843e-08 - accuracy: 1.0000
# [8.38432754335372e-08, 1.0]
results = model.evaluate(X2_test, y_test)
results
# 6/6 [==============================] - 0s 2ms/step - loss: 8.3747e-08 - accuracy: 1.0000
# [8.374658477805497e-08, 1.0]
In beiden Fällen beträgt die Genauigkeitsrate 100% und der Fehler ist Null.
Normalverteilung
Als nächstes kommt die Normalverteilung.
Erstellen Sie zunächst die Daten.
n=250
x1=np.random.normal(2,0.5, n)
x2=np.random.normal(2,0.5, n)
y=np.ones(n)
plt.figure(figsize=(4, 4), dpi=50)
plt.scatter(x1,x2)
x11=np.random.normal(-2,0.5, n)
x22=np.random.normal(-2,0.5, n)
yy=np.zeros(n)
plt.scatter(x11,x22)
x1=np.concatenate([x1,x11],axis=0)
x2=np.concatenate([x2,x22],axis=0)
y=np.concatenate([y,yy],axis=0)
X=np.stack([x1,x2],1)#.reshape(-1,2)
Verwenden Sie das gleiche neuronale Netzwerk wie für Kreise. Das Ergebnis ist
results = model.evaluate(X_train, y_train)
results
# 8/8 [==============================] - 0s 1ms/step - loss: 3.0139e-05 - accuracy: 1.0000
# [3.0139368391246535e-05, 1.0]
Die korrekte Antwortrate mit Null Fehler beträgt wieder 100%.
In diesem Fall
Es wird auch sein.
XOR
Als nächstes kommt XOR.
n=125
x1=np.random.uniform(0,5, n)
x2=np.random.uniform(0,5, n)
y=np.ones(n)
x11=np.random.uniform(-5,0, n)
x22=np.random.uniform(-5,0, n)
yy=np.ones(n)
x1=np.concatenate([x1,x11],axis=0)
x2=np.concatenate([x2,x22],axis=0)
y=np.concatenate([y,yy],axis=0)
plt.figure(figsize=(4, 4), dpi=50)
plt.scatter(x1,x2)
x11=np.random.uniform(0,5, n)
x22=np.random.uniform(0,-5, n)
yy=np.zeros(n)
x111=np.random.uniform(-5,0, n)
x222=np.random.uniform(0,5, n)
yyy=np.zeros(n)
x11=np.concatenate([x11,x111],axis=0)
x22=np.concatenate([x22,x222],axis=0)
yy=np.concatenate([yy,yyy],axis=0)
plt.scatter(x11,x22)
len(x1),len(x2)
# (250, 250)
Sie können sehen, dass 250 Daten erstellt wurden.
Mische und teile die Trainings- und Testdaten.
x1=np.concatenate([x1,x11],axis=0)
x2=np.concatenate([x2,x22],axis=0)
y=np.concatenate([y,yy],axis=0)
X=np.stack([x1,x2],1)#.reshape(-1,2)
len(y)
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.5, random_state=42)
Wir werden versuchen, diese Daten nach NN von 2 Schichten (1. Schicht 4 Einheiten, 2. Schicht 2 Einheiten) zu klassifizieren. Ergebnis ist
results = model.evaluate(X_train, y_train)
results
# 8/8 [==============================] - 0s 2ms/step - loss: 0.0818 - accuracy: 0.9640
# [0.08181502670049667, 0.9639999866485596]
results = model.evaluate(X_test, y_test)
results
# 8/8 [==============================] - 0s 2ms/step - loss: 0.1269 - accuracy: 0.9520
# [0.1269153356552124, 0.9520000219345093]
Der Fehler ist fast Null und die richtige Antwortrate liegt bei über 90%.
Als nächstes ändern wir die Struktur der Daten wie folgt.
X_train, X_test, y_train, y_test = train_test_split(
x1*x2, y, test_size=0.33, random_state=42)
model = models.Sequential()
model.add(layers.Dense(1, activation='tanh', input_shape=(1,)))
model.add(layers.Dense(1, activation='sigmoid'))
model.compile(optimizer='rmsprop',
loss='binary_crossentropy',
metrics=['accuracy'])
model.fit(
X_train,
y_train,
batch_size=10,
epochs=500,
verbose=0)
Das Ergebnis ist wie folgt.
results = model.evaluate(X_train, y_train)
results
# 11/11 [==============================] - 0s 1ms/step - loss: 5.6793e-04 - accuracy: 1.0000
# [0.0005679333116859198, 1.0]
results = model.evaluate(X_test, y_test)
results
# 6/6 [==============================] - 0s 3ms/step - loss: 0.0070 - accuracy: 0.9939
# [0.007003221195191145, 0.9939393997192383]
Der Fehler war fast Null und die richtige Antwortrate war fast 100%.
Referenz:
"Simulator de Manabu Neural Network" (Amazon Kindle Publishing)
"Das Gehirn mit Gehirn, Verstand und Mathematik der künstlichen Intelligenz enträtseln" (Blue Bucks) "Ansatz zur spärlichen Modellierung basierend auf Kompressionserfassung"