If you have already learned the basics of Python, NumPy, machine learning, and neural networks, the next practical step is to build your first neural network.

One of the best frameworks for doing this is PyTorch.

PyTorch makes it relatively easy to create neural networks, define layers, calculate loss, perform backpropagation, and train models using Python.

In this beginner-friendly tutorial, you will build a complete neural network from scratch using PyTorch.

You will learn how to:

• Install PyTorch
• Create training data
• Convert data into tensors
• Build a neural network
• Define a loss function
• Choose an optimizer
• Train the model
• Make predictions
• Evaluate the results
• Save and load the trained model

By the end of this guide, you will understand the complete workflow behind training a simple neural network with PyTorch.

---

What Are We Going to Build?

We will build a simple binary classification neural network.

Its job will be to predict whether a student is likely to pass or fail based on:

• Study hours
• Attendance percentage

For example:

Study Hours = 8
Attendance = 90%

The model might predict:

Pass

Another student might have:

Study Hours = 2
Attendance = 40%

The model might predict:

Fail

This is a simple example, but the same basic training process is used in much larger neural-network systems.

---

Step 1: Install PyTorch

First, make sure Python is installed on your computer.

You can check it using:

python --version

or:

python3 --version

Now install PyTorch.

A common installation command is:

pip install torch

If you also want common supporting packages, you can install:

pip install torch torchvision torchaudio

For GPU-enabled installations, the correct command may depend on your operating system, Python version, GPU, and CUDA setup.

After installation, verify PyTorch:

import torch

print(torch.__version__)

If a version number appears without an error, PyTorch is installed correctly.

---

Step 2: Import PyTorch

Create a new Python file.

For example:

first_neural_network.py

Now import PyTorch:

import torch
import torch.nn as nn
import torch.optim as optim

Here:

torch

provides tensors and mathematical operations.

torch.nn

provides neural-network layers and loss functions.

torch.optim

provides optimization algorithms such as Adam and SGD.

---

Step 3: Create the Training Data

For this example, we will create a small dataset manually.

Each student will have two features:

Study Hours
Attendance Percentage

Our labels will represent:

0 = Fail
1 = Pass

Create the input data:

X = torch.tensor([
    [1.0, 30.0],
    [2.0, 40.0],
    [3.0, 45.0],
    [4.0, 55.0],
    [5.0, 60.0],
    [6.0, 70.0],
    [7.0, 80.0],
    [8.0, 90.0],
    [9.0, 95.0],
    [10.0, 98.0]
])

Now create the labels:

y = torch.tensor([
    [0.0],
    [0.0],
    [0.0],
    [0.0],
    [1.0],
    [1.0],
    [1.0],
    [1.0],
    [1.0],
    [1.0]
])

Here, each input row contains two values.

For example:

[8.0, 90.0]

means:

8 Study Hours
90% Attendance

and its corresponding label is:

1

which means:

Pass

---

Step 4: Normalize the Input Data

Notice that our two input features have very different scales.

Study hours range roughly from:

1 to 10

while attendance ranges from:

30 to 98

Neural networks often train better when input features are scaled to similar ranges.

We can normalize the data.

For this simple example:

X[:, 0] = X[:, 0] / 10.0
X[:, 1] = X[:, 1] / 100.0

Now the values become much smaller.

For example:

8 Study Hours → 0.8
90% Attendance → 0.9

Normalized inputs can make training more stable.

In real machine-learning projects, you might use standardization or tools such as StandardScaler.

---

Step 5: Build the Neural Network

Now we can create our neural network.

In PyTorch, neural-network models normally inherit from:

nn.Module

Create the model:

class StudentModel(nn.Module):

    def __init__(self):
        super().__init__()

        self.layer1 = nn.Linear(2, 4)
        self.relu = nn.ReLU()
        self.layer2 = nn.Linear(4, 1)

    def forward(self, x):
        x = self.layer1(x)
        x = self.relu(x)
        x = self.layer2(x)

        return x

Now let’s understand this model.

---

Understanding the Neural Network Architecture

Our network looks like:

2 Input Features
      ↓
4 Hidden Neurons
      ↓
ReLU Activation
      ↓
1 Output

The two input features are:

Study Hours
Attendance

The first layer is:

nn.Linear(2, 4)

