FPS - Fractal Pulsating Spiral Pipeline v3

The pipeline is not yet updated, but the complete, debugged, and explanatory notebook is now here in /notebooks

🌀 Vue d'ensemble (mise à jour et correction du readme à venir)

La FPS (Fractal Pulsating Spiral) est un système d'oscillateurs adaptatifs avec régulation spiralée implémentant les équations mathématiques décrites dans le document théorique FPS. Le pipeline actuel est en pré-phase 3, avec une architecture fonctionnelle complète prête pour l'implémentation de la latence adaptative et de la fonction G(x) réellement adaptative.

État actuel : Pipeline validé et cohérent (1er juillet 2025)

Le système FPS a atteint sa maturité opérationnelle avec :

• ✅ Pipeline unifié : Cohérence parfaite entre runs principaux et batch runs
• ✅ Métriques validées : Tous les calculs vérifiés et cohérents à travers le pipeline
• ✅ Effort dynamique : Métrique d'effort corrigée avec saturation à MAX_EFFORT=100
• ✅ Naming unique : Fichiers CSV avec suffixe de mode (évite les collisions)
• ✅ Performance validée : +40.1% vs Kuramoto, +200.7% vs Neutral

---

Démarrage rapide

disable spacing_effect in config.son ("spacing_effect": {"enabled": false}) for falsifiable results

Installation

# Cloner le repository
git clone https://github.com/Exybris/FPS-real-tests_fractal-pulsating-spiral
cd FPS_Project

# Créer un environnement virtuel
python3 -m venv venv
source venv/bin/activate  # Linux/Mac

# Installer les dépendances
python3 -m pip install --upgrade pip
pip3 install -r requirements.txt

Premier run

# Pipeline complet avec validation
python3 main.py complete --config config.json

# Pour un run simple
python3 main.py run --config config.json --mode FPS

# Avec mode verbose pour voir les métriques dynamiques
python3 main.py complete --config config.json --verbose

# Mode strict
python3 simulate.py --config config.json --mode FPS --strict

Aggrégation des logs /logs

# Installation rapide des dépendances
python -m pip install pyarrow

# Agrégation de tous les fichiers .csv et .json (tous dossiers confondus)
python3 aggregate_all.py -o aggregated/fps_dataset.h5

# Agrégation filtrée sur quelques métriques (tous dossiers confondus)
python3 aggregate_all.py --metrics "S(t),A_mean(t),effort(t)"

Outils optionnels

visualisations des dynamiques individuelles à chaque strate (remplacer dans le script par nom des logs que l'on veut observer)

python3 visualize_individual.py

Visualisation du spacing effect dans les pics d'exploration des combinaisons gamma et G

python3 analyze_spacing.py --csv logs/run_YYYYMMDD-HHMMSS_FPS_seed*.csv --cfg logs/config_run_YYYYMMDD-HHMMSS_FPS_seed*.json --out spacing_report

Visualisation des corrélations tau - performances pour raffinement éventuel du mode transcendant_synergy

python3 analyze_temporal_correlations.py

Apprentissage des états du systèmre : Il découvre ses propres états, apprend à les interpréter, et mémorise pour l'avenir

python3 sentiments.py --log run_*.csv --auto_K --memory_path sentiments_memory.json

Résultats attendus :

• ✅ effort(t) variable ∈ [0.27, 64.4] (dynamique contrôlée)
• ✅ Fichiers CSV nommés avec suffixe de mode (ex: run_20250701-190340_FPS_seed12345.csv)
• ✅ Détection automatique d'émergences (133 événements dans le dernier run)
• ✅ Génération de 5 visualisations + rapport HTML complet

---

Architecture du pipeline

Structure des modules

FPS_Project/
├── main.py              # Point d'entrée - pipeline unifié
├── config.json          # Configuration pré-phase 3
├── simulate.py          # Simulation avec naming unique
├── dynamics.py          # Équations FPS : S(t), An(t), fn(t), φn(t)
├── regulation.py        # Régulation : G(x), σn(t), γn(t)
├── metrics.py           # Métriques avec effort corrigé
├── analyze.py           # Analyse et scoring empirique
├── compare_modes.py     # Comparaison FPS vs contrôles
├── explore.py           # Détection d'émergences
├── visualize.py         # Visualisations et rapports
├── init.py              # Initialisation avec mode_suffix
├── utils.py             # Utilitaires et validation

Workflow opérationnel

1. Configuration : config.json avec paramètres dynamiques
2. Simulation : Génération des trajectoires avec naming unique
3. Métriques : Calcul avec effort saturé à MAX_EFFORT=100
4. Analyse : Scoring empirique et détection d'émergences
5. Comparaison : Validation vs Kuramoto et Neutral

---

Équations mathématiques implémentées

Signal global S(t) en mode extended

S(t) = Σₙ [Aₙ(t) · sin(2πfₙ(t)·t + φₙ) · γₙ(t) · G(Eₙ(t) - Oₙ(t))]

Où :

• Aₙ(t) : Amplitude adaptative de la strate n
• fₙ(t) : Fréquence dynamique
• φₙ : Phase initiale
• γₙ(t) : Facteur de latence (sinusoïdal dans la config actuelle)
• G(x) : Fonction de régulation (sinc dans la config actuelle)

Dynamique des amplitudes An(t)

An_t[n] = A0 * compute_sigma(In_t[n], k, x0)

Où compute_sigma est la fonction sigmoïde de plasticité.

Plasticité βₙ(t)

beta_n_t = beta_n * A_factor * t_factor  # Sans effort_factor (désactivé)

Où :

• A_factor = An_t[n] / A0 : Adaptation selon amplitude courante
• t_factor = 1.0 + 0.5 * sin(2π·t/T) : Modulation temporelle

Métrique d'effort

effort = Σₙ [|ΔAₙ|/(|Aₙ|+ε) + |Δfₙ|/(|fₙ|+ε) + |Δγₙ|/(|γₙ|+ε)]

Avec saturation : effort = min(effort, MAX_EFFORT) où MAX_EFFORT = 100.0

Extension S_i(t) - Couplage spatial gaussien

S_i(t) = Σ(j≠i) Oj(t) · w_ji · exp(-d²ij/(2σ²connexion)) / total_weight

Avec :

• Distance cyclique : distance = min(|i-j|, N-|i-j|)
• Portée adaptative : σ_connexion = N/4.0

---

Métriques et validation

Métriques principales (dernier run)

Métrique	Valeur	Score
mean_S	0.014	-
std_S	0.209	5/5 (très stable)
mean_effort	3.263	-
max_effort	64.415	Saturé correctement
entropy_S	0.823	5/5 (innovation maximale)
fluidity	0.549	3/5 (modérée)
mean_abs_error	0.040	5/5 (excellente régulation)
mean_C	0.991	Quasi-synchronisation
adaptive_resilience	0.736	3/5 (correcte)
cpu_efficiency	46335 ops/sec	5/5 (performance optimale)

Comparaison avec contrôles

SCORES GLOBAUX:
├── FPS:      0.687
├── Kuramoto: 0.490
└── Neutral:  0.228

EFFICIENCE FPS:
├── vs Kuramoto: +40.1%
└── vs Neutral:  +200.7%

ANALYSE PAR CRITÈRE:
├── Innovation:      FPS +477.6% vs Kuramoto
├── Stabilité:       FPS +1448.8% vs Kuramoto
├── Résilience:      FPS -26.4% vs Kuramoto
├── Fluidité:        FPS -44.7% vs Kuramoto
└── CPU efficiency:  FPS -79.2% vs Kuramoto

Événements d'émergence détectés

Dans le dernier run (T=50, dt=0.1) :

• Anomalies : 75 événements
• Émergences harmoniques : 35 événements
• Cycles de phase : 11 événements
• Patterns fractals : 12 événements
• Total : 133 événements détectés

---

Configuration actuelle

Paramètres système

{
  "system": {
    "N": 5,              // Nombre de strates
    "T": 50,             // Durée de simulation
    "dt": 0.1,           // Pas de temps
    "seed": 12345,       // Graine pour reproductibilité
    "signal_mode": "extended"  // Mode avec γₙ(t)·G(x)
  }
}

Paramètres dynamiques

{
  "dynamic_parameters": {
    "dynamic_phi": true,    // Phases φₙ(t) temporelles
    "dynamic_beta": true,   // Plasticité βₙ(t) adaptative
    "dynamic_gamma": true,  // Latence γ(t) expressive
    "dynamic_G": true       // Régulation G(x,t) temporelle
  }
}

Modes de régulation

{
  "latence": {
    "gamma_mode": "sinusoidal"  // γ(t) = 1 + A·sin(2πt/T)
  },
  "regulation": {
    "G_arch": "sinc"            // G(x) = sinc(λx)
  },
  "enveloppe": {
    "env_mode": "dynamic"       // σₙ(t) adaptatif
  }
}

---

Lecture des résultats

Structure des outputs

fps_pipeline_output/run_YYYYMMDD_HHMMSS/
├── logs/
│   ├── run_*_FPS_*.csv     # Métriques temporelles
│   ├── batch_run_*.csv         # Runs de validation
│   └── checksum_*.txt          # Intégrité des données
├── reports/
│   ├── comparison_fps_vs_controls.txt
│   ├── rapport_complet_fps.html
│   └── fps_exploration/        # Détails des émergences
├── figures/
│   ├── signal_evolution_fps.png
│   ├── metrics_dashboard.png
│   ├── criteria_terms_matrix.png
│   ├── empirical_grid.png
│   └── fps_vs_kuramoto.png
└── configs/

Indicateurs de bon fonctionnement

✅ Signes positifs :

• effort(t) oscille sans exploser (< 100)
• entropy_S > 0.7 (innovation)
• std_S < 0.3 (stabilité)
• Détection d'émergences > 133 événements
• Fichiers CSV avec suffixe de mode

⚠️ Points d'attention :

• effort(t) saturé à 100 fréquemment
• variance_d²S > 200

---

Tests et validation

Vérification de cohérence

# Vérifier les métriques dynamiques
python3 -c "
import pandas as pd
df = pd.read_csv('fps_pipeline_output/run_*/logs/run_*_FPS_*.csv')
print('effort(t) dynamique:', df['effort(t)'].std() > 0)
print('Valeur max effort:', df['effort(t)'].max())
"

# Tester la reproductibilité
python3 main.py run --config config.json --mode FPS  # Run 1
python3 main.py run --config config.json --mode FPS  # Run 2
# → Métriques identiques avec même seed

Benchmarks performance

Mesures empiriques actuelles :

• cpu_step(t) : ~0.000022s/strate/pas
• cpu_efficiency : ~46335 ops/sec
• Mémoire : ~50MB pour N=5, T=50
• Complexité : O(N·T) confirmée

---

Propriétés émergentes du système

Émergences documentées

1. Patterns fractals spontanés (12 détectés)

   • Auto-similarité non-programmée
   • Corrélations multi-échelles

2. Harmoniques temporelles (35 détectées)

   • Résonances naturelles
   • Périodicité émergente

3. Cycles de phase (11 détectés)

   • Synchronisation/désynchronisation adaptative
   • Transitions de phase

Caractéristiques système

• Innovation sans instabilité : +477.6% avec stabilité +1448.8% vs Kuramoto
• Désynchronisation productive : mean_C = 0.991 (quasi-sync)
• Adaptation énergétique : effort contrôlé malgré complexité
• Robustesse : Pas d'explosion numérique avec MAX_EFFORT

---

Prochaines étapes (Phase 3)

1. Latence adaptative : γₙ(t) fonction de l'état du système
2. G(x) réellement adaptative : Régulation contextuelle
3. Scaling avancé : Validation N > 50, T > 1000
4. Optimisation performance : Réduire effort, améliorer fluidité et résilience

---

Contribution et support

Principes de développement

1. Maintenir la cohérence : Vérifier métriques à chaque changement
2. Préserver la reproductibilité : Seeds et naming rigoureux
3. Documenter les émergences : Explorer les patterns détectés
4. Valider empiriquement : Toujours comparer avec contrôles

Ressources

• Repository : FPS Tests
• Documentation théorique : FPS_Paper.docx
• Logs de développement : docs/CHANGELOG.md

---

Conclusion

La FPS en pré-phase 3 est un système pleinement opérationnel démontrant des propriétés émergentes remarquables. Avec une performance supérieure aux modèles de référence (+40.1% vs Kuramoto) et une stabilité maintenue malgré la complexité dynamique, le pipeline est prêt pour l'implémentation des fonctionnalités adaptatives de la phase 3.

🌀 La spirale fractale pulse avec cohérence et créativité ! 🌀

---

FPS v1.4 - Système adaptatif à émergence fractale
Pipeline validé : 296 événements émergents, reproductibilité 100%
© 2025 Gepetto & Andréa Gadal & Claude - Recherche collaborative