AI, Machine Learning, Neural Networks, and LLMs: A Beginner's Map

When I first started learning AI, the hardest part was not the math. It was the vocabulary.

People said AI, machine learning, deep learning, neural networks, generative AI, and LLM as if they were interchangeable. Then I would read another article and discover that they were not the same thing at all.

So before this series gets into tokens, weights, transformers, training, inference, quantization, or GPUs, I want to build one map.

If this map is clear, almost every later topic becomes easier to place.

Artificial Intelligence
│
├── Rule-based and search-based systems
│
└── Machine Learning
    │
    ├── Linear models, trees, SVMs, etc.
    │
    └── Neural Networks
        │
        └── Deep Learning
            │
            ├── Vision models
            ├── Speech models
            └── Generative models
                │
                └── Large Language Models

This diagram is simplified, but it gives us the right mental direction.

1. AI is the broadest idea

Artificial intelligence is the umbrella term.

NIST describes AI in several related ways, including machine-based systems that can make predictions, recommendations, or decisions for human-defined objectives. The important point for a beginner is that AI is much broader than ChatGPT or even machine learning.

An AI system can use many techniques.

For example, imagine a chess program.

It might examine possible moves, search many future positions, score them with rules, and choose the best move. That is an intelligent system, but it does not necessarily need to learn from millions of games in the modern machine-learning sense.

So this statement is important:

Not all AI is machine learning.

AI is the goal or field: make machines perform tasks that require some form of perception, prediction, reasoning, decision-making, planning, generation, or intelligent behavior.

Machine learning is one major way to get there.

2. Machine learning means learning patterns from data

NIST defines machine learning around computer systems that adapt and learn from data to improve accuracy.

That is a major change from traditional programming.

In ordinary programming, a human might write rules:

IF email contains "WIN MONEY NOW"
AND sender is unknown
THEN mark as spam

In machine learning, we can instead provide many examples:

Email A → spam
Email B → not spam
Email C → spam
Email D → not spam
...

The learning algorithm tries to discover a useful relationship between the inputs and the correct outputs.

After training, we get a model.

You can think of the model as a learned mathematical object that transforms new inputs into predictions or outputs.

training data
      ↓
learning algorithm
      ↓
trained model
      ↓
new input → prediction

This is why a model is not the same thing as the program that runs it.

That distinction becomes very important in local AI.

A GGUF file containing model weights is one thing. A runtime such as llama.cpp that loads those weights and performs inference is another.

If you have read our llama.cpp beginner guide, this is the same separation from a more fundamental angle:

model = learned parameters
runtime = software that executes the model
application = product that uses the runtime and model

3. Not every machine-learning model is a neural network

This was one of my early misconceptions.

I thought modern AI basically meant neural networks.

But machine learning existed long before today’s large neural networks became dominant.

A machine-learning model might be:

• linear regression
• logistic regression
• a decision tree
• a random forest
• a support vector machine
• a nearest-neighbor model
• a neural network

These methods can all learn patterns from data, but their internal structures are very different.

A simple linear model might learn something conceptually like:

prediction = a × feature1 + b × feature2 + c

A decision tree might repeatedly ask questions:

Is income > X?
    ├── yes → ask another question
    └── no  → follow another branch

A neural network instead builds many layers of mathematical transformations.

So the next statement is also important:

Not all machine learning uses neural networks.

4. A neural network is a particular kind of model

An artificial neural network is built from connected computational units arranged in layers.

A very simplified network looks like this:

inputs
  ↓
layer 1
  ↓
layer 2
  ↓
output

Each connection can have a numerical weight. During training, those weights are adjusted so the network becomes better at producing useful outputs.

That sentence introduces one of the most important words in the entire AI series:

weights.

When someone says a model has 7 billion parameters, many of those parameters are learned numerical values that influence how information flows through the network.

We will spend a full article on parameters and weights later, because this idea connects directly to model size, VRAM use, quantization, and local inference.

For now, the main point is simpler:

neural network
=
a mathematical structure containing many learned parameters

5. What makes deep learning “deep”?

Deep learning generally refers to machine learning using neural networks with multiple layers of learned representations.

The word deep does not mean the system is philosophical or deeply intelligent.

It refers to depth in the computational network.

One reason deep learning became so powerful is that different layers can learn different levels of representation.

For image recognition, a simplified intuition might be:

pixels
  ↓
edges
  ↓
shapes
  ↓
parts
  ↓
objects

Real networks are not this cleanly labeled, but the idea is useful: later representations can be built from earlier ones.

