Whether GPT-5 can now solve my homework assignments better is still yet to be determined, over the year, we have witnessed an AI Cold War starting from the DeepSeek-R1, Anthropic’s Claude 4 Opus, Google’s Gemini 2.5 Pro, xAI’s Grok-4 and eventually the brand new, GPT-5, each claiming to be a step forward in the race towards AGI.

With tensions at its peak and occasional nightmares of this unstoppable force called AI taking away my job, I woke up late one night at 3 a.m. with a random thought crossing my mind. “Which is the most powerful neural network architecture ever to exist ?”. I sat down with my laptop and asked ChatGPT the question, its response was GPT- 4o. Such a narcissist ! But suddenly a moment of realization dawned upon me, isn’t the Human Brain supposed to be the most powerful neural network ?

Turns out the human brain is by far the most powerful, efficient, and adaptable neural network ever to exist. In fact almost any neural network architecture we’ve ever invented whether CNNs, RNNs, attention mechanism, reinforcement learning or Hebbian learning, are all inspired by the brain. This simple yet hard truth hits at the root of AI research that inspires AI researchers and neuroscientists all over the world.

Why is the Human Brain the Ultimate Neural Network ?

Here are 5 facts you surely knew but never realized, which makes your brain “far superior to even the best artificial neural networks” that have been developed till date.

1. Energy efficiency :

The human brain has evolved to use energy extremely efficiently. It runs on the power of a light bulb, stores the equivalent of millions of gigabytes, and performs trillions of operations every second and yet we still doubt our own potential. Isn’t that wild? For context, today’s computer doing the same work would require the output of a small hydroelectric plant.

2. Generalization / One-Shot Learning :

Our brains learn new concepts from very few examples. Both you and me can probably recognize a new object after seeing it only once or twice. This is however not the case for ANN’s which usually need millions of training examples. In general, human excel at understanding abstract patterns and applying knowledge to new situations, a capability still limited in AI.

3. Lifelong Learning :

Humans keep learning throughout life and can add new skills without forgetting old ones, (excluding us IITians though, we can’t even remember what we learnt in the previous semester). Our brains continually integrate fresh information into existing knowledge. In contrast, standard neural networks suffer from catastrophic forgetting - learning something new often erases what was learned before.

4. Multi-modal Reasoning:

Our brain naturally combines sight, sound, touch, language, sixth, seventh and all our senses to decide which questions are important for the exam or which food to order at Nescafe. We can look at a pizza, smell it, taste it and immediately know what a pizza is. Many of us can even distinguish from which shop it was ordered. Most AI systems, even large ones, still specialize in one or two modalities at a time (e.g. image or text) unlike us who fuse multiple inputs for better understanding.

5. Consciousness and self-awareness:

Uniquely, the human brain has subjective awareness. We know we exist, have thoughts, goals and feelings. Tough situations often compel us to go beyond our limits improving our performance massively. We all know how powerful our brain becomes when self-realization hits us the night before our exams. By contrast, AI programs have no real consciousness or real emotions. This self-reflective aspect of the brain is far beyond current machines.

---

The Human Brain’s Architecture in a Deep Learning Style :

Cerebrum, cerebellum, and medulla oblongata - Class 8 biology book, that’s pretty much all I remember when it comes to the brain’s architecture. Wait, but that’s not a neural network! What about all those perceptrons, hidden layers, activation functions, backpropagation, and regularization? Well, it turns out our “empty” brain is not so empty after all, it has all these components in its own way. In fact, researchers often draw analogies between the brain’s structure and deep learning models. So today, let’s traverse through our brain’s neural network architecture, the deep learning style.

The Input Layer :

The brain’s “input layer” is made up of our sensory organs : eyes, ears, nose, tongue, and skin. The eyes work like image sensors, performing convolution-like operations before sending signals to the brain. Similarly, the ears receive audio signals and process time-frequency features, much like a spectrogram input. Overall, our senses convert light, sound, touch, and other stimuli into electrical signals for the brain to interpret.

Hidden layers : Cortical Processing = Deep Feature Abstractions

The neocortex(80% of the brain’s volume) oversees hierarchical processing, combining simple sensory signals into increasingly complex features.

Our Visual System (like CNN’s) comprises of :

• V1 (primary visual cortex) = edge detectors

• V2-V4 = complex shapes and patterns

• IT (inferotemporal cortex) = object categories

• Hierarchical, feedforward & feedback loops, similar to ResNet / DenseNet.

The Auditory System also follows a similar hierarchy (A1 → A2 → belt areas) for extracting time-frequency features. The Prefrontal Cortex acts like a transformer decoder block, handling reasoning, planning and working memory. Meanwhile, the Motor Cortex is equivalent to the decoder or output layers in a sequence-to-sequence model.

Activation function :

Apparently, neurons don’t use the traditional activation functions we use like sigmoid or ReLU. Instead, they use something called Leaky Integrate-and-Fire, which is basically nothing but brief electrical spikes when a threshold is reached.

Spiking Neural Networks (SNNs) in neuromorphic chips such as BrainScaleS try to replicate this : f(x) = 1 if potential > θ else 0.

Each neuron’s spike is analogous to a binary activation function in AI models, but the brain’s sparse spiking is far more nuanced as it also includes timing, rate and refractory periods.

Learning rules (Hebbian and Backpropagation):

The brain updates connections through multiple mechanisms. One is Hebbian learning analogous to unsupervised learning which is roughly, “cells that fire together wire together.” The most obvious one though is Reinforcement learning through dopamine modulation in which dopamine gives feedback, like reinforcement signals.

