Utilisation de tensorflow matures, le cadre Pytorch est utilisé pour reconnaître le réseau de neurones récursif (RNN), qui a considérablement réduit le seuil de la technologie.

Cependant, pour les débutants, cela ne suffit pas. La connaissance, il faut savoir.

Pour éviter des erreurs de faible niveau, mettez la base théorique, utilisez ensuite RNN pour résoudre des problèmes plus réalistes si .

Il y a donc une question intéressante à penser:

N'utilisez pas le cadre de TensorFlow, comment construisez-vous RNN?

Aucune tête ne s'inquiète pas. Voici un guide: Utiliser Numpy pour construire RNN dans le champ NLP depuis le début.
Peut vous emmener dans le processus de construction de la RNC.

Premièrement, le paramètre d'initialisation

Contrairement au réseau neurologique normal, RNN présente trois paramètres de poids, à savoir:
Entrées (poids d'entrée, poids d'état intérieur (sortie poids)

Les trois paramètres décrits ci-dessus sont initialisés avec une valeur aléatoire.

Ensuite, de la taille intégrée (Word_embedding taille) et la taille de sortie est initialement 100 et 80.
La taille de sortie est le nombre total de vecteurs uniques disponibles au loin.

Variable Prew_Memory fait référence à intal_state (c'est la mémoire de la séquence précédente).

Les autres paramètres fournissent également des valeurs d'initialisation.

Dégradé de poids, gradient de dégradé et expube_state_weight nommé DU, DW et DV. hidden_dim = 100 output_dim = 80 # this is the total unique words in the vocabularyinput_weights = np.random.uniform(0, 1, (hidden_dim,hidden_dim))internal_state_weights = np.random.uniform(0,1, (hidden_dim, hidden_dim))output_weights = np.random.uniform(0,1, (output_dim,hidden_dim))

La variable Bptt_tocrat indique le nombre de timbres de temps que le réseau doit être rédigé dans une communication inverse, qui consiste à réparer le problème de gradient manquant.

Lundi, étalé vers l'avant
1, Vecteur de sortie et d'entrée

L'exemple est:
J'aime le jeu. prev_memory = np.zeros((hidden_dim,1))learning_rate = 0.0001 nepoch = 25 T = 4 # length of sequencebptt_truncate = 2 dU = np.zeros(input_weights.shape)dV = np.zeros(output_weights.shape)dW = np.zeros(internal_state_weights.shape) Supposons que dans le vocabulaire:

, j'ai été mappé à l'index 2, correspondant à l'indice de 45, pour correspondre aux 10,

** correspondant à l'expression t64 points de symbole

** Correspondant à l'index 1.

Pour afficher le boîtier de l'entrée à la sortie, nous initialisons d'abord le trempage du mot.

L'entrée a été complétée et la sortie doit ensuite être prise en compte.

Dans cette section, l'unité RNN est incluse et la sortie est le mot suivant très probable.

Utilisé pour former RNN, lorsqu'un mot t + 1 est donné utilisé comme sortie, par exemple, lorsque de la sortie de l'unité RNN est "similaire" de l'entrée est "I".

Maintenant sous la forme de vecteur incorporé et que le format de sortie nécessaire pour calculer la fonction de perte (trou) est
Cryptage de chaleur unique input_string = [2,45,10,65]embeddings = [] # this is the sentence embedding list that contains the embeddings for each wordfor i in range(0,T): x = np.random.randn(hidden_dim,1) embeddings.append(x) (une voie chaude).

Il s'agit de la manipulation de chaque mot en dehors du premier mot de la chaîne d'entrée, car l'apprentissage réseau nerveux n'est qu'un exemple d'exemple et l'entrée d'origine est un premier exemple de la phrase de mot.

2, calculez la boîte noire de RNN

Il existe des paramètres actuels et connais également l'entrée et la sortie, pour calculer la propagationLe front peut être démarré.

dedans:

U
Pour le compte du poids d'entrée,

W ] Représenter le poids de l'état interne,

V

représente le poids de la sortie.

DOIT L'entrée est soulevée avec l'entrée (x) et l'état interne au lieu de recevoir l'activation de la classe précédente (Prev_Memory).

La fonction d'activation utilisée entre les classes et les classes est le poisson.

3, après calcul de la fonction de perte

la fonction de perte utilisée est pour perdre l'entropie transversale selon la formule suivante donnant: ] Plus important encore, nous devons voir la principale ligne de code. Comme vous le savez, la sortie au sol (y) est [0, 0, .. 1, ... 0] et présumé_output (Y ^ chapeau) sous la forme [0,34, 0,03 ,. 0,45], nous devons prendre une valeur unique de celui-ci enfreignant les dégâts totaux.

À cette fin, la somme des erreursDe chaque valeur dans Y et Y Vector ^ avec la fonction Somme.

TOTAL_LOSS est de perdre tout le modèle (y compris tous les délais).

Mardi, étalé def tanh_activation(Z): return (np.exp(Z)-np.exp(-Z))/(np.exp(Z)-np.exp(-Z)) # this is the tanh function can also be written as np.tanh(Z)def softmax_activation(Z): e_x = np.exp(Z - np.max(Z)) # this is the code for softmax function return e_x / e_x.sum(axis=0) def Rnn_forward(input_embedding, input_weights, internal_state_weights, prev_memory,output_weights): forward_params = [] W_frd = np.dot(internal_state_weights,prev_memory) U_frd = np.dot(input_weights,input_embedding) sum_s = W_frd + U_frd ht_activated = tanh_activation(sum_s) yt_unactivated = np.asarray(np.dot(output_weights, tanh_activation(sum_s))) yt_activated = softmax_activation(yt_unactivated) forward_params.append([W_frd,U_frd,sum_s,yt_unactivated]) return ht_activated,yt_activated,forward_params

Règles rénales Étendues à l'envers:

Comme indiqué ci-dessus: le Le coût représente l'erreur, représentant la différence de chapeau Y ^ à Y.

Parce que le coût est la fonction de fonction, les modifications d'activation A sont représentées par dcost / cuir.

En fait, cela signifie que cette valeur de changement (erreur) du point de vue du bouton d'activation.

def calculate_loss(output_mapper,predicted_output): total_loss = 0 layer_loss = [] for y,y_ in zip(output_mapper.values(),predicted_output): # this for loop calculation is for the first equation, where loss for each time-stamp is calculated loss = -sum(y[i]*np.log2(y_[i]) for i in range(len(y))) loss = loss/ float(len(y)) layer_loss.append(loss) for i in range(len(layer_loss)): #this the total loss calculated for all the time-stamps considered together. total_loss = total_loss + layer_loss[i] return total_loss/float(len(predicted_output)) De même, la modification des nombres liés à Z est exprimée sous la forme de peau / dz et le changement de Z comparé à W est exprimé en tant que DW / DZ.

Enfin, nous sommes intéressés par des changements de poids (erreur).



Étant donné qu'il n'y avait pas de relation directe entre le poids et le coût, chaque valeur de changement relatif pourrait être directement multipliée (telle que telle que celle telle que celle telle que telle que telles que telles que telles que telles que le public.au). Afficher).

