La technologie de « Particle Life »

 (github.com/hunar4321)
1 points par GN⁺ 2023-12-30 | 1 commentaires | Partager sur WhatsApp
  • Particle Life Simulation est une simulation primitive de vie artificielle qui produit des motifs complexes d’auto-organisation à partir de simples règles d’attraction et de répulsion entre des particules semblables à des atomes
  • En dehors de l’interface graphique, le code tient sur moins d’une page, et l’algorithme central de l’implémentation C++ se trouve dans les 100 premières lignes de /particle_life/src/ofApp.cpp
  • Une démo JavaScript est proposée en versions 2D et 3D, et le README inclut un exemple qui crée 200 particules jaunes, rouges et vertes sur un canvas 500x500 et applique des règles de force entre les groupes de couleurs
  • Pour trouver des motifs intéressants, il est recommandé de procéder par exploration aléatoire puis par ajustements progressifs plutôt que de chercher des paramètres exacts, avec de grands changements occasionnels pour éviter de rester bloqué dans un optimum local
  • La limite actuelle vient de la boucle imbriquée qui calcule la distance entre toutes les paires de particules, ce qui donne une complexité de calcul en temps quadratique ; le calcul parallèle sur GPU, la sauvegarde des paramètres, l’extension des types de particules et une UI plus intuitive restent des chantiers ouverts

Objectif de Particle Life Simulation

  • Particle Life Simulation est un programme qui simule des motifs primitifs de vie artificielle en appliquant de simples règles d’attraction ou de répulsion entre des particules semblables à des atomes
  • Il vise à montrer comment des motifs complexes d’auto-organisation et des comportements semblables au vivant peuvent émerger de règles simples
  • En dehors des éléments de GUI, le code tient sur moins d’une page
  • Un tutoriel et un walkthrough sont disponibles en vidéo sur YouTube

Démos et mode d’exécution

  • Une démo JavaScript en ligne est disponible en 2D et en 3D
  • La version C++ s’utilise en téléchargeant le dépôt, en le décompressant, puis en lançant particle_life.exe dans le dossier /particle_life/bin/
  • Le README contient une image de l’interface de la version C++ ainsi que des images de résultats d’exemple

Méthode d’exploration des motifs

  • Il n’est pas nécessaire d’ajuster les paramètres avec précision pour reproduire des motifs intéressants
  • La meilleure méthode consiste d’abord à essayer une exploration aléatoire des paramètres, puis à affiner progressivement lorsqu’un motif intéressant apparaît
  • Pour éviter de rester piégé dans un optimum local, on peut de temps à autre faire de grands sauts dans les paramètres
  • Avec cette approche, des motifs différents et intéressants peuvent continuer à apparaître

Code et structure de l’implémentation

  • Le code source est fourni en C++, JavaScript et Python
  • Pour contribuer au programme C++, l’algorithme central se trouve dans les 100 premières lignes de /particle_life/src/ofApp.cpp
    • Le reste concerne les composants GUI et le contrôle du rendu
    • La GUI et le rendu sont fournis par la bibliothèque openFrameworks
  • Méthode de build pour la version C++
    • Télécharger le dépôt
    • Télécharger openFrameworks
    • Importer le dossier /particle_life/ dans le projet avec le projectGenerator d’openFrameworks
    • Ou créer un nouveau projet openFrameworks, ajouter ofxGui, puis remplacer le dossier /src/ du projet généré par le /src/ du dépôt
    • Il est ensuite possible de compiler le code C++ en local

Fonctionnement de l’exemple JavaScript

  • L’exemple JavaScript du README fonctionne sur un canvas 500x500
  • atom est créé comme un objet possédant x, y, vx, vy, color
  • La fonction create crée un groupe de particules de même couleur dans la quantité indiquée et les ajoute aussi au tableau global atoms
  • rule(atoms1, atoms2, g) calcule la force entre deux groupes de particules
    • La force n’est appliquée que lorsque la distance d entre deux particules est supérieure à 0 et inférieure à 80
    • La force est calculée avec (g * 1) / d
    • La valeur de g détermine les règles d’attraction ou de répulsion entre les groupes de couleurs
  • L’exemple crée 200 particules jaunes, 200 rouges et 200 vertes
  • update applique ensuite les règles pour chaque combinaison de groupes de couleurs, efface l’écran puis redessine les particules sur un fond noir
  • La boucle d’animation est exécutée avec requestAnimationFrame(update)
  • Une version plus optimisée se trouve dans le fichier particle_life.html

