J’ai rassemblé ci-dessous des notes que j’ai prises en suivant les tutoriels vidéo de Daniel Shiffman sur les réseaux neuronaux, qui eux-mêmes s’inspirent largement de Make Your Own Neural Network, un livre écrit par Tariq Rashid. Les concepts et les formules ne sont pas de moi, je ne fais que les écrire afin de m’aider à les comprendre et à les mémoriser.

Pente et ordonnée à l’origine

Une droite est traditionnellement représentée par cette équation, dans laquelle $m$ représente la pente et $b$ l’ordonnée à l’origine :

Dans le cas de la régression linéaire (ou méthode des moindres carrés ordinaire), nous allons calculer la valeur $m$ avec la formule ci-dessous. Cette formule est tirée de cette vidéo réalisée par Daniel Shiffman dans le cadre de son cours Intelligence et apprentissage. Nous pouvons considérer que le numérateur de cette fraction représente la corrélation entre la croissance de la valeur $x$ et celle de la valeur $y$ (qui détermine la pente de notre droite).

Mes séquenceurs en forme de graphe pourraient également générer leur propre accompagnement musical lorsqu’ils croissent.

Structure et composition

Comment ces arbres produiront-ils de la musique ? Comment cette musique sera-t-elle définie à l’intérieur de l’arbre ? Par exemple, un arbre pourrait être doté d’une tonique et d’une armature.

La notion de « marcheur » est aussi très importante. Ce devrait être le marcheur qui « consulte » l’arbre et produit la musique. De cette façon, puisque l’on voit le marcheur se promener, le lien visuel entre son mouvement et la musique est plus intéressant que si la musique provenait inexplicablement de l’arbre seul. Enfin, la musique sans marcheur pourrait aussi être intéressante, mais je vais commencer par les marcheurs.

Un marcheur pourrait commencer au tronc de l’arbre en produisant la tonique. Lorsqu’il arrive à un embranchement, il pourra créer un nouveau marcheur. Ces marcheurs pourront ensuite s’engager dans les branches de l’arbre, et générer des sons simultanément.

Les notes pourraient être générées par les embranchements ou par les branches elles-mêmes. La longueur d’une note pourrait être déterminée par la longueur du segment sur lequel le marcheur se trouve — cependant, ces longueurs pourraient changer pendant que le marcheur avance, ce qui créerait des sons atonaux.

Pour l’instant, les notes seront représentées par les embranchements. Ça me semble une façon naturelle de commencer l’expérience. Donc, les objets Segment dont la propriété children est plus grande que 1 représentent un embranchement. Ce serait plus simple qu’un marcheur « s’endorme » lorsqu’il atteint un embranchement. Avant de s’endormir, il crée de nouveaux marcheurs (un pour chaque children du Segment) et leur lègue sa mémoire. Ou alors il ne s’endort pas et s’engage toujours dans la première branche de la liste children. De toute façon, un marcheur et les marcheurs qu’il a généré doivent être absolument égaux, il n’y aura pas de hiérarchie chez ces marcheurs.

// All the walkers would refer to a single instance of Song.
// Then, when a walker modulates the song, it will be modulated
// for all walkers.
let mixo = new Song({
    scale: "E mixolydian",
    currentChord: 1
});
// Define the music inside the Walker itself?
// The melody notes should represent degrees on the scale,
// starting at 1 being the tonic,
// not semitones with zero-based numbering.

//branchingModulo
let walker = new Walker({
    scale: "E mixolydian",
    melodies: [[1, 4, 6, 7],
               [1, 5, 8, 9]],
    currentMelodyIndex: [0, 2],
    speed: 3,
    branchingModulo: 4,
    walkingDepth: 0,
    song: mixo
});

// A walker could then have any number of methods
// that would define and alter its behaviour.

walker.branch = function(s) {
    // What happens when the Walker meets a branching Segment
    // s.children
    this.makeNote();
    this.currentSegment = s.children[0];
};

walker.sing = function() {
    // What happens when the Walker meets a branching Segment
    this.sing();
};

L’avancée d’un marcheur

Le niveau d’avancée d’un marcheur sur son segment doit être une valeur entre 0 et 1. Donc, sa vitesse est aussi un nombre entre 0 et 1. Sa vitesse est ajoutée à son niveau d’avancée à chaque pas (niveau qui plafonne à 1). La position du marcheur est ensuite calculée par interpolation linéaire entre les deux extrémités du segment.

Librairies musicales

Afin de soutenir ces liens entre la structure mathématique (et spatiale) de mes arbres et les accompagnements musicaux qu’ils généreront, je vais utiliser deux librairies JavaScript à vocation musicale: Tonal et Teoria. Ces outils devraient me permettre de manipuler des notions de théorie musicale plus aisément.

Une note à moi-même : afin d’utiliser l’extension Tonal.Key de Tonal.js dans un fureteur (plutôt que sur un serveur Node.js), j’ai dû utiliser Browserify en l’invoquant de cette manière :

node ./node_modules/.bin/browserify main.js -o bundle.js

Contexte

Cette note de blog fait partie de mon projet de recherche Vers un cinéma algorithmique, démarré en avril 2018. Je vous invite à consulter la toute première note du projet pour en apprendre davantage.

