Pinout réseau de neurones WRAPPER ENTITY: i_clk_PAD : in STD_LOGIC; i_TCK_PAD : in STD_LOGIC; i_rst_n_PAD : in STD_LOGIC; -- circuit 1 IOs i_clk_sync_PAD : in STD_LOGIC; -- PAD i_retina_dta_PAD : in STD_LOGIC_VECTOR (13 downto 0); -- PADs i_valid_dta_PAD : in STD_LOGIC; -- PAD o_ready_PAD : out STD_LOGIC; -- PAD i_RX_PAD : in STD_LOGIC; -- PAD o_TX_PAD : out STD_LOGIC; -- PAD o_en_AER_l1_PAD : out STD_LOGIC; -- PAD o_AER_l1_PAD : out STD_LOGIC_VECTOR (5 downto 0); -- PADs (from C2) -- circuit 2 IOs o_en_AER_l2_PAD : out STD_LOGIC; -- bump - passage par courone o_AER_l2_PAD : out STD_LOGIC_VECTOR (5 downto 0)

Dépendance principales sources VHDL

Interface rétine(analyse layer 1) COMPONENT retina_comm is Port ( clk : in STD_LOGIC; rst_n : in STD_LOGIC; run : in STD_LOGIC; clk_in : in STD_LOGIC; valid_out : in STD_LOGIC; ready_in : out STD_LOGIC; data_retina : in STD_LOGIC_VECTOR (13 DOWNTO 0); rd_fifo : in STD_LOGIC; empty_n : out STD_LOGIC; data_out : out STD_LOGIC_VECTOR (13 DOWNTO 0)); END COMPONENT; COMPONENT event_extraction is PORT (clk : in STD_LOGIC; rst_n : in STD_LOGIC; run : in STD_LOGIC; en_event : out STD_LOGIC_VECTOR (47 DOWNTO 0); event : out STD_LOGIC_VECTOR (383 DOWNTO 0); empty : in STD_LOGIC; rd_fifo : out STD_LOGIC; data_out : in STD_LOGIC_VECTOR (13 DOWNTO 0)); END COMPONENT; Signal données provenant de la rétine 48 macro-cellules et donc 48*8 événements Fréquence horloges: -clk_in (horloge provenant de la rétine- >peut être à une fréquence proche?) -clk: 150MHz (horloge globale layer1) Signification de run Ce composant comporte une fifo pour palier à l’asynchronisme entre les 2 horloges (profondeur 8 cases et largeur 14 bits) Que représente Ce lien? Interface coding layer et Data Link Layer Contient une machine d’état lisant la fifo de « retina_comm» 1 cycle sur 4

analyse layer 1 (suite) COMPONENT top_layer1 IS PORT ( clk : in STD_LOGIC; rst_n : in STD_LOGIC; run : in STD_LOGIC;. spike_46 : OUT STD_LOGIC; enb_47 : OUT STD_LOGIC; addrb_47 : OUT STD_LOGIC_VECTOR (7 DOWNTO 0); dob_47 : IN STD_LOGIC_VECTOR (31 DOWNTO 0); spike_47 : OUT STD_LOGIC; thresh : IN STD_LOGIC_VECTOR (767 DOWNTO 0); en_event : in STD_LOGIC_VECTOR (47 DOWNTO 0); event : in STD_LOGIC_VECTOR (383 DOWNTO 0)); 48*16bits : seuils déclenchement neurones une des 48 sorties du layer 1 (un spike) Entrée des 4 coéf de pondération Associés à chaque événement 48*8 events

Analyse layer 1 (suite) ENTITY wgt_muxer IS PORT( clk : in STD_LOGIC; rst_n : in STD_LOGIC; run : in STD_LOGIC; en_event : in STD_LOGIC; event : in STD_LOGIC_VECTOR (7 downto 0); enb : out STD_LOGIC; addrb : out STD_LOGIC_VECTOR (7 downto 0); dob : in STD_LOGIC_VECTOR (31 downto 0); en_nrn1 : out STD_LOGIC; -- nrn (I,J) en_nrn2 : out STD_LOGIC; -- nrn (I-1, J-1) en_nrn3 : out STD_LOGIC; -- nrn (I-1, J) en_nrn4 : out STD_LOGIC; -- nrn (I-1, J+1) en_nrn5 : out STD_LOGIC; -- nrn (I, J-1) en_nrn6 : out STD_LOGIC; -- nrn (I, J+1) en_nrn7 : out STD_LOGIC; -- nrn (I+1, J-1) en_nrn8 : out STD_LOGIC; -- nrn (I+1, J) en_nrn9 : out STD_LOGIC; -- nrn (I+1, J+1) wgt_nrn1 : out STD_LOGIC_VECTOR (7 downto 0); wgt_nrn2 : out STD_LOGIC_VECTOR (7 downto 0); wgt_nrn3 : out STD_LOGIC_VECTOR (7 downto 0); wgt_nrn4 : out STD_LOGIC_VECTOR (7 downto 0); wgt_nrn5 : out STD_LOGIC_VECTOR (7 downto 0); wgt_nrn6 : out STD_LOGIC_VECTOR (7 downto 0); wgt_nrn7 : out STD_LOGIC_VECTOR (7 downto 0); wgt_nrn8 : out STD_LOGIC_VECTOR (7 downto 0); wgt_nrn9 : out STD_LOGIC_VECTOR (7 downto 0) );END wgt_muxer; Signal activation du bloc neurone en aval Événement provenant de la rétine Signal de sortie contenant le poids envoyé au bloc neurone 47 entités wgt_muxer

