DEV Community: Paul Chibueze

Building and Training a Neural Network with PyTorch: A Step-by-Step Guide

Paul Chibueze — Fri, 26 Jul 2024 08:36:36 +0000

Imagine a world where machines can not only see but also understand and classify images as effortlessly as humans. This capability has been at the heart of many breakthroughs in artificial intelligence, revolutionizing fields from healthcare to retail.

In recent years, advancements in deep learning have enabled computers to recognize objects, identify faces, and even understand emotions depicted in images. One of the pivotal tasks in this domain is image classification — teaching computers to categorize images into predefined classes based on their visual features.

In this guide, we’ll embark on a journey to build and train a neural network using PyTorch. We’ll start by preparing our data — transforming raw images into a format suitable for training our model. Then, we’ll delve into defining our neural network architecture, which will learn to recognize various clothing items based on their pixel patterns. For this project we will use FashionMNIST dataset.

FashionMNIST, is a dataset that captures grayscale images of clothing items, serves as an excellent playground for learning and mastering image classification techniques. Similar to its predecessor, MNIST (which consists of handwritten digits), FashionMNIST challenges us to distinguish between different types of apparel with the aid of deep learning models. PyTorch provides tools to download and load datasets conveniently.

As we progress, we’ll explore how to train our model using backpropagation and gradient descent, evaluate its performance on unseen data, and ensure it generalizes well to new examples.

Finally, we’ll learn how to save our trained model’s parameters, enabling us to deploy it in real-world applications or continue refining its capabilities.

I guess you are already excited, I am too.

What is a Neural Network?

A neural network is a series of interconnected nodes, inspired by the structure of the human brain. It learns by processing data and adjusting its internal connections based on the results. In this case, the neural network will learn to recognize patterns in images of clothing and predict the corresponding category (t-shirt, dress, etc.).

Throughout this tutorial, we will cover essential steps in deep learning especially for building classification neural network models. Some of the steps we will employ includes:

Data Preparation: We will download and prepare our dataset, transforming it into a format suitable for training with PyTorch.
Model Definition: We will also define a neural network architecture using PyTorch’s nn.Module that will learn to classify images into different clothing categories.
Training and Evaluation: We will then implement the training loop to optimize our model’s parameters using gradient descent, evaluate its performance on test data, and monitor its progress.
Model Persistence: you will also see how to save and load trained models, allowing you to reuse them for predictions or further training.

By the end of this journey, you will not only have a grasp of the fundamental concepts of deep learning with PyTorch but also a practical understanding of how to apply them to real-world datasets.

Let’s embark on this learning adventure together!

Dataset Preparation

The first step is to prepare our dataset. Like I initially said, we will use the FashionMNIST dataset, which is readily available in PyTorch’s torchvision library. This dataset contains 70,000 grayscale images of 10 different classes of clothing items.

We start by importing the necessary libraries:

import torch
from torch import nn
from torch.utils.data import DataLoader
from torchvision import datasets
from torchvision.transforms import ToTensor

torch: The core PyTorch library for building and training neural networks.
nn: A submodule of torch containing building blocks for neural networks like layers and activation functions.
DataLoader: A class from torch.utils.data that helps us load and iterate over datasets in batches.
datasets: A submodule of torchvision providing access to pre-downloaded datasets like Fashion MNIST.
ToTensor: A data transform that converts images to PyTorch tensors.

After we are done importing libraries, its time we download the training dataset and test data set too from the FashionMNIST plaform and also load them into our environment.

# download training data from the FashionMNISTdataset.
training_data = datasets.FashionMNIST(
    train=True,
    transform=ToTensor(),
    download=True,
    root="data"
)

# download test data from the FashionMNIST dataset.
test_data = datasets.FashionMNIST(
    train=False,
    transform=ToTensor(),
    download=True,
    root="data"
)

The above code downloads the FashionMNIST dataset. We also specify that we want the training data by setting (train=True) and test data (train=False). We also apply the ToTensor transform, which converts the raw image data (pixel intensities between 0 and 255) into PyTorch tensors.

Data Loaders

Next step is to define or dataset loaders, Data loaders will help us load the dataset in batches, making it easier to manage memory and speed up training of our model. To define our data loaders for our model, we first declare the loading batch size.

batch_size = 64

# create data loaders
training_loader = DataLoader(training_data, batch_size=batch_size)
test_loader = DataLoader(test_data, batch_size=64)

for X, y in test_loader:
  print(f"Shape of X [N C H W]: {X.shape}")
  print(f"Shape of y: {y.shape} {y.dtype}")
  break

We just define the batch size, which will help control how many images are processed at once during training. We then create data loaders for both the training and test data. Our configuration is that the data loaders will feed the data into the neural network in batches during training and evaluation.

