Ceci est un mémo pour moi pendant que je lis Introduction aux applications de traitement du langage naturel en 15 étapes. Cette fois, au chapitre 3, étape 08, j'écrirai mes propres points.
Le chapitre 3 est une explication de base des bases de l'apprentissage profond et de son application au traitement du langage naturel. À l'étape 08, en guise d'introduction aux réseaux de neurones, un aperçu des perceptrons multicouches et une implémentation simple à l'aide de la bibliothèque d'apprentissage en profondeur Keras.
Le modèle qui a poussé les neurones qui composent les cellules cérébrales d'un organisme dans un modèle mathématique est ** Perceptron **, et le modèle qui imite un neurone est appelé ** Perceptron simple **.
--n entrées: x1, x2, ..., xn --n poids: w1, w2, ..., wn
z = f(x1w1 + x2w2 + ... + xnwn + b)
La formule ci-dessus peut être codée exactement telle quelle, mais elle peut être écrite de manière concise et la vitesse de traitement est rapide en utilisant l'opération NumPy des vecteurs. Lorsque le perceptron simple est considéré comme un discriminateur, trouver une valeur appropriée des poids (w et b) est ** apprendre **.
import numpy as np
x = np.array([...])
w = np.array([...])
b = ..
z = b + np.dot(x, w)
Similaire aux cellules nerveuses du cerveau, en utilisant la sortie d'un perceptron simple comme entrée d'un autre perceptron simple, il est possible de créer une structure dans laquelle un grand nombre de perceptrons sont connectés, ** perceptron multicouche (MLP) ** Appelé.
test_mlp.py
import numpy as np
W_1 = np.array([
[1, 2, 3],
[4, 5, 6],
])
x = np.array([10, 20, 30])
print(np.dot(W_1, x))
print(np.dot(x, W_1))
[140 320]
Traceback (most recent call last):
File "test_mlp.py", line 11, in <module>
print(np.dot(x, W_1))
ValueError: shapes (3,) and (2,3) not aligned: 3 (dim 0) != 2 (dim 0)
Dans ce qui précède, les poids des deux perceptrons de la première couche de MLP sont stockés dans W_1 (tableau 2 lignes et 3 colonnes). En calculant le produit interne de celui-ci et le vecteur d'entrée de 3 lignes et 1 colonne, la sortie de 2 lignes et 1 colonne est obtenue (2 lignes et 3 colonnes * 3 lignes et 1 colonne = 2 lignes et 1 colonne).
Bien sûr, si vous essayez de calculer le produit interne en échangeant W_1 et x, une erreur se produira.
Alors que les perceptrons simples ne peuvent être appliqués qu'à des problèmes linéairement séparables, ** les perceptrons multicouches peuvent également traiter des problèmes linéairement inséparables **.
En 08.2, chaque couche était implémentée en tant que fonction, mais elle peut être décrite de manière concise en utilisant une bibliothèque.
import keras.layers import Dense
import keras.models import Sequential
model = Sequential()
#Implémentation de première couche
model.add(Dense(units = 2, activation = 'relu', input_dim = 3))
#Implémentation de la deuxième couche
model.add(Dense(units = 1, activation = 'sigmoid'))
--Dense: couche entièrement connectée --input_dim: nombre de dimensions d'entrée. La dimension de sortie de la couche précédente devient la dimension d'entrée telle qu'elle est à partir de la deuxième couche, elle peut donc être omise. --units: nombre de dimensions de sortie --activation: fonction d'activation --Relu: Dans le passé, les sigmoïdes, etc. étaient utilisés, mais ils sont excellents en termes de précision et de facilité de convergence. --Sigmoïde: utilisé dans la dernière couche de MLP pour les classificateurs à 2 classes
Dans l'apprentissage du discriminateur, une paire de vecteur de caractéristiques X et d'étiquette correcte y est donnée en tant que données d'enseignant. Les paramètres du classifieur (poids) sont ajustés de sorte que la sortie lorsque X est entré soit proche de y.
model.compile(loss = 'binary_crossentropy', optimizer = Adam(lr = 0.001))
--loss: fonction de perte. Évaluez la précision d'identification d'un modèle avec une fonction qui exprime l'ampleur de l'écart entre X et y. --binary_crossentropy: correspondance de fonction de perte pour le classificateur à 2 classes --optimer: méthode d'optimisation. L'ajustement des paramètres s'appelle l'optimisation et il existe différentes méthodes. --lr: taux d'apprentissage. Un paramètre qui détermine combien la valeur de poids est augmentée ou diminuée dans une mise à jour --Grand: Le changement de poids est trop important pour se déplacer autour de la valeur optimale, ou diverger sans converger dans le pire des cas.
Lorsque vous instanciez une couche avec Keras, les pondérations sont implicitement ** initialisées avec des nombres aléatoires **.
Si vous voulez accéder aux poids, utilisez les méthodes .get_weights () et .set_weights ().
Comme je l'ai écrit en 10.3, si vous souhaitez spécifier l'initialisation du poids, vous pouvez le spécifier avec model.add (Dense (.., kernel_initializer =)).
model.fit(X, y, batch_size = 32, epochs = 100)
--batch_size: valeur du nombre de données d'entraînement à entraîner à la fois pour tous --epochs: valeur du nombre de fois qu'une donnée d'entraînement est utilisée pour l'entraînement --fit: processus d'apprentissage. La méthode de propagation de retour d'erreur est utilisée en interne
L'obsession d'imiter les cellules cérébrales a été abandonnée et elle a été développée dans le but de permettre aux ordinateurs d'effectuer un traitement intelligent.
Keras est une bibliothèque d'encapsuleurs pour TensorFlow. TensorFlow est une célèbre bibliothèque d'apprentissage en profondeur développée par Google et possède de nombreuses API de bas niveau, il est donc facile à mettre en œuvre à l'aide de Keras, qui fournit des API de haut niveau. Étant donné que la majeure partie du calcul du réseau neuronal est une opération vectorielle / matrice, il est concevable d'utiliser le GPU pour apprendre un réseau neuronal plus grand à grande vitesse.
Recommended Posts