Python: apprentissage profond du traitement du langage naturel: principes de base

Apprentissage profond dans le traitement du langage naturel

L'apprentissage en profondeur est utilisé dans diverses tâches telles que les suivantes dans le traitement du langage naturel.

Traduction automatique qui traduit des phrases dans différentes langues
Synthèse automatique qui extrait uniquement les informations importantes
Lecture automatique qui répond en fonction de documents et de questions
Un système qui répond aux questions sur les images
etc

Ce sont tous des domaines sur lesquels les chercheurs et les entreprises informatiques renommées du monde entier travaillent activement. L'apprentissage en profondeur est presque toujours utilisé dans les dernières méthodes utilisées pour ces derniers. Par conséquent, pour ceux qui essaient de faire de la recherche et des affaires liées au traitement du langage naturel On peut dire que l'apprentissage du deep learning et des réseaux de neurones est presque indispensable.

Alors pourquoi l'apprentissage profond est-il si utilisé dans le traitement du langage naturel? Afin de gérer les mots sur un ordinateur, il est absolument nécessaire de les convertir en valeurs numériques. Comme la manière classique

One hot vector
TFIDF

Etc.

En fait, ils sont faciles à faire, c'est donc un excellent moyen de commencer lorsque vous voulez faire quelque chose avec le traitement du langage naturel.

Mais dans ces vecteurs

① parcimonie
Les dimensions du vecteur peuvent aller de dizaines de milliers à des centaines de milliers, souvent à court de mémoire.

② Je ne peux pas gérer le sens
Tous les mots ne se différencient que par leur fréquence d'apparition et perdent leur individualité.

Il y a des problèmes tels que.

Donc, si vous utilisez un modèle de réseau neuronal Parce que le vecteur de mot peut être appris par la méthode de propagation de retour d'erreur

Embedding(Attribuer un vecteur de seulement quelques centaines de dimensions à chaque mot)Juste bien

De plus, parce que vous pouvez apprendre le vecteur des mots tout en considérant le contexte Si les mots ont des significations similaires, des vecteurs similaires peuvent être obtenus. Par rapport au TFIDF etc., il a l'avantage de pouvoir gérer le sens des mots.

Embedding

L'incorporation signifie «incorporé» en japonais.

Dans le traitement du langage naturel par apprentissage en profondeur, le symbole «mot» est utilisé. L'incorporation est effectuée par incorporation dans un vecteur d-dimensionnel (d est d'environ 100 à 300).

L'incorporation est la première chose à faire lors de la création d'un modèle pour un réseau neuronal qui gère les mots.

Dans keras, il existe une couche d'intégration, qui peut être utilisée comme suit.

from keras.models import Sequential
from keras.layers.embeddings import Embedding

vocab_size = 1000 #Nombre de vocabulaire à gérer
embedding_dim = 100 #Dimensions du vecteur Word
seq_length = 20 #Durée de la peine

model = Sequential()
model.add(Embedding(input_dim=vocab_size, output_dim=embedding_dim, input_length=seq_length))

Les valeurs qui doivent être spécifiées ici sont input_dim, output_dim et input_length.

input_dim:Nombre de vocabulaire, nombre de types de mots
output_dim:Dimensions du vecteur Word
input_length:Durée de chaque phrase

Vecteurs de mots combinés de tous les mots

Un exemple de ce que l'on appelle une matrice d'intégration est illustré dans la figure.

Comme prémisse, attribuez un identifiant unique à chaque mot Il fait référence à la ligne de l'ID dans la matrice d'intégration. (ID = 0 est la 0ème ligne, ID = i est la ème ligne.)

Et le vecteur de chaque mot correspond à la ligne de Embedding Matrix. La longueur horizontale d de la matrice d'intégration correspond à la dimension du vecteur mot.

Quant à la valeur de chaque cellule, keras stocke automatiquement une valeur aléatoire. Aussi, comme le montre la figure

Dans la plupart des cas, la ligne 0 est attribuée unk ou Unknown.

La raison d'utiliser unk est de limiter le vocabulaire à gérer et tous les autres mots mineurs Il s'agit d'économiser de la mémoire en le définissant sur Inconnu. Comment limiter le vocabulaire Il est courant de ne traiter que ceux qui apparaissent le plus fréquemment dans le corpus (document) à traiter.

L'entrée pour l'intégration est une matrice composée d'identifiants attribués aux mots La taille doit être (taille du lot, longueur de la phrase).

Ici, la taille du lot représente le nombre de données (instructions) qui sont calculées en parallèle à la fois.

