Note de réseau Lei Feng: Cet article est issu d'un blog personnel de développeur de la science des données, compilées Lei Feng réseau.

De nombreux développeurs recommandent au novice: Si vous souhaitez que l'entrée de l'apprentissage de la machine, il faut d'abord comprendre quelques-unes des uvres d'algorithme à clé, puis commencer à mains sur la pratique. Mais je ne pense pas.

Je pense que la pratique que la théorie, le novice première chose à faire est de comprendre l'ensemble du modèle de flux de travail, le flux de données est à peu près comment, à travers laquelle la jonction critique, où le résultat final de l'acquisition, et ont immédiatement commencé les pratiques de travail, construire votre propre modèles d'apprentissage de la machine. En ce qui concerne l'algorithme mécanisme de mise en uvre et les fonctions internes peuvent être effectuées plus étude approfondie et maître dans la pratique, etc. Après la compréhension de l'ensemble du processus.

La question est donc, car il n'a pas besoin d'un débutant à maîtriser les détails de l'algorithme, mais dans le processus de mise en uvre du modèle et des algorithmes connexes doit être utilisé, comment le faire? La réponse est déjà réalisée au moyen d'une bonne bibliothèque sur Internet, par exemple tensorflow.

Dans cet article, nous utiliserons le modèle de classification tensorflow texte Realize basé sur réseau de neurones profond (DNN), et j'espère que vous tous débutant Aide. Le code complet pour le texte en question est déjà ouvert sur GitHub, et les amis intéressés peuvent être téléchargés sur le lien suivant:

Voici le contenu du tutoriel officiel:

A propos tensorflow

Tensorflow est le cadre de l'apprentissage de la machine open source de Google. On peut voir à partir du nom du principe de base de ce cadre: tenseur (Tensor) constitué d'un tableau multidimensionnel flux directionnel (flux) figure entre (graphique) noeuds, la sortie de l'entrée est venu.

En tensorflow, chaque opération peut être exprimée par voie graphique flux (flux de données du graphique) de données. Chaque graphique de flux de données comporte deux éléments importants:

un ensemble d'objets tf.Operation représentent l'opération elle-même;

un ensemble d'objets tf.Tensor, représente une opération de données.

Comme indiqué ci-dessous, où l'on calcule ce diagramme illustrant un exemple simple de la façon dont le fonctionnement spécifique.

On suppose sur la figure x = , y = . Depuis le fonctionnement tf.Tensor est utilisé pour représenter les données, nous allons d'abord définir tensorflow tf.Tensor deux constantes stockées des objets de données. définition de l'objet figure tf.Operation puis utilisez l'addition, le code spécifique est comme suit:

importer tensorflow comme tf

x = tf.constant ()

y = tf.constant ()

op = tf.add (x, y)

Maintenant que nous avons défini deux éléments importants dans le graphe de flux de données: tf.Operation et tf.Tensor, alors comment construire la carte elle-même le fait, le code spécifique comme suit:

importer tensorflow comme tf

my_graph = tf.Graph

avec my_graph.as_default:

x = tf.constant ()

y = tf.constant ()

op = tf.add (x, y)

Jusqu'à présent, nous avons achevé la définition du diagramme de flux de données, dans tensorflow, définir uniquement en vue d'opérations de calcul suivantes (à savoir, le débit directionnel de données entre le noeud de commande de la figure). Ici tensorflow prévoit également que, pour les calculs ultérieurs, nous devons être unis par la gestion tf.Session, donc nous devons définir une tf.Session des objets de cette session.

Dans l'environnement d'exploitation tensorflow, tf.Session conçu pour emballer tf.Operation effectué tf.Tensor base. En conséquence, lors de la définition des objets tf.Session également besoin de passer les, dans ce mode de réalisation particulier graphe de flux de données correspondant (paramètres du graphique peuvent être passés à travers) le code est le suivant:

importer tensorflow comme tf

my_graph = tf.Graph

avec tf.Session (graphique = my_graph) comme sess:

x = tf.constant ()

y = tf.constant ()

op = tf.add (x, y)

