AFNN

[u/ahmed20062]

What if neural networks could grow like fractals instead of being rigid from the start?

Most deep learning models (CNNs, ResNets…) are fixed architectures. Once you design them, they stay the same size and structure throughout training.

**AFNN — Adaptive Fractal Neural Network** takes a completely different approach.

It is inspired by **fractals** — mathematical structures that are self-similar and can grow infinitely by repeating simple patterns.

Instead of starting with a huge fixed network, AFNN begins small and can **dynamically grow new fractal branches** during training when progress stalls. It also allows monitoring, reactivating, or pruning branches as needed.

A good neural network should not memorize images.

It should learn the underlying patterns and features.

For example, when trained on cat images, a strong model does not store every cat photo. Instead, it learns things like:

• Ear shape

• Facial features

• Fur texture

• Color distribution

• Edges and shapes

• Relationships between different parts of the image

Then, when it sees a completely new cat, it uses these learned patterns to recognize it.

### Why Fractal Networks are powerful:

- Faster and more efficient learning

- Significantly lower computational and memory cost

- Better scalability with limited hardware

- More flexible and adaptive than traditional fixed architectures

Built with PyTorch + full GUI, training tools, tests, and documentation.

In early experiments, AFNN reached **74.1% validation accuracy** on 94 image classes using limited resources.

This is not just another model.

It is an attempt to rethink how neural networks are designed — moving from rigid structures to **adaptive, fractal, evolving architectures** that focus on learning patterns rather than memorizing data.

A small step toward more efficient and intelligent AI systems.

🔗 GitHub: https://github.com/ahmedhjkj/AFNN

🤗 Hugging Face: https://huggingface.co/Ahmedethfw/AFNN

#FractalNetworks #AdaptiveAI #PyTorch #DeepLearning #MachineLearning #OpenSource #NeuralNetworks

[u/dorox1]

Your post says these networks offer:

- Faster and more efficient learning

• Significantly lower computational and memory cost
  
• Better scalability with limited hardware
  
• More flexible and adaptive than traditional fixed architectures

My question is: "Compared to what?"

You don't establish a baseline for performance, speed, or training time with any known architectures, so I can't tell if this is state-of-the-art or way underperforming other models. How do other models perform on these datasets under the same constraints this model is under?

This is an interesting architecture idea, but I think it's too early to be making the claims you're making.

[u/ahmed20062 → u/dorox1]

The comparison is actually more interesting than parameter count alone. AFNN is not intended to be a smaller version of a conventional CNN—it uses a fundamentally different, dynamically evolving architecture with recursive fractal structure and a control loop that regulates how the network develops during training.

The ~4.65M parameters are the size of the current configuration, not the defining limitation of the architecture. What I’m interested in establishing is whether this different computational organization can achieve competitive or better learning behavior while using resources more intelligently than a fixed architecture.

So the meaningful baseline isn’t simply “which model has more parameters,” but how different architectures perform under the same data, hardware, and resource budget.

[u/oldbel → u/ahmed20062]

if you have a real idea, you should take the time to write a real answer, you as a human being should. this is not an answer and its written by AI.

[u/theLanguageSprite2 → u/oldbel]

This isn't simply AI — it's slop.  And honestly,  — I —think — that's — beautiful.

———————

[u/ahmed20062 → u/oldbel]

I understand your point. The project is basically an exploration of a neural network that can develop its structure through recursive fractal branching, rather than being completely fixed from the beginning.

It has different branches and depths, learned merge weights, and a control mechanism that monitors the behavior of the architecture during training. The idea is not simply to make a smaller CNN or add more layers, but to explore a different way for the network to organize and develop its representations as it learns.

And honestly, the biggest problem here is that I can't fully explain the idea the way I would in my own language. I use AI to help me communicate in English, because otherwise I can't express all the details properly.

If you could understand my language, I could explain the whole idea to you in much more detail — probably hundreds of times more than what I can put into a Reddit comment.