[GO] Python-Continuous Time Markov-Kettenzustandsübergangssimulation

Überblick

** Kontinuierliche Zeit ** Implementiert eine Zustandsübergangssimulation der Markov-Kette. Der verwendete Algorithmus ist der Gillespie-Algorithmus. Nach dem Posten der Implementierung werde ich die Gliederung kurz erläutern.

** Diskrete Zeit ** Informationen zur Zustandsübergangssimulation der Markov-Kette finden Sie in diesem Artikel. Python - Markov Chain State Transition Simulation

Implementierung

Betrachten Sie die Markov-Kette bei drei Zuständen (Zustand = 0,1,2).

CTMC.py

import numpy as np
import math
import random
import matplotlib.pyplot as plt
#Anzahl der Staaten
N=3
#Übergangsratenmatrix
TRANSITION_MATRIX = [[-0.3, 0.1, 0.2],
                     [0.2, -0.9, 0.7],
                     [0.7, 0.2, -0.9]]

initial_state = 0 #Ausgangszustand
current_state = initial_state #Aktuellen Zustand
next_state = 0 #Nächster Zustand
dt = 0 #Staatliche Aufenthaltszeit

state_list = [] #Staatsspeicherliste
dt_list=[] #Speicherliste der Verweilzeit
state_list.append(current_state)
dt_list.append(dt)

time = 0
T=15 #Beobachtungszeit

#Gillespy-Algorithmus(Gillespie Algorithm)
while(time <= T):
    rand_s = random.random() #Zufallszahl, die den Zustand bestimmt
    rand_t = random.random() #Zufallszahl, die die Aufenthaltsdauer bestimmt
    q =  -TRANSITION_MATRIX[current_state][current_state] #propensity function
    total = 0
#Bestimmen Sie den nächsten Übergangszustand
    for i in range(N):
        if(i == current_state):
            continue
        total += TRANSITION_MATRIX[current_state][i]
        if(rand_s < total/q):
            next_state  = i
            break;
    current_state = next_state
    state_list.append(current_state)
#Bestimmen Sie die Aufenthaltsdauer im aktuellen Zustand
    dt = 1/q * math.log(1/rand_t)
    time += dt
    dt_list.append(dt)
#Handlung
arr_state = np.array(state_list)
arr_dt = np.array(dt_list)
arr_cumsum = np.cumsum(arr_dt)
arr_state_repeat = np.repeat(arr_state,2)
arr_time_repeat = np.repeat(arr_cumsum,2)
plt.plot(arr_time_repeat[1:],arr_state_repeat[:-1],label="state")
plt.xlabel("time")
plt.ylabel("state")
plt.title("DTMC")
plt.legend()
plt.grid(color='gray')

Es ist eine grafische Darstellung des Ergebnisses.

Es ist ersichtlich, dass der Übergang zwischen den Zuständen [0,1,2] bis zum Zeitpunkt T = 15 wiederholt wird. (In diesem Diagramm geht es zu ungefähr 17,5 über, dies ist jedoch eine Spezifikation. Sie kann durch Entfernen des Endes der Liste entfernt werden, wird hier jedoch nicht entfernt, da der Code kompliziert wird. )

Gillespie-Algorithmus

Die Hauptidee dieses Algorithmus ist die Übergangsrate

1. Wenn der nächste Übergang ** stattfindet **
2. ** In welchen ** Zustand soll übergegangen werden? Die beiden werden zufällig durch Zufallszahlen bestimmt. Es ist so ausgelegt, dass je größer die Summe der Übergangsraten ist, desto einfacher der sofortige Übergang ist und je größer die Übergangsrate ist, desto einfacher ist der Übergang. Weitere Informationen finden Sie unter Wikipedia.