„Particle Life“-Technologie

 (github.com/hunar4321)
1 Punkte von GN⁺ 2023-12-30 | 1 Kommentare | Auf WhatsApp teilen
  • Particle Life Simulation ist eine primitive Simulation künstlichen Lebens, die mit einfachen Regeln für Anziehung und Abstoßung zwischen atomähnlichen Partikeln komplexe selbstorganisierende Muster erzeugt
  • Der Code umfasst ohne GUI weniger als eine Seite, und der Kernalgorithmus der C++-Implementierung steht in den ersten 100 Zeilen von /particle_life/src/ofApp.cpp
  • Eine JavaScript-Demo ist in 2D- und 3D-Versionen verfügbar, und das README enthält ein Beispiel, das auf einer 500x500-Canvas jeweils 200 gelbe, rote und grüne Partikel erzeugt und Kraftregeln zwischen den Farbgruppen anwendet
  • Für interessante Muster wird eher zufällige Exploration mit schrittweiser Feinabstimmung empfohlen als exakt passende Parameter; gelegentlich helfen größere Parametersprünge dabei, nicht in lokalen Maxima steckenzubleiben
  • Die aktuelle Grenze liegt darin, dass die verschachtelten Schleifen zur Berechnung aller Partikelpaare eine quadratische Zeitkomplexität verursachen; parallele GPU-Berechnung, Parameterspeicherung, erweiterte Partikeltypen und eine intuitivere UI bleiben offene Aufgaben

Ziel der Particle Life Simulation

  • Particle Life Simulation ist ein Programm zur Simulation primitiver künstlicher Lebensmuster, indem auf atomähnliche Partikel einfache Regeln für Anziehung oder Abstoßung angewendet werden
  • Der Fokus liegt darauf zu zeigen, dass aus einfachen Regeln komplexe selbstorganisierende und lebensähnliche Muster entstehen können
  • Ohne GUI-Elemente umfasst der Code weniger als eine Seite
  • Tutorials und Walkthroughs sind als YouTube-Video verfügbar

Demos und Ausführung

  • Eine JavaScript-Online-Demo ist in 2D und 3D verfügbar
  • Die C++-Version wird ausgeführt, indem man das Repository herunterlädt, entpackt und particle_life.exe im Ordner /particle_life/bin/ startet
  • Das README enthält Interface-Bilder der C++-Version und Beispielbilder der Ergebnisse

Vorgehen bei der Mustersuche

  • Um interessante Muster zu reproduzieren, müssen die Parameter nicht exakt getroffen werden
  • Am besten versucht man zunächst eine zufällige Parameterexploration und justiert dann schrittweise nach, sobald ein interessantes Muster gefunden wurde
  • Um nicht in lokalen Maxima steckenzubleiben, kann man gelegentlich größere Parametersprünge einbauen
  • Auf diese Weise können immer wieder unterschiedliche und interessante Muster entstehen

Code und Implementierungsstruktur

  • Der Quellcode ist in C++, JavaScript und Python verfügbar
  • Wer zum C++-Programm beitragen möchte, findet den Kernalgorithmus in den ersten 100 Zeilen von /particle_life/src/ofApp.cpp
    • Der Rest betrifft GUI-Komponenten und Rendering-Steuerung
    • GUI und Rendering werden von der openFrameworks-Bibliothek bereitgestellt
  • So wird die C++-Version gebaut
    • Das Repository herunterladen
    • openFrameworks herunterladen
    • Mit dem projectGenerator von openFrameworks den Ordner /particle_life/ in ein Projekt importieren
    • Oder ein neues openFrameworks-Projekt erstellen, ofxGui hinzufügen und dann den Ordner /src/ des erzeugten Projekts durch /src/ aus dem Repository ersetzen
    • Danach kann der C++-Code lokal kompiliert werden

Funktionsweise des JavaScript-Beispiels

  • Das JavaScript-Beispiel im README läuft auf einer 500x500-canvas
  • atom wird als Objekt mit x, y, vx, vy und color erstellt
  • Die Funktion create erzeugt eine Gruppe gleichfarbiger Partikel in der angegebenen Anzahl und fügt sie auch dem gesamten atoms-Array hinzu
  • rule(atoms1, atoms2, g) berechnet die Kraft zwischen zwei Partikelgruppen
    • Die Kraft wird nur angewendet, wenn der Abstand d zwischen zwei Partikeln größer als 0 und kleiner als 80 ist
    • Die Kraft wird als (g * 1) / d berechnet
    • Der Wert g bestimmt die Regeln für Anziehung oder Abstoßung zwischen Farbgruppen
  • Das Beispiel erzeugt jeweils 200 gelbe, rote und grüne Partikel
  • update wendet die Regeln für jede Kombination von Farbgruppen an, löscht dann den Bildschirm und zeichnet die Partikel erneut auf schwarzem Hintergrund
  • Die Animationsschleife läuft über requestAnimationFrame(update)
  • Eine stärker optimierte Version befindet sich in der Datei particle_life.html

