This project is a subproject from a bigger and older project called CAI and is sister to Keras based K-CAI NEURAL API. You can find trained neural network models in the pre-trained-neural-api-networks repository.

Basics of Neural Networks in Pascal - Loading and Saving	Neural Networks for Absolute Beginners! Learning a Simple Function	Coding a Neural Network in Pascal that Learns to Calculate the Hypotenuse

• The Pascal computer language is easy to learn. Pascal allows developers to make a readable and understandable source code.
• You'll be able to make super-fast native code and at the same time have a readable code.
• This API can outperform some major APIs in some architectures.

You'll need Lazarus development environment. If you have an OpenCL capable device, you'll need its OpenCL drivers. Many examples use the CIFAR-10 dataset. You'll also find examples for the CIFAR-100, MNIST, Fashion MNIST and the Places365-Standard Small images 256x256 dataset.

This project is Lazarus based. That said, as of release v2.0.0, a number of units do compile with Delphi and you can create and run neural networks with Delphi. You'll be able to compile these units with Delphi: neuralvolume, neuralnetwork, neuralab, neuralabfun, neuralbit, neuralbyteprediction, neuralcache, neuraldatasets, neuralgeneric, neuralplanbuilder, Neural OpenCL, Neural Threading and neuralfit.

Clone this project, add the neural folder to your Lazarus unit search path and you'll be ready to go!

You can get A.I. powered help from these tools:

• CAI Neural API support at Poe (free)
• CAI Neural API support at Poe
• CAI Neural API support at ChatGPT4

The documentation covers:

• Easy examples
• Simple image classification examples
• Youtube videos
• Advanced examples
• Data structures (Volumes)
• Neural network layers
• Dataset support
• Training (fitting) your neural network
• Parallel computing
• Full set of examples
• Normalization Cheat Sheet
• Layer Authoring Guide — checklist for adding a new layer plus mini-guides on reading numerical-gradient failures and picking a tolerance
• Other scientific publications from the same author

You can click on the image above to watch the video.

Assuming that you would like to train a neural network to learn a function that has 2 inputs and one output, you could start with something like this:

    NN.AddLayer([
      TNNetInput.Create(2),
      TNNetFullConnectReLU.Create(32),
      TNNetFullConnectReLU.Create(32),
      TNNetFullConnectLinear.Create(1)
    ]);

The example above has 2 inputs (TNNetInput), 2 dense layers (TNNetFullConnectReLU) with 32 neurons each and one output (TNNetFullConnectLinear).

You can learn more about how to build and train simple neural networks at the following source code examples:

• Only one neuron
• Training a neural network to learn the hypotenuse function
• Training a neural network to learn the hypotenuse function with FitLoading
• Training a neural network to learn boolean functions AND, OR and XOR with neuralfit unit
• Training a neural network to learn boolean functions AND, OR and XOR without neuralfit unit
• Reptile first-order meta-learning: learning an initialization that adapts to a new sine-regression task in a few SGD steps
• Lottery Ticket Hypothesis: magnitude-prune a small dense net, then retrain the sparse mask from the original init vs from fresh random weights — the original-init "winning ticket" matches the dense net and beats random reinit at moderate-to-high sparsity (pure CPU)

Loading is very easy:

    NN := TNNet.Create;
    NN.LoadFromFile('MyTrainedNeuralNetwork.nn');

Saving is as easy:

    NN.SaveToFile('MyTrainedNeuralNetwork.nn');

The CIFAR-10 dataset is a well-known collection of images commonly used to train machine learning and computer vision algorithms. It was created by the Canadian Institute for Advanced Research (CIFAR). It contains 60K 32x32 color images. The images are classified into 10 different classes, with 6,000 images per class. The classes represent airplanes, cars, birds, cats, deer, dogs, frogs, horses, ships, and trucks. Despite its relatively low resolution and small size, CIFAR-10 can be challenging for models to achieve high accuracy, making it a good dataset for testing advancements in machine learning techniques.

Follows a source code example for the CIFAR-10 image classification:

NN := TNNet.Create();
NN.AddLayer([
  TNNetInput.Create(32, 32, 3), //32x32x3 Input Image
  TNNetConvolutionReLU.Create({Features=}16, {FeatureSize=}5, {Padding=}0, {Stride=}1, {SuppressBias=}0),
  TNNetMaxPool.Create({Size=}2),
  TNNetConvolutionReLU.Create({Features=}32, {FeatureSize=}5, {Padding=}0, {Stride=}1, {SuppressBias=}0),
  TNNetMaxPool.Create({Size=}2),
  TNNetConvolutionReLU.Create({Features=}32, {FeatureSize=}5, {Padding=}0, {Stride=}1, {SuppressBias=}0),
  TNNetFullConnectReLU.Create({Neurons=}32),
  TNNetFullConnectLinear.Create(NumClasses),
  TNNetSoftMax.Create()
]);

CreateCifar10Volumes(ImgTrainingVolumes, ImgValidationVolumes, ImgTestVolumes);

WriteLn('Neural Network will minimize error with:');
WriteLn(' Layers: ', NN.CountLayers());
WriteLn(' Neurons:', NN.CountNeurons());
WriteLn(' Weights:', NN.CountWeights());

NeuralFit := TNeuralImageFit.Create;
NeuralFit.InitialLearningRate := fLearningRate;
NeuralFit.Inertia := fInertia;
NeuralFit.Fit(NN, ImgTrainingVolumes, ImgValidationVolumes, ImgTestVolumes, NumClasses, {batchsize}128, {epochs}100);

These examples train a neural network to classify images in classes such as: image has a cat, image has a dog, image has an airplane...

• Simple CIFAR-10 Image Classifier
• Simple CIFAR-10 Image Classifier with OpenCL
• Many neural network architectures for CIFAR-10 image classification
• MNIST, Fashion MNIST and CIFAR-100

You can save and load trained models (neural networks) with TNNet.SaveToFile and TNNet.LoadFromFile. The file format is portable meaning that you can train on CPU and run on GPU or train in AMD and run on ARM as examples. The following code shows a simple example for image classification loading a pre-trained model:

  procedure ClassifyOneImageSimple;
  var
    NN: TNNet;
    ImageFileName: string;
    NeuralFit: TNeuralImageFit;
  begin
    WriteLn('Loading Neural Network...');
    NN := TNNet.Create;
    NN.LoadFromFile('SimplePlantLeafDisease-20230720.nn');
    NeuralFit := TNeuralImageFit.Create;
    ImageFileName := 'plant/Apple___Black_rot/image (1).JPG';
    WriteLn('Processing image: ', ImageFileName);
    WriteLn(
      'The class of the image is: ',
      NeuralFit.ClassifyImageFromFile(NN, ImageFileName)
    );
    NeuralFit.Free;
    NN.Free;
  end;  

Basics of Neural Networks in Pascal - Loading and Saving	Neural Networks for Absolute Beginners! Learning a Simple Function	Coding a Neural Network in Pascal that Learns to Calculate the Hypotenuse
Pre-trained Neural Networks & Transfer Learning with Pascal's CAI Neural API	Coding a Neural Network in Pascal that Learns the OR Boolean Operation	A Dive into Identity Shortcut Connection - The ResNet building block
Increasing Image Resolution with Neural Networks	Ultra Fast Single Precision Floating Point Computing	AVX and AVX2 Code Optimization

Some videos make referrence to uvolume unit. The current neuralvolume unit used to be called uvolume. This is why it's mentioned.

Although these examples require deeper understanding about neural networks, they are very interesting:

• Identity Shortcut Connection - ResNet building block
• ResNet-20 - includes a web server example
• DenseNetBC L40
• Separable Convolutions - MobileNet building block
• Gradient Ascent - Visualizing patterns from inner neurons in image classification

  

• Artificial Art - Let a neural network produce art via a generative adversarial network

  

• Super Resolution - A neural network learns how to increase image resolution

  

• CIFAR-10 Resized - A program that resizes CIFAR-10 and CIFAR-100 images to 64x64 and 128x128 pixels.

  

  

• Autoencoder - Shows an autoencoder built with hyperbolic tangents and trained with Tiny ImageNet 200.

  

There is also a full set of examples that you can look at.

Volumes behave like dynamically created arrays. They are the main array like structure used by this API. TNNetVolume class allows you to create volumes that can be accessed as 1D, 2D or 3D arrays and be operated with Advanced Vector Extensions (AVX) - Single Instruction Multiple Data (SIMD) instruction set. The usual way to create a volume is:

constructor Create(pSizeX, pSizeY, pDepth: integer; c: T = 0);

You can access the data as 1D or 3D with:

property Raw[x: integer]: T read GetRaw write SetRaw;
property Data[x, y, d: integer]: T read Get write Store; default;

Your code will look like this:

// Usage Examples
vInput := TNNetVolume.Create(32, 32, 3);
vInput[1, 1, 1] := 1;
vInput[2, 2, 2] := vInput[1, 1, 1] + 1;
vInput.Raw[10] := 5;

vInput.RandomizeGaussian();
WriteLn('Avg: ', vInput.GetAvg());
WriteLn('Variance: ', vInput.GetVariance());
WriteLn('Std Dev: ', vInput.GetStdDeviation());

WriteLn('Multiplying by 10');
vInput.Mul(10);
WriteLn('Avg: ', vInput.GetAvg());
WriteLn('Variance: ', vInput.GetVariance());
WriteLn('Std Dev: ', vInput.GetStdDeviation());

As examples, you can add, subtract, multiply and calculate dot products with:

procedure Add(Original: TNNetVolume); overload;
procedure Sub(Original: TNNetVolume); overload;
procedure Mul(Value: Single); overload;
function DotProduct(Original: TNNetVolume): TNeuralFloat; overload;

In the case that you need the raw position or raw pointer to an element of the volume, you can get with:

function GetRawPos(x, y, d: integer): integer; overload;
function GetRawPos(x, y: integer): integer; overload;
function GetRawPtr(x, y, d: integer): pointer; overload;
function GetRawPtr(x, y: integer): pointer; overload;
function GetRawPtr(x: integer): pointer; overload;

You can easily operate volumes with OpenCL via TEasyOpenCLV:

  TEasyOpenCLV = class (TEasyOpenCL)
    public
      function CreateBuffer(flags: cl_mem_flags; V: TNNetVolume): cl_mem; overload;
      function CreateInputBuffer(V: TNNetVolume): cl_mem; overload;
      function CreateHostInputBuffer(V: TNNetVolume): cl_mem; overload;
      function CreateOutputBuffer(V: TNNetVolume): cl_mem; overload;
      function CreateBuffer(V: TNNetVolume): cl_mem;  overload;

      function WriteBuffer(buffer: cl_mem; V: TNNetVolume; blocking: cl_bool = CL_FALSE): integer;
      function ReadBuffer(buffer: cl_mem; V: TNNetVolume; blocking: cl_bool = CL_TRUE): integer;

      function CreateAndWriteBuffer(V: TNNetVolume; var buffer: cl_mem): integer; overload;
      function CreateAndWriteBuffer(V: TNNetVolume): cl_mem; overload;
      function CreateWriteSetArgument(V: TNNetVolume; kernel:cl_kernel; arg_index: cl_uint): cl_mem;
      function CreateOutputSetArgument(V: TNNetVolume; kernel:cl_kernel; arg_index: cl_uint): cl_mem;
  end;

Volumes can be organized in pairs:

  /// Implements a pair of volumes
  TNNetVolumePair = class(TObject)
    protected
      FA: TNNetVolume;
      FB: TNNetVolume;
    public
      constructor Create(); overload;
      constructor Create(pA, pB: TNNetVolume); overload;
      constructor CreateCopying(pA, pB: TNNetVolume); overload;

      destructor Destroy(); override;

      property A:TNNetVolume read FA;
      property B:TNNetVolume read FB;
      property I:TNNetVolume read FA;
      property O:TNNetVolume read FB;
  end;

Depending on the problem that you are trying to solve, modelling the training with pairs or pair lists might be helpful. Typically, a pair will be (input, desired output). This is how volume lists and volume pair lists have been implemented:

TNNetVolumeList = class (specialize TFPGObjectList<TNNetVolume>
TNNetVolumePairList = class (specialize TFPGObjectList<TNNetVolumePair>)

The layered structure of artificial neural networks is inspired by the organization of the human brain and nervous system. In the human brain, information processing occurs in a hierarchical manner. Sensory inputs are first processed by lower-level neurons, which extract simple features. These features are then passed on to deeper neurons that combine them to recognize more complex patterns. This hierarchical processing is mirrored in artificial neural networks through the use of stacked layers.

Biological neurons are connected to each other through synapses, forming complex networks. Similarly, in artificial neural networks, neurons in one layer are connected to neurons in the next layer, mimicking this interconnected structure. Biological neurons fire (activate) based on a non-linear response to their inputs. This non-linearity is crucial for the brain's ability to learn complex patterns. In artificial neural networks, we use non-linear activation functions (such as ReLU) to introduce this non-linearity. Different regions of the brain specialize in processing different types of information. For instance, the visual cortex has layers specialized for detecting edges, shapes, and complex objects. This specialization is reflected in artificial neural networks, where different layers can learn to recognize different levels of abstraction.

In the context of artificial neural networks, we can see this biologically-inspired layered approach implemented. For example:

NN := TNNet.Create();
NN.AddLayer([
  TNNetInput.Create(32, 32, 3),
  TNNetConvolutionLinear.Create({neurons=}16, {featuresize}3, {padding}1, {stride}1),
  TNNetReLU6.Create()
]);

This code snippet demonstrates the creation of a neural network with an input layer and a convolutional layer followed by a ReLU6 activation. This structure is inspired by the visual cortex in the brain, where neurons respond to specific patterns in their receptive fields, similar to how convolutional layers operate. The CAI Neural API also supports the creation of more complex, biologically-inspired architectures. These architectures are designed with multiple layers of different types, mirroring the complex structure of the brain.

Artificial neural networks with multiple layers and specialized structures are inspired by the hierarchical and specialized nature of biological neural processing. It's important to note that while artificial neural networks are inspired by biological neural networks, they are highly simplified models. The human brain is far more complex, with various types of neurons, complex connectivity patterns, and mechanisms we don't yet fully understand. However, the layered structure in artificial neural networks has proven to be a powerful approach for solving complex problems in machine learning, inspired by the remarkable capabilities of biological neural networks.

The input layer serves as the gateway to the entire network. It's like the sensory organs of our brain, receiving information from the outside world. Without an input layer, the neural network would have no way to receive and interpret the initial data, making it impossible to perform any meaningful computations or learning tasks. The TNNetInput class implements the input layer.

Fully connected layers, also known as dense layers, are a fundamental component of neural networks. In these layers, every neuron is connected to every neuron in the previous layer, allowing for comprehensive information processing across the entire network.

In the context of the CAI Neural API, fully connected layers are represented by various classes derived from TNNetFullConnect. These layers play a crucial role in transforming input data and learning complex patterns.

The computation process in a fully connected layer involves:

1. Multiplying input values by the layer's weights.
2. Adding bias terms (if not suppressed).
3. Applying an activation function (if present).

Key types of fully connected layers include:

1. TNNetFullConnectLinear: a basic fully connected layer without an activation function. It performs a linear transformation of the input data.
2. TNNetFullConnectReLU: incorporates the Rectified Linear Unit (ReLU) activation function. ReLU introduces non-linearity by outputting the input for positive values and zero for negative values, helping the network learn complex patterns.
3. TNNetFullConnectSigmoid: applies the sigmoid activation function to the layer's output. Sigmoid squashes the output between 0 and 1, useful for binary classification tasks.
4. TNNetComplexLinear: the 2-dimensional complex base rung of the same Cayley–Dickson family — each 2-channel group (Re,Im) is multiplied by a learned complex w = a + b·i via the 2×2 complex-multiply block [[a,-b],[b,a]] (Re' = a·Re − b·Im, Im' = a·Im + b·Re), using ~1/2 the weights of an equal-width real dense layer while still mixing the real and imaginary parts. The forward block equals the true complex product and is norm-multiplicative |w·X| = |w|·|X|. Input/output Depth must be multiples of 2. See examples/ComplexLinear/.
5. TNNetQuaternionLinear: a hypercomplex dense layer that shares each 4×4 Hamilton block from a single learned quaternion, coupling 4-channel groups (rotation/scaling in quaternion space) with ~1/4 the weights of an equal-width real dense layer. Input/output Depth must be multiples of 4.
6. TNNetOctonionLinear: the 8-dimensional octonion (Cayley–Dickson) generalization of the above — each 8-channel group is multiplied by a learned octonion via the (non-associative) octonion product, assembled as an 8×8 signed block, using ~1/8 the weights of an equal-width real dense layer. The implementation hard-codes an auditable Cayley–Dickson sign table verified by a norm-multiplicativity test (|W·X| = |W|·|X|). Input/output Depth must be multiples of 8. See examples/OctonionLinear/.

Fully connected layers are typically used in neural network architectures as:

1. Hidden layers for processing and transforming features.
2. Output layers for producing final predictions.

For example, in the provided context, we see a simple neural network structure:

NN := TNNet.Create();
NN.AddLayer([
  TNNetInput.Create(2),       // Input layer with 2 inputs
  TNNetFullConnect.Create(2), // Hidden fully connected layer with 2 neurons
  TNNetFullConnect.Create(1)  // Output fully connected layer with 1 neuron  
]);

Neurons, filters, and kernels are often used as synonyms in the context of neural networks, particularly in convolutional neural networks (CNNs). They are closely related concepts that are used interchangeably. Here's why:

• Neurons: in artificial neural networks, neurons are the basic computational units. They receive input, process it, and produce an output. In the context of CNNs, the term "neuron" is sometimes used to refer to a single element in a feature map.
• Filters: in CNNs, filters (also called convolution kernels) are small matrices of weights that slide over the input data to detect specific features. Each filter produces a feature map in the output layer.
• Kernels: in image processing and CNNs, kernels are small matrices used for various operations like blurring, sharpening, or edge detection. In the context of CNNs, kernels and filters are essentially the same thing. The reason these terms are often used synonymously is that they all contribute to the feature detection and transformation process in neural networks:
  • A single filter/kernel can be thought of as a specialized neuron that detects a specific feature across the entire input.
  • The weights in a filter/kernel are analogous to the weights in a traditional neuron.
  • The output of applying a filter/kernel to an input region is similar to the activation of a neuron in response to its inputs.

In practice, when implementing CNNs, the terms "filter" and "kernel" are more commonly used than "neuron" when referring to the convolutional layers. However, the underlying concept of a computational unit that processes input and produces output remains the same across these terms.

Convolutional layers are fundamental building blocks in neural networks, particularly in the field of computer vision and image processing. They are designed to automatically and adaptively learn spatial hierarchies of features from input data, such as images.

In the context of the CAI Neural API, convolutional layers are implemented as classes derived from TNNetConvolutionAbstract. This abstract base class provides the core functionality for convolutional operations.

The structure of a convolutional layer typically includes:

1. Input: A multi-dimensional array (usually 3D for images: width, height, and channels).
2. Kernels (or filters): small matrices of weights that slide over the input.
3. Feature maps: the output produced by applying the kernels to the input.

Key parameters of convolutional layers include:

• Number of features (or filters).
• Feature size (kernel size).
• Padding.
• Stride.

The CAI Neural API offers several types of convolutional layers:

1. TNNetConvolution: the standard convolutional layer.
2. TNNetConvolutionLinear: a convolutional layer without an activation function.
3. TNNetConvolutionReLU: a convolutional layer with a ReLU activation function.
4. TNNetComplexConv: the 2-dimensional complex base rung of the same Cayley–Dickson convolution family — each 2-channel input patch (Re,Im) is complex-multiplied by a learned complex filter tap w = a + b·i (Re' = a·Re − b·Im, Im' = a·Im + b·Re) and accumulated, coupling the real and imaginary parts across space using only ~1/2 the weights of an equal-width real convolution. Input Depth and the feature count must both be multiples of 2. It reuses the gradient-checked 2×2 complex-multiply forward/backward kernel of its dense sibling TNNetComplexLinear. See examples/ComplexLinear/.
5. TNNetQuaternionConv: a hypercomplex convolution whose per-output-channel filter taps are quaternion weights — each 4-channel input patch is Hamilton-multiplied by a learned quaternion and accumulated, so the four channel components are coupled (rotation/scaling in quaternion space) using only ~1/4 the weights of an equal-width real convolution. Input Depth and the feature count must both be multiples of 4. It reuses the gradient-checked 4×4 Hamilton forward/backward kernel of its dense sibling TNNetQuaternionLinear (the library's first hypercomplex layer). See examples/QuaternionConv/ and examples/QuaternionLinear/.
6. TNNetOctonionConv: the 8-dimensional octonion (Cayley–Dickson) generalization of TNNetQuaternionConv — each 8-channel input patch is octonion-multiplied by a learned octonion filter tap and accumulated, coupling all eight channel components across space using only ~1/8 the weights of an equal-width real convolution. Input Depth and the feature count must both be multiples of 8. It reuses the same auditable, norm-multiplicativity-verified 8×8 Cayley–Dickson forward/backward kernel as its dense sibling TNNetOctonionLinear. See examples/OctonionConv/ and examples/OctonionLinear/.

Convolutional layers are crucial in neural networks because they:

1. Automatically learn hierarchical features from data.
2. Maintain spatial relationships in the input.
3. Reduce the number of parameters compared to fully connected layers.
4. Enable the network to be translation-invariant.

In practice, convolutional layers are often used in combination with other layer types, such as pooling layers (e.g., TNNetMaxPool) and normalization layers (e.g., TNNetMovingStdNormalization), to create powerful neural network architectures for tasks like image classification, object detection, and segmentation.

Here's a brief example of how to create a convolutional layer using the CAI Neural API:

NN := TNNet.Create();
NN.AddLayer([
  TNNetInput.Create(32, 32, 3),  // Input layer for 32x32 RGB images
  TNNetConvolutionLinear.Create(
    {Features=}64,     // Number of output features
    {FeatureSize=}5,   // 5x5 kernel size
    {Padding=}2,       // Padding of 2 pixels
    {Stride=}1,        // Stride of 1 pixel
    {SuppressBias=}1   // Suppress bias
  ),
  TNNetReLU6.Create()  // Activation function
]);

This example creates a convolutional layer with 64 features, a 5x5 kernel size, padding of 2, and a stride of 1, followed by a ReLU6 activation function.

These are tha available convolutional layers in CAI:

Grouped pointwise convolutions are an interesting and efficient variant of standard convolutions in neural networks. Grouped pointwise convolutions are a type of convolution operation where the input channels are divided into groups, and each group is processed separately. This is particularly useful for 1x1 convolutions (pointwise) where the spatial dimensions are not affected. The grouped approach can significantly reduce the number of parameters in a neural network as shown in the papers Grouped Pointwise Convolutions Reduce Parameters in Convolutional Neural Networks and An Enhanced Scheme for Reducing the Complexity of Pointwise Convolutions in CNNs for Image Classification Based on Interleaved Grouped Filters without Divisibility Constraints. By reducing parameters, these convolutions can make models more efficient in terms of computation and memory usage. These convolutions can be combined with other techniques like normalization and intergroup connections. This flexibility allows for the creation of more sophisticated network designs. Grouped pointwise convolutions are particularly useful in efficient network designs, such as mobile or edge computing applications where resource constraints are significant. They allow for maintaining model expressivity while reducing computational requirements.

The grouped pointwise convolutional layers are:

A locally connected layer is a type of neural network layer that shares some similarities with convolutional layers but has some distinct characteristics:

• Structure: Locally connected layers, like convolutional layers, operate on local regions of the input. However, unlike convolutional layers, they do not share weights across different positions in the input.
• Weight independence: Each local region in the input has its own set of weights, which are not shared with other regions. This allows the layer to learn position-specific features.
• Flexibility: Locally connected layers offer more flexibility in learning spatial hierarchies compared to fully connected layers, while still maintaining position-specific information unlike convolutional layers.
• Parameters: These layers typically have more parameters than convolutional layers due to the lack of weight sharing, which can lead to increased computational complexity and memory usage.
• Use cases: Locally connected layers can be useful in scenarios where position-specific features are important, such as in face recognition tasks where different parts of the face have distinct characteristics based on their location.

Max, min, and avg poolings are downsampling techniques used in neural networks, particularly in convolutional neural networks (CNNs). Let's explore each of these pooling types as implemented in the CAI Neural API:

1. Max Pooling (TNNetMaxPool): Max pooling selects the maximum value from a defined region of the input.

• It reduces spatial dimensions while retaining the most prominent features.
• Useful for detecting specific features regardless of their position in the input.

2. Min Pooling (TNNetMinPool): Min pooling selects the minimum value from a defined region of the input.

• It can be useful for detecting dark features or gaps in the input.
• Less common than max pooling but valuable in specific scenarios.

3. Average Pooling (TNNetAvgPool): Average pooling calculates the average value of a defined region of the input.

• It smooths the input and can help in reducing noise.
• Often used when we want to preserve more contextual information compared to max pooling.

Unique pooling variants in the API:

• TNNetMinMaxPool: Performs both max and min pooling and concatenates the results.
• TNNetAvgMaxPool: Combines average and max pooling.
• TNNetLpPool: generalized Lp pooling y = ((1/N)·Σ|xᵢ|^p)^(1/p) over each window, with a configurable real exponent p (TNNetLpPool.Create(PoolSize, Stride, Padding, p), default p=2). p=1 is mean-of-absolute-values, p=2 is RMS pooling, and large p approaches max pooling — a single knob interpolating between average and max pooling. Its analytic backward pass ∂y/∂xᵢ = (y^(1-p)/N)·|xᵢ|^(p-1)·sign(xᵢ) is numerically gradient-checked.
• TNNetSoftPool: exponentially-weighted ("softmax") pooling (Stergiou, Poppe & Kalliatakis, 2021). Over each window it computes wᵢ = exp(β·xᵢ)/Σⱼexp(β·xⱼ) and y = Σᵢ wᵢ·xᵢ (TNNetSoftPool.Create(PoolSize, Stride, Padding, β), default β=1; window softmax stabilised by subtracting the window max). The optional inverse-temperature β is a single knob spanning the average↔max family: β → ∞ recovers max pooling, β → 0 recovers average pooling, and β = 1 is the original SoftPool. Unlike max pooling every cell receives gradient: its analytic backward pass ∂y/∂xᵢ = wᵢ·(1 + β·(xᵢ − y)) is numerically gradient-checked across a β sweep.
• TNNetStochasticPool: stochastic pooling (Zeiler & Fergus, 2013). Over each window it builds a probability distribution pᵢ = aᵢ/Σⱼaⱼ from the (assumed non-negative, e.g. post-ReLU) activations. While training (toggled on by TNNet.EnableDropouts(true), like dropout) it samples one cell with probability pᵢ and outputs it, routing the whole window gradient to that sampled cell (like max pooling routes to its argmax); at inference it is deterministic, outputting the probability-weighted expectation y = Σᵢ pᵢ·aᵢ. Sampling uses the library RNG so it is reproducible under a fixed RandSeed. If a window sum is ≤ 0 (degenerate / negative activations) it falls back to the plain window mean. Constructor params (size/stride/padding) match TNNetMaxPool; assumes square feature maps (SizeX = SizeY).

Backpropagation in pooling layers: During backpropagation, pooling layers distribute the gradient differently:

• Max Pooling: The gradient is passed only to the neuron that had the maximum value during the forward pass.
• Min Pooling: Similar to max pooling, but for the minimum value.
• Average Pooling: The gradient is divided equally among all neurons in the pooling region.

The CAI Neural API implements these backpropagation methods in the respective Backpropagate() functions of each pooling class.

Deconvolution (Upsampling) counterparts: The API also provides deconvolution or upsampling layers, which can be seen as the inverse operations of pooling:

• TNNetDeMaxPool: a deconvolution layer that can upsample the input.
• TNNetUpsample: also known as depth_to_space, this layer can increase the spatial dimensions of the input.

These layers are crucial in architectures like autoencoders or in tasks requiring upsampling, such as image segmentation.

When to use each pooling type:

• Max Pooling: it is useful for detecting features regardless of their exact location. It's commonly used in classification tasks.
• Min Pooling: it is useful when the absence of features is important, or when working with inverted data.
• Average Pooling: it is good for preserving more context and reducing noise. Often used in later layers of the network.
• TNNetMinMaxPool: used when you want to capture both the presence and absence of features.
• TNNetAvgMaxPool: used when you need to balance between preserving prominent features and maintaining context.

The CAI Neural API also provides specialized versions:

• TNNetMaxChannel and TNNetMinChannel: perform max and min operations across the entire channel into a single number per channel.
• TNNetAvgChannel: averages the entire channel into a single number per channel.

Normalization layers may offer:

• Improved training stability.
• Better generalization.
• Potential for faster convergence.

The available normalization techniques are:

• Zero-centering (TNNetChannelZeroCenter).
• Standard deviation normalization (TNNetMovingStdNormalization, TNNetChannelStdNormalization).
• Per-sample layer normalization (TNNetLayerNorm, TNNetRMSNorm, TNNetGroupNorm).

See the Normalization cheat sheet for a side-by-side comparison of every normalization layer (axes reduced over, learnable parameters, formula, and when to use each).

TNNetLayerNorm normalizes each input sample over all its elements (SizeX*SizeY*Depth) to zero mean and unit variance, then applies a learnable per-element scale (gamma) and bias (beta). Unlike batch normalization it does not depend on batch statistics, which makes it well suited to transformers and recurrent models. Add it with NN.AddLayer(TNNetLayerNorm.Create());.

TNNetRMSNorm is a cheaper, transformer-friendly variant that divides each sample by the root mean square of its elements (no mean subtraction) and applies a learnable per-element scale. Add it with NN.AddLayer(TNNetRMSNorm.Create());.

TNNetRMSNormGated keeps the same RMS normalization but replaces the per-element scale with a learnable per-channel sigmoid gate sigmoid(g[d]). The gate logits are initialised to 0, so an untrained layer halves each normalized activation (sigmoid(0) = 0.5) and the channels open or close independently during training. Add it with NN.AddLayer(TNNetRMSNormGated.Create());.

TNNetSwitchableNorm lets the network learn how much LayerNorm vs RMSNorm to apply to the same input. It computes both a LayerNorm-style normalization L = (x - mean)/sqrt(var + eps) and an RMSNorm-style normalization R = x / sqrt(mean(x^2) + eps) per sample, then blends them with a softmax over two learnable scalar logits: y = a_ln * L + a_rms * R with (a_ln, a_rms) = softmax(w_ln, w_rms). There is no per-element gamma/beta; the only parameters are the two mixing logits, both initialised to 0 so an untrained layer is an exact 50/50 blend. Add it with NN.AddLayer(TNNetSwitchableNorm.Create());.

TNNetGroupNorm splits the input channels (Depth) into Groups contiguous groups and normalizes each group independently, then applies a learnable per-element scale and bias. Depth must be divisible by Groups; otherwise it falls back to a single group. Pass the group count to the constructor, e.g. NN.AddLayer(TNNetGroupNorm.Create(8));.

Normalization layers (TNNetLayerMaxNormalization, TNNetLayerStdNormalization, TNNetLocalResponseNorm2D, TNNetLocalResponseNormDepth) help stabilize training and can improve model performance by managing the scale and distribution of activations. They are particularly useful in deep networks where the scale of values can change dramatically between layers.

TNNetLayerMaxNormalization normalizes based on the maximum value, while TNNetLayerStdNormalization uses standard deviation. These are particularly useful when you want to normalize the activations within a specific range or distribution without learning any parameters. They can be applied to various network architectures and are especially helpful when dealing with varying scales of input features.

TNNetLocalResponseNorm2D and TNNetLocalResponseNormDepth implement types of local Response Normalization (LRN). LRN is inspired by lateral inhibition in real neurons. It's particularly useful in Convolutional Neural Networks (CNNs) for image processing tasks. You may use it in scenarios where you want to create competition amongst neuron outputs in the same layer.

TNNetLocalResponseNorm2D is applied across nearby kernel maps at the same spatial position, while TNNetLocalResponseNormDepth normalizes across the depth dimension. These layers can help in increasing the generalization capability of the model, reducing the chances of overfitting and enhancing the model's ability to detect high-frequency features with a big response.

Random layers (TNNetRandomMulAdd, TNNetChannelRandomMulAdd) serve as powerful regularization techniques, helping to prevent overfitting and improve the model's ability to generalize. They can be especially beneficial when working with limited datasets or when you want your model to be robust to small variations in input.

These layers provide various tools for normalization, regularization, and introducing controlled variability in neural networks. The choice of which layers to use and where to place them in your network architecture depends on the specific problem you're trying to solve, the characteristics of your data, and the behavior you want to encourage in your model.

These layers are essential for creating flexible and powerful neural network architectures. Let's break them down:

1. Concatenation Layers: There are two main types of concatenation layers in the CAI Neural API: a. TNNetConcat:

   • This layer concatenates outputs from multiple layers along the depth dimension.
   • It's designed to work with layers that have the same spatial dimensions (X and Y sizes).
   • Usage: It's particularly useful when you want to combine features from different processing paths in your network. b. TNNetDeepConcat:
   • This layer also concatenates outputs from multiple layers, but it's specifically optimized for the depth dimension.
   • It maintains separate arrays to track the depths of each layer and channel, allowing for efficient deep concatenation.
   • Usage: Ideal for creating architectures that process information in parallel and then combine the results.

2. Summation Layer (TNNetSum):

   • This layer adds together the outputs of multiple layers element-wise.
   • It's designed to work with layers of the same size.
   • Usage: Commonly used in residual network (ResNet) style architectures, where it allows for skip connections that help mitigate the vanishing gradient problem and enable the training of very deep networks.

These layers provide several benefits in neural network design:

1. Flexibility: they allow for the creation of complex, non-linear network topologies that can process information in parallel and then combine it in various ways.
2. Feature Fusion: concatenation and summation layers enable the network to combine features from different processing streams, potentially capturing multi-scale or multi-aspect information.
3. Skip Connections: summation layers are crucial for implementing skip connections, which are fundamental to many modern architectures like ResNets and DenseNets.
4. Dimensionality Manipulation: the transposition layers allow for creative manipulations of data dimensions, which can be crucial for certain types of operations or for interfacing between different parts of a network.
5. Custom Architectures: these layers provide the building blocks for designing novel network architectures tailored to specific tasks or data types.

By using these layers creatively, developers can build highly customized and efficient neural network architectures that are optimized for their specific use cases.

For contrastive / metric-learning models the goal is not to classify but to embed: map each input to a vector so that semantically-similar inputs land close together and dissimilar ones far apart. Three layers compose into such a head:

How to build a contrastive / metric-learning head. Build a small embedding sub-net (an MLP or conv trunk) that maps the input to an embed_dim vector, end it with TNNetL2Normalize so embeddings live on the unit sphere, then train it with TNNetTripletLoss. Because the triplet head takes no external target — supervision is implicit in its anchor|positive|negative depth layout — you feed it three embeddings at once. The cleanest fully-native way is a weight-shared siamese net: feed the triplet as three spatial positions, embed each with pointwise (featuresize=1) layers so the same weights apply to all three, TNNetL2Normalize, then TNNetReshape(1, 1, 3*embed_dim) to lay the three embeddings out as the a|p|n depth chunks the loss head consumes. At inference, drop the loss head and read the embedding directly; use TNNetCosineSimilarity (or a plain dot product on unit-norm vectors) to score pairs. See the worked Triplet embedding example.

TNNetSplitChannels and TNNetSplitChannelEvery are specialized layer types in the CAI Neural API that allow for selective channel manipulation within neural networks.

1. TNNetSplitChannels: This layer is designed to pick or split selected channels from the previous layer. It provides fine-grained control over which specific channels are passed on to subsequent layers in the network. Key features:

   • It can be created with a specific range of channels (ChannelStart and ChannelLen) or with an array of specific channel indices.

   Potential uses:

   • Feature selection: Allowing the network to focus on specific features represented by certain channels.
   • Creating multiple parallel paths in the network that process different subsets of the input channels.
   • Implementing attention-like mechanisms by selectively passing certain channels forward.

2. TNNetSplitChannelEvery: This layer is a specialized version of TNNetSplitChannels. It splits channels at regular intervals.

   Potential uses:

   • Creating regular patterns of channel selection throughout the network.
   • Implementing a form of grouped convolutions or channel-wise operations.
   • Reducing the computational load by consistently selecting a subset of channels at regular intervals.

Both these layers offer powerful tools for manipulating the flow of information through the network's channels. They allow for the creation of more complex and efficient network architectures by providing fine control over which features (represented by channels) are processed in different parts of the network.

These layers could be particularly useful in scenarios where:

• You want to reduce the computational complexity of your model by focusing on the most important channels.
• You're designing a network with multiple parallel paths, each operating on different subsets of the input features.
• You're implementing custom attention mechanisms or feature selection techniques within your network.

Picking the right channel-select layer. Three closely related layers select depth channels — pick by the shape of the selection:

• TNNetGather(Channel) selects a single channel (Output[x,y,0] := Input[x,y,Channel], output depth 1) — the degenerate one-index case.
• TNNetSplitChannels selects a contiguous range (Create(ChannelStart, ChannelLen)) or an explicit list, and is the right tool for plain slicing / parallel-path splits.
• TNNetGatherChannels([i0, i1, ...]) selects an arbitrary, ordered, possibly-repeated index list (Output[x,y,k] := Input[x,y,Channels[k]], output depth = list length), so it doubles as a learnable-free channel reorder / prune / duplicate. Add it via the convenience builder TNNet.AddGatherChannels([...]). See the runnable examples/GatherChannelsRouting/ demo. Repeats are allowed; backward accumulates the duplicated output errors onto the shared source channel.

The layers TNNetTransposeXD and TNNetTransposeYD are specialized layer types in the CAI Neural API that perform specific transposition operations on the input data. These transposition operations can be particularly useful in various neural network architectures and data processing pipelines:

• Reshaping Data: they allow for flexible reshaping of data between different network layers, which can be crucial for certain model designs.
• Feature Manipulation: by swapping spatial and depth dimensions, these layers can help in reorganizing feature representations, which might be beneficial for subsequent processing steps.
• Dimension Reduction or Expansion: depending on the input shape, these transpositions can effectively reduce or expand certain dimensions, potentially helping in compressing or expanding feature representations.
• Adapting to Different Input Formats: these layers can be useful when dealing with data that comes in different formats or when interfacing between different parts of a neural network that expect data in specific shapes.
• Custom Architecture Designs: they provide flexibility in designing custom neural network architectures that may require unconventional data flows between layers.

These layers are implemented with both forward (Compute) and backward (Backpropagate) methods, indicating that they are fully integrated into the network's training process and can be used in the middle of a network, not just as preprocessing steps. This can be particularly valuable for researchers and practitioners working on novel network designs or dealing with unconventional data structures.

Activation functions are a fundamental component of neural networks. These functions play several crucial roles in neural networks:

• Introducing non-linearity: this allows the network to model complex, non-linear relationships in data.
• Normalizing outputs: many activation functions map inputs to a fixed range, helping to prevent issues like exploding gradients.
• Representing features: different activation functions can help in capturing various types of patterns or features in the data. The choice of activation function can significantly impact the performance and learning capabilities of a neural network, and different problems may benefit from different activation functions.

The CAI Neural API supports various types of activation functions, as per the below table:

Gated Linear Units split the input along the channel (depth) axis into two equal halves A and B, and output A multiplied by a gating activation applied to B. The output depth is therefore half of the input depth, and the input depth must be even. These layers have no trainable parameters. They are commonly used inside transformer feed-forward blocks (https://arxiv.org/abs/2002.05202).

Multi-head self-attention builder. TNNet.AddMultiHeadSelfAttention(d_model, Heads, CausalMask=false) wires the single-head TNNetScaledDotProductAttention above into a full multi-head block in one call: it splits the [Q_all|K_all|V_all] (depth 3*d_model) input slab into Heads per-head [Q_h|K_h|V_h] slices (d_k = d_model/Heads) via TNNetSplitChannels, runs one SDPA head per slice, concatenates the head outputs back to depth d_model with TNNetDeepConcat, and applies a TNNetPointwiseConvLinear(d_model) per-token out-projection. The two intermediate steps are also exposed as TNNet.AddSplitQKVHeads and TNNet.AddMultiHeadSDPAConcat. (The out-projection is pointwise rather than TNNetFullConnectLinear because over a SeqLen x 1 x d_model tensor a fully-connected layer would flatten and mix the whole sequence into one vector.) An optional Variant argument (avSDPA default, avDifferential, avSink) swaps the plain per-head SDPA for TNNetDifferentialAttention or TNNetSinkAttention (with NumSinks sink slots) — the default keeps every existing call bit-for-bit unchanged.

Multi-head cross-attention builder. TNNet.AddMultiHeadCrossAttention(d_model, Heads, QuerySource, KeyValueSource, CausalMask=false) wires encoder-decoder cross-attention in one call: the Query is projected (token-wise TNNetPointwiseConvLinear(d_model)) from QuerySource (the decoder stream, a QSeqLen x 1 x d_model token tensor) while the Keys and Values are projected from a separate KeyValueSource (the encoder output, a KVSeqLen x 1 x d_model token tensor). The query and key/value sequence lengths may differ — the result lives on the query grid (QSeqLen x 1 x d_model). Per head it slices d_k = d_model/Heads channels out of each projection, packs them as [Q_h|K_h|V_h] with TNNetDeepConcat, runs one TNNetScaledDotProductAttention head, concatenates the heads, and applies a token-wise TNNetPointwiseConvLinear(d_model) out-projection. (As with self-attention, every projection is pointwise rather than TNNetFullConnect*, which would flatten the sequence axis.)

Grouped-Query / Multi-Query attention builder. TNNet.AddMultiHeadGroupedQueryAttention(d_model, QueryHeads, KVHeads, CausalMask=false) builds the GQA attention shape used by modern LLMs (Llama-2/3, Mistral): the Query is projected to the full d_model (QueryHeads heads of d_k = d_model/QueryHeads) but the Keys and Values are projected to only KVHeads*d_k channels, so several query heads share one key/value head (QueryHeads/KVHeads heads per group). KVHeads=1 degenerates to Multi-Query Attention; KVHeads=QueryHeads to plain multi-head attention. Each query head slices its own d_k Q channels plus the d_k channels of its shared KV group, packs [Q_h|K_group|V_group], runs one TNNetScaledDotProductAttention, and the heads are concatenated and out-projected with a token-wise TNNetPointwiseConvLinear(d_model). The win is inference-memory: the K/V projection params shrink by a factor QueryHeads/KVHeads versus full MHA. Requires d_model mod QueryHeads = 0 and QueryHeads mod KVHeads = 0.

Multi-head Latent Attention (MLA) builder. TNNet.AddMultiHeadLatentAttention(d_model, Heads, LatentDim, CausalMask=false) builds the DeepSeek-V2 (Liu et al. 2024) attention shape, a compression axis orthogonal to GQA: instead of sharing full-width K/V across query-head groups, MLA low-rank-factors the K/V projection. Each token is first down-projected to a tiny shared latent c_KV of width LatentDim << d_model (the only state a decoder would cache), then K and V are reconstructed per head by up-projections from c_KV. Query is projected to the full d_model per head; each head packs [Q_h|K_h|V_h], runs one TNNetScaledDotProductAttention, and the heads are concatenated and out-projected with a token-wise TNNetPointwiseConvLinear(d_model) (all projections are pointwise so the token axis is preserved). The win is cacheable-state size: LatentDim/(2*d_model) of plain MHA's K/V cache. The default RopeDim=0 is NoPE; RopeDim>0 (even) adds the paper's decoupled-RoPE slice: RoPE cannot be applied to the compressed latent (the up-projection would smear positions), so a small extra rope dimension carries position — rope-Q is a per-head projection of x rotated by TNNetRotaryEmbedding, while rope-K is one projection of x shared across all heads and rotated once, so the decode state grows by only RopeDim. Each head attends with concat(Q_h,ropeQ_h)·concat(K_h,ropeK). For KV-cache incremental decode the per-head SDPA layers support BeginIncrementalDecode, and TNNetRotaryEmbedding.PositionOffset lets a streamed length-1 token be rotated with its absolute position; examples/LatentAttention/ demonstrates both this path and a true latent-only cache (d_c floats/token, < 1e-5 faithful) with a printed cache-memory comparison. See examples/LatentAttention/.

Set Transformer (ISAB + PMA) builders. Two permutation-invariant set primitives (Lee et al. 2019, Set Transformer), each owning a learnable bank of vectors. TNNet.AddInducedSetAttention(InducingPoints, Heads) wires TNNetInducedSetAttention (ISAB): instead of O(N^2) self-attention over the N input tokens it keeps a small bank of M = InducingPoints learnable inducing points and applies two stacked cross-attention blocks — H = MAB(I, X) (the M points attend over the N inputs → (M,d)), then Y = MAB(X, H) (the N inputs attend back over the M summaries → (N,d)) — giving an O(N*M) shape-preserving set-to-set map. TNNet.AddAttentionPooling(NumSeeds, Heads) wires TNNetAttentionPooling (PMA): pools a variable-length set (N,1,d) to a fixed (k,1,d) (k = NumSeeds) by letting k learnable seed vectors cross-attend over the inputs — a trainable, content-addressed, permutation-invariant readout (k=1 is a learned-query weighted-sum pool, categorically unlike the parameter-free TNNetAvgChannel/TNNetMaxChannel). Heads=1 emits the bare single-head layer with identity Q/K/V projections (only the inducing/seed bank is learnable), keeping the two-stage softmax-Jacobian backward exact and gradient-checkable. Heads>1 builds a genuine multi-head MAB by the repo's concat-of-H idiom (no head-axis tensor): d_model splits into Heads subspaces of width d_model/Heads, each head gets its own learnable per-token input projection (a 1×1 TNNetPointwiseConvLinear that preserves the set axis) feeding a single-head ISAB/PMA with its own bank, the heads are concatenated back to d_model and run through a learnable per-token out-projection — so each head keeps the exact softmax-Jacobian backward while the model now learns Q/K/V projections and mixes head subspaces (d_model must be divisible by Heads). See examples/SetTransformer/. TNNet.AddSAB(InducingPoints, Heads, DFF) completes the family with the paper's full Set Attention Block: it wraps the multi-head ISAB MAB in two post-norm residual sub-blocks — H = LayerNorm(X + MAB(X,X)) then out = LayerNorm(H + FFN(H)), where FFN is a token-wise TNNetPointwiseConvReLU(DFF) → TNNetPointwiseConvLinear(d_model) (1×1 convs, so the (N,1,d_model) set axis and permutation-equivariance are preserved). See examples/SetAttentionBlock/.

Sinkhorn (doubly-stochastic) attention builder. TNNet.AddSinkhornAttention(out Attended, W; KIter=20, Tau=1.0) builds a single-head attention block that is a drop-in contrast to softmax attention: it projects the input to Q/K/V with token-wise TNNetPointwiseConvLinear, forms the scaled QKᵀ score matrix with TNNetDotProducts, and then — instead of the one-sided row softmax — normalizes the scores with the existing TNNetSinkhorn layer so the attention map is doubly stochastic (rows AND columns sum to 1), before weighting the values and out-projecting. Where standard attention lets every query distribute its own probability mass independently (columns can starve or saturate), the doubly-stochastic map balances how much each key is attended to overall — the optimal-transport view of attention. The TNNetSinkhorn normalizer is returned in W for inspection/annealing (SetTau), and Attended is the block output. KIter/Tau are the Sinkhorn iteration count and temperature. The default softmax path (AddSingleHeadSelfAttention / AddMultiHeadSelfAttention) is unchanged. See examples/SinkhornMatching/.

Spiking block builder. TNNet.AddSpikingBlock(pHidden, tau=2.0, V_th=1.0, alpha=2.0, LearnDynamics=false) wires the canonical spiking-network linear → LIF → rate-readout pipeline over a (T, 1, D) tensor on the time axis in one call: a per-timestep TNNetPointwiseConvLinear(pHidden) synaptic-current projection (pointwise so each time step is projected independently — TNNetFullConnect* would flatten/mix the time axis), then a TNNetLIFNeuron(tau, V_th, alpha, LearnDynamics) emitting a binary spike train, then a TNNetAvgChannel rate readout averaging spikes over time to a (1, 1, pHidden) firing-rate vector (ready for a dense head). Returns the rate-readout layer. LearnDynamics forwards to the LIF layer's opt-in trainable per-channel threshold/leak. Composes existing layers (no new class). See examples/SpikingMNIST/.

Talking-Heads attention builder. TNNet.AddTalkingHeadsAttention(Heads, d_model, CausalMask=false, PreSoftmaxMix=true, PostSoftmaxMix=true) builds full Talking-Heads multi-head attention (Shazeer et al. 2020) — a learnable Heads x Heads linear mix across heads applied to the attention maps. Because this repo has no single head-axis tensor (multi-head is H separate concatenated TNNetScaledDotProductAttention layers, whose softmax is fused and never exposes a per-head logit slab), this is necessarily a builder, not a drop-in layer: it composes attention from finer primitives so the per-head scores become a real graph tensor. Per head it forms score_h = TNNetDotProducts(Q_h, K_h) scaled by 1/sqrt(d_k), transposes so heads stack on the Depth axis, and TNNetDeepConcats the H slabs into a (key, query, H) tensor; the cross-head mix is then a TNNetPointwiseConvLinear(H) (a 1x1 conv over the head axis at every (key,query) position — exactly Shazeer's H x H multiply). A PreSoftmaxMix mix is applied to the logits and a PostSoftmaxMix mix to the post-softmax weights (each individually toggleable for ablation), with the softmax taken over the key axis between them; then weights·V per head, concat, and a token-wise TNNetPointwiseConvLinear(d_model) out-projection. Composes existing serializable layers (no new class), so save/load works for free. Requires d_model mod Heads = 0.

Conformer block builder. TNNet.AddConformerBlock(Heads, d_ff, ConvKernelSize) builds the convolution-augmented transformer block of Conformer (Gulati et al. 2020) over a (SeqLen, 1, d_model) tensor. It is a "macaron" block that sandwiches a multi-head self-attention module (global mixing) and a convolution module (local mixing) between two half-step feed-forward modules, each sub-module a pre-norm residual, with a final LayerNorm: x += 0.5·FFN(x); x += MHSA(x); x += Conv(x); x += 0.5·FFN(x); x := LayerNorm(x). Composed entirely from existing serializable primitives (TNNetLayerNorm, TNNetPointwiseConvLinear per-token projections, AddMultiHeadSelfAttention, TNNetGLU conv gating, TNNetCausalConv1D 1-D conv over the time axis, TNNetSwish, TNNetSum residuals, TNNetMulByConstant(0.5) macaron scaling), so it needs no new leaf class and round-trips through SaveToString/LoadFromString; shape-preserving so blocks stack. (The paper's per-channel depthwise conv has no 1-D-over-sequence primitive in tree yet, so the channel-mixing TNNetCausalConv1D is the documented stand-in.) See examples/Conformer/.

Transformer encoder block builder. TNNet.AddTransformerEncoderBlock(d_model, Heads, d_ff, PreNorm=true, CausalMask=false) assembles a complete transformer encoder block over a SeqLen x 1 x d_model tensor in one call: an attention sub-block (LayerNorm → token-wise Q|K|V slab projection TNNetPointwiseConvLinear(3*d_model) → AddMultiHeadSelfAttention → residual sum) followed by a SwiGLU feed-forward sub-block (LayerNorm → TNNetPointwiseConvLinear(2*d_ff) → TNNetSwiGLU → TNNetPointwiseConvLinear(d_model) → residual sum). With PreNorm=true (default) each LayerNorm precedes its sub-block (x + Sublayer(LayerNorm(x))); with PreNorm=false it follows the residual sum (LayerNorm(x + Sublayer(x)), post-norm). Every projection — including both FFN projections — is a pointwise (1×1) convolution so the token axis is preserved (TNNetFullConnect* would flatten the whole sequence). The output shape stays SeqLen x 1 x d_model, so blocks can be stacked.

Transformer decoder block builder. TNNet.AddTransformerDecoderBlock(d_model, Heads, d_ff, EncoderOutput, PreNorm=true) assembles a complete encoder-decoder transformer decoder block over a SeqLen x 1 x d_model decoder stream in one call by composing three residual sub-blocks: (1) a causal multi-head self-attention sub-block (same wiring as the encoder block with CausalMask=true); (2) a cross-attention sub-block whose Query comes from the decoder stream and whose Key/Value come from the explicit EncoderOutput layer (a KVSeqLen x 1 x d_model encoder-memory tensor, via AddMultiHeadCrossAttention); and (3) a token-wise SwiGLU feed-forward sub-block. PreNorm places each LayerNorm before its sub-block (default) or after the residual sum (post-norm), matching AddTransformerEncoderBlock. The query and encoder-memory sequence lengths may differ — the output stays on the decoder grid (SeqLen x 1 x d_model), so decoder blocks can be stacked. See examples/TransformerDecoderBlock/.

Perceiver encoder builder. TNNet.AddPerceiverEncoder(NumLatents, d_latent, Heads, Depth, d_ff=0, PreNorm=true) assembles a Perceiver / Perceiver-IO latent-bottleneck encoder (Jaegle et al. 2021, arXiv:2103.03206) over a (InputSeqLen, 1, d_model) input in one call, decoupling the bulk of the compute from the input length. It (1) optionally projects the input width to d_latent (a 1×1 TNNetPointwiseConvLinear, inserted only when d_model <> d_latent), then (2) reads the whole input into a small fixed-size learnable latent array Z of shape (NumLatents, 1, d_latent) (NumLatents << InputSeqLen) via AddAttentionPooling(NumLatents, Heads) — the PMA seed bank is the Perceiver latent array, and this input→latent cross-attention is the only place the input enters, at cost linear in InputSeqLen; then (3) refines Z with a Depth-deep tower of AddTransformerEncoderBlock(Heads, d_ff) latent self-attention blocks whose quadratic cost lives only in the cheap NumLatents² tower. Output length is NumLatents regardless of input length — distinct from AddInducedSetAttention (projects back to the n input rows) and AddAttentionPooling alone (single pool, no self-attention refinement). Composes existing layers (no new class). See examples/Perceiver/.

TNNetDiagonalSSM is the first recurrent layer in the library: a diagonal-state linear-recurrence ("SSM-lite") sequence mixer that provides an O(n) causal alternative to the O(n^2) scaled-dot-product-attention head. The input is a (SeqLen, 1, Depth) sequence laid out along the X axis (the same convention the attention layers use); the recurrence runs left-to-right along X with the depth channels fully parallel. See examples/DiagonalSSM/ for a single-layer demo that prints the learned per-channel decay spectrum.

MLP-Mixer block builder. TNNet.AddMLPMixerBlock(TokensHidden, ChannelsHidden, ActFn=TNNetReLU) assembles a complete all-MLP Mixer block (Tolstikhin et al. 2021, MLP-Mixer: An all-MLP Architecture for Vision) over a (Tokens, 1, Channels) sequence in one call — an attention-free alternative to AddTransformerEncoderBlock that mixes information with two MLPs along different axes, each wrapped in a pre-LayerNorm residual: (1) a token-mixing MLP that TNNetTransposeXD-swaps the token/channel axes, runs a pointwise Linear(TokensHidden) → ActFn → Linear(Tokens) across the (now-Depth) token axis — the same MLP shared over every channel — then transposes back; followed by (2) a channel-mixing MLP Linear(ChannelsHidden) → ActFn → Linear(Channels) applied independently per token. Every projection is a pointwise (1×1) convolution so the token axis is preserved and both sub-blocks are shape-preserving (Tokens and Channels are read from the current last layer), so the output stays (Tokens, 1, Channels) and blocks stack. See examples/MLPMixer/.

Gated Linear Attention block builder. TNNet.AddGatedLinearAttentionBlock(d_ff, PreNorm=true, NormClass=nil) assembles a complete transformer-style block over a (SeqLen, 1, d_model) sequence in one call — an attention-free linear-recurrence alternative to AddTransformerEncoderBlock that swaps the multi-head self-attention arm for the GLA time-mixing builder. It composes two pre-LayerNorm (or post-LayerNorm with PreNorm=false) residual sub-blocks with inline TNNetSum residuals: (1) a GLA time-mixing sub-block (LayerNorm → AddGatedLinearAttention → residual sum), wrapping the TNNetGatedLinearAttention matrix-state per-channel-gated linear-attention recurrence; followed by (2) a SwiGLU feed-forward sub-block (LayerNorm → TNNetPointwiseConvLinear(2*d_ff) → TNNetSwiGLU → TNNetPointwiseConvLinear(d_model) → residual sum). d_model is inferred from the input depth and every projection is a pointwise (1×1) convolution, so the output stays (SeqLen, 1, d_model) and blocks stack. Composes existing layers (no new class). See examples/GatedLinearAttentionBlock/, where a 3-block tower reaches 100% exact recall vs 81% for the bare mixer on an overwrite key→value recall task.

Fourier Neural Operator block builders. TNNet.AddFourierNeuralOperator1D(OutDepth, Modes, ActFn=nil) and TNNet.AddFourierNeuralOperator2D(OutDepth, ModesX, ModesY, ActFn=nil) wrap the TNNetSpectralConv1D/TNNetSpectralConv2D leaf layers in the canonical FNO Fourier layer (Li et al. 2021) y = ActFn(SpectralConv(x) + W₁ₓ₁(x)): a global spectral branch in mode space summed with a local pointwise (1×1 conv, TNNetPointwiseConvLinear) residual branch in grid space, both mapping Depth → OutDepth from the same input, then an optional activation (ActFn=nil = none). Stack these blocks to build a resolution-invariant PDE-surrogate operator. Note: TNNetSpectralConv2D's radix-2 FFT requires power-of-two SizeX/SizeY. See examples/FourierNeuralOperator/ and examples/SpectralConv2D/.

When TNNetCellBias is added after convolutional layers, it introduces a trainable bias to each output cell of the convolutional layer. This can have several effects on the neural network:

1. Fine-tuning: TNNetCellBias allows for fine-tuning of the network's output by adding a learnable bias to each cell. This can help the network adjust its predictions more precisely.
2. Increased flexibility: by adding a bias to each cell individually, the network gains additional parameters to optimize, potentially allowing it to learn more complex representations.
3. Improved learning speed: placing this layer before and after convolutions can speed up learning. This is because it gives the network an additional way to adjust its output, potentially making it easier to find optimal solutions.
4. Parameter increase: adding TNNetCellBias increases the number of trainable parameters in the network. While this can be beneficial for learning, it also increases the model's complexity and the risk of overfitting.

It's worth noting that the effectiveness of adding TNNetCellBias after convolutional layers can vary depending on the specific architecture and problem at hand. While it can potentially speed up learning and improve the network's flexibility, it's important to experiment and validate its impact on your particular use case. TNNetChannelBias adds a trainable bias to each channel in the output. It's like TNNetCellBias, but operating on entire channels instead of individual cells.

Composite helper: TNNet.AddSEBlock(InputLayer, ReductionRatio) wires the standard Squeeze-and-Excitation pattern (TNNetAvgChannel -> TNNetFullConnectReLU(C/r) -> TNNetFullConnectSigmoid(C) -> TNNetChannelMulByLayer) onto an existing branch. See examples/SEBlockCifar/.

Composite helper: TNNet.AddCBAM(InputLayer, ReductionRatio=16, SpatialKernelSize=7) wires the Convolutional Block Attention Module (Woo et al. 2018) over a conv feature map in one call — channel attention then spatial attention, shape-preserving. Channel attention pools the map with both global average (TNNetAvgChannel) and global max (TNNetMaxChannel), runs each through a reduce->ReLU->expand MLP, sums them, sigmoids, and rescales per channel (TNNetChannelMulByLayer) — the dual-pool extension of AddSEBlock. Spatial attention then builds a 2-channel descriptor (pointwise C->2 conv), applies a padded SpatialKernelSize conv -> sigmoid gate, and rescales per spatial position. v1 simplifications (vs the paper): two separate channel MLPs rather than one shared MLP, and a learned C->2 spatial descriptor rather than fixed avg/max-over-depth. Keep inputs square (TNNetMaxChannel assumes SizeX == SizeY). See examples/CBAMAttention/.

Composite helper: TNNet.AddMixtureOfExperts(InputLayer, NumExperts, ExpertHiddenDim) wires a soft/dense Mixture-of-Experts feed-forward block (Shazeer et al. 2017) in one call, shape-preserving so it is a drop-in FFN replacement (d_model = InputLayer.Output.Depth). A token-wise gating network (TNNetPointwiseConvLinear(NumExperts) -> TNNetSoftMax) produces per-expert weights g; NumExperts parallel shape-preserving expert MLPs (TNNetPointwiseConvReLU(ExpertHiddenDim) -> TNNetPointwiseConvLinear(d_model)) each compute E_e(x); the block returns Sum_e g[e] * E_e(x). Each scalar gate weight is sliced with TNNetSplitChannels(e,1), broadcast across d_model with TNNetDeepConcat.Replicate, and cell-multiplied into the expert output with TNNetCellMulByCell (the same broadcast-multiply mechanism AddCBAM uses), then summed with TNNetSum. v1 is a soft, dense gate: every expert runs on every token and the outputs are blended — it trains end-to-end with existing layers (no new gradient code). See examples/MixtureOfExperts/.

Composite helper: TNNet.AddTopKMixtureOfExperts(InputLayer, NumExperts, ExpertHiddenDim, TopCnt, out AuxLossHead, AuxCoeff=0.01) is the sparse hard top-k sibling of AddMixtureOfExperts. The gate softmax is routed through the new TNNetTopKGate(TopCnt) — which keeps the TopCnt largest gate weights per token, zeroes the rest, and renormalizes the survivors to sum to 1 (so each token is a convex blend of only its top-TopCnt experts), with an exact fused mask+renorm Jacobian backward dL/dg_j = (1/s)(dL/dy_j − Σ_i dL/dy_i·y_i) over the surviving set. A load-balancing auxiliary loss head TNNetLoadBalanceLoss(TopCnt, Coeff) is attached as a second output leaf and returned via out AuxLossHead: it implements the Switch-Transformer loss (Fedus et al. 2021) L_aux = Coeff·E·Σ_i f_i·P_i where E = NumExperts, f_i is the (stop-gradient) fraction of tokens whose top-TopCnt set touches expert i and P_i is expert i's mean gate probability, so the gradient flows through P_i only (dL_aux/dg_t[i] = Coeff·E·f_i/T) and pushes the gate to spread load instead of collapsing onto one expert. v1 still evaluates all experts then masks (correct, but not yet compute-sparse); Gumbel-noise gating and true sparse dispatch are logged follow-ups. See examples/TopKMoE/.

Composite helper: TNNet.AddMixtureOfDepths(InputLayer, BlockBuilder, Capacity) wires a Mixture-of-Depths conditional-compute block (Raposo et al. 2024) in one call, shape-preserving so it is a drop-in trunk wrapper. A per-token router (TNNetPointwiseConvLinear(1) over Depth -> TNNetSigmoid, pointwise so the token axis is preserved) scores each of the SeqLen positions; the top-Capacity positions are selected along the sequence axis (TransposeXD -> TNNetTopK(Capacity) -> TransposeXD, since TNNetTopK masks over Depth), their router weight is broadcast across d_model and cell-multiplied into the wrapped block's output (keeping the router on the gradient path through the hard top-k), and the result is added residually so non-selected positions pass through unchanged. With Capacity = SeqLen it is bit-for-bit equal to the wrapped block alone (the degenerate correctness anchor). A load-balancing auxiliary loss and a Gumbel/learned-threshold router are logged follow-ups. See examples/MixtureOfDepths/.

Composite helper: TNNet.AddReversibleBlock(InputLayer, HiddenDim) wires a RevNet-style reversible additive-coupling block in one call: it splits the input depth into halves x1|x2 and produces y1 = x1 + F(x2), y2 = x2 + G(y1), output = Concat(y1, y2) (shape-identical to the input), where F/G are small pointwise residual functions. The defining property is exact analytic invertibility — x2 = y2 - G(y1), x1 = y1 - F(x2) recovers the input without inverting F/G. See examples/ReversibleBlock/.

TNNetAffineCoupling is the library's first exact-likelihood normalizing-flow primitive (RealNVP, Dinh et al. 2016, arXiv:1605.08803; Glow, Kingma & Dhariwal 2018, arXiv:1807.03039) — a bijection whose Jacobian log-determinant is available in closed form, so a stack of these (interleaved with fixed channel permutations) trains by exact maximum likelihood under a unit-Gaussian base. Distinct from the memory-saving AddReversibleBlock (a RevNet recompute trick with NO tractable Jacobian) and from TNNetMixtureDensity (a density head that is not invertible). It splits the Depth axis into two contiguous halves a|b; one half passes through unchanged and conditions an affine map of the other: forward y_a = x_a, y_b = x_b·exp(s) + t; inverse (sampling) x_b = (y_b − t)·exp(−s), where [s_pre; t] = W·x_a + b is a single per-position linear conditioner over the unchanged half and s = clamp·tanh(s_pre/clamp) is the Glow log-scale clamp for stability. The transformed half is chosen by the pTransformSecond constructor flag so stacked couplings update every channel. log|det J| = Σ s is exposed as the public read-only LogDetJacobian, so a flow's NLL is loss = 0.5·||z||² − Σ_couplings(LogDetJacobian); backward folds the negative-log-det gradient in via LogDetLossWeight (default 1.0). FStruct[0]=transform-second flag, FStruct[1]=inverse flag, FFloatSt[0]=s clamp; all round-trip via Save/Load. Created with TNNetAffineCoupling.Create() or TNNetAffineCoupling.Create(pTransformSecond, pInverse, pClamp). See examples/NormalizingFlow/ (fits a 2-D two-moons density by maximum likelihood and samples new points back through the inverse flow).

TNNetInvertible1x1Conv is Glow's learnable invertible 1×1 convolution (Kingma & Dhariwal 2018, arXiv:1807.03039 sec. 3.2) — the channel-mixing companion to TNNetAffineCoupling. It applies a learnable C×C matrix W per spatial position across the Depth axis, y[x,y,:] = W·x[x,y,:], a trainable generalization of the fixed channel permutation that couplings rely on for mixing. Distinct from TNNetHouseholderLinear (exactly orthogonal → log-det identically 0, zero volume change) and from TNNetPointwiseConvLinear (generic 1×1 conv with no tractable inverse or log-det). W is parametrized by its LU decomposition W = P·L·(U + diag(s)) with P a fixed permutation chosen at init (regenerated from a stored seed), L unit-lower-triangular, U strictly-upper-triangular, and s the log-scale vector; this makes the per-position log-det the cheap Σ log|s| (O(C)) instead of an O(C³) determinant. LogDetJacobian returns SizeX·SizeY·Σ log|s| for the current forward, composing additively with the couplings' log-dets; backward folds the negative-log-det gradient in via LogDetLossWeight (default 1.0). The map is exactly invertible by triangular solves (no matrix inverse) — pass pInverse=true for the sampling direction, reusing the same L/U/s. FStruct[0]=C, FStruct[1]=permutation seed, FStruct[2]=inverse flag; L/U/s round-trip via the per-neuron save. Created with TNNetInvertible1x1Conv.Create() or TNNetInvertible1x1Conv.Create(pInverse, pPermSeed). See examples/NormalizingFlow/, which interleaves it with TNNetAffineCoupling (the real Glow step) and shows the learnable mixing reaching a higher mean log-likelihood than the fixed-permute baseline.

TNNetActNorm is Glow's data-dependent activation normalization (Kingma & Dhariwal 2018, arXiv:1807.03039 sec. 3.1) — the third and final Glow flow-step primitive, completing the canonical trio TNNetActNorm → TNNetInvertible1x1Conv → TNNetAffineCoupling. It is a per-channel invertible affine transform y[.,.,c] = s[c]·x[.,.,c] + b[c] with learnable scale s (stored as a log-scale, s = exp(logs), to stay strictly non-zero) and bias b. On the first forward minibatch it lazily data-dependent-initialises logs = −ln(std[c]) and b = −mean[c]/std[c] so that batch comes out per-channel ~0 mean / ~1 variance; an "initialised" flag in FStruct guards the init so it fires exactly once and never re-fires on reload — after which logs,b are ordinary trainable weights (identical behaviour at train and sample time, exactly the property a flow needs). Genuinely distinct from every existing normalizer (TNNetChannelStdNormalization, TNNetGroupNorm, TNNetInstanceNorm, …): those recompute statistics each forward and expose no inverse and no log-det, so they cannot sit inside a flow's exact-likelihood NLL. ActNorm's log-det is the cheap LogDetJacobian = SizeX·SizeY·Σ_c logs[c] (one term per channel), composing additively with the other two flow layers; backward folds the negative-log-det gradient in via LogDetLossWeight (default 1.0) and propagates to logs, b, and the input. Exactly invertible by x = (z − b)/s (pInverse=true, no solve needed). FStruct[0]=C, FStruct[1]=initialised flag, FStruct[2]=inverse flag; neuron 0 = logs, neuron 1 = b, both round-tripping via Save/Load. Created with TNNetActNorm.Create() or TNNetActNorm.Create(pInverse).

Composite helper: TNNet.AddNeuralODEBlock(InputLayer, HiddenDim, Steps) wires a continuous-depth (Neural ODE) residual block (Chen et al. 2018) in one call, shape-preserving so it is a drop-in replacement for a residual trunk (d_model = InputLayer.Output.Depth). A residual step x_{n+1} = x_n + f(x_n) is one explicit Euler step of dx/dt = f(x,t); this block replaces a stack of distinct residual blocks with one shared f integrated over Steps Euler sub-steps with fixed step h = 1/Steps. f is a shape-preserving pointwise sub-block over Depth (TNNetPointwiseConvReLU(HiddenDim) -> TNNetPointwiseConvLinear(d_model)); step 1 owns the only real weights and every later step reuses them via TNNetConvolutionSharedWeights, so the parameter count is independent of Steps (the "depth for free" property). Each step scales f's output by h (TNNetMulByConstant) and adds it residually (TNNetSum). An optional 4-arg overload AddNeuralODEBlock(InputLayer, HiddenDim, Steps, Method) selects the integrator via TNNetODEMethod = (odeEuler, odeMidpoint) — the midpoint (RK2) method evaluates the same shared f twice per step (k1 = f(y); k2 = f(y + (h/2)*k1); y := y + h*k2), improving accuracy with no extra parameters (the 3-arg form stays Euler, bit-for-bit unchanged). Training uses ordinary stored-activation backprop through the unrolled steps; the adjoint-sensitivity O(1)-memory backward is a logged follow-up. See examples/NeuralODE/ (which also renders an ASCII trajectory visualisation of the learned flow untangling two interleaving half-moons).

Composite helper: TNNet.AddDeepEquilibriumBlock(InputLayer, HiddenDim, MaxIters) wires a Deep Equilibrium block (Bai/Kolter/Koltun 2019) — the implicit cousin of AddNeuralODEBlock. Where Neural-ODE unrolls a fixed number of explicit Euler steps, a DEQ defines its output as the fixed point z* = f(z*; x) of a shape-preserving weight-tied map f, found by iterating z := f(z+x) from z_0 = 0 until the residual ||z_{k+1}-z_k|| falls below tolerance or a MaxIters cap (a data-dependent "adaptive depth", parameter count independent of the iteration count). The forward runs a damped, output-bounded Picard iteration; the backward is the tractable jacobian-free phantom gradient (Geng et al. 2021) — all iterates except the last are detached, so gradients flow through only the final f application (the exact implicit-function-theorem gradient is a logged follow-up). f reuses one TNNetDeepEquilibriumSharedConv (a weight-tied conv that rebuilds its cache each forward so every application is byte-identical, as a true fixed point requires). See examples/DeepEquilibrium/.

Composite helper: TNNet.AddPonderNetBlock(InputLayer, HiddenDim, MaxSteps, PriorLambda) wires a PonderNet block (Banino, Balaguer & Blundell 2021) — a learned probabilistic-halting adaptive-computation paradigm, distinct from the implicit fixed-point AddDeepEquilibriumBlock and from any fixed-depth stack. A weight-tied step f is applied up to MaxSteps times (h_n = h_{n-1} + f(h_{n-1}), parameter count independent of MaxSteps via TNNetDeepEquilibriumSharedConv weight sharing); a shared tiny halting head TNNetPonderHalting emits lambda_n = sigmoid(...) in (0,1) per step, giving the geometric halting distribution p_n = lambda_n * prod_{k<n}(1-lambda_k) (the last step forces lambda=1 so the p_n sum to 1). The block output is the smooth p_n-weighted sum of the per-step states — no hard argmax, so the block is differentiable end-to-end. The companion TNNetPonderCostLoss head adds KL(p || truncated-geometric(prior_lambda)), a "pay to ponder" regularizer that pulls the expected step count toward the prior's mean so the model only spends extra steps where the task forces it. Inference always unrolls MaxSteps (static shapes). See examples/PonderNet/.

Composite helper: TNNet.AddFiLMConditioned(featLayer, condLayer) wires Feature-wise Linear Modulation in one call: condLayer -> TNNetFullConnectLinear(2*D) -> reshape(1,1,2*D) -> TNNetFiLM([featLayer, cond]), inferring D = featLayer.Output.Depth. It removes the manual Depth -> 2*Depth bookkeeping every FiLM call site repeats and mirrors the AddPreNormResidual/AddGatedResidual builder family. See examples/FiLMConditioning/.

Composite helper: TNNet.AddAffineBlock wires a learnable per-channel affine transform y[d] = gamma[d]*x[d] + beta[d] in one call (TNNetChannelMul -> TNNetChannelBias), separable from FullConnect. It starts as the exact identity (gamma=1, beta=0), so it can be inserted into a frozen network and fine-tuned cheaply (BitFit-style adaptation). See examples/AffineFineTune/.

Composite helper: TNNet.AddLoRAAdapter(FrozenLayer, Rank, Alpha=1.0) wires a LoRA low-rank adapter (Hu et al. 2021) in one call: a rank-r bypass down: TNNetPointwiseConvLinear(Rank) -> up: TNNetPointwiseConvLinear(d_out) is built from the input feeding FrozenLayer, scaled by Alpha/Rank, and added residually to FrozenLayer's output. The up projection is zero-initialised, so the adapter is the exact identity perturbation at step 0 — the frozen base's output is bit-for-bit unchanged on the first forward. Freeze the base (per-layer LearningRate := 0, BitFit-style) and train only the adapter for parameter-efficient fine-tuning. NOTE: the builder zeros the up weights at construction, so do not call NN.InitWeights() afterwards (it would re-randomise them). See examples/LoRAFineTune/.

TNNetEmbedding is designed to convert input tokens (usually represented as integers) into dense vector representations (embedding vectors). TNNetTokenAndPositionalEmbedding extends TNNetEmbedding by adding positional information to the token embeddings. This is crucial for transformer models that don't have an inherent notion of sequence order. Both layers are crucial for modern NLP tasks, especially when working with transformer-based models. They allow the network to work with text data by converting tokens into rich, informative vector representations that capture both semantic meaning and positional information. By using TNNetTokenAndPositionalEmbedding, you're equipping your model with the fundamental building blocks needed for advanced NLP tasks as it provides both embedding and positional encoding.

To illustrate how these layers might be used in practice, let's consider a simple example. Suppose you're building a language model for text generation. You could use these layers:

    FNN.AddLayer([
      TNNetInput.Create(csContextLen, 1, 1),
      TNNetTokenAndPositionalEmbedding.Create(csModelVocabSize, csEmbedDim, {EncodeZero=}1, {ScaleEmbedding=}0.02, {ScalePositional=}0.01)
    ]);

    for I := 1 to 2 do FNN.AddTransformerBlockCAI({Heads=}8, {IntermediateDim=}2048, {NoForward=}true, {HasNorm=}false);

    FNN.AddLayer([
      TNNetPointwiseConvLinear.Create(csModelVocabSize),
      TNNetPointwiseSoftMax.Create({SkipBackpropDerivative=}1)
    ]);

The above example resembles a simplified version of models like GPT (Generative Pre-trained Transformer). It's designed to process sequential data such as text generation tasks. The use of token and positional embeddings, followed by transformer blocks, is a standard approach in modern NLP models. The final pointwise convolution and softmax layers are typical for generating probability distributions over a vocabulary, which is common in language models. The number of transformer blocks (2) indicates that this is a lightweight model. The choice of parameters like embedding dimensions, number of heads, and intermediate dimensions would depend on the specific requirements of the task and computational constraints.

This API implements popular weight initialization methods including He (Kaiming) and Glorot/Bengio (Xavier):

• InitUniform(Value: TNeuralFloat = 1).
• InitLeCunUniform(Value: TNeuralFloat = 1).
• InitHeUniform(Value: TNeuralFloat = 1).
• InitHeUniformDepthwise(Value: TNeuralFloat = 1).
• InitHeGaussian(Value: TNeuralFloat = 0.5).
• InitHeGaussianDepthwise(Value: TNeuralFloat = 0.5).
• InitGlorotBengioUniform(Value: TNeuralFloat = 1).
• InitSELU(Value: TNeuralFloat = 1).

• procedure FlipX();
• procedure FlipY();
• procedure CopyCropping(Original: TVolume; StartX, StartY, pSizeX, pSizeY: integer);
• procedure CopyResizing(Original: TVolume; NewSizeX, NewSizeY: integer);
• procedure AddGaussianNoise(pMul: TNeuralFloat);
• procedure AddSaltAndPepper(pNum: integer; pSalt: integer = 2; pPepper: integer = -2);

You can add layers one by one or you can add an array of layers in one go. Follows an example adding layers one by one:

NN.AddLayer(TNNetConvolutionReLU.Create({Features=}64, {FeatureSize=}5, {Padding=}2, {Stride=}1));
NN.AddLayer(TNNetMaxPool.Create(2));

The next example shows how to add an array of layers that is equivalent to the above example:

NN.AddLayer([
  TNNetConvolutionReLU.Create({Features=}64, {FeatureSize=}5, {Padding=}2, {Stride=}1),
  TNNetMaxPool.Create(2)
]);

Since 2017, this API supports multi-paths architectures. You can create multi-paths with AddLayerAfter method. For concatenating (merging) paths, you can call either TNNetConcat or TNNetDeepConcat. Follows an example:

// Creates The Neural Network
NN := TNNet.Create();
 
// This network splits into 2 paths and then is later concatenated
InputLayer := NN.AddLayer(TNNetInput.Create(32, 32, 3));
 
// First branch starting from InputLayer (5x5 features)
NN.AddLayerAfter(TNNetConvolutionReLU.Create({Features=}16, {FeatureSize=}5, {Padding=}2, {Stride=}1), InputLayer);
NN.AddLayer(TNNetMaxPool.Create(2));
NN.AddLayer(TNNetConvolutionReLU.Create({Features=}64, {FeatureSize=}5, {Padding=}2, {Stride=}1));
NN.AddLayer(TNNetMaxPool.Create(2));
EndOfFirstPath := NN.AddLayer(TNNetConvolutionReLU.Create({Features=}64, {FeatureSize=}5, {Padding=}2, {Stride=}1));
 
// Another branch starting from InputLayer (3x3 features)
NN.AddLayerAfter(TNNetConvolutionReLU.Create({Features=}16, {FeatureSize=}3, {Padding=}1, {Stride=}1), InputLayer);
NN.AddLayer(TNNetMaxPool.Create(2));
NN.AddLayer(TNNetConvolutionReLU.Create({Features=}64, {FeatureSize=}3, {Padding=}1, {Stride=}1));
NN.AddLayer(TNNetMaxPool.Create(2));
EndOfSecondPath := NN.AddLayer(TNNetConvolutionReLU.Create({Features=}64, {FeatureSize=}3, {Padding=}1, {Stride=}1));
 
// Concats both branches into one branch.
NN.AddLayer(TNNetDeepConcat.Create([EndOfFirstPath, EndOfSecondPath]));
NN.AddLayer(TNNetConvolutionReLU.Create({Features=}64, {FeatureSize=}3, {Padding=}1, {Stride=}1));
NN.AddLayer(TNNetLayerFullConnectReLU.Create(64));
NN.AddLayer(TNNetLayerFullConnectReLU.Create(NumClasses));

These source code examples show AddLayerAfter:

• DenseNetBC L40
• Identity Shortcut Connection - ResNet building block

You can find more about multi-path architectures at:

• Multi-path Convolutional Neural Networks for Complex Image Classification.
• Dual Path Networks.

These datasets can be easily loaded:

procedure CreateCifar10Volumes(out ImgTrainingVolumes, ImgValidationVolumes, ImgTestVolumes: TNNetVolumeList);

Source code example: Simple CIFAR-10 Image Classifier

procedure CreateCifar100Volumes(out ImgTrainingVolumes, ImgValidationVolumes, ImgTestVolumes: TNNetVolumeList);

Source code example: CAI Optimized DenseNet CIFAR-100 Image Classifier

procedure CreateMNISTVolumes(out ImgTrainingVolumes, ImgValidationVolumes,
  ImgTestVolumes: TNNetVolumeList;
  TrainFileName, TestFileName: string;
  Verbose:boolean = true;
  IsFashion:boolean = false);

Source code examples:

• Simple MNIST Image Classifier
• Simple Fashion MNIST Image Classifier

In the case that your dataset has one class per folder, you can call CreateVolumesFromImagesFromFolder for loading your data into RAM:

// change ProportionToLoad to a smaller number if you don't have enough RAM.
ProportionToLoad := 1;
WriteLn('Loading ', Round(ProportionToLoad*100), '% of the Plant leave disease dataset into memory.');
CreateVolumesFromImagesFromFolder
(
  ImgTrainingVolumes, ImgValidationVolumes, ImgTestVolumes,
  {FolderName=}'plant', {pImageSubFolder=}'',
  {color_encoding=}csRGB{RGB},
  {TrainingProp=}0.9*ProportionToLoad,
  {ValidationProp=}0.05*ProportionToLoad,
  {TestProp=}0.05*ProportionToLoad,
  {NewSizeX=}128, {NewSizeY=}128
);

The example above shows how to load the dataset with 90% loaded into training and 5% loaded for each validation and testing. Images are being resized to 128x128.

Source code examples:

• Simple Plant Leaf Disease Image Classifier for the PlantVillage Dataset
• Colorectal Cancer Dataset Image Classifier
• Malaria Dataset Image Classifier
• Tiny ImageNet 200

In the case that your image classification dataset is too big to be stored in RAM, you can follow this example:

    FTrainingFileNames, FValidationFileNames, FTestFileNames: TFileNameList;
...
    ProportionToLoad := 1;
    CreateFileNameListsFromImagesFromFolder(
      FTrainingFileNames, FValidationFileNames, FTestFileNames,
      {FolderName=}'places_folder/train', {pImageSubFolder=}'',
      {TrainingProp=}0.9*ProportionToLoad,
      {ValidationProp=}0.05*ProportionToLoad,
      {TestProp=}0.05*ProportionToLoad
    );

Then, you can call a fitting method made specific for this:

NeuralFit := TNeuralImageLoadingFit.Create;
...
NeuralFit.FitLoading({NeuralNetworkModel}NN, {ImageSizeX}256, {ImageSizeY}256, FTrainingFileNames, FValidationFileNames, FTestFileNames, {BatchSize}256, {Epochs}100);

TNeuralImageLoadingFit.FitLoading has been tested with Places365-Standard Small images 256x256 with easy directory structure. You can follow this example:

• Simple Plant Leaf Disease Image Classifier with Few RAM

When loading an image from a file, the easiest and fastest method is calling LoadImageFromFileIntoVolume(ImageFileName:string; V:TNNetVolume). When loading from an TFPMemoryImage, you can load with LoadImageIntoVolume(M: TFPMemoryImage; Vol:TNNetVolume). For saving an image, the fastest method is SaveImageFromVolumeIntoFile(V: TNNetVolume; ImageFileName: string).

The easiest way to train your neural network is utilizing unit neuralfit.pas. Inside this unit, you’ll find the class TNeuralImageFit that is used by many examples.

TNeuralImageFit has been designed for image classification tasks and can be called as follows:

procedure Fit(pNN: TNNet;
  pImgVolumes, pImgValidationVolumes, pImgTestVolumes: TNNetVolumeList;
  pNumClasses, pBatchSize, Epochs: integer);

Each volume should be provided with property tag that contains the corresponding class. TNeuralImageFit internally implements data augmentation techniques: flipping, making gray, cropping and resizing. These techniques can be controlled with:

property HasImgCrop: boolean read FHasImgCrop write FHasImgCrop;
property HasMakeGray: boolean read FHasMakeGray write FHasMakeGray;
property HasFlipX: boolean read FHasFlipX write FHasFlipX;
property HasFlipY: boolean read FHasFlipY write FHasFlipY;
property MaxCropSize: integer read FMaxCropSize write FMaxCropSize; 

Once you have a trained neural network, you can use an advanced classification procedure that will average the classification probability of the input image with its flipped and cropped versions. This process frequently gives a higher classification accuracy at the expense of internally running the very same neural network a number of times. This is how you can classify images:

procedure ClassifyImage(pNN: TNNet; pImgInput, pOutput: TNNetVolume);

In the case that you would like to look into TNeuralImageFit in more detail, the Simple CIFAR-10 Image Classifier example is a good starting point.

In the case that your training, validation and testing data can be defined as volume pairs from input volume to output volume, the easiest way to train your neural network will be calling TNeuralFit. This class has the following fitting method:

procedure Fit(pNN: TNNet;
  pTrainingVolumes, pValidationVolumes, pTestVolumes: TNNetVolumePairList;
  pBatchSize, Epochs: integer);

Both AND, OR and XOR with neuralfit unit and hypotenuse function examples load volume pair lists for training.

The TNeuralFit implementation has a limitation: your dataset needs to be placed into RAM. In the case that your dataset is too large for RAM, you can call TNeuralDataLoadingFit:

TNNetGetPairFn = function(Idx: integer; ThreadId: integer): TNNetVolumePair of object;
TNNetGet2VolumesProc = procedure(Idx: integer; ThreadId: integer; pInput, pOutput: TNNetVolume) of object;
  
TNeuralDataLoadingFit = class(TNeuralFitBase)
...
    procedure FitLoading(pNN: TNNet;
      TrainingCnt, ValidationCnt, TestCnt, pBatchSize, Epochs: integer;
      pGetTrainingPair, pGetValidationPair, pGetTestPair: TNNetGetPairFn); overload;
    procedure FitLoading(pNN: TNNet;
      TrainingCnt, ValidationCnt, TestCnt, pBatchSize, Epochs: integer;
      pGetTrainingProc, pGetValidationProc, pGetTestProc: TNNetGet2VolumesProc); overload;

The Hypotenuse with FitLoading example uses TNeuralDataLoadingFit so it creates training pairs on the fly.

TNeuralImageFit and TNeuralDataLoadingFit both descend from TNeuralFitBase. From TNeuralFitBase, you can define training properties:

property Inertia: single read FInertia write FInertia;
property InitialEpoch: integer read FInitialEpoch write FInitialEpoch;
property InitialLearningRate: single read FInitialLearningRate write FInitialLearningRate;
property LearningRateDecay: single read FLearningRateDecay write FLearningRateDecay;
property CyclicalLearningRateLen: integer read FCyclicalLearningRateLen write FCyclicalLearningRateLen;
property Momentum: single read FInertia write FInertia;
property L2Decay: single read FL2Decay write FL2Decay;
property FileNameBase: string read FFileNameBase write FFileNameBase;

You can also collect current statistics:

property CurrentEpoch: integer read FCurrentEpoch;
property CurrentStep: integer read FCurrentStep;
property CurrentLearningRate: single read FCurrentLearningRate;
property TestAccuracy: TNeuralFloat read FTestAccuracy;
property TrainingAccuracy: TNeuralFloat read FTrainingAccuracy;
property Running: boolean read FRunning;

Some events are available:

property OnStart: TNotifyEvent read FOnStart write FOnStart;
property OnAfterStep: TNotifyEvent read FOnAfterStep write FOnAfterStep;
property OnAfterEpoch: TNotifyEvent read FOnAfterEpoch write FOnAfterEpoch;

You can define your own learning rate schedule:

property CustomLearningRateScheduleFn: TCustomLearningRateScheduleFn read FCustomLearningRateScheduleFn write FCustomLearningRateScheduleFn;
property CustomLearningRateScheduleObjFn: TCustomLearningRateScheduleObjFn read FCustomLearningRateScheduleObjFn write FCustomLearningRateScheduleObjFn;

TNeuralFitBase descends from TMObject that allows you to code your own message treatment:

property MessageProc: TGetStrProc read FMessageProc write FMessageProc;
property ErrorProc: TGetStrProc read FErrorProc write FErrorProc;

On your own code, you could something is:

MyFit.MessageProc := {$IFDEF FPC}@{$ENDIF}Self.MessageProc;
MyFit.ErrorProc := {$IFDEF FPC}@{$ENDIF}Self.ErrorProc;

If you don’t need any message at all, you can hide messages by calling:

procedure HideMessages();

You can also disable fitting verbosity with:

property Verbose: boolean read FVerbose write FVerbose;

Your code will look like this:

NeuralFit := TNeuralImageFit.Create;
...
NeuralFit.Verbose := false;
NeuralFit.HideMessages();

This API has easy to use, lightweight and platform independent parallel processing API methods.

As an example, assuming that you need to run a procedure 10 times in parallel, you can create 10 thread workers as follows:

FProcs := TNeuralThreadList.Create( 10 );

As an example, this is the procedure that we intend to run in parallel:

procedure MyClassName.RunNNThread(index, threadnum: integer);
begin
  WriteLn('This is thread ',index,' out of ',threadnum,' threads.');
end; 

Then, to run the procedure RunNNThread passed as parameter 10 times in parallel, do this:

FProcs.StartProc({$IFDEF FPC}@RunNNThread{$ELSE}RunNNThread{$ENDIF});

You can control the blocking mode (waiting threads to finish before the program continues) as per declaration:

procedure StartProc(pProc: TNeuralProc; pBlock: boolean = true);

Or, if you prefer, you can specifically say when to wait for threads to finish as per this example:

FProcs.StartProc({$IFDEF FPC}@RunNNThread{$ELSE}RunNNThread{$ENDIF}, false);
// insert your code here
FProcs.WaitForProc(); // waits until all threads are finished.

When you are done, you should call:

FProcs.Free; 

Beyond the runnable examples above, TNNet exposes a family of in-process introspection and diagnostic methods (most are demonstrated by the linked examples). They are grouped here by what they inspect; the linked example carries the full description, sample output and caveats.

• TNNet.PrintSummary / SummaryString — Keras-style table of per-layer index, class, output shape (X,Y,D), param and neuron counts, ending with totals (SummaryString returns it as a string instead of writing to stdout). Used throughout the examples (e.g. ConfusionMatrixReport, GradientNormReport, PerplexityEval).
• TNNet.ToGraphvizDot — emits a Graphviz .dot of the layer DAG (one node per layer, edges following the real graph incl. multi-input TNNetSum / TNNetDeepConcat); render with dot -Tpng net.dot -o net.png. → example
• TNNet.DiffArchitecture(OtherNet) / DiffArchitectureFromString(s) — unified-diff-style report of architectural differences between two networks (LCS-aligned so single inserts/removes don't cascade). → example
• TNNet.ReceptiveFieldReport(NN) — analytically propagates the receptive-field recurrence through the spatial layers (size, jump, input coverage, global-mixing cut point); no data needed. → example
• TNNet.CountFLOPsPerLayer(NN) — per-layer forward-pass FLOP estimate and each layer's share, flagging layer classes the estimator doesn't model. → example
• TNNet.LayerTimingReport(NN, Sample, Iterations) — per-layer forward-pass wall-clock cost: mean microseconds/forward and percent of total (ASCII #-bar) measured over Iterations forward passes.

• TNNet.WeightHistogramReport(NN) — per-trainable-layer weight statistics and ASCII bar histograms. → example
• TNNet.WeightSpectrumReport(NN) — top singular value per layer (power iteration via the reusable TNNet.EstimateSpectralNorm helper); flags rank-1 collapse / high spectral norm. → example
• TNNet.EstimateSpectralRadius(Layer, Iters) — power-iteration estimate of a layer weight matrix's spectral radius ρ = |λ|_max (the largest-magnitude eigenvalue, via the v := W·v / ‖W·v‖ recurrence — no Wᵀ step), the eigenvalue sibling of the singular-value EstimateSpectralNorm. For a non-symmetric matrix ρ ≤ σ_1, so radius is the tighter, correct stability target for recurrent / echo-state reservoirs (scale to ρ_target < 1 directly) while σ_1 (the norm) is the right Lipschitz/clipping bound. Requires a square matrix (returns 0 otherwise). → used in example
• TNNet.WeightSpectralTailReport(NN) — label-free HT-SR quality metric: power-law tail exponent alpha per layer plus a network-average weighted-alpha (the WeightWatcher metric). → example

• TNNet.ActivationStatsReport(NN, Samples) — per-layer activation distribution statistics; flags near-collapsed / saturating layers. → example
• TNNet.DeadNeuronReport(NN, Samples) — dead-unit counts across ReLU-family layers over a probe batch. → example
• TNNet.NeuronCorrelationReport(NN, Samples) — intra-layer neuron redundancy: a |rho| histogram, top correlated pairs, and an effective-neuron count. → example
• TNNet.IntrinsicDimensionReport(NN, Probes) — per-layer effective dimensionality: PCA participation ratio + the nonlinear TwoNN manifold estimate, side by side. → example
• TNNet.RepresentationSimilarityReport(NN, Probes [, OtherNet]) — linear-CKA similarity between every pair of layer activations (rotation/scale-invariant; optional cross-net). → example
• TNNet.RoutingEntropyReport(NN, Probe) — batch-level routing diagnostic for a TNNetSoftDecisionTree layer: per-leaf occupancy (is the tree using all 2^D leaves or collapsing onto a few?), average per-gate binary entropy (crisp vs mushy splits), and average per-sample effective-leaf-count exp(−Σ P_l·ln P_l) (decisive vs diffuse routing). The statistical companion to the example's single-point decision path. → example

• TNNet.ConfusionMatrixReport(NN, Samples, NumClasses) — confusion matrix + precision/recall/F1 + most-confused pairs + per-class hard-example indices. → example
• TNNet.TopLogitMarginReport(NN, Samples, NumClasses) — per-sample top1 − top2 logit margin, per-class stats, and a lowest-margin "hard examples" pool. → example
• TNNet.PerplexityReport(NN, Tokens, ContextLen) — cross-entropy, perplexity, bits-per-character, top-k accuracy and worst-K positions for a sequence head. → example
• TNNet.TTAReport(NN, Probes, Labels) — test-time-augmentation accuracy over a fixed transform menu vs the clean baseline, with a helps/neutral/hurts verdict. → example
• TNNet.DecisionBoundaryReport(NN, Probes) — ASCII argmax map, confidence overlay and boundary-length estimate for a 2-input classifier head. → example
• neuralcalibration unit (separate from the *Report family) — CalibrationReport / ComputeCalibration (ECE/MCE, Brier, reliability diagram) and FitTemperature (temperature scaling, never mutating the backbone). → example

• TNNet.GradientNormReport(NN, Input, Target) — per-layer ‖dL/dx‖ and ‖dL/dW‖ with vanishing/exploding flags. → example
• TNNet.LossLandscapeProbe(NN, Samples, K, R) — loss along a filter-normalised random direction; sharpness scalar + loss-doubling radius. → example
• TNNet.GradientConflictReport(NN, Samples [, UseTrueLabel, LayerIdx]) — pairwise per-sample gradient cosines: conflict fraction + per-class-pair mean-cosine matrix. → example
• TNNet.GradientNoiseScaleReport(NN, Samples [, UseTrueLabel, LayerIdx]) — gradient signal-to-noise ratio and the simple noise scale B_simple (the critical batch size). → example
• TNNet.NeuralTangentKernelReport(NN, Samples [, TargetClass]) — empirical NTK Gram, its eigenspectrum, condition number and kernel-target alignment. → example
• TNNet.HessianCurvatureReport(NN, Samples) — loss-surface sharpness: Hessian trace + top eigenvalue via finite-difference Hessian-vector products. → example
• TNNet.LocalLearningCoefficientReport(NN, Samples [, ChainLen, Eps, Gamma]) — Local Learning Coefficient (LLC, an empirical RLCT from Singular Learning Theory): effective-dimensionality / degeneracy of the minimum, estimated from a tempered anchored-SGLD chain (LLC_hat = n·β·(mean_chain[L] − L(w*))). Counts flat, degenerate directions the 2nd-order Hessian top eigenvalue is blind to; non-destructive (weights snapshotted and restored). → example
• TNNet.EnableInputGradient — helper that resizes the input layer's error tensors so a backward pass can deposit d(output)/d(input) on Layers[0] (off by default; needed by the saliency, adversarial and effective-RF reports).

• TNNet.AdversarialRobustnessReport(NN, Samples, Labels, EpsList) — FGSM accuracy-vs-eps degradation curve, per-sample critical-eps histogram, robust/fragile verdict. → example
• TNNet.MCDropoutUncertaintyReport(NN, Probes [, Labels]) — Monte-Carlo-Dropout total / aleatoric / epistemic (BALD) uncertainty, keeping dropout active at inference. → example
• TNNet.EquivarianceReport(NN, Probes) — output invariance error under a fixed flip / reverse / roll transform menu, with an invariant/sensitive verdict. → example
• TNNet.EffectiveReceptiveFieldReport(NN, Probes) — empirical (gradient-measured) receptive field vs the analytical one — what a unit actually weights. → example

• TNNet.SaliencyReport(NN, Probe) — input-gradient / SmoothGrad / Integrated-Gradients heatmaps for the predicted class (with the IG completeness check). → example
• TNNet.GradCAMReport(NN, Probe [, ConvLayerIdx, ForcedClass]) — Grad-CAM (Selvaraju et al. 2017) coarse, class-discriminative conv-feature heatmap for the predicted class, nearest-upsampled to the input plane (complements the fine input-pixel SaliencyReport). → example
• TNNet.LRPReport(NN, Probe [, ForcedClass, TopK, Eps]) — Layer-wise Relevance Propagation (Bach et al. 2015): a conservation method (not a gradient one) that back-distributes the explained logit's relevance via the epsilon-rule, printing the per-layer conservation residual, the top-k most-relevant input positions and an input-relevance heatmap (skips attention/norm layers honestly). → example
• TNNet.AttentionEntropyReport(NN, Probes) — per-row attention entropy with dead/spike head flags for every TNNetScaledDotProductAttention layer. → example
• TNNet.ActivationPatchingReport(NN, CleanInput, CorruptInput [, TargetIdx]) — causal trace: which layer's activations carry the information that decides the prediction. → example
• TNNet.LogitLensReport(NN, pInput [, HeadStartIdx]) — re-applies the net's own trained head at each depth (zero new params) to see when the prediction crystallises. → example
• TNNet.TunedLensReport(NN, pInput [, HeadStartIdx, TrainIters, LearningRate]) — the learned sibling of the logit lens (Belrose et al. 2023): fits one per-layer affine translator (frozen trunk + head) on the unlabelled probe by KL-to-self, then prints the tuned lens' KL-to-final and entropy side by side with the raw logit-lens columns — the tuned curve commits earlier and tracks the final answer more faithfully (lower KL-to-final). → example
• TNNet.PredictionDepthReport(NN, Support, SupportLabels, Queries [, QueryLabels]) — per-example difficulty via the depth where a k-NN vote locks onto the final answer. → example
• TNNet.LayerSensitivityReport(NN, Samples [, Targets]) — output/loss delta from small multiplicative per-layer weight perturbations, with a fragility verdict. → example
• TNNet.MagnitudePruningReport(NN, Samples [, Labels, Tolerance, PerLayer]) — no-retrain accuracy-vs-sparsity curve and the prunability knee (global or per-layer). → example

• TNNet.ModeConnectivityReport(NN, SnapshotB, Samples) — loss barrier along the linear interpolation between two trained nets ("same basin or separated?"). → example
• TNNet.PermutationAlignReport(NN, SnapshotB, Samples [, ScoreMode, K]) — "Git Re-Basin": loss barrier before vs after quotienting out neuron-permutation symmetry. → example

This NLP source code example shows a (hello world) small neural network trained on the Tiny Stories dataset. A more complex NLP example showing the implementation of the GPT-3 Small architecture is also available.

In short, this API supports:

• Samplers: TNNetSamplerGreedy, TNNetSamplerTopK and TNNetSamplerTopP.
• A logit processor for repetition control: TNNetTokenHistoryPenalty — a stateful pre-sampler that reshapes the next-token logits in place using generation history, with three standard knobs (repetition penalty in the sign-correct CTRL form, frequency penalty, and presence penalty). Use it as Penalty.Apply(Logits); tok := Sampler.GetToken(Logits); Penalty.RegisterToken(tok);.
• A tokenizer: TNeuralTokenizer.
• A transformer decoder: AddTransformerBlockCAI.

In the case that you would like to know more about what the CAI's author is working at, here we go.

Optimizing the first layers of a convolutional neural network:

• Color-aware two-branch DCNN for efficient plant disease classification.
• Reliable Deep Learning Plant Leaf Disease Classification Based on Light-Chroma Separated Branches.

Optimizing deep layers of a convolutional neural network:

• Grouped Pointwise Convolutions Reduce Parameters in Convolutional Neural Networks.
• An Enhanced Scheme for Reducing the Complexity of Pointwise Convolutions in CNNs for Image Classification Based on Interleaved Grouped Filters without Divisibility Constraints.

Optimizing LLMs:

• Saving 77% of the Parameters in Large Language Models Technical Report

Publicações em Português:

• A Evolução dos Algoritmos Mentais.
• Da Física à Inteligência Extrassomática.
• Inteligência Artificial Popperiana.
• Operações Lógicas Quânticas e Colorabilidade de Grafos.

Pull requests are welcome. Having requests accepted might be hard.

In the case that you need help with your own A.I. project (Pascal, Python, or PHP), please feel free to contact the author of this API.

You can cite this API in BibTeX format with:

@software{cai_neural_api_2021_5810077,
  author       = {Joao Paulo Schwarz Schuler},
  title        = {CAI NEURAL API},
  month        = dec,
  year         = 2021,
  publisher    = {Zenodo},
  version      = {v1.0.6},
  doi          = {10.5281/zenodo.5810077},
  url          = {https://doi.org/10.5281/zenodo.5810077}
}