We haven’t really found anything though that works quite like the back-propagation algorithm that artificial neural networks use, and researchers are exploring brain-like approximations.

But when did humans start learning from their mistakes ? After all, History repeats itself !

Feedback & Attention: Transformers in Biology ?

Modern AI uses “attention” mechanisms (the core of Transformer models) to focus on relevant inputs. The brain also has top-down feedback and attention networks that highlight valuable information. Intriguingly, recent work suggests that networks of neurons and astrocytes (a type of brain cell) could implement a transformer-like attention operation.

Optimization (neuromodulation):

Just as AI optimizers tune learning rates, the brain uses neuromodulators, like dopamine and serotonin, to regulate learning and plasticity. These chemicals help the brain balance stability vs change, similar to how an optimizer balances fitting vs noise.

Regularization :

Our brain actively forgets irrelevant details and adds noise to signals which prevents overfitting. Sleep plays a crucial role, neural replay at night consolidates memory and prunes unused connections (synaptic pruning). This is analogous to popularly used techniques like dropout, L1 regularization or rehearsal used in AI to improve the performance of the neural network and to prevent forgetting.

Well, that explains why I have such a bad memory, turns out I am just sleep deprived.

Another interesting fact, remember the weird dreams you used to encounter in your sleep that totally made no sense, could they be a source of imaginative data augmentation ? Well, I’ll leave this mystery up to you to decipher.

Plasticity: Continual, Online Learning

Brain connections change continuously over time i.e. our weights and biases evolve with experiences. Unlike static-trained ANNs, out brain does lifelong learning, any time or place without catastrophic forgetting. Inspired by this, researchers call for more continual learning or elastic weight consolidation algorithms to emulate the brain’s nonstop adaptation.

The Output layer :

The brain’s outputs are our decisions and actions – moving muscles, speaking words, etc. In a neural network, the output layer might label an image or make a prediction. However, whether in the physical world or in the software world, we are both judged by the decisions we make and we must face the necessary consequences.

Damn, that was deep ……

Where AI Still Lags: Innovation vs. Pattern-Learning

Despite impressive capabilities, AI today is still fundamentally a pattern-matcher. It can analyse data, generate art or music, write coherent text but only by remixing what it has seen. In practice, this means AI struggles to invent truly novel concepts or ask original questions without human guidance.

In a very recent paper by Apple, titled “The Illusion of Thinking”, researchers tested Large Reasoning Models (LRMs), AI systems that generate step-by-step reasoning before producing an answer. They created controlled puzzle environments where complexity could be adjusted without altering the logical structure. The results showed that LRMs outperform standard LLMs on medium-complexity puzzles but underperform on simpler ones and collapse entirely on overly complex tasks. Surprisingly, their reasoning effort rose with difficulty only up to a certain point, after which it dropped, despite having resources left. Further analysis of their reasoning traces revealed inconsistent logic, lack of explicit algorithm use, and fundamental limitations in their true reasoning ability.

The human brain, however, constantly imagines the unimagined. People form abstract concepts without direct examples (wormholes or time travel being the best examples), reason counterfactually (“What if ? How ? Why ?”) and dream about inventions that have never existed. Our brains master new ideas from very few examples .

Sir Issac Newton saw an apple fall from the tree and came up with the Universal Law of Gravitation. Mr Albert Einstein who has never himself been to space formed the revolutionary field equations whose solutions describe the conditions under which black holes can form. Isn’t that mid-blowingly incredible ?

Learning is not the same as understanding. And understanding is not the same as creativity. The spark of creativity and genuine understanding i.e. going beyond the data remains uniquely human.

Conclusion : Towards Brain Like AI

Artificial intelligence has come a long way, but even our most advanced models remain far from matching the human brain’s efficiency and adaptability. Enter neuromorphic computing, a cutting-edge approach that aims to close that gap by mimicking the brain’s architecture and processing style, promising AI that is faster, more energy-efficient, and closer to human-like cognition. Looking ahead, we could expect advanced AI systems with real-time learning and adaptability, to cognitive computing systems, and even AI designed to better align with human values and ethics. Neuromorphic computing is not just a technological leap, it’s a paradigm shift in the development of intelligent machines.

As we stand on the brink of this new era, it’s worth remembering the words of Alan Turing:

Let's assume you have a reasonably clear picture of what you want to build. In reality, this is rarely the case—especially when venturing into uncharted territory—but let's stick with this simpler scenario.

When crafting anything meaningful, it helps to think within two distinct realms:

• The Problem Space: The landscape of all the things you may set out to accomplish. A point in this space might be "Create a 2D platformer."

• The Solution Space: The vast territory of all possible ways to make them happen. A corresponding point in this space would be <The complete C source code for the game>.

Through this perspective, we've captured something fundamental about the act of creation—it's about finding your way through the solution space until you reach something that fulfils what you set out to do in the problem space.

The Mountain in the Fog

This journey bears striking parallels to climbing a mountain shrouded in dense fog while equipped only with a barometer. You can see your immediate surroundings clearly, get a rough sense of your altitude, but the path ahead remains largely obscured. The summit exists somewhere above you, but the route to reach it unfolds step by step.

Analogously, in software engineering, local deviations in the problem space translate smoothly into the solution space. Sticking with the example of a 2D platformer, if you want to change the size of the enemies, that's a straightforward parameter adjustment. Need to add another collectable? Once you've built the infrastructure for one, the second follows naturally from established patterns.

But global changes prove treacherous. Deciding to add a particle-effects system or water-tiles that obey fluid physics can send you scrambling across entirely different terrain in the solution space. These aren't simple parameter tweaks or copy-and-pastes—they're architectural shifts that demand new foundations.

