Neural Networks, Explained for Beginners: Start Here If They’ve Confused You

Neural Networks, Explained for Beginners: Start Here If They’ve Confused You

If you've ever felt overwhelmed by the jargon around neural networks—neurons, layers, backpropagation, activation functions—you're not alone. The good news is that the core idea is surprisingly simple. A neural network is a computational system inspired by the way biological brains process information, but in practice, it's a mathematical model that learns patterns from data. This article will strip away the confusion, give you a clear mental model, and walk you through a real, working example you can run on your own computer.

By the end, you'll understand what a neural network does, how it learns, and you'll have built and trained a simple one yourself.

What Is a Neural Network, Really?

At its simplest, a neural network is a function that maps inputs to outputs. Imagine you have a spreadsheet of house prices: square footage, number of bedrooms, and location. You want to predict the price. A neural network learns the relationship between those inputs and the output (price) by adjusting internal parameters called *weights* and *biases*.

A neural network is made of layers of *neurons*. Each neuron takes a set of inputs, multiplies each by a weight, adds a bias, and applies an *activation function* to produce an output. That output becomes the input to the next layer. The final layer produces the network's prediction.

Think of it like a chain of simple calculations. Each neuron is a tiny decision-maker. When you stack hundreds or thousands of them, the network can model very complex patterns.

Key Concepts You Need to Know

Before we dive into code, let's clarify a few terms that often cause confusion.

Neurons and Layers

• **Input layer**: The raw data you feed in (e.g., square footage, number of bedrooms).
• **Hidden layers**: Layers between input and output. They transform the data. More hidden layers make the network "deep."
• **Output layer**: The final prediction (e.g., predicted price).

Weights and Biases

• **Weights** determine how much influence each input has on the neuron's output. During training, weights are adjusted to reduce error.
• **Biases** allow the neuron to output a nonzero value even when all inputs are zero. They give the network flexibility.

Activation Function

An activation function decides whether a neuron should "fire" or not. Common ones:

• **ReLU (Rectified Linear Unit)**: outputs 0 for negative inputs, and the input itself for positive values. It's simple and fast.
• **Sigmoid**: squashes values between 0 and 1, useful for probabilities.
• **Softmax**: used in the output layer for multi-class classification.

Loss Function

The loss function measures how wrong the network's predictions are. For example, Mean Squared Error (MSE) is common for regression. The goal of training is to minimize this loss.

Backpropagation and Gradient Descent

• **Backpropagation** is the algorithm that calculates how much each weight contributed to the error.
• **Gradient descent** uses that information to adjust weights in the direction that reduces the loss. It's like rolling a ball downhill to find the lowest point.

Requirements

To follow along, you need:

• A computer running Windows, macOS, or Linux.
• Python 3.8 or later installed.
• Basic familiarity with the command line.
• An internet connection to install packages.

We'll use **PyTorch**, a popular deep learning framework. It's beginner-friendly and widely used in research and industry.

Step-by-step Installation

1. Install Python (if not already installed)

Check your Python version. Open a terminal and run:

python --version

If Python is not installed or the version is below 3.8, download it from [python.org](https://www.python.org/downloads/). During installation, check "Add Python to PATH."

2. Create a virtual environment (recommended)

This keeps dependencies isolated for this project.

python -m venv nn-tutorial

This creates a folder named `nn-tutorial` containing a clean Python environment.

3. Activate the virtual environment

On Windows:

nn-tutorial\Scripts\activate

On macOS/Linux:

source nn-tutorial/bin/activate

You should see `(nn-tutorial)` appear in your terminal prompt.

4. Install PyTorch

Visit [pytorch.org](https://pytorch.org) and select your system configuration. For most beginners without a GPU, this command works:

pip install torch torchvision

This installs PyTorch (CPU version) and torchvision for image datasets.

5. Install additional libraries

We'll also need NumPy for data handling and Matplotlib for visualization.

pip install numpy matplotlib

Usage Examples

Now let's build a neural network from scratch using PyTorch. We'll train it on a classic dataset: handwritten digits (MNIST). The network will learn to recognize digits 0 through 9.

Example 1: Build a Simple Neural Network

Create a new Python file called `mnist_net.py` and paste the following code.

import torch
import torch.nn as nn
import torch.optim as optim
import torchvision
import torchvision.transforms as transforms
import matplotlib.pyplot as plt

# 1. Load and normalize the MNIST dataset
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.5,), (0.5,))
])

trainset = torchvision.datasets.MNIST(root='./data', train=True,
                                      download=True, transform=transform)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=64,
                                          shuffle=True)

testset = torchvision.datasets.MNIST(root='./data', train=False,
                                     download=True, transform=transform)
testloader = torch.utils.data.DataLoader(testset, batch_size=64,
                                         shuffle=False)

