[[PageOutline]]
= Identificación ARIMA automática bayesiana =

La identificación ARIMA automática bayesiana consiste en la búsqueda de un modelo estadístico adecuado para un serie temporal correspondiente a un proceso estocástico lineal, estacionario o no.

== Obtención de series homocedásticas ==
En el directorio [source:tolp/OfficialTolArchiveNetwork/ArimaTools/doc/wiki/Identify/MacroEconomicSeries/ MacroEconomicSeries] está disponible un ejemplo TOL sencillo de uso de esta potente y compleja herramienta, en el que se identifican modelos ARIMA regulares para series macroeconómicas anuales de distintos países.

Antes de nada hay que obtener los datos originales y si fuera necesario transformarlos hasta conseguir que la serie sea homocedástica, es decir, la transformación de Box-Cox se supone ya aplicada. Existen formas de automatizar esto pero en la práctica sólo se usan la transformación logarítmica cuando los datos son positivos por naturaleza y la identidad en caso contrario así que no merece la pena adentrarse en este problema.

{{{
#!java
//////////////////////////////////////////////////////////////////////////////
//Carga de datos
//////////////////////////////////////////////////////////////////////////////
//Nuestras series ya están en una métrica homocedástica
// GDP: tasa de variación anual del producto interior bruto
// UNM: porcentaje de desempleados en la población activa
// POP: tasa de variación anual del número de habitantes
Set If(ObjectExist("Set","MacroEconomicSeries"), MacroEconomicSeries,
        MacroEconomicSeries = { Include("MacroEconomicSeries.oza") });
Real If(ObjectExist("Real","concept"), concept, concept= 1); //GDP
Real If(ObjectExist("Real","country"), country, country=12); //ESP

Serie output = MacroEconomicSeries[concept][country];
Text name = Name(MacroEconomicSeries[concept][country]);
}}}

== Configuración de los rangos de los grados de los polinomios ARIMA ==
La identificación de las estructuras ARIMA es equivalente a la determinación de lso grados de los polinomios 
que intervienen en ella, y aunque en principio no hay ninguna limitación en dichos grados más allá del tamaño 
de la serie, en la práctica es conveniente acotarlos superiormente por razones de eficiencia. Pr este motivo
definiremos los rangos de grados ARIMA para cada periodicidad. En este caso sólo hay factor regular con periodo 1:
{{{
#!java
Set ARIMADegRange = { [[
 @ARIMADegreeRangeStruct(
  Period=1,MinAR=0,MaxAR=5,MinMA=0,MaxMA=5,MinDIF=0,MaxDIF=2 ) 
]] };
}}}

== Filtrado de efectos exógenos ==
Dada una serie homocedástica de datos reales (la transformación de Box-Cox se supone ya aplicada), lo primero que hay que hacer es filtrar los efectos exógenos mediante un conjunto de inputs lineales dados por el analista y, si existen, un conjunto de outliers detectados automáticamente mediante AIA. Para ello se requiere de un primer proceso de sobrediferenciación muy básico. En este caso no se proponen inputs.
{{{
#!java
//////////////////////////////////////////////////////////////////////////////
//Filtro lineal y de outliers
//////////////////////////////////////////////////////////////////////////////
//Configuración por defecto del filtro lineal y de outliers
NameBlock flt.cfg = ArimaTools::Filter::@Config::Default(?);
//Adaptación de la configuración al caso particular
Real flt.cfg::optMaxOrder := 2;
//Filtrado de inputs lineales y AIA
NameBlock filter = ArimaTools::Filter::OverDifAIALinear(
  Serie output,        //Serie output a modelar
  Set ARIMADegRange,   //Rangos de grados ARIMA
  Set InputTry,        //Inputs tentativos
  NameBlock flt.cfg);  //Configuración del filtro
}}}

== Identificador de raíces unitarias ==
A continuación comienza propiamente la identificación del modelo empezando por las raíces 
unitarias o polinomios de diferenciación-integración. Se trata de medir la probabilidad 
de que cada uno de los polinomios propuestos de lugar a un ruido diferenciado estacionario.
Este proceso se basa en modelos lineales que son aproximaciones autoregresivas del modelo 
ARIMA conjunto con las que se generan miles de simulaciones de la distribución t de Student 
multivariante asociada a los parámetros, para calcular finalmente la probabilidad de 
estacionariedad como el ratio de polinomios con todas las raíces fuera del círculo unidad,
ponderando en cada caso por el inverso del volumen de la región de estacionariedad.
En el caso regular se trata de un método asintóticamente exacto de medir esta
probablidad. Si hay estacionalidad(es) entonces sólo es una aproximación pero se ha 
visto empíricamente que funciona bastante bien salvo en algunos casos patológicos.
El resultado de este proceso es un ''ranking'' de los polinomios propuestos 
ordenados de mayor a menor probabilidad de estacionariedad.
{{{
#!java
//////////////////////////////////////////////////////////////////////////////
//Identificador de raíces unitarias.
//////////////////////////////////////////////////////////////////////////////
//Configuración por defecto
NameBlock ur.cfg = ArimaTools::UnitRoot::@Config::Default(?);
//Adaptación de la configuración al caso particular
//Número de simulaciones por polinonio propuesto
Real ur.cfg::sampleLength := 10000; 
//Se descartan los polinomios con menos del 0.01% de probabilidad
Real ur.cfg::minProb := 1E-4; 
//Identificador de raíces unitarias que construye un ranking ordenado según 
//la probabilidad de cada una de las opciones.
NameBlock id.ur = ArimaTools::UnitRoot::Identify(
  filter::_.filtered, //Serie filtrada de efectos exógenos
  ARIMADegRange,      //Rangos de grados ARIMA
  ur.cfg);            //Configuración
}}}

