Forem: Matteo

[Boost]

Matteo — Fri, 29 Aug 2025 15:32:12 +0000

Matteo

Aug 29 '25

Making scientific python blazingly fast with PyTorch

#gpu #python #performance #programming

Comments 1

3 min read

Making scientific python blazingly fast with PyTorch

Matteo — Fri, 29 Aug 2025 13:42:22 +0000

If you’ve ever written scientific code in Python, you know the stack Numpy + Scipy, a lot of people say it is fast, but to me not fast enough. In my recent paper TorchFX: A Modern Approach to Audio DSP with PyTorch and GPU Acceleration (DAFx25), I explored a solution to this long-standing problem.

The idea is simple yet powerful: instead of relying on the traditional NumPy + SciPy stack, we can swap them out for PyTorch, instantly gaining GPU acceleration, an object-oriented API, and direct compatibility with AI workflows.

The slow python problem

Python itself is notoriously slow for heavy computations. The interpreter adds overhead, and loops kill performance. That’s why scientific programming in Python always starts with NumPy and SciPy, which wrap C and Fortran under the hood. But even then, scaling to large matrices multiplication (as it happens in multichannel audio) is a challenge.

Already used solutions (and their limitations)

Over the years, developers have tried different hacks to speed up Python:

Vectorization with NumPy – great, but requires reshaping your code.
Cython – lets you drop into C, but you need to rewrite parts of your program.
Numba – JIT compilation is cool, but not everything is parallelizable, and libraries like SciPy aren’t fully supported.

All of these approaches share one problem: you must refactor your code in sometimes not so elegant ways, and you’re still limited by CPU-based execution (actually numba supports also a simple @cuda.jit decorator to run code on an NVIDIA GPU, but even there you often need to add types as in cython and know about cuda kernels).

PyTorch to the rescue

This is where PyTorch comes in. Originally built for AI, PyTorch provides:

Tensors that work like NumPy arrays, but with GPU acceleration.
An object-oriented API, more structured than SciPy’s MATLAB-inspired procedural style.
Direct integration with AI models—any function you write, if you extend the class nn.Module, can be dropped into a neural network.

In our paper, we introduce TorchFX, a new library built on top of PyTorch, designed specifically for audio DSP. With TorchFX, you can:

Apply digital filters and many DSP effects using GPU acceleration.
Work naturally with multichannel audio.
Build filter chains with an intuitive pipe operator (|), making code both clean and fast (similarly to what happens in langchain).

And the performance? In our benchmarks, TorchFX crushed SciPy when dealing with multi-channel or long-duration signals. While SciPy slows down linearly with more channels, TorchFX (especially on GPU) keeps execution times almost flat—even for huge datasets.

Conclusions

Python’s slowness has always been the elephant in the room for scientific computing. While solutions like Numba and Cython help, they demand compromises. Our proposal is simple: if you’re starting from NumPy and SciPy, switch to PyTorch.

With TorchFX, we show how this shift can significantly speed up scientific Python for audio DSP:

Cleaner, object-oriented code
Built-in AI compatibility
GPU acceleration out of the box

The result? Your code will run blazingly fast.

TorchFX is open-source and available here: https://github.com/matteospanio/torchfx

Avoid the Chaos: How to Properly Manage Python Packages with Virtual Environments

Matteo — Sun, 30 Jun 2024 09:23:22 +0000

Managing environments

In embarking on projects, I've learned the hard way that starting without the right tools can lead to wasted time and frustration. This has been evident in my tendency to recklessly install packages, turning my system's Python environment into a chaotic mess. Despite the availability of better alternatives, I've also stuck with the default Python shell. Investing upfront time and effort to avoid these pitfalls can greatly benefit your journey as a Python enthusiast.

While most programming languages provide a standard library with diverse functionalities, managing additional libraries can be challenging. It's crucial to effectively utilize the standard library, which includes features like file handling, string manipulation, and date/time management. However, to fully leverage Python's capabilities, additional libraries are often required. Python's vibrant developer community produces a plethora of third-party packages, allowing for quick and easy installation. Yet, it's essential to exercise caution and avoid the temptation to install every intriguing package, as it can lead to a chaotic environment where nothing functions properly.

With this understanding, let's delve into pip, the default package manager tool that accompanies Python installation.

pip and virtual environments