The way you summit a mountain isn't by staring hard into the fog from a standstill, desperately trying to foresee the entire path. You move around, follow locally-upward terrain, and backtrack when the path ahead proves insurmountable. Progress emerges from this dance between exploration and retreat, and the same is true in the domain of software engineering.

This mirrors the actor-critic model that governs effective problem-solving. In mountain climbing, the real world serves as both simulator and critic—it shows you where you can step next, and whether each step takes you higher. But who fills these roles in software engineering?

The Simulator Dilemma

You have two options for your simulator. The first is obvious: the code and the computer. Write something, run it, see what happens. Fast feedback, accurate results, reality as your guide—if the way you architect your code sucks, it eventually sticks out like a sore thumb.

The second option seduces many: design up-front, making yourself the simulator. You sit in your chair, stare at whiteboards, and try to mentally execute every possible path through your imagined system. This approach suffers from two fatal flaws: it's glacially slow, and it's breathtakingly inaccurate. You end up solving problems that don't exist while the real problems laugh at you from the shadows.

As Mike Acton puts it in his brilliant talk: "solving problems you probably don't have creates more problems you definitely do." Your mental simulator isn't just unreliable—it's actively counterproductive, generating phantom requirements that will haunt your codebase long after you've forgotten why you added them.

What Do We Care About?

Strip away the buzzwords and methodologies, and software engineering boils down to two fundamental concerns: runtime speed and development speed. Everything else is commentary.

We could use these as our critics, but they're sparse metrics. They'll tell you whether something is good or bad, but they won't whisper hints about what you could do locally to climb higher. It's like having a barometer that only reads "terrible" or "acceptable"—not particularly useful when you're trying to navigate the next few steps.

Ideally, we want a critic that stays true to our terminal objectives of runtime and development speed while also providing dense information about the local terrain. We need something that can guide our immediate decisions while keeping us pointed toward the summit. Luckily, the ivory tower of software architecture has a decree for us: OOP.

Projection Oriented Programming

OOP has a widely agreed upon set of characteristics often referred to as the "four pillars": encapsulation, inheritance, polymorphism, and abstraction. However, in practice, OOP literature seems to prescribe something more: basing the code’s hierarchy of encapsulation on the underlying domain model. Have some enemies in your game? Better have an Enemy class. Have more than one kind? Make sure to inherit from an AbstractEnemy class.

To spare the onslaught of No-true-Scotsman arguments, let’s call this subset of OOP “Projection Oriented Programming” after this clever comment.

A central issue with this style of programming is that software performance often ties deeply to code architecture. No amount of posterior optimization will resurrect the data-cache performance lost to bloated objects stuffed with computationally unrelated fields. No clever tricks will recover from the instruction-cache carnage wrought by pointless inheritance hierarchies and virtual function calls.

As Mike Acton, again, puts it: this reflects a kind of engineering by "storytelling" rather than engineering by engineering—prioritizing making code "read like a story" about the problem domain over making it actually solve computational problems efficiently.
(P.S. You should really watch that talk)

Besides, effective performance optimization demands holistic context and deep domain knowledge. When you've architected your code around encapsulation based on the underlying domain model, you've simply set yourself up for failure. What scope remains for noticing domain knowledge that may motivate optimization, if your code is a tangled web of objects trying to interface with other objects using only the methods that have “meaning” in the underlying domain model? Every potential improvement gets strangled by the very boundaries you thought were helping.

Premature Encapsulation

While the "final" code may well benefit from strategic encapsulation boundaries, that doesn't mean we should commit to encapsulating from the get-go while we're still navigating the fog of early development and discovery.

POP may wreck performance, but even stripped of its domain-modelling baggage, traditional OOP remains surprisingly rigid for rapid development. When you're still figuring out what your code actually needs to do, locking yourself into interface contracts feels like building walls before you know where the rooms should go.

Trash the Faulty Map

There's a vacuum for an important metric in the space of software architecture: locality of behaviour. Keep related things close together. Don't scatter the implementation of a single concept across seven different interfaces just because some methodology told you to.

Casey Muratori offers another compass bearing: don't plan abstractions; build first, discover them later. Let the real patterns emerge from flat code rather than imposing theoretical structures on problems you don't yet understand.

There's nothing wrong with omniscient code—code that’s aware of the entire context of the problem you’re trying to solve. The imaginary boundaries we draw between "concerns" often cause more problems than they solve.

Large Language Models like GPT-4 have revolutionized the way we communicate with AI so we can write text more easily, get coding help, generate ideas, and a lot more. While cloud-hosted LLMs are the trend of the day today, increasingly, people are going the local LLM way, hosting such models on their local machines themselves.. Why the shift ?

More Concerns about Privacy

If you ‘re running a cloud-hosted LLM, all of the text that you type - your input, your personal information, even your own proprietary code is sent over the internet to remote servers. And there, you have no agency. Who specifically can view it? How is it secured? Could it leak, get hacked, get sent in a lawsuit? For anyone who’s got sensitive information, these aren’t theoretical concerns they’re showstoppers. Local LLMs avoid that altogether. All the processing is done on your computer, so your data never actually exists outside of your ownership. For privacy-minded individuals and communities, that’s compelling reason to go local. The thing with cloud AI is that when you delete a conversation, it doesn’t necessarily mean it is deleted. Most of them keep chat logs for 30 days or forever if there’s a law that requires them to. within that time, Humans sometimes do read conversations for safety review, policy enforcement, or training the model. Even after deletion, backups and legal compliance can preserve your words in the system.