La longueur de la phrase doit être la même pour toutes les données. Le problème ici est que la longueur de la phrase n'est pas constante. Par conséquent, la durée de la peine est arbitrairement fixée à D.

Les instructions inférieures ou égales à la longueur D ajoutent 0 pour que la longueur soit D
Pour les phrases plus longues que D, supprimez le mot de la fin pour que la longueur soit D.

C'est ce qu'on appelle communément le rembourrage

Voici un exemple d'utilisation.

import numpy as np
from keras.models import Sequential
from keras.layers.embeddings import Embedding


batch_size = 32 #Taille du lot
vocab_size = 1000 #Nombre de vocabulaire à gérer
embedding_dim = 100 #Dimensions du vecteur Word
seq_length = 20 #Durée de la peine

#À l'origine, il était nécessaire de convertir le mot en ID, mais cette fois j'ai préparé les données d'entrée facilement.
input_data = np.arange(batch_size * seq_length).reshape(batch_size, seq_length)

#Ajoutez l'incorporation au modèle.
model = Sequential()
model.add(Embedding(input_dim=vocab_size, output_dim=embedding_dim, input_length=seq_length))

# input_Vérifiez comment la forme des données change.
output = model.predict(input_data)
print(output.shape)

RNN

Dans cette section, vous en apprendrez davantage sur RNN.

RNN est une abréviation de Recurrent Neural Network
Traduit par «réseau neuronal récursif» en japonais.

Excellent pour gérer des séries de longueur variable, c'est-à-dire des chaînes d'entrée de longueur arbitraire C'est un mécanisme important fréquemment utilisé dans le traitement du langage naturel.

Étant donné que les données chronologiques peuvent être utilisées en plus des langues, elles ont un large éventail d'applications telles que la reconnaissance vocale.

Récurrent signifie «répéter».

RNN signifie donc réseau neuronal "répétitif".

Le RNN le plus simple est exprimé par la formule suivante.

Ici, t est souvent exprimé en temps. xt est l'entrée du temps t, ht est le vecteur d'état caché du temps t, yt est la sortie du temps t Tous les trois sont des vecteurs.

Le vecteur zéro est souvent utilisé pour h0.

f et g sont des fonctions d'activation, telles que la fonction sigmoïde.

Wh, Wy, U et bh sont respectivement des matrices et des biais apprenables.

Une illustration simple ressemblera à la figure.

Il existe de nombreuses variantes de RNN autres que celles présentées ci-dessus, La structure de base est celle illustrée sur la figure.

De plus, vous n'avez pas à vous souvenir de ces définitions strictes lorsque vous utilisez des keras. Gardez à l'esprit que vous allez entrer les colonnes d'entrée dans l'ordre et obtenir le vecteur d'état masqué et la sortie à chaque fois.

Vous pouvez également empiler plusieurs couches sur le RNN comme n'importe quel autre réseau neuronal.

LSTM

Qu'est-ce que LSTM

LSTM est un type de RNN, et LSTM dispose d'un mécanisme pour compenser les lacunes propres à RNN.

J'expliquerai les inconvénients propres à RNN. RNN est un réseau neuronal qui est profondément dans la direction du temps, alors considérez les valeurs entrées plus tôt. On dit qu'il est difficile d'entraîner les paramètres, c'est-à-dire qu'il n'est pas bon pour la mémoire à long terme.

La sensation est que RNN «oublie» les éléments saisis plus tôt.

LSTM est un mécanisme bien connu pour empêcher cela.

Qu'est-ce que LSTM?-Abréviation de la mémoire de termes
Comme son nom l'indique, il permet une mémoire à long terme et une mémoire à court terme.

Largement utilisé par les chercheurs du monde entier.

LSTM a introduit le concept de «porte» à RNN. Un type de RNN avec une porte. Cette porte permet une mémoire à long et à court terme.

Le contour de LSTM est comme indiqué sur la figure.

L'intérieur de LSTM est décrit par la formule suivante. (Pas besoin de se souvenir.)

• ⊙ représente la multiplication de chaque élément et du produit Adamal.

Ici, i est appelé la porte d'entrée, f est appelée la porte de l'oubli et o est appelée la porte de sortie.

Notez que la fonction sigmoïde est utilisée pour la fonction d'activation de ces portes. Quelle est la fonction sigmoïde?

C'est. La sortie de ces portes est donc un nombre compris entre 0 et 1.