Also we use the for loop to iterate through the batches of data and prints the shapes of the input images (X) and their corresponding labels (y). We see that X has a shape of [batch_size, channel, height, width], where batch_size is 64 in this case, channel is 1 (grayscale images), and height and width are both 28 (representing the 28x28 pixel images). The labels y are a one-dimensional tensor of integers representing the clothing categories.

Since we have defined and configured our data loaders for both the training and and testing datasets, lets then define how we mount our model unto our devices, in our case we will mount it into our CPU device.

# get cpu, gpu or mps device for training.
device = (
    "cuda"
    if torch.cuda.is_available()
    else "mps"
    if torch.backends.mps.is_available()
    else "cpu"
)
print(f"Using {device} device")

# OUTPUT

Using cpu device

Our code checks if a GPU or MPS device is available and uses that for training if possible, otherwise it defaults to CPU. Using a GPU or MPS can significantly speed up the training process considering that training large neural models requires compute power and CPU allocation.

Consequently, all things being equal, we will continue with the next step which is defining our network.

Defining the Neural Network Model

We define a simple fully connected neural network. Our model will have three layers with ReLU activations in between.

To define a neural network in PyTorch, we create a class that inherits from nn.Module. We define the layers of the network in the init function and specify how data will pass through the network in the forward function. To accelerate operations in the neural network, we move it to the GPU or MPS if available.

class NeuralNetwork(nn.Module):
    def __init__(self):
        super(NeuralNetwork, self).__init__()
        self.Flatten = nn.Flatten()
        self.linear_relu_stack = nn.Sequential(
            nn.Linear(28*28, 512),
            nn.ReLU(),
            nn.Linear(512, 512),
            nn.ReLU(),
            nn.Linear(512, 10),
        )

    def forward(self, x):
        x = self.Flatten(x)
        logits = self.linear_relu_stack(x)
        return logits

device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model = NeuralNetwork().to(device)
print(model)

# OUTPUT

NeuralNetwork(
  (Flatten): Flatten(start_dim=1, end_dim=-1)
  (linear_relu_stack): Sequential(
    (0): Linear(in_features=784, out_features=512, bias=True)
    (1): ReLU()
    (2): Linear(in_features=512, out_features=512, bias=True)
    (3): ReLU()
    (4): Linear(in_features=512, out_features=10, bias=True)
  )
)

Few things you should know about our neural network:

nn.Module: Base class for all neural network modules in PyTorch.
Flatten: Flattens the input tensor.
nn.Sequential: A sequential container to define the layers of the model.
nn.Linear: Fully connected layer.
nn.ReLU: ReLU activation function.

Now, looks like we are all set, lets move over to defining our loss function and optimizer.

Defining the Loss Function and Optimizer

The loss function measures how well the model’s predictions match the actual labels. while the optimizer updates the model parameters to minimize the loss.

To handle this, we just define the following variables

loss_fn = nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(model.parameters(), lr=1e-3, momentum=0.9)

Explaining each of the concepts, we will have that;

nn.CrossEntropyLoss: is a loss function used primarily for classification tasks where the model predicts probabilities for each class. It combines nn.LogSoftmax() and nn.NLLLoss() in one single class. The CrossEntropyLoss expects raw logits (the output of the model before applying soft max) as input. It computes the soft max internally to normalize logits and then computes the negative log likelihood loss between the predicted class probabilities and the actual target labels.

torch.optim.SGD: also is the optimizer that implements Stochastic Gradient Descent (SGD), a fundamental optimization algorithm used for training neural networks. SGD updates the model parameters in the direction of the negative gradient of the loss function with respect to the parameters. The model.parameters() argument specifies which parameters of the model should be optimized.

lr (Learning rate): which is a scalar factor that controls the step size taken during optimization. It determines how much to change the model parameters with respect to the gradient of the loss function. A higher learning rate can speed up convergence, but if it’s too high, it may cause the model to overshoot optimal values. Conversely, a lower learning rate can improve stability and precision but may require more iterations to converge.

momentum: Momentum simply is a parameter that accelerates SGD in the relevant direction and dampens oscillations. It improves the convergence rate and helps SGD to escape shallow local minima more effectively. A common value for momentum is 0.9, but it can be tuned depending on the specific problem and dataset characteristics.

In summary, these components together form the backbone of the optimization process during training. nn.CrossEntropyLoss computes the loss based on model predictions and target labels, torch.optim.SGD updates the model parameters based on the computed gradients, and lr and momentum are crucial hyperparameters that affect how quickly and effectively the model learns from the data. Adjusting these parameters can significantly impact the training process and model performance.

Defining our Training Function

The training function iterates over the data loader, computes predictions, calculates the loss, and updates the model parameters.

