DEV Community

Arthur
Arthur

Posted on

How to Run GPU-Accelerated Python Applications with PyTorch

Hello, I'm Arthur! I enjoy exploring programming, AI technologies, server infrastructure, and practical solutions that help developers build better applications.

Machine learning applications can require significant computing power, especially when working with large datasets and deep learning models.

Python provides several libraries for machine learning, and PyTorch is one of the most popular choices for building and training neural networks.

In this tutorial, we'll explore how to check GPU availability and run a simple GPU-accelerated operation using Python and PyTorch.

1. What Is GPU Acceleration?

A CPU is designed to handle different types of general-purpose tasks. A GPU, however, can perform many mathematical operations in parallel.

This makes GPUs particularly useful for:

  • Deep learning model training
  • Image processing
  • Large-scale matrix operations
  • Natural language processing
  • AI inference workloads

For developers working with demanding machine learning projects, HelloServer GPU Dedicated Servers provide an option to explore dedicated GPU infrastructure for these workloads.

2. Install Python and PyTorch

First, create a new project:

mkdir pytorch-gpu-project
cd pytorch-gpu-project

python -m venv venv
Enter fullscreen mode Exit fullscreen mode

Activate the virtual environment:

# Windows
venv\Scripts\activate

# Linux
source venv/bin/activate
Enter fullscreen mode Exit fullscreen mode

Install PyTorch using the official installation selector to choose a compatible CPU or CUDA build:

https://pytorch.org/get-started/locally/

3. Check GPU Availability

Before running machine learning operations, check whether PyTorch can detect an NVIDIA GPU.

Create a file named main.py:

import torch

print("PyTorch version:", torch.__version__)

if torch.cuda.is_available():
    print("GPU detected:", torch.cuda.get_device_name(0))
    print("CUDA is available")
else:
    print("No CUDA-enabled GPU detected")
Enter fullscreen mode Exit fullscreen mode

Run the script:

python main.py
Enter fullscreen mode Exit fullscreen mode

If your system has a compatible NVIDIA GPU and CUDA-enabled PyTorch installation, it should display the GPU name.

4. Run Matrix Multiplication on GPU

Matrix multiplication is a common operation in machine learning.

Let's create two random matrices and multiply them using the GPU.

import torch

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

matrix_a = torch.randn(1000, 1000, device=device)
matrix_b = torch.randn(1000, 1000, device=device)

result = torch.matmul(matrix_a, matrix_b)

if device.type == "cuda":
    torch.cuda.synchronize()

print("Device:", device)
print("Result shape:", result.shape)
Enter fullscreen mode Exit fullscreen mode

This example automatically uses CUDA when a compatible GPU is available. Otherwise, it falls back to the CPU.

5. Measure Execution Time

You can compare CPU and GPU execution times to understand how different hardware handles the same operation.

import torch
import time

size = 2000

a = torch.randn(size, size)
b = torch.randn(size, size)

start = time.perf_counter()
cpu_result = torch.matmul(a, b)
cpu_time = time.perf_counter() - start

if torch.cuda.is_available():
    a_gpu = a.cuda()
    b_gpu = b.cuda()

    torch.cuda.synchronize()
    start = time.perf_counter()

    gpu_result = torch.matmul(a_gpu, b_gpu)

    torch.cuda.synchronize()
    gpu_time = time.perf_counter() - start

    print("CPU time:", cpu_time)
    print("GPU time:", gpu_time)
else:
    print("CUDA GPU is not available")
Enter fullscreen mode Exit fullscreen mode

Actual results depend on GPU architecture, CPU performance, memory, and workload size. Small operations may not benefit from GPU acceleration because transferring data also takes time.

6. Monitor GPU Usage

While running machine learning applications, monitoring GPU resources can help identify performance problems.

For NVIDIA GPUs, use:

nvidia-smi
Enter fullscreen mode Exit fullscreen mode

This command displays information such as:

  • GPU utilization
  • Memory usage
  • Temperature
  • Running GPU processes
  • Power consumption

You can also monitor GPU activity continuously:

watch -n 1 nvidia-smi
Enter fullscreen mode Exit fullscreen mode

This is useful when testing model training or inference workloads on a Linux server.

7. Choosing the Right Server for Your Project

Not every application requires a dedicated GPU. The right infrastructure depends on what your application actually does.

For machine learning, deep learning, and AI workloads, GPU resources and VRAM are important considerations.

For developers working with these workloads, HelloServer GPU Dedicated Server Hosting is an option to explore when evaluating dedicated GPU computing resources.

On the other hand, smaller applications, API testing, development environments, and lightweight backend services may work perfectly well on a VPS.

Developers can also explore HelloServer VPS Hosting for virtual server resources suited to general development and hosting tasks.

Choosing the right server from the beginning can help avoid unnecessary infrastructure costs.

Final Thoughts

GPU acceleration can improve certain machine learning workloads when the application and hardware are configured correctly.

With Python and PyTorch, developers can easily check GPU availability, perform matrix operations, and monitor resource usage.

Start with small experiments, understand how CUDA works, and gradually move toward more advanced machine learning projects.

Understanding both software optimization and hardware requirements is an important step toward building efficient AI applications.

Top comments (0)