pip is Python's package manager. Its name is a recursive acronym that stands for Pip Installs Packages. pip is a powerful tool that allows you to install, upgrade, and remove additional libraries, and it is included in Python installation starting from version 3.4.

Legacy Python

If you are using an older version of Python, you can install pip manually. To do so, simply download the get-pip.py file from the official Python website at https://bootstrap.pypa.io/get-pip.py and run it with Python.

Installing packages

To install a Python package using pip, simply use the install command followed by the name of the package. For example, to install the requests package, which is commonly used for making HTTP requests, you would type:

pip install requests

pip will then download and install the requests package and any dependencies it requires.

Now that you have installed requests, you can use it in your Python code by importing it as usual:

import requests

response = requests.get('https://www.example.com')
print(response.text)

To uninstall a package that you no longer need, you can use the uninstall command followed by the name of the package. For example, to uninstall the requests package, you would type:

pip uninstall requests

As you can see, pip is a simple and straightforward tool for managing Python packages. However, it has one major limitation: it installs packages globally, which can lead to conflicts between different projects that require different versions of the same package.

To avoid these conflicts, it is best to use virtual environments. A virtual environment is an isolated environment that contains its own Python interpreter and its own set of installed packages. This allows you to work on multiple projects with different dependencies without worrying about conflicts. Python provides a built-in module called venv that allows you to create and manage virtual environments. To create a new virtual environment, you can use the following command:

python -m venv myenv

This will create a new directory called myenv that contains a copy of the Python interpreter and a copy of the pip package manager.
Let's look in detail at the folder structure of the virtual environment with the shell utility tree:

$ tree -L 4 myenv

myenv
├── bin
│   ├── activate
│   ├── activate.csh
│   ├── activate.fish
│   ├── Activate.ps1
│   ├── pip
│   ├── pip3
│   ├── pip3.10
│   ├── python -> python3
│   ├── python3 -> /usr/bin/python3
│   └── python3.10 -> python3
├── include
├── lib
│   └── python3.10
│       └── site-packages
│           ├── _distutils_hack
│           ├── distutils-precedence.pth
│           ├── pip
│           ├── pip-22.0.2.dist-info
│           ├── pkg_resources
│           ├── setuptools
│           └── setuptools-59.6.0.dist-info
├── lib64 -> lib
└── pyvenv.cfg

As you can see the bin directory contains the activate script that allows you to activate the virtual environment. The lib directory contains the installed packages, and the include directory contains the header files needed to compile C extensions. The pyvenv.cfg file contains the configuration of the virtual environment.

To activate the virtual environment, you can use the following command:

source myenv/bin/activate

This will activate the virtual environment, and you will see the name of the virtual environment in your shell prompt.

TIP

On Windows, the command to activate the virtual environment is slightly different:
myenv\Scripts\activate

Once the virtual environment is activated, any packages you install using pip will be installed in the virtual environment rather than globally. This allows you to work on your project without worrying about conflicts with other projects.

For example, to install the requests package in the virtual environment, you would type:

pip install requests

but this time the package will be installed in the myenv directory rather than globally. In fact if you look at the lib directory of the virtual environment you will see the installed packages:

$ tree -L 1 myenv/lib/python3.10/site-packages

myenv/lib/python3.10/site-packages
├── certifi
├── certifi-2024.6.2.dist-info
├── charset_normalizer
├── charset_normalizer-3.3.2.dist-info
├── _distutils_hack
├── distutils-precedence.pth
├── idna
├── idna-3.7.dist-info
├── pip
├── pip-22.0.2.dist-info
├── pkg_resources
├── requests
├── requests-2.32.3.dist-info
├── setuptools
├── setuptools-59.6.0.dist-info
├── urllib3
└── urllib3-2.2.2.dist-info

When you are finished working on your project, you can deactivate the virtual environment using the following command:

deactivate

This will return you to the global Python environment.

Managing requirements

When working on a project, it is common to have a list of required packages that need to be installed. This list is often stored in a file called requirements.txt, which can be used to install all the required packages at once. To create a requirements.txt file, you can use the following command:

pip freeze > requirements.txt

This will create a requirements.txt file that contains a list of all the packages installed in the current environment. To install the packages listed in a requirements.txt file, you can use the following command:

pip install -r requirements.txt

This will install all the packages listed in the requirements.txt file.

pipx