def train(dataloader, model, loss_fn, optimizer):
    size = len(dataloader.dataset)
    print(f"size: {size}")
    for batch, (X, y) in enumerate(dataloader):
        X = X.to(device)  # Move input data to the device (GPU or CPU)
        y = y.to(device)  # Move target labels to the device (GPU or CPU)

        # compute predicted y by passing X to the model
        prediction = model(X)

        # compute the loss
        loss = loss_fn(prediction, y)

      #  apply zero gradients, perform a backward pass, and update the weights
        optimizer.zero_grad()  
        loss.backward()  
        optimizer.step()  

        # print training progress
        if batch % 100 == 0:
            loss_value = loss.item()  
            current = batch * len(X)
            print(f"loss: {loss_value:>7f}  [{current:>5d}/{size:>5d}]")

Now, to check the model’s performance against the test dataset to ensure it is learning, lets define a test learning function

def test(dataloader, model, loss_fn):
    size = len(dataloader.dataset)
    num_batches = len(dataloader)
    model.eval()
    test_loss, correct = 0,0
    with torch.no_grad():
        for X, y in dataloader:
            X = X.to(device)
            y = y.to(device)
            prediction = model(X)
            test_loss += loss_fn(prediction, y).item()
            correct += (prediction.argmax(1) == y).type(torch.float).sum().item()
        test_loss /= num_batches
        correct /= size
    print(f"Test Error: \n Accuracy: {(100*correct):>0.1f}%, Avg loss: {test_loss:>8f} \n")

Its time we train our model, lets do that in the next step

Defining the training loop

The training process is conducted over several iterations (epochs). During each epoch, the model learns parameters to make better predictions. We print the model’s accuracy and loss at each epoch; we’d like to see the accuracy increase and the loss decrease with every epoch.

epoch = 5
for t in range(epoch):
  print(f"Epoch {t+1}\n-------------------------------")
  train(training_loader, model, loss_fn, optimizer)
  test(test_loader, model, loss_fn)
print("Done!")

# OUTPUT 

Epoch 1
-------------------------------
size: 60000
loss: 2.301722 [    0/60000]
loss: 2.196219 [ 6400/60000]
loss: 1.919408 [12800/60000]
loss: 1.602865 [19200/60000]
loss: 1.206242 [25600/60000]
loss: 1.089895 [32000/60000]
loss: 1.010409 [38400/60000]
loss: 0.888665 [44800/60000]
loss: 0.871484 [51200/60000]
loss: 0.801176 [57600/60000]
Test Error: 
 Accuracy: 70.4%, Avg loss: 0.797208 

Epoch 2
-------------------------------
size: 60000
loss: 0.793278 [    0/60000]
loss: 0.839569 [ 6400/60000]
loss: 0.590993 [12800/60000]
loss: 0.796638 [19200/60000]
loss: 0.679180 [25600/60000]
loss: 0.645485 [32000/60000]
loss: 0.705061 [38400/60000]
loss: 0.694501 [44800/60000]
loss: 0.680406 [51200/60000]
loss: 0.634787 [57600/60000]
Test Error: 
 Accuracy: 78.1%, Avg loss: 0.632338 

Epoch 3
-------------------------------
size: 60000
loss: 0.558544 [    0/60000]
loss: 0.660779 [ 6400/60000]
loss: 0.436486 [12800/60000]
loss: 0.679563 [19200/60000]
loss: 0.600478 [25600/60000]
loss: 0.567539 [32000/60000]
loss: 0.587003 [38400/60000]
loss: 0.657008 [44800/60000]
loss: 0.643853 [51200/60000]
loss: 0.547364 [57600/60000]
Test Error: 
 Accuracy: 80.3%, Avg loss: 0.560929 

Epoch 4
-------------------------------
size: 60000
loss: 0.462072 [    0/60000]
loss: 0.580780 [ 6400/60000]
loss: 0.374757 [12800/60000]
loss: 0.618166 [19200/60000]
loss: 0.552829 [25600/60000]
loss: 0.526478 [32000/60000]
loss: 0.529090 [38400/60000]
loss: 0.666382 [44800/60000]
loss: 0.634566 [51200/60000]
loss: 0.482042 [57600/60000]
Test Error: 
 Accuracy: 81.2%, Avg loss: 0.523512 

Epoch 5
-------------------------------
size: 60000
loss: 0.403316 [    0/60000]
loss: 0.539046 [ 6400/60000]
loss: 0.340361 [12800/60000]
loss: 0.577453 [19200/60000]
loss: 0.509404 [25600/60000]
loss: 0.496750 [32000/60000]
loss: 0.495348 [38400/60000]
loss: 0.670772 [44800/60000]
loss: 0.620382 [51200/60000]
loss: 0.439184 [57600/60000]
Test Error: 
 Accuracy: 82.2%, Avg loss: 0.500474 