This means:

2 Inputs
↓
4 Hidden Units

The second layer is:

nn.Linear(4, 1)

This means:

4 Hidden Units
↓
1 Output

The final output will help us predict whether the student passes or fails.

---

Step 6: Create the Model

Now create an instance of the network.

model = StudentModel()

You can print it:

print(model)

The output should look similar to:

StudentModel(
  (layer1): Linear(in_features=2, out_features=4, bias=True)
  (relu): ReLU()
  (layer2): Linear(in_features=4, out_features=1, bias=True)
)

PyTorch automatically creates trainable weights and biases for the linear layers.

---

Step 7: Choose the Loss Function

We are solving a binary classification problem.

The student can be:

Pass

or:

Fail

For this task, we can use:

criterion = nn.BCEWithLogitsLoss()

BCEWithLogitsLoss combines:

• Binary Cross-Entropy
• Sigmoid processing

This is generally preferred over manually applying a sigmoid before BCELoss, because it is numerically more stable.

---

Step 8: Choose an Optimizer

Now we need an optimizer.

An optimizer updates the neural network’s weights and biases during training.

We will use Adam:

optimizer = optim.Adam(
    model.parameters(),
    lr=0.01
)

Here:

lr = 0.01

means the learning rate is 0.01.

The learning rate controls how large the model’s parameter updates are.

---

Step 9: Train the Neural Network

Now comes the most important part: training.

Create the training loop:

epochs = 1000

for epoch in range(epochs):

    optimizer.zero_grad()

    outputs = model(X)

    loss = criterion(outputs, y)

    loss.backward()

    optimizer.step()

    if (epoch + 1) % 100 == 0:
        print(
            f"Epoch [{epoch + 1}/{epochs}], "
            f"Loss: {loss.item():.4f}"
        )

This is the basic PyTorch training process.

Let’s understand it line by line.

---

What Does optimizer.zero_grad() Do?

PyTorch accumulates gradients by default.

Before calculating new gradients, we clear the previous gradients:

optimizer.zero_grad()

Without this step, gradients from previous iterations would be added together.

---

What Does model(X) Do?

This line:

outputs = model(X)

runs the training data through the neural network.

This is called the:

Forward Pass

The data travels through:

Input
↓
Linear Layer
↓
ReLU
↓
Linear Layer
↓
Output

The model generates predictions.

---

What Does the Loss Function Do?

Next:

loss = criterion(outputs, y)

The loss function compares the predictions with the correct answers.

For example:

Prediction = 0.30
Correct Answer = 1

The prediction is far from the target.

The loss will therefore be relatively high.

The goal of training is to gradually reduce the loss.

---

What Does loss.backward() Do?

This line:

loss.backward()

performs backpropagation.

PyTorch calculates gradients for all trainable model parameters.

These gradients tell us how the parameters should change to reduce the loss.

This process is powered by PyTorch’s automatic differentiation system.

---

What Does optimizer.step() Do?

After gradients have been calculated:

optimizer.step()

updates the model’s weights and biases.

The basic idea is:

Old Parameters
      ↓
Calculated Gradients
      ↓
Optimizer
      ↓
Updated Parameters

The network should gradually improve as training continues.

---

What Happens During Training?

The training loop repeatedly performs:

Forward Pass
      ↓
Prediction
      ↓
Calculate Loss
      ↓
Backpropagation
      ↓
Update Parameters
      ↓
Repeat

You may see output similar to:

Epoch [100/1000], Loss: 0.4502
Epoch [200/1000], Loss: 0.2501
Epoch [300/1000], Loss: 0.1450
Epoch [400/1000], Loss: 0.0904
Epoch [500/1000], Loss: 0.0618

The exact numbers will vary.

Usually, we want the loss to decrease as the model learns.

---

Step 10: Make a Prediction

Now let’s test the trained model.

Suppose a student studies for:

8 hours

and has:

85% attendance

Remember that our training data was normalized.

Therefore:

8 / 10 = 0.8
85 / 100 = 0.85

Create a test input:

test_student = torch.tensor([
    [0.8, 0.85]
])

Now make a prediction:

with torch.no_grad():
    output = model(test_student)
    probability = torch.sigmoid(output)

print(probability.item())

You might get something like:

