My Journey Into Neural Networks: From Confusion to Building

"Every expert was once a beginner who refused to stop asking questions."

There is something almost magical about watching a computer recognize a face, classify an image, or generate text that feels human. At first, it looks effortless. But once I stepped into the world of neural networks, I began to see what was really behind the curtain: mathematics, experimentation, debugging, patience, and persistence.

This story is not just about neural networks. It is about confusion, small victories, difficult lessons, and the slow realization that understanding does not arrive all at once. It grows layer by layer — just like the networks I was trying to learn.

Where It All Began

Artificial intelligence sounded exciting to me long before I understood a single line of it.

I saw machines generating images, translating languages, helping doctors diagnose diseases, and powering tools that seemed intelligent in ways I had only imagined. Naturally, I became curious.

How could a computer learn something humans spend years mastering?

The more I read, the more questions I had. Eventually, I realised that if I truly wanted to understand AI, I could not remain a spectator. I had to learn how it worked from the inside. That decision marked the beginning of one of the most challenging and rewarding learning experiences of my life.

At first, I thought learning AI would mainly involve coding. I was wrong. Artificial Intelligence is mathematics. It is statistics. It is logic. It is problem-solving. Most of all, it is a new way of thinking.

My First Reality Check

Like many beginners, I wanted to jump straight into the exciting parts — building image classifiers, detecting objects, creating intelligent systems. Instead, I found myself staring at linear algebra, probability, gradients, derivatives, optimization, and neural network theory.

That was humbling.

I kept asking myself: "Why do I need all this mathematics before I can build something interesting?" At that stage, math felt like a barrier instead of a tool. I saw symbols, not meaning. I opened tutorials, watched a few minutes, became overwhelmed, and closed everything again.

The problem was not lack of interest. The problem was trying to understand everything at once. That was my first lesson: learning AI is not a sprint. It is a marathon.

Learning to Slow Down

One evening, after hours of trying to make concepts fit together, I stopped chasing speed. I changed the question. Instead of asking "how quickly can I finish this course?" I started asking: "What is the one thing I can truly understand today?"

That shift changed everything. Instead of rushing through ten topics, I focused on one. Instead of collecting lectures, I paused and asked myself whether I could explain the idea in my own words. If I could not, I stayed with it a little longer.

I stopped measuring progress by how much content I finished. I started measuring it by how much I actually understood. Ironically, slowing down made me learn faster.

Confusion Became Part of the Process

One thing no tutorial prepared me for was how often I would feel confused. At first, confusion felt like failure. Whenever I could not understand something after one reading, I assumed I was not smart enough. Later, I learned the truth: confusion is often a sign that the brain is building something new.

I started keeping a notebook — not to copy definitions, but to write questions:

• Why do we need activation functions?
• Why can one layer not solve everything?
• What exactly is a weight?
• How does a computer know whether it made the right prediction?
• Why does changing one number improve an entire model?

At first, those pages made me feel inexperienced. Later, they became proof of growth. The notebook stopped being a record of what I knew and became a record of how I learned.

The Mathematics I Did Not Know I Needed

One of the biggest surprises was discovering that mathematics was not my enemy — it was my guide. I will always remember Mr. Buri Gershom with gratitude. Long before I seriously studied AI, he taught me Discrete Mathematics and Multivariable Calculus at university. At the time, like many students, I wondered when those lessons would ever matter.

The answer came much later. As I moved deeper into neural networks, I began seeing familiar ideas hiding inside unfamiliar terms. Optimization was no longer just a chapter from calculus — it became the process through which a network learns. Partial derivatives became the language of backpropagation. Logical reasoning helped me think systematically about algorithms and computation.

Suddenly, subjects that once felt separate were connected. I realised that education is rarely wasted. Sometimes knowledge only waits for the right moment to reveal its value.

Learning Neural Networks From First Principles

Eventually I reached neural networks. I thought this would be the exciting part. Instead, it felt like standing at the base of another mountain. Neurons. Weights. Biases. Activation functions. Forward propagation. Loss functions. Backpropagation. Every chapter introduced another unfamiliar word.

I remember staring at diagrams full of circles and arrows while everyone called them "simple." To me, they looked anything but simple. There were moments when I genuinely wondered whether I had chosen a field beyond my ability.

So I changed my approach. Rather than trying to master the mathematics immediately, I focused on the story. What problem is this network solving? How does information move? Why does each layer exist? Once I understood the purpose, the equations began to make sense. They stopped looking like random symbols and started looking like explanations.

The Habit That Changed Everything

If there is one habit that transformed my learning, it was learning to teach myself. After every study session, I would close my laptop and ask: "Can I explain this without looking at my notes?" If the answer was no, I knew I had not really understood it yet. So I would go back, read again, draw diagrams, watch another explanation.

Sometimes I searched for three or four different explanations of the same topic. One analogy might fail, and another would suddenly click. That taught me something valuable: struggling with a topic does not always mean you need more effort — sometimes you just need a different explanation.

When Code Refused to Cooperate

Eventually, theory had to become practice. It was time to build. I was excited. I imagined writing a few lines of code, pressing run, and watching the model learn magically. Reality had different plans. My first attempt failed. Then the second. Then the third.

