[PYTHON] Manabu NN avec application: comprendre le terrain de jeu Tensol Flow avec Keras
Cet article a été soumis le 13 octobre 2020, mais il a été supprimé et légèrement réécrit, et il a été soumis à nouveau le 14 octobre 2020 à 15h12.
Terrain de jeu Tensol Flow ([Terrain de jeu de réseau neuronal](https://playground.tensorflow.org/#activation=tanh&batchSize=10&dataset=circle®Dataset=reg-plane&learningRate=0.03®ularizationRate=0&noise=0&networkShape=4,27&seed=Towetize04,27&seed=0&networkShape} false & percTrainData = 50 & x = true & y = true & xTimesY = false & xSquared = false & ySquared = false & cosX = false & sinX = false & cosy = false & sinY = false & collectStats = false & problem = classification & initZero = false & hideText = false)) est une application d'apprentissage de réseau neuronal qui s'exécute sur le navigateur. Avec cela, tout le monde peut facilement comprendre le réseau neuronal en peu de temps.
Veuillez vous référer à Manabu NN in App: Moving Artificial Intelligence-Tensol Flow Playground.
Cependant, afin de comprendre le contenu plus en détail, c'est une façon d'essayer de faire la même chose dans un autre langage de programmation. Cet article utilise des keras pour ce faire.
Cercle
L'image ci-dessus est l'écran initial de Tensol Flow Playground. Un cercle est sélectionné pour les données de sortie, et X1 et X2 sont sélectionnés pour les données d'entrée. Je vais essayer.
Une option consiste à essayer le même mouvement avec Keras pour obtenir une compréhension précise de ce que cela fait. J'ai donc fait le programme suivant.
#Initialisation
%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
Construction de données
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)
Résultat d'exécution
#Création de données d'entraînement et de données de test
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)
Construction et optimisation du réseau
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)
#Évaluation des résultats
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]
Les deux résultats n'ont aucune erreur. Toutes les questions étaient correctes. Modifions les données d'entrée pour une meilleure compréhension.
J'ai pu classer les données proprement avec un simple Perceptron. Faisons cela avec 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)
Le résultat est le suivant.
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]
Dans les deux cas, le taux de précision est de 100% et l'erreur est de zéro.
distribution normale
Vient ensuite la distribution normale.
Tout d'abord, créez les données.
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)
Utilisez le même réseau neuronal que pour les cercles. Le résultat est
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]
Le taux de réponse correct avec zéro erreur est à nouveau de 100%.
Dans ce cas
Ce sera également le cas.
XOR
Vient ensuite 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)
Vous pouvez voir que 250 éléments de données ont été créés.
Mélangez et divisez les données d'entraînement et de test.
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)
Nous allons essayer de classer ces données par NN de 2 couches (1ère couche 4 unités, 2ème couche 2 unités). Le résultat est
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]
L'erreur est presque nulle et le taux de réponse correcte est supérieur à 90%.
Ensuite, modifions la structure des données comme suit.
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)
Le résultat est le suivant.
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]
L'erreur était presque nulle et le taux de précision était de presque 100%.
référence:
"Simulator de Manabu Neural Network" (Amazon Kindle Publishing)
"Démêler le cerveau avec les mathématiques du cerveau, de l'esprit et de l'intelligence artificielle" (Blue Bucks) "Approche de la modélisation clairsemée basée sur la détection de la compression"