Dessiner des formes floues avec WebGL n’est pas simple. Par défaut, toutes les formes créées sont très précises et leurs contours bien définis. Comme je cherche à créer des animations aux ambiances brumeuses et incertaines, je suis en train de créer quelques premiers outils pour me permettre de dessiner du flou avec WebGL.

Dessiner des cercles flous ne s’est pas avéré trop compliqué, puisqu’une simple fonction de distance par rapport au centre du cercle peut être calculée aisément par le gpu. Le dessin de formes plus complexes me demande cependant d’en apprendre beaucoup plus sur WebGL, une technologie que je connais encore peu.

J’ai commencé par les quadrilatères. J’ai créé un système avec lequel je peux définir un rectangle principal, qui sera formé par les triangles a et b que l’on voit dans le diagramme en haut à gauche de mes notes crayonnées.

Ce projet constitue ma toute première expérience de programmation à la volée, c’est-à-dire que le programme a été conçu pour être modifié en temps réel. L’animation de ce programme est réalisée avec p5.js et WebGL, et la musique est produite avec SuperCollider. La musique utilise également des échantillons de piano distribués librement.

Le principe sur lequel cette animation repose est la simulation du comportement d’une volée d’oiseaux, ces oiseaux artificiels que l’on appelle boids en anglais. J’ai d’abord appris l’existence de ces simulations grâce aux vidéos de Daniel Shiffman. Shiffman a traité à plusieurs reprises de ce sujet, mais cette vidéo en particulier m’a inspiré cette animation.

Le projet peut être visionné sur YouTube et une version plus courte (qui contient, à mon avis, la meilleure partie de la vidéo) est présente sur mon fil Twitter.

Je veux implémenter l’algorithme de parcours en profondeur dans mes systèmes de séquenceurs en forme de graphe. Je verrai de quelles façons je peux me servir de cet algorithme pour créer des formes visuelles et des séquences musicales intéressantes. Je ne sais pas vraiment comment je pourrais utiliser cet algorithme pour son usage habituel (parcourir un graphe afin de déterminer s’il existe un chemin d’un sommet à un autre), mais pour l’instant, j’imagine qu’il pourrait me servir à créer des motifs déterministes à l’intérieurs de mes graphes. D’une façon générale, j’aimerais voir comment je pourrais traverser mes graphes de façons déterministes, puisque mes premières expérimentations ne sont que des parcours stochastiques.

Ordre de sélection des voisins à visiter

Une question importante qui n’est pas nécessairement soulevée par l’algorithme de parcours en profondeur, c’est l’ordre dans lequel sont sélectionnés les voisins à visiter. Et pour cause : ça n’a normalement pas d’importance. Enfin… je ne crois pas. Répondre à la question « y a-t-il un chemin entre ces deux sommets ? » n’implique pas de choisir ces sommets à visiter dans un ordre particulier. Mais dans mon cas, comme je m’intéresse aux formes que j’obtiendrai en appliquant cet algorithme, et comme je cherche une solution déterministe, l’ordre de sélection sera important.

Je suis en train de fabriquer une application Node.js qui me permettra de faire de la programmation improvisée. L’expression anglaise “live coding” est plus souvent utilisée. Wikipedia la traduit par « programmation à la volée » ou « programmation juste-à-temps ». Je ne suis pas enchanté par ces traductions mais faute de mieux, ça fera. Elle contient deux champs de texte CodeMirror, la première qui contrôle un serveur SuperCollider, et la seconde qui controle un sketch p5.js.

Pour créer cette application, j’ai utilisé une bonne quantité de code écrit pour Prynth, un logiciel créé par Ivan Franco, Harish Venkatesan, Ajin Tom et Antoine Maiorca. Prynth est distribué avec une licence Creative Commons Cc By-Nc-Sa 4.0. J’ai également repris un peu de code écrit par Olivia Jack pour son logiciel Hydra, qui est distribué avec une licence Gnu Affero Gpl v3.0.

Mon application s’appelle Les environs. Elle peut être téléchargée sur GitHub.

Je commence mon apprentissage d’un sujet immense : la programmation de “shaders” WebGL. Le code source de ces premières expériences peut être consulté sur GitHub.

En apprenant à travailler avec les graphes, il m’est venu l’idée de m’en servir pour créer des animations qui combineraient du mouvement visuel et du mouvement sonore. L’idée m’est aussi venue en voyant le séquenceur circulaire dont Sam Tarakajian parle sur sa chaîne YouTube consacrée à Max/Msp. Une démonstration vidéo de ce projet se trouve sur mon fil Twitter.

Je suis récemment tombé par hasard sur une chose dont la beauté me foudroie : la synthèse granulaire. Il s’agit d’une méthode qui sert à transformer des sons en les découpant en très petits segments (nommés grains). En faisant des premières expériences de synthèse granulaire, je n’ai pas pu m’empêcher d’imaginer comment ce principe pourrait être utilisé en arts visuels et en cinéma. J’ai fait en partant de cette idée quelques expériences qui se sont avérées très peu concluantes, mais dont je partage tout de même les notes ci-dessous.

Ce court métrage est sur YouTube.