Done!

epochs: Number of times to iterate over the entire training dataset in our case 5 times.

train(): Calls the training function.

test(): Calls the evaluation(test) function.

At this point, we already have a trained model that can perfectly predict and classify images and provide output value or expected value as the case may be.

Moving forward, next thing to consider is ways to save our trained model, so that when we want to use or deploy them for application usage, we can easily call them and provide the required classes and values.

To save our defined model, we follow the following ways;

torch.save(model.state_dict(), "model.pth")
print("Saved PyTorch Model State to model.pth")

>> # OUTPUT Saved PyTorch Model State to model.pth

This approach will save the model and and serialize the internal state dictionary (containing the model parameters).

After saving the model, if next time we want to use our model for predictions, we will first load them into our compute space. And to do that we;

model = NeuralNetwork().to(device)
model.load_state_dict(torch.load("model.pth"))

# OUTPUT <All keys matched successfully>

The above process involves loading our model which also includes re-creating the model structure and loading the state dictionary into it.

Finally, to make use of our loaded model for maybe prediction or classification.

Model Usage for prediction

classes = [
    "T-shirt/top",
    "Trouser",
    "Pullover",
    "Dress",
    "Coat",
    "Sandal",
    "Shirt",
    "Sneaker",
    "Bag",
    "Ankle boot",
]



# set model to evaluation mode
model.eval()


sample_index = 1  # sample Index (Change this index to select a different sample)
x, y = test_data[sample_index][0], test_data[sample_index][1]

# make prediction without gradient calculation
with torch.no_grad():
    x = x.to(device)
    prediction = model(x.unsqueeze(0))

    # get predicted and actual classes
    predicted, actual = classes[prediction.argmax(dim=1).item()], classes[y]

    print(f'Predicted: "{predicted}", Actual: "{actual}"')

# OUTPUT: Predicted: "Pullover", Actual: "Pullover"

Preparation and Data

classes = [
    "T-shirt/top",
    "Trouser",
    "Pullover",
    "Dress",
    "Coat",
    "Sandal",
    "Shirt",
    "Sneaker",
    "Bag",
    "Ankle boot",
]

classes: This is a list of class labels that correspond to the categories the model is trained to recognize. Each index in this list represents a specific class.

Set Model to Evaluation Mode

model.eval()

model.eval(): Sets the model to evaluation mode. This is important because some layers (e.g., dropout, batch normalization) behave differently during training and evaluation. In evaluation mode, these layers operate in inference mode, ensuring consistent results during testing.

Select a Single Test Sample

x, y = test_data[0][0], test_data[0][1]

x, y = test_data[0][0], test_data[0][1]: Selects the first sample from the test_data dataset. x is the input data (e.g., an image), and y is the corresponding label (e.g., the class index).

Make Prediction Without Gradient Calculation

with torch.no_grad():
    x = x.to(device)
    pred = model(x)

with torch.no_grad():: Disables gradient calculation, which is not needed for evaluation and reduces memory usage and computation time.

x = x.to(device): Moves the input data to the specified device (CPU or GPU) where the model is located.

pred = model(x): Passes the input data through the model to obtain the predictions. pred is typically a tensor containing the output logits or probabilities for each class.

To Determine Predicted and Actual Class Labels

predicted, actual = classes[pred[0].argmax(0)], classes[y]

pred[0].argmax(0): Finds the index of the class with the highest score in the model's output for the first (and only) sample in the batch. This index corresponds to the predicted class.

classes[pred[0].argmax(0)]: Uses the index to look up the predicted class label from the classes list.

classes[y]: Uses the true label index y to look up the actual class label from the classes list.

Print the Predicted and Actual Class Labels

print(f'Predicted: "{predicted}", Actual: "{actual}"')

Prints the predicted and actual class labels in a formatted string.

Conclusion

we walked through the entire process of building, training and evaluating a neural network using PyTorch with the FashionMNIST dataset. We covered essential concepts such as dataset preparation, defining a neural network model, setting up training and evaluation loops, saving and loading models, and making predictions.

Lastly, constant practice leads to mastery, so experiment with different models, hyperparameters, and datasets to deepen your understanding and improve your skills in deep learning and image classifications.

Till next time, but for now all I can say is, Happy coding! 🚀

Reference

What is a Neural Network? | IBM

Neural networks allow programs to recognize patterns and solve common problems in artificial intelligence, machine…*www.ibm.com

Fashion MNIST

An MNIST-like dataset of 70,000 28x28 labeled fashion images*www.kaggle.com

Quickstart - PyTorch Tutorials 2.3.0+cu121 documentation

Read the PyTorch Domains documentation to learn more about domain-specific libraries*pytorch.org

Building an Image Classification model with PyTorch from scratch

