---

Février 2019

Volume 34, numéro 2

Cet article a fait l'objet d'une traduction automatique.

[Intelligence artificielle]

Gros plan sur les réseaux neuronaux

Par Frank La La | Février 2019

Les réseaux neuronaux sont un élément essentiel de nombreuses solutions avancées de l’intelligence artificielle (IA). Toutefois, quelques personnes derstand d’annuler les fondements de mathématiques ou structurels core de ce concept. Tandis que la recherche initiale neuronal réseaux dates retour décennies, il n’a pas été que récemment que la puissance de calcul et la taille des jeux de données de formation apportées les pratiques pour une utilisation générale.

Réseaux neuronaux, ou plus précisément, réseaux neuronaux artificiels, faiblement reposent sur des réseaux de neurones biologiques dans les cerveaux des animaux. Lors de la pas un algorithme en soi, un réseau neuronal est un type de framework pour les algorithmes traiter l’entrée et produire un résultat « appris ». Réseaux neuronaux ont fait leur preuve utiles à effectuer les tâches que les méthodes de programmation traditionnels graves difficultés à résoudre. Bien qu’il existe plusieurs variantes de réseaux neuronaux, ils partagent tous la même structure de base et les concepts. Il existe des infrastructures, telles que Keras, conçu pour les rendre plus facile à implémenter et à masquer de nombreux détails d’implémentation. Toutefois, j’ai jamais complètement saisi la puissance et la beauté de réseaux neuronaux jusqu'à ce que j’ai dû à un programme manuellement. Il s’agit de l’objectif de cette colonne : pour créer un réseau neuronal simple à partir de zéro avec Python.

Neurones et les réseaux neuronaux

Avant de créer un réseau neuronal à partir de zéro, il est important de comprendre ses principaux composants. Chaque réseau neuronal se compose d’une série de nœuds connectés appelée neurones. À son tour, chaque neurone fait partie d’un réseau de neurones disposés en couches. Chaque neurone dans chaque couche est connecté à chaque neurone de la couche suivante. Chaque neurone artificiel prend une série d’entrées et calcule une valeur de somme pondérée. Le neurone activera ou pas selon la sortie de la fonction d’activation, qui prend toutes les valeurs d’entrée et les poids, ainsi que d’un décalage et calcule un nombre. Ce nombre est une valeur comprise entre -1 et 1 ou 0 et 1, selon le type de fonction d’activation. Cette valeur est ensuite passée aux autres neurones connectées à la couche suivante dans un processus appelé propagation vers l’avant.

Comme pour les couches, il existe trois types de base : entrée couches, les calques masqués et couches de sortie. Couches d’entrée représentent les données d’entrée, tandis que la couche de sortie contient la sortie. Les couches masquées déterminent la profondeur du réseau neuronal, c’est là le terme « deep learning » à partir de. Dans la pratique, les réseaux neuronaux peuvent avoir des centaines de niveaux masqués, avec la limite supérieure uniquement en cours de puissance de traitement disponible.

Propagation de vers l’avant

La propagation de vers l’avant est le processus par les flux de données via un réseau neuronal à partir de la couche d’entrée vers la couche de sortie. Elle implique une somme pondérée de toutes les entrées de l’informatique et en tenant compte d’un a priori. Une fois que la somme pondérée est calculée, il est alors exécutée via une fonction d’activation. À l’aide du neurone dans Figure 1 par exemple, le neurone dispose de deux entrées, x1 et x2, ainsi que deux poids, w1 et w2. La somme pondérée est représentée par z, alors que la valeur un représente la valeur calculée par la fonction d’activation lorsqu’il a passé la valeur de la somme pondérée. N’oubliez pas l’objectif de la fonction d’activation pour compresser la sortie du neurone en une valeur comprise entre une plage. Décalage est ajouté pour ajuster la sensibilité du neurone.

Figure 1 la Propagation vers l’avant dans un réseau neuronal