Le i de la porte d'entrée est multiplié par ¯ht pour chaque élément. Vous pouvez voir que nous ajustons la quantité d'informations transmises à partir de l'entrée au temps t. Comme son nom l'indique, la porte vient de l'image d'une «porte».

La porte d'oubli f est multipliée par ct-1 pour chaque élément. Nous ajustons la quantité d'informations transmises jusqu'au temps t-1 au temps t (= combien d'informations passées sont oubliées).

Et o de la porte de sortie est de ct qui contient les informations du temps 1 à t Nous ajustons la quantité d'informations utilisées comme sortie ht du vecteur d'état caché.

Voici le tableau complet du LSTM conçu pour réaliser la mémoire à court terme et la mémoire à long terme.

Implémentation de LSTM

J'implémenterai LSTM avec keras immédiatement. keras a un module qui facilite l'utilisation de LSTM Vous pouvez utiliser LSTM sans connaître les formules décrites.

Plus précisément, il est utilisé comme suit.

from keras.layers.recurrent import LSTM

units = 200

lstm = LSTM(units, return_sequences=True)

Ici, unités est le nombre de dimensions du vecteur d'état caché de LSTM. Habituellement, il devrait être d'environ 100 à 300.

En général, plus vous devez apprendre de paramètres, plus vous pouvez modéliser les phénomènes complexes. Il est difficile d'apprendre à ce niveau (la consommation de mémoire augmente, le temps d'apprentissage est long).

C'est une bonne idée de l'ajuster en fonction de l'environnement d'apprentissage.

Et cette fois

return_Spécifiez un argument appelé séquences.

C'est un argument pour décider du formatage de la sortie de LSTM.

