[PYTHON] Transformez le programme de calcul du modèle SIR en une interface graphique

introduction

Dans l'article précédent, j'ai décrit le modèle SIR qui explique la propagation des maladies infectieuses. À ce moment-là, j'ai également publié un programme Python d'intégration numérique qui résout le modèle SIR. Dans cet article, je vais essayer de faire du programme Python une interface graphique.

Article précédent: Modèle de prédiction mathématique des maladies infectieuses (modèle SIR): étude de cas (1) https://qiita.com/kotai2003/items/d74583b588841e6427a2

Description de l'interface graphique

La raison de la conversion du programme que j'ai créé en une interface graphique est "Je veux que les autres l'utilisent". À l'avenir, je voudrais le distribuer sous la forme de setup.exe, pas seulement le code Py de l'interface graphique.

Tout d'abord, la configuration d'écran de l'interface graphique créée cette fois. Entrez le taux d'infection du modèle SIR (bêta) et le taux d'élimination (gamma) dans les espaces à droite et appuyez sur le bouton Dessiner en dessous pour tracer les résultats du calcul du modèle SIR sur l'écran central.

\begin{align}

\frac{dS}{dt} &= -\beta SI \\
\frac{dI}{dt} &=  \beta SI -\gamma I \\
\frac{dR}{dt} &=  \gamma I \\

\end{align} 

\begin{align}
S &:Personne infectable\quad \text{(Susceptible)}　\\
I &:Personne infectée\quad \text{(Infectious)}　\\
R &:Ceux qui sont décédés après une infection ou qui ont acquis une immunité\quad \text{(Removed)}　\\
\beta &:Taux d'infection\quad \text{(The infectious rate)} \quad [1/day] \\
\gamma &:Taux d'exclusion\quad \text{(The Recovery rate)} \quad [1/day]　\\
\end{align}

L'écran initial indique Condition typique ~, mais ceci est pour référence lors de la saisie du taux d'infection (Bêta) et du taux d'élimination (Gamma).

L'écran suivant affiche le résultat du calcul. Le résultat de l'intégration numérique du modèle SIR est affiché dans Line Plot. Les valeurs nouvellement entrées du taux d'infection (bêta) et du taux d'élimination (gamma) seront mises à jour dans le titre.

Vous pouvez quitter l'interface graphique en appuyant sur le bouton Quitter en bas à droite.

Description du programme

La bibliothèque GUI utilisait Tkinter. Je vais expliquer brièvement le fonctionnement du programme.

(1) Préparez le widget Canvas avec Tkinter. Dans le widget d'entrée de Tkinter, préparez une zone de texte pour entrer le taux d'infection (bêta) et le taux de suppression (gamma). (2) Calculez le modèle SIR avec scipy et tracez le résultat avec matplotlib. (3) Dessinez la figure matplotlib avec le widget Canvas.

Importez les bibliothèques requises.

import tkinter
import tkinter.messagebox as tkmsg
import matplotlib.pyplot as plt
from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg
from matplotlib.backends.backend_tkagg import NavigationToolbar2Tk

import numpy as np
from functools import partial
from scipy.integrate import odeint

Préparez les fonctions requises pour l'intégration numérique du modèle SIR.

# SIR Differential Equation
def SIR_EQ(v, t, beta, gamma):
    '''
    dS/dt = -beta * S * I
    dI/dt = beta * S * I - gamma * I
    dR/dt = gamma * I

    [v[0], v[1], v[2]]=[S, I, R]

    dv[0]/dt = -beta * v[0] * v[1]
    dv[1]/dt = beta * v[0] * v[1] - gamma * v[1]
    dv[2]/dt = gamma * v[1]

    '''
    return [-beta*v[0]*v[1], beta * v[0] * v[1] - gamma * v[1], gamma * v[1]]

# Solving SIR Equation
def Calc_SIR(var_b, var_r):
    # parameters
    t_max = 14
    dt = 0.01
    #beta_const = 0.0026
    #gamma_const = 0.5

    beta_const = var_b
    gamma_const = var_r

    # initial_state
    S_0 = 762
    I_0 = 1
    R_0 = 0
    ini_state = [S_0, I_0, R_0]  # [S[0], I[0], R[0]]

    # numerical integration
    times = np.arange(1, t_max, dt)
    args = (beta_const, gamma_const)
    # Solver SIR model
    result = odeint(SIR_EQ, ini_state, times, args)
    return times,result

