Programming on Matias Di Bernardo

Acoustic modal response optimization for small rooms with genetic algorithms

Thu, 26 Jun 2025 00:00:00 +0000

This work was developed in the context of the course Instruments and Acoustic Measurements at UNTREF Argentina.

Introduction

Control rooms and critical listening environments often suffer from uneven low-frequency acoustic responses. These irregularities, caused by a clustered distribution of vibrational modes, produce “colorations” that hamper accurate sound evaluation. Traditionally, criteria such as those by Bonello, Bolt and Louden have been used to optimize the geometry of rectangular rooms and improve modal distribution. However, these methodologies do not consider the influence of complex boundaries nor the positions of source and listener.

This work presents an open-source tool developed in Python/FEniCS that addresses these limitations. The software uses geometric optimization by brute force over finite element models (FEM) to find room dimensions and contours that provide a more uniform modal distribution.

Theoretical Framework and Classical Criteria

Low-frequency behavior in an enclosure is dominated by standing waves, or normal modes, which are characterized by pressure nodes and antinodes. Axial, tangential and oblique modes — whose frequencies depend on the room dimensions — can produce coloration problems when they cluster.

Classical design criteria, such as those of Bolt, Bonello and Louden, focus on avoiding modal clustering and propose optimal geometric ratios for rectangular rooms. However, these approaches have a major limitation: they do not consider crucial factors such as the position of the sound source and the receiver, and they are restricted to simple geometries.

Methodology and Software Development

The developed tool combines a two-stage optimization process.

Initial Search: First, the software performs a rapid search on rectangular parallelepipeds using the classical modal superposition (MS) method to identify the most promising initial geometric proportions.
Refinement and Optimization: Then, it refines the search by generating random planar contours with enforced symmetry and applies the Frequency-Domain Finite Element Method (FD-FEM) to evaluate the acoustic merit of complex geometries. This method is more accurate than modal superposition for non-rectangular geometries.

To quantify acoustic performance, a combined figure of merit is used: the Mean Sound Field Deviation (MSFD). This metric integrates two key parameters:

Magnitude Deviation (MD): Measures how flat the frequency response is at a specific position.
Spatial Deviation (SD): Measures the variation of magnitude across the listening area.

The tool includes a graphical user interface (GUI) in PyQt5 that allows the user to define dimensions, margins, and source/receiver positions, and to visualize results and optimized geometries.

Results and Conclusions

Case studies on three reference control-room volumes showed MSFD improvements of up to 5 dB compared to the baseline design. The results demonstrate that:

Impact of Margins: As the available design space for optimization increases, better results are obtained, improving the overall response by up to 3 dB. This improvement is observed mainly in the Magnitude Deviation (MD).

Complex Geometries: Increasing the number of walls in a complex geometry produces solutions superior to simple rectangular parallelepipeds, with a mean difference of 1.3 dB in the merit factor. The optimization process does not yield a single solution but a variety of geometries that present a minimum MSFD.

Comparison with Traditional Criteria: A complex optimized geometry outperformed rooms dimensioned according to classic criteria by Bolt, Louden and Cox. Although these criteria are effective and computationally free, the software’s ability to model complex geometries and consider the locations of sources and receivers provides a superior condition.

The study concludes that the software is an effective tool for modal acoustic optimization. Future improvements are suggested, such as implementing more advanced optimization algorithms — for example, genetic algorithms — to reduce computation time and increase process efficiency.

A detailed analysis of the development of this algorithm is available in the following paper.

Automatic Workout Routine Generator

Wed, 17 Apr 2024 00:00:00 +0000

Automatic Workout Routine Generator

This project was the final project asignment for the Algoritmos y Programación II on UNTREF. The idea of the application is to function as a smart workout planification, where the user input certain criterias and the program establish the best workout routine to maximice the users preference. The program was written in the Go programming language.

Data Management

This course does not focues on databases, so we choose to use a CSV to simulate a database. This file contains all the information of the different routines and the differente attributes. This serve as a presistency file wheras all the logic is handle by the program.

