JackRipperVA•This week
[P] [R] sANNd: A New Neural Network Framework Using Trainable Iterators
sANNd
sANNd is a lightweight, modular neural network library designed as a sandbox for experimenting with new ideas in artificial intelligence.
The Mould Class: A Pythonic Building Block
The Mould class is a core component of sANNd. It provides a Pythonic way to apply functions to data that’s bundled inside objects:
Encapsulated Variables:
Each Mould object holds a set of variables (for example, weights or parameters) inside it. This means related data is kept together in one place (the object), making the code organized and intuitive.
Static Functions:
A Mould class defines its operation as a static method – essentially a function that isn’t tied to a specific instance. This static function takes in inputs (and possibly other Mould objects’ variables) and produces an output.
In simple terms, the Mould’s static method describes how to transform input data using the Mould’s internal variables.
Pythonic Usage:
Using static methods in this way is a clean, Pythonic design. You call the Mould’s function through the class, but it applies to the data in the object. This approach lets you clearly separate what the operation is (the logic in the static function) from which data it uses (the variables inside the Mould instance).
Example: Imagine a Mould class called LinearMould that has a static function to compute a linear transformation (like y = W*x + b). An instance of LinearMould would hold specific W and b values, and you’d use the static method to apply that linear formula to an input. This gives you the convenience of object-oriented design (encapsulating W and b) with the clarity of a standalone function defining the math.
Chaining Moulds for Complex Computations
Moulds become even more powerful when you chain them together. You can connect multiple Moulds so that the output of one becomes the input of the next:
Sequential Operations:
Just like stacking layers in a neural network, you can place Moulds in sequence. For example, you might take the output from LinearMouldA and feed it into LinearMouldB.
In code, this might look as simple as using the output of one call as the argument to the next. The design of sANNd makes this straightforward – the static function of each Mould knows how to handle the data coming in.
Building Pipelines:
By chaining Moulds, you create a pipeline of transformations. Each Mould handles one step of computation, and together they produce a final result.
This could represent a multi-layer neural network, a data processing pipeline, or any custom sequence of operations you need.
There’s no strict limit to how you can chain them; you have the freedom to combine Moulds in any order that makes sense for your experiment.
Clarity and Modularity:
Because each Mould is a self-contained piece (with its variables and function), chaining them doesn’t turn your code into a black box. You can inspect or modify any part of the chain easily.
This modular design means you can insert, remove, or replace Moulds to see how it affects the overall computation, which is great for experimentation.
Implicit Backward Path (Automatic Backpropagation)
One major benefit of using chained Moulds is that they implicitly define the backward path for training with gradient descent (backpropagation):
Automatic Gradient Flow: When you connect Moulds in a sequence for a forward pass (input → Mould A → Mould B → output), you’ve essentially defined a computation graph.
sANNd uses this graph to handle the reverse computation automatically.
In other words, if you calculate an error or loss based on the final output, sANNd can propagate that error backwards through each Mould in the chain.
No Manual Backprop:
You do not need to manually code how gradients flow through each Mould.
The way you set up the Moulds’ static functions already determines how outputs depend on inputs and internal variables. sANNd leverages that to perform backpropagation. This is similar in spirit to how libraries like PyTorch/TF do “autograd,” but here it’s a natural result of the Mould chain architecture.
Gradient Descent Ready:
Because the backward path is established by the forward connections, you can apply gradient descent optimizations out of the box. For instance, you can adjust the weights inside each Mould based on the computed gradients to minimize your loss.
The design ensures that each Mould’s contribution to the final error is tracked, so all parts of your model learn appropriately during training.
In short, defining your model with Moulds means you get training capability for free. You focus on describing the forward computations, and sANNd handles the math behind learning from errors.
Comparing sANNd to Traditional Frameworks
sANNd’s approach is quite different from traditional Python-based neural network frameworks.
Here’s how it stacks up against frameworks like TensorFlow, PyTorch, or Keras in terms of approach, flexibility, and intended use:
Design Approach:
Traditional frameworks use predefined layer classes and often build a computation graph behind the scenes. For example, Keras might have a Dense layer class, and TensorFlow might construct a static graph (in TF1) or use eager execution (in TF2).
sANNd takes a simpler approach – it uses plain Python classes and static functions (Moulds) to define computations. There’s no need to learn a new graph syntax or decorators; if you know Python functions and classes, you can read and write sANNd models. This makes the internal workings more transparent and easier to follow.
Flexibility:
While frameworks like PyTorch and TensorFlow are very powerful, they can introduce a lot of boilerplate and assume you’re building typical architectures.
sANNd is extremely modular and flexible. You aren’t limited to the layers someone else defined – you can create any operation you want as a Mould.
Want to experiment with a novel activation function or a custom recurrent connection? Just define it in a Mould.
There’s less magic and abstraction obscuring your code, so unconventional model structures are easier to implement. (Of course, major frameworks can also be extended, but sANNd makes this feel more natural by staying within standard Python paradigms.)
Intended Use:
sANNd is intended for experimentation and research. It’s like a toolkit for tinkering. You get fine-grained control over every part of the network, which is ideal for trying out bold new ideas that don’t fit the mold of common deep learning models.
In contrast, TensorFlow/PyTorch shine in production environments and large-scale training – they are optimized (GPU support, highly efficient tensor operations) and come with many utilities for things like data loading, distributed training, etc.
sANNd doesn’t aim to replace them for those heavy-lifting tasks. Instead, it’s meant for when you need a lighter, more interpretable setup to prototype concepts.
You might use sANNd to prove out a concept or test a hypothesis in AI research, and later switch to a bigger framework if you need to scale it up.
Simplicity vs. Complexity:
By design, sANNd keeps things simple.
The trade-off is that it might not have the raw performance optimizations of the large frameworks. However, this simplicity is a feature – it means the code is easier to understand and modify.
For many research scenarios, being able to quickly tweak an idea is more important than squeezing out maximum speed. Traditional frameworks, with their complexity, can sometimes be harder to adapt for radically different ideas (you might find yourself fighting the framework). With sANNd, the framework gets out of your way as much as possible.
Modular and Experimental by Nature
One of the driving philosophies of sANNd is to be modular and experimental, to further ML research:
Modularity:
sANNd is built from small, composable pieces. The Mould class is one such piece, and you can imagine building additional components in a similar spirit.
This modular design means you can re-use components, mix and match them, or replace one implementation with another without affecting the rest of your system.
It’s like having a box of building blocks for neural networks – you can assemble them in standard ways or in completely novel configurations.
Experimentation Friendly:
Because it avoids heavy abstraction, sANNd lets you directly see and control what’s happening at each step. This is great for research, where you might need to observe intermediate results, inject custom behavior, or adjust the learning process on the fly.
sANNd’s straightforward structure (Python objects and functions) makes such interventions possible. You’re not constrained to a fixed training loop or forced to use certain layer types.
True Intelligence Research: Achieving “True Intelligence” (often related to artificial general intelligence or other forms of broader AI) may require going beyond the usual neural network designs.
sANNd aims to be a playground for these ideas. Its flexibility allows researchers to integrate unconventional elements — be it new memory structures, dynamic connection patterns, or hybrid models that combine symbolic and neural approaches. You can use sANNd to prototype these offbeat ideas quickly. In essence, it’s easier to test “what if we try this?” scenarios with sANNd than with more rigid frameworks.
In summary, sANNd’s unique Mould class and design philosophy offer a fresh take on building neural networks.
It emphasizes clarity, composability, and flexibility, allowing you to focus on creativity and understanding. Whether you’re stacking simple Moulds into a deep model, or inventing a completely new form of network, sANNd provides a friendly foundation.
It’s not here to dethrone TensorFlow or PyTorch in industry applications – instead, it’s here to give researchers and enthusiasts a more malleable tool for exploring the frontiers of AI.
Enjoy using sANNd as your neural network sandbox, and happy experimenting!
![[P] [R] sANNd: A New Neural Network Framework Using Trainable Iterators](https://jfbmhhfxbbrxcmwilqxt.supabase.co/storage/v1/object/public/resource-images/MachineLearning_No-code_AI_20250328_190640_processed_image.jpg)
![[D] Playing big league at home on a budget?](https://jfbmhhfxbbrxcmwilqxt.supabase.co/storage/v1/object/public/resource-images/MachineLearning_AI_implementation_for_beginners_20250328_190039_processed_image.jpg)
![[D] Do you know any institutions/nonprofits/companies/governments/etc. trying to apply deep learning and other ML/AI/GenAI techniques to implement universal basic income (UBI) or something similar to UBI like universal basic services?](https://jfbmhhfxbbrxcmwilqxt.supabase.co/storage/v1/object/public/resource-images/MachineLearning_AI_implementation_20250328_185813_processed_image.jpg)
![13 Best AI Tools For Startups & Entrepreneurs [2024]](https://img.youtube.com/vi/J1D_LPYKViY/maxresdefault.jpg)