Analyse layer 1(suite)->topologie du réseau de neurones COMPONENT smlt_spk_l1 PORT( clk : in STD_LOGIC; rst_n : in STD_LOGIC; run : in STD_LOGIC; wgt1 : in STD_LOGIC_VECTOR (7 downto 0); wgt2 : in STD_LOGIC_VECTOR (7 downto 0); wgt3 : in STD_LOGIC_VECTOR (7 downto 0); wgt4 : in STD_LOGIC_VECTOR (7 downto 0); wgt5 : in STD_LOGIC_VECTOR (7 downto 0); wgt6 : in STD_LOGIC_VECTOR (7 downto 0); wgt7 : in STD_LOGIC_VECTOR (7 downto 0); wgt8 : in STD_LOGIC_VECTOR (7 downto 0); wgt9 : in STD_LOGIC_VECTOR (7 downto 0); en_wgt1 : in STD_LOGIC; en_wgt2 : in STD_LOGIC; en_wgt3 : in STD_LOGIC; en_wgt4 : in STD_LOGIC; en_wgt5 : in STD_LOGIC; en_wgt6 : in STD_LOGIC; en_wgt7 : in STD_LOGIC; en_wgt8 : in STD_LOGIC; en_wgt9 : in STD_LOGIC; en_wgt_sum : out STD_LOGIC; wgt_sum : out STD_LOGIC_VECTOR (15 downto 0) ); Sommation des poids actifs Registre potentiel de la neurone

Analyse layer 1 (suite)->topologie du réseau de neurones COMPONENT neuron PORT( clk : in STD_LOGIC; rst_n : in STD_LOGIC; en_wgt : in STD_LOGIC; spike : out STD_LOGIC; thresh : in STD_LOGIC_VECTOR (15 downto 0); wgt : in STD_LOGIC_VECTOR (15 downto 0) ); Contient la fonction De transformation: «step function» que l’on Peut approximer par une Sigmoide pour l’apprentissage Ce composant contient Un mécanisme d’accumulation et de soustraction par le seuil tous les trois déclenchement de neurones

analyse layer 1 ENTITY top_config_l1 IS PORT ( clk : in STD_LOGIC; TCK : in STD_LOGIC; rst_n : in STD_LOGIC; enb_0 : IN STD_LOGIC; addrb_0 : IN STD_LOGIC_VECTOR(7 DOWNTO 0); dob_0 : OUT STD_LOGIC_VECTOR(31 DOWNTO 0);. ram_word : in STD_LOGIC_VECTOR (31 DOWNTO 0); valid_word : in STD_LOGIC; ctl_word : in STD_LOGIC); END top_config_l1; Entité comportant 47 blocs RAM de 256*32bits (ils servent à stocker les coéf de pondération des synapses). Les mémoires sont elles déjà initialisées? Bus servant à initialiser les différents coéf (comprendre le fonctionnement) Horloge de configuration à 20 MHz Fichier dpram_256x32_h_in.txt pour initialiser les mémoires?

Analyse layer1 COMPONENT config_thresh1 IS PORT ( TCK : in STD_LOGIC; rst_n : in STD_LOGIC; ram_word : in STD_LOGIC_VECTOR (31 DOWNTO 0); valid_word : in STD_LOGIC; thresh : out STD_LOGIC_VECTOR (767 downto 0); ctl_word : in STD_LOGIC); END COMPONENT; Bloc contenant les mémoires des seuils 48*16bits (48 seuils à initialiser dans le layer 1) Les différents seuils sont stoché dans un gros registre (48*16)

Analyse layer1 --configuration word constructor COMPONENT config_RAM IS PORT ( TCK : in STD_LOGIC; rst_n : in STD_LOGIC; busy : in STD_LOGIC; en_RX : in STD_LOGIC; en_TX : out STD_LOGIC; RX_reg : in STD_LOGIC_VECTOR (7 DOWNTO 0); TX_reg : out STD_LOGIC_VECTOR (7 DOWNTO 0); ram_word : out STD_LOGIC_VECTOR (31 DOWNTO 0); valid_word : out STD_LOGIC; ctl_word : out STD_LOGIC; run: out STD_LOGIC); END COMPONENT; Composant servant à partir des octets reçus de la liaison série de constituer Les mots de configuration pour les coéf de pondération ainsi que les seuils d’activation Octet reçu via liaison série Mot de configuration

Analyse layer1 -- External communication and data pre-processing -- Serial transmitter (1 Mbyte/s) COMPONENT send_1MB is Port ( clk : in STD_LOGIC; rst_n : in STD_LOGIC; wrt : in STD_LOGIC; dat : in STD_LOGIC_VECTOR (7 downto 0); TX : out STD_LOGIC; busy : out STD_LOGIC); END COMPONENT; -- Serial receiver (1 Mbyte/s) COMPONENT recv_1MB is Port ( clk : in STD_LOGIC; rst_n : in STD_LOGIC; rx : in STD_LOGIC; dat : out STD_LOGIC_VECTOR (7 downto 0); dat_en : out STD_LOGIC); END COMPONENT;

Analyse layer1 -- AER for the layer 1 AER_l1_inst : AER_out_l1 PORT MAP ( clk => clk, rst_n => rst_n_sync_150, run => run_int, en_aer => en_AER_l1, aer_addr => AER_l1, spk_l1 => spk_l1 ); Horloge 150MHz Entrée spikes 48 bits 6 bits (sortie événement neurone) Algo: -Les événements sont stockés dans un registre mémoire. -On a un registre « roue libre » de largeur le nombre de neurones du « layer» -Si un événement correspond à l’index du bit actif du registre en roue libre, alors l’adresse de l’événement est généré et cet événement est remis à zéro en mémoire (quand l’adresse de l’événement est générée, un signal de contrôle l’est aussi) -La sortie n’est valable que quand en_AER=‘1’=> Nécessité d’information sur le temps relatif au démarrage de l’accélérateur (ajouter dans le testeur ou mettre dans blancs ds la mémoire) -Dans le pire cas (variation importante du niveau de gris ), on a une sortie par cycle. -Stocker dans la mémoire DDR