Sometimes, you may want to install a Python application that is not a library, but a standalone program. In this case, you can use pipx. pipx is a tool that allows you to install and manage Python applications in an isolated environment. This means that when you install an application with pipx, it is not installed in the system, but in a dedicated virtual environment. This allows you to avoid conflicts between different versions of libraries and keep your system clean.

pipx install <package_name>

To uninstall a package installed with pipx, you can use the following command:

pipx uninstall <package_name>

It is important to note that pipx is not a replacement for pip. It is a complementary tool that is used specifically for installing and managing Python applications. If you want to install a library, you should use pip instead. pipx is particularly useful for installing command-line tools that are written in Python, such as black, flake8, isort, and many others that you will likely to use transversally in your projects.

conda

conda is an open-source package management system and environment management system that runs on Windows, macOS, and Linux. It is a powerful tool that allows you to create and manage virtual environments, install and update packages, and manage dependencies. conda is particularly popular in the scientific computing community, as it provides access to a wide range of scientific computing libraries and tools. I suggest to have a look at the official documentation at https://docs.conda.io/en/latest/ to get started with conda. An important thing to note is that conda has its own way to install packages through the conda install command, which is different from pip. This is because conda manages its own package repositories, which are separate from the Python Package Index (PyPI). This means that some packages may be available on conda but not on PyPI, and vice versa, anyway conda can install packages from PyPI as well using the pip package manager.

conda solves the virtual environment problem its own way, it lets you create and activate virtual environments creating them for you. When you install conda for the first time it comes with a default virtual environment called base. As stated before a good practice is to create a virtual environment for each project, anyway the conda design encourages you to reuse a virtual environment. For example, you can create a virtual environment called torch and install the torch package in it, then you can create another virtual environment called tensorflow and install the tensorflow package in it. This way you can switch between the two environments when you need to work on a project that requires torch or tensorflow. This is a different approach from venv where you create a new virtual environment for each project. If you find yourself working on multiple projects that require the same set of packages, conda can be a good choice for you.

poetry & friends

poetry is a tool for dependency management and packaging in Python. It allows you to declare the libraries your project depends on and it will manage (install/update) them for you. It also allows you to specify the Python version and the Python interpreter to use. poetry is particularly popular in the data science community, as it provides a simple and powerful way to manage dependencies and package your projects. This tool is really similar to npm in the JavaScript world, or cargo in the Rust world, and it is a great way to manage your Python projects. You can find more information about poetry at https://python-poetry.org/.

One of the most interesting features of poetry, in my opinion, is the fact that you are enforced to organize your project in a specific way. This is because poetry expects your project to have a specific structure, with a pyproject.toml file that contains the project's metadata and dependencies. This makes it easier to manage your project and share it with others, as they will know exactly where to find the project's dependencies and how to install them.

poetry is not the only tool in this category. Other popular tools include pipenv and pip-tools. Each of these tools has its own strengths and weaknesses, and the best tool for you will depend on your specific needs and preferences.

Python's Static Typing Safari: In Search of Code Clarity

Matteo — Sun, 12 Nov 2023 12:12:37 +0000

Introduction

In the vast landscape of programming languages, Python stands out as a dynamically typed language, celebrated for its readability and simplicity. Its syntax, clear and concise, makes it an ideal choice for scripting and automating processes with just a few lines of code. However, as projects grow in complexity and involve multiple contributors, the need for a more robust syntax becomes evident.

In this exploration, we dive into the realm of Python's static typing, unraveling its nuances and unveiling the tools at our disposal. Beyond the simplicity of dynamically typed languages, Python provides features like type annotations, function overloading, and generics, offering developers a sophisticated toolkit for crafting elegant and maintainable code.

Let's embark on a journey through the evolution of a simple addition function, uncovering the power of type annotations, the resurgence of overloading, and the elegance introduced by generics in Python. Join us as we navigate the intricacies of Python's static typing, discovering how it transforms code clarity and enhances the development experience.

Bug alert!

Consider the following lines of code:

def mysum(a, b):
    return a + b

This function sums two elements. In this case, it might seem reasonable to leave it as it is, as you get function overloading for free on types:

mysum(1, 2)      # a: int,   b: int   -> int
mysum(0.5, 1.2)  # a: float, b: float -> float
mysum(1, 0.6)    # a: int,   b: float -> float
mysum(7, 4+2.3j) # a: int, b: complex -> complex