# 2. Define the neural network architecture
class SimpleNN(nn.Module):
    def __init__(self):
        super(SimpleNN, self).__init__()
        self.fc1 = nn.Linear(28*28, 128)  # input layer (784 pixels) -> hidden layer (128 neurons)
        self.fc2 = nn.Linear(128, 64)     # hidden layer (128) -> hidden layer (64)
        self.fc3 = nn.Linear(64, 10)      # hidden layer (64) -> output layer (10 classes)

    def forward(self, x):
        x = x.view(-1, 28*28)             # flatten the image to a 1D vector
        x = torch.relu(self.fc1(x))       # activation function for first hidden layer
        x = torch.relu(self.fc2(x))       # activation for second hidden layer
        x = self.fc3(x)                   # output layer (no activation, we'll use CrossEntropyLoss)
        return x

# 3. Instantiate the model, define loss function and optimizer
model = SimpleNN()
criterion = nn.CrossEntropyLoss()         # good for classification
optimizer = optim.SGD(model.parameters(), lr=0.01)  # stochastic gradient descent

# 4. Train the network
num_epochs = 5
for epoch in range(num_epochs):
    running_loss = 0.0
    for images, labels in trainloader:
        optimizer.zero_grad()             # clear previous gradients
        outputs = model(images)           # forward pass
        loss = criterion(outputs, labels) # compute loss
        loss.backward()                   # backpropagation
        optimizer.step()                  # update weights

        running_loss += loss.item()
    print(f"Epoch {epoch+1}, Loss: {running_loss/len(trainloader):.4f}")

print("Training complete!")

# 5. Test the network
correct = 0
total = 0
with torch.no_grad():                     # no need to compute gradients during evaluation
    for images, labels in testloader:
        outputs = model(images)
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

print(f"Accuracy on test set: {100 * correct / total:.2f}%")

**Explanation of each step:**

• **Data loading**: We download the MNIST dataset, normalize pixel values to range [-1, 1], and create batches of 64 images.
• **Network definition**: `SimpleNN` has three fully connected layers. We flatten the 28x28 image into a 784-dimensional vector, pass it through two hidden layers with ReLU activation, and finally to a 10-neuron output layer (one for each digit).
• **Training loop**: For each epoch (full pass over the data), we compute the loss, backpropagate, and update weights.
• **Testing**: We evaluate accuracy on unseen test data. No gradients are computed to save memory.

Run the script:

python mnist_net.py

You should see output like:

Epoch 1, Loss: 0.6543
Epoch 2, Loss: 0.3210
Epoch 3, Loss: 0.2456
Epoch 4, Loss: 0.1987
Epoch 5, Loss: 0.1678
Training complete!
Accuracy on test set: 95.12%

Your accuracy may vary slightly, but you should see around 95%—not bad for a simple network trained in seconds!

Example 2: Visualize Predictions

Let's add a quick visualization to see what the network is predicting. Add this code at the end of your script.

# Visualize some test images with predictions
dataiter = iter(testloader)
images, labels = next(dataiter)

# Get predictions
outputs = model(images)
_, predicted = torch.max(outputs, 1)

# Plot the first 10 images
fig, axes = plt.subplots(2, 5, figsize=(10, 4))
for idx, ax in enumerate(axes.flat):
    ax.imshow(images[idx].squeeze(), cmap='gray')
    ax.set_title(f"True: {labels[idx].item()}, Pred: {predicted[idx].item()}")
    ax.axis('off')
plt.tight_layout()
plt.show()

Run the script again. A window will pop up showing 10 handwritten digits with their true labels and the network's predictions. You'll see that most are correct, but a few might be wrong—that's normal.

What's Next? (Practical Next Steps)

You've just built and trained a neural network. Here's how to go deeper:

• **Experiment with architecture**: Try adding more hidden layers or changing the number of neurons. See how accuracy changes.
• **Tune hyperparameters**: Adjust the learning rate (e.g., 0.001 or 0.1), batch size, or number of epochs.
• **Try a different dataset**: Use CIFAR-10 (color images of objects) by replacing `torchvision.datasets.MNIST` with `torchvision.datasets.CIFAR10`. You'll need to adjust the input size (32x32x3) and possibly add convolutional layers.
• **Learn about convolutional neural networks (CNNs)**: They are much better for image tasks. PyTorch's `nn.Conv2d` is your friend.
• **Explore transfer learning**: Use a pretrained model (like ResNet) from `torchvision.models` and fine-tune it for your own task.

For more advanced tutorials, the Hugging Face Blog and Google AI Blog often publish beginner-friendly guides with code examples. The Towards Data Science platform also has many practical walkthroughs.

Conclusion

Neural networks are not magic—they are a series of simple mathematical operations that, when stacked and trained, can learn complex patterns. You've seen the core concepts: neurons, layers, weights, activation functions, and backpropagation. More importantly, you've run a working example that trains on real data and makes predictions.

The confusion around neural networks often comes from the sheer number of new terms, but each one represents a small, understandable piece. Start with the code you have here. Modify it. Break it. Fix it. That's the best way to learn.

Now you have a foundation. Go build something.