Autres ports

Sujets liés et inspiration

  • Les sujets liés sont Particle Life Simulation, Primordial Soup - Evolution, Conway's game of life, Cellular automata, Self organizing patterns
  • Ce projet s’inspire de Clusters, de Jeffery Ventrella
  • Le code de Ventrella n’était pas accessible
  • La principale différence semble être l’absence d’implémentation de la détection de collision
    • En retirant la détection de collision, il aurait été possible de simuler des milliers de particules en temps réel
  • Des contrôles GUI ont été ajoutés pour modifier les paramètres en temps réel
    • Cela facilite l’ajustement fin et l’exploration
    • Des motifs jamais vus auparavant ont pu apparaître à partir d’un modèle relationnel très simple
  • Le code a commencé comme un support pédagogique destiné aux non-programmeurs et au grand public
    • Le but était de montrer que la complexité peut émerger de la simplicité
    • Il pourrait faire partie des codes de vie artificielle les plus simples, à une seule dizaine de lignes d’ordre de grandeur

Chantiers restants

  • Ajouter une fonction de sauvegarde et de chargement des paramètres afin que les utilisateurs puissent partager facilement des modèles intéressants
  • Permettre d’ajouter davantage de types de particules, actuellement fixés à 4
  • La boucle imbriquée qui calcule la distance entre toutes les paires de particules constitue le principal goulot d’étranglement
    • La complexité de calcul est quadratique
    • Il faut trouver un moyen de contourner cette limite
  • Le calcul de distance entre paires de particules se parallélise facilement et pourrait donc être exécuté sur GPU
  • Il faut ajouter le redimensionnement de l’écran et améliorer la gestion des limites
    • Un grand nombre de particules se déplaçant rapidement peuvent sortir des limites de l’écran
  • Ajouter une UI plus intuitive pour permettre un contrôle plus fin des paramètres
  • Il serait possible d’ajouter un bouton de randomisation ou une simple méta-règle qui modifie récursivement les règles initiales
    • L’objectif est d’éviter que les motifs se figent dans un optimum local et de les faire continuer à évoluer
  • On pourrait utiliser un algorithme évolutif comme meilleure méthode pour sélectionner et optimiser les paramètres
    • Cela nécessiterait d’écrire une fonction d’aptitude
    • On ne sait pas encore ce que serait une fonction d’aptitude pertinente dans le cadre de ce programme
    • Dans le monde réel, la fonction d’aptitude est la compétition et la survie du plus apte
    • Ici, l’utilisateur affine et sélectionne les paramètres qui produisent des motifs intéressants, mais la notion d’« intérêt » est difficile à définir

À lire aussi