Different exercises are categorized by tematics. There are two entities on the program that are represented as structs in Go, this are the Exercise and the Routines.

Exercise

All the exercises have the following attributes:

Name: Name of the exercise.
Description: Detailed description of the exercise.
Duration: Estimated duration of the exercise.
Calories: Number of calories burned during the exercise.
Type: Type of exercise (e.g., cardio, strength, flexibility).
Muscle Group: Muscle group targeted by the exercise.
Points: Points assigned to the exercise for each of its types.
Difficulty: Difficulty level of the exercise.

Routines

All the routines are a collection of exercises. This are paresed as a linked list of exercise. Aside from this, the routins have the following attributes:

Name: Name of the routine.
Exercises: String that stores the IDs of the exercises in the routine, separated by commas.
AvailableExercises: Linked list of the exercises available for creating the routine.

Algorithm

The idea is to maximice different parameters, for example, maximum calories burnt in the least ammount of time, or the minimum duration for this muscle group or type of exercise. To find the best solutions based on the existing data we propose a dynamic programming algorithm that searches for all the posiblities from the data and find the maximum or minimum according to the specifications of the user. The DP apprach uses memory to avoid recalculation combinantions that already were computed, with this optimization the algorithm is fast enough that can generate the routines in miliseconds (with the test dataset under evaluation).

User Interface

At the moment, the programm is designed to be used form the terminal as a CLI application. The user can crear an exersice and a rutine, list the avaliable optionas, and generate a custom routine base on the specifications that he choose.

This is the first iteration of the project and it is fully functional but we plan to create a custom GUI to be user friendly, but for this proposse it will be better to use a different framework and use this GO application as the backend for a web or app service.

Conclusions

With this project I solidify my knowledege on programming topics like data structurs and algorithms because we used the theory seen in class and applied it to a real case scenario. Also it help me to get used to the Go langeage and it became a leangauge that I really enjoy coding on it. The code for this project is avaliable on this repository.

Z-Plane Visualizer

Sat, 12 Aug 2023 00:00:00 +0000

On the Procesamiento Digital de Señales (Digital Signal Processing) course at UNTREF, we explore the Z-Plane for filtering design with discrete variables. During the class, the professor introduced a tool built in MATLAB that visualizes the magnitude and phase plots in relation to the positions of zeros and poles on the Z-Plane. Inspired by this, I decided to recreate this tool in Python.

Leveraging my experience with the PyGame library, I was able to build a real-time application that allows for the movement of poles and zeros, enabling users to see how the transfer function changes in real time.

How It Works

First, I map the pixel positions on the Z-Plane to coordinates according to the unit circle representation. Then, I construct the transfer function, where each zero $z_{n}$ is a term in the numerator, and each pole $z_{i}$ is a term in the denominator. With the transfer function $H(z)$, I can plot both the magnitude and phase plots, which are also mappings from the normalized response into a space within the app.

$$ H(z) = \frac{\sum_{n=0}^{N} (z - z_{n})}{\sum_{i=0}^{N} (z - z_{i})} $$

Each frame recalculates the transfer function. The program performs efficiently because I store the zeros and poles in arrays, enabling faster computations with the help of numpy, which is already highly optimized. This allows real-time visualizations of the changes and provides a more intuitive understanding of the behavior of the Z-Plane. The following code snippet shows how the transfer function is computed using complex exponentials:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


def e(w, root):
 return (np.exp(1j*w) - root)

def transfer_function(zeros, poles):
 w = np.linspace(-np.pi, np.pi, RES)

 for zero in zeros:
 num = e(w, zero)

 for pole in poles:
 den = e(w, pole)

 H_z = num/den

 mag = np.abs(H_z)
 ang = np.angle(H_z)

 return mag, ang

This project is designed as educational material, providing students with a practical tool to better understand the interactions between poles and zeros in the Z-Plane. It is not intended as a professional filter design tool.

Functionality

