Component catalogue
A model is an encoder, a core network and a decoder (see Model architecture), each selected by a name in the configuration. This page lists the core types, the encoder and decoder types, and the registries through which code adds new components. The other lists of names (synapse types, activations, training strategies, datasets, analyzers and more) live on the pages that explain them; Other component lists links to them.
Component names are resolved when the component is built, not when the
configuration loads, so a misspelled name passes the loader and fails when
the model, dataset or trainer is built. dendritic-train --validate-only
builds every component without training and reports such errors.
Core types
model.core.type selects the core. Names are case-insensitive.
dendritic_modeling.networks.architectures.factory.get_available_architectures()
returns every built-in name and every registered extension.
Population networks
|
Core |
Configuration |
|---|---|---|
|
Layers of named excitatory and inhibitory populations with explicit, directed connections, feedforward or recurrent; each population has its own morphology and options. See Population networks. |
|
Structured E/I cores
Stacks of excitation/inhibition (E/I) layers: each layer has an excitatory
population of dendritic trees and an optional inhibitory population, wired by
synapse counts per branch. They read the sections
model.core.architecture, connectivity, transfer, morphology,
sparsity, reactivation, blocklinear and implementation; a
recurrent structured core also reads dynamics, synapse_types,
dendritic_spikes, soma_feedback and recurrent_ei. See
Structured E/I cores, and Integration modes for the integration
rules.
|
Core |
|---|---|
|
Structured E/I core whose integration rule comes from
|
|
Shunting (divisive) inhibition. |
|
Raw additive (subtractive) inhibition. |
|
Additive inhibition with voltage normalization. |
|
Signed weights ( |
|
Signed weights in one synapse bank per branch that reads the excitatory and inhibitory inputs together, combined additively. |
|
The |
Recurrent unified E/I cores
Layered E/I networks with an excitatory and an optional inhibitory population
per layer, feedforward or recurrent, configured by model.core.unified_ei.
See Unified E/I core.
|
Core |
|---|---|
|
Each population’s options set its integration rule and morphology.
The names |
|
|
|
As the |
Spatial cores
Cores for image-shaped inputs (batch, channels, height, width). See
Embedded and spatial cores.
|
Core |
Configuration |
|---|---|---|
|
Flattens the input and applies a structured E/I core to it, without spatial locality. |
Structured E/I sections |
|
Applies one shared structured E/I core to every local patch and
returns a |
Structured E/I sections and |
|
An AlexNet-shaped network of dendritic convolution stages and a dendritic classifier. |
|
Baselines and controls
Conventional networks for comparisons, described in Baselines and comparison models.
|
Core |
Configuration |
|---|---|---|
|
Dense, fixed-sparse or learned Top-K multilayer perceptron. |
|
|
Conventional feature normalization and dense affine readout |
|
|
Paired nonnegative E/I source routing, shunting or additive branches, and an affine readout; a reduced control, not a population network. |
|
|
Point-neuron MLPs matched to the parameter count of a dendritic reference. |
Structured E/I sections or |
|
Sparse structured MLPs with the branch structure of a structured E/I reference. |
Structured E/I sections |
|
One-layer point controls matched to the effective parameter count of a structured E/I reference. |
Structured E/I sections |
|
The sparse matched control applied to local image patches. |
Structured E/I sections and |
|
PyTorch recurrent networks. |
|
|
Sparse point-neuron E/I network with leaky channels of several time constants. |
|
|
Fixed Legendre delay-network memory with sparse learned input and readout. |
|
Pass-through
identity (alias none) passes the encoder output to the decoder
unchanged; it reads no section.
Names that are not core types
The architecture factory also builds encoder, decoder and Python building
blocks: mlp, effectivematchedparammlp, alexnet, cnn,
cnn_down, cnn_downsample, cnndownsample, cnn_up,
cnn_upsample, cnnupsample, mlpautoencoder,
mlpvariationalautoencoder, cnnautoencoder,
cnnvariationalautoencoder, pathway_router and router. They take
flat parameters that model.core cannot express, so model.core.type set
to one of them raises an error that names the alternatives (affine_mlp for
a plain MLP core, point_mlp for a matched control).
Encoder and decoder types
model.encoder.type and model.decoder.type select the encoder and the
decoder; their options go under model.encoder.params and
model.decoder.params. Names are case-insensitive. The loader rejects an
option that the selected type does not read, unless it holds its default
value.
Encoders:
|
Encoder and the options it reads |
|---|---|
|
Passes the input through. |
|
Routes the input features into separate pathways and concatenates
their outputs. |
|
The encoder half of a multilayer-perceptron (variational) autoencoder:
|
|
The encoder half of a convolutional (variational) autoencoder:
|
Decoders:
|
Decoder and the options it reads |
|---|---|
|
A multilayer perceptron from the core output to |
|
Passes the core output through. A written |
The decoder’s input_dim is always set from the core output size. Other
names, such as linear or the CNN building blocks, load but fail when
the model is built.
Pretraining autoencoder encoders
An autoencoder encoder is trained before the main phase. With
training.encoder_pretraining.epochs positive, dendritic-train first
trains the whole autoencoder to reconstruct the training inputs and keeps the
state with the lowest validation loss; its encoder then feeds the core. A
trained autoencoder can instead come from model.initial_checkpoint (with
epochs: 0). Without either, the run raises.
model:
encoder:
type: mlpautoencoder
params: {encoder_hidden_dims: [256], latent_dim: 32, decoder_hidden_dims: [256]}
training:
encoder_pretraining:
epochs: 50 # 0 (default): no pretraining
batch_size: 256
loss_function: mse # mse | log_mse | bce | vae_elbo (variational only)
optimizer: adam
learning_rate: 0.001
weight_decay: 0.0
early_stopping: true
patience: 10
grad_clip_value: null
freeze_encoder: true # false: the encoder trains with the model
With freeze_encoder (the default) the encoder receives no gradients in
the main phase and stays in evaluation mode, so a variational encoder returns
its latent mean; the run directory holds the pretraining losses in
encoder_pretraining/summary.json, and the model checkpoints contain the
encoder. Pretraining runs in single-process training: start a DDP run from the
checkpoint of a single-process run, and use another encoder with FSDP. A
positive epochs with an encoder that is not an autoencoder raises.
dendritic-train and the FSDP entry point check these requests for the
built-in encoder types before they create the run directory, so a rejected
request leaves no files behind; an encoder that a plugin builds is checked once
the model is built.
Extension registries
Code outside the library adds named components by registering them. A registered name is then accepted wherever the configuration selects that kind of component.
Function |
Registers |
Selected by |
Name rules |
|---|---|---|---|
|
A core builder, called as |
|
Built-in names are reserved; an existing extension name needs
|
|
A sparse synapse class, built as |
|
Existing names, built-in or registered, need |
|
An activation or reactivation-gate builder. |
|
Existing names need |
|
A |
|
Existing names, built-in or registered, need |
|
An optimizer builder, called as |
|
Existing names need |
|
A loss builder, a callable without arguments that returns a
|
|
Existing names need |
|
A dataset builder, called with the task configuration; it returns
|
|
Registered names are looked up before the built-in loaders, so
registering a built-in name such as |
|
A sequence-task builder, called as |
|
Existing names need |
|
An analyzer: configuration field, class, output directory and the phase of the analysis order it runs in. |
|
Existing names need |
|
The estimator class of one information estimation method. |
|
Only the members of |
Registrations run in the process that uses them. A package makes them available to every DendriNet command and script by declaring them as a plugin, which the library loads before the first configuration, whenever a registry meets a name it does not know and whenever a registry lists its names; plugins can also register configuration sections, model builders and additive integration rules (Extending DendriNet).
Other component lists
Components |
Where they are listed |
|---|---|
Sparse synapse types ( |
|
Weight transforms ( |
|
Synapse initialization ( |
|
Activations and reactivation gates ( |
|
Indexed projection backends ( |
|
Population options, connections and time constants |
Options reference, Connections, Temporal constants and delays |
Receptor synapse types, spiking soma, dendritic spikes and soma feedback |
|
Training strategies ( |
|
Loss functions ( |
|
Optimizers ( |
|
Datasets ( |
|
Analyzers ( |
|
Baselines and matched controls |