return_Si les séquences sont vraies
LSTM sort la série de sortie (vecteurs d'état cachés h1h1 à hThT) correspondant à toutes les séries d'entrée.

return_Si les séquences sont fausses
LSTM sort uniquement le vecteur d'état caché au dernier moment T.

Nous utiliserons toutes les séquences de sortie dans un chapitre ultérieur, nous laisserons donc return_sequences défini sur True ici.

La méthode de construction du modèle est la suivante lorsqu'il est connecté à Embedding.

from keras.models import Sequential
from keras.layers.embeddings import Embedding
from keras.layers.recurrent import LSTM

vocab_size = 1000 #Nombre de vocabulaire à gérer
embedding_dim = 100 #Dimensions du vecteur Word
seq_length = 20 #Durée de la peine
lstm_units = 200 #Nombre de dimensions du vecteur d'état caché de LSTM

model = Sequential()
model.add(Embedding(input_dim=vocab_size, output_dim=embedding_dim))
model.add(LSTM(lstm_units, return_sequences=True))

Cliquez ici pour des exemples d'utilisation

import numpy as np
from keras.models import Sequential
from keras.layers.embeddings import Embedding
from keras.layers.recurrent import LSTM


batch_size = 32 #Taille du lot
vocab_size = 1000 #Nombre de vocabulaire à gérer
embedding_dim = 100 #Dimensions du vecteur Word
seq_length = 20 #Durée de la peine
lstm_units = 200 #Nombre de dimensions du vecteur d'état caché de LSTM

#J'ai également préparé les données d'entrée facilement cette fois-ci.
input_data = np.arange(batch_size * seq_length).reshape(batch_size, seq_length)

#Ajouter LSTM au modèle
model = Sequential()
model.add(Embedding(input_dim=vocab_size, output_dim=embedding_dim, input_length=seq_length))
model.add(LSTM(lstm_units,return_sequences=True))

# input_Vérifiez comment la forme des données change.
output = model.predict(input_data)
print(output.shape)

BiLSTM

Jusqu'à présent, saisissez la série x = {x1, ..., xT} vers RNN, y compris LSTM à partir de x1 Je suis entré dans l'ordre depuis le début sur xT.

Contrairement au passé, vous pouvez également entrer par l'arrière de xT à x1.

Combiné deux autres directions d'entrée

Réseau neuronal récursif bidirectionnel (bi-réseau neuronal récurrent directionnel) est souvent utilisé.

L'avantage de ceci est l'information propagée depuis le début et l'information propagée depuis l'arrière à chaque fois. Autrement dit, les informations de toute la série d'entrée peuvent être prises en compte.

Et celui qui relie le LSTM dans deux directions

LSTM bidirectionnel, communément appelé BiLSTM.

Le contour est comme indiqué sur la figure.

Il existe plusieurs façons de connecter les RNN dans deux directions, mais je vais vous montrer comment les implémenter avant de les expliquer.

from keras.layers.recurrent import LSTM
from keras.layers.wrappers import Bidirectional

bilstm = Bidirectional(LSTM(units, return_sequences=True), merge_mode='sum')

Il peut être facilement implémenté en utilisant LSTM comme argument de cette manière.

Un autre argument, merge_mode, sert à spécifier comment connecter des LSTM bidirectionnels. En gros, choisissez parmi {'sum', 'mul', 'concat', 'ave'}.

sum:Somme des éléments
mul:Produit d'élément
concat:Joindre
ave:moyenne
None:Renvoie la liste sans fusionner

Cliquez ici pour un exemple

import numpy as np
from keras.models import Sequential
from keras.layers.embeddings import Embedding
from keras.layers.recurrent import LSTM
from keras.layers.wrappers import Bidirectional


batch_size = 32 #Taille du lot
vocab_size = 1000 #Nombre de vocabulaire à gérer
embedding_dim = 100 #Dimensions du vecteur Word
seq_length = 20 #Durée de la peine
lstm_units = 200 #Nombre de dimensions du vecteur d'état caché de LSTM

#J'ai également préparé les données d'entrée facilement cette fois-ci.
input_data = np.arange(batch_size * seq_length).reshape(batch_size, seq_length)

#Ajout de BiLSTM au modèle.
model = Sequential()
model.add(Embedding(input_dim=vocab_size, output_dim=embedding_dim, input_length=seq_length))
model.add(Bidirectional(LSTM(lstm_units, return_sequences=True), merge_mode='concat'))

# input_Vérifiez comment la forme des données change.
output = model.predict(input_data)
print(output.shape)

Fonction Softmax

C'est un peu hors sujet, mais habituons-nous à travailler avec la fonction Softmax.

La fonction Softmax est un type de fonction d'activation Il est utilisé dans la couche la plus proche de la sortie du réseau neuronal lors de la classification.

La définition de la fonction Softmax est la chaîne d'entrée x = {x1, ..., xn} (chaque élément est un nombre réel)

En convertissant en une chaîne de sortie y = {y1, ..., yn} qui a le i-ème élément Comme vous pouvez le voir dans cette définition, la colonne de sortie y est

Rencontrer. C'était le cas lorsque la colonne d'entrée était un nombre réel.

Lors de la mise en œuvre réelle avec Keras

from keras.layers.core import Activation

#x taille: [Taille du lot, nombre de classes]

y = Activation('softmax')(x)

# sum(y[0]) = 1, sum(y[1]) = 1, ...

Appliquez la fonction softmax pour chaque lot et utilisez-la.

Il s'agit du paramètre par défaut d'activation ('softmax') En effet, softmax agit sur l'axe du nombre de classes, qui est le dernier élément de la taille de l'entrée x.

Autrement dit, la taille de x est[Taille du lot, d, nombre de classes]Même si c'est comme la 3D
Activation('softmax')Est applicable.

En passant, comment écrire un modèle comme celui-ci sans utiliser keras.models.

Cela s'appelle l'API fonctionnelle.

Cliquez ici pour des exemples d'utilisation

import numpy as np
from keras.layers import Input
from keras.layers.core import Activation
from keras.models import Model


x = Input(shape=(20, 5))
#Agir softmax sur x
y = Activation('softmax')(x)

model = Model(inputs=x, outputs=y)

sample_input = np.ones((12, 20, 5))
sample_output = model.predict(sample_input)

print(np.sum(sample_output, axis=2))

Attention

Qu'est-ce que l'attention

Supposons maintenant que vous ayez deux phrases s = {s1, ..., sN}, t = {t1, ..., tL}.

Ici, soyons une phrase de question et t une phrase de réponse candidate.

À ce stade, comment la machine peut-elle déterminer automatiquement si t est valide en tant que réponse à s?

Peu importe combien vous regardez t seul, vous ne pouvez pas dire si t est valide ou non. Vous devez vous référer aux informations de s pour déterminer si t est valide.

C'est là que le mécanisme d'attention est utile.

Dans les chapitres précédents, vous avez appris que les instructions peuvent être converties en vecteurs d'état masqués par RNN.

Plus précisément, préparez deux RNN séparés et utilisez un RNN. Vecteur d'état caché s Converti en et t masqué par l'autre RNN Peut être converti en.

Par conséquent, pour utiliser les informations de t en considération des informations de s, à chaque instant de t comme suit. Calculez les caractéristiques en considérant le vecteur d'état caché à chaque instant de s.

De cette manière, en calculant où «attention» dans la série source de référence s à chaque instant de la série cible t. Vous pouvez extraire de manière flexible les informations de la série cible tout en tenant compte des informations de la série source de référence.

Le contour est comme indiqué sur la figure.

La figure montre le cas du RNN unidirectionnel, mais Attention peut être appliqué même pour le RNN bidirectionnel.
Aussi
L'attention peut être appliquée même si le temps maximum (nombre total de vecteurs d'état cachés) de la source de référence et du RNN cible est différent.