Analyse layer1 COMPONENT wgt_muxer PORT ( clk : in STD_LOGIC; rst_n : in STD_LOGIC; run : in STD_LOGIC; en_event : in STD_LOGIC; event : in STD_LOGIC_VECTOR (7 downto 0); enb : out STD_LOGIC; addrb : out STD_LOGIC_VECTOR (7 downto 0); dob : in STD_LOGIC_VECTOR (31 downto 0); en_nrn1 : out STD_LOGIC; -- nrn (I,J) en_nrn2 : out STD_LOGIC; -- nrn (I-1, J-1) en_nrn3 : out STD_LOGIC; -- nrn (I-1, J) en_nrn4 : out STD_LOGIC; -- nrn (I-1, J+1) en_nrn5 : out STD_LOGIC; -- nrn (I, J-1) en_nrn6 : out STD_LOGIC; -- nrn (I, J+1) en_nrn7 : out STD_LOGIC; -- nrn (I+1, J-1) en_nrn8 : out STD_LOGIC; -- nrn (I+1, J) en_nrn9 : out STD_LOGIC; -- nrn (I+1, J+1) wgt_nrn1 : out STD_LOGIC_VECTOR (7 downto 0); wgt_nrn2 : out STD_LOGIC_VECTOR (7 downto 0); wgt_nrn3 : out STD_LOGIC_VECTOR (7 downto 0); wgt_nrn4 : out STD_LOGIC_VECTOR (7 downto 0); wgt_nrn5 : out STD_LOGIC_VECTOR (7 downto 0); wgt_nrn6 : out STD_LOGIC_VECTOR (7 downto 0); wgt_nrn7 : out STD_LOGIC_VECTOR (7 downto 0); wgt_nrn8 : out STD_LOGIC_VECTOR (7 downto 0); wgt_nrn9 : out STD_LOGIC_VECTOR (7 downto 0) ); END COMPONENT; Sert à envoyer les Poids aux différentes Neurones de la zone D’influence 1 événement (1 neurone couche 1) Issu du gros DEMUX

Analyse layer 1 ENTITY smlt_spk_l1 IS PORT( clk : in STD_LOGIC; rst_n : in STD_LOGIC; run : in STD_LOGIC; wgt1 : in STD_LOGIC_VECTOR (7 downto 0); wgt2 : in STD_LOGIC_VECTOR (7 downto 0); wgt3 : in STD_LOGIC_VECTOR (7 downto 0); wgt4 : in STD_LOGIC_VECTOR (7 downto 0); wgt5 : in STD_LOGIC_VECTOR (7 downto 0); wgt6 : in STD_LOGIC_VECTOR (7 downto 0); wgt7 : in STD_LOGIC_VECTOR (7 downto 0); wgt8 : in STD_LOGIC_VECTOR (7 downto 0); wgt9 : in STD_LOGIC_VECTOR (7 downto 0); en_wgt1 : in STD_LOGIC; en_wgt2 : in STD_LOGIC; en_wgt3 : in STD_LOGIC; en_wgt4 : in STD_LOGIC; en_wgt5 : in STD_LOGIC; en_wgt6 : in STD_LOGIC; en_wgt7 : in STD_LOGIC; en_wgt8 : in STD_LOGIC; en_wgt9 : in STD_LOGIC; en_wgt_sum : out STD_LOGIC; wgt_sum : out STD_LOGIC_VECTOR (15 downto 0) );END smlt_spk_l1; Composant Permettant De faire la sommation pour Chaque neurones de sortie

Schéma synoptique A quelle fréquence fonctionne ce bus de données?(150MHz): Selon moi, on reçoit 150/4 Mpixels/s, donc la fréquence de rafraichissement est ~3050 image/s Comment fonctionne l’interface rétine? 3 signaux La séparation entre circuits Est ici Configuration transmise de C1 à C2 via: ram_word, valid_word 1 Mbits

Bloc extraction données rétine (layer1) Le composant «event_extraction» mets en œuvre une machine d’état et un système de décodage de démultiplexage des événements: Tous les quatres cycles, génération d’un événement Le bench « top_circuit_1_tb.vhd » est obsolète 13 8 Préfixe pour identifier la macro cellule Identification pixel 0

Analyse layer 2 Layer1: 48 neurones Layer2: 64 neurones dans le code et 50 d’après l’article ()

Analyse layer 2 ENTITY layer2_unit IS PORT ( clk : in STD_LOGIC; TCK : in STD_LOGIC; rst_n_150 : in STD_LOGIC; rst_n_20 : in STD_LOGIC; run : in STD_LOGIC; spike : OUT STD_LOGIC; thresh : in STD_LOGIC_VECTOR (15 DOWNTO 0); spk_l1 : in STD_LOGIC_VECTOR (47 downto 0); block_nb : in STD_LOGIC_VECTOR (15 downto 0); ram_word : in STD_LOGIC_VECTOR (31 DOWNTO 0); valid_word : in STD_LOGIC; ctl_word : in STD_LOGIC); END layer2_unit; Ce bloc contient 1des 64 neurones du 2 layer ce qui inclu: 1 mémoire de 192*8 bits contenant les coéf de pondération

Analyse layer 2 COMPONENT smlt_spk_l2 PORT( clk : in STD_LOGIC; rst_n : in STD_LOGIC; run : in STD_LOGIC; addrb : out STD_LOGIC_VECTOR (7 downto 0); dob : in STD_LOGIC_VECTOR (7 downto 0); enb : out STD_LOGIC; spk_l1 : in STD_LOGIC_VECTOR (47 downto 0); en_wgt_sum : out STD_LOGIC; wgt_sum : out STD_LOGIC_VECTOR (15 downto 0); END COMPONENT; Spikes provenant De la couche 1 Ce composant contient Un process permettant le scan de tous les événements provenant de L1 et une addition du poids synaptique à la somme correspondant à une de 64 neurones cicle (cette connectique correspond à du « pleinement connecté »)

Analyse layer 2 COMPONENT neuron PORT( clk : in STD_LOGIC; rst_n : in STD_LOGIC; en_wgt : in STD_LOGIC; spike : out STD_LOGIC; thresh : in STD_LOGIC_VECTOR (15 downto 0); wgt : in STD_LOGIC_VECTOR (15 downto 0) ); Seuil commun Au 64 neurones

Analyse layer2 AER_l2_inst : AER_out_l2 PORT MAP ( clk => clk, rst_n => rst_n_sync_150, run => run, en_aer => en_AER_l2, aer_addr => AER_l2, spk_l2 => spk_l2 ); Entrée 64 bits 6 bits

Synthèse caractéristiques réseau ANN Réseau de neurones « feedforward » (perceptron) Réseau neurones à spikes (fonction activation « step») Apprentissage supervisé (à partir d’une base de données on va déterminer des règles globales de décision->afin de converger vers un état précis) offline Les caractéristiques des layers sont: (48*256,48,64) Les neurones sont déclenchées suivant l’information spatiale. c.a.d, si une zone de l’image contient une information pertinente, Dans l’implantation matérielle, le mécanisme de génération de « spikes » est mis en œuvre avec un arbre d’additionneur-accumulateur et un comparateur. Le registre d’accumulation est décrémenté d’une valeur du seuil associé après chaque déclenchement.

Connection entre les layers: (entrée et layer1)

Schéma testeur v1 (à base spartan6l) PC U A R T 0 (4) GPIOTX/RXGPIOTX/RX Addr data (32 bits*2) Contrôleur Mémoire DDR Externe(TX/RX) 1 (2) DMA + UC gestion signaux ANN r/w Le débit du bridge est: Comment peut on utiliser le bridge USB/RS232 driver python? ->Débit maximal d’environ 1Mbits (voir doc UG) Débit design testé (entrées+sorties): Entrées données: 14bits+1(37,4MHz) Sorties données: -12 (150MHz) Entrées contrôle: 2 I/O UART: 2 Sorties contrôle: 3 Sorties horloges: 3 Total: 36->35 dispo en single ended (sur- capacité) U A R T 1 (1) Débit mémoire externe: (1): Le débit de l’UART est à 1Mbits (utilisée pour La configuration de l’ANN) (2): chercher une IP Xilinx Existante (ou voir sur opencores) (3): le circuit génère 3 horloges: 150MHz (globale), 37,5MHz (horloge entrée pixels), 20MHz (configuration). Peut on générer des fréquences <= ou y a-t-il une tolérance de la techno ASIC? (4) : Quelle est la fréquence du bus (1Mbits) Circuit Horloge (3) Bridge USB/ RS232 Temps de remplissage de la mémoire à prendre en compte ( 250*48*16*16*8 bits~ 25 Mbits à charger, possibilité d’utiliser SPI) Système reset ANNANN Mécanisme d’exclusion mutuelle sur la mémoire (flag busy) Nécessité d’adapter le code de l’UART pour travailler en mode sur-échantillonné (registre >8 bit pour la détection du start) Re-programmation dynamique avec DCM_CLKGEN (non, dans cette version) Trigger DMA Stratégie: On initialise les poids synaptiques (UARTs), on charge la mémoire DDR avec les événements (via UART), enfin on alimente en événements le réseau ANN. AU bout d’un certain temps on récupère les données en mémoire DDR, puis on récupère les données PC via l’UART

Schéma testeur v1.1 (à cause de la sur-capacité en I/O single ended) PC U A R T 0 (4) GPIOTXGPIOTX Addr data (32 bits*2) Contrôleur Mémoire DDR Externe(TX/RX) 1 (2) DMA + UC gestion signaux ANN r/w Débit design testé (entrées+sorties): Entrées données: 14bits+1(37,4MHz) Sorties données: (150MHz) U A R T 1 (1) Mémoire DDR Circuit Horloge (3) Bridge USB/ RS232 Système reset ANNANN Trigger DMA Stratégie: on charge via les UARTs les poids synaptiques, on charge la mémoire DDR avec les événements, on lance le DMA, puis on récupère les données avec l’analyseur logique Analyseur Logique (config Minimale 12 canaux <=200MHz sampling) 2*12 PC Trigger +horloge GPIO _RX ready Analyseur logique nécessaire car on a pas assez d’I/O avec la solution précédente

Capacité IO carte Extension MXP: 19 I/0s single ended (J1) Header J8 et J6: 2*8 I/0s Besoin: datas +2RS232+signaux de contrôle 3 horloges (Comment faire sortir horloges->IO dédiées?-> utilisation OSERDES?) Total besoin: 36 Alim 12 volt

Circuit horloge et reset testeur v0 66.6Mhz Clock gen circuit Horloge globale FPGA (vitesse bus 32 bits) et horloge globale réseau de neurones: 150 MHz, Horloge événements réseau neurones:37,5Mhz, Horloges UART 0 et 1: 1MHz, Horloge de configuration des mémoire (poids synapses, seuils): 20MHz, horloge contrôleur mémoire DDR: à déterminer Reset circuit Un reset par domaine d’horloge: -reset UART (synchrone 1MHz) -reset horloge globale FPGA 150MHz (synchrone 150MHz) -reset chip réseau de neurones (reset asynchrone) -reset horloge contrôleur mémoire DDR (synchrone à déterminer?) not lock OU Reset externe ANNANN

Circuit horloge v1 66.6Mhz Clock gen circuit Horloge globale FPGA (vitesse bus 32 bits) et horloge globale réseau de neurones: 150 MHz, Horloge événements réseau neurones:37,5Mhz, Horloges UART 0 et 1: 1MHz (impossibilité de générer d’où 4MHz), Horloge de configuration des mémoire (poids synapses, seuils): 20MHz, horloge contrôleur mémoire DDR: à déterminer not lock 150Mhz PLL_ADV 2*150MHz ( bus frequency ->DDR) et 75MHz (horloge software calibration->au maximum 100MHz ) 37,5MHz 20MHz Clock gen circuit 8MHz 4MHz

Débit utile chip ANN vs débit max mémoire DDR Débit utile chip ANN (réfléchir pour faire une architecture DMA générique par rapport aux débits): 14*37,5M+12*150M=2325 Mbit/s (à approfondir demain) Pour 1000 images par seconde, on a: 1000*48*16*16=12,28Mpixels Soit un débit binaire de : 14*12,28M+12*49,15M=761,2Mbits/s (il faut tenir compte du fait qu’on est en bidirectionnel?) Débit contrôleur mémoire pour LPDDR (MCB Spartan6 avec speed grade de - 2,S6LX16 CSG324 Bank 3 ):

Configuration MCB 1 FIFO rétention données (profondeur 64) FIFO Rétention command es Codeur priorité UC ROUTAGEROUTAGE IOBIOB DDR Contrôleur mémoire Banque Mémoire 0 Banque Mémoire 3 Adresse (12 bits) + BA (3 bits) CK P/N,CKE CS, WE CAS RAS DQ (16 bits) 32 bits Mémoire tampon: -Lecture/écriture bus sur front montant et descendant LDQ,UDQ Horloge synchrone Avec les données Horloge contrôleur actif sur front montant et descendant PORTPORT Séquencement: -émission donnée -émission commande … Permet de définir la séquence d’attribution du bus (réglable ou Round robin) Ports (32 bits) Principe: la fréquence du bus est 2 fois celle du banc mémoire

Etapes fonctionnement MCB Adaptation d’impédance Avec un bloc Iodelay, on centre le front montant d’horloge au milieu de la data Calibration permanente du fait des effets de la variation de température

Schéma interface MCB avec RS232 et DMA

MCB code généré par Xilinx mig_v3_92_0.vhd memc3_infrastructure.vhd memc3_wrapper.vhd mcb_raw_wrapper.vhd mcb_soft_calibration.vhd iodrp_controller.vhd iodrp_mcb_controller.vhd Synthèse d’horloge Memory chip control interface

Configuration MCB 2: wrapper contrôleur MCB generic ( C3_P0_MASK_SIZE : integer := 4; C3_P0_DATA_PORT_SIZE : integer := 32; C3_P1_MASK_SIZE : integer := 4; C3_P1_DATA_PORT_SIZE : integer := 32; C3_MEMCLK_PERIOD : integer := 6666; -- Memory data transfer clock period. C3_RST_ACT_LOW : integer := 0; -- # = 1 for active low reset, -- # = 0 for active high reset. C3_INPUT_CLK_TYPE : string := "DIFFERENTIAL"; -- input clock type DIFFERENTIAL or SINGLE_ENDED. C3_CALIB_SOFT_IP : string := "TRUE"; -- # = TRUE, Enables the soft calibration logic, -- # = FALSE, Disables the soft calibration logic. C3_SIMULATION : string := "FALSE"; -- # = TRUE, Simulating the design. Useful to reduce the simulation time, -- # = FALSE, Implementing the design. DEBUG_EN : integer := 0; -- # = 1, Enable debug signals/controls, -- = 0, Disable debug signals/controls. C3_MEM_ADDR_ORDER : string := "BANK_ROW_COLUMN"; -- The order in which user address is provided to the memory controller, -- ROW_BANK_COLUMN or BANK_ROW_COLUMN. C3_NUM_DQ_PINS : integer := 16; -- External memory data width. C3_MEM_ADDR_WIDTH : integer := 13; -- External memory address width. C3_MEM_BANKADDR_WIDTH : integer := 2 -- External memory bank address width. );

Configuration MCB 2: wrapper contrôleur MCB port ( mcb3_dram_dq : inout std_logic_vector(C3_NUM_DQ_PINS-1 downto 0); mcb3_dram_a : out std_logic_vector(C3_MEM_ADDR_WIDTH-1 downto 0); mcb3_dram_ba : out std_logic_vector(C3_MEM_BANKADDR_WIDTH-1 downto 0); mcb3_dram_cke : out std_logic; mcb3_dram_ras_n : out std_logic; mcb3_dram_cas_n : out std_logic; mcb3_dram_we_n : out std_logic; mcb3_dram_dm : out std_logic; mcb3_dram_udqs : inout std_logic; mcb3_rzq : inout std_logic; mcb3_dram_udm : out std_logic; c3_sys_clk_p : in std_logic; c3_sys_clk_n : in std_logic; c3_sys_rst_i : in std_logic; c3_calib_done : out std_logic; c3_clk0 : out std_logic; c3_rst0 : out std_logic; mcb3_dram_dqs : inout std_logic; mcb3_dram_ck : out std_logic; mcb3_dram_ck_n : out std_logic; Signal envoit adresse colonne puis ligne (10 et 12) Adresse banc mémoire

Configuration MCB 2: wrapper contrôleur MCB

Plan mémoire

Cas d’utilisation: détection d’image D’après les gens du CEA, la rétine a un «frame rate» d’environ 1000 images par seconde (on peut donc déduire la fréquence d’émission des données à l’accélérateur matériel ) Dans le testeur, on pré-charge le flot de données brutes associées au cas d’utilisation suivant: la détection d’un quatre blanc sur fond noir. Le scénarii de test est le suivant: on émet une séquence de 30 images à l’accélérateur en modulant le niveau de gris du quatre (modulation linéaire-> on part d’un niveau de gris de 255 puis décroissance linéaire ) Nb image Niveau gris

Schéma carte interfaçage chip CEA avec chip réseau ANN Réseau ANN (1 accélérateurs matériel traitant un cadrant de 48 macro-cellules (*4=192 macro- cellules)) Bridge (à base de carte spartan6l) Conversion fromat données bitmap (niveau gris ou RGB ou autre vers format Événements macro-cellule) RETINE+L2 (matrice de processeur- >SIMD,12*16 processeurs->1 par macro-cellule) 24+8 bits (bus parallèle dont chaque bit représente un bout de donnée d’un MACRO_PROC) 14 bits- *4 -La RETINE + L2 du list émet des bursts de: 256*24bits ou 3072*24bits -de la rétine+L2 vers le bridge on aura 24 liaison séries avec les signaux de contrôle associés: clk_strobe et signal valid -

NEMESIS bridge_rétine L2_réseau ANN v1 UART0UART0 GPIOTX0GPIOTX0 Contrôleur Mémoire DDR Externe(TX/RX) 1 (2) DMA + UC gestion signaux ANN UART1UART1 Circuit Horloge Système reset ANNANN Trigger DMA (réseau ANN et rétine OK) 24 I S E R D E S (1->8, 1->4) 2*12 liaisons série Signaux contrôle+ horloge maître design 32 bits l’horloge fournie par la rétine est maître (est ce possible ?) horloge/4 ou horloge/8 (si diff) 24 pixels (8 bits) BUFFERBUFFER Capacité banc IO? Déclenchement SERDES? - >différentiel ou single-ended (standard?) *:Stockage image antérieure rétine (256*8=2048 bits, mémoire FPGA: 576Kbits)+stockage données burst après traitement? Image antérieure 24 RAM blocks (32*18K disponibles)* 24 soustra cteur 24 compa rateurs 24 seuils Mémoire LPDDR 32 Mbits ->stockage burst: -3072*24*1,75 bits= -256*24*1,75 bits= 24 *14 (événements) addr *24 14 signaux Données Entrée + 2 signaux UART + 3 Signaux d’horloge + 1 signal données Entrée Valides + 1 signal Réseau prêt GPIO RX Analyseur Logique (config Minimale 12 canaux <=200MHz sampling) Trigger +horloge synchro 2*12 ANN ready? Stratégie: on initialise les seuils, on initialise les poids synaptiques (UARTs),on génère les événements à partir des « burst », on les stocke, puis on émet les événements 1 à 1 au réseau ANN GPIO TX1 ANN ready CS UART PC Comp teur pixels *24 Sytème inutile

Questions à poser et réponses (au LIST sur la L2 de rétine) Comment se fait l’interface via la L2 (Rétine)? - La rétine (L1+L2) est embarqué sur la « carte applicative RETINE»: module B2B. A partir de ce bus, on peut lire n’importe quelle mémoire (1 parmi 8 ou plusieurs suivant une séquence qui sera définie par le programmeur de la L2 ). La FPGA Zynq de la carte applicative servira peut être à relayer ce bus de données. Il faut donc demander à GST des données concernant l’interface physique (peuvent il sortir directement en différentiel). -En ce qui concerne les données émises par la L2 (doute sur le fait que ce soit un niveau de gris ou un événement->index macro cellule+pixel), la dynamique est paramétrable (de 1 à 8 bits suivant la programmation de la L2), les données sont émises en série (1bit sur les 24 représente un lien série) -Remarque concernant les prototypes: que ce soit pour le générateur de pattern numérique ou pour le bridge, il serait mieux d’avoir les systèmes de réception et d’émission couplés. Rebouclage des données dans le spartan6 (on est en surcapacité en ce qui concerne le nombre d’IO single ended->utilisation en plus d’Ios différentielles) ou de reboucler les données dans la carte applicative rétine développée par GST. -Concernant les données émises par la L1, il s’agit d’un format de données 16*192bits (chaque colonne représente 1liaison série provenant d’une macro cellule qui délivre une donnée de 16 bits ) -concernant les burst de taille: 256*24 bits

Protocole de communication L2 ->ANN Matrice macro processeurs MEM0 (4k*24bi ts) 24bits (2 colonnes) MEM7 (4k*24bi ts) Crossbar 24bits (2 colonnes)... 24bits Séquence lecture Paramétrable 2. la commutation se fait au rythme des bursts MUX 24 bits Récepteur Fonctionnement système: -Le récepteur initie le transfert en mettant son flag ready à 1 -la séquence de commutation du mux est définie par le programmeur de la couche L2 -Il faudrait définir une séquence de lecture de façon à ce que le récepteur récupère ¼ du flux - Le crossbar est paramétrable et peut-être paramétrée soit pour envoyer des données des mémoires vers la matrice (ou l’inverse) soit vers le récepteur (ou l’inverse) ready+cs addr0 addr7 burst1burst0 valid temps sélection mémoire Valid actif Valid inactif Bidir

Interface 32 bits Le FPGA spartan6l avec le package CSG324 a quatre bancs d’IO ayant les caractéristiques suivantes: 32 Global clock (GCLK) input pins (8 per bank) can connect directly to the global clock buffers (BUFGs), to the BUFIO2 and then to local I/O clocking, or to the BUFIO2 and then to DCMs and PLLs Each Spartan-6 device has 16 BUFGs (2 banks share 8) Au niveau du nombre d’I/O disponibles (voir doc carte LX16)-> header J1 (Mini expansion port-> I/O type ->,achat alimentation de 12 volts nécessaire)->attention toutes les IO ne sont pas sur le même banc et IO diff->limite la capacité) Nécessité d’acheter la carte d’extension FMC pour l’entrée 32 bits-> du coup l’horloge du système sera issue d’un des connecteur du FMC

NEMESIS bridge_rétine L2_réseau ANN v1.1 (dataflow) UART0UART0 GPIOTX0GPIOTX0 UART1UART1 Circuit Horloge Système reset ANNANN 24 I S E R D E S (1->8, 1->4) 2*12 liaisons série Signaux contrôle+ horloge maître design 32 bits horloge/4 ou horloge/8 (si diff) 24 pixels (8 bits) BUFFERBUFFER Image antérieure 24 RAM blocks (32*18K disponibles) 24 soustra cteur 24 compa rateurs 24 seuils addr *24 14 signaux Données Entrée + 2 signaux UART + 3 Signaux d’horloge + 1 signal données Entrée Valides + 1 signal Réseau prêt GPIO RX Analyseur Logique (config Minimale 12 canaux <=200MHz sampling) Trigger +horloge synchro 2*12 ANN ready? GPIO TX1 ANN ready CS UART0 PC Comp teur pixels 24*14 événements OSERDE S Stratégie: on initialise les mémoires de seuils, on initialise les mémoires de poids Synaptiques (UARTs), les données de la rétine sont ensuite traitées en continu Horloge rétine Sytème inutile

Bibliothèque pour modéliser le réseau ann (FANN) Utilisation Fann -> bibliothèque C avec un «wrapper» pour python, mais pas assez flexible pour permettre de customiser le réseau de neurones->exemple en utilisant la fonction «fann_create_sparse_array()»: for(neuron_it = (layer_it - 1)->first_neuron; neuron_it != last_neuron; neuron_it++) { /* random neuron in the output layer that has space * for more connections */ do { random_number = (int) (0.5 + fann_rand(0, num_neurons_out - 1)); random_neuron = layer_it->first_neuron + random_number; /* checks the last space in the connections array for room */ } while(ann->connections[random_neuron->last_con - 1]); /* find an empty space in the connection array and connect */ for(i = random_neuron->first_con; i last_con; i++) { if(ann->connections[i] == NULL) { ann->connections[i] = neuron_it; ann->weights[i] = (fann_type) fann_random_weight(); break; } Le pointeur “layer_it” représente le pointeur de la couche de neurones actuelle (sélection neurone aléatoire-> fonction “fann_rand”)

Bibliothèque pour modéliser la rétine (python v1) Picture Load (convert RGB->gray level) substract present with previous Comparison>= (gray level ceil) Sort stage 1 Which Macro-cell (integer Div by 16) Sort stage 2 Which Pixel (mod 16) Plot images List of matrix (gray level matrix) List of matrix List of (row,col) arrays where the events are located Events generation (concatenation) List of generated events per Matrix (natural integer) List of macro_cell number per matrix List of pixel number per matrix VHDL Bench file (check events order) Generated Events compression to fit to Ann input (L2 process?) To neural network input dataset Take only 48 relevent dots (points saillants)

Modélisation rétine (python v2) Picture Load (convert RGB->gray level) Locate shape on the picture Spike vector generation Plot images List of matrix (gray level matrix) List of boolean matrix (mask) VHDL Bench file (check events order) To neural network input dataset For each letter (A,B,C) For each number_spike_vect For each macrocel: if (useful_point) randomly select one else 0 Letters are classified List of 48 elements vector that can be classified in Letter A, B, C,…. Each element vector is a concatenation of: macrocel_number+pixel_number

Bibliothèque pour modéliser la rétine+ le réseau ann (python+Pybrain) ANN input Dataset Events from L2 ANN Model (48,48,64-> Shape classifier) ANN Trainer Performance_function=f(epochs) Set of weights per layer -Réseau ANN à décrire avec les objets Pybrain? -Quels algorithmes d’apprentissage supervisés (se documenté sur la rétro- propagation) ai-je à ma disposition? -Comment déterminer chacun des seuils par neurone (algo génétique?) Init weights Set 48+1 ceils by hand Fixed point converter

Flot Pybrain VHDL Faire l’apprentissage supervisé avec des données flottantes

Caractéristiques modèle de réseau de neurones pour l’apprentissage supervisé Perceptron multi-couches: (48*256,48,64) Réseau de neurones à apprentissage supervisé (avec rétro-propagation du gradiant)(-> y a-t-il une rétro propagation sur le bias (seuil décision)?) Réseau de neurones avec une fonction d’activation sigmoide

Mapping rétine et vecteur entrée fourni au réseau neurones pour l’apprentissage Une macrocellule Macrocellule Macrocellule macrocellules de coin macrocellules de bord -30 macrocellules du milieu ->nombres de poids synaptiques nécessaires: -Macrocellules «coin»: ( *64+64)* -Macrocellules « bord»: ( *64+3*64+64)* -Macrocellule «milieu»: (4*256)*

Zone d’influence d’une macro-cellule Au milieu de la rétineBordure (pas d’effets de bord) coin 16 8

Pybrain: analyse objet layer LinearLayer: Un buffer d’entrée (48 éléments) de flottant 64bits, et un buffer de sortie (48 éléments flottants sur 64 bits) Fonction d’activation par couche (et de créer un bias): – Pour l’objet «LinearLayer» -> aucune transformation (y=x) – Pour l’objet «SigmoidLayer»->transformation avec la fonction sigmoide SigmoidLayer: Comment paramétrer la fonction sigmoide pour s ’approcher de la fonction « step» et régler le seuil de décision On peut redéfinir ces propres fonctions de transfert en faisant un héritage de la classe «NeuronLayer» et en faisant un «override» (polymorphisme) sur les fonctions: «_forwardImplementation()» et «_backwardImplementation() » (attention la fonction définie doit être au moins dérivable une fois, dérivée définie dans _ backwardImplementation)

Pybrain: analyse objet connection La fonction « FullConnection(Layer1,Layer2)» renvoie un objet connexion: le buffer de sortie de Layer1 est lié au buffer d’entrée de Layer2 à la façon d’une multiplication matricielle (?->) Cette fonction correspond au type de connexion entre le hidden layer et la sortie Possibilité de faire une fonction connection « custom » Buffer entrée Layer2 Buffer sortie Layer1

Schéma fonctionnel appli réseau neurones python (connection entre deux couches de neurones) Objet layer i Objet layer j INBUFINBUF OUTBUFOUTBUF fct activati on OUTERROUTERR INERRINERR Fct dérivée INBUFINBUF OUTBUFOUTBUF fct activati on INERRINERR OUTERROUTERR Fct dérivée Objet connexion (1) INBUFINBUF OUTBUFOUTBUF Matrice des Poids synaptiques INERRINERR OUTERROUTERR Objet Contenant Les poids (self.params) Matrice des Poids Synaptiques transposée Calcul partiel du gradiant dS (self.derivs) OUTERROUTERR INBUFINBUF (1): faire une classe permettant de customiser la connection entre le layer d’entrée Et le layer hidden

Détail opération objet connexion entre layer in et hidden Matrice poids Vecteur spike Macro_cellule_0 Macro_cellule_47 Spikes macrocellule 0 *

Détail opération objet connexion entre layer in et hidden Inbuf (dimension->48*256) ->fonction d’activation couche De neurones antérieure Outerr (dimension-> 48) ->sortie erreur rétro propagée Couche postérieure Inbuf(0)* Inbuf(n)* 0 n=48*256 0 p=47 Variation De poids associées au différentes macrocellules Inbuf(0)* Inbuf(n)* Outerr(0)Outerr(p) Outerr(0) Outerr(p) Outerr(0) Association fct activation entrée avec l’erreur de sortie

Test classe

Schéma fonctionnel appli réseau neurones python (connexion bias couches de neurones) Objet layer INBUFINBUF OUTBUFOUTBUF fct activati on OUTERROUTERR INERRINERR Fct dérivée Bias (valeur constante) Objet connexion (2) INBUFINBUF Matrice des Poids synaptiques OUTBUFOUTBUF (1) (1): les différents poids Associés aux bias seront sommés avec les autres poids Synaptiques associés Aux neurones Objet Contenant Les poids (self.params) Calcul partiel du gradiant dS (self.derivs) INBUFINBUF OUTERROUTERR (2): faire un objet connexion Avec une matrice n’utilisant Qu’une valeur paramètre Pour la connexion entre le bias Et le layer de sortie (3) (3): faire une extension de l’objet Container params de façon À faire une initialisation sur des réel positifs

Initialisation poids (inclus les bias) synaptiques algo python Il faut différencier les bias des poids classiques car il n’ont pas la même dynamique: codage sur 8 bits pour les poids synaptiques et codage sur 16 bits pour les bias Sachant qu’on crée deux connexions séparées: entre layer « in » et « hidden » et «bias » et « hidden » les poids et bias sont ils sommés? (Oui, les résultats des différentes connexions sont sommées->voir méthode « _forwardImplementation » définie dans la classe « FullConnexion->outbuf+=») Lire article pour les méthodes d’initialisation des poids-> ils doivent évoluer dans un sous-ensemble des réels positifs [0;256] si ce sont des poids et dans un sous ensemble négatif si se sont des bias additionnés ((-1)*[0;((2^16)-1)])

Calcul du gradiant dans le cas d’une fonction d’activation sigmoide (Eqn 8c) Taux d’apprentissage (self.alpha dans le code python) Erreur couche neurones j nœud p Fonction d’activation couche neurones i nœud q Dérivée fonction sigmoideErreur sortie couche j pour le pattern p Variation poid m reliant i et j

Algorithme de mis à jour du gradiant sous python Pour chaque pattern d’entrée : Propagation pattern entrée en activant chacune des neurones Calcul erreur quadratique moyenne rétro-propagation sommation de l’erreur avec l’erreur antérieure Si (mode « batchlearning » désactivé)//mode on-line training Calcul du Gradient: =self.module.derivs-self.weightdecay*self.modules.params self.momentum= self.momentum+self.alpha*gradient Nouveaux_poids=self.modules.params+self.momentum self.derivs=inbuf*outerr (du point de vu de l’objet « connexion») Quel est l’effet du réglage des bias sur le Gradient ds l’algo python. On a « self.derivs » qui dépend de l’erreur rétro-propagée et des fonction d’activation de la couche de neurones en amont (le bias à régler doit être un réel positif)

Le bias dans l’algorithme VHDL C’est un entier naturel qui conditionne l’apparition du spike elsif mp >= UNSIGNED (thresh) and cpt < "11" then spike <= '1'; cpt <= cpt + 1;

Schéma fonctionnel appli réseau de neurones

Diagramme classe appli python