Pour illustrer cela, il peut être préférable de passer par le code. Pour simplifier les choses clair, je vais utiliser les noms de variables qui correspondent avec ceux de Figure 1. Commencez par lancer un bloc-notes Jupyter (pour plus d’informations, cliquez ici : msdn.com/magazine/mt829269), entrez puis qui suit dans une cellule vide, puis exécutez :

x1 = .5
w1 = .2
x2 = 4
w2 = .5
b = .03

z = x1 * w1 + x2 * w2 + b

print (z)

La valeur de z, la somme pondérée, est 2.13. Rappelez-vous que l’étape suivante consiste à exécuter cette valeur via une fonction d’activation. Ensuite, entrez le code suivant dans une nouvelle cellule pour créer une activation
fonction et exécutez-le :

import numpy as np
def sigmoid_activation(weighted_sum):
  return 1.0 / (1.0 + np.exp(-1 * weighted_sum))
a = sigmoid_activation(z)
print(a)

La sortie doit indiquer à qui un est égal à 0.8937850083248244. Dans un réseau neuronal multicouche, la valeur d’un est transmise à la couche suivante. Par conséquent, les activations dans une couche en cascade à l’autre et, éventuellement, via l’ensemble du réseau.

Le sigmoid_activation retourne des valeurs comprises entre 0 et 1, quel que soit la taille ou le nombre est de petite. Entrez le code suivant pour le tester :

print(sigmoid_activation(1000000))
print(sigmoid_activation(.000001))

La sortie doit lire 1.0 et à peu près 0,50, respectivement.

Pour plus d’informations sur la constante mathématique e, reportez-vous à l’article de Wikipedia sur le sujet (bit.ly/2s8VL9Q).

Comment fonctionne un réseau neuronal ?

Étant donné la simplicité relative de la structure et des mathématiques d’un réseau neuronal, il est normal de vous demander comment il peut être appliqué à un large éventail de problèmes d’intelligence artificielle. La puissance réside dans le réseau, pas nécessairement les neurones eux-mêmes. Chaque neurone dans un réseau neuronal représente une combinaison de valeurs d’entrée, le poids et biais. Grâce à une formation, les pondérations appropriées et les valeurs peuvent être déterminés.

À ce stade, vous avez sans doute entendu sur le jeu de données MNIST, qui est couramment utilisé comme une sorte de « Hello World » pour les réseaux neuronaux. J’avais le vu des dizaines de fois avant que la notion de réseaux neuronaux comment fonctionnait enfin cliqué pour moi. Si vous n’êtes pas familiarisé avec le problème, il existe de nombreuses exemples en ligne qui la décomposer (consultez varianceexplained.org/r/digit-eda). Le défi de jeu de données MNIST montre clairement combien il est facile pour les réseaux neuronaux à tirer sur les tâches qui ont DECALEE les approches traditionnelles algorithmiques depuis des décennies.

Voici le problème résumé, étant donné une image en nuances de gris de 28 x 28 pixel d’un chiffre manuscrite un réseau neuronal doit apprendre à lire en tant que la valeur correcte. Cette image 28 x 28 pixel est constitué des valeurs numériques individuels 784 comprise entre 0 et 255, ce qui facilite d’imaginer la structure de la couche d’entrée. La couche d’entrée se compose de 784 neurones, avec les valeurs passées à l’aide d’une fonction d’activation qui garantit des valeurs entre zéro et un. Par conséquent, plus clairs aura une valeur plus proche à un et plus sombre pixels aura une valeur plus proche de zéro. La couche de sortie se compose de 10 neurones, un pour chaque chiffre. Le neurone avec la valeur la plus élevée représente la réponse. Par exemple, si le neurone 8 a la valeur la plus élevée de la fonction d’activation, puis le réseau neuronal a déterminé que huit est la valeur de sortie.