0.93

This means the model estimates approximately a 93% probability of passing.

---

Step 11: Convert Probability into Pass or Fail

We can use a threshold.

For example:

Probability >= 0.5 → Pass
Probability < 0.5 → Fail

Use:

with torch.no_grad():

    output = model(test_student)

    probability = torch.sigmoid(output)

    if probability.item() >= 0.5:
        print("Prediction: Pass")
    else:
        print("Prediction: Fail")

The result may be:

Prediction: Pass

---

Complete PyTorch Neural Network Code

Here is the complete example in one place:

import torch
import torch.nn as nn
import torch.optim as optim


# Training data
X = torch.tensor([
    [1.0, 30.0],
    [2.0, 40.0],
    [3.0, 45.0],
    [4.0, 55.0],
    [5.0, 60.0],
    [6.0, 70.0],
    [7.0, 80.0],
    [8.0, 90.0],
    [9.0, 95.0],
    [10.0, 98.0]
])


# Labels
y = torch.tensor([
    [0.0],
    [0.0],
    [0.0],
    [0.0],
    [1.0],
    [1.0],
    [1.0],
    [1.0],
    [1.0],
    [1.0]
])


# Normalize inputs
X[:, 0] = X[:, 0] / 10.0
X[:, 1] = X[:, 1] / 100.0


# Neural network
class StudentModel(nn.Module):

    def __init__(self):
        super().__init__()

        self.layer1 = nn.Linear(2, 4)
        self.relu = nn.ReLU()
        self.layer2 = nn.Linear(4, 1)

    def forward(self, x):

        x = self.layer1(x)
        x = self.relu(x)
        x = self.layer2(x)

        return x


# Create model
model = StudentModel()


# Loss function
criterion = nn.BCEWithLogitsLoss()


# Optimizer
optimizer = optim.Adam(
    model.parameters(),
    lr=0.01
)


# Training
epochs = 1000

for epoch in range(epochs):

    optimizer.zero_grad()

    outputs = model(X)

    loss = criterion(outputs, y)

    loss.backward()

    optimizer.step()

    if (epoch + 1) % 100 == 0:
        print(
            f"Epoch [{epoch + 1}/{epochs}], "
            f"Loss: {loss.item():.4f}"
        )


# Test new student
test_student = torch.tensor([
    [0.8, 0.85]
])


# Prediction
with torch.no_grad():

    output = model(test_student)

    probability = torch.sigmoid(output)

    print(
        "Pass Probability:",
        probability.item()
    )

    if probability.item() >= 0.5:
        print("Prediction: Pass")
    else:
        print("Prediction: Fail")

This small program contains the main steps used in most neural-network projects.

---

Understanding the Full Workflow

Our complete workflow looks like:

Create Data
    ↓
Convert Data to Tensors
    ↓
Normalize Features
    ↓
Build Neural Network
    ↓
Choose Loss Function
    ↓
Choose Optimizer
    ↓
Forward Pass
    ↓
Calculate Loss
    ↓
Backpropagation
    ↓
Update Parameters
    ↓
Repeat Training
    ↓
Make Predictions

Once you understand this workflow, more advanced PyTorch projects become much easier.

---

Why Did We Not Add Sigmoid Inside the Model?

You may wonder why the model does not contain:

nn.Sigmoid()

Our model produces raw values called:

Logits

We use:

nn.BCEWithLogitsLoss()

which internally handles the sigmoid-related calculation while computing the loss.

This is generally more numerically stable than:

nn.Sigmoid()

combined with:

nn.BCELoss()

During prediction, however, we use:

torch.sigmoid(output)

to convert logits into probabilities.

---

What Are Weights and Biases?

The nn.Linear layers contain:

• Weights
• Biases

For example:

nn.Linear(2, 4)

automatically creates trainable parameters.

You can inspect them using:

for name, parameter in model.named_parameters():
    print(name)
    print(parameter)

You may see parameter names such as:

layer1.weight
layer1.bias
layer2.weight
layer2.bias

These are the values the neural network learns during training.

---

What Is ReLU Doing?

Our network contains:

self.relu = nn.ReLU()

ReLU means:

Rectified Linear Unit

Its basic behavior is:

If x > 0
Return x

If x <= 0
Return 0

For example:

Input = -5 → Output = 0

Input = 3 → Output = 3

Activation functions such as ReLU allow neural networks to learn nonlinear relationships.

---

What Happens If We Add More Hidden Layers?

Our current network has:

Input Layer
↓
One Hidden Layer
↓
Output Layer

We can make it deeper.

For example:

class BiggerModel(nn.Module):

    def __init__(self):
        super().__init__()

        self.network = nn.Sequential(
            nn.Linear(2, 16),
            nn.ReLU(),

            nn.Linear(16, 8),
            nn.ReLU(),

            nn.Linear(8, 1)
        )

    def forward(self, x):
        return self.network(x)

The architecture becomes:

2 Inputs
   ↓
16 Neurons
   ↓
ReLU
   ↓
8 Neurons
   ↓
ReLU
   ↓
1 Output

However, a bigger network is not automatically better.

For simple problems, smaller models may work perfectly well.

---

Using nn.Sequential

For simple feed-forward neural networks, you can make the code shorter using:

nn.Sequential

For example:

model = nn.Sequential(

    nn.Linear(2, 4),

    nn.ReLU(),

    nn.Linear(4, 1)
)

This represents the same basic architecture as our earlier custom model.

nn.Sequential is useful when layers simply run one after another.

---

How to Evaluate the Model

Training loss alone is not enough.

In real projects, you should evaluate performance using unseen data.

Normally, datasets are divided into:

Training Data
Validation Data
Test Data

For example:

70% Training
15% Validation
15% Testing

The exact split can vary depending on the project.

The training data teaches the model.

Validation data helps tune the model and monitor training.

Test data provides a final evaluation on unseen examples.

---

What Is Accuracy?

For classification problems, one common metric is accuracy.

Accuracy measures:

Correct Predictions
------------------- × 100
Total Predictions

For example:

Correct Predictions = 90
Total Predictions = 100

Accuracy is:

90%

However, accuracy is not always sufficient, especially for imbalanced datasets.

Other metrics include:

• Precision
• Recall
• F1 Score
• ROC-AUC

---

How to Save a PyTorch Model

After training a model, you may want to save it.

Use:

torch.save(
    model.state_dict(),
    "student_model.pth"
)

This saves the learned parameters.

The file:

student_model.pth

can later be loaded without retraining the model from scratch.

---

How to Load a PyTorch Model

First, recreate the same model architecture.

model = StudentModel()

Now load the saved weights:

model.load_state_dict(
    torch.load("student_model.pth")
)

Then switch the model to evaluation mode:

model.eval()

Now the model is ready for predictions.

---

model.train() vs model.eval()

PyTorch models can operate in different modes.

During training:

model.train()

During testing or prediction:

model.eval()

This is especially important when using layers such as:

• Dropout
• Batch Normalization

These layers behave differently during training and evaluation.

---

Why Use torch.no_grad()?

During prediction, we used:

with torch.no_grad():

This tells PyTorch that gradients are not required.

Since we are not training the model, there is no need to create a gradient graph.

This can:

• Reduce memory usage
• Improve inference efficiency

For prediction and evaluation, torch.no_grad() is commonly used.

---

How to Use a GPU

If your computer has compatible GPU acceleration, PyTorch can use it.

For NVIDIA CUDA:

device = torch.device(
    "cuda" if torch.cuda.is_available() else "cpu"
)

Then move the model:

model = model.to(device)

Move tensors too:

X = X.to(device)
y = y.to(device)

Your model and data must generally be on the same device.

For larger neural networks, GPU acceleration can significantly reduce training time.

---

Common Beginner Mistakes

When building your first neural network, several mistakes are common.

Forgetting to Clear Gradients

Always remember:

optimizer.zero_grad()

before backpropagation in a typical training step.

---

Using the Wrong Input Shape

nn.Linear(2, 4) expects two input features.

If you provide a different number of features, PyTorch will throw a shape-related error.

---

Forgetting Data Normalization

Large differences between input feature scales can make training harder.

Normalize or standardize features when appropriate.

---

Using the Wrong Loss Function

Different tasks need different losses.

For example:

Binary classification:

nn.BCEWithLogitsLoss()

Multi-class classification:

nn.CrossEntropyLoss()

Regression:

nn.MSELoss()

