Notes sur l'utilisation de TensorFlow sur Bash sur Ubuntu sous Windows Donc, je peux utiliser TensorFlow, mais je ne sais pas comment l'utiliser.
Il existe une bibliothèque appelée TFLearn qui facilite l'utilisation de TensorFlow, donc je l'ai également incluse.
$ pip install tflearn
En regardant l'exemple de code, il y avait un programme appelé logic.py qui semble apprendre les opérations logiques, donc je l'ai essayé cette fois.
Comme logic.py est une collection d'apprentissage de plusieurs opérations logiques, j'ai essayé d'extraire uniquement les parties pertinentes.
import tensorflow as tf
import tflearn
# Logical OR operator
X = [[0., 0.], [0., 1.], [1., 0.], [1., 1.]]
Y = [[0.], [1.], [1.], [1.]]
# Graph definition
with tf.Graph().as_default():
g = tflearn.input_data(shape=[None, 2])
g = tflearn.fully_connected(g, 128, activation='linear')
g = tflearn.fully_connected(g, 128, activation='linear')
g = tflearn.fully_connected(g, 1, activation='sigmoid')
g = tflearn.regression(g, optimizer='sgd', learning_rate=2.,
loss='mean_square')
# Model training
m = tflearn.DNN(g)
m.fit(X, Y, n_epoch=100, snapshot_epoch=False)
# Test model
print("Testing OR operator")
print("0 or 0:", m.predict([[0., 0.]]))
print("0 or 1:", m.predict([[0., 1.]]))
print("1 or 0:", m.predict([[1., 0.]]))
print("1 or 1:", m.predict([[1., 1.]]))
C'est mon premier regard, mais je comprends d'une manière ou d'une autre le sens. Lorsque cela a été fait, le résultat était le suivant.
--
Training Step: 100 | total loss: 0.00227
| SGD | epoch: 100 | loss: 0.00227 -- iter: 4/4
--
Testing OR operator
0 or 0: [[0.031054211780428886]]
0 or 1: [[0.9823662638664246]]
1 or 0: [[0.9786670207977295]]
1 or 1: [[0.9999874830245972]]
Si vous le regardez numériquement comme 0 ou 1, vous avez appris OR.
D'ailleurs, dans le premier code, 128 couches intermédiaires sont reliées par deux couches. J'ai essayé de supprimer la couche intermédiaire parce que je n'ai pas besoin de la couche intermédiaire comme l'apprentissage OU. Au lieu de cela, j'ai augmenté le nombre d'apprentissage à 2000.
import tensorflow as tf
import tflearn
# Logical OR operator
X = [[0., 0.], [0., 1.], [1., 0.], [1., 1.]]
Y = [[0.], [1.], [1.], [1.]]
# Graph definition
with tf.Graph().as_default():
g = tflearn.input_data(shape=[None, 2])
g = tflearn.fully_connected(g, 1, activation='sigmoid')
g = tflearn.regression(g, optimizer='sgd', learning_rate=2., loss='mean_square')
# Model training
m = tflearn.DNN(g)
m.fit(X, Y, n_epoch=2000, snapshot_epoch=False)
# Test model
print("Testing OR operator")
print("0 or 0:", m.predict([[0., 0.]]))
print("0 or 1:", m.predict([[0., 1.]]))
print("1 or 0:", m.predict([[1., 0.]]))
print("1 or 1:", m.predict([[1., 1.]]))
Le résultat de cela.
--
Training Step: 2000 | total loss: 0.00098
| SGD | epoch: 2000 | loss: 0.00098 -- iter: 4/4
--
Testing OR operator
0 or 0: [[0.041201911866664886]]
0 or 1: [[0.9756871461868286]]
1 or 0: [[0.9764388799667358]]
1 or 1: [[0.9999741315841675]]
Il semble que j'ai pu apprendre OU correctement.
Ensuite, j'ai essayé d'apprendre ET. Le code est le même que changer simplement le signal de l'enseignant en ET.
import tensorflow as tf
import tflearn
# Logical AND operator
X = [[0., 0.], [0., 1.], [1., 0.], [1., 1.]]
Y = [[0.], [0.], [0.], [1.]]
# Graph definition
with tf.Graph().as_default():
g = tflearn.input_data(shape=[None, 2])
g = tflearn.fully_connected(g, 1, activation='sigmoid')
g = tflearn.regression(g, optimizer='sgd', learning_rate=2., loss='mean_square')
# Model training
m = tflearn.DNN(g)
m.fit(X, Y, n_epoch=2000, snapshot_epoch=False)
# Test model
print("Testing AND operator")
print("0 and 0:", m.predict([[0., 0.]]))
print("0 and 1:", m.predict([[0., 1.]]))
print("1 and 0:", m.predict([[1., 0.]]))
print("1 and 1:", m.predict([[1., 1.]]))
Le résultat de cela.
--
Training Step: 2000 | total loss: 0.00137
| SGD | epoch: 2000 | loss: 0.00137 -- iter: 4/4
--
Testing AND operator
0 and 0: [[8.591794176027179e-05]]
0 and 1: [[0.04014528915286064]]
1 and 0: [[0.03964542970061302]]
1 and 1: [[0.9525935053825378]]
C'est certainement devenu ET.
Puisque OU et ET peuvent être séparés linéairement, une couche intermédiaire n'est pas nécessaire, mais XOR ne peut pas être séparé linéairement, donc une couche intermédiaire est nécessaire. Toutefois, dans l'exemple de code, au lieu de former directement XOR, NAND et OR sont formés, combinés et utilisés.
Je ne savais pas pourquoi je ne l'avais pas entraîné directement, alors j'ai écrit un code pour entraîner directement XOR.
import tensorflow as tf
import tflearn
# Logical XOR operator
X = [[0., 0.], [0., 1.], [1., 0.], [1., 1.]]
Y = [[0.], [1.], [1.], [0.]]
# Graph definition
with tf.Graph().as_default():
g = tflearn.input_data(shape=[None, 2])
g = tflearn.fully_connected(g, 2, activation='sigmoid')
g = tflearn.fully_connected(g, 1, activation='sigmoid')
g = tflearn.regression(g, optimizer='sgd', learning_rate=2., loss='mean_square')
# Model training
m = tflearn.DNN(g)
m.fit(X, Y, n_epoch=2000, snapshot_epoch=False)
# Test model
print("Testing XOR operator")
print("0 xor 0:", m.predict([[0., 0.]]))
print("0 xor 1:", m.predict([[0., 1.]]))
print("1 xor 0:", m.predict([[1., 0.]]))
print("1 xor 1:", m.predict([[1., 1.]]))
Cela a juste fait le signal du professeur XOR et ajouté deux couches intermédiaires. Alors, quand j'ai fait ça, ça s'est passé comme ça.
--
Training Step: 2000 | total loss: 0.25000
| SGD | epoch: 2000 | loss: 0.25000 -- iter: 4/4
--
Testing XOR operator
0 xor 0: [[0.5000224709510803]]
0 xor 1: [[0.5000009536743164]]
1 xor 0: [[0.49999910593032837]]
1 xor 1: [[0.4999775290489197]]
Je ne peux pas apprendre ça. Ainsi, lorsque j'ai cherché sur Google, la page suivante a été capturée. C'est le site habituel de Stack Overflow.
tflearn / tensorflow does not learn xor
Selon cela, avec le réglage standard, la valeur initiale du poids semble être assez étroite avec un écart type de 0,02. Par conséquent, il semble préférable d'élargir la plage des valeurs de poids initiales de -1 à 1.
import tensorflow as tf
import tflearn
# Logical XOR operator
X = [[0., 0.], [0., 1.], [1., 0.], [1., 1.]]
Y = [[0.], [1.], [1.], [0.]]
# Graph definition
with tf.Graph().as_default():
tnorm = tflearn.initializations.uniform(minval=-1.0, maxval=1.0)
g = tflearn.input_data(shape=[None, 2])
g = tflearn.fully_connected(g, 2, activation='sigmoid', weights_init=tnorm)
g = tflearn.fully_connected(g, 1, activation='sigmoid', weights_init=tnorm)
g = tflearn.regression(g, optimizer='sgd', learning_rate=2., loss='mean_square')
# Model training
m = tflearn.DNN(g)
m.fit(X, Y, n_epoch=2000, snapshot_epoch=False)
# Test model
print("Testing XOR operator")
print("0 xor 0:", m.predict([[0., 0.]]))
print("0 xor 1:", m.predict([[0., 1.]]))
print("1 xor 0:", m.predict([[1., 0.]]))
print("1 xor 1:", m.predict([[1., 1.]]))
Le résultat de l'exécution en modifiant le réglage de la valeur initiale du poids de cette manière.
--
Training Step: 2000 | total loss: 0.00131
| SGD | epoch: 2000 | loss: 0.00131 -- iter: 4/4
--
Testing XOR operator
0 xor 0: [[0.03527239337563515]]
0 xor 1: [[0.9663047790527344]]
1 xor 0: [[0.9607295393943787]]
1 xor 1: [[0.03082425333559513]]
J'ai pu apprendre XOR en toute sécurité.
C'est facile à comprendre car le code correspond à l'idée de réseau de neurones. Il n'est peut-être pas possible d'ajuster TensorFlow, mais pour ceux qui ne savent pas ce que TensorFlow peut faire en premier lieu, pourquoi ne pas commencer par TF Learn?
Recommended Posts