The application has the following functionality:

Display and move poles/zeros: The user can select and choose the position of zero or pole in the Z plane. With the symmetry option active, all the poles and zeros selected or moved are attached to their symmetric par with respect to the imaginary axes.
Order: The order of the poles/zeros can be modified with the mouse wheel up to increse or down to decrease. It supports up to order 4. The color of the zero/pole change with the order.
Information: Holding the cursor over a pole or zero displays information about the position, symmetry and order.
Zoom: With the plus and minus symbols, the user can zoom in and out of the Z plane.
Delete: The trash bin symbol clears all the poles and zeros from the plane, and the user can also delete specific poles or zeros by pressing right click on them.
Magnitude Graph: The magnitude spectrum displayed in the app is normalized. This decision helps to keep the focus on the shape of the magnitude and it makes sure that the graph is visually meaningful for the user. The downside is that the difference in peak values is not captured.
Phase Graph: The phase is displayed unwrapped between $-\pi$ and $\pi$.

Demo

Here is a quick demo of the app in action:

The source code for this project can be found on this repo.

AI learns to play 2048 game

Fri, 17 Feb 2023 00:00:00 +0000

I used this project as an introduction to Reinforcement Learning. Having mostly worked with supervised and unsupervised learning, I wanted to start with a small, simple project to quickly grasp the main ideas and create something fun. I followed this YouTube video as a reference, which explains how to use Reinforcement Learning (RL) to train a model capable of playing the snake game. To make it more challenging, I applied the same network to the 2048 game.

Code

The code has three main components:

The Game: Implements the game logic and the graphical user interface (GUI).
Agent: Controls the gameplay.
AI Model: A neural network that learns how to play and guides the agent.

Game State

I modeled the game state as a 4x4 matrix representing the board. The actions in the game are represented by a vector, with the following possibilities:

Left: [1, 0, 0, 0]
Right: [0, 1, 0, 0]
Up: [0, 0, 1, 0]
Down: [0, 0, 0, 1]

Reward

The RL model works with rewards to quantify when the agent performs well or poorly. Initially, I defined the following rewards:

+10 points: When the agent doubles the points. This is crucial because, in 2048, points increase exponentially.
-10 points: When the game is lost. This serves as a straightforward negative reward.

Initially, the model showed slow improvement. To address this, I added an additional reward:

+2 points: When points are increased. This reward incentivizes actions that maximize board clearance and progress.

How the Model Works

The model is a simple linear neural network. It takes the game state as input and predicts the best next action to maximize the reward.

Rewards are managed using a technique called Q-Learning. A Q Value represents the quality of a decision based on the loss function. The loss function is derived from the Bellman Equation:

$$ NewQ(s, a) = Q(s, a) + \alpha [R(s, a) + \lambda \, \text{max}Q'(s', a') - Q(s, a)] $$

Where:

$Q(s, a)$: The Q Value for a specific state and action.
$\alpha$: Learning rate.
$R(s, a)$: Reward for a specific state and action.
$\lambda$: Discount rate.
$\text{max}Q’(s’, a’)$: Maximum expected future reward.

Experiments and Results

Random Test as a Baseline

To establish a baseline, I tested the average score achievable by taking random actions. After 1,000 iterations, the average score was 170, far below the 2048 points needed to win the game.

Initial Results

My initial attempts were discouraging. The model performed worse than random movements. Here are some early results:

Game 1,000 | Score: 208 | Record: 416 | Mean Score: 200 | Reward: 640
Game 1,000 | Score: 116 | Record: 346 | Mean Score: 161 | Reward: 310
Game 1,000 | Score: 112 | Record: 348 | Mean Score: 146 | Reward: 320

In these attempts, the agent developed a suboptimal strategy of filling the board before increasing points.

Improvements

After experimenting with the reward parameters, I focused on the exploration phase. Initially, the exploration games parameter, which randomly picks moves, was set to 25 games. Increasing this parameter allowed the agent to explore more strategies, leading to better results:

Game 1,000 | Score: 478 | Record: 478 | Mean Score: 230
Game 1,000 | Score: 514 | Record: 964 | Mean Score: 382

As the model improved, I extended the training to more games:

Game 3,796 | Score: 770 | Record: 1,366 | Mean Score: 469
Game 4,852 | Score: 631 | Record: 1,462 | Mean Score: 483

Finally, with 200 exploration games and 5,000 training games, the results were as follows:

Game 5,000 | Score: 840 | Record: 1,678 | Mean Score: 512

Although the model didn’t beat the game, I was satisfied with the progress. I believe that with longer training (the final run lasted 4 hours) and additional network layers, it would be possible to win the game using this architecture.

Demo

Here is a demo of the application, showcasing the agent’s learning process:

I implemented keybindings to control the game’s speed, providing three options:

Fast: For rapid training.
Slow: To observe and analyze the agent’s progress and mistakes.
Medium: Rarely used.

The complete code for this project is available in this repository.

Time Scale Modification Algorithms

Sat, 11 Feb 2023 00:00:00 +0000

Time scale modifications algorithms are used to speed up or slow down the reproduction velocity of an audio. When you change the sample rate of an audio, the velocity changes but it also changes the pitch (when the audio is speed up it sounds highier pitch). There are different algorithms that change the velocity of the audio but mantain the pitch.

The main reference for this study is the following article, where all the different algorithms are describe in detail.

A Review of Time-Scale Modification of Music Signals.
— Jonathan Driedger and Meinard Müller¹

Algorithm comparison

There are two main algorithms, the Overlap-and-add (OLA) and the Phase Vocoder (PV). Both achieve good results under different signals and conditions. For this, a final implementation using Harmonic Percussion Separation (HPS) combines both algorithms and achiving the best results.

OLA

This method works on time domain and overlap sections of the audio (windows) and rearange it to achive a certain desire change on speed. This method works well for percussive signals, but it introduces artifacts when used with harmonic or tonal signals.

PV

This method works on frequency domain, and it combines chunks of audio in the frequency domain to achieve the desire change in time. This uses the phase vocoder principle to propagate the phase between the windows, this grantice the continuity of when applied to harmonic signals. On the contrary, it does not work for percussive signals becouse the phase propagation process eliminate the transients in the signals.

I created visualizations using Manim to enhance my class presentation. The first video demonstrates how the PV algorithm aligns windows to ensure smooth transitions in the generated signal over time. To achieve this, a Gaussian window is applied, which maintains continuity and smoothness, even at the start and end of the sequence.

The second video showcases the effects of applying the PV algorithm to a signal containing transients.

As predicted by theory, the transients vanish because the PV algorithm disrupts the vertical phase alignment. While these examples utilize idealized signals, they effectively demonstrate the key strengths and limitations of the algorithm.

HPS

To use both methods with their ideal signals, the HPS algorithms is used. This algorithm separete the signal into the harmonics and the percussive parts. It works by comparing the continuty of the signal in the STFT representation and using a filter to compare vertical versus horizontal presence on the spectrogram. With a threshold, a binary mask can be define over the spectrogram to separete the percussive parts from the harmoincs sections.

Results

We succesfully implement all the algorithms and compare them, verifying the theortical contents presented on the referenca article. In the process, we develope the toolkit to use this algorithms with the python programming language. All the code is avaliable on this repo

Academic Presentation

The study was preseented with my classmates on the JAAS (Jornadas de Acustica, Audio y Sonido). The main ideas and conclusions were preseneted on the conference. In the following repoert there is all the details and anlysis done for this proyect (in spanish).

ALGORITMOS DE MODIFICACIÓN DE ESCALA TEMPORAL.
— Matías Di Bernardo; Matías Vereertbruhggen; Sebastían Carro ²

A Review of Time-Scale Modification of Music Signal paper. ↩︎
JAAS 2023 - Algoritmos de Modificación de Escala Temporal paper. ↩︎