Hey everyone! It's been a while since I last shared an update about my projects.
The reason? Over the past few months, I've been completely absorbed in one of the most fascinating and challenging things I've ever worked on: researching new ways for neural networks to learn.
And despite all the difficulties, some genuinely interesting results are starting to emerge.
It all started with a question...
Can we build a neural network that doesn't just learn during a training phase, but can continue growing, adapting, and acquiring new knowledge over time?
And more importantly, can we discover different ways to make it learn?
I started experimenting with various learning algorithms, combining existing approaches, modifying them, and testing some entirely new ideas.
Some experiments were complete disasters. Others seemed to work incredibly well, at least until I discovered something was wrong. 😅
But some of the most interesting observations came precisely from those failures.
A network that can grow and learn
One of the directions I'm exploring is a neural architecture whose structure can grow, rather than necessarily remaining fixed.
The idea is to build a system where new capabilities and knowledge can be added progressively, while trying to preserve what's already been learned.
During these experiments, I've observed some fascinating properties of learning mechanisms, particularly how different components can contribute to better predictions and error correction.
Some results forced me to rethink my approach entirely. Others opened up possibilities I hadn't even considered when I started.
But let's be clear: this is nowhere near artificial general intelligence.
For now, the system mainly works on classification and pattern recognition. It isn't a generative model, and it certainly can't learn just anything.
And that's exactly what makes this stage interesting to me: understanding and validating the fundamental principles before attempting something more ambitious.
Research takes much longer than you think
One thing I've learned is that coming up with an idea is relatively easy.
Proving that it actually works is a completely different story.
You can spend days designing an experiment, implementing it, training a network, collecting results, and convincing yourself you've discovered something important.
Then you find a bug.
Maybe it's a tiny mistake in signal propagation, weight updates, state management, or model evaluation.
You fix it, rerun everything, and suddenly the results are completely different.
What looked like an extraordinary discovery might have been nothing more than a programming error.
And you have to start again.
From scratch.
And what happens when AI writes your code?
This is where things get almost comical.
I use AI coding tools extensively to implement ideas, write code, prepare experiments, and analyze results.
They allow me to explore far more possibilities than I could ever test working entirely on my own.
But there's a huge catch: code that runs successfully isn't necessarily code that correctly implements the algorithm you had in mind.
Sometimes AI introduces subtle logical bugs. Sometimes it unintentionally changes a fundamental behavior. And sometimes it writes a test that confirms a result without actually validating what matters.
The worst part is that everything can look perfectly fine.
Training completes. Metrics improve. Tests pass.
Then you start investigating more deeply and discover that the result isn't valid.
That means reviewing the implementation, fixing the experiments, checking whether the model is genuinely learning, and running the entire evaluation again.
I've learned to be much more skeptical of results that look too good.
An experiment that fails correctly is worth far more than an experiment that succeeds because of a bug.
But something interesting is happening
Despite all of this, I'm genuinely excited about where the research is heading.
I'm exploring different learning mechanisms and experimenting with ways to make them work together rather than relying on a single algorithm.
The goal isn't simply to achieve a higher accuracy score on a dataset.
I want to understand how to build a network that can learn more flexibly, grow when necessary, reuse what it has already learned, and adapt to new problems.
Some experiments have already demonstrated promising behaviors. Others have exposed important limitations that I still need to solve.
And there will probably be plenty more failed attempts along the way.
But that's the fascinating thing about research: sometimes you discover something while trying to prove an entirely different idea.
So, what's next?
For now, I'll keep experimenting.
My priority is to establish a solid, reproducible foundation that can pass increasingly difficult tests. Only then will I seriously explore more general capabilities and, eventually, generation.
I have no idea where all of this will lead.
Some ideas might turn out to be dead ends. Others might become something genuinely useful.
What I do know is that I'm learning an enormous amount, not only about artificial intelligence, but also about how difficult it can be to distinguish a real discovery from a convincing-looking result.
So no, I haven't disappeared. I've just been stuck in an endless loop of experiments, bug fixing, training runs, and new ideas. 😂
And for once, it's a loop I'm in no hurry to escape.
Hopefully, I'll have some concrete results to share soon.
Stay curious. Keep experimenting. 🚀