OpenAI CEO Sam Altman himself recently made headlines quoting a plain fact: ChatGPT chat has no specific legal safeguards. In a This Past Weekend podcast interview, he equated it with talking to a therapist without privilege your talks can be subpoenaed. In recent court hearings, including the New York Times case, even those which are deleted have to be stored. Altman himself called it a "privacy nightmare" and admitted, "We haven't figured out that yet for when you chat with ChatGPT."

Aside from the concern, OpenAI's terms of service allow your data to be used to enhance models unless you choose not to in a process that is not necessarily front-and-center or convenient. So, inadvertently, your own work, research, or code could get baked into future AI training sets.

For the majority of individuals, especially those who are working with sensitive information, that is too much to give up for convenience.

API fees

Yes, not everybody uses LLMs in visible API calls, but cost is still a huge consideration:

The majority of business AI tools available today have subscription or pay-per-use-based models, and thus intense or frequent use may quickly be expensive. For example, OpenAI's $20/month ChatGPT Plus subscription and even extensive use can still hit usage caps or be charged additionally.

Students and enthusiasts testing out complicated projects frequently encounter these thresholds, and thus cloud AI is less convenient for repetitive experimenting or large-scale work.

For some, running an LLM locally is a means of evading periodic subscription fees and usage limits entirely, gaining unlimited use without cost shock.

Internet Dependency is a Real workflow killer

Cloud-based LLMs require but one inevitability: a solid internet connection. Easy enough until you're in a coffee shop with spotty Wi-Fi, on a train with iffy signal strength, or in a rural area where "high-speed internet" is 3 Mbps on a good day.

When that occurs, your previously useful AI is now sluggish, unresponsive, or simply unavailable. And it's not only annoying it can bring workflows to a screeching halt. Picture never finishing your train of thought during a brainstorm because your request took 30 seconds to reply. Or losing a critical project deadline only to have your AI session timeout.

Local LLMs eliminate all that in the first place. The moment the model is loaded onto your computer, it is ready to go no buffering, no cut-off sessions, no "reconnecting…" messages. You can work in the middle of the forest, on a flight, or in the event of an internet outage without losing a beat.

For remote workers, travel, or students in low-connectivity zones, or simply anyone who wants AI to work every time they launch it, this reliability is not a nicety, it is a complete game-changer.

Why Use Local LLMs Even When It Feels Counterintuitive

If you're unaware, open-source large language models (LLMs) are a lot like the large brands you already know such as OpenAI's GPT or Google's Gemini but with one huge difference: with open models, you receive the weights. That's the secret sauce of their training, and what it means is that you get to host them on your hardware whether that be your laptop, a custom desktop, or even a server you own.

But you might ask: "Aren't these models huge? How in the world could my laptop possibly accommodate one?" And you'd be correct the largest proprietary models are huge, sometimes requiring clusters of high-end GPUs just to execute. But the open-source world has been developing smaller, more efficient models that can be executed on consumer hardware. And don't let their size fool you many of these smaller models punch well above their weight. Just check out the leaderboards and you'll find entries like the 27 billion parameter Gemma holding its own against industry giants.

Running AI locally isn't without its disadvantages. You'll need lots of disk space, good RAM, and sometimes a good GPU. Getting it all installed can even be a weekend project instead of a plug-and-play service. On paper, the usability of cloud APIs may seem like the no-brainer option.

So why are so many getting local? Because local LLMs give you what the cloud just can't:

Control - You have total control over what runs, what gets calculated, and where it happens.

Speed - Local inference removes the network bottleneck, therefore responses tend to be quicker.

Offline Access - Whether you are on the move, on a flaky connection, or completely off-grid, your AI is always with you.

To increasingly more users, these advantages are well worth the additional setup time. The outcome? Local LLMs are no longer a hobbyist's plaything they're becoming a serious, functional device for AI-powered work.

Tools That Enable Running Local LLMs

Running large language models on your machine can look intimidating, but through a chain of welcoming libraries and tools, it has never been simpler. These platforms offer a simple means of installing, running, and hosting local LLMs, making access easier for students, software developers, and AI enthusiasts.

Ollama

Ollama offers a tidy, user-friendly interface for running numerous local models. Ollama offers model management, inference, and integration, which makes it easy to download, run, and deploy top LLMs with minimal technical inconvenience. Ollama works with models like Llama 2, deepseek-r1 and many more specifically built for local running, and it works with most operating systems like Windows and macOS.

LM Studio

LM Studio is customization and tuning all the way. It's for users who want more control over model performance and behavior, like the ability to train models on your data or adjust parameters for specific tasks. This type of flexibility makes it popular with researchers and special projects.

LLaMA.cpp

A lightweight and efficient open-source counterpart to Meta's LLaMA models, LLaMA.cpp allows for LLaMA models to be run on consumer hardware, like laptops without the need for specialized GPUs. It's ideal for users who need to run high-power models on low-resource setups.

GPT4All

GPT4All offers open weights of different models based on privacy and access. It comes with everything required to quickly get started and is particularly welcoming for new users who desire a convenient local AI experience.

These technologies are now making local LLMs available to a broad audience ranging from ordinary users who need a personalized chatbot to developers creating personalized AI programs.

What models can be executed locally

Due to the rate of acceleration of AI, it is no longer a fantasy to run gigantic language models on individual devices. There are now a number of effective, high-performance models that are being used extensively by developers, researchers, and hobbyists who desire AI capability without depending on the cloud.

Some of the Most Popular Local Models Today

Qwen 2.5 - Alibaba created Qwen 2.5, which stands out in the sense that it is multilingual and CPU-friendly in design. It can run well in PCs with about 16GB RAM, which means it is accessible to most users who might not have high-end GPUs. People like it since it provides power with simplicity.

