How Can You Build a Simple Neural Network on a MacBook?

Building a simple neural network on a MacBook is a practical way to learn the basics of machine learning without special hardware. With the right Python setup and a small project, you can train a model that recognizes patterns in data in under an hour, while also learning the core workflow: prepare data, define a model, train it, and evaluate results.

What you need (and what you don’t)

A modern MacBook is enough for beginner neural network projects. For small datasets and simple models, the CPU works fine. An Apple Silicon Mac (M1/M2/M3) can also speed things up in some cases, but it’s not a requirement.

You need:

macOS with Terminal access
Python 3.10+ (3.11 is fine for most setups)
A virtual environment tool (built-in venv works well)
A deep learning library (PyTorch is a popular choice)

You don’t need:

A dedicated GPU for your first model
Complex MLOps tools
Large datasets

Set up Python on macOS

macOS comes with system Python components, but using your own isolated project environment avoids conflicts.

Create a project folder:

bash

1mkdir simple-nn-mac
2cd simple-nn-mac

Create and activate a virtual environment:

bash

1python3 -m venv .venv
2source .venv/bin/activate

Upgrade packaging tools:

bash

1python -m pip install --upgrade pip setuptools wheel

Install PyTorch (simple and reliable)

Install PyTorch from pip:

bash

1pip install torch torchvision

This is typically enough to run on CPU. On Apple Silicon, PyTorch also supports accelerated backends for some workloads, but you can treat that as a bonus rather than a requirement.

Confirm it works:

bash

1python -c "import torch; print(torch.__version__); print(torch.tensor([1.0,2.0]) * 3)"

Pick a tiny project: classify handwritten digits

A classic beginner task is digit classification using the MNIST dataset (images of digits 0–9). You’ll train a neural network to predict the correct digit from an image.

Create a file named train_mnist.py:

python

1import torch
2from torch import nn
3from torch.utils.data import DataLoader
4from torchvision import datasets, transforms
5
6# 1) Data: download MNIST, transform images to tensors
7transform = transforms.Compose([
8    transforms.ToTensor(),
9    transforms.Normalize((0.1307,), (0.3081,))  # mean/std for MNIST
10])
11
12train_data = datasets.MNIST(root="data", train=True, download=True, transform=transform)
13test_data  = datasets.MNIST(root="data", train=False, download=True, transform=transform)
14
15train_loader = DataLoader(train_data, batch_size=64, shuffle=True)
16test_loader  = DataLoader(test_data, batch_size=256, shuffle=False)
17
18# 2) Model: a small fully connected neural network
19class SimpleNN(nn.Module):
20    def __init__(self):
21        super().__init__()
22        self.net = nn.Sequential(
23            nn.Flatten(),              # 1x28x28 -> 784
24            nn.Linear(784, 128),
25            nn.ReLU(),
26            nn.Linear(128, 10)         # 10 classes: digits 0-9
27        )
28
29    def forward(self, x):
30        return self.net(x)
31
32device = "cpu"
33model = SimpleNN().to(device)
34
35# 3) Loss and optimizer
36loss_fn = nn.CrossEntropyLoss()
37optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)
38
39# 4) Training loop
40def train_one_epoch():
41    model.train()
42    total_loss = 0.0
43
44    for x, y in train_loader:
45        x, y = x.to(device), y.to(device)
46
47        logits = model(x)
48        loss = loss_fn(logits, y)
49
50        optimizer.zero_grad()
51        loss.backward()
52        optimizer.step()
53
54        total_loss += loss.item()
55
56    return total_loss / len(train_loader)
57
58# 5) Evaluation loop
59@torch.no_grad()
60def evaluate():
61    model.eval()
62    correct = 0
63    total = 0
64
65    for x, y in test_loader:
66        x, y = x.to(device), y.to(device)
67        logits = model(x)
68        preds = torch.argmax(logits, dim=1)
69        correct += (preds == y).sum().item()
70        total += y.size(0)
71
72    return correct / total
73
74if __name__ == "__main__":
75    for epoch in range(1, 6):
76        train_loss = train_one_epoch()
77        acc = evaluate()
78        print(f"Epoch {epoch}: loss={train_loss:.4f}, test_acc={acc:.4f}")

Run it:

bash

1python train_mnist.py

After a few epochs, you should see test accuracy climb into the 90%+ range. That’s a complete neural network project: data ingestion, model definition, training, and evaluation.

What each part is doing

Neural networks can feel abstract until you map code to concepts:

Dataset + transforms: turns image files into normalized tensors so the network sees consistent inputs.
Model (SimpleNN): a stack of layers. Linear layers learn weights; ReLU adds non-linearity so the model can learn more than straight-line patterns.
Loss function: CrossEntropyLoss compares predicted class scores to the true label.
Optimizer: Adam updates the weights to reduce loss.
Training loop: forward pass → compute loss → backpropagation → update weights.
Evaluation: checks accuracy on unseen test data.

Make it slightly better with a small upgrade

Once the baseline works, try one improvement that keeps the project simple: add another hidden layer.

Replace the nn.Sequential(...) with:

python

1self.net = nn.Sequential(
2    nn.Flatten(),
3    nn.Linear(784, 256),
4    nn.ReLU(),
5    nn.Linear(256, 128),
6    nn.ReLU(),
7    nn.Linear(128, 10)
8)

Train again and compare accuracy and training time. Small changes like this teach you how capacity and computation relate.

Tips for a smooth MacBook workflow

Run long training jobs while plugged in; sustained CPU work drains battery quickly.
If the fan ramps up (Intel Macs), reduce batch size (for example, 32) to lower peak load.
Keep projects isolated with venv so different experiments don’t conflict.
Print metrics each epoch so you can tell if learning is happening; a flat accuracy can mean a bug in data shape, labels, or loss.

Where to go next

After MNIST, the next step is a small convolutional neural network (CNN), since CNNs are better suited for images. Another good direction is using your own dataset, even if it’s tiny, such as classifying two types of objects from a folder of images. The same workflow applies: load data, define a model, train, evaluate, iterate.

A MacBook is a solid learning machine for neural networks. Start small, get a full training script running end-to-end, then improve one piece at a time.