Ajouter simplement deux couches masquées, avec des 32 neurones chacune, aura une incidence importante. Comment ça ? Rappelez-vous que chaque neurone est connecté à chaque neurone de la couche précédente et la couche suivante. Cela signifie qu’il existe un poids 784 x 32 dans la première couche, 32 x 32 poids dans la seconde couche et poids de 32 x 10 dans la troisième couche. Il existe également des écarts 32 + 32 + 10 qui doivent être ajoutées, également. Qui génère un total de valeurs réglables 26,506 et dans cet exemple relativement simple d’un réseau neuronal à trois couches, à peine plus 26,506 poids et biais. En effet, cela signifie qu’il n’y a des 26,506 paramètres pour ajuster pour obtenir une sortie idéale. Pour une visualisation excellente et
Explication de cette structure et la puissance sous-jacente, regardez les » mais que * est * un réseau neuronal ? | L’apprentissage profond, chapitre 1 » vidéo sur YouTube à bit.ly/2RziJVW. Expérimentation interactive avec les réseaux neuronaux, veillez à consulter playground.tensorflow.org.

N’oubliez pas qu’un réseau neuronal réel peut avoir des centaines de milliers de neurones sur des centaines de couches. Il est cette quantité substantielle de paramètres qui donne des réseaux neuronaux leur capacité PRÉDISPOSITION à effectuer des tâches qui ont toujours été au-delà des fonctionnalités des programmes informatiques. Avec toutes ces « dispositifs et cadrans » il a peu se demandent comment ces relativement simple
C’est le cas de nombreuses tâches peuvent résoudre les structures. Cela est également pourquoi l’apprentissage d’un réseau neuronal nécessite autant de puissance de traitement et GPU sont donc parfaits pour ce type de calcul massivement parallèle.

Création d’un réseau neuronal

Avec la structure et des mathématiques expliqué, il est temps de créer un réseau neuronal. Entrez le code dans Figure 2 dans une nouvelle cellule et exécutez-le. La fonction de réseau neuronal initialize simplifie la création de réseaux neuronaux multicouches.

Figure 2 Création d’un réseau neuronal

def initialize_neural_network(num_inputs, num_hidden_layers, 
  num_nodes_hidden, num_nodes_output):
    
  num_nodes_previous = num_inputs # number of nodes in the previous layer

  network = {}
    
  # Loop through each layer and randomly initialize 
  # the weights and biases associated with each layer.
  for layer in range(num_hidden_layers + 1):
        
    if layer == num_hidden_layers:
      layer_name = 'output' 
      num_nodes = num_nodes_output
    else:
      layer_name = 'layer_{}'.format(layer + 1) 
      num_nodes = num_nodes_hidden[layer] 
        
    # Initialize weights and bias for each node.
    network[layer_name] = {}
    for node in range(num_nodes):
      node_name = 'node_{}'.format(node+1)
      network[layer_name][node_name] = {
        'weights': np.around(np.random.uniform(size=num_nodes_previous), 
          decimals=2),
        'bias': np.around(np.random.uniform(size=1), decimals=2),
      }
    
    num_nodes_previous = num_nodes

  return network

Pour créer un réseau neuronal avec 10 entrées, deux sorties et cinq couches masquées avec 32 nœuds, entrez le code suivant dans une cellule vide et exécutez-le :

network1 = initialize_neural_network(10, 5, [32, 32, 32, 32, 32], 2)

Pour créer un réseau qui a une structure pour faire correspondre le réseau neuronal précédent décrit pour résoudre le défi MNIST, ajustez les paramètres comme suit :

mnist_network = initialize_neural_network(784, 2, [32, 32], 10)
print(network1)

Ce code crée un réseau neuronal avec les nœuds d’entrée 784, deux couches masquées avec 32 nœuds et une couche de sortie de 10 nœuds. Notez que la sortie affiche les réseaux au format JSON. Notez également que les poids et biais sont initialisés à des valeurs aléatoires.

Exploration du réseau neuronal

Jusqu'à présent, nous avons la structure d’un réseau neuronal, mais nous n’avons pas fait quoi que ce soit avec lui. Maintenant, nous allons créer une entrée pour network1, ce qui a 10 nœuds d’entrée, comme suit :

