[PYTHON] Machen Sie das SIR-Modellberechnungsprogramm zu einer GUI

Einführung

Im vorherigen Artikel habe ich das SIR-Modell beschrieben, das die Ausbreitung von Infektionskrankheiten erklärt. Zu dieser Zeit habe ich auch ein Python-Programm für die numerische Integration veröffentlicht, das das SIR-Modell löst. In diesem Artikel werde ich versuchen, das Python-Programm in eine GUI zu verwandeln.

Vorheriger Artikel: Mathematisches Vorhersagemodell für Infektionskrankheiten (SIR-Modell): Fallstudie (1) https://qiita.com/kotai2003/items/d74583b588841e6427a2

GUI-Beschreibung

Der Grund für die Konvertierung des von mir erstellten Programms in eine GUI ist "Ich möchte, dass andere es verwenden". In Zukunft möchte ich es in Form von setup.exe verteilen, nicht nur in Form des Py-Codes der GUI.

Zunächst wurde diesmal die Bildschirmkonfiguration der GUI erstellt. Geben Sie die Infektionsrate (Beta) und die Entfernungsrate (Gamma) des SIR-Modells in die Felder rechts ein und klicken Sie auf die Schaltfläche Zeichnen darunter. Das Berechnungsergebnis des SIR-Modells wird auf dem mittleren Bildschirm angezeigt.

\begin{align}

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

\end{align} 

\begin{align}
S &:Infizierbare Person\quad \text{(Susceptible)}　\\
I &:Infizierte Person\quad \text{(Infectious)}　\\
R &:Diejenigen, die nach einer Infektion starben oder Immunität erlangten\quad \text{(Removed)}　\\
\beta &:Infektionsrate\quad \text{(The infectious rate)} \quad [1/day] \\
\gamma &:Ausschlussrate\quad \text{(The Recovery rate)} \quad [1/day]　\\
\end{align}

Auf dem Startbildschirm wird Typischer Zustand ~ angezeigt. Dies dient jedoch als Referenz bei der Eingabe der Infektionsrate (Beta) und der Entfernungsrate (Gamma).

Der nächste Bildschirm zeigt das Berechnungsergebnis. Das numerische Integrationsergebnis des SIR-Modells wird im Liniendiagramm angezeigt. Die neu eingegebenen Werte für Infektionsrate (Beta) und Eliminationsrate (Gamma) werden im Titel aktualisiert.

Sie können die GUI verlassen, indem Sie unten rechts auf die Schaltfläche Beenden klicken.

Programm Beschreibung

Die GUI-Bibliothek verwendete Tkinter. Ich werde kurz die Funktionsweise des Programms erläutern.

(1) Bereiten Sie das Canvas Widget mit Tkinter vor. Bereiten Sie im Eingabe-Widget von Tkinter ein Textfeld für die Eingabe der Infektionsrate (Beta) und der Entfernungsrate (Gamma) vor. (2) Berechnen Sie das SIR-Modell mit scipy und zeichnen Sie das Ergebnis mit matplotlib auf. (3) Zeichnen Sie die Matplotlib-Figur mit dem Canvas-Widget.

Importieren Sie die erforderlichen Bibliotheken.

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

Bereiten Sie die Funktionen vor, die für die numerische Integration des SIR-Modells erforderlich sind.

# 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

Bereiten Sie eine Funktion vor, die zum Zeitpunkt des Ereignisses der Schaltfläche von Tkinter ausgeführt werden soll. Es ist ein Mechanismus, um die Achseninstanz (= ax) von matplotlib in der DrawCanvas-Funktion vorzubereiten und die Instanz zu zeichnen. Die letzte canvas.draw () zeigt die Achseninstanz von matplotlib im Canvas-Widget.

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()

Dieser Teil ist das Hauptprogramm. Die Einstellungen für jedes Tkinter-Widget werden in diesem Abschnitt beschrieben.

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')  #Anpassen des Grafikbereichs#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)  #Textfeld generieren
        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)  #Textfeld generieren
        EditBox_gamma.grid(row=4, column=2)

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

        #Verschiedene Einstellungen in Bezug auf Schaltflächen
        ReDrawButton = tkinter.Button(text="Draw", width=15, command=partial(DrawCanvas, Canvas, ax1))  #Tastengenerierung
        ReDrawButton.grid(row=5, column=1, columnspan=2)  #Zeichenposition(Texto)

        QuitButton = tkinter.Button(text="Quit", width=15, command=Quit)  #Tastengenerierung
        QuitButton.grid(row=7, column=1, columnspan=2)  #Zeichenposition(Texto)

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

        traceback.print_exc()
    finally:
        input(">>")  #Warten auf Anzeige, wenn ein Fehler ausgegeben wird

Zusammenfassung

Es scheint, dass Tkinter und PyQT als Python-GUI-Bibliotheken bekannt sind, aber ich habe gehört, dass Tkiknter auch für Anfänger einfach zu programmieren ist, deshalb habe ich mich für Tkinter entschieden. Ich bin immer noch an PyQT interessiert. Wenn Sie beide verwendet haben, hinterlassen Sie bitte einen Kommentar.

Ich denke, der Vorteil von Python GUI ist, dass es plattformübergreifend ist. Wenn Sie ein Programm erstellen, können Sie es ohne Änderungen für Windows, Mac OS, Linux verwenden. Derzeit denke ich darüber nach, ein Deep Learning-Programm unter Windows zu entwickeln und es auf der Jetson-Serie (Linux) von Nvidia zu implementieren. Zu diesem Zeitpunkt denke ich, dass die Python-GUI sehr nützlich sein wird.

Referenzmaterial

1. Eine Geschichte über die Kombination von Matplotlib mit GUI (Tkinter) https://www.shtsno24.tokyo/2018/12/matplotlibguitkinter.html
2. Implementierungshandbuch für Matplotlib & Seaborn https://amzn.to/2ujQ2CL
3. Einführung eines mathematischen Vorhersagemodells für Infektionskrankheiten (SIR-Modell) https://qiita.com/kotai2003/items/3078f4095c3e94e5325c
4. Mathematisches Vorhersagemodell für Infektionskrankheiten (SIR-Modell): Fallstudie (1) https://qiita.com/kotai2003/items/d74583b588841e6427a2
5. Embedding in Tk https://matplotlib.org/gallery/user_interfaces/embedding_in_tk_canvas_sgskip.html