All the calls to the mysum function are correct, and each time Python is able to infer the correct return type. Similarly, these function calls are valid and correct:

mysum([1, 2, 3], [4, 5, 6])
mysum("foo", "bar")

However, what happens when you start calling the function with mixed arguments?

mysum(1, "foo")
mysum({"a": 2}, [1, 4, 7])
mysum(5, None)

These lines are legitimate Python, yet most text editors won't complain. However, once the script executes, the Python interpreter crashes against these type mismatches:

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 2, in mysum
TypeError: unsupported operand type(s) for +: 'int' and 'NoneType'

Type annotations

TypeError! How is this possible?! Who dared to tell the interpreter to check types? Even though the use of types in Python is mostly transparent, it doesn't mean they don't exist. Therefore, annotating types in Python can be a good idea to save hours of debugging. Consider the following:

def mysum_number(
    a: int | float | complex,
    b: int | float | complex,
) -> int | float | complex:
    return a + b

def mysum_list(a: list, b: list) -> list:
    return a + b

def mysum_str(a: str, b: str) -> str:
    return a + b

Let's break down the code above. The first function, mysum_number, accepts two arguments of type int, float, or complex and returns a value of the same type. The second function, mysum_list, accepts two arguments of type list and returns a value of the same type. The third function, mysum_str, accepts two arguments of type str and returns a value of the same type.

Now, every time you want to add two elements, knowing their type is enough to decide which function to call. However, this precision sacrifices overloading. To call all functions in the same way, indicating the desire for an overload, the standard library typing contains the overload decorator. The refactored code looks like this:

from typing import overload

@overload
def mysum(
    a: int | float | complex,
    b: int | float | complex
) -> int | float | complex:
    ...

@overload
def mysum(a: list, b: list) -> list:
    ...

@overload
def mysum(a: str, b: str) -> str:
    ...

def mysum(a, b):
    return a + b

Overloading is back. Now, the function calls seen earlier all work, and those that used to generate a TypeError at runtime are now highlighted in red by our IDE.

Note: The three dots ... have a special meaning in Python; it is the symbol known as an ellipsis. This symbol is usually used as a placeholder, but its meaning can vary slightly depending on the context. I recommend checking the documentation if you are curious and want to understand more about it.

Generics

We could consider ourselves satisfied like this, but the typing module offers many other features. Among these, the use of Generics stands out, which in this case can be exploited to create a more elegant solution:

from typing import TypeVar

T = TypeVar("T", int, float, complex, str, list)

def mysum(a: T, b: T) -> T:
    return a + b

TypeVar allows you to define a type that varies depending on the context, but once it is determined, it cannot change:

mysum(1, 2)     # T = int
mysum(5, 0.7)   # T = float
mysum("a", "b") # T = str

Since Python 3.12 the T typevar declaration can be omitted¹, and the type can be directly specified in the function definition:

def mysum[T: (int, float, complex, str, list)](a: T, b: T) -> T:
    return a + b

Note: Along with T some constraints have been added, which are the types that T can assume. In this case, T can be int, float, complex, str, or list. That's because the + operator is defined for these types and not for others.

Sum up

In this exploration of Python's static typing, we delved into crucial concepts that enhance code clarity and maintainability. Let's recap the key takeaways:

Clear Syntax for All Sizes: Python's dynamic typing shines in small scripts, offering a clear and concise syntax. However, as projects grow, the need for a more expressive syntax becomes apparent.
Navigating Overloading: The journey from a dynamically typed function to an overloaded one, thanks to the typing module's overload decorator, showcases Python's adaptability to diverse project requirements.
Type Annotations as Guides: Embracing type annotations is akin to providing a map for your code. Explicitly specifying types not only aids in debugging but also serves as documentation, making your code more understandable and maintainable.
Generics: The Elegance Factor: The introduction of generics via TypeVar elevates Python's static typing to new heights. With constraints on acceptable types, developers can craft more elegant and type-safe solutions.
Evolution of Python's Typing Tools: From annotations to overloading and generics, Python's typing tools evolve to cater to various development scenarios, offering a versatile toolkit for developers.

As you navigate your coding endeavors, remember that Python's static typing is not about rigid constraints but about providing developers with powerful tools to enhance their code's expressiveness and robustness. Embrace these tools judiciously, and may your coding journey be both clear and elegant.

PEP 695 -- Type Parameter Syntax ↩