├── images ├── wn.png ├── ann.png ├── autoc.png └── diagramaflujo.png ├── examples ├── estudio_01_simple │ ├── pasajeros_1960.predict │ ├── pasajeros_1949_1959.dat │ └── mineria_series_temporales.R ├── estudio_03_completo │ ├── serie1_lm.png │ ├── serie1_stl.png │ ├── serie1_final.png │ ├── serie1_acf_pacf.png │ ├── serie1_inicial.png │ ├── serie1_acf_pacf_diff │ ├── serie1_descompose.png │ ├── serie1_acf_pacf_diff.png │ ├── serie1.dat │ └── analisis_serie1.R ├── estudio_04_completo │ ├── serie2_lm.png │ ├── serie2_stl.png │ ├── serie2_acf_pacf.png │ ├── serie2_diff_acf.png │ ├── serie2_inicial.png │ ├── serie2_predict.png │ ├── serie2_descompose.png │ ├── serie2_logged_diffed.png │ ├── serie2_serie_estacion.png │ ├── serie2.dat │ └── analisis_serie2.R ├── pruebas_simples │ ├── basico_alisados.R │ ├── basico_timeseries.R │ ├── basico_multivariantes.R │ ├── basico_redesneuronales.R │ ├── basico_crossvalidation.R │ ├── basico_imputation.R │ └── basico_comparacion.R ├── estudio_02_simple │ ├── serie2.dat │ ├── serie1.dat │ └── st2.R └── analisis_simple_co2 │ └── co2.csv ├── DeepLearningTimeSeries └── README.md ├── analisisgrafico ├── PPStech.csv └── analisisgrafico.md └── README.md /images/wn.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/manuparra/seriestemporales/HEAD/images/wn.png -------------------------------------------------------------------------------- /images/ann.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/manuparra/seriestemporales/HEAD/images/ann.png -------------------------------------------------------------------------------- /images/autoc.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/manuparra/seriestemporales/HEAD/images/autoc.png -------------------------------------------------------------------------------- /examples/estudio_01_simple/pasajeros_1960.predict: -------------------------------------------------------------------------------- 1 | 417 391 419 461 472 535 622 606 508 461 390 432 2 | -------------------------------------------------------------------------------- /images/diagramaflujo.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/manuparra/seriestemporales/HEAD/images/diagramaflujo.png -------------------------------------------------------------------------------- /DeepLearningTimeSeries/README.md: -------------------------------------------------------------------------------- 1 | # Aproximación al análisis, estudio y predicción de Series temporales con DeepLearning 2 | 3 | -------------------------------------------------------------------------------- /examples/estudio_03_completo/serie1_lm.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/manuparra/seriestemporales/HEAD/examples/estudio_03_completo/serie1_lm.png -------------------------------------------------------------------------------- /examples/estudio_03_completo/serie1_stl.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/manuparra/seriestemporales/HEAD/examples/estudio_03_completo/serie1_stl.png -------------------------------------------------------------------------------- /examples/estudio_04_completo/serie2_lm.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/manuparra/seriestemporales/HEAD/examples/estudio_04_completo/serie2_lm.png -------------------------------------------------------------------------------- /examples/estudio_04_completo/serie2_stl.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/manuparra/seriestemporales/HEAD/examples/estudio_04_completo/serie2_stl.png -------------------------------------------------------------------------------- /examples/pruebas_simples/basico_alisados.R: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/manuparra/seriestemporales/HEAD/examples/pruebas_simples/basico_alisados.R -------------------------------------------------------------------------------- /examples/estudio_03_completo/serie1_final.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/manuparra/seriestemporales/HEAD/examples/estudio_03_completo/serie1_final.png -------------------------------------------------------------------------------- /examples/pruebas_simples/basico_timeseries.R: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/manuparra/seriestemporales/HEAD/examples/pruebas_simples/basico_timeseries.R -------------------------------------------------------------------------------- /examples/estudio_03_completo/serie1_acf_pacf.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/manuparra/seriestemporales/HEAD/examples/estudio_03_completo/serie1_acf_pacf.png -------------------------------------------------------------------------------- /examples/estudio_03_completo/serie1_inicial.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/manuparra/seriestemporales/HEAD/examples/estudio_03_completo/serie1_inicial.png -------------------------------------------------------------------------------- /examples/estudio_04_completo/serie2_acf_pacf.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/manuparra/seriestemporales/HEAD/examples/estudio_04_completo/serie2_acf_pacf.png -------------------------------------------------------------------------------- /examples/estudio_04_completo/serie2_diff_acf.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/manuparra/seriestemporales/HEAD/examples/estudio_04_completo/serie2_diff_acf.png -------------------------------------------------------------------------------- /examples/estudio_04_completo/serie2_inicial.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/manuparra/seriestemporales/HEAD/examples/estudio_04_completo/serie2_inicial.png -------------------------------------------------------------------------------- /examples/estudio_04_completo/serie2_predict.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/manuparra/seriestemporales/HEAD/examples/estudio_04_completo/serie2_predict.png -------------------------------------------------------------------------------- /examples/pruebas_simples/basico_multivariantes.R: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/manuparra/seriestemporales/HEAD/examples/pruebas_simples/basico_multivariantes.R -------------------------------------------------------------------------------- /examples/estudio_03_completo/serie1_acf_pacf_diff: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/manuparra/seriestemporales/HEAD/examples/estudio_03_completo/serie1_acf_pacf_diff -------------------------------------------------------------------------------- /examples/estudio_03_completo/serie1_descompose.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/manuparra/seriestemporales/HEAD/examples/estudio_03_completo/serie1_descompose.png -------------------------------------------------------------------------------- /examples/estudio_04_completo/serie2_descompose.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/manuparra/seriestemporales/HEAD/examples/estudio_04_completo/serie2_descompose.png -------------------------------------------------------------------------------- /examples/pruebas_simples/basico_redesneuronales.R: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/manuparra/seriestemporales/HEAD/examples/pruebas_simples/basico_redesneuronales.R -------------------------------------------------------------------------------- /examples/estudio_03_completo/serie1_acf_pacf_diff.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/manuparra/seriestemporales/HEAD/examples/estudio_03_completo/serie1_acf_pacf_diff.png -------------------------------------------------------------------------------- /examples/estudio_04_completo/serie2_logged_diffed.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/manuparra/seriestemporales/HEAD/examples/estudio_04_completo/serie2_logged_diffed.png -------------------------------------------------------------------------------- /examples/estudio_04_completo/serie2_serie_estacion.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/manuparra/seriestemporales/HEAD/examples/estudio_04_completo/serie2_serie_estacion.png -------------------------------------------------------------------------------- /examples/estudio_01_simple/pasajeros_1949_1959.dat: -------------------------------------------------------------------------------- 1 | 112 118 132 129 121 135 148 148 136 119 104 118 2 | 115 126 141 135 125 149 170 170 158 133 114 140 3 | 145 150 178 163 172 178 199 199 184 162 146 166 4 | 171 180 193 181 183 218 230 242 209 191 172 194 5 | 196 196 236 235 229 243 264 272 237 211 180 201 6 | 204 188 235 227 234 264 302 293 259 229 203 229 7 | 242 233 267 269 270 315 364 347 312 274 237 278 8 | 284 277 317 313 318 374 413 405 355 306 271 306 9 | 315 301 356 348 355 422 465 467 404 347 305 336 10 | 340 318 362 348 363 435 491 505 404 359 310 337 11 | 360 342 406 396 420 472 548 559 463 407 362 405 12 | -------------------------------------------------------------------------------- /examples/estudio_02_simple/serie2.dat: -------------------------------------------------------------------------------- 1 | 580.38 581.86 580.97 580.8 579.79 2 | 580.39 580.42 580.82 581.4 581.32 3 | 581.44 581.68 581.17 580.53 580.01 4 | 579.91 579.14 579.16 579.55 579.67 5 | 578.44 578.24 579.1 579.09 579.35 6 | 578.82 579.32 579.01 579 579.8 7 | 579.83 579.72 579.89 580.01 579.37 8 | 578.69 578.19 578.67 579.55 578.92 9 | 578.09 579.37 580.13 580.14 579.51 10 | 579.24 578.66 578.86 578.05 577.79 11 | 576.75 576.75 577.82 578.64 580.58 12 | 579.48 577.38 576.9 576.94 576.24 13 | 576.84 576.85 576.9 577.79 578.18 14 | 577.51 577.23 578.42 579.61 579.05 15 | 579.26 579.22 579.38 579.1 577.95 16 | 578.12 579.75 580.85 580.41 579.96 17 | 579.61 578.76 578.18 577.21 577.13 18 | 579.1 19 | -------------------------------------------------------------------------------- /examples/estudio_04_completo/serie2.dat: -------------------------------------------------------------------------------- 1 | 580.38 581.86 580.97 580.8 579.79 2 | 580.39 580.42 580.82 581.4 581.32 3 | 581.44 581.68 581.17 580.53 580.01 4 | 579.91 579.14 579.16 579.55 579.67 5 | 578.44 578.24 579.1 579.09 579.35 6 | 578.82 579.32 579.01 579 579.8 7 | 579.83 579.72 579.89 580.01 579.37 8 | 578.69 578.19 578.67 579.55 578.92 9 | 578.09 579.37 580.13 580.14 579.51 10 | 579.24 578.66 578.86 578.05 577.79 11 | 576.75 576.75 577.82 578.64 580.58 12 | 579.48 577.38 576.9 576.94 576.24 13 | 576.84 576.85 576.9 577.79 578.18 14 | 577.51 577.23 578.42 579.61 579.05 15 | 579.26 579.22 579.38 579.1 577.95 16 | 578.12 579.75 580.85 580.41 579.96 17 | 579.61 578.76 578.18 577.21 577.13 18 | 579.1 19 | -------------------------------------------------------------------------------- /examples/estudio_02_simple/serie1.dat: -------------------------------------------------------------------------------- 1 | 13067.3 13130.5 13198.4 13254.2 13303.7 2 | 13353.9 13409.3 13459.2 13504.5 13552.6 3 | 13614.3 13669.5 13722.6 13772.1 13832 4 | 13862.6 13893 13926.8 13968.9 14004.7 5 | 14033.1 14066 14110.1 14155.6 14192.2 6 | 14231.7 14281.5 14330.3 14359.3 14396.6 7 | 14430.8 14478.4 14515.7 14554.9 14602.5 8 | 14646.4 14695.4 14746.6 14807.4 14874.4 9 | 14923.3 14988.7 15054.1 15121.7 15184.2 10 | 15239.3 15288.9 15346.2 15393.5 15439 11 | 15483.5 15531.5 15579.4 15628.5 15677.3 12 | 15736.7 15788.3 15839.7 15900.6 15961.5 13 | 16018.3 16076.9 16139 16203 16263.3 14 | 16327.9 16398.9 16478.3 16538.2 16621.6 15 | 16697 16777.2 16833.1 16891.6 16956.8 16 | 17026.3 17085.4 17106.9 17169.4 17239.4 17 | 17292 17354.2 17414.2 17447.3 17482.6 18 | 17526 17568.7 19 | -------------------------------------------------------------------------------- /examples/estudio_03_completo/serie1.dat: -------------------------------------------------------------------------------- 1 | 13067.3 13130.5 13198.4 13254.2 13303.7 2 | 13353.9 13409.3 13459.2 13504.5 13552.6 3 | 13614.3 13669.5 13722.6 13772.1 13832 4 | 13862.6 13893 13926.8 13968.9 14004.7 5 | 14033.1 14066 14110.1 14155.6 14192.2 6 | 14231.7 14281.5 14330.3 14359.3 14396.6 7 | 14430.8 14478.4 14515.7 14554.9 14602.5 8 | 14646.4 14695.4 14746.6 14807.4 14874.4 9 | 14923.3 14988.7 15054.1 15121.7 15184.2 10 | 15239.3 15288.9 15346.2 15393.5 15439 11 | 15483.5 15531.5 15579.4 15628.5 15677.3 12 | 15736.7 15788.3 15839.7 15900.6 15961.5 13 | 16018.3 16076.9 16139 16203 16263.3 14 | 16327.9 16398.9 16478.3 16538.2 16621.6 15 | 16697 16777.2 16833.1 16891.6 16956.8 16 | 17026.3 17085.4 17106.9 17169.4 17239.4 17 | 17292 17354.2 17414.2 17447.3 17482.6 18 | 17526 17568.7 19 | -------------------------------------------------------------------------------- /examples/pruebas_simples/basico_crossvalidation.R: -------------------------------------------------------------------------------- 1 | library(fpp) # To load the data set a10 2 | plot(a10, ylab="$ million", xlab="Year", main="Antidiabetic drug sales") 3 | plot(log(a10), ylab="", xlab="Year", main="Log Antidiabetic drug sales") 4 | 5 | 6 | # plot(acf(diff(diff(log(a10),lag=12)),lag.max = frequency(a10)*20)) 7 | # plot(pacf(diff(diff(log(a10),lag=12)),lag.max = frequency(a10)*20)) 8 | 9 | 10 | k <- 60 # minimum data length for fitting a model 11 | n <- length(a10) 12 | mae1 <- matrix(NA,n-k,12) 13 | mae2 <- matrix(NA,n-k,12) 14 | st <- tsp(a10)[1]+(k-2)/12 15 | 16 | for(i in 1:(n-k)){ 17 | xshort <- window(a10, end=st + i/12) 18 | #xshort <- window(a10, start=st+(i-k+1)/12, end=st+i/12) 19 | xnext <- window(a10, start=st + (i+1)/12, end=st + (i+12)/12) 20 | 21 | fit1 <- Arima(xshort, order=c(3,0,1), seasonal=list(order=c(0,1,1), period=12), 22 | include.drift=TRUE, lambda=0, method="ML") 23 | fcast1 <- forecast(fit1, h=12) 24 | 25 | mae1[i,1:length(xnext)] <- abs(fcast1[['mean']]-xnext) 26 | 27 | fit2 <- Arima(xshort, order=c(1,0,1), seasonal=list(order=c(0,0,1), period=12), 28 | include.drift=TRUE, lambda=0, method="ML") 29 | fcast2 <- forecast(fit2, h=12) 30 | 31 | mae2[i,1:length(xnext)] <- abs(fcast2[['mean']]-xnext) 32 | } 33 | 34 | plot(1:12, colMeans(mae1,na.rm=TRUE), type="l", col=2, xlab="horizon", ylab="MAE",ylim=c(0.65,1.25)) 35 | lines(1:12, colMeans(mae2,na.rm=TRUE), type="l",col=3) 36 | legend("topleft",legend=c("ARIMA(3,0,1)(0,1,1)","ARIMA(1,0,1)(0,01)"),col=2:4,lty=1) 37 | 38 | 39 | ###################### One-step forecasts without re-estimation ############################ 40 | 41 | library(fpp) 42 | plot(hsales) 43 | train <- window(hsales,end=1989.99) 44 | fit <- auto.arima(train) 45 | refit <- Arima(hsales, model=fit) 46 | fc <- window(fitted(refit), start=1990) 47 | abs(fc-window(hsales, start=1990)) 48 | -------------------------------------------------------------------------------- /examples/estudio_02_simple/st2.R: -------------------------------------------------------------------------------- 1 | library("tseries") 2 | 3 | 4 | rm(list=ls()) # Eliminamos lo que haya en el espacio de trabajo 5 | 6 | 7 | #Leemos la serie temporal 8 | serie2 <- scan("serie2.dat") 9 | 10 | #Mostramos la serie para ver que forma tiene 11 | plot.ts(serie2) 12 | 13 | #Dividida en 87 valores, que son 3 Trimestres de 1971, mas 84 Trimestres mas hasta 1992. 14 | 15 | #Usamos como frecuencia 4, ya que los datos estan procesados en Trimestres 16 | #Y ademas, como es el segundo Trimestre, indicamos que la serie empieza en 2 trimestre 17 | serie2.ts <- ts(serie2, frequency = 1,start=c(1875,1)) 18 | print(serie2.ts) 19 | 20 | plot.ts(serie2.ts) 21 | 22 | #The estimated values of the seasonal, trend and irregular components are now stored here 23 | decompose.serie2.ts <- decompose(serie2.ts) 24 | #Print out the estimated values od seasonal component 25 | decompose.serie2.ts$seasonal 26 | #Plot all components, seasonal, trend and irregular 27 | plot(decompose.serie2.ts) 28 | 29 | #Try STL 30 | serie1.stl <- stl(serie1.ts,"per") 31 | plot(serie1.stl) 32 | 33 | serie1.log.ts <- log(serie1.ts) 34 | serie1.log <- log(serie1) 35 | 36 | #Datos de TRAIN 37 | serie1.TR <- serie1.log[1:(length(serie1.log)-4)] 38 | tiempo.serie1.TR <- 1:length(serie1.TR) 39 | #Datos de TEST 40 | serie1.TS <- serie1.log[(length(serie1.log)-4+1):length(serie1)] 41 | tiempo.serie1.TS <- (tiempo.serie1.TR[length(tiempo.serie1.TR)]+1):(tiempo.serie1.TR[length(tiempo.serie1.TR)]+4) 42 | 43 | plot.ts(tiempo.serie1.TR, xlim=c(1,tiempo.serie1.TS[length(tiempo.serie1.TS)])) 44 | lines(tiempo.serie1.TS,serie1.TS,col="red") 45 | 46 | 47 | #Hacemos regresion Linea 48 | parametros.H1 <- lm (serie1.TR ~ tiempo.serie1.TR ) 49 | 50 | #tendencia 51 | TendEstimadaTR.H1 <- parametros.H1$coefficients[1]+tiempo.serie1.TR*parametros.H1$coefficients[2] 52 | TendEstimadaTS.H1 <- parametros.H1$coefficients[1]+tiempo.serie1.TS*parametros.H1$coefficients[2] 53 | 54 | plot.ts(serie1.TR,xlim=c(1,tiempo.serie1.TS[length(tiempo.serie1.TS)])) 55 | lines(tiempo.serie1.TR,TendEstimadaTR.H1,col="blue") 56 | lines(tiempo.serie1.TS,serie1.TS,col="red") 57 | plot(log(jj), type="o") 58 | #Dibujamos la Tendencia Estimada de Test en Green 59 | lines(tiempo.serie1.TS,TendEstimadaTS.H1,col="green") 60 | 61 | 62 | 63 | -------------------------------------------------------------------------------- /examples/analisis_simple_co2/co2.csv: -------------------------------------------------------------------------------- 1 | CO2;Year&Month;Year;Month 2 | 333.13;1974.38;1974;5 3 | 332.09;1974.46;1974;6 4 | 331.10;1974.54;1974;7 5 | 329.14;1974.63;1974;8 6 | 327.36;1974.71;1974;9 7 | 327.29;1974.79;1974;10 8 | 328.23;1974.88;1974;11 9 | 329.55;1974.96;1974;12 10 | 330.62;1975.04;1975;1 11 | 331.40;1975.13;1975;2 12 | 331.87;1975.21;1975;3 13 | 333.18;1975.29;1975;4 14 | 333.92;1975.38;1975;5 15 | 333.43;1975.46;1975;6 16 | 331.85;1975.54;1975;7 17 | 330.01;1975.63;1975;8 18 | 328.51;1975.71;1975;9 19 | 328.41;1975.79;1975;10 20 | 329.25;1975.88;1975;11 21 | 330.97;1975.96;1975;12 22 | 331.60;1976.04;1976;1 23 | 332.60;1976.13;1976;2 24 | 333.57;1976.21;1976;3 25 | 334.72;1976.29;1976;4 26 | 334.68;1976.38;1976;5 27 | 334.17;1976.46;1976;6 28 | 332.96;1976.54;1976;7 29 | 330.80;1976.63;1976;8 30 | 328.98;1976.71;1976;9 31 | 328.57;1976.79;1976;10 32 | 330.20;1976.88;1976;11 33 | 331.58;1976.96;1976;12 34 | 332.67;1977.04;1977;1 35 | 333.17;1977.13;1977;2 36 | 334.86;1977.21;1977;3 37 | 336.07;1977.29;1977;4 38 | 336.82;1977.38;1977;5 39 | 336.12;1977.46;1977;6 40 | 334.81;1977.54;1977;7 41 | 332.56;1977.63;1977;8 42 | 331.30;1977.71;1977;9 43 | 331.22;1977.79;1977;10 44 | 332.37;1977.88;1977;11 45 | 333.49;1977.96;1977;12 46 | 334.71;1978.04;1978;1 47 | 335.23;1978.13;1978;2 48 | 336.54;1978.21;1978;3 49 | 337.79;1978.29;1978;4 50 | 337.95;1978.38;1978;5 51 | 338.00;1978.46;1978;6 52 | 336.37;1978.54;1978;7 53 | 334.47;1978.63;1978;8 54 | 332.46;1978.71;1978;9 55 | 332.29;1978.79;1978;10 56 | 333.76;1978.88;1978;11 57 | 334.80;1978.96;1978;12 58 | 336.00;1979.04;1979;1 59 | 336.63;1979.13;1979;2 60 | 337.93;1979.21;1979;3 61 | 338.95;1979.29;1979;4 62 | 339.05;1979.38;1979;5 63 | 339.27;1979.46;1979;6 64 | 337.64;1979.54;1979;7 65 | 335.68;1979.63;1979;8 66 | 333.77;1979.71;1979;9 67 | 334.09;1979.79;1979;10 68 | 335.29;1979.88;1979;11 69 | 336.76;1979.96;1979;12 70 | 337.77;1980.04;1980;1 71 | 338.26;1980.13;1980;2 72 | 340.10;1980.21;1980;3 73 | 340.88;1980.29;1980;4 74 | 341.47;1980.38;1980;5 75 | 341.31;1980.46;1980;6 76 | 339.41;1980.54;1980;7 77 | 337.74;1980.63;1980;8 78 | 336.07;1980.71;1980;9 79 | 336.07;1980.79;1980;10 80 | 337.22;1980.88;1980;11 81 | 338.38;1980.96;1980;12 82 | 339.32;1981.04;1981;1 83 | 340.41;1981.13;1981;2 84 | 341.69;1981.21;1981;3 85 | 342.51;1981.29;1981;4 86 | 343.02;1981.38;1981;5 87 | 342.54;1981.46;1981;6 88 | 340.88;1981.54;1981;7 89 | 338.75;1981.63;1981;8 90 | 337.05;1981.71;1981;9 91 | 337.13;1981.79;1981;10 92 | 338.45;1981.88;1981;11 93 | 339.85;1981.96;1981;12 94 | 340.90;1982.04;1982;1 95 | 341.70;1982.13;1982;2 96 | 342.70;1982.21;1982;3 97 | 343.65;1982.29;1982;4 98 | 344.28;1982.38;1982;5 99 | 343.42;1982.46;1982;6 100 | 342.02;1982.54;1982;7 101 | 339.97;1982.63;1982;8 102 | 337.84;1982.71;1982;9 103 | 338.00;1982.79;1982;10 104 | 339.20;1982.88;1982;11 105 | 340.63;1982.96;1982;12 106 | 341.41;1983.04;1983;1 107 | 342.68;1983.13;1983;2 108 | 343.04;1983.21;1983;3 109 | 345.27;1983.29;1983;4 110 | 345.92;1983.38;1983;5 111 | 345.40;1983.46;1983;6 112 | 344.16;1983.54;1983;7 113 | 342.11;1983.63;1983;8 114 | 340.11;1983.71;1983;9 115 | 340.15;1983.79;1983;10 116 | 341.38;1983.88;1983;11 117 | 343.02;1983.96;1983;12 118 | 343.87;1984.04;1984;1 119 | 344.59;1984.13;1984;2 120 | 345.11;1984.21;1984;3 121 | 347.07;1984.29;1984;4 122 | 347.38;1984.38;1984;5 123 | 346.78;1984.46;1984;6 124 | 344.96;1984.54;1984;7 125 | 342.71;1984.63;1984;8 126 | 340.86;1984.71;1984;9 127 | 341.13;1984.79;1984;10 128 | 342.84;1984.88;1984;11 129 | 344.32;1984.96;1984;12 130 | 344.88;1985.04;1985;1 131 | 345.62;1985.13;1985;2 132 | 347.23;1985.21;1985;3 133 | 347.62;1985.29;1985;4 134 | 348.53;1985.38;1985;5 135 | 347.87;1985.46;1985;6 136 | 346.00;1985.54;1985;7 137 | 343.86;1985.63;1985;8 138 | 342.55;1985.71;1985;9 139 | 342.57;1985.79;1985;10 140 | 344.11;1985.88;1985;11 141 | 345.49;1985.96;1985;12 142 | 346.04;1986.04;1986;1 143 | 346.70;1986.13;1986;2 144 | 347.38;1986.21;1986;3 145 | 349.38;1986.29;1986;4 146 | 349.93;1986.38;1986;5 147 | 349.26;1986.46;1986;6 148 | 347.44;1986.54;1986;7 149 | 345.55;1986.63;1986;8 150 | 344.21;1986.71;1986;9 151 | 343.67;1986.79;1986;10 152 | 345.09;1986.88;1986;11 153 | 346.27;1986.96;1986;12 154 | 347.33;1987.04;1987;1 155 | 347.82;1987.13;1987;2 156 | 349.29;1987.21;1987;3 157 | 350.91;1987.29;1987;4 158 | 351.71;1987.38;1987;5 159 | 350.94;1987.46;1987;6 160 | 349.10;1987.54;1987;7 161 | 346.77;1987.63;1987;8 162 | 345.73;1987.71;1987;9 163 | -------------------------------------------------------------------------------- /examples/pruebas_simples/basico_imputation.R: -------------------------------------------------------------------------------- 1 | library(imputeTS) 2 | library(forecast) 3 | 4 | 5 | # tsAirgap is a example time series with missing data included in imputeTS package 6 | x <- tsAirgap 7 | 8 | plot(x) 9 | 10 | #Replace missing data using na.kalman method from imputeTS 11 | x <- na.kalman(x) 12 | 13 | plot(x) 14 | 15 | x <- na.interpolation(x) 16 | 17 | plot(x) 18 | 19 | #Perform a forecast using ets method from forecast 20 | # The h parameter specifies how far in the future to forecast 21 | result <- forecast(ets(x),h=10) 22 | 23 | #This is the result 24 | result$mean 25 | 26 | plot(result) 27 | 28 | 29 | ############################################## 30 | 31 | library(zoo) 32 | 33 | j <- c(0,-1,-2,-1.1,0.1,0.9,2.1,1,-0.1,-1.1,-1.9,-1,0.1,NaN,NaN,NaN,0,-1,-2,-1,0,1.1,2,1.2,0.1) 34 | j <- c(0.1,1,1.9,0.9,0,-1,-2,-1.1,0.1,0.9,2.1,1,-0.1,-1.1,-1.9,-1,0.1,NaN,NaN,NaN,0,-1,-2,-1,0,1.1,2,1.2,0.1,-0.9,-1.8,-0.8,0.1,1,2,1.1,0.1,NaN,NaN,NaN,NaN,NaN,NaN,NaN,0.1,-1,-2.1,-1.3,-0.2,0.9,1.9,1,0) 35 | 36 | ts <- ts(j) 37 | plot(ts) 38 | 39 | x <- na.mean(ts) 40 | plot(x) 41 | x <- na.ma(ts) 42 | plot(x) 43 | x <- na.ma(ts,2) 44 | plot(x) 45 | x <- na.ma(ts,9) 46 | plot(x) 47 | x <- na.interpolation(ts,"linear") 48 | plot(x) 49 | x <- na.interp(ts, lambda = NULL) 50 | plot(x) 51 | x <- na.interpolation(ts,"spline") 52 | plot(x) 53 | x <- na.interpolation(ts,"stine") 54 | plot(x) 55 | x <- na.kalman(ts) # model="StructTS" 56 | plot(x) 57 | x <- na.kalman(ts,model="auto.arima") 58 | plot(x) 59 | 60 | 61 | x <- na.locf(ts) 62 | plot(x) 63 | x <- na.seadec(ts, algorithm = "kalman") 64 | plot(x) 65 | x <- na.seasplit(ts, algorithm = "kalman") 66 | plot(x) 67 | 68 | 69 | x <- na.aggregate(ts,2) 70 | plot(x) 71 | x <- na.approx(ts) 72 | plot(x) 73 | x <- na.StructTS(ts) 74 | plot(x) 75 | 76 | ############################################## 77 | 78 | library(mice) 79 | 80 | data <- airquality 81 | data[4:10,3] <- rep(NA,7) 82 | data[1:5,4] <- NA 83 | 84 | pMiss <- function(x){sum(is.na(x))/length(x)*100} 85 | apply(data,2,pMiss) 86 | apply(data,1,pMiss) 87 | 88 | md.pattern(data) 89 | data <- data[-c(5,6)] 90 | summary(data) 91 | 92 | tempData <- mice(data,m=5,maxit=50,meth='pmm',seed=500) 93 | summary(tempData) 94 | 95 | ts <- ts(data[1]) 96 | plot(ts) 97 | tempData <- mice(data[1],m=5,maxit=50) 98 | 99 | ts <- ts(data[2]) 100 | plot(ts) 101 | 102 | ########################################################### 103 | 104 | # Perform imputation with auto.arima and Kalman filter 105 | library(forecast) 106 | 107 | ## Airpass used as an example 108 | data <- AirPassengers 109 | plot(data) 110 | 111 | ## Set missing values 112 | data[c(10,13,15,50,51,52,53,54,55,60)] <- NA 113 | plot(data) 114 | 115 | ## Fit arima model 116 | fit <- auto.arima(data) 117 | 118 | ## Use Kalman filter 119 | kal <- KalmanRun(data,fit$model) 120 | 121 | tmp <- which(fit$model$Z == 1) 122 | id <- ifelse (length(tmp) == 1, tmp[1],tmp[2]) 123 | 124 | ## Fill in the values 125 | id.na <-which(is.na(data)) 126 | data[id.na] <- kal$states[id.na,id] 127 | print(data) 128 | 129 | ################################################################################## 130 | 131 | #' Transform a univariate time series to a matrix with lags as columns. 132 | #' @param data The time series. 133 | #' @param lags The maxi mum amount of lags to be created. 134 | #' @return A data frame with the lags in the columns. 135 | create.lags <- function(data, lags = 0){ 136 | if (lags < 1){ 137 | warning("No lags introduced.") 138 | return(data) 139 | } 140 | data.new <- data.frame(data[(lags+1):length(data)]) 141 | cnames <-"x" 142 | for(i.lag in 1:lags) { 143 | ind <-(lags + 1 - i.lag) : (length(data) - i.lag) 144 | data.new <- cbind(data.new,data[ind]) 145 | cnames <- c(cnames, paste("lag", as.character(i.lag), sep = "_")) 146 | } 147 | colnames(data.new) <- cnames 148 | return(data.new) 149 | } 150 | 151 | 152 | j <- c(0.1,1,1.9,0.9,0,-1,-2,-1.1,0.1,0.9,2.1,1,-0.1,-1.1,-1.9,-1,0.1,NaN,NaN,NaN,0,-1,-2,-1,0,1.1,2,1.2,0.1,-0.9,-1.8,-0.8,0.1,1,2,1.1,0.1,NaN,NaN,NaN,NaN,NaN,NaN,NaN,0.1,-1,-2.1,-1.3,-0.2,0.9,1.9,1,0) 153 | 154 | ts <- ts(j) 155 | plot(ts) 156 | 157 | j2 <- create.lags(ts, lags = 1) 158 | j3 <- create.lags(ts, lags = 5) 159 | 160 | library(VIM) 161 | 162 | res <- kNN(j3,variable="x",k=5) 163 | plot(ts(res[1])) 164 | 165 | library(mice) 166 | 167 | res <- mice(j3,m=5,maxit=50,meth='pmm',seed=500) 168 | plot(ts(complete(res,1)[1])) 169 | -------------------------------------------------------------------------------- /examples/pruebas_simples/basico_comparacion.R: -------------------------------------------------------------------------------- 1 | 2 | 3 | ###############################Modelo aditivo prophet##################################### 4 | 5 | library(prophet) 6 | 7 | setwd("C:/Users/Kuko/Desktop/Series temporales/Pruebas R") 8 | 9 | df <- read.csv('C:/Users/Kuko/Desktop/Series temporales/Pruebas R/example_wp_peyton_manning.csv') 10 | plot(1:length(df$ds),df$y,type="l") 11 | df$y <- log(df$y) 12 | plot(1:length(df$ds),df$y,type="l") 13 | 14 | m <- prophet(df) 15 | 16 | future <- make_future_dataframe(m, periods = 365) 17 | tail(future) 18 | 19 | forecast <- predict(m, future) 20 | tail(forecast[c('ds', 'yhat', 'yhat_lower', 'yhat_upper')]) 21 | 22 | plot(m, forecast) 23 | 24 | prophet_plot_components(m, forecast) 25 | 26 | plot(1:length(df$ds),df$y,type="l",xlim=c(min(time(forecast$ds)),max(time(forecast$ds))),ylim=c(min(df$y,forecast$yhat),max(df$y,forecast$yhat))) 27 | lines(1:length(forecast$ds),forecast$yhat,type="l",col="red") 28 | 29 | 30 | library(forecast) 31 | 32 | accuracy(df$y,forecast$yhat[1:length(df$y)]) 33 | 34 | ###########################Alisado exponencial doble stat################################### 35 | 36 | df <- read.csv('C:/Users/Kuko/Desktop/Series temporales/Pruebas R/example_wp_peyton_manning.csv') 37 | plot(1:length(df$ds),df$y,type="l") 38 | df$y <- log(df$y) 39 | plot(1:length(df$ds),df$y,type="l") 40 | 41 | j <- ts(df$y,frequency=365) 42 | 43 | aliHW <- HoltWinters(j) 44 | pred.aliHW <- predict(aliHW, n.ahead=365, prediction.interval=FALSE) 45 | 46 | #plot(aliHW, pred.aliHW) 47 | plot(1:length(df$ds),df$y,type="l",xlim=c(min(time(df$ds)),max(time(df$ds))+365),ylim=c(min(df$y,aliHW$fitted[,1],pred.aliHW),max(df$y,aliHW$fitted[,1],pred.aliHW))) 48 | lines(366:length(df$y),aliHW$fitted[,1],col="blue") 49 | lines((length(df$ds)+1):(length(df$ds)+365),pred.aliHW,type="l",col="blue") 50 | 51 | accuracy(df$y[366:length(df$y)],aliHW$fitted[,1]) 52 | 53 | #################################red neuronal forecast###################################### 54 | 55 | df <- read.csv('C:/Users/Kuko/Desktop/Series temporales/Pruebas R/example_wp_peyton_manning.csv') 56 | plot(1:length(df$ds),df$y,type="l") 57 | df$y <- log(df$y) 58 | plot(1:length(df$ds),df$y,type="l") 59 | 60 | #df$y = (df$y-min(df$y))/(max(df$y)-min(df$y)) 61 | df$y <- scale(df$y) 62 | j <- ts(df$y,frequency=365) 63 | 64 | fit <- nnetar(j) 65 | 66 | f.nn <- forecast(fit,h=365) 67 | plot(f.nn) 68 | 69 | plot(1:length(df$ds),df$y,type="l",xlim=c(min(time(df$ds)),max(time(df$ds))+365),ylim=c(min(df$y,fit$fitted,f.nn$mean,na.rm=TRUE),max(df$y,fit$fitted,f.nn$mean,na.rm=TRUE))) 70 | lines(1:length(df$y),fit$fitted,col="green") 71 | lines((length(df$ds)+1):(length(df$ds)+365),f.nn$mean,col="green") 72 | 73 | accuracy(df$y[366:length(df$y)],fit$fitted) 74 | 75 | ##########################################ARIMA forecast################################## 76 | 77 | df <- read.csv('C:/Users/Kuko/Desktop/Series temporales/Pruebas R/example_wp_peyton_manning.csv') 78 | plot(1:length(df$ds),df$y,type="l") 79 | df$y <- log(df$y) 80 | plot(1:length(df$ds),df$y,type="l") 81 | 82 | j <- ts(df$y,frequency=365) 83 | 84 | h <- auto.arima(j,stepwise=FALSE,approximation=FALSE) 85 | 86 | arima <- Arima(j,model=h) 87 | 88 | f <- forecast(arima,h=365) 89 | plot(f) 90 | 91 | 92 | 93 | plot(1:length(df$ds),df$y,type="l",xlim=c(min(time(df$ds)),max(time(df$ds))+365),ylim=c(min(df$y,f$fitted,f$mean,na.rm=TRUE),max(df$y,f$fitted,f$mean,na.rm=TRUE))) 94 | lines(1:length(df$y),f$fitted,col="orange") 95 | lines((length(df$ds)+1):(length(df$ds)+365),f$mean,col="orange") 96 | 97 | 98 | accuracy(df$y,f$fitted) 99 | 100 | 101 | 102 | par(mfrow=c(2,2)) 103 | plot(1:length(df$ds),df$y,type="l",xlim=c(min(time(forecast$ds)),max(time(forecast$ds))),ylim=c(min(df$y,forecast$yhat),max(df$y,forecast$yhat)),main="Prophet (MAE=0.33 RMSE=0.48)",xlab="time",ylab="y") 104 | lines(1:length(forecast$ds),forecast$yhat,type="l",col="red") 105 | plot(1:length(df$ds),df$y,type="l",xlim=c(min(time(df$ds)),max(time(df$ds))+365),ylim=c(min(df$y,aliHW$fitted[,1],pred.aliHW),max(df$y,aliHW$fitted[,1],pred.aliHW)),main="Holt Winter (MAE=0.37 RMSE=0.54",xlab="time",ylab="y") 106 | lines(366:length(df$y),aliHW$fitted[,1],col="blue") 107 | lines((length(df$ds)+1):(length(df$ds)+365),pred.aliHW,type="l",col="blue") 108 | plot(1:length(df$ds),df$y,type="l",xlim=c(min(time(df$ds)),max(time(df$ds))+365),ylim=c(min(df$y,f$fitted,f$mean,na.rm=TRUE),max(df$y,f$fitted,f$mean,na.rm=TRUE)),main="auto.arima (MAE=0.28 RMSE=0.42)",xlab="time",ylab="y") 109 | lines(1:length(df$y),f$fitted,col="orange") 110 | lines((length(df$ds)+1):(length(df$ds)+365),f$mean,col="orange") 111 | plot(1:length(df$ds),df$y,type="l",xlim=c(min(time(df$ds)),max(time(df$ds))+365),ylim=c(min(df$y,fit$fitted,f.nn$mean,na.rm=TRUE),max(df$y,fit$fitted,f.nn$mean,na.rm=TRUE)),main="nnetar (MAE=0.73 RMSE=1.01)",xlab="time",ylab="y") 112 | lines(1:length(df$y),fit$fitted,col="green") 113 | lines((length(df$ds)+1):(length(df$ds)+365),f.nn$mean,col="green") 114 | 115 | 116 | #########################################COMPARACIÓN#################################################### 117 | 118 | library(forecast) 119 | library(prophet) 120 | 121 | plot(AirPassengers) 122 | 123 | AirPassengers <- log(AirPassengers) 124 | 125 | df <- data.frame(time(AirPassengers),AirPassengers[1:length(AirPassengers)]) 126 | colnames(df) <- c("ds","y") 127 | y <- (AirPassengers-min(AirPassengers))/(max(AirPassengers)-min(AirPassengers)) 128 | 129 | m <- prophet(df) 130 | aliHW <- HoltWinters(AirPassengers) 131 | h <- auto.arima(AirPassengers,stepwise=FALSE,approximation=FALSE) 132 | arima <- Arima(AirPassengers,model=h) 133 | fit <- nnetar(y) 134 | 135 | future <- make_future_dataframe(m, periods = 20, freq = 'm') 136 | forecast <- predict(m, future) 137 | pred.aliHW <- predict(aliHW, n.ahead=20, prediction.interval=FALSE) 138 | f <- forecast(arima,h=20) 139 | f.nn <- forecast(fit,h=20) 140 | 141 | 142 | 143 | 144 | accuracy(df$y,forecast$yhat[1:length(df$y)]) 145 | accuracy(AirPassengers[13:length(AirPassengers)],aliHW$fitted[,1]) 146 | accuracy(AirPassengers[1:length(AirPassengers)],f$fitted) 147 | accuracy(y[13:length(y)],fit$fitted[13:length(fit$fitted)]) 148 | 149 | 150 | par(mfrow=c(2,2)) 151 | plot(1:length(df$ds),df$y,type="l",xlim=c(min(time(forecast$ds)),max(time(forecast$ds))),ylim=c(min(df$y,forecast$yhat),max(df$y,forecast$yhat)),main="Prophet (MAE=0.026 RMSE=0.033)",xlab="time",ylab="y") 152 | lines(1:length(forecast$ds),forecast$yhat,type="l",col="red") 153 | plot(1:length(AirPassengers),AirPassengers[1:length(AirPassengers)],type="l",xlim=c(0,length(AirPassengers)+20),ylim=c(min(AirPassengers[1:length(AirPassengers)],aliHW$fitted[,1],pred.aliHW),max(AirPassengers[1:length(AirPassengers)],aliHW$fitted[,1],pred.aliHW)),main="Holt Winter (MAE=0.029 RMSE=0.039)",xlab="time",ylab="y") 154 | lines(13:length(AirPassengers),aliHW$fitted[,1],col="blue") 155 | lines((length(AirPassengers)+1):(length(AirPassengers)+20),pred.aliHW,type="l",col="blue") 156 | plot(1:length(AirPassengers),AirPassengers[1:length(AirPassengers)],type="l",xlim=c(0,length(AirPassengers)+20),ylim=c(min(AirPassengers[1:length(AirPassengers)],f$fitted,f$mean),max(AirPassengers[1:length(AirPassengers)],f$fitted,f$mean)),main="auto.arima (MAE=0.026 RMSE=0.035)",xlab="time",ylab="y") 157 | lines(1:length(df$y),f$fitted,col="orange") 158 | lines((length(AirPassengers)+1):(length(AirPassengers)+20),f$mean,col="orange") 159 | plot(1:length(y),y[1:length(y)],type="l",xlim=c(0,length(AirPassengers)+20),ylim=c(min(y[1:length(y)],fit$fitted,f.nn$mean,na.rm=TRUE),max(y[1:length(y)],fit$fitted,f.nn$mean,na.rm=TRUE)),main="nnetar (MAE=0.023 RMSE=0.029)",xlab="time",ylab="y") 160 | lines(1:length(y),fit$fitted,col="green") 161 | lines((length(y)+1):(length(y)+20),f.nn$mean,col="green") 162 | 163 | 164 | -------------------------------------------------------------------------------- /examples/estudio_04_completo/analisis_serie2.R: -------------------------------------------------------------------------------- 1 | library(tseries) 2 | library(psych) 3 | library(forecast) 4 | 5 | 6 | #Limpio la broza 7 | rm(list=ls()) 8 | 9 | #Leemos la serie 10 | serie <-scan("serie2.dat") 11 | #Convertimos la serie a TS datatype y parametrizamos 12 | #el tiempo de inicio y frecuencia. 13 | serie.ts <- ts(serie, start=c(1875,1)) 14 | serie.ts <- log(serie.ts) 15 | 16 | 17 | #Dibujamos la serie completa 18 | png(file="serie2_inicial.png", bg="transparent",width = 800, height = 350) 19 | plot(serie.ts,xlab="Trimestre",ylab="Población") 20 | dev.off() 21 | 22 | #Hacemos la descomposicion en componentes. 23 | png(file="serie2_descompose.png", bg="transparent",width = 800, height = 350) 24 | serie.decompose <- decompose (serie.ts,type="mult") 25 | plot( serie.decompose) 26 | dev.off() 27 | 28 | #Hacemos la descomposicion en componentes con STL 29 | png(file="serie2_stl.png", bg="transparent",width = 800, height = 350) 30 | serie.stl <- stl (serie.ts,s.window="periodic") 31 | plot( serie.stl) 32 | dev.off() 33 | 34 | #Estadistica básica sobre los datos. 35 | describe (serie) 36 | 37 | #Superposicion de la tendencia y el componente estacional 38 | #trend <- serie.decompose$trend 39 | #seasonal <- serie.decompose$seasonal 40 | #ts.plot(cbind(trend,trend*seasonal),lty=1:2) 41 | 42 | #png(file="serie2_logged_diffed.png", bg="transparent",width = 800, height = 400) 43 | #par(mfrow=c(1,2)) 44 | #plot(serie.ts, type="o", col="blue", lty="dashed") 45 | #plot(diff(serie.ts), main="logged and diffed") 46 | #dev.off() 47 | 48 | #Usamos el test KPSS para comprobar si es o no estacionaria 49 | kpss_test <- kpss.test(serie.ts, null = "Trend") 50 | #P-value = 0.01, 51 | 52 | #Verificamos ACF y PACF para comprobar si hay o no Tend/Estac. 53 | png(file="serie2_acf_pacf.png", bg="transparent",width = 800, height = 400) 54 | par(mfrow=c(1,2)) 55 | acf(serie.ts) 56 | pacf(serie.ts) 57 | dev.off() 58 | result <- adf.test(serie.ts, alternative = "stationary") 59 | cat("Test devuelve Dickey-Fuller con un p-value=", result$p.value, "\n") 60 | 61 | 62 | #Ajustamos los datos al modelo lineal 63 | tiempo <- 1:length(serie) 64 | parametros <- lm (serie ~ tiempo) 65 | TendEstimada<-parametros$coefficients[1]+tiempo*parametros$coefficients[2] 66 | series<-matrix(c(t(serie), t(TendEstimada)), ncol=2); # Mostramos resultado 67 | png(file="serie2_lm.png", bg="transparent",width = 800, height = 400) 68 | par(mfrow=c(1,1)) 69 | matplot(series, pch=1, type= "l") 70 | dev.off() 71 | 72 | 73 | #Descartamos el modelo lineal 74 | JBtr <- jarque.bera.test(parametros$residuals) 75 | TT <- t.test(c(parametros$residuals,TendEstimada-serie)) 76 | 77 | #Como no usamos el modelo de tendencia, pues usamos la serie en si 78 | SerSinTend<-serie; 79 | 80 | plot.ts(SerSinTend) 81 | 82 | 83 | 84 | # #Probamos con Filtro de medias moviles: 85 | # for (k in 3:5) { 86 | # filtro<-rep(1/k, k); # Creamos el filtro 87 | # # Filtramos señal 88 | # SerFiltrada<-filter(serie,filter=filtro,sides=2,method="convolution") 89 | # # Mostramos en la misma figura la serie y la tendencia estimada 90 | # series<-matrix(c(t(serie), t(SerFiltrada)), ncol=2); 91 | # matplot(series, pch=1, type= "l") 92 | # 93 | # cat("Calculo tendencia con filtro de orden k=", k, "\n") 94 | # print("Pulse una tecla para continuar...") 95 | # pause<-readline(); # para pausar la ejecución 96 | # } 97 | # 98 | # SerSinTend2<-serie-SerFiltrada; 99 | # #Mostramos ambas aproximaciones diferenciadas 100 | # series<-matrix(c(t(SerSinTend), t(SerSinTend2)), ncol=2); 101 | # matplot(series, pch=1, type= "l") 102 | # 103 | # series<-matrix(c(t(SerSinTend), t(ser)), ncol=2); 104 | # matplot(series, pch=1, type= "l") 105 | 106 | 107 | #Como el filtro quita los valores iniciales y finales (2), quitamos los NA 108 | #aux_filter<- SerSinTend2[!is.na(SerSinTend2)]; 109 | 110 | #Vemos los resultados de ACF y PACF para cada modelo de aprox. 111 | acf(SerSinTend) 112 | adf.test(SerSinTend) 113 | pacf(SerSinTend) 114 | 115 | 116 | 117 | #Buscamos si hay Estacionalidad. 118 | tiempo <- 1:length(serie) 119 | parametros <- lm (log(serie) ~ tiempo) 120 | plot(parametros) 121 | jarque.bera.test(parametros$residuals) 122 | 123 | 124 | #Eliminamos la estacionalidad y la tendencia. 125 | # Calculamos estacionalidad, con periodo k=43 126 | k<- 10; 127 | estacionalidad<-matrix(nrow=1, ncol=k); 128 | estacionalidad[,]<- 0 129 | for (i in 1:k) { 130 | secuencia<-seq(i, length(SerSinTend), by=k); 131 | for (j in secuencia) { 132 | estacionalidad[1,i]<- estacionalidad[1,i] + SerSinTend[j]; 133 | } 134 | 135 | estacionalidad[1,i]<-estacionalidad[1,i]/length(secuencia); 136 | } 137 | 138 | plot.ts(as.numeric(estacionalidad)) 139 | 140 | # Mostramos la estacionalidad, repetida por toda la serie 141 | #estacionalidad<-as.numeric(estacionalidad[1:43]) 142 | aux<-rep(estacionalidad,10); 143 | auxTotal<- aux[1:86] 144 | aux<- aux[1:12] 145 | 146 | plot.ts(aux) 147 | png(file="serie2_serie_estacion.png", bg="transparent",width = 800, height = 400) 148 | series<-matrix(c(t(SerSinTend), t(aux)), ncol=2); 149 | matplot(series, pch=1, type= "l") 150 | dev.off() 151 | 152 | #Nos quedamos con la serie sin tendencia, ni estacionalidad. 153 | SerSinTendEst<- SerSinTend-aux; 154 | #Trazamos para ver como se ve la cosa 155 | plot.ts(SerSinTendEst) 156 | 157 | #Aplicamos el TEST Dickey-Fuller 158 | adf.test(diff(SerSinTendEst)) 159 | png(file="serie2_diff_acf.png", bg="transparent",width = 800, height = 400) 160 | par(mfrow=c(1,2)) 161 | acf(diff(SerSinTendEst)) 162 | pacf(diff(SerSinTendEst)) 163 | dev.off() 164 | #No obteneimos un p-value <=0.01 165 | 166 | #Aplicamos dos diferenciaciones hasta que pase el test. 167 | #Se aplican 2 diferenciaciones 168 | #a.diff <- diff(SerSinTendEst) 169 | #a.diff <- diff(a.diff) 170 | #adf.test(a.diff) 171 | #acf(a.diff) 172 | #pacf(a.diff) 173 | #Ya podemos entrever el modelo pues el test ha bajado de 0.01 174 | 175 | 176 | #Modelo y prediccion 177 | fit <- auto.arima(SerSinTendEst) 178 | plot(forecast(fit)) 179 | modArima<-auto.arima(SerSinTendEst,D=5,max.P = 5, max.Q = 5) 180 | #Nos da una idea de como podria ser. 181 | modArima <- fit 182 | 183 | fit = arima(SerSinTendEst, order = c(2,0,0)) 184 | modArima <- fit 185 | 186 | #Elegimos un modelo probando varios prometedores 187 | modelo321<- arima(SerSinTendEst, order=c(3, 2, 1)); # Ajustamos modelo 188 | modelo320<- arima(SerSinTendEst, order=c(3, 2, 0)); # Ajustamos modelo 189 | #Este parece el mejor, aunque 222 parece ser mas prometedor. 190 | Acf(residuals(modelo320)) 191 | modelo330<- arima(SerSinTendEst, order=c(3, 3, 0)); # Ajustamos modelo 192 | modelo430<- arima(SerSinTendEst, order=c(4, 3, 0)); # Ajustamos modelo 193 | modelo222<- arima(SerSinTendEst, order=c(2, 2, 2)); # Ajustamos modelo 194 | 195 | #Ajustamos los valores 196 | valoresAjustados.H1 <- SerSinTendEst+modArima$residuals 197 | 198 | #Extraemos las predicciones 199 | Predicciones.H1 <- predict(modArima,n.ahead=12) 200 | valoresPredichos.H1<- Predicciones.H1$pred 201 | 202 | #Dibujamos la serie, los valores ajustados y los predichos. 203 | plot.ts(SerSinTendEst) 204 | lines(valoresAjustados.H1, col="blue") 205 | lines(valoresPredichos.H1, col="red") 206 | 207 | #Tests sobre el modelo 208 | boxtestM1 <- Box.test(modArima$residuals) 209 | JB.H1 <- jarque.bera.test(modArima$residuals) 210 | SW.H1 <- shapiro.test(modArima$residuals) 211 | #JB y SW tienen p-value <0.01 , luego se acepta el modelo. 212 | 213 | #Reconstruimos el modelo: 214 | 215 | 216 | tiempo <- 1:length(serie) 217 | parametros <- glm (serie ~ tiempo) 218 | TendEstimada<-parametros$coefficients[1]+tiempo*parametros$coefficients[2] 219 | 220 | tiempoPredicho<- (tiempo[length(tiempo)]+1):(tiempo[length(tiempo)]+3); 221 | TendPredicha<-parametros$coefficients[1]+tiempoPredicho*parametros$coefficients[2] 222 | 223 | 224 | 225 | plot.ts(SerSinTendEst) 226 | lines(valoresAjustados.H1, col="blue") 227 | lines(valoresPredichos.H1, col="red") 228 | 229 | vvP <- valoresPredichos.H1 + aux 230 | vvA <- valoresAjustados.H1 + auxTotal 231 | 232 | 233 | #valoresAjustados <- valoresAjustados.H1 + aux 234 | valoresPredichos <- valoresPredichos.H1 + TendPredicha 235 | valoresAjustados <- valoresAjustados.H1 + TendEstimada 236 | 237 | #Mostramos los datos. 238 | png(file="serie2_predict.png", bg="transparent",width = 800, height = 400) 239 | plot.ts(serie) 240 | lines(vvP,col="red") 241 | lines(vvA,col="blue") 242 | dev.off() 243 | 244 | #Imprimimos los resultados de 12 valores: 245 | print ("VALORES PREDICHOS:") 246 | print (valoresPredichos) 247 | 248 | -------------------------------------------------------------------------------- /examples/estudio_03_completo/analisis_serie1.R: -------------------------------------------------------------------------------- 1 | #Cargamos librerias 2 | library(tseries) 3 | library(psych) 4 | library(forecast) 5 | 6 | 7 | #Liberamos los datos. 8 | rm(list=ls()) 9 | 10 | #Leemos la serie 11 | serie <-scan("serie1.dat") 12 | 13 | 14 | #Convertimos la serie a TS datatype y parametrizamos 15 | #el tiempo de inicio y frecuencia. 16 | serie.ts <- ts(serie, start=c(1971,2),frequency=4) 17 | 18 | #Almacenamos la serie tal. 19 | png(file="serie1_inicial.png", bg="transparent",width = 800, height = 350) 20 | plot(serie.ts,xlab="Trimestre",ylab="Población") 21 | dev.off() 22 | 23 | #Hacemos la descomposicion en componentes. 24 | png(file="serie1_descompose.png", bg="transparent",width = 800, height = 350) 25 | serie.decompose <- decompose (serie.ts,type="mult") 26 | plot( serie.decompose) 27 | dev.off() 28 | 29 | #Hacemos la descomposicion en componentes con STL 30 | png(file="serie1_stl.png", bg="transparent",width = 800, height = 350) 31 | serie.stl <- stl (serie.ts,s.window="periodic") 32 | plot( serie.stl) 33 | dev.off() 34 | 35 | #Estadistica básica sobre los datos. 36 | describe (serie) 37 | 38 | #Superposicion de la tendencia y el componente estacional 39 | trend <- serie.decompose$trend 40 | seasonal <- serie.decompose$seasonal 41 | ts.plot(cbind(trend,trend*seasonal),lty=1:2) 42 | 43 | #Mostramos la diferencia y el log de la serie. 44 | par(mfrow=c(1,2)) 45 | plot(serie.ts, type="o", col="blue", lty="dashed") 46 | plot(diff(log(serie.ts)), main="logged and diffed") 47 | 48 | 49 | #Usamos el test KPSS para comprobar si es o no estacionaria 50 | kpps_test <- kpss.test(serie.ts, null = "Trend") 51 | #P-value = 0.01, 52 | 53 | #Verificamos ACF y PACF para comprobar si hay o no Tend/Estac. 54 | png(file="serie1_acf_pacf.png", bg="transparent",width = 800, height = 400) 55 | par(mfrow=c(1,2)) 56 | acf(serie.ts) 57 | pacf(serie.ts) 58 | dev.off() 59 | result <- adf.test(serie.ts, alternative = "stationary") 60 | cat("Test devuelve Dickey-Fuller con un p-value=", result$p.value, "\n") 61 | 62 | 63 | #Ajustamos los datos al modelo lineal 64 | tiempo <- 1:length(serie) 65 | parametros <- lm (serie ~ tiempo) 66 | TendEstimada<-parametros$coefficients[1]+tiempo*parametros$coefficients[2] 67 | series<-matrix(c(t(serie), t(TendEstimada)), ncol=2); # Mostramos resultado 68 | png(file="serie1_lm.png", bg="transparent",width = 800, height = 400) 69 | par(mfrow=c(1,1)) 70 | matplot(series, pch=1, type= "l") 71 | grid(10,10,col=1) 72 | dev.off() 73 | 74 | 75 | #Realizamos unos test para comprobar la validez del modelo 76 | JBtr <- jarque.bera.test(parametros$residuals) 77 | TT <- t.test(c(parametros$residuals,TendEstimada-serie)) 78 | 79 | 80 | #Eliminamos la tendencia a partir de la regresion linea hecha. 81 | SerSinTend<-serie-TendEstimada; 82 | 83 | 84 | 85 | #Probamos con Filtro de medias moviles: 86 | for (k in 3:5) { 87 | filtro<-rep(1/k, k); # Creamos el filtro 88 | # Filtramos señal 89 | SerFiltrada<-filter(serie,filter=filtro,sides=2,method="convolution") 90 | # Mostramos en la misma figura la serie y la tendencia estimada 91 | series<-matrix(c(t(serie), t(SerFiltrada)), ncol=2); 92 | matplot(series, pch=1, type= "l") 93 | 94 | cat("Calculo tendencia con filtro de orden k=", k, "\n") 95 | print("Pulse una tecla para continuar...") 96 | pause<-readline(); # para pausar la ejecución 97 | } 98 | 99 | SerSinTend2<-serie-SerFiltrada; 100 | #Mostramos ambas aproximaciones diferenciadas para ver que tal se ve 101 | series<-matrix(c(t(SerSinTend), t(SerSinTend2)), ncol=2); 102 | matplot(series, pch=1, type= "l") 103 | grid(50,50,col=2) # 104 | 105 | 106 | #Como el filtro quita los valores iniciales y finales (2), quitamos los NA 107 | aux_filter<- SerSinTend2[!is.na(SerSinTend2)]; 108 | 109 | #Vemos los resultados de ACF y PACF para cada modelo de aprox. 110 | acf(SerSinTend) 111 | adf.test(SerSinTend) 112 | acf(aux_filter) 113 | adf.test(aux_filter) 114 | pacf(SerSinTend) 115 | pacf(aux_filter) 116 | 117 | 118 | #Buscamos si hay Estacionalidad. 119 | tiempo <- 1:length(serie) 120 | parametros <- lm (log(serie) ~ tiempo) 121 | plot(parametros) 122 | jarque.bera.test(parametros$residuals) 123 | 124 | 125 | # #Eliminamos la estacionalidad y la tendencia. 126 | # k<- ?; 127 | # estacionalidad<-matrix(nrow=1, ncol=k); 128 | # estacionalidad[,]<- 0 129 | # for (i in 1:k) { 130 | # secuencia<-seq(i, length(SerSinTend), by=k); 131 | # for (j in secuencia) { 132 | # estacionalidad[1,i]<- estacionalidad[1,i] + SerSinTend[j]; 133 | # } 134 | # 135 | # estacionalidad[1,i]<-estacionalidad[1,i]/length(secuencia); 136 | # } 137 | # 138 | # plot.ts(as.numeric(estacionalidad)) 139 | # 140 | # # Mostramos la estacionalidad, repetida por toda la serie 141 | # #estacionalidad<-as.numeric(estacionalidad[1:43]) 142 | # aux<-rep(estacionalidad,length(SerSinTend)/length(estacionalidad)); 143 | # plot.ts(aux) 144 | # series<-matrix(c(t(SerSinTend), t(aux)), ncol=2); 145 | # matplot(series, pch=1, type= "l") 146 | # 147 | # #Nos quedamos con la serie sin tendencia, ni estacionalidad. 148 | # SerSinTendEst<- SerSinTend[1:length(SerSinTend)-1]-aux; 149 | # #Trazamos para ver como se ve la cosa 150 | # plot.ts(SerSinTendEst) 151 | 152 | #Se recalcula esta variables para sobreescribir los valroes. 153 | SerSinTendEst <- SerSinTend 154 | 155 | #Aplicamos el TEST Dickey-Fuller 156 | adf.test(diff(SerSinTendEst)) 157 | acf(SerSinTendEst) 158 | pacf(SerSinTendEst) 159 | #No obteneimos un p-value <=0.01 160 | 161 | #Aplicamos dos diferenciaciones hasta que pase el test. 162 | #Se aplican 2 diferenciaciones 163 | a.diff <- diff(SerSinTendEst) 164 | a.diff <- diff(a.diff) 165 | adf.test(a.diff) 166 | png(file="serie1_acf_pacf_diff.png", bg="transparent",width = 800, height = 400) 167 | par(mfrow=c(1,2)) 168 | acf(a.diff) 169 | pacf(a.diff) 170 | dev.off() 171 | 172 | #Ya podemos entrever el modelo pues el test ha bajado de 0.01 173 | 174 | 175 | #Modelo y prediccion 176 | fit <- auto.arima(SerSinTendEst) 177 | plot(forecast(fit)) 178 | modArima<-auto.arima(SerSinTendEst,D=5,max.P = 5, max.Q = 5) 179 | 180 | #Nos da una idea de como podria ser. 181 | 182 | 183 | 184 | #Elegimos un modelo 185 | modelo321<- arima(SerSinTendEst, order=c(3, 2, 1)); # Ajustamos modelo 186 | modelo320<- arima(SerSinTendEst, order=c(3, 2, 0)); # Ajustamos modelo 187 | #Este parece el mejor, aunque 222 parece ser mas prometedor. 188 | Acf(residuals(modelo320)) 189 | modelo330<- arima(SerSinTendEst, order=c(3, 3, 0)); # Ajustamos modelo 190 | modelo430<- arima(SerSinTendEst, order=c(4, 3, 0)); # Ajustamos modelo 191 | modelo222<- arima(SerSinTendEst, order=c(2, 2, 2)); # Ajustamos modelo 192 | 193 | #nos quedamos con el modelo Arima inicial propuesto. 194 | modelo222 <- modArima 195 | 196 | #Ajustamos los valores 197 | valoresAjustados.H1 <- SerSinTendEst+modelo222$residuals 198 | 199 | #Extraermos las predicciones 200 | Predicciones.H1 <- predict(modelo222,n.ahead=3) 201 | valoresPredichos.H1<- Predicciones.H1$pred 202 | 203 | #Dibujamos la serie, los valores ajustados y los predichos. 204 | plot.ts(SerSinTendEst) 205 | lines(valoresAjustados.H1, col="blue") 206 | lines(valoresPredichos.H1, col="red") 207 | 208 | #Tests sobre el modelo 209 | boxtestM1 <- Box.test(modelo222$residuals) 210 | JB.H1 <- jarque.bera.test(modelo222$residuals) 211 | SW.H1 <- shapiro.test(modelo222$residuals) 212 | #JB y SW tienen p-value <0.01 , luego se acepta el modelo. 213 | 214 | #Reconstruimos el modelo: 215 | tiempo <- 1:length(serie) 216 | parametros <- lm (serie ~ tiempo) 217 | TendEstimada<-parametros$coefficients[1]+tiempo*parametros$coefficients[2] 218 | 219 | tiempoPredicho<- (tiempo[length(tiempo)]+1):(tiempo[length(tiempo)]+3); 220 | TendPredicha<-parametros$coefficients[1]+tiempoPredicho*parametros$coefficients[2] 221 | 222 | #Pintamos para ver como vamos. 223 | plot.ts(SerSinTendEst) 224 | lines(valoresAjustados.H1, col="blue") 225 | lines(valoresPredichos.H1, col="red") 226 | 227 | 228 | #valoresAjustados <- valoresAjustados.H1 + aux 229 | valoresPredichos <- valoresPredichos.H1 + TendPredicha 230 | valoresAjustados <- valoresAjustados.H1 + TendEstimada 231 | 232 | valoresPredichos <- valoresPredichos 233 | valoresAjustados <- valoresAjustados 234 | 235 | #Mostramos los datos con todas las series, ajustada, datos y prediccion 236 | png(file="serie1_final.png", bg="transparent",width = 800, height = 400) 237 | plot.ts(serie) 238 | lines(valoresAjustados,col="blue") 239 | lines(valoresPredichos,col="red") 240 | dev.off() 241 | 242 | 243 | # Imprimimos por pantalla los valores solicitados de la prediccion 244 | print ("VALORES PREDICHOS:") 245 | print (valoresPredichos) 246 | 247 | 248 | 249 | -------------------------------------------------------------------------------- /examples/estudio_01_simple/mineria_series_temporales.R: -------------------------------------------------------------------------------- 1 | #Nombre: Manuel Parra Royón -- 50600285D 2 | #Email: manuelparra@ugr.es 3 | #Ejercicio Guiado. Curso 2014-2015 4 | 5 | 6 | #Constantes 7 | NTest=12 8 | NPred=12 9 | 10 | rm(list=ls()) # Eliminamos lo que haya en el espacio de trabajo 11 | 12 | library("tseries") # para el test ADF 13 | 14 | 15 | 16 | #Carga de los datos 17 | serie <- scan("pasajeros_1949_1959.dat") 18 | #Mostramos la serie para ver que forma tiene 19 | plot.ts(serie) 20 | # Mostramos ACF 21 | serie.ts <- ts(serie, frequency = 12) 22 | #Mostramos la serie descompuesta en diferentes partes: 23 | # tendencia, etc. 24 | plot(decompose(serie.ts)) 25 | 26 | 27 | #Convertimos la serie a logaritmica 28 | serie.ts <- log(serie.ts) 29 | serie.log <- log(serie) 30 | #Volvemos a dibujarla para ver el aspecto que tiene 31 | plot(decompose(serie.ts)) 32 | 33 | 34 | #Dividimos la serie en TEST y TRAIN 35 | #TRAIN 36 | serieTr <- serie.log[1:(length(serie.log)-NTest)] 37 | tiempoTr <- 1:length(serieTr) 38 | #TEST 39 | serieTs <- serie.log[(length(serie.log)-NTest+1):length(serie)] 40 | tiempoTs <- (tiempoTr[length(tiempoTr)]+1):(tiempoTr[length(tiempoTr)]+NTest) 41 | 42 | #Visualizmos la parte de Test (se muestra la serie completa mas el anadido) 43 | plot.ts(serieTr, xlim=c(1,tiempoTs[length(tiempoTs)])) 44 | lines(tiempoTs,serieTs,col="red") 45 | 46 | 47 | #Aplicamos regresion lineal 48 | parametros.H1 <- lm (serieTr ~ tiempoTr ) 49 | #Calculamos la estimacion de la tendecia 50 | 51 | 52 | #Calculamos la tendencia estimada para TEST y TRAIN 53 | #Calculamos la tendencia estimada en el TRAIN 54 | TendEstimadaTrH1 <- parametros.H1$coefficients[1]+tiempoTr*parametros.H1$coefficients[2] 55 | #Calculamos la tendencia estimada en el Test 56 | TendEstimadaTsH1 <- parametros.H1$coefficients[1]+tiempoTs*parametros.H1$coefficients[2] 57 | 58 | 59 | #Mostramos las graficas de la serie de Entrenamiento 60 | plot.ts(serieTr,xlim=c(1,tiempoTs[length(tiempoTs)])) 61 | #Dibujamos la Tendencia Estimada de Train en Azul 62 | lines(tiempoTr,TendEstimadaTrH1,col="blue") 63 | lines(tiempoTs,serieTs,col="red") 64 | #Dibujamos la Tendencia Estimada de Test en Green 65 | lines(tiempoTs,TendEstimadaTsH1,col="green") 66 | 67 | 68 | 69 | #Validacion del modelo. Comprobamos que los errores a lo largo de la serie 70 | #son errores se distribuyen uniformemente (NORMAL) a lo largo del tiempo 71 | #Test de JarqueBera para Train 72 | JBtr <- jarque.bera.test(parametros.H1$residuals) 73 | #Obtenemos 0.41 , luego podemos decir que los datos siguen una 74 | #Distribucion normal. 75 | 76 | #Test de JarqueBera para Test 77 | JBts <- jarque.bera.test((TendEstimadaTsH1-serieTs)) 78 | #Obtenemos > 0.05 , luego podemos decir que los datos siguen una 79 | #Distribucion normal. 80 | 81 | #Comparamos la media del error para Test y Train 82 | #Aplicamos la T-student 83 | TT <- t.test(c(parametros.H1$residuals,TendEstimadaTsH1-serieTs)) 84 | #El resultado es de media 0, y por tanto el modelo lineal es posible 85 | 86 | 87 | 88 | 89 | #Eliminamos la tendencia tanto en Train como en Test 90 | serieTr.SinTend.H1 <- serieTr-TendEstimadaTrH1 91 | serieTs.SinTend.H1 <- serieTs-TendEstimadaTsH1 92 | #Mostramos la serie sin tendencia 93 | plot.ts(serieTr.SinTend.H1,xlim=c(1,tiempoTs[length(tiempoTs)])) 94 | lines(tiempoTs,serieTs.SinTend.H1,col="red") 95 | 96 | #Ahora le quitamos la estacionalidad 97 | 98 | #Como vimos cada doce valores tenemos una estacionalidad 99 | k <- 12 100 | #Extraemos la estacionalidad 101 | estacionalidad.H1 <- decompose(serie.ts)$seasonal[1:k] 102 | #Tenemos 12 valores de estacionalidad 103 | 104 | 105 | 106 | #Calculamos la serie sin la tendencia ni la estacionalidad. 107 | aux <- rep (estacionalidad.H1, length(serieTr)/length(estacionalidad.H1)) 108 | serieTr.SinTendEst.H1 <- serieTr.SinTend.H1-aux 109 | serieTs.SinTendEst.H1 <- serieTs.SinTend.H1-estacionalidad.H1 110 | #Representamos el resultado. 111 | plot.ts(serieTr.SinTendEst.H1, xlim=c(1,tiempoTs[length(tiempoTs)])) 112 | lines(tiempoTs,serieTs.SinTendEst.H1,col="red") 113 | 114 | 115 | 116 | #Test de ADF de la serie de Entrenamiento 117 | adftest.H1 <- adf.test(serieTr.SinTendEst.H1) 118 | #Comprueba la no estacionalidad, luego si es valor >0.05, 119 | # luego no es estacionaria 120 | serieTr.SinTendEstDiff.H1 <- diff(serieTr.SinTendEst.H1) 121 | serieTs.SinTendEstDiff.H1 <- diff(serieTs.SinTendEst.H1) 122 | 123 | #Probamos de nuevo con los datos y comprobamos que es estacionaria 124 | adftest.H1 <- adf.test(serieTr.SinTendEstDiff.H1) 125 | #Obtenemos un p-value < 0.05 126 | 127 | #Compromamos PACF y ACF graficamente 128 | acf(serieTr.SinTendEstDiff.H1) 129 | pacf(serieTr.SinTendEstDiff.H1) 130 | #Luego son graficas tipicas de modelos autoregresivos 131 | #Si contamos las lineas, podemos extraer que se trata 132 | #de un modelo ARIMA de orden 4. 133 | 134 | 135 | 136 | #Arima: 4, Modelo de diferenciacion=1, medias moviles =0 137 | modelo.H1 <- arima(serieTr.SinTendEst.H1,order=c(4,1,0)) 138 | #Valores ajustados del modelo como residuos + la serie sin tendencia 139 | valoresAjustados.H1 <- serieTr.SinTendEst.H1+modelo.H1$residuals 140 | 141 | #Llamamos a la funcion predict para tener los valores de 12 elementos 142 | Predicciones.H1 <- predict(modelo.H1,n.ahead=NPred) 143 | valoresPredichos.H1<- Predicciones.H1$pred 144 | #Valores predichos en una lista (12 valores) 145 | 146 | 147 | #Calculamos el error del ajuste, para ver como de buena es 148 | # nuestra prediccion (error cuadratico) 149 | errorTr.H1 <- sum((modelo.H1$residuals)^2) 150 | errorTs.H1 <- sum((valoresPredichos.H1-serieTs.SinTendEst.H1)^2) 151 | 152 | 153 | 154 | 155 | #Mas resultados 156 | #Vamos dibujar la serie de Entrenamiendo son la Estacionalidad ni la tendencia 157 | plot.ts(serieTr.SinTendEst.H1,xlim=c(1,tiempoTs[length(tiempoTs)])) 158 | lines(valoresAjustados.H1, col="blue") 159 | #Dibujamos la recosntruccion de la serie, parece bastante precisa. 160 | #Para la predicción el ajuste no es muy bueno 161 | lines(tiempoTs,serieTs.SinTendEst.H1, col="red") 162 | lines(tiempoTs,valoresPredichos.H1, col="blue") 163 | 164 | 165 | #Validacion con test estadisticos 166 | #Box Test,para comprobar que los residuos son aleatorios. 167 | boxtestM1 <- Box.test(modelo.H1$residuals) 168 | #Luego obtenemos que son residous son aleaotrios 169 | #Si esto es así los errores son aleaotrios, el modelo es valido con 170 | #respecto a los residuos 171 | 172 | #Aplicamos los test siguientes: 173 | JB.H1 <- jarque.bera.test(modelo.H1$residuals) 174 | SW.H1 <- shapiro.test(modelo.H1$residuals) 175 | #Verificamos los p-values: 176 | #Todos son > 0.05, luego correctas las hipotesis. 177 | # jarque.bera =>Normalidad de residuos 178 | 179 | #Vemos el histograma de los residuos (y densidad) 180 | hist(modelo.H1$residuals,col="blue",prob=T, ylim=c(0,20),xlim=c(-0.2,0.2)) 181 | lines(density(modelo.H1$residuals)) 182 | #Con esto anterior hemos validado el modelo 183 | #de prediccion ARIMA(4,1) y el modelo es valido. 184 | 185 | 186 | 187 | #Ya se ha validado el modelo, luego ahora 188 | #Seguimos los pasos iniciales sin realizar la division de la serie en ajuste y test. 189 | serieEntera <- serie.log 190 | tiempo <- 1:length(serieEntera) 191 | parametros <- lm(serieEntera~tiempo) 192 | TendEstimada <- parametros$coefficients[1]+tiempo*parametros$coefficients[2] 193 | serieSinTend <- serieEntera-TendEstimada 194 | 195 | aux <- ts(serieEntera,frequency=12) 196 | aux <- decompose(aux)$seasonal 197 | estacionalidad<-as.numeric(aux[1:12]) 198 | aux <- rep(estacionalidad,length(serieSinTend)/length(estacionalidad)) 199 | 200 | serieSinTendEst <- serieSinTend - aux 201 | modelo <- arima (serieSinTendEst, order=c(4,1,0)) 202 | valoresAjustados <- serieSinTendEst + modelo$residuals 203 | #Realizmos la prediccion de los valores para NPred valores 204 | #con la funcion predict 205 | Predicciones <- predict (modelo,n.ahead=NPred) 206 | #Almacenamos en valoresPredichos el valor 207 | valoresPredichos <- Predicciones$pred 208 | 209 | 210 | #Ahora deshacemos los cambios para tener las predicciones reales. 211 | valoresAjustados <- valoresAjustados + aux 212 | valoresPredichos <- valoresPredichos + estacionalidad 213 | 214 | valoresAjustados <- valoresAjustados + TendEstimada 215 | tiempoPred <- (tiempo[length(tiempo)]+(1:NPred)) 216 | TendEstimadaPred <- parametros$coefficients[1]+tiempoPred*parametros$coefficients[2] 217 | valoresPredichos <- valoresPredichos+TendEstimadaPred 218 | 219 | #Le damos la vuelta (antes hemos usado log) 220 | valoresAjustados<-exp(valoresAjustados) 221 | valoresPredichos<-exp(valoresPredichos) 222 | 223 | #Pintamos la serie 224 | plot.ts(serie,xlim=c(1,max(tiempoPred)),ylim=c(100,650)) 225 | lines(valoresAjustados, col="blue") 226 | lines(valoresPredichos, col="red") 227 | 228 | write.csv(valoresPredichos,file = "valores_predichos.csv") 229 | 230 | 231 | 232 | -------------------------------------------------------------------------------- /analisisgrafico/PPStech.csv: -------------------------------------------------------------------------------- 1 | date,Apple,IBM,Intel 2 | 2016-05-02,90.52,147.72,29.91 3 | 2016-04-01,93.173,144.545,30.021 4 | 2016-03-01,108.33,150.002,32.073 5 | 2016-02-01,96.105,129.778,29.337 6 | 2016-01-04,96.229,122.348,30.486 7 | 2015-12-01,104.058,134.926,33.857 8 | 2015-11-02,116.95,136.691,34.171 9 | 2015-10-01,117.632,136.062,33.044 10 | 2015-09-01,108.576,140.812,29.414 11 | 2015-08-03,110.998,143.648,27.853 12 | 2015-07-01,118.866,156.048,28.02 13 | 2015-06-01,122.913,156.693,29.443 14 | 2015-05-01,127.666,163.427,33.353 15 | 2015-04-01,122.129,163.768,31.278 16 | 2015-03-02,121.426,153.451,30.048 17 | 2015-02-02,125.359,154.828,31.951 18 | 2015-01-02,113.882,145.556,31.523 19 | 2014-12-01,107.292,152.326,34.624 20 | 2014-11-03,115.603,153.968,35.539 21 | 2014-10-01,104.525,155.024,32.237 22 | 2014-09-02,97.508,179.004,33.005 23 | 2014-08-01,99.202,181.333,33.099 24 | 2014-07-01,92.066,179.676,31.911 25 | 2014-06-02,89.495,169.927,29.095 26 | 2014-05-01,87.086,172.824,25.725 27 | 2014-04-01,80.732,183.11,24.917 28 | 2014-03-03,73.433,179.401,24.096 29 | 2014-02-03,71.996,172.578,23.115 30 | 2014-01-02,68.081,163.768,22.694 31 | 2013-12-02,76.298,173.862,24.007 32 | 2013-11-01,75.625,166.549,22.046 33 | 2013-10-01,70.674,165.226,22.419 34 | 2013-09-03,64.461,170.73,20.999 35 | 2013-08-01,65.876,168.047,20.138 36 | 2013-07-01,60.785,178.926,21.177 37 | 2013-06-03,53.263,175.321,21.984 38 | 2013-05-01,60.409,190.834,22.029 39 | 2013-04-01,59.084,184.939,21.527 40 | 2013-03-01,59.068,194.764,19.631 41 | 2013-02-01,58.9,183.378,18.768 42 | 2013-01-02,60.428,184.646,18.71 43 | 2012-12-03,70.601,174.171,18.337 44 | 2012-11-01,77.647,172.826,17.403 45 | 2012-10-01,78.619,176.11,19.039 46 | 2012-09-04,88.099,187.807,19.946 47 | 2012-08-01,87.853,176.4,21.856 48 | 2012-07-02,80.314,176.669,22.425 49 | 2012-06-01,76.795,176.308,23.254 50 | 2012-05-01,75.97,173.892,22.547 51 | 2012-04-02,76.792,185.896,24.603 52 | 2012-03-01,78.84,187.305,24.36 53 | 2012-02-01,71.33,176.605,23.286 54 | 2012-01-03,60.026,172.227,22.706 55 | 2011-12-01,53.257,164.429,20.841 56 | 2011-11-01,50.258,168.113,21.408 57 | 2011-10-03,53.228,164.439,20.904 58 | 2011-09-01,50.143,155.746,18.179 59 | 2011-08-01,50.604,153.11,17.148 60 | 2011-07-01,51.347,161.261,18.838 61 | 2011-06-01,44.14,152.127,18.695 62 | 2011-05-02,45.739,149.803,18.99 63 | 2011-04-01,46.041,150.593,19.378 64 | 2011-03-01,45.828,143.963,16.892 65 | 2011-02-01,46.446,142.913,17.971 66 | 2011-01-03,44.62,142.454,17.812 67 | 2010-12-01,42.416,129.053,17.455 68 | 2010-11-01,40.916,124.393,17.563 69 | 2010-10-01,39.578,125.716,16.513 70 | 2010-09-01,37.313,117.434,15.813 71 | 2010-08-02,31.967,107.795,14.552 72 | 2010-07-01,33.828,111.855,16.837 73 | 2010-06-01,33.076,107.569,15.897 74 | 2010-05-03,33.779,109.119,17.507 75 | 2010-04-01,34.333,111.804,18.537 76 | 2010-03-01,30.902,111.154,18.091 77 | 2010-02-01,26.907,110.209,16.662 78 | 2010-01-04,25.255,105.603,15.62 79 | 2009-12-01,27.711,112.946,16.425 80 | 2009-11-02,26.288,109.02,15.459 81 | 2009-10-01,24.787,103.602,15.27 82 | 2009-09-01,24.373,102.743,15.638 83 | 2009-08-03,22.119,101.403,16.237 84 | 2009-07-01,21.485,100.83,15.271 85 | 2009-06-01,18.729,89.279,13.129 86 | 2009-05-01,17.859,90.869,12.47 87 | 2009-04-01,16.546,87.786,12.413 88 | 2009-03-02,13.823,82.41,11.823 89 | 2009-02-02,11.744,78.276,10.022 90 | 2009-01-02,11.852,77.532,10.044 91 | 2008-12-01,11.223,71.195,11.414 92 | 2008-11-03,12.186,69.03,10.745 93 | 2008-10-01,14.148,78.211,12.373 94 | 2008-09-02,14.946,98.393,14.458 95 | 2008-08-01,22.293,102.405,17.653 96 | 2008-07-01,20.902,107.245,17.022 97 | 2008-06-02,22.018,99.326,16.477 98 | 2008-05-01,24.82,108.46,17.781 99 | 2008-04-01,22.874,100.733,16.974 100 | 2008-03-03,18.87,96.093,16.151 101 | 2008-02-01,16.44,95.025,15.228 102 | 2008-01-02,17.8,89.051,15.992 103 | 2007-12-03,26.047,89.874,20.207 104 | 2007-11-01,23.962,87.446,19.767 105 | 2007-10-01,24.978,96.2,20.303 106 | 2007-09-04,20.181,97.592,19.518 107 | 2007-08-01,18.21,96.673,19.435 108 | 2007-07-02,17.326,91.346,17.744 109 | 2007-06-01,16.048,86.888,17.834 110 | 2007-05-01,15.936,88.002,16.662 111 | 2007-04-02,13.123,84.051,16.068 112 | 2007-03-01,12.217,77.513,14.297 113 | 2007-02-01,11.126,76.428,14.843 114 | 2007-01-03,11.273,81.29,15.581 115 | 2006-12-01,11.156,79.65,15.054 116 | 2006-11-01,12.053,75.362,15.908 117 | 2006-10-02,10.662,75.453,15.787 118 | 2006-09-01,10.123,66.963,15.217 119 | 2006-08-01,8.922,66.17,14.478 120 | 2006-07-03,8.937,63.009,13.24 121 | 2006-06-01,7.531,62.529,13.976 122 | 2006-05-01,7.86,65.036,13.255 123 | 2006-04-03,9.256,66.781,14.622 124 | 2006-03-01,8.248,66.886,14.241 125 | 2006-02-01,9.006,65.077,15.076 126 | 2006-01-03,9.929,65.772,15.485 127 | 2005-12-01,9.453,66.5,18.18 128 | 2005-11-01,8.918,71.92,19.433 129 | 2005-10-03,7.573,66.083,17.058 130 | 2005-09-01,7.05,64.743,17.893 131 | 2005-08-01,6.166,65.066,18.67 132 | 2005-07-01,5.608,67.196,19.643 133 | 2005-06-01,4.84,59.741,18.833 134 | 2005-05-02,5.228,60.828,19.513 135 | 2005-04-01,4.742,61.333,16.966 136 | 2005-03-01,5.48,73.378,16.757 137 | 2005-02-01,5.899,74.342,17.305 138 | 2005-01-03,5.056,74.873,16.137 139 | 2004-12-01,4.234,79.009,16.812 140 | 2004-11-01,4.408,75.531,16.087 141 | 2004-10-01,3.445,71.793,15.972 142 | 2004-09-01,2.548,68.585,14.393 143 | 2004-08-02,2.268,67.746,15.276 144 | 2004-07-01,2.126,69.502,17.464 145 | 2004-06-01,2.139,70.364,19.771 146 | 2004-05-03,1.845,70.716,20.451 147 | 2004-04-01,1.695,70.238,18.403 148 | 2004-03-01,1.778,73.161,19.455 149 | 2004-02-02,1.573,76.874,20.885 150 | 2004-01-02,1.483,78.921,21.801 151 | 2003-12-01,1.405,73.711,22.894 152 | 2003-11-03,1.375,72.009,23.959 153 | 2003-10-01,1.505,71.037,23.523 154 | 2003-09-02,1.362,70.124,19.647 155 | 2003-08-01,1.487,65.107,20.411 156 | 2003-07-01,1.386,64.374,17.755 157 | 2003-06-02,1.253,65.365,14.845 158 | 2003-05-01,1.18,69.754,14.852 159 | 2003-04-01,0.935,67.143,13.112 160 | 2003-03-03,0.93,62.027,11.601 161 | 2003-02-03,0.987,61.647,12.292 162 | 2003-01-02,0.944,61.725,11.145 163 | 2002-12-02,0.942,61.172,11.081 164 | 2002-11-01,1.019,68.607,14.86 165 | 2002-10-01,1.057,62.194,12.299 166 | 2002-09-03,0.953,45.941,9.875 167 | 2002-08-01,0.97,59.389,11.851 168 | 2002-07-01,1.003,55.343,13.342 169 | 2002-06-03,1.165,56.601,12.973 170 | 2002-05-01,1.532,63.244,19.612 171 | 2002-04-01,1.596,65.717,20.3 172 | 2002-03-01,1.556,81.597,21.578 173 | 2002-02-01,1.427,76.984,20.258 174 | 2002-01-02,1.625,84.537,24.848 175 | 2001-12-03,1.44,94.778,22.302 176 | 2001-11-01,1.4,90.571,23.16 177 | 2001-10-01,1.155,84.574,17.304 178 | 2001-09-04,1.02,71.779,14.484 179 | 2001-08-01,1.22,78.22,19.812 180 | 2001-07-02,1.235,82.227,21.11 181 | 2001-06-01,1.529,88.707,20.714 182 | 2001-05-01,1.312,87.378,19.127 183 | 2001-04-02,1.676,89.88,21.875 184 | 2001-03-01,1.451,75.079,18.622 185 | 2001-02-01,1.2,77.983,20.214 186 | 2001-01-02,1.422,87.329,26.171 187 | 2000-12-01,0.978,66.276,21.264 188 | 2000-11-01,1.085,72.904,26.922 189 | 2000-10-02,1.286,76.705,31.816 190 | 2000-09-01,1.693,87.705,29.385 191 | 2000-08-01,4.007,102.805,52.938 192 | 2000-07-03,3.341,87.315,47.178 193 | 2000-06-01,3.444,85.224,47.245 194 | 2000-05-01,2.761,83.474,44.064 195 | 2000-04-03,4.078,86.627,44.804 196 | 2000-03-01,4.465,91.968,46.615 197 | 2000-02-01,3.768,79.829,39.924 198 | 2000-01-03,3.411,87.118,34.945 199 | 1999-12-01,3.38,83.723,29.073 200 | 1999-11-01,3.218,79.988,27.086 201 | 1999-10-01,2.634,76.151,27.341 202 | 1999-09-01,2.081,93.784,26.237 203 | 1999-08-02,2.145,96.545,29.018 204 | 1999-07-01,1.831,97.322,24.352 205 | 1999-06-01,1.522,100.081,20.999 206 | 1999-05-03,1.449,89.821,19.08 207 | 1999-04-01,1.512,80.897,21.584 208 | 1999-03-01,1.181,68.546,20.967 209 | 1999-02-01,1.144,65.646,21.154 210 | 1999-01-04,1.354,70.773,24.847 211 | 1998-12-01,1.346,71.207,20.902 212 | 1998-11-02,1.05,63.773,18.974 213 | 1998-10-01,1.22,57.267,15.716 214 | 1998-09-01,1.253,49.555,15.111 215 | 1998-08-03,1.025,43.433,12.545 216 | 1998-07-01,1.138,51.01,14.874 217 | 1998-06-01,0.943,44.201,13.057 218 | 1998-05-01,0.875,45.235,12.584 219 | 1998-04-01,0.9,44.526,14.235 220 | 1998-03-02,0.904,39.915,13.746 221 | 1998-02-02,0.777,40.131,15.793 222 | 1998-01-02,0.602,37.87,14.263 223 | 1997-12-01,0.431,40.123,12.365 224 | 1997-11-03,0.584,41.992,13.664 225 | 1997-10-01,0.56,37.7,13.554 226 | 1997-09-02,0.713,40.571,16.243 227 | 1997-08-01,0.715,38.801,16.21 228 | 1997-07-01,0.575,40.4,16.155 229 | 1997-06-02,0.468,34.479,12.472 230 | 1997-05-01,0.547,33.046,13.324 231 | 1997-04-01,0.559,30.658,13.467 232 | 1997-03-03,0.6,26.217,12.232 233 | 1997-02-03,0.534,27.459,12.474 234 | 1997-01-02,0.547,29.895,14.265 235 | 1996-12-02,0.686,28.871,11.508 236 | 1996-11-01,0.793,30.372,11.151 237 | 1996-10-01,0.756,24.517,9.657 238 | 1996-09-03,0.729,23.662,8.384 239 | 1996-08-01,0.797,21.738,7.011 240 | 1996-07-01,0.723,20.366,6.6 241 | 1996-06-03,0.69,18.755,6.447 242 | 1996-05-01,0.859,20.224,6.628 243 | 1996-04-01,0.801,20.346,5.948 244 | 1996-03-01,0.807,21.006,4.99 245 | 1996-02-01,0.904,23.154,5.16 246 | 1996-01-02,0.908,20.443,4.846 247 | 1995-12-01,1.048,17.216,4.975 248 | 1995-11-01,1.253,18.205,5.337 249 | 1995-10-02,1.19,18.277,6.126 250 | 1995-09-01,1.221,17.76,5.268 251 | 1995-08-01,1.409,19.428,5.378 252 | 1995-07-03,1.471,20.414,5.695 253 | 1995-06-01,1.518,18,5.544 254 | 1995-05-01,1.358,17.438,4.915 255 | 1995-04-03,1.247,17.695,4.482 256 | 1995-03-01,1.149,15.358,3.714 257 | 1995-02-01,1.287,14.072,3.49 258 | 1995-01-03,1.312,13.443,3.036 259 | 1994-12-01,1.268,13.699,2.793 260 | 1994-11-01,1.211,13.186,2.76 261 | 1994-10-03,1.4,13.838,2.716 262 | 1994-09-01,1.092,12.932,2.686 263 | 1994-08-01,1.173,12.723,2.872 264 | 1994-07-01,1.088,11.447,2.588 265 | 1994-06-01,0.856,10.869,2.552 266 | 1994-05-02,0.945,11.655,2.727 267 | 1994-04-04,0.965,10.592,2.661 268 | 1994-03-01,1.07,10.062,2.943 269 | 1994-02-01,1.174,9.74,2.997 270 | 1994-01-03,1.05,10.361,2.845 271 | 1993-12-01,0.937,10.361,2.701 272 | 1993-11-01,1.01,9.88,2.679 273 | 1993-10-01,0.982,8.394,2.755 274 | 1993-09-01,0.747,7.664,3.08 275 | 1993-08-02,0.846,8.348,2.797 276 | 1993-07-01,0.882,8.074,2.274 277 | 1993-06-01,1.256,8.959,2.392 278 | 1993-05-03,1.8,9.571,2.411 279 | 1993-04-01,1.626,8.726,2.068 280 | 1993-03-01,1.634,9.13,2.498 281 | 1993-02-01,1.682,9.758,2.53 282 | 1993-01-04,1.884,9.145,2.318 283 | 1992-12-01,1.892,8.945,1.888 284 | 1992-11-02,1.82,12.119,1.552 285 | 1992-10-01,1.659,11.664,1.465 286 | 1992-09-01,1.426,14.084,1.425 287 | 1992-08-03,1.453,15.109,1.257 288 | 1992-07-01,1.473,16.308,1.295 289 | 1992-06-01,1.512,16.846,1.235 290 | 1992-05-01,1.879,15.62,1.083 291 | 1992-04-01,1.891,15.417,1.159 292 | 1992-03-02,1.832,14.186,1.197 293 | 1992-02-03,2.123,14.759,1.376 294 | 1992-01-02,2.032,15.087,1.297 295 | 1991-12-02,1.769,14.919,1.062 296 | 1991-11-01,1.593,15.506,0.888 297 | 1991-10-01,1.612,16.267,0.88 298 | 1991-09-03,1.55,17.157,0.915 299 | 1991-08-01,1.659,16.04,1.073 300 | 1991-07-01,1.445,16.563,1.018 301 | 1991-06-03,1.296,15.889,1.008 302 | 1991-05-01,1.468,17.361,1.208 303 | 1991-04-01,1.714,16.653,1.067 304 | 1991-03-01,2.119,18.411,1.013 305 | 1991-02-01,1.784,20.816,1.035 306 | 1991-01-02,1.726,20.297,0.991 307 | 1990-12-03,1.337,18.095,0.834 308 | 1990-11-01,1.143,18.196,0.813 309 | 1990-10-01,0.953,16.706,0.726 310 | 1990-09-04,0.899,16.844,0.72 311 | 1990-08-01,1.147,16.132,0.723 312 | 1990-07-02,1.298,17.458,0.964 313 | 1990-06-01,1.383,18.398,1.018 314 | 1990-05-01,1.275,18.789,1.045 315 | 1990-04-02,1.213,16.878,0.856 316 | 1990-03-01,1.24,16.433,0.905 317 | 1990-02-01,1.048,16.084,0.872 318 | 1990-01-02,1.044,15.084,0.856 319 | 1989-12-01,1.083,14.395,0.748 320 | 1989-11-01,1.359,14.931,0.753 321 | 1989-10-02,1.425,15.147,0.731 322 | 1989-09-01,1.363,16.506,0.699 323 | 1989-08-01,1.363,17.696,0.65 324 | 1989-07-03,1.215,17.191,0.661 325 | 1989-06-01,1.261,16.724,0.628 326 | 1989-05-01,1.459,16.387,0.704 327 | 1989-04-03,1.189,16.875,0.628 328 | 1989-03-01,1.086,16.135,0.569 329 | 1989-02-01,1.106,17.965,0.558 330 | 1989-01-03,1.148,19.151,0.563 331 | 1988-12-01,1.224,17.868,0.515 332 | 1988-11-01,1.144,17.373,0.433 333 | 1988-10-03,1.172,17.816,0.536 334 | 1988-09-01,1.312,16.763,0.596 335 | 1988-08-01,1.21,16.2,0.607 336 | 1988-07-01,1.344,18.11,0.753 337 | 1988-06-01,1.4,18.344,0.783 338 | 1988-05-02,1.256,16.202,0.666 339 | 1988-04-04,1.239,16.169,0.672 340 | 1988-03-01,1.209,15.349,0.636 341 | 1988-02-01,1.299,16.758,0.612 342 | 1988-01-04,1.252,15.865,0.553 343 | 1987-12-01,1.267,16.306,0.574 344 | 1987-11-02,0.995,15.636,0.466 345 | 1987-10-01,1.162,17.137,0.563 346 | 1987-09-01,1.7,21.089,0.834 347 | 1987-08-03,1.625,23.554,0.762 348 | 1987-07-01,1.24,22.368,0.69 349 | 1987-06-01,1.217,22.576,0.636 350 | 1987-05-01,1.187,22.229,0.634 351 | 1987-04-01,1.189,22.1,0.679 352 | 1987-03-02,0.968,20.719,0.567 353 | 1987-02-02,1.05,19.253,0.549 354 | 1987-01-02,0.833,17.625,0.451 355 | 1986-12-01,0.608,16.427,0.303 356 | 1986-11-03,0.6,17.402,0.332 357 | 1986-10-01,0.52,16.775,0.293 358 | 1986-09-02,0.503,18.251,0.282 359 | 1986-08-01,0.555,18.828,0.332 360 | 1986-07-01,0.469,17.829,0.264 361 | 1986-06-02,0.538,19.713,0.332 362 | 1986-05-01,0.555,20.503,0.394 363 | 1986-04-01,0.454,20.872,0.412 364 | 1986-03-03,0.424,20.237,0.376 365 | 1986-02-03,0.375,20.154,0.401 366 | 1986-01-02,0.347,20.093,0.408 367 | 1985-12-02,0.33,20.624,0.423 368 | 1985-11-01,0.302,18.535,0.412 369 | 1985-10-01,0.279,17.083,0.368 370 | 1985-09-03,0.236,16.294,0.372 371 | 1985-08-01,0.225,16.656,0.376 372 | 1985-07-01,0.238,17.133,0.408 373 | 1985-06-03,0.27,16.139,0.376 374 | 1985-05-01,0.261,16.775,0.381 375 | 1985-04-01,0.319,16.353,0.397 376 | 1985-03-01,0.332,16.418,0.401 377 | 1985-02-01,0.371,17.322,0.404 378 | 1985-01-02,0.435,17.487,0.444 379 | 1984-12-03,0.437,15.788,0.404 380 | 1984-11-01,0.371,15.612,0.412 381 | 1984-10-01,0.373,15.981,0.401 382 | 1984-09-04,0.377,15.794,0.448 383 | 1984-08-01,0.398,15.731,0.52 384 | 1984-07-02,0.383,13.935,0.441 385 | 1984-06-01,0.398,13.321,0.437 386 | 1984-05-01,0.441,13.573,0.446 387 | 1984-04-02,0.471,14.211,0.506 388 | 1984-03-01,0.371,14.226,0.52 389 | 1984-02-01,0.394,13.773,0.538 390 | 1984-01-03,0.371,14.139,0.531 391 | 1983-12-01,0.366,15.115,0.607 392 | 1983-11-01,0.306,14.542,0.603 393 | 1983-10-03,0.339,15.586,0.545 394 | 1983-09-01,0.347,15.601,0.596 395 | 1983-08-01,0.559,14.694,0.592 396 | 1983-07-01,0.523,14.686,0.581 397 | 1983-06-01,0.733,14.67,0.538 398 | 1983-05-02,0.866,13.572,0.413 399 | 1983-04-04,0.758,14.158,0.358 400 | 1983-03-01,0.634,12.312,0.348 401 | 1983-02-01,0.685,11.98,0.336 402 | 1983-01-03,0.613,11.857,0.311 403 | 1982-12-01,0.448,11.542,0.28 404 | 1982-11-01,0.478,10.373,0.276 405 | 1982-10-01,0.381,9.482,0.268 406 | 1982-09-01,0.274,8.71,0.237 407 | 1982-08-02,0.27,8.369,0.265 408 | 1982-07-01,0.203,7.688,0.233 409 | 1982-06-01,0.191,7.103,0.226 410 | 1982-05-03,0.21,7.205,0.218 411 | 1982-04-01,0.221,7.428,0.228 412 | 1982-03-01,0.253,6.908,0.208 413 | 1982-02-01,0.274,7.153,0.184 414 | 1982-01-04,0.306,7.255,0.188 415 | 1981-12-01,0.332,6.485,0.163 416 | 1981-11-02,0.279,6.214,0.181 417 | 1981-10-01,0.3,5.777,0.206 418 | 1981-09-01,0.229,6.071,0.175 419 | 1981-08-03,0.302,6.184,0.202 420 | 1981-07-01,0.375,6.203,0.244 421 | 1981-06-01,0.39,6.396,0.26 422 | 1981-05-01,0.497,6.493,0.296 423 | 1981-04-01,0.426,6.383,0.273 424 | 1981-03-02,0.368,6.791,0.262 425 | 1981-02-02,0.398,6.995,0.253 426 | 1981-01-02,0.424,6.916,0.269 427 | 1980-12-01,0.512,7.292,0.291 428 | -------------------------------------------------------------------------------- /analisisgrafico/analisisgrafico.md: -------------------------------------------------------------------------------- 1 | # Análisis gráfico de series 2 | 3 | ``` 4 | library(lessR) 5 | theme(colors="gray") 6 | library(tidyverse) 7 | ``` 8 | 9 | # Plot Time Series 10 | 11 | 12 | # Single Time Series 13 | 14 | Plot a time series of values over a range of dates. 15 | 16 | ggplot wants the date to be its own variable in the data table, so the data table contains a column of dates and at least one column of values that are to be plotted against the dates, one value for each date. date fields in the data file with values such as 2016-05-02 are initially read as a character strings, so need to interpret them as a date class, instead of character strings, integers, etc. 17 | 18 | Data file for this example, ```PPStech.csv```, contains a date column and corresponding stock prices for Apple, IBM, Intel in this example, the name of the variable that contains the dates is date. 19 | 20 | *Option 1*: read the dates in the data file as character strings, then convert 21 | 22 | ``` 23 | mydata <- Read("./PPStech.csv") 24 | ``` 25 | 26 | #' the R as.Date function converts from class character to class date 27 | #' then save the result into the data table with lessR Transform function 28 | #' or base R transform function 29 | #' As always, lessR functions default to data=mydata. To illustrate, the following leads to the same result as the above. 30 | 31 | ``` 32 | mydata <- Transform(date=as.Date(date), quiet=TRUE) 33 | ``` 34 | or 35 | 36 | *Option 2*: use the R colClasses option to instruct R how to read the data values under the Date column directly as dates. 37 | 38 | For large data sets, the use of the colClasses option can drastically speed up reading a data table because R does not have to do the work of examining all the data values to infer the corresponding class of each variable. Instead you inform R as how to read the data values for specified columns, as integer, numeric, factor, date, etc. 39 | 40 | ``` 41 | mydata <- Read("./PPStech.csv", 42 | colClasses=list(date="Date")) 43 | ``` 44 | 45 | After reading the data into the R data table mydata, the data table begins with the following. 46 | head(mydata, n=3) 47 | 48 | This data table is in what is called the *wide format*, as it has multiple (three) measurements per row. However, the data is *not* tidy data because the each of the three measurements represents a *different* observation. 49 | 50 | 51 | 52 | ## lessR 53 | 54 | Standard time series plot with dates on the x-axis. 55 | 56 | ´´´ 57 | Plot(date, Apple) 58 | ´´´ 59 | 60 | lessR also accepts input as an R times series. First sort the data so as to have the data begin with the most distant date and end with the most recent date. 61 | 62 | ´´´ 63 | mydata <- Sort(date, quiet=TRUE) 64 | Apple.ts <- ts(mydata$Apple, frequency=12, start=c(1980, 12)) 65 | Plot(Apple.ts) 66 | ´´´ 67 | 68 | 69 | ## ggplot2 70 | 71 | ggplot time series of single variable in which the time series can be plotted as a line and/or an area, for which there are specific geoms. 72 | 73 | 74 | ggplot requires tidy formatted data. To plot a single time series, just need two columns of the data table, the column of dates and one column of measurements. Although the data table is not tidy, de facto reading just the date and the stock prices for a single company acts as tidy data, ignoring the other measurements in each data row. 75 | 76 | Plot line only. 77 | 78 | ´´´ 79 | ggplot(mydata, aes(date, Apple)) + geom_line() 80 | ´´´ 81 | 82 | Plot area only. 83 | 84 | ´´´ 85 | ggplot(mydata, aes(date, Apple)) + geom_area() 86 | ´´´ 87 | 88 | Plot customized area. 89 | 90 | ´´´ 91 | ggplot(mydata, aes(date, Apple)) + geom_area(fill="green", alpha=.2) 92 | ´´´ 93 | 94 | Plot customized line and area. 95 | 96 | ´´´ 97 | ggplot(mydata, aes(date, Apple)) + 98 | geom_area(fill=rgb(0,1,0), alpha=.2) + 99 | geom_line(color="darkgreen") 100 | ´´´ 101 | 102 | Can modify the format of the displayed dates with the ggplot scale_x_date function. The scales package is needed for the date_format function. 103 | 104 | ´´´ 105 | library(scales) 106 | ´´´ 107 | 108 | 109 | See ?strptime for date formats, e.g., %b is the abbreviated month name. 110 | 111 | ´´´ 112 | ggplot(mydata, aes(date, Apple)) + geom_line() + 113 | scale_x_date(labels=date_format("%b-%Y")) 114 | ´´´ 115 | 116 | 117 | ## Multiple Time Series on the Same Graph 118 | 119 | The data table as read is in *wide format*, multiple measurements per row. *Not* in tidy format because multiple observations, that is, measurements from different companies, appear in the same row. 120 | 121 | ## lessR 122 | 123 | For lessR, specify the multiple variables as a vector. lessR accepts the data in this non-tidy wide format. 124 | 125 | ´´´ 126 | Plot(date, c(Apple, IBM, Intel)) 127 | ´´´ 128 | 129 | An alternate format for the different plots is to successively stack the plots on top of each other, according to the parameter stack. By default the area under each plot is filled according to a lighter color than its stroke (border). (Currently no way to specify the area fill color.) 130 | Plot(date, c(Apple, IBM, Intel), stack=TRUE) 131 | 132 | Go to a black background. Can also invoke colors orange.black or gray.black with the lessR theme function. 133 | 134 | ´´´ 135 | Plot(date, c(Apple, IBM, Intel), stack=TRUE, bg="black", grid="off") 136 | ´´´ 137 | 138 | 139 | Turn off the area fill by setting area to FALSE. 140 | 141 | ´´´ 142 | Plot(date, c(Apple, IBM, Intel), stack=TRUE, area=FALSE) 143 | ´´´ 144 | 145 | Turn off the border by setting line.width=0. 146 | 147 | ´´´ 148 | Plot(date, c(Apple, IBM, Intel), stack=TRUE, line.width=0) 149 | ´´´ 150 | 151 | Can easily change the order of the plots by changing the order of the variables in the input vector. 152 | 153 | ´´´ 154 | Plot(date, c(Intel, Apple, IBM)) # new order 155 | ´´´ 156 | 157 | lessR also accepts the data from a multivariate R time series. However, to create the time series the data must be ordered from oldest to most recent. To do so, use the lessR Sort function, as base R does not have a function for sorting a data frame. 158 | 159 | ´´´ 160 | mydata <- Sort(date, quiet=TRUE) 161 | ´´´ 162 | 163 | To create the multivariate time series, first create an R matrix form of the stock prices for the three companies. Then apply the ts function. 164 | 165 | ´´´ 166 | a <- as.matrix(mydata[, c("Apple", "IBM", "Intel")], nrow=nrow(mydata), ncol=3) 167 | a.ts <- ts(a, frequency=12, start=c(1980, 12)) 168 | ´´´ 169 | 170 | Feed the multivariate time series directly into the lessR Plot function. 171 | 172 | ´´´ 173 | Plot(a.ts) 174 | ´´´ 175 | 176 | As before, can also stack the time series plots. 177 | 178 | ´´´ 179 | Plot(a.ts, stack=TRUE) 180 | ´´´ 181 | 182 | ## ggplot2 183 | 184 | Consistent with Hadley Wickham's tidyverse that emphasizes tidy data, ggplot2 requires input data to be tidy. To plot multiple time series on the same graph, here by company, tidy format dictates one observation per row. 185 | 186 | Tidy the data table to *long format*, with one observation per row. To reshape to tidy data, use the melt function from Hadley Wickham's reshape2 package. That is, melt the wide form of the data table with multiple observations per row to the long form, i.e., tidy form. 187 | 188 | ´´´ 189 | library(reshape2) 190 | ´´´ 191 | 192 | The *melt* function refers to three different types of variables. 193 | 194 | * id.vars: x-axis variable, here the dates to be plotted against 195 | 196 | * value.name: y-axis variable, the measured values plotted against the dates 197 | 198 | * variable.name: the grouping variable Company 199 | 200 | The variable Company is created from the variables in the existing wide form of the data table: Apple, IBM, and Intel. 201 | 202 | 203 | Function melt presumes by default that after the ID variable and variable names, all remaining variables are measured variables, here Apple, IBM and Intel. melt then takes the measurements for these variables and puts them under the variable specified as the value.name, and takes the name of each of the original variables and defines these names as values of the corresponding grouping variable Company. 204 | 205 | 206 | Here leave the original wide form of the data in data frame mydata alone and instead create a new data frame in long format called myd. 207 | 208 | ´´´ 209 | myd <- melt(mydata, id.vars="date", variable.name="Company", value.name="Price") 210 | ´´´ 211 | 212 | The newly created variable Company has three values: Apple, IBM, Intel. 213 | 214 | ´´´ 215 | head(myd, n=3) 216 | ´´´ 217 | 218 | Now can plot each time series in a different color. 219 | 220 | ´´´ 221 | ggplot(myd, aes(date, Price, color=Company)) + geom_line() 222 | ´´´ 223 | 224 | Or, differentiate the plots from each other by the type of plotting line. 225 | 226 | ´´´ 227 | ggplot(myd, aes(date, Price, linetype=Company)) + geom_line() 228 | ´´´ 229 | 230 | 231 | Stacked area plot, each area (region) plotted separately. 232 | 233 | ´´´ 234 | ggplot(myd, aes(date, Price, fill=Company)) + geom_area() 235 | ´´´ 236 | 237 | Change the order of the stacking by using the R factor function to re-order the levels of the grouping variable Company, a factor, which defines the stack order. 238 | 239 | ´´´ 240 | myd <- Transform(Company=factor(Company, levels=c("Intel", "Apple", "IBM")), data=myd, quiet=TRUE) 241 | ´´´ 242 | 243 | Then reorder the data frame according to this order. General specification is myd[rows,columns], so myd[rows, ] means no change to the columns. 244 | 245 | ´´´ 246 | myd <- myd[order(myd$Company), ] 247 | ´´´ 248 | 249 | Plot with new order. 250 | 251 | ´´´ 252 | ggplot(myd, aes(date, Price, fill=Company)) + geom_area() 253 | ´´´ 254 | 255 | 256 | ## ggplot2 Faceted Time Series 257 | 258 | With ggplot2, can plot each time series separately in its own graph, stacked vertically for comparison. 259 | 260 | ´´´ 261 | ggplot(myd, aes(date, Price, fill=Company)) + geom_area() + facet_grid(Company ~ .) 262 | ´´´ 263 | 264 | Retain the gray scale, with a narrow black border at top of each graph. 265 | 266 | ´´´ 267 | ggplot(myd, aes(date, Price, fill=Company)) + 268 | geom_area(color="black", size=.25, fill="darkgray") + 269 | facet_grid(Company ~ .) 270 | ´´´ 271 | 272 | ## ggplot2 Customization 273 | 274 | PACKAGE RColorBrewer has functions that generate gradients of colors. But to see all the scales, need a RColorBrewer function, so load the library. 275 | 276 | ´´´ 277 | library(RColorBrewer) 278 | ´´´ 279 | 280 | Display built-in color scales from the RColorBrewer library that are synchronized with ggplot via special ggplot functions. 281 | 282 | ´´´ 283 | display.brewer.all() 284 | ´´´ 285 | 286 | Use ggplot functions scale_fill_brewer or scale_color_brewer, the distinction between filling in the interior of a region and the border of the region. 287 | 288 | Use the default brewer scale, "Blues". 289 | 290 | ´´´ 291 | ggplot(myd, aes(date, Price, fill=Company)) + geom_area() + 292 | scale_fill_brewer() 293 | ´´´ 294 | 295 | Specify the gray brewer scale. 296 | 297 | ´´´ 298 | ggplot(myd, aes(date, Price, fill=Company)) + geom_area() + 299 | scale_fill_brewer(palette="Greys") 300 | ´´´ 301 | 302 | An explicit gray scale function, from which can specify start and end points of grayness, where 0 is black, 1 is white. 303 | 304 | ´´´ 305 | ggplot(myd, aes(date, Price, fill=Company)) + geom_area() + 306 | scale_fill_grey(start=.4, end=.8) 307 | ´´´ 308 | 309 | Can also manually specify discrete color ranges, here toned down a bit with some alpha transparency. 310 | 311 | ´´´ 312 | ggplot(myd, aes(date, Price, fill=Company)) + geom_area(alpha=.7) + 313 | scale_fill_manual(values=c(Apple="blue", IBM="red", Intel="green")) 314 | ´´´ 315 | 316 | The ggplot scales are based on the hls (or hsl) color model: hue lightness (luminance) saturation. 317 | 318 | HSL Color Picker: http://www.workwithcolor.com/hsl-color-picker-01.htm 319 | 320 | Darken colors: changed default luminosity from 65 down to 45. 321 | 322 | ´´´ 323 | ggplot(myd, aes(date, Price, fill=Company)) + geom_area() + 324 | scale_fill_hue(l=45) 325 | ´´´ 326 | 327 | Can modify virtually every detail of a ggplot graph with the theme function. Here modify the labels, title and theme. 328 | 329 | ´´´ 330 | ggplot(myd, aes(date, Price, fill=Company)) + geom_area(alpha=.8) + 331 | labs(y="Adjusted Closing Price") + 332 | ggtitle("Stock Market Data") + 333 | theme_bw() + 334 | theme(panel.grid.major.y=element_line(color="grey50"), 335 | panel.grid.major.x=element_blank(), 336 | panel.grid.minor=element_blank(), 337 | plot.title=element_text(size=rel(1.1), face="bold"), 338 | legend.position="top", 339 | legend.title=element_blank(), 340 | legend.key=element_blank()) 341 | ´´´ 342 | 343 | 344 | ## Forecasting with Time Series 345 | 346 | Get the data. 347 | 348 | ´´´ 349 | mydata <- Read("./PPStech.csv", colClasses=list(date="Date")) 350 | ´´´ 351 | 352 | First use R functions to get forecast. Need to get data re-ordered from earliest to latest for R and lessR. R has no single function to sort a data frame, here use lessR Sort. 353 | 354 | ´´´ 355 | mydata <- Sort(date) 356 | ´´´ 357 | 358 | In base R, to work with time series data convert the vector of values to an R class specifically called ts for time series. Create the time series object with R function ts. The dates are calculated as specified by the ts function, not read from the data. ts is an R function, so need to specify the relevant data frame for each specified variable. 359 | 360 | ´´´ 361 | A <- ts(mydata$Apple, start=c(1980,12), frequency=12) 362 | ´´´ 363 | 364 | ## Interlude: How R works. 365 | 366 | View the time series, monthly data from Dec 1980 until May 2016. 367 | 368 | ´´´ 369 | A 370 | ´´´ 371 | 372 | Use the R class function to know what is the corresponding class, such as integer, Date, ts, etc. We created an R object of class ts. 373 | 374 | ´´´ 375 | class(A) 376 | ´´´ 377 | 378 | 379 | Plot is what R calls a generic function, each method is a version of the function adapted to different classes of input. View all different plot methods with the R methods function. 380 | 381 | ´´´ 382 | methods(plot) 383 | ´´´ 384 | 385 | Standard R plot function, here for class ts. 386 | 387 | ´´´ 388 | plot(A) 389 | ´´´ 390 | 391 | Same as explicitly indicating ts method for plot. 392 | 393 | ´´´ 394 | plot.ts(A) 395 | ´´´ 396 | 397 | lessR function Plot also plots a time series object. Note that lessR graphics may require first deleting the R graph. 398 | 399 | ´´´ 400 | Plot(A) 401 | ´´´ 402 | 403 | ## Holt-Winters Exponential Smoothing Forecast 404 | 405 | Exponential smoothing models the current value as a weighted average of all past observations with exponentially decreasing weights over time. One of the most widely used exponential smoothing forecasting methods is Holt-Winters, which models trend and seasonal components, called triple exponential smoothing. 406 | 407 | R provides the corresponding function, HoltWinters. Here save the results into an R object named Ahw. 408 | 409 | ´´´ 410 | Ahw <- HoltWinters(A) 411 | ´´´ 412 | 413 | The result is a class of hw. 414 | 415 | ´´´ 416 | class(Ahw) 417 | ´´´ 418 | 419 | Holt-Winters estimates the trend (a and b) and seasonality (s). Display the output by listing the name of the created R object. 420 | 421 | ´´´ 422 | Ahw 423 | ´´´ 424 | 425 | Obtain the forecasts with the R generic predict function, here the method adapted for the hw class, predict.HoltWinters. 426 | 427 | ´´´ 428 | Ahw.p <- predict(Ahw, n.ahead=24) 429 | Ahw.p 430 | ´´´ 431 | 432 | Plot data in the time series object A. Accommodate room for plot beyond actual data for the forecasted values. 433 | 434 | ´´´ 435 | plot(A, xlim=c(1980, 2018)) 436 | ´´´ 437 | 438 | Plot the forecasts in Ahw.p into the future. lines(Ahw.p, col="red") 439 | 440 | Include error bands for the forecasts from package/function forecast. 441 | 442 | ´´´ 443 | library(forecast) 444 | ´´´ 445 | 446 | Create object of class forecast. Forecast 24 months into the future. Obtain the forecast plus the .80 and .95 confidence bands. 447 | 448 | ´´´ 449 | fhw <- forecast(Ahw, h=24) 450 | ´´´ 451 | 452 | Print (i.e., display) the contents of fhw, i.e., print.forecast. 453 | 454 | ´´´ 455 | fhw 456 | ´´´ 457 | 458 | Again, check the class just to know. 459 | 460 | ´´´ 461 | class(fhw) 462 | ´´´ 463 | 464 | Plot the forecast object fhw, i.e., plot.forecast. 465 | 466 | ´´´ 467 | plot(fhw) 468 | ´´´ 469 | 470 | Equivalent to ggplot. 471 | 472 | ´´´ 473 | autoplot(fhw) 474 | ´´´ 475 | 476 | Use R unclass function to see what is in fhw. Not the print view, but the actual contents. Stat output of R functions is in the form of an R list. 477 | 478 | ´´´ 479 | unclass(fhw) 480 | ´´´ 481 | 482 | 483 | ## ggplot2 Forecast 484 | 485 | The autoplot function from the forecast library is all we need, but for pedagogy, set up the plot directly from ggplot. 486 | 487 | 488 | Optional, set up a custom range of dates to provide for the x-axis based on the R class of date. R internal date storage is the number of days since the origin of "1970-01-01". For pedagogy, to see how it works. 489 | 490 | ´´´ 491 | d1 <- as.Date(3987) # "1980-12-01" 492 | d2 <- as.Date(18993) # "2022-01-01" 493 | ´´´ 494 | 495 | In practice usually easier to convert a character string to an object of class Date. Still not needed, but can set up optional specified range of dates for plot. 496 | 497 | ´´´ 498 | d1 <- as.Date("1980-12-01") 499 | d2 <- as.Date("2022-01-01") 500 | ´´´ 501 | 502 | now begin the work of what is needed in ggplot and get sequence of dates for the forecast with R seq function 503 | 504 | ´´´ 505 | date <- seq(as.Date("2016-06-01"), as.Date("2018-05-01"), by="month") 506 | ´´´ 507 | 508 | Look at the output of unclass(fhw) to see what is in fhw. Second column of fhw$lower and fhw$upper are the .95 confidence bounds. fhw$mean contains the predictions. Use this information to create a new data frame, called df. 509 | 510 | ´´´ 511 | df <- data.frame(date, as.numeric(fhw$mean), fhw$lower[,2], fhw$upper[,2]) 512 | names(df) <- c("date", "Apple", "lower95", "upper95") 513 | ´´´ 514 | 515 | 516 | ´´´ 517 | head(df, n=3) 518 | ´´´ 519 | 520 | Now the structure of the df data frame matches the mydata data frame. 521 | 522 | ´´´ 523 | head(mydata, n=3) 524 | ´´´ 525 | 526 | Can optionally add the xlim specification to plot a wider x-axis. Just plot the .95 confidence interval here, using geom_smooth. Plot the data from data frame mydata. Plot the forecasts from data frame df. 527 | 528 | ´´´ 529 | ggplot(mydata, aes(date, Apple)) + geom_line(color="black") + 530 | #xlim(d1, d2) + 531 | geom_line(data=df, aes(date, Apple, color="red")) + 532 | geom_smooth(data=df, mapping=aes(ymin=lower95, ymax=upper95), stat="identity") + 533 | theme(legend.position="none") 534 | ´´´ -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Series Temporales 2 | 3 | 4 | 5 | Table of Contents 6 | ================= 7 | 8 | * [Series Temporales](#series-temporales) 9 | * [Introducción](#introducción) 10 | * [Análisis de series temporales univariantes](#análisis-de-series-temporales-univariantes) 11 | * [Enfoques](#enfoques) 12 | * [Enfoque clásico (descomposición)](#enfoque-clásico) 13 | * [Enfoque de los Alisados o Suavizados](#enfoque-de-los-alisados-o-suavizados) 14 | * [ARIMA](#arima-(autoregresive-integrated-moving-average)) 15 | * [SARIMA](#sarima-(seasonal-autoregresive-integrated-moving-average)) 16 | * [Predicción de series temporales con redes neuronales](#predicción-de-series-temporales-con-redes-neuronales) 17 | * [Predicción de series temporales con deep learning](#predicción-de-series-temporales-con-deep-learning) 18 | * [Análisis de series temporales multivariantes](#análisis-de-series-temporales-multivariantes) 19 | * [Enfoque Box-Jenkins](#enfoque-box-jenkins-1) 20 | * [VAR](#var) 21 | * [VEC](#vec) 22 | * [Manejo de datos perdidos en series temporales](#manejo-de-datos-perdidos-en-series-temporales) 23 | * [Series temporales con R](#series-temporales-con-r) 24 | * [Series temporales con alisados, arima, etc. con R](#series-temporales-con-alisados-arima-etc-con-r) 25 | * [Paquetes R para el análisis y tratamiento de Series Temporales:](#paquetes-r-para-el-análisis-y-tratamiento-de-series-temporales) 26 | * [Series temporales con redes neuronales con R](#series-temporales-con-redes-neuronales-con-r) 27 | * [Paquetes R para el análisis y tratamiento de Series Temporales con redes neuronales:](#paquetes-r-para-el-análisis-y-tratamiento-de-series-temporales-con-redes-neuronales) 28 | * [Imputación de datos perdidos en series temporales con R](#imputación-de-datos-perdidos-en-series-temporales-con-r) 29 | * [Paquetes R para la imputación de datos perdidos en series Temporales:](#paquetes-r-para-la-imputación-de-datos-perdidos-en-series-temporales) 30 | * [Análisis gráfico de series temporales](#análisis-gráfico-de-series-temporales) 31 | * [Ejemplos de análisis de series temporales](#ejemplos-de-análisis-de-series-temporales) 32 | * [Cursos relacionados](#cursos-relacionados) 33 | * [Bibliografía](#bibliografía) 34 | 35 | 36 | 37 | 38 | 39 | ## Introducción 40 | 41 | Una serie temporal es una colección de observaciones de una variable tomadas de forma secuencial y ordenada en el tiempo (instantes de tiempo equiespaciados). Las series pueden tener una periodicidad anual, semestral, trimestral, mensual, etc., según los periodos de tiempo en los que están recogidos los datos que la componen. Las series temporales se pueden definir como un caso particular de los procesos estocásticos, ya que un proceso estocástico es una secuencia de variables aleatorias, ordenadas y equidistantes cronológicamente referidas a una característica observable en diferentes momentos. 42 | 43 | Algunos ejemplos de series temporales vienen de campos como la economía (producto interior bruto anual, tasa de inflación, tasa de desempleo, ...), la demografía (nacimientos anuales, tasa de dependencia, ...), la meteorología (temperaturas máximas, medias o mínimas, precipitaciones diarias, ...), etc. 44 | 45 | ![STexample](https://datascienceplus.com/wp-content/uploads/2015/08/gtemp-490x301.png) 46 | 47 | El objetivo de una serie temporal reside en estudiar los cambios en esa variable con respeto al tiempo (descripción), y en predecir sus valores futuros (predicción). Por lo tanto, el análisis de series temporales presenta un conjunto de técnicas estadísticas que permiten extraer las regularidades que se observan en el comportamiento pasado de la variable, para tratar de predecir el comportamiento futuro. 48 | 49 | Una serie temporal se representa mediante un gráfico temporal, con el valor de la serie en el eje de ordenadas y los tiempos en el eje de abscisas. Esta es la forma más sencilla de comenzar el análisis de una serie temporal y permite detectar las características y componentes más importantes de una serie. 50 | 51 | **Componentes de una serie temporal** 52 | 53 | Los componentes que forman una serie temporal son los siguientes: 54 | 55 | - Tendencia: Se puede definir como un cambio a largo plazo que se produce en relación al nivel medio, o el cambio a largo plazo de la media. La tendencia se identifica con un movimiento suave de la serie a largo plazo. 56 | - Estacionalidad: Se puede definir como cierta periodicidad de corto plazo, es decir, cuando se observa en la serie un patrón sistemático que se repite periódicamente (cada año, cada mes, etc., dependiendo de las unidades de tiempo en que vengan recogidos los datos). Por ejemplo, el paro laboral aumenta en general en invierno y disminuye en verano. 57 | - Ciclo: Similar a la estacionalidad, ya que se puede definir como una fluctuación alrededor de la tendencia, pero de una duración irregular (no estrictamente periódica). 58 | - Irregular: Son factores que aparecen de forma aleatoria y que no responden a un comportamiento sistemático o regular y por tanto no pueden ser predecidos. No se corresponden a la tendencia ni a la estacionalidad ni a los ciclos. 59 | 60 | **Tipos de series temporales** 61 | 62 | Además, las series temporales se pueden dividir en: 63 | 64 | - Estacionarias: es aquella en la que las propiedades estadísticas de la serie son estables, no varían con el tiempo, más en concreto su media, varianza y covarianza se mantienen constantes a lo lardo del tiempo. Si una serie temporal tiene una media constante a lo largo del tiempo, decimos que es estacionaria con respecto a la media. Si tiene varianza constante con respecto al tiempo, decimos que es estacionaria en varianza. 65 | - No estacionarias: son aquellas en las que las propiedades estadísticas de la serie sí varían con el tiempo. Estas series pueden mostrar cambio de varianza, tendencia o efectos estacionales a lo largo del tiempo. Una serie es no estacionaria en media cuando muestra una tendencia, y una serie es no estacionaria en varianza cuando la variabilidad de los datos es diferente a lo largo de la serie. 66 | 67 | La importancia de esta división reside en que la estacionaridad (en media y en varianza) es un requisito que debe cumplirse para poder aplicar modelos paramétricos de análisis y predicción de series de datos. Ya que con series estacionarias podemos obtener predicciones fácilmente, debido a que como la media es constante se puede estimar con todos los datos y utilizar este valor para predecir una nueva observación. Y también permite obtener intervalos de confianza para las predicciones. 68 | 69 | Un tipo especial de serie estacionaria es la serie denominada **ruido blanco**. Un ruido blanco es una serie estacionaria tal que ninguna observación influye sobre las siguientes, es decir, donde los valores son independientes e idénticamente distribuidos a lo largo del tiempo con media y covarianza cero e igual varianza. 70 | 71 | ![STexample](./images/wn.png) 72 | 73 | Otro tipo especial de serie temporal es la llamada **camino aleatorio**, una serie es un camino aleatorio si la primera diferenciación de la serie es un ruido blanco. 74 | 75 | Las series temporales también se pueden dividir según cuántas variables se observan o según su variabilidad: 76 | 77 | - Univariante: la serie temporal es un conjunto de observaciones sobre una única caracteristica o variable. 78 | - Multivariante: (o vectorial): la serie temporal es un conjunto de observaciones de varias variables.
79 |
80 | - Homocedástica: una serie es homocedástica si su variabilidad se mantiene constante a lo largo de la serie. 81 | - Heterocedástica: una serie es heterocedástica cuando la variabilidad de la serie aumenta o disminuye a lo largo del tiempo. 82 | 83 | Por otro lado, la variable que se observa en una serie temporal puede ser de tipo: 84 | 85 | - Flujo: variable cuya cantidad es acumulada a lo largo del tiempo, por ejemplo: inversión, ahorro, etc. 86 | - Stock: variable cuya cantidad se mide en un determinado momento del tiempo, por ejemplo: población, nº parados, etc. 87 | 88 | ________________________________________________________________________ 89 | 90 | ## Análisis de series temporales univariantes 91 | 92 | La tarea de predicción y análisis de series temporales por lo general consta de cinco pasos básicos (sólo como referencia): 93 | 94 | - Definición del problema. A menudo, esta es la parte más difícil de la predicción. 95 | En la definición del problema se necesita que se comprenda la forma en que se utilizarán las predicciones. Hay que dedicar tiempo para hablar con todas las entidades que van a participar en la recogida de datos, el mantenimiento de bases de datos, y el uso de las predicciones. 96 | 97 | - Recopilación de información. 98 | Hay al menos dos tipos de información necesaria: 99 | 1. los datos estadísticos 100 | 2. la experiencia acumulada de las personas (expertos) en los datos y que hacen las predicciones. 101 | Será difícil obtener suficientes datos históricos para ser capaz de encajar un buen modelo estadístico. Sin embargo, datos historicos antiguos serán menos útiles para la predicción. 102 | 103 | - Análisis Preliminar (exploratorio) 104 | Primero, es necesario hacer una representación gráfica de los datos. Y hacerse las siguientes preguntas: 105 | - ¿Existen patrones? ¿Hay una/alguna tendencia que destaque? ¿Es importante la estacionalidad? ¿Hay presencia los ciclos? ¿Hay algunas anomalías en los datos que puedan ser explicados por expertos (conocimiento experto)? ¿Qué relación tienen las variables que se estudian? 106 | 107 | - Elección y ajuste de modelos. 108 | El mejor modelo a utilizar depende (en la mayoría de los casos) de la disponibilidad de datos históricos, la fuerza de las relaciones entre la variable de predicción y las variables explicativas. Cada modelo es una construcción artificial que se basa en un conjunto de supuestos (explícitos e implícitos) y por lo general consiste en uno o más parámetros que deben ser "equipados" utilizando los datos históricos conocidos. Pra ello: modelos de regresión , los métodos de suavización exponencial, los modelos de Box-Jenkins ARIMA, los modelos dinámicos de regresión, redes neuronales, y vectores autorregresivos, deeplearning, ... 109 | 110 | - Uso y evaluación de un modelo de predicción. 111 | Una vez que el modelo ha sido seleccionado y sus parámetros estimados, el modelo se utiliza para hacer predicciones. El rendimiento del modelo sólo puede ser evaluado correctamente después de que los datos para el período de predicción estén disponibles. 112 | 113 | ## Enfoques 114 | 115 | ### Enfoque clásico 116 | 117 | El análisis más clásico de las series temporales se basa en la idea de que los valores que toma la variable de observación son la consecuencia de las componentes anteriores (tendencia, estacionalidad, ciclo y aleatoriedad), aunque no siempre aparecen todas. Luego este enfoque descriptivo **determinista** consiste en encontrar componentes que se correspondan a una tendencia a largo plazo, un comportamiento estacional y una parte aleatoria. 118 | 119 | El primer paso a seguir a la hora de realizar un análisis es determinar cómo se combinan los componentes de la serie. Para ello se consideran dos modelos habituales para relacionar los valores de la serie con los componentes anteriores: 120 | 121 | - Modelo aditivo: donde cada componente contribuye al comportamiento de la variable de interés en forma aditiva (unidades). 122 | - Modelo multiplicativo: donde cada componente contribuye al comportamiento de la variable de interés en forma multiplicativa (porcentaje). 123 | 124 | Si a modelo multiplicativo se le aplica un logaritmo para estabilizarlo, entonces es equivalente a un modelo aditivo. Así pues, una serie temporal se puede descomponer y denotar en su manera aditiva como: 125 | 126 | Xt = Tt + Et + It 127 | 128 | ó en su forma multiplicativa como: 129 | 130 | Xt = Tt x Et x It 131 | 132 | donde Tt es la tendencia, Et es la componente estacional, que constituyen la señal o parte 133 | determinística, e It es el ruido o parte aleatoria. 134 | 135 | Para conocer qué tipo se adapta mejor a la serie, se pueden seguir los siguientes procedimientos: 136 | 137 | - De manera visual: 138 | - La tendencia y la estacionalidad se mantienen relativamente constantes -> modelo aditivo 139 | - La tendencia y la estacionalidad varian creciendo o decreciento -> modelo multiplicativo 140 | - De forma matemática: 141 | - Calcular las series diferencia y cociente, D y C. 142 | - Calcular el coeficiente de variación para cada serie, CVD y CVC. 143 | - Comparar sendos coeficientes. 144 | - Si CVC < CVD -> modelo multiplicativo 145 | - Si CVC > CVD -> modelo aditivo 146 | 147 | Una vez que se conoce la forma en que se relacionan los componentes, se descompone la serie estimando los componentes de tendencia y estacionalidad: 148 | 149 | - Componente de tendencia: la forma de la tendencia se puede modelar mediante los siguientes métodos (es importante reseñar que como la finalidad del análisis no es solo describir la serie sino predecir, hay que tener en cuenta cómo continúa la tendencia estimada para valores futuros): 150 | - Modelos lineales 151 | - Modelos polinómicos 152 | - Filtrado (Médias móviles)(no se recomienda ya que no predice, solo describe) 153 | - Diferenciación (diferencias regulares) 154 | - Componente de estacionalidad: para estimar el efecto estacional se pueden obtener los índices o coeficientes de estacionalidad que representan el valor promedio para cada elemento de la estación (si es anual para cada mes, si es trimestral cada trimestre, esto es, el periodo de la serie)(la suma de los índices estacionales debe de ser igual al número de periodos). Además, la serie original se puede desestacionalizar también mediante una diferenciación estacional de la serie. 155 | - Médias móviles centradas 156 | - Diferenciación (diferencias estacionales) 157 | 158 | *Se puede diferenciar la parte regular (lag=1) para la tendencia y se puede diferenciar la parte estacional para la estacionalidad (lag=periodo), o ambas. Se seleccionaría aquella diferenciación que minimice la varianza, ya que en una serie sobrediferenciada la varianza aumenta.* 159 | 160 | Y por lo tanto, la tendencia y la estacionalidad una vez modelados se pueden eliminar para obtener la componente aleatoria: 161 | 162 | It = Xt − Tt − Et 163 | 164 | ó 165 | 166 | It = Xt / (Tt * Et) 167 | 168 | En este punto se tiene una descomposición de la serie en componentes que separan tendencia, estacionalidad y ruido. Estos componentes obtenidos de la serie la describen, pero no la predicen. Las predicciones de valores futuros se consiguen usando las componentes Tt y Et con valores de tiempo t+1, t+2, etc. Para ello se realiza un pronóstico futuro de la tendencia, y se le añade la predicción de la estacionalidad (índice de estacionalidad) correspondiente a cada periodo (la componente irregular o aleatorio no es predecible y por lo tanto no se considera). 169 | 170 | **Ventajas e inconvenientes** 171 | 172 | Los métodos clásicos de análisis de series temporales tienen la ventaja de no ser excesivamente complejos, ya que explican la evolución pasada de una serie en función de pautas simples pero tienen problemas y limitaciones. Aunque son útiles para describir las pautas que sigue una serie temporal, las predicciones que proporcionan suelen ser muy malas (es decir, con un gran error asociado). La razón de esto es que en una serie temporal la observación más reciente depende, en general, de sus valores pasados, pero esta dependencia suele ser más fuerte con los datos más recientes y más débil con los más alejados. 173 | 174 | ### Enfoque de los Alisados o Suavizados 175 | 176 | Los métodos de suavizado o alisado se basan en modelos paramétricos **deterministas** que se ajustan a la evolución de la serie. Son técnicas de tipo predictivo más que descriptivo (resultan más adecuados para pronosticar). Estos modelos se pueden emplear en: 177 | 178 | **Series temporales sin tendencia ni estacionalidad** 179 | 180 | Este tipo de series tienen un comportamiento más o menos estable que sigue un patrón subyacente salvo fluctuaciones aleatorias (comportamiento estacionario), a este tipo de series se le pueden aplicar: 181 | 182 | - Modelos "naive" o ingenuos: según la importancia que se le de a las observaciones se tiene: 183 | - Se otorga la misma importancia a todas las observaciones a la hora de predecir, de esta forma la previsión vendrá dada por la media de las observaciones. 184 | - Se da importancia únicamente a la última de las observaciones ignorando el resto, de forma que el ajuste de la serie es su “sombra”, es la misma serie pero retardada en una unidad de periodo. 185 | - Modelos de médias móviles: se basan en considerar únicamente las últimas k observaciones. De esta forma se da el mismo peso a los últimos k datos y nada al resto. Este procedimiento no es tan extremo como los anteriores, y al sustituir cada dato por una media de los k últimos la serie se suaviza y se elimina ruido, obteniendo el patrón subyacente de la misma. Cuantas más observaciones relevantes (k) tomemos al aplicar este tipo de ajuste más se suavizará la serie. 186 | - Modelos de suavizado exponencial simple: consisten en dar importancia a todos los datos anteriores, pero concediéndoles diferentes pesos, ya que los datos más relevantes a la hora de efectuar una previsión son los últimos de los que se dispone, disminuyendo la importancia conforme nos alejamos de ellos. De esta manera se sustituye cada dato de la serie por una media ponderada de las observaciones anteriores, considerando que los pesos de las mismas decaen de forma exponencial conforme éstas se alejan en el tiempo (la fórmula del ajuste es recursiva). La cantidad de alisado (de nivel) depende de un parámetro, alpha, que modula la importancia que tienen las observaciones pasadas sobre el presente. Su valor oscila entre 0 y 1. Si alpha toma un valor próximo a 0 las predicciones a lo largo de la serie son muy similares entre sí, y se modifican poco con la nueva información. El caso extremo se produce cuando alpha es cero, lo que implicaría que la predicción es una constante a lo largo del tiempo. Si alpha, por el contrario, toma un valor próximo a 1 la predicción se va adaptando al último valor observado, por lo que se puede decir que los valores alejados en el tiempo no tienen mucha influencia sobre la predicción. El suavizado exponencial simple es el más similar a un modelo ARIMA con cero órdenes de autorregresión, un orden de diferenciación y un orden de media móvil. 187 | 188 | **Series temporales no estacionales con tendencia** 189 | 190 | En el caso de series temporales con tendencia lineal (creciente o decreciente) pero sin comportamiento estacional, el modelo clásico que más se suele aplicar es el de Holt: 191 | 192 | - Modelos de suavizado exponencial de Holt: en estos modelos se aplican un suavizado exponencial simple de manera doble, por lo que también son conocidos como suavizado exponencial doble (en un principio se alisa directamente a la variable objeto de estudio, mientras que en la segunda operación se procede a alisar a la variable alisada previamente obtenida). Estos modelos dependen de dos parámetros, alpha y beta (suavizado de nivel y de tendencia). El parámetro beta modula la importancia que tienen las observaciones pasadas sobre la pendiente estimada en tiempo t. Al igual que para alpha, los valores de beta oscilan entre 0 y 1. Si beta toma un valor próximo a 0 entonces la pendiente es constante o casi constante, es decir, cambia poco a lo largo de la serie temporal. Si beta toma un valor próximo a 1, la predicción de la pendiente se va adaptando al último valor observado y las observaciones de las pendientes más alejadas en el tiempo no tienen apenas influencia sobre la predicción. El modelo de suavizado exponencial de Holt es muy similar a un modelo ARIMA con cero órdenes de autorregresión, dos órdenes de diferenciación y dos órdenes de media móvil. 193 | - Modelos de suavizado exponencial de Brown: el modelo de Brown es un caso especial del modelo de Holt, en el que sus parámetros de suavizado son el nivel y la tendencia, pero se asumen iguales. 194 | 195 | **Series temporales con tendencia y estacionalidad** 196 | 197 | En el caso de series temporales con tendencia lineal (creciente o decreciente) y comportamiento estacional, el modelo clásico que se aplica es el de Holt-Winters: 198 | 199 | - Modelo de Holt-Winters: es una extensión del modelo de Holt, solo que además considera estacionalidad, luego ahora el modelo depende de tres parámetros, alpha, beta y gamma (suavizado de nivel, de tendencia y estacional). El parámetro gamma modula la importancia que tienen las observaciones hechas en el mismo periodo de tiempos pasados sobre la predicción en tiempo t. Gamma oscila entre 0 y 1. Si gamma es 0 la predicción en tiempo t va a tomar un valor constante que va a depender de todas las observaciones pasadas dentro de ese mismo periodo. Si gamma es 1 la prediccion en tiempo t va a depender solamente de la observación hecha en tiempo t-p, siendo p la frecuencia (por ejemplo t = 12 para observaciones mensuales). La tendencia y la estacionalidad se pueden combinar de manera aditiva o multiplicativa (el modelo multiplicativo sería más adecuado cuando la amplitud del ciclo va cambiando en el tiempo). El modelo de suavizado exponencial aditivo de Winters es muy similar a un modelo ARIMA con cero órdenes de autorregresión, un orden de diferenciación, un orden de diferenciación estacional y p+1 órdenes de media móvil, donde p es el número de periodos contenidos en un intervalo estacional. Mientras que el modelo de suavizado exponencial multiplicativo de Winters no es similar a ningún modelo ARIMA. 200 | 201 | ### Enfoque Box-Jenkins 202 | 203 | Hasta ahora se han analizado las series temporales desde un punto de vista determinista o clásico, sin tener en cuenta cuál es el mecanismo que genera la serie. Pero ahora con este nuevo enfoque se analizan desde un punto de vista **estocástico**, por lo que el punto de partida para elaborar un modelo a partir de una serie temporal consiste en considerar que dicha serie está generada y es una realización particular de un proceso estocástico. 204 | 205 | Pero para poder efectuar inferencias sobre los parámetros de un proceso estocástico, es preciso imponer restricciones a este último. Las restricciones que se imponen habitualmente son que sea estacionario y ergódico. Ya se ha visto cuándo un proceso es estacionario, pero ¿cúando es ergódico?. Antes de explicar un proceso ergódico necesitamos definir la autocorrelación. Se denomina **autocorrelación** de orden k, pk, a la correlación (dependencia) de cualesquiera dos variables aleatorias del proceso estocástico (serie temporal), distanciadas k instantes de tiempo. Algunas de sus principales caracteristicas son: 206 | - La autocorrelación de periodo k=0 (p0) siempre es 1 por definición. 207 | - La autocorrelación es simétrica pi=p-i 208 | - La autocorrelación siempre es menor que 1 y mayor que -1 (|pk| < 1) 209 | 210 | La autocorrelación se puede medir mediante las funciones de autocorrelación: 211 | 212 | - Función de autocorrelación simple (ACF): esta función mide la correlación entre dos variables separadas por k periodos. Proporciona la estructura de dependencia lineal de la misma. Así la ACF va a ser una sucesión de valores (p1, p2, ... pk,) que representan cómo influye una observación sobre las siguientes. De forma que p1 denota la influecia de una observación,pi, sobre la siguiente pi+1, p2 representa la influencia de una observación,pi, sobre la de dos periodos posteriores pi+2 y así sucesivamente. Un valor de pi próximo a 1 indica que hay mucha relación entre una observación y la i posiciones posterior, y que esa relación es positiva (si el valor es próximo a -1 que esa relación es negativa). 213 | - Función de autocorrelación parcial (PACF): esta función mide la correlación entre dos variables separadas por k periodos pero cuando no se considera la dependencia creada por los retardos intermedios existentes entre ambas. 214 | 215 | Las funciones de **autocorrelación simple y parcial** constituyen uno de los instrumentos clave para ajustar el modelo que genera una serie temporal. Así pues, un proceso es ergódico cuando conforme k se hace más grande, a autocorrelación se hace más pequeña. Es decir, que la dependencia entre variables tiene menos importancia pasado más tiempo. 216 | 217 | ![STexample](./images/autoc.png) 218 | 219 | **ARIMA (AutoRegresive Integrated Moving Average)** 220 | 221 | Box y Jenkins desarrollaron modelos estadísticos para series temporales que tienen en cuenta la dependencia existente entre los datos, esto es, cada observación en un momento dado es modelada en función de los valores anteriores. Los modelos se conocen con el nombre genérico de ARIMA (AutoRegresive Integrated Moving Average)(ARIMA para procesos estocásticos no estacionarios y ARMA para procesos estocásticos estacionarios), que deriva de sus tres componentes Autoregresivo, Integrado y Medias Móviles: 222 | 223 | - _Procesos Autoregresivos AR(p)_
Los modelos autoregresivos se basan en la idea de que el valor actual de la serie, Xt, puede explicarse o predecirse en función de _p_ valores pasados Xt-1, ... Xt-p más un término de error, donde _p_ determina el número de valores pasados necesarios para pronosticar un valor actual. El orden del modelo expresa el número de observaciones retrasadas de la serie temporal que intervienen en la ecuación, así pues, un modelo autoregresivo de orden 1 AR(1), la variable Xt está determinada únicamente por un valor pasado, esto es Xt-1 y así sucesivamente. Todos los procesos autorregresivos son procesos invertibles. Xt=f0+f1Xt-1+f2Xt-2+......+fpXt-p+at 224 | 225 | - _Procesos de Medias Móviles MA(q)_
Un modelo de medias móviles es aquel que explica el valor de una determinada variable en un período _t_ en función de un término independiente y una sucesión de errores correspondientes a períodos precedentes, ponderados convenientemente. Estos modelos se denotan normalmente con las siglas MA, seguidos del orden entre paréntesis. Todos los procesos de medias móviles son procesos estacionarios. No todos los procesos de medias móviles son invertibles. Xt=m+at+q1at-1+q2at-2+......+qpat-p 226 | 227 | - _Proceso Autoregresivo de Medias Móviles ARMA(p,q)_
Una extensión natural de los modelos AR(p) y MA(q) es un tipo de modelos que incluyen tanto términos autorregresivos como de medias móviles. Los modelos autorregresivos de medias móviles, ARMA(p,q), son la suma de un proceso autorregresivo de orden _p_ y uno de medias móviles de orden _q_. Es muy probable que una serie de tiempo tenga características de AR y de MA a la vez y, por consiguiente, sea ARMA. Un proceso ARMA(p, q) es estacionario si lo es su componente autorregresiva, y es invertible si lo es su componente de medias móviles. 228 | 229 | - _Proceso Integrado I(d)_
No todas las series temporales son estacionarias, algunas presentan cambios de nivel en el tiempo o la varianza no es constante, por lo que la serie se diferencia _d_ veces para hacerla estacionaria. A este tipo de procesos se les considera procesos integrados, y se puede aplicar a esta serie diferenciada un modelo ARMA(p,q) para dar lugar a un modelo ARIMA(p,d,q). 230 | 231 | Luego un Proceso Autoregresivo Integrado y de Media Móvil, ARIMA (p,d,q), es una serie de tiempo autoregresiva integrada de media móvil. Donde denota _p_ el número de términos autoregresivos, _d_ el número de veces que la serie debe ser diferenciada para hacerla estacionaria y _q_ el número de términos de la media móvil invertible. La metodología Box-Jenkins para la construcción de los modelos ARIMA(p,d,q) se realiza de manera iterativa mediante un proceso en el que se puede distinguir cuatro etapas: 232 | 233 | - **Identificación:** esta primera fase consiste en identificar el posible modelo ARIMA(p,d,q) que sigue la serie (es posible identificar más de un modelo candidato que pueda describir la serie), lo que requiere: 234 | 235 | - Generalmente en primer lugar se debe de representar gráficamente la serie para identificar la tendencia y la estacionalidad (si es que las hay)(la estacionalidad de puede ver con las gráficas de las subsecuencias estacionarias). Posteriormente se prosigue modelando y eliminando tanto la tendencia como la estacionalidad para conseguir la estacionariedad (sobre todo si son muy pronunciadas y se ve claramente que existen)(ya se ha explicado anteriormente cómo se estiman y modelan ambas)(en caso de observarse un componente estacional muy fuerte además de tendencia, se puede probar a eliminar primero el componente estacional por si la serie resultante ya fuera estacionaria, y así no tener que realizar además la eliminación de la tendencia)(también pueden no eliminarse directamente e incluirse las diferenciaciones necesarias para hacerlo en el modelo ARIMA). Aunque en el análisis y modelado de series temporales no hay un patrón fijo a seguir, lo recomendable es llegar al análisis de tendencia y estacionalidad con la serie temporal lo mas limpia posible, eliminando todo tipo de comportamientos no deseados, luego si al graficar la serie vemos claramente que es heterocedástica (no es constante en varianza)(es frecuente observar que la varianza aumenta con el nivel de la serie)(por lo tanto no sigue una distribución normal) es recomendable realizar alguna de las siguientes transformaciones para acercarse más a una distribución normal: 236 | - Transformación logarítmica: consiste en aplicar a los datos de la serie original un logaritmo de forma. Los valores pequeños se expandirán y los grandes se contraeran. Solo se puede llevar a cabo con valores positivos (aunque esto se soluciona sumando una constante a los valores). Una transformación logaritmica se deshace con una transformación exponencial. 237 | - Transformación de Box-Cox: al igual que la anterior, son una familia de transformaciones potenciales para corregir sesgos en la distribución de errores, varianzas desiguales y principalmente para corregir la no linealidad en la relación (mejorar correlación entre las variables). La diferencia está en que se emplea e identifica un parámetro lambda que va a representar el mejor valor para elevar los datos que aumenta la normalidad. 238 | 239 | - Una vez esto hecho se comprueba la estacionariedad. La condición de estacionaridad es un requisito que debe cumplirse para poder aplicar modelos paramétricos de análisis y predicción de series de datos. Pero ¿cómo saber si una serie es estacionaria? 240 | - Gráficamente: Representando y observando las gráficas de autocorrelación (ACF) y autocorrelación parcial (PACF). Como norma general si el ACF tiende “rápidamente” a 0 entonces es estacionaria, cuando la serie no es estacionaria, el ACF decrece lentamente a 0. 241 | - Test estadísticos: 242 | - Dickey-Fuller Ampliado (Test ADF). La hipótesis nula en este test es que la serie no es estacionaria, luego si el valor resultante, p-value, es menor de 0.05 (ya que el p-value representa la probabilidad de la hipótesis tomada) indica que la serie es estacionaria con un nivel de confianza del 95% (en caso contrario no habría evidencia para rechazar la hipótesis de no estacionariedad). 243 | - Kwiatkowski-Phillips-Schmidt-Shin (Test KPSS). En este caso la hipótesis es la contraria, luego un p-value mayor que 0.05 indica que la serie sí es estacionaria. 244 | 245 | Si encontramos que la serie no es estacionaria ni habiendo eliminado la tendencia y la estacionalidad, se debe de diferenciar hasta conseguir que lo sea (lo ideal es diferenciar lo menos posible, solo en este caso en que tras la eliminación de la tendencia y estacionalidad aún es necesaria). La parte integrada suele ser necesaria para corregir la estacionaridad en la varianza. Normalmente los ordenes de diferenciación para que desaparezcan la tendencia o estacionalidad que quede no suelen ser elevados. Uno de los errores más comunes es aplicar una difereciación extra de la necesitada por la serie temporal para ser estacionaria, lo que es conocido como **sobrediferenciación**. Un indicio de que una serie temporal ha sido sobrediferenciada, es que el primer rezago de la gráfica de autocorrelación es -0.5 o un valor más negativo. Otro síntoma de sobrediferenciación es un incremento en la desviación estándar (y la varianza) trás aplicar una diferenciación más, luego el orden óptimo de diferenciación es frecuentemente aquel que hace que la desviación estándar (y varianza) sea la más baja posible. 246 | - Por último, una vez que la serie sea estacionaria, se determina un modelo ARIMA (o ARMA en caso de que no haga falta diferenciar) para la serie estacionaria, es decir, los órdenes p, d y q de su estructura autorregresiva, integrado y de media móvil. El modelo se puede deducir leyendo los correlogramas de la serie, es decir, las funciones de autocorrelación y autocorelación parcial (de la serie transformada, no de la original), ya que por norma general cuando solo hay un componente: 247 | 248 | - Los modelos AR tienen un ACF que decrece rápidamente a 0 (con diferentes posibles formas: regulares, sinusoidales, anternando +/-). El número del orden “p” (AR(p)) puede ser tantos valores “distintos de 0 como haya en el PACF” o el lag del mayor rezago significativo (hay que sopesar la capacidad predictiva que se puede ganar frente a al ruido que se pueda añadir). 249 | - Los modelos MA tiene un PACF que decrece rápidamente a 0 (con diferentes posibles formas: regulares, sinusoidales, anternando +/-)(aunque generalmente no ayuda a establecer el orden). El número del orden “q” (MA(q)) es tantos “valores distintos de 0” como haya en el ACF, o el lag del mayor rezago significativo (hay que sopesar la capacidad predictiva que se puede ganar frente a al ruido que se pueda añadir). 250 | 251 | Considerando un valor “distinto de cero” si no está en el rango (-2/sqrt(N), 2/sqrt(N)), con N=longitud de la serie (banda de significancia, suelen ser del 95%). Luego la identificación de los órdenes del modelo consiste en comparar la ACF y PACF estimada de la serie estacionaria con la ACF y PACF de los modelos teóricos. Hay situaciones que no son muy claras, en estos casos puede tratarse de un modelo con las dos partes, la AR y la MA. Estos son modelos ARMA(p,q) o ARIMA(p,0,q). Sus funciones FAS y FAP son combinaciones de las de ambas partes, por lo que son más difíciles de identificar a simple vista. Debido a que en la práctica es difícil identificar con exactitud el orden p y q del modelo ARMA, se pueden plantear dos o más modelos plausibles, que luego de ser estimados son útiles para la elección del más apropiado. 252 | 253 | - **Estimación:** una vez seleccionado provisionalmente un modelo para la serie estacionaria, se pasa a la segunda etapa, donde se estiman los coeficientes/parámetros de los términos autorregresivos (AR) y de media móvil (MA) del modelo (siempre el modelo estacionario, no el original). Los parámetros se suelen obtener por máxima verosimilitud o por mínimos cuadrados lineales, pero en otras ocasiones se recurre a la estimación no lineal de los parámetros, el objetivo en ambos casos es encontrar los valores de los parametros que minimizen el sumatorio de los errores al cuadrado (o dicho de otra forma, minimizar la suma de los cuadrados de los residuos). 254 | 255 | - **Validación:** en esta etapa se busca evaluar si el modelo (o los modelos) estimado(s) se ajusta(n) razonablemente bien a los datos (y si se estimaron varios modelos para conocer cuál es mejor) antes de hacer uso del modelo para la predicción. Así pues la validación o verificación incluye 3 tipos de análisis: 256 | 257 | - El análisis de los coeficientes o parámetros del modelo: se desea que el modelo estimado cumpla con las condiciones de estacionariedad e invertibilidad y que exista significancia estadística en los rezagos incorporados. 258 | - La evaluación de la bondad del ajuste: ya que los modelos han sido elegidos mediante identificación, es importante determinar cuál de los modelos presenta una mejor bondad de ajuste. 259 | - AIC (Akaike Information Criterion): es una medida de la calidad relativa de un modelo estadístico que proporciona un medio para la selección de un modelo entre un conjunto de modelos. El AIC maneja un trade-off entre la bondad de ajuste del modelo y la complejidad del modelo, para ello tiene en cuenta lo bien que el modelo se ajusta a los datos penalizando la complejidad del modelo que puede llevar a un sobreentrenamiento (es decir, un modelo más complejo puede ajustarse mejor a los datos, pero esto puede hacer que el modelo sea peor para datos futuros). Un valor más pequeño del AIC representa un mejor ajuste. 260 | - BIC (Bayesian Information Criterion): similar a AIC. 261 | - Métodos de validación con datos de entrenamiento y test: una práctica común es seleccionar un modelo basándose únicamente en el ajuste del mismo con todos los datos que forman parte de la serie, pero que un modelo se ajuste y reproduzca bien unos datos no significa necesariamente que prediga datos a futuro bien (frecuentemente mientras mejor se ajusta a unos datos, peor predice datos a futuro, lo que es llamado **sobreentrenamiento**), aunque sea un buen indicador de ello. Para evitar esto, se puede dividir la serie en datos de entrenamiento empleados para estimar el modelo, y datos de test empleados para evaluar la predicción del modelo. Emplear este tipo de técnicas se hace más difícil con series temporales ya que los datos no son independientes y hay que tener cuidado al dividir la serie en entrenamiento y test (se recomienda que las observaciones de entrenamiento ocurran temporalmente antes que la de test). 262 | - Hold out: se puede emplear cuando la serie temporal es larga, empleando los datos más recientes para servir de datos test (se recomienda al menos un 20% o tantos datos como el periodo que se quiere predecir), mientras que el resto de datos (los más antiguos) se emplean para ajustar el modelo. 263 | - Validación cruzada (en su variante Leave-one-out): basada en el método rolling forecast origin, se puede emplear con series temporales cortas (por ejemplo en las que no hay suficientes datos para usar como un periodo de test igual al que se pretende predecir) o largas (esta técnica es una variante de la validación cruzada dejando uno fuera y hace un uso más eficiente de los datos disponibles, ya que al eliminar una o varias observaciones no se elimina toda la información asociada a ellas debido a la correlación inherente entre observaciones de una serie temporal)(por contra es más costosa en cómputo y tiempo). Suponiendo que son necesitadas k observaciones para realizar una predicción fiable, entonces el proceso funciona como sigue: se seleccionan las observaciones 1...k+i para entrenamiento y la observación k+i para test. Esto se realiza de manera iterativa para i=1 hasta el número total de observaciones menos k, y se aplican medidas del error de la estimación (por ejemplo el error medio absoluto, el error cuadrático medio, etc.) (La recomendación con respecto a la validación es realizar una **validación interna y otra externa**. Para ello se dividen los datos en datos de entrenamiento, test y validación. En la validación interna se lleva a cabo una elección del mejor modelo en base a los datos de entrenamiento y test, y en la validación externa se testea el mejor modelo con los datos de validación). 264 | 265 | ![STexample](https://i.stack.imgur.com/fXZ6k.png) 266 | 267 | Una vez explicados se puede matizar una diferenciación entre ellos, y es que los criterios de información (como AIC o BIC) no realizan una valoración en función de la predicción sino que la valoración se ciñe al ajuste del modelo a los datos observados, mientras que por otro lado los métodos de validación (hold out, validación cruzada) realizan una valoración del modelo con respecto a la predicción futura que se puede realizar a partir de lo aprendido con los datos observados. Cada uno de los métodos anteriores tiene sus ventajas y desventajas, usar un método de validación con datos de entrenamiento y test tiene la ventaja de que puede usarse para comparar predicciones de métodos diferentes (ARIMA, ETS, ...) pero con el coste de tener que usar algunas observaciones para testear. Mientras que los criterios de información tienen la ventaja de que emplean todas las observaciones, pero requieren que los datos de los modelos comparados sean los mismo, es decir, no puede usarse para comparar entre modelos ARIMA y ETS, o entre diferentes diferenciaciones de los modelos ARIMA, etc. 268 | - El análisis de los residuos: debe verificarse el supuesto de que los errores del modelo son un proceso puramente aleatorio (media cero, varianza constante y no correlación serial), es decir, no tienen estructura de dependencia (los residuos no deben estar correlacionados el pasado, deben ser independientes los unos de los otros) y siguen un proceso de ruido blanco. 269 | - Gráficos sobre los residuos. Se pueden pintar diversos gráficos sobre los residuos cuyo propósito es testear la validez de la asumpción de aleatoriedad de los residuos. 270 | - Diagrama de secuencia de los residuos: el gráfico debe de mostrar unos residuos planos y sin tendencia (media constante en 0) y una dispersión vertical aproximadamente igual a lo largo del eje horizontal (varianza constante). 271 | - Lag de los residuos: los datos aleatorios no deben exhibir ninguna estructura en este ploteo. Una estructura en este ploteo indica que los residuos no son aleatorios. 272 | - Histograma de los residuos: el histograma realiza una sumarización gráfica de la distribución de los residuos, debe tener una forma acampanada. 273 | - Gráfico de probabilidad normal de los residuos: chequea si los residuos están aproximadamente normalmente distribuidos. La idea consiste en representar los datos empíricos observados frente a los datos que se obtendrían en una distribución normal teórica. Si la distribución de la variable es normal, los puntos quedarán cerca de una línea recta (tendrán una forma aproximadamente lineal). Es frecuente observar una mayor variabilidad (separación) en los extremos. 274 | - Gráfico Q-Q: Similar al gráfico de probabilidad normal, con la diferencia de que se usa el cuantil de la distribución como eje X. 275 | ![STexample](http://www.itl.nist.gov/div898/handbook/pmc/section6/negiz4/gif/res4plot.gif) 276 | - Correlogramas de los residuos. Se evalúa con el correlograma que los errores del modelo no tengan correlación y sean ruido blanco (la ACF y la PACF de un ruido blanco (serie de datos independientes entre sí) tienen todos los coeficientes nulos en teoría, o no significativos en las gráficas al menos para el 95% de los coeficientes estimados). 277 | - Los estadísticos Ljung–Box (y también Box-Pierce) (test de aleatoriedad) (son test de portmanteau). La hipótesis nula para estos test es que los residuos son independientes (es decir, están incorrelacionados). Luego si el p-value obtenido es pequeño indica que no son aleatorios, en cambio, cuanto mayor es su p-valor más evidencia hay de que los residuos son ruido blanco. El nivel mínimo es 0,05, es decir, debe suceder que el p-valor sea mayor que 0,05. 278 | - Los estadísticos Jarque Bera, Shapiro-Wilk, Kolmogorov-Smirnov, D'Agostino, Lilliefors o Anderson-Darling (test de normalidad, o prueba de normalidad). Presentan como hipótesis nula que los errores se encuentran distribuidos normalmente, luego un p-value menor que 0.05, denotará que la hipótesis se puede rechazar, y los residuos no siguen una distribución normal (el test de Shapiro-Wilk no se recomienda para un conjunto de valores superior a 50). 279 | 280 | Para que un modelo sea válido, los diferentes análisis sobre los residuos obtenidos en la estimación serán "ruido blanco". Un ruido blanco es una serie estacionaria en la que ninguna observación depende de las otras y, por tanto, todos los valores de la ACF y la PACF son nulos. El correlograma y el correlograma parcial deben ser muy similares y los valores no deben ser significativamente distintos de cero. Si ésto no es así y los residuos muestran estructura, habrá que realizar una nueva estimación incorporando la estructura más parecida al modelo teórico que podamos intuir y se repiten las etapas anteriores hasta obtener un modelo adecuado. 281 | 282 | - **Predicción:** una vez seleccionado el mejor modelo, éste se puede utilizar para conseguir la mejor predicción de los valores a futuro de la serie a partir de su propia historia. ¿Pero cuál es el mejor predictor que se puede aplicar a los datos? El mejor predictor posible será "el que menos se equivoca" o, en términos estadísticos, aquel que minimiza el error cuadrático medio respecto a otro potencial predictor alternativo. A la hora de realizar una predicción con el modelo obtenido, hay dos tipos de estrategias: 283 | - One-step-ahead prediction: en esta estrategia se emplean los datos que se tienen para predecir el instante de tiempo siguiente (una vez que se tenga el instante de tiempo siguiente real, se empleará este en lugar del predicho para la siguiente predicción one-step-ahead). 284 | - Multi-step-ahead prediction: en esta estrategia se pretende predecir más de un instante de tiempo siguiente, para ello la predicción se puede emplear directamente (prediciendo todos los valores temporales de una vez) o de manera iterada (predice los instantes de tiempo uno a uno empleando un one-step-ahead de manera repetida, y empleando los valores predichos para predecir los siguientes). 285 | 286 | ![STexample](./images/diagramaflujo.png) 287 | 288 | **SARIMA (Seasonal AutoRegresive Integrated Moving Average)** 289 | 290 | En principio se tiene que los modelos ARIMA(p,d,q) vistos anteriormente son modelos no estacionarios (aunque también se pueden ajustar a modelos estacionarios eliminando la estacionalidad previamente como se ha visto), por ello, también existen los modelos estacionales autorregresivos integrados de média móvil ARIMA(p,d,q)(P,D,Q)S (o SARIMA(p,d,q)(P,D,Q)). Aunque la metodología para constuir estos procesos es igual, son útiles sobre todo cuando la serie de tiempo observada tiene intervalos de observación menores a un año ya que entonces es frecuente que estas tengan variaciones ó patrones sistemáticos cada cierto periodo. Esta estacionalidad debe ser captadas e incluida dentro de la estructura del modelo a construir. Este tipo de procesos tiene las siguientes características: 291 | 292 | - Contiene una componente ARIMA(p,d,q) que modela la dependencia regular, que es la dependencia asociada a observaciones consecutivas. 293 | - Contiene una componente ARIMA(P,D,Q) que modela la dependencia estacional, que está asociada a observaciones separadas por periodos. 294 | 295 | En principio la parte estacional se puede modelizar de la misma forma que la parte regular. La identificación se realiza estudiando la ACF y la PACF en los retardos estacionales. Cuando una serie tiene parte regular y parte estacional, la FAS presenta una interrelación entre ellas. Básicamente la ACF y PACF de los modelos estacionales presentan las siguientes características: 296 | 297 | - ACF: en los primeros rezagos se observa únicamente la parte regular, mientras que la parte estacional se observa en los retardos del orden del periodo (12, 24, etc.). También se puede observar la interacción entre ambos, mediante una componente regular en los retardos cercanos a los estacionales. 298 | - PACF: nuevamente en los primeros rezagos se observa únicamente la parte regular, mientras que la parte estacional se observa en los retardos del orden del periodo (12, 24, etc.). Nuevamente se puede observar la interacción entre ambos, mediante una componente regular en los retardos cercanos a los estacionales (positiva o negativa a la derecha y positiva a la izquierda). 299 | 300 | Por ejemplo, un modelo ARIMA(0,0,0)(0,0,1)12 mostraría únicamente una barra significativa en el rezago 12 de la ACF, mientras que la PACF mostraría un decaimiento exponencial en el rezago estacionario. De manera similar, un ARIMA(0,0,0)(1,0,0)12 mostraría un decaimiento exponencial en los rezagos estacionales de la ACF, y una sola barra significativa en el rezago 12 del PACF. 301 | 302 | **Ventajas e inconvenientes** 303 | 304 | Por último, una de las desventajas de los modelos de Box-Jenkins está en que asumen que las observaciones están presentes en cada periodo de tiempo (ya que son necesarios para el cómputo de las autocorrelaciones), algo que no siempre es así ya que es habitual encontrar series de tiempo con valores perdidos. Por lo que este tipo de series requiere que se apliquen previamente métodos que estimen los valores faltantes para poder emplear el método ARIMA. 305 | 306 | ________________________________________________________________________ 307 | 308 | ## Predicción de series temporales con redes neuronales 309 | 310 | Hasta ahora, los enfoques de análisis de series temporales se han llevado a cabo desde un punto de vista lineal, ya que con los métodos vistos anteriormente se obtienen resultados satisfactorios en series de tiempo lineales, pero al utilizarlos en series no lineales, presentan limitaciones ya que no son capaces de capturar las relaciones no lineales de los datos. Así entran en juego los métodos capaces de capturar las relaciones lineales y no lineales entre los datos, como son las **redes neuronales**. 311 | 312 | Los métodos de predicción basados en redes neuronales artificiales están basados en modelos matemáticos simples del cerebro. Una red neuronal puede ser vista como una red de neuronas organizadas en capas, en la que los predictores (o entradas) forman la capa más baja y las predicciones (salidas) forman la capa más alta. Entre ambas capas pueden existir capas intermedias con neuronas ocultas. Esta capa intermedia oculta es la que permite una relación no linear entre las entradas y las salidas permitiendo al modelo más grados de libertad (ya que se emplean funciones de activación no lineales, como la función sigmoide)(si solo se tuvieran la capa de entrada y salida sería una regresión lineal (modelo más simple)). Una neurona artificial consta de los siguientes elementos: 313 | 314 | - Un conjunto de entradas. 315 | - Un conjunto de pesos sinápticos, correspondientes a cada entrada. 316 | - Una función de agregación, Σ. 317 | - Una función de activación, f. 318 | - Un conjunto de salidas. 319 | 320 | ![STexample](./images/ann.png) 321 | 322 | Luego cada neurona va a recibir un conjunto de entradas ponderadas por un peso específico, a las que le aplica una función de activación una vez realizado el sumatorio del valor de las mismas, para obtener así una salida. Los pesos son valores reales que multiplican a las entradas. En un principio los pesos son inicializados aleatoriamente (luego hay una componente aleatoria asociada a cada red neuronal), pero estos pesos se actualizan mediante algoritmos de entrenamiento sobre los datos observados que minimizan una función de coste, por lo que van a representar el conocimiento de la red. 323 | La función de activación define la salida de la neurona, se puede decir que representa el potencial de activación de la neurona... 324 | 325 | En su forma simplificada, esta función es binaria, esto es, se activa la neurona o no. Una función rampa también puede ser usada para reflejar el incremento del potencial de activación que ocurre cuando la entrada se incrementa. Esta función de activación es lineal, y por consiguiente tiene los mismos problemas que la función binaria. Los problemas mencionados anteriormente, pueden ser manejados usando una función de activación sigmoidal. La función de tangente hiperbólica puede también ser cualquier función sigmoidal. 326 | 327 | 328 | 329 | ¿qué es función de activación y tipos? 330 | 331 | ¿algoritmos entrenamiento? 332 | ¿umbral?¿bias? 333 | ¿función de coste? 334 | 335 | Para aquellas redes que usen funciones de activación como por ejemplo la sigmoide, una **normalización** de los datos es frecuentemente de ayuda, ya que si no se realiza la normalización los datos de entrada tendrán un efecto adicional sobre la neurona, dando lugar a decisiones incorrectas. Entre los tipos de normalización más comunes se pueden encontrar: 336 | - min-max: reescala los valores de los datos entre el rango 0 y 1 (-1 y 1), correspondiéndose el valor mayor de los datos a 1, y el menor a 0. 337 | - z-score: los datos son escalados para tener una media de 0 y una desviación estándar de 1 (μ = 0 y σ = 1), se obtiene restando a cada elemento la media de la población y dividiendolo entre la desviación estándar de la población, y cada valor representa el número de desviaciones estándar que está por encima o por debajo de la media. 338 | - decimal scaling: normaliza los datos moviendo el punto decimal. El número de movimientos del punto decimal para los datos viene dado por valor máximo absoluto de los datos. 339 | 340 | En las redes neuronales, los nodos de cada capa están conectados con otros nodos o incluso consigo mismos (cada conexión es diferente además porque también tienen un peso asociado), dependiendo de la arquitectura e interconexión de todas las neuronas de una red, pueden clasificárse en distintas categorías: 341 | 342 | - Redes neuronales Feed-Forward: es la red neuronal más sencilla, en estos modelos multicapa las salidas de cada capa son las entradas de la capa siguiente, luego la información se mueve solo en una dirección, hacia delante desde las entradas hasta las salidas pasando por las capas ocultas, y por lo tanto no hay ciclos. Su desempeño es bueno para aplicaciones en las que no se requiera que la red retenga información de eventos pasados como ayuda para evaluar eventos futuros. 343 | - Redes neuronales parcialmente recurrentes: son redes multicapa con algunas conexiones recurrentes, de forma que son una mejora de las redes neuronales Feed-Forward al incluir retroalimentación, pero no llegan a ser completamente recurrentes. En estas redes generalmente existen en la capa de entrada ciertas neuronas especiales (neuronas de contexto) receptoras de las conexiones recurrentes, mientras que el resto de las neuronas actúan como receptores de los datos de entrada. Las redes neuronales parcialmente recurrentes más conocidas son: 344 | - La red de Jordan: las neuronas de contexto reciben una copia de las neuronas de salida y de ellas mismas, acumulando así las salidas de la red para todos los instantes anteriores. 345 | - La red de Elman: las neuronas de contexto reciben una copia de las neuronas ocultas de la red. 346 | - Redes neuronales recurrentes: es un tipo de red neuronal en la que no solo las salidas de cada capa son las entradas de la capa siguiente sino que además se puede formas ciclos entre las capas, ya que una neurona se puede conectar con si misma o con otra neurona de la misma capa o incluso con neuronas de la capa anterior (tienen caminos de retroalimentación entre todos los elementos que las conforman). Luego estas redes neuronales recurrentes son más eficaces para resolver problemas con no-linealidades temporales significativas ya que pueden mantener información pasada, lo que está intimamente ligado con secuencias de tiempo por ejemplo. El problema de estas redes reside en que funcionan bien cuándo la información que se pretende mantener es muy cercana, pero no funcionan tan bien cuándo la información es lejana, esto es así ya que la influencia de las entradas pasadas decaen rapidamente con el tiempo. Aquí es dónde aparece un tipo especial de red neuronal recurrente que puede resolver el problema: 347 | - Redes neuronales Long-Short Term Memory: son capaces de aprender las dependencias largas ya que han sido especialmente diseñadas para ello (tienen neuronas especiales que usan celdas de memoria que almacenan información un tiempo arbitrario). 348 | 349 | ![STexample](https://lh3.googleusercontent.com/LG5dLIqDTDKNiSCsRtrt8_B0at9slkrdVxVO2BRJ6Hva6asqP2vsixIsuLZt-cS1QYy9B7Tw9mrjCviL7e1I7_sa) 350 | 351 | Con respecto a las series temporales, la idea base reside en que los valores futuros son dependientes de los valores pasados, es decir, buscando en los valores pasados de una serie temporal se puede predecir su comportamiento en el futuro. Luego los valores de los rezagos de las series temporales pueden ser usados como entradas a una red neuronal, de igual modo que se usan en un modelo autoregresivo lineal, y los valores futuros a predecir como las salidas de la red. La aplicación de redes neuronales artificiales a la predicción de series temporales se puede realizar de acuerdo a una serie de etapas que pueden ser: 352 | 353 | - Búsqueda de las variables de entrada: tiene como objetivo identificar los retrasos o rezagos de la serie que deben considerarse como variables de entrada en la red neuronal. Para ello se pueden emplear algunos de los análisis tradicionales de series temporales para estimar la dependencia entre los datos, como son las funciones de autocorrelación simple y parcial, etc. Así se pueden obtener el número de rezagos significativos de la parte regular y de la parte estacional. Aquí es importante reseñar que la serie (o los rezagos) que se le pasa a la red neuronal como entrada no tiene la necesidad de ser estacionaria como sí ocurría en los modelos ARIMA)(Pero aunque la red neuronal no necesita que la serie sea estacionaria, si lo es se puede eliminar ruido en la serie, por lo que la predicción podra arrojar mejores resultados). 354 | - Planteamiento de varias redes neuronales tentativas: tiene como objetivo determinar varias arquitectura de la red con diferentes parámetros de entrada como pueden ser el número de rezagos significativos o nº de neuronas de la capa oculta (también se puede transformar o diferenciar la serie (luego se desharán los cambios)). 355 | - Entrenamiento y test (validación): se dividen los datos disponibles en datos de entrenamiento y datos de test para validar la red neuronal (mediante hold-out, validación cruzada, etc.). Se entrenan los diversos modelos de redes neuronales planteados (mediante algoritmos de entrenamiento como por ejemplo back-propagation, etc.) para ajustar los parámetros con los datos de entrenamiento, y se testean con los datos de test para ver cuál de ellos ofrece un mejor rendimiento minimizando el error de predicción (el error de predicción se mide por ejemplo mediante el error medio absoluto, el error cuadrático medio, etc.) (Vuelve a aparecer aquí la opción de validación interna y externa). 356 | ![STexample](http://www.obitko.com/tutorials/neural-network-prediction/images/train.gif) 357 | - Predicción: se realiza la predicción con el modelo que la fase anterior haya determinado como el mejor. 358 | 359 | **Ventajas y desventajas** 360 | 361 | Los modelos no lineales son más potentes, pero por contra necesitan de más datos de entrenamiento, de más parámetros por ajustar, y se comportan peor (por ejemplo son más dados a producir sobreentrenamiento, etc...). Además, su computación es más pesada lo que va a conllevar un mayor tiempo de cómputo. 362 | 363 | ________________________________________________________________________ 364 | 365 | ## Predicción de series temporales con deep learning 366 | 367 | En construcción... 368 | 369 | La estructura anterior de las redes neuronales artificiales (red neuronal poco profunda, superficial o shallow), se ha mantenido vigente durante bastante tiempo debido a los problemas de entrenamiento que se presentaban en las redes neuronales a medida que se ampliaba y profundizaba su estructura. El principal problema es conocido como el problema de la desaparición del gradiente (vanishing gradient problem)(entre otros problemas como capacidad computacional, etc.), dicho problema reside en los algoritmos de entrenamiento (propagación hacia atrás (backpropagation)) debido a que el error se va diluyendo de forma exponencial a medida que atraviesa capas en su camino hasta el principio de la red, lo que es un problema porque en una red muy profunda (con muchas capas ocultas) sólo las últimas capas se entrenan, mientras que las primeras apenas sufren cambios. Lo que ofrece un rendimiento muy bajo con redes neuronales profundas ya que al tener un gran conjunto de pesos iniciales acaba estancándose en algún mínimo local. De echo, los experimentos han demostrado que las redes neuronales profundas con pesos iniciales inicialidos de manera aleatoria, obtienen peores resultados que las redes neuronales con solo una o dos capas ocultas. 370 | 371 | Debido a esta dificultad de entrenar estas arquitecturas profundas de una manera eficiente, las redes neuronales profundas no han tenido relevancia hasta la aparición de algunas técnicas que superan las dificultades de entrenamiento de una estructura profunda, como son los métodos de aprendizaje greedy layer-wise, que sí pueden realizar el entrenamiento de manera adecuada ya que su idea clave es pre-entrenar la red capa por capa de una manera ascendente, de forma que una vez realizado este proceso de pre-entrenamiento, el algoritmo de back-propagation sí puede ser usado para encontrar los parámetros óptimos de la red completa de una manera descendente. Esto ha dado lugar a una mejora significativa de los resultados de las redes neuronales cuando se **pre-entrena** la red con algoritmos de aprendizaje no supervisados. Además, ha dado lugar a que se haya convertido en una técnica muy habitual en Deep Learning entrenar en primer lugar de manera no supervisada greedy layer-wise, y continuar con un entrenamiento supervisado, es decir, el entrenamiento supervisado, en lugar de empezar con pesos al azar, empieza con pesos útiles, especialmente para las primeras capas. 372 | 373 | Un método alternativo al pre-entrenamiento consiste en entrenar la red neuronal profunda de una manera más simple, empleando ReLu en lugar de la típica función sigmoide ¿resuelve problema backpropagation?. 374 | 375 | Al entrenar una red neuronal profunda puede que se produzca sobreentrenamiento si el volumen de datos disponibles es relativamente pequeño con respecto al tamaño de la red neuronal. Cuando se produce este sobreentrenamiento, existe un cierto punto donde el error de test empieza a incrementar mientras el error de entrenamiento aún decrece, lo que significa que el modelo memoriza los datos de entrenamiento dados pero no predice bien en una situación real. Este sobreentrenamiento puede ser observado ¿COMO? 376 | 377 | Así pues una red neuronal profunda es una red neuronal artificial con una arquitectura mayor y más compleja que las 3 o 4 capas habituales de un perceptrón multicapa (entrada, ocultas y salida). Este cambio hacía una estructura profunda (gran número de capas) incrementa la capacidad de absorción automática de caracterísiticas abstractas de una red neuronal sobre los datos. La técnicas de Deep learning han mostrado buenas capacidades para modelar y predecir series temporales por medio de aquitecturas como: 378 | 379 | **Arquitecturas de deep learning empleadas en series temporales** 380 | 381 | - Auto-codificadores (Auto-encoders): se suelen implementar como redes de neuronas con tres capas (entrada y salida de igual tamaño y oculta de tamaño mayor o menor), aprenden a producir a la salida exactamente la misma información que recibe a la entrada. Lo interesante de esto radica en que si la capa oculta tiene un nº menor de neuronas que la capa de entrada, la red se verá obligada a encontrar una representación intermedia de la información en su capa oculta usando menos números, o si por el contrario si la capa oculta tiene más neuronas ahora la red tendría que aprender nuevamente un código alternativo, pero en este caso disperso (cuidado aquí que hay que hacer que la red no solo se limite a copiar información). En ambos casos la red está forzada a generalizar, y encontrar patrones o características fundamentales en los ejemplos que pueda representar mediante las neuronas de su capa oculta. 382 | - Auto-codificadores apilados (stacked auto-encoders): un solo auto-codificador puede encontrar características simples, pero si se quiere que detecten conceptos más complejos se necesita emplear varios. La manera de hacerlo es usar el resultado codificado en la capa oculta de un auto-codificador como la capa oculta de otro auto-codificador. Esto va a permitir obtener características más complejas de los datos. La idea de deep learning mediante auto-codificadores es continuar haciendo esto repetidas veces, por lo que se tendrá una jerarquía de características cada vez más complejas, junto con una pila de codificadores, que serán entrenados uno a uno (mediante back-propagation) usando cada codificador entrenado para entrenar el siguiente (se elimina así el problema inherente a la back-propagation en redes profundas). Tras este paso de pre-entrenamiento los autocodificadores dejan los pesos inicializados eficazmente para en la última capa añadir una o más capas enteramente conectadas con la última capa del autodecodificador de forma que ahora toda la red ahora puede verse como un perceptrón de múltiples capas y es entrenado utilizando backpropagation (este paso también se denomina ajuste fino (fine tuning)). 383 | ![STexample](https://rubenlopezg.files.wordpress.com/2014/04/stacked-autoencoder1.png) 384 | 385 | - Redes de creencia profunda (Deep Belief Networks): una red de creencia profunda está formada por un conjunto de máquinas de Bolztmann restringuidas. 386 | - Máquina de Boltzmann restringuida (Restricted Boltzmann Machine): es una red neuronal shallow que puede aprender una distribución de probabilidad sobre su propio conjunto de entradas. Están compuestas de una capa oculta y otra visible con conexiones completamente conectadas y no dirigidas entre ellas. El principal interés en ellas ha venido por la reciente introducción del algoritmo de entrenamiento no supervisado de la divergencia contrastiva, método por el cuál se entrenan. 387 | 388 | Este procedimiento puede volver a ser visto como un procedimiento de dos pasos, un primero que lleva a cabo un aprendizaje de características de los datos de entrada, y un segundo paso añadido para la predicción. Es muy similar a los autoencoders apilados, pero en este caso los autoencoders han sido reemplazados por MBR, luego en una red de creencia profunda la capa de entrada de la primera MBR es la capa de entrada para toda la red, la capa oculta de la primera MBR es la capa de entrada de la segunda MBR, y así sucesivamente. Cada MBR se pre-entrena de manera greedy layer-wise una a una pero esta vez en vez de con back-propagation, se realiza con el algoritmo de divergencia contrastiva. Después del pre-entrenamiento, y al igual que en los autoencoders apilados, los pesos están inicializados y la red se puede ampliar mediante la conexión de una o más capas completamente conectadas a la capa oculta final MBR, formando un perceptrón de múltiples capas que puede ser afinado mediante backpropagation. 389 | 390 | - LSTM (Recurrent neural networks): 391 | 392 | 393 | 394 | 395 | **Última capa** 396 | 397 | On a deep neural network of many layers, the final layer has a particular role. When dealing with labeled input, the output layer classifies each example, applying the most likely label. Each node on the output layer represents one label, and that node turns on or off according to the strength of the signal it receives from the previous layer’s input and parameters. 398 | 399 | Deep-learning networks end in an output layer: a logistic, or softmax, classifier that assigns a likelihood to a particular outcome or label. 400 | 401 | Softmax is a function used as the output layer of a neural network that classifies input. It converts vectors into class probabilities. Softmax normalizes the vector of scores by first exponentiating and then dividing by a constant. 402 | 403 | Then a supervised learner such as softmax or SVM/SVR can be added on top of DBN. 404 | 405 | *** 406 | 407 | Loss Functions in DeepLearning 408 | 409 | MSE: Mean Squared Error: Linear Regression 410 | EXPLL: Exponential log likelihood: Poisson Regression 411 | XENT: Cross Entropy: Binary Classification 412 | MCXENT: Multiclass Cross Entropy 413 | RMSE_XENT: RMSE Cross Entropy 414 | SQUARED_LOSS: Squared Loss 415 | NEGATIVELOGLIKELIHOOD: Negative Log Likelihood 416 | 417 | 418 | *** 419 | 420 | FUNCIONES DE ACTIVACION 421 | 422 | Sigmoid and tanh should not be used as activation function for the hidden layer. This is because of the vanishing gradient problem, i.e., if your input is on a higher side (where sigmoid goes flat) then the gradient will be near zero. 423 | The best function for hidden layers is thus ReLu. 424 | 425 | outputo layer -> Regression: linear (because values are unbounded) 426 | Classification: softmax (simple sigmoid works too but softmax works better) 427 | 428 | ¿activation funtion in hidden and output layer? 429 | 430 | 431 | 432 | *** 433 | 434 | **Librerias que permiten aplicar deep learning sobre series temporales** 435 | 436 | - TensorFlow 437 | - Theano 438 | - Keras 439 | 440 | ************ 441 | 442 | Activation function te marca la salida de la red, por ejemplo, sofmax clasificación en eqtiquetas, sigmoide regresión logística... 443 | 444 | The sigmoid function can be applied easily, the ReLUs will not vanish the effect during your training process. However, when you want to deal with classification problems, they cannot help much. 445 | 446 | *** 447 | 448 | Forma de obtener el número de capas óptimo: Otro consejo: No te lances a meter capas. Empieza entrenando con pocos datos y pocas capas. Mantén siempre un conjunto de datos de entrenamiento y uno de test. Nunca entrenes con los datos de test. Pero durante el entrenamiento ve evaluando el error en ambos conjuntos. Si ves que ambos van bajando, genial. Si el error de test empieza a diverger, necesitas más datos. Si el error de entrenamiento se estanca y lo quieres más bajo, necesitas más capas. 449 | 450 | *** 451 | 452 | greedy = algoritmo voraz 453 | 454 | 455 | *** 456 | 457 | 458 | TRUCOS 459 | 460 | - before training on the whole dataset try to overfit on a very small subset of it, that way you know your network can converge. 461 | - Always use dropout to minimize the chance of overfitting. Use it after large > 256 (fully connected layers or convolutional layers). 462 | - Avoid Sigmoid's , TanH's gates they are expensive and get saturated and may stop back propagation. In fact the deeper your network the less attractive Sigmoid's and TanH's are. Use the much cheaper and effective ReLU's and PreLU's instead. 463 | - Don't use ReLU's they are so 2012. Yes they are a very useful non-linearity that solved a lot of problems. However try fine-tuning a new model and watch nothing happen because of bad initialization with ReLU's blocking backpropagation. Instead use PreLU's with a very small multiplier usually 0.1. Using PreLU's converges faster and will not get stuck like ReLU's during the initial stages. 464 | - Use Batch Normalization (check paper Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift) ALWAYS. It works and it is great. It allows faster convergence ( much faster) and smaller datasets. You will save time and resources 465 | - Always go for the smaller models, if you are working and deploying deep learning models like me, you quickly understand the pain of pushing gigabytes of models to your users or to a server in the other side of the world. Go for the smaller models even if you lose some accuracy. 466 | - Don't even try to train anything without a high end GPU. 467 | ________________________________________________________________________ 468 | 469 | ## Análisis de series temporales multivariantes 470 | 471 | Los modelos vistos hasta ahora, constituyen una modelización univariante de una serie temporal (útiles para conocer las características de una serie temporal de tendencia, ciclo, estacionalidad, o para predecir), pero no tienen en cuenta la interrelación entre distintas variables (variable objeto de estudio con otras variables relevantes), y por lo tanto su utilidad puede verse limitada. Esta necesidad del estudio interrelacional entre variables se hace latente en muchos ámbitos, un ejemplo de esta necesidad se refleja en el ámbito económico, ya que por ejemplo la realidad económica de sectores, países, empresas, o el conjunto de la economía mundial viene determinada porque sus variables económicas se determinan por la interrelación entre distintas variables, así por ejemplo las ventas de una empresa están en relación con la renta de los consumidores, o la demanda de turistas está en relación con el crecimiento del PIB o de los precios relativos, etc. 472 | 473 | Para resolver estas limitaciones se presentan los modelos multivariantes, que son modelos que sí tienen en cuenta la interrelación entre variables de distintas series temporales, luego estos modelos contienen varias series temporales. Concretamente estudian la relación entre una variable de interés y una serie de variables explicativas (que influyen en la variable de interés). En el marco multivariante se considera el pasado tanto de la variable que se quiere explicar, como el de las variables que están relacionadas con dicha variable. Los modelos multivariantes de series temporales son una generalización de los modelos univariantes, la diferencia está en que en vez de una sola variable hay n variables (en vez de una serie, hay varias series). 474 | 475 | ## Enfoque Box-Jenkins 476 | 477 | La forma multivariante de los modelos ARIMA Box-Jenkins es llamada modelos VARMA o ARMAV (AutoRegressive Moving Average Vector) (VARIMA o ARIMAV). Sin embargo, el ajuste de este tipo modelos es bastante complicado, lo que hace que por simplicidad una de las formas más frecuentes de modelar modelos multivariantes sea como vectores autoregresivos: 478 | 479 | **VAR** 480 | 481 | Los modelos de **vectores autoregresivos**, VAR, son unos de los modelos más empleados para el análisis de series de tiempo multivariantes. Los modelos VAR son una extensión de los modelos AR, con la diferencia de que mientras que los modelos autorregresivos univariantes recogen la dinámica de una sola serie temporal, los modelos multivariantes recogen las estructuras dinámicas sobre varias series temporales (por lo que presentan tantas ecuaciones como series haya). Dicha estructura consiste en un sistema de ecuaciones en la que cada una representa una función lineal de los rezagos pasados de la variable (como en un modelo AR) y los rezagos de las demás variables de las otras series (no se distingue entre variables endógenas y exógenas). Por ejemplo, si un modelo AR(p) venía dado por la expresión: yt=f0+f1yt-1+f2yt-2+......+fpyt-p+at, ahora se tiene que en lugar de modelar el comportamiento de una variable, modelamos el de k variables, es decir consideremos un vector columna de k variables aleatorias: Yt=[y1, y2, ... , yk]. Luego la expresión general de un modelo VAR viene dada por: 482 | 483 | yt=f1yt-1+f2yt-2+......+fpyt-p+gxt+at 484 | 485 | Donde yt es la variable objeto de predicción (vector de variables a predecir), xt es un vector de k variables explicativas, y f y g son los vectores de coeficientes a estimar, con a como el vector de perturbaciones aleatorias. Esta estructura es propicia para ser representada en forma matricial, y es fácilmente extendible para contener un número mayor de series y de rezagos. El número de rezagos empleado viene denotado por el componente p de VAR(p). 486 | 487 | Al igual que con los modelos univariantes, existe una metodología para la construcción de los modelos multivariantes: 488 | - Se necesita que las series temporales que forman el modelo multivariante sean estacionarias (una serie temporal multivariante es estacionaria si todas las series temporales que la componen son estacionarias), para ello se pueden emplear las mismas técnicas para comprobar la estacionariedad (gráficas de las funciones de autocorrelación, test de estacionariedad, etc.), y también para conseguir que sea estacionaria (diferenciación). 489 | - Se necesita identificar el modelo VAR(p) que sigue la serie (longitud de retardos seleccionados), para ello se tiene que determinar el orden más apropiado para el modelo, lo que se puede hacer de la misma manera que en las series univariantes (extensiones multivariantes del AIC, BIC, HQ, etc.)(Puede ser el caso que este conjunto de pruebas estadísticas no dejen una dirección clara, entonces se tiene que se ha demostrado que los criterios BIC y HQ proporcionan estimaciones consistentes del verdadero orden del retardo, mientras que AIC sobreestima el orden del retardo con una alta probabilidad). 490 | - Se estiman ecuación a ecuación como una serie univariante aplicando MCO transformado matricialmente para un sistema de ecuaciones. 491 | - Se necesita validar el modelo multivariante elegido, para ello es crucial que los residuos cumplan la asunción de ser ruidos blancos multivariantes. Se destaca aquí los test de Portmanteau que prueban que los residuos están incorrelacionados. 492 | - La predicción con modelos VAR es una extensión de la predicción con modelos AR. 493 | 494 | **VEC** 495 | 496 | En los modelos VAR, así como en la modelización univariante de series temporales, se asume que las series temporales utilizadas son estacionarias, esto debe de ser así ya que cuando se efectúan regresiones entre variables no estacionarias podemos caer en el problema de las llamadas correlaciones espurias (estimaciones de modelos que presentan en principio buenas validaciones, pero que encierran relaciones no-reales). Aunque en general la regresión entre series no estacionarias conduce a correlaciones espurias, existe una situación especial en el que tal regresión no sería espuria, sino que el estimador MCO sería correcto. Esa situación especial recibe el nombre de **cointegración** (Por definición, una combinación lineal de dos o más series no estacionarias puede ser estacionaria. Luego si existe una combinación lineal de series que es estacionaria, se dice que las series no estacionarias, con raíz unitaria, que dan lugar a esa combinación están cointegradas). La combinación lineal estacionaria se denomina ecuación de cointegración y puede interpretarse como la relación de equilibrio a largo plazo entre las distintas variables que conforman la ecuación por lo cual, en sí misma, tiene una alta importancia para el análisis de los fenómenos que la serie contiene. 497 | 498 | Pues bien, un modelo de **vector de corrección del error** (VEC)(VECM, Vector Error Correction Models) es un modelo VAR restringido (habitualmente con sólo dos variables) que tiene restricciones de cointegración incluidas en su especificación, por lo que se diseña para ser utilizado con series que no son estacionarias pero de las que se sabe que son cointegradas. El principio detrás de estos modelos es que existe una relación de equilibrio a largo plazo entre variables y que, sin embargo, en el corto plazo puede haber desequilibrios. Con los modelos de corrección del error, una proporción del desequilibrio de un período es corregido gradualmente a través de ajustes parciales en el corto plazo. Una de las claves de los modelos VEC es determinar si las series que se modelan son cointegradas y, si es así, determinar la ecuación de integración. Para ello se utiliza el método de Johansen (luego si la serie multivariante es cointegrada se utiliza un modelo VEC, si no es cointegrada se utiliza un modelo VAR). 499 | 500 | ________________________________________________________________________ 501 | 502 | ## Manejo de datos perdidos en series temporales 503 | 504 | En el desarrollo teórico de la mayoría de técnicas y modelos no se tienen en cuenta algunas cuestiones que surgen en su aplicación práctica, como es en concreto la existencia de datos faltantes, también denominados perdidos o incompletos. Muchas series temporales existentes contienen valores perdidos o no presentes en las observaciones que las componen (ya sean provocados por mediciones incorrectas, errores, etc). Estos valores perdidos crean numerosos problemas y hacen dificil el análisis de los datos, por lo tanto su presencia hace que sea necesaria una etapa de preprocesado de la serie. Los modelos de pérdida de datos se clasifican en tres tipos diferentes: MCAR, MAR y MNAR. Conocer esta causa que genera los datos perdidos es importante ya que puede ser de ayuda a la hora de seleccionar un método concreto para tratarlos. 505 | 506 | La manera más simple de tratar con ellos es descartándolos, pero esto solo es posible cuándo son muy pocos los valores perdidos y no tienen influencia en el análisis posterior. Otra forma de lidiar con ellos es realizar el análisis únicamente con los datos disponibles. Pero uno de los métodos más conocidos para tratar con este problema es la imputación. 507 | 508 | **Imputación** 509 | 510 | En estadística, la imputación es el proceso de reemplazar los valores perdidos con valores sustitutos. El objetivo de la imputación es rellenar los valores perdidos con estimaciones (realizadas con el método de aprendizaje más apropiado para cada caso) de estos teniendo en cuenta las relaciones posibles entre las observaciones. Luego existen diversos métodos de imputación diferenciados en la forma de estimar los datos faltantes, cuya elección preferible vendrá dada por la naturaleza de la serie: 511 | 512 | - Métodos de imputación simples 513 | - Imputación mediante la media: se reemplazan los valores perdidos por la media de los valores observados. 514 | - Imputación mediante regresión: se estima una regresión de las observaciones existentes y se imputa cada valor perdido mediante la ecuación de regresión estimada. 515 | - Imputación mediante regresión estocástica: similar al enterior pero se imputa añadiendo a la predicción un valor residual para reestablecer la pérdida de variabilidad. 516 | - Imputación mediante médias móviles: se reemplazan las observaciones faltantes por los valores estimados mediante médias móviles. 517 | - Imputación por Last Observation Carried Forward (locf): reemplaza el dato perdido por la observacion que le precede. 518 | - Imputación por interpolación: se estiman los valores perdidos interpolando (uniendo de manera lineal, polinomial, etc.) el último valor válido antes del valor perdido y el primer valor válido después del valor perdido. 519 | - Métodos de imputación basados en máxima verosimilitud 520 | - Imputación múltiple: consiste en realizar varias imputaciones de las observaciones faltantes para luego analizar los conjuntos de datos completados y combinar los resultados obtenidos para obtener una estimacion final. El análisis de imputación múltiple esta dividido en tres fases: fase de imputacion, fase de análisis y fase de puesta en común. 521 | - Imputación mediante el algoritmo EM (Expectation-Maximization): es un algoritmo importante para el análisis de datos faltantes. Es un método iterativo de dos pasos (esperanza y maximizacion) donde se comienza por reemplazar los datos ausentes por unos valores estimados y a continuación se procede a una primera estimación de los parámetros, para con estos parámetros volver a iniciar al primer paso y así sucesivamente hasta que la convergencia de los parámetros sea aceptable. 522 | - Métodos de imputación basados en machine learning 523 | - Imputación con K-Nearest Neighbor: se estiman los valores peridos con la media de los vecinos seleccionados. 524 | - Imputación con K-means 525 | - Imputación con máquinas de soporte vectorial 526 | 527 | En el ámbito de la imputación, la imputación en series temporales univariantes es un reto adicional, debido a que la mayoría de algoritmos complejos están desarrollados para series temporales multivariantes ya que dependen de la correlación entre los inter-atributos para estimar los valores de los datos perdidos (imputación múltiple, EM, kNN, etc.), algo que no ocurre en el caso univariante (al ser un único atributo). Pero además de los métodos simples, también hay posibilidades adicionales más complejas para la imputación en series temporales univariantes: 528 | - Algoritmos multivariantes con datos retardados: consisten en emplear indirectamente los algoritmos de series multivariantes en series univariantes empleando el tiempo (variable implícita de una serie temporal) como un atributo más. La forma habitual de hacer esto es mediante lags (variables que toman el valor de otra variable en un instante de tiempo previo) y leads (toman el valor de otra variable en un instante de tiempo posterior). 529 | - Filtro de Kalman con modelos ARIMA de espacio de estados: todos los modelos ARIMA pueden ser reescritos (y estimados) como modelos en el espacio de estados. Estos modelos en el espacio de estados pueden entre otras muchas cosas estimar observaciones perdidas. Luego los principales beneficios de representar sistemas dinámicos en forma de espacio de estados es que el espacio de estados permite que las variables no observadas puedan ser incorporadas y estimadas junto con el modelo observable, y que además, estos modelos en el espacio de estados pueden ser analizados usando un algoritmo recursivo llamado filtro de Kalman (Kalman filter), que es usado, entre otras cosas, para determinar las estimaciones óptimas de los modelos en el espacio de estados. 530 | 531 | ________________________________________________________________________ 532 | 533 | ## Series temporales con R 534 | 535 | ## Series temporales con alisados, arima, etc. con R 536 | 537 | **Series temporales univariantes** 538 | 539 | Para que R trate a un conjunto de datos como serie temporal: 540 | 541 | ts(data, start, end, frequency) 542 | 543 | - data: vector o matrix con las observaciones 544 | - start: tiempo de la primera observación 545 | - end: tiempo de la última observación 546 | - frequency: número de observaciones por unidad de tiempo 547 | 548 | Conocer el tiempo de comienzo de la serie: 549 | 550 | start(serie temporal) 551 | 552 | Conocer el tiempo de fin de la serie: 553 | 554 | end(serie temporal) 555 | 556 | Conocer la frecuencia de la serie: 557 | 558 | frequency(serie temporal) 559 | 560 | Representación gráfica de la serie: 561 | 562 | plot(serie temporal) *llama internamente a plot.ts(serie temporal)* 563 | 564 | Representación numérica de la serie: 565 | 566 | print(serie temporal) 567 | 568 | Unidad de tiempo a la que pertenece cada observación de la serie: 569 | 570 | cycle(serie temporal) 571 | 572 | Obtener un subconjunto de la serie teporal (puede ser interesante por ejemplo para pintar un año y ver si presenta componente estacional): 573 | 574 | window(serie temporal, start, end) 575 | 576 | - start: tiempo de la primera observación 577 | - end: tiempo de la última observación 578 | 579 | Extraer las subseries estacionales de la serie y pintarlas todas juntas (es interesante para ver la componente estacional)(lo ideal es usarlas sin la componente tendecia): 580 | 581 | monthplot(serie temporal, phase) 582 | 583 | - phase: indica la estación a la que corresponde cada muestra 584 | 585 | boxplot(formula, serie temporal) 586 | 587 | - formula: fórmula que indica la serie temporal y su división en ciclos (es decir, a que estación o ciclo corresponde cada muestra) 588 | 589 | Agregación de los datos de la serie temporal (puede ser interesante por ejemplo para cambiar la frecuencia de anual a trimestral)(siempre que los datos sean agregables): 590 | 591 | aggregate(serie temporal, FUN, nfrequency) 592 | 593 | -FUN: función con la que se computa la agregación (mean) 594 | -nfrequency: nuevo número de observaciones por unidad de tiempo (12->mensual, 4->trimestral, 1->anual...) 595 | 596 | Retardar la serie temporal: 597 | 598 | lag(serie temporal, k) *paquete stat* *realiza un rezago del tiempo de la serie temporal* 599 | Lag(serie temporal, k) *paquete quantmod* *si se le pasa una serie temporal realiza un rezago del tiempo de la serie temporal, si no, realiza un rezago de los datos añadiento un valor NA al principio* 600 | 601 | - k: número de rezagos aplicados a la serie 602 | 603 | Descomposición de una serie temporal en Tendencia + Efecto estacional + Residuos: 604 | 605 | decompose(serie temporal, type) *mediante medias móviles* 606 | 607 | - type: tipo de serie, aditiva o multiplicativa 608 | 609 | stl(serie temporal, s.windows) *mediante loess* 610 | 611 | - s.windows: establecido con "period" o con el periodo para la extracción de la estacionalidad 612 | 613 | Transformación logarítmica de una serie: 614 | 615 | log(serie temporal, base) 616 | 617 | - base: base del logaritmo. 10 por defecto 618 | 619 | Transformación BoxCox de una serie: 620 | 621 | BoxCox(serie temporal, lambda) 622 | 623 | - lambda: parámetro de la transformación, el parámetro óptimo para los datos se consigue con la función BoxCox.lambda(serie temporal, method=c("loglik","guerrero")) 624 | 625 | Test de heterodasticidad de Goldfeld-Quandt (hipótesis nula de que la varianza es igual en toda la serie): 626 | 627 | gqtest(formula) *paquete lmtest* 628 | 629 | - formula: descripción simbólica del modelo 630 | 631 | Cómputo de las estimaciones de las funciones de autocorrelación y autocorrelación parcial: 632 | 633 | acf(serie temporal, lag.max) *paquete stats* 634 | Acf(serie temporal, lag.max) *paqute forecast* 635 | 636 | pacf(serie temporal, lag.max) *paquete stats* 637 | Pacf(serie temporal, lag.max) *paqute forecast* 638 | 639 | - lag.max: número máximo de retardos calculados 640 | 641 | Cálculo del test de Dickey-Fuller Ampliado (Test ADF) para estacionariedad: 642 | 643 | adf.test(serie temporal) *paquete tseries* *siempre elimina la tendencia de la serie evaluada* 644 | 645 | adfTest(serie temporal, type) *paquete fUnitRoots* 646 | 647 | type: tipo de regresión de raíz unitaria empleada. "nc" sin intercepto ni tendencia, "c" sin tendencia con intercept, "ct" con intercepto y tendencia 648 | 649 | Cálculo del test de Kwiatkowski-Phillips-Schmidt-Shin (Test KPSS) para estacionariedad: 650 | 651 | kpss.test(serie temporal) 652 | 653 | Cálculo de la tendencia mediante modelos lineales y polinómicos: 654 | 655 | lm(formula) 656 | 657 | - formula: 658 | - Para modelos lineales: serie temporal ~ tiempo 659 | - Para modelos polinómicos: serie temporal ~ tiempo + I(tiempo^2) + ... 660 | 661 | Cálculo de la tendencia mediante filtrado (medias móviles): 662 | 663 | filter(serie temporal, filter, method, sides) 664 | 665 | - filter: vector de coeficientes del filtro 666 | - method: "convolution" para usar medias móviles 667 | - sides: "2" para centrados 668 | 669 | decompose(sertie temporal)$trend 670 | 671 | ma(serie temporal, order, centre) *paquete forecast* 672 | 673 | - order: orden la media móvil 674 | - centre: si se desea centrar la media móvil sea cual sea el orden 675 | 676 | Eliminación de la tendencia mediante diferenciación (lag=1): 677 | 678 | diff(serie temporal) 679 | 680 | Eliminación de la estacionalidad mediante diferenciación del orden del periodo: 681 | 682 | diff(serie temporal, lag) 683 | 684 | - lag: retardo a emplear 685 | 686 | La diferenciación se puede deshacer con: 687 | 688 | diffinv(serie temporal, lag) 689 | 690 | - lag: retardo empleado 691 | 692 | Cálculo del número de diferenciaciones regulares necesarias para hacer la serie estacionaria: 693 | 694 | ndiffs(serie temporal, test) 695 | 696 | - test: tipo de test con el que se realiza el cálculo; "adf" (Augmented Dickey-Fuller), "kpss", "pp" (Phillips-Perron) 697 | 698 | Cálculo del número de diferenciaciones estacionales necesarias para hacer la serie estacionaria: 699 | 700 | nsdiffs(serie temporal, m) 701 | 702 | - m: longitud del periodo estacional 703 | 704 | Cálculo (identificación) automático del mejor modelo ARIMA al que se ajustan los datos (se puede usar por ejemplo simplemente como una primera aproximación)(lo ideal es usarlo con la serie ya una vez sea estacionaria): 705 | 706 | auto.arima(serie temporal, seasonal, stepwise, d, D) 707 | 708 | - seasonal: con true o false indicamos si las búsqueda restringuen el componente estacional 709 | - stepwise: a FALSE realiza una búsqueda sobre todos los modelos (lento), a TRUE hace una búsqueda gradual (rápido) 710 | - d: orden de la primera diferenciación regular 711 | - D: orden de la diferenciación estacional 712 | 713 | Simulación de un modelo ARIMA: 714 | 715 | arima.sim(model, n) 716 | 717 | - model: lista con los componenetes AR y MA, se puede usar también _order_ para el orden 718 | - n: longitud de la serie que se simula 719 | 720 | Ajuste del modelo ARIMA sobre una serie temporal: 721 | 722 | arima(serie temporal, order, seasonal) *paquete stats* 723 | Arima(serie temporal, order, seasonal,lambda) *permite una componente de tendencia* *paquete forecast* 724 | 725 | - order: especificación de los tres componentes del modelo en forma de vector 726 | - seasonal: especificación de la parte estacional del modelo junto con el periodo (si la serie original es estacionaria) 727 | - lambda: si está presente indica el valor que debe de emplear una transformación de BoxCox sobre los datos 728 | 729 | Ajuste de un modelo autorregresivo AR sobre una serie temporal: 730 | 731 | ar(serie temporal, order.max, method) 732 | 733 | - order.max: orden máximo del modelo a ajustar 734 | - method: método con el que se ajusta el modelo 735 | 736 | Evaluación de la bondad del ajuste de varios modelos mediante el criterio AIC (Akaike Information Criterion) o BIC (Bayesian Information Criterion): 737 | 738 | AIC(object, object, ...) 739 | BIC(object, object, ...) 740 | 741 | - object: modelos de serie temporal que se quieren comparar 742 | 743 | Test de Ljung-Box y Box-Pierce para la hipótesis de independencia: 744 | 745 | Box.test(residuos modelo,type) 746 | 747 | - type: "Ljung-Box" o "Box-Pierce" (por defecto) 748 | 749 | Test de normalidad con los estadísticos Jarque Bera y Shapiro-Wilk: 750 | 751 | jarque.bera.test(residuos modelo) 752 | shapiro.test(residuos modelo) 753 | 754 | Predecir una serie temporal: 755 | 756 | forecast(object, h) 757 | 758 | - object: modelo de serie temporal 759 | - h: número de periodos a predecir 760 | 761 | predict(object, n.ahead) 762 | 763 | - object: modelo de serie temporal 764 | - n.ahead: número de periodos a predecir 765 | 766 | Medición de la afinidad del modelo predicho (Error medio (ME), Error medio absoluto (MAE), Porcentaje del error medio absoluto (MAPE), Error medio absoluto escalado (MASE), Porcentaje del error medio (MPE), etc.): 767 | 768 | accuracy(object, x) 769 | 770 | - object: objeto de la clase forecast (también sirve con arima) o un vector numérico con las predicciones 771 | - x: vector con los valores reales a comparar 772 | 773 | Ajustar una serie temporal mediante un alisado exponencial simple: 774 | 775 | HoltWinters(serie temporal, alpha, beta, gamma) *paquete stats* 776 | 777 | - alpha: parámetro alpha del alisado exponencial 778 | - beta: parámetro beta del alisado exponencial. Debe establecerse a FALSE 779 | - gamma: parámetro gamma del alisado exponencial. Debe establecerse a FALSE 780 | 781 | ses(serie temporal, alpha, h) *paquete forecast* 782 | 783 | - alpha: parámetro alpha del alisado exponencial 784 | - h: nº de periodos a predecir 785 | 786 | Ajustar una serie temporal mediante un alisado exponencial doble: 787 | 788 | HoltWinters(serie temporal, alpha, beta, gamma) *paquete stats* 789 | 790 | - alpha: parámetro alpha del alisado exponencial 791 | - beta: parámetro beta del alisado exponencial 792 | - gamma: parámetro gamma del alisado exponencial. Debe establecerse a FALSE 793 | 794 | holt(serie temporal, alpha, beta, h, exponential, damped) *paquete forecast* 795 | 796 | - alpha: parámetro alpha del alisado exponencial 797 | - beta: parámetro beta del alisado exponencial 798 | - h: nº de periodos a predecir 799 | - exponential: a TRUE se calcula una tendencia exponencial, a FALSE lineal 800 | - damped: a TRUE para no usar una tendencia lineal 801 | 802 | Ajustar una serie temporal mediante un alisado exponencial Holt-Winter: 803 | 804 | HoltWinters(serie temporal, alpha, beta, gamma, seasonal) *paquete stats* 805 | 806 | - alpha: parámetro alpha del alisado exponencial 807 | - beta: parámetro beta del alisado exponencial 808 | - gamma: parámetro gamma del alisado exponencial 809 | - seasonal: permite diferenciar entre un modelo aditivo o multiplicativo. Solo disponible si está presente el parámetro gamma 810 | 811 | hw(serie temporal, alpha, beta, gamma, seasonal, h, exponential, damped) *paquete forecast* 812 | 813 | - alpha: parámetro alpha del alisado exponencial 814 | - beta: parámetro beta del alisado exponencial 815 | - gamma: parámetro gamma del alisado exponencial 816 | - seasonal: permite diferenciar entre un modelo aditivo o multiplicativo 817 | - h: nº de periodos a predecir 818 | - exponential: a TRUE se calcula una tendencia exponencial, a FALSE lineal 819 | - damped: a TRUE para no usar una tendencia lineal 820 | 821 | Predicción de valores de una serie temporal ajustada con un alisado: 822 | 823 | forecast(object, h) *forecast.HoltWinters()* 824 | 825 | - object: modelo de serie temporal 826 | - h: número de periodos a predecir 827 | 828 | predict(object, n.ahead) *predict.HoltWinters* 829 | 830 | - object: modelo de serie temporal 831 | - n.ahead: número de periodos a predecir 832 | 833 | Ajuste de una serie temporal aditiva (con tendencia no lineal y estacionalidad semanal y anual)(buena con periodicidad diaria): 834 | 835 | prophet(df, changepoints, n.changepoints, changepoint.prior.scale) 836 | 837 | - df: data.frame con una columna ds con el tiempo, y otra columna y con las observaciones 838 | - changepoints: fechas dentro de df$ds para testear si hay en ellas un cambio de tendencia. Por defecto vacío 839 | - n.changepoints: número de fechas a testear. Por defecto 25 840 | - changepoint.prior.scale: establece la flexibilidad en el cambio de tendencia.Por defecto 0.5 841 | 842 | Extensión del data.frame de la serie temporal aditiva con los periodos temporales a predecir: 843 | 844 | make_future_dataframe(m, periods, freq) 845 | 846 | - m: objeto prophet 847 | - periods: nº de periodos que se va a predecir 848 | - freq: frecuencia de la serie 849 | 850 | Predicción de la serie temporal aditiva: 851 | 852 | predict(object, df) *predict.prophet* 853 | 854 | - object: objeto prophet 855 | - df: data.frame con el periodo a predecir incluido (también predice la serie ajustada) 856 | 857 | **Series temporales multivariantes** 858 | 859 | Determinación del nº de lags óptimos a emplear en un modelo VAR: 860 | 861 | VARselect(serie temporal, lag.max) *paquete vars* 862 | 863 | - lag.max: número máximo de retardos a evaluar 864 | 865 | VARorder(serie temporal, maxp) *paquete MTS* 866 | 867 | - max.p: número máximo de retardos a evaluar 868 | 869 | Estimación de un modelo VAR empleando mínimos cuadrados ordinarios por ecuación: 870 | 871 | VAR(serie temporal, p) 872 | 873 | - p: orden, nº de rezagos empleados 874 | 875 | Ploteo de un modelo VAR ajustado: 876 | 877 | plot(modeloVAR) 878 | 879 | - modeloVAR: resultado del ajuste de un modelo VAR 880 | 881 | Pruebas de cointegración de Johansen: 882 | 883 | ca.jo(serie tempotal, type, K) 884 | 885 | - type: test empleado, "eigen" o "trace" 886 | - K: lag de la serie VAR 887 | 888 | Ajuste y estimación de los parámetros de cointegración: 889 | 890 | cajorls(serie temporal, r) 891 | 892 | - r: rango de cointegración 893 | 894 | Transformación de un modelo VECM en un modelo VAR: 895 | 896 | vec2var(z, r) 897 | 898 | - z: objeto obtenido con ca.jo 899 | - r: rango de cointegración 900 | 901 | ### Paquetes R para el análisis y tratamiento de Series Temporales: 902 | 903 | - stats: incorporado en R 904 | - base: incorporado en R 905 | - tseries: https://cran.r-project.org/web/packages/tseries/index.html 906 | - forecast: https://cran.r-project.org/web/packages/forecast/index.html 907 | - TSA: https://cran.r-project.org/web/packages/TSA/TSA.pdf 908 | - prophet: https://cran.r-project.org/web/packages/prophet/prophet.pdf 909 | 910 | - vars: https://cran.r-project.org/web/packages/vars/vars.pdf 911 | - MTS: https://cran.r-project.org/web/packages/MTS/MTS.pdf 912 | ________________________________________________________________________ 913 | 914 | ## Series temporales con redes neuronales con R 915 | 916 | Debido a que las redes neuronales tienen un componente aleatorio, es aconsejable establecer una semilla para asegurar que los datos sean reproducibles. 917 | 918 | Ajuste de una serie temporal con redes neuronales feed-fordward: 919 | 920 | nnetar(serie temporal, p, P, size, repeats, lambda, scale.inputs) *paquete forecast* 921 | 922 | - p: nº de retardos no estacionales. Para datos no estacionales, el valor por defecto es el nº óptimo de razagos (acorde al AIC) de un modelo AR(p) lineal. Para datos estacionales, el valor por defecto sigue la misma metodología, pero aplicada a los datos ajustados estacionalmente (a partir de una descomposición stl) 923 | - P: nº de retardos estacionales. Por defecto es 1 924 | - size: nº de neuronas de la capa oculta. Por defecto es el redondeo al entero más cercano de k=(p+P+1)/2 (la mitad de los nodos de entrada) 925 | - repeats: nº de redes ajustadas con valores de los pesos diferentes (inicializados aleatoriamente) 926 | - lambda: parámetro para una transformación de box cox 927 | - scale.inputs: por defecto TRUE, las entradas son escaladas 928 | 929 | nnet(formula, x, y, data, size, linout) *paquete nnet* 930 | 931 | - formula: formula que debe aprender la red neuronal (valor real de la serie y rezagos) 932 | - x: matriz o data.frame con los datos de los rezagos de la serie 933 | - y: matriz o data.frame con los datos reales de la serie 934 | - data: data.frame con los valores que aparecen en formula 935 | - size: número de neuronas de la capa oculta 936 | - linout: salida lineal o logística 937 | 938 | neuralnet(formula, data, hidden, algorithm) *paquete neuralnet* 939 | 940 | - formula: formula que debe aprender la red neuronal (valor real de la serie y rezagos) 941 | - data: data.frame con los valores que aparecen en formula 942 | - hidden: número de neuronas de la capa oculta 943 | - algorithm: algoritmo empleado para calcular (entrenar) la red 944 | 945 | mlp(x, y, size, learnFunc, linOut) *paquete rsnns* 946 | 947 | - x: entradas de la red neuronal 948 | - y: salidas de la red neuronal 949 | - size: nº de neuronas en la capa oculta 950 | - learnFunc: algoritmo empleado para aprender la red 951 | - linOut: función de activación de la salida lineal (TRUE) o logística 952 | 953 | Normalización de las observaciones de una serie temporal: 954 | 955 | scale(x) 956 | 957 | - x: datos que se van a normalizar 958 | 959 | normalizeData(x, type) 960 | 961 | - x: datos que se van a normalizar 962 | - type: tipo de normalización empleada ("0_1", "norm" o "center") 963 | 964 | denormalizeData(x, normParams) 965 | 966 | - x: valores a des-normalizar 967 | - normParams: parámetros generados durante la normalización (se obtienen con getNormParameters(x)) 968 | 969 | Ajuste de una serie temporal con redes neuronales parcialmente recurrentes: 970 | 971 | jordan(x, y, size, learnFunc, linOut) *paquete rsnns* 972 | 973 | - x: entradas de la red neuronal 974 | - y: salidas de la red neuronal 975 | - size: nº de neuronas en la capa oculta 976 | - learnFunc: algoritmo empleado para aprender la red 977 | - linOut: función de activación de la salida lineal (TRUE) o logística 978 | 979 | elman(x, y, size, learnFunc, linOut) *paquete rsnns* 980 | 981 | - x: entradas de la red neuronal 982 | - y: salidas de la red neuronal 983 | - size: nº de neuronas en la capa oculta 984 | - learnFunc: algoritmo empleado para aprender la red 985 | - linOut: función de activación de la salida lineal (TRUE) o logística 986 | 987 | ### Paquetes R para el análisis y tratamiento de Series Temporales con redes neuronales: 988 | 989 | - forecast: https://cran.r-project.org/web/packages/forecast/index.html 990 | - nnet: https://cran.r-project.org/web/packages/nnet/nnet.pdf 991 | - neuralnet https://cran.r-project.org/web/packages/neuralnet/neuralnet.pdf 992 | - rsnns: https://cran.r-project.org/web/packages/RSNNS/RSNNS.pdf 993 | - rnn: https://cran.r-project.org/web/packages/rnn/rnn.pdf 994 | 995 | ________________________________________________________________________ 996 | 997 | ## Imputación de datos perdidos en series temporales con R 998 | 999 | **Series temporales univariantes** 1000 | 1001 | Aunque la imputación en general está bien cubierta en R, es dificil encontrar funciones para la imputación de series temporales univariantes. El problema reside en que la mayoría de técnicas de imputación estandar no pueden ser aplicadas a series temporales univariantes de forma directa, ya que la mayoría de algoritmos dependen de correlaciones entre los inter-atributos, mientras que la imputación de series univariantes necesitan emplear dependencias del tiempo. 1002 | 1003 | Imputación de valores perdidos mediante la media: 1004 | 1005 | na.mean(serie temporal) 1006 | 1007 | Imputación de valores perdidos mediante médias móviles: 1008 | 1009 | na.ma(serie temporal, k) 1010 | 1011 | - k: ventana de la média móvil 1012 | 1013 | Imputación de valores perdidos mediante locf: 1014 | 1015 | na.locf(serie temporal, option) *paquete imputeTS* 1016 | 1017 | - option: locf para reemplazar con la anterior, nocb para reemplazar con la posterior 1018 | 1019 | na.locf(serie temporal, fromLast) *paquete zoo* 1020 | 1021 | - fromLast: valor a true para reemplazar con la posterior, en caso contrario con la anterior 1022 | 1023 | Imputación de valores perdidos mediante interpolación: 1024 | 1025 | na.interpolation(serie temporal, option) *paquete imputeTS* 1026 | 1027 | - option: "linear" "spline" (polinomial) o "stine" 1028 | 1029 | na.approx(serie temporal) *paquete zoo* 1030 | 1031 | na.interp(serie temporal) *paquete forescast* 1032 | 1033 | Imputación de valores perdidos mediante agregación: 1034 | 1035 | na.aggregate(serie temporal, by) 1036 | 1037 | - by: agrupación para generar la imputación 1038 | 1039 | Imputación de valores perdidos mediante filtro de Kalman en modelos en el espacio de estados o estructurales: 1040 | 1041 | na.kalman(serie temporal, model, smooth) 1042 | 1043 | - model: modelo usado al que se le aplica el filtro de Kalman. Puede ser "auto.arima" para usar una representación en el espacio de estados de los modelos ARIMA, o "StructTS" para usar un modelo estructural ajustado por máxima verosimilitud. 1044 | - smooth: "true" para usar kalmanSmooth (mejor opción para imputación) o "false" para kalmanRun. 1045 | 1046 | Imputación de valores perdidos por descomposición estacional: 1047 | 1048 | na.seadec(serie temporal, algorithm) 1049 | 1050 | - algorithm: algoritmo usado para realizar la imputación 1051 | 1052 | Imputación de valores perdidos por división estacional: 1053 | 1054 | na.seasplit(serie temporal, algorithm) 1055 | 1056 | - algorithm: algoritmo usado para realizar la imputación 1057 | 1058 | **Series temporales multivariantes** 1059 | 1060 | Imputación de valores perdidos mediante imputación múltiple: 1061 | 1062 | mice(serie temporal, m, method) 1063 | 1064 | - m: número de imputaciones múltiples 1065 | - method: método de imputación de los datos 1066 | 1067 | Imputación de valores perdidos mediante k-NN: 1068 | 1069 | kNN(serie temporal, variable, k) *paquete imputeTS* 1070 | 1071 | - variable: nombre de la columna a imputar 1072 | - k: número de vecinos cercanos usados 1073 | 1074 | 1075 | 1076 | ### Paquetes R para la imputación de datos perdidos en series Temporales: 1077 | 1078 | - zoo: https://cran.r-project.org/web/packages/zoo/zoo.pdf 1079 | - forecast: https://cran.r-project.org/web/packages/forecast/index.html 1080 | - imputeTS: https://cran.r-project.org/web/packages/imputeTS/index.html 1081 | 1082 | - mtsdi: https://cran.r-project.org/web/packages/mtsdi/mtsdi.pdf 1083 | - mice: https://cran.r-project.org/web/packages/mice/mice.pdf 1084 | - amelia: https://cran.r-project.org/web/packages/Amelia/Amelia.pdf 1085 | - mvnmle: https://cran.r-project.org/web/packages/mvnmle/mvnmle.pdf 1086 | - missForest: https://cran.r-project.org/web/packages/missForest/missForest.pdf 1087 | - yaImpute: https://cran.r-project.org/web/packages/yaImpute/yaImpute.pdf 1088 | - VIM: https://cran.r-project.org/web/packages/VIM/VIM.pdf 1089 | 1090 | 1091 | ## Análisis gráfico de series temporales 1092 | 1093 | [Ver](./analisisgrafico/analisisgrafico.md) 1094 | 1095 | ________________________________________________________________________ 1096 | 1097 | ## Ejemplos de análisis de series temporales 1098 | 1099 | - Ejemplo básico de las funciones referentes a una serie temporal: [Ver](./examples/pruebas_simples/basico_timeseries.R) 1100 | - Ejemplo básico de las funciones referentes a una serie temporal con alisados exponenciales: [Ver](./examples/pruebas_simples/basico_alisados.R) 1101 | - Ejemplo básico de las funciones referentes a una serie temporal con redes neuronales: [Ver](./examples/pruebas_simples/basico_redesneuronales.R) 1102 | - Ejemplo básico de comparación de funciones de modelado de series temporales con redes neuronales, modelos arima, alisados exponenciales y modelos aditivos: [Ver](./examples/pruebas_simples/basico_comparacion.R) 1103 | - Ejemplo básico de las funciones referentes a la imputación: [Ver](./examples/pruebas_simples/basico_imputation.R) 1104 | - Ejemplo básico de las funciones referentes a la validación cruzada: [Ver](./examples/pruebas_simples/basico_crossvalidation.R) 1105 | - Ejemplo básico de las funciones referentes a una serie temporal multivariante: [Ver](./examples/pruebas_simples/basico_multivariantes.R) 1106 | 1107 | - Ejemplo simple de análisis y modelado de series temporales sin predicción: http://www.itl.nist.gov/div898/handbook/pmc/section6/pmc62.htm 1108 | - Ejemplo simple de análisis, modelado y predicción de series temporales: http://www.itl.nist.gov/div898/handbook/pmc/section4/pmc44a.htm 1109 | - Ejemplo simple de análisis, modelado y predicción de series temporales: [Ver](./examples/analisis_simple_co2/) 1110 | 1111 | - Caso ejemplo Análisis y modelado Series temporales simple 01: [Ver](./examples/estudio_01_simple/) 1112 | - Caso ejemplo Análisis y modelado Series temporales simple 02: [Ver](./examples/estudio_02_simple/) 1113 | - Caso ejemplo Análisis y modelado Series temporales completo 03: [Ver](./examples/estudio_03_completo/) 1114 | - Caso ejemplo Análisis y modelado Series temporales completo 04: [Ver](./examples/estudio_04_completo/) 1115 | 1116 | 1117 | ________________________________________________________________________ 1118 | 1119 | # Cursos relacionados 1120 | 1121 | Series temporales: 1122 | 1123 | https://www.udacity.com/course/time-series-forecasting--ud980 1124 | 1125 | Machine learning: 1126 | 1127 | https://es.coursera.org/learn/machine-learning 1128 | 1129 | Redes neuronales: 1130 | 1131 | https://www.coursera.org/learn/neural-networks 1132 | 1133 | Deep learning: 1134 | 1135 | https://www.udacity.com/course/deep-learning--ud730 1136 | 1137 | ________________________________________________________________________ 1138 | 1139 | # Bibliografía 1140 | 1141 | - The analysis of time series. An introduction. Chris Chatfield
1142 | - Time series analysis. With apllications in R. Jonathan D. Cryer
1143 | - Time series analysis and its applications. With R examples. Robert H. Shumway
1144 | - Using R for data analysis and graphics. Introduction, code and commentary. J. H. Maindonald
1145 | - Data preprocesing in data mining. Salvador García, Julián Luengo and Francisco Herrera
1146 | 1147 | - Introduction to time series analysis http://www.itl.nist.gov/div898/handbook/pmc/section4/pmc4.htm
1148 | - Series temporales http://halweb.uc3m.es/esp/Personal/personas/jmmarin/esp/EDescrip/tema7.pdf
1149 | - Series temporales http://humanidades.cchs.csic.es/cchs/web_UAE/tutoriales/PDF/SeriesTemporales.pdf
1150 | - Introducción al análisis de series temporales http://halweb.uc3m.es/esp/Personal/personas/amalonso/esp/seriestemporales.pdf
1151 | - Introducción al análisis de series temporales https://www.ucm.es/data/cont/docs/518-2013-11-11-JAM-IAST-Libro.pdf
1152 | - Introducción a series de tiempo http://www.estadisticas.gobierno.pr/iepr/LinkClick.aspx?fileticket=4_BxecUaZmg%3D
1153 | - Modelización con datos de series temporales https://www.ucm.es/data/cont/docs/518-2013-10-25-Tema_6_EctrGrado.pdf
1154 | - Series temporales: Modelo ARIMA http://www.estadistica.net/ECONOMETRIA/SERIES-TEMPORALES/modelo-arima.pdf
1155 | - Modelo ARIMA https://www.uam.es/personal_pdi/economicas/anadelsur/pdf/Box-Jenkins.PDF
1156 | - Técnicas de suavización http://renanquispellanos.com/recursos/aporte%20intelectual/tecnicas%20prediccion/12.unidad9.pdf
1157 | - Alisado de series temporales http://www.estadistica.net/ECONOMETRIA/SERIES-TEMPORALES/alisado.pdf
1158 | - Análisis descriptivo de series temporales con R https://www.uam.es/personal_pdi/ciencias/acuevas/docencia/doct/Series-temporales-con-R.pdf
1159 | - Análisis básico de series temporales con R https://rpubs.com/joser/SeriesTemporalesBasicas
1160 | - Quick-R: Time Series http://www.statmethods.net/advstats/timeseries.html
1161 | - Series temporales en R https://dl.orangedox.com/9fzOYs2ZoimR4izLVE/7-Series%20temporales%20en%20R.pdf
1162 | - A Complete Tutorial on Time Series Modeling in R https://www.analyticsvidhya.com/blog/2015/12/complete-tutorial-time-series-modeling/
1163 | - A little book of R for time series https://media.readthedocs.org/pdf/a-little-book-of-r-for-time-series/latest/a-little-book-of-r-for-time-series.pdf
1164 | - Methods for the estimation of missing values in time series http://ro.ecu.edu.au/cgi/viewcontent.cgi?article=1063&context=theses
1165 | - Comparison of different Methods for Univariate Time Series Imputation in R: https://arxiv.org/ftp/arxiv/papers/1510/1510.03924.pdf
1166 | - A blog by Rob J Hyndman: http://robjhyndman.com/hyndsight/
1167 | - Redes de neuronas recurrentes http://eva.evannai.inf.uc3m.es/et/docencia/doctorado/cib/documentacion/NNRecurrentes.pdf
1168 | - A Beginner’s Guide to Recurrent Networks and LSTMs: https://deeplearning4j.org/lstm
1169 | - ¿Qué es y cómo funciona “Deep Learning”? https://rubenlopezg.wordpress.com/2014/05/07/que-es-y-como-funciona-deep-learning/
1170 | - Multivariate time series models: http://lipas.uwasa.fi/~bepa/Multivariate.pdf
1171 | - Analysis of multiple time series: https://www.kevinsheppard.com/images/5/56/Chapter5.pdf
1172 | - Técnicas avanzadas de predicción: https://www.uam.es/docencia/predysim/combinado5/unidad5.htm
1173 | - Johansen Test for Cointegrating Time Series Analysis in R:https://www.quantstart.com/articles/Johansen-Test-for-Cointegrating-Time-Series-Analysis-in-R
1174 | 1175 | - Análisis de series temporales https://www.youtube.com/watch?v=NDOPKRAT3-E
1176 | - Análisis clásico de series temporales https://www.youtube.com/watch?v=cQxFPPIj7gc
1177 | - Series temporales https://www.youtube.com/watch?v=NRtgyq3MjAs
1178 | - Prácticas series temporales https://www.youtube.com/watch?v=XXu2Mbg5-Lg
1179 | - Predicción con series temporales https://www.youtube.com/watch?v=XXu2Mbg5-Lg
1180 | - Lectura de correlogramas https://www.youtube.com/watch?v=zpFyhbcNWIU
1181 | - Modelo autorregresivo en R https://www.youtube.com/watch?v=a5QQp9peaZ4
1182 | - Introduction to ARIMA modeling in R https://www.youtube.com/watch?v=zFo7QixEKvg
1183 | --------------------------------------------------------------------------------