A step-by-step guide to building a CNN model with PyTorch.medium.com

Code

Machine-learning/cloth-classification-using-pytorch.ipynb at main · chibuezedev/Machine-learning

Collection of my Machine learning models. Contribute to chibuezedev/Machine-learning development by creating an account…github.com

Analogy of Hypertext-Driven RESTful APIs: Unleashing the Power of Hyperlinks

Paul Chibueze — Fri, 21 Jul 2023 07:52:07 +0000

When we think about developing RESTful APIs, one term that often comes to mind is HATEOAS (Hypermedia as the Engine of Application State). HATEOAS enables the API to guide the client’s navigation through the application by including hyperlinks in the API responses. While HATEOAS is a powerful concept, there is another approach to designing RESTful APIs that deserves attention: Hypertext-Driven APIs.

Understanding Hypertext-Driven APIs
Hypertext-Driven APIs, as the name suggests, leverage hypertext and hyperlinks to drive client interaction with the API. Unlike traditional APIs that require clients to have prior knowledge of resource URIs and actions, hypertext-driven APIs provide links within the API responses that allow clients to navigate and discover resources.

In this approach, the API acts as a sort of “hypermedia document” that not only provides data but also includes links to related resources and actions that can be performed. This empowers clients to dynamically explore the API without relying on hard-coded URLs or predefined navigation paths.

Now, before you continue reading, there are couple of things you need to have installed to get you started on testing the codes on each example.

Make sure you have Node.js & npm installed on your machine. You can download and install Node.js from the official website: https://nodejs.org or NPM from https://docs.npmjs.com/downloading-and-installing-node-js-and-npm
Create a new directory for your project.
Open a terminal or command prompt and navigate to the project directory.
Copy the code example into a new file and save it with a .js extension, for example ecommerce.js. In the terminal or command prompt, install the required dependencies by running the following command:

npm install express

Once the installation is complete, start the server by running the following command:

node ecommerce.js

You should see a message indicating that the server is running on a specific port (in this case, 3000).
Open a web browser and navigate to http://localhost:3000/products to test the product listing endpoint.

You should see a JSON response containing information about the available products.

Try accessing other endpoints such as /cart, /cart/checkout, and /cart/payment_info to test different functionalities of the e-commerce platform.

Feel free to explore the code and make modifications to suit your needs. You can add new routes, implement functionality for adding/removing items from the cart, or integrate with a database to persist data.

Please note that this is a basic example for testing purposes. In a real-world scenario, you would need to consider additional security measures, handle database operations, and handle user authentication/authorization.

Rethinking API Interaction

Imagine a RESTful API for an e-commerce platform. Traditionally, a client would need to know the specific URIs for retrieving a list of products, adding items to the shopping cart, and checking out. With a hypertext-driven API, the API response itself contains hyperlinks for these actions and more.

For example, instead of relying on a fixed URL for retrieving products, the API response may include a link with the relation type “products” that the client can follow to get the list of available products. Similarly, the response may include links to add items to the cart or proceed to the checkout.

Lets see some codes.

const express = require('express'); 
const app = express(); 
const PORT = 3000; 

app.get('/products', (req, res) => { 
const productData = [{ 
  id: '1', 
  name: 'Product 1', 
  description: 'This is product 1', 
  price: 10.99, 
  imageLink: 'https://via.placeholder.com/150', 
  addToCartLink: '/cart/add/1' }, 

{ 
  id: '2', 
  name: 'Product 2', 
  description: 'This is product 2', 
  price: 19.99, 
  imageLink: 'https://via.placeholder.com/150', 
  addToCartLink: '/cart/add/2' 
}]; 

  res.json(productData); 
}); 

app.get('/cart', (req, res) => {

const cartData = { 
  items: [ { 
  id: '1', 
  name: 'Product 1', 
  description: 'This is product 1', 
  price: 10.99, 
  quantity: 2, 
  imageLink: 'https://via.placeholder.com/150', 
  removeFromCartLink: '/cart/remove/1' } ], 
  subTotal: 21.98, 
  tax: 1.77, 
  total: 23.75, 
  checkoutLink: '/cart/checkout' 
}; 

res.json(cartData); 
}); 


app.get('/cart/checkout', (req, res) => {

const checkoutData = { 
  firstName: 'John', 
  lastName: 'Doe', 
  email: 'johndoe@example.com', 
  address: '123 Main St.',
  city: 'Anytown', 
  state: 'CA', 
  zipCode: '90210', 
  paymentInfoLink: '/cart/payment_info' 
}; 

res.json(checkoutData); 
}); 

app.get('/cart/payment_info', (req, res) => {

const paymentData = { 
  cardNumber: '**** **** **** 1234', 
  expDate: '06/25', cvv: '123', 
  paymentLink: '/cart/submit_payment' 
}; 
res.json(paymentData); 
}); 


