TensorFlow 2.0 ist ein sehr leistungsfähiges Framework, das für maschinelles Lernen wie Deep Learning verwendet werden kann. TensorFlow behandelt numerische Berechnungsalgorithmen abstrakt in Form von "Berechnungsgraphen".
Es ist wie ein Ausführungsplan in SQL. Dies scheint in der Lage zu sein, "Definition des Algorithmus" und "Ausführung des Algorithmus" zu trennen. Bei richtiger Anwendung ist es nicht nur für maschinelles Lernen, sondern auch für allgemeine numerische Berechnungen sehr nützlich.
Lösen wir diesmal die Lotka-Volterra-Gleichung! Es ist eine Gleichung, die die Fluktuation der Anzahl von Raubtieren und Beutetieren modelliert. Es ist auch berühmt für die Reproduktion der "periodischen Lösung", die in der natürlichen Welt zu sehen ist.
import tensorflow as tf
import matplotlib.pyplot as plt
import timeit
a = 0.2
b = 0.04
c = 0.4
d = 0.05
d_esa = lambda esa, hoshokusha: a*esa - b*esa*hoshokusha
d_hoshokusha = lambda esa, hoshokusha: -c*hoshokusha + d*esa*hoshokusha
def runge_kutta(f, x, y, dt):
k1 = dt*f(x,y)
k2 = dt*f(x+0.5*k1, y+0.5*k1)
k3 = dt*f(x+0.5*k2, y+0.5*k2)
k4 = dt*f(x+k3, y+k3)
return (k1+2.0*k2+2.0*k3+k4)/6.0
@tf.function
def lotka_volterra(t_max, t_num, esa_init, hoshokusha_init):
esa_result = []
hoshokusha_result = []
t_result = []
t = 0.0
esa = esa_init
hoshokusha = hoshokusha_init
esa_result.append(esa)
hoshokusha_result.append(hoshokusha)
t_result.append(t)
dt = t_max / t_num
while t < t_max:
t += dt
esa += runge_kutta(d_esa, esa, hoshokusha, dt)
hoshokusha += runge_kutta(d_hoshokusha, esa, hoshokusha, dt)
esa_result.append(esa)
hoshokusha_result.append(hoshokusha)
t_result.append(t)
return esa_result, hoshokusha_result, t_result
# warm up！！！！！！
esa_result, hoshokusha_result, t_result = lotka_volterra(100.0, 2000, 10, 1)
print(timeit.timeit(lambda: lotka_volterra(100.0, 2000, 10, 1), number=1))
plt.plot(t_result, esa_result)
plt.plot(t_result, hoshokusha_result)
plt.show()
Durch Hinzufügen des Dekorators "tf.function" wird die interne Berechnung als Grafik in TensorFlow berechnet. Ab Tensorflow 2.0 ist es bis zu einem gewissen Grad möglich, "mit Python-Code zu schreiben". Ich bin dankbar. In diesem Fall können Sie es sofort als "reinen Python-Code" ausführen, indem Sie "tf.function" verwenden.
In meiner persönlichen Umgebung verlangsamte das Hinzufügen von "tf.function" die Ausführungszeit um etwa das Vierfache. (ZENTRALPROZESSOR) Natürlich ist es diesmal nur Overhead, also ist es natürlich (´ ・ ω ・ `)
Wie war es?
Es stellt sich heraus, dass Sie TensorFlow 2.0 für die Lotka-Volterra-Gleichung überhaupt nicht verwenden müssen!
TensorFlow kann für numerische Berechnungen nützlich sein, die erheblich schwerer als diese Zeit sind, z. B. die Verwendung vieler Matrixoperationen (Tensoroperationen) wie partielle Differentialgleichungen.
Ich habe es versucht, aber es hat nicht funktioniert, weil es ein Geheimnis für den Weihnachtsmann war! Ich wünsche Ihnen ein schönes Jahr: dogeza:
Recommended Posts