diff --git "a/tikon/_Trads/\340\256\244\340\256\256\340\256\277\340\256\264\340\257\215/\340\256\265\340\257\207_\340\256\232\340\257\201_\340\256\265\340\256\262\340\257\210/__init__.py" b/pruebas/__init__.py similarity index 100% rename from "tikon/_Trads/\340\256\244\340\256\256\340\256\277\340\256\264\340\257\215/\340\256\265\340\257\207_\340\256\232\340\257\201_\340\256\265\340\256\262\340\257\210/__init__.py" rename to pruebas/__init__.py diff --git a/setup.py b/setup.py index f2b5eed9..70b04981 100644 --- a/setup.py +++ b/setup.py @@ -17,7 +17,7 @@ long_description='Tiko\'n es una herramienta para desarrollar modelos de agroecología (relaciones tróficas' 'entre insectos, enfermedades, y plantas). Está escrito para permitir la integración de modelos' 'de cultivos existentes.', - install_requires=['pymc', 'numpy', 'matplotlib', 'scipy', 'SALib', 'pathvalidate', 'pymc3', 'theano'], + install_requires=['numpy', 'matplotlib', 'scipy', 'SALib', 'pathvalidate', 'pymc3', 'theano', 'spotpy'], classifiers=[ 'License :: OSI Approved :: GNU General Public License v3 (GPLv3)', 'Programming Language :: Python :: 3 :: Only', diff --git a/tikon/Controles.py b/tikon/Controles.py index 4804530a..d80a7154 100644 --- a/tikon/Controles.py +++ b/tikon/Controles.py @@ -5,7 +5,6 @@ import pathvalidate from pkg_resources import resource_filename -usar_pymc3 = False # Este documento contiene información general para el programa Tiko'n @@ -39,6 +38,7 @@ def espec_dir_modelo_cult(modelo, directorio): def valid_archivo(archivo): direc, nombre = os.path.split(archivo) disco, direc = os.path.splitdrive(direc) + return os.path.join(disco, direc, nombre) direc = pathvalidate.sanitize_file_path(direc, replacement_text='_') nombre = pathvalidate.sanitize_filename(nombre, replacement_text='_') diff --git a/tikon/Coso.py b/tikon/Coso.py index 77fea49b..5fb39807 100644 --- a/tikon/Coso.py +++ b/tikon/Coso.py @@ -9,13 +9,13 @@ import numpy as np -from tikon.Matemáticas.Variables import VarSciPy, VarCalib from tikon import __correo__ from tikon.Controles import directorio_base, dir_proyectos from tikon.Matemáticas import Arte, Incert -from tikon.Matemáticas.Calib import ModBayes, ModGLUE, ModCalib +from tikon.Matemáticas.Calib import ModSpotPy, ModCalib from tikon.Matemáticas.Experimentos import Experimento from tikon.Matemáticas.Sensib import prep_anal_sensib +from tikon.Matemáticas.Variables import VarSciPy, VarSpotPy class Coso(object): @@ -790,7 +790,7 @@ def simular(símismo, exper=None, nombre=None, paso=1, tiempo_final=None, n_rep_ símismo.dibujar(exper=exper, directorio=directorio_dib, mostrar=mostrar, **opciones_dib) def calibrar(símismo, nombre=None, aprioris=None, exper=None, paso=1, n_rep_estoc=10, tiempo_final=None, - n_iter=10000, quema=100, extraer=10, método='Metrópolis adaptivo', pedazitos=None, + n_iter=10000, quema=100, extraer=10, método='mle', pedazitos=None, usar_especificadas=True, dibujar=False, depurar=False): """ Esta función calibra un Simulable. Para calibrar un modelo, hay algunas cosas que hacer: @@ -898,23 +898,18 @@ def calibrar(símismo, nombre=None, aprioris=None, exper=None, paso=1, n_rep_est # 5. Conectar a las observaciones d_obs = símismo.dic_simul['d_obs_calib'] # type: dict[dict[np.ndarray]] - # 6. Creamos el modelo ModCalib de calibración, lo cual genera variables PyMC - if método.lower() == 'metrópolis' or método.lower() == 'metrópolis adaptivo': - símismo.ModCalib = ModBayes(función=símismo._simul_exps, - dic_argums=dic_argums, - d_obs=d_obs, - lista_d_paráms=lista_paráms, - aprioris=lista_aprioris, - lista_líms=lista_líms, - id_calib=nombre, - función_llenar_coefs=símismo._llenar_coefs, - método=método - ) - elif método.lower() == 'glue': - símismo.ModCalib = ModGLUE() - - else: - raise ValueError + # 6. Creamos el modelo ModCalib de calibración, lo cual genera variables SpotPy + símismo.ModCalib = ModSpotPy( + función=símismo._simul_exps, + dic_argums=dic_argums, + d_obs=d_obs, + lista_d_paráms=lista_paráms, + aprioris=lista_aprioris, + lista_líms=lista_líms, + id_calib=nombre, + función_llenar_coefs=símismo._llenar_coefs, + método=método + ) if nombre_pdzt_ant is not None: símismo.borrar_calib(id_calib=nombre_pdzt_ant) @@ -1054,9 +1049,6 @@ def validar(símismo, exper, nombre=None, calibs=None, paso=1, n_rep_parám=20, :param dib_dists: Si hay que dibujar las distribuciones utilizadas para la simulación. :type dib_dists: bool - :param dib_dists: Si hay que dibujar las distribuciones utilizadas para la simulación. - :type dib_dists: bool - :return: Un diccionario con los resultados de la validación. :rtype: dict """ @@ -1529,7 +1521,7 @@ def _prep_dic_simul(símismo, exper, n_rep_estoc, n_rep_paráms, paso, n_pasos, n_rep_estoc=n_rep_estoc, n_rep_parám=n_rep_paráms) if tipo == 'calib': - símismo._gen_dics_calib(exper=exper) + símismo._gen_dics_calib(exper=exper, n_rep_estoc=n_rep_estoc) def _gen_dic_predics_exps(símismo, exper, n_rep_estoc, n_rep_parám, paso, n_pasos, detalles): raise NotImplementedError @@ -1537,7 +1529,7 @@ def _gen_dic_predics_exps(símismo, exper, n_rep_estoc, n_rep_parám, paso, n_pa def _gen_dics_valid(símismo, exper, paso, n_pasos, n_rep_estoc, n_rep_parám): raise NotImplementedError - def _gen_dics_calib(símismo, exper): + def _gen_dics_calib(símismo, exper, n_rep_estoc): raise NotImplementedError def _simul_exps(símismo, paso, n_pasos, extrn, detalles, devolver_calib, depurar=False): @@ -1580,23 +1572,15 @@ def _simul_exps(símismo, paso, n_pasos, extrn, detalles, devolver_calib, depura print('Simulación (%s) calculada en: ' % exp, time.time() - antes) # Procesar los egresos de la simulación. - antes = time.time() símismo._procesar_simul() - dif_p_s = time.time() - antes if devolver_calib: # Convertir los diccionarios de predicciones en un vector numpy. - antes = time.time() símismo._procesar_valid() - dif_p_v = time.time() - antes - antes = time.time() símismo._procesar_calib() - dif_p_c = time.time() - antes - print('Procesando predicciones: \n\tSimul: {}\n\tValid: {}\n\tCalib: {}\n\tTotal: {}' - .format(dif_p_s, dif_p_v, dif_p_c, dif_p_s + dif_p_v + dif_p_c)) # Devolver las predicciones. - return símismo.dic_simul['d_calib'] + return símismo.dic_simul def _procesar_simul(símismo): """ @@ -1658,22 +1642,15 @@ def _procesar_calib(símismo): for t_dist, l_matr_v in d_l_m_valid.items(): d_dist = d_calib[t_dist] # type: dict - # Por una razón extraña, PyMC se queja si no hacemos copias aquí. A ver si hay que hacer lo mismo con PyMC3. - d_dist['mu'] = np.zeros_like(d_dist['mu']) - d_dist['sigma'] = np.zeros_like(d_dist['sigma']) - for i, m in enumerate(l_matr_v): r = d_índs[t_dist][i]['rango'] parc, etps, días = d_índs[t_dist][i]['índs'] if t_dist == 'Normal': - d_dist['mu'][r[0]:r[1]] = np.mean(m[parc, :, 0, etps, días], axis=1) - - # Evitar sigmas de 0. Causan muchos problemas después. - d_dist['sigma'][r[0]:r[1]] = np.maximum(1, np.std(m[parc, :, 0, etps, días], axis=1)) + d_dist[r[0]:r[1]] = m[parc, :, 0, etps, días] else: - raise ValueError + raise ValueError(t_dist) def _procesar_matrs_sens(símismo): """ @@ -1886,7 +1863,7 @@ def sacar_dists_de_dic(d, l=None, u=None): u.append(ll) sacar_dists_de_dic(d=v, l=l, u=u) - elif isinstance(v, VarCalib): + elif isinstance(v, VarSpotPy): u.append(ll) l.append((u.copy(), v)) u.pop() @@ -2096,7 +2073,7 @@ def prep_receta_json(d, d_egr=None): # Transformar matrices numpy a texto d_egr[ll] = v.tolist() - elif isinstance(v, VarCalib): + elif isinstance(v, VarSpotPy): # Si el itema es un variable de PyMC, borrarlo d_egr.pop(ll) diff --git "a/tikon/Matem\303\241ticas/Arte.py" "b/tikon/Matem\303\241ticas/Arte.py" index 307d6463..ee7bb7bc 100644 --- "a/tikon/Matem\303\241ticas/Arte.py" +++ "b/tikon/Matem\303\241ticas/Arte.py" @@ -4,7 +4,7 @@ from matplotlib.backends.backend_agg import FigureCanvasAgg as TelaFigura from matplotlib.figure import Figure as Figura -from tikon.Matemáticas.Variables import VarSciPy, VarCalib +from tikon.Matemáticas.Variables import VarSciPy, VarSpotPy from tikon.Controles import valid_archivo @@ -265,7 +265,7 @@ def graficar_dists(dists, valores=None, rango=None, título=None, archivo=None): # Poner cada distribución en el gráfico for dist in dists: - if isinstance(dist, VarCalib): + if isinstance(dist, VarSpotPy): ejes = fig.subplots(1, 2) dist.dibujar(ejes=ejes) @@ -300,7 +300,7 @@ def graficar_dists(dists, valores=None, rango=None, título=None, archivo=None): # Si hay valores, hacer un histrograma if valores is not None: valores = valores.astype(float) - ejes.hist(valores, normed=True, color='green', histtype='stepfilled', alpha=0.2) + ejes.hist(valores, density=True, color='green', histtype='stepfilled', alpha=0.2) # Si se especificó un título, ponerlo if título is not None: diff --git "a/tikon/Matem\303\241ticas/Calib.py" "b/tikon/Matem\303\241ticas/Calib.py" index 87af845d..5c527405 100644 --- "a/tikon/Matem\303\241ticas/Calib.py" +++ "b/tikon/Matem\303\241ticas/Calib.py" @@ -1,17 +1,14 @@ -import math as mat -from tempfile import mkdtemp +import os +import tempfile from warnings import warn as avisar import numpy as np -import pymc as pm2 -import pymc3 as pm3 -import theano.tensor as tt -from pymc3.step_methods import smc as mcs -from theano.compile.ops import as_op +import spotpy +import scipy.stats as estad -from tikon.Controles import usar_pymc3 +from tikon.Matemáticas.Experimentos import BDtexto from tikon.Matemáticas.Incert import trazas_a_dists -from tikon.Matemáticas.Variables import VarPyMC2 +from tikon.Matemáticas.Variables import _inv_logit class ModCalib(object): @@ -114,218 +111,165 @@ def __init__(símismo, función, dic_argums, d_obs, lista_d_paráms, aprioris, l super().__init__(id_calib=id_calib, lista_d_paráms=lista_d_paráms, método=método) símismo.n_iter = 0 - if not usar_pymc3: - - # Crear una lista de los objetos estocásticos de PyMC para representar a los parámetros. Esta función - # también es la responsable para crear la conexión dinámica entre el diccionario de los parámetros y - # la maquinaría de calibración de PyMC. - l_var_paráms = trazas_a_dists(id_simul=símismo.id, l_d_pm=lista_d_paráms, l_lms=lista_líms, - l_trazas=aprioris, formato='calib', comunes=False) - - # Crear una lista de los variables "finales" de los parámetros - l_vars_pymc = [v.var for v in l_var_paráms] - - # Un variable de prueba - vacío_2 = pm2.Normal('vacío_2', 0, 1) - l_vars_pymc.append(vacío_2) - - # Llenamos las matrices de coeficientes con los variables PyMC recién creados. - función_llenar_coefs(nombre_simul=id_calib, n_rep_parám=1, dib_dists=False) - - # Una función determinística para llamar a la función de simulación del modelo que estamos calibrando. Le - # pasamos los argumentos necesarios, si aplican. Hay que incluir los parámetros de la lista l_var_pymc, - # porque si no PyMC no se dará cuenta de que la función simular() depiende de los otros parámetros y se le - # olvidará de recalcularla cada vez que cambian los valores de los parámetros. - - # Para hacer: formalizar - avisar('Código experimental--¡¡probablemente no funcional!!') - # err_temp = [VarPyMC2('error_mu_{}'.format(x), tipo_dist='Gamma', paráms={'a': 1, 'escl': 1, 'ubic': 0}) - # for x in range(12)] - # l_err_temp = [v.var for v in err_temp] - # n_mem = [VarPyMC2('n_mem_error_{}'.format(x), tipo_dist='Gamma', paráms={'a': 1, 'escl': 10, 'ubic': 1}) - # for x in range(12)] - # l_n_mem = [v.var for v in n_mem] - # l_vars_err = l_err_temp + l_n_mem - # - # def calc_err(mu, mag, n_mem, n_etps=12): - # e = np.zeros_like(mu, dtype=float) - # tam = len(mu) // n_etps - # - # for n in range(mu.shape[0]): - # - # rest = n % tam - # div = n // tam - # - # mem = n_mem[div] - # mitad_mem = mem / 2 - # - # if rest <= mitad_mem: - # lím_inf = div * tam - # lím_sup = div * tam + mem - # - # elif rest >= tam - mitad_mem: - # lím_inf = (div + 1) * tam - mem - 1 - # lím_sup = (div + 1) * tam - 1 - # else: - # lím_inf = n - mitad_mem - # lím_sup = n + mitad_mem - # - # lím_inf = np.maximum(lím_inf, div * tam) - # lím_sup = np.minimum(lím_sup, (div+1) * tam - 1) - # - # máx_preds = np.max(mu[mat.ceil(lím_inf):mat.floor(lím_sup) + 1]) - # mín_preds = np.min(mu[mat.ceil(lím_inf):mat.floor(lím_sup) + 1]) - # - # if lím_inf != int(lím_inf): - # val_lím_inf = np.interp(lím_inf, range(mu.shape[0]), mu) - # máx_preds = max(máx_preds, val_lím_inf) - # mín_preds = min(mín_preds, val_lím_inf) - # - # if lím_sup != int(lím_sup): - # val_lím_sup = np.interp(lím_sup, range(mu.shape[0]), mu) - # máx_preds = max(máx_preds, val_lím_sup) - # mín_preds = min(mín_preds, val_lím_sup) - # - # rango_preds = np.maximum(0, máx_preds - mín_preds) - # - # e[n] = rango_preds * mag[div] - # - # return np.maximum(e, 1) - - # fin de para hacer: formalizar - - # res = función(**dic_argums) - - - @pm2.deterministic(trace=False) - def simul(_=l_vars_pymc, d=d_obs): - res = función(**dic_argums) - return res - - var_error = VarPyMC2('error_mod', tipo_dist='Gamma', paráms={'a': 1, 'escl': .01, 'ubic': 0}) - # var_error = pm2.Gamma('error_mod', alpha=1, beta=1/0.1) - # - @pm2.deterministic(trace=False) - def calc_tau_mod(r=simul, ve=var_error.var): + # Crear una lista de los objetos estocásticos de PyMC para representar los parámetros. Esta función + # también es la responsable de crear la conexión dinámica entre el diccionario de los parámetros y + # la maquinaria de calibración de PyMC. + l_var_paráms = trazas_a_dists(id_simul=símismo.id, l_d_pm=lista_d_paráms, l_lms=lista_líms, + l_trazas=aprioris, formato='calib', comunes=False) + + # Crear una lista de los variables "finales" de los parámetros + l_vars_pymc = [v.var for v in l_var_paráms] + + # Un variable de prueba + vacío_2 = pm2.Normal('vacío_2', 0, 1) + l_vars_pymc.append(vacío_2) + + # Llenamos las matrices de coeficientes con los variables PyMC recién creados. + función_llenar_coefs(nombre_simul=id_calib, n_rep_parám=1, dib_dists=False) + + # Una función determinística para llamar a la función de simulación del modelo que estamos calibrando. Le + # pasamos los argumentos necesarios, si aplican. Hay que incluir los parámetros de la lista l_var_pymc, + # porque si no PyMC no se dará cuenta de que la función simular() depiende de los otros parámetros y se le + # olvidará de recalcularla cada vez que cambian los valores de los parámetros. + + # Para hacer: formalizar + avisar('Código experimental--¡¡probablemente no funcional!!') + + # err_temp = [VarPyMC2('error_mu_{}'.format(x), tipo_dist='Gamma', paráms={'a': 1, 'escl': 1, 'ubic': 0}) + # for x in range(12)] + # l_err_temp = [v.var for v in err_temp] + # n_mem = [VarPyMC2('n_mem_error_{}'.format(x), tipo_dist='Gamma', paráms={'a': 1, 'escl': 10, 'ubic': 1}) + # for x in range(12)] + # l_n_mem = [v.var for v in n_mem] + # l_vars_err = l_err_temp + l_n_mem + # + # def calc_err(mu, mag, n_mem, n_etps=12): + # e = np.zeros_like(mu, dtype=float) + # tam = len(mu) // n_etps + # + # for n in range(mu.shape[0]): + # + # rest = n % tam + # div = n // tam + # + # mem = n_mem[div] + # mitad_mem = mem / 2 + # + # if rest <= mitad_mem: + # lím_inf = div * tam + # lím_sup = div * tam + mem + # + # elif rest >= tam - mitad_mem: + # lím_inf = (div + 1) * tam - mem - 1 + # lím_sup = (div + 1) * tam - 1 + # else: + # lím_inf = n - mitad_mem + # lím_sup = n + mitad_mem + # + # lím_inf = np.maximum(lím_inf, div * tam) + # lím_sup = np.minimum(lím_sup, (div+1) * tam - 1) + # + # máx_preds = np.max(mu[mat.ceil(lím_inf):mat.floor(lím_sup) + 1]) + # mín_preds = np.min(mu[mat.ceil(lím_inf):mat.floor(lím_sup) + 1]) + # + # if lím_inf != int(lím_inf): + # val_lím_inf = np.interp(lím_inf, range(mu.shape[0]), mu) + # máx_preds = max(máx_preds, val_lím_inf) + # mín_preds = min(mín_preds, val_lím_inf) + # + # if lím_sup != int(lím_sup): + # val_lím_sup = np.interp(lím_sup, range(mu.shape[0]), mu) + # máx_preds = max(máx_preds, val_lím_sup) + # mín_preds = min(mín_preds, val_lím_sup) + # + # rango_preds = np.maximum(0, máx_preds - mín_preds) + # + # e[n] = rango_preds * mag[div] + # + # return np.maximum(e, 1) + + # fin de para hacer: formalizar + + # res = función(**dic_argums) + + @pm2.deterministic(trace=False) + def simul(_=l_vars_pymc, d=d_obs): + res = función(**dic_argums) + return res + + var_error = VarPyMC2('error_mod', tipo_dist='Gamma', paráms={'a': 1, 'escl': .01, 'ubic': 0}) + + # var_error = pm2.Gamma('error_mod', alpha=1, beta=1/0.1) + # + @pm2.deterministic(trace=False) + def calc_tau_mod(r=simul, ve=var_error.var): # return 1 / float(var_error)**2 - return 1 / np.maximum(1, (var_error*r['Normal']['mu'])**2) - # - # @pm2.deterministic(trace=False) - # def calc_error_temp(r=simul, e=l_err_temp, n=l_n_mem, d=d_obs, ve=var_error): - # - # error = calc_err(r['Normal']['mu'], mag=err_temp, n_mem=n_mem) - # return error - - # Ahora, las observaciones - l_var_obs = [] # Una lista para los variables de observación - for tipo, m_obs in d_obs.items(): - # Para cada tipo (distribución) de observación y su matriz de observaciones correspondiente... - - # ... crear la distribución apropiada en PyMC - if tipo == 'Gamma': - # Si las observaciones siguen una distribución Gamma... - - # Crear el variable PyMC - var_obs = pm2.Gamma('obs_{}'.format(tipo), alpha=simul['Gamma']['alpha'], - beta=simul['Gamma']['beta'], - value=m_obs, observed=True, trace=False) - - # ...y agregarlo a la lista de variables de observación - l_var_obs.extend([var_obs]) - - elif tipo == 'Normal': - # Si tenemos distribución normal de las observaciones... - # - # mu_final = pm2.Normal('mu_final', mu=mu, tau=calc_tau_mod, trace=False) - - # tau = simul['Normal']['sigma'] ** -2 - tau = pm2.HalfNormal('mitau', tau=1e6) - # mu = pm2.Normal('mu_error', mu=simul['Normal']['mu'], tau=tau, trace=False) - var_obs = pm2.Normal('obs_{}'.format(tipo), - # mu=mu_final, - tau=calc_tau_mod, - mu=simul['Normal']['mu'], - value=m_obs, observed=True, trace=False) - - nuevos = [var_obs, - tau, - # mu, - # mu_final, - # var_obs.parents['mu'], - # tau.parents['a'], tau.parents['a'].parents['self'] - ] - l_var_obs.extend(nuevos) - else: - raise ValueError - - # Otro variable de prueba - vacío_0 = pm2.Normal('vacío_0', 0, 1) - - # Y, por fin, el objeto MCMC de PyMC que trae todos estos componentes juntos. - símismo.MCMC = pm2.MCMC({simul, -# calc_error_temp, - calc_tau_mod, - # var_error.var, - *l_vars_pymc[0:1], - var_error.var, -# *l_vars_err, - *l_var_obs, vacío_0, vacío_2}, - db='sqlite', - dbname=símismo.id, - dbmode='w') - else: + return 1 / np.maximum(1, (var_error * r['Normal']['mu']) ** 2) + + # + # @pm2.deterministic(trace=False) + # def calc_error_temp(r=simul, e=l_err_temp, n=l_n_mem, d=d_obs, ve=var_error): + # + # error = calc_err(r['Normal']['mu'], mag=err_temp, n_mem=n_mem) + # return error + + # Ahora, las observaciones + l_var_obs = [] # Una lista para los variables de observación + for tipo, m_obs in d_obs.items(): + # Para cada tipo (distribución) de observación y su matriz de observaciones correspondiente... + + # ... crear la distribución apropiada en PyMC + if tipo == 'Gamma': + # Si las observaciones siguen una distribución Gamma... + + # Crear el variable PyMC + var_obs = pm2.Gamma('obs_{}'.format(tipo), alpha=simul['Gamma']['alpha'], + beta=simul['Gamma']['beta'], + value=m_obs, observed=True, trace=False) + + # ...y agregarlo a la lista de variables de observación + l_var_obs.extend([var_obs]) + + elif tipo == 'Normal': + # Si tenemos distribución normal de las observaciones... + # + # mu_final = pm2.Normal('mu_final', mu=mu, tau=calc_tau_mod, trace=False) + + # tau = simul['Normal']['sigma'] ** -2 + tau = pm2.HalfNormal('mitau', tau=1e6) + # mu = pm2.Normal('mu_error', mu=simul['Normal']['mu'], tau=tau, trace=False) + var_obs = pm2.Normal('obs_{}'.format(tipo), + # mu=mu_final, + tau=calc_tau_mod, + mu=simul['Normal']['mu'], + value=m_obs, observed=True, trace=False) + + nuevos = [var_obs, + tau, + # mu, + # mu_final, + # var_obs.parents['mu'], + # tau.parents['a'], tau.parents['a'].parents['self'] + ] + l_var_obs.extend(nuevos) + else: + raise ValueError - símismo.MCMC = pm3.Model() - - with símismo.MCMC as mod: - # Crear una lista de los objetos estocásticos de PyMC para representar a los parámetros. Esta función - # también es la responsable para crear la conexión dinámica entre el diccionario de los parámetros y - # la maquinaría de calibración de PyMC. - l_var_paráms = trazas_a_dists(id_simul=símismo.id, l_d_pm=lista_d_paráms, l_lms=lista_líms, - l_trazas=aprioris, formato='calib', comunes=False) - - # Llenamos las matrices de coeficientes con los variables PyMC recién creados. - función_llenar_coefs(nombre_simul=id_calib, n_rep_parám=1, dib_dists=False) - - # Una función determinística para llamar a la función de simulación del modelo que estamos calibrando. Le - # pasamos los argumentos necesarios, si aplican. Hay que incluir los parámetros de la lista l_var_pymc, - # porque si no PyMC no se dará cuenta de que la función simular() depiende de los otros parámetros y se le - # olvidará de recalcularla cada vez que cambian los valores de los parámetros. - @as_op(itypes=[tt.fscalar] * len(l_var_paráms), otypes=[tt.fscalar]) - def simul(_=l_var_paráms): - return función(**dic_argums) - - # Ahora, las observaciones - l_var_obs = [] # Una lista para los variables de observación - for tipo, m_obs in d_obs.items(): - # Para cada tipo (distribución) de observación y su matriz de observaciones correspondiente... - - # ... crear la distribución apropiada en PyMC - if tipo == 'Gamma': - # Si las observaciones siguen una distribución Gamma... - - # Crear el variable PyMC - var_obs = pm2.Gamma('obs_{}'.format(tipo), alpha=simul['Gamma']['alpha'], - beta=simul['Gamma']['beta'], - value=m_obs, observed=True, trace=False) - - # ...y agregarlo a la lista de variables de observación - l_var_obs.extend([var_obs]) - - elif tipo == 'Normal': - # Si tenemos distribución normal de las observaciones... - tau = simul['Normal']['sigma'] ** -2 - var_obs = pm2.Normal('obs_{}'.format(tipo), mu=simul['Normal']['mu'], tau=tau, - value=m_obs, observed=True, trace=False) - nuevos = [var_obs, tau, var_obs.parents['mu'], var_obs.parents['mu'].parents['self'], - tau.parents['a'], tau.parents['a'].parents['self']] - l_var_obs.extend(nuevos) - else: - raise ValueError - - # Y, por fin, el objeto MCMC de PyMC que trae todos estos componentes juntos. - símismo.MCMC = pm2.MCMC({simul, *l_var_paráms, *l_var_obs}, db='sqlite', dbname=símismo.id, - dbmode='w') + # Otro variable de prueba + vacío_0 = pm2.Normal('vacío_0', 0, 1) + + # Y, por fin, el objeto MCMC de PyMC que trae todos estos componentes juntos. + símismo.MCMC = pm2.MCMC({simul, + # calc_error_temp, + calc_tau_mod, + # var_error.var, + *l_vars_pymc[0:1], + var_error.var, + # *l_vars_err, + *l_var_obs, vacío_0, vacío_2}, + db='sqlite', + dbname=símismo.id, + dbmode='w') def calib(símismo, rep, quema, extraer): """ @@ -347,32 +291,86 @@ def calib(símismo, rep, quema, extraer): símismo.n_iter += rep - if not usar_pymc3: - # Utilizar el algoritmo Metrópolis Adaptivo para la calibración. Sería probablemente mejor utilizar NUTS, pero - # para eso tendría que implementar pymc3 aquí y de verdad no quiero. - if símismo.método.lower() == 'metrópolis adaptivo': - símismo.MCMC.use_step_method(pm2.AdaptiveMetropolis, símismo.MCMC.stochastics, - delay=200, interval=200, - greedy=False, shrink_if_necessary=True, verbose=4 - ) - elif símismo.método.lower() == 'metrópolis': - pass + # Utilizar el algoritmo Metrópolis Adaptivo para la calibración. Sería probablemente mejor utilizar NUTS, pero + # para eso tendría que implementar pymc3 aquí y de verdad no quiero. + if símismo.método.lower() == 'metrópolis adaptivo': + símismo.MCMC.use_step_method(pm2.AdaptiveMetropolis, símismo.MCMC.stochastics, + delay=200, interval=200, + greedy=False, shrink_if_necessary=True, verbose=4 + ) + elif símismo.método.lower() == 'metrópolis': + pass + else: + raise ValueError + + # Llamar la función "sample" (muestrear) del objeto MCMC de PyMC + símismo.MCMC.sample(iter=rep, burn=quema, thin=extraer, verbose=1, tune_interval=10) + + +class ModSpotPy(ModCalib): + + def __init__(símismo, función, dic_argums, d_obs, lista_d_paráms, aprioris, lista_líms, id_calib, + función_llenar_coefs, método): + super().__init__(id_calib=id_calib, lista_d_paráms=lista_d_paráms, método=método) + + símismo.paráms = trazas_a_dists( + id_simul=símismo.id, l_d_pm=lista_d_paráms, l_lms=lista_líms, + l_trazas=aprioris, formato='calib', comunes=False + ) + + for prm in símismo.paráms: + prm.modelo = símismo + + # Llenamos las matrices de coeficientes con los variables SpotPy recién creados. + función_llenar_coefs(nombre_simul=id_calib, n_rep_parám=1, dib_dists=False) + + símismo.func = función + símismo.args_f = dic_argums + símismo.d_obs = d_obs + + def calib(símismo, rep, quema, extraer): + + if símismo.método in _algs_spotpy: + + temp = tempfile.NamedTemporaryFile('w', encoding='UTF-8', prefix='CalibTinamït_') + + mod_spotpy = ParaSpotPy(func=símismo.func, args_f=símismo.args_f, paráms=símismo.paráms, obs=símismo.d_obs) + + muestreador = _algs_spotpy[símismo.método](mod_spotpy, dbname=temp.name, dbformat='csv', save_sim=False) + + if símismo.método == 'dream': + muestreador.sample(repetitions=2000 + rep, runs_after_convergence=rep) else: - raise ValueError + muestreador.sample(rep) + egr_spotpy = BDtexto(temp.name + '.csv') + + cols_prm = [c for c in egr_spotpy.sacar_cols() if c.startswith('par')] + trzs = np.array([pr._transf_vals(v) for pr, v in zip(símismo.paráms, egr_spotpy.obt_datos(cols_prm))]) + probs = egr_spotpy.obt_datos('like1') + + if os.path.isfile(temp.name + '.csv'): + os.remove(temp.name + '.csv') + + if símismo.método == 'dream': + trzs = trzs[-rep:] + probs = probs[-rep:] + else: + buenas = probs >= np.quantile(probs, 0.95) + trzs = trzs[:, buenas] + probs = probs[buenas] + + rango_prob = (probs.min(), probs.max()) + pesos = (probs - rango_prob[0]) / (rango_prob[1] - rango_prob[0]) - # Llamar la función "sample" (muestrear) del objeto MCMC de PyMC - símismo.MCMC.sample(iter=rep, burn=quema, thin=extraer, verbose=1, tune_interval=10) + res = {} + for i, p in enumerate(símismo.paráms): + # col_p = ('par' + str(p)).replace(' ', '_') + p.traza = trzs[i] + + return res else: - if símismo.método.lower() == 'mcs': - n_trazas = 1 - dir_temp = mkdtemp(prefix='TKN_MCS') - traza = mcs.sample_smc(n_steps=rep, - n_chains=n_trazas, - progressbar=False, - homepath=dir_temp, - stage=0, - random_seed=42) + raise ValueError('Método de calibración "{}" no reconocido.'.format(símismo.método)) def guardar(símismo, nombre=None): """ @@ -384,10 +382,6 @@ def guardar(símismo, nombre=None): # Asegurarse de que el nombre de la calibración sea en el formato de texto id_calib = str(símismo.id) - # Reabrir la base de datos SQLite - # bd = pm2.database.sqlite.load(id_calib) - # bd.connect_model(símismo.MCMC) - # Si no se especificó nombre, se empleará el mismo nombre que el id de la calibración. if nombre is None: nombre = símismo.id @@ -396,12 +390,9 @@ def guardar(símismo, nombre=None): for d_parám in símismo.lista_parám: # type: dict - # Para cada parámetro en la lista, convertir el variable PyMC en un vector numpy de sus trazas, y + # Para cada parámetro en la lista, convertir el variable SpotPy en un vector numpy de sus trazas, y # cambiar el nombre - vec_np = d_parám[id_calib].traza() - if not len(vec_np): - vec_np = np.zeros(símismo.n_iter) - vec_np[:] = float(d_parám[id_calib]) + vec_np = d_parám[id_calib].traza # Quitar el nombre y variable inicial d_parám.pop(id_calib) @@ -409,18 +400,73 @@ def guardar(símismo, nombre=None): # Guardar la traza bajo el nuevo nombre d_parám[nombre] = vec_np - # Cerrar la base de datos de nuevo - símismo.MCMC.db.close() +_algs_spotpy = { + 'fast': spotpy.algorithms.fast, + 'dream': spotpy.algorithms.dream, + 'mc': spotpy.algorithms.mc, + 'mcmc': spotpy.algorithms.mcmc, + 'mle': spotpy.algorithms.mle, + 'lhs': spotpy.algorithms.lhs, + 'sa': spotpy.algorithms.sa, + 'sceua': spotpy.algorithms.sceua, + 'rope': spotpy.algorithms.rope, + 'abc': spotpy.algorithms.abc, + 'fscabc': spotpy.algorithms.fscabc, -class ModGLUE(ModCalib): +} - def __init__(símismo, id_calib, lista_d_paráms, método): - super().__init__(id_calib=id_calib, lista_d_paráms=lista_d_paráms, método=método) - raise NotImplementedError - def calib(símismo, rep, quema, extraer): - raise NotImplementedError +class ParaSpotPy(object): + def __init__(símismo, func, args_f, paráms, obs): + """ - def guardar(símismo, nombre=None): - raise NotImplementedError + Parameters + ---------- + mod : Modelo.Modelo + líms_paráms : dict + obs: xr.Dataset + """ + + símismo.paráms = paráms + + símismo.func = func + símismo.args_f = args_f + + símismo.obs = obs + + símismo.res = None + + def parameters(símismo): + return spotpy.parameter.generate([p.var for p in símismo.paráms]) + + def simulation(símismo, x): + for v, p in zip(x, símismo.paráms): + p.val = v + + símismo.res = símismo.func(**símismo.args_f)['d_calib']['Normal'] + return np.mean(símismo.res, axis=1) + + def evaluation(símismo): + return símismo.obs['Normal'] + + def objectivefunction(símismo, simulation, evaluation, params=None): + # like = spotpy.likelihoods.gaussianLikelihoodMeasErrorOut(evaluation,simulation) + + return _dens_con_pred(evaluation, símismo.res) + + +def _dens_con_pred(obs, sim): + res = [] + for s, o in zip(sim, obs): + d = o*(1+np.exp(-o*2)) / (1-np.exp(-o*2)) + if np.isnan(d): + d = 1 + + s = s / d + o = o / d + try: + res.append(_inv_logit(estad.gaussian_kde(s)(o)[0])) + except np.linalg.linalg.LinAlgError: + res.append(1 if o == s[0] else 0) + return np.mean(res) diff --git "a/tikon/Matem\303\241ticas/Distribuciones.py" "b/tikon/Matem\303\241ticas/Distribuciones.py" index 8113b371..76a0fc35 100644 --- "a/tikon/Matem\303\241ticas/Distribuciones.py" +++ "b/tikon/Matem\303\241ticas/Distribuciones.py" @@ -1,12 +1,6 @@ import math as mat import numpy as np - -try: - import pymc3 as pm3 -except ImportError: - pm3 = None - import scipy.stats as estad # Par asimplificar el código (un poquitísimo) @@ -130,10 +124,6 @@ 'límites': (0, inf), 'tipo': 'cont' }, - # 'FrechetIzquierda': {'scipy': estad.frechet_l, - # 'pymc': None, - # 'límites': (-inf, 0) - # }, 'LogísticaGeneral': {'scipy': estad.genlogistic, 'paráms': ['c', 'ubic', 'escl'], 'límites': (0, inf), @@ -319,16 +309,11 @@ 'límites': (0, inf), 'tipo': 'cont' }, - - # Desactivada por complicación de conversión PyMC-SciPy - # - # 'TNoCentral': {'scipy': estad.nct, - # 'paráms': ['df', 'nc', 'ubic', 'escl'], - # 'pymc': NoncentralT, - # 'límites': (-inf, inf), - # 'tipo': 'cont' - # }, - + 'TNoCentral': {'scipy': estad.nct, + 'paráms': ['df', 'nc', 'ubic', 'escl'], + 'límites': (-inf, inf), + 'tipo': 'cont' + }, 'Normal': {'scipy': estad.norm, 'paráms': ['ubic', 'escl'], 'límites': (-inf, inf), diff --git "a/tikon/Matem\303\241ticas/Experimentos.py" "b/tikon/Matem\303\241ticas/Experimentos.py" index f5842e62..3459e8bb 100644 --- "a/tikon/Matem\303\241ticas/Experimentos.py" +++ "b/tikon/Matem\303\241ticas/Experimentos.py" @@ -820,7 +820,7 @@ def calc_n_obs(símismo): :rtype: int """ - with open(símismo.archivo) as d: + with open(símismo.archivo, encoding='utf8') as d: n_filas = sum(1 for f in d if len(f)) - 1 # Sustrayemos la primera fila return n_filas diff --git "a/tikon/Matem\303\241ticas/Incert.py" "b/tikon/Matem\303\241ticas/Incert.py" index 41ce5575..a5bb85db 100644 --- "a/tikon/Matem\303\241ticas/Incert.py" +++ "b/tikon/Matem\303\241ticas/Incert.py" @@ -3,9 +3,8 @@ import numpy as np import scipy.stats as estad -from tikon.Matemáticas.Variables import VarSciPy, VarCalib, VarPyMC2, VarPyMC3 from tikon import __email__ as correo -from tikon.Controles import usar_pymc3 +from tikon.Matemáticas.Variables import VarSciPy, VarSpotPy try: import pymc3 as pm3 @@ -88,13 +87,10 @@ def trazas_a_dists(id_simul, l_d_pm, l_trazas, formato, comunes, l_lms=None, n_r # Si querremos generar distribuciones para una calibración, generar un variable PyMC directamente. # El nombre para el variable PyMC - nombre_pymc = 'parám_{}'.format(n) + nombre_spotpy = 'parám_{}'.format(n) # Convertir el texto directamente en distribución - if usar_pymc3: - dist = VarPyMC3.de_texto(texto=d_parám[trzs_texto[0]], nombre=nombre_pymc) - else: - dist = VarPyMC2.de_texto(texto=d_parám[trzs_texto[0]], nombre=nombre_pymc) + dist = VarSpotPy.de_texto(texto=d_parám[trzs_texto[0]], nombre=nombre_spotpy) elif formato == 'valid': # Si querremos una distribución para una validación, generar una traza en NumPy @@ -110,23 +106,23 @@ def trazas_a_dists(id_simul, l_d_pm, l_trazas, formato, comunes, l_lms=None, n_r dist = VarSciPy.de_texto(texto=d_parám[trzs_texto[0]]) else: - raise ValueError + raise ValueError(formato) else: # Si tenemos más que una calibración aplicable o esta está en formato de matriz... if formato == 'calib': # El nombre para el variable PyMC - nombre_pymc = 'parám_%i' % n + nombre_spotpy = 'parám_%i' % n # Un vector numpy de la traza de datos para generar la distribución PyMC. vec_np = gen_vector_coefs(d_parám=d_parám, í_trazas=l_í_trazas[n]) # Generar la distribución PyMC if usar_pymc3: - dist = VarPyMC3.ajust_dist(datos=vec_np, líms=l_lms[n], cont=True, nombre=nombre_pymc) + dist = VarPyMC3.ajust_dist(datos=vec_np, líms=l_lms[n], cont=True, nombre=nombre_spotpy) else: - dist = VarPyMC2.ajust_dist(datos=vec_np, líms=l_lms[n], cont=True, nombre=nombre_pymc) + dist = VarPyMC2.ajust_dist(datos=vec_np, líms=l_lms[n], cont=True, nombre=nombre_spotpy) elif formato == 'valid': # En el caso de validación, simplemente querremos una distribución NumPy @@ -232,7 +228,7 @@ def calc_índs(d_trza, l_trza): índs = np.random.choice(range(tamaño_máx), size=rep_per_calib[i], replace=devolv) d_índs[nombre_trz] = índs - elif isinstance(dist, VarCalib): + elif isinstance(dist, VarSpotPy): # ..y si es un variable de calibración activa, poner el variable sí mismo en la matriz d_índs[nombre_trz] = None @@ -300,7 +296,7 @@ def gen_vector_coefs(d_parám, í_trazas): dist_sp = VarSciPy.de_texto(d_parám[trz]) vector.append(dist_sp.muestra_alea(n=índs)) - elif isinstance(d_parám[trz], VarCalib): + elif isinstance(d_parám[trz], VarSpotPy): # Variables de calibraciones activas (PyMC) se agregan directamente vector.append(d_parám[trz]) @@ -436,7 +432,7 @@ def validar_matr_pred(matr_predic, vector_obs): :return: Devuelve los valores de R2, de RCNEP (Raíz cuadrada normalizada del error promedio), y el R2 de la exactitud de los intervalos de confianza (1.0 = exactitud perfecta). - :rtype: (float, float, float) + :rtype: dict """ # Quitar observaciones que faltan diff --git "a/tikon/Matem\303\241ticas/Prueba_PyMC.py" "b/tikon/Matem\303\241ticas/Prueba_PyMC.py" index 6c409ae9..d710082f 100644 --- "a/tikon/Matem\303\241ticas/Prueba_PyMC.py" +++ "b/tikon/Matem\303\241ticas/Prueba_PyMC.py" @@ -223,7 +223,7 @@ def func_todo(mu=var_mu.var, s=var_s.var, _=l_vars): if isinstance(v, VarPyMC2): if 'z' not in v.nombre and v.nombre != 'func_todo': try: - dib.plot(v.traza()) + dib.plot(v.traza) dib.title(v.nombre) dib.show() diff --git "a/tikon/Matem\303\241ticas/Pruebas.py" "b/tikon/Matem\303\241ticas/Pruebas.py" index 6c79652d..3fa127c3 100644 --- "a/tikon/Matem\303\241ticas/Pruebas.py" +++ "b/tikon/Matem\303\241ticas/Pruebas.py" @@ -66,11 +66,11 @@ lista_dist=[nombre])[0] if dibujar: - dib.hist(núms, normed=True, color='red', histtype='stepfilled', alpha=0.2, bins=100) + dib.hist(núms, density=True, color='red', histtype='stepfilled', alpha=0.2, bins=100) - dib.hist(puntos_scipy, normed=True, color='blue', histtype='stepfilled', alpha=0.2, bins=100) + dib.hist(puntos_scipy, density=True, color='blue', histtype='stepfilled', alpha=0.2, bins=100) - dib.hist(puntos_pymc, normed=True, color='green', histtype='stepfilled', alpha=0.2, bins=100) + dib.hist(puntos_pymc, density=True, color='green', histtype='stepfilled', alpha=0.2, bins=100) x = np.linspace(dist_scipy.ppf(0.01), dist_scipy.ppf(0.99), 100) dib.plot(x, dist_scipy.pdf(x), 'b-', lw=2, alpha=0.6) diff --git "a/tikon/Matem\303\241ticas/Variables.py" "b/tikon/Matem\303\241ticas/Variables.py" index 485c064f..5dd1a6a0 100644 --- "a/tikon/Matem\303\241ticas/Variables.py" +++ "b/tikon/Matem\303\241ticas/Variables.py" @@ -1,16 +1,16 @@ import ast import math as mat +import re from warnings import warn as avisar import matplotlib.pyplot as dib import numpy as np -import pymc as pm2 -import pymc3 as pm3 +import spotpy from scipy import stats as estad from scipy.optimize import minimize as minimizar -from tikon.Matemáticas import Distribuciones as Ds from tikon import __email__ as correo +from tikon.Matemáticas import Distribuciones as Ds # Clases de variables @@ -28,12 +28,13 @@ def __init__(símismo, tipo_dist, paráms, nombre=None): """ if tipo_dist not in símismo.dists_disp(): - raise ValueError('La distribución "{}" no está implementada para el tipo de variable "{}".' - .format(tipo_dist, símismo.__class__.__name__)) + raise ValueError( + 'La distribución "{}" no está implementada para el tipo de variable "{}".' + .format(tipo_dist, símismo.__class__.__name__) + ) símismo.tipo_dist = tipo_dist símismo.paráms = paráms - símismo.nombre = nombre def a_texto(símismo): """ @@ -54,7 +55,7 @@ def de_texto(cls, texto, nombre=None): # Primero, decidimos si tenemos una especificación de distribución por nombre o por rango (y densidad) if '~' in texto: # Si tenemos especificación por nombre... - return cls.de_texto_dist(texto, nombre=nombre) + return cls.de_texto_dist(texto) else: # Si tenemos especificación por rango (y/o densidad): @@ -71,8 +72,7 @@ def de_texto(cls, texto, nombre=None): if prcnt == 100: return cls.de_líms(líms_dens, cont=True, nombre=nombre) else: - return cls.de_densidad(dens=prcnt, líms_dens=líms_dens, líms=líms, cont=True, - nombre=nombre) + return cls.de_densidad(dens=prcnt, líms_dens=líms_dens, líms=líms, cont=True, nombre=nombre) else: líms = tuple(float(x) for x in texto.strip('()').split(',')) @@ -80,7 +80,7 @@ def de_texto(cls, texto, nombre=None): return cls.de_líms(líms, cont=True, nombre=nombre) @classmethod - def ajust_dist(cls, datos, líms, cont, lista_dist=None, nombre=None): + def ajust_dist(cls, datos, líms, cont, lista_dist=None): """ Esta función, tomando las límites teoréticas de una distribución y una serie de datos proveniendo de dicha distribución, escoge la distribución más apropriada y ajusta sus parámetros. @@ -94,13 +94,11 @@ def ajust_dist(cls, datos, líms, cont, lista_dist=None, nombre=None): :param líms: Las límites teoréticas de la distribucion (p. ej., (0, np.inf), (-np.inf, np.inf), etc.) :type líms: tuple - :param nombre: El nombre del variable, si vamos a generar un variable de PyMC - :type nombre: str :param lista_dist: Una lista de los nombres de distribuciones a considerar. dist=None las considerará todas. :type lista_dist: list - :return: Distribución PyMC o de Scipy su ajuste (p) + :return: Distribución PyMC o de Scipy :rtype: VarAlea """ @@ -108,8 +106,7 @@ def ajust_dist(cls, datos, líms, cont, lista_dist=None, nombre=None): if lista_dist is None: lista_dist = cls.dists_disp() - resultado = cls._ajust_dist(datos=datos, líms=líms, cont=cont, nombre=nombre, - lista_dist=lista_dist) + resultado = cls._ajust_dist(datos=datos, líms=líms, cont=cont, lista_dist=lista_dist) return resultado['dist'] @@ -131,9 +128,6 @@ def de_densidad(cls, dens, líms_dens, líms, cont, nombre=None): :param cont: Indica si la distribución es una distribución contínua o discreta. :type cont: bool - :param nombre: El nombre de la distribución (se emplea únicamente para variables PyMC). - :type nombre: str - :return: Una distribución con las características deseadas. :rtype: VarAlea @@ -141,7 +135,7 @@ def de_densidad(cls, dens, líms_dens, líms, cont, nombre=None): raise NotImplementedError @classmethod - def _ajust_dist(cls, datos, líms, cont, lista_dist, nombre=None): + def _ajust_dist(cls, datos, líms, cont, lista_dist): """ :param datos: @@ -161,24 +155,45 @@ def _ajust_dist(cls, datos, líms, cont, lista_dist, nombre=None): @classmethod def de_líms(cls, líms, cont, nombre): - raise NotImplementedError + """ + Esta función toma una "tupla" de límites para un parámetro de una función y devuelve una distribución + Scipy correspondiente. Se usa en la inicialización de las + distribuciones de los parámetros de ecuaciones. + + :param líms: Los límites para los valores posibles del parámetro. Para límites infinitas, usar np.inf y + -np.inf. Ejemplos: (0, np.inf), (-10, 10), (-np.inf, np.inf). + :type líms: tuple + + :param cont: Determina si el variable es continuo o discreto + :type cont: bool + + :param nombre: Nombre para algunos tipos de distribuciones. Inútil para SciPy. + :type nombre: str + + :return: Destribución no informativa conforme a las límites especificadas. + :rtype: str + """ + + tipo_dist, paráms = _líms_a_dist(líms, cont) + + return cls(tipo_dist=tipo_dist, paráms=paráms, nombre=nombre) @classmethod - def de_texto_dist(cls, texto, nombre=None): + def de_texto_dist(cls, texto): # Dividir el nombre de la distribución de sus parámetros. tipo_dist, paráms = texto.split('~') paráms = ast.literal_eval(paráms) - return cls(tipo_dist=tipo_dist, paráms=paráms, nombre=nombre) + return cls(tipo_dist=tipo_dist, paráms=paráms) @classmethod - def de_scipy(cls, dist_scipy, nombre): + def de_scipy(cls, dist_scipy): tipo_dist = NotImplemented paráms = NotImplemented - return cls(nombre=nombre, tipo_dist=tipo_dist, paráms=paráms) + return cls(tipo_dist=tipo_dist, paráms=paráms) @staticmethod def dists_disp(): @@ -192,7 +207,7 @@ def dists_disp(): class VarSciPy(VarAlea): - def __init__(símismo, tipo_dist, paráms): + def __init__(símismo, tipo_dist, paráms, nombre=None): """ :param tipo_dist: @@ -238,7 +253,7 @@ def dibujar(símismo, ejes): n = 10000 puntos = símismo.muestra_alea(n) - y, delim = np.histogram(puntos, normed=True, bins=n // 100) + y, delim = np.histogram(puntos, density=True, bins=n // 100) x = 0.5 * (delim[1:] + delim[:-1]) ejes.plot(x, y, 'b-', lw=2, alpha=0.6) @@ -260,7 +275,7 @@ def de_densidad(cls, dens, líms_dens, líms, cont, nombre=None): # Asegurarse de que el rango cabe en los límites if líms_dens[0] < mín or líms_dens[1] > máx: - raise ValueError('El rango tiene que caber entre los límites teoréticos del variable.') + raise ValueError() # Si no decimos el contrario, no invertiremos la distribución. inv = False @@ -687,149 +702,33 @@ def aprox_dist(cls, datos, líms, cont, lista_dist=None): return resultado - @classmethod - def de_líms(cls, líms, cont, nombre=None): - """ - Esta función toma una "tupla" de límites para un parámetro de una función y devuelve una distribución - Scipy correspondiente. Se usa en la inicialización de las - distribuciones de los parámetros de ecuaciones. - - :param líms: Los límites para los valores posibles del parámetro. Para límites infinitas, usar np.inf y - -np.inf. Ejemplos: (0, np.inf), (-10, 10), (-np.inf, np.inf). - :type líms: tuple - - :param cont: Determina si el variable es continuo o discreto - :type cont: bool - - :param nombre: Nombre para algunos tipos de distribuciones. Inútil para SciPy. - :type nombre: str - - :return: Destribución no informativa conforme a las límites especificadas. - :rtype: str - """ - - tipo_dist, paráms = _líms_a_dist(líms, cont) - - return cls(tipo_dist=tipo_dist, paráms=paráms) - @staticmethod def dists_disp(): return [x for x, d in Ds.dists.items() if d['scipy'] is not None] -class VarCalib(VarAlea): +class VarSpotPy(VarAlea): - def __init__(símismo, nombre, tipo_dist, paráms): + def __init__(símismo, nombre, tipo_dist, paráms, transf=None): """ - :param nombre: - :type nombre: str :param tipo_dist: El tipo de distribución. (P.ej., ``Normal``, ``Uniforme``, etc.) :type tipo_dist: str :param paráms: :type paráms: dict + :param transf: + :type transf: dict[str, str | float | int] """ - símismo.var = NotImplemented # type: pm2.Stochastic | pm3.model.FreeRV - super().__init__(tipo_dist=tipo_dist, nombre=nombre, paráms=paráms) - - def dibujar(símismo, ejes=None): - if ejes is None: - fig, ejes = dib.subplots(1, 2) - - símismo._dibujar(ejes=ejes) - - def _dibujar(símismo, ejes): - raise NotImplementedError - - def traza(símismo): - """ - - :return: - :rtype: np.ndarray - """ - raise NotImplementedError - - @classmethod - def de_densidad(cls, dens, líms_dens, líms, cont, nombre=None): - raise NotImplementedError - - @classmethod - def _ajust_dist(cls, datos, líms, cont, lista_dist, nombre=None): - raise NotImplementedError - - @classmethod - def de_líms(cls, líms, cont, nombre): - raise NotImplementedError - - @staticmethod - def dists_disp(): - raise NotImplementedError - - def __float__(símismo): - """ - - :return: - :rtype: float - """ - raise NotImplementedError - - def __abs__(símismo): - return abs(símismo.__float__()) - - def __sub__(símismo, otro): - return símismo.__float__() - otro - - def __add__(símismo, otro): - return símismo.__float__() + otro - - def __neg__(símismo): - return -1*símismo - - def __pow__(símismo, exp, módulo=None): - return (símismo.__float__() ** exp) % módulo - - def __mul__(símismo, otro): - return símismo.__float__() * otro - - def __truediv__(símismo, otro): - return símismo.__float__() / otro - - def __floordiv__(símismo, otro): - return símismo.__float__() // otro - - def __radd__(símismo, otro): - return símismo + otro - - def __rsub__(símismo, otro): - return otro - símismo.__float__() - - def __rmul__(símismo, otro): - return símismo * otro - - def __rtruediv__(símismo, otro): - return otro / símismo.__float__() - + super().__init__(tipo_dist=tipo_dist, paráms=paráms) -class VarPyMC2(VarCalib): - """ - Esta clase representa variables de PyMC v2. - """ + símismo.traza = np.array([]) - def __init__(símismo, nombre, tipo_dist, paráms, transf=None): - """ + símismo.val = None + símismo.modelo = None - :param nombre: - :type nombre: str - :param tipo_dist: - :type tipo_dist: str - :param paráms: - :type paráms: dict - :param transf: - :type transf: dict[str, str | float | int] - """ - - super().__init__(nombre=nombre, tipo_dist=tipo_dist, paráms=paráms) + nombre = re.sub('\W|^(?=\d)', '_', nombre) + símismo.nombre = nombre # Sacar los límites y también verificar que existe este variable if tipo_dist in Ds.dists: @@ -837,7 +736,7 @@ def __init__(símismo, nombre, tipo_dist, paráms, transf=None): elif tipo_dist in ['NormalExp', 'LogitInv']: líms_dist = (-np.inf, np.inf) else: - raise ValueError('La distribución %s no existe en la base de datos de Tikon para distribuciones PyMC2.' % + raise ValueError('La distribución %s no existe en la base de datos de Tikon para distribuciones SpotPy.' % tipo_dist) # Hacer transformaciones de forma de distribución si necesario @@ -847,119 +746,66 @@ def __init__(símismo, nombre, tipo_dist, paráms, transf=None): líms_dist[0] = -líms_dist[1] líms_dist[1] = np.inf inv = True # Invertimos la distribución - nombre = 'inv_{}'.format(nombre) else: inv = False - # Transformar distribuciones con límites a distribuciones aproximativas con límites. - if líms_dist[0] != -np.inf: - if líms_dist[1] != np.inf: - - # El caso [R, R] se transforma con logit. - if transf is None: - avisar('A PyMC2 no le gustan distribuciones con límites, como "{}". Tomaremos el logit inverso ' - 'de una distribución normal en vez.'.format(tipo_dist)) - - # Normalizar la distribución inicial al rango [0, 1] - d_scipy = VarSciPy(tipo_dist=tipo_dist, paráms=paráms) - norm_suma = - (líms_dist[0] * paráms['escl'] + paráms['ubic']) - norm_mult = 1 / (paráms['escl'] * (líms_dist[1] - líms_dist[0])) - - # Tomar la mitad de la densidad de esta distribución normalizada como el mu de nuestra distribución - # normal - mu = _logit((d_scipy.percentiles(0.5) + norm_suma) * norm_mult) - - # Aproximar sigma según los percentiles de la distribución original que corresponden a 1 desviación - # estándar de la distribución normal. - p16 = d_scipy.percentiles(estad.norm.cdf(-1)) - p84 = d_scipy.percentiles(estad.norm.cdf(1)) - sigma = (-_logit((p16 + norm_suma) * norm_mult) + _logit((p84 + norm_suma) * norm_mult)) / 2 - - # Establecer la distribución Logit Inversa y sus parámetros - tipo_dist = 'Normal' - paráms = {'escl': sigma, 'ubic': mu} - transf = {'tipo': 'LogitInv', 'mult': 1 / norm_mult, 'suma': -norm_suma} - - elif transf['tipo'] != 'LogitInv': - raise ValueError('Debes utilizar una transformación Logit Inversa ("LogitInv") con distribuciones' - 'en el rango [R, R] con PyMC2.') - else: - - # El caso [R, inf) se transforma con log. - if transf is None: - avisar('A PyMC2 no le gustan distribuciones con límite inferior, como "{}". Tomaremos el ' - 'exponencial de una distribución normal en vez.'.format(tipo_dist)) - # Normalizar la distribución inicial para tener 99.9% se su densidad en el rango [0, 1] - d_scipy = VarSciPy(tipo_dist=tipo_dist, paráms=paráms) - norm_suma = - (líms_dist[0] * paráms['escl'] + paráms['ubic']) - norm_mult = 1 / (paráms['escl'] * (d_scipy.percentiles(0.999) - líms_dist[0])) - - # Tomar la mitad de la densidad de esta distribución normalizada como el mu de nuestra distribución - # normal - mu = mat.log((d_scipy.percentiles(0.5) + norm_suma) * norm_mult) - - # Aproximar sigma según los percentiles de la distribución original que corresponden a 1 desviación - # estándar de la distribución normal. - p16 = d_scipy.percentiles(estad.norm.cdf(-1)) - p84 = d_scipy.percentiles(estad.norm.cdf(1)) - sigma = (-mat.log((p16 + norm_suma) * norm_mult) + mat.log((p84 + norm_suma) * norm_mult)) / 2 - - # Establecer la distribución Normal Exponencial y sus parámetros - tipo_dist = 'Normal' - if inv: - # De-invertir la distribución, si necesario. - paráms = {'ubic': mu, 'escl': sigma} - transf = {'tipo': 'Exp', 'mult': -1 / norm_mult, 'suma': norm_suma} - else: - paráms = {'ubic': mu, 'escl': sigma} - transf = {'tipo': 'Exp', 'mult': 1 / norm_mult, 'suma': -norm_suma} - - elif transf['tipo'] != 'Exp': - raise ValueError('Debes utilizar una transformación Exponencial ("Exp") con distribuciones' - 'en el rango [R, inf) o (-inf, R] con PyMC2.') - # Generar la distribución y sus parámetros - if tipo_dist == 'Cauchy': - var = pm2.Cauchy(nombre, alpha=0, beta=1) + if tipo_dist == 'Chi2': + raise NotImplementedError + var = spotpy.parameter.Chisquare(símismo.nombre, dt=paráms['df']) + + elif tipo_dist == 'Exponencial': + var = spotpy.parameter.Exponential(símismo.nombre, scale=1) - elif tipo_dist == 'Laplace': - var = pm2.Laplace(nombre, mu=0, tau=1) + elif tipo_dist == 'Gamma': + raise NotImplementedError + var = spotpy.parameter.Gamma(símismo.nombre, k=paráms['a']) - elif tipo_dist == 'Logística': - var = pm2.Logistic(nombre, mu=0, tau=1) + elif tipo_dist == 'LogNormal': + raise NotImplementedError + var = spotpy.parameter.logNormal(símismo.nombre) elif tipo_dist == 'Normal': - var = pm2.Normal(nombre, mu=0, tau=1) + var = spotpy.parameter.Normal(símismo.nombre, mean=0, stddev=1) - elif tipo_dist == 'T': - var = pm2.T(nombre, nu=paráms['df']) + elif tipo_dist == 'Uniforme': + var = spotpy.parameter.Uniform(símismo.nombre, low=0, high=1) + + elif tipo_dist == 'Weibull': + raise NotImplementedError + var = spotpy.parameter.Weibull(símismo.nombre) else: - raise ValueError('La distribución "{}" existe en la base de datos de Tiko\'n para distribuciones PyMC2,' - 'pero no está configurada en la clase VarPyMC2.'.format(tipo_dist)) + raise ValueError( + 'La distribución "{}" existe en la base de datos de Tiko\'n para distribuciones SpotPy,' + 'pero no está configurada en la clase VarSpotPy.'.format(tipo_dist)) # Hacer transformaciones necesarias símismo.transf = transf if transf is not None and transf['tipo'] not in ['Exp', 'LogitInv']: - raise ValueError('') + raise ValueError(transf['tipo']) símismo.mult = paráms['escl'] símismo.suma = paráms['ubic'] + if inv: + símismo.mult *= -1 símismo.var = var símismo.tipo_dist = tipo_dist - def _dibujar(símismo, ejes): + def dibujar(símismo, ejes=None): + if ejes is None: + fig, ejes = dib.subplots(1, 2) n = 10000 - puntos = np.array([símismo.var.rand() for _ in range(n)]) + puntos = símismo.var(size=n) # Transformaciones necesarias puntos = símismo._transf_vals(puntos) # Crear el histograma - y, delim = np.histogram(puntos, normed=True, bins=n // 100) + y, delim = np.histogram(puntos, density=True, bins=n // 100) x = 0.5 * (delim[1:] + delim[:-1]) # Dibujar el histograma @@ -967,106 +813,39 @@ def _dibujar(símismo, ejes): ejes[0].set_title('Distribución') # Dibujar la traza sí misma - ejes[1].plot(símismo.traza()) + ejes[1].plot(símismo.traza) ejes[1].set_title('Traza') - def traza(símismo): - """ - Devuelve la traza del variable. Si no hay traza, devuelve un matriz vacía. - - :return: La traza del variable. - :rtype: np.ndarray - """ - - # Devolver la traza si existe. - try: - # Intentar obtener la traza. - trz = símismo.var.trace(chain=None)[:] - - # Devolver la traza con las transformaciones necesaria. - return símismo._transf_vals(trz) - - except (AttributeError, TypeError): - # Si hubo error, devolver una matriz vacía. - return np.array([]) - - def _transf_vals(símismo, vals): - - vals_transl = np.add(np.multiply(vals, símismo.mult), símismo.suma) - - if símismo.transf is None: - return vals_transl - else: - mult = símismo.transf['mult'] - suma = símismo.transf['suma'] - tipo = símismo.transf['tipo'] - if tipo == 'Exp': - vals_transf = np.exp(vals_transl) - elif tipo == 'LogitInv': - vals_transf = _inv_logit(vals_transl) - else: - raise ValueError('') - - vals_transf = np.multiply(vals_transf, mult) - vals_transf = np.add(vals_transf, suma) - - return vals_transf - @classmethod def de_densidad(cls, dens, líms_dens, líms, cont, nombre=None): - """ - Devuelve un objeto de variable PyMC2 a base de información de distribución de densidad y de límites teoréticos. - - :param dens: La fracción (en ``[0, 1]``) de densidad que caye adentro de ``líms_prcnt``. - :type dens: float | int - - :param líms_dens: Los límites adentro de cuales ``frac`` densidad cae. - :type líms_dens: np.ndarray | list | tuple - - :param líms: Los límites teoréticos del variable. - :type líms: np.ndarray | list | tuple - - :param cont: Si es una distribución continua o no. - :type cont: bool - - :param nombre: El nombre del variable. - :type nombre: str - - :return: El variable PyMC2. - :rtype: VarPyMC2 - - """ - # Convertir None a infinidad en los límites de densidad y teoréticos. mín = líms[0] if líms[0] is not None else -np.inf máx = líms[1] if líms[1] is not None else np.inf - rango = np.array([líms_dens[0] if líms_dens[0] is not None else -np.inf, - líms_dens[1] if líms_dens[1] is not None else np.inf]) # Los límites de densidad - - # Validar los rangos y límites - if rango[0] < mín or rango[1] > máx: - raise ValueError('Los límites de densidad ({}, {}) están afuera del rango teorético ({}, {}).' - .format(rango[0], rango[1], mín, máx)) - - # Inicializar el diccionario de parámetros. - paráms = {'escl': 1, 'ubic': 0} + if líms_dens[0] < mín or líms_dens[1] > máx: + raise ValueError( + 'Los límites de densidad ({}, {}) están afuera del rango teorético ({}, {}).' + .format(*líms_dens, mín, máx) + ) # Primero, arreglar unos casos especiales que nos podrían causar problemas después... # Si tenemos una densidad de 100% en el rango especificado... if dens == 1: - # Generar la distribución con este rango en vez. - return cls.de_líms(líms=rango, cont=cont, nombre=nombre) + # Generar una distribución uniforme en este rango. + return cls(nombre, 'Uniforme', paráms={'ubic': líms_dens[0], 'escl': líms_dens[1] - líms_dens[0]}) # No se puede tener límites de densidad iguales con densidad < 1, por supuesto. if líms_dens[0] == líms_dens[1]: raise ValueError('No se puede tener una densidad < 1 en un rango [a, b] si a = b.') # Si los rangos de la densidad corresponden con los rangos teoréticos, pero con densidad < 1... - if rango[0] == mín and rango[1] == máx: + if líms_dens[0] == mín and líms_dens[1] == máx: raise ValueError('No se puede tener una densidad < 1 en un rango igual al rango teorético.') + # Inicializar el diccionario de parámetros. + paráms = {'escl': 1, 'ubic': 0} + # Invertir distribuciones entre (-inf, R] if mín == -np.inf and máx != np.inf: mín = -máx @@ -1075,46 +854,37 @@ def de_densidad(cls, dens, líms_dens, líms, cont, nombre=None): # Ahora, crear la distribución apriopiada. if mín == -np.inf: - if máx == np.inf: - # El caso (-inf, inf). Muy facil. - - # Calcular los parámetros de una distribución normal. - mu = np.mean(rango) # El promedio del rango de densidad - # Calcular sigma analíticamente - sigma = ((rango[1] - rango[0]) / 2) / estad.norm.ppf((1 - dens) / 2 + dens) + # Ya convertimos distribuciones en (-inf, R] a [-R, inf), así que no es posible tener máx != inf. - # Especificar la distribución. - tipo_dist = 'Normal' - paráms = {'ubic': mu, 'escl': sigma} - transf = None + # El caso (-inf, inf). Muy facil. + mu = np.mean(líms_dens) + sigma = mu / estad.norm.ppf((1 - dens) / 2 + dens) - else: - # Ya convertimos distribuciones en (-inf, R] a [-R, inf), así que no debería ser posible llegar - # hasta este error. - raise ValueError('No debería ser posible llegar hasta este error.') + tipo_dist = 'Normal' + paráms = {'ubic': mu, 'escl': sigma} + transf = None else: # Primero, normalizar el límite inferior. paráms['ubic'] += mín - rango = np.subtract(rango, mín) + líms_dens = np.subtract(líms_dens, mín) máx -= mín if máx == np.inf: # El caso [R, inf) - - if rango[0] == 0: + if líms_dens[0] == 0: # Si el límite inferior del rango de densidad es igual al límite teorético, solamente tenemos # que asegurarnos que ``dens`` densidad quede abajo del límite inferior transformado. - lím_norm_sup = np.log(rango[1]) # El límite superior de densidad en la distribución normal + lím_norm_sup = np.log(líms_dens[1]) # El límite superior de densidad en la distribución normal sigma = 1 # Tomar un sigma de 1, por simplicidad. De verdad no importa mucho. mu = lím_norm_sup - estad.norm(0, 1).ppf(dens) # Mu en función de sigma y la densidad else: # Sino, tenemos que asegurarnos que la densidad caiga entre los dos límites transformados. - log_rango = np.log(rango) + log_rango = np.log(líms_dens) mu = np.mean(log_rango) # Mu es el promedio entre ambos límites de densidad @@ -1125,18 +895,14 @@ def de_densidad(cls, dens, líms_dens, líms, cont, nombre=None): tipo_dist = 'Normal' # Pasar escala y ubicación a la transformación... - transf = {'tipo': 'Exp', 'mult': paráms['escl'], 'suma': paráms['ubic']} - - # ... Y guardar mu y sigma como la ubicación y la escala de la distribución normal - paráms['ubic'] = mu - paráms['escl'] = sigma + transf = {'tipo': 'Exp', 'mult': sigma, 'suma': mu} else: # El caso [R, R] # Normalizar la distribución paráms['escl'] *= máx - rango = np.divide(rango, máx) + rango = np.divide(líms_dens, máx) if rango[0] == 0: # Si el límite inferior del rango de densidad es igual al límite teorético, solamente tenemos @@ -1144,7 +910,7 @@ def de_densidad(cls, dens, líms_dens, líms, cont, nombre=None): lím_norm_sup = _logit(rango[1]) sigma = 1 # Tomar un sigma de 1, por simplicidad. De verdad no importa mucho. - mu = lím_norm_sup - estad.norm(0, 1).ppf(dens) # Mu en función de sigma y la densidad + mu = lím_norm_sup - estad.norm(0, sigma).ppf(dens) # Mu en función de sigma y la densidad elif rango[1] == 1: # Si el límite superior del rango de densidad es igual al límite teorético, solamente tenemos @@ -1167,33 +933,29 @@ def de_densidad(cls, dens, líms_dens, líms, cont, nombre=None): tipo_dist = 'Normal' # Pasar escala y ubicación a la transformación... - transf = {'tipo': 'LogitInv', 'suma': paráms['ubic'], 'mult': paráms['escl']} - - # ... Y guardar mu y sigma como la ubicación y la escala de la distribución normal - paráms['ubic'] = mu - paráms['escl'] = sigma + transf = {'tipo': 'LogitInv', 'suma': mu, 'mult': sigma} return cls(nombre=nombre, tipo_dist=tipo_dist, paráms=paráms, transf=transf) + def _transf_vals(símismo, vals): + + if símismo.transf is None: + return vals * símismo.mult + símismo.suma + else: + mult = símismo.transf['mult'] + suma = símismo.transf['suma'] + tipo = símismo.transf['tipo'] + if tipo == 'Exp': + vals_transf = np.exp(vals * mult + suma) + elif tipo == 'LogitInv': + vals_transf = _inv_logit(vals * mult + suma) + else: + raise ValueError(tipo) + + return vals_transf * símismo.mult + símismo.suma + @classmethod def _ajust_dist(cls, datos, líms, cont, lista_dist, nombre=None): - """ - - :param datos: - :type datos: - :param líms: - :type líms: - :param cont: - :type cont: - :param lista_dist: La lsita de distribuciones posibles. Si no se especifica, se tomará la lista de - distribuciones disponibles para este tipo de variable. El uso de límites (-inf, +inf) en las llamadas a - :func:`VarSciPy.aprox_dist` aseguran que éste únicamente tome distribuciones sin límites. - :type lista_dist: list[str] - :param nombre: - :type nombre: - :return: - :rtype: - """ mín = líms[0] if líms[0] is not None else -np.inf máx = líms[1] if líms[1] is not None else np.inf @@ -1254,222 +1016,62 @@ def _ajust_dist(cls, datos, líms, cont, lista_dist, nombre=None): return {'dist': cls(nombre=nombre, tipo_dist=tipo_dist, paráms=paráms, transf=transf), 'p': ajustado['p']} - @classmethod - def de_líms(cls, líms, cont, nombre): - - tipo_dist, paráms = _líms_a_dist(líms=líms, cont=cont) - - return cls(nombre=nombre, tipo_dist=tipo_dist, paráms=paráms) - @staticmethod def dists_disp(): - return ['Beta', 'Cauchy', 'Chi2', 'Exponencial', 'WeibullExponencial', 'Gamma', 'MitadCauchy', 'MitadNormal', - 'GammaInversa', 'Laplace', 'Logística', 'LogNormal', 'Normal', 'Pareto', 'T', - 'NormalTrunc', 'Uniforme', 'VonMises', 'Weibull', 'Bernoulli', 'Binomial', 'Geométrica', - 'Hypergeométrica', 'BinomialNegativo', 'Poisson', 'UnifDiscr', - 'NormalExp', 'LogitInv' # Funciones auxiliares para transformaciones - ] - - def __float__(símismo): - - return símismo._transf_vals(float(símismo.var.value)) - - -class VarPyMC3(VarCalib): - """ - Esta clase representa variables de PyMC v3. - """ - - def __init__(símismo, nombre, tipo_dist, paráms): - super().__init__(nombre=nombre, tipo_dist=tipo_dist, paráms=paráms) - - if pm3 is None: - raise ImportError( - 'PyMC 3 (pymc3) no está instalado en esta máquina.\nDeberías de instalarlo un día. De verdad que' - 'es muy chévere.') - - símismo.traza_modelo = None - - transform_pymc = {'mult': 1, 'sum': 0} - - if tipo_dist == 'Beta': - dist = pm3.Beta(nombre=nombre, alpha=paráms['a'], beta=paráms['b']) - a_priori = pm3.Beta.dist(alpha=paráms['a'], beta=paráms['b']) - transform_pymc['mult'] = paráms['scale'] - transform_pymc['sum'] = paráms['loc'] - - elif tipo_dist == 'Cauchy': - dist = pm3.Cauchy(nombre=nombre, alpha=paráms['a'], beta=paráms['scale']) - a_priori = pm3.Cauchy.dist(alpha=paráms['a'], beta=paráms['scale']) - - elif tipo_dist == 'Chi2': - dist = pm3.ChiSquared(nombre=nombre, nu=paráms['df']) - a_priori = pm3.ChiSquared.dist(nu=paráms['df']) - transform_pymc['mult'] = paráms['scale'] - transform_pymc['sum'] = paráms['loc'] - - elif tipo_dist == 'Exponencial': - dist = pm3.Exponential(nombre=nombre, lam=1 / paráms['scale']) - a_priori = pm3.Exponential.dist(lam=1 / paráms['scale']) - transform_pymc['sum'] = paráms['loc'] - - elif tipo_dist == 'Gamma': - dist = pm3.Gamma(nombre=nombre, alpha=paráms['alpha'], beta=1 / paráms['scale']) - a_priori = pm3.Gamma.dist(alpha=paráms['alpha'], beta=1 / paráms['scale']) - transform_pymc['sum'] = paráms['loc'] - - elif tipo_dist == 'MitadCauchy': - dist = pm3.HalfCauchy(nombre=nombre, beta=paráms['scale']) - a_priori = pm3.HalfCauchy.dist(beta=paráms['scale']) - transform_pymc['sum'] = paráms['loc'] - - elif tipo_dist == 'MitadNormal': - dist = pm3.HalfNormal(nombre=nombre, sd=paráms['scale']) - a_priori = pm3.HalfNormal.dist(sd=paráms['scale']) - transform_pymc['sum'] = paráms['loc'] + return [ + 'Chi2', 'Exponencial', 'Gamma', 'LogNormal', 'Normal', 'Uniforme', 'Weibull', + 'NormalExp', 'LogitInv' # Funciones auxiliares para transformaciones + ] - elif tipo_dist == 'GammaInversa': - dist = pm3.InverseGamma(nombre=nombre, alpha=paráms['a'], beta=paráms['scale']) - a_priori = pm3.InverseGamma.dist(alpha=paráms['a'], beta=paráms['scale']) - transform_pymc['sum'] = paráms['loc'] + def poner_val(símismo, val): + símismo.val = val - elif tipo_dist == 'Laplace': - dist = pm3.Laplace(nombre=nombre, mu=paráms['loc'], b=paráms['scale']) - a_priori = pm3.Laplace.dist(mu=paráms['loc'], b=paráms['scale']) - - elif tipo_dist == 'Logística': - dist = pm3.Logistic(nombre=nombre, mu=paráms['loc'], s=paráms['scale']) - a_priori = pm3.Logistic.dist(mu=paráms['loc'], s=paráms['scale']) - - elif tipo_dist == 'LogNormal': - dist = pm3.Lognormal(nombre=nombre, mu=paráms['loc'], sd=paráms['scale']) # para hacer: verificar - a_priori = pm3.Lognormal.dist(mu=paráms['loc'], sd=paráms['scale']) # para hacer: verificar - - elif tipo_dist == 'Normal': - dist = pm3.Normal(nombre=nombre, mu=paráms['loc'], sd=paráms['scale']) - a_priori = pm3.Normal.dist(mu=paráms['loc'], sd=paráms['scale']) - - elif tipo_dist == 'Pareto': - dist = pm3.Pareto(nombre=nombre, alpha=paráms['b'], m=paráms['scale']) # para hacer: verificar - a_priori = pm3.Pareto.dist(alpha=paráms['b'], m=paráms['scale']) # para hacer: verificar - - elif tipo_dist == 'T': - dist = pm3.StudentT(nombre=nombre, nu=paráms['df'], mu=paráms['loc'], - sd=paráms['scale']) # para hacer: verificar - a_priori = pm3.StudentT.dist(nu=paráms['df'], mu=paráms['loc'], sd=paráms['scale']) # para hacer: verificar - - elif tipo_dist == 'NormalTrunc': - mín, máx = min(paráms[0], paráms[1]), max(paráms[0], paráms[1]) # SciPy, aparamente, los puede inversar - mín_abs, máx_abs = mín * paráms['scale'] + paráms['mu'], máx * paráms['scale'] + paráms['mu'] - NormalTrunc = pm3.Bound(pm3.Normal, lower=mín_abs, upper=máx_abs) - dist = NormalTrunc(nombre=nombre, mu=paráms['loc'], sd=paráms['scale']) - a_priori = NormalTrunc.dist(mu=paráms['loc'], sd=paráms['scale']) - - elif tipo_dist == 'Uniforme': - dist = pm3.Uniform(nombre=nombre, lower=paráms['loc'], upper=paráms['loc'] + paráms['scale']) - a_priori = pm3.Uniform.dist(lower=paráms['loc'], upper=paráms['loc'] + paráms['scale']) - - elif tipo_dist == 'VonMises': - dist = pm3.VonMises(nombre=nombre, mu=paráms['loc'], kappa=paráms['kappa']) - a_priori = pm3.VonMises.dist(mu=paráms['loc'], kappa=paráms['kappa']) - transform_pymc['mult'] = paráms['scale'] - - elif tipo_dist == 'Weibull': - raise NotImplementedError # Para hacer: implementar la distrubución Weibull (minweibull en SciPy) - dist = pm3.Weibull() - a_priori = pm3.Weibull.dist() - - elif tipo_dist == 'Bernoulli': - dist = pm3.Bernoulli(nombre=nombre, p=paráms['p']) - a_priori = pm3.Bernoulli.dist(p=paráms['p']) - transform_pymc['sum'] = paráms['loc'] - - elif tipo_dist == 'Binomial': - dist = pm3.Binomial(nombre=nombre, n=paráms['n'], p=paráms['p']) - a_priori = pm3.Binomial.dist(n=paráms['n'], p=paráms['p']) - transform_pymc['sum'] = paráms['loc'] - - elif tipo_dist == 'Geométrica': - dist = pm3.Geometric(nombre=nombre, p=paráms['p']) - a_priori = pm3.Geometric.dist(p=paráms['p']) - transform_pymc['sum'] = paráms['loc'] - - elif tipo_dist == 'BinomialNegativo': - n = paráms['n'] - p = paráms['p'] - dist = pm3.NegativeBinomial(nombre=nombre, mu=n(1 - p) / p, alpha=n) - a_priori = pm3.NegativeBinomial.dist(mu=n(1 - p) / p, alpha=n) - avisar('Tenemos que verificar esta distribución') # para hacer: verificar - transform_pymc['sum'] = paráms['loc'] - - elif tipo_dist == 'Poisson': - dist = pm3.Poisson(nombre=nombre, mu=paráms['mu']) - a_priori = pm3.Poisson.dist(mu=paráms['mu']) - transform_pymc['sum'] = paráms['loc'] - - elif tipo_dist == 'UnifDiscr': - dist = pm3.DiscreteUniform(nombre=nombre, lower=paráms['low'], upper=paráms['high']) - a_priori = pm3.DiscreteUniform.dist(lower=paráms['low'], upper=paráms['high']) - transform_pymc['sum'] = paráms['loc'] + def __float__(símismo): + """ - else: - raise ValueError( - 'La distribución %s no existe en la base de datos de Tiko\'n para distribuciones de PyMC 3.' % - tipo_dist) - - # Hacer modificaciones, si necesario. - if transform['mult'] != 1: - a_priori = None - if transform['sum'] == 0: - dist = pm3.Deterministic('{}_m'.format(nombre), dist * transform['mult']) - else: - dist = pm3.Deterministic('{}_m_s'.format(nombre), dist * transform['mult'] + transform['sum']) - elif transform['sum'] != 0: - dist = pm3.Deterministic('{}_s'.format(nombre), dist + transform['sum']) + :return: + :rtype: float + """ + return símismo._transf_vals(símismo.val) - # Guardar el variable - símismo.var = dist + def __abs__(símismo): + return abs(símismo.__float__()) - # Guardar la distribución a priori (para gráficos). - símismo.a_priori = a_priori + def __sub__(símismo, otro): + return símismo.__float__() - otro - def _dibujar(símismo, ejes): - trz = símismo.traza_modelo - if trz is None: - raise ValueError('Todavía no se ha hecho una calibración con este variable.') + def __add__(símismo, otro): + return símismo.__float__() + otro - pm3.traceplot(trace=trz, varnames=símismo.nombre, priors=[símismo.a_priori], ax=ejes) + def __neg__(símismo): + return -1 * símismo - def traza(símismo): + def __pow__(símismo, exp, módulo=None): + return (símismo.__float__() ** exp) % módulo - trz = símismo.traza_modelo + def __mul__(símismo, otro): + return símismo.__float__() * otro - if trz is None: - return [] - else: - return trz.get_values(símismo.var) + def __truediv__(símismo, otro): + return símismo.__float__() / otro - @classmethod - def de_densidad(cls, dens, líms_dens, líms, cont, nombre=None): - raise NotImplementedError + def __floordiv__(símismo, otro): + return símismo.__float__() // otro - @classmethod - def _ajust_dist(cls, datos, líms, cont, lista_dist, nombre=None): - raise NotImplementedError + def __radd__(símismo, otro): + return símismo + otro - @classmethod - def de_líms(cls, líms, cont, nombre): - raise NotImplementedError + def __rsub__(símismo, otro): + return otro - símismo.__float__() - @staticmethod - def dists_disp(): + def __rmul__(símismo, otro): + return símismo * otro - return ['Beta', 'Cauchy', 'Chi2', 'Exponencial', 'Gamma', 'MitadCauchy', 'MitadNormal', 'GammaInversa', - 'Laplace', 'Logística', 'LogNormal', 'Normal', 'Pareto', 'T', 'NormalTrunc', 'Uniforme', 'VonMises', - 'Weibull', 'Bernoulli', 'Binomial', 'Geométrica', 'BinomialNegativo', 'Poisson', 'UnifDiscr'] + def __rtruediv__(símismo, otro): + return otro / símismo.__float__() - def __float__(símismo): - raise NotImplementedError('') + def __str__(self): + return self.nombre # Funciones auxiliares diff --git a/tikon/Paisaje/Geog.py b/tikon/Paisaje/Geog.py index 8cfa5c8e..86b4d33e 100644 --- a/tikon/Paisaje/Geog.py +++ b/tikon/Paisaje/Geog.py @@ -1,7 +1,7 @@ import datetime as ft import pandas as pd -from taqdir.مقام import مقام -from taqdir.ذرائع.مشاہدات import دن_مشا, مہنہ_مشا, سال_مشا +from تقدیر.مقام import مقام +from تقدیر.ذرائع.مشاہدات import دن_مشا, مہنہ_مشا, سال_مشا # Ofrecemos la oportunidad de utilizar تقدیر, taqdir, en español diff --git a/tikon/Proyectos/Artificial/Artificial.py b/tikon/Proyectos/Artificial/Artificial.py index 371f5f32..9834a3f7 100644 --- a/tikon/Proyectos/Artificial/Artificial.py +++ b/tikon/Proyectos/Artificial/Artificial.py @@ -1,4 +1,5 @@ import csv +from pprint import pprint import numpy as np @@ -10,7 +11,7 @@ Genera datos artificiales y después intenta calibrar para re-descubrir los mismos parámetros conocidos. """ -dib = False +dib = True dib_aprioris = dib dib_valid_perf = dib dib_simul = dib @@ -19,20 +20,33 @@ dib_calibs = dib proyecto = 'Artificial' -nombre = 'bprueba 20-2' -adaptivo = True -if adaptivo: - método = 'Metrópolis Adaptivo' -else: - método = 'Metrópolis' +nombre = 'Pruebita algs 2' +métodos = [ + 'mle', + 'rope', + # 'sceua', + 'mc', + 'mcmc', + 'lhs', + 'sa', + 'abc', + 'fscabc', + 'dream', + 'fast' +] +método = '' quema = 0 -n_iter = 30 +n_iter = 300 +n_rep_parám = 30 +n_rep_estoc = 30 extr = 1 -pedazitos = 10 -nombre = '{} {} i{} q{}{}'.format('MA' if adaptivo else 'M', nombre, - '{}k'.format(n_iter / 1000) if n_iter >= 1000 else n_iter, - '{}k'.format(quema / 1000) if quema >= 1000 else quema, - ' pd{}'.format(pedazitos) if pedazitos else '') +pedazitos = 1 +nombre = '{} {} i{} q{}{}'.format( + método, nombre, + '{}k'.format(n_iter / 1000) if n_iter >= 1000 else n_iter, + '{}k'.format(quema / 1000) if quema >= 1000 else quema, + ' pd{}'.format(pedazitos) if pedazitos else '' +) depurar = False print(nombre) @@ -211,70 +225,65 @@ def _agregar_exp(red, exper): # Aplicar a prioris restringidos basados en los valores aplicados para la simulación _aplicar_a_prioris(red=Red_coco, d_a_pr=a_pr_verd) -# Para borrar # para hacer: borrar -p = 90 -print('\tCalibrando con p={}...'.format(p)) -a_pr = _gen_a_prioris(vals=vals_paráms, prec=p) -_aplicar_a_prioris(red=Red_coco, d_a_pr=a_pr) -_agregar_exp(red=Red_coco, exper=Exper_artificial) -Red_coco.calibrar(nombre='{}, Clb prec. {}'.format(nombre, p), exper=Exper_artificial, - n_rep_estoc=20, quema=quema, n_iter=n_iter, extraer=extr, método=método, dibujar=dib_calibs, - depurar=depurar, pedazitos=pedazitos) -Red_coco.guardar_calib(descrip='Calib con datos artificiales, precisión de {}'.format(p), - utilizador='Julien Malard', contacto='julien.malard@mail.mcgill.ca') -arch = 'C:\\Users\jmalar1\PycharmProjects\Tikon\\tikon\Proyectos\\Artificial\\{}'.format( - '{}, Clb prec. {}'.format(nombre, p)) -import os, shutil - -dir_base = os.path.split(arch)[0] -dir_imgs = os.path.join(dir_base, 'imgs_trazas ' + nombre) -from pymc.database.sqlite import load -import matplotlib.pyplot as plt - -bd = load(arch) -if os.path.isdir(dir_imgs): - shutil.rmtree(dir_imgs) -os.mkdir(dir_imgs) - -for v in bd.trace_names[0]: - trz = bd.trace(v, chain=None)[:] - plt.plot(trz) - plt.title(v) - plt.savefig(os.path.join(dir_imgs, v + '.png')) - plt.clf() - -raise SystemExit(0) - -# Fin borrar # para hacer - # Validar con estos valores -print('Validación inicial...') +# print('Validación inicial...') _agregar_exp(red=Red_coco, exper=Exper_artificial) valid_perfecta = Red_coco.validar(nombre='Valid con verdaderos'.format(nombre), exper=Exper_artificial, usar_especificadas=True, detalles=False, dibujar=dib_valid_perf, dib_dists=dib_dists, - n_rep_parám=30, n_rep_estoc=30, depurar=depurar) -print('Validación Perfecta\n********************') + n_rep_parám=n_rep_parám, n_rep_estoc=n_rep_estoc, depurar=depurar) pprint(valid_perfecta) +print('Validación Perfecta\n********************') + +a_pr = _gen_a_prioris(vals=vals_paráms, prec=0) +_aplicar_a_prioris(red=Red_coco, d_a_pr=a_pr) +for m in métodos: + print('Calibrando con {}.\n********************'.format(m)) + print('\tValidando antes de calib...') + vld = Red_coco.validar(nombre='Vld antes clb {}'.format(m), exper=Exper_artificial, + usar_especificadas=True, detalles=False, guardar=True, + dibujar=dib_valid, dib_dists=dib_dists, n_rep_parám=n_rep_parám, n_rep_estoc=n_rep_estoc, + depurar=depurar) + pprint(vld) + print('\tCalibrando con {}...'.format(m)) + Red_coco.calibrar(nombre='{}, Clb {}'.format(nombre, m), exper=Exper_artificial, + n_rep_estoc=n_rep_estoc, quema=quema, n_iter=n_iter, extraer=extr, método=m, + dibujar=dib_calibs, + depurar=depurar, pedazitos=pedazitos) + Red_coco.guardar_calib(descrip='Calib con datos artificiales, {}'.format(m), + utilizador='Julien Malard', contacto='julien.malard@mail.mcgill.ca') + print('Validando con {}...'.format(m)) + valid = Red_coco.validar(nombre='Vld con clb {}'.format(m), exper=Exper_artificial, + usar_especificadas=False, detalles=False, guardar=True, + dibujar=dib_valid, dib_dists=dib_dists, n_rep_parám=n_rep_parám, n_rep_estoc=n_rep_estoc, + depurar=depurar) + + print('Resultados de validación después de calib con {}:\n============='.format(m)) + pprint(valid) +SystemExit(0) # Intentar calibrar, y validar, con rangos de menos en menos restringidos -for p in range(90, -10, -10): +for p in range(0, 100, 10): print('Calibrando con p={}.\n********************'.format(p)) a_pr = _gen_a_prioris(vals=vals_paráms, prec=p) _aplicar_a_prioris(red=Red_coco, d_a_pr=a_pr) print('\tValidando antes de calib...') - Red_coco.validar(nombre='Vld antes clb prec {}'.format(p), exper=Exper_artificial, - usar_especificadas=True, detalles=False, guardar=True, - dibujar=dib_valid, dib_dists=dib_dists, n_rep_parám=10, n_rep_estoc=10, depurar=depurar) + vld = Red_coco.validar(nombre='Vld antes clb prec {}'.format(p), exper=Exper_artificial, + usar_especificadas=True, detalles=False, guardar=True, + dibujar=dib_valid, dib_dists=dib_dists, n_rep_parám=n_rep_parám, n_rep_estoc=n_rep_estoc, + depurar=depurar) + pprint(vld) print('\tCalibrando con p={}...'.format(p)) Red_coco.calibrar(nombre='{}, Clb prec. {}'.format(nombre, p), exper=Exper_artificial, - n_rep_estoc=20, quema=quema, n_iter=n_iter, extraer=extr, método=método, dibujar=dib_calibs, + n_rep_estoc=n_rep_estoc, quema=quema, n_iter=n_iter, extraer=extr, método=método, + dibujar=dib_calibs, depurar=depurar, pedazitos=pedazitos) Red_coco.guardar_calib(descrip='Calib con datos artificiales, precisión de {}'.format(p), utilizador='Julien Malard', contacto='julien.malard@mail.mcgill.ca') print('Validando con p={}...'.format(p)) valid = Red_coco.validar(nombre='Vld con clb prec {}'.format(p), exper=Exper_artificial, usar_especificadas=False, detalles=False, guardar=True, - dibujar=dib_valid, dib_dists=dib_dists, n_rep_parám=10, n_rep_estoc=10, depurar=depurar) + dibujar=dib_valid, dib_dists=dib_dists, n_rep_parám=n_rep_parám, n_rep_estoc=n_rep_estoc, + depurar=depurar) print('Resultados de validación después de calib con precisión de {}%:\n============='.format(p)) pprint(valid) diff --git a/tikon/Proyectos/Opisina_arenosella/O. arenosella_Sri Lanka.py b/tikon/Proyectos/Opisina_arenosella/O. arenosella_Sri Lanka.py index 58e5b99c..1c81504f 100644 --- a/tikon/Proyectos/Opisina_arenosella/O. arenosella_Sri Lanka.py +++ b/tikon/Proyectos/Opisina_arenosella/O. arenosella_Sri Lanka.py @@ -1,10 +1,10 @@ from pprint import pprint -from tikon.RAE.Planta import Hojas -from tikon.RAE.RedAE import Red import tikon.RAE.Insecto as Ins from tikon.Matemáticas.Experimentos import Experimento from tikon.Proyectos.Opisina_arenosella.a_prioris import a_prioris +from tikon.RAE.Planta import Hojas +from tikon.RAE.RedAE import Red # Opciones artísticas dibujar = True @@ -13,11 +13,13 @@ # Empezamos las cosas serias ahora proyecto = 'Opisina_arenosella' -método = 'Metrópolis adaptivo' -n_iter = 10000 +método = 'mle' +n_iter = 100 quema = 0 extraer = 1 -pedazitos = 5 +pedazitos = 1 +n_rep_estoc = 30 +n_rep_parám = 30 O_arenosella_senc = Ins.Sencillo(nombre='O. arenosella_senc', proyecto=proyecto) Parasitoide_senc = Ins.Sencillo(nombre='Parasitoide_senc', proyecto=proyecto) @@ -27,74 +29,110 @@ Coco = Hojas(nombre='Palma de coco', proyecto=proyecto) # Unidades: mm2 / ha Coco.estimar_densidad(rango=(38, 42), certidumbre=0.95) -O_arenosella_senc.secome(Coco) -Parasitoide_senc.secome(O_arenosella_senc) - -Red_coco_senc = Red('Campos coco sencillo', organismos=[Coco, O_arenosella_senc, Parasitoide_senc], - proyecto=proyecto) -Red_coco_senc.guardar() - +# O_arenosella_senc.secome(Coco) +# Parasitoide_senc.secome(O_arenosella_senc) +# +# Red_coco_senc = Red('Campos coco sencillo', organismos=[Coco, O_arenosella_senc, Parasitoide_senc], +# proyecto=proyecto) +# Red_coco_senc.guardar() +# Experimento_A = Experimento(nombre='Sitio A', proyecto=proyecto) Experimento_A.agregar_pobs(archivo='Oarenosella_A.csv', col_tiempo='Día', factor=655757.1429 / 500) Experimento_B = Experimento(nombre='Sitio B', proyecto=proyecto) Experimento_B.agregar_pobs(archivo='Oarenosella_B.csv', col_tiempo='Día', factor=655757.1429 / 500) - -Red_coco_senc.añadir_exp(Experimento_A, - corresp={'O. arenosella_senc': {'adulto': ['Larva', 'Pupa']}, - 'Parasitoide_senc': {'adulto': ['Para_larva_abs', 'Para_pupa_abs']} - } - ) - -Red_coco_senc.añadir_exp(Experimento_B, - corresp={'O. arenosella_senc': {'adulto': ['Estado 1', 'Estado 2', 'Estado 3', 'Estado 4', - 'Estado 5', 'Pupa']} - } - ) - -# Intentar calibrar -ajuste_inic = Red_coco_senc.validar(nombre='senc Sitio A, Antes de calibrar', exper=Experimento_A, dibujar=dibujar, - dib_dists=dibujar) -print('Ajuste inicial: ', ajuste_inic) -Red_coco_senc.calibrar(nombre='Sin a priori', exper=Experimento_A, n_iter=n_iter, quema=quema, extraer=extraer, - dibujar=dibujar, método=método, pedazitos=pedazitos) -Red_coco_senc.validar(nombre='senc Sitio A, con calibración', exper=Experimento_A, dibujar=dibujar, - dib_dists=dibujar) -Red_coco_senc.validar(nombre='senc Sitio B, con calibración', exper=Experimento_B, dibujar=dibujar, - dib_dists=dibujar) -Red_coco_senc.guardar_calib(descrip='Calibración de red sencilla (oruga y parasitoide) para O. arenosella en coco, ' - 'sin usar a prioris. Se aplicó el sitio A de Perera et al. para la calibración.', - utilizador='Julien Malard', - contacto='julien.malard@mail.mcgill.ca') -Red_coco_senc.guardar() - -# Especificar distribuciones a priori -for a_priori in a_prioris[O_arenosella_senc.nombre]: - O_arenosella_senc.especificar_apriori(dibujar=dibujar, **a_priori) - -for a_priori in a_prioris[Parasitoide_senc.nombre]: - Parasitoide_senc.especificar_apriori(dibujar=dibujar, **a_priori) - -# Verificar el modelo ahora -ajuste_con_aprioris = Red_coco_senc.validar(exper=Experimento_A, nombre='senc Sitio A, ajust con aprioris') -print('Ajuste con a priosis: ', ajuste_con_aprioris) - -# Intentar calibrar de nuevo -Red_coco_senc.validar(nombre='senc Sitio A, con a prioris', exper=Experimento_A, opciones_dib=ops_dib, dibujar=dibujar, - dib_dists=dibujar) -Red_coco_senc.calibrar('senc Con aprioris', exper=Experimento_A, n_iter=n_iter, quema=quema, extraer=extraer, - dibujar=dibujar, método=método, pedazitos=pedazitos) -Red_coco_senc.validar(nombre='senc Sitio A, con calib a prioris', exper=Experimento_A, opciones_dib=ops_dib, - dibujar=dibujar, dib_dists=dibujar) -Red_coco_senc.validar(nombre='senc Sitio B, con calib a prioris', exper=Experimento_B, opciones_dib=ops_dib, - dibujar=dibujar, dib_dists=dibujar) -Red_coco_senc.guardar_calib(descrip='Calibración de red sencilla (oruga y parasitoide) para O. arenosella en coco, ' - 'empleando a prioris.' - 'Se aplicó el sitio A de Perera et al. para la calibración.', - utilizador='Julien Malard', - contacto='julien.malard@mail.mcgill.ca') -Red_coco_senc.guardar() - +# +# Red_coco_senc.añadir_exp(Experimento_A, +# corresp={'O. arenosella_senc': {'adulto': ['Larva', 'Pupa']}, +# 'Parasitoide_senc': {'adulto': ['Para_larva_abs', 'Para_pupa_abs']} +# } +# ) +# +# Red_coco_senc.añadir_exp(Experimento_B, +# corresp={'O. arenosella_senc': {'adulto': ['Estado 1', 'Estado 2', 'Estado 3', 'Estado 4', +# 'Estado 5', 'Pupa']} +# } +# ) +# +# # Intentar calibrar +# ajuste_inic = Red_coco_senc.validar( +# nombre='senc Sitio A, Antes de calibrar', exper=Experimento_A, dibujar=dibujar, n_rep_estoc=n_rep_estoc, +# n_rep_parám=n_rep_parám, dib_dists=dibujar +# ) +# print('Ajuste inicial: ') +# pprint(ajuste_inic) +# +# Red_coco_senc.calibrar( +# nombre='Sin a priori', exper=Experimento_A, n_iter=n_iter, quema=quema, extraer=extraer, n_rep_estoc=n_rep_estoc, +# dibujar=dibujar, método=método, pedazitos=pedazitos +# ) +# vld = Red_coco_senc.validar(nombre='senc Sitio A, con calibración', exper=Experimento_A, dibujar=dibujar, +# n_rep_estoc=n_rep_estoc, +# n_rep_parám=n_rep_parám, +# dib_dists=dibujar) +# print('Sencilla, sitio A con calib sin AP\n********************') +# pprint(vld) +# +# vld = Red_coco_senc.validar( +# nombre='senc Sitio B, con calibración', exper=Experimento_B, dibujar=dibujar, n_rep_estoc=n_rep_estoc, +# n_rep_parám=n_rep_parám, +# dib_dists=dibujar) +# print('Sencilla, sitio B con calib sin AP\n********************') +# pprint(vld) +# +# Red_coco_senc.guardar_calib(descrip='Calibración de red sencilla (oruga y parasitoide) para O. arenosella en coco, ' +# 'sin usar a prioris. Se aplicó el sitio A de Perera et al. para la calibración.', +# utilizador='Julien Malard', +# contacto='julien.malard@mail.mcgill.ca') +# Red_coco_senc.guardar() +# +# # Especificar distribuciones a priori +# for a_priori in a_prioris[O_arenosella_senc.nombre]: +# O_arenosella_senc.especificar_apriori(dibujar=dibujar, **a_priori) +# +# for a_priori in a_prioris[Parasitoide_senc.nombre]: +# Parasitoide_senc.especificar_apriori(dibujar=dibujar, **a_priori) +# +# # Verificar el modelo ahora +# ajuste_con_aprioris = Red_coco_senc.validar( +# exper=Experimento_A, nombre='senc Sitio A, ajust con aprioris', n_rep_estoc=n_rep_estoc, n_rep_parám=n_rep_parám +# ) +# print('Ajuste con a prioris\n********************') +# pprint(ajuste_con_aprioris) +# +# # Intentar calibrar de nuevo +# vld = Red_coco_senc.validar(nombre='senc Sitio A, con a prioris', exper=Experimento_A, opciones_dib=ops_dib, +# n_rep_estoc=n_rep_estoc, +# n_rep_parám=n_rep_parám, +# dibujar=dibujar, +# dib_dists=dibujar) +# print('Sencilla, antes calib\n********************') +# pprint(vld) +# Red_coco_senc.calibrar('senc Con aprioris', exper=Experimento_A, n_iter=n_iter, quema=quema, extraer=extraer, +# n_rep_estoc=n_rep_estoc, +# dibujar=dibujar, método=método, pedazitos=pedazitos) +# +# vld = Red_coco_senc.validar(nombre='senc Sitio A, con calib a prioris', exper=Experimento_A, opciones_dib=ops_dib, +# n_rep_estoc=n_rep_estoc, +# n_rep_parám=n_rep_parám, +# dibujar=dibujar, dib_dists=dibujar) +# print('Sencilla, sitio A con calib\n********************') +# pprint(vld) +# +# vld = Red_coco_senc.validar(nombre='senc Sitio B, con calib a prioris', exper=Experimento_B, opciones_dib=ops_dib, +# n_rep_estoc=n_rep_estoc, +# n_rep_parám=n_rep_parám, +# dibujar=dibujar, dib_dists=dibujar) +# print('Sencilla, sitio B con calib\n********************') +# pprint(vld) +# +# Red_coco_senc.guardar_calib(descrip='Calibración de red sencilla (oruga y parasitoide) para O. arenosella en coco, ' +# 'empleando a prioris.' +# 'Se aplicó el sitio A de Perera et al. para la calibración.', +# utilizador='Julien Malard', +# contacto='julien.malard@mail.mcgill.ca') +# Red_coco_senc.guardar() +# # # Bueno, ahora vamos a ver con una estructura de red más compleja (agregando un depredador generalista) Araña = Ins.Sencillo('Araña', proyecto=proyecto) @@ -104,22 +142,38 @@ for a_priori in a_prioris[Araña.nombre]: Araña.especificar_apriori(dibujar=dibujar, **a_priori) -Red_coco_senc.añadir_org(Araña) - -Red_coco_senc.validar(nombre='senc Sitio A, con araña y ap', exper=Experimento_A, dibujar=dibujar) - -Red_coco_senc.calibrar(nombre='senc Con araña y ap', exper=Experimento_A, n_iter=n_iter, quema=quema, extraer=extraer, - dibujar=dibujar, método=método, pedazitos=pedazitos) -Red_coco_senc.validar(nombre='senc Sitio A, con araña y calib', exper=Experimento_A, dibujar=dibujar, dib_dists=dibujar) -Red_coco_senc.validar(nombre='senc Sitio B, con araña y calib', exper=Experimento_B, dibujar=dibujar, dib_dists=dibujar) -Red_coco_senc.guardar_calib(descrip='Calibración de red sencilla (oruga y parasitoide) para O. arenosella en coco, ' - 'empleando a prioris.' - 'Se aplicó el sitio A de Perera et al. para la calibración.', - utilizador='Julien Malard', - contacto='julien.malard@mail.mcgill.ca') -Red_coco_senc.guardar() - -del(Red_coco_senc) +# Red_coco_senc.añadir_org(Araña) +# +# vld = Red_coco_senc.validar(nombre='senc Sitio A, con araña y ap', exper=Experimento_A, dibujar=dibujar, +# n_rep_estoc=n_rep_estoc, +# n_rep_parám=n_rep_parám, +# ) +# print('Sencilla + araña, antes calib\n********************') +# pprint(vld) +# +# Red_coco_senc.calibrar(nombre='senc Con araña y ap', exper=Experimento_A, n_iter=n_iter, quema=quema, extraer=extraer, +# dibujar=dibujar, método=método, pedazitos=pedazitos, n_rep_estoc=n_rep_estoc) +# +# vld = Red_coco_senc.validar(nombre='senc Sitio A, con araña y calib', exper=Experimento_A, n_rep_estoc=n_rep_estoc, +# n_rep_parám=n_rep_parám, dibujar=dibujar, +# dib_dists=dibujar) +# print('Sencilla + araña, sitio A con calib\n********************') +# pprint(vld) +# +# vld = Red_coco_senc.validar(nombre='senc Sitio B, con araña y calib', exper=Experimento_B, n_rep_estoc=n_rep_estoc, +# n_rep_parám=n_rep_parám, dibujar=dibujar, +# dib_dists=dibujar) +# print('Sencilla + araña, sitio B con calib\n********************') +# pprint(vld) +# +# Red_coco_senc.guardar_calib(descrip='Calibración de red sencilla (oruga y parasitoide) para O. arenosella en coco, ' +# 'empleando a prioris.' +# 'Se aplicó el sitio A de Perera et al. para la calibración.', +# utilizador='Julien Malard', +# contacto='julien.malard@mail.mcgill.ca') +# Red_coco_senc.guardar() +# +# del Red_coco_senc # Intentemos algo más interesante ahora. O_arenosella = Ins.MetamCompleta('O. arenosella', proyecto=proyecto, njuvenil=5) @@ -167,15 +221,29 @@ pprint(Red_coco.ver_coefs_no_espec()) -Red_coco.validar(exper=Experimento_A, nombre='Sitio A, antes calib', usar_especificadas=True, dibujar=dibujar, - dib_dists=dibujar) -Red_coco.calibrar(exper=Experimento_A, nombre='Sin araña', n_iter=n_iter, quema=quema, extraer=extraer, - dibujar=dibujar, método=método, pedazitos=pedazitos) +vld = Red_coco.validar(exper=Experimento_A, nombre='Sitio A, antes calib', usar_especificadas=True, dibujar=dibujar, + n_rep_estoc=n_rep_estoc, + n_rep_parám=n_rep_parám, + dib_dists=dibujar) +print('Completa, antes calib\n********************') +pprint(vld) -Red_coco.validar(nombre='Sitio A, con calib', exper=Experimento_A, opciones_dib=ops_dib, dibujar=dibujar, - dib_dists=dibujar) -Red_coco.validar(nombre='Sitio B, con calib', exper=Experimento_B, opciones_dib=ops_dib, dibujar=dibujar, - dib_dists=dibujar) +Red_coco.calibrar(exper=Experimento_A, nombre='Sin araña', n_iter=n_iter, quema=quema, extraer=extraer, + n_rep_estoc=n_rep_estoc, dibujar=dibujar, método=método, pedazitos=pedazitos) + +vld = Red_coco.validar(nombre='Sitio A, con calib', exper=Experimento_A, opciones_dib=ops_dib, dibujar=dibujar, + n_rep_estoc=n_rep_estoc, + n_rep_parám=n_rep_parám, + dib_dists=dibujar) +print('Completa, sitio A con calib\n********************') +pprint(vld) + +vld = Red_coco.validar(nombre='Sitio B, con calib', exper=Experimento_B, opciones_dib=ops_dib, dibujar=dibujar, + n_rep_estoc=n_rep_estoc, + n_rep_parám=n_rep_parám, + dib_dists=dibujar) +print('Completa, sitio B con calib\n********************') +pprint(vld) # Red_coco.validar(Experimento_B, n_rep_parám=10, n_rep_estoc=10) @@ -195,14 +263,29 @@ for a_priori in a_prioris[Araña.nombre]: Araña.especificar_apriori(dibujar=dibujar, **a_priori) -Red_coco.validar(nombre='Sitio A, antes calib con araña', exper=Experimento_A, opciones_dib=ops_dib, - dibujar=dibujar, dib_dists=dibujar) +vld = Red_coco.validar(nombre='Sitio A, antes calib con araña', exper=Experimento_A, opciones_dib=ops_dib, + n_rep_estoc=n_rep_estoc, + n_rep_parám=n_rep_parám, + dibujar=dibujar, dib_dists=dibujar) +print('Completa + araña, antes calib\n********************') +pprint(vld) + Red_coco.calibrar(nombre='Con araña', exper=Experimento_A, n_iter=n_iter, quema=quema, dibujar=dibujar, - método=método, pedazitos=pedazitos) -Red_coco.validar(nombre='Sitio A, con calib y araña', exper=Experimento_A, opciones_dib=ops_dib, dibujar=dibujar, - dib_dists=dibujar) -Red_coco.validar(nombre='Sitio B, con calib y araña', exper=Experimento_B, opciones_dib=ops_dib, dibujar=dibujar, - dib_dists=dibujar) + método=método, pedazitos=pedazitos, n_rep_estoc=n_rep_estoc) + +vld = Red_coco.validar(nombre='Sitio A, con calib y araña', exper=Experimento_A, opciones_dib=ops_dib, dibujar=dibujar, + n_rep_estoc=n_rep_estoc, + n_rep_parám=n_rep_parám, + dib_dists=dibujar) +print('Completa + araña, sitio A con calib\n********************') +pprint(vld) + +vld = Red_coco.validar(nombre='Sitio B, con calib y araña', exper=Experimento_B, opciones_dib=ops_dib, dibujar=dibujar, + n_rep_estoc=n_rep_estoc, + n_rep_parám=n_rep_parám, + dib_dists=dibujar) +print('Completa + araña, sitio B con calib\n********************') +pprint(vld) Red_coco.guardar_calib(descrip='Calibración de red completa (oruga, parasitoide y araña) para O. arenosella en coco, ' 'empleando a prioris.' diff --git a/tikon/Proyectos/Opisina_arenosella/Oarenosella_A.csv b/tikon/Proyectos/Opisina_arenosella/Oarenosella_A.csv index d1f7add5..fc2b76b4 100644 --- a/tikon/Proyectos/Opisina_arenosella/Oarenosella_A.csv +++ b/tikon/Proyectos/Opisina_arenosella/Oarenosella_A.csv @@ -1,4 +1,4 @@ -Da,Estado 1,Estado 2,Estado 3,Estado 4,Estado 5,Larva,Pupa,Para_larva_por,Para_larva_abs,Para_pupa_por,Para_pupa_abs +Día,Estado 1,Estado 2,Estado 3,Estado 4,Estado 5,Larva,Pupa,Para_larva_por,Para_larva_abs,Para_pupa_por,Para_pupa_abs 0,0,90,200,175,250,715,300,6,42.9,15,45 7,0,25,100,170,180,475,260,16,76,28,72.8 14,850,25,10,0,10,895,60,8,71.6,30,18 diff --git a/tikon/Proyectos/Opisina_arenosella/Oarenosella_B.csv b/tikon/Proyectos/Opisina_arenosella/Oarenosella_B.csv index 9e3662cc..ba1b9c57 100644 --- a/tikon/Proyectos/Opisina_arenosella/Oarenosella_B.csv +++ b/tikon/Proyectos/Opisina_arenosella/Oarenosella_B.csv @@ -1,4 +1,4 @@ -Da,Estado 1,Estado 2,Estado 3,Estado 4,Estado 5,Pupa +Día,Estado 1,Estado 2,Estado 3,Estado 4,Estado 5,Pupa 0,0,60,150,95,145,92 7,0,27,70,70,90,104 14,0,10,50,55,80,75 diff --git a/tikon/Proyectos/Opisina_arenosella/Prueba artificial.py b/tikon/Proyectos/Opisina_arenosella/Prueba artificial.py deleted file mode 100644 index 660e6843..00000000 --- a/tikon/Proyectos/Opisina_arenosella/Prueba artificial.py +++ /dev/null @@ -1,5 +0,0 @@ -from tikon.RAE.RedAE import Red - -proyecto = 'Opisina_arenosella' - -red = Red('Coco artificial', proyecto=proyecto) diff --git a/tikon/Proyectos/Opisina_arenosella/a_prioris.py b/tikon/Proyectos/Opisina_arenosella/a_prioris.py index 49db8cc4..374900f1 100644 --- a/tikon/Proyectos/Opisina_arenosella/a_prioris.py +++ b/tikon/Proyectos/Opisina_arenosella/a_prioris.py @@ -96,10 +96,10 @@ org_inter='Parasitoide_senc', etp_inter='adulto', rango=(10000 ** 2, 100000 ** 2), certidumbre=0.80), # para hacer - # dict(etapa='adulto', - # ubic_parám=['Estoc', 'Dist', 'Normal', 'sigma'], - # rango=(0, 0.01), - # certidumbre=1), + dict(etapa='adulto', + ubic_parám=['Estoc', 'Dist', 'Normal', 'sigma'], + rango=(0, 0.01), + certidumbre=1), ], 'O. arenosella': [ @@ -118,10 +118,10 @@ rango=(0.025, 0.029), certidumbre=0.5, ), - # dict(etapa='huevo', - # ubic_parám=['Estoc', 'Dist', 'Normal', 'sigma'], - # rango=(0, 0.01), - # certidumbre=1), + dict(etapa='huevo', + ubic_parám=['Estoc', 'Dist', 'Normal', 'sigma'], + rango=(0, 0.01), + certidumbre=1), dict(etapa='juvenil_1', ubic_parám=['Depredación', 'Ecuación', 'Kovai', 'a'], rango=((1823 - 100 * 1.96) / (53.1 + 10.64 * 1.96) * 1e-9 * .2, @@ -149,10 +149,10 @@ rango=(1, 4), certidumbre=0.80, ), - # dict(etapa='juvenil_1', - # ubic_parám=['Estoc', 'Dist', 'Normal', 'sigma'], - # rango=(0, 0.01), - # certidumbre=1), + dict(etapa='juvenil_1', + ubic_parám=['Estoc', 'Dist', 'Normal', 'sigma'], + rango=(0, 0.01), + certidumbre=1), dict(etapa='juvenil_2', ubic_parám=['Depredación', 'Ecuación', 'Kovai', 'a'], rango=((1823 - 100 * 1.96) / (53.1 + 10.64 * 1.96) * 1e-9 * .2, @@ -179,10 +179,10 @@ ubic_parám=['Transiciones', 'Prob', 'Normal', 'sigma'], rango=(1, 4), certidumbre=0.80), - # dict(etapa='juvenil_2', - # ubic_parám=['Estoc', 'Dist', 'Normal', 'sigma'], - # rango=(0, 0.01), - # certidumbre=1), + dict(etapa='juvenil_2', + ubic_parám=['Estoc', 'Dist', 'Normal', 'sigma'], + rango=(0, 0.01), + certidumbre=1), dict(etapa='juvenil_3', ubic_parám=['Depredación', 'Ecuación', 'Kovai', 'a'], rango=((1823 - 100 * 1.96) / (53.1 + 10.64 * 1.96) * 1e-9 * .2, @@ -205,10 +205,10 @@ ubic_parám=['Transiciones', 'Prob', 'Normal', 'sigma'], rango=(1, 4), certidumbre=0.80), - # dict(etapa='juvenil_3', - # ubic_parám=['Estoc', 'Dist', 'Normal', 'sigma'], - # rango=(0, 0.01), - # certidumbre=1), + dict(etapa='juvenil_3', + ubic_parám=['Estoc', 'Dist', 'Normal', 'sigma'], + rango=(0, 0.01), + certidumbre=1), dict(etapa='juvenil_4', ubic_parám=['Depredación', 'Ecuación', 'Kovai', 'a'], rango=((1823 - 100 * 1.96) / (53.1 + 10.64 * 1.96) * 1e-9 * .2, @@ -231,10 +231,10 @@ ubic_parám=['Transiciones', 'Prob', 'Normal', 'sigma'], rango=(1, 4), certidumbre=0.80), - # dict(etapa='juvenil_4', - # ubic_parám=['Estoc', 'Dist', 'Normal', 'sigma'], - # rango=(0, 0.01), - # certidumbre=1), + dict(etapa='juvenil_4', + ubic_parám=['Estoc', 'Dist', 'Normal', 'sigma'], + rango=(0, 0.01), + certidumbre=1), dict(etapa='juvenil_5', ubic_parám=['Depredación', 'Ecuación', 'Kovai', 'a'], rango=((1823 - 100 * 1.96) / (53.1 + 10.64 * 1.96) * 1e-9 * .2, @@ -257,14 +257,14 @@ ubic_parám=['Transiciones', 'Prob', 'Normal', 'sigma'], rango=(1, 4), certidumbre=0.80), - # dict(etapa='juvenil_5', - # ubic_parám=['Estoc', 'Dist', 'Normal', 'sigma'], - # rango=(0, 0.01), - # certidumbre=1), - # dict(etapa='pupa', - # ubic_parám=['Estoc', 'Dist', 'Normal', 'sigma'], - # rango=(0, 0.01), - # certidumbre=1), + dict(etapa='juvenil_5', + ubic_parám=['Estoc', 'Dist', 'Normal', 'sigma'], + rango=(0, 0.01), + certidumbre=1), + dict(etapa='pupa', + ubic_parám=['Estoc', 'Dist', 'Normal', 'sigma'], + rango=(0, 0.01), + certidumbre=1), dict(etapa='pupa', ubic_parám=['Transiciones', 'Prob', 'Normal', 'mu'], rango=(7, 9), @@ -297,10 +297,10 @@ ubic_parám=['Reproducción', 'Prob', 'Normal', 'sigma'], rango=(1, 2), certidumbre=0.80), - # dict(etapa='adulto', - # ubic_parám=['Estoc', 'Dist', 'Normal', 'sigma'], - # rango=(0, 0.01), - # certidumbre=1), + dict(etapa='adulto', + ubic_parám=['Estoc', 'Dist', 'Normal', 'sigma'], + rango=(0, 0.01), + certidumbre=1), ], 'Parasitoide larvas': [ @@ -314,16 +314,16 @@ certidumbre=0.80), dict(etapa='adulto', ubic_parám=['Depredación', 'Ecuación', 'Kovai', 'a'], - rango=(10 / 20 / 2, 30 / 10 / 2), + rango=(0 / 20 / 2, 30 / 10 / 2), certidumbre=0.80), dict(etapa='adulto', ubic_parám=['Depredación', 'Ecuación', 'Kovai', 'b'], - rango=(1.0e8, 1.0e9), + rango=(1.0e6, 1.0e9), certidumbre=0.80), - # dict(etapa='adulto', - # ubic_parám=['Estoc', 'Dist', 'Normal', 'sigma'], - # rango=(0, 0.01), - # certidumbre=1), + dict(etapa='adulto', + ubic_parám=['Estoc', 'Dist', 'Normal', 'sigma'], + rango=(0, 0.01), + certidumbre=1), dict(etapa='juvenil', ubic_parám=['Transiciones', 'Mult', 'Linear', 'a'], rango=(1, 10), @@ -336,10 +336,10 @@ ubic_parám=['Transiciones', 'Prob', 'Normal', 'sigma'], rango=(.5, .6), certidumbre=0.80), - # dict(etapa='juvenil', - # ubic_parám=['Estoc', 'Dist', 'Normal', 'sigma'], - # rango=(0, 0.01), - # certidumbre=1), + dict(etapa='juvenil', + ubic_parám=['Estoc', 'Dist', 'Normal', 'sigma'], + rango=(0, 0.01), + certidumbre=1), ], 'Parasitoide pupas': [ @@ -353,16 +353,16 @@ certidumbre=0.80), dict(etapa='adulto', ubic_parám=['Depredación', 'Ecuación', 'Kovai', 'a'], - rango=(10 / 20 / 2, 30 / 10 / 2), + rango=(0 / 20 / 2, 30 / 10 / 2), certidumbre=0.80), dict(etapa='adulto', ubic_parám=['Depredación', 'Ecuación', 'Kovai', 'b'], - rango=(0.1e6, 3.0e6), + rango=(0.1e3, 3.0e6), certidumbre=0.80), - # dict(etapa='adulto', - # ubic_parám=['Estoc', 'Dist', 'Normal', 'sigma'], - # rango=(0, 0.01), - # certidumbre=1), + dict(etapa='adulto', + ubic_parám=['Estoc', 'Dist', 'Normal', 'sigma'], + rango=(0, 0.01), + certidumbre=1), dict(etapa='juvenil', ubic_parám=['Transiciones', 'Mult', 'Linear', 'a'], rango=(1, 10), @@ -375,9 +375,9 @@ ubic_parám=['Transiciones', 'Prob', 'Normal', 'sigma'], rango=(.5, .6), certidumbre=0.80), - # dict(etapa='juvenil', - # ubic_parám=['Estoc', 'Dist', 'Normal', 'sigma'], - # rango=(0, 0.01), - # certidumbre=1), + dict(etapa='juvenil', + ubic_parám=['Estoc', 'Dist', 'Normal', 'sigma'], + rango=(0, 0.01), + certidumbre=1), ] } diff --git a/tikon/RAE/RedAE.py b/tikon/RAE/RedAE.py index 2af1ea41..7d253915 100644 --- a/tikon/RAE/RedAE.py +++ b/tikon/RAE/RedAE.py @@ -1551,9 +1551,6 @@ def _analizar_valid(símismo): """ - matr_preds_total = None - vector_obs_total = None - # El diccionario de validación por etapa valids_detalles = {} @@ -1565,6 +1562,8 @@ def _analizar_valid(símismo): n_etps = len(símismo.etapas) + d_res_valid = {} + # Para cada experimento... for exp, d_obs_exp in d_obs_valid.items(): @@ -1594,21 +1593,19 @@ def _analizar_valid(símismo): valids_detalles[exp][org][etp] = {} - valids_detalles[exp][org][etp][parc] = validar_matr_pred( + valids = validar_matr_pred( matr_predic=matr_preds, vector_obs=vec_obs ) + valids_detalles[exp][org][etp][parc] = valids + for ll, v in valids.items(): + if ll not in d_res_valid: + d_res_valid[ll] = [] + d_res_valid[ll].append(v) - if matr_preds_total is None: - matr_preds_total = matr_preds - vector_obs_total = vec_obs - else: - matr_preds_total = np.append(matr_preds_total, matr_preds, axis=-1) - vector_obs_total = np.append(vector_obs_total, vec_obs, axis=-1) + d_res_valid = {ll: np.mean(v) for ll, v in d_res_valid.items()} - valid = validar_matr_pred(matr_predic=matr_preds_total, vector_obs=vector_obs_total) - - return {'Valid': valid, 'Valid detallades': valids_detalles} + return {'Valid': d_res_valid, 'Valid detallades': valids_detalles} def _procesar_matrs_sens(símismo): """ @@ -2193,7 +2190,7 @@ def temp(m, l): símismo.dic_simul['l_m_obs_todas'].extend(l_m_obs_todas) símismo.dic_simul['l_días_obs_todas'].extend(l_días_obs_todas) - def _gen_dics_calib(símismo, exper): + def _gen_dics_calib(símismo, exper, n_rep_estoc): # El diccionario de observaciones para la validación... l_obs_v = dic_a_lista(símismo.dic_simul['d_obs_valid']) @@ -2226,10 +2223,7 @@ def _gen_dics_calib(símismo, exper): n_obs_cumul += n_obs # El diccionario vacío para guardar predicciones - símismo.dic_simul['d_calib']['Normal'] = { - 'mu': np.empty(n_obs_cumul), - 'sigma': np.empty(n_obs_cumul) - } + símismo.dic_simul['d_calib']['Normal'] = np.empty((n_obs_cumul, n_rep_estoc)) # El diccionario de observaciones para la calibración d_obs_c['Normal'] = np.empty(n_obs_cumul) diff --git "a/tikon/Trads/Tamil/\340\256\265\340\257\207_\340\256\232\340\257\201_\340\256\265\340\256\262\340\257\210/\340\256\252\340\257\202\340\256\232\340\257\215\340\256\232\340\256\277.py" "b/tikon/Trads/Tamil/\340\256\265\340\257\207_\340\256\232\340\257\201_\340\256\265\340\256\262\340\257\210/\340\256\252\340\257\202\340\256\232\340\257\215\340\256\232\340\256\277.py" deleted file mode 100644 index 71df7080..00000000 --- "a/tikon/Trads/Tamil/\340\256\265\340\257\207_\340\256\232\340\257\201_\340\256\265\340\256\262\340\257\210/\340\256\252\340\257\202\340\256\232\340\257\215\340\256\232\340\256\277.py" +++ /dev/null @@ -1,43 +0,0 @@ -from tikon.RAE import Insecto as Ins - - -class பூச்சி(Ins.Insecto): - def __init__(தாங்கள், பெயர், திட்டம், முட்டை=False, புழு_எண்=0, கூடு=False, பெரியது=True, - சமன்பாடு_வகை=None): - super().__init__(nombre=பெயர், proyecto=திட்டம், huevo=முட்டை, njuvenil=புழு_எண், - pupa=கூடு, adulto=பெரியது, tipo_ecuaciones=சமன்பாடு_வகை) - - def தின்றுகிறது(símismo, இரை, இரை_படி=None, தின்றவர்_படி=None): - símismo.secome(símismo, presa=இரை, etps_presa=இரை_படி, etps_depred=தின்றவர்_படி) - - def தின்றாது(símismo, இரை, இரை_படி=None, தின்றவர்_படி=None): - símismo.nosecome(símismo, presa=இரை, etps_presa=இரை_படி, etps_depred=தின்றவர்_படி) - -class ஒட்டுணி(Ins.Parasitoide): - def __init__(தாங்கள், பெயர், திட்டம், கூடு=False): - super().__init__(nombre=பெயர், proyecto=திட்டம், pupa=கூடு) - def ஒட்டுணி_இல்லை(símismo, இரை, உள்ளே=None): - super().noparasita(víctima=இரை, etps_infec=உள்ளே) - - def இதின்_ஒட்டுணி(símismo, இரை, உள்ளே, வெளியே): - super().parasita(víctima=இரை, etps_infec=உள்ளே, etp_sale=வெளியே) - -class ஸ்பெசிடெ(Ins.Esfécido): - def __init__(தாங்கள், பெயர், திட்டம்): - super().__init__(nombre=பெயர், proyecto=திட்டம்) - - def பிடிக்காது(símismo, இரை, இரை_படி=None): - super().nocaptura(víctima=இரை, etps_víc=இரை_படி) - - def பிடிக்கும்(símismo, இரை, இரை_படி): - super().captura(víctima=இரை, etps_víc=இரை_படி) - -class எளியது(Ins.Sencillo): - def __init__(தாங்கள், பெயர், திட்டம்): - super().__init__(nombre=பெயர், proyecto=திட்டம்) - - def தின்றுகிறது(símismo, இரை, இரை_படி=None, தின்றவர்_படி=None): - símismo.secome(símismo, presa=இரை, etps_presa=இரை_படி, etps_depred=தின்றவர்_படி) - - def தின்றாது(símismo, இரை, இரை_படி=None, தின்றவர்_படி=None): - símismo.nosecome(símismo, presa=இரை, etps_presa=இரை_படி, etps_depred=தின்றவர்_படி) diff --git "a/tikon/Trads/Tamil/\340\256\265\340\257\207_\340\256\232\340\257\201_\340\256\265\340\256\262\340\257\210/\340\256\265\340\257\207_\340\256\232\340\257\201_\340\256\265\340\256\262\340\257\210.py" "b/tikon/Trads/Tamil/\340\256\265\340\257\207_\340\256\232\340\257\201_\340\256\265\340\256\262\340\257\210/\340\256\265\340\257\207_\340\256\232\340\257\201_\340\256\265\340\256\262\340\257\210.py" deleted file mode 100644 index 37de59dc..00000000 --- "a/tikon/Trads/Tamil/\340\256\265\340\257\207_\340\256\232\340\257\201_\340\256\265\340\256\262\340\257\210/\340\256\265\340\257\207_\340\256\232\340\257\201_\340\256\265\340\256\262\340\257\210.py" +++ /dev/null @@ -1,44 +0,0 @@ -from tikon.RAE import RedAE - - -class வேளாண்_சுழ்_வலை(RedAE.Red): - def __init__(தாங்கள், பெயர், திட்டம், உயிரனங்கள்): - super().__init__(nombre=பெயர், proyecto=திட்டம், organismos=உயிரனங்கள்) - - def உயிரினம்_நீக்க(தாங்கள், உயிரினம்): - return super().quitar_org(organismo=உயிரினம்) - - def அளவிடு(தாங்கள், பெயர்=None, முதல்_நிகழ்வெண்_பரவல்=None, சோதனை=None, - படி=1, திரும்ப_எண்=10000, எரி=100, சேமிக்க=10, - ஒவியம்=False): - return super().calibrar(nombre=பெயர், aprioris=முதல்_நிகழ்வெண்_பரவல், exper=சோதனை, paso=படி, - n_iter=திரும்ப_எண், quema=எரி, extraer=சேமிக்க, dibujar=ஒவியம்) - - def சோதனை_சேருக(தாங்கள், சோதனை, விவரங்கள்): - super().añadir_exp(experimento=சோதனை, corresp=விவரங்கள்) - - def நடக்க(símismo, சோதனை, படி=1, கடைசியான_நேரம்=None, பண்பளவு_திரும்ப_எண்=100, - சமவாய்ப்பு_திரும்ப_எண்=100, - அளவிடுகள்='Todos', குறிப்பிடபட்ட_பயன்_செய்ய=False, - விவரங்கள்=True, ஒவியம்=True, ஒவியம்_கோப்புறை=None, காமி்க்க=True, - ஒவிய_அமைப்புகள்=None): - super().simular(exper=சோதனை, paso=படி, tiempo_final=கடைசியான_நேரம், - n_rep_parám=பண்பளவு_திரும்ப_எண், - n_rep_estoc=சமவாய்ப்பு_திரும்ப_எண், calibs=அளவிடுகள், - usar_especificadas=குறிப்பிடபட்ட_பயன்_செய்ய, - detalles=விவரங்கள், dibujar=ஒவியம், directorio_dib=ஒவியம்_கோப்புறை, mostrar=காமி்க்க, - opciones_dib=ஒவிய_அமைப்புகள்) - - def செல்லுபடியாக்கு(símismo, சோதனை, அளவிடுகள்=None, படி=1, - பண்பளவு_திரும்ப_எண்=100, சமவாய்ப்பு_திரும்ப_எண்=100, - குறிப்பிடபட்ட_பயன்_செய்ய=False, - விவரங்கள்=True, ஒவியம்=True, காமிக்க=False, ஒவிய_அமைப்புகள்=None): - return super().validar(exper=சோதனை, calibs=அளவிடுகள், paso=படி, - n_rep_parám=பண்பளவு_திரும்ப_எண், - n_rep_estoc=சமவாய்ப்பு_திரும்ப_எண், - usar_especificadas=குறிப்பிடபட்ட_பயன்_செய்ய, - detalles=விவரங்கள், dibujar=ஒவியம், - mostrar=காமிக்க, opciones_dib=ஒவிய_அமைப்புகள்) - - def உயிரினம்_சேருக(símismo, உயிரினம்): - return super().añadir_org(organismo=உயிரினம்) diff --git "a/tikon/_Trads/\340\256\244\340\256\256\340\256\277\340\256\264\340\257\215/__init__.py" "b/tikon/_Trads/\340\256\244\340\256\256\340\256\277\340\256\264\340\257\215/__init__.py" deleted file mode 100644 index 6ab97cd0..00000000 --- "a/tikon/_Trads/\340\256\244\340\256\256\340\256\277\340\256\264\340\257\215/__init__.py" +++ /dev/null @@ -1 +0,0 @@ -from tikon._Trads.தமிழ் import வே_சு_வலை diff --git "a/tikon/_Trads/\340\256\244\340\256\256\340\256\277\340\256\264\340\257\215/\340\256\265\340\257\207_\340\256\232\340\257\201_\340\256\265\340\256\262\340\257\210/\340\256\252\340\257\202\340\256\232\340\257\215\340\256\232\340\256\277.py" "b/tikon/_Trads/\340\256\244\340\256\256\340\256\277\340\256\264\340\257\215/\340\256\265\340\257\207_\340\256\232\340\257\201_\340\256\265\340\256\262\340\257\210/\340\256\252\340\257\202\340\256\232\340\257\215\340\256\232\340\256\277.py" deleted file mode 100644 index 0a56c384..00000000 --- "a/tikon/_Trads/\340\256\244\340\256\256\340\256\277\340\256\264\340\257\215/\340\256\265\340\257\207_\340\256\232\340\257\201_\340\256\265\340\256\262\340\257\210/\340\256\252\340\257\202\340\256\232\340\257\215\340\256\232\340\256\277.py" +++ /dev/null @@ -1,46 +0,0 @@ -from tikon.RAE import Insecto as Ins - - -class பூச்சி(Ins.Insecto): - def __init__(தாங்கள், பெயர், திட்டம், முட்டை=False, புழு_எண்=0, கூடு=False, பெரியது=True, சமன்பாடு_வகை=None): - super().__init__(nombre=பெயர், proyecto=திட்டம், huevo=முட்டை, njuvenil=புழு_எண், - pupa=கூடு, adulto=பெரியது, tipo_ecuaciones=சமன்பாடு_வகை) - - def தின்றுகிறது(தாங்கள், இரை, இரை_படி=None, தின்றவர்_படி=None): - super().secome(presa=இரை, etps_presa=இரை_படி, etps_depred=தின்றவர்_படி) - - def தின்றாது(தாங்கள், இரை, இரை_படி=None, தின்றவர்_படி=None): - super().nosecome(presa=இரை, etps_presa=இரை_படி, etps_depred=தின்றவர்_படி) - - -class ஒட்டுணி(Ins.Parasitoide): - def __init__(தாங்கள், பெயர், திட்டம், கூடு=False): - super().__init__(nombre=பெயர், proyecto=திட்டம், pupa=கூடு) - - def ஒட்டுணி_இல்லை(símismo, இரை, உள்ளே=None): - super().noparasita(víctima=இரை, etps_infec=உள்ளே) - - def இதின்_ஒட்டுணி(தாங்கள், இரை, உள்ளே, வெளியே): - super().parasita(víctima=இரை, etps_infec=உள்ளே, etp_sale=வெளியே) - - -class ஸ்பெசிடெ(Ins.Esfécido): - def __init__(தாங்கள், பெயர், திட்டம்): - super().__init__(nombre=பெயர், proyecto=திட்டம்) - - def பிடிக்காது(தாங்கள், இரை, இரை_படி=None): - super().nocaptura(víctima=இரை, etps_víc=இரை_படி) - - def பிடிக்கும்(தாங்கள், இரை, இரை_படி): - super().captura(víctima=இரை, etps_víc=இரை_படி) - - -class எளியது(Ins.Sencillo): - def __init__(தாங்கள், பெயர், திட்டம்): - super().__init__(nombre=பெயர், proyecto=திட்டம்) - - def தின்றுகிறது(தாங்கள், இரை, இரை_படி=None, தின்றவர்_படி=None): - super().secome(presa=இரை, etps_presa=இரை_படி, etps_depred=தின்றவர்_படி) - - def தின்றாது(தாங்கள், இரை, இரை_படி=None, தின்றவர்_படி=None): - super().nosecome(presa=இரை, etps_presa=இரை_படி, etps_depred=தின்றவர்_படி) diff --git "a/tikon/_Trads/\340\256\244\340\256\256\340\256\277\340\256\264\340\257\215/\340\256\265\340\257\207_\340\256\232\340\257\201_\340\256\265\340\256\262\340\257\210/\340\256\265\340\257\207_\340\256\232\340\257\201_\340\256\265\340\256\262\340\257\210.py" "b/tikon/_Trads/\340\256\244\340\256\256\340\256\277\340\256\264\340\257\215/\340\256\265\340\257\207_\340\256\232\340\257\201_\340\256\265\340\256\262\340\257\210/\340\256\265\340\257\207_\340\256\232\340\257\201_\340\256\265\340\256\262\340\257\210.py" deleted file mode 100644 index 926fcc4d..00000000 --- "a/tikon/_Trads/\340\256\244\340\256\256\340\256\277\340\256\264\340\257\215/\340\256\265\340\257\207_\340\256\232\340\257\201_\340\256\265\340\256\262\340\257\210/\340\256\265\340\257\207_\340\256\232\340\257\201_\340\256\265\340\256\262\340\257\210.py" +++ /dev/null @@ -1,44 +0,0 @@ -from tikon.RAE import RedAE - - -class வேளாண்_சுழ்_வலை(RedAE.Red): - def __init__(தாங்கள், பெயர், திட்டம், உயிரனங்கள்): - super().__init__(nombre=பெயர், proyecto=திட்டம், organismos=உயிரனங்கள்) - - def உயிரினம்_நீக்க(தாங்கள், உயிரினம்): - return super().quitar_org(organismo=உயிரினம்) - - def அளவிடு(தாங்கள், பெயர்=None, முதல்_நிகழ்வெண்_பரவல்=None, சோதனை=None, - படி=1, திரும்ப_எண்=10000, எரி=100, சேமிக்க=10, - ஒவியம்=False): - return super().calibrar(nombre=பெயர், aprioris=முதல்_நிகழ்வெண்_பரவல், exper=சோதனை, paso=படி, - n_iter=திரும்ப_எண், quema=எரி, extraer=சேமிக்க, dibujar=ஒவியம்) - - def சோதனை_சேருக(தாங்கள், சோதனை, விவரங்கள்): - super().añadir_exp(experimento=சோதனை, corresp=விவரங்கள்) - - def நடக்க(தாங்கள், சோதனை, படி=1, கடைசியான_நாள்=None, பண்பளவு_திரும்ப_எண்=100, - சமவாய்ப்பு_திரும்ப_எண்=100, - அளவிடுகள்='Todos', குறிப்பிடபட்ட_பயன்_செய்ய=False, - விவரங்கள்=True, ஒவியம்=True, ஒவியம்_கோப்புறை=None, காமி்க்க=True, - ஒவிய_அமைப்புகள்=None): - super().simular(exper=சோதனை, paso=படி, tiempo_final=கடைசியான_நாள், - n_rep_parám=பண்பளவு_திரும்ப_எண், - n_rep_estoc=சமவாய்ப்பு_திரும்ப_எண், calibs=அளவிடுகள், - usar_especificadas=குறிப்பிடபட்ட_பயன்_செய்ய, - detalles=விவரங்கள், dibujar=ஒவியம், directorio_dib=ஒவியம்_கோப்புறை, mostrar=காமி்க்க, - opciones_dib=ஒவிய_அமைப்புகள்) - - def செல்லுபடியாக்கு(தாங்கள், சோதனை, அளவிடுகள்=None, படி=1, - பண்பளவு_திரும்ப_எண்=100, சமவாய்ப்பு_திரும்ப_எண்=100, - குறிப்பிடபட்ட_பயன்_செய்ய=False, - விவரங்கள்=True, ஒவியம்=True, காமிக்க=False, ஒவிய_அமைப்புகள்=None): - return super().validar(exper=சோதனை, calibs=அளவிடுகள், paso=படி, - n_rep_parám=பண்பளவு_திரும்ப_எண், - n_rep_estoc=சமவாய்ப்பு_திரும்ப_எண், - usar_especificadas=குறிப்பிடபட்ட_பயன்_செய்ய, - detalles=விவரங்கள், dibujar=ஒவியம், - mostrar=காமிக்க, opciones_dib=ஒவிய_அமைப்புகள்) - - def உயிரினம்_சேருக(தாங்கள், உயிரினம்): - return super().añadir_org(organismo=உயிரினம்) diff --git "a/tikon/trads/\340\256\244/Clima/CLIMA.py" "b/tikon/trads/\340\256\244/Clima/CLIMA.py" deleted file mode 100644 index e942792c..00000000 --- "a/tikon/trads/\340\256\244/Clima/CLIMA.py" +++ /dev/null @@ -1,14 +0,0 @@ -from tikon.Clima.CLIMA import Clima -from tikon.Clima.CLIMA import Diario - - -class Diario(Diario): - - def buscar(தன், fecha_inic, fecha_fin): - return super().buscar(fecha_inic=fecha_inic, fecha_fin=fecha_fin) - - -class Clima(Clima): - - def gendiario(தன், fecha_inic, fecha_fin): - return super().gendiario(fecha_inic=fecha_inic, fecha_fin=fecha_fin) diff --git "a/tikon/trads/\340\256\244/Clima/Estad_diario.py" "b/tikon/trads/\340\256\244/Clima/Estad_diario.py" deleted file mode 100644 index d1338fdf..00000000 --- "a/tikon/trads/\340\256\244/Clima/Estad_diario.py" +++ /dev/null @@ -1,3 +0,0 @@ -from tikon.Clima.Estad_diario import __author__ - -__author__ = __author__ diff --git "a/tikon/trads/\340\256\244/Clima/Estad_futuro.py" "b/tikon/trads/\340\256\244/Clima/Estad_futuro.py" deleted file mode 100644 index 8b137891..00000000 --- "a/tikon/trads/\340\256\244/Clima/Estad_futuro.py" +++ /dev/null @@ -1 +0,0 @@ - diff --git "a/tikon/trads/\340\256\244/Clima/Manejo.py" "b/tikon/trads/\340\256\244/Clima/Manejo.py" deleted file mode 100644 index 8b137891..00000000 --- "a/tikon/trads/\340\256\244/Clima/Manejo.py" +++ /dev/null @@ -1 +0,0 @@ - diff --git "a/tikon/trads/\340\256\244/Clima/PyKrige/__init__.py" "b/tikon/trads/\340\256\244/Clima/PyKrige/__init__.py" deleted file mode 100644 index bdf93f20..00000000 --- "a/tikon/trads/\340\256\244/Clima/PyKrige/__init__.py" +++ /dev/null @@ -1,3 +0,0 @@ -from tikon.Clima.PyKrige.__init__ import __name__ - -__name__ = __name__ diff --git "a/tikon/trads/\340\256\244/Clima/PyKrige/core.py" "b/tikon/trads/\340\256\244/Clima/PyKrige/core.py" deleted file mode 100644 index 07ce4590..00000000 --- "a/tikon/trads/\340\256\244/Clima/PyKrige/core.py" +++ /dev/null @@ -1,3 +0,0 @@ -from tikon.Clima.PyKrige.core import __doc__ - -__doc__ = __doc__ diff --git "a/tikon/trads/\340\256\244/Clima/PyKrige/uk.py" "b/tikon/trads/\340\256\244/Clima/PyKrige/uk.py" deleted file mode 100644 index 8255b3af..00000000 --- "a/tikon/trads/\340\256\244/Clima/PyKrige/uk.py" +++ /dev/null @@ -1,39 +0,0 @@ -from tikon.Clima.PyKrige.uk import UniversalKriging -from tikon.Clima.PyKrige.uk import __doc__ - -__doc__ = __doc__ - - -class UniversalKriging(UniversalKriging): - - def update_variogram_model(self, variogram_model, variogram_parameters=None, variogram_function=None, nlags=6, - weight=False, anisotropy_scaling=1.0, anisotropy_angle=0.0): - return super().update_variogram_model(variogram_model=variogram_model, - variogram_parameters=variogram_parameters, - variogram_function=variogram_function, nlags=nlags, weight=weight, - anisotropy_scaling=anisotropy_scaling, anisotropy_angle=anisotropy_angle) - - def display_variogram_model(self): - return super().display_variogram_model() - - def switch_verbose(self): - return super().switch_verbose() - - def switch_plotting(self): - return super().switch_plotting() - - def get_epsilon_residuals(self): - return super().get_epsilon_residuals() - - def plot_epsilon_residuals(self): - return super().plot_epsilon_residuals() - - def get_statistics(self): - return super().get_statistics() - - def print_statistics(self): - return super().print_statistics() - - def execute(self, style, xpoints, ypoints, mask=None, backend="vectorized", specified_drift_arrays=None): - return super().execute(style=style, xpoints=xpoints, ypoints=ypoints, mask=mask, backend=backend, - specified_drift_arrays=specified_drift_arrays) diff --git "a/tikon/trads/\340\256\244/Clima/PyKrige/variogram_models.py" "b/tikon/trads/\340\256\244/Clima/PyKrige/variogram_models.py" deleted file mode 100644 index 701daaa7..00000000 --- "a/tikon/trads/\340\256\244/Clima/PyKrige/variogram_models.py" +++ /dev/null @@ -1,3 +0,0 @@ -from tikon.Clima.PyKrige.variogram_models import __doc__ - -__doc__ = __doc__ diff --git "a/tikon/trads/\340\256\244/Clima/__init__.py" "b/tikon/trads/\340\256\244/Clima/__init__.py" deleted file mode 100644 index 4cc1e672..00000000 --- "a/tikon/trads/\340\256\244/Clima/__init__.py" +++ /dev/null @@ -1,6 +0,0 @@ -from tikon.Clima.__init__ import __all__ -from tikon.Clima.__init__ import __author__ - -__author__ = __author__ - -__all__ = __all__ diff --git "a/tikon/trads/\340\256\244/Controles.py" "b/tikon/trads/\340\256\244/Controles.py" deleted file mode 100644 index 96178b99..00000000 --- "a/tikon/trads/\340\256\244/Controles.py" +++ /dev/null @@ -1,15 +0,0 @@ -from tikon.Controles import archivo_ctrls -from tikon.Controles import dir_proyectos -from tikon.Controles import directorio_base -from tikon.Controles import dirs_modelos -from tikon.Controles import usar_pymc3 - -usar_pymc3 = usar_pymc3 - -directorio_base = directorio_base - -dir_proyectos = dir_proyectos - -archivo_ctrls = archivo_ctrls - -dirs_modelos = dirs_modelos diff --git "a/tikon/trads/\340\256\244/Coso.py" "b/tikon/trads/\340\256\244/Coso.py" deleted file mode 100644 index b6a15310..00000000 --- "a/tikon/trads/\340\256\244/Coso.py" +++ /dev/null @@ -1,90 +0,0 @@ -from tikon.Coso import Coso -from tikon.Coso import Simulable - - -class Coso(Coso): - - def actualizar(தன்): - return super().actualizar() - - def especificar_apriori(தன்): - return super().especificar_apriori() - - def borrar_calib(தன், id_calib, recursivo=True): - return super().borrar_calib(id_calib=id_calib, recursivo=recursivo) - - def limpiar_especificados(தன், recursivo=True): - return super().limpiar_especificados(recursivo=recursivo) - - def guardar_especificados(தன், nombre_dist="dist_especificada"): - return super().guardar_especificados(nombre_dist=nombre_dist) - - def guardar(தன், திட்டம்=None, especificados=False, iterativo=True): - return super().guardar(proyecto=திட்டம், especificados=especificados, iterativo=iterativo) - - def cargar(தன், fuente): - return super().cargar(fuente=fuente) - - def ver_coefs_no_espec(தன்): - return super().ver_coefs_no_espec() - - def generar_aprioris(cls, directorio=None): - return super().generar_aprioris(directorio=directorio) - - -class Simulable(Simulable): - - def actualizar(தன்): - return super().actualizar() - - def incrementar(தன், paso, i, detalles, extrn): - return super().incrementar(paso=paso, i=i, detalles=detalles, extrn=extrn) - - def simular(தன், exper=None, பெயர்=None, paso=1, tiempo_final=None, n_rep_parám=100, n_rep_estoc=100, - calibs="Todos", usar_especificadas=False, detalles=True, dibujar=True, directorio_dib=None, - mostrar=True, opciones_dib=None, dib_dists=True, valid=False, depurar=False): - return super().simular(exper=exper, nombre=பெயர், paso=paso, tiempo_final=tiempo_final, n_rep_parám=n_rep_parám, - n_rep_estoc=n_rep_estoc, calibs=calibs, usar_especificadas=usar_especificadas, - detalles=detalles, dibujar=dibujar, directorio_dib=directorio_dib, mostrar=mostrar, - opciones_dib=opciones_dib, dib_dists=dib_dists, valid=valid, depurar=depurar) - - def calibrar(தன், பெயர்=None, aprioris=None, exper=None, paso=1, n_rep_estoc=10, tiempo_final=None, n_iter=10000, - quema=100, extraer=10, método="Metrópolis adaptivo", pedazitos=None, usar_especificadas=True, - dibujar=False, depurar=False): - return super().calibrar(nombre=பெயர், aprioris=aprioris, exper=exper, paso=paso, n_rep_estoc=n_rep_estoc, - tiempo_final=tiempo_final, n_iter=n_iter, quema=quema, extraer=extraer, método=método, - pedazitos=pedazitos, usar_especificadas=usar_especificadas, dibujar=dibujar, - depurar=depurar) - - def avanzar_calib(தன், rep=10000, quema=100, extraer=10): - return super().avanzar_calib(rep=rep, quema=quema, extraer=extraer) - - def guardar_calib(தன், descrip, utilizador, contacto=""): - return super().guardar_calib(descrip=descrip, utilizador=utilizador, contacto=contacto) - - def añadir_exp(தன், experimento, corresp): - return super().añadir_exp(experimento=experimento, corresp=corresp) - - def validar(தன், exper, பெயர்=None, calibs=None, paso=1, n_rep_parám=20, n_rep_estoc=20, usar_especificadas=False, - detalles=False, guardar=True, dibujar=True, mostrar=False, opciones_dib=None, dib_dists=True, - depurar=False): - return super().validar(exper=exper, nombre=பெயர், calibs=calibs, paso=paso, n_rep_parám=n_rep_parám, - n_rep_estoc=n_rep_estoc, usar_especificadas=usar_especificadas, detalles=detalles, - guardar=guardar, dibujar=dibujar, mostrar=mostrar, opciones_dib=opciones_dib, - dib_dists=dib_dists, depurar=depurar) - - def sensibilidad(தன், பெயர், exper, n, método="Sobol", calibs=None, por_dist_ingr=0.95, n_rep_estoc=30, - tiempo_final=None, detalles=False, usar_especificadas=True, opciones_sens=None, dibujar=False): - return super().sensibilidad(nombre=பெயர், exper=exper, n=n, método=método, calibs=calibs, - por_dist_ingr=por_dist_ingr, n_rep_estoc=n_rep_estoc, tiempo_final=tiempo_final, - detalles=detalles, usar_especificadas=usar_especificadas, - opciones_sens=opciones_sens, dibujar=dibujar) - - def dibujar(தன், mostrar=True, directorio=None, exper=None): - return super().dibujar(mostrar=mostrar, directorio=directorio, exper=exper) - - def dibujar_calib(தன்): - return super().dibujar_calib() - - def especificar_apriori(தன்): - return super().especificar_apriori() diff --git "a/tikon/trads/\340\256\244/Cultivo/CULTIVO.py" "b/tikon/trads/\340\256\244/Cultivo/CULTIVO.py" deleted file mode 100644 index ca5b3aeb..00000000 --- "a/tikon/trads/\340\256\244/Cultivo/CULTIVO.py" +++ /dev/null @@ -1,10 +0,0 @@ -from tikon.Cultivo.CULTIVO import Cultivo - - -class Cultivo(Cultivo): - - def ejec(தன், carpeta): - return super().ejec(carpeta=carpeta) - - def incr(தன், paso, daño_plagas): - return super().incr(paso=paso, daño_plagas=daño_plagas) diff --git "a/tikon/trads/\340\256\244/Cultivo/ModExtern/DSSAT/DSSAT.py" "b/tikon/trads/\340\256\244/Cultivo/ModExtern/DSSAT/DSSAT.py" deleted file mode 100644 index 545068ed..00000000 --- "a/tikon/trads/\340\256\244/Cultivo/ModExtern/DSSAT/DSSAT.py" +++ /dev/null @@ -1,18 +0,0 @@ -from tikon.Cultivo.ModExtern.DSSAT.DSSAT import Experimento -from tikon.Cultivo.ModExtern.DSSAT.DSSAT import importar_todos_suelos -from tikon.Cultivo.ModExtern.DSSAT.DSSAT import importar_suelo -from tikon.Cultivo.ModExtern.DSSAT.DSSAT import leer_datos_egr -from tikon.Cultivo.ModExtern.DSSAT.DSSAT import leer_egr -from tikon.Cultivo.ModExtern.DSSAT.DSSAT import gen_ingr -from tikon.Cultivo.ModExtern.DSSAT.DSSAT import dir_DSSAT - -dir_DSSAT = dir_DSSAT - - -class Experimento(Experimento): - - def gen_ingresos(தன்): - return super().gen_ingresos() - - def gen_dssbatch(தன்): - return super().gen_dssbatch() diff --git "a/tikon/trads/\340\256\244/Cultivo/ModExtern/DSSAT/__init__.py" "b/tikon/trads/\340\256\244/Cultivo/ModExtern/DSSAT/__init__.py" deleted file mode 100644 index 0d725bd3..00000000 --- "a/tikon/trads/\340\256\244/Cultivo/ModExtern/DSSAT/__init__.py" +++ /dev/null @@ -1,6 +0,0 @@ -from tikon.Cultivo.ModExtern.DSSAT.__init__ import __all__ -from tikon.Cultivo.ModExtern.DSSAT.__init__ import __author__ - -__author__ = __author__ - -__all__ = __all__ diff --git "a/tikon/trads/\340\256\244/Cultivo/ModExtern/DSSAT/fileC.py" "b/tikon/trads/\340\256\244/Cultivo/ModExtern/DSSAT/fileC.py" deleted file mode 100644 index 7fbd7c30..00000000 --- "a/tikon/trads/\340\256\244/Cultivo/ModExtern/DSSAT/fileC.py" +++ /dev/null @@ -1,10 +0,0 @@ -from tikon.Cultivo.ModExtern.DSSAT.fileC import FileC - - -class FileC(FileC): - - def leer(தன்): - return super().leer() - - def escribir(தன்): - return super().escribir() diff --git "a/tikon/trads/\340\256\244/Cultivo/ModExtern/DSSAT/fileCli.py" "b/tikon/trads/\340\256\244/Cultivo/ModExtern/DSSAT/fileCli.py" deleted file mode 100644 index ef2a836b..00000000 --- "a/tikon/trads/\340\256\244/Cultivo/ModExtern/DSSAT/fileCli.py" +++ /dev/null @@ -1,16 +0,0 @@ -from tikon.Cultivo.ModExtern.DSSAT.fileCli import FileCli - - -class FileCli(FileCli): - - def leer(தன், cod_clima): - return super().leer(cod_clima=cod_clima) - - def escribir(தன்): - return super().escribir() - - def decodar(தன், doc): - return super().decodar(doc=doc) - - def encodar(தன், doc_clima): - return super().encodar(doc_clima=doc_clima) diff --git "a/tikon/trads/\340\256\244/Cultivo/ModExtern/DSSAT/fileS.py" "b/tikon/trads/\340\256\244/Cultivo/ModExtern/DSSAT/fileS.py" deleted file mode 100644 index 86bf1056..00000000 --- "a/tikon/trads/\340\256\244/Cultivo/ModExtern/DSSAT/fileS.py" +++ /dev/null @@ -1,7 +0,0 @@ -from tikon.Cultivo.ModExtern.DSSAT.fileS import escribir -from tikon.Cultivo.ModExtern.DSSAT.fileS import decodar -from tikon.Cultivo.ModExtern.DSSAT.fileS import cargar_suelos_doc -from tikon.Cultivo.ModExtern.DSSAT.fileS import cargar_suelo -from tikon.Cultivo.ModExtern.DSSAT.fileS import DSSAT_a_Tikon - -DSSAT_a_Tikon = DSSAT_a_Tikon diff --git "a/tikon/trads/\340\256\244/Cultivo/ModExtern/DSSAT/fileW.py" "b/tikon/trads/\340\256\244/Cultivo/ModExtern/DSSAT/fileW.py" deleted file mode 100644 index 7a453a4c..00000000 --- "a/tikon/trads/\340\256\244/Cultivo/ModExtern/DSSAT/fileW.py" +++ /dev/null @@ -1,16 +0,0 @@ -from tikon.Cultivo.ModExtern.DSSAT.fileW import FileW - - -class FileW(FileW): - - def leer(தன், cod_clima): - return super().leer(cod_clima=cod_clima) - - def escribir(தன்): - return super().escribir() - - def decodar(தன், doc): - return super().decodar(doc=doc) - - def encodar(தன், doc_clima): - return super().encodar(doc_clima=doc_clima) diff --git "a/tikon/trads/\340\256\244/Cultivo/ModExtern/DSSAT/fileX.py" "b/tikon/trads/\340\256\244/Cultivo/ModExtern/DSSAT/fileX.py" deleted file mode 100644 index a0bd65fe..00000000 --- "a/tikon/trads/\340\256\244/Cultivo/ModExtern/DSSAT/fileX.py" +++ /dev/null @@ -1,16 +0,0 @@ -from tikon.Cultivo.ModExtern.DSSAT.fileX import FileX - - -class FileX(FileX): - - def leer(தன், documento): - return super().leer(documento=documento) - - def escribir(தன், carpeta): - return super().escribir(carpeta=carpeta) - - def decodar(தன், doc, sección): - return super().decodar(doc=doc, sección=sección) - - def encodar(தன், doc, sección): - return super().encodar(doc=doc, sección=sección) diff --git "a/tikon/trads/\340\256\244/Cultivo/NuevoCultivo.py" "b/tikon/trads/\340\256\244/Cultivo/NuevoCultivo.py" deleted file mode 100644 index 81e757a2..00000000 --- "a/tikon/trads/\340\256\244/Cultivo/NuevoCultivo.py" +++ /dev/null @@ -1,52 +0,0 @@ -from tikon.Cultivo.NuevoCultivo import Cultivo -from tikon.Cultivo.NuevoCultivo import EnvolturaDSSAT -from tikon.Cultivo.NuevoCultivo import EnvolturaModCult -from tikon.Cultivo.NuevoCultivo import dic_info -from tikon.Cultivo.NuevoCultivo import mods_cult - - -class Cultivo(Cultivo): - - def estab_modelo(தன், programa, cód_modelo, dir_trabajo): - return super().estab_modelo(programa=programa, cód_modelo=cód_modelo, dir_trabajo=dir_trabajo) - - def actualizar(தன்): - return super().actualizar() - - def dibujar(தன், mostrar=True, directorio=None, exper=None): - return super().dibujar(mostrar=mostrar, directorio=directorio, exper=exper) - - def especificar_apriori(தன்): - return super().especificar_apriori() - - def incrementar(தன், paso, i, detalles, extrn): - return super().incrementar(paso=paso, i=i, detalles=detalles, extrn=extrn) - - -class EnvolturaModCult(EnvolturaModCult): - - def prep_simul(தன், info_simul): - return super().prep_simul(info_simul=info_simul) - - def empezar_simul(தன்): - return super().empezar_simul() - - def incrementar(தன், paso, daño_plagas=None): - return super().incrementar(paso=paso, daño_plagas=daño_plagas) - - def leer_resultados(தன்): - return super().leer_resultados() - - -class EnvolturaDSSAT(EnvolturaDSSAT): - - def prep_simul(தன், info_simul): - return super().prep_simul(info_simul=info_simul) - - def leer_resultados(தன்): - return super().leer_resultados() - - -dic_info = dic_info - -mods_cult = mods_cult diff --git "a/tikon/trads/\340\256\244/Cultivo/VARIEDAD.py" "b/tikon/trads/\340\256\244/Cultivo/VARIEDAD.py" deleted file mode 100644 index 7189e55a..00000000 --- "a/tikon/trads/\340\256\244/Cultivo/VARIEDAD.py" +++ /dev/null @@ -1,4 +0,0 @@ -from tikon.Cultivo.VARIEDAD import Variedad - - -class Variedad(Variedad): diff --git "a/tikon/trads/\340\256\244/Cultivo/__init__.py" "b/tikon/trads/\340\256\244/Cultivo/__init__.py" deleted file mode 100644 index e69de29b..00000000 diff --git "a/tikon/trads/\340\256\244/Interfaz/Fechas.py" "b/tikon/trads/\340\256\244/Interfaz/Fechas.py" deleted file mode 100644 index 83a48317..00000000 --- "a/tikon/trads/\340\256\244/Interfaz/Fechas.py" +++ /dev/null @@ -1,15 +0,0 @@ -from tikon.Interfaz.Fechas import CholQij -from tikon.Interfaz.Fechas import Fecha -from tikon.Interfaz.Fechas import FechaUniversal - - -class FechaUniversal(FechaUniversal): - - -class Fecha(Fecha): - - def convertir(தன், fecha_abs): - return super().convertir(fecha_abs=fecha_abs) - - -class CholQij(CholQij): diff --git "a/tikon/trads/\340\256\244/Interfaz/IGU.py" "b/tikon/trads/\340\256\244/Interfaz/IGU.py" deleted file mode 100644 index 9433de20..00000000 --- "a/tikon/trads/\340\256\244/Interfaz/IGU.py" +++ /dev/null @@ -1,3 +0,0 @@ -from tikon.Interfaz.IGU import பயன்பாடு - -பயன்பாடு = பயன்பாடு diff --git "a/tikon/trads/\340\256\244/Interfaz/N\303\272meros.py" "b/tikon/trads/\340\256\244/Interfaz/N\303\272meros.py" deleted file mode 100644 index b80f957c..00000000 --- "a/tikon/trads/\340\256\244/Interfaz/N\303\272meros.py" +++ /dev/null @@ -1,3 +0,0 @@ -from tikon.Interfaz.Números import dic_trads - -dic_trads = dic_trads diff --git "a/tikon/trads/\340\256\244/Interfaz/aarambu.py" "b/tikon/trads/\340\256\244/Interfaz/aarambu.py" deleted file mode 100644 index 1e24d6e1..00000000 --- "a/tikon/trads/\340\256\244/Interfaz/aarambu.py" +++ /dev/null @@ -1,12 +0,0 @@ -from tikon.Interfaz.aarambu import botón_ayuda -from tikon.Interfaz.aarambu import botón_inic -from tikon.Interfaz.aarambu import logo -from tikon.Interfaz.aarambu import பக்கம்_ஆரம்பு - -பக்கம்_ஆரம்பு = பக்கம்_ஆரம்பு - -botón_inic = botón_inic - -botón_ayuda = botón_ayuda - -logo = logo diff --git "a/tikon/trads/\340\256\244/Interfaz/arup.py" "b/tikon/trads/\340\256\244/Interfaz/arup.py" deleted file mode 100644 index a135c720..00000000 --- "a/tikon/trads/\340\256\244/Interfaz/arup.py" +++ /dev/null @@ -1,15 +0,0 @@ -from tikon.Interfaz.arup import formato -from tikon.Interfaz.arup import அள்ளவுகள் -from tikon.Interfaz.arup import எழுத்து -from tikon.Interfaz.arup import நிறங்கள் -from tikon.Interfaz.arup import விவரங்கள் - -நிறங்கள் = நிறங்கள் - -அள்ளவுகள் = அள்ளவுகள் - -எழுத்து = எழுத்து - -விவரங்கள் = விவரங்கள் - -formato = formato diff --git "a/tikon/trads/\340\256\244/Interfaz/mozhigal.py" "b/tikon/trads/\340\256\244/Interfaz/mozhigal.py" deleted file mode 100644 index 5cfa69e9..00000000 --- "a/tikon/trads/\340\256\244/Interfaz/mozhigal.py" +++ /dev/null @@ -1,3 +0,0 @@ -from tikon.Interfaz.mozhigal import பக்கம்_மொழிகள் - -பக்கம்_மொழிகள் = பக்கம்_மொழிகள் diff --git "a/tikon/trads/\340\256\244/Interfaz/\340\244\205\340\244\250\340\245\201\340\244\252\340\245\215\340\244\260\340\244\257\340\245\213\340\244\227.py" "b/tikon/trads/\340\256\244/Interfaz/\340\244\205\340\244\250\340\245\201\340\244\252\340\245\215\340\244\260\340\244\257\340\245\213\340\244\227.py" deleted file mode 100644 index 891a0198..00000000 --- "a/tikon/trads/\340\256\244/Interfaz/\340\244\205\340\244\250\340\245\201\340\244\252\340\245\215\340\244\260\340\244\257\340\245\213\340\244\227.py" +++ /dev/null @@ -1,12 +0,0 @@ -from tikon.Interfaz.अनुप्रयोग import botón_ayuda -from tikon.Interfaz.अनुप्रयोग import botón_inic -from tikon.Interfaz.अनुप्रयोग import logo -from tikon.Interfaz.अनुप्रयोग import डिब्बा_शुरू - -डिब्बा_शुरू = डिब्बा_शुरू - -botón_inic = botón_inic - -botón_ayuda = botón_ayuda - -logo = logo diff --git "a/tikon/trads/\340\256\244/Interfaz/\340\244\206\340\244\260\340\245\201\340\244\252.py" "b/tikon/trads/\340\256\244/Interfaz/\340\244\206\340\244\260\340\245\201\340\244\252.py" deleted file mode 100644 index a03d202b..00000000 --- "a/tikon/trads/\340\256\244/Interfaz/\340\244\206\340\244\260\340\245\201\340\244\252.py" +++ /dev/null @@ -1,9 +0,0 @@ -from tikon.Interfaz.आरुप import colores -from tikon.Interfaz.आरुप import fuentes_texto -from tikon.Interfaz.आरुप import tamaños - -colores = colores - -tamaños = tamaños - -fuentes_texto = fuentes_texto diff --git "a/tikon/trads/\340\256\244/Interfaz/\340\256\256\340\256\244\340\257\215\340\256\244\340\256\277\340\256\257.py" "b/tikon/trads/\340\256\244/Interfaz/\340\256\256\340\256\244\340\257\215\340\256\244\340\256\277\340\256\257.py" deleted file mode 100644 index dba986f0..00000000 --- "a/tikon/trads/\340\256\244/Interfaz/\340\256\256\340\256\244\340\257\215\340\256\244\340\256\277\340\256\257.py" +++ /dev/null @@ -1,15 +0,0 @@ -from tikon.Interfaz.மத்திய import botón_மொழி -from tikon.Interfaz.மத்திய import logo -from tikon.Interfaz.மத்திய import கோப்பு_விரம்பங்கள் -from tikon.Interfaz.மத்திய import தப்பா_மேலே -from tikon.Interfaz.மத்திய import பக்கம்_மத்திய - -பக்கம்_மத்திய = பக்கம்_மத்திய - -தப்பா_மேலே = தப்பா_மேலே - -logo = logo - -கோப்பு_விரம்பங்கள் = கோப்பு_விரம்பங்கள் - -botón_மொழி = botón_மொழி diff --git "a/tikon/trads/\340\256\244/Manejo/Aplicaci\303\263n.py" "b/tikon/trads/\340\256\244/Manejo/Aplicaci\303\263n.py" deleted file mode 100644 index 5451020c..00000000 --- "a/tikon/trads/\340\256\244/Manejo/Aplicaci\303\263n.py" +++ /dev/null @@ -1,20 +0,0 @@ -from tikon.Manejo.Aplicación import Aplicación -from tikon.Manejo.Aplicación import Fertilizante -from tikon.Manejo.Aplicación import Fungicida -from tikon.Manejo.Aplicación import Herbicida -from tikon.Manejo.Aplicación import Insecticida - - -class Aplicación(Aplicación): - - -class Insecticida(Insecticida): - - -class Herbicida(Herbicida): - - -class Fungicida(Fungicida): - - -class Fertilizante(Fertilizante): diff --git "a/tikon/trads/\340\256\244/Manejo/__init__.py" "b/tikon/trads/\340\256\244/Manejo/__init__.py" deleted file mode 100644 index e69de29b..00000000 diff --git "a/tikon/trads/\340\256\244/Matem\303\241ticas/Arte.py" "b/tikon/trads/\340\256\244/Matem\303\241ticas/Arte.py" deleted file mode 100644 index 8b137891..00000000 --- "a/tikon/trads/\340\256\244/Matem\303\241ticas/Arte.py" +++ /dev/null @@ -1 +0,0 @@ - diff --git "a/tikon/trads/\340\256\244/Matem\303\241ticas/Calib.py" "b/tikon/trads/\340\256\244/Matem\303\241ticas/Calib.py" deleted file mode 100644 index 76ba020a..00000000 --- "a/tikon/trads/\340\256\244/Matem\303\241ticas/Calib.py" +++ /dev/null @@ -1,67 +0,0 @@ -from Matemáticas.Incert import VarCalib, VarPyMC2, VarPyMC3 -from tikon.Matemáticas.Calib import ModBayes -from tikon.Matemáticas.Calib import ModCalib -from tikon.Matemáticas.Calib import ModGLUE - - -class ModCalib(ModCalib): - - def calib(தன், rep, quema, extraer): - return super().calib(rep=rep, quema=quema, extraer=extraer) - - def guardar(தன், பெயர்=None): - return super().guardar(nombre=பெயர்) - - -class ModBayes(ModBayes): - - def calib(தன், rep, quema, extraer): - return super().calib(rep=rep, quema=quema, extraer=extraer) - - def guardar(தன், பெயர்=None): - return super().guardar(nombre=பெயர்) - - -class ModGLUE(ModGLUE): - - def calib(தன், rep, quema, extraer): - return super().calib(rep=rep, quema=quema, extraer=extraer) - - def guardar(தன், பெயர்=None): - return super().guardar(nombre=பெயர்) - - -class VarCalib(VarCalib): - - def obt_val(தன்): - return super().obt_val() - - def dibujar(தன்): - return super().dibujar() - - def traza(தன்): - return super().traza() - - -class VarPyMC2(VarPyMC2): - - def obt_val(தன்): - return super().obt_val() - - def dibujar(தன்): - return super().dibujar() - - def traza(தன்): - return super().traza() - - -class VarPyMC3(VarPyMC3): - - def obt_val(தன்): - return super().obt_val() - - def dibujar(தன்): - return super().dibujar() - - def traza(தன்): - return super().traza() diff --git "a/tikon/trads/\340\256\244/Matem\303\241ticas/Distribuciones.py" "b/tikon/trads/\340\256\244/Matem\303\241ticas/Distribuciones.py" deleted file mode 100644 index c82bd3f0..00000000 --- "a/tikon/trads/\340\256\244/Matem\303\241ticas/Distribuciones.py" +++ /dev/null @@ -1,9 +0,0 @@ -from tikon.Matemáticas.Distribuciones import dists -from tikon.Matemáticas.Distribuciones import inf -from tikon.Matemáticas.Distribuciones import pi - -inf = inf - -pi = pi - -dists = dists diff --git "a/tikon/trads/\340\256\244/Matem\303\241ticas/Ecuaciones.py" "b/tikon/trads/\340\256\244/Matem\303\241ticas/Ecuaciones.py" deleted file mode 100644 index 4b72445b..00000000 --- "a/tikon/trads/\340\256\244/Matem\303\241ticas/Ecuaciones.py" +++ /dev/null @@ -1,9 +0,0 @@ -from tikon.Matemáticas.Ecuaciones import ecs_cult -from tikon.Matemáticas.Ecuaciones import ecs_orgs -from tikon.Matemáticas.Ecuaciones import ecs_suelo - -ecs_orgs = ecs_orgs - -ecs_suelo = ecs_suelo - -ecs_cult = ecs_cult diff --git "a/tikon/trads/\340\256\244/Matem\303\241ticas/Experimentos.py" "b/tikon/trads/\340\256\244/Matem\303\241ticas/Experimentos.py" deleted file mode 100644 index cdd04f4d..00000000 --- "a/tikon/trads/\340\256\244/Matem\303\241ticas/Experimentos.py" +++ /dev/null @@ -1,112 +0,0 @@ -from tikon.Matemáticas.Experimentos import BD -from tikon.Matemáticas.Experimentos import BDsql -from tikon.Matemáticas.Experimentos import BDtexto -from tikon.Matemáticas.Experimentos import Experimento - - -class Experimento(Experimento): - - def obt_datos_rae(தன், egr, t_final=None, por_parcela=False): - return super().obt_datos_rae(egr=egr, t_final=t_final, por_parcela=por_parcela) - - def obt_parcelas(தன், tipo): - return super().obt_parcelas(tipo=tipo) - - def obt_info_parcelas(தன், parc): - return super().obt_info_parcelas(parc=parc) - - def superficies(தன், parc): - return super().superficies(parc=parc) - - def tiempo_final(தன், tipo): - return super().tiempo_final(tipo=tipo) - - def agregar_pobs(தன், archivo, col_tiempo, col_parc=None, cols_etps=None, factor=1, cód_na=None): - return super().agregar_pobs(archivo=archivo, col_tiempo=col_tiempo, col_parc=col_parc, cols_etps=cols_etps, - factor=factor, cód_na=cód_na) - - def agregar_muertes(தன், archivo, col_tiempo, col_parc=None, cols_etps=None, factor=1, cód_na=None): - return super().agregar_muertes(archivo=archivo, col_tiempo=col_tiempo, col_parc=col_parc, cols_etps=cols_etps, - factor=factor, cód_na=cód_na) - - def agregar_reprs(தன், archivo, col_tiempo, col_parc=None, cols_etps=None, factor=1, cód_na=None): - return super().agregar_reprs(archivo=archivo, col_tiempo=col_tiempo, col_parc=col_parc, cols_etps=cols_etps, - factor=factor, cód_na=cód_na) - - def agregar_trans_hacía(தன், archivo, col_tiempo, col_parc=None, cols_etps=None, factor=1, cód_na=None): - return super().agregar_trans_hacía(archivo=archivo, col_tiempo=col_tiempo, col_parc=col_parc, - cols_etps=cols_etps, factor=factor, cód_na=cód_na) - - def agregar_crec(தன், archivo, col_tiempo, col_parc=None, cols_etps=None, factor=1, cód_na=None): - return super().agregar_crec(archivo=archivo, col_tiempo=col_tiempo, col_parc=col_parc, cols_etps=cols_etps, - factor=factor, cód_na=cód_na) - - def agregar_parcelas(தன், archivo, col_nombres, col_superficies=None, col_polígonos=None, recalc_superf=False): - return super().agregar_parcelas(archivo=archivo, col_nombres=col_nombres, col_superficies=col_superficies, - col_polígonos=col_polígonos, recalc_superf=recalc_superf) - - def agregar_cultivos(தன், archivo): - return super().agregar_cultivos(archivo=archivo) - - def agregar_aplicaciones(தன், archivo): - return super().agregar_aplicaciones(archivo=archivo) - - def actualizar_fechas(தன், nueva_fecha_inic, días=None): - return super().actualizar_fechas(nueva_fecha_inic=nueva_fecha_inic, días=días) - - def mover_fechas(தன், dif): - return super().mover_fechas(dif=dif) - - def prep_archivo(தன், archivo): - return super().prep_archivo(archivo=archivo) - - -class BD(BD): - - def sacar_cols(தன்): - return super().sacar_cols() - - def obt_datos(தன், cols): - return super().obt_datos(cols=cols) - - def obt_datos_tx(தன், cols): - return super().obt_datos_tx(cols=cols) - - def obt_días(தன், col): - return super().obt_días(col=col) - - def calc_n_obs(தன்): - return super().calc_n_obs() - - def leer_fechas(lista_fechas): - return super().leer_fechas() - - -class BDtexto(BDtexto): - - def calc_n_obs(தன்): - return super().calc_n_obs() - - def obt_datos(தன், cols): - return super().obt_datos(cols=cols) - - def obt_datos_tx(தன், cols): - return super().obt_datos_tx(cols=cols) - - def sacar_cols(தன்): - return super().sacar_cols() - - -class BDsql(BDsql): - - def calc_n_obs(தன்): - return super().calc_n_obs() - - def obt_datos(தன், cols): - return super().obt_datos(cols=cols) - - def obt_datos_tx(தன், cols): - return super().obt_datos_tx(cols=cols) - - def sacar_cols(தன்): - return super().sacar_cols() diff --git "a/tikon/trads/\340\256\244/Matem\303\241ticas/Incert.py" "b/tikon/trads/\340\256\244/Matem\303\241ticas/Incert.py" deleted file mode 100644 index 8b137891..00000000 --- "a/tikon/trads/\340\256\244/Matem\303\241ticas/Incert.py" +++ /dev/null @@ -1 +0,0 @@ - diff --git "a/tikon/trads/\340\256\244/Matem\303\241ticas/Prueba_PyMC.py" "b/tikon/trads/\340\256\244/Matem\303\241ticas/Prueba_PyMC.py" deleted file mode 100644 index 7ac98153..00000000 --- "a/tikon/trads/\340\256\244/Matem\303\241ticas/Prueba_PyMC.py" +++ /dev/null @@ -1,26 +0,0 @@ -from tikon.Matemáticas.Prueba_PyMC import ModBayes -from tikon.Matemáticas.Prueba_PyMC import adaptivo -from tikon.Matemáticas.Prueba_PyMC import emp -from tikon.Matemáticas.Prueba_PyMC import fin -from tikon.Matemáticas.Prueba_PyMC import i -from tikon.Matemáticas.Prueba_PyMC import líms -from tikon.Matemáticas.Prueba_PyMC import n_iter - -i = i - -adaptivo = adaptivo - -emp = emp - -fin = fin - -n_iter = n_iter - - -class ModBayes(ModBayes): - - def calib(தன், rep, quema, extraer): - return super().calib(rep=rep, quema=quema, extraer=extraer) - - -líms = líms diff --git "a/tikon/trads/\340\256\244/Matem\303\241ticas/Pruebas.py" "b/tikon/trads/\340\256\244/Matem\303\241ticas/Pruebas.py" deleted file mode 100644 index 8ccc6189..00000000 --- "a/tikon/trads/\340\256\244/Matem\303\241ticas/Pruebas.py" +++ /dev/null @@ -1,12 +0,0 @@ -from tikon.Matemáticas.Pruebas import con_errores -from tikon.Matemáticas.Pruebas import dibujar -from tikon.Matemáticas.Pruebas import dists -from tikon.Matemáticas.Pruebas import n_rep - -n_rep = n_rep - -dibujar = dibujar - -con_errores = con_errores - -dists = dists diff --git "a/tikon/trads/\340\256\244/Matem\303\241ticas/Unidades.py" "b/tikon/trads/\340\256\244/Matem\303\241ticas/Unidades.py" deleted file mode 100644 index e52a304b..00000000 --- "a/tikon/trads/\340\256\244/Matem\303\241ticas/Unidades.py" +++ /dev/null @@ -1,10 +0,0 @@ -from tikon.Matemáticas.Unidades import Unidad - - -class Unidad(Unidad): - - def agregar(dic_orig, dic_nuevo): - return super().agregar(dic_nuevo=dic_nuevo) - - def texto_a_unidades(texto): - return super().texto_a_unidades() diff --git "a/tikon/trads/\340\256\244/Matem\303\241ticas/__init__.py" "b/tikon/trads/\340\256\244/Matem\303\241ticas/__init__.py" deleted file mode 100644 index 3ef83323..00000000 --- "a/tikon/trads/\340\256\244/Matem\303\241ticas/__init__.py" +++ /dev/null @@ -1,3 +0,0 @@ -from tikon.Matemáticas.__init__ import __author__ - -__author__ = __author__ diff --git "a/tikon/trads/\340\256\244/Paisaje/NuevoPaisaje.py" "b/tikon/trads/\340\256\244/Paisaje/NuevoPaisaje.py" deleted file mode 100644 index e8a5a647..00000000 --- "a/tikon/trads/\340\256\244/Paisaje/NuevoPaisaje.py" +++ /dev/null @@ -1,16 +0,0 @@ -from tikon.Paisaje.NuevoPaisaje import Paisaje - - -class Paisaje(Paisaje): - - def actualizar(தன்): - return super().actualizar() - - def dibujar(தன், mostrar=True, directorio=None, exper=None): - return super().dibujar(mostrar=mostrar, directorio=directorio, exper=exper) - - def especificar_apriori(தன்): - return super().especificar_apriori() - - def incrementar(தன், paso, i, detalles, extrn): - return super().incrementar(paso=paso, i=i, detalles=detalles, extrn=extrn) diff --git "a/tikon/trads/\340\256\244/Paisaje/PAISAJE.py" "b/tikon/trads/\340\256\244/Paisaje/PAISAJE.py" deleted file mode 100644 index 530b9810..00000000 --- "a/tikon/trads/\340\256\244/Paisaje/PAISAJE.py" +++ /dev/null @@ -1,13 +0,0 @@ -from tikon.Paisaje.PAISAJE import Paisaje - - -class Paisaje(Paisaje): - - def inic(தன், datos): - return super().inic(datos=datos) - - def leer_documento(documento): - return super().leer_documento() - - def simul(தன், fecha_init, tiempo_simul, paso): - return super().simul(fecha_init=fecha_init, tiempo_simul=tiempo_simul, paso=paso) diff --git "a/tikon/trads/\340\256\244/Paisaje/PARCELA.py" "b/tikon/trads/\340\256\244/Paisaje/PARCELA.py" deleted file mode 100644 index a8dbf50c..00000000 --- "a/tikon/trads/\340\256\244/Paisaje/PARCELA.py" +++ /dev/null @@ -1,10 +0,0 @@ -from tikon.Paisaje.PARCELA import Parcela - - -class Parcela(Parcela): - - def ejec(தன்): - return super().ejec() - - def incr(தன், paso): - return super().incr(paso=paso) diff --git "a/tikon/trads/\340\256\244/Paisaje/SIG.py" "b/tikon/trads/\340\256\244/Paisaje/SIG.py" deleted file mode 100644 index 29099565..00000000 --- "a/tikon/trads/\340\256\244/Paisaje/SIG.py" +++ /dev/null @@ -1,7 +0,0 @@ -from tikon.Paisaje.SIG import Parcela - - -class Parcela(Parcela): - - def calcular_área(தன்): - return super().calcular_área() diff --git "a/tikon/trads/\340\256\244/Paisaje/__init__.py" "b/tikon/trads/\340\256\244/Paisaje/__init__.py" deleted file mode 100644 index e69de29b..00000000 diff --git "a/tikon/trads/\340\256\244/__init__.py" "b/tikon/trads/\340\256\244/__init__.py" deleted file mode 100644 index 0ac8490a..00000000 --- "a/tikon/trads/\340\256\244/__init__.py" +++ /dev/null @@ -1,27 +0,0 @@ -from tikon import __author__ -from tikon import __correo__ -from tikon import __email__ -from tikon import __version__ -from tikon import archivo_ctrls -from tikon import ctrls_cambiados -from tikon import dirs_auto -from tikon import dirs_modelos -from tikon import mods_faltan - -எழுத்தாளர் = __author__ - -__email__ = __email__ - -__correo__ = __correo__ - -__version__ = __version__ - -archivo_ctrls = archivo_ctrls - -dirs_modelos = dirs_modelos - -dirs_auto = dirs_auto - -mods_faltan = mods_faltan - -ctrls_cambiados = ctrls_cambiados diff --git "a/tikon/trads/\340\256\244/\340\256\265\340\257\207_\340\256\232\340\257\201_\340\256\265\340\256\262\340\257\210/Enfermedad.py" "b/tikon/trads/\340\256\244/\340\256\265\340\257\207_\340\256\232\340\257\201_\340\256\265\340\256\262\340\257\210/Enfermedad.py" deleted file mode 100644 index 01ed8f39..00000000 --- "a/tikon/trads/\340\256\244/\340\256\265\340\257\207_\340\256\232\340\257\201_\340\256\265\340\256\262\340\257\210/Enfermedad.py" +++ /dev/null @@ -1,15 +0,0 @@ -from tikon.RAE.Enfermedad import DosHuéspedes -from tikon.RAE.Enfermedad import Enfermedad -from tikon.RAE.Enfermedad import EnfermedadHoja - - -class Enfermedad(Enfermedad): - - def infecta(தன், etp_símismo, etp_huésped, huésped): - return super().infecta(etp_símismo=etp_símismo, etp_huésped=etp_huésped, huésped=huésped) - - -class EnfermedadHoja(EnfermedadHoja): - - -class DosHuéspedes(DosHuéspedes): diff --git "a/tikon/trads/\340\256\244/\340\256\265\340\257\207_\340\256\232\340\257\201_\340\256\265\340\256\262\340\257\210/Gen_organismos.py" "b/tikon/trads/\340\256\244/\340\256\265\340\257\207_\340\256\232\340\257\201_\340\256\265\340\256\262\340\257\210/Gen_organismos.py" deleted file mode 100644 index 8b137891..00000000 --- "a/tikon/trads/\340\256\244/\340\256\265\340\257\207_\340\256\232\340\257\201_\340\256\265\340\256\262\340\257\210/Gen_organismos.py" +++ /dev/null @@ -1 +0,0 @@ - diff --git "a/tikon/trads/\340\256\244/\340\256\265\340\257\207_\340\256\232\340\257\201_\340\256\265\340\256\262\340\257\210/Organismo.py" "b/tikon/trads/\340\256\244/\340\256\265\340\257\207_\340\256\232\340\257\201_\340\256\265\340\256\262\340\257\210/Organismo.py" deleted file mode 100644 index 17d8b207..00000000 --- "a/tikon/trads/\340\256\244/\340\256\265\340\257\207_\340\256\232\340\257\201_\340\256\265\340\256\262\340\257\210/Organismo.py" +++ /dev/null @@ -1,30 +0,0 @@ -from tikon.RAE.Organismo import Organismo - - -class Organismo(Organismo): - - def actualizar(தன்): - return super().actualizar() - - def añadir_etapa(தன், பெயர், posición, ecuaciones, lím_error=0.1): - return super().añadir_etapa(nombre=பெயர், posición=posición, ecuaciones=ecuaciones, lím_error=lím_error) - - def quitar_etapa(தன், பெயர்): - return super().quitar_etapa(nombre=பெயர்) - - def aplicar_ecuación(தன், etapa, tipo_ec): - return super().aplicar_ecuación(etapa=etapa, tipo_ec=tipo_ec) - - def victimiza(தன், víctima, etps_símismo=None, etps_víctima=None, método="presa", etp_sale=None): - return super().victimiza(víctima=víctima, etps_símismo=etps_símismo, etps_víctima=etps_víctima, método=método, - etp_sale=etp_sale) - - def novictimiza(தன், víctima, etps_símismo=None, etps_víctima=None, método="presa"): - return super().novictimiza(víctima=víctima, etps_símismo=etps_símismo, etps_víctima=etps_víctima, método=método) - - def especificar_apriori(தன், etapa, ubic_parám, rango, certidumbre, org_inter=None, etp_inter=None, dibujar=False): - return super().especificar_apriori(etapa=etapa, ubic_parám=ubic_parám, rango=rango, certidumbre=certidumbre, - org_inter=org_inter, etp_inter=etp_inter, dibujar=dibujar) - - def verificar_ecs(தன், ecs, etp): - return super().verificar_ecs(ecs=ecs, etp=etp) diff --git "a/tikon/trads/\340\256\244/\340\256\265\340\257\207_\340\256\232\340\257\201_\340\256\265\340\256\262\340\257\210/Planta.py" "b/tikon/trads/\340\256\244/\340\256\265\340\257\207_\340\256\232\340\257\201_\340\256\265\340\256\262\340\257\210/Planta.py" deleted file mode 100644 index 1c54bea6..00000000 --- "a/tikon/trads/\340\256\244/\340\256\265\340\257\207_\340\256\232\340\257\201_\340\256\265\340\256\262\340\257\210/Planta.py" +++ /dev/null @@ -1,25 +0,0 @@ -from tikon.RAE.Planta import Completa -from tikon.RAE.Planta import Hojas -from tikon.RAE.Planta import HojasRaices -from tikon.RAE.Planta import Planta - - -class Planta(Planta): - - def fijar_densidad(தன், densidad, parte="hoja"): - return super().fijar_densidad(densidad=densidad, parte=parte) - - def estimar_densidad(தன், rango, certidumbre, parte="hoja"): - return super().estimar_densidad(rango=rango, certidumbre=certidumbre, parte=parte) - - def externalizar(தன்): - return super().externalizar() - - -class Hojas(Hojas): - - -class HojasRaices(HojasRaices): - - -class Completa(Completa): diff --git "a/tikon/trads/\340\256\244/\340\256\265\340\257\207_\340\256\232\340\257\201_\340\256\265\340\256\262\340\257\210/RedAE.py" "b/tikon/trads/\340\256\244/\340\256\265\340\257\207_\340\256\232\340\257\201_\340\256\265\340\256\262\340\257\210/RedAE.py" deleted file mode 100644 index 8459eeb4..00000000 --- "a/tikon/trads/\340\256\244/\340\256\265\340\257\207_\340\256\232\340\257\201_\340\256\265\340\256\262\340\257\210/RedAE.py" +++ /dev/null @@ -1,28 +0,0 @@ -from tikon.RAE.RedAE import Red - - -class Red(Red): - - def añadir_org(தன், organismo): - return super().añadir_org(organismo=organismo) - - def quitar_org(தன், organismo): - return super().quitar_org(organismo=organismo) - - def actualizar(தன்): - return super().actualizar() - - def dibujar(தன், mostrar=True, directorio=None, exper=None, n_líneas=0, incert="componentes"): - return super().dibujar(mostrar=mostrar, directorio=directorio, exper=exper, n_líneas=n_líneas, incert=incert) - - def incrementar(தன், paso, i, detalles, mov=False, extrn=None): - return super().incrementar(paso=paso, i=i, detalles=detalles, mov=mov, extrn=extrn) - - def añadir_exp(தன், experimento, corresp=None, corresp_pobs=None, corresp_crec=None, corresp_repr=None, - corresp_trans=None, corresp_muertes=None): - return super().añadir_exp(experimento=experimento, corresp=corresp, corresp_pobs=corresp_pobs, - corresp_crec=corresp_crec, corresp_repr=corresp_repr, corresp_trans=corresp_trans, - corresp_muertes=corresp_muertes) - - def especificar_apriori(தன்): - return super().especificar_apriori() diff --git "a/tikon/trads/\340\256\244/\340\256\265\340\257\207_\340\256\232\340\257\201_\340\256\265\340\256\262\340\257\210/__init__.py" "b/tikon/trads/\340\256\244/\340\256\265\340\257\207_\340\256\232\340\257\201_\340\256\265\340\256\262\340\257\210/__init__.py" deleted file mode 100644 index e69de29b..00000000 diff --git "a/tikon/trads/\340\256\244/\340\256\265\340\257\207_\340\256\232\340\257\201_\340\256\265\340\256\262\340\257\210/\340\256\252\340\257\202\340\256\232\340\257\215\340\256\232\340\256\277.py" "b/tikon/trads/\340\256\244/\340\256\265\340\257\207_\340\256\232\340\257\201_\340\256\265\340\256\262\340\257\210/\340\256\252\340\257\202\340\256\232\340\257\215\340\256\232\340\256\277.py" deleted file mode 100644 index 536927ea..00000000 --- "a/tikon/trads/\340\256\244/\340\256\265\340\257\207_\340\256\232\340\257\201_\340\256\265\340\256\262\340\257\210/\340\256\252\340\257\202\340\256\232\340\257\215\340\256\232\340\256\277.py" +++ /dev/null @@ -1,42 +0,0 @@ -from tikon.RAE.Insecto import Esfécido -from tikon.RAE.Insecto import Insecto -from tikon.RAE.Insecto import MetamCompleta -from tikon.RAE.Insecto import MetamIncompleta -from tikon.RAE.Insecto import Parasitoide -from tikon.RAE.Insecto import Sencillo - - -class பூச்சி(Insecto): - - def தின்றுகிறது(தன், இரை, இரை_படி=None, தின்றவர்_படி=None): - return தன்.secome(presa=இரை, etps_presa=இரை_படி, etps_depred=தின்றவர்_படி) - - def தின்றாது(தன், இரை, இரை_படி=None, தின்றவர்_படி=None): - return தன்.nosecome(presa=இரை, etps_presa=இரை_படி, etps_depred=தின்றவர்_படி) - - -class Sencillo(Sencillo): - - -class MetamCompleta(MetamCompleta): - - -class MetamIncompleta(MetamIncompleta): - - -class Parasitoide(Parasitoide): - - def parasita(தன், víctima, etps_infec, etp_sale): - return super().parasita(víctima=víctima, etps_infec=etps_infec, etp_sale=etp_sale) - - def noparasita(தன், víctima, etps_infec=None): - return super().noparasita(víctima=víctima, etps_infec=etps_infec) - - -class Esfécido(Esfécido): - - def captura(தன், víctima, etps_víc): - return super().captura(víctima=víctima, etps_víc=etps_víc) - - def nocaptura(தன், víctima, etps_víc=None): - return super().nocaptura(víctima=víctima, etps_víc=etps_víc)