1, RNV Propagande

Comme il y a trois poids dans RNN, nous avons besoin de trois pentes. Piste Input_Peights (dloss / du), Intal_state_weights (DLoss / DW) et Sortie_Porteurs (Dloss / DV).

Trois gradients peuvent être représentés comme suit:

Code DLoss / DY_Unactive comme suit:

]

Calcul de deux fonctions de gradients, une fonction est humanisée_backward et l'autre est add_backward.

Dans un boîtier multipliciotrong n_backward, les deux paramètres sont renvoyés, l'un est un gradient (Dloss / DV) par rapport au poids et au repos est la chaîne de gradient, fera partie d'une corde à gradient à une base d'autre les montants.
En cas de supplément_backward, le dérivé de chaque composant dans la fonction supplémentaire (HT_UNACTIVÉ) est 1 lors du calcul du dérivé. Par exemple: dh_unactivé / du_frd = 1 (h_unactivé = u_frd + w_frd) et dérivé de DU_FRD / DU_FRD sont 1.

Le calcul de gradient n'a besoin que de ces deux fonctions. Les fonctions human_backward sont utilisées pour inclure l'équation de points vectoriels et add_backward utilisé pour inclure deux équations supplémentaires.

def delta_cross_entropy(predicted_output,original_t_output): li = [] grad = predicted_output for i,l in enumerate(original_t_output): #check if the value in the index is 1 or not, if yes then take the same index value from the predicted_ouput list and subtract 1 from it. if l == 1: #grad = np.asarray(np.concatenate( grad, axis=0 )) grad[i] -= 1 return grad

À ce sujet, la propagation inverse de RNN a été analysée et comprise actuellement à la fois. Effectuer des fonctions informatiques, puis être utilisée pour calculer la pente sur l'horodatage. Comme indiqué dans le code suivant, FORW_PARAMS_T est une liste dans laquelle les paramètres de transition réseau d'une étape temporelle spécifique. Les variables DS constituent une partie importante car ce code de code considère l'état caché de l'horodatage précédent, qui aidera à extraire les informations nécessaires à la communication inverse. Pour RNN, il y a un problème dans lequel la pente disparaît, la transmission raccourcie est raccourcie, pas l'original. Dans cette technique, l'unité actuelle ne regardera que le joint du temps au lieu d'un horodatage, TQue k indique le nombre d'unités précédemment tracées. 4 par gradients décroissants 5, la séquence de formation Après toutes les étapes ci-dessus, le réseau de Dieu Kinh Peut être démarré .. Le taux d'apprentissage à former est des méthodes statiques et dynamiques pour modifier le taux d'apprentissage en utilisant un déclin pas à pas. Félicitations!Maintenant, vous avez construit une construction de la tête pour établir un réseau nerveux! Donc, il est donc temps, continuant de passer à l'architecture senior de LSTM et de Gru.