pinout réseau de neurones
DESCRIPTION
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 - PowerPoint PPT PresentationTRANSCRIPT
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ésenteCe 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érationAssocié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 poidsactifs
Registre potentiel de la neurone
Analyse layer 1 (suite)->topologie du réseaude 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 fonctionDe transformation:«step function» que l’on Peut approximer par une Sigmoide pour l’apprentissage
Ce composant contientUn 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 constructorCOMPONENT 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 depondé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 1AER_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 layer1COMPONENT 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 lesPoids aux différentesNeurones de la zoneD’influence
1 événement (1 neurone couche 1)Issu du gros DEMUX
Analyse layer 1ENTITY 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;
ComposantPermettant De faire la sommation pourChaque neuronesde 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 circuitsEst ici
Configuration transmise de C1 à C2via: 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 provenantDe la couche 1
Ce composant contientUn 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 communAu 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
UART0
(4)
GPIOTX/RX
Addr
data (32 bits*2)
ContrôleurMémoire
DDRExterne(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: 2I/O UART: 2Sorties contrôle: 3Sorties horloges: 3Total: 36->35 dispo en single ended (sur- capacité)
UART1
(1)
Débit mémoire externe:(1): Le débit de l’UARTest à 1Mbits (utilisée pourLa 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)
CircuitHorloge
(3)
BridgeUSB/
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èmereset
ANN
Mécanisme d’exclusion mutuelle sur la mémoire (flag busy)
Nécessité d’adapter le code de l’UART pour travailler en modesur-é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émoireDDR avec les événements (via UART), enfin on alimente en événementsle réseau ANN. AU bout d’un certain temps on récupère les données en mémoireDDR, 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
UART0
(4)
GPIOTX
Addr
data (32 bits*2)
ContrôleurMémoire
DDRExterne(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:-12+2 (150MHz)
UART1
(1)
Mémoire DDR
CircuitHorloge
(3)
BridgeUSB/
RS232
Systèmereset
ANN
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
AnalyseurLogique(config
Minimale12 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: 14 +12 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
Resetcircuit
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
ANN
Circuit horloge v166.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
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,28MpixelsSoit 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)
FIFORétention command
es
Codeurpriorité UC R
OUTAGE
IOB
DDR
Contrôleurmémoire
BanqueMémoire
0
BanqueMémoire
3
Adresse (12 bits) + BA (3 bits)
CK P/N,CKE
CS, WECAS RAS
DQ (16 bits) 32 bits
Mémoire tampon:-Lecture/écriture bus sur front montantet descendant
LDQ,UDQ
Horloge synchrone Avec les données
Horloge contrôleur actif sur front montant et descendant
PORT
Séquencement: -émission donnée-émission commande…
Permet de définir la séquence d’attribution du bus(réglable ouRound 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 RS232et DMA
MCB code généré par Xilinx
mig_v3_92_0.vhd
memc3_infrastructure.vhdmemc3_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ôleurMCB
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ôleurMCB
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ôleurMCB
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
Niveaugris
30
255
Schéma carte interfaçagechip CEA avec chip réseau ANN
Réseau ANN(1 accélérateursmaté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 RGBou 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*24bitsou3072*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
U A R T 0
GPIOTX0
ContrôleurMémoire
DDRExterne(TX/RX) 1
(2)
DMA+
UC gestion signaux
ANN
UART1
CircuitHorloge
Systèmereset
ANN
Trigger DMA(réseau ANN et rétine OK)24
ISERDES
(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)
BUFFER
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érieure24 RAM blocks (32*18K disponibles)*
24soustracteur
24 comparateurs
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 signauxDonnéesEntrée+2 signauxUART +3Signaux d’horloge+1 signal donnéesEntréeValides+1 signalRéseauprêt
GPIO RX
AnalyseurLogique(config
Minimale12 canaux
<=200MHz sampling)
Trigger+horlogesynchro
2*12ANN 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 TX1ANN ready
CS
UART
PC
PC
Compteur
pixels
*24
Sytème inutile
Questions à poseret 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 24bits
. . .
1. Séquence lectureParamétrable2. la commutation sefait au rythme des bursts
MUX24 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
addr0addr7
burst1 burst0valid
temps sélection mémoire
Valid actifValid 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)
U A R T 0
GPIOTX0
UART1
CircuitHorloge
Systèmereset
ANN
24ISERDES
(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)
BUFFER
Image antérieure24 RAM blocks (32*18K disponibles)
24soustracteur
24 comparateurs
24 seuils
addr
*24
14 signauxDonnéesEntrée+2 signauxUART +3Signaux d’horloge+1 signal donnéesEntréeValides+1 signalRéseauprêt
GPIO RX
AnalyseurLogique(config
Minimale12 canaux
<=200MHz sampling)
Trigger+horlogesynchro
2*12ANN ready?
GPIO TX1ANN ready
CS
UART0
PC
PC
Compteur
pixels
24*14événements
OSERDES
Stratégie: on initialise les mémoires de seuils, on initialise les mémoires de poidsSynaptiques (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 < random_neuron->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
(convertRGB->gray level)
substractpresent with
previous
Comparison>=(gray level ceil)
Sort stage 1Which
Macro-cell(integer
Div by 16)
Sort stage 2WhichPixel
(mod 16)
Plotimages
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 perMatrix (natural integer)
List of macro_cell number permatrix
List of pixel number per matrix
VHDLBench file
(check eventsorder)
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
(convertRGB->gray level)
Locate shape on the picture
Spike vector generation
Plotimages
List of matrix (gray level matrix)
List of boolean matrix (mask)
VHDLBench file
(check eventsorder)
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
Lettersare classified
List of 48 elements vector that can be classified inLetter 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
ANNModel
(48,48,64->Shape
classifier)
ANNTrainer
Performance_function=f(epochs)
Set of weights per layer
-Réseau ANN à décrire avec les objetsPybrain?-Quels algorithmes d’apprentissage supervisés (se documenté sur la rétro-propagation) ai-je à ma disposition?-Comment déterminer chacun des seuilspar neurone (algo génétique?)
Init weights
Set 48+1 ceils by hand
Fixed pointconverter
Flot Pybrain
VHDL
Faire l’apprentissage supervisé avec des données flottantes
Caractéristiques modèle de réseau de neuronespour 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 neuronespour l’apprentissage
0 7
158
40 47
Une macrocellule
150
16 31
255240
Macrocellule0
0
255
Macrocellule47
- 4 macrocellules de coin- 8+6 macrocellules de bord-30 macrocellules du milieu
->nombres de poids synaptiquesnécessaires:-Macrocellules «coin»: (256+64+3*64+64)*-Macrocellules « bord»: (256+64+3*64+3*64+64)*-Macrocellule «milieu»: (4*256)*
Zone d’influence d’une macro-cellule
Au milieu de la rétine Bordure(pas d’effetsde bord)
coin16
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
INBUF
OUTBUF
fctactivati
on
OUTERR
INERR
Fctdérivée
INBUF
OUTBUF
fctactivati
on
INERR
OUTERR
Fctdérivée
Objet connexion (1)
INBUF
OUTBUF
Matrice desPoids
synaptiques
INERR
OUTERR
ObjetContenantLes poids
(self.params)
Matrice desPoids
Synaptiquestransposée
Calcul partiel du gradiant dS
(self.derivs)
OUTERR
INBUF
(1): faire une classepermettant de customiserla connection entre le layer d’entréeEt 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éeCouche postérieure
Inbuf(0)*
Inbuf(n)*
0 n=48*256 0 p=47
VariationDe poidsassociéesau différentesmacrocellules
Inbuf(0)* Inbuf(n)*
Outerr(0) Outerr(p)Outerr(0)
Outerr(p) Outerr(p)
Outerr(0)
Association fct activation entréeavec l’erreur de sortie
Test classe
Schéma fonctionnel appli réseau neurones python(connexion bias couches de neurones)
Objet layer
INBUF
OUTBUF
fctactivati
on
OUTERR
INERR
Fctdérivée
Bias (valeur constante)
Objet connexion(2)
INBUF
Matrice desPoids
synaptiques
OUTBUF
(1)
(1): les différents poidsAssociés aux bias seront sommés avec les autres poids Synaptiques associés Aux neurones
ObjetContenantLes poids
(self.params)
Calcul partiel du gradiant
dS(self.derivs)
INBUF
OUTERR
(2): faire un objet connexionAvec une matrice n’utilisantQu’une valeur paramètrePour la connexion entre le biasEt le layer de sortie
(3)
(3): faire une extension de l’objetContainer 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 sigmoide Erreur 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 neuronesCalcul erreur quadratique moyennerétro-propagationsommation 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.paramsself.momentum= self.momentum+self.alpha*gradientNouveaux_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