== Identificación de los grados ARMA ==

Cada par de polinomios regulares AR y MA lleva asociado una ACF teórica única que es posible comparar 
con las ACF muestrales para calcular la verosimilitud de un modelo ARMA regular con respecto a esas 
ACF muestrales. Integrando dicha verosimilitud por un prior no informativo o el que se considere 
oportuno, en la región de estacionariedad asociada al par de grados {{{(p,q)}}} que definen una estrutura 
ARMA regular, se puede calcular la probabilidad a posteriori de dicha estructura.

Dentro del paquete ArimaTools se ofrecen distintos métodos para el cálculo de esta integral, todos 
ellso basados en simulación de modelos ARMA estacionarios.

Para cada polinomio de diferencias con probabilidad significativa se tomará la ACF muestral del ruido 
diferenciado, y para cada factor regular o estacional, se extraerán las autocorrelaciones de órdenes 
múltiplos de la periodicidad {{{s}}} correspondiente que no sean satélites de las periodicidades superiores 
para minimizar la contaminación entre los distintos factores. Para cada uno de estos factores se 
calculará la probabilidad de cada par de grados {{{(p*s,q*s)}}} como si se tratara de un modelo regular 
{{{(p,q)}}}.

Finalmente se obtendrán las probabilidades del producto cartesiano de los pares {{{(p*s,q*s)}}} 
correspondientes a cada polinomio de diferencias multiplicando las probabilidades de dichos pares
por la probabilidad de las raíces unitarias calculada en el apartado anterior. De esta forma 
se obtiene un ''ranking'' de modelos ARIMA ordenados por probabilidad de mayor a menor.

{{{
#!java
//////////////////////////////////////////////////////////////////////////////
//Identificador de los grados de los polinomios ARMA
//////////////////////////////////////////////////////////////////////////////
//Configuración por defecto
NameBlock arma.cfg = ArimaTools::@ARMA.Sampler.ACF.Reg.Config::Default(?);
//Adaptación de la configuración al caso particular
Text arma.cfg::sampler := ArimaTools::@ARMA.Sampler.ACF.Reg.Config::Options::
  Sampler::ImportanceSampling;
Text arma.cfg::acfCov := ArimaTools::@ARMA.Sampler.ACF.Reg.Config::Options::
  ACFCov::TheoricalBartlett;
Real arma.cfg::sampleLength := 200;
//Identificador de raíces ARMA que construye un ranking ordenado según 
//la probabilidad de cada una de las opciones.
NameBlock id.arma = ArimaTools::@ARMA.Splitter.ACF::Identify(
  filter::_.filtered, //Serie filtrada de efectos exógenos
  ARIMADegRange,      //Rangos de grados ARIMA
  id.ur,              //Ranking de raíces unitarias
  arma.cfg);          //Configuración
}}}

== Estimación y diagnosis de la estructura ARIMA completa ==
El último paso es estimar los modelos ordenados por probabilidad sobre la serie 
homocedástica original incorporando los inputs de usuario y el AIA encontrados en 
el filtro inicial. Una vez estimados hay que efectuar la diagnosis de calidad del
mismo que consiste en comprobar qeu efectivamente cumple los requisitos de un modelo
ARIMA
 * hipótesis sobre los residuos
   * siguen una distribución normal de media nula
   * son independendientes entre sí
 * hipótesis de los parámetros
   * deben ser significativos
   * no pueden ser colineales dos a dos ni estar demasiado cerca (correlación alta)
   * no pueden ser multicolineales
   * los polinomios AR y MA resultantes deben tener todas las raíces fuera del círculo unidad

Esto se traduce en una batería de tests para los que se obtiene la potencia del mismo 
que es siempre un número entre 0 y 1. Para cada uno se establecen dos límites, aceptación 
y rechazo, mediante los cuales se califica el test con el siguiente criterio
 * Si la potencia es menor que el límite de aceptación se clasifica el test como bueno.
 * Si se sitúa entre el límite de aceptación y el de rechazo el tets es aceptable o regular.
 * Si sobrepasa el límite de rechazo se dice que el resultado del test es malo.
El modelo se calificará como el peor de los tests de la batería de diagnosis.
Entre los modelos de igual calificación se utilizará el criterio de Swartz para establecer
las prioridades de ordenación.

{{{
#!java
//////////////////////////////////////////////////////////////////////////////
//Estimación y diagnosis de la estructura ARIMA completa
//////////////////////////////////////////////////////////////////////////////
//Configuración por defecto
NameBlock arima.cfg = ArimaTools::ARIMA.Identifier::@Config::Default(?);
//Adaptación de la configuración al caso particular
//Los modelos de este ejemplo son pequeños y rápidos de estimar por lo que 
//no hay porqué poner un límite de intentos fallidos.
Real arima.cfg::maxTry := 1/0;
//Si al llegar a 20 intentos ya hay uno bueno paramos
Real arima.cfg::maxTryForGood := 20;
//Si al llegar a 50 intentos ya hay uno aceptable paramos
Real arima.cfg::maxTryForAcceptable := 50;
//Identificador de la estructura ARIMA que recorre el ranking propuesto
//estimando y diagnosticando cada modelo hasta que se cumplen las
//condiciones mínimas exigidas o se aborta el proceso y devuelve el mejor 
//modelo encontrado hasta ese momento.
Set id.arima = ArimaTools::ARIMA.Identifier::Identify(
// output, id.arma::ranking, (filter::_.model::Definition)->Input, Mercadona::Config::arima.cfg);
 output, id.arma::ranking, filter::_.model::Definition->Input, arima.cfg);
}}}