app.post('/cart/submit_payment', (req, res) => { // handle payment submission 

res.sendStatus(200); }); 

app.listen(PORT, () => { 
console.log(`Server running on port ${PORT}`); 
});

In the above example, a GET request to /products returns information about available products, including hyperlinks for adding each product to the shopping cart. A GET request to /cartreturns cart information, including items in the cart, a sub-total, tax, and a checkout hyperlink. A GET request to /cart/checkout returns checkout information, such as billing and shipping information, and a hyperlink for entering payment information. A GET request to /cart/payment_info returns a form for entering payment information, and a hyperlink for submitting payment information.

By breaking down the overall user flow into smaller resource interactions, each with hyperlinks to related resources, this e-commerce platform can be designed to be more flexible and adaptable, allowing clients to interact with the API in a more dynamic way.

Another example, Let’s consider an API for a social networking platform. A traditional RESTful API for this platform may have endpoints for retrieving users, posts, and comments, with specific URLs and routes for each of these resources.

However, a hypertext-driven API for this platform would include hyperlinks within the responses that allow clients to navigate and interact with the API in a more dynamic way.

For instance, a response for retrieving a user may not only include the user’s profile information but also hyperlinks to the user’s posts, followers, and following list. Instead of requiring clients to know the URLs for these resources and making multiple API calls to retrieve them, clients can simply follow the hyperlinks to access additional information and resources.

Similarly, a response for retrieving a post may include hyperlinks to the post’s author, comments, and related posts. Clients can follow these links to explore the post’s context and engage with other relevant resources.

By including hyperlinks within the responses, a hypertext-driven API for a social networking platform can make the user experience more interactive and seamless. Clients can explore and interact with the API in a more natural and intuitive way, without having to rely on prior knowledge of specific URLs and APIs.

Get code this illustration:

const express = require('express'); 
const app = express();

const PORT = 3000; 

app.get('/users/:id', (req, res) => { 

  const userId = req.params.id; 

  const userData = { 
   id: userId, 
   name: 'John Doe', 
   bio: 'Software developer and music lover', 
   postsLink: `/users/${userId}/posts`, 
   followersLink: `/users/${userId}/followers`, 
   followingLink: `/users/${userId}/following` 
};
   res.json(userData); 
}); 


app.get('/users/:id/posts', (req, res) => { 

   const userId = req.params.id; 

   const postsData = [ 
{ 
   id: '1', 
   authorId: userId, 
   content: 'My first post', 
   commentsLink: `/posts/1/comments`, 
   relatedPostsLink: `/users/${userId}/related_posts` 
}, 
{ 
   id: '2', 
   authorId: userId, 
   content: 'My second post', 
   commentsLink: `/posts/2/comments`, 
   relatedPostsLink: `/users/${userId}/related_posts` 
  } 
]; 

res.json(postsData); }); // other endpoints for comments, following, related posts, etc. 


app.listen(PORT, () => { 
console.log(`Server running on port ${PORT}`); 
});

In the example above, a GET request to /users/:id returns information about a specific user, including hyperlinks for accessing their posts, followers, and following list. A GET request to /users/:id/ posts returns the user’s posts, along with hyperlinks for accessing comments and related posts.

By including hyperlinks within the responses, clients can dynamically navigate and interact with the API without having to rely on hardcoded URLs or predefined navigation paths. This simplifies client development and promotes loose coupling between the client and server components.

Benefits of Hypertext-Driven APIs

Improved Discoverability

Hypertext-driven APIs enhance discoverability by providing a roadmap for clients to explore available resources and actions. Clients no longer need to rely on API documentation or prior knowledge to navigate the API. They can simply follow links and let the API guide them.

Flexibility and Adaptability

By using hyperlinks to drive interaction, hypertext-driven APIs become more flexible and adaptable. Adding or modifying resources and actions does not require changing client code, as clients can dynamically discover and interact with new features through the hyperlinks provided in the API responses.

Loose Coupling

Hypertext-driven APIs promote loose coupling between the client and the API. The client does not need to have hardcoded knowledge of resource URLs or specific API routes. Instead, it relies on the hyperlinks provided by the API to navigate and interact. This decoupling makes the API more resilient to future changes and allows for easier evolution of both the client and server components.

Simplified Client Development

Clients interacting with hypertext-driven APIs can focus more on business logic and user experience, as they can delegate the navigation and interaction aspects to the API itself. This can streamline client development, reduce complexity, and improve maintainability.

Conclusion

While HATEOAS is a well-known approach for designing RESTful APIs, hypertext-driven APIs offer an alternative perspective that emphasizes the power of hyperlinks. By embedding hyperlinks within the API responses, these APIs enable dynamic navigation and discovery, improving discoverability, flexibility, and the overall client experience.

