Upload app.py

app.py

@@ -0,0 +1,467 @@
+import numpy as np
+from scipy.integrate import odeint
+import emcee
+import panel as pn
+import param
+import plotly.graph_objects as go
+from plotly.subplots import make_subplots
+import plotly.io as pio
+
+
+# Définition du thème sombre
+pio.templates.default = "plotly_dark"
+
+# Initialiser l'extension Panel
+pn.extension('katex', 'mathjax', 'plotly')
+
+# Informations personnelles
+photo_url = "PPFB.png"
+prenom = "Yaya"
+nom = "Toure"
+email = "[email protected]"
+whatsapps_url = "https://wa.me/message/GW7RWRW3GR4WN1"
+linkedin_url = "https://www.linkedin.com/in/yaya-toure-8251a4280/"
+github_url = "https://github.com/CodingYayaToure"
+universite = "UNCHK"
+formation = "Licence Analyse Numerique et Modelisation | Master Calcul scientifique et Modelisation"
+certificat = "Collecte et Fouille de Donnees (UADB-CNAM Paris)"
+TP_Scilab = "https://codingyayatoure.github.io/Equation_de_Transport_en_1D_par_la_Methode_des_Differences_Finis/"
+
+# Créer le template du tableau de bord
+template = pn.template.ReactTemplate(title='Progiciel de Simulation des Interactions Microbiennes en Fermentation de Jus de Légumes. | Approche Modélisation mathématique ')
+
+# Classe pour la dynamique Consumer-Resource
+class ConsumerResourceApp(param.Parameterized):
+    # Paramètres du modèle
+    r = param.Number(10.0, bounds=(0.1, 20.0), step=0.1, doc="Taux d'approvisionnement en ressources")
+    d = param.Number(0.1, bounds=(0.01, 1.0), step=0.01, doc="Taux de mortalité des consommateurs")
+    c = param.Number(0.1, bounds=(0.01, 1.0), step=0.01, doc="Coefficient de consommation")
+    K = param.Number(1.0, bounds=(0.1, 10.0), step=0.1, doc="Concentration à laquelle la croissance est à moitié maximale")
+    X0 = param.Number(1.0, bounds=(0.1, 10.0), step=0.1, doc="Population initiale des consommateurs")
+    S0 = param.Number(5.0, bounds=(0.1, 20.0), step=0.1, doc="Concentration initiale de la ressource")
+    
+    @param.depends('r', 'd', 'c', 'K', 'X0', 'S0')
+    def view(self):
+        # Fonction de croissance dépendante de la ressource (Monod)
+        def mu(S):
+            return S / (self.K + S)
+
+        # Équations différentielles
+        def model(y, t):
+            X, S = y
+            dXdt = mu(S) * X - self.d * X  # Dynamique des consommateurs
+            dSdt = self.r - self.c * mu(S) * X  # Dynamique des ressources
+            return [dXdt, dSdt]
+
+        # Conditions initiales
+        y0 = [self.X0, self.S0]
+
+        # Temps pour la simulation (en heures)
+        t_hours = np.linspace(0, 100, 500)
+
+        # Résoudre le système d'équations différentielles
+        solution = odeint(model, y0, t_hours)
+
+        # Créer les graphiques avec Plotly en utilisant des sous-graphiques
+        fig = make_subplots(
+            rows=1, cols=3,
+            specs=[[{'type': 'scatter'}, {'type': 'scatter'}, {'type': 'scatter'}]],
+            subplot_titles=["Population des Consommateurs (X)", "Concentration de la Ressource (S)", "Population et Ressource sur le même repère"]
+        )
+        
+        # Ajouter la trace pour les consommateurs
+        fig.add_trace(go.Scatter(x=t_hours, y=solution[:, 0], mode='lines', name='Population des Consommateurs (X)', line=dict(color='blue')), row=1, col=1)
+
+        # Ajouter la trace pour les ressources
+        fig.add_trace(go.Scatter(x=t_hours, y=solution[:, 1], mode='lines', name='Concentration de la Ressource (S)', line=dict(color='green')), row=1, col=2)
+
+        # Ajouter la trace pour les consommateurs et les ressources sur le même graphique
+        fig.add_trace(go.Scatter(x=t_hours, y=solution[:, 0], mode='lines', name='Population des Consommateurs (X)', line=dict(color='blue')), row=1, col=3)
+        fig.add_trace(go.Scatter(x=t_hours, y=solution[:, 1], mode='lines', name='Concentration de la Ressource (S)', line=dict(color='green')), row=1, col=3)
+
+        # Mettre à jour la mise en page du graphique
+        fig.update_layout(
+            title='Dynamique du Modèle Consumer-Resource',
+            xaxis_title='Temps',
+            yaxis_title='Population / Concentration',
+            legend_title='Légende',
+            height=400,
+            width=1500,
+            font_color="white",
+            template='plotly_dark'
+        )
+
+        return pn.pane.Plotly(fig)
+
+    def panel_view(self):
+        return pn.Column(
+            pn.Row(pn.Param(self, width=400), self.formulas()),  # Aligner les widgets et les formules sur la même ligne
+            self.view  # Appeler la vue pour qu'elle se mette à jour dynamiquement
+        )
+
+    def formulas(self):
+        return pn.Column(
+            pn.pane.LaTeX(r"""
+            $$
+            \text{Fonction de croissance : } \mu(S) = \frac{S}{K + S}
+            $$
+            """, styles={'font-size': '16pt'}),
+            pn.pane.LaTeX(r"""
+            $$
+            \text{Dynamique des consommateurs : } \frac{dX}{dt} = \mu(S) \times X - d \times X
+            $$
+            """, styles={'font-size': '16pt'}),
+            pn.pane.LaTeX(r"""
+            $$
+            \text{Dynamique des ressources : } \frac{dS}{dt} = r - c \times \mu(S) \times X
+            $$
+            """, styles={'font-size': '16pt'})
+        )
+
+# Classe pour la dynamique des populations microbiennes
+class MicrobialDynamicsApp(param.Parameterized):
+    # Paramètres du modèle pour la dynamique des populations microbiennes
+    r1 = param.Number(0.5, bounds=(0.1, 1.0), step=0.01, doc="Taux de croissance espèce 1")
+    r2 = param.Number(0.3, bounds=(0.1, 1.0), step=0.01, doc="Taux de croissance espèce 2")
+    K1 = param.Number(100, bounds=(10, 200), step=1, doc="Capacité de charge espèce 1")
+    K2 = param.Number(80, bounds=(10, 200), step=1, doc="Capacité de charge espèce 2")
+    alpha = param.Number(0.01, bounds=(0.001, 0.1), step=0.001, doc="Compétition espèce 2 sur espèce 1")
+    beta = param.Number(0.01, bounds=(0.001, 0.1), step=0.001, doc="Compétition espèce 1 sur espèce 2")
+    
+    @param.depends('r1', 'r2', 'K1', 'K2', 'alpha', 'beta')
+    def view(self):
+        # Équations différentielles pour les populations microbiennes
+        def model(y, t):
+            X1, X2 = y
+            dX1dt = self.r1 * X1 * (1 - (X1 + self.alpha * X2) / self.K1)
+            dX2dt = self.r2 * X2 * (1 - (X2 + self.beta * X1) / self.K2)
+            return [dX1dt, dX2dt]
+
+        # Conditions initiales
+        y0 = [10, 5]  # Population initiale des deux espèces
+
+        # Temps pour la simulation
+        t = np.linspace(0, 50, 500)
+
+        # Résoudre le système d'équations différentielles
+        solution = odeint(model, y0, t)
+
+        # Créer le graphique avec Plotly
+        fig = go.Figure()
+        fig.add_trace(go.Scatter(x=t, y=solution[:, 0], mode='lines', name='Espèce 1', line=dict(color='red')))
+        fig.add_trace(go.Scatter(x=t, y=solution[:, 1], mode='lines', name='Espèce 2', line=dict(color='purple')))
+
+        # Mettre à jour la mise en page du graphique
+        fig.update_layout(
+            title='Dynamique des Populations Microbiennes',
+            xaxis_title='Temps',
+            yaxis_title='Population',
+            legend_title='Légende',
+            height=400,
+            width=1500,
+            font_color="white",
+            template='plotly_dark'
+        )
+
+        return pn.pane.Plotly(fig)
+
+    def panel_view(self):
+        return pn.Column(
+            pn.Row(pn.Param(self, width=400), self.formulas()),  # Aligner les widgets et les formules sur la même ligne
+            self.view  # Appeler la vue pour qu'elle se mette à jour dynamiquement
+        )
+
+    def formulas(self):
+        return pn.Column(
+            pn.pane.LaTeX(r"""
+            $$
+            \frac{{dX_1}}{{dt}} = r_1 X_1 \left( 1 - \frac{{X_1 + \alpha X_2}}{{K_1}} \right)
+            $$
+            """, styles={'font-size': '16pt'}),
+            pn.pane.LaTeX(r"""
+            $$
+            \frac{{dX_2}}{{dt}} = r_2 X_2 \left( 1 - \frac{{X_2 + \beta X_1}}{{K_2}} \right)
+            $$
+            """, styles={'font-size': '16pt'})
+        )
+
+# Classe pour la modélisation de la fermentation
+class FermentationModelApp(param.Parameterized):
+    # Paramètres du modèle de fermentation
+    mu_max = param.Number(0.8, bounds=(0.1, 2.0), step=0.1, doc="Taux de croissance maximal")
+    Ks = param.Number(10.0, bounds=(1.0, 50.0), step=1.0, doc="Constante de demi-saturation")
+    Yxs = param.Number(0.5, bounds=(0.1, 1.0), step=0.1, doc="Rendement de croissance sur substrat")
+    Sin = param.Number(20.0, bounds=(10.0, 100.0), step=1.0, doc="Concentration initiale en substrat")
+    X0 = param.Number(0.1, bounds=(0.01, 5.0), step=0.01, doc="Concentration initiale en biomasse")
+    P0 = param.Number(0.0, bounds=(0.0, 5.0), step=0.1, doc="Concentration initiale en produit")
+    
+    @param.depends('mu_max', 'Ks', 'Yxs', 'Sin', 'X0', 'P0')
+    def view(self):
+        # Équations différentielles pour la fermentation
+        def model(y, t):
+            X, S, P = y
+            mu = self.mu_max * S / (self.Ks + S)
+            dXdt = mu * X
+            dSdt = -dXdt / self.Yxs
+            dPdt = 0.1 * dXdt  # Production de produit proportionnelle à la croissance
+            return [dXdt, dSdt, dPdt]
+
+        # Conditions initiales
+        y0 = [self.X0, self.Sin, self.P0]
+
+        # Temps pour la simulation
+        t = np.linspace(0, 50, 500)
+
+        # Résoudre le système d'équations différentielles
+        solution = odeint(model, y0, t)
+
+        # Créer le graphique avec Plotly
+        fig = go.Figure()
+        fig.add_trace(go.Scatter(x=t, y=solution[:, 0], mode='lines', name='Biomasse (X)', line=dict(color='blue')))
+        fig.add_trace(go.Scatter(x=t, y=solution[:, 1], mode='lines', name='Substrat (S)', line=dict(color='green')))
+        fig.add_trace(go.Scatter(x=t, y=solution[:, 2], mode='lines', name='Produit (P)', line=dict(color='orange')))
+
+        # Mettre à jour la mise en page du graphique
+        fig.update_layout(
+            title='Modélisation de la Fermentation',
+            xaxis_title='Temps',
+            yaxis_title='Concentration',
+            legend_title='Légende',
+            height=400,
+            width=1500,
+            font_color="white",
+            template='plotly_dark'
+        )
+
+        return pn.pane.Plotly(fig)
+
+        
+    def formulas(self):
+        return pn.Column(
+            pn.pane.LaTeX(r"""
+            $$
+            \mu = \frac{{\mu_{{\text{{max}}}} \cdot S}}{{K_s + S}}
+            $$
+            """, styles={'font-size': '16pt'}),
+            pn.pane.LaTeX(r"""
+            $$
+            \frac{{dX}}{{dt}} = \mu \cdot X
+            $$
+            """, styles={'font-size': '16pt'}),
+            pn.pane.LaTeX(r"""
+            $$
+            \frac{{dS}}{{dt}} = -\frac{1}{{Y_{{xs}}}} \cdot \frac{{dX}}{{dt}}
+            $$
+            """, styles={'font-size': '16pt'}),
+            pn.pane.LaTeX(r"""
+            $$
+            \frac{{dP}}{{dt}} = 0.1 \cdot \frac{{dX}}{{dt}}
+            $$
+            """, styles={'font-size': '16pt'})
+        )
+
+    
+
+    def panel_view(self):
+        return pn.Column(
+            pn.Row(pn.Param(self, width=400), self.formulas()),  # Aligner les widgets et les formules sur la même ligne
+            self.view  # Appeler la vue pour qu'elle se mette à jour dynamiquement
+        )
+
+# Classe pour l'estimation des paramètres par MCMC
+class EstimationParametresFermentation(param.Parameterized):
+    # Paramètres pour l'estimation MCMC
+    n_marcheurs = param.Integer(32, bounds=(10, 100), doc="Nombre de marcheurs MCMC")
+    n_etapes = param.Integer(1000, bounds=(100, 5000), doc="Nombre d'étapes MCMC")
+    niveau_bruit = param.Number(0.1, bounds=(0.01, 0.5), doc="Niveau de bruit dans les données synthétiques")
+    
+    def __init__(self, **params):
+        super().__init__(**params)
+        self.parametres_reels = {
+            'mu_max': 0.8,
+            'Ks': 10.0,
+            'Yxs': 0.5
+        }
+    
+    def generer_donnees_synthetiques(self, t):
+        def modele(y, t, mu_max, Ks, Yxs):
+            X, S, P = y
+            mu = mu_max * S / (Ks + S)
+            dXdt = mu * X
+            dSdt = -dXdt / Yxs
+            dPdt = 0.1 * dXdt
+            return [dXdt, dSdt, dPdt]
+        
+        y0 = [0.1, 20.0, 0.0]
+        solution = odeint(modele, y0, t, args=(self.parametres_reels['mu_max'], self.parametres_reels['Ks'], self.parametres_reels['Yxs']))
+        bruit = np.random.normal(0, self.niveau_bruit, solution.shape)
+        return solution + bruit
+    
+    def log_vraisemblance(self, theta, t, donnees):
+        mu_max, Ks, Yxs = theta
+        
+        def modele(y, t, mu_max, Ks, Yxs):
+            X, S, P = y
+            mu = mu_max * S / (Ks + S)
+            dXdt = mu * X
+            dSdt = -dXdt / Yxs
+            dPdt = 0.1 * dXdt
+            return [dXdt, dSdt, dPdt]
+        
+        y0 = [0.1, 20.0, 0.0]
+        try:
+            solution = odeint(modele, y0, t, args=(mu_max, Ks, Yxs))
+            sigma2 = self.niveau_bruit ** 2
+            return -0.5 * np.sum((donnees - solution) ** 2 / sigma2 + np.log(2 * np.pi * sigma2))
+        except:
+            return -np.inf
+    
+    def log_apriori(self, theta):
+        mu_max, Ks, Yxs = theta
+        if 0.1 < mu_max < 2.0 and 1.0 < Ks < 50.0 and 0.1 < Yxs < 1.0:
+            return 0.0
+        return -np.inf
+    
+    def log_probabilite(self, theta, t, donnees):
+        lp = self.log_apriori(theta)
+        if not np.isfinite(lp):
+            return -np.inf
+        return lp + self.log_vraisemblance(theta, t, donnees)
+    
+    def lancer_mcmc(self):
+        t = np.linspace(0, 50, 50)
+        donnees = self.generer_donnees_synthetiques(t)
+        ndim = 3
+        pos = [
+            [self.parametres_reels['mu_max'], self.parametres_reels['Ks'], self.parametres_reels['Yxs']] + 1e-4 * np.random.randn(ndim)
+            for i in range(self.n_marcheurs)
+        ]
+        sampler = emcee.EnsembleSampler(self.n_marcheurs, ndim, self.log_probabilite, args=(t, donnees))
+        sampler.run_mcmc(pos, self.n_etapes, progress=True)
+        return sampler, t, donnees
+    
+    @param.depends('n_marcheurs', 'n_etapes', 'niveau_bruit')
+    def vue(self):
+        sampler, t, donnees = self.lancer_mcmc()
+        
+        fig = make_subplots(rows=2, cols=2,
+                            subplot_titles=('Chaînes MCMC', 'Distribution postérieure', 'Ajustement du modèle', 'Corrélations des paramètres'))
+        
+        echantillons = sampler.get_chain()
+        
+        # Tracer les chaînes MCMC
+        for i in range(3):
+            fig.add_trace(go.Scatter(y=echantillons[:, 0, i], mode='lines', name=f'Paramètre {i+1}'), row=1, col=1)
+        
+        echantillons_plats = sampler.get_chain(discard=100, thin=15, flat=True)
+        
+        # Tracer les distributions postérieures
+        for i in range(3):
+            fig.add_trace(go.Histogram(x=echantillons_plats[:, i], name=f'Paramètre {i+1}', nbinsx=30), row=1, col=2)
+    
+        params_med = np.median(echantillons_plats, axis=0)
+        y0 = [0.1, 20.0, 0.0]
+    
+        # Définir une fonction de modèle pour odeint
+        def modele(y, t):
+            mu_max, Ks, Yxs = params_med
+            X, S, P = y
+            mu = mu_max * S / (Ks + S)
+            dXdt = mu * X
+            dSdt = -dXdt / Yxs
+            dPdt = 0.1 * dXdt
+            return [dXdt, dSdt, dPdt]
+    
+        # Utiliser la fonction de modèle dans odeint
+        solution = odeint(modele, y0, t)
+    
+        fig.add_trace(go.Scatter(x=t, y=donnees[:, 0], mode='markers', name='Données (X)', marker=dict(color='blue')), row=2, col=1)
+        fig.add_trace(go.Scatter(x=t, y=solution[:, 0], mode='lines', name='Modèle (X)', line=dict(color='red')), row=2, col=1)
+    
+        # Tracer les corrélations des paramètres
+        fig.add_trace(go.Scatter(x=echantillons_plats[:, 0], y=echantillons_plats[:, 1],
+                                 mode='markers', marker=dict(size=2),
+                                 name='mu_max vs Ks'), row=2, col=2)
+    
+        fig.update_layout(height=400, width=1200,
+                          showlegend=True,
+                          template='plotly_dark')
+        
+        return pn.pane.Plotly(fig)
+   
+    def vue_panneau(self):
+        return pn.Column(
+            pn.Row(
+                pn.Param(self.param,
+                         widgets={
+                             'n_marcheurs': pn.widgets.IntSlider,
+                             'n_etapes': pn.widgets.IntSlider,
+                             'niveau_bruit': pn.widgets.FloatSlider}),
+                self.description_mcmc()
+            ),
+            self.vue  # Correction pour supprimer '()' et référencer dynamiquement
+        )
+    
+    def description_mcmc(self):
+        return pn.pane.Markdown("""
+# Estimation des paramètres par MCMC
+## Cette section permet d'estimer les paramètres du modèle de fermentation en utilisant l'algorithme MCMC (Markov Chain Monte Carlo).
+- ## **n_marcheurs**: Nombre de chaînes MCMC parallèles.
+- ## **n_etapes**: Nombre d'itérations pour chaque chaîne.
+- ## **niveau_bruit**: Niveau de bruit dans les données synthétiques.
+## Les graphiques montrent:
+### 1. L'évolution des chaînes MCMC.
+### 2. Les distributions postérieures des paramètres.
+### 3. L'ajustement du modèle aux données.
+### 4. Les corrélations entre les paramètres.
+""")
+
+# Informations personnelles et photo
+photo = pn.pane.PNG(photo_url, width=200, height=200)
+info = pn.Column(
+    pn.pane.Markdown(f"<div style='font-size:16px'><strong>Prénom</strong>: {prenom}</div>"),
+    pn.pane.Markdown(f"<div style='font-size:16px'><strong>Nom</strong>: {nom}</div>"),
+    pn.pane.Markdown(f"<div style='font-size:16px'><strong>Email</strong>: <a href='mailto:{email}'>{email}</a></div>"),
+    #pn.pane.Markdown(f"<div style='font-size:16px'><strong>WhatsApp</strong>: <a href='{whatsapps_url}'>WhatsApp</a></div>"),
+    #pn.pane.Markdown(f"<div style='font-size:16px'><strong>LinkedIn</strong>: <a href='{linkedin_url}'>LinkedIn</a></div>"),
+   # pn.pane.Markdown(f"<div style='font-size:16px'><strong>GitHub</strong>: <a href='{github_url}'>GitHub</a></div>"),
+    pn.pane.Markdown(f"<div style='font-size:16px'><strong>Université</strong>: {universite}</div>"),
+    pn.pane.Markdown(f"<div style='font-size:16px'><strong>Formation</strong>: {formation}</div>"),
+    pn.pane.Markdown(f"<div style='font-size:16px'><strong>Certificat</strong>: {certificat}</div>"),
+    pn.pane.Markdown(f"<div style='font-size:16px'><strong>Autre Projet </strong>: <a href='{TP_Scilab}'>Pour comprendre l'équation de Transport en 1D avec Scilab</a></div>"),
+    sizing_mode='stretch_width'
+)
+
+
+
+# Créer les applications
+consumer_app = ConsumerResourceApp()
+microbial_app = MicrobialDynamicsApp()
+ferm_app = FermentationModelApp()
+
+# Créer l'application
+application_estimation_parametres = EstimationParametresFermentation()
+
+# Afficher l'application Panel
+#template = pn.template.ReactTemplate(title='Estimation des paramètres par MCMC')
+#template.main[0, 0] = application_estimation_parametres.vue_panneau()
+
+
+# Créer la mise en page
+layout = pn.Row(
+    pn.Column(photo, info, width=300),  # Ajouter la photo et les informations personnelles à gauche
+    pn.Column(
+        pn.Tabs(
+            ('Consumer-Resource Dynamics', consumer_app.panel_view()),
+            ('Microbial Dynamics', microbial_app.panel_view()),
+            (' Fermentation', ferm_app.panel_view()),
+            ('Estimation Parametres', application_estimation_parametres.vue_panneau())
+        )
+    )
+)
+
+# Ajouter le layout au template principal
+template.main[0, 0] = layout
+
+# Exécuter l'application
+template.servable()