from random import seed
np.random.seed(2019)
input_values = np.around(np.random.uniform(size=10), decimals=2)

print('Input values = {}'.format(input_values))

La sortie sera un tableau numpy de 10 valeurs aléatoires qui servira de valeurs d’entrée pour le réseau neuronal. Ensuite, pour afficher les poids et biais pour le premier nœud de la première couche, entrez le code suivant :

node_weights = network1['layer_1']['node_1']['weights']
node_bias = network1['layer_1']['node_1']['bias']

print(node_weights)
print(node_bias)

Notez qu’il existe 10 valeurs de poids et une seule valeur pour l’écart. Ensuite, entrez le code suivant pour créer une fonction qui calcule la somme pondérée :

def calculate_weighted_sum(inputs, weights, bias):
  return np.sum(inputs * weights) + bias

Entrez maintenant le code suivant pour calculer et afficher la somme pondérée (z) pour ce nœud :

weighted_sum_for_node = calculate_weighted_sum(inputs, node_weights, node_bias)
print('Weighted sum for layer1, node1 = {}'.format(
  np.around(weighted_sum_for_node[0], decimals=2)))

La valeur retournée doit être 3.15. Ensuite, utilisez la fonction sigmoid_activation pour calculer une valeur pour ce nœud, comme suit :

node_output_value  = sigmoid_activation(weighted_sum_for_node)
print('Output value for layer1, node1 = 
  {}'.format(np.around(node_output_value[0], decimals=2)))

La dernière valeur de sortie pour ce nœud est 0,96. C’est cette valeur qui sera transmise à tous les neurones de la couche suivante.

N’hésitez pas à expérimenter et itérer au sein du même si les nœuds de 5 600 ou c’est le cas dans ce réseau. Vous pouvez également vous pourrez répéter les étapes que j’ai décrit pour chacun de ces nœuds pour obtenir une évaluation de l’énorme volume de calculs dans un réseau neuronal. Naturellement, il s’agit d’une tâche préférable d’exécuter par programme. Je couvrirai ceci et comment former un réseau neuronal principal dans la colonne suivante.

Pour résumer

Réseaux neuronaux ont conduit à des progrès incroyables dans AI et ont été appliqués à des problèmes réels difficiles telles que de la vision d’ordinateur et de reconnaissance vocale avec succès. Bien que leurs structures complexes, ils sont apportés relativement simples de blocs de construction. Neurones sont disposés en couches dans un réseau neuronal et chaque neurone transmet les valeurs. Par conséquent, les valeurs d’entrée en cascade dans l’ensemble du réseau et influencent la sortie.

Neurones eux-mêmes sont simples et effectuer des fonctions mathématiques de base. Ils deviennent puissants, toutefois, lorsqu’ils sont connectés entre eux. Le nombre de valeurs ajustable même dans des réseaux neuronaux simples fournit un grand contrôle sur le résultat et peut s’avérer utile dans la formation.

Bien que cet article se concentre sur la création d’un réseau neuronal principal dans Python, pratiquement n’importe quel langage de programmation peut servir à créer un réseau neuronal. Il existe des exemples en ligne de cette procédure en JavaScript, C#, Java ou n’importe quel nombre de langages modernes. Où Python convient parfaitement, cependant, est dans le groupe de disponibilité des infrastructures largement prise en charge, tels que Keras, pour simplifier la création de réseaux neuronaux.

---

Frank La Vigne works chez Microsoft en tant qu’IA technologie Solutions professionnel où il aide les entreprises gagnez en efficacité en obtenant le meilleur parti de leurs données avec l’analytique et d’intelligence artificielle. Il a également des hôtes le DataDriven podcast. Il tient un blog régulièrement et que vous pouvez regarder lui sur son canal YouTube, « De Frank type « télévision World » (FranksWorld.TV).

---

Discuter de cet article sur le forum MSDN Magazine