[PYTHON] Exemple d'utilisation de Keras: Input (Embedding + Flatten)

1. Installez Keras

Étant donné que la méthode d'installation de Tensorflow et Theano est introduite sur divers sites, une explication détaillée est omise ici. Installation de Keras

pip install Keras

Ensuite, jouez simplement avec le fichier de configuration et sélectionnez Theano ou Tensorflow. Si vous utilisez Tensorflow sur le backend, il utilisera automatiquement le GPU.

Lors de l'utilisation de Tensorflow avec Keras, à partir de janvier 2017, l'erreur suivante peut se produire.

AttributeError: 'module' object has no attribute 'control_flow_ops'

Il semble qu'une telle erreur se produise car python.control_flow_ops n'existe pas dans tensorflow. StackOverflow, [git Discussion](https://github.com / fchollet / keras / issues / 3857). Il peut être guéri en le définissant au début du script comme suit.

import tensorflow as tf
tf.python.control_flow_ops = tf

2. Input(Embedding + Flatten) + Layer + Dropout + Output

Il s'agit de l'exemple de code introduit dans Kaggle Summary: Redhat. Le problème initial est un problème de classification binaire de savoir si un client inconnu achète ou non un service à partir d'environ 100 variables basées sur les informations client. Parmi eux, qianqian a publié une méthode d'analyse utilisant Keras. ** Normalement, les variables sont conçues et prétraitées, puis placées dans la couche d'entrée telles quelles, mais qianqian transmet chaque variable indépendamment à travers les couches Embedding et Flatten, puis les fusionne. ** **

Code auteur (qianqian) ou [ce code](https: // Veuillez utiliser gist.github.com/TomHortons/dd672a4323f42aed59316c9f56f72574).

Voici un diagramme qui visualise le modèle créé avec visualize_util. (Voir «Autre» dans cet article)

Ici, nous nous concentrerons sur l'explication du traitement Embedding + Flatten à partir du code source de référence.

Regardons d'abord la partie de création d'entrée. L'entrée est créée avec le code suivant.

flatten_layers = []
inputs = []

for c in columns:

    inputs_c = Input(shape=(1,), dtype='int32')

    num_c = len(np.unique(data[c].values))

    embed_c = Embedding(
                    num_c,
                    dim,
                    dropout=0.2,
                    input_length=1
                    )(inputs_c)
    flatten_c= Flatten()(embed_c)

    inputs.append(inputs_c)
    flatten_layers.append(flatten_c)

flatten = merge(flatten_layers,mode='concat')

colonnes est une liste qui stocke les noms de colonnes. Comme vous pouvez le voir sur la première figure, chaque variable n'est pas saisie telle quelle. Input-> Embedding-> flatten est exécuté pour chaque variable, et toutes les 1600 variables sont fusionnées pour en faire une couche d'entrée. En d'autres termes, les données numériques unidimensionnelles sont étendues à 32 dimensions et entrées.

fc1 = Dense(hidden,activation='relu')(flatten)
dp1 = Dropout(0.5)(fc1)

outputs = Dense(1,activation='sigmoid')(dp1)

Après cela, une couche intermédiaire (fc1) et une dropbou (dp1) sont définies comme sortie.

Comme vous pouvez le voir dans cet article, Deep Language Modeling for Question Answering using Keras L'intégration semble être utilisée comme Word2Vec dans l'apprentissage des langues. La raison pour laquelle Embedding était utilisée pour des données numériques qui n'étaient pas un apprentissage de la langue était un mystère, j'ai donc vérifié le forum Kaggle.

Cela ressemble à ça quand je l'explique grossièrement.

Le calque Incorporation transforme chaque catégorie en un espace d'entités différent. Il n'est pas facile de trouver une représentation qui encode les meilleures fonctionnalités, et pouvez-vous entraîner tout cela avec cette technique? .. Le meilleur neuronal se compose uniquement de la couche d'intégration avec un score de 0,9877. En y ajoutant plus de fonctionnalités, il passera à 0,989. Il est difficile de déterminer chaque paramètre (nombre de couches cachées, dimension d'incorporation, méthode de fusion des fonctionnalités supplémentaires, taille du lot, nombre d'époques de train) en premier lieu.

Le calque Embedding a les fonctions suivantes. Pour les données de catégorie [1,2,3]

1. Effectuer le codage, 1: [1,0,0], 2: [0,1,0], 3: [0,0,1]
2. Multipliez la matrice de poids W dont la forme est (3, k).
3. Enfin, une matrice one-hot (la valeur spécifique est 1 puis zéro) avec la forme (4, k) est complétée.

Où k est la dimension de la fonction potentielle définie par l'utilisateur. En d'autres termes, la couche d'intégration effectue une transformation linéaire des données de catégorie.

En outre, il y a l'explication suivante à propos de la couche dix plate.

Puisqu'il n'y a qu'un seul type de séquence d'entrée (l'entrée est unidimensionnelle), la sortie de la couche d'intégration est N * 1 * 32. Par conséquent, il est nécessaire de transformer la forme de la sortie en N * 32. Où N est le nombre de données d'entrée (probablement). Si M est le nombre de quantités de caractéristiques de catégorie, il aura une entrée dimensionnelle M * 32. Pour les raisons ci-dessus, la sortie aplatie est concaténée. L'entrée du modèle Keras est la couche d'entrée exprimée dans une liste.

Très gentiment, il a réécrit la relation entre le calque d'incorporation et le calque d'aplatissement afin que vous puissiez voir la sortie du calque du milieu.

inputs = [model.layers[0].input,K.learning_phase()]
outputs = [model.layers[3].output]
func = K.function(inputs, outputs)

sample_size = data.shape[0]
data_ae = []
batches = make_batches(sample_size, batch_size)
for batch_index, (batch_start, batch_end) in enumerate(batches):
    X_0 = data[batch_start:batch_end].toarray()
    yy = func([X_0,0])[0]
    print yy.shape
    data_ae.append(yy)


data_ae = np.vstack(data_ae)

Autre

Visualisez chaque couche du modèle créé par Keras.

Installez pydot-ng et

pip install pydot-ng

Exécutez comme suit.

from keras.utils.visualize_util import plot
plot(model, to_file="model.png ", show_shapes=True)

Vérifiez la sortie de la couche intermédiaire

Lors de la conception d'un modèle Keras, vous souhaitez parfois vérifier le comportement de la couche intermédiaire. Dans Document, la sortie de la couche intermédiaire est visualisée en décrivant la fonction Keras.

from keras import backend as K

# with a Sequential model
get_3rd_layer_output = K.function([model.layers[0].input],
                                  [model.layers[3].output])
layer_output = get_3rd_layer_output([X])[0]

S'il y a une couche d'exclusion, cela fonctionne lorsque l'indicateur de phase d'apprentissage est défini.

get_3rd_layer_output = K.function([model.layers[0].input, K.learning_phase()],
                                  [model.layers[3].output])

# output in test mode = 0
layer_output = get_3rd_layer_output([X, 0])[0]

# output in train mode = 1
layer_output = get_3rd_layer_output([X, 1])[0]