Après la définition d'un bon tf.Session, nous pouvons effectuer un flux de données correspondant par la méthode tf.Session.run de la figure. Le procédé peut être exécuté en passant des paramètres correspondants tf.Operation récupère l'objet, et importer tous les objets associés tf.Tensor tf.Operation, puis relation de dépendance récursive tf.Operation avec toutes les opérations en cours. Ce mode de réalisation est spécifiquement réalisé des codes d'opération de sommation sont comme suit:

importer tensorflow comme tf

my_graph = tf.Graph

avec tf.Session (graphique = my_graph) comme sess:

x = tf.constant ()

y = tf.constant ()

op = tf.add (x, y)

entraîner = sess.run (fetch = op)

print (résultat)

> > >  

On peut voir que le résultat de l'opération est .

A propos des modèles prédictifs

Après avoir compris les principes de base de tensorflow, la tâche suivante est de savoir comment construire un modèle prédictif. En bref, un algorithme d'apprentissage machine à + données est égale au modèle prédit. Modèle de prévision comme indiqué ci-dessous flux:

Comme le montre, les données après algorithmes d'apprentissage machine de formation de ce modèle. Après un bon modèle de formation, les données d'entrée à prédire, sera en mesure d'obtenir les résultats prévus correspondants. écoulement généralement comme indiqué ci-dessous:

Dans cet exemple, nous allons construire le besoin de modèle pour la saisie de texte, la sortie de la catégorie correspondante, à savoir l'achèvement de la classification texte. Ainsi, il devrait y avoir un texte d'entrée (texte), la sortie est une catégorie (catégorie). Plus précisément, dans ce cas, nous avons déjà acquis des données d'étiquette (par exemple, dont certains ont marqué la classe de segment de texte), alors l'algorithme est formé avec ces données, le dernier, puis une formation sur la nouvelle classification de texte modèle. Ce processus est connu comme l'apprentissage supervisé (apprentissage supervisé). De plus, parce que notre tâche est la classification des données texte, il appartient au problème de classification de catégorie.

Pour construire ce modèle de classification texte, ici nous avons besoin d'introduire quelques connaissances de base des réseaux de neurones.

A propos des réseaux de neurones

En substance, un modèle de calcul de réseau neuronal (modèle de calcul) de. (Note: Ici, le terme fait référence à une méthode du modèle de calcul par le langage mathématique et des concepts mathématiques système décrit) et ce modèle peut également être il ne nécessite pas d'apprentissage calculé automatiquement et la formation, la programmation précise.

Le modèle le plus original et le plus fondamental est un algorithme de réseau de neurones modèle Perceptron (Perceptron), sur le modèle de la machine détaillée de la perception, voir ce blog:

Étant donné que le modèle est une structure de réseau de neurones du tissu cérébral humain simulant le système proposé, il a une structure similaire aux réseaux du cerveau humain.

Comme indiqué plus haut, la structure de réseau de neurones peut généralement être divisée en trois couches: la couche d'entrée, une couche cachée (couche cachée), et une couche de sortie.

Pour comprendre exactement comment fonctionnent les réseaux de neurones, nous devons utiliser tensorflow leurs propres mains pour construire un modèle de réseau de neurones, voici un exemple concret. (Une partie de ce mode de réalisation de la section de code ouvert GitHub: link)

Dans cet exemple, nous avons deux couches cachées (le nombre de couches cachées sur la sélection est un autre problème, plus de détails, voir: lien). En résumé, le rôle principal de la couche cachée est la couche d'entrée pour convertir les données en une forme plus pratique pour l'utilisation de la couche de sortie.

Comme représenté, ce mode de réalisation chaque noeud dans la couche d'entrée représente un mot dans le texte d'entrée, suivie de la première couche cachée. Il convient de noter que le nombre de noeuds de la première couche cachée est la couche sélectionnée est une tâche importante, souvent appelée la sélection des fonctionnalités.