Weitere Portierungen

Verwandte Themen und Inspiration

  • Verwandte Themen sind Particle Life Simulation, Primordial Soup - Evolution, Conway's game of life, Cellular automata und Self organizing patterns
  • Dieses Projekt wurde von Jeffery Ventrellas Clusters inspiriert
  • Auf Ventrellas Code konnte nicht zugegriffen werden
  • Der Hauptunterschied dürfte darin liegen, dass keine Kollisionserkennung implementiert wurde
    • Durch den Verzicht auf Kollisionserkennung wurde es vermutlich möglich, Tausende von Partikeln in Echtzeit zu simulieren
  • GUI-Steuerelemente wurden hinzugefügt, damit Parameter in Echtzeit verändert werden können
    • Dadurch werden Feinabstimmung und Exploration erleichtert
    • In diesem sehr einfachen Beziehungsmodell konnten zuvor ungesehene Muster entstehen
  • Der Code begann als Lehrmaterial für Nicht-Programmierer und die breite Öffentlichkeit
    • Ziel war zu zeigen, dass Komplexität aus Einfachheit entstehen kann
    • Es könnte einer der einfachsten Codes für künstliches Leben überhaupt sein, möglicherweise im einstelligen Bereich

Offene Aufgaben

  • Eine Funktion zum Speichern und Laden von Parametern hinzufügen, damit Nutzer interessante Modelle leicht teilen können
  • Mehr Partikeltypen ermöglichen statt der derzeit festgelegten vier
  • Die verschachtelten Schleifen zur Berechnung der Abstände aller Partikelpaare sind der größte Engpass
    • Die Rechenkomplexität ist quadratisch
    • Es wird ein Weg benötigt, dies zu umgehen
  • Die Berechnung der Partikelpaar-Abstände lässt sich leicht parallelisieren und könnte daher auf der GPU ausgeführt werden
  • Eine anpassbare Bildschirmgröße und bessere Randprüfung werden benötigt
    • Viele schnelle Partikel können den Bildschirmrand verlassen
  • Eine intuitivere UI hinzufügen, damit Parameter feiner gesteuert werden können
  • Man könnte einen Randomize-Button oder einfache Metaregeln hinzufügen, die Anfangsregeln rekursiv weiter verändern
    • Ziel ist, dass Muster nicht in lokalen Maxima steckenbleiben, sondern sich weiter verändern
  • Für eine bessere Auswahl und Optimierung von Parametern könnte ein evolutionärer Algorithmus verwendet werden
    • Dafür müsste eine Fitnessfunktion geschrieben werden
    • Welche Fitnessfunktion in diesem Programmkontext passend wäre, ist derzeit unklar
    • In der realen Welt sind Wettbewerb und Survival of the fittest die Fitnessfunktion
    • Hier wählt und justiert der Nutzer Parameter, die interessante Muster erzeugen, aber „Interessantheit“ ist schwer zu definieren

Verwandte Beiträge