The rise of large datasets, GPUs, better optimization methods, and improved neural-network architectures made deep learning practical at scales that were previously difficult.

6. Generative AI does something different

Many traditional machine-learning systems are designed mainly to classify, rank, predict, or estimate.

For example:

photo → "cat"
transaction → fraud probability
house data → estimated price

Generative AI models are designed to generate new content or structured outputs based on learned patterns.

That content can include:

text
images
audio
video
code

This is why an image generator and a language model can both be called generative AI even though their architectures and training methods can be quite different.

Generative AI is therefore not another word for LLM.

An LLM is one important type of generative model focused on language and language-like token sequences.

7. An LLM is a large neural-network language model

Now we can finally place the term that dominates current AI discussion.

LLM means large language model.

Modern LLMs are generally deep neural networks trained on very large collections of token sequences. Most influential modern LLM architectures are based on the Transformer, introduced in the 2017 paper Attention Is All You Need.

A simplified view is:

text
  ↓
tokens
  ↓
large neural network
  ↓
probabilities for what token may come next
  ↓
selected next token
  ↓
repeat

That next-token mechanism sounds almost too simple when you first hear it.

But predicting the next token across huge and diverse datasets forces the model to learn useful statistical structure about language, syntax, facts, styles, code, relationships, and many patterns that appear in text.

Models such as GPT-3 demonstrated that scaling this basic training objective can produce surprisingly broad few-shot and language-generation capabilities.

This gives us another important rule:

An LLM is AI, and it is machine learning, and it uses deep neural networks — but AI is much bigger than LLMs.

8. The hierarchy is useful, but reality is not a perfect set of boxes

The nested diagram at the beginning is a learning tool, not a law of nature.

Real systems combine techniques.

A modern AI application may contain:

LLM
+ search
+ retrieval
+ rules
+ databases
+ tools
+ ranking models
+ safety filters
+ traditional software

For example, a chatbot that answers questions about company documents might use an LLM for generation, an embedding model for retrieval, a database for storage, and ordinary code for authentication and business logic.

Calling the entire product “the AI” hides all of those layers.

For technical work, it is better to ask:

Which part are we talking about?

9. Model, training, inference, and application are different things

These four words are easy to mix together.

Training

Training is the process that changes model parameters using data and an optimization procedure.

data + computation → learned weights

Model

The model is the learned mathematical structure and its parameters.

Inference

Inference means using the trained model to produce outputs from new inputs.

trained weights + prompt → output

Application

The application is the software product around the model.

Chat interfaces, APIs, file upload systems, web search, memory, tool execution, and user accounts can all exist outside the core neural network.

This distinction will matter constantly when we discuss local AI.

When you download a quantized model and run it on your GPU, you are normally doing inference, not training.

10. Why local AI makes this map easier to understand

Running models locally taught me these distinctions faster than reading definitions alone.

When everything happens inside one commercial website, the layers are hidden.

With local AI, you see the pieces separately:

Model file
   ↓
Inference runtime
   ↓
CPU / GPU
   ↓
API or command line
   ↓
User interface

You can replace one model without replacing the runtime.

You can change quantization without changing the model architecture.

You can change the runtime while keeping the same model family.

You can change the user interface without retraining anything.

Once those pieces become visible, many AI terms stop feeling mysterious.

11. The five sentences I would memorize

If you are just starting, I think these five statements are enough for today:

1. AI is the broad field of building systems that perform intelligent tasks.
2. Machine learning is a major branch of AI that learns useful patterns from data.
3. Neural networks are one family of machine-learning models.
4. Deep learning uses multi-layer neural networks to learn complex representations.
5. LLMs are large deep-learning models designed to model and generate language-like token sequences.

And one bonus sentence:

The model, the runtime, and the application are not the same thing.

That last sentence becomes extremely useful once you start running AI locally.

12. Where the series goes next

This is AI Foundations #1.

The goal of this series is not to throw definitions at you. William and machaMochaLatte will build the concepts in order so that later topics depend on earlier ones.

The next questions are more interesting:

• What does it actually mean for a machine to “learn”?
• What are parameters and weights?
• Why do we represent information with vectors and tensors?
• What happens during a forward pass?
• What are loss functions and gradient descent?
• Why are tokens necessary for language models?
• What does attention actually do?
• Why did the Transformer change language modeling?
• What is the difference between training and inference cost?
• Why can quantization make a model smaller without retraining it from scratch?

Those are the pieces we will assemble one at a time.

For today, the important thing is the map.

Once you know where each term belongs, AI stops looking like one giant black box and starts looking like a system made of understandable parts.