Apporter l'IA à la création musicale sur Bela
Un guide pour utiliser des modèles d'IA pour la musique sur la plateforme Bela.
― 7 min lire
Table des matières
Créer de la musique avec la techno, c'est toujours fait partie de l'expression humaine. En avançant, de nouveaux outils et plateformes facilitent la vie des musiciens et des développeurs pour combiner son et technologie innovante. Une de ces plateformes, c'est Bela, un outil puissant qui aide les gens à créer de la musique et d'autres projets audio.
Ces dernières années, on a vu un intérêt grandissant pour l'utilisation de l'intelligence artificielle (IA) dans la création musicale. L'IA peut aider à créer des sons, des motifs et même interpréter des gestes. Mais utiliser ces technologies avancées sur de petits appareils, comme Bela, a ses propres défis. Cet article présente une méthode pour faciliter l'utilisation des modèles d'apprentissage profond sur la plateforme Bela, permettant à plus de gens d'expérimenter avec la musique et la technologie.
Le Défi de l'IA dans la Musique
Quand on essaie de faire tourner des modèles d'IA sur de petits appareils, les développeurs rencontrent souvent des obstacles majeurs. Ces appareils ont généralement une puissance de traitement et une mémoire limitées. Ça veut dire que les modèles d'IA standard, qui peuvent nécessiter beaucoup de ressources, ne fonctionnent pas bien. En plus, les tâches doivent être faites En temps réel, ce qui signifie qu'elles doivent réagir aux inputs des utilisateurs sans délai.
À cause de ces limitations, beaucoup de potentiels utilisateurs abandonnent l'idée d'utiliser l'IA dans la création musicale. Les directives disponibles pour utiliser ces modèles sur des plateformes comme Bela sont souvent compliquées, ce qui rend difficile le démarrage pour les non-experts.
La Plateforme Bela
Bela est une plateforme spécialement conçue pour créer des projets audio. Elle permet aux utilisateurs d’enregistrer, de traiter et de manipuler le son en temps réel. Grâce à un environnement à faible latence-c'est-à-dire qu'il y a peu de délai entre l'entrée et la sortie-Bela prend en charge des projets interactifs nécessitant un retour immédiat.
Bela supporte plusieurs entrées et sorties, ce qui est top pour capturer de l'audio de différentes sources. Ça laisse aussi place à la créativité, car les développeurs peuvent créer leurs propres applis allant de simples générateurs de sons à des installations complexes.
Présentation du Pipeline
Pour aider les utilisateurs à déployer des modèles d'IA sur Bela plus facilement, un nouveau pipeline a été créé. Ce pipeline se compose d'une série d'étapes qui guident les utilisateurs dans l'enregistrement de données, l'Entraînement des modèles d'IA et l'exécution de ces modèles sur Bela. Chaque étape est conçue pour rendre le processus plus fluide et efficace.
Étape 1 : Enregistrement des Données
La première étape est de rassembler des données à partir de divers capteurs. Ça peut inclure des microphones, des capteurs piézo et d'autres entrées numériques. En utilisant plusieurs cartes Bela, les utilisateurs peuvent enregistrer plusieurs canaux de données en même temps. Ça aide à capturer une large gamme de signaux audio qui peuvent être utilisés pour entraîner les modèles d'IA.
Une fois les données enregistrées, elles sont envoyées à un ordinateur hôte pour traitement. Cette étape consiste à aligner les signaux des différentes cartes et à les convertir dans un format que les modèles d'IA peuvent utiliser facilement.
Étape 2 : Entraînement du Modèle d'IA
Après que les données aient été collectées et traitées, l'étape suivante est l'entraînement du modèle d'IA. C'est là que la magie opère. En utilisant des outils comme PyTorch, les utilisateurs peuvent créer des modèles qui apprennent à partir des données qu'ils ont collectées.
Une fois entraîné, le modèle est exporté dans un format compréhensible par Bela, généralement comme un modèle TensorFlow Lite. Ça le rend compatible avec la plateforme Bela et prêt à être utilisé en temps réel.
Étape 3 : Cross-Compilation du Code
Maintenant que le modèle est prêt, les utilisateurs doivent préparer le code pour qu'il fonctionne sur Bela. À cause des limitations de Bela, il est souvent nécessaire de faire une cross-compilation sur une machine plus puissante. Ça veut dire que le code est écrit et compilé sur un ordinateur portable ou de bureau avant d'être transféré sur Bela.
Un conteneur Docker est utilisé pour simplifier ce processus. Docker permet aux utilisateurs de regrouper le logiciel et ses composants nécessaires, ce qui facilite l'exécution sur différentes machines. Dans ce cas, le code compilé peut être directement transféré à la plateforme Bela, où il est prêt à fonctionner.
Étape 4 : Exécution du Modèle en Temps Réel
Avec tout en place, il est temps de faire tourner le modèle en temps réel. C'est là que tout se met en place. Le modèle d'IA traite les signaux audio entrants et génère une sortie presque instantanément. Pour s'assurer que ce processus se déroule sans accroc, il est essentiel de suivre les meilleures pratiques en matière de codage.
L'allocation de mémoire doit être gérée attentivement, car allouer de la mémoire pendant le traitement audio peut provoquer des retards. Au lieu de ça, toute la mémoire devrait être pré-allouée avant que le traitement audio ne commence.
De plus, les tâches nécessitant des calculs importants, comme l'inférence du modèle d'IA, devraient être gérées dans un thread séparé. Ça permet au thread audio principal de continuer à traiter le son sans hésitation, réduisant ainsi le risque de coupures.
Avantages du Pipeline
Le pipeline décrit dans cet article offre plusieurs avantages pour les musiciens et les développeurs :
Simplifie le Processus : Un ensemble d'étapes claires rend plus facile pour les non-experts de commencer à utiliser l'IA dans leurs projets.
Réduit les Temps d'Attente : La cross-compilation sur une machine plus rapide signifie que les utilisateurs passent moins de temps à attendre que leur code soit construit.
Encourage l'Expérimentation : Avec un accès plus facile aux capacités d'IA, plus de gens peuvent essayer de nouvelles idées et créer des expériences audio uniques.
Performance en Temps Réel : Grâce à des pratiques de codage optimisées, les utilisateurs peuvent profiter d'applications audio réactives sans délai.
Conclusion
Alors que la technologie continue d'évoluer, l'intersection de la musique et de l'IA offre des opportunités excitantes pour la créativité. Des plateformes comme Bela ouvrent des portes pour les musiciens et les développeurs. En fournissant un pipeline simplifié pour utiliser des modèles d'apprentissage profond sur Bela, plus de gens peuvent plonger dans le monde de l'IA embarquée.
Cette approche rend non seulement l'accès plus simple, mais encourage aussi l'expérimentation et l'innovation. Avec les bons outils et processus en place, le monde de l'interaction audio en temps réel continuera de se développer. Les musiciens peuvent désormais explorer de nouvelles avenues de créativité, fusionnant son et technologie avancée pour produire quelque chose de vraiment spécial. Ce n'est que le début, et l'avenir semble bright pour ceux qui sont prêts à expérimenter et à repousser les limites de la création musicale.
Titre: Pipeline for recording datasets and running neural networks on the Bela embedded hardware platform
Résumé: Deploying deep learning models on embedded devices is an arduous task: oftentimes, there exist no platform-specific instructions, and compilation times can be considerably large due to the limited computational resources available on-device. Moreover, many music-making applications demand real-time inference. Embedded hardware platforms for audio, such as Bela, offer an entry point for beginners into physical audio computing; however, the need for cross-compilation environments and low-level software development tools for deploying embedded deep learning models imposes high entry barriers on non-expert users. We present a pipeline for deploying neural networks in the Bela embedded hardware platform. In our pipeline, we include a tool to record a multichannel dataset of sensor signals. Additionally, we provide a dockerised cross-compilation environment for faster compilation. With this pipeline, we aim to provide a template for programmers and makers to prototype and experiment with neural networks for real-time embedded musical applications.
Auteurs: Teresa Pelinski, Rodrigo Diaz, Adán L. Benito Temprano, Andrew McPherson
Dernière mise à jour: 2023-06-20 00:00:00
Langue: English
Source URL: https://arxiv.org/abs/2306.11389
Source PDF: https://arxiv.org/pdf/2306.11389
Licence: https://creativecommons.org/licenses/by/4.0/
Changements: Ce résumé a été créé avec l'aide de l'IA et peut contenir des inexactitudes. Pour obtenir des informations précises, veuillez vous référer aux documents sources originaux dont les liens figurent ici.
Merci à arxiv pour l'utilisation de son interopérabilité en libre accès.
Liens de référence
- https://dl.acm.org/ccs_flat.cfm
- https://bela.io/
- https://developer.nvidia.com/embedded/jetson-modules
- https://coral.ai/products/dev-board-mini/
- https://coral.ai/products/accelerator
- https://www.intel.com/content/www/us/en/developer/articles/tool/neural-compute-stick.html
- https://pytorch.org/docs/stable/jit.html
- https://www.tensorflow.org/lite
- https://onnxruntime.ai/
- https://github.com/acids-ircam/nn_tilde
- https://github.com/rodrigodzf/torchplugins
- https://neutone.space/
- https://youtu.be/jAIRf4nGgYI
- https://github.com/ninon-io/Neurorave-hardware
- https://github.com/cpmpercussion/empi
- https://github.com/domenicostefani/deep-classf-runtime-wrappers
- https://github.com/pelinski/bela-dl-pipeline
- https://numpy.org/
- https://github.com/alibaba/TinyNeuralNetwork
- https://github.com/pelinski/bela-tflite-example
- https://www.docker.com/
- https://cmake.org/
- https://www.youtube.com/watch?v=xGmRaTaBNZA&list=PLCrgFeG6pwQmdbB6l3ehC8oBBZbatVoz3&index=20
- https://www.youtube.com/watch?v=Cdh_BAzr8aE&t=21258s
- https://learn.bela.io/using-bela/languages/c-plus-plus/#the-bela-api-for-c
- https://github.com/acids-ircam/lottery_generative/tree/master/code/statistics
- https://www.rossbencina.com/code/real-time-audio-programming-101-time-waits-for-nothing