Ce mécanisme appelé Attention est une technique importante qui est couramment utilisée dans le traitement du langage naturel par apprentissage en profondeur.

Il apparaît fréquemment dans les traductions automatiques, les résumés automatiques et les documents de dialogue.

Historiquement, son utilité a été largement reconnue depuis sa première utilisation en traduction automatique.

De plus, cette fois, nous utilisons la moyenne pondérée du vecteur d'état caché de s.

J'ai présenté Soft Attention

Sélectionnez au hasard un vecteur d'état caché

L'attention dure existe également.

Il en est également dérivé et peut être utilisé dans le domaine de la reconnaissance d'images.

Parmi eux annoncés par Google

Le papier Attention est tout ce dont vous avez besoin est très célèbre.

Mise en œuvre de l'attention

Pour implémenter Attention avec keras

Vous devez utiliser le calque de fusion.

Puisque la version 2.0 ou ultérieure de Keras ne peut pas fusionner le modèle séquentiel utilisé jusqu'au chapitre précédent,

Ici, nous utilisons l'API fonctionnelle de Keras. L'utilisation simple de l'API fonctionnelle est la suivante.

Dans le modèle séquentiel, nous venons d'ajouter de nouvelles couches,

Vous pouvez créer des modèles complexes plus librement en utilisant l'API fonctionnelle.

from keras.layers import Input, Dense
from keras.layers.embeddings import Embedding
from keras.layers.recurrent import LSTM
from keras.layers.wrappers import Bidirectional
from keras.layers.merge import dot, concatenate
from keras.layers.core import Activation
from keras.models import Model

batch_size = 32 #Taille du lot
vocab_size = 1000 #Nombre de vocabulaire à gérer
embedding_dim = 100 #Dimensions du vecteur Word
seq_length1 = 20 #Durée de la peine 1
seq_length2 = 30 #Durée de la peine 2
lstm_units = 200 #Nombre de dimensions du vecteur d'état caché de LSTM
hidden_dim = 200 #Nombre de dimensions du vecteur de sortie final

input1 = Input(shape=(seq_length1,))
embed1 = Embedding(input_dim=vocab_size, output_dim=embedding_dim, input_length=seq_length1)(input1)
bilstm1 = Bidirectional(LSTM(lstm_units, return_sequences=True), merge_mode='concat')(embed1)

input2 = Input(shape=(seq_length2,))
embed2 = Embedding(input_dim=vocab_size, output_dim=embedding_dim, input_length=seq_length2)(input2)
bilstm2 = Bidirectional(LSTM(lstm_units, return_sequences=True), merge_mode='concat')(embed2)

#Calculez le produit pour chaque élément
product = dot([bilstm2, bilstm1], axes=2) #taille du produit:[Taille du lot, longueur de la phrase 2, longueur de la phrase 1]

a = Activation('softmax')(product)
c = dot([a, bilstm1], axes=[2, 1])
c_bilstm2 = concatenate([c, bilstm2], axis=2)
h = Dense(hidden_dim, activation='tanh')(c_bilstm2)

model = Model(inputs=[input1, input2], outputs=h)

Puisque chaque couche est utilisée comme une fonction de cette manière, on l'appelle l'API fonctionnelle.

Veillez également à ne pas mettre la taille du lot dans la forme spécifiée dans le nouveau calque d'entrée.

Et lors de la définition d'un modèle, vous devez spécifier les entrées et les sorties comme arguments,

Si vous avez plusieurs entrées et sorties, vous pouvez les mettre dans une liste et les transmettre.

Et le nouveau point([u, v], axes=2)Calcule le produit de matrice par lots de u et v.

Le nombre de dimensions dans les axes spécifiés doit être égal pour u et v.

Aussi, dot([u, v], axes=[1,2])Puis u 1ère dimension et v 2ème dimension
Vous pouvez également spécifier différentes dimensions, telles que.

Maintenant, implémentons Attention à l'aide de l'API fonctionnelle basée sur la formule suivante.

