Dans cet article, nous allons apprendre à intégrer un réseau de neurones dans le SBC. Nous allons créer un réseau de neurones à 3 couches pour approximer la fonction sin(x).
Le processus est divisé en deux parties : 1. formation du réseau, qui se fera sur le PC et ; 2. faire fonctionner le réseau, ce qui se fera dans le SBC.
Partie 1. Formation sur les réseaux de neurones
Pour cette partie nous utiliserons des notebooks Jupyter, avec les librairies Keras, Numpy et Pylab.
Étape 1. Importer les bibliothèques nécessaires

Étape 2. Créer l'ensemble de données d'entraînement
Notre ensemble de données se compose de 10000 0 nombres aléatoires dans la plage 2 - 0 * pi en tant qu'entrée X et de leur fonction sin correspondante en tant qu'entrée Y. Notez que nous avons ajusté la plage de Y pour qu'elle s'étende de 1 à XNUMX.

Étape 3. Créer le réseau de neurones
Pour créer le réseau de neurones, nous créons un objet modèle et y ajoutons 3 couches. Cela se fait via l'API fournie par la bibliothèque Keras.
Le nombre de neurones sera de 32 pour la première couche, 32 pour la couche intermédiaire et 1 pour la sortie.
Nous utiliserons les activations relu et sigmoïde.
L'optimiseur utilisé est Adam et la fonction d'erreur MSE.
Le nombre de paramètres réseau est de 1153.

Étape 4. Formation
Lors de la formation, le réseau de neurones utilise l'ensemble de données pour ajuster ses paramètres de manière à minimiser l'erreur.
Dans ce cas, nous avons passé 10 fois l'intégralité de l'ensemble de données sur le réseau, par lots de 32 échantillons.
Comme on peut le voir, à la fin de la formation, l'erreur est très faible, 2.5e-5.

Étape 5. Vérification
Nous allons maintenant tester le réseau de neurones une dernière fois et le comparer aux valeurs attendues. Comme le montre le graphique, le réseau se rapproche assez bien de la fonction sinus.

Étape 6. Exporter les données
Cette fonction permet d'exporter les poids du réseau de neurones vers un fichier texte puis de le charger depuis le SBC.

Partie 2. Exécution sur le SBC
Dans un premier temps, nous allons passer en revue l'implémentation du réseau de neurones.
Le réseau neuronal est divisé en 4 classes : Neural_Network, Layer, Perceptron et Activation.
Chaque classe a essentiellement 1 méthode appelée processus qui est chargée de faire tout le travail, ainsi que les méthodes de chargement et de sauvegarde.
Le Activation , implémente les fonctions d'activation linéaire, relu, sigmoïde et tanh.

Le perceptron classe est responsable de l'exécution de toutes les multiplications. Notez que la fonction de multiplication vectorielle est implémentée dans ASM afin de ne pas sacrifier les performances.


Implémentation ASM vs Python
La multiplication vectorielle est responsable de la majeure partie de l'utilisation du processeur, donc son implémentation sur ASM permet d'améliorer considérablement les performances de la bibliothèque. Dans cet exemple, une simple multiplication vectorielle 100x100 est effectuée. Une implémentation python prend 1339us, tandis que l'implémentation ASM ne prend que 28us. C'est environ 50 fois plus rapide tout en conservant les mêmes valeurs de sortie.

Le Couche classe regroupe quelques perceptrons en parallèle.

La classe Réseau neuronal empile toutes les couches du réseau.

Enfin, nous pouvons revoir/vérifier l'utilisation du réseau.
Nous allons copier le fichier avec les poids sur le SBC et exécuter le main.py suivant.
Ce code charge le réseau depuis le fichier sine.unn et calcule le sinus de 0.123 puis affiche la valeur obtenue par le réseau et le sinus réel, ainsi que le temps de calcul en microsecondes.

Sortie:

Comme nous le voyons, la sortie se rapproche de la valeur attendue avec 4 décimales.
Ce réseau, avec 1153 poids, nécessitait 4612(1153*4) octets de RAM pour stocker les poids en valeur flottante et 5.8 ms pour les traiter.