Chaque noeud de la figure (également appelé neurones), la volonté d'un poids. Le processus de formation que l'on appelle est en fait en dessous de nous ajustons constamment ces poids, de sorte que le processus de la production réelle et la production attendue du modèle qui correspond plus étroitement. Bien sûr, en plus du poids, le réseau entier, plus une valeur de décalage. (Voir les détails sur les écarts: lien)

Après avoir fait la pondération pour chaque noeud et ajoute une valeur de décalage et doit également être émis vers la couche suivante après la fonction d'activation (fonction d'activation) à traiter. En effet, ici la fonction d'activation détermine le dernier cas où la sortie de chaque noeud, tout en ajoutant de l'élément non-linéaire est l'ensemble du modèle. Si l'analogie de la lampe à faire avec des mots, la fonction d'activation est équivalente au rôle du commutateur. L'étude réelle du scénario d'application et les caractéristiques spécifiques, une variété de fonctions d'activation de remplacement, dans laquelle l'écran est fonction de sélection Relu.

De plus figure montre également une deuxième couche cachée, une première couche et sa fonction et pas de différence essentielle, la seule différence est que son entrée est la sortie de la première couche, la première couche est l'entrée de données d'origine.

Enfin, la couche de sortie, le présent mode de réalisation est appliquée dans une méthode de codage à chaud pour classer les résultats. Voici les dits moyens de codage uniques chaud que chaque vecteur a un seul élément est 1, d'autres sont codant zéro. Par exemple, nous voulons que les données de texte est divisé en trois catégories (sport, l'aviation et l'infographie), les résultats de codage:

Les avantages sont ici codant pour un chaud: le numéro du noeud de sortie est exactement égal au nombre de classes de sortie. En outre, similaire à la couche cachée et la structure couche de sortie qui précède, nous avons avec une valeur de pondération pour chaque noeud, ainsi que le décalage approprié, la dernière étape par la fonction d'activation.

Mais avec une fonction différente d'activation fonction d'activation de mode de réalisation présente la couche cachée et la couche de sortie. Étant donné que le but ultime de cet exemple est de sortie le texte correspondant aux informations de chaque catégorie, et est la relation ici entre toutes les catégories mutuellement exclusives. Sur la base de ces caractéristiques, nous avons choisi la fonction Softmax que la fonction d'activation de la couche de sortie. La fonction caractéristique est de convertir la valeur de sortie à une valeur décimale entre 0 et 1, et ces petites valeurs et est égal à 1. Il suffit donc de représenter la distribution de chaque probabilité de classe par la décimale. Si le résultat de la sortie des trois catégories originales viennent d'être mentionnées est 1.2,0.9 et 0,4, par la fonction Softmax post-traitement est obtenu:

On peut voir ces trois décimales et exactement 1.

Jusqu'à présent, nous avons défini les flux de données diagramme du réseau de neurones, ce qui suit est un code spécifique pour atteindre:

# Paramètres réseau

n_hidden_1 = 10 # 1er numéro de couche de caractéristiques

n_hidden_2 = 5 # Numéro 2 de la couche de fonctionnalités

n_input = total_words # Mots à vocab

n_classes = 3 # Catégories: graphiques, l'espace et le base-ball

def multilayer_perceptron ( input_tensor, poids, biais ):

layer_1_multiplication = Tf.matmul (input_tensor, poids )

layer_1_addition = Tf.add (layer_1_multiplication, les biais )

layer_1_activation = Tf.nn.relu (layer_1_addition)

# Couche cachée avec l'activation RELU

layer_2_multiplication = Tf.matmul (layer_1_activation, poids )

layer_2_addition = Tf.add (layer_2_multiplication, les biais )

layer_2_activation = Tf.nn.relu (layer_2_addition)

# Couche de sortie avec activation linéaire

out_layer_multiplication = Tf.matmul (layer_2_activation, poids )

out_layer_addition = Out_layer_multiplication + biais

retour out_layer_addition

la formation de réseau de neurones

Comme mentionné précédemment, le train de modèle dans une tâche très importante est d'ajuster le poids des nuds. Dans cette section, nous allons décrire comment mettre en uvre ce processus tensorflow dans.