Préparez une fonction à exécuter lors de l'événement du bouton de Tkinter. C'est un mécanisme pour préparer l'instance d'axes (= ax) de matplotlib dans la fonction DrawCanvas et tracer l'instance. Le canvas.draw () final montrera l'instance des axes de matplotlib dans le widget canvas.

def Quit():
    tkmsg.showinfo("Tomomi Research Inc.","Thank you for running this program!")
    root.quit()
    root.destroy()

#Draw Button
def DrawCanvas(canvas, ax):
    value_beta = EditBox_beta.get()
    value_gamma = EditBox_gamma.get()
    if value_beta != '':
        EditBox_beta.delete(0, tkinter.END)
        EditBox_gamma.delete(0, tkinter.END)
        ax.cla()
        beta = float(value_beta)
        gamma = float(value_gamma)
        t_r, res_r = Calc_SIR(beta,gamma)

        ax.plot(t_r, res_r)
        ax.legend(['Susceptible', 'Infectious', 'Removed'])
        ax.set_title('Beta='+str(beta)+', Gamma='+str(gamma) )
        ax.set_xlabel('time(days)')
        ax.set_ylabel('population')
    canvas.draw()

Cette partie est le programme principal. Les paramètres de chaque Widget de Tkinter sont écrits dans cette partie.

if __name__ == '__main__':
    try:
        # GUI generate
        root = tkinter.Tk()
        root.title("SIR model")

        # Graph setting
        fig, ax1 = plt.subplots()
        #fig.gca().set_aspect('equal', adjustable='box')  #Ajustement de la zone graphique#get current axes

        ax1.set_title('Typical Condition:  beta=0.0026, gamma=0.5, $S_0$=762, $I_0$=1')


        # Generate Canvas
        Canvas = FigureCanvasTkAgg(fig, master=root)
        Canvas.get_tk_widget().grid(row=0, column=0, rowspan=10)

        #Beta
        EditBox_beta = tkinter.Entry(width=5)  #Générer une zone de texte
        EditBox_beta.grid(row=1, column=2)

        GridLabel_beta = tkinter.Label(text="Beta")
        GridLabel_beta.grid(row=1, column=1)

        # Gamma
        EditBox_gamma = tkinter.Entry(width=5)  #Générer une zone de texte
        EditBox_gamma.grid(row=4, column=2)

        GridLabel_gamma = tkinter.Label(text="Gamma")
        GridLabel_gamma.grid(row=4, column=1)

        #Divers paramètres liés aux boutons
        ReDrawButton = tkinter.Button(text="Draw", width=15, command=partial(DrawCanvas, Canvas, ax1))  #Génération de bouton
        ReDrawButton.grid(row=5, column=1, columnspan=2)  #Position du dessin(Texto)

        QuitButton = tkinter.Button(text="Quit", width=15, command=Quit)  #Génération de bouton
        QuitButton.grid(row=7, column=1, columnspan=2)  #Position du dessin(Texto)

        DrawCanvas(Canvas, ax1)
        root.mainloop()
    except:
        import traceback

        traceback.print_exc()
    finally:
        input(">>")  #En attente d'affichage lorsqu'une erreur est crachée

Résumé

Il semble que Tkinter et PyQT soient célèbres comme bibliothèques d'interface graphique Python, mais j'ai entendu dire que Tkiknter est facile à programmer même pour les débutants, j'ai donc choisi Tkinter. Je suis toujours intéressé par PyQT, donc si vous avez utilisé les deux, laissez un commentaire.

Je pense que l'avantage de l'interface graphique Python est qu'elle est multiplateforme. Si vous créez un programme, vous pouvez l'utiliser pour Windows, Mac OS, Linux sans aucune modification. Actuellement, je pense développer un programme Deep Learning sous Windows et l'implémenter sur la série Jetson (Linux) de Nvidia. À ce moment-là, je pense que l'interface graphique Python sera très utile.

Matériel de référence

1. Une histoire sur la combinaison de Matplotlib avec l'interface graphique (Tkinter) https://www.shtsno24.tokyo/2018/12/matplotlibguitkinter.html
2. Manuel de mise en œuvre de Matplotlib et Seaborn https://amzn.to/2ujQ2CL
3. Introduction d'un modèle de prédiction mathématique pour les maladies infectieuses (modèle SIR) https://qiita.com/kotai2003/items/3078f4095c3e94e5325c
4. Modèle de prédiction mathématique des maladies infectieuses (modèle SIR): étude de cas (1) https://qiita.com/kotai2003/items/d74583b588841e6427a2
5. Embedding in Tk https://matplotlib.org/gallery/user_interfaces/embedding_in_tk_canvas_sgskip.html