Modelos matemáticos
Introducción a los modelos matemáticos
¿Qué es un sistema dinámico?
Modelos Estocásticos vs. Modelos Determinísticos
El lenguaje del Determinismo y las EDOs
Sistemas complejos y la imposibilidad de una solución exacta
Modelos númericos
Modelos numéricos al rescate
Soluciones numéricas vs. exactas
Sistemas caóticos
Fórmula RK4 vs. fórmula de Euler
Solución al sistema de Lorenz
Modelos epidemiológicos
Modelo SIR
Mejorando el modelo SIR
Ajustando un modelo epidemiológico a datos reales
Los sistemas dinámicos son sistemas que simplemente evolucionan en el tiempo. Vamos a profundizar en la formulación matemática necesaria para hacer modelos y veremos cómo las funciones matemáticas describen la realidad con un ejemplo sencillo de un péndulo en movimiento como el que ves a continuación:
Ahora que entendemos que un modelo es una representación simplificada de la realidad, debes preguntarte: ¿Qué parte de la realidad quieres modelar ¿Con qué propósito? ¿Quieres predecir un evento o la ocurrencia de una situación particular? ¿Cuáles son las variables y sus relaciones? ¿Puedes obtener datos para validar el modelo?
Un sistema es la porción de realidad que vamos a modelar, si este cambia a medida que el tiempo avanza se le conoce como modelo dinámico. Tener un modelo de la realidad implica tener una o varias funciones que describe cómo evoluciona el fragmento de la realidad que elegí. Este fragmento es conocido como sistema dinámico.
Primero, voy a tomar como caso particular un péndulo y quiero saber cuál será su posición en el futuro. Al decir esto, he identificado la parte de la realidad que quiero modelar: un objeto sólido que cuelga de una cuerda muy fina que puedo disponer para que efectúe oscilaciones alrededor de un punto fijo. Esta parte de la realidad que quiero modelar se denomina el sistema y cuando el sistema cambia a medida que el tiempo avanza, se le denomina sistema dinámico.
Una vez que tengo identificado el sistema, lo siguiente es determinar cuáles son las variables que son relevantes para el objetivo que quiero lograr. Aquí se dice que lo que quiero cuantificar es la posición del objeto, pero resulta que la posición del péndulo viene dada por la ubicación específica del peso que cuelga de la cuerda, y dependiendo de qué tanto quiera simplificar el sistema, necesitaré dos o tres coordenadas en el espacio. Supongamos que etiqueto estas coordenadas como
Ahora, como el objeto en general estará en movimiento, decimos que estas coordenadas (que ahora son nuestras variables del modelo) dependen del instante de tiempo en el cual observamos el objeto (aquí la relación del modelo es entre el tiempo y las coordenadas) y escribimos:
x = x(t)
y = y(t)
z = z(t)
En matemáticas existen muchos tipos de relaciones entre variables, así que nos vamos a enfocar en el único tipo de relación que nos interesa: las relaciones que denominamos funciones. No vamos a profundizar en los detalles de lo que una función matemática es pero vamos a dejar claro que las funciones son el tipo de relación que necesitamos porque permiten crear modelos donde, por ejemplo, un objeto no puede estar en dos lugares al mismo tiempo, ya que eso va contra la lógica de nuestra realidad observable.
Para profundizar sobre el concepto de función matemática te recomiendo tomar Curso de Funciones Matemáticas para Data Science e Inteligencia Artificial.
Dicho esto, las funciones serán la base para construir nuestros modelos matemáticos ya que nos permiten hacer descripciones exactas de las variables que caracterizan el sistema (o trozo de realidad) del cual queremos hacer predicciones. En este curso vamos a trabajar con estas funciones usando Python, así que vamos a comenzar escribiendo un código en este lenguaje que te permitirá hacer una simulación de este sistema dinámico.
Antes conviene que definamos cuáles son las funciones que describen el movimiento del péndulo. Por simplicidad, tomaremos un péndulo que se mueve en un plano bidimensional así:
Aquí, θ₀ y ω son el ángulo inicial de apertura y la frecuencia de oscilación del péndulo, respectivamente, y la función θ(t) describe cómo varía el ángulo de oscilación del péndulo según el tiempo t. Estos valores son constantes y se toman como condiciones iniciales del problema, es decir, definen el estado inicial del péndulo (qué tanto va a oscilar y qué tan rápido). Escribir estas ecuaciones en Python no requiere muchas líneas de código, y para este ejercicio primero vamos a usar las siguientes librerías:
Luego definimos las posiciones en las coordenadas x e y definidas previamente, así:
Donde tenemos un ángulo inicial θ₀ de π/4 radianes y la frecuencia ω con un valor de π radianes por segundo. Veamos ahora cómo se ve el movimiento de un péndulo descrito por estas funciones, para ello vamos a definir una función que dibuja la posición del péndulo dependiendo del valor de tiempo que quieras ver:
En este caso, i representa el valor de tiempo para el cual nuestra función dibuja la posición del péndulo. Los valores tmax y dt representan el máximo tiempo (en segundos) que puede dibujar la función y el intervalo de tiempo que separa instantes sucesivos en el proceso de simular el movimiento del péndulo, respectivamente. Ahora puedes ejecutar la función para un valor particular de tiempo así:
De aquí ves cómo diferentes tiempos en las ecuaciones, reflejan los diferentes estados de posición del objeto y por lo tanto se evidencia que estas ecuaciones describen un movimiento pendular. Así, vemos cómo las funciones nos ayudan en la descripción de sistemas dinámicos. En el notebook de esta clase está el código completo para que puedas generar un gif animado del péndulo en movimiento a partir de lo que viste aquí.
De este ejercicio debemos tener en cuenta dos puntos muy importantes:
Aportes 13
Preguntas 0
Las dos librerías que se necesitaran se instalan (en Windows) abriendo el cmd y poniendo las siguientes líneas:
SciPy : python -m pip install --user numpy scipy matplotlib ipython jupyter pandas sympy nose
NumPy : pip install numpy
Imageio : pip install imageio
Este sistema visto como una ecuación diferencial se escribiría como una ecuación diferencial de primer orden, sin embargo el modelo que muchos conocemos solo es preciso para valores de theta pequeños.
Yo andaba pasando todo a Colab hasta que leí casi a final lo del notebook
No se aún usar python, Ya me asusté, así que lo estudiaré y volveré con toda la furia para pasar este curso.
Les comparto el codigo con alguna optimizaciones rapidas para crear el gif, lo puden correr como un script desde consola
import numpy as np
import scipy as sp
import imageio
import matplotlib.pyplot as plt
import os
import shutil
from matplotlib.patches import Circle
from matplotlib.animation import FuncAnimation
os.mkdir('pendulum')
theta0 = np.pi / 4
w = sp.pi
def theta(t): return theta0 * np.cos(w*t)
def x(t): return np.sin(theta(t))
def y(t): return -np.cos(theta(t))
tmax, dt = 10, .1
t = np.arange(0, tmax, dt)
filenames = []
def make_plot(i):
r = 0.05
n = int(i / dt)
fig = plt.figure(dpi=72)
ax = fig.add_subplot(111)
ax.plot([0, x(i)], [0, y(i)], lw=2, c='k')
c0 = Circle((0, 0), r/2, fc='k', zorder=10)
c1 = Circle((x(i), y(i)), r, fc='b', ec='b', zorder=10)
ax.add_patch(c0)
ax.add_patch(c1)
ax.set_xlim(-1.1, 1.1)
ax.set_ylim(-1.1, 0)
ax.set_aspect('equal', adjustable='box')
plt.grid(True)
filenames.append('pendulum/frames_img{:04d}.png'.format(n))
plt.savefig('pendulum/frames_img{:04d}.png'.format(n))
for i in t:
make_plot(i)
images = []
for filename in filenames:
images.append(imageio.imread(filename))
imageio.mimsave('pendulum.gif', images)
shutil.rmtree('pendulum')
No puedo crear el gif :’(
Sistema: Es la porción de realidad que vamos a modelar, su este cambia a medida que el tiempo avanza se le conoce como modelo dinámico.
Una vez elegido el sistema es necesario elegir las variables del modelo, las cuales relacionaremos por medio de funciones, en muchos casos conocemos estas funciones a través de lo que conocemos en ciencia como leyes, basadas en el conocimiento obtenido anteriormente. Por lo general este conocimiento se traduce en una Ecuación Diferencial Ordinaria (EDO).
Nota:
Tener un modelo de la realidad implica tener una o varias funciones que describe como evoluciona el fragmento de la realidad que elegí. Este fragmento es conocido como sistema dinámico
Hola, es recomendable recomendable trabajar en anaconda-spyder para este taller o en jupyter)?
Falta cambiar el grafico dentro del mismo cuadro de la figura.
import numpy as np
import scipy as sp
import matplotlib.pyplot as plt
from matplotlib.patches import Circle
from matplotlib.animation import FuncAnimation
import imageio
import shutil
theta0 = np.pi/4
w = np.pi
def theta(t): return theta0*np.cos(w*t)
def x(t): return np.sin(theta(t))
def y(t): return-np.cos(theta(t))
tmax, dt = 10, 0.05
t = np.arange(0,tmax,dt)
filenames=[]
def make_plot(i):
r = 0.05
n = int(i/dt)
fig = plt.figure(dpi = 72)
ax = fig.add_subplot(111)
ax.plot([0,x(i)], [0,y(i)], lw = 2, c = 'k')
c0 = Circle((0,0), r/2, fc = 'k', zorder = 10)
c1 = Circle((x(i), y(i)), r, fc = 'b', ec = 'b', zorder = 10)
ax.add_patch(c0)
ax.add_patch(c1)
ax.set_xlim(-1.1, 1.1)
ax.set_ylim(-1.1, 0)
ax.set_aspect('equal', adjustable = 'box')
plt.grid(True)
filenames.append('frames_img{:04d}.png'.format(n))
plt.savefig('frames_img{:04d}.png'.format(n))
plt.show()
if __name__=='__main__':
tmax, dt = 10, 0.01
t = np.arange(0, tmax, dt)
filenames = []
for i in t:
make_plot(i)
Les dejo el codigo de mi simulacion con animacion en matplotlib, la primera linea es necesaria porque la simule en Jupyter.
Modificando, el parametro “interval” en la funcion “FuncAnimation” pueden hacer la animacion mas rapida o mas lenta
%matplotlib notebook
import numpy as np
import scipy as sp
import matplotlib.pyplot as plt
from matplotlib.animation import FuncAnimation
theta0 = np.pi/4
w = sp.pi
def theta(t): return theta0*np.cos(w*t)
def x(t): return np.sin(theta(t))
def y(t): return -np.cos(theta(t))
tmax, dt = 10, 0.01
t = np.arange(0, tmax, dt)
fig, ax = plt.subplots()
xdata, ydata = [], []
ln, = ax.plot([], [], 'ro')
line, = ax.plot([], [], 'o-', lw=2)
def init():
ax.set_xlim(-1.1, 1.1)
ax.set_ylim(-1.1, 0)
return ln,
def update(frame):
xdata.append(x(frame))
ydata.append(y(frame))
line.set_data([0,x(frame)], [0, y(frame)])
ln.set_data(xdata, ydata)
return ln,
ani = FuncAnimation(fig, update, frames=t, interval=100,
init_func=init, blit=True)
plt.show()
SE PUEDE CREAR ESTO EN LA VERSION LIBRE DE PYTHON?
¿Quieres ver más aportes, preguntas y respuestas de la comunidad?