L'histoire du calcul numérique des équations différentielles avec TensorFlow 2.0

introduction

TensorFlow 2.0 est un framework très puissant qui peut être utilisé pour l'apprentissage automatique tel que l'apprentissage profond. TensorFlow traite les algorithmes de calcul numérique de manière abstraite sous la forme de "graphes de calcul".

C'est comme un plan d'exécution en SQL. Cela semble pouvoir séparer «définition de l'algorithme» et «exécution de celui-ci». S'il est utilisé correctement, il sera très utile non seulement pour l'apprentissage automatique, mais également pour les calculs numériques généraux.

Je l'ai essayé

Résolvons cette fois l'équation Lotka-Volterra! C'est une équation qui modélise la fluctuation du nombre de prédateurs et de proies. Il est également célèbre pour reproduire la «solution périodique» que l'on peut voir dans le monde naturel.

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

En ajoutant le décorateur tf.function, le calcul interne sera calculé sous forme de graphique sur TensorFlow. À partir de Tensorflow 2.0, il est possible «d'écrire avec du code Python» dans une certaine mesure. Je suis reconnaissant. Dans ce cas, vous pouvez l'exécuter immédiatement en tant que "code Python pur" en prenant tf.function.

Dans mon environnement personnel, l'ajout de tf.function a ralenti le temps d'exécution d'environ 4 fois. (CPU) Bien sûr, cette fois, ce n'est que des frais généraux, donc c'est naturel (´ ・ ω ・ `)

en conclusion

Comment était-ce?

Il s'avère que vous n'avez pas du tout besoin d'utiliser TensorFlow 2.0 pour l'équation Lotka-Volterra!

TensorFlow peut être utile pour les calculs numériques qui sont considérablement plus lourds que cette fois, comme l'utilisation de nombreuses opérations matricielles (tenseur) telles que les équations aux dérivées partielles.

J'ai essayé de le faire, mais cela n'a pas fonctionné parce que c'était un secret avec le Père Noël! Bonne année: dogeza: