Cliquez ici pour la loterie de Keras à partir de rien [http://qiita.com/Ishotihadus/items/6ecf5684c2cbaaa6a5ef)
La dernière fois a fait un ensemble de données approximatif et l'a formé approximativement. J'avais l'habitude d'utiliser un modèle séquentiel simple, mais j'ai utilisé l'API fonctionnelle, qui me donne une sensation plus flexible et en couches.
L'entrée est de 5 dimensions et chaque élément est supérieur ou égal à 0 et inférieur à 1. La sortie est unidimensionnelle, -1 si la somme des éléments d'entrée est de 2,5 ou moins, 1 si elle est supérieure à 2,5. Une soi-disant «classification à deux classes» a été effectuée.
La couche d'entrée est de 5 dimensions. La couche cachée est de 20 dimensions et la fonction d'activation est tanh. La couche de sortie est unidimensionnelle et la fonction d'activation est également tanh.
La fonction de perte pendant l'entraînement utilise la perte de charnière.
Jusqu'à présent, j'ai appris dans l'atmosphère et estimé dans l'atmosphère. (!)
Cependant, la mise en œuvre de la méthode d'apprentissage est un peu gênante. Il est vrai que le calcul et la mise en italique des différentiels devraient être implémentés, mais comme il s'agit d'un dieu nommé Keras (en fait TensorFlow ou Theano dieu à l'intérieur), ignorons-le un instant.
Le but de ce temps est de pouvoir au moins estimer à partir des paramètres.
Comme je le dis plusieurs fois, chaque couche effectue trois opérations: "somme pondérée pour l'entrée", "biais" et "appliquer la fonction d'activation (le cas échéant)". Faisons ces 3 opérations à la main et vérifions que cela fonctionne correctement.
Si le modèle est trop grand, le calcul manuel sera gênant, alors réduisez-le. L'entrée est bidimensionnelle (chaque élément est égal ou supérieur à 0 et inférieur à 1), et la sortie est égale à -1 si la somme des entrées est inférieure ou égale à 0,5 et à 1 si elle est supérieure à 0,5. Le calque masqué a 5 dimensions et les autres conditions sont les mêmes qu'auparavant.
Cette fois, je veux connaître la valeur, il est donc préférable de le faire dans un environnement interactif.
Contrairement à la dernière fois, le calque est traité tel quel, pas le tenseur (l'état où l'entrée est donnée au calque). Il renvoie le tenseur lorsque vous le saisissez dans le modèle.
import numpy as np
from keras.layers import Input, Dense
from keras.models import Model
data = np.random.rand(250,2)
labels = (np.sum(data, axis=1) > 0.5) * 2 - 1
input = Input(shape=(2,))
hidden = Dense(5, activation='tanh')
output = Dense(1, activation='tanh')
model = Model(input=input, output=output(hidden(input)))
model.compile('adam', 'hinge', metrics=['accuracy'])
model.fit(data, labels, nb_epoch=150, validation_split=0.2)
Maintenant, connaissons le poids. Les poids peuvent être obtenus par get_weights () sur les couches.
hidden.get_weights()
La sortie ressemble à ceci: Le premier tableau est le vecteur de poids, le second est le biais.
[array([[-1.08239257, 0.32482854, 0.95010394, 0.00501535, -0.47380614],
[-0.56682748, 1.15749049, 0.91618514, 0.37518814, -0.67639047]], dtype=float32),
array([-0.18290569, 0.21453567, 0.01353107, 0.27740911, 0.09604219], dtype=float32)]
Le même poids est obtenu pour la «sortie» comme suit.
[array([[-0.8775745 ],
[ 1.09351909],
[ 0.21981503],
[ 1.31380796],
[-0.10301871]], dtype=float32),
array([ 0.27410847], dtype=float32)]
Maintenant, calculons réellement.
L'entrée est $ \ boldsymbol {x} $ (vecteur vertical à deux dimensions).
À ce stade, à partir de la sortie ci-dessus, la sortie de la couche cachée $ \ boldsymbol {h} $ est la suivante (tanh est appliqué à l'élément, $ {} ^ \ top $ est la translocation).
\boldsymbol{h} = \tanh\left(
\begin{bmatrix}
-1.08239257 & 0.32482854 & 0.95010394 & 0.00501535 & -0.47380614 \\
-0.56682748 & 1.15749049 & 0.91618514 & 0.37518814 & -0.67639047
\end{bmatrix}^\top\boldsymbol{x} + \begin{bmatrix}
-0.18290569 \\ 0.21453567 \\ 0.01353107 \\ 0.27740911 \\ 0.09604219
\end{bmatrix}\right)
Et la sortie $ \ boldsymbol {y} $ de la couche de sortie peut être calculée comme suit.
\boldsymbol{y} = \tanh\left(
\begin{bmatrix}
-0.8775745 \\ 1.09351909 \\ 0.21981503 \\ 1.31380796 \\ -0.10301871
\end{bmatrix}^\top\boldsymbol{h} + 0.27410847\right)
Calculons manuellement en fonction de cela. ici
\boldsymbol{x} = \begin{bmatrix}0.3 \\ 0.1\end{bmatrix}
Essayez comme. À partir de là, réduisez le nombre de chiffres après la virgule décimale.
\begin{array}{rl}
\boldsymbol{h} &= \tanh\left(
\begin{bmatrix}
-1.0824 & 0.3248 & 0.9501 & 0.0050 & -0.4738 \\
-0.5668 & 1.1575 & 0.9162 & 0.3752 & -0.6764
\end{bmatrix}^\top\begin{bmatrix}0.3 \\ 0.1\end{bmatrix} + \begin{bmatrix}
-0.1829 \\ 0.2145 \\ 0.0135 \\ 0.2774 \\ 0.0960
\end{bmatrix}\right) \\
&= \tanh\left(
\begin{bmatrix}-0.3814 \\ 0.2132 \\ 0.3766 \\ 0.0390 \\-0.2098\end{bmatrix} + \begin{bmatrix}
-0.1829 \\ 0.2145 \\ 0.0135 \\ 0.2774 \\ 0.0960
\end{bmatrix}
\right) \\
&= \begin{bmatrix}-0.5112 \\ 0.4034 \\ 0.3715 \\ 0.3063 \\ -0.1133\end{bmatrix}
\\\\
\boldsymbol{y} &= \tanh\left(
\begin{bmatrix}
-0.8776 \\ 1.0935 \\ 0.2198 \\ 1.3138 \\ -0.1030
\end{bmatrix}^\top
\begin{bmatrix}-0.5112 \\ 0.4034 \\ 0.3715 \\ 0.3063 \\ -0.1133\end{bmatrix}
+ 0.2741\right) \\
&= \tanh\left(1.3855 + 0.2741\right) \\
&= 0.9302
\end{array}
Hmm? 0,3 + 0,1 vaut 0,5 ou moins, mais c'est une valeur positive ...
model.predict(np.array([[0.3, 0.1]]))
Le résultat est
array([[ 0.93015909]], dtype=float32)
Ainsi, il s'avère que la même estimation peut être faite à la main (bien que l'estimation soit erronée).
Il s'est avéré que je ne pouvais pas apprendre correctement car le nombre de dimensions était petit et le modèle convenait ... (environ 85%).
Il semble que le calcul ait été fait pour le moment, alors disons que ça va.
Si vous pouvez faire un poids, vous pouvez créer un modèle qui répondra certainement correctement, alors faisons-le.
Il vous suffit d'ajouter les deux entrées avec un poids de 1 et de soustraire -0,5, alors faites-le avec set_weights ().
import numpy as np
from keras.layers import Input, Dense
from keras.models import Model
data = np.random.rand(250,2)
labels = (np.sum(data, axis=1) > 0.5) * 2 - 1
input = Input(shape=(2,))
output = Dense(1, activation='tanh')
model = Model(input=input, output=output(input))
model.compile('adam', 'hinge', metrics=['accuracy'])
output.set_weights([np.array([[1.0], [1.0]]), np.array([-0.5])])
Terrible. Courons avec ça.
test = np.random.rand(200, 2)
predict = np.sign(model.predict(test).flatten())
real = (np.sum(test, axis=1) > 0.5) * 2 - 1
print(sum(predict == real) / 200.0)
Non. 100%.
La prochaine fois, nous travaillerons avec un ensemble de données légèrement plus grand.
Recommended Posts