1 commentaires

 
GN⁺ 2023-12-30
Commentaires Hacker News
  • L’un de mes premiers projets de code à l’école était le Jeu de la vie de Conway, mais comme le noir et blanc était un peu ennuyeux, j’y ai ajouté des « gènes » RGB : les cellules nouvellement nées héritaient d’un mélange des couleurs de leurs parents, avec aussi des mutations aléatoires.
    C’était assez amusant de voir quel « camp » finissait par dominer le plateau.
    Démo : https://genetic-life.surge.sh/
    Source : à l’origine en C++, porté vers Rust/WASM https://github.com/franky47/genetic-life
  • Le plus intéressant de ceux que j’ai générés, c’est celui-ci : https://hunar4321.github.io/particle-life/particle_life.html...
    Il finit par se stabiliser en un gros amas instable et un amas stable, tous deux immobiles, donc ça s’arrête là.
    Mais avant cela, il montrait bien ce que j’espérais voir : des objets qui se rencontrent et fusionnent.
  • C’est vraiment fascinant. On dirait une version plus complexe du Jeu de la vie de John Conway.
    Avec de tels paramètres, il est étonnant de voir de petites choses semblables à des organismes se former facilement, même à très petite échelle.
    Certains pensent que les paramètres de l’univers réel sont réglés pour rendre l’apparition de la vie facile, mais j’ai plutôt l’impression qu’ils sont réglés pour rendre la formation de la vie difficile.
    • Ce sont plutôt des molécules que des êtres vivants. Bien sûr, quand un ensemble de règles complexe s’approche d’un état stationnaire, il m’est déjà arrivé de l’imaginer comme un lointain empire stellaire où les couleurs seraient attribuées à différents régimes politiques.
      Ce qui donne cette illusion, c’est le mouvement. Comme aucune loi de conservation n’est intégrée à ce système, le mouvement se maintient. Si l’on crée une paire A-B où B est attiré par A et A repousse B, elle file tout droit.
      Si les règles avaient été conçues pour inclure des lois de conservation, comme la conservation de l’énergie ou de la quantité de mouvement, on obtiendrait des structures beaucoup moins intéressantes, plus proches de l’aspect tardif d’une explosion de pentomino dans le Jeu de la vie de Conway.
      Si j’avais un processeur suffisamment puissant, j’aimerais voir ça en 3D, et essayer des options comme des forces qui décroissent en inverse de r, en inverse du cube de r, ou en r * log(r), ou encore des particules qui « se repoussent de loin et s’attirent de très près ». Même avec des optimisations intelligentes, j’ai l’impression qu’un tel système finirait par se figer.
    • Cela ne donne pas pour autant de raison de croire que la vie soit particulièrement rare dans l’univers.
  • Coïncidence amusante, j’ai récemment fait quelque chose de similaire : https://webgl-particle-life.netlify.app/
    Source : https://github.com/ath92/particle-life
    Cette version fait tout le travail dans des shaders WebGL et stocke l’état de la simulation dans des textures et des uniforms.
    Cela permet de simuler et d’afficher davantage de particules, mais elle utilise des extensions WebGL moins bien prises en charge, donc elle peut ne pas fonctionner sur tous les appareils.
  • Articles liés :
    Particle Life Emerges from Simplicity - https://news.ycombinator.com/item?id=34156592 - décembre 2022, 1 commentaire
    Particle Life Simulation - https://news.ycombinator.com/item?id=33680845 - novembre 2022, 1 commentaire
    Particle Life - https://news.ycombinator.com/item?id=21875720 - décembre 2019, 7 commentaires
  • Cette implémentation est beaucoup plus aboutie, mais j’en avais déjà fait une dans Godot 4 avec des compute shaders.
    Si ça vous intéresse, c’est ici : https://github.com/jasonjmcghee/compute-shaders
  • Je n’y avais jamais pensé auparavant, mais en comparant, je me rends compte que le Jeu de la vie de Conway est davantage basé sur les ondes que sur les particules.
    Autrement dit, dans CGoL, les règles s’appliquent aux positions de la grille, et non à des objets qui se déplacent à travers la grille. Je me demande si ce système pourrait aussi être formulé selon une approche basée sur les ondes.
    Par ailleurs, dans ce système, à chaque frame toutes les particules agissent les unes sur les autres quelle que soit la distance, donc la vitesse de la lumière semble infinie. À l’inverse, dans CGoL, chaque cellule ne peut influencer que ses voisines immédiates à chaque frame, ce qui donne une sorte de vitesse de la lumière.
  • Je regarde en ce moment la version JS en 3D, et c’est peut-être ce que j’ai préféré depuis le Jeu de la vie de Conway original ou l’économiseur d’écran Primordial Life des années 90.
    Je me demande s’il était prévu d’ajouter la prise en charge des shaders. J’aimerais voir une version plus lente et plus « grumeleuse » en plein écran.
    Ça transformerait probablement mon Mac en radiateur, mais en ce moment c’est plutôt un avantage ;)
  • Ça me rappelle Swarm Chemistry de Hiroki Sayama.
    https://www.youtube.com/watch?v=BpN-DE3o6u8
    https://bingdev.binghamton.edu/sayama/SwarmChemistry/
  • Si ce genre de choses vous intéresse, je recommande Smooth-life et Lenia.
    Lenia a notamment quelques variantes plus complexes ; sur ce sujet, « Flow Lenia » ou « Particle Lenia » me viennent à l’esprit.