---

Using Too High a Learning Rate

If the learning rate is too high, training may become unstable.

Instead of decreasing, the loss may jump around.

Common values to test include:

0.1
0.01
0.001
0.0001

There is no universal best learning rate.

---

Training on Too Little Data

Our example uses only a few data points because it is designed for learning.

Real-world models generally require significantly more high-quality data.

---

How Neural Network Training Really Works

When you run:

loss.backward()

PyTorch calculates gradients.

Suppose one weight is:

0.50

and the calculated gradient suggests that reducing it could lower the loss.

The optimizer may update it to something like:

0.48

The model repeats this process across many parameters and training iterations.

Over time:

Random Parameters
      ↓
Training
      ↓
Gradually Improved Parameters
      ↓
Better Predictions

This is the core idea behind neural-network learning.

---

Where to Go After Your First Neural Network

Once you successfully build this model, continue gradually.

Next Step 1: Learn PyTorch Tensors

Understand:

• Tensor shapes
• Indexing
• Reshaping
• Broadcasting
• Matrix multiplication

Next Step 2: Learn Dataset and DataLoader

Learn how to process larger datasets efficiently.

Next Step 3: Build a Regression Model

For example:

House Price Prediction

Next Step 4: Build a Multi-Class Classifier

For example:

Cat
Dog
Bird

Next Step 5: Learn CNNs

Convolutional Neural Networks are widely used for images.

Build projects such as:

Handwritten Digit Recognition
Image Classification

Next Step 6: Learn Transformers

After understanding basic neural networks, move toward:

• Attention
• Transformers
• NLP
• Generative AI
• Large language models

---

Beginner PyTorch Project Ideas

After completing this tutorial, try building:

1. Student pass/fail predictor
2. House price predictor
3. Spam classifier
4. Iris flower classifier
5. Handwritten digit classifier
6. Customer churn predictor
7. Cat vs dog classifier
8. Sentiment analysis model
9. Fashion image classifier
10. Simple text classification model

Projects will help you understand PyTorch much faster than only reading theory.

---

Frequently Asked Questions

Can a beginner build a neural network with PyTorch?

Yes. PyTorch is one of the most beginner-friendly frameworks for learning neural networks, especially if you already know basic Python.

Do I need mathematics before learning PyTorch?

You can start with basic examples without advanced mathematics, but eventually you should learn linear algebra, probability, statistics, derivatives, and gradients.

What does nn.Module do?

nn.Module is the base class used to create neural-network models in PyTorch.

What is nn.Linear?

nn.Linear creates a fully connected neural-network layer.

For example:

nn.Linear(10, 5)

takes 10 input features and produces 5 outputs.

What is ReLU?

ReLU is an activation function that helps neural networks learn nonlinear patterns.

What does loss.backward() do?

It performs backpropagation and calculates gradients for the model’s trainable parameters.

What does optimizer.step() do?

It updates the model parameters based on calculated gradients.

Why do we normalize data?

Normalization helps keep features on similar numerical scales, which can improve training stability and convergence.

Can PyTorch train models on a GPU?

Yes. PyTorch supports GPU and other accelerator backends depending on the hardware and environment.

---

Final Thoughts

Building your first neural network with PyTorch may look complicated at first, but the basic workflow is surprisingly consistent.

The process is:

Prepare Data
     ↓
Create Tensors
     ↓
Build Neural Network
     ↓
Choose Loss Function
     ↓
Choose Optimizer
     ↓
Forward Pass
     ↓
Calculate Loss
     ↓
Backpropagation
     ↓
Update Parameters
     ↓
Repeat
     ↓
Make Predictions

Once you understand this pattern, you have learned one of the most important foundations of deep learning.

Do not focus only on memorizing PyTorch code.

Make sure you understand what each step is doing:

• Tensors store data.
• Layers transform the data.
• Activation functions introduce nonlinear behavior.
• The loss function measures error.
• Backpropagation calculates gradients.
• The optimizer updates weights and biases.
• Training repeats this process until the model improves.

Start with small neural networks like the one in this tutorial. Then gradually move toward datasets, image classification, CNNs, Transformers, and generative AI.

The best way to learn PyTorch is simple:

Learn the concept, write the code, train a model, experiment with it, and build real projects.