LLaMA 3 Series - Meta's new LLaMA 3 models are in high demand. Their smaller counterparts (like the 8-billion-parameter model) can be executed on regular laptops with 16GB RAM and have excellent reasoning and general knowledge capabilities. The open LLaMA framework encourages community contributions and custom development.

Mistral 7B - With its stable performance and adequate memory efficiency, Mistral 7B is best suited for users who want a high-performance but thrifty model. Both general AI assistants and memory-demanding tasks are suitable for it.

DeepSeek Coder (7B) - In case you are in need of coding as your main goal, DeepSeek Coder is suitable for coding activities like code generation and debugging, which works well on mid-range hardware.

Gemma 2B - Google DeepMind's Gemma 2B is praised for its responsiveness and adaptability in different hardware setups, ranging from consumer-grade laptops and desktops.

DeepSeek-R1 – One of the strongest models out there disrupting the LLM world. It uses state-of-the-art reasoning techniques like reinforcement learning, mixture-of-experts (MoE), and chain-of-thought reasoning to tackle challenging problems in math, programming, and clinical reasoning occasionally outperforming models like OpenAI's o1 often at a fraction of the cost. Fully open-sourced under an MIT license, DeepSeek-R1 has extensively distilled variants (1.5B to 70B) that are performance- and resource-optimized many of which can be executed locally with as little as 8-16 GB RAM.

Why These Models Matter

While these local models are still in the process of reaching the sheer size of cloud giants like GPT-4, they are catching up very fast. They can offer sufficient power for ordinary tasks like conversing, coding assistance, document Q&A, etc., without the cost of infrastructure.

And because they're performance-optimized, they can be run on 8 to 16GB RAM machines, and even on CPUs by themselves, so local AI is accessible to more people than ever before.

How do you install an LLM locally

Having a local large language model running may seem daunting, but software now has made it surprisingly easy. Below is a straightforward guide to use Ollama, one of the simpler platforms to host and run local LLMs.

Step 1: Check Your Hardware

Prior to beginning, make sure that your computer has the below minimums: RAM: 8-16 GB minimum (the higher, the better)
CPU: latest multi-core processor (GPU is optional but will accelerate inference)
Disk Space: Minimum of 10–20 GB of available space for storing models

Step 2: Download and Install Ollama
Visit ollama.com and download the correct installer for your platform (Windows or macOS).
Run the installer and follow the on-screen instructions.

Step 3: Choose and Download Models
Ollama provides many popular local models such as LLaMA 2, Phi-2, and others.
Download your preferred model(s) via the Ollama app or CLI. The download will take some time depending on your internet speed and model size.

Step 4: Deploying Your Model Locally
Once you've installed, launch Ollama's app and start developing your model straight on your computer.
For CLI users, you are able to run commands like ollama run llama2 to start a session.

Step 5: Explore Advanced Use
All of these tools, including Ollama, allow you to integrate local LLMs into your own applications or automate workflows.
You may also train models on your data or customize responses as you gain more experience.

Useful Links

Ollama Documentation - Step-by-step directions and troubleshooting.

Model Libraries - Browse and download other open-source models.

Conclusion: Local LLMs - Making AI Personal, Private, and Practical

Only true AI connoisseurs know the value of a locally running fine-tuned model.

Local large language models are changing the way we access AI. They give back control to your hands by preserving data in a private manner and off-loading costly subscription charges. Offline running of AI makes you less reliant on a shoddy internet connection or worried about ballooning API expenses. While local LLMs require a bit more configuration and hardware, the benefits - privacy, affordability, speed, and autonomy make them increasingly popular among developers, students, and AI enthusiasts. As the technology advances further, expect local models to be more powerful and intuitive, unleashing their productivity and creativity without compromise.

The need for segment trees?

To understand why segment trees exist ,let's consider a scenario that every programmer encounters: array range queries. You have an array of numbers, and you keep getting annoying queries like "What's the sum from index 3 to 17?" or "What's the minimum value between positions 5 and 12?"

The common approaches are both slow when dealing with many updates and queries

The naïve approach: iterate through the range for every query. This gives us O(n) time complexity per query and O(1) per update.

The other approach is Prefix Sums which give us O(1) queries but O(n) for updates.

Segment trees give us a middle path for times when we want both updates and queries with O(log n) queries and O(log n) updates

The Basic Idea

To represent the input array as a binary tree. (I’m sure you guys can start to smell the log n).

Each Node represents a piece of the array (the root has the whole array) and contains the answer for that piece (like the sum of all elements in the piece). Each node has 2 children representing the left and right half of the piece.

And to answer queries we combine the answers of these nodes to get the answer for our desired segment.

The Lifecycle of a segment tree

1) Build the tree-

Building the tree is a one-time investment with O(n) complexity. We use a bottom-up approach, starting with individual elements and combining them level by level until we reach the root.

2) Use for Queries and Updates

Once built, the tree handles two main operations:

• Queries: Finding the answer for a specific range by combining relevant node values

• Updates: Modifying individual elements and propagating changes up the tree

3) Profit

Once you understand how to combine the segments to get a answer the code for building the tree, updates and queries looks very similar. So lets see that in action.

Consider a query the sum from index 2 to 8.

You can see that if we combine all the red nodes, we will get our answer.
Now How Do we choose the red nodes?

Simple we start from root and see if a child has a overlap with the target indexes 2 to 8 then we query it and return the combination of the answers from the children So for sum that’s just answer(left) + answer(right). We do this recursively.

The stopping condition is

1) if the node is entirely in the target like [3,4] and [5,8] we just return there answer for the node directly [Remember that each node contains answer for its piece of the array].

