Keras à partir de rien 1er

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

Qu'est-ce que rien

Keras démarre sans connaître Keras, ni même le réseau neuronal, ni même Python. On suppose que seul Python3 est installé (cela dépend de l'environnement, donc google).

Tout d'abord, installez-le.

$ sudo pip3 install tensorflow keras

Ensuite, démarrez Python.

$ python3

Je pense que le type interactif est plus facile à faire.

Faire un tableau

Les tableaux sont gérés par NumPy. Parce qu'il n'est pas tard.

import numpy as np
array = np.array([0.1,0.2,0.3])

La séquence a été créée. La première ligne charge la bibliothèque, elle est donc toujours nécessaire lors de son utilisation (c'est vrai).

Vous pouvez également créer deux dimensions. La direction de la ligne (direction horizontale) dans la matrice est le tableau interne. Si ci-dessous

\begin{pmatrix}0.1 & 0.2 & 0.3 \\ 0.4 & 0.6 & 0.8\end{pmatrix}

Représente.

array = np.array([[0.1,0.2,0.3], [0.4,0.6,0.8]])

La matrice zéro, la matrice avec tous les éléments 1 et la matrice unitaire sont les suivantes. Vous pouvez indiquer le nombre d'éléments dans le tableau avec (a, b, c, ...). Taple pour Python.

array = np.zeros((2,3))
array = np.ones((3,1))
array = np.identity(5) #la taille est(5,5)

Faisons une matrice aléatoire.

array = np.random.rand(3,2) #Distribution uniforme de 0 à moins de 1
array = np.random.randn(5,4) #Distribution normale avec moyenne 0 et variance 1
array = np.random.randint(0, 5, size=(2,3)) #Distribution uniforme discrète de 0 à moins de 5

Pratiquez jusqu'à présent.

Créer un jeu de données

Je veux apprendre, donc je vais simplement créer un ensemble de données.

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

Les données de la première ligne ne sont que 250 données en 5 dimensions. L'étiquette sur la deuxième ligne est un tableau qui prend une somme à 5 dimensions pour chacune des 250 données, et vaut 1 si elle est supérieure à 2,5 (ou 0 sinon).

En utilisant cela, si vous entrez un tableau à 5 dimensions approprié, créons un réseau de neurones qui vous indique 1 lorsque la somme est supérieure à 2,5.

Mettre en forme l'ensemble de données

Il y a deux classes de sortie, donc je veux vraiment que ce soit un chaud. En d'autres termes, pour une entrée (5ème dimension), la sortie est 2D, et si la somme des entrées est de 2,5 ou moins, elle sera «[1,0]», et si elle est supérieure à 2,5, elle sera «[0,1]». Voilà pourquoi.

Utilisez la fonction Keras pour ce faire. Les journaux sont crachés lors de l'importation, mais vous ne devriez pas avoir à vous en soucier.

from keras.utils import np_utils
labels = np_utils.to_categorical(labels)

Cela fait "labels" 250 tableaux bidimensionnels.

Créer un réseau neuronal

Sequential est un modèle simple qui empile simplement les couches. On a l'impression de saisir la sortie de la couche précédente telle quelle. Toutes les arêtes sont dessinées entre les nœuds (bien sûr, il peut être retiré, mais omis). Cette fois, considérons-le comme une couche intermédiaire (couche d'entrée, couche cachée, couche de sortie).

from keras.models import Sequential
from keras.layers import Dense, Activation
model = Sequential()

Ensuite, insérez le calque masqué en entrée. J'utiliserai un calque appelé Dense pour le moment. Vingt flèches sortent de chacun des cinq nœuds, indiquant qu'il y a 20 nœuds dans la couche suivante. Le nombre de nœuds doit correspondre au nombre de dimensions des données d'entrée (bien sûr).

model.add(Dense(20, input_dim=5))

Ensuite, mettons dans la fonction d'activation. Cinq valeurs numériques sont entrées pour chacun des 20 nœuds, et la somme pondérée (+ biais) des cinq valeurs numériques est prise de manière appropriée et la fonction est appliquée à la fin. La fonction à ce moment-là est la fonction d'activation. Cette fois, c'est la fonction de rampe.

model.add(Activation('relu'))

Je pense que ces deux sont identiques même s'ils sont résumés par Dense (20, input_dim = 5, activation = 'relu').

Vient ensuite la couche cachée - la couche de sortie. Les valeurs proviennent de chacun des 20 nœuds (après l'application de la fonction d'activation). La sortie est bidimensionnelle et applique une somme pondérée et une fonction softmax aux 20 valeurs qui arrivent au nœud. La fonction softmax semble être bonne pour la catégorisation.

model.add(Dense(2, activation='softmax'))

Cela ressemble à la figure ci-dessous (j'en ai fait 10 car il est difficile d'écrire 20 nœuds). C'est différent du diagramme général du réseau neuronal, mais je l'ai arrangé pour l'explication.

En fait, Dense et Activation représentent des couches, mais j'ai senti qu'il serait plus facile à comprendre si j'imaginais quelque chose à connecter.

compiler

Compilez avant d'apprendre.

Le premier est la fonction d'optimisation, le second est la fonction de perte et le troisième est une liste de métriques. Pour le moment, utilisez quelque chose de commun.

model.compile('rmsprop', 'categorical_crossentropy', metrics=['accuracy'])

Apprentissage

nb_epoch est le nombre de fois. validation_split est le pourcentage de données utilisées pour la validation (toutes les données ne sont pas utilisées pour la formation, seulement 80% sont utilisées pour la formation et les 20% restants sont utilisés pour l'évaluation).

model.fit(data, labels, nb_epoch=300, validation_split=0.2)

Avez-vous appris?

Prédiction de données inconnues

Essayez de voir si cela fonctionne réellement.

test = np.random.rand(200, 5)
predict = np.argmax(model.predict(test), axis=1)
real = (np.sum(test, axis=1) > 2.5) * 1
sum(predict == real) / 200.0

Elle peut être discriminée avec une précision d'environ 98%. Eh bien, c'est une condition si simple. Au fait, si vous portez un jugement sans transformer l'apprentissage, ce sera d'environ 50%. Eh bien, la chance de le toucher correctement est de 50%.

Résumé de ce programme

Les couches sont empilées en même temps que le modèle est défini.

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

data = np.random.rand(250,5)
labels = np_utils.to_categorical((np.sum(data, axis=1) > 2.5) * 1)
model = Sequential([Dense(20, input_dim=5), Activation('relu'), Dense(2, activation='softmax')])
model.compile('rmsprop', 'categorical_crossentropy', metrics=['accuracy'])
model.fit(data, labels, nb_epoch=300, validation_split=0.2)

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