Dans tensorflow, les coefficients de pondération de noeud et les valeurs de polarisation mémorisées dans une variable, à savoir tf.Variable objet. Lorsque les données SCHEMA de l'appel de la fonction d'exécution, ces valeurs restent inchangées. Dans un scénario général d'apprentissage automatique, la valeur initiale des valeurs de poids et les valeurs de décalage sont déterminées par la distribution normale aussi. code spécifique comme indiqué ci-dessous:

poids = {

'H1': tf.Variable (tf.random_normal ( )),

'H2': tf.Variable (tf.random_normal ( )),

'Out': tf.Variable (tf.random_normal ( ))

}

biais = {

'B1': tf.Variable (tf.random_normal ( )),

'B2': tf.Variable (tf.random_normal ( )),

'Out': tf.Variable (tf.random_normal ( ))

}

Après avoir exécuté le réseau de neurones avec les valeurs initiales, sera une valeur de sortie réelle Z, et nous nous attendions à la valeur de la production devrait, alors nous devons faire est de calculer un entre eux d'erreur, et en ajustant les poids et d'autres paramètres afin de minimiser . En général, il y a plusieurs façons de calculer l'erreur, parce que nous avons affaire à cette classification, donc une erreur d'entropie croisée. (Sur la raison pour laquelle la classification choisie entropie croisée, voir: Connexion)

En tensorflow, nous pouvons appeler tf.nn.softmax_cross_entropy_with_logits fonction pour calculer l'erreur d'entropie croisée, parce qu'ici nous avons choisi la fonction d'activation Softmax, de sorte que la fonction d'erreur est apparue préfixe softmax_. code spécifique comme suit (nous fonctionnons également le code appel tf.reduced_mean () pour calculer l'erreur moyenne):

# Construct modèle

prédiction = multilayer_perceptron (input_tensor, poids, biais)

# Définir la perte

entropy_loss = tf.nn.softmax_cross_entropy_with_logits (logits = prédiction, les étiquettes = output_tensor)

= perte tf.reduce_mean (entropy_loss)

Après obtention de l'erreur, la tâche suivante est de savoir comment minimiser. La méthode que nous avons choisi ici est la méthode la plus courante de descente de gradient stochastique, son diagramme visuel est la suivante:

De même, la méthode utilisée pour calculer la descente de gradient, il y a beaucoup, nous utilisons ici le moment Adaptive estimation (Adam) méthode d'optimisation, à savoir la méthode d'optimisation adaptative d'estimation de moment, incarnée dans tensorflow est tf.train.AdamOptimizer (learning_rate). fonction minimiser (perte). Ici nous avons besoin de passer des paramètres pour déterminer gradient étape de calcul de la longueur learning_rate.

Qui est très pratique, la fonction AdamOptimizer encapsule deux fonctions: Tout d'abord, le calcul du gradient, et le second gradient de mise à jour. En d'autres termes, non seulement appeler la fonction calcule une valeur de gradient, mais aussi de mettre à jour tout le résultat calcul objet de tf.Variables, ce qui réduit considérablement la complexité de la programmation.

une partie de formation de modèle détaillé du code est le suivant:

learning_rate = 0,001

# Construct modèle

prédiction = multilayer_perceptron (input_tensor, poids, biais)

# Définir la perte

entropy_loss = tf.nn.softmax_cross_entropy_with_logits (logits = prédiction, les étiquettes = output_tensor)

= perte tf.reduce_mean (entropy_loss)

optimiseur = tf.train.AdamOptimizer (learning_rate = learning_rate) .minimize (perte)

traitement des données

Dans le présent mode de réalisation, les données brutes nous avons obtenu de nombreux segments de texte en anglais, afin d'importer le modèle de données, nous avons besoin des données brutes processus de pré-traitement nécessaire. Ici, il comprend deux parties:

codage pour chaque mot;

créer un tenseur correspondant pour chaque segment de texte, où le nombre 1 représente l'apparition d'un mot, ce mot 0 signifie non.

Des codes spécifiques sont les suivants:

numpy d'importation comme #numpy np est un paquet pour le calcul scientifique