2) if the node has only one element, we return the answer for that node since there are no more children

The implementation is not long

Source Trust me - My usual implementation for max segment tree is 26 lines all said and done and these are short lines.
Practice a bit and you can spam these out in a few minutes.

Proof of Correctness

Here's a secret: you don't need to know the proof of correctness to use them. While knowing these proofs is good and will help you write modifications of segment trees when questions call for it. You don’t need to stress too much about doing immediately, take time try different websites and blogs and find one that explains it in a way you find easy to understand.

Why we need to see the light.

But hold on, why is lighting, out of all things, so vital for creating realistic computer graphics? Well, to illustrate, allow me to show you what happens when we do not apply lighting to a 3D scene

It’s pretty hard to make out that the scene in front of us is in 3D. The details of each model are difficult to make out and the overall scene looks flat.

Let’s turn on the light

Much better isn’t it. With a little illumination we have revealed an entirely new world. One can easily distinguish the various features of the monkey and the sphere looks more like a three-dimensional object than a circle.

But before we dive into the process of how we can achieve basic lightning, it is only befitting to first talk about the man who made this possible, Bui Tuong Phong.

The life of Phong

Bui Tuong Phong was born in Hanoi in 1942. At this time, Vietnam was officially controlled by the French and was known as French Indochina. However, Paris had fallen to the Germans and in the ensuing chaos the Japanese had occupied a large portion of Phong’s homeland. This foreign intervention had united the Vietnamese in armed struggle, and the communist guerillas were being led by Ho Chi Minh. When Japan left the country in 1945, Ho Chi Minh declared Vietnam independent, something which the French would not accept.

What followed became known as the First Indochina war, where the French suffered a shocking defeat. In the peace talks that followed it was decided that the country would be split in two, with a communist government in the north and a pro-western government in the south. Neither side was happy with this arrangement and the Second Indochina war (Popularly known as the Vietnam war) soon followed.

By this time, Phong had moved to Saigon (modern day Ho Chi Minh City). During this time the United States started Operation Ranch Hand, a campaign to spray herbicides in Vietnam to remove the dense vegetive cover used by North Vietnamese forces. Herbicide was often stored in key military facilities around Saigon and their surroundings were often sprayed for security purposes.

Some have speculated that Phong might have been indirectly exposed to these chemicals during his time in the city and have theorized that this might have had a hand in his later illness. However, we don’t have direct evidence to validate this.

In 1964 Phong went to France to further his education. He left during the same year as the Gulf of Tonkin incident which was one of the key events which lead to the deployment of US forces in Vietnam. In France, he obtained several degrees before joining the Institut de Recherche en Informatique et en Automatique (then known as IRIA, now INRIA) where he focused on operating system development.

Phong immigrated to the United States in 1971, and joined the University of Utah as a research assistant. It was here that he first worked on a new method of light simulation. The most novel approach of his work was the manner in which he dealt with light reflection, which greatly enhanced the realism of computer graphics. He introduced his groundbreaking ideas in his 1973 PhD dissertation and published it in a paper in 1975. Unfortunately, all this coincided with his diagnosis of leukaemia, and the absence of modern methods of treatment made the disease fatal. Phong passed away in 1975, right after joining Stanford as a professor.

The Phong Reflection Model

Let us now turn our attention to the actual implementation of the Phong Reflection Model. We know that real objects get their illumination from 3 primary sources.

• The Environment

• Direct Sources of Light

• It’s inherent ‘shininess’, that is how much light it can reflect.

Phong lighting recreates this by adding 3 components while computing the amount of lighting, namely:-

• Ambient Lighting

• Diffuse Lighting

• Specular Lighting

Let’s explore each component individually

Ambient Lighting

The word Ambience refers to the character and atmosphere. Hence, ambient lighting refers to the background lighting which affects all objects in the scene. In the Phong Model, ambient lighting is approximated by just multiplying a constant value with the inherent colour of the object. For bright environments the value of this constant is high, while it is lowered to simulate darker scenes

Mathematically, it is computed using the formula

Here I_a is a vector giving the colour and intensity of ambient light, k_a varies from 0 to 1 and L_a is the inherent colour of the face.

Diffuse Lighting

Diffuse lighting tries to mimic the effect of light on rough surfaces. This shading effect is not dependent on the angle at which we view it, giving a non-shiny appearance.

In computer graphics, diffuse lighting is computed using Lambert’s Cosine Law, which states that the intensity of light on a surface is proportional to the cosine of the angle between the surface normal and the direction of light.

Mathematically, we can say

Where I_d is the amount of diffuse lighting and theta is the angle between surface normal and direction of light.

Let us take n to be the surface normal and l to be the direction of light from the surface as shown in the figure below.

We can then say, using the properties of dot product that

This fits logically as well. Objects just under a light source will be more illuminated than objects at an angle.

Hence, we compute the component of diffuse lighting as:

Here I_d is a vector representing the colour and intensity of diffuse lighting, k_d is the surface’s coefficient of diffuse reflection (generally the same as the colour of the object) and L_d is a vector representing the colour and intensity of the light source. We take the max of n.l and 0 to avoid errors coming from negative cosines.

Specular Lighting

The main innovation of Phong’s lighting model was the manner in which it handled reflections. Shiny surfaces reflect light, and when this reflected light reaches our eyes, it creates a concentrated bright spot on the object, known as a specular highlight.

In order to compute these specular highlights, we need to consider the position of both the viewer and the source of light with respect to the surface.

Let us assume I is the direction of light, n is the direction of the normal of the surface, r is the direction of reflected light and e is the direction of the viewer’s eye from the surface as shown in the figure below.