Hypertext-driven APIs empower clients to rely on the guidance provided by the API, reducing the need for hardcoded URLs and predefined navigation paths. This promotes loose coupling, simplifies client development, and allows for easier evolution of both the client and server components.

So, next time you design a RESTful API, consider the potential of hypertext-driven APIs and embrace the power of hyperlinks. Let your API become a hypermedia document that guides clients on their journey and unlocks a whole new level of flexibility and adaptability.

Reference:
https://restfulapi.net/hateoas/
https://roy.gbiv.com/untangled/2008/rest-apis-must-be-hypertext-driven

Follow on Twitter

How then shall a developer stay healthy and mentally fit?

Paul Chibueze — Fri, 10 Feb 2023 16:33:15 +0000

"I shall get up as early as 4:00 am, make myself a cup of tea and probably start hitting the keyboard till whenever it's time for standup or Mr. A meeting time". This is probably the most morning ritual for 80% of developers, they pay more attention to the calendar schedules and pay almost no attention to their state of health.

However, I am writing this as a developer, who was caught up by the 2020 coronavirus outbreak and was forced to adopt the newer method of this generation's working style "Remote". Before then, I've had this normal routine of almost every developer, wake up in the morning, look at my schedules for the day and probably head over to the office. While in the office it's mostly about, writing that piece of code for the next feature from my company, and meetings from the HR to the tribes. This process goes down from Monday till Friday. On Saturday I feel so weak that id off my alarm and slept till my neighbors come knocking at my door the following morning.

Moreover, this recycling life of most developers and in turn same as mine is one of the problems we have as software engineers. It might not bother you, but everything you do as a developer or a non-developer largly depends on how active you are to notice things around you.

One of the biggest factors we as developers should pay attention to is our ability to think critically in a healthy state of mind. Most times, it's not always about writing those codes but ensuring we are actually in the best state to solve those problems with our code. I will go on and list some of the things developers are expected to do to ensure the best state of the mind and increase productivity at work.

Develop that attitude of exercising at least two times a week. in as much as your activities may be always include free time to exercise and make sure you stay fit. Being physically active can improve your brain health, help manage weight, reduce the risk of disease, strengthen bones and muscles, and improve your ability to do everyday activities.

Build self-awareness and observe what's going on inside your mind. Let go of all those things that create clutter in your mind. Try to forgive people unconditionally and be free. Try to figure out your dharma.

Socialization often prepares people to participate in a social group by teaching them its norms and expectations. Socialization has three primary goals: teaching impulse control and developing a conscience, preparing people to perform certain social roles, and cultivating shared sources of meaning and value.

Take good care of your diet. A healthy diet is essential for good health and nutrition. It protects you against many chronic non-communicable diseases, such as heart disease, diabetes and cancer. Eating a variety of foods and consuming less salt, sugars and saturated and industrially-produced trans-fats, are essential for a healthy diet.

Don't forget to pay attention to your eye, protect it at all costs. I was a victim of this and I got my right eye damaged after staring for a long time at the screen without taking eye precautions. Use anti-blue light glasses and make sure you give your eye the necessary care it demands. Eat more fruits. Reduce the use of blue lights in your setup rooms and also bedrooms to make sure you give your eye the necessary relaxations it requires.

Finally, make sure you don't remain introverted, relationships are one of the most powerful feelings we have as humans. Meet with your family members and loved ones in your free time.

Now, at this point i feel like youve learnt one thing or the other to help your maintain a stable state of mind as a creative and productive developer. By paying attention to our health we tend to prevent pretigious treat to our level of productivity and help us focus more and be more productive.

Roadmap To Backend Developer in 2022.

Paul Chibueze — Sun, 10 Jul 2022 00:07:48 +0000

Backend just like the kitchen is where the whole mixing and fries are done. Our web applications are incomplete or almost nothing without the backend, it could be seen as the backbone of every web application. It serves the informations we have in our database to the users once such demand is called for. There's always the unseens part of every restaurant, where all the fries are done before it is served to the customers. When we talk about the internet , the backend is considered the kitchen.
However, it is so important to know how to start and where to start as a beginner who wishes to go into backend development. In this blog we will explore the core backend super master Roadmap covering steps on how to start and resources to refer to along your journey.

Know the Basics of Coding The most fundamental step in learning backend development is to learn to code. Learn fundamentals syntax, variables, functions, objects, data types, and execution. Some of the common programming languages used in the backend are PHP, Javascript, Python, and C#. Learning software languages will help you speed up your career in backend development.

Besides, one must learn various databases to help store data electronically. Traditionally, backend developers used either relational or NoSQL databases. NoSQL databases are document-based and have a dynamic schema, whereas SQL databases are table-based and have a fixed or predefined schema.