Cliquez ici pour des exemples d'utilisation

import numpy as np
from keras.layers import Input, Dense
from keras.layers.embeddings import Embedding
from keras.layers.recurrent import LSTM
from keras.layers.wrappers import Bidirectional
from keras.layers.merge import dot, concatenate
from keras.layers.core import Activation
from keras.models import Model

batch_size = 32 #Taille du lot
vocab_size = 1000 #Nombre de vocabulaire à gérer
embedding_dim = 100 #Dimensions du vecteur Word
seq_length1 = 20 #Durée de la peine 1
seq_length2 = 30 #Durée de la peine 2
lstm_units = 200 #Nombre de dimensions du vecteur d'état caché de LSTM
hidden_dim = 200 #Nombre de dimensions du vecteur de sortie final

#Pour utiliser la couche d'intégration commune aux deux LSTM, définissez d'abord la couche d'intégration.
embedding = Embedding(input_dim=vocab_size, output_dim=embedding_dim)

input1 = Input(shape=(seq_length1,))
embed1 = embedding(input1)
bilstm1 = Bidirectional(LSTM(lstm_units, return_sequences=True), merge_mode='concat')(embed1)

input2 = Input(shape=(seq_length2,))
embed2 = embedding(input2)
bilstm2 = Bidirectional(LSTM(lstm_units, return_sequences=True), merge_mode='concat')(embed2)

#Calculez le produit pour chaque élément
product = dot([bilstm2, bilstm1], axes=2) #Taille:[Taille du lot, longueur de la phrase 2, longueur de la phrase 1]

#Mettre en œuvre le mécanisme d'attention ici
a = Activation('softmax')(product)
c = dot([a, bilstm1], axes=[2, 1])
c_bilstm2 = concatenate([c, bilstm2], axis=2)
h = Dense(hidden_dim, activation='tanh')(c_bilstm2)


model = Model(inputs=[input1, input2], outputs=h)

sample_input1 = np.arange(batch_size * seq_length1).reshape(batch_size, seq_length1)
sample_input2 = np.arange(batch_size * seq_length2).reshape(batch_size, seq_length2)

sample_output = model.predict([sample_input1, sample_input2])
print(sample_output.shape)

Dropout

L'abandon se fait en définissant au hasard certaines des variables sur 0 pendant l'entraînement. C'est une méthode pour améliorer les performances de généralisation et éviter le surapprentissage.

① Qu'est-ce que le surapprentissage?

Lors de l'exécution d'un apprentissage supervisé avec un modèle tel qu'un réseau neuronal
Souvent trop adapté aux données d'entraînement
Il provoque un «surapprentissage» dans lequel la performance des données d'évaluation est nettement inférieure à celle des données d'apprentissage.

② Qu'est-ce que la performance de généralisation?

Indépendamment des données d'entraînement et des données d'évaluation, sans surentraînement avec les données d'entraînement
Généralement, les hautes performances sont appelées «performances de généralisation».

Lorsque vous l'utilisez réellement, définissez le rapport des variables sur 0 avec une valeur comprise entre 0 et 1. Ajoutez un calque Dropout.

#Lors de l'utilisation du modèle séquentiel
from keras.models import Sequential
from keras.layers import Dropout


model = Sequential()

...

model.add(Dropout(0.3))

#Lors de l'utilisation de l'API fonctionnelle
from keras.layers import Dropout

y = Dropout(0.3)(x)

Cliquez ici pour des exemples d'utilisation

import numpy as np
from keras.layers import Input, Dropout
from keras.layers.embeddings import Embedding
from keras.layers.recurrent import LSTM
from keras.layers.wrappers import Bidirectional
from keras.models import Model

batch_size = 32  #Taille du lot
vocab_size = 1000  #Nombre de vocabulaire à gérer
embedding_dim = 100  #Dimensions du vecteur Word
seq_length = 20  #Durée de la peine 1
lstm_units = 200  #Nombre de dimensions du vecteur d'état caché de LSTM

input = Input(shape=(seq_length,))

embed = Embedding(input_dim=vocab_size, output_dim=embedding_dim,
                  input_length=seq_length)(input)

bilstm = Bidirectional(
    LSTM(lstm_units, return_sequences=True), merge_mode='concat')(embed)

output = Dropout(0.3)(bilstm)

model = Model(inputs=input, outputs=output)

sample_input = np.arange(
    batch_size * seq_length).reshape(batch_size, seq_length)

sample_output = model.predict(sample_input)

print(sample_output.shape)