diff --git a/HACKING.md b/HACKING.md index 46fbe50b..e83ef452 100644 --- a/HACKING.md +++ b/HACKING.md @@ -1,4 +1,13 @@ Hacking on this site ==================== -Todo! Talk about how the parts interact (Flask, Frozen-Flask, MDPages, etc) +This was the developers' first foray into web-stuff, so it's a little bit +awkward. + +Basically, it pursues a model-view design. Where the Markdown files are the +model, which get converter into views by Flask by filling out the HTML templates +and parsing the Markdown files using `model.py`. The properties of the pages, +such as which pages are to be included, can be found in `__init__.py`. + +This guide is far from complete, so if you have any more questions, don't +hesitate to ask Trevor or Sean. diff --git a/ctn_waterloo/__init__.py b/ctn_waterloo/__init__.py index e468b06c..bf18fff7 100644 --- a/ctn_waterloo/__init__.py +++ b/ctn_waterloo/__init__.py @@ -8,6 +8,7 @@ from .pages import FlatPages from .model import Model + DEBUG = True SITE_NAME = "CNRGlab @ UWaterloo" FREEZER_BASE_URL = 'http://compneuro.uwaterloo.ca/' @@ -152,7 +153,10 @@ def publications_page(citekey): def research_index(): g.topic = 'research' page = pages.get('research_index') - page.topics = [model.research(topic) for topic in page['topics']] + categories = ('Theory', 'Applications', 'Tools') + page.categories = [{'category': cat, 'topics': model.research_categories(cat)} + for cat in categories] + #page.topics = [model.research(topic) for topic in page['topics']] return render_template('research_index.html', page=page) diff --git a/ctn_waterloo/content/research/cognition/cognitive-robotics.md b/ctn_waterloo/content/research/cognition/cognitive-robotics.md deleted file mode 100644 index 161d651e..00000000 --- a/ctn_waterloo/content/research/cognition/cognitive-robotics.md +++ /dev/null @@ -1,10 +0,0 @@ -title: Cognitive Robotics - -Feel free to correct, comment, or suggest any thoughts or ideas. - -Principle Investigator: Jonathan Gagne; [Project Status](?q=node/585) - -## Project: Teaching an industrial robotic arm to perform task based on a -hierarchy of simpler tasks. - -To fill in diff --git a/ctn_waterloo/content/research/cognition/demo.md b/ctn_waterloo/content/research/cognition/demo.md deleted file mode 100644 index 2c562cc4..00000000 --- a/ctn_waterloo/content/research/cognition/demo.md +++ /dev/null @@ -1,8 +0,0 @@ -title: Demo - -A simplified demo-version of the model. To run, download and extract the zip -file below to your computer. You will need the Nengo simulation environment -(http://www.nengo.ca) installed on your computer. Start Nengo, then select -File->Open, and open the "runme.py" file in the extracted directory. - -[Download](http://models.nengo.ca/sites/models.nengo.ca/files/demo_0.zip) diff --git a/ctn_waterloo/content/research/cognition/large-scale-neural-and-cognitive-simulation.md b/ctn_waterloo/content/research/cognition/large-scale-neural-and-cognitive-simulation.md deleted file mode 100644 index f30c68ad..00000000 --- a/ctn_waterloo/content/research/cognition/large-scale-neural-and-cognitive-simulation.md +++ /dev/null @@ -1,55 +0,0 @@ -title: Large-scale neural and cognitive simulation - -See http://nengo.ca/build-a-brain/spaunvideos/ for recent movies of Spaun, implementing this work. - -Of particular relevance to the present proposal, we have developed methods for simulating cognitive behaviour (Eliasmith, 2004; Stewart and Eliasmith, 2008; Stewart and Eliasmith, 2009), and have successfully applied it in preliminary work to the well-known Wason card task, which tests language-based reasoning (Eliasmith, 2005). These developments begin to extend our work on high-dimensional neural representation and dynamics (Eliasmith, 2005) to more cognitive domains. The over-riding challenge that we now encounter, and the focus of this proposal, is scaling up both the theory and the simulations to tackle cognitive tasks in more demanding circumstances. We have begun preliminary work on the scaling of clean-up memory, a kind of associative memory necessary to implement our 'semantic pointer' architecture (Stewart et al., 2009, see Methods). In that work, we demonstrated how to construct a spiking neural network that can scale as well as an ideal associative memory, making this element of the architecture biologically plausible. Specifically, the network could clean up elements in an 8-part symbolic structure, using a vocabulary of 10,000 symbols, with 99% accuracy, using 100,000 neurons. To the best of our knowledge, past models have not employed vocabularies of this size, so these results are encouraging. - -Objectives - -Our central objective is to build biologically detailed models of cognition. Building such models is crucial to improving our understanding of cognitive function in several ways, including: justifying or challenging assumptions currently made by cognitive modellers (Stewart and Eliasmith, 2009); applying neuroscientific constraints to cognitive models (Stewart and Eliasmith, 2009); and addressing cognitive functions over-looked by current cognitive models (Eliasmith, 2005). - -Despite the potential benefits of constructing such biologically detailed simulations, there are no broadly accepted, systematic methods for relating biological data to our high-level understanding of cognitive systems. While our lab has had some success bridging the neural/cognitive gap in specific circumstances (Eliasmith, 2005), we have not yet demonstrated a consistent, scalable architecture that applies to a range of cognitive tasks. - -There are several reasons why such methods are difficult to develop. First, it is challenging to relate realistic neural hardware to cognition without making highly implausible assumptions about the nature of the underlying hardware (see Pertinent Literature for current examples). Second, cognitive models are, by their very nature, large in scale. That is, they often recruit the activation of many areas of cortex. If those areas are to be simulated at the level of single neurons, computational constraints quickly make such simulations practically difficult. Third, it is unclear that current neural-based architectures can, even in principle, scale beyond toy problems (see Pertinent Literature). Fourth, there are few systematic methods that allow for the design of large-scale neural simluations, even if computational problems are solved and the function of the system is identified. And, finally, there have been few proposals for what the functional architecture of the system is that are detailed enough to implement in neurobiological simulations. - -Short-term objectives: Elsewhere, we have argued at length that our Neural Engineering Framework (NEF) in principle provides a method for addressing the first four of these challenges (Eliasmith and Anderson, 2003, see Methods). However, in order to address these challenges successfully in the cognitive case it is important to establish a reasonable working hypothesis about the basic functional architecture underlying cognitive processing. For this reason, work on this project will be organized around the “semantic pointer hypothesis.” A simple statement of the hypothesis is as follows: “High-level cognitive functions in biological systems are made possible by semantic pointers. Semantic pointers are neural representations that carry partial semantic content and are composable into the complex structures necessary to support cognition. Semantic pointers are generated and used by perceptual and motor areas for deep semantic processing.” - -Our key short-term objective is to show that this hypothesis can be realized in biologically realistic simulations which meet the first, third, and fourth challenges listed above (i.e., neurally plausible implementation, in-principle scalability, and systematic design). There are two aspects of this hypothesis that must be expanded in detail to meet these challenges. First, we must indicate how semantic information, even if partial, will be captured by the representations that we choose to identify as semantic pointers. Second, we must describe how to construct complex structures using 'semantic pointer' representations (see Methods). Indeed, in the conclusion to a recent review of his own and others' work on the issue of semantic processing, Barsalou (2009) states: “Perhaps the most pressing issue surrounding this area of work is the lack of well-specified computational accounts” (p. 1287). Ideally, this is where the semantic pointer hypothesis will contribute to our understanding of cognitive processing. - -In the short term, we will determine if our approach can successfully address these challenges using neural simulations on small-scale problems. However, each of these problems, and the methods adopted, have been carefully chosen to allow for a significant increase in scale. Currently, we have chosen two cognitive tasks: the Wason card task (Eliasmith, 2005), and the Raven's Progressive Matrices (RPM; Rasmussen, 2009). These emphasize language processing (Wason, 1968) and general intelligence (Marshalek et al., 1983), respectively. - -Concurrently, we will develop computational tools that allow us to scale up these preliminary models. Specifically, we will extend our Nengo simulation environment to run efficiently on a high-performance computing (HPC) infrastructure, such as Sharcnet (our preferred HPC consortium in Ontario). These extensions will result in parallelization of the network setup and temporal simulation algorithms (the two largest current bottlenecks). - -Long-term objectives: Our long-term objective is to meet the second challenge identified above: large-scale simulation of a cognitive architecture. Again, we will tackle this problem by both developing the relevant computational tools, and extending our specific models to exploit those tools. Currently, the theory behind the NEF allows for a wide degree of flexibility in characterizing neural activity. It allows a model to be specified in terms of spiking neurons, non-spiking neurons, population activity, or just in terms of the relevant representations (i.e., with no neurons). This flexibility is crucial to exploit in order to practically scale cognitive models. As a result, Nengo will be extended to incorporate this flexibility in a parallel environment. This will allow the user to control the degree of detail in which each object of the simulation (i.e., network, subnetwork, neural population, neuron, etc.) is run, while gaining the advantages of parallel implementation. - -To exploit these tools, we will scale up the Wason and RPM models. Currently, these models use 100 dimensional vectors (see Methods). To scale up to our current clean-up memory (Stewart et al., 2009), they will need to employ 500 dimensional vectors. This will allow processing of 10,000 distinct symbols, approximating the size of vocabulary of a 6 year old (Anglin, 1993). In the context of the Wason task, this will allow for many more inferences to be tested across a wider variety of contexts, and for the representations used in the inferences to be more complex. For RPM, this scaling will allow the system to take the same test administered to human subjects, aiding a straightforward comparison of the model and human data. In both cases, determining when and how the system fails and succeeds will test the appropriateness of the underlying representational and architectural hypotheses. - -Currently, there are no neural cognitive models with this size of lexicon. Establishing such ambitious targets should significantly advance our understanding of how neural resources can be used to account for cognitive behaviour. It will also allow for a more direct comparison of the model with the many fMRI and ERP experiments performed during cognitive tasks, because the scale of the activity generated by the model will be comparable to the collected data. In short, scaling up models should both challenge current theory and more convincingly contact available data. - -Pertinent Literature - -Perhaps the best known cognitive model is ACT-R (Anderson et al., 2004). This is a hybrid model that implements a classical cognitive architecture (Fodor and Pylyshyn, 1988) by combining a production system with procedural learning and a neurally-inspired model of declarative memory. Despite extensive success at modelling a wide variety of cognitive tasks, there is no characterization of the neural processing underlying the model, and there is strong evidence that including more neurally plausible components in the architecture would allow it to better account for human data (van Maanen, 2009). In short, ACT-R is an ideal point of comparison for the current state-of-the-art in cognitive modelling, as well as being useful as a point of departure for demonstrating the benefits of neural modelling. - -A recent, more neurally-based cognitive approach is the LISA model (Hummel and Holyoak, 2003). LISA is also an implementation of a classical architecture: all elements of the structures are explicitly tokened whenever a structure is tokened. In LISA, each population only represents one object, subproposition, or proposition. Unfortunately, this results in exponentially poor scaling and unrealistic resource demands (Stewart and Eliasmith, 2009). More recently, van der Velde and de Kamps (2006) introduced the neural blackboard architectures (NBA) as a means of modelling cognition. To avoid the exponential growth in resources attributable to LISA, the NBA uses a smaller set of “cell assemblies” that represent basic symbols. Larger structures are then built by binding these assemblies together using a highly intricate system of neural gates. While better than LISA, NBA scales poorly, and introduces a complex and brittle control system into the architecture. In addition to these theoretical scaling issues, both the NBA and LISA, in practice, avoid important biological constraints. Neither approach uses spiking neurons, enforce local connectivity constraints, or have neural evidence for their assumed binding mechanism (Stewart and Eliasmith, 2009). - -Methods and proposed approach - -The three main methods that we will exploit to realize these goals are the NEF for neural simulation, a vector symbolic architecture (VSA) for binding, and a semantic pointer architecture for realizing cognitive processing. - -The NEF: Over the past several years, we have developed a neural modelling approach that permits the construction of large-scale models (Eliasmith and Anderson, 2003). The size of these models is not limited for two main reasons: 1) because we provide a general mathematical description of a neural subsystem for which the inputs and the outputs are the same (i.e., trains of neural spikes); and 2) because our approach permits the analytical calculation of connection weight matrices. As a result, many subsystems can be concatenated to form complex models (e.g., our Wason model has 9 such subsystems), without the need for learning. Furthermore, because there are no assumptions made about the form of the neural nonlinearity (i.e., spike generator), our methods permit the inclusion of very high degrees of neural realism (e.g., using conductance-based single neuron models), or not, depending on the research question at hand. Finally, because representation in the NEF is descibed in terms of general vector spaces, the size of a vector space does not adversely influence the application of the theory. Consequently, if we can characterize a cognitive function as a transformation of vector spaces -- a very general kind of description -- the NEF provides a method to map that function onto a neural substrate, incorporating known neurological constraints (e.g., tuning curves, connection constraints, neurotransmitter type, etc.). Thus, to construct large-scale models of cognition, we need to express the relevant functions in such a vector space. - -Vector Symbolic Architectures: The term “Vector Symbolic Architecture” was coined by Gayler (2003) to describe a class of closely related approaches to encoding syntactic structure using distributed, vector representations (Smolensky, 1990; Plate, 1991; Kanerva, 1994). In order to construct structured representations, VSAs define two operations. The first is a binding operation, which is a kind of vector product (). The second operation is a merging operation, which is vector superposition (). Unlike binding, the results of merging vectors is similar to both of the merged vectors. The similarity of vectors is determined a metric on the vector space, usually the inner product. - -The binding and merging operations can be used to construct structured representations, for example, of “The dog chased the boy,” or chased(dog, boy). To encode this in a VSA, vectors for each of the roles and each of the fillers are needed. Then, to encode such a proposition as , we perform the following calculation: . To make use of this representation, the terms can be unbound. This is done by binding with the inverse of a term. For example, to decode the from the structure, given only , we bind with the inverse of , and the result is approximately equal to . Unlike classical architectures, VSAs rely on `reduced' representations. In such representations, the output of the vector binding operation does not explicitly include the bound components. As a result, the unbound elements must be recognized in the face of noise: i.e., they must be cleaned-up. This is why clean-up memories are crucial to the proper functioning of VSAs, and why we have been exploring their implementation in spiking neurons (Stewart et al., 2009). - -Because the NEF maps vector transformations onto neural function, it is a natural method for examining the biological plausibility of VSAs (Eliasmith, 2004). Furthermore, VSAs can be used to compose semantic pointers in a manner suitable for supporting language-like processing. Consequently, our past work has provided proof-of-concept implementations of VSAs, and hence the neural composability of semantic pointers (Stewart and Eliasmith, 2009; Eliasmith, 2005). However, the vectors we have employed are low-dimensional and randomly generated, thus unable to effectively reflect semantic relationships. - -Semantic Pointers: It has been suggested for some time that a vector space is a natural way to represent semantic relationships in a cognitive system. However, there is concern that such spaces are not sufficiently sophisticated to represent the kinds of complex representational structures that underlie cognition (Barsalou, 1999). This is where the notion of a “pointer” is of crucial importance. In computer science, a pointer is a set of numbers that indicates the memory address of a piece of information. Notably, a pointer and the information contained at its address are arbitrarily related. This, however, does not describe linguistic representation well, hence we suggest that 'cognitive' pointers are (shallowly) semantic. Nevertheless, the notion of a 'pointer' does provide the insight that the manipulation of compact, address-like representations can provide great efficiency when building a flexible architecture. - -Recent empirical evidence is consistent with this notion of semantic pointers. For instance, Solomon and Barsalou (2004) demonstrated that pairings of target words and properties can result in significant differences in response times to determining if a property belongs to a target word. Specifically, false pairings that were lexically associated took longer to process than those that were not. This suggests that the semantics of the pointer were sufficient in the semantically easy cases, but insufficient in the hard cases, forcing the pointer to be 'de-referenced' in semantic memory, taking extra time. A similar result was reported in an fMRI experiment carried out by Kan et al. (2003). There, activation in semantically rich perceptual systems was only present in the difficult cases, while activation of frontal areas was evident in all cases. This work demonstrates that deep processing is not needed when a simpler word association (i.e., shallow semantic) strategy is sufficient to complete the task. - -Given this functional characterization of semantic pointers, the remaining issue is how such pointers are generated. Given their semantic content, we assume that they are generated on the basis of the full semantics of a lexical item. These semantics are, arguably, found largely in perceptual processing areas (Barsalou, 2009). Consequently, we adopt hierarchical, generative statistical models of perception (Hinton, 2007), from which we can extract 'compressed' representations (Eliasmith, 2007); i.e., semantic pointers. In such models, a higher level in the processing hierarchy attempts to build a statistical model of the level below it. Taken together, the levels define a model of the original input data. This kind of hierarchical structure naturally allows the progressive generation of more complex features at higher levels, and progressively captures higher-order correlations in the data. Higher levels have fewer nodes than lower levels, so the highest level of the hierarchy can act as a compressed version of the state of the perceptual cortex, i.e., it can be a semantic pointer. To de-reference such a pointer, the activity of the last level can be fixed, acting as a statistical prior on the activity of lower levels, allowing the entire network to sample the distribution (i.e., fill-in the semantic details). - -In applications to vision, these models have been shown to generate neuron tuning curves that mimic those seen in visual cortex (Lee et al., 2007). As well, many of the most actively researched models of biological object recognition can be seen as constructing exactly these kinds of statistical models (e.g., Riesenhuber and Poggio, 1999). Consequently, we are actively developing a simple visual model of this class to generate 'grounded' semantic pointers for the visual processing in the RPM task. - -In sum, we are proposing to use the neural modelling methods of the NEF to implement a VSA that can appropriately process vectors in syntactic structures, where the surface semantics of those vectors are determined by the highest level of a hierarchical statistical model of perceptual systems. We have had preliminary success with these methods, and have chosen them due to their in-principle ability to scale well in a detailed neural simulation. We will extend our Nengo modelling environment to evaluate the scalability of these methods, and bring them in closer contact with empirical evidence. diff --git a/ctn_waterloo/content/research/cognition/modelling-problem-solving-in-ravens-progressive-matrices.md b/ctn_waterloo/content/research/cognition/modelling-problem-solving-in-ravens-progressive-matrices.md deleted file mode 100644 index 65a8da11..00000000 --- a/ctn_waterloo/content/research/cognition/modelling-problem-solving-in-ravens-progressive-matrices.md +++ /dev/null @@ -1,34 +0,0 @@ -title: Modelling problem solving in Raven's Progressive Matrices - -Principle Investigator: [Daniel Rasmussen](?q=node/488) - -Raven's Progressive Matrices is one of the most widely used tests of general -intelligence. It has been found to be both domain independent and highly -correlated with other measures of intellectual ability [Marshalek et al., -1983]. In the RPM subjects are presented with a 3x3 matrix, where each cell-- -except for the blank cell in the bottom right--contains multiple features. The -task is to determine, given eight possibilities, which answer belongs in the -blank cell. Subjects accomplish this by finding the rules that govern the -features in each row or column. Once these rules have been found, they can be -applied to the last row/column to determine which features will complete the -rule in the blank cell. This task requires a complex array of cognitive -abilities, and so represents an interesting challenge for understanding human -intelligence. - -There are many theories as to how subjects go about solving these matrices. -Over the years researchers have focused on topics including the di fferent -types of rules (Carpenter et al. [1990], DeShon et al. [1995]), error types -(Babcock [2002]), the importance of early visual processing (Meo et al. -[2007]), working memory (Kyllonen and Christal [1990]), and executive -functions (Unsworth and Engle [2005]). - -There are two significant tasks which stand out as necessary to flesh out this -research. The first is developing a working model that combines these theories -to recreate human performance. This is the proverbial proof in the pudding; if -our theories about how subjects solve the RPM are correct, then we should be -able to use those theories to solve the RPM. The second gap in the RPM -literature is an explanation of how subjects create new rules. What is missing -is that crucial intermediate step; we have theories on how visual information -is collected in RPM situations, and given a set of rules we have theories on -how they are used to solve the matrix, but we are lacking in theories that -explain how we make that move from visual information to rule. diff --git a/ctn_waterloo/content/research/cognition/neural-cognitive-architecture.md b/ctn_waterloo/content/research/cognition/neural-cognitive-architecture.md deleted file mode 100644 index 18d1a2d1..00000000 --- a/ctn_waterloo/content/research/cognition/neural-cognitive-architecture.md +++ /dev/null @@ -1,80 +0,0 @@ -title: Neural Cognitive Architecture - -Cognitive science has developed a wide variety of theories about human -cognition. While some of these theories are merely _descriptive_ (i.e. they -describe human cognitive behaviour), many are _mechanistic_, in that they -postulate a set of internal components which interact over time to produce the -observed behaviour. These components can be referred to as a _cognitive -architecture_. - -The most successful and widely used cognitive architecture is -[ACT-R](http://act-r.psy.cmu.edu/). This includes components for memory, -vision, motor behaviour, time estimation, and central executive control. These -same components have been used for models of mental arithmetic, problem -solving, task switching, car driving, phone dialing, sequence memory, GUI -usage, and so on (see [here](http://act-r.psy.cmu.edu/publications/index.php) -for more examples and related publications). These models come from many -different people and many different labs, making it the most widely used and -tested cognitive archicture. - -The focus of ACT-R research has been to develop this common setof components -for modelling cognitive activities. By re-using these same components, they -can minimize the amount of parameter fitting and model-tweaking needed to -match human behaviour on all these tasks. However, they have been focussed on -_what_ the brain does, not _how_ it does it. That is, they want to identify -the algorithms behind cognition, not how neurons implement that algorithm. - -Recently, John Anderson (the core person behind ACT-R) has been doing a lot of -work with fMRI to try to identify the neurological correlates to the various -components of ACT-R. The intent here is to bring in neural evidence to help -constrain ACT-R theory, which right now is mostly constrained by psychology -data (i.e. the model's behaviour has to match human reaction times, error -rates, and so on). Adding in neural constraints can help to suggest -modifications to ACT-R, or provide support for some of the ACT-R assumptions. -This has led to a work comparing the activity of particular brain areas to -various ACT-R components, in tasks such as the [Tower of -Hanoi](http://act-r.psy.cmu.edu/publications/pubinfo.php?id=606), and [mental -symbol manipulation](http://act-r.psy.cmu.edu/publications/pubinfo.php?id=500) -(for more, see -[here](http://act-r.psy.cmu.edu/publications/index.php?subtopic=37)). There's -also a short overview of this approach -[here](http://act-r.psy.cmu.edu/publications/pubinfo.php?id=800). and for a -more complete overview, see John Anderson's book "[How Can the Human Mind -Occur in the Physical Universe?](http://www.amazon.com/Physical-Universe- -Oxford-Cognitive-Architectures/dp/0195324250)". - -It is definitely promising to see a degree of correlation between ACT-R -predictions of BOLD signals and real data. However, without an explicit -implementational story for the various components, many assumptions have to be -made to create these BOLD predictions. Furthermore, if we had a fully neural -implementation of these components, we could also bring in a lot of other -neural evidence involving spiking patterns, connectivity, neurotransmitter -use, drug effects, and even DBS. - -Our goal is to create a fully neural implementation of each of the components -of ACT-R, using realistic spiking neurons constrained by known neural anatomy. - -We have chosen ACT-R as an interesting minimal target for building large-scale -neural systems. If we can build a neural system with components that can -perform the few basic functions needed by ACT-R, then we can relate the -resulting neural model to a wide range of behavioural data, while still being -able to look at low-level neural effects. - -Currently, we are focusing on the basal ganglia, which for the ACT-R people -correlates to a production system, along with a reinforcement learning system -to use reward feedback to control action selection. This certainly doesn't -completely capture everything about the basal ganglia, but there seems to be -enough evidence that it's at least in the right general ballpark. It fits in -nicely with the dimensionality reduction ideas, and the dopamine/reinforcement -learning connection. - -This basic model of this system is currently at a stage where it can do basic -action selection based on the current context, choose an action that will -modify the current context, modify that context, and choose a new action. -Interestingly, constraining the neural model to use GABA results in a model -that requires about 50ms to make a choice, which is the experimental best-fit -to a wide range of behavioural data. - -## Publications - - * [Spiking neurons and central executive control: The origin of the 50-millisecond cognitive cycle](http://arts.uwaterloo.ca/~cnrglab/?q=node/568) diff --git a/ctn_waterloo/content/research/cognition/project-status.md b/ctn_waterloo/content/research/cognition/project-status.md deleted file mode 100644 index 33571b79..00000000 --- a/ctn_waterloo/content/research/cognition/project-status.md +++ /dev/null @@ -1,25 +0,0 @@ -title: Project Status - -## To do: - - * fix cleanup memory - -## Progress: - -**23/06/11** -wrapped things up for publication - - * fix figure solver (run model with more dimensions) - * get results for complete RAPM - * analyze performance as model degrades (modelling aging) - -**15/08/10** - thesis complete -**11/10/09** - haven't updated this in a while, all the to-do's are now complete: - - * test model on more complex matrices - * develop system that handles abstract rules - * develop system that can fetch desired matrix data (rather than simply providing it as function input) - * come up with a more formal system to represent matrices as HRRs - -**14/07/09** - cleanup memory integrated into model -**19/05/09** - model now working with spiking neurons -**01/05/09** - completed report on "proof of concept" model diff --git a/ctn_waterloo/content/research/cognition/results.md b/ctn_waterloo/content/research/cognition/results.md deleted file mode 100644 index 5eaa4b03..00000000 --- a/ctn_waterloo/content/research/cognition/results.md +++ /dev/null @@ -1,20 +0,0 @@ -title: Results - -**Publications** -Rasmussen, D., Eliasmith, C. (2011). [A neural model of rule generation in -inductive reasoning](/files/Rasmussen%2C%20Eliasmith%20-%202011%20-%20A%20Neural%20Model%20of%20Rule%20Generation%20in%20Inductive%20Reasoning.pdf). Topics in Cognitive Science. 3(1), 140-153. - -Rasmussen, D., Eliasmith, C. (2010). [A neural model of rule generation in -inductive reasoning](http://compneuro.uwaterloo.ca/cnrglab/?q=node/660). In -Richard Cattrambone, Stellan Ohlsson (Ed.), 32nd Annual Conference of the -Cognitive Science Society. Portland: Cognitive Science Society. - -**Papers** -Rasmussen, D. (2009). [A neural model of rule finding in Raven's Progressive -Matrices](http://compneuro.uwaterloo.ca/cnrglab/?q=node/576). Centre for -Theoretical Neuroscience Technical Report CTN-TR-20090601-002. - -**Thesis** -Rasmussen, D. (2010). [A neural modelling approach to investigating general -intelligence](http://compneuro.uwaterloo.ca/cnrglab/?q=node/671). Masters -Thesis. University of Waterloo, Waterloo. diff --git a/ctn_waterloo/content/research/cognition/symbolic-reasoning-in-spiking-neurons.md b/ctn_waterloo/content/research/cognition/symbolic-reasoning-in-spiking-neurons.md deleted file mode 100644 index 82a0d890..00000000 --- a/ctn_waterloo/content/research/cognition/symbolic-reasoning-in-spiking-neurons.md +++ /dev/null @@ -1,106 +0,0 @@ -title: Symbolic Reasoning in Spiking Neurons - - * Talk and paper presented at the 32nd Annual Meeting of the Cognitive Science Society (CogSci 2010) - * by Terrence C. Stewart, Xuan Choo, and Chris Eliasmith; Centre for Theoretical Neuroscience, University of Waterloo - * Slides available in [[pdf](/files/2010-SymbolicReasoning-talk.pdf)] and [[odp](/files/2010-SymbolicReasoning-talk.odp)] - -## Goal - - * To create a neural cognitive architecture - * that is biologically realistic - * (spiking neurons, anatomical constraints, neural parameters, etc.) - * and supports high-level cognition - * (symbol manipulation, cognitive control, etc.) - * Advantages - * Connect cognitive theory to neural data - * Neural implementation imposes constraints on theory - -## Required Components - - * Representation - * Distributed representation of high-dimensional vectors - * Transformation - * Manipulate and combine representations - * Memory - * Store representations over time - * Control - * Apply the right operations at the right time - -## Representation - - * Assumption: Cognition uses high-dimensional vectors for representation - * [2,4,-3,7,0,2,...] - * Forms the top level of many hierarchical object recognition models - * The vector is compressed information - * Different vectors for each thing that can be represented - * including DOG, CAT, SQUARE, TRIANGLE, RED, BLUE, SENTENCE, etc. - -## How can a group of neurons represent vectors? - - * We know how this happens in visual and motor cortex - * (e.g. Georgopoulos et al., 1986) - * Representing a spatial (x,y) location (2-dimensional vector) - * Distributed representation - * Each neuron has a preferred direction - * One direction it fires most strongly for - * Uniformly distributed around the circle - -You do not have the latest version of Flash installed. Please visit this link -to download it: [http://www.adobe.com/products/flashplayer/](http://www.adobe.com/products/flashplayer/) - -[[avi](/files/v/2dencode.avi)] - - * Neural representation - * Using Leaky Integrate-and-Fire (LIF) neurons - * Input current is the dot product of the represented vector with the preferred vector times the neuron gain (randomly chosen) plus a constant bias current (randomly chosen) - * How good is this representations? - - * We know how to go from vector to spikes - * Can we go the other way around? - * Use the post-synaptic current to recover the original vector - * Linear decoding - - * Take a weighted sum of neuron outputs to approximate the original input - * Need decoding weights for optimal estimate - * (see Eliasmith & Anderson, 2003 for calculations) - * Extends to higher dimensions - * Forms the basis of the Neural Engineering Framework - * Decrease error by increasing number of neurons - * Distributed representation - * Robust to noise, neuron loss - -You do not have the latest version of Flash installed. Please visit this link -to download it: [http://www.adobe.com/products/flashplayer/](http://www.adobe.com/products/flashplayer/) - -[[avi](/files/v/2ddecode.avi)] - -## Transformation - -You do not have the latest version of Flash installed. Please visit this link -to download it: [http://www.adobe.com/products/flashplayer/](http://www.adobe.com/products/flashplayer/) - -[[avi](/files/v/communicate.avi)] - -You do not have the latest version of Flash installed. Please visit this link -to download it: [http://www.adobe.com/products/flashplayer/](http://www.adobe.com/products/flashplayer/) - -[[avi](/files/v/convolve1.avi)] - -You do not have the latest version of Flash installed. Please visit this link -to download it: [http://www.adobe.com/products/flashplayer/](http://www.adobe.com/products/flashplayer/) - -[[avi](/files/v/convolve2.avi)] - -## Memory - -## Control - -## Sequential Action - -## Information Routing - -## Question Answering - -## Results - -## Conclusions diff --git a/ctn_waterloo/content/research/cognition_index.md b/ctn_waterloo/content/research/cognition_index.md index fd1f5b6a..bb344aec 100644 --- a/ctn_waterloo/content/research/cognition_index.md +++ b/ctn_waterloo/content/research/cognition_index.md @@ -1,43 +1,20 @@ title: Cognition picture: http://i.imgur.com/DIDdp7P.jpg +category: Applications intro: > Research into neural mechanisms behind many cognitive phenomena, including working memory, syntactic generalization, structured representations, associative memory, and more. -people: - - Daniel Rasmussen -toc: - - Cognitive Robotics - - Large-scale neural and cognitive simulation - - Modelling problem solving in Raven's Progressive Matrices - - - Demo - - Project Status - - Results - - Neural Cognitive Architecture - - Symbolic Reasoning in Spiking Neurons -We have done work on working memory that some may -consider cognitive, but we are now more focused on methods for building -cognitive architectures in general. The architecture we have developed is -called the [Semantic Pointer Architecture](/research/spa.html) -This is a novel cognitive architecture that combines our -interest in VSAs with the vector processing capabilities of the NEF. [Early -work](236) focused on doing inferential symbolic processing in a biologically -plausible, spiking neural network. This work demonstrates syntactic -generalization (generalizing over syntactic structure despite sensitivity to -semantic information) -- what has often be called a hallmark of cognitive -function. +We're all about relating that high level cognitive processes to neurons. -We have now extended this work significantly in two ways: 1. we are addressing -issues of scalability (which seems to be the major strength of not adopting a -classical architecture); and 2. we are incorporating a [biologically plausible -clean-up memory](15) (a kind of associative memory). +We did Raven's. -Details of our work on cognitive modelling are forthcoming in a currently -submitted paper. For now you can read this [summary](202), which was written -for a grant application to NSERC. +We did counting strategies. -You can also watch some demonstration videos related to this work, including -[convolution/binding in neurons](229), [a neural production system](230), and -[high-dimensional representation](228) +We did word search stuff. + +We did planning. + +(Is there something else I'm forgetting? Can I put RL stuff here?) \ No newline at end of file diff --git a/ctn_waterloo/content/research/other/experimental-neuroscience.md b/ctn_waterloo/content/research/constants-constraints/experimental-neuroscience-links.md similarity index 100% rename from ctn_waterloo/content/research/other/experimental-neuroscience.md rename to ctn_waterloo/content/research/constants-constraints/experimental-neuroscience-links.md diff --git a/ctn_waterloo/content/research/other/glossary-of-neuroscience-terms.md b/ctn_waterloo/content/research/constants-constraints/glossary-of-neuroscience-terms.md similarity index 100% rename from ctn_waterloo/content/research/other/glossary-of-neuroscience-terms.md rename to ctn_waterloo/content/research/constants-constraints/glossary-of-neuroscience-terms.md diff --git a/ctn_waterloo/content/research/constants-constraints_index.md b/ctn_waterloo/content/research/constants-constraints_index.md index 69989410..1aeb8922 100644 --- a/ctn_waterloo/content/research/constants-constraints_index.md +++ b/ctn_waterloo/content/research/constants-constraints_index.md @@ -1,8 +1,8 @@ title: Neural Modelling Constants and Constraints picture: static/img/placeholder.png +category: Tools intro: Important information we often refer to when modelling. -people: - - Chris Eliasmith + toc: - Membrane time constant (tau_rc) - Neurotransmitter Time Constants (PSCs) @@ -10,5 +10,9 @@ toc: - Number of Inhibitory Interneurons - Spike Rates - Typical Number of Inputs + - Experimental Neuroscience Links + - Glossary of Neuroscience Terms -We attempt to match our models to the properties of actual neurons. This set of pages is meant to collect important information about actual neurons, along with relevant citations. +We attempt to match our models to the properties of actual neurons. +This set of pages is meant to collect important information about actual neurons, +along with relevant citations and links. diff --git a/ctn_waterloo/content/research/motor-control/1-link-arm-models.md b/ctn_waterloo/content/research/motor-control/1-link-arm-models.md deleted file mode 100644 index 67d412a7..00000000 --- a/ctn_waterloo/content/research/motor-control/1-link-arm-models.md +++ /dev/null @@ -1,14 +0,0 @@ -title: 1 link arm models - -Here are links to some of the different arm models that we've been working with, in both Python and Matlab. - -####Python simulations - -Here is Python code that simulates a simple 1 link arm model. -The model is generated by MapleSim and compiled down to some highly optimized C code (arm.py). - -To compile the MapleSim simulator, download the folder and run "python setup.py build_ext -i". - - - -[1 Link Arm Python code](https://github.com/studywolf/blog/tree/master/OSC/Arms/OneLinkArm) diff --git a/ctn_waterloo/content/research/motor-control/2-link-arm-models.md b/ctn_waterloo/content/research/motor-control/2-link-arm-models.md deleted file mode 100644 index 7ebd9e6e..00000000 --- a/ctn_waterloo/content/research/motor-control/2-link-arm-models.md +++ /dev/null @@ -1,24 +0,0 @@ -title: 2 link arm models - -Here are links to some of the different arm models that we've been working with, in both Python and Matlab. - -####Python simulations - -Here is Python code that simulates a simple 2 link arm model. -There is Python only code (arm_python.py), and a simulation generated from MapleSim and compiled down to some highly optimized C code (arm.py). - -To compile the MapleSim simulator, download the folder and run "python setup.py build_ext -i". - - - -[2 Link Arm Python code](https://github.com/studywolf/blog/tree/master/OSC/Arms/TwoLinkArm) - - -####Matlab simulations -Here is Matlab code that simulates a simple arm model. -To add forces to the arm, you can use the keys 'q' and 'w' for the shoulder and 'o' and 'p' for the elbow. -Should be able to just paste and run this in recent Matlab versions. - - - -[2 Link Arm Matlab code](http://compneuro.uwaterloo.ca/files/2linkarm-matlabcode.m) diff --git a/ctn_waterloo/content/research/motor-control/3-link-arm-models.md b/ctn_waterloo/content/research/motor-control/3-link-arm-models.md deleted file mode 100644 index c01f5e95..00000000 --- a/ctn_waterloo/content/research/motor-control/3-link-arm-models.md +++ /dev/null @@ -1,25 +0,0 @@ -title: 3-link arm models - -Here are links to some of the different arm models that we've been working with, in both Python and Matlab. -This is a 3 link arm model simulation, developed in MapleSim5. - -####Python simulations - -Here is Python code that simulates a simple 2 link arm model. -There is Python only code (arm_python.py), and a simulation generated from MapleSim and compiled down to some highly optimized C code (arm.py). - -To compile the MapleSim simulator, download the folder and run "python setup.py build_ext -i". - - - -[3 Link Arm Python code](https://github.com/studywolf/blog/tree/master/OSC/Arms/ThreeLinkArm) - - -####Matlab simulations - -All necessary files to run in Matlab are included. The files were compiled for a 64-bit system. To run on a 32-bit system, recompile the model using the modelGen.m file. The model currently only runs on PCs. To run, open the 'run' file and hit 'F5'. The number keys will activate/deactivate muscles, and the letters beneath will reset the activation level to 0. Please contact me (Travis) if you have any questions or would like the corresponding MapleSim files. The -files are open for sharing and modification, but shout outs are appreciated. - - - -[3 Link Arm Matlab code](http://compneuro.uwaterloo.ca/files/3LinkArm.zip) diff --git a/ctn_waterloo/content/research/motor-control/6-muscle-3-link-arm-model.md b/ctn_waterloo/content/research/motor-control/6-muscle-3-link-arm-model.md deleted file mode 100644 index 5336f207..00000000 --- a/ctn_waterloo/content/research/motor-control/6-muscle-3-link-arm-model.md +++ /dev/null @@ -1,14 +0,0 @@ -title: 6-muscle 3-link arm model - -Here are links to some of the different arm models that we've been working with, in Matlab. - -####Matlab simulations - -This is a 6 muscle, 3 link arm model simulation for Matlab, developed in MapleSim5. The muscles are an implementation of Hill's muscle model, and the model measurements are from the paper 'On control of reaching movements for musculo-skeletal redundant arm model' by K.Tahara et al. - -All necessary files to run in Matlab are included. The files were compiled for a 64-bit system. To run on a 32-bit system, recompile the model using the modelGen.m file. The model currently only runs on PCs. To run, open the 'run' file and hit 'F5'. The number keys will activate/deactivate muscles, and the letters beneath will reset the activation level to 0. Please contact me (Travis) if you have any questions or would like the corresponding MapleSim files. The files are open for sharing and modification, but shout outs are appreciated. - - - -[3 Link 6 Muscle Arm Matlab code](http://compneuro.uwaterloo.ca/files/6Muscle3LinkArm.zip) - diff --git a/ctn_waterloo/content/research/motor-control/9-muscle-3-link-arm-model.md b/ctn_waterloo/content/research/motor-control/9-muscle-3-link-arm-model.md deleted file mode 100644 index c0894785..00000000 --- a/ctn_waterloo/content/research/motor-control/9-muscle-3-link-arm-model.md +++ /dev/null @@ -1,14 +0,0 @@ -title: 9-muscle 3-link arm model - -Here are links to some of the different arm models that we've been working with, in both Python and Matlab. - -####Matlab simulations - -This is a 9 muscle, 3 link arm model simulation for Matlab, developed in MapleSim5. The muscles are an implementation of Hill's muscle model, and the model measurements are from the paper 'On control of reaching movements for musculo-skeletal redundant arm model' by K.Tahara et al. - -All necessary files to run in Matlab are included. The files were compiled for a 64-bit system. To run on a 32-bit system, recompile the model using the modelGen.m file. The model currently only runs on PCs. To run, open the 'run' file and hit 'F5'. The number keys will activate muscles, and the corresponding letters beneath will reset the activation level to 0. Please contact me (Travis) if you have any questions or would like the corresponding MapleSim files. The files are open for sharing and modification, but shout outs are appreciated. - - - -[3 Link 9 Muscle Arm Matlab code](http://compneuro.uwaterloo.ca/files/9Muscle3LinkArm.zip) - diff --git a/ctn_waterloo/content/research/motor-control/neural-integrator-learning-demo.md b/ctn_waterloo/content/research/motor-control/neural-integrator-learning-demo.md deleted file mode 100644 index 8e570540..00000000 --- a/ctn_waterloo/content/research/motor-control/neural-integrator-learning-demo.md +++ /dev/null @@ -1,3 +0,0 @@ -title: Neural integrator learning demo - -Please download [this example](http://compneuro.uwaterloo.ca/files/NIdemo.zip). It runs in matlab and simulink. (See the readme). diff --git a/ctn_waterloo/content/research/motor-control/optimal-control-of-simple-arm-model.md b/ctn_waterloo/content/research/motor-control/optimal-control-of-simple-arm-model.md deleted file mode 100644 index a5f721f3..00000000 --- a/ctn_waterloo/content/research/motor-control/optimal-control-of-simple-arm-model.md +++ /dev/null @@ -1,16 +0,0 @@ -title: Optimal control of simple arm model - -Feel free to correct, comment, or suggest any thoughts or ideas. - - -Principle Investigator: Travis DeWolf; - - -This is a very simple implementation of a 'hierarachical' controller of a -simple linear 2d arm model. The descending command guides the arm in a -straight line to the target point, the low level controller matches the -descending command using quadratic programming. The target can be moved with -the [w,s,a,d] keys. - - -[Matlab code](/files/optimal%20hier%20w%20linear%20model.zip) diff --git a/ctn_waterloo/content/research/motor-control/simple-3-link-arm-model.md b/ctn_waterloo/content/research/motor-control/simple-3-link-arm-model.md deleted file mode 100644 index b58ab607..00000000 --- a/ctn_waterloo/content/research/motor-control/simple-3-link-arm-model.md +++ /dev/null @@ -1,35 +0,0 @@ -title: Simple 3-link arm model - -To run, download the attached .zip file, extract the .mdl, and past this code -into a script file. This simulation was made by creating a model in MapleSim -4, exporting to C, and then importing into simulink. Created in Matlab -7.7.0471 (R2008b). %% This is a simple 3-link arm model created by designing -an arm in %% MapleSim4, exporting to C, and then importing into Matlab. clear; -close all; % Constants dt = .2; L1 = 3.1; L2 = 2.7; L3 = 1.5; % Initial -torques tau1 = 0; tau2 = 0; tau3 = 0; % Set up initial state of the model % -[ElbowAngle WristAngle WristVelocity ElbowVelocity ShoulderAngle % -ShoulderVelocity] armState = [pi/2 pi/2 0 0 pi/2 0]; % Load in the simulink -model mdl = load_system('MapleSim_TorqueArm1'); -set_param(mdl,'SaveFinalState','on', 'FinalStateName', ['armState'], -'LoadInitialState', 'on', ... 'InitialState',['armState']); [t,x,y] = -sim('MapleSim_TorqueArm1',[0 dt],[],[0 tau1 tau2 tau3]); ch = ''; keydown=0; % -Set up figure and character input figure(1); clf; hold on; grid; set(gca, -'NextPlot', 'replacechildren'); set(gcf,'doublebuffer','on'); -set(gcf,'KeyPressFcn','keydown=1;'); t = 0; % set start time while 1==1 %for i -= dt:dt:endTime t = t+dt; set_param(mdl, 'InitialState',['armState']); -[t1,x,y] = sim('MapleSim_TorqueArm1',[t t+dt],[],[t tau1 tau2 tau3]); %% -Keyboard Control ch = get(gcf,'CurrentCharacter'); if keydown==1 switch(ch) -case 'q' %shoulder left tau1=tau1+.1; case 'w' %shoulder right tau1 = tau1-.1; -case 'e' % set negative! tau1 = -tau1; case 'r' % set to 0! tau1 = 0; case 'o' -%elbow left tau2 = tau2+.1; case 'p' tau2 = tau2-.1; case 'u' % set negative! -tau2 = -tau2; case 'y' % set to O! tau2 = 0; case 'f' tau3 = tau3+.1; case 'g' -tau3 = tau3-.1; case 'h' tau3 = -tau3; case 'j' tau3 = 0; end keydown=0; end -%% Plot the arm and torques S1 = sin(x(1)); C1 = cos(x(1)); C12 = -cos(x(1)+x(2)); S12 = sin(x(1)+x(2)); C123 = cos(x(1)+x(2)+x(3)); S123 = -sin(x(1)+x(2)+x(3)); x1 = L1*C1; y1 = L1*S1; %xy of elbow x2 = x1+L2*C12; y2 = -y1 + L2*S12; %xy of hand x3 = x2 + L3*C123; y3 = y2 + L3*S123; %xy of finger -clf; hold on; axis([-5 5 -5 5]); grid; plot([0 x1],[0 y1]); %plot shoulder to -elbow plot([x1 x2],[y1,y2]) %plot elbow to wrist plot([x2 x3],[y2 y3]) % plot -wrist to finger plot(x3,y3,'ro'); %plot finger % print the torques -text(2,-1,sprintf('tau1=%2.2f',tau1)); text(2,0,sprintf('tau2=%2.2f',tau2)); -text(2,1,sprintf('tau3=%2.2f',tau3)); drawnow(); %% end diff --git a/ctn_waterloo/content/research/motor-control_index.md b/ctn_waterloo/content/research/motor-control_index.md index aeea1cd9..f17f0e54 100644 --- a/ctn_waterloo/content/research/motor-control_index.md +++ b/ctn_waterloo/content/research/motor-control_index.md @@ -1,56 +1,13 @@ title: Motor Control picture: http://compneuro.uwaterloo.ca/files/9Muscle3LinkArmPic.png +category: Applications intro: Developing a biologically plausible framework for models of neural control of movement. -people: - - Travis DeWolf -toc: - - 1 link arm models - - 2 link arm models - - 3 link arm models - - 6-muscle 3-link arm model - - 9-muscle 3-link arm model - - Neural integrator learning demo - - -As part of the research in our lab we are looking at biological mappings of a hierarchical optimal control framework behind motor control in the brain. Travis DeWolf has been working on developing a biologically plausible framework for models of neural control of movement, to read an abbreviated description of this model, please click here: [NOCH framework](http://compneuro.uwaterloo.ca/files/NOCH-1.pdf). - -Recent work in the lab has focused on the development of operational space control and adaptive control models implemented in neurons. - -To read more about motor control discussion you can check out related [motor control blog posts](http://studywolf.wordpress.com/category/motor-control/). - -If you have any questions or comments, please email -[Travis DeWolf](http://compneuro.uwaterloo.ca/people/travis-dewolf.html). - -## **Motor Control Projects** - -### **Arm models** - -As part of building models of the motor control system it was necessary to develop simulations with realistic dynamics to control. Simpler one and two link arm models are common, and easy to find online, but more complicated models quickly become much more complicated to develop. The models here were developed with MapleSim, and they can be accessed both from Python and Matlab. - -[1 link arm models](motor-control/1-link-arm-models.html) - -[2 link arm models](motor-control/2-link-arm-models.html) -[3 link arm models](motor-control/3-link-arm-models.html) - -[6 muscle 3 link arm model](motor-control/6-muscle-3-link-arm-model.html) - -[9 muscle 3 link arm model](motor-control/9-muscle-3-link-arm-model.html) - -### **Controllers** - -#### **Operational space controllers** - -Controllers based on the operational space control framework by Dr. Oussama Khatib, presented in [this paper](http://cs.stanford.edu/groups/manips/images/pdfs/Khatib_1987_IJRA.pdf). An introduction to OSC can be found in [this tutorial](http://www.stanford.edu/~smenon/code/rppbot/MathTutorial_01_RPPBot.htm) by Samir Menon. - -For more discussion and slower walk through of the development of operational space controllers you can check out [related OSC blog posts](http://studywolf.wordpress.com/category/robotics/). - -[Python implementations are available here.](https://github.com/studywolf/blog/tree/master/OSC) - - -Adaptive controllers that are able to learn the dynamics and kinematics of the system being controlled +Control is important -[2 link arm adaptive controllers](motor-control/2-link-arm-adaptive-controllers.html)--> +# Arm +# Quadrocopter diff --git a/ctn_waterloo/content/research/nef_index.md b/ctn_waterloo/content/research/nef_index.md index 55253d5c..46235a50 100644 --- a/ctn_waterloo/content/research/nef_index.md +++ b/ctn_waterloo/content/research/nef_index.md @@ -1,8 +1,7 @@ title: Neural Engineering Framework picture: http://i.imgur.com/BANP6Bh.png?1 +category: Theory intro: The NEF is the main method we use for constructing neural simulations. -people: - - Chris Eliasmith toc: - Overview of the NEF - - Principle 1 diff --git a/ctn_waterloo/content/research/neuromorphic-hardware_index.md b/ctn_waterloo/content/research/neuromorphic-hardware_index.md new file mode 100644 index 00000000..4a4ad9d1 --- /dev/null +++ b/ctn_waterloo/content/research/neuromorphic-hardware_index.md @@ -0,0 +1,6 @@ +title: neuromorphic hardware +category: Applications +picture: static/img/placeholder.png +intro: Hardware inspired by neurons + +Because low power stuff is important \ No newline at end of file diff --git a/ctn_waterloo/content/research/other/artificial-neural-networks-tutorials.md b/ctn_waterloo/content/research/other/artificial-neural-networks-tutorials.md deleted file mode 100644 index 17185e62..00000000 --- a/ctn_waterloo/content/research/other/artificial-neural-networks-tutorials.md +++ /dev/null @@ -1,11 +0,0 @@ -title: Artificial Neural Networks - Tutorials - -### Tangent Propagation - -Tutorial (with a slightly different approach) on the derivation of the tangent -propagation algorithm [here](/files/tangent_prop.pdf) - -### Boltzmann Machine - -Tutorial slides on Boltzmann machine -[here](/files/boltz_tutorial.pdf) diff --git a/ctn_waterloo/content/research/other/philosophy.md b/ctn_waterloo/content/research/other/philosophy.md deleted file mode 100644 index dd15dbeb..00000000 --- a/ctn_waterloo/content/research/other/philosophy.md +++ /dev/null @@ -1,11 +0,0 @@ -title: Philosophy - -[Relevant Publications](?q=biblio/term/philosophy/) in philosophy of -neuroscience, science, and mind. - -Recent work in philosophy of mind has focused on: - - 1. understanding what kind of computer the brain is - 2. considering what the best kind of architecture is for understanding cognitive function - 3. considering the relationship between models and theories in science generally (with consideration of neuroscience specifically) - 4. characterizing mental representation in a neurally informed way diff --git a/ctn_waterloo/content/research/other/society_modelling.md b/ctn_waterloo/content/research/other/society_modelling.md new file mode 100644 index 00000000..beb5ef36 --- /dev/null +++ b/ctn_waterloo/content/research/other/society_modelling.md @@ -0,0 +1,3 @@ +title: Societal modelling + +Insert stuff about Pete's work. \ No newline at end of file diff --git a/ctn_waterloo/content/research/other_index.md b/ctn_waterloo/content/research/other_index.md index 0a420ea6..b40d079a 100644 --- a/ctn_waterloo/content/research/other_index.md +++ b/ctn_waterloo/content/research/other_index.md @@ -1,13 +1,10 @@ title: Other +category: Applications picture: static/img/placeholder.png intro: Forays into other research areas. -people: - - Chris Eliasmith + toc: - - Experimental Neuroscience - - - Glossary of Neuroscience Terms - - Artificial Neural Networks - Tutorials - - Philosophy + - Modelling society - Text classification diff --git a/ctn_waterloo/content/research/perception/a-selective-history-of-visual-attention-presentation.md b/ctn_waterloo/content/research/perception/a-selective-history-of-visual-attention-presentation.md deleted file mode 100644 index f05e9c67..00000000 --- a/ctn_waterloo/content/research/perception/a-selective-history-of-visual-attention-presentation.md +++ /dev/null @@ -1,17 +0,0 @@ -title: A Selective History of Visual Attention Presentation - -Here is a presentation by John Tsotsos (York University), titled "A Selective -History of Visual Attention". **Summary: ** "Recent years have seen a renewed -interest in the study of visual attention. This tutorial aims to present the -state of the art in the computational modeling of visual attention. Starting -from the biology of the primate visual system, we will show how various -aspects of visual attention have been addressed in the computational modeling -literature, and conclude with a more detailed discussion of a number of recent -applications. The half day tutorial covers a broad range of topics from the -basics of primate visual function to applications of visual attention in -computer vision. Most of the major paradigms and issues in selective attention -research are discussed in a systematic way." - -[A Selective History of Visual -Attention](http://www.cse.yorku.ca/~albertlr/attention_tutorial_eccv2008.htm) -[Direct link to slides](http://macro.cse.yorku.ca/~albertlr/ECCV2008Tutorial/ECCV-Overview2008.ppt) diff --git a/ctn_waterloo/content/research/perception/some-approaches-to-vision.md b/ctn_waterloo/content/research/perception/some-approaches-to-vision.md deleted file mode 100644 index e4ea98a4..00000000 --- a/ctn_waterloo/content/research/perception/some-approaches-to-vision.md +++ /dev/null @@ -1,17 +0,0 @@ -title: Some approaches to vision - -Here are links to a bunch of papers that propose models of vision. Some are neurally inspired, others are not. - -Poggio's HMAX: http://riesenhuberlab.neuro.georgetown.edu/hmax.html - -Serre's network : http://web.mit.edu/serre/www/Publications.htm - -Yann LeCun's CNN: http://yann.lecun.com/exdb/publis/index.html#lecun-98 (no. 86) - -AAM (classical paper): http://personalpages.manchester.ac.uk/staff/timothy.f.cootes/ - -AAM Fitting: http://www.ri.cmu.edu/projects/project_448.html - -SIFT: http://www.cs.ubc.ca/~lowe/keypoints/ - -Viola and Jones: [http://www.stat.uchicago.edu/~amit/19CRS/DEA/cascade\_face\_detection.pdf](http://www.stat.uchicago.edu/~amit/19CRS/DEA/cascade_face_detection.pdf) diff --git a/ctn_waterloo/content/research/perception/top-down-visual-feedback-project-status.md b/ctn_waterloo/content/research/perception/top-down-visual-feedback-project-status.md deleted file mode 100644 index 6ea1f63b..00000000 --- a/ctn_waterloo/content/research/perception/top-down-visual-feedback-project-status.md +++ /dev/null @@ -1,11 +0,0 @@ -title: "Top-down visual feedback: Project Status" - -### Tasks to do - - * Implement both types of deep networks for in depth understanding of the model, for future testing and for extension to segmentation. - * Understand the expressive power of RBM and what a 3rd order RBM (Gated BM) brings to the table - * How can feedback connections be used for segmentation? - -### Progress - -**10/16/2009** DBN is terrible at handling noise/occlusions. A DBN which achieves 1.35% error on 10,000 test set achieves 1.48%, 2.55%, 10.57% and 31.4% error respectively as we add white pixels to its 1 to 4 borders below: This is simply due to the fact that DBN is trained on the foreground as well as the background, it's looking for black borders on all digit images! **10/14/2009** Studying and implementing Annealed Importance Sampling for RBMs in order to estimate the partition function as well as the true probability of observed images **9/28/2009** Implementing sparsity to RBM to allow for more robustness to noise, especially on the borders **9/22/2009** DBN recognition rate drops from 1.35% to 32% when a 1 pixel wide white border is added to the test image set **8/23/2009** first GPU implementation for Up-Down algorithm finally finished, speed up is 10x **8/17/2009** GPU implementation for nonlinear neighborhood component analysis finished, speed up allows for learning finish in reasonable time using mini-batch conjugate gradient updates **6/10/2009** Setting up CUDA for GPU processing **6/5/2009** Finished implementation of deep belief network **5/15/2009** - Read up on Mean Field Contrastive Divergence learning, testing a 3rd order sparse (weight matrix) BM model for segmentation. **5/12/2009** - Investigating the representational abilities of RBM. Some test result show that RBM still have trouble encoding 's' shaped 2D distributions; maybe need nonparametric energy function as well as learn non-spherical Gaussian visible units. **5/7/2009** - Investigating feature selection and segmentation of objects in images. DBN or other generative models model the entire input space, which is 28x28, but often background pixels are just noise and shouldn't be modeled. Human can ignore the background and just learn the variations of the foreground without a teacher segmenting out which regions to learn. Computer Vision can not. using a coherence model (hack before a Bayesian model), with backward "greedy piecewise" feature selection, the noisy 2's with background and gaussian noise is found to have the masks on the right, which is similar to the true mask on the left side. ![](/files/background_noise.png) Notes on further improvement: 1. use low entropy as a constraint 2. robust statistics (rid of outliers - salt & peppers noise) 3. why(if) is it convex loss function for feature selection optimization problem 4. integrate with a teacher writing the digit 5. or better yet, maybe this is cheating, but optimize the parameter of the model to match some supervised masks for each digit The problem here is that for the class of 2's, they are different, whereas in this example the 2's are all the same. Now the trick is to use invariance in CNN or DBN to solve this problem. **4/28/2009** - Debugging finished, all the partial derivatives of the network (weights as well as nodes) are very close to the numerical counterparts. Now, training must be done to see if Levenberg Marquadt algorithm is needed or if it is enough to stick with plain and simple gradient descent. LeCun argues against conjugate gradient, but conjugate gradient is much faster. **4/26/2009** - Debugging continues and adding code to preprocess the input (MNIST digits) There are several ways to go about this. **4/24/2009** - Old ideas just keep repeating themselves. In [this paper](http://yann.lecun.com/exdb/publis/pdf/lecun-98.pdf), where LeNet 5 is described, the approach to learn F6 layer activation is reminiscent of the recent nonlinear embedding methods! **4/23/2009** - Begin implementing a Conv Neural Net (LeNet 5), which is Type II of the deep networks. What is unique about the CNN is that it uses backpropagation to fine tune the weights in the earlier layers. This is not typically seen in other hierarchical vision models. (Regarding biologically plausibility of backprop: Hinton doesn't believe evolution isn't able to come up with a way to tune lower layer weights if it helps improve recognition at an higher layer [ref](http://www.cs.toronto.edu/~hinton/absps/montrealTR.pdf). Another advantage of CNN is its weight sharing and downsampling ideas. But this makes implementation slightly complicated. CNN is also a misnomer, since all that is necessary is filtering or dot product. I'm guessing the reason it was named "Convolution" is for the property of filtering across the 2D image. In image processing, convolution and filtering (correlation) is often the same since the kernel is symmetric. diff --git a/ctn_waterloo/content/research/perception/top-down-visual-feedback.md b/ctn_waterloo/content/research/perception/top-down-visual-feedback.md deleted file mode 100644 index 18a653cc..00000000 --- a/ctn_waterloo/content/research/perception/top-down-visual-feedback.md +++ /dev/null @@ -1,33 +0,0 @@ -title: Top-down visual feedback - -Feel free to correct, comment, or suggest any thoughts or ideas. - -Principle Investigator: Charlie Tang; [Project Status](?q=node/523) - -## Project: Top-down feedback for segmentation in vision - -Recent advances in "deep" hierarchical modeling inspired by the cortex are -exciting. There are two main types of deep architectures. One is based on -generative, probabilistic modeling of the sensory data (Hinton's group). The -other is of a feedforward discriminative and/or sparse coding type of model -(Le Cun's group). Both can be adapted to a semi-supervised framework as well. - -There are massive feedback connections present in the cortex. Deep belief -network use feedback as part of the likelihood function p(v|h) as well as -setting a prior on h. Therefore, it uses feedback to "imagine" sensory data. - -There are still questions left to be asked. First, is the brain really a -probabilistic model with each neural populations representing one random -variable? And what about top-down projections which skip down multiple layers? -Second, for recognition, most existing deep networks use 1 forward propagation -in a discriminative framework. The fact that no feedback is incorporated in -the model is often justified by the task at hand, which is simple -categorization detection, or recognition. Though the jury is still out on -whether recognition needs feedback or not, it is likely to be the case that -segmentation of objects/digits/faces need feedback connections. This is the -main focus of the project. - -## Learning about deep learning - Questions - - * what is the expressiveness of a simple RBM model, what is the complexity of the pdf it can model? - * why does pretraining (unsupervised modeling of data distribution) help fine tuning in a deep feedforward network? diff --git a/ctn_waterloo/content/research/perception_index.md b/ctn_waterloo/content/research/perception_index.md index 5b170c46..dc1388e7 100644 --- a/ctn_waterloo/content/research/perception_index.md +++ b/ctn_waterloo/content/research/perception_index.md @@ -1,64 +1,20 @@ title: Perception picture: http://i.imgur.com/JR9qfHL.png?1 +category: Applications intro: Visual recognition and processing, auditory processing, etc. -people: - - Eric Hunsberger - - Trevor Bekolay -toc: - - A Selective History of Visual Attention Presentation - - Some approaches to vision - - Top-down visual feedback - - - "Top-down visual feedback: Project Status" [Relevant publications](?q=/biblio/term/vision/) from the lab on vision. -## Our vision projects +## Previous work - * [Understanding the role of feedback](?q=node/522) - * [An attentional model]() +Trevor's auditory processing. -## **Visual Recognition and Processing** +Aaron's touch processing. -Techniques inspired by biological vision are the state of the art in various -application domains +ImageNet in spiking neurons. - 1. SIFT, GLOH: object recognition - 2. Convolution Neural Network: handwriting digit recognition - 3. Standard model: fast feedforward detection task +That other fancy vision stuff Eric did. -We seek to use biological inspirations and hierarchical architectures to -attack the problem of achieving better recognition performance. +## Current projects -Specific projects currently include - - * Most feedforward visual models contain engineered or pre-built spatial arrangement, e.g. in the form of receptive fields of the complex cells. We ask if it is possible to learn these arrangements using sensory stimulus. - - * It is well known that class-specific visual data, such as face images of a person under various transformations, lies on a low dimensional manifold embedded in high dimensional space. We ask if it is possible to use hierarchical models to help find functions which project a new sensory input onto class-specific manifolds. - -## **Useful Links and References** - - * Top 100 papers in [vision science](http://www.psych.neu.edu/faculty/y.petrov/most-important-vision-papers.html) - -### Visual Cortical Models - - * The Standard Model: [here](http://web.mit.edu/serre/www/Publications.htm) - -### Computer Vision - - * SIFT:[here](http://www.cs.ubc.ca/~lowe/keypoints/) - - * Viola and Jones:[here](http://portal.acm.org/citation.cfm?id=966458) - - * AAM (classical paper): [here](http://personalpages.manchester.ac.uk/staff/timothy.f.cootes/) - - * AAM Fitting: [here](http://www.ri.cmu.edu/projects/project_448.html) - -### Coding/Representation - - * The Field Lab: [here](http://redwood.psych.cornell.edu/index.php) - -### Machine Learning - - * Yann LeCun's website: [here](http://yann.lecun.com/exdb/publis/index.html) - -### Attention +Eric's more comprehensive model of the visual system. diff --git a/ctn_waterloo/content/research/philosophy_index.md b/ctn_waterloo/content/research/philosophy_index.md new file mode 100644 index 00000000..79bcb4ef --- /dev/null +++ b/ctn_waterloo/content/research/philosophy_index.md @@ -0,0 +1,14 @@ +title: Philosophy +picture: static/img/placeholder.png +category: Applications +intro: Thinking about the Brain + +[Relevant Publications](?q=biblio/term/philosophy/) in philosophy of +neuroscience, science, and mind. + +Recent work in philosophy of mind has focused on: + + 1. Understanding what kind of computer the brain is + 2. Considering what the best kind of architecture is for understanding cognitive function + 3. Considering the relationship between models and theories in science generally (with consideration of neuroscience specifically) + 4. Characterizing mental representation in a neurally informed way diff --git a/ctn_waterloo/content/research/software/advanced-nengo-tips-and-tricks.md b/ctn_waterloo/content/research/software/advanced-nengo-tips-and-tricks.md deleted file mode 100644 index 4599dbfe..00000000 --- a/ctn_waterloo/content/research/software/advanced-nengo-tips-and-tricks.md +++ /dev/null @@ -1,115 +0,0 @@ -title: Advanced Nengo tips and tricks - -This reference sheet gathers some extra information that may be useful for -more advanced users of Nengo. Specifically, there is information on: - User- -defined functions - Function inputs (defining a wide variety of functions to -drive a network) - More precise control over tuning curves (with preferred -direction vectors) - -## User-defined functions - - * When creating a function input or defining the function being computed by a decoded origin, you can type in standard expressions for the function. - * For function inputs, the variable you write the function over is always x0, which is time. - * For decoded terminations, you can have multi-dimensional functions, and the variables are x0, x1, ... - * The syntax is typical: +,-,*,/, cos, sin, ln, exp, sqrt, max, and others. The list of all functions registered to the parser is provided when you first create a function input of type 'user-defined function' in the pull-down menu. - -## Function inputs - -For most situations, we want to define inputs that change over time. Here we -are basing the example on the network constructed in the [Building a -Feedforward network (Part 2)](?q=node/592) tutorial. The methods are the same -for all networks. - - * For many common types of inputs, we can use the Configure interface. - * Right-click on the second function input in the model and select Configure. - * Go to functions->Constant function - -![](/files/p3-10.png) - - * Right-click on Constant function and choose Replace - * Use the drop-down box to select SineFunction - * Press the right-arrow button twice to see the constructor that allows you to set amplitude and omega (frequency) - -![](/files/p3-11.png) - - * Double-click on amplitude and set it to 10 - * Double-click on omega and set it to 5 - -![](/files/p3-12.png) - - * Click on Create, OK, and Done. - * Run the simulation and plot the result. You may also wish to add probes for the two function inputs. - -![](/files/p3-14.png) - -![](/files/p3-13.png) - - * We can also create functions using the script console - * Click on an function input so that it is highlighted in yellow. - * Press Ctrl-P to go to the script console - * Enter the following command: - -` that.functions=[ca.nengo.math.impl.SineFunction(amplitude=10,omega=5)] ` - - * This creates the same function as done through the GUI above - -![](/files/p3-15.png) - - * There are a variety of other functions available - -` ca.nengo.math.impl.PiecewiseConstantFunction([0.25,0.5,0.75],[0,5,0,-5]) ` - -![](/files/p3-16.png) - -` ca.nengo.math.impl.LinearCurveFitter.InterpolatedFunction([0,0.2,0.4,0.6,0.7 -,1.0],[0,5,4,0,-2,0]) ` - -![](/files/p3-17.png) - - * For example, consider multiplying the following two functions together - * Select the first function input, go to the script console, and enter - -` that.functions=[ca.nengo.math.impl.PiecewiseConstantFunction([0.3,0.6],[0,5, -0])] ` - - * Select the second function input, go to the script console, and enter - -` that.functions=[ca.nengo.math.impl.SineFunction(amplitude=10,omega=20)] ` - - * Run the simulation and plot the inputs and results - -![](/files/p3-18.png) - -![](/files/p3-19.png) - - * You can also define your own functions using Python code - * Since this will involve a few lines of code, we can use the script editor (or any text editor) - * Go to View->Open Script Editor - * Choose File->Open->myfunction.py ` class MyFunction(ca.nengo.math.impl.AbstractFunction): def map(self,x): t=x[0] if t<0.2: return 0 return -30_t_t+20*t ` - * This is a basic definition of a Python class inherting from AbstractFunction. It defines the function that is 0 for t<0.2 and -30t2+20t otherwise. - * To use this, close the script editor and return to the script console - * type “run myfunction.py”. This will define the new class. We can now use it in the same way as the other functions. - -` that.functions=[MyFunction(1)] ` ![](/files/p3-20.png) - -## Setting preferred direction vectors - -The preferred direction vectors (a.k.a. encoding vectors) for ensembles are -normally randomly chosen from a unit sphere. We may wish to configure these to -be more consistent with known neural properties. - - * The easiest way to set preferred direction vectors is to click on the 'Advanced' tab when creating a population of neurons. Changing the 'Encoding distribution' slider determines how clustered neurons are along the dimensions of the vector space being represented. - * More fine grained control of encoders can be done with a script or with the script console. - * The following code allows us to explicitly specify encoding vectors. This assumes that you have constructed a population of 200 2-dimensional neurons, and it is selected. - -` import random - -class MyVectors(ca.nengo.util.VectorGenerator): def -genVectors(self,number,dimensions): base=[[1,1],[1,-1],[-1,1],[-1,-1]] -vectors=[] while len(vectors) ` -that.ensembleFactory.encoderFactory=MyVectors() that.neurons=200 ` - - * In this case, the vectors are randomly chosen from the set [1,1],[1,-1],[-1,1],[-1,-1]. This is optimal for multiplication (see the [Building a Feedforward network (Part 2)](?q=node/592) tutorial). - * Note that we have to set the number of neurons so that new neurons are created using the new encoding vectors. - - diff --git a/ctn_waterloo/content/research/software/building-a-controlled-integrator.md b/ctn_waterloo/content/research/software/building-a-controlled-integrator.md deleted file mode 100644 index 60349f21..00000000 --- a/ctn_waterloo/content/research/software/building-a-controlled-integrator.md +++ /dev/null @@ -1,56 +0,0 @@ -title: Building a controlled integrator - -This tutorial assumes you have completed (or at least read through) the -[Building a neural integrator](?q=node/588) tutorial. - -The controlled integrator is a more sophisticated computation, that implements -a nonlinear dynamical system. It essentially allows the inputs to control how -much integration the network performs, on-the-fly. It can be thought of as a -tunable low-pass filter. This model can be directly loaded by opening -[controlled integrator.nef](/files/controlled integrator.nef.zip) within Nengo, or -you can build it yourself by following these steps. - -1. Create a 2-dimensional neural ensemble with 500 neurons and a radius of 2. - -2. Create three terminations - - * **input**: time constant of `0.05`, dimension 0f `1`, transformation matrix of `[0.5 0]`. This acts the same as the input in the previous model, but only affects the first dimension. - * **control**: time constant of `0.01`, dimension of `1`, with a transformation matrix of `[0 1]`. This stores the input control signal into the second dimension of the ensemble. Note that it uses a faster time constant, since we want to be able to tune the filter quickly. - * **feedback**: time constant of `0.05`, dimension of `1`, with a transformation matrix of `[1 0]`. This will be used in the same manner as the feedback termination in the previous model. - -3. Create a new origin that multiplies the values in the vector together - -![](/files/p4-9.png) - - * Right-click on the population and select **Add decoded origin** - * This is a `1` dimensional output, with a **User-defined Function** of `x0*x1` (this effectively multiplies the first and second inputs, hence allowing one to control/gate the other). Note that no actual multiplication occurs in the neurons, instead this is a projection from a two-dimensional to a one-dimensional space. This may take a moment to configure. - -4. Create two **Function inputs** called **input** and **control**. - - * Start with **Constant functions** with a value of `1` - * Use the script console to set the **input** function by clicking on it and entering the following input function. - -` that.functions=[ PiecewiseConstantFunction( [0.2,0.3,0.44,0.54,1.3,1.7] , -[0,0.5,0,-1.0,0,0.5,0 ])] ` - - * Use the script console to set the **control** function by clicking on it and entering ` that.functions=[ PiecewiseConstantFunction( [0.9] , [1,0.5] )] ` - -5. Connect the network - - * Connect the **input** function to the **input** termination, the **control** function to the **control** termination, and the **product** origin to the **feedback** termination. - -6. Run the simulation and plot results as before - - * Add a probe to the **X** representation of the integrator and the **origin** of the function input - * Run the simulation for 2s. Plot X. If you select both the input and integrator data (via Ctrl-clicking) and plot them together through the right-click menu, they will be on the same graph. - * For the first 0.9 seconds, the network will act as an integrator (a control signal of 1). After this, the control signal will drop to 0.5, which will cause it to act as a highly leaky integrator, or a low-pass filter. - - * We can improve the performance of this model by increasing the number of neurons. On the right it is run with 5000 neurons in the ensemble for 1s. - - * WARNING: 5000 neurons take a long time to generate (~5 minutes) on a good laptop. - -![](/files/p4-11.png)![](/files/p4-10a_0.png) - - * You can also run the simulation interactively: right-click the background and select **Interactive plots**. See the [interactive plots reference sheet](?q=node/594). - - diff --git a/ctn_waterloo/content/research/software/building-a-feedforward-network-part-1.md b/ctn_waterloo/content/research/software/building-a-feedforward-network-part-1.md deleted file mode 100644 index dc4c92c4..00000000 --- a/ctn_waterloo/content/research/software/building-a-feedforward-network-part-1.md +++ /dev/null @@ -1,67 +0,0 @@ -title: Building a feedforward network (part 1) - -In part 1 of this tutorial we will build an extremely simple circuit in Nengo, -which simply communicates a single scalar value from one population of neurons -to another (a communication channel). We will then implement linear and -nonlinear transformations of that value in a feedforward network in part 2. In -part 3, we will look at more complex representations (vectors) and more -sophisticated nonlinear transformations. - -1. Create two populations of neurons - - * Right-click on the background of the Nengo world and create a **New network** called `feedforward network`. - * Right-click inside **feedforward network** and select **create new-> NEFEnsemble**. - * Set the name to `A`, the number of nodes to `100`, radius to `1`, dimension to `1`, and select **LIF Neurons**. Click **Ok**. - * Do the same to create a `B` ensemble. - * Right-click on either **A** or **B** and select **Plot->Constant rate responses**. This shows the tuning curves of the neurons. - -2. Create terminations on the receiving population - - * Connections between ensembles are built using **origins** and **terminations**. An origin from one ensemble can be connected to a termination on another. - * Right-click on the **B** ensemble and select **Add decoded termination**. Set the name to `input`. Set the input dimension to `1` and click **Set weights**1`. - * Set tauPSC to `0.01`. This synaptic time constant differs according to which neurotransmitter is involved. 10ms is a reasonable time constant for AMPA (5-10ms). - -3. Connect the populations together - -![](/files/p2-5.png) - - -![](/files/p2-5cropped.png) - - * Every ensemble automatically has an origin called **X**. This is an origin suitable for building any linear transformation. - * Click and drag from the **X** origin from **A** to the termination on **B**. This will create the desired projection between the neurons in the populations. This calculates the connection weights between all neurons in both populations necessary to compute the function you have defined (which is B=1*A at the moment). - -4. Add an input function to drive the neurons - - * Right-click inside the **Network Viewer** and choose **Create new->Function input**. Give it the name `external input`. Set its output dimensions to `1`. - * Press **Set Function** to define the behaviour of this input. Select **Constant Function** from the drop-down list and then press **Set** to define the value itself. For this model, set it to `0.05`. - * Add a termination on the first neural ensemble **A** following the steps above and connect the input function to that ensemble by dragging. - -5. Collect some data - - * Before running the simulation, we need to identify which aspects of the simulation we want to save for later analysis. The main method for doing this is via **Probes**. For this case, we will add two probes: one to record from the **external input** and one to record from the **B** ensemble. - * Right-click on the **external input** and select **Add probe->input**. A triangle will appear indicating the presence of the probe. - * Right-click on the **B** ensemble and select **Add probe->X - Function of NEFEnsemble state**. - * Right-click on the **B** population and select **Collect Spikes** to record the neuron spike trains. - -6. Run the simulation - - * Right-click on the **Network Viewer** background and choose **Run feedforward network** - * Set start time to `0`, step size to `0.001` (for a 1ms time step), and end time to `1`. For convenience, enable the setting to open the data viewer after simulation. Click OK. When finished, the **Data Viewer** panel will appear on the left. - * Expand the **Data Viewer** tree by clicking on the entries until the two probes are shown - * Double-click **Spikes Pattern** to see the spikes generated by the neurons. - * Double-click on the **input** probe to show that the input stays at 0.5 over the whole simulation - * Double-click on the **X** probe to show what value is encoded by the second neural ensemble over time. ![](/files/p2-14.png) - * To compare these plots, select both probes by ctrl-clicking to on the probes in the **Data Viewer** tree. Now right-click and select **Plot data together**. - * You can also interact with this model in real time. Right-click on the **Network Viewer** background and select **Interactive plots**. - * Press the **play** button (bottom right) and slide the control up and down. The graph will show the output caused by the changing input. Other plots are available from this screen by right-clicking network elements. See the [interactive plots reference sheet](?q=node/594) for more details. - -## Congratulations, you're done! - -You've finished building a simple neural communication channel. If you want to -increase the accuracy, you can increase the number of neurons in the -populations (the more neurons you choose, the more patient you will have to be -while they are generated). However, brains do more than just represent their -input; parts 2 and 3 show how to actually do some transformations. - - diff --git a/ctn_waterloo/content/research/software/building-a-feedforward-network-part-2.md b/ctn_waterloo/content/research/software/building-a-feedforward-network-part-2.md deleted file mode 100644 index 359781b7..00000000 --- a/ctn_waterloo/content/research/software/building-a-feedforward-network-part-2.md +++ /dev/null @@ -1,82 +0,0 @@ -title: Building a feedforward network (part 2) - -This tutorial assumes you've completed [Building a feedforward network (part -1)](?q=node/591). - -## Scaling the input signal - -1. Right-click on the **input** to the **B** population and select -**Configure**. - -2. At the bottom of this panel double-click **transform**. This is the weight -you set to 1 when constructing the termination. Change this value to `0.5` to -scale the input down to half its original value. - -3. Re-run the simulation (or go to **interactive plots**), and see that -changing this value scales the input as expected. - -## Combining inputs linearly - -![](/files/p2-20.png) To add two values, you must create another -termination on the **B** population and project to it as well. Before doing -this, set the **A** to **B** transformation back to 1. - -1. Create a termination on the **B** population called `input 2` with weight -`1`. - -2. Create a new ensemble **C**. - -3. Create a projection from **C**'s **X** origin to **input 2** by dragging. - -4. Create a new constant **Function input** and set its value to `-0.7`. - - * Add an input termination on **C** and connect the **Function input** to the **C** ensemble. - * Add a probe to the new **Function input**. - * Run the simulation and plot the values for the three probes ![](/files/p2-21.png) - * The **X** value for the **B** probe should indicate the result of `0.5-0.7=-0.2` (A+C=B). Note: This looks noisier than before because of the scale of the plot. - -## Congratulations, you can build linear brains! - -You can now compute any linear transformation in a neural circuit. Exactly the -same steps as above can be followed for vector representations, where the -transformation weight becomes a matrix. For more on vector representation, see -the [motor cortex](?q=node/595) tutorial. - -## Nonlinear transformations - -Of course, nonlinearities are essential for interesting computation. We begin -with simple examples here before moving on to more interesting examples in -part 3. - -1. Revert the simulation to a communication channel - - * Right-click on the **C** population and select **remove model**. Answer **Yes** to delete the population. - * Do the same to the the second **Function input** and the **input 2** termination on the **B** population (right-click just on the termination). - -2. Define the nonlinear function you want to compute - - * For one-dimensional ensembles, we can calculate arbitrary 1-dimensional functions (e.g. f(x)=x2, f(x)=θ(x) (thresholding); f(x)=√x, etc.). - * To perform a non-linear operation, we need to define a new origin. Right-click on the **B** ensemble and select **Add decoded origin**. Set the name to `square` and dimension to `1`. - * Click on **Set Functions**, select **User-defined Function** and press **Set**. - * For the Expression, enter `x0*x0`. We refer to the represented value as `x0`. When when have vectors the values are `x0`, `x1`, `x2`, etc. Press **Ok**, **Ok**, and **Ok**. - -3. Collect data from the new output - - * Add a probe for the new origin by right-clicking on the ensemble and selecting **Add probe->square - Function of NEFEnsemble state** - -4. Set the input function to something useful - - * Click on the input function that is currently a constant value. You can change this in two ways, through the configure panel or the script console. Let's do the second for variety. ![](/files/p3-9d.png) - * Open the **Script Console** from the menu bar (under **View**). - * With the function input selected type the following in the console: - -` that.functions=[InterpolatedFunction([0,1],[-1,1])] ` - - * This creates an input that starts at -1 and grows linearly to 1 - -5. Run the model and view the probe data. The output of the network will -approximate x2. Note that there is an initial start-up transient in the graph -(shown above). You can also use the **Interactive plots** to manually control -the input. See the [interactive plots reference sheet](?q=node/594). - - diff --git a/ctn_waterloo/content/research/software/building-a-feedforward-network-part-3.md b/ctn_waterloo/content/research/software/building-a-feedforward-network-part-3.md deleted file mode 100644 index 37a507a2..00000000 --- a/ctn_waterloo/content/research/software/building-a-feedforward-network-part-3.md +++ /dev/null @@ -1,52 +0,0 @@ -title: Building a feedforward network (part 3) - -In parts 1 & 2 of this tutorial we determined how to construct a network to -perform arbitrary linear transformations, and nonlinear transformations of one -variable. In part 3, we extend this to compute nonlinear transformations of -any number of variables. - -1. Construct the needed populations - - * In a clean Nengo world right-click and select **New network**. Construct three populations of neurons (NEFEnsembles), **A**, **B** and **Z**, that are 1 dimensional with 100 neurons each. **A** and **B** should have a radius of 10 and **Z** should have a radius of 100. The radius is the range these neurons are optimized to represent. - * Construct an **H** population with 2 dimensions, 200 neurons, and a radius of 10. - -2. Add input functions - - * Create two Constant input functions with 1 dimension each and values of 8 and 5. - -3. Add terminations to the populations - - * Add input terminations to **A**, **B**, and **Z** with time constants of 0.01 (AMPA) and a weight of 1. - * Add two input terminations to the hidden layer, **H**. For each one, the input dimension is 1. For the **A** input, use **Set Weights** to make the transformation be `[1 0]`. For the **B** input, use **Set Weights** to make the transformation be `[0 1]`. - -4. Create the nonlinear origin - - * Now we need to create a new origin that will estimate the nonlinear function between the two values stored in the **H** ensemble. For this example we'll just compute the product. - * Right-click on the **H** ensemble and select **Add decoded origin**. Set the name to `product`. Set Output dimensions to `1`. - * Click on **Set Functions**. Select **User-defined Function** and press **Set**. For the Expression, enter `x0*x1`. - * Press **OK**, **OK**, and **OK** to finish creating the origin. - -5. Connect the network ![](/files/p3-7.png) - - * Connect the two function inputs to **A** and **B**, respectively. - * Connect **A** and **B** to the appropriate **H** terminations. - * Connect the **product** origin of **H** to **Z**. - -6. Collect data and run the simulation - - * Add a probe to the **Z** ensemble by right-clicking on it and selecting **Add probe-> X - Function of NEFEnsemble state**. Run the simulation. - * The result should be approximately 40. - * Performance can be improved by increasing the number of neurons in the ensembles. The number of neurons can be adjusted using the Configure option (right-click on the ensemble) or the script console (click on the ensemble to select it and then open the console and enter `that.neurons=200`). - * WARNING: large numbers of neurons (>500) can take a long time to calculate. - * This graph uses 500 neurons for the one-dimensional ensembles and 1000 for the combined ensemble ![](/files/p3-9.png) - * Interact with the network by right-clicking and choosing **Interactive plots**. In this new window, right-click to show controls for changing the input and live plots of spikes, decoded values, voltages, etc. See the [interactive plots reference sheet](?q=node/594). - -## Congratulations you can build nonlinear brains! - -By combining the two parts of this tutorial, you can build neural models that -(attempt to) compute any linear or nonlinear function of arbitrarily high- -dimensional vectors. Of course, these are feedforward only. For examples of -recurrent models, see the linear [neural integrator](?q=node/588) and -nonlinear [controlled integrator](?q=node/589) tutorials. - - diff --git a/ctn_waterloo/content/research/software/building-a-neural-integrator.md b/ctn_waterloo/content/research/software/building-a-neural-integrator.md deleted file mode 100644 index 13f4735b..00000000 --- a/ctn_waterloo/content/research/software/building-a-neural-integrator.md +++ /dev/null @@ -1,70 +0,0 @@ -title: Building a neural integrator - -Neural integrators are often used in sensorimotor systems, with perhaps the -best known example being eye control. However, they are also important for -path integration, optimal inferencing, noise supression, working memory, and -many other biologically relevant computations. Integrators essentially extend -the time constant of their elements (neurons) by using recurrent feedback. We -can show that for a neural ensemble to approximate integration, it needs to -connect to itself with an identity transformation (i.e. x = Ix), and have an -input weight of τ, which is the synaptic time constant of the neurotransmitter -used on the input. This integrator model can be directly loaded by opening -[neural integrator.nef](/f/neural integrator.nef.zip) within Nengo. -Alternatively, follow these steps to build it yourself. 1. Create a one- -dimensional ensemble called **Integrator** with 225 neurons. - From the file -menu, select **New Network** and provide the name `Integrator` - Right-click -on the background of the network window and select **Create new->NEFEnsemble** -- Enter the parameters: `225` neurons, radius of `1`, dimension of `1`. 2. Add -two terminations with synaptic time constants of 0.01s. Call the first one -`input` and give it a weight of `0.01`. Call the second one `feedback` and -give it a weight of `1`. - Right-click on the ensemble and select **Add -decoded termination** - Enter the parameters above. For the weight, set the -input dimension to `1` and click on **Set weights** to enter the value. - -Repeat for the second termination (**feedback**) 3. Create a new **Function -input** using a **Constant Function** with a value of `1`. - Right-click on -the background of the **Network Viewer** and select **Create new->Function -Input** - Click **Set functions** and choose or set the appropriate values 4. -Connect the network - Connect the Function input **origin** to the **input** -termination by dragging - Connect the **X** origin of the ensemble back to its -own **feedback** termination by dragging 5. Gather data - Right-click the -population and select **Add probe->X - Function of NEFEnsemble state** - -Right-click the population and select **Collect spikes** to gather a spike -raster - You can add any other probes of interest, including on individual -neurons. You see the neurons by double-clicking the population. 6. Run the -simulation ![](/files/p4-1.png) - Right-click on the background and -run the simulation for 1 second with a time step of 1ms (0.001) - Plot the -results by double-clicking the probe of interest in the **Data Viewer**. - As -expected, the final result of the representation in the X probe is -approximately 1 (the integral of 1 from 0 to 1). - To adjust the input in real -time, right-click on the background and select **Interactive plots**. Open -plots by right-clicking on the objects and add a control slider by right- -clicking on the function input. All items can be moved and resized by -dragging. See the [interactive plots reference sheet](?q=node/594). -**Congratulations, you're done!** The remainder of the tutorial demonstrates -variations on the basic integrator. ## Representation Range - Run the -simulation again, but adjust the end time to be 2.0s. - Note that the value -reaches slightly above 1 and then stops increasing. This is due to the radius -of the ensemble: it cannot accurately represent values outside of [-1,1] -because the neurons are saturating. - Adjust the radius of the ensemble to 1.5 -using either the Configure interface (right-click the **integrator** and -select **configure**, then change the **radii** option) or the script console -(**View->Toggle script console**, select the population and type -`that.radii=[1.5]` into the console). Run the model again and it integrates -longer before saturating. ![](/files/p4-8.png) ## More interesting -input - We can also run the model with a more complex input. Change the -Function input using the following command from the script console (after -clicking on the function input) ` that.functions=[PiecewiseConstantFunction([0 -.2,0.3,0.5,0.6,0.8,0.9],[0,5,0,-10,0,5,0])] ` - Run this simulation for 1s. ## -Changing the number of neurons & synaptic time constants - Note that there may -be a significant amount of drift in the representation. This can be reduced by -increasing the number of neurons. This can be done in the configure menu -(right-click the **integrator**, and select **configure**). Double-click -**neurons** and enter the number you'd like. WARNING: values much over 1000 -may be slow to generate, although you can run simulations of millions of -neurons on workstations. - You can also reduce drift by using a different -neurotransmitter. - Change the input termination to have a tau of 0.1 (100ms: -NMDA) and a transform of 0.1. Also change the feedback termination to have a -tau of 0.1 (but leave its transform at 1). This can be done by right-clicking -the termination and selecting **configure**. - - diff --git a/ctn_waterloo/content/research/software/building-motor-cortex-vector-representations.md b/ctn_waterloo/content/research/software/building-motor-cortex-vector-representations.md deleted file mode 100644 index 1aa753ec..00000000 --- a/ctn_waterloo/content/research/software/building-motor-cortex-vector-representations.md +++ /dev/null @@ -1,63 +0,0 @@ -title: Building motor cortex (vector representations) - -This tutorial focuses on building networks with higher-dimensional -representations. Unlike the simple [communication channel](?q=node/591/) or -[neural integrator](?q=node/588), many parts of cortex are best characterized -as using vector (as opposed to scalar) representations. - -Perhaps the best known example of vector representation in neuroscience is -found in the work of Georgopoulos and colleagues in motor cortex. In this -tutorial we build and explore representations like that found in motor cortex. - -In these experiments, Georgopoulos et al. found that neurons in primary motor -cortex had **preferred directions** of arm movement. In the 2D planar -movements that were being executed, the movement direction that caused the -highest activation of different neurons (i.e. the **preferred direction**) -were distributed about evenly around the starting point of the arm. Here we -construct a population of neurons with this kind of response. - -1. Create a network - - * Right-click on the background of the top-level Nengo world and select **New network**. Call it `motor cortex`. - -2. Create some cortical neurons - - * Right-click in the **Network Viewer** and select **Create new->NEFEnsemble**. - * Set the name to `motor cortex`, the number of nodes (neurons) to `100`, and the number of dimensions to `2`. - * The default method for generating preferred direction vectors in Nengo is to choose them from an even distribution around the unit circle (as in motor cortex). (To change this, you can click the **Advanced** button, but for now the default is appropriate). - * Click **Ok**. - -3. Create terminations on the neurons - - * To accept input, terminations need to be created on the population. Right-click the **motor cortex** population and select **Add decoded termination**. Set its name to `input` and tauPSC to `0.01`, indicating a 10ms time constant for the post-synaptic current (AMPA receptors). - * When adding a termination, the input dimension can be adjusted. This defines the shape of the transformation matrix for the termination, allowing for projections that change the dimension of the data. In this example, one 2-dimensional value will be provided (i.e. the reach target location). - * Set the dimensions to `2` and click **Set Weights**. Input the 2-D identity matrix `[1 0; 0 1]`. This simply takes the 2D input and maps it into each of the dimensions represented by the neurons. - -4. Create an input to drive the neurons - - * Right-click in the **Network Viewer** and select **Create new->Function input**. - * Set the name to be `target`, the output dimensions to be `2`, and press **Set Functions**. - * For both dimensions, choose **Constant Function** and click **Set**. Set the values for each to be `0.5`. This defines the horizontal and vertical position of target vector being represented by motor cortex. - -![](/files/motor%20img1.png) - -5. Connect the network - - * Drag the **origin** from the **target** function to the **input** termination on the motor cortex neurons. - -6. Collect data from the network - - * To display the performance of this network, the **Interactive plots** system is used. See the [interactive plots reference sheet](?q=node/594) for a summary of this feature. - * Right-click in the **Network Viewer** and select **Interactive plots**. - * This shows the network again, but now right-clicking on the elements lets you choose the kinds of plots and controls to display. - * Press **play** (bottom right) to start the simulation. Some graphs may be already open as the Interactive plots can save the most recent layout. - * Right-click the **motor cortex** and select **preferred directions** to show the neuron activity plotted along their preferred directions in the 2D space. Also select the **XY plot** from the right-click menu to see the value decoded from this neural activity. - * Right-click the **target** and select **controls** to display slider controls that allow you to control the input. Move these sliders and see the effect on the preferred direction plot. - * Right-click the **target** and select **XY plot** to show a 2D plot of the current control values. - * Right-click the **target** and select **value** to show the inputs to the network over time. - * Right-click the **motor cortex** population and select **firing rate** to see the overall activity of these neurons. While they are initially randomly ordered, right-click on the firing rate grid and select **improve layout** to organize the neurons so that ones with similar preferred direction vectors will be near each other, as in motor cortex. Move the sliders and observe the change in firing pattern. - * This summarizes approximately how motor cortex was thought to encode a movement to a target by Georgopolous et al. (There are some important differences, please ask if you are interested). - -## Congratulations, you built some motor cortex! - - diff --git a/ctn_waterloo/content/research/software/cogsci-2010.md b/ctn_waterloo/content/research/software/cogsci-2010.md deleted file mode 100644 index 2a0abcfa..00000000 --- a/ctn_waterloo/content/research/software/cogsci-2010.md +++ /dev/null @@ -1,22 +0,0 @@ -title: CogSci 2010 - -These pages provide a step-by-step tutorial on the use of Nengo, our software -for cognitive modelling using the Neural Engineering Framework. You can -download this software at [nengo.ca](/files/nengo.zip). This tutorial is available online at -[http://ctn.uwaterloo.ca/~cnrglab/?q=node/650](http://ctn.uwaterloo.ca/~cnrglab/?q=node/650). - -For further information, the slides that accompany this tutorial are also -here. - -## Slides - - * [1D Representation](/files/Nengo1-1DRepresentation.pdf) - * [Linear Transformations](/files/Nengo2-LinearTransformations.pdf) - * [Nonlinear Transformations](/files/Nengo3-NonlinearTransformations.pdf) - * [Dynamics](/files/Nengo4-Dynamics.pdf) - * [Cognitive Modelling](/files/Nengo5-CognitiveModelling.pdf) - * [Further Applications](/files/Nengo6-FurtherApplications.pdf) - -## On-line Tutorials - - diff --git a/ctn_waterloo/content/research/software/demo-learning-feedforward-transformations.md b/ctn_waterloo/content/research/software/demo-learning-feedforward-transformations.md deleted file mode 100644 index 938580af..00000000 --- a/ctn_waterloo/content/research/software/demo-learning-feedforward-transformations.md +++ /dev/null @@ -1,46 +0,0 @@ -title: Demo - Learning feedforward transformations - -In this demo you simulate a network that learns nonlinear feedforward -transformations of a scalar. Variants of this network will learn dynamic -(recurrent) transformations as well vector transformations. We do not discuss -these extensions here. - -For those online, all of the files needed for this simulation are in [learning -scalars.zip](/files/learning scalars.zip). Be sure to place the -[learning_rule.py](/files/learning_rule.py_.txt) file in the `python` -directory. - -1. Open the network to be simulated. - -![](/files/learn%20net.png) - - * On a blank Nengo world, got to **File->Open from file** the menu bar. Select **learning scalars.nef** and click **Open**. - * (Skip this step if you don't care about scripts) This network was generated from the [learning_scalars.py](/files/learning_scalars.py__0.txt) script. To view the script select **View->Open script editor**. In the editor select **File->Open** and open the file **learning_scalars.py**. To run the script to generate this network, open the script console (**View->Toggle script console**) and type `run NIPSdemos/learning_scalars.py`. - -2. Run the network - - * You can run the network as is for 2s by right-clicking in the **Network Viewer**. - * Look at the graphs by expanding the tree in the **Data Viewer**. (The default input is Gaussian white noise) - -3. Interact with the network - - * Instead of looking in the **Data Viewer** you can interact directly with the network. - * Right-click in the **Network Viewer** and select **Interactive plots** - * Hit the **play** button (bottom right). The network will be injected with Gaussian white noise, and begin to learn the nonlinear transformation defined (x2). - * You can plot spiking behaviour, etc. as desired. See the [interactive plots reference sheet](?q=node/594). - * Note that the network learns reasonably quickly. After the first few seconds it is able to perform the defined nonlinearity reasonably well. This is evident from the lessening of the **error**, and the graph from the **B** population compared to the graph from the **A** population (or the input). - * Note also, that if you **reset** the network, it does not re-initialize the weights to a random matrix. You have to reload the .nef file to do that. So hitting **play** after **reset** will use already learned weights. - -4. Change the learned function - - * Close the interactive plots - * Drag the connection from to the **RightInput** on the **error** population away from the population (so it disconnects, but don't remove it). - -![](/files/learning%20net.png) - - * Right-click **A** and select **Add decoded origin**. Click **Set functions**, choose **User defined function**, click **Set**, and you can type a function in terms of the represented variable `x0`. A simple linear function is `0.5*x0`, which is just a scaled version of the input. - * Connect your new origin to where you disconnected the previous origin. Re-open the **Interactive plots** and watch the system attempt to learn the newly defined function. - * You can now switch the connections while the simulation is running. Drag the new origin connection off, and the **x_squared** connection back on to the **RightInput** termination. You will see the effects immediately in the plots. - * This experiment shows that the weights that are learned between A and B are the weights that subtract the error from the defined function (if you remove the **error** connection to the B population, you will see the system break down slowly). - - diff --git a/ctn_waterloo/content/research/software/demo-simple-motor-control-arm.md b/ctn_waterloo/content/research/software/demo-simple-motor-control-arm.md deleted file mode 100644 index f8314ff4..00000000 --- a/ctn_waterloo/content/research/software/demo-simple-motor-control-arm.md +++ /dev/null @@ -1,28 +0,0 @@ -title: Demo - Simple motor control (arm) - - -This demo shows a simple motor control network for a two-link arm implemented -in Nengo. It emphasizes the ability to vary the simulation level of detail, -and demonstrates the integration of a neural model with a physics engine. - -1. Loading the demo - - * In an empty Nengo environment, go to **View->Toggle script console** - * In the console at the bottom of the screen enter: `run NIPSdemos/armdemo.py`. - * Wait a moment as the system generates a network with all of the necessary network elements and the 3D virtual environment in Nengo. - -2. Interacting with the demo - - * Right-click in the **Network Viewer** and select **Interactive plots**. This interface allows you to adjust aspects of the model while it is running. - * The two sliders control the input to the system, indicating the point for the arm to reach towards. The network calculates what adjustment to arm joint angles are needed to reach that target (shown as a red ball in the 3D view). - * Click **play** (bottom right) to see the arm move towards the target. Change the target location by adjusting the sliders. - * The grey shaded grid shows the firing rates of neurons in the output (motor) population. Observe how they change as you adjust the sliders. - -![](/files/armDemo.png) - -3. Changing the accuracy of the simulation - - * The simulation can use spiking neurons (the default), rate neurons, or bypass neurons altogether. Press the down-arrow at the bottom of the **Interactive plots** window. This will reveal the configuration panel. Change the **mode** to **direct**. Neurons will no longer be used in the simulation, and the result will be directly calculated instead. - * You will see that the spike plot will stop, and that the graph will go from being noisy (due to neuron spiking effects) to being smooth. - - diff --git a/ctn_waterloo/content/research/software/demo-somatosensory-working-memory.md b/ctn_waterloo/content/research/software/demo-somatosensory-working-memory.md deleted file mode 100644 index 20e772de..00000000 --- a/ctn_waterloo/content/research/software/demo-somatosensory-working-memory.md +++ /dev/null @@ -1,39 +0,0 @@ -title: Demo - Somatosensory working memory - -This model is based on that published in Singh, R., Eliasmith, C. (2006). -Higher-dimensional neurons explain the tuning and dynamics of working memory -cells. Journal of Neuroscience. 26, 3667--3678. [[pdf](/files/singh.eliasmith.2006.2d%20working%20mem.pdf)] - -1. To run this demo, open [somatosensory working -memory.nef](/files/somatosensory%20working%20memory.nef.zip). - -2. Once it's loaded, run it for 3s by right-clicking the **Network Viewer**. - -3. One interesting aspect of this model is that it uses adapting neurons -(spike rates change with constant input). - -4. The far more interesting thing about this model is that it explains the -data set from Romo et al. (1999) on somatosensory descrimination task in the -macaque. The classes of neural response that they indentified is shown in -figure 1. No other model has been able to capture all of these response types. - -![](/files/working%20mem.jneuro.png) - -Figure 1: PSTH plots during memorization. The gray bars under the axes -indicate the onset of the stimulus, and black bars above the graph mark -periods of monotonicity. The higher stimulus frequency (f1) is marked with -darker response curves. a, c, e, Positive monotonic. b, d, f, Negative -monotonic. a, b, Early neurons. c, d, Persistent neurons. e, f, Late neurons. -[Graph from Romo et al. (1999).] - -4. To compare the model, you can open the **Spike Pattern** in the **Data -Viewer** for the **somatosensory cortex** population. Note that the data above -is filtered with a Gaussian kernel to make it into smooth firing rates, you -will have to compare spike densities. - - * Look to see if you can find the classes of neuron experimentally identified above in the spike raster. - * For instance 'c' above has some neurons with a brief initial burst and then reasonably constant firing. - * As well, some neurons have very rapid bursts and then silence ('b'), or prolonged silence until a later increase in firing ('e'). Few neurons slow down firing over time (some lines in 'd'). - * To verify that the full set of patterns is present, you have to run the simulation with a variety of inputs, and track a single neuron across different inputs. - - diff --git a/ctn_waterloo/content/research/software/interactive-plots-reference-sheet.md b/ctn_waterloo/content/research/software/interactive-plots-reference-sheet.md deleted file mode 100644 index 0c3331a9..00000000 --- a/ctn_waterloo/content/research/software/interactive-plots-reference-sheet.md +++ /dev/null @@ -1,59 +0,0 @@ -title: Interactive plots reference sheet - -![](/files/armDemo1.png) This sheet provides basic information on how -to use Nengo's interactive plots. - -Interactive plots are started by right-clicking on the background of the -**Network Viewer** and selecting **Interactive plots** from the menu. This -creates a window that shows each named population and input. Right-click on -these to access controls and plot types (or to hide them). All objects can be -moved and resized by dragging. You can grab the background to reposition -everything. You can make changes to the network in Nengo while the plots are -running. - -## Controls - - * Simulator controls: - - * The simulator controls on the bottom of the screen let you run the simulation (>), move to the end (>>|) or begining (|<<) of simulated data, and reset the simulation (<~). - * The two numbers that count time tell you the length of time currently available for scanning by dragging the slider. If you drag the slider back into this range, the simulation will show data from that point in time. If you press **play** within this window, it will continue from this point. Once the slider gets to the end of the window, the simulation generates new data. - * Function input controls - - * If you have defined a function input, it will be used to run the simulation when it first starts. - * If you want to control the simulation manually, right-click the function input and select **control**. As soon as you grab and move this slider, you will be in control of that input value. - * To use your original input function again, you will have to hit the **reset** button. - * Usually you want to also select **value** so you can see what input you're giving. - * To change the range of values, right-click and **increase** or **decrease** the range. This doubles or halves the current range. - -## Kinds of plot - -All plots are available for a population by right-clicking the population. -There are several kinds and include: - - * **value**. These plots show the decoded values of vector elements, or the set value of function inputs. Any function origin name after the word **value** (e.g. **value: product**) tells you which origin is being plotted. **value** alone means the plot is simply of whatever value is being represented by the population (referred to as **X**). Right-clicking and selecting **label** will label the plot. - * **firing rate**. This plot places all neurons in a square and shows the filtered spike train (see Options for filtering), or the firing rate (for rate neurons) of the population. Right-clicking and selecting **improve layout** will attempt to order the neurons by their tuning curves. - * **voltage grid**. This plot is like **firing rate** except the subthreshold voltage of all neurons is shown on a 2D grid. Yellow dots indicate spikes from the neuron. The layout can be similarly improved. (This is the same as the firing rate plot for rate neurons). - * **voltage graph**. This plot shows the same as the above, but over time and for only those neurons you select (select them by right clicking the graph). - * **spike raster**. This plot shows spike times for all the neurons. (For rate neurons it shows if the neuron is active or not). - * **preferred directions**. This plot is only shown for 2D populations. It shows the preferred direction vector of each neuron scaled by its firing rate. - * **XY plot**. This plot is only shown for 2D populations or function inputs. It plots the x and y values on a plane. - -## Options - -You can configure aspects of the display by clicking the down-arrow at the -bottom of the window. This reveals the following options: - - * **mode**. This is the simulation mode. **Default** is spiking neurons. **Rate** is rate neurons. **Direct** is no neurons. - * **time step**. This is the time step (in seconds) of the simulation. - * **speed**. This determines how close to real time the simulation runs. Often the **fastest** will not be real time; more often it's useful to run the simulations at **0.1x** speed or slower. - * **recording time**. This is the time (in seconds) that data is saved for. Once the simulation has run longer than this time, the earliest data is thrown away. Essentially available data is in a sliding window, and this is its width. - * **filter**. For spiking neurons all value and firing rate plots are filtered by an exponential with a time constant set by this value (in seconds). This can be thought of as a PSC filtered spike train at a receiving population. - * **time shown**. This determines the width of the time axis (in seconds) in the plots. - * **layout**. These two buttons let you save and restore the layout. The last saved layout is automatically restored on load. - -## Tips - - * Any plots representing multiple signals can be right-clicked and signals can be turned on or off if things get cluttered. - * Right-clicking the background lets you re-show populations or inputs you may have hidden. - - diff --git a/ctn_waterloo/content/research/software/nengo-model-archive.md b/ctn_waterloo/content/research/software/nengo-model-archive.md deleted file mode 100644 index f0d1288f..00000000 --- a/ctn_waterloo/content/research/software/nengo-model-archive.md +++ /dev/null @@ -1,17 +0,0 @@ -title: Nengo Model Archive - -Here we will post links to various Nengo models that you can download and play -with. Some are quite large files. All are zipped .nef files. You need -[Nengo](http://nengo.ca) to load and run these files. - -### Motor Control - - * [Integrator](/files/Integrator.nef_.zip) - This is the integrator you construct in the [tutorial](?q=node/5). Networks like this are found in fish through mammals. This sort of network is used for controlling horizontal eye position. However very similar networks are used for many other behaviours, as discussed in this [paper](?q=node/434). - -### Cognitive - - * [Working memory](/files/Code.zip) This model and [report](/files/SYDE556report.pdf) compares 1D and 2D working memory in terms of RMS and stability. Here are some cool movies referred to in the report: [spikes movie](/files/spikemovie.zip), [2000 neurons](/files/all940dim2000.zip), [40 dimensions](/files/all940dim.zip) and [20 dimensions](/files/all920dim.zip). It also incorporates methods for running function representation simulations in Nengo. - -### Perception - -### Other diff --git a/ctn_waterloo/content/research/software/nesim-tutorials-not-nengo.md b/ctn_waterloo/content/research/software/nesim-tutorials-not-nengo.md deleted file mode 100644 index 6eb0cab4..00000000 --- a/ctn_waterloo/content/research/software/nesim-tutorials-not-nengo.md +++ /dev/null @@ -1,6 +0,0 @@ -title: NESim Tutorials (not Nengo) - -NESim tutorials (examples) are -[here](http://compneuro.uwaterloo.ca/codelibrary/NEHelp/index.html). - - diff --git a/ctn_waterloo/content/research/software/nips-2009.md b/ctn_waterloo/content/research/software/nips-2009.md deleted file mode 100644 index 74c497ac..00000000 --- a/ctn_waterloo/content/research/software/nips-2009.md +++ /dev/null @@ -1,133 +0,0 @@ -title: NIPS 2009 - -The following activities were written for the Neural Information Processing -Systems (NIPS 2009) conference for use at our demo table for Nengo. The -software for use in this tutorial can be downloaded at -[http://www.nengo.ca](http://www.nengo.ca/). This demo is available online at -http://ctnsrv.uwaterloo.ca/cnrglab/node/175. - - -The videos we were running at the demo booth are posted here: [http://www.yout -ube.com/watch?v=q4jxI26gUtA](http://www.youtube.com/watch?v=q4jxI26gUtA). - - - -Nengo (www.nengo.ca) is a graphical neural simulation environment. The -following are available at the booth, and on the web. - - - - -## Rapid tutorials (3-5 min) - - - - - - - * [Rapid tutorial - Nonlinear transformations](189) - - - * [Rapid tutorial - An integrator](187) - - - * [Rapid tutorial - Braitenberg vehicle](188) - - - - -## Tutorials (10-15 min) - - - - - - - * [Building motor cortex (vector representations)](190) - - - * [Building a feedforward network (part 1)](179) - - - * [Building a feedforward network (part 2)](180) - - - * [Building a feedforward network (part 3)](186) - - - * [Building a neural integrator](176) - - - * [Building a controlled integrator](177) - - - - -## Demos (3-5 min) - - - - - - - * [Demo - Somatosensory working memory](178) - - - * [Demo - Learning feedforward transformations](183) - - - * [Demo - Simple motor control (arm)](185) - - - - -## Other - - - - - - - * [Interactive plots reference sheet](181) - - - * [Advanced Nengo tips and tricks](182) - - - - -## Selected related publications - - - - -Stewart, T.C., Tripp, B., Eliasmith, C. (2009) Python Scripting in the Nengo -Simulator. _Frontiers in Neuroinformatics_. 3:7. - - - - -Stewart, T. and C. Eliasmith. (2009) Compositionality and biologically -plausible models. In W. Hinzen, E. Machery, and M. Werning (eds.) _Oxford -Handbook of Compositionality_. Oxford University Press. - - - - -Singh, R. and C. Eliasmith (2006). Higher-dimensional neurons explain the -tuning and dynamics of working memory cells. _Journal of Neuroscience_. 26: -3667-3678. - - - - -Eliasmith, C. (2005). A unified approach to building and controlling spiking -attractor networks. _Neural Computation_. 17(6): 1276-1314. - - - - -Eliasmith, C. and C. H. Anderson (2003). _Neural Engineering: Computation, -representation and dynamics in neurobiological systems._ MIT Press. - - diff --git a/ctn_waterloo/content/research/software/part-five-cognitive-models.md b/ctn_waterloo/content/research/software/part-five-cognitive-models.md deleted file mode 100644 index fff7d92c..00000000 --- a/ctn_waterloo/content/research/software/part-five-cognitive-models.md +++ /dev/null @@ -1,195 +0,0 @@ -title: "Part Five: Cognitive Models" - -## Larger Systems - - * So far, we've seen how to implement the various basic components - * representations - * linear transformation - * non-linear transformation - * feedback - * The goal is to use these components to build full cognitive models using spiking neurons - * Constrained by the actual properties of real neurons in real brains (numbers of neurons, connectivity, neurotransmitters, etc) - * Should be able to produce behavioural predictions in terms of timing, accuracy, lesion effects, drug treatments, etc - * Some simple examples - * Motor control - * take an existing engineering control model for what angles to move joints to to place the hand at a particular position - -` run demo/armcontrol.py ` - -![](/files/p5-101.png) - - * Braitenberg vehicle - * connect range sensors to opposite motors on a wheeled robot - -` run demo/vehicle.py ` - -![](/files/p5-102.png) - -## Binding Semantic Pointers (SPs) - - * We want to manipulate sophisticated representational states (this is the purpose of describing the semantic pointer architecture (SPA)) - * The main operation to manipulate representations in the SPA is circular convolution (for binding) - * Let's explore a binding circuit for semantic pointers - - * Input: Two semantic pointers (high-dimensional vectors) - - * Output: One semantic pointer (binding the original two) - - * Implementation: element-wise multiplication of DFT (as described in slides) - -` run demo/convolve.py ` - -![](/files/p5-201.png) - - * To deal with high-dimensional vectors, we don't want to have to set each individual value for each vector - * would need 100 controls to configure a single 100-dimensional vector - * Nengo has a specialized "semantic pointer" graph for these high-dimensional cases - - * Instead of showing the value of each element in the vector (as with a normal graph), it shows the similarity between the currently represented vector and all the known vectors - * "How much like CAT is this? How much like DOG? How much like RED? How much like TRIANGLE?" - * You can configure which comparisons are shown using the right-click menu - * You can also use it to _set_ the contents of a neural group by right-clicking and choosing "set value". This will force the neurons to represent the given semantic pointer. You can go back to normal behaviour by selecting "release value". - * Use the right-click menu to set the input values to "a" and "b". The output should be similar to "a*b". - - * This shows that the network is capable of computing the circular convolution operation, which binds two semantic pointers to create a third one. - * Use the right-click menu to set the input values to "a" and "~a*b". The output should be similar to "b". - * This shows that convolution can be used to transform representations via binding and unbinding, since "a_(~a_b)" is approximately "b". - -## Control and Action Selection: Basal Ganglia - - * Pretty much every cognitive model has an action selection component - * Out of many possible things you could do right now, pick one - * Usually mapped on to the basal ganglia - * Some sort of winner-take-all calculation based on how suitable the various possible actions are to the current situation - * Input: A vector representing how good each action is (for example, [0.2, 0.3, 0.9, 0.1, 0.7]) - * Output: Which action to take ([0, 0, 1, 0, 0]) - - * Actually, the output from the basal ganglia is inhibitory, so the output is more like [1, 1, 0, 1, 1] - * Implementation - - * Could try doing it as a direct function - * Highly non-linear function - * Low accuracy - * Could do it by setting up inhibitory interconnections - * Like the integrator, but any value above zero would also act to decrease the others - * Often used in non-spiking neural networks (e.g. PDP++) to do k-winner-take-all - * But, you have to wait for the network to settle, so it can be rather slow - * Gurney, Prescott, & Redgrave (2001) - * Model of action selection constrained by the connectivity of the basal ganglia - -![](/files/p5-103.png) - - * Each component computes the following function - -![](/files/p5-104.png) - - * Their model uses unrealistic rate neurons with that function for an output - * We can use populations of spiking neurons and compute that function - * We can also use correct timing values for the neurotransmitters involved - -` run demo/basalganglia.py ` - - * Adjust the input controls to change the five utility values being selected between - * Graph shows the output from the basal ganglia (each line shows a different action) - * The selected action is the one set to zero - -![](/files/p5-105.png) - - * Comparison to neural data - * Ryan & Clark, 1991 - * Stimulate regions in medial orbitofrontal cortex, measure from GPi, see how long it takes for a response to occur - -![](/files/p5-106.png) - - * To replicate - * Set the inputs to [0, 0, 0.6, 0, 0] - * Run simulation for a bit, then pause it - * Set the inputs to [0, 0, 0.6, 1, 0] - * Continue simulation - * Measure how long it takes for the neurons for the fourth action to stop firing - -![](/files/p5-107.png) - - * In rats: 14-17ms. In model: 14ms (or more if the injected current isn't extremely large) - -![](/files/p5-108.png) - -## Sequences of Actions - - * To do something useful with the action selection system we need two things - * A way to determine the utility of each action given the current context - * A way to take the output from the action selection and have it affect behaviour - * We do this using the representations of the semantic pointer architecture - * Any cognitive state is represented as a high-dimensional vector (a semantic pointer) - * Working memory stores semantic pointers (using an integrator) - * Calculate the utility of an action by computing the dot product between the current state and the state for the action (i.e. the IF portion of an IF-THEN production rule) - * This is a linear operation, so we can directly compute it using the connection weights between the cortex and the basal ganglia - * The THEN portion of a rule says what semantic pointers to send to what areas of the brain. This is again a linear operation that can be computed on the output of the thalamus using the output from the basal ganglia - * Simple example: - * Five possible states: A, B, C, D, and E - * Rules for IF A THEN B, IF B THEN C, IF C THEN D, IF D THEN E, IF E THEN A - * Five `production rules' (semantic pointer mappings) cycling through the five states - -` run demo/sequence.py ` - -![](/files/p5-109.png) - - * Can set the contents of working memory in Interactive Plots by opening an SP graph, right-clicking on it, and choosing "set value" (use "release value" to allow the model to change the contents) - * Cycle time is around 40ms, slightly faster than the standard 50ms value used in ACT-R, Soar, EPIC, etc. - * This depends on the time constant for the neurotransmitter GABA - -![](/files/p5-110.png) - -## Routing of Information - - * What about more complex actions? - * Same model as above, be we want visual input to be able to control where we start the sequence - * Simple approach: add a visual buffer and connect it to the working memory - -` run demo/sequencenogate.py ` - -![](/files/p5-113.png) - - * Problem: If this connection always exists, then the visual input will always override what's in working memory. this connection needs to be controllable - - * Solution - - * Actions need to be able to control the flow of information between cortical areas. - * Instead of sending a particular SP to working memory, we need "IF X THEN transfer the pattern in cortex area Y to cortex area Z"? - * In this case, we add a rule that says "IF it contains a letter, transfer the data from the visual area to working memory" - * We make the utility of the rule lower than the utility of the sequence rules, so that it will only transfer that information (open that gate) when no other action applies. - -` run demo/sequencerouted.py ` - -![](/files/p5-112.png) - - * The pattern in the visual buffer is successfully transferred to working memory, then the sequence is continued from that letter. - -![](/files/p5-111.png) - - * Takes longer (60-70ms) for these more complex productions to occur - -## Question Answering - - * The control signal in the previous network can also be another semantic pointer that binds/unbinds the contents of the visual buffer (instead of just a gating signal) - * This more flexible control does not add processing time - * Allows processing the representations while routing them - * This allows us to perform arbitrary symbol manipulation such as "take the contents of buffer X, unbind it with buffer Y, and place the results in buffer Z" - * Example: Question answering - * System is presented with a statement such as "red triangle and blue circle" - * a semantic pointer representing this statement is placed in the visual cortical area - * "statement+red*triangle+blue*circle" - * Statement is removed after a period of time - * Now a question is presented, such as "What was Red?" - * "question+red" is presented to the same visual cortical area as before - * Goal is to place the correct answer in a motor cortex area (in this case, "triangle") - * This is achieved by creating two action rules: - * If a statement is in the visual area, move it to working memory (as in the previous example) - * If a question is in the visual area, unbind it with working memory and place the result in the motor area - * This example requires a much larger simulation than any of the others in this tutorial (more than 50,000 neurons). If you run this script, Nengo may take a long time (hours!) to solve for the decoders and neural connection weights needed. We have pre-computed the larger of these networks for you, and they can be downloaded at [/files/question.zip](/files/question.zip). - -![](/files/p5-202.png) - -` run demo/question.py ` - - diff --git a/ctn_waterloo/content/research/software/part-four-feedback-and-dynamics.md b/ctn_waterloo/content/research/software/part-four-feedback-and-dynamics.md deleted file mode 100644 index 066ac999..00000000 --- a/ctn_waterloo/content/research/software/part-four-feedback-and-dynamics.md +++ /dev/null @@ -1,97 +0,0 @@ -title: "Part Four: Feedback and Dynamics" - -## Storing Information Over Time: Constructing an Integrator - - * The basis of many of our cognitive models is the integrator. Mathematically, the output of this network should be the integral of the inputs to this network. - * Practically speaking, this means that if the input to the network is zero, then its output will stay at whatever value it is currently at. This makes it the basis of a neural memory system, as a representation can be stored over time. - * Integrators are also often used in sensorimotor systems, such as eye control - * For an integrator, a neural ensemble needs to connect to itself with a transformation weight of 1, and have an input with a weight of τ, which is the same as the synaptic time constant of the neurotransmitter used. - * Create a one-dimensional ensemble called Integrator. Use 100 neurons and a radius of 1. - * Add two terminations with synaptic time constants of 0.1s. Call the first one “input” and give it a weight of 0.1. Call the second one “feedback” and give it a weight of 1. - * Create a new Function input using a Constant Function with a value of 1. - * Connect the Function input to the input termination - * Connect the X origin of the ensemble back to its own feedback termination. - -![](/files/p4-101.png) - - * Go to Interactive Plots. Create a graph for the value of the ensemble (right-click on the ensemble and select "value"). - * Press Play to run the simulation. The value stored in the ensemble should linearly increase, reaching a value of 1 after approximately 1 second. - * You can increase the amount of time shown on the graphs in Interactive Plots. Do this by clicking on the small downwards-pointing arrow at the bottom of the window. This will reveal a variety of settings for Interactive Plots. Change the "time shown" to 1. - -![](/files/p4-102.png) - -## Representation Range - - * What happens if the previous simulation runs for longer than one second? - * The value stored in the ensemble does not increase after a certain point. This is because all neural ensembles have a range of values they can represent (the radius), and cannot accurately represent outside of that range. - -![](/files/p4-103.png) - - * Adjust the radius of the ensemble to 1.5 using either the Configure interface or the script console (that.radii=[1.5]). Run the model again. It should now accurately integrate up to a maximum of 1.5. - -![](/files/p4-104.png) - -## Complex Input - - * We can also run the model with a more complex input. Change the Function input using the following command from the script console (after clicking on it in the black model editing mode interface). Press Ctrl-P to show the script console. ` that.functions=[ca.nengo.math.impl.PiecewiseConstantFunction([0.2,0.3,0.44,0.54,0.8,0.9],[0,5,0,-10,0,5,0])] ` - - * You can see what this function looks like by right-clicking on it in the editing interface and selecting "Plot". - -![](/files/p4-5.png) - - * Return to Interactive Plots and run the simulation. - -![](/files/p4-105.png) - -## Adjusting Synaptic Time Constants - - * You can adjust the accuracy of an integrator by using different neurotransmitters. - * Change the input termination to have a tau of 0.01 (10ms: GABA) and a transform to be 0.01. Also change the feedback termination to have a tau of 0.01 (but leave its transform at 1). - -![](/files/p4-106.png) - - * By using a shorter time constant, the network dynamics are more sensitive to small-scale variation (i.e. noise). - * This indicates how important the use of a particular neurotransmitter is, and why there are so many different types with vastly differing time constants. - - * AMPA: 2-10ms - * GABAA: 10-20ms - * NMDA: 20-150ms - * The actual details of these time constants vary across the brain as well. We are collecting empirical data on these from various sources at [http://ctn.uwaterloo.ca/~cnrglab/?q=node/505](http://ctn.uwaterloo.ca/~cnrglab/?q=node/505) - * You can also run this example using scripting ` run demo/integrator.py ` - -## Controlled Integrator - - * We can also build an integrator where the feedback transformation (1 in the previous model) can be controlled. - * This allows us to build a tunable filter. - * This requires the use of multiplication, since we need to multiply two stored values together. This was covered in the previous part of the tutorial. - * We can efficiently implement this by using a two-dimensional ensemble. One dimension will hold the value being represented, and the other dimension will hold the transformation weight. - * Create a two-dimensional neural ensemble with 225 neurons and a radius of 1.5. - * Create the following three terminations: - * “input”: time constant of 0.1, 1 dimensional, with a transformation matrix of [0.1 0]. This acts the same as the input in the previous model, but only affects the first dimension. - * “control”: time constant of 0.1, 1 dimensional, with a transformation matrix of [0 1]. This stores the input control signal into the second dimension of the ensemble. - * “feedback”: time constant of 0.1, 1 dimensional, with a transformation matrix of [1 0]. This will be used in the same manner as the feedback termination in the previous model. - * Create a new origin that multiplies the values in the vector together - * This is exactly the same as the multiplier in the previous part of this tutorial - * This is a 1 dimensional output, with a User-defined Function of x0*x1 - * Create two function inputs called “input” and “control”. Start with Constant functions with a value of 1 - * Use the script console to set the “input” function by clicking on it and entering the same input function as used above. - -` that.functions=[ca.nengo.math.impl.PiecewiseConstantFunction([0.2,0.3,0.44,0 -.54,0.8,0.9],[0,5,0,-10,0,5,0])] ` - - * Connect the input function to the input termination, the control function to the control termination, and the product origin to the feedback termination. - -![](/files/p4-9.png) - - * Go to Interactive Plots and show a graph for the value of the ensemble (right-click->X->value). If you run the simulation, this graph will show the values of both variables stored in this ensemble (the integrated value and the control signal). For clarity, turn off the display of the cotrol signal by right-clicking on the graph and removing the checkmark beside "v[1]". - * The performance of this model should be similar to that of the non-controlled integrator. - -![](/files/p4-107.png) - - * Now adjust the control input to be 0.3 instead of 1. This will make the integrator into a leaky integrator. This value adjusts how quickly the integrator forgets over time. - -![](/files/p4-108.png) - - * You can also run this example using scripting ` run demo/controlledintegrator.py ` - - diff --git a/ctn_waterloo/content/research/software/part-one-one-dimensional-representation.md b/ctn_waterloo/content/research/software/part-one-one-dimensional-representation.md deleted file mode 100644 index f41f4200..00000000 --- a/ctn_waterloo/content/research/software/part-one-one-dimensional-representation.md +++ /dev/null @@ -1,101 +0,0 @@ -title: "Part One: One-Dimensional Representation" - -## Installing and Running Nengo - - * Install Nengo from the provided USB keys. Do this by copying the nengo directory onto your computer. - * Alternatively, download it from [/files/nengo.zip](/files/nengo.zip) - * You must also have Java installed on your computer - * Nengo will run faster if you also have Python installed along with the NumPy and SciPy libraries. Versions of these for Windows can be found in the windows directory - * To run Nengo, either: - * Double-click on nengo.bat (in Windows) - * run ./nengo (in OS X and Linux) - -![](/files/p1-1.png) - -## Creating Networks - - * When creating an NEF model, the first step is to create a Network. This will contain all of the neural ensembles and any needed inputs to the system. - * File->New Network - * Give the network a name - -![](/files/p1-2.png) - - * You can create networks inside of other networks. This can be useful for hierarchical organization of models. - -## Creating an Ensemble - - * Ensembles must be placed inside networks in order to be used - * Right-click inside a network - * Create New->NEF Ensemble - -![](/files/p1-3.png) - - * Here the basic features of the ensemble can be configured - * Name - * Number of nodes (i.e. neurons) - * Dimensions (the number of values in the vector encoded by these neurons; leave at 1 for now) - * Radius (the range of values that can be encoded; for example, a value of 100 means the ensemble can encode numbers between -100 and 100) - * Node Factory (the type of neuron to use) - -![](/files/p1-4.png) - - * For this tutorial (and for the majority of our research), we use LIF Neuron, the standard Leaky-Integrate-and-Fire neuron. Clicking on Set allows for the neuron parameters to be configured - * tauRC (RC time constant for the neuron membrane; usually 0.02) - * tauRef (absolute refractory period for the neuron; usually 0.002) - * Max rate (the maximum firing rate for the neurons; each neuron will have a maximum firing rate chosen from a uniform distribution between low and high) - * Intercept (the range of possible x-intercepts on the tuning curve graph; normally set to -1 and 1) - * Because there are many parameters to set and we often choose similar values, Nengo will remember your previous settings. Also, you can save templates by setting up the parameters as you like them and clicking on New in the Templates box. You will then be able to go back to these settings by choosing the template from the drop-down box. - -![](/files/p1-5.png) - - * You can double-click on an ensemble to view the individual neurons within it - -![](/files/p1-5b.png) - -## Plotting Tuning Curves - - * This shows the behaviour of each neuron when it is representing different values (i.e. the tuning curves for the neurons) - * Right-click on the ensemble, select Plot->Constant Rate Responses - -![](/files/p1-6.png) - - * tauRC affects the linearity of the neurons (smaller values are more linear) - * Max rate affects the height of the curves at the left and right sides - * Intercept affects where the curves hit the x-axis (i.e. the value where the neuron starts firing) - -## Plotting Representation Error - - * We often want to determine the accuracy of a neural ensemble. - * Right-click on the ensemble, select Plot->Plot Distortion:X - -![](/files/p1-7.png) - - * Mean Squared Error (MSE) is also shown (at the top) - * MSE decreases as the square of the number of neurons (so RMSE is proportional to 1/N) - * Can also affect representation accuracy by adjusting the range of intercepts. This will cause the system to be more accurate in the middle of the range and less accurate at the edges. - -## Adjusting an Ensemble - - * After an ensemble is created, we can inspect and modify many of its parameters - * Right-click on an ensemble and select Configure - -![](/files/p1-8.png) - - * neurons (number of neurons; this will rebuild the whole ensemble) - * radii (the range of values that can be encoded; can be different for different dimensions) - * encoders (preferred direction vectors for each neuron) - -### The Script Console - - * Nengo also allows users to interact with the model via a scripting interface using the Python language. This can be useful for writing scripts to create components of models that you use often. - * You can also use it to inspect and modify various aspects of the model. - * Press Ctrl-P or choose View->Toggle Script Console to show the script interface - * The full flexibility of the Python programming language is available in this console. It interfaces to the underlying Java code of the simulation using Jython, making all Java methods available. - * If you click on an object in the GUI (so that it is highlighted in yellow), this same object is available by the name "that" in the script console. - * Click on an ensemble - * Open the script console - * type "print that.neurons" - * type "that.neurons=50" - * You can also run scripts by typing "run [scriptname.py]" - - diff --git a/ctn_waterloo/content/research/software/part-three-non-linear-transformations.md b/ctn_waterloo/content/research/software/part-three-non-linear-transformations.md deleted file mode 100644 index 9566986b..00000000 --- a/ctn_waterloo/content/research/software/part-three-non-linear-transformations.md +++ /dev/null @@ -1,106 +0,0 @@ -title: "Part Three: Non-Linear Transformations" - -## Functions of one variable - - * We now turn to creating nonlinear transformations in Nengo. The main idea here is that instead of using the X origin, we will create a new origin that estimates some arbitrary function of X. This will allow us to estimate any desired function. - * The accuracy of this estimate will, of course, be dependent on the properties of the neurons. - * For one-dimensional ensembles, we can calculate various 1-dimensional functions: - - * f(x)=x2 - * f(x)=θ(x) (thresholding) - * f(x)=√x - * To perform a non-linear operation, we need to define a new origin - - * The X origin just uses f(x)=x. - * Create a new ensemble and a function input. The ensemble should be one-dimensional with 100 neurons and a radius of 1. Use a Constant Function input set two 0.5. - * Create a termination on the ensemble and connect the function input to it - * Now create a new origin that will estimate the square of the value. - * Right-click on the combined ensemble and select Add decoded origin - * Set the name to "square" - * Click on Set Functions - * Select User-defined Function and press Set - * For the Expression, enter "x0*x0". We refer to the value as x0 because when we extend this to multiple dimensions, we will refer to them as x0, x1, x2, and so on. - * Press OK, OK, and OK. - * You can now generate a plot that shows how good the ensemble is at calculating the non-linearity. Right-click on the ensemble and select Plot->Plot distortion:square. - -![](/files/p3-9b.png) - - * Start Interactive Plots. - * Create a control for the input, so you can adjust it while the model runs (right-click on the input and select "control") - * Create a graph of the "square" value from the ensemble. Do this by right-clicking on the ensemble in the Interactive Plots window and selecting "square->value". - * For comparison, also create a graph for the standard X origin byt right-clicking on the ensemble and selecting "X->value". This is the standard value graph that just shows the value being represented by this ensemble. - * Press Play to run the simulation. With the default input of 0.5, the squared value should be near 0.25. Use the control to adjust the input. The output should be the square of the input. - -![](/files/p3-101.png) - - * You can also run this example using scripting ` run demo/squaring.py ` - -## Functions of multiple variables - - * Since X (the value being represented by an ensemble) can also be multidimensional, we can also calculate these sorts of functions - * f(x)=x0*x1 - * f(x)=max(x0,x1) - * To begin, we create two ensembles and two function inputs. These will represent the two values we wish to multiply together. - * The ensembles should be one-dimensional, use 100 neurons and have a radius of 10 (so they can represent values between -10 and 10) - * The two function inputs should be constants set to 8 and 5 - * The terminations you create to connect them should have time constants of 0.01 (AMPA) - -![](/files/p3-1.png) - - * Now create a two-dimensional neural ensemble with a radius of 15 called Combined - * Since it needs to represent multiple values, we increase the number of neurons it contains to 200 - * Add two terminations to Combined - * For each one, the input dimensions are 1 - * For the first one, use Set Weights to make the transformation be [1 0] - * For the second one, use Set Weights to make the transformation be [0 1] - * Connect the two other ensembles to the Combined one - -![](/files/p3-2.png) - - * Next, create an ensemble to store the result. It should have a radius of 100, since it will need to represent values from -100 to 100. Give it a single one-dimensional termination with a weight of 1. - -![](/files/p3-3.png) - - * Now we need to create a new origin that will estimate the product between the two values stored in the combined ensemble. - * Right-click on the combined ensemble and select Add decoded origin. - * Set the name to “product” - * Set Output dimensions to 1 - -![](/files/p3-4.png) - - * Click on Set Functions - * Select User-defined Function and press Set. - -![](/files/p3-5.png) - - * For the Expression, enter x0*x1 - -![](/files/p3-6.png) - - * Press OK, OK, and OK to finish creating the origin - * Connect the new origin to the termination on the result ensemble - -![](/files/p3-7.png) - - * Add a probe to the result ensemble and run the simulation - * The result should be approximately 40. - * Adjust the input controls to multiple different numbers together. - -![](/files/p3-102.png) - - * You can also run this example using scripting ` run demo/multiplication.py ` - -## Combined approaches - - * We can combine these two approaches in order to compute more complex funxtions, such as x2y. - * Right-click on the ensemble representing the first of the two values and select Add decoded origin. - * Give it the name "square", set its output dimensions to 1, and press Set Functions. - * As before, select the User-defined Function and press Set. - * Set the Expression to be "x0*x0". - * Press OK, OK, and OK to finish creating the origin. - * This new origin will calculate the square of the value represented by this ensemble. - * If you connect this new origin to the Combined ensemble instead of the standard X origin, the network will calculate x2y instead of xy. - -![](/files/p3-9a.png) - - diff --git a/ctn_waterloo/content/research/software/part-two-linear-transformations.md b/ctn_waterloo/content/research/software/part-two-linear-transformations.md deleted file mode 100644 index 6e5d2659..00000000 --- a/ctn_waterloo/content/research/software/part-two-linear-transformations.md +++ /dev/null @@ -1,182 +0,0 @@ -title: "Part Two: Linear Transformations" - -## Creating Terminations - - * Connections between ensembles are built using Origins and Terminations. The Origin from one ensemble can be connected to the Termination on the next ensemble - * Create two ensembles. They can have different neural properties and different numbers of neurons, but for now make sure they are both one-dimensional. - * Right-click on the second ensemble and select Add Decoded Termination - * Provide a name (for example, “input”) - * Set the input dimension to 1 and use Set Weights to set the connection weight to 1 - * Set tauPSC to 0.01 (this synaptic time constant differs according to which neurotransmitter is involved. 10ms is the time constant for AMPA (5-10ms). - -![](/files/p2-1.png) ![](/files/p2-2.png) - -![](/files/p2-3.png) - -## Creating Projections - - * We can now connect the two neural ensembles. - * Every ensemble automatically has an origin called X. This is an origin suitable for building any linear transformation. In Part Three we will show how to create origins for non-linear transformations. - -![](/files/p2-4.png) - - * Click and drag from the origin to the termination. This will create the desired projection. - -![](/files/p2-5.png) - -## Adding Inputs - - * In order to test that this projection works, we need to set the value encoded by the first neural ensemble. We do this by creating an input to the system. This is how all external inputs to Nengo models are specified. - * Right-click inside the Network and choose Create New->Function Input. - * Give it a name (for example, “external input”) - * Set its output dimensions to 1 - -![](/files/p2-6.png) - - * Press Set Function to define the behaviour of this input - * Select Constant Function from the drop-down list and then press Set to define the value itself. For this model, set it to 0.5. - -![](/files/p2-7.png) ![](/files/p2-8.png) - -![](/files/p2-9.png) - - * Add a termination on the first neural ensemble and create a projection from the new input to that ensemble. - -![](/files/p2-10.png) - -## Interactive Plots - - * To observe the performance of this model, we now switch over to Interactive Plots. This allows us to both graph the performance of the model and adjust its inputs on-the-fly to see how this affects behaviour. - * Start Interactive Plots by right-clicking inside the Network and selecting Interactive Plots - -![](/files/p2-101.png) - - * The text shows the various components of your model, and the arrows indicate the synaptic connections between them. - * You can move the components by left-click dragging them, and you can move all the components by dragging the background. - * You can hide a component by right-clicking on it and selecting "hide" - * To show a hidden component, right click on the background and select the component by name - * The bottom of the window shows the controls for running the simulation. - * The simulation can be started and stopped by pressing the Play or Pause button at the bottom right. Doing this right now will run the simulation, but no data will be displayed since we don't have any graphs open yet! - * The reset button on the far left clears all the data from the simulation and puts it back to the beginning. - * In the middle is a slider that shows the current time in the simulation. Once a simulation has been run, we can slide this back and forth to observe data from different times in the simulation. - * Right-clicking on a component also allows us to select a type of data to show about that component. - * Right-click on A and select "value". This creates a graph that shows the value being represented by the neuron in ensemble A. You can move the graph by left-click dragging it, and you can resize it by dragging near the corners or using a mouse scroll wheel. - * Press the Play button at the bottom-right or the window and confirm that this group of neurons successfully represents its input value, which we previously set to be 0.5. - -![](/files/p2-102.png) - - * Now let us see what happens if we change the input. Right-click on the input and select "control". This lets us vary the input while the simulation is running. - * Drag the slider up and down while the simulation is running (press Play again if it is paused). The neurons in ensemble A should be able to successfully represent the changing values. - -![](/files/p2-103.png) - - * We can also view what the individual neurons are doing during the simulation. Right-click on A and choose "spike raster". This shows the individual spikes coming from the neurons. Since there are 100 neurons in ensemble A, the spikes from only a sub-set of these are shown. You can right-click on the spike raster graph and adjust the proportion of spikes shown. Change it to 50%. - * Run the simulation and change the input. This will affect the neuron firing patterns. - -![](/files/p2-104.png) - - * We can also see the voltage levels of all the individual neurons. Right-click on A and choose "voltage grid". Each neuron is shown as a square and the shading of that square indicates the voltage of that neuron's cell membrane, from black (resting potential) to white (firing threshold). Yellow indicates a spike. - * The neurons are initially randomly ordered. You can change this by right-clicking on the voltage grid and selecting "improve layout". This will attempt to re-order the neurons so that neurons with similar firing patterns are near each other, as they are in the brain. This does not otherwise affect the simulation in any way. - * Run the simulation and change the input. This will affect the neuron voltage. - -![](/files/p2-105.png) - - * So far, we have just been graphing information about neural ensemble A. We have shown that these 100 neurons can accurately represent a value that is directly input to them. - * For this to be useful for constructing cognitive models, we need to also show that the spiking output from this group of neurons can be used to transfer this information from one neural group to another. - * In other words, we want to show that B can represent the same thing as A, where B's only input is the neural firing from group A. For this to happen, the correct synaptic connection weights between A and B (as per the Neural Engineering Framework) must be calculated. - * Nengo automatically calculates these weights whenever an origin is created. - * We can see that this communication is successful by creating graphs for ensemble B. - - * Do this by right-clicking on B and selecting "value", and then right-clicking on B again and selecting "voltage grid". - * To aid in identifying which graph goes with which ensemble, right click on a graph and select "label". - * Graphs can be moved (by dragging) and resized (by dragging near the edges and corners or by the mouse scroll wheel) as desired. - -![](/files/p2-106.png) - - * Notice that the neural ensembles can be representing the same value, but have a different firing pattern. - * Close the Interactive Plots when you are finished. - -## Adding Scalars - - * If we want to add two values, we can simply add another termination to the final ensemble and project to it as well. - * Create a termination on the second ensemble called “input 2” - * Create a new ensemble - * Create a projection from the X origin to input 2 - -![](/files/p2-19.png) - - * Create a new Function input and set its value to -0.7 - * Add the required termination and projection to connect it to the new ensemble - -![](/files/p2-20.png) - - * Switch to Interactive Plots. - * Show the controls for the two inputs - * Create value graphs for the three neural ensembles - * Press Play to start the simulation. The value for the final ensemble should be 0.5-0.7=-0.2 - * Use the control sliders to adjust the input. The output should still be the sum of the inputs. - -![](/files/p2-107.png) - - * This will be true for most values. However, if the sum is outside of the radius that was set when the neural group was formed (in this case, from -1 to 1), then the neurons may not be able to fire fast enough to represent that value (i.e. they will saturate). Try this by computing 1+1. The result will only be around 1.3. - * To accurately represent values outside of the range -1 to 1, we need to change the radius of the output ensemble. Return to the standard black editing mode and right-click on ensemble B. Select "Configure" and change its radii to 2. Now return to the Interactive Plots. The network should now accurately compute that 1+1=2. - -## Adjusting Transformations - - * So far, we have only considered projections that do not adjust the values being represented in any way. However, due to the NEF derivation of the synaptic weights between neurons, we can adjust these to create arbitrary linear transformations (i.e. we can multiply any represented value by a matrix). - * Each termination in Nengo has an associated transformation matrix. This can be adjusted as desired. In this case, we will double the weight of the original value, so instead of computing x+y, the network will compute 2x+y. - * Right-click on the first termination in the ensemble that has two projections coming into it. Select Configure. Double-click on transform. - * Double-click on the 1.0 and change it to 2.0 - -![](/files/p2-22.png) - - * Click on OK and then Done - * Now run the simulation. The final result should be 2(0.5)-0.7=0.3 - -## Multiple Dimensions - - * Everything discussed above also applies to ensembles that represent more than one dimension. - * To create these, set the number of dimensions to 2 when creating the ensemble - -![](/files/p2-24.png) - - * When adding a termination, the input dimension can be adjusted. This defines the shape of the transformation matrix for the termination, allowing for projections that change the dimension of the data - -![](/files/p2-25.png) - - * For example, two 1-dimensional values can be combined into a single two-dimensional ensemble. This would be done with two terminations: one with a transformation (or coupling) matrix of [1 0] and the other with [0 1]. If the two inputs are called a and b, this will result in the following calculation: - - * a*[1 0] + b*[0 1] = [a 0] + [0 b] = [a b] - * This will be useful for creating non-linear transformations, as discussed further in the next section. - * There are additional ways to view 2D representations in the interactive plots - - * Including plotting the activity of the neurons along their preferred direction vectors - * Plotting the 2D decoded value of the representation - -![](/files/p2-108.png) - -## Scripting - - * Along with the ability to construct models using this point-and-click interface, Nengo also provides a Python scripting language interface for model creation. These examples can be seen in the "demo" directory. - * To create the communication channel through the scripting interface, go to the Script Console (Ctrl-P) and type - -` run demo/communication.py ` - - * The actual code for this can be seen by opening the communication.py file in the demo directory. - -` import nef - -net=nef.Network('Communications Channel') input=net.make_input('input',[0.5]) -A=net.make('A',100,1) B=net.make('B',100,1) net.connect(input,A) -net.connect(A,B) net.add_to(world) ` - - * The following demo scripts create models similar to those seen in this part of the tutorial: - * `demo/singleneuron.py` shows what happens with an ensemble with only a single neuron on it (poor representation) - * `demo/twoneurons.py` shows two neurons working together to represent - * `demo/manyneurons.py` shows a standard ensemble of 100 neurons representing a value - * `demo/communication.py` shows a communication channel - * `demo/addition.py` shows adding two numbers - * `demo/2drepresentation.py` shows 100 neurons representing a 2-D vector - * `demo/combining.py` shows two separate values being combined into a 2-D vector - - diff --git a/ctn_waterloo/content/research/software/rapid-tutorial-an-integrator.md b/ctn_waterloo/content/research/software/rapid-tutorial-an-integrator.md deleted file mode 100644 index 90c754d0..00000000 --- a/ctn_waterloo/content/research/software/rapid-tutorial-an-integrator.md +++ /dev/null @@ -1,34 +0,0 @@ -title: Rapid tutorial - An integrator - -In this tutorial, you will construct a neural integrator. This is a circuit -that uses feedback to maintain its own state, functioning as a memory. - -1. Open the partially completed integrator - - * Goto **File->open from file** and select [partial neural integrator.nef](/files/partial%20neural%20integrator.nef_.zip). - -2. Connect the network - -![](/files/rapidIntegrator1.png) - - * The basic components of the network have been constructed for you. Connecting these components tells the system to compute the necessary synaptic connection weights to optimally realize the desired function. - * Connect the **origin** of the **input** to the termination called **input** of the **integrator** - * Connect the **X** origin of the **integrator** to its own **feedback** termination. - -3. Run the network - - * Right-click on the background in the Network Viewer and select **Interactive plots**. - * Click the **play** button (in the bottom-right corner). The grey squares show the firing rates of the neurons. - * The first second of input is defined for you. Press **reset** (the arrow in the bottom left) to repeat this sequence. The network will compute the integral of this input over time. - * Move the slider to provide your own input. Set it to a large number. Notice that the network integrates this value up to a certain point, but then can go no higher. This is because the neurons have saturated: they are firing as fast as they can. Every group of neurons has a particular range over which they are optimized to represent. Moving outside of this range results in saturation. - -4. Adjust the network - - * Return to the black **Network Viewer** screen. - * To make the system into a low-pass filter (leaky integrator), do the following: - * Right-click the **feedback** termination on the **integrator** population and select **configure**. - * At the bottom, double-click **transform**, double-click the value (1.0) and set to a smaller value (e.g. 0.9). The smaller the value, the 'leakier' the integrator will be. Click **Save** and **Done**. - * Return to the **Interactive plots** and click **reset** and **play** to view the results. - * In the **Network Viewer** screen, disconnect the **feedback** connection. This will eliminate the recurrent connections which allows the network to have a memory. Return to the **Interactive plots** and examine the results. Now when you move the controller between extremes, the output is merely a scaled version of the input. - - diff --git a/ctn_waterloo/content/research/software/rapid-tutorial-braitenberg-vehicle.md b/ctn_waterloo/content/research/software/rapid-tutorial-braitenberg-vehicle.md deleted file mode 100644 index 3e014259..00000000 --- a/ctn_waterloo/content/research/software/rapid-tutorial-braitenberg-vehicle.md +++ /dev/null @@ -1,38 +0,0 @@ -title: Rapid tutorial - Braitenberg vehicle - -In this tutorial, you will connect groups of neurons to control a robot moving -around its environment. The robot has two range sensors and two motors, so you -will use the standard Braitenberg Vehicle control system. - -1. Create the robot and its world - - * Open the **Script Console** by going to **View->Toggle Script Console**. - * Type `run NIPSDemos/vehicle.py`. Wait a moment for the network to be created. - -2. Run the Simulation - - * Open the **Network Viewer** by double-clicking on the **Braitenberg** network - * Right-click inside the **Network Viewer** and select **Interactive plots** - * Press the **play** button (bottom right). - * The graphs show the spike rasters from four groups of neurons: two groups of afferent sensory neurons; and two groups of efferent motor neurons. Next to these is the graph of the decoded values from these spikes. - * Boxes will fall, but the robot will not move because its inputs have not yet been connected to its motors. - -![](/files/braitenberg-model.png) - -3. Connect the network - - * Go back to the **Network Viewer** - * Click on the **left input's** origin called **X** and drag it to the **right motor's** termination. This will connect the two, calculating the optimal synaptic connection weights to transfer information between neural populations. - * Do the same to connect the **right input** to the **left motor**. - -4. Run the Simulation - -![](/files/braitenberg-plots.png) - - * Go back to **Interactive plots**. - * The robot should be attempting to avoid walls. - * Reset the simulation (by pressing the arrow in the bottom left) if the robot seems stuck. - * Since the left sensor is connected to the right motor, notice that the value graphs for these two neural groups are similar. However, the spike rasters will be quite different. Some neurons fire more for large values, while other fire more for small values. - * What happens if you connect the inputs the other way around? Try this and see the change in the robot's behaviour. You can connect and disconnect the neural projections while the simulation is running. - - diff --git a/ctn_waterloo/content/research/software/rapid-tutorial-nonlinear-transformations.md b/ctn_waterloo/content/research/software/rapid-tutorial-nonlinear-transformations.md deleted file mode 100644 index 4866a023..00000000 --- a/ctn_waterloo/content/research/software/rapid-tutorial-nonlinear-transformations.md +++ /dev/null @@ -1,37 +0,0 @@ -title: Rapid tutorial - Nonlinear transformations - -In this tutorial, you will connect groups of neurons to create a system that -can multiply two numbers together. You will then modify this network to -compute a new function. - -1. Open the partially completed multiplication network - - * Go to **File->Open from file** and select [partial multiplication.nef](/files/partial multiplication.nef.zip). - -2. Connect the network - -![](/files/rapidMulti1.png) - - * The basic components of the network have been constructed for you. Connecting components tells the system to compute the necessary synaptic connection weights to optimally realize the desired function. - * Connect **input 1** and **input 2** to the inputs for neural ensembles **A** and **B**. - * Connect **A** and **B** to the two inputs of **H**. - * Connect the **product** output of **H** to the input of **Z**. - -3. Run the network - - * Right-click on the background in the Network Viewer and select **Interactive plots**. - * Click the **play** button (in the bottom-right corner). The grey squares show the firing rates of the neurons. - * The graph displays the decoded output of the network. This should be approximately 40, since the input sliders are currently set to 8 and 5. - * Move the sliders up and down to adjust this input. The output will change accordingly. - -4. Change the function being computed - - * Close the Interactive Plots window. - * Right-click on the **H** population and select **Add decoded origin**. Change the name to `my function` and click **Set functions** (dimension should be 1). Select **user-defined function** from the drop down and click **set**. - * Type in a new function. Try `x0*x0+cos(x1)`. You can also use your own function, but the neurons in this example are only optimized for representing values between -100 and 100. Click OK three times. - * Disconnect the **product** projection from **H** to **Z** and connect the new origin called **my function** in its place. - * Right-click on the Network Viewer and select **Interactive plots**. - * Adjust the sliders to confirm that the new function is being calculated. - * To compare the behaviour of neurons to the ideal calculation of this function, we can switch simulation modes. Click on the down-arrow at the bottom of the interactive plots. Change the **mode** from **default** to **direct**. This will bypass the neurons, producing an exact result. - - diff --git a/ctn_waterloo/content/research/software/summary-of-available-tutorials-and-demos.md b/ctn_waterloo/content/research/software/summary-of-available-tutorials-and-demos.md deleted file mode 100644 index 3a4c8657..00000000 --- a/ctn_waterloo/content/research/software/summary-of-available-tutorials-and-demos.md +++ /dev/null @@ -1,52 +0,0 @@ -title: Summary of available tutorials and demos - -Nengo (www.nengo.ca) is a graphical neural simulation environment. The -following are available at the booth, and on the web at -http://compneuro.uwaterloo.ca/cnrglab/. - -## Rapid tutorials (3-5 min) - - * [Rapid tutorial - Nonlinear transformations](?q=node/603) - * [Rapid tutorial - An integrator](?q=node/601) - * [Rapid tutorial - Braitenberg vehicle](?q=node/602) - -## Tutorials (10-15 min) - - * [Building motor cortex (vector representations)](?q=node/595) - * [Building a feedforward network (part 1)](?q=node/591) - * [Building a feedforward network (part 2)](?q=node/592) - * [Building a feedforward network (part 3)](?q=node/600) - * [Building a neural integrator](?q=node/588) - * [Building a controlled integrator](?q=node/589) - -## Demos (3-5 min) - - * [Demo - Somatosensory working memory](?q=node/590) - * [Demo - Learning feedforward transformations](?q=node/597) - * [Demo - Simple motor control (arm)](?q=node/599) - -## Other - - * [Interactive plots reference sheet](?q=node/594) - * [Advanced Nengo tips and tricks](?q=node/587) - -## Selected related publications - -Stewart, T.C., Tripp, B., Eliasmith, C. (2009) Python Scripting in the Nengo -Simulator. _Frontiers in Neuroinformatics_. 3:7. - -Stewart, T. and C. Eliasmith. (2009) Compositionality and biologically -plausible models. In W. Hinzen, E. Machery, and M. Werning (eds.) _Oxford -Handbook of Compositionality_. Oxford University Press. - -Singh, R. and C. Eliasmith (2006). Higher-dimensional neurons explain the -tuning and dynamics of working memory cells. _Journal of Neuroscience_. 26: -3667-3678. - -Eliasmith, C. (2005). A unified approach to building and controlling spiking -attractor networks. _Neural Computation_. 17(6): 1276-1314. - -Eliasmith, C. and C. H. Anderson (2003). _Neural Engineering: Computation, -representation and dynamics in neurobiological systems._ MIT Press. - - diff --git a/ctn_waterloo/content/research/software/tutorials.md b/ctn_waterloo/content/research/software/tutorials.md deleted file mode 100644 index 84a767b0..00000000 --- a/ctn_waterloo/content/research/software/tutorials.md +++ /dev/null @@ -1,11 +0,0 @@ -title: Tutorials - -The following tutorials are meant to provide a hands-on demonstration of the various capabilities of the software we have written. They are focussed on the Nengo simulator. - -Beginners should start with the video tutorials, or the tutorials in the Nengo documentation. - -The tutorials below include slides explaining some of the concepts behind the NEF, as well as how to use Nengo. The most recent of these is the CogSci 2010 tutorial. - -Also, if you are adventurous, you can download various examples from the Nengo Model Archive. There may be few, if any, instructions with some of those examples. - - diff --git a/ctn_waterloo/content/research/software_index.md b/ctn_waterloo/content/research/software_index.md index b9bb80b6..19cd72ad 100644 --- a/ctn_waterloo/content/research/software_index.md +++ b/ctn_waterloo/content/research/software_index.md @@ -1,36 +1,7 @@ title: Software picture: http://i.imgur.com/ygXcJ0y.png +category: Tools intro: Software we've developed, support, or use extensively. -people: - - Chris Eliasmith - - Trevor Bekolay - - Terry Stewart -toc: - - Advanced Nengo tips and tricks - - Nengo Model Archive - - Tutorials - - - CogSci 2010 - - - "Part One: One-Dimensional Representation" - - "Part Two: Linear Transformations" - - "Part Three: Non-Linear Transformations" - - "Part Four: Feedback and Dynamics" - - "Part Five: Cognitive Models" - - NIPS 2009 - - - Summary of available tutorials and demos - - Interactive plots reference sheet - - Building a controlled integrator - - Building a feedforward network (part 1) - - Building a feedforward network (part 2) - - Building a feedforward network (part 3) - - Building a neural integrator - - Building motor cortex (vector representations) - - Demo - Learning feedforward transformations - - Demo - Simple motor control (arm) - - Demo - Somatosensory working memory - - Rapid tutorial - An integrator - - Rapid tutorial - Braitenberg vehicle - - Rapid tutorial - Nonlinear transformations - - NESim Tutorials (not Nengo) Here you will find links to various software that we have written, support, or use a lot. We will attempt to post any software used in a publication. If it diff --git a/ctn_waterloo/content/research/spa_index.md b/ctn_waterloo/content/research/spa_index.md index dbd625a4..11eae067 100644 --- a/ctn_waterloo/content/research/spa_index.md +++ b/ctn_waterloo/content/research/spa_index.md @@ -1,15 +1,12 @@ title: Semantic Pointer Architecture picture: http://i.imgur.com/Tm7hBer.png +category: Theory intro: > Semantic pointers are neural representations that carry partial semantic content and are composable into the representational structures necessary to support complex cognition. These pages describe a cognitive architecture based on them. This architecture has been used to build the world's largest functional brain model, Spaun. -people: - - Chris Eliasmith - - Xuan Choo - - Terry Stewart toc: - Semantic Pointer Architecture diff --git a/ctn_waterloo/content/research/syde-750_index.md b/ctn_waterloo/content/research/syde-750_index.md index 81bbd3d7..219109af 100644 --- a/ctn_waterloo/content/research/syde-750_index.md +++ b/ctn_waterloo/content/research/syde-750_index.md @@ -1,10 +1,8 @@ title: SYDE 556/750 - Simulating Neurobiological Systems picture: http://i.imgur.com/f5JyChE.png +category: Theory intro: > Course information for SYDE 556/750, taught Winter 2016. -people: - - Chris Eliasmith - - Terry Stewart toc: - SYDE 556 Course Outline - SYDE 556 Possible Projects diff --git a/ctn_waterloo/content/research/theoretical-neuroscience/aplysia-whole-brain-model.md b/ctn_waterloo/content/research/theoretical-neuroscience/aplysia-whole-brain-model.md deleted file mode 100644 index 3c8267ab..00000000 --- a/ctn_waterloo/content/research/theoretical-neuroscience/aplysia-whole-brain-model.md +++ /dev/null @@ -1,28 +0,0 @@ -title: Aplysia whole-brain model - -Hello! Xuan and I (Travis) were talking about some possible side projects that -could be fun/interesting, and we arrived at the idea of developing a whole -brain NEF model of the Aplysia sea slug -(http://en.wikipedia.org/wiki/Aplysia_californica) that Eric Kandel started -his work on classical conditioning on way back when (60's? who was even ALIVE -then? man). I think most everyone knows about the slug. It's a great candidate -because much(/most/all?) of the brain has been mapped out and lots of people -have researched a bunch of different areas/functions that we can hopefully use -to build on. From what I've found in my (admittedly incomplete) search of the -internet all that has been developed are models of different areas of the -Aplysia brain and almost all the ones I've found don't model functions, but -put together a network of neurons with similar connections as found in Aplysia -and then run and see what happens. So I thought we could start a private page -on here to post about the development here and chat about this in time when we -need breaks from our own projects, plus it will probably help get everyone -into the whole brain model thinking for the other models we're developing. -Thoughts? Ideas? Already completed models? Here are some links! [Sea Slug -Nervous System Model](http://www.seaslugforum.net/display.cfm?id=4690) -[Cyberbranchaea - Optimal Foraging -Simulation](http://www.life.illinois.edu/slugcity/cyberslug.html) [Learning -and Memory in Aplysia](http://brembs.net/learning/aplysia/) [Neural Mechanisms -of Motor Program Switching in -Aplysia](http://www.jneurosci.org/cgi/content/abstract/21/18/7349) [A Simple -Aplysia-Like Spiking Neural Network to Generate Adaptive Behavior in -Autonomous Robots](http://adb.sagepub.com/cgi/content/abstract/16/5/306?rss=1) -[Development of the nervous system of Aplysia californica.](http://www.pubmedcentral.nih.gov/articlerender.fcgi?artid=393264) diff --git a/ctn_waterloo/content/research/theoretical-neuroscience/brain-nested-controllers-to-do-things-motivation-to-doseefeel-anything.md b/ctn_waterloo/content/research/theoretical-neuroscience/brain-nested-controllers-to-do-things-motivation-to-doseefeel-anything.md deleted file mode 100644 index 5789f393..00000000 --- a/ctn_waterloo/content/research/theoretical-neuroscience/brain-nested-controllers-to-do-things-motivation-to-doseefeel-anything.md +++ /dev/null @@ -1,11 +0,0 @@ -title: Brain = nested controllers to do things + motivation to do/see/feel anything - -Basically, there are streams of stuff (classic works, and a re-emergence in the past few years) pushing deeper into showing that what the brain 'wants' (to obtain or avoid) shapes not only motor outputs, but also things that *should* be free of such influences, i.e., things for which we should have 'true-value' goals rather than 'desired end-state' goals. This includes basic perception, e.g., people can really see what they want to see, - -http://research.chicagogsb.edu/cdr/docs/dunning.pdf - -And also their thoughts, feelings, and perceptions about things and their effects on and for us. For instance, "wanting to like" something often makes people construe mixed, ambiguous or equivocal information about it positively (I have some studies here, plus tons of other work is out there). But motivational forces can also push actions and motor planning in conflict with pre-existing (or otherwise manipulated) cognitions; this is why we can feel compelled to do things we'll regret, even if we know we'll regret them, or can 'want' something we won't 'like'. Neurally speaking, there's converging evidence from Kent Berridge's lab, Bechara, Bush, Zink, Brian Knutson, and some of my own stuff with Antonio Rangel that you can tease apart dissociable (but not disjoint) sub-systems related more to cognitive/emotional appraisal, versus motivational vigour and action planning/motor output. - -From a modeling perspective, to the extent that using control theory is really the way to go for capturing goal orientation in how the brain works (i.e., as providing a means to both specify and achieve 'desired' states, and avoid undesirable ones), *and* given that one can really model every damn thing in the brain using nested/hierarchical controllers (Chris, I think you and I discussed this once with Mark Churchland, and maybe Lloyd?), I think someone could use the NEF to basically nail down all these "whole-brain", cross- and inter-systemic effects of motivation, and come up with a really integrative framework for how motivational forces dissociably and synergistically shape and warp basic perception, feelings/thoughts, and impulses/desires/motor planning/actual actions. This would be a nice step towards understanding how brains operate on their own in the environment to construct sharp and opinionated 'worldviews' and preferences, and thus actually settle on, choose, and plan specific motor outputs (and not others), without the modeler-as-god telling it what it likes, what it should see, or what it should do, or using input signals that are basically designed to do the same. This seems related to how HRRs were used in the Wason Task paper and the follow-up application Paul and I did to abductive hypothesis-generation and inference (only way cooler). - -This would be better than all the robotics stuff on just straight goal-directed behavior, which tend to work in (highly rigid) practice mainly by omitting all the fun representational and guts stuff that might actually be of primary interest to some (i.e., me). diff --git a/ctn_waterloo/content/research/theoretical-neuroscience/chains-of-reasoning.md b/ctn_waterloo/content/research/theoretical-neuroscience/chains-of-reasoning.md deleted file mode 100644 index 72bdef06..00000000 --- a/ctn_waterloo/content/research/theoretical-neuroscience/chains-of-reasoning.md +++ /dev/null @@ -1,4 +0,0 @@ -title: Chains of reasoning - - -This is an attempt to explain where the '50ms per cognitive step' assumption typically found in cognitive architectures comes from. diff --git a/ctn_waterloo/content/research/theoretical-neuroscience/questions-about-the-brain.md b/ctn_waterloo/content/research/theoretical-neuroscience/questions-about-the-brain.md deleted file mode 100644 index 5c8283fe..00000000 --- a/ctn_waterloo/content/research/theoretical-neuroscience/questions-about-the-brain.md +++ /dev/null @@ -1,14 +0,0 @@ -title: Questions about the brain - -The point of this section is to write down any important general questions -that show up via discussion, etc. It will be marked private, since a good -question is often the most important starting point of new research. - -### 1. What about those bias currents - -In all of our models of single neurons, we include a bias or background -current: ` a_i = G_i[ \alpha_i <\tilde{\phi}_i x> + J^{bias}_i> ` The intent -is to include the effects of 'other currents' and provide a 'background' -firing rate. However, when not in vivo cortical cells do not have a background -firing rate. Thus, these currents are not intrinsic. If we think we have -modeled the entire system, we should have no background currents. diff --git a/ctn_waterloo/content/research/theoretical-neuroscience/what-do-we-mean-by-whole-brain-modelling.md b/ctn_waterloo/content/research/theoretical-neuroscience/what-do-we-mean-by-whole-brain-modelling.md deleted file mode 100644 index 92f26e37..00000000 --- a/ctn_waterloo/content/research/theoretical-neuroscience/what-do-we-mean-by-whole-brain-modelling.md +++ /dev/null @@ -1,55 +0,0 @@ -title: What do we mean by 'whole brain' modelling? - -### Introduction - -For various practical reasons, most people choose a brain subsystem (or often -function) in order to build a model. This has the advantage of being doable, -but the disadvantage of considering component parts in isolation from the -entire system (which usually leads to mischaracterizing the part -- often -seriously). An excellent book on how to decompose & analyze complex systems is -Bechtel & Richardson's Discovering Complexity. I won't repeat their arguments -here, but the speak to the importance of 'reintegrating' a system (i.e. -synthesis) after decomposition (i.e. analysis). - -Given our commitment to constructing methods that should help build -arbitrarily large, complex models at various levels of neural detail, I think -it is somewhat natural to consider the question of how to integrate all of the -various modelling projects going on in the lab. - -Right now, I take the major divisions to be: - -### Perception - - * Perceptual integration includes multi-modal integration, as well as including both top-down and bottom-up effects on processing. - - * Perception is hierarchical and recurrent; dimensionality decreases as we progress up the hierarchy - - * Perception attempts to reduce dimensionality by inferring reasonable causal models - -### Action - - * Action integration typically means integrating action with perception - - * Action is hierarchical and recurrent; dimensionality increases as we progress down the hierarchy - - * Action attempts to perform optimal control in a hierarchy, where the top of the hierarchy has the most general specification of a motor goal (e.g. goto position x). - -### Cognition - - * Cognitive integration means tying cognition to action and perception in appropriate ways. Sometimes this means doing less with the cognitive system (and allowing the other systems to be 'smart'). - - * I suspect cognition is abstract perception and action, hence part of the same hierarchies. - -### Motivation - - * The Litt et al (2008) paper is our only real foray into this area. - - * It extremely important for us to better understand learning, motivation, etc. I'm thinking mainly of TD-learning types of models (or Q-learning, etc.), which have been usefully mapped to dopamine and serotonin subsystems found in brainstem and basal ganglia. - - * 'Old' valuation systems (midbrain) must be integrated with 'new' evaluation systems (cortex), as in the Litt paper. - -### An overall view - -(unfinished) * Hierarchies in and out, with linking the two & motivation -guiding resource allocation * Nested (hierarchical) controllers strike me as a -fruitful avenue of understanding integration and neural organization diff --git a/ctn_waterloo/content/research/theoretical-neuroscience/what-is-theoretical-neuroscience.md b/ctn_waterloo/content/research/theoretical-neuroscience/what-is-theoretical-neuroscience.md index f6ed7df2..319ba283 100644 --- a/ctn_waterloo/content/research/theoretical-neuroscience/what-is-theoretical-neuroscience.md +++ b/ctn_waterloo/content/research/theoretical-neuroscience/what-is-theoretical-neuroscience.md @@ -1,9 +1,5 @@ title: What is theoretical neuroscience? -## What is theoretical neuroscience? - - - In recent years, most of the behavioral sciences have seen a heavy influx of influence from the neurosciences. Most obviously, the psychology of only three decades ago was almost bereft of brain-related talk. Now, however, one of the @@ -39,8 +35,8 @@ the development of such tools is theoretical physics. Interestingly, an analogous subfield has been developing in neuroscience over the last few decades as well, and it is often appropriately called -“theoretical neuroscience” (though perhaps equally as often called -“computational neuroscience”). In fact, the analogy between theoretical +"theoretical neuroscience" (though perhaps equally as often called +"computational neuroscience"). In fact, the analogy between theoretical neuroscience and theoretical physics is quite useful for understanding the importance of theoretical neuroscience to neuroscience in general. For instance, both theoretical physics and theoretical neuroscience are centrally @@ -49,12 +45,12 @@ statistically quantifying the data generated by the phenomena, but rather coming up with quantitative descriptions of the deterministic regularities and mechanisms giving rise to those data. Take, for instance, one of the greatest advances in theoretical physics, the development of Newton's three laws of -motion. The second, perhaps most famous, law is that “The alteration of motion +motion. The second, perhaps most famous, law is that "The alteration of motion is ever proportional to the motive force impressed; and is made in the -direction of the right line in which that force is impressed” (Newton, 1729, +direction of the right line in which that force is impressed" (Newton, 1729, p. 19). In short form: F=ma. The purpose of this statement is to make a clear, -straightforward hypothesis about motion. I describe similar principles in the -sections [sub:Representation-NEF]-[sub:Dynamics-NEF]???links for neural +straightforward hypothesis about motion. Similar principles in the +Neural Engineering Framework for neural representation, transformation, and dynamics. @@ -101,14 +97,10 @@ theoretical physics, theoretical neuroscience can help in at least two crucial ways. Specifically, it should: - - - 1. Quantify, and hence make more precise and testable, hypotheses about the functioning of neural systems; - 2. Summarize large amounts of experimental data, and hence serve to unify the many sources of data from different “neuro-” and behavioral sub-disciplines. - + 2. Summarize large amounts of experimental data, and hence serve to unify the many sources of data from different "neuro-"" and behavioral sub-disciplines. The first of these stem from the commitment to using mathematics to describe @@ -122,10 +114,10 @@ systems. Large neural systems where all of the parts are the same, and interact in the same way simply do not exist. -Thus, the links between the “lowest” and “highest” levels of characterizing +Thus, the links between the "lowest" and "highest" levels of characterizing neural systems are complex and unavoidable. It is perhaps in this kind of circumstance that quantification of the system of interest plays its most -crucial role. If we can state our hypotheses about neural function at a “high” +crucial role. If we can state our hypotheses about neural function at a "high" level, and quantify the relationship between levels, then our high-level hypothesis will connect to low-level details. In fact, ideally, a hypothesis at any level should contact data at all other levels. It is precisely this @@ -135,21 +127,15 @@ eventually a mature theory of biological cognition. This ideal role for theoretical neuroscience has not yet been realized. -Perhaps this is because there has historically been more of a focus on “low” +Perhaps this is because there has historically been more of a focus on "low" levels of neural systems (i.e. single cells or small networks). This is perfectly understandable in light of the complexity of the system being -tackled. Nevertheless, I believe we are now in a position to begin to move +tackled. Nevertheless, we believe we are now in a position to begin to move past this state of affairs. -In the context of this book, I will adopt methods from theoretical -neuroscience that I believe currently have the best potential to realize this -ideal role. At the same time I hope the contents of this book will prod +In the context of our lab, we adopt methods from theoretical +neuroscience that we believe currently have the best potential to realize this +ideal role. At the same time we hope our work will prod theoretical neuroscientists to consider expanding the viable areas of -application of their methods to all of the behavioral sciences. In the next -section I introduce a series of theoretical principles developed in the -context of traditional theoretical neuroscience. In subsequent chapters I -suggest a way of applying these same principles to large-scale, cognitive -modeling. This should help to not only test, but also to refine such -principles, and it will help make our cognitive models subject to data from -all of the various disciplines of the behavioral sciences. +application of their methods to all of the behavioral sciences. diff --git a/ctn_waterloo/content/research/theoretical-neuroscience/whole-brain-simulation.md b/ctn_waterloo/content/research/theoretical-neuroscience/whole-brain-simulation.md deleted file mode 100644 index ffb72dae..00000000 --- a/ctn_waterloo/content/research/theoretical-neuroscience/whole-brain-simulation.md +++ /dev/null @@ -1,15 +0,0 @@ -title: Whole brain simulation - -The NEF methods are really ideal for doing extremely large scale neural simulations. Here are several reasons why: - -1. Ability to swap single cell models of arbitrary precision -2. Ability to analytically determine population connectivity -3. Ability to add/remove learning as desired -4. Ability to abstract over spiking neurons (to rate neurons) -5. Ability to abstract over rate neurons (to populations) -6. Ability to abstract over populations (to control models) -7. Ability to abstract over inhibitory/excitatory connections - -It might make something of a technical splash to run a simulation of 100 million neurons that actually do something (as opposed to the splash made by Izchevich which just ran that size of network). - -To summarize, we have very adjustable simulation scales, which can be exploited by many people other than us. As well, the simulation scales can be adjusted independently for different parts of the model. People really don't know how to do this in general. There is a big desire to extract computational principles from brain models. There is also a converse but equally large desire to make large models highly detailed so as to compare them to neural data. The NEF provides a smooth means of doing both. diff --git a/ctn_waterloo/content/research/theoretical-neuroscience_index.md b/ctn_waterloo/content/research/theoretical-neuroscience_index.md index b497aed7..405a441a 100644 --- a/ctn_waterloo/content/research/theoretical-neuroscience_index.md +++ b/ctn_waterloo/content/research/theoretical-neuroscience_index.md @@ -1,8 +1,8 @@ title: Theoretical Neuroscience picture: http://i.imgur.com/JiZ67DA.png +category: Applications intro: Exploring general issues in theoretical neuroscience. -people: - - Chris Eliasmith + toc: - What is theoretical neuroscience? - Correlations, network structure and the NEF diff --git a/ctn_waterloo/content/research_index.md b/ctn_waterloo/content/research_index.md index 14928423..4d15ec9c 100644 --- a/ctn_waterloo/content/research_index.md +++ b/ctn_waterloo/content/research_index.md @@ -4,9 +4,11 @@ topics: - syde-750 - spa - cognition - - motor-control + - control - perception + - philosophy - software - theoretical-neuroscience - constants-constraints + - neuromorphic-hardware - other diff --git a/ctn_waterloo/model.py b/ctn_waterloo/model.py index 6a4aa95a..efd1fc81 100644 --- a/ctn_waterloo/model.py +++ b/ctn_waterloo/model.py @@ -56,13 +56,14 @@ def person(self, person): return person def people(self, group=None): - if group is None: - test = lambda p: p.path.startswith('people/') - else: - test = lambda p: p.path.startswith('people/') and p['group'] == group - - people = sorted([self.person(p) for p in self.pages if test(p)], - key=lambda p: p['name']) + """Returns a list, sorted by name, of people belonging to a group""" + + # define function to test membership with + test = lambda p: p.path.startswith('people/') and p['group'] == group + # get members + members = [self.person(p) for p in self.pages if test(p)] + # sort members by name + people = sorted(members, key=lambda p: p['name']) return people def publication(self, pub): @@ -108,6 +109,20 @@ def publications(self, end=None, start=None, author=None): return allpubs + def research_categories(self, cat): + """Returns a list of research topics belonging to a category""" + def test(p): + try: + return (p.path.startswith('research/') and + p.meta['category'] == cat) + except KeyError: + return False + + # get members + members = [p for p in self.pages if test(p)] + # TODO: Return in a certain order? Maybe a determined index? + return members + def research(self, topic): def _recursive_map(f, data): if isinstance(data, list): @@ -126,7 +141,10 @@ def _flatten(l): page.url = url_for('research_topic', topic=topic) page.toc = _recursive_map( lambda title: {'title': title, - 'url': url_for('research_page', topic=topic, slug=slugify(title))}, + 'url': url_for('research_page', + topic=topic, + slug=slugify(title)) + }, page['toc']) page.articles = [self.pages.get('research/' + topic + '/' + slugify(p['title'])) diff --git a/ctn_waterloo/templates/research_index.html b/ctn_waterloo/templates/research_index.html index a9436489..7636cbfa 100644 --- a/ctn_waterloo/templates/research_index.html +++ b/ctn_waterloo/templates/research_index.html @@ -5,7 +5,11 @@ {% block main %}
-
{% endfor %} + {% endfor %}
{% endblock main %}