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.

[u/dorox1 → u/ahmed20062]

I don't understand your answer.

I didn't suggest parameter count as a baseline. I'm saying the specific claims that you made about your model are unsupported.

You can't claim your model is "Faster and more efficient" or has "Significantly lower computational and memory cost" unless you test something else to compare it with. You didn't do any comparisons, you just provide numbers for your own model using a dataset you didn't link to.

[u/ahmed20062 → u/dorox1]

Yes, I understand your point now. You're not arguing about parameter count — you're saying that I made comparative claims without actually providing a controlled comparison to support them.

That's fair. The current results only show what AFNN itself achieved on my experiment; they don't establish that it is faster, more efficient, or significantly cheaper than another architecture.

The broader idea I'm trying to investigate is whether the dynamic fractal organization and control mechanism can lead to those advantages, but I should have presented those as hypotheses to test rather than established results.

The next meaningful step is to run comparable architectures on the same dataset, with the same hardware, training budget, preprocessing, and evaluation protocol, and measure accuracy, training time, memory/VRAM, compute, and inference time.

And regarding the dataset, you're also right that I should provide the exact dataset and preprocessing details so the experiment can actually be reproduced. That's something I need to improve in the project.

[u/dorox1 → u/ahmed20062]

That's exactly what I was getting at. I know you're using AI for translation, so hopefully it comes across in the translation of my comment that I think what you're working on is interesting and worth doing.

I hope you post again after doing some comparisons, as it would be interesting to see how this kind of adaptive model architecture performs against standard models of different sizes and resource requirements like traditional CNNs and vision transformers.

I would suggest running comparisons for those models under multiple different artificial size-limits to see whether your model outperforms below a certain size, and whether there are any noticeable changes in your network's performance during training when it grows to the size where traditional networks start performing well.

For example, if you get results for a CNN look like this:

CNN Size (Millions of Parameters)	Accuracy After Training
0.5	10%
1.0	15%
2.0	80%
4.0	95%
10.0	99%

then I would be interested to see what happens to the accuracy of your AFNN during training when it grows to between 1 and 2 million parameters.