Sometimes I forgot a bracket. Sometimes the tensor shapes were wrong. Sometimes images would not load. Sometimes the model would train and still produce terrible predictions. At first, that was frustrating. Eventually, I realised the error messages were not the enemy — they were clues.

Instead of panicking every time I saw red text in the terminal, I started reading carefully. Debugging became less frightening. I stopped seeing bugs as proof that I was not good enough. I started seeing them as puzzles. That shift made programming far more enjoyable.

Learning by Building: tiny_cnn and Beyond

Reading about neural networks and building one are two completely different experiences. It is like learning how to swim from a book. You can understand every technique, but until you step into the water, you do not truly know how to swim.

That is why I started tiny_cnn — a project where I build neural network components from scratch, starting with the simplest building blocks and working my way up. No black boxes. No "just import the library." Every neuron, every activation function, every forward pass and backpropagation step is written by hand, line by line.

This is not just about writing code that works. It is about building intuition that no high-level library can give you. Inspired by the philosophy of building from first principles — popularised by researchers like Andrej Karpathy — I believe that to truly understand neural networks, you must be able to explain what happens under the hood when you call model.fit().

tiny_cnn is my sandbox. It is where curiosity meets construction. And it is only the beginning — more projects on neural networks are coming soon, including deeper dives into convolutional architectures, transformer internals, and practical experiments with training dynamics.

If this kind of work resonates with you, check out my other project, The Residual Stream, where I'm building a transformer from absolute scratch — from the matrix multiply up. Together, these projects represent my commitment to understanding AI from the ground floor.

Understanding Before Libraries

One thing I am especially grateful for is resisting the urge to reach for high-level frameworks too early. There is nothing wrong with TensorFlow or PyTorch — they are incredible tools. But before using them, I trained myself to ask: "Could I explain this if the libraries were removed?"

If the answer was no, I knew there was more to learn. It slowed me down at first. But in the long run, it made me much stronger.

Data Matters More Than I Expected

Once my model finally started running, I thought the difficult part was over. Again, I was wrong. The model trained successfully, but the accuracy was not impressive. I immediately started changing the architecture — more layers, more filters, different activation functions, different optimizers, different learning rates. Sometimes the results became worse.

That is when I realised I had been focusing too much on the model and not enough on the data. Images need resizing. Pixel values need normalization. Training and testing sets must be split correctly. Classes should be balanced. The model can only learn from what it receives. If the data is poor, the understanding will be poor too.

Error Messages Became Teachers

At first, error messages felt personal. Every red line seemed to say "you do not know what you are doing." Later, I understood: the computer was not insulting me. It was communicating. It was telling me exactly where it had become confused.

That changed the way I debugged. I started asking better questions: What is this error actually saying? What does the function expect? What am I giving it instead? Why are the dimensions different? I also learned to respect small details — a misplaced parenthesis, a forgotten comma, an incorrect path, a typo in a variable name. Small mistakes can stop an entire model from working. Computers do not reward assumptions. They reward precision.

Learning to Be a Beginner

One of the hardest things was not convolution or backpropagation — it was accepting that I was still a beginner. It is easy to compare yourself with experienced researchers and engineers. You see someone explain a difficult concept with ease, and it is tempting to think: "Maybe I am just not good enough."

I had moments like that too. But over time, I realised something important: every expert I admired had once struggled with the same confusion, the same bugs, and the same questions. The difference was not that they never struggled — the difference was that they kept going.

That thought removed a lot of pressure. I stopped expecting myself to understand everything immediately. I gave myself permission to be a student — to ask questions, to revisit concepts, to make mistakes, to learn slowly. The moment I stopped trying to look knowledgeable was the moment I started learning more deeply.

Learning to Be Comfortable With Not Knowing

One of the biggest changes in me had nothing to do with programming. It had everything to do with mindset. When I started, I believed successful learners understood things quickly. Whenever I struggled for days, I wondered whether I was intelligent enough.

Today, I know better. Learning is rarely a straight line. Some ideas take an hour. Others take weeks. Some take months. That is perfectly okay. I have learned to say: "I do not understand this yet."

That word — yet — changed everything. It reminded me that confusion is temporary. Understanding grows through patience. Every difficult concept becomes familiar if we refuse to stop asking questions.

What This Journey Gave Me

This journey gave me more than technical knowledge. It gave me patience. It gave me discipline. It gave me respect for small progress. It gave me comfort with uncertainty. It gave me confidence to build, fail, adjust, and try again.

Most importantly, it taught me that real learning is not about knowing everything immediately. It is about staying curious long enough to understand something that once felt impossible.

What's Next: More Coming Soon

tiny_cnn is just the beginning. I am actively working on more projects that explore neural network internals — from convolutional architectures and their visual feature hierarchies to the inner workings of transformers and attention mechanisms. Every project will be built from scratch, documented thoroughly, and shared in public.

If you are on a similar journey — or just starting yours — I hope this article encourages you to keep going. The mountain is still there. But it no longer looks impossible.

Build from scratch. Ask better questions. Stay curious. And never stop climbing.