Relational Databases
MySQL
Oracle
PostgreSQL
NoSQL Databases
Firebase
MongoDB
Cassandra
Furthermore, students should be well-read with data structures and algorithms to ease their workflow and improve efficiency. Learning version control systems (VCS) is also essential in the basics. Version control systems such as Git, Github, and GitLab are the most commonly used solutions to assist frontend and backend developers in interactions and managing the changes made over time.

Gain Intermediate Skills Frameworks in backend development form the essential skills after the fundamentals of coding and databases. They are crucial as using frameworks allows the creation of templates and code that may be reused in the future. They minimise the amount of code one must write. Hence, programming becomes more efficient. As a result, knowing a framework is also an excellent idea.

Common frameworks used in backend development are -

Microsoft's ASP.NET is a web application platform that allows programmers to create dynamic websites. It enables you to create web applications using a full-featured programming language such as C#.
Laravel is regarded as among the best PHP frameworks developing online applications. It aids in the creation of fantastic apps by utilising creative grammar.
Rails, often known as Ruby on Rails, is a free and open-source framework built on the Ruby programming language. When using RoR, developers do not have to work on every single program in the web application development process.
Django is a set of Python libraries that allows you to rapidly and efficiently develop a high-quality web application that can be used on both the front and backend.
Node.js is a runtime environment that allows software developers to use JavaScript to launch frontend and backend web projects.

Advanced Topics The topics and tools mentioned in the advanced sections are relatively more challenging than the previous skills. Therefore, learners should focus on APIs, Security, Caching, and Testing.

APIs
An Application Programming Interface enables two apps to communicate with one another. Backend developers utilise APIs to connect various apps or services to improve user experience on the frontend. Some of the APIs to learn are -

REST
JSON
AES
GSON
SOAP
XML-RPC
Caching
It is the technique of storing a copy of a given resource in a cache (temporary storage site) and quickly providing the data when requested. Caching's primary purpose is to increase data retrieval performance while removing the need to contact the underlying storage layer, which is slow to process. Some caching tools are -

CDN
Server-Side
Redis
Client-Side
Security
Web security knowledge is crucial for backend development. You can learn some of these topics to enhance your understanding of web security:

HTTPS
SSL
CORS
Hashing Algorithms
Testing
Backend testing is the process of checking a web application's database or server end. The goal of backend testing is to evaluate the database layer's efficiency while ensuring it is free of data corruption, deadlocks, and data loss. In backend testing, commonly used testing methods are as follows. These methods are also used in other software-related careers:

Integration testing
Functional testing
Unit testing

Learn Additional Tools In addition to the different fundamental tools and advanced topics, here are some topics that add value to your knowledge of backend development.

Code Analysis Tools
Code analysis is a technique for troubleshooting and evaluating code to ensure smooth work. Some analysis tools include -

SonarLint
PMD
SonarQube
JUnit
JaCoCo
Architectural Pattern
An architectural pattern is a reusable solution to problems encountered when designing software. Among the most prevalent architectural patterns are SOA, Microservices, and CQRS.

Message Broker
A message broker is a piece of software that allows apps, systems, and services to communicate to exchange data. The primary function of a broker is to translate the server's formal message protocol into the client's formal message protocol (receiver). You should learn one of the message brokers provided and use it in different projects.

Containerization
Containerization is the process of packaging software code with all of the necessary components, such as frameworks, dependencies, and other libraries, to build isolated services in a container. A backend developer performs containerization to quickly migrate or run a container regardless of its infrastructure or environment. Some of the most commonly used containers are tools like Docker.

Web Servers
The Apache, often known as the Apache HTTP Server, is a cross-platform open-source web server. The Apache Software Foundation created it. NGINX is another open-source web server that can be used for reverse proxying, load balancing, caching, mail proxying, and other purposes.

Practicing with Real-World Applications Since all the backend development tools have different use cases and requirements, an aspiring backend developer needs to know which tool can help them in a particular requirement.

Hence, practicing is an important step. Look for small projects and tasks on how to learn backend development. These projects can help in understanding the different tools better. Making a simple application like business websites, blogs, etc., can help you practice what you learned practically.

Creating a Clone This is an advanced step that will test all your skills in backend development. The idea behind creating a clone is to create a copy of an existing startup or a business using backend development.

Since these businesses have different complexities involved in their products, it will be a good way to expand your knowledge horizon. It will also help you ideate your online products, which is the best way to showcase your skills.

Conclusion
Backend development is a lucrative option in the IT space, opening good career options. There are also a lot of advancements in this field; hence, it is ever-growing with a lot of new things to keep up with each year.

For more reference about how to get started as a backend developer visit Roadmap.sh