We can immediately conclude that for the eyes to receive maximum reflected light, the angle between r and e should be as small as possible. Therefore, we can write the equation as

Where I_s is the colour and intensity of the specular highlight and cl is the colour of the light source.

But there is still something missing. We know that some objects are “shinier” than others. However, in this equation we do not consider the inherent property of the material to reflect light. To remedy this, we introduce a new constant called p to depict the capacity of an object to reflect light.

Using this new constant, we can increase the realism of our lighting model. We know that the shinier objects have crisper reflections. To simulate this, we modify our original equation to

Since max (0, e.r) is between 0 and 1, increasing the value of p will make the specular highlight smaller and more concentrated, while a lower value of p will give the impression of a duller surface.

Putting it all together

After calculating the ambient, diffuse and specular components for a surface, all that remains is to add them up to get the final result

Pretty cool huh? Do note that while the ambient component is added just once, the diffuse and specular components need to be added for every light source in the environment.

A bit about Shaders

It is also important to discuss shaders, which are special programs executed by the GPU whenever we draw an object. There are 2 main types of shaders, vertex shaders and fragment shaders.

While a full tutorial on shader algorithms is beyond the scope of this article, keep in mind that vertex shaders are called once for each vertex, while fragment shaders are called for every pixel. Since we need to calculate lighting for each pixel, all the calculations discussed so far are usually programmed into the fragment shader.

Further Reading

If you are still curious about the fascinating world of computer graphics, do check out the following related topics: -

• Blinn Phong Reflection Model

• Physics Based Rendering

• Inverse Square Law in Lighting

• GLSL (The OpenGL Shading Language)

Sources

https://arxiv.org/pdf/2404.14376v2

https://shuangz.com/courses/cs114/docs/proj1/

https://ulink.utah.edu/s/1077/20/interior.aspx?sid=1077&gid=1&pgid=252&cid=3074&ecid=3074&ciid=9191&crid=0

https://cs184.eecs.berkeley.edu/sp20/lecture/6-32/the-rasterization-pipeline

https://www.tutorialspoint.com/computer_graphics/computer_graphics_diffuse_shading.htm

https://cs184.eecs.berkeley.edu/sp20/lecture/6-32/the-rasterization-pipeline

https://www.nv5geospatialsoftware.com/docs/IntroShaders.html

Four years is quite a long time... How have you seen IIT Patna transform over the years?

I joined IIT Patna in 2021, the medium of instruction was Online for 1.5 semesters, given this predicament a lot of us did not get the proper exposure that a fresher would get, let’s say actual knowledge building and networking within clubs and events started a year later for us, that’s one less year of exposure and learning which significantly impacted mine and the previous batch.

IIT Patna was doing great in the technical field, some stellar figures and headlines in research. Until late IIT Patna was consistently sending a good number of students to International Internships and exchange programs. In terms of campus it was pretty humble, 2 food outlets inside campus and 2 outside, not much. The growth in infrastructure in the past years has been remarkable, but we aspire for more, there is so much in terms of facilities we have now, Super Computer even an auditorium included, that we simply did not enjoy then.

As for students, I feel to a certain extent their morale has come down, you talk to someone pre-covid, the campus morale was pretty high, if there was a certain inconvenience people would show up and be vocal about their problems, everyone was active and optimistic, newer boundaries were being pushed. I feel post Covid that is not the case.

You have served many roles in these 4 years, from robotics captain to UGR. Which one was your favourite and why?

There are things we do out of want, and the rest we do out of need. I wanted to lead the Robotics program here, in fact when I came to IIT Patna there were barely 1-2 people who even had legit experience with hobby micro-controllers. But after covid, we had no experienced seniors left, I recall those nights in the lab where I would learn each and every component’s use, how it would have to be coded or engineered and show the rest of the team how we could do it. Every night 10 PM to 2 AM my batch-mates would find Panav in the lab, half the days even alone or just one friend to accompany.

Fun fact is, I never wanted to go for UGR, what I actually wanted to go for was Students’ Technical Council, not as the General Secretary, but as a 4th year secretary instead. I wanted to contribute what I could to the tech culture actively, but as need dictated I reluctantly stood for UGR, while people saw remarkable change and reforms, I for the most part I did not enjoy it. The UGR in my term took up unnecessary responsibilities, I hope Yash (UGR 2025-2026) does not get to experience the amount of stress and pressure that I did.

What interests you the most in technology and how have your interests evolved over the years at IIT Patna?

What I work in is an intersection of Robotics and Software, currently I am a Robotics Software Engineer. Now whatever code I wrote, I didn’t like it Vanilla, I wanted it to be of use somewhere.

Some might be learning Dijkstra, Dynamic Window Algorithm, RAN-SAC, Graph Optimization on Google Colab or Leetcode, I get the thrill when I run it on a robot, the amount of understanding when that code interacts with the physical world is unparalleled, one parameter change could make the difference between a 500 kg bot navigating in peace or crushing my teammate’s foot, very cool!

Clubs at IIT Patna are underrated, they can take something that just means a hobby to you and make it a viable career option, events, guidance from seniors, competitions these will teach you more than your B. Tech curriculum.

IIT Patna will once again go for the Inter IITs this December. What do you think we should focus on in order to maximize our chances of winning?

From what we saw last year, many problem statements which we were confident at ended with inconsistent outcomes, you really need to judge the judge, if it’s a scientist don’t propose something radical they cannot digest, if it’s a corporate employee jaw dropping numbers or radical approaches may go well, some judges to be honest haven’t explored the problem statement as much as the teams, they are often wooed by hollow pitches from some teams. There were a few fields not explored as well yet but the team constantly looked for help from professors, seniors, alumni, and eventually PS’s we were not very confident at gave us good outcomes.

