Dépôt : STaRS × ESE — Full Pipeline 2026

Dépôt : STaRS × ESE — Full Pipeline 2026 STaRS_ESE/ ├─ LICENSE.md ├─ README.md ├─ stars_core.py ├─ ese_core.py ├─ pipeline_figure.py ├─ examples/ │ ├─ example_stars.py │ ├─ example_stars_net.py │ ├─ example_ese.py └─ figures/ LICENSE.md © 2026 Kevin Fradier — Creative Commons Attribution - Pas d’Utilisation Commerciale - Pas de Modification 4.0 International (CC BY-NC-ND 4.0) README.md STaRS × ESE — Pipeline Méthodologique Universel Auteur : Kevin Fradier — Chercheur indépendant 🇫🇷 Licence : CC BY-NC-ND 4.0 Description STaRS et ESE sont des outils universels bottom-up pour détecter, quantifier et tester des structures robustes dans des données scientifiques, sans interprétation causale : STaRS : colonnes stratigraphiques fossiles, robustesse locale et inter-bassins (STaRS-NET) ESE : séquences, champs, réseaux, multi-domaines (ESE-NET) Pipeline complet : STaRS local → STaRS-NET → ESE-NET → résultats publiables ⚠️ Message clé : STaRS et ESE ne disent pas ce qui s'est passé. Ils indiquent jusqu'où les données peuvent parler. Installation git clone https://github.com/ton-compte/STaRS_ESE.git cd STaRS_ESE pip install numpy scipy hurst matplotlib scikit-learn Exemples d'usage # STaRS local from examples.example_stars import run_stars_example run_stars_example() # STaRS-NET from examples.example_stars_net import run_stars_net_example run_stars_net_example() # ESE multi-domaines from examples.example_ese import run_ese_example run_ese_example() # Générer figure condensée pipeline from pipeline_figure import * Principe Bottom-up : pas d'hypothèse globale Falsifiable : comparaison au bruit Reproductible : graine + hash explicite Multi-domaines : fossiles, champs, séquences, réseaux Sécurisé publiquement : pas de cause ni scénario Structure du dépôt stars_core.py→ STaRS local + inter-bassins ese_core.py→ ESE multi-domaines pipeline_figure.py→ Figure pipeline condensée STaRS × ESE examples/→ Exemples opérationnels prêts à lancer figures/→ Pour sauvegarder les chiffres émergents Résultats publiables Courbes enregistrées / enveloppes de bruit Graphes réseaux Scores : STaRS local, NRSS réseau, ESE multi-domaines Hachages de reproductibilité ❌ Interdit : interprétation causale, extinction, scénario, climat Philosophie Critique d'immunité maximale Standardisation du pipeline Applicable à tout domaine où la structure peut être testée STaRS-TIME / STaRS-EXT → cas d'application, pas d'outil supplémentaire Exemple rapide — stars_core.py from stars_core import STaRS_analyze import numpy as np strat_data = [np.random.randint(0,5,10) for _ in range(8)] result = STaRS_analyze(strat_data) print(result) Figures pipeline Figure condensée prête à publier :pipeline_figure.py Blocages couleur par phase, flèches entre modules, message méthodologique clair ✅ . . exemples/exemple_stars.py — STaRS local # Exemple opérationnel STaRS local import numpy as np from stars_core import STaRS_analyze def run_stars_example(): # Données stratigraphiques simulées strat_data = [np.random.randint(0, 5, 10) for _ in range(8)] result = STaRS_analyze(strat_data) print("\n✅ Résultat STaRS local :") print("Mean Entropy :", result["mean_entropy"]) print("Robustness Corr :", result["robustness_corr"]) print("Robustness Std :", result["robustness_std"]) print("Hash :", result["hash"]) if __name__ == "__main__": run_stars_example() exemples/example_stars_net.py — Inter-bassins STaRS-NET # Exemple opérationnel STaRS-NET inter-bassins import numpy as np from stars_core import STaRS_analyze def generate_network(basins_data): """Construction réseau simple : corrélation entre bassins""" n = len(basins_data) corr_matrix = np.zeros((n, n)) sums = [np.sum(b) for b in basins_data] for i in range(n): for j in range(n): if i != j: corr_matrix[i,j] = np.corrcoef(sums[i], sums[j])[0,1] if np.std(sums[i])*np.std(sums[j])>0 else 0 return corr_matrix def run_stars_net_example(): # Simuler plusieurs bassins basins_data = [[np.random.randint(0,5,10) for _ in range(8)] for _ in range(5)] # Calculer STaRS pour chaque bassin results = [STaRS_analyze(b) for b in basins_data] print("\n✅ Scores STaRS locaux :") for i,r in enumerate(results): print(f"Bassin {i+1} Hash {r['hash']} Robustness {r['robustness_corr']:.2f}") # Construire réseau inter-bassins network = generate_network(basins_data) print("\n✅ Matrice corrélation inter-bassins :") print(np.round(network,2)) if __name__ == "__main__": run_stars_net_example() examples/example_ese.py — ESE multi-domaines # Exemple opérationnel ESE multi-domaines import numpy as np from ese_core import ese_analyze def run_ese_example(): # Exemple séquence symbolique seq = "AGCTTAGGCTAAGCTTAGGCTA"*10 metrics_seq = ese_analyze(seq, data_type='sequence') print("\n✅ Analyse séquence (ESE) :") print("Entropy :", metrics_seq["entropy"]) print("Compression :", metrics_seq["compression"]) print("Hurst :", metrics_seq["hurst"]) print("Hash :", metrics_seq["hash"]) # Exemple champ spatial field = np.random.randn(128,128) metrics_field = ese_analyze(field, data_type='spatial') print("\n✅ Analyse champ spatial (ESE) :") print("Mean field :", metrics_field["mean_field"]) print("Std field :", metrics_field["std_field"]) print("Radial power (sample) :", metrics_field["radial_power"][:5]) print("Hash :", metrics_field["hash"]) if __name__ == "__main__": run_ese_example() ✅ Tout est prêt pour le dépôt : STaRS local et inter-bassins → example_stars.pyetexample_stars_net.py ESE multi-domaines →example_ese.py Chaque script génère des scores, du hash, de la robustesse et des résultats testables Compatible avec le pipeline condensé (figure + README) pipeline tout-en-un : STaRS local → STaRS-NET inter-bassins → ESE multi-domaines → figure condensée du pipeline, tout dans un seul script prêt-à-lancer . 🚀 pipeline_all.py """ Pipeline complet STaRS × ESE Auteur : Kevin Fradier — Chercheur indépendant 🇫🇷 Licence : CC BY-NC-ND 4.0 Description : Exécution complète STaRS local, STaRS-NET inter-bassins, ESE multi-domaines, et génération de la figure condensée du pipeline avec scores et hashes. """ import numpy as np import hashlib import matplotlib.pyplot as plt from matplotlib.patches import FancyBboxPatch, ConnectionPatch # ----------------------------- # STaRS CORE # ----------------------------- AUTHOR_SIGNATURE = "Kevin Fradier | STaRS | 2026" def simulate_taphonomic_noise(counts, loss_rate=0.3): noisy = [] for level in counts: mask = np.random.rand(len(level)) > loss_rate noisy.append(level * mask) return noisy def strat_entropy(level): p = level / np.sum(level) if np.sum(level)>0 else level p = p[p>0] return -np.sum(p*np.log2(p)) def robustness_test(data, n_iter=50): original = np.array([np.sum(l) for l in data]) scores = [] for _ in range(n_iter): perturbed = simulate_taphonomic_noise(data) pert = np.array([np.sum(l) for l in perturbed]) corr = np.corrcoef(original, pert)[0,1] scores.append(corr) return np.nanmean(scores), np.nanstd(scores) def STaRS_analyze(strat_data): entropies = [strat_entropy(l) for l in strat_data] mean_corr, std_corr = robustness_test(strat_data) result = { "mean_entropy": float(np.mean(entropies)), "robustness_corr": mean_corr, "robustness_std": std_corr, "signature": AUTHOR_SIGNATURE } h = hashlib.sha256(str(result).encode()).hexdigest() result["hash"] = h return result # ----------------------------- # STaRS-NET (inter-bassins) # ----------------------------- def generate_network(basins_data): n = len(basins_data) corr_matrix = np.zeros((n, n)) sums = [np.sum(b) for b in basins_data] for i in range(n): for j in range(n): if i != j: corr_matrix[i,j] = np.corrcoef(sums[i], sums[j])[0,1] if np.std(sums[i])*np.std(sums[j])>0 else 0 return corr_matrix # ----------------------------- # ESE CORE # ----------------------------- import zlib from hurst import compute_Hc from scipy.ndimage import gaussian_filter ESE_AUTHOR_SIGNATURE = "Kevin Fradier | ESE | 2026" def shannon_entropy(seq): probs = [seq.count(c)/len(seq) for c in set(seq)] return -sum(p*np.log2(p) for p in probs if p>0) def compression_ratio(seq): raw = bytes(seq, 'utf-8') return len(zlib.compress(raw))/len(raw) def hurst_exponent(seq): numeric = np.array([ord(c) for c in seq]) H, _, _ = compute_Hc(numeric, kind='change') return H def ese_analyze(data, data_type='sequence'): result = {"signature": ESE_AUTHOR_SIGNATURE} if data_type=='sequence': result.update({ "entropy": shannon_entropy(data), "compression": compression_ratio(data), "hurst": hurst_exponent(data) }) elif data_type=='spatial': field_corr = gaussian_filter(data, sigma=3) fft2 = np.fft.fftshift(np.fft.fft2(field_corr)) power = np.abs(fft2)**2 mean, std = np.mean(data), np.std(data) result.update({ "mean_field": mean, "std_field": std, "radial_power": power[:5, :5].tolist() # échantillon pour affichage }) h = hashlib.sha256(str(result).encode()).hexdigest() result["hash"] = h return result # ----------------------------- # EXECUTION PIPELINE # ----------------------------- def run_pipeline(): print("\n=== STaRS LOCAL ===") # Simuler 5 bassins basins_data = [[np.random.randint(0,5,10) for _ in range(8)] for _ in range(5)] stars_results = [STaRS_analyze(b) for b in basins_data] for i,r in enumerate(stars_results): print(f"Bassin {i+1} Hash {r