1 Kommentare

 
GN⁺ 2023-12-30
Hacker-News-Kommentare
  • Eines meiner ersten Coding-Projekte in der Schule war Conways Spiel des Lebens, aber nur Schwarzweiß war etwas langweilig. Also habe ich RGB-„Gene“ eingebaut, neu geborene Zellen die Farben ihrer Eltern mischen lassen und zufällige Mutationen hinzugefügt.
    Ziemlich interessant zu beobachten, welches „Lager“ das Spielfeld übernimmt.
    Demo: https://genetic-life.surge.sh/
    Source: ursprünglich C++, nach Rust/WASM portiert: https://github.com/franky47/genetic-life
  • Das Interessanteste, das ich erzeugt habe, war dieses hier: https://hunar4321.github.io/particle-life/particle_life.html...
    Am Ende pendelt es sich auf einen großen, instabilen Klumpen und einen stabilen Klumpen ein, und beide bewegen sich nicht mehr, also ist dort Schluss.
    Davor zeigt es aber genau die Szenen, die ich erwartet hatte: Objekte treffen aufeinander und verschmelzen.
  • Wirklich faszinierend. Es wirkt wie eine komplexere Version von John Conways Spiel des Lebens.
    Erstaunlich, dass sich bei solchen Parametern selbst in sehr kleinem Maßstab leicht Dinge bilden, die wie kleine Lebewesen wirken.
    Manche glauben, die Parameter des realen Universums seien so abgestimmt, dass Leben leicht entstehen kann; mir kommt es eher so vor, als seien sie darauf abgestimmt, die Entstehung von Leben schwierig zu machen.
    • Das sind eher Moleküle als Lebewesen. Wobei ich mir natürlich schon einmal vorgestellt habe, wenn sich ein komplexes Regelwerk einem stationären Zustand nähert, dass das wie weit entfernte Sternenreiche wirkt, denen man Farben nach Regierungsform zuweist.
      Was die Täuschung erzeugt, ist die Bewegung. In diesem System sind keine Erhaltungssätze eingebaut, daher bleibt Bewegung erhalten. Wenn man ein A-B-Paar baut, bei dem B von A angezogen wird und A B abstößt, schießt es einfach davon.
      Hätte man die Regeln so entworfen, dass Erhaltungssätze wie Energie- oder Impulserhaltung enthalten sind, wären deutlich weniger interessante Strukturen entstanden, eher wie Conways Spiel des Lebens, wenn die Pentomino-Explosion in eine spätere Phase übergeht.
      Wenn ich einen ausreichend großen Prozessor hätte, würde ich das gern in 3D sehen und auch Optionen ausprobieren, bei denen Kräfte mit dem Kehrwert von r, dem Kehrwert von r hoch drei oder mit r * log(r) abfallen, oder Teilchen, die „aus der Ferne abstoßen und aus nächster Nähe anziehen“. Selbst mit cleverer Optimierung habe ich das Gefühl, dass so ein System zum Stillstand kommen würde.
    • Trotzdem gibt es auch keinen Grund zu glauben, dass Leben im Universum besonders selten ist.
  • Lustiger Zufall: Ich habe kürzlich etwas Ähnliches gebaut: https://webgl-particle-life.netlify.app/
    Source: https://github.com/ath92/particle-life
    Diese Version erledigt alles in WebGL-Shadern und speichert den Simulationszustand in Texturen und Uniforms.
    Dadurch kann sie mehr Partikel simulieren und zeichnen, verwendet aber weniger breit unterstützte WebGL-Erweiterungen und läuft daher möglicherweise nicht auf allen Geräten.
  • Verwandte Beiträge:
    Particle Life Emerges from Simplicity - https://news.ycombinator.com/item?id=34156592 - Dezember 2022, 1 Kommentar
    Particle Life Simulation - https://news.ycombinator.com/item?id=33680845 - November 2022, 1 Kommentar
    Particle Life - https://news.ycombinator.com/item?id=21875720 - Dezember 2019, 7 Kommentare
  • Diese Implementierung ist deutlich ausgereifter, aber ich habe vor einiger Zeit in Godot 4 einmal etwas mit Compute-Shadern gebaut.
    Falls es jemanden interessiert, hier ist es: https://github.com/jasonjmcghee/compute-shaders
  • Früher hatte ich nie darüber nachgedacht, aber im Vergleich fällt mir auf, dass Conways Spiel des Lebens eher wellenbasiert als partikelbasiert ist.
    Das heißt, bei CGoL werden die Regeln auf Positionen im Gitter angewendet, nicht auf Objekte, die sich durch das Gitter bewegen. Ich frage mich, ob man dieses System auch wellenbasiert aufbauen könnte.
    Außerdem wirken in diesem System in jedem Frame alle Partikel unabhängig von der Entfernung aufeinander, sodass die Lichtgeschwindigkeit unendlich zu sein scheint. In CGoL dagegen kann jede Zelle pro Frame nur ihre direkten Nachbarn beeinflussen, es gibt also eine Art Lichtgeschwindigkeit.
  • Ich schaue mir gerade die 3D-JS-Version an, und sie könnte seit dem ursprünglichen Conway-Spiel des Lebens oder dem Primordial-Life-Bildschirmschoner aus den 90ern das sein, was mir am besten gefällt.
    Ich frage mich, ob es Überlegungen gab, Shader-Support hinzuzufügen. Ich würde gern eine langsamere, „klumpigere“ Version im Vollbild sehen.
    Vermutlich würde das meinen Mac in eine Heizung verwandeln, aber im Moment wäre das eher ein Vorteil ;)
  • Erinnert mich an Hiroki Sayamas Swarm Chemistry.
    https://www.youtube.com/watch?v=BpN-DE3o6u8
    https://bingdev.binghamton.edu/sayama/SwarmChemistry/
  • Wenn dich diese Art von Systemen weiter interessiert, empfehle ich Smooth-life und Lenia.
    Gerade bei Lenia gibt es einige komplexere Varianten; in Bezug auf dieses Thema fallen mir „Flow Lenia“ oder „Particle Lenia“ ein.