The most apparent and fixable bottleneck was of compute, we have a super computer at IIT Patna now, through PIC Technical as a supervising professor we could and should be able to access those, furthermore Google Colab Credits and other cloud computing platforms can be used for intensive tasks.

Our teams put so much effort into showcasing detail, but they fall short in avoiding penalties that cost us 4 or more places each year, let’s say you show some material to the judge on your phone or make a late submission for the sake of adding a little more detail, that can cost you 75% or more points overall, will that little detail matter if missing in the report ? Probably not!

My point being if we’re putting X amount of effort into a problem statement, we can avoid losing it all by just putting 5% of our conscious effort into avoiding penalties, but these repeat every year.

Many first and second year students are interested in knowing how to prepare and contribute to the inter IITs. What would your advice be to them?

Team formation must strike a balance between fielding your best and experienced people along with a few who learn enough to carry the learnings for next year. As a sophomore even I was asked by many to join in a team but chose not to, I helped out in minor things wherever I could.

Now the good news for the freshers and sophomores here is, they get a better representation in teams than the older IITs, especially Mid-Prep onwards. Else they can contribute from the auxiliary team and gain all the project experience and credits they need.

Last year I saw a few motivated freshers pulling equal or more weight than their seniors in some cases. Reaching out to any faculty, facility inside or outside the institute for help. That's the kind of energy we need.

What in your opinion is the most important skill which freshers should work on right after entering the institute?

I would like them to understand what vertical and horizontal skill means. Coding as you know it is turning into a horizontal skill rather than a vertical skill, because it goes along with so many things. Simulations for material science, programming micro-controllers, running a simulation in MATLAB. What I'm trying to say is having some coding proficiency is becoming a need, but this alone won't get you in most places. You need a vertical domain/skill where you focus.

Learn time management and worth ethic, when you commit to something see it through, if they keep jumping ship whenever the going gets tough they'll end up average with a paperweight resume by final year, avoid that.

Many people want to start learning technology in college, but are often confused and overwhelmed with all the different choices they have. What would your advice be to them?

Good question, what would you pursue ? What club you join will dictate your career too. In this case I took up whatever club I found thrilling. When one does something out of sheer interest and to push the limits it doesn't feel like a chore or work. Naturally you will be focused and enjoy working to an extent you will master the field. With enough proficiency you'll find a place to apply your skills however big or small the demand will be. And this is the career I would ask you to pursue. Imagine working the next 40 years on something that doesn't excite you, must be miserable right ?

Future scope and novelty should have some weightage but your interest must lie first.

Many people ignore technical clubs in college because they are unable to fit it in their schedules. How did you manage time across club activities, academics and internships?

Okay, that’s pretty important. Now you need to participate and sports and cultural activities to maintain fitness and sanity, but what made going for a tech club so glamorous ? You get PoR’s, Projects and technical expertise all in one package. For those who ignore tech clubs in the first two years are going to have a vanilla resume which they will struggle to fill with redundant projects such as To-Do apps or calculators on python, You’re from an IIT do better!

Every batch has a few students who participate in many clubs, put time into physical activities, still pull off top tier grades and even branch changes. It is going to be inconvenient, now you need to do well in “academics” but for the most part what you'll learn through clubs will be far more relevant. You need to master time management, get out of that comfort zone.

Currently many students in their 3rd year are looking for good internships. However non-IT roles don't often come to campus. Could you share your journey in order to help students find opportunities they would be interested in.

I often tell people to land jobs with ease today you either need to be 95 percentile in some skill else you can make do with 80 percentile in proficiency if you are good at networking.

Go for competitions and hackathons, you will build valuable contacts, host events on campus, call up entrepreneurs and alumni working in that field.

I agree most opportunities lie off campus, you need to look out for them, hunting for the right emails is quite valuable. I don't remember getting many responses from LinkedIn, alternate job portals help, and the best however are posts on Linkedin. I've seen these recruiters they are facing a genuine shortage of talent, however the resume needs to be up to the mark the expectation from an IITians resume and questioning is much higher. The problem with most IITians I see is they dabble with all fields nervously and end up mastering none, by the time they apply for a job, they’re not at par with expectations.

Is there anything which you feel that STC could improve on this year in order to enhance the tech culture at IITP?

Well, STC has taken up a lot of initiatives, one cannot say they haven’t done enough. The OneIITP app, I recently came across the recently updated Cabshare app, They also assisted with team formation of some of the best people who made the institute site prototype. The hostel allocation, and so many digital platforms that the institute relies on.

Other than HelloWorld and ICTC which are just very intense, a lot of work goes into that from STC and the Clubs, I’d say they are trying pretty hard and the students need to show up for themselves.

One thing I would like STC to do is to try and procure GPU Servers, preferably Physical systems for the long run, because the students will need computers for ever-increasing computing demands for quality work. This could be training models, running local LLM’s, Simulating Robots in Nvidia’s cutting edge simulators, 3d modelling or even aerodynamic/material simulations.

I recall how I was a part of the ISRO team and we had about 10 or more people run small batches of training, fitting data on individual laptops, combine them to get a result and something goes wrong all over again. Computing was a huge bottleneck, what would take 3-4 hours, would take us 1-2 days of gruelling teamwork.

Do you have any final words of advice for the tech community here at IIT Patna?

The people who get farthest are the ones who do it out of passion, don’t just try to master algorithms for Online Assessments or Interviews!! Go after Olympiads, Go after ICTC, try to see if you can make something novel of your own. If learning just enough to get a job is your goal, this can be done without an IIT. You’re here for more!