def calibrar(símismo,
líms_paráms,
datos,
método='epm',
n_iter=300,
vars_obs=None):
"""
Efectuar la calibración.
Parameters
----------
líms_paráms: dict
Diccionario de cada parámetro con sus límites teoréticos.
datos: xr.Dataset or xr.DataArray or str or pd.DataFrame or dict or Fuente or list or BD
Los datos para la calibración.
método
n_iter
vars_obs
Returns
-------
"""
# Para hacer: limpiar comunicación de datos entre calibrador y CalibradorGeog, y también con validadores
if isinstance(datos, xr.Dataset):
obs = datos
else:
datos = datos if isinstance(datos, BD) else BD(datos)
obs = datos.obt_vals(vars_obs)
return símismo._efec_calib(líms_paráms=líms_paráms,
método=método,
n_iter=n_iter,
obs=obs)
def setUpClass(cls):
n_obs = 50
datos_x = np.random.rand(n_obs)
ec = 'y = a*x + b'
cls.paráms = {'a': 2.4, 'b': -5}
cls.clbrds = {ll: v(ec=ec, paráms=list(cls.paráms)) for ll, v in calibradores.items()}
datos_y = cls.paráms['a'] * datos_x + cls.paráms['b'] + np.random.normal(0, 0.1, n_obs)
cls.bd_datos = BD(
fuentes=FuenteDic({'y': datos_y, 'x': datos_x, 'f': np.arange(n_obs)}, 'Datos generados', fechas='f')
)
def setUpClass(cls):
cls.paráms = {
'708': {
'taza de contacto': 81.25,
'taza de infección': 0.007,
'número inicial infectado': 22.5,
'taza de recuperación': 0.0375
},
'1010': {
'taza de contacto': 50,
'taza de infección': 0.005,
'número inicial infectado': 40,
'taza de recuperación': 0.050
}
}
cls.mod = gen_mds(arch_mds)
simul = SimuladorGeog(cls.mod).simular(t=100,
vals_geog=cls.paráms,
vars_interés=[
'Individuos Suceptibles',
'Individuos Infectados',
'Individuos Resistentes'
])
# Para hacer: dimensiones múltiples,
datos = {
lg: {ll: v[:, 0]
for ll, v in simul[lg].a_dic().items()}
for lg in cls.paráms
}
cls.datos = BD([
FuenteDic(datos[lg],
'Datos geográficos',
lugares=lg,
fechas=np.arange(101)) for lg in cls.paráms
])
def setUpClass(cls):
cls.paráms = prms = {
'a': {'701': 3.4, '708': 3, '1001': 10},
'b': {'701': -1.5, '708': -1.1, '1001': -3}
} # Nota: ¡a en (0, +inf) y b en (-inf, +inf) según los límites en el modelo externo!
cls.ec = 'y = a*x + b'
n_obs = {'701': 500, '708': 50, '1001': 500}
datos_x = {lg: np.random.rand(n) for lg, n in n_obs.items()}
datos_y = {
lg: datos_x[lg] * prms['a'][lg] + prms['b'][lg] + np.random.normal(0, 0.1, n_obs[lg])
for lg in n_obs
} # y = a*x + b
lugares = [x for ll, v in datos_x.items() for x in [ll] * v.size]
x = [i for v in datos_x.values() for i in v]
y = [i for v in datos_y.values() for i in v]
cls.clbrds = {ll: v(ec=cls.ec, paráms=['a', 'b']) for ll, v in calibradores.items()}
fchs = pd.date_range(0, periods=len(x))
cls.bd = BD(FuenteDic(
{'lugar': lugares, 'x': x, 'y': y, 'f': fchs}, 'Datos geográficos', lugares='lugar', fechas='f'
))
cls.lugar = gen_lugares(arch_csv_geog, nivel_base='País', nombre='Iximulew')
def validar(símismo,
t,
datos,
paráms=None,
funcs=None,
vars_extern=None,
corresp_vars=None):
"""
Efectua la validación.
Parameters
----------
t: int or EspecTiempo
La especificación de tiempo para la validación.
datos: xr.Dataset or xr.DataArray or str or pd.DataFrame or dict or Fuente or list
La base de datos para la validación.
paráms: dict
Diccionario de los parámetros calibrados para cada lugar.
funcs: list
Funciones de validación para aplicar a los resultados.
vars_extern: str or list or Variable
Variable(s) exógenos cuyos valores se tomarán de la base de datos para alimentar la simulación y con
los cuales por supuesto no se validará el modelo.
corresp_vars:
Diccionario de correspondencia entre nombres de valores en el modelo y en la base de datos.
Returns
-------
dict
Validación por variable.
"""
t = t if isinstance(t, EspecTiempo) else EspecTiempo(t)
if not isinstance(datos, xr.Dataset):
datos = datos if isinstance(datos, BD) else BD(datos)
datos = datos.obt_vals(
buscar_vars_interés(símismo.mod, datos, corresp_vars))
funcs = funcs or list(eval_funcs)
vars_extern = vars_extern or []
if not isinstance(vars_extern, list):
vars_extern = [vars_extern]
vars_interés = buscar_vars_interés(símismo.mod, datos, corresp_vars)
vars_valid = [v for v in vars_interés if v not in vars_extern]
vals_extern = datos[list(
{_resolver_var(v, corresp_vars)
for v in vars_extern})]
extern = {
vr: vals_extern[_resolver_var(vr, corresp_vars)].dropna('n')
for vr in vars_extern
}
extern = {ll: v for ll, v in extern.items() if v.sizes['n']}
res = símismo.mod.simular(t=t,
extern={
**paráms,
**extern
},
vars_interés=vars_valid)
vals_calib = datos[list(
{_resolver_var(v, corresp_vars)
for v in vars_valid})]
# Para hacer: si implementamos Dataset en ResultadosSimul este se puede combinar en una línea
valid = {}
for r in res:
vr_datos = _resolver_var(str(r), corresp_vars)
vals_calib_vr = vals_calib[vr_datos].dropna('n')
if vals_calib_vr.sizes['n']:
eje = r.vals[_('fecha')].values
eje_obs = pd.to_datetime(vals_calib_vr[_('fecha')].values)
eje_res = relativizar_eje(eje, eje_obs)
buenas_fechas = xr.DataArray(np.logical_and(
eje_res[0] <= eje_obs, eje_obs <= eje_res[-1]),
dims='n')
datos_r = vals_calib_vr.where(buenas_fechas,
drop=True).dropna('n')
if datos_r.sizes['n'] > 1:
fechas_obs = datos_r[_('fecha')]
interpoladas = r.interpolar(fechas=fechas_obs)
valid[str(r)] = _valid_res(
datos_r.values, interpoladas.values,
pd.to_datetime(datos_r[_('fecha')].values), funcs)
return valid
def validar(símismo,
t,
datos,
paráms=None,
funcs=None,
vars_extern=None,
corresp_vars=None,
clima=None):
"""
Efectua la validación.
Parameters
----------
t: int or EspecTiempo
La especificación de tiempo para la validación.
datos: xr.Dataset or xr.DataArray or str or pd.DataFrame or dict or Fuente or list
La base de datos para la validación.
paráms: dict
Diccionario de los parámetros calibrados para cada lugar.
funcs: list
Funciones de validación para aplicar a los resultados.
vars_extern: str or list or Variable
Variable(s) exógenos cuyos valores se tomarán de la base de datos para alimentar la simulación y con
los cuales por supuesto no se validará el modelo.
corresp_vars:
Diccionario de correspondencia entre nombres de valores en el modelo y en la base de datos.
Returns
-------
dict
Validación por variable.
"""
t = t if isinstance(t, EspecTiempo) else EspecTiempo(t)
if not isinstance(datos, pd.DataFrame):
datos = datos if isinstance(datos, BD) else BD(datos)
datos = datos.obt_vals(
buscar_vars_interés(símismo.mod, datos, corresp_vars))
funcs = funcs or list(eval_funcs)
vars_extern = vars_extern or []
if not isinstance(vars_extern, list):
vars_extern = [vars_extern]
vars_interés = buscar_vars_interés(símismo.mod, datos, corresp_vars)
vars_valid = [v for v in vars_interés if v not in vars_extern]
vals_extern = datos[
list({_resolver_var(v, corresp_vars)
for v in vars_extern}) + [_('fecha')]]
# Para hacer: inter y extrapolación como opción en todas simulaciones, y extrapolación con función según líms
if not np.datetime64(t.f_inic) in vals_extern[_('fecha')].values:
vals_extern = vals_extern.append(
{_('fecha'): pd.to_datetime(t.f_inic)}, ignore_index=True)
vals_extern = vals_extern.sort_values(_('fecha'))
vals_extern = vals_extern.interpolate(limit_area='inside').bfill()
vals_extern = vals_extern.set_index(_('fecha'))
extern = {
vr: vals_extern[_resolver_var(vr, corresp_vars)].dropna()
for vr in vars_extern
}
extern = {ll: v for ll, v in extern.items() if len(v)}
res = símismo.mod.simular(t=t,
extern={
**paráms,
**extern
},
vars_interés=vars_valid,
clima=clima)
vals_calib = datos[
list({_resolver_var(v, corresp_vars)
for v in vars_valid}) + [_('fecha')]]
# Para hacer: inter y extrapolación como opción en todas simulaciones, y extrapolación con función según líms
if not np.datetime64(t.f_inic) in vals_calib[_('fecha')].values:
vals_calib = vals_calib.append(
{_('fecha'): pd.to_datetime(t.f_inic)}, ignore_index=True)
vals_calib = vals_calib.sort_values(_('fecha'))
vals_calib_interp = vals_calib.interpolate(
limit_area='inside').set_index(_('fecha'))
vals_calib = vals_calib.set_index(_('fecha'))
vals_calib.loc[t.f_inic] = vals_calib_interp.loc[t.f_inic]
# Para hacer: si implementamos Dataset en ResultadosSimul este se puede combinar en una línea
valid = {}
for r in res:
vr_datos = _resolver_var(str(r), corresp_vars)
vals_calib_vr = vals_calib[vr_datos].dropna()
if len(vals_calib_vr):
eje = r.vals[_('fecha')].values
eje_obs = pd.to_datetime(vals_calib_vr.index.values)
eje_res = relativizar_eje(eje, eje_obs)
buenas_fechas = np.logical_and(eje_res[0] <= eje_obs,
eje_obs <= eje_res[-1])
datos_r = vals_calib_vr[buenas_fechas]
if len(datos_r) > 1:
fechas_obs = datos_r.index
interpoladas = r.interpolar(fechas=fechas_obs)
buenas = np.isfinite(
r.interpolar(fechas=fechas_obs)).values[:, 0]
valid[str(r)] = _valid_res(datos_r.values[buenas],
interpoladas.values[buenas],
datos_r.index[buenas], funcs)
return valid
def setUpClass(cls):
fnt1 = fnt.FuenteCSV(arch_datos1, nombre='prueba 1', fechas='fecha', lugares='lugar')
fnt2 = fnt.FuenteCSV(arch_datos2, nombre='prueba 1', fechas='fecha', lugares='lugar')
cls.bd = BD(fuentes=[fnt1, fnt2])