de collections importer compteur

= Compteur vocab

text = « Salut du Brésil »

#GET tous les mots

pour mot dans text.split ( ''):

vocab = 1 +

mots #Convert à index

def get_word_2_index (vocab):

word2index = {}

pour i, mot énumération (vocabulaire):

word2index  = I

retour word2index

#Now nous avons un indice

word2index = get_word_2_index (vocab)

total_words = len (vocab)

#Ceci est la façon dont nous créons un tableau numpy (notre matrice)

matrice = np.zeros ((total_words), DTYPE = float)

#Now nous remplissons les valeurs

pour mot à text.split:

matrice = 1 +

impression (matrice)

> > >  

Le code peut être vu de ce qui précède, lorsque le texte d'entrée est « Salut du Brésil », la matrice de sortie est . Lorsque vous saisissez du texte seulement « Salut » temps et ce qui va se passer, le code spécifique et les résultats sont les suivants:

matrice = np.zeros ((total_words), DTYPE = float)

text = "Salut"

pour mot à text.split:

matrice = 1 +

impression (matrice)

> > >  

On peut voir, lorsque la sortie est .

Par conséquent, nous pouvons encoder la catégorie d'information, mais cette fois en utilisant un codage d'un chaud:

y = np.zeros ((3), DTYPE = float)

si la catégorie == 0:

y = 1.  #

catégorie Elif == 1:

y = 1.  #

autre:

y = 1.  #

Exécutez le modèle et prédire

Maintenant que nous avons une compréhension préliminaire des termes tensorflow, le modèle de réseau de neurones, et les données de formation de modèle pré-traitement, ci-dessous, nous allons montrer comment appliquer ces connaissances aux données réelles.

Voici notre source de données 20 Newsgroups, qui comprend 18.000 communiqués de presse, la couverture de 20 catégories, open source, gratuit pour téléchargement à l'adresse:

Tout d'abord, afin d'importer ces ensembles de données, nous avons besoin de l'aide scikit-learn bibliothèque. Il est également une bibliothèque open source, basé sur le langage Python, l'apprentissage machine principalement liée aux données de traitement des tâches. Dans cet exemple, nous utilisons seulement l'une des trois classes: comp.graphics, sci.space et rec.sport.baseball.

Les données finales seront divisées en deux sous-ensembles, un ensemble de données d'apprentissage, un ensemble de test. Tout conseil est ici préférable de ne pas regarder ensemble de données de test avant. Vérifiez à l'avance car les données d'essai auront une incidence sur le choix des paramètres du modèle, affectant ainsi le modèle universel pour d'autres données inconnues.

Présentation de code de données spécifique est la suivante:

de fetch_20newsgroups à l'importation de sklearn.datasets

catégories =

newsgroups_train = Fetch_20newsgroups (= sous-ensemble 'train', les catégories = catégories)

newsgroups_test = Fetch_20newsgroups (= sous-ensemble 'test', les catégories = catégories)

terminologie des réseaux de neurones, est une époque de traiter toutes les données de formation d'un passage vers l'avant (vers l'avant passe) a été ajoutée après un cycle complet de passe (pass vers l'arrière) a. Le premier se réfère ici au procédé actuel pour obtenir le droit de reproduire la valeur de sortie réelle, l'erreur en fonction du résultat signifie à son tour le processus d'ajustement de poids. Ici nous nous concentrons sur ce que la fonction tf.Session.run, en fait, appeler une forme complète:

tf.Session.run (fetch, feed_dict = Aucun, options = Aucun, run_metadata = Aucun)

Au début de cet article décrit la fonction, nous ne récupèrera que paramètre passé par l'opération d'addition, mais en fait, il prend également en charge une variété d'exploitation utilisation entrant. Dans les données réelles pour les sessions de formation de modèle, on passe les deux opérations: une est l'erreur de calcul (à savoir, algorithme du gradient stochastique), l'autre fonction est d'optimiser (par exemple estimation de moment d'adaptation).

Un autre paramètre important dans la fonction d'exécution est feed_dict, nous traitons le modèle de données d'entrée pour chaque paramètre entrant par ce. Pour entrer les données, il faut d'abord définir tf.placeholders.

Selon l'interprétation officielle du document, ici il est juste un espace réservé Airbus, utilisé pour les données de référence pour être des modèles importés, ne nécessite pas d'initialisation, pas stocker les données réelles. Défini dans le présent mode de réalisation code tf.placeholders est comme suit:

n_input = total_words # Mots à vocab

n_classes = 3 # Catégories: graphiques, sci.space et baseball

input_tensor = tf.placeholder (tf.float32, , Name = "entrée")

output_tensor = tf.placeholder (tf.float32, , Name = "sortie")

Avant la formation proprement dite du modèle, diviser les données en BATCH requis, la quantité de traitement de données, à savoir un calcul. A cette époque, il reflète les avantages précédemment définis tf.placeholders, que vous pouvez spécifier un lot variable de dimension par la définition des espaces réservés dans du paramètre « Aucun ». C'est, la taille spécifique du lot et similaires peuvent être utilisés lors révisait plus tard. Ici, nous passons le lot de phase de formation de modèle plus grand, et la bêta pourrait apporter quelques modifications, si nécessaire d'utiliser lots variable. Ensuite, dans la formation, nous allons obtenir des données réelles de texte traitées par get_batches chaque fonction. DETAILLE partie de formation de modèle du code comme suit:

training_epochs = 10

# Lancer le graphique

avec tf.Session comme sess:

sess.run (init) #inits les variables (distribution normale, rappelez-vous?)

# Cycle de formation

pour l'époque de portée (training_epochs):

avg_cost = 0.

total_batch = int (len (newsgroups_train.data) / batch_size)

# Boucle sur tous les lots

for i in range (total_batch):

batch_x, batch_y = get_batch (newsgroups_train, i, batch_size)

# Run op d'optimisation (backprop) et op des coûts (pour obtenir la valeur de la perte)

c, _ = sess.run ( , Feed_dict = {input_tensor: batch_x, output_tensor: batch_y})

Jusqu'ici, nous avons complété le modèle de formation pour les données réelles, l'application suivante au moment de la données de test pour tester le modèle. Au cours des essais, et la formation est similaire à la partie avant, nous devons aussi définir les éléments cartographiques, y compris les opérations et les types de données. Ici, pour la précision de calcul du modèle, mais aussi parce que nous avons introduit un résultat encodées chaud, donc besoin d'obtenir l'indice de sortie correcte, et l'indice de la sortie prédite, et vérifie si elles sont égales, sinon égal, pour calculer l'erreur moyenne correspondante . Code de mise en uvre spécifique et les résultats sont les suivants:

# Modèle d'essai

index_prediction = tf.argmax (prédiction, 1)

index_correct = tf.argmax (output_tensor, 1)

correct_prediction = tf.equal (index_prediction, index_correct)

# Calculer la précision

= Précision tf.reduce_mean (tf.cast (correct_prediction, "float"))

total_test_data = len (newsgroups_test.target)

batch_x_test, batch_y_test = get_batch (newsgroups_test, 0, total_test_data)

print ( "Précision:", accuracy.eval ({input_tensor: batch_x_test, output_tensor: batch_y_test}))

> > >  Epoch: 0001 = perte 1133,908114347

Epoch: 0002 = perte 329,093700409

Epoch: 0003 = perte 111,876660109

Epoch: 0004 = perte 72,552971845

Epoch: 0005 = perte 16,673050320

Epoch: 0006 = perte 16,481995190

Epoch: perte 0007 = 4,848220565

Epoch: perte 0008 = 0,759822878

Epoch: perte 0009 = 0,000000000

Epoch: perte 0010 = 0,079848485

Optimisation Terminé!

Précision: 0,75

Enfin, vous pouvez le voir, l'exactitude de notre modèle de prévision de 75%, pour commencer, ce résultat est bon. , Nous avons obtenu jusqu'à présent une tâche de classification de texte basé sur le modèle de réseau de neurones par tensorflow.

Source: moyenne, Lei Feng réseau compilé