Patent Application
20180137408
The present invention relates generally to neural networks, and more specifically to methods and systems for event-based artificial spiking neural networks.
Artificial spiking neural networks (SNNs) have earned interest in the past decades and are now widely used in multiple artificial intelligence tasks, such as image recognition and sound source separation. This is due to the fact that these neural networks are not only more biologically realistic than neural networks using previous generations of neurons but they were also proven to be more computationally powerful. Artificial spiking neural networks have been implemented on many hardware devices like graphical processing units (GPUs), field-programmable gate arrays (FPGAs) and application-specific integrated circuits (ASICs).
When simulating spiking neural networks, one can consider a time-driven or an event-driven strategy. While the event-driven strategy is widely used in software implementations because of its efficiency, most published works on hardware artificial spiking neural networks use a time-driven approach. This might be explained by the difficulty of implementing an event-driven algorithm which supports biologically accurate models. However, hardware implementations using a simple neuron model, such as the leaky integrate-and-fire (LIF) model, could benefit from the event-driven strategy, pairing the efficiency of the event-driven approach with the parallel computational capability of hardware implementations.
The present disclosure describes systems and methods for operating an event-driven spiking neural network. The neural network is based on a pipelined comparator tree used to find the next neuron to fire (as per the event-driven simulation strategy), with each neuron having a firing time associated therewith. The neuron's discharge is then processed by updating the post-synaptic neurons affected by the firing event. The architecture can be duplicated or otherwise scaled to increase the performance of the system.
In accordance with a first broad aspect, there is provided a method for operating an event-driven neural network comprising a plurality of neurons. The method comprises: (i) setting an initial state of the network and (ii) determining a next event in the network as a time to a next neuron firing. Step (ii) comprises: (a) populating entries of a top level of at least one multi-level comparator with values representative of neuron firing times; (b) comparing pairs of entries and selecting from each pair an entry having a closest neuron firing time; (c) propagating the selected ones from each pair to a next level of the comparator and updating the entries of the top level with one or more new values; (d) repeating steps (b) and (c) until all top level entries are updated and no new values are written to any level of the comparator; and (e) determining the time to a next neuron firing based on the neuron firing time of the value in the final level. The method further comprises (iii) setting a subsequent time of simulation to the next neuron firing time and (iv) simulating the network at the subsequent time of simulation.
In some embodiments, steps (b) and (c) are performed over one clock cycle. In some embodiments, the method further comprises repeating steps (ii) to (iv) iteratively during operation of the network.
In some embodiments, selecting from each pair an entry comprises promoting a random one of the entries of a pair when the associated neuron firing times are identical.
In some embodiments, the method further comprises distributing the plurality of neurons across a plurality of processing elements each having a comparator, performing steps (a) to (d) in parallel in each one of the processing elements, and outputting intermediate values from the final level of each comparator of each processing element; inputting the intermediate values into a merger unit having a comparator; and performing steps (a) to (d) in the merger unit with the intermediate values set as top level entries.
In some embodiments, the method further comprises storing data associated with every neuron that is about to fire in pre-synaptic neuron memories provided in each one of the processing elements.
In some embodiments, the method further comprises identifying as synchronized neurons any neurons from separate processing elements that are set to fire at a same time; and redirecting the synchronized neurons to a same processing element. In some embodiments, the synchronized neurons are pairs of pre-synaptic and post-synaptic neurons.
In some embodiments, simulating the network at the subsequent time of simulation comprises: finding post-synaptic neurons associated with pre-synaptic neurons ready to fire; determining synaptic weights between the post-synaptic neurons and the pre-synaptic neurons ready to fire; determining potential values of the post-synaptic neurons upon fire; and updating next firing times and values for the pre-synaptic neurons and the post-synaptic neurons.
In accordance with another broad aspect, there is provided a spiking neural network comprising a memory having stored thereon program code executable by a processor and at least one processing unit. The processing unit is configured for (i) setting an initial state of the network and (ii) determining a next event in the network as a time to a next neuron firing. Step (ii) comprises: (a) populating entries of a top level of at least one multi-level comparator with values representative of neuron firing times; (b) comparing pairs of entries and selecting from each pair an entry having a closest neuron firing time; (c) propagating the selected ones from each pair to a next level of the comparator and updating the entries of the top level with one or more new values; (d) repeating steps (b) and (c) until all top level entries are updated and no new values are written to any level of the comparator; and (e) determining the time to a next neuron firing based on the neuron firing time of the value in the final level. The processing unit is also configured for (iii) setting a subsequent time of simulation to the next neuron firing time and (iv) simulating the network at the subsequent time of simulation.
In some embodiments, steps (b) and (c) are performed over one clock cycle. In some embodiments, the method further comprises repeating steps (ii) to (iv) iteratively during operation of the network.
In some embodiments, selecting from each pair an entry comprises promoting a random one of the entries of a pair when the associated neuron firing times are identical.
In some embodiments, the processing unit is further configured for distributing the plurality of neurons across a plurality of processing elements each having a comparator, performing steps (a) to (d) in parallel in each one of the processing elements, and outputting intermediate values from the final level of each comparator of each processing element; inputting the intermediate values into a merger unit having a comparator; and performing steps (a) to (d) in the merger unit with the intermediate values set as top level entries.
In some embodiments, the processing unit is further configured for storing data associated with every neuron that is about to fire in pre-synaptic neuron memories provided in each one of the processing elements.
In some embodiments, the processing unit is further configured for identifying as synchronized neurons any neurons from separate processing elements that are set to fire at a same time; and redirecting the synchronized neurons to a same processing element. In some embodiments, the synchronized neurons are pairs of pre-synaptic and post-synaptic neurons.
In some embodiments, simulating the network at the subsequent time of simulation comprises: finding post-synaptic neurons associated with pre-synaptic neurons ready to fire; determining synaptic weights between the post-synaptic neurons and the pre-synaptic neurons ready to fire; determining potential values of the post-synaptic neurons upon fire; and updating next firing times and values for the pre-synaptic neurons and the post-synaptic neurons.
In accordance with yet another aspect, there is provided a non-transitory computer-readable medium having stored thereon instructions for operating an event-based neural network. The instructions are executable by a processing unit for (i) setting an initial state of the network and (ii) determining a next event in the network as a time to a next neuron firing. Step (ii) comprises: (a) populating entries of a top level of at least one multi-level comparator with values representative of neuron firing times; (b) comparing pairs of entries and selecting from each pair an entry having a closest neuron firing time; (c) propagating the selected ones from each pair to a next level of the comparator and updating the entries of the top level with one or more new values; (d) repeating steps (b) and (c) until all top level entries are updated and no new values are written to any level of the comparator; and (e) determining the time to a next neuron firing based on the neuron firing time of the value in the final level. The instructions are also executable for (iii) setting a subsequent time of simulation to the next neuron firing time, (iv) simulating the network at the subsequent time of simulation, and (v) repeating steps (ii) to (iv) iteratively during operation of the network.
Further features and advantages of the present invention will become apparent from the following detailed description, taken in combination with the appended drawings, in which:
It will be noted that throughout the appended drawings, like features are identified by like reference numerals.
An artificial event-driven spiking neural network (SNN) is described herein. In contrast to a time-driven SNN, rather than simulating every moment of simulation time, the event-driven SNN attempts to find moments in simulation time where certain events occur, for example a neuron firing, and simulates only those moments. The network may be implemented on a single field-programmable gate array (FPGA), Application Specific Gate Array (ASIC), or the like, and can simulate any deterministic or stochastic spiking neural network with regular topology (i.e. with a repetitive connection pattern). As will be discussed further below, for the sake of efficiency, synaptic weights are evaluated on-the-fly with a non-linear transformation of the input features respectively associated with every neuron. It should however be understood that, in some embodiments, irregular topologies and plasticity may be implemented using an external memory to store synaptic weights and delays. In addition, multi-FPGA or multi-ASIC implementation may be used to increase the size of the simulated neural network.
The SNN is based on a pipelined comparator used to find the next neuron to fire (as per the event-driven simulation strategy), with each neuron having a firing time associated therewith. The neuron's discharge is then processed by updating the post-synaptic neurons affected by the firing event. The architecture can be duplicated or otherwise scaled to increase the performance of the system. The system may also use synchrony processing for efficient event-driven simulation (SPEEDS) to allow temporal jumps when there is no activity within the spiking neural network and parallel computations when many events are processed at a specific timestep. Since the computational power is mostly used towards spike processing (rather than membrane potential updates), the system significantly improves efficiency as compared to time-driven implementations.
With reference to
At step 104, a next event in the network is determined using a pipelined comparator. The determination is made by performing successive comparisons of neuron firing times to find the closest neuron firing time tfire=x. At step 106, the subsequent time of simulation tsim=i+x is set based on the next neuron firing time tfire=x determined at step 104, and the next simulation of the network occurs at time tsim=i+x., as per step 108. Simulating the network at the subsequent time of simulation comprises processing the event, such as the firing of a neuron, and applying the discharge of the neuron to all post-synaptic neurons associated with the firing neuron.
With reference to
For example, and referring to
Each entry is populated with a value representative of a neuron firing time for a given neuron. In some embodiments, the comparator is originally empty and each entry of the top level in the comparator is populated. In other embodiments, one or more of the entries are already populated, and only empty entries are populated. In further embodiments, all entries are already populated, and execution of step 202 causes one or more of the entries to be overwritten.
In
In some embodiments, the neuron firing times are stored in the top level of the comparator tree 300 and the subsequent levels (e.g. levels 2, 1, and 0 of
At step 204, the neuron firing times of the pairs of entries for the levels of the comparator tree 300 are compared to one another. When only the top level of the comparator tree 300 has been populated, only the entries of the top level are compared.
At step 206, one entry from each pair is selected as having a closer neuron firing time. If the neuron firing times are identical, the selection may be performed at random, based on a default selection setting, or in any other suitable way.
At step 208, the selected neuron firing times from each pair (or a value representative of the neuron firing time or of the neuron associated with the neuron firing time) are propagated to a next level. In other words, those neurons which were selected at step 206 are “promoted” to the next level of the comparator, and the entries of the next level of the comparator tree are populated with values from the selected neurons. In addition, the entries of the top level are updated with one or more values.
Propagation may occur at each clock cycle or using any other measure of time. Initially, before all levels of the comparator tree 300 have been filled, propagation consists in selecting the closest firing time of each pair of entries and writing those values to a next level. When enough clock cycles have gone by such that all levels have been filled, comparisons may still be effected between pairs where one or both values have been updated at a previous iteration. If a comparison does not result in a change in the value of the next level, then no new value is written for that entry and the previous value is retained. If all top level entries are updated and no new values are written to any level, then a closest firing time is found in the entry of the last level and the method 104 moves on to step 210. At step 210, a time until firing is determined based on the firing time of the neuron in the last level.
Steps 204, 206, and 208 are shown to form loop A, which is repeated until the condition for outputting the closest firing time has been met. At the first iteration of loop A, only the top level contains values. At each subsequent iteration of loop A, an additional level is populated with values and values of the top level may be updated. It may be that only a single new value is written in the top level at any given iteration of loop A. It may also be that no new value is written in the top level at any given iteration of loop A and one or more new values are written at another level of the comparator tree 300. Each step of loop A may be performed concurrently for multiple levels of the comparator tree 300 at each clock cycle in a pipeline fashion. When no new values are written and all entries are updated, the method 104 exits loop A and moves on to step 210. The time until firing of the neuron in the last level is then used to set the subsequent time of simulation of the network, as per step 106 of method 100.
In order to use the pipelined comparator tree 300, the structure is first filled with the initial firing time of every neuron of the network, as per step 202. Each time a neuron is given a firing time, a comparison between the newly written value and the value located on the adjacent memory space (i.e. the value with the same address but with the least significant bit (LSB) inverted) is executed to find the next neuron to fire, as per steps 204 and 206. The resulting firing time is then stored on the next clock cycle in the next level of the comparator along with the least significant bits of the address, as per step 208. As discussed above, if two neurons have the same firing time, any one of them can be promoted to the next level. The same process is then repeated in a pipelined fashion during the following clock cycles until the final level of the comparator (i.e. level 0) is reached. Once every value is written in the comparator and a latency of one clock cycle per level has elapsed, the comparator tree of
With reference to
With reference to
With reference to
Each processing element 5040, 5041, . . . , 504N handles a given one of the N banks (i.e. a given number of neurons, with all processing elements 5040, 5041, . . . , 504N processing the same number of neurons) and performs all tasks required to update the neurons of a single bank using data from the pre-synaptic neuron and the simulation time. These tasks include, but are not limited to, finding the post-synaptic neurons for a given pre-synaptic neuron, spike processing, and neuron resetting. Synchrony processing for efficient event-driven simulation is implemented by sending the data associated with every neuron that will fire at the current simulation time to the pre-synaptic neuron memories 5060, 5061, . . . , 506N for the purpose of improving overall efficiency. The best efficiency can indeed be achieved when all processing elements 5040, 5041, . . . , 504N are computing neuron spikes in parallel.
The controller unit 502 is used to keep track of the current simulation time and feed the processing elements with pre-synaptic neurons firing at that precise time. Once in each processing element 5040, 5041, . . . , or 504N, the identifiers (i.e. ID numbers) of the pre-synaptic neurons are stored, along with the corresponding features, in the pre-synaptic neuron memory 5060, 5061, . . . , or 506N of the given processing element 5040, 5041, . . . , or 504N. As used herein, the term “feature” refers to a characteristic that allows to dynamically compute the synaptic weight between a pre-synaptic neuron and a given post-synaptic neuron for purposes of saving memory space. It should however be understood that, in some embodiments, the synaptic weight of each neural connection (i.e. associated with each pair of neurons) may be stored in memory, thereby alleviating the need to store features associated with neurons and dynamically compute the synaptic weight. In this case, learning can be implemented in the spiking neural network by modifying the stored weights over the course of the simulation.
Each pre-synaptic neuron memory 5060, 5061, . . . , or 506N is a buffer that serially feeds the synaptic processing element 5080, 5081, . . . , or 508N of each processing element 5040, 5041, . . . , or 504N. The synaptic processing element 5080, 5081, . . . , or 508N then uses the data received from the pre-synaptic neuron memory 5060, 5061, . . . , or 506N to compute the impact of spikes on the post-synaptic neurons. The synaptic processing element 5080, 5081, . . . , or 508N is also used to implement synchrony processing for efficient event-driven simulation by detecting post-synaptic neurons that are synchronized with the actual pre-synaptic neuron (i.e. neurons from separate processing elements 5040, 5041, . . . , 504N that will fire at the same time). For this purpose, the synaptic processing element 5080, 5081, . . . , or 508N checks whether one or more neurons are synchronized with the neuron identified in the processing element 5040, 5041, . . . , or 504N as possibly being the next neuron to fire. When synchronized neurons are identified, each processing element 5040, 5041, . . . , 504N associates an identifier (referred to as “SyncNeuronID”) with each synchronized neuron for identification thereof. In order to allow parallel computations, each synchronized neuron is then redirected to the pre-synaptic neuron memories 5060, 5061, . . . , 506N via the merger unit 512 and the controller unit 502. In this manner, synchrony processing for efficient event-driven simulation can be implemented, thereby significantly increasing the number of neurons that can be processed at any given time.
The comparator tree 5100, 5101, . . . , or 510N is used at the end of each processing element 5040, 5041, . . . , or 504N to find the next neuron to fire in each bank as the neuron firing times are updated. Each comparator tree 5100, 5101, . . . , or 510N outputs an intermediate single entry corresponding to the next neuron to fire in each bank. When all the pre-synaptic neuron memories 5060, 5061, . . . , or 506N are empty, the merger unit 512, which uses the same comparator tree structure as the one used in each comparator tree 5100, 5101, . . . , or 510N, finds the next neuron to fire from the outputs of all the comparator trees 5100, 5101, . . . , 510N. The intermediate single entries output from the comparator trees 5100, 5101, . . . , or 510N are thus input to the merger unit and set as the entries of a top level of another comparator tree (not shown) and outputs at its final level a final single entry which corresponds to the next neuron to fire. This next neuron to fire, which is identified by its ID number (“TopNeuronID”), cycles back from the merger unit 512 to the controller unit 502 along with its firing time (“TopFiringTime”) and feature and will be used for a new simulation cycle. In the new cycle, the controller unit 512 sends the received information to the processing elements 5040, 5041, . . . , 504N as the identifier (“PreNeuronID”) and feature of the pre-synaptic neuron. The information provided by the controller unit 502 indicates which neuron just fired and is used by the processing elements 5040, 5041, . . . , 504N to determine the neurons that are affected by the neuron discharge and that should accordingly be updated.
In the first stage, the topology solver 602 uses an identifier (e.g. ID number, referred to as “PreNeuronID” in
In the second stage, the feature memory 604 receives the post-synaptic neuron ID number from the topology solver 602 and extracts the feature (referred to as “PostFeature” in
In the third stage, the features, i.e. the feature attached to the post-synaptic neuron (PostFeature) obtained from the feature memory 604 and the feature attached to the pre-synaptic neuron (referred to as “PreFeature” in
where pi(t) is the membrane potential of neuron i at time t, I0 is the input current and τ is the membrane time constant. Equation (1) describes the evolution of the membrane potential of an isolated leaky integrate-and-fire neuron with an initial potential of 0 V. It should however be understood that invertible equations other than equation (1) could also be used to embody the evolution of the membrane potential.
In the fourth stage, combinational logic is used in the synapse model 612 to sum of the synaptic weight (indicative of an increase or decrease in the neuron's potential value) and the potential value of the post-synaptic neuron. The result, which is referred to as “UpdatedPostPotential” in
where t0→p is the time it takes for a neuron with an initial potential of 0 V to reach the potential p assuming a constant I0. Equation (2) is an inverse of equation (1) and allows to find the time at which a certain potential is reached after a previous spike when the potential is reset to 0 V. It should again be understood that an inverse membrane model equation, which is different from equation (2) and would correspond to another membrane potential than the one discussed above with reference to equation (1), could apply.
The membrane model 610 and the inverse membrane model 614 also receive the simulation time (referred to as “SimulationTime” in
t
s(t)=t+t0→p
where ts(t) is the neuron's next firing time, t is the current simulation time, and t0→p
The inverse membrane model 614 further outputs a flag, referred to as “SynchronizedFlag” in
The fifth stage of the pipeline contains the synchrony memory 616, which is used to store the ID numbers of the synchronized post-synaptic neurons, prior to transmission to the controller unit (reference 502 in
In one embodiment, the read operation performed in the second stage and the write operation performed in the fifth stage are executed in parallel using dual-port Random-access memory (RAM) blocks provided in the FPGA. However, it may be desirable for a validity check to be performed in the second stage to stall the pipeline if a read operation is performed on a post-synaptic neuron that is currently being updated in the third, fourth or fifth stage. This may be done by setting an invalidity bit when the firing time value is read in the second stage and by resetting the invalidity bit when the firing time value is written back to memory in the fifth stage. This is analogous to a Read-After-Write (RAW) hazard handling in microprocessor pipelines. Also, to ensure that a synchronized neuron is not detected twice when using synchrony processing, a synchrony check may be performed in the same manner by setting a synchrony bit when a synchronized pre-synaptic neuron is detected and by resetting it when the neuron's potential is reset during a following computation. In one embodiment, the synchrony bit is read from the comparator tree memory 606 at the second stage of the pipelined synaptic processing element at the same time as the value of the PostFiringTime parameter, with the synchrony bit being concatenated with PostFiringTime. The synchrony bit may then be delayed and sent to the inverse membrane model 614. If the synchrony bit is equal to 1, synchrony detection is disabled to avoid detecting the same neuron twice. Otherwise, if the synchrony bit is not set, i.e. equal to 0, synchrony detection will be performed on the neuron.
Referring again to
At this point, the comparator tree 300 is ready to be used in the global architecture of the system 500. Each time a value is written in the comparator tree memory 518 of one of the synaptic processing elements 5080, 5081, . . . or 508N, the value is written in the leftmost level of the pipelined comparator tree 300. The newly written value then goes through the same processing steps described in conjunction with
The processing unit 712 may comprise any suitable devices configured to cause a series of steps to be performed so as to implement the computer-implemented methods 100, 200 such that instructions 716, when executed by a computing device 710 or other programmable apparatus, may cause the functions/acts/steps specified in the methods described herein to be executed. The processing unit 712 may comprise, for example, any type of general-purpose microprocessor or microcontroller, a digital signal processing (DSP) processor, a central processing unit (CPU), an integrated circuit, a field programmable gate array (FPGA), a reconfigurable processor, other suitably programmed or programmable logic circuits, or any combination thereof.
The memory 714 may comprise any suitable known or other machine-readable storage medium. The memory 714 may comprise non-transitory computer readable storage medium such as, for example, but not limited to, an electronic, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus, or device, or any suitable combination of the foregoing. The memory 714 may include a suitable combination of any type of computer memory that is located either internally or externally to device such as, for example, random-access memory (RAM), read-only memory (ROM), compact disc read-only memory (CDROM), electro-optical memory, magneto-optical memory, erasable programmable read-only memory (EPROM), and electrically-erasable programmable read-only memory (EEPROM), Ferroelectric RAM (FRAM) or the like. Memory may comprise any storage means (e.g., devices) suitable for retrievably storing machine-readable instructions executable by processing unit.
Table 1 below lists the resources for several implementations of the system 500 in terms of six-input look-up tables (LUTs), flip-flops (FFs), slices and block RAMs (BRAMs). When comparing the last three columns, it can be noted that the resource usage does not increase significantly with the addition of neurons since the comparator tree structure is well distributed among the processing elements. Also, comparison between the first two columns shows that the system 500 is scalable since the number of BRAMs is proportional to the number of neurons.
460 (55.3%)
To test an embodiment of the system 500, an image segmentation application was performed. Features f, which are pixel values of an input gray-scale image, were associated to every neuron in the network and connections were made using an eight-neighbor topology. Synaptic weights wij between neurons i and j were computed using the following equation:
where parameters wmax=255, α=100 and δ=4. With the system 500, a strong synaptic weight corresponds to two adjacent neurons having a similar grayscale level while a weak synaptic weight corresponds to two adjacent neurons having different grayscale levels. Also, neurons were provided with the same parameters but were initialized with random membrane potentials.
The spiking neural network used for image segmentation was tested using 1-bank, 2-bank, and 4-bank architectures. The impact of synchrony processing (SPEEDS) was also evaluated by disabling such processing in some experiments. For each case, the average performance (in spikes per second) of the implementation was measured on a system clocked at 100 MHz. The results are shown in Table 2 below.
The results of Table 2 show that the event-driven simulation of a spiking neural network implemented on an FPGA can be affected by the parallel computational capability of hardware digital resources. These parallel computations are achieved by processing synchronized events on separate processing elements. The performance is improved as the number of banks is increased but the magnitude of this improvement depends on the topology of the spiking neural network itself.
In another example implementation, an image matching application was implemented. In the image matching application, a first sub-SNN is used for processing a test image and a second sub-SNN is used to represent the reference image. Bidirectional connections are established between these two sub-networks which causes neurons representing similar segments to synchronize.
Like in the image segmentation application, the neurons are provided an identifier, with the most significant bit of the identifier being representative of the sub-network to which the neuron belongs. The neurons are distributed into N banks as with the image segmentation application. The size of the sub-networks is dependent on the number of segments of the image being matched. In this example implementation, the topology solver establishes the bidirectional connections between the sub-networks. The topology solver associated with a given bank is also configured for only mapping post-synaptic neurons which are located within the associated bank.
Each neuron is associated with two values, namely an average grey level and a compactness of the segment. These values are stored in memory and are used when computing the synaptic weight. Specifically, the synaptic weight is calculated for both values for pre- and post-synaptic neurons, then the smaller of the two weights is assigned as the synaptic weight, following a fuzzy logic “AND” operation. Therefore, in this example implementation, a high synaptic weight will only be assigned if the neurons have both similar average grey levels and similar compactness. A synchrony detection module is used to evaluate a number of synchronized neuron pairs across both sub-networks, and if the number surpasses a predetermined threshold, the image matching application indicates a match to the reference image.
Table 3 below lists the resources for several implementations of the proposed system in terms of FFs, LUTs, slices, and BRAMs for use in an image matching application. The results illustrate that, in this embodiment, fewer memory components are required for performing the matching than are required for the segmentation described hereinabove. Additionally, doubling the number of neurons does not double the memory requirements, due to the granularity of the memory.
460 (55.3%)
Table 4 indicates that a performance of the image matching application increases as a number of complex neurons to evaluate increases. This is because a larger number of neurons means a larger number of post-synaptic neurons are generated for each evaluated neuron, which increases event speed for each evaluated neuron. Also, while SPEEDS had an effect on the image matching application, for this implementation it was not as significant as for the implementation of the image segmentation application discussed hereinabove.
While illustrated in the block diagrams as groups of discrete components communicating with each other via distinct data signal connections, it will be understood by those skilled in the art that the present embodiments may be provided by a combination of hardware and software components, with some components being implemented by a given function or operation of a hardware or software system, and many of the data paths illustrated being implemented by data communication within a computer application or operating system. The structure illustrated is thus provided for efficiency of teaching the present embodiment.
The system 500 described herein may be implemented in a high level procedural or object oriented programming or scripting language, or a combination thereof, to communicate with or assist in the operation of a computer system, for example the computing device 710 and/or the circuit assembly 710′. Alternatively, the system 500 may be implemented in assembly or machine language. The language may be a compiled or interpreted language. Program code for implementing the system 500 may be stored on a storage media or a device, for example a ROM, a magnetic disk, an optical disc, a flash drive, or any other suitable storage media or device. The program code may be readable by a general or special-purpose programmable computer for configuring and operating the computer when the storage media or device is read by the computer to perform the procedures described herein. Embodiments of the system 500 may also be considered to be implemented by way of a non-transitory computer-readable storage medium having a computer program stored thereon. The computer program may comprise computer-readable instructions which cause a computer, or more specifically at least one processing unit of the computer, to operate in a specific and predefined manner to perform the functions described herein.
Computer-executable instructions may be in many forms, including program modules, executed by one or more computers or other devices. Generally, program modules include routines, programs, objects, components, data structures, etc., that perform particular tasks or implement particular abstract data types. Typically the functionality of the program modules may be combined or distributed as desired in various embodiments.
Various aspects of the system and methods herein-disclosed may be used alone, in combination, or in a variety of arrangements not specifically discussed in the embodiments described in the foregoing and are therefore not limited in their application to the details and arrangement of components set forth in the foregoing description or illustrated in the drawings. For example, aspects described in one embodiment may be combined in any manner with aspects described in other embodiments. Although particular embodiments have been shown and described, it will be obvious to those skilled in the art that changes and modifications may be made without departing from this invention in its broader aspects. The scope of the following claims should not be limited by the embodiments set forth in the examples, but should be given the broadest reasonable interpretation consistent with the description as a whole.
This application claims priority under 35 U.S.C. 119(e) of U.S. Provisional Application No. 62/165,467, filed on May 22, 2015, entitled “Hardware Architecture for Spiking Neural Networks”, which is hereby incorporated by reference in its entirety.
| Filing Document | Filing Date | Country | Kind |
|---|---|---|---|
| PCT/CA2016/050579 | 5/20/2016 | WO | 00 |
| Number | Date | Country | |
|---|---|---|---|
| 62165467 | May 2015 | US |
