Cliquez ici pour la loterie de Keras à partir de rien [http://qiita.com/Ishotihadus/items/6ecf5684c2cbaaa6a5ef)

Dernier examen

La dernière fois a fait un ensemble de données approximatif et l'a formé approximativement.

L'entrée est un vecteur à 5 dimensions avec des éléments 0 ou plus et moins de 1. La sortie est 0 si la somme des éléments du vecteur est inférieure ou égale à 2,5 et 1 si elle est supérieure à 2,5. La soi-disant «classification à deux classes» est effectuée.

L'ensemble de données a été créé comme suit. La sortie est un vecteur bidimensionnel unidimensionnel afin que le réseau neuronal puisse être manipulé facilement.

data = np.random.rand(250,5)
labels = np_utils.to_categorical((np.sum(data, axis=1) > 2.5) * 1)

Lors de la fabrication du modèle, j'ai fait ce qui suit. Deux couches se chevauchaient (sans entrée). L'entrée est de 5 dimensions, la couche cachée entre elles est de 20 dimensions et la sortie est de 2 dimensions.

model = Sequential()
model.add(Dense(20, input_dim=5, activation='relu'))
model.add(Dense(2, activation='softmax'))
model.compile('rmsprop', 'categorical_crossentropy', metrics=['accuracy'])

Fonction d'activation

Dans le réseau neuronal, nous prenons la somme pondérée des valeurs provenant de la couche précédente. Ajoutez-y la constante de biais et appliquez la fonction à la fin. La fonction à appliquer est la fonction d'activation. Vous pouvez également appliquer une fonction d'activation en utilisant une couche appelée ʻActivation`. Vous pouvez l'utiliser pour spécifier des paramètres, mais vous n'êtes pas obligé de l'utiliser.

Le biais devient un seuil lorsqu'il est négatif en termes de sens (il ne se déclenchera que si cette valeur est dépassée!). Au fait, le biais peut toujours être égal à 0 (spécifiez bias = False).

Types de fonctions d'activation

J'ai essayé de résumer dans une certaine mesure. Il est difficile de dire quoi choisir. Je pense que tanh et relu sont globalement populaires.

Les deux suivants prennent 1 de -1. tanh est plus raide. Lorsque l'entrée est 0, la sortie fonctionne également linéairement autour de 0,0, mais lorsque la valeur absolue devient grande, elle reste à -1 ou 1.

--Softsign

Tangente hypabolique (tanh)

Les deux suivants ne prennent que 0 ou plus et 1 ou moins. Le sigmoïde dur est plus raide et se brise. Le sigmoïde est lisse. Lorsque l'entrée est 0, la sortie est 0,5. Comme ci-dessus, il fonctionne linéairement autour de 0, mais reste à 0 ou 1 lorsque la valeur absolue augmente.

--Fonction sigmoïde (sigmoïde) --Sigmoïde_dur

Les deux valeurs suivantes prennent une valeur de 0 ou plus. Encore une fois, la fonction de rampe est plus raide et se brise. Soft Plus est (assez) lisse. Lorsque la valeur augmente dans une certaine mesure (lorsqu'elle est vue à partir de zéro), elle devient linéaire et lorsqu'elle diminue, elle devient proche de zéro. relu peut également prendre une valeur de coefficient inférieure à 0.

--Softplus --Fonction de rampe (relu)

Tout ce qui reste est la fonction linéaire et softmax.

Pour le linéaire, multipliez simplement par un coefficient pour ajouter un biais (le coefficient et le biais sont-ils appris?). Cependant, je ne pense pas que cela ait beaucoup de sens que la fonction d'activation soit linéaire, donc je ne l'utiliserai peut-être pas beaucoup.

Softmax multiplie toutes les valeurs produites par cette couche par une fonction exponentielle (c'est-à-dire les rend toutes positives) et normalise la somme à 1. Une fois cette fonction appliquée, la somme est égale à 1 et toutes les valeurs sont positives, donc elle peut être jugée comme une probabilité. C'est pourquoi j'ai utilisé softmax à la fin de l'exemple précédent.

Méthode d'optimisation (optimiseur)

Le premier argument de compile. Il existe différentes méthodes, mais comment savoir quels paramètres doivent être pris pour réduire l'erreur. Puisqu'il n'est pas possible de calculer intuitivement des paramètres évidents (comme la méthode des moindres carrés), je voudrais tourner les itérations pour réduire l'erreur une par une.

Voir This.

Vous pouvez sélectionner sgd, rsmprop, adagrad, adadelta, adam, adamax, nadam. Dans l'ensemble, il semble être une croyance commune que vous devriez choisir Adam (en ce sens que cela fonctionne raisonnablement bien sans trop prendre en compte les paramètres). RNN (Retroactive Neural Network) est lent à optimiser, il semble donc préférable d'utiliser rmsprop.

Au final, toutes les méthodes consistent à réduire progressivement la différenciation (gradient). SGD est juste le nom de "méthode probabiliste de descente de gradient". La raison pour laquelle je veux réduire le différentiel est que plus le gradient est petit (le différentiel est petit), plus la valeur extrême (maximum ou minimum) est proche. Si vous réduisez petit à petit le différentiel de la fonction d'erreur, la valeur de la fonction d'erreur se rapprochera automatiquement du minimum (bien sûr, cela dépend de la forme de la fonction). Cependant, l'efficacité de l'approche diffère selon la méthode, et parfois elle va trop loin. Elle s'inscrit également dans une solution locale, c'est-à-dire «elle peut être minime, mais globalement elle n'est pas du tout bonne». Ce sont des méthodes qui peuvent être réduites en tenant compte de ces éléments.

Fonction objective

Le deuxième argument de compile. La fonction que vous souhaitez réduire. Cela a presque la même signification que la perte. J'ai parlé de "quel type de méthode d'optimisation je veux réduire l'erreur", mais c'est "quels critères devraient être utilisés pour déterminer l'erreur". La «différence» signifie ici la différence entre la valeur estimée à partir du réseau neuronal actuel et la valeur de réponse correcte.

Vous pouvez choisir celui ci-dessous, mais peu importe celui que vous choisissez, il est toujours "suffisamment grand pour être imprévisible".

Erreur quadratique moyenne (mse: somme des carrés de différence)
Erreur absolue moyenne (msa: somme des valeurs absolues de différence)
Taux d'erreur absolu moyen (mspa: somme des valeurs absolues de la différence divisée par la valeur de réponse correcte (taux d'erreur))
Erreur quadratique moyenne logistique (msle: somme des carrés de la différence entre "la valeur logarithmique de 1") --La somme des pertes de charnière (charnière) --La somme des carrés des pertes de charnière (squared_hinge) --Entropie croisée lors de la classification de 2 classes (binary_crossentropy) --Entropie croisée pendant la classification de classe N (catégorical_crossentropy) --Sparse N-class classification crossentropy (sparse_categorical_crossentropy) -KL divergence (kld)
poisson
Similitude cosinus négative (cosinus_proximity)

La perte charnière est une fonction qui vaut 0 pour 1 ou plus et 1-x $ pour 1 ou moins pour la valeur obtenue en multipliant la valeur estimée et la valeur de réponse correcte (la perte est faible si les signes sont identiques).

L'entropie croisée est (presque) la quantité d'informations mutuelles. D'une manière ou d'une autre, vous pouvez voir que plus la taille est petite, meilleure est la catégorisation.

La divergence KL représente généralement la distance de la distribution de probabilité. La norme de divergence KL crée une atmosphère pour estimer la distribution de probabilité.

La similarité cosinus (négative) est le degré de différence dans la direction du vecteur. Apprenez à ce que les directions des vecteurs soient proches. Par conséquent, sa taille est ignorée et apprise.

Essayez d'organiser la fonction objectif

Organisons certaines options dans le même ensemble de données et dans la même situation.

Cette fois, la sortie est unidimensionnelle, -1 ou 1 (-1 si le total est de 2,5 ou moins, 1 s'il est supérieur à 2,5). Puisque le signe est important, la perte est la perte de charnière et la fonction d'activation de sortie est tanh. J'ai défini la fonction d'optimisation sur adam.

import numpy as np
from keras.models import Sequential
from keras.layers import Dense, Activation

data = np.random.rand(250,5)
labels = (np.sum(data, axis=1) > 2.5) * 2 - 1
model = Sequential([Dense(20, input_dim=5, activation='tanh'), Dense(1, activation='tanh')])
model.compile('adam', 'hinge', metrics=['accuracy'])
model.fit(data, labels, nb_epoch=150, validation_split=0.2)

test = np.random.rand(200, 5)
predict = np.sign(model.predict(test).flatten())
real = (np.sum(test, axis=1) > 2.5) * 2 - 1
print(sum(predict == real) / 200.0)

Il faut un peu de temps pour apprendre, mais il semble que la précision soit raisonnable. Eh bien, parce que l'ensemble de données est cela.