Detección de anomalías en series temporales: sistemas complejos e IA

Contenido

Detección de anomalías en series temporales.

Este tutorial aborda el problema de detectar anomalías en el preprocesamiento para el pronóstico de series de tiempo.

contexto

Durante el'análisis de datos series de tiempo, debemos buscar valores atípicos, tal como lo hacemos con los datos estáticos. Si ha trabajado con datos en cualquier capacidad, sabrá lo dolorosos que son los valores atípicos para un analista. Estos valores atípicos se denominan "anomalías" en la jerga de series temporales.

El código de Aayush Bajaj, quien creó este tutorial, está disponible: TUBERÍA

Desde una perspectiva tradicional, un valor atípico/anomalía es:

“Una observación que se desvía tanto de otras observaciones que hace sospechar que fue generada por un mecanismo diferente. »

Por lo tanto, se pueden considerar los valores atípicos como observaciones que no siguen el comportamiento esperado.

Como se muestra en la figura anterior, los valores atípicos en las series temporales pueden tener dos significados diferentes. La distinción semántica entre ellos depende principalmente de su interés como analista o del escenario particular.

Estas observaciones se han relacionado con ruido, datos erróneos o no deseados, que en sí mismos no tienen ningún interés para el analista. En estos casos, los valores atípicos deben eliminarse o corregirse para mejorar la calidad de los datos y generar un conjunto de datos más limpio que pueda ser utilizado por otros algoritmos de minería de datos. Por ejemplo, se eliminan los errores de transmisión del sensor para obtener predicciones más precisas, porque el objetivo principal es realizar predicciones.

Sin embargo, en los últimos años –especialmente en el campo de los datos de series temporales– muchos investigadores se han esforzado por detectar y analizar fenómenos inusuales pero interesantes. La detección de fraude es un buen ejemplo: el objetivo principal es detectar y analizar el valor atípico en sí. Estas observaciones a menudo se denominan anomalías.

El problema de detección de anomalías para series temporales generalmente se formula como la identificación de puntos de datos que son valores atípicos en relación con una norma o señal habitual. Eche un vistazo a algunos tipos de valores atípicos:

Punto atípico

Un punto atípico son datos que se comportan de manera inusual en una instancia temporal específica en comparación con otros valores de la serie temporal (valor atípico global) o con sus puntos vecinos (valor atípico local).

Los valores atípicos pueden ser univariados o multivariados, dependiendo de si afectan a una o más variables dependientes del tiempo, respectivamente.

La figura contiene dos valores atípicos puntuales univariados, O1 y O2, mientras que la serie temporal multivariada se compone de tres variables y tiene valores atípicos puntuales univariados (O3) y multivariados (O1 y O2).

Analizaremos los valores atípicos univariados con más detalle en la sección Detección de anomalías.

Subsecuencia de valores atípicos

Esto significa puntos consecutivos en el tiempo cuyo comportamiento conjunto es inusual, aunque cada observación tomada individualmente no es necesariamente un valor atípico. Los valores atípicos de subsecuencia también pueden ser globales o locales y pueden afectar a una (valor atípico de subsecuencia univariada) o varias (valores atípicos de subsecuencia multivariada) variables dependientes del tiempo.

Detección de descomposición

STL significa procedimiento de descomposición de tendencias estacionales basado en LOESS. Esta técnica le brinda la posibilidad de dividir la señal de su serie temporal en tres partes: estacional, de tendencia y residual.

Funciona para series temporales estacionales, que también es el tipo de datos de series temporales más popular. Para generar un gráfico de descomposición STL, simplemente utilizamos los siempre sorprendentes modelos estadísticos para que hagan el trabajo pesado por nosotros.

plt.rc('cifra',tamaño de figura=(12,8)) plt.rc('hacen',tamaño=15) resultado = estacional_decompose(lim_catfish_sales,model='aditivo') figura = resultado.plot()

Si analizamos la desviación de los residuos e introducimos un umbral para ella, obtendremos un algoritmo Detección de anomalías. Para implementar esto, solo necesitamos los datos sobre los residuos de la descomposición.

plt.rc('cifra',tamaño de figura=(12,6)) plt.rc('hacen',tamaño=15) fig, ax = plt.subplots() x = result.resid.index y = result.resid.values ax.plot_date(x, y, color='negro',estilo de línea='--') hacha.anotar('Anomalía', (mdates.date2num(x[35]), y[35]), xytext=(30, 20), coordenadas de texto ='puntos de compensación', color ='rojo',arrowprops=dict(colorcara='rojo',estilo de flecha='elegante')) fig.autofmt_xdate() plt.show()

Es simple, robusto, puede manejar muchas situaciones diferentes y todas las anomalías siempre pueden interpretarse de manera intuitiva.

La mayor desventaja de esta técnica son las rígidas opciones de ajuste. Aparte del umbral y quizás del intervalo de confianza, no hay mucho que puedas hacer al respecto. Por ejemplo, realiza un seguimiento de los usuarios de su sitio web que estaba cerrado al público y luego se abrió repentinamente. En este caso, debe realizar un seguimiento por separado de las anomalías que se produzcan antes y después de los períodos de publicación.

Detección por árboles de regresión

Podemos utilizar el poder y la solidez de los árboles de decisión para identificar valores atípicos/anomalías en datos de series temporales.

La idea principal, que difiere de otros métodos populares de detección de valores atípicos, es que Isolation Forest identifica explícitamente anomalías en lugar de perfilar puntos de datos normales. Isolation Forest, como cualquier método de conjunto de árboles, se basa en árboles de decisión.

En otras palabras, Isolation Forest detecta anomalías basándose únicamente en el hecho de que las anomalías son pocos y diferentes puntos de datos. El aislamiento de anomalías se implementa sin recurrir a mediciones de distancia o densidad.

Al aplicar un modelo IsolationForest, configuramos contaminación = outliers_fraction, que le dice al modelo qué proporción de valores atípicos están presentes en los datos. Esta es una métrica de prueba/error. Fit and Predict (Data) realiza una detección de valores atípicos en los datos y devuelve 1 para normal y -1 para anomalía. Finalmente, visualizamos anomalías con la vista Serie temporal.

Hagámoslo paso a paso. Primero, visualice los datos de la serie temporal:

plt.rc('cifra',tamaño de figura=(12,6)) plt.rc('hacen',tamaño=15) bagre_sales.plot()

A continuación, debemos establecer algunos parámetros como la fracción de valores atípicos y entrenar nuestro modelo IsolationForest. Podemos utilizar el muy útil scikit-learn para implementar el algoritmo Isolation Forest (consulte git en la parte superior de la página).

fracción_atípica = flotante(.01) escalador = StandardScaler() np_scaled = escalador.fit_transform(catfish_sales.values.reshape(-1, 1)) datos = pd.DataFrame(np_scaled)
Bosque de aislamiento de trenes #
modelo = BosqueAislamiento(contaminación=fracción_atípica) modelo.fit(datos)

ventas_gagre['anomalía'] = modelo.predecir (datos)
Visualización #
higo, hacha = plt.subplots(tamaño de higo=(10,6)) a = ventas_gato.loc[ventas_gato['anomalía'] == -1, ['Total']] #anomalía
ax.plot(catfish_sales.index, catfish_sales['Total'], color='negro', etiqueta = 'Normal') ax.scatter(a.índice,a['Total'], color='rojo', etiqueta = 'Anomalía') plt.legend() plt.show();

Como puede ver, el algoritmo hizo un muy buen trabajo identificando nuestras anomalías implantadas, pero inicialmente también etiquetó algunos puntos como "valores atípicos". Esto se debe a dos razones:

Inicialmente, el algoritmo es lo suficientemente ingenuo como para poder comprender qué constituye una anomalía. Cuantos más datos obtiene, más variación podrá ver y se ajustará.
Si ve muchos verdaderos negativos, significa que su configuración de contaminación es demasiado alta. Por el contrario, si no ve los puntos rojos donde deberían estar, la configuración de contaminación está demasiado baja.

La mayor ventaja de esta técnica es que puedes introducir tantas variables o características aleatorias como quieras para crear modelos más sofisticados.

La debilidad es que un número cada vez mayor de funciones pueden comenzar a afectar el rendimiento de su computadora con bastante rapidez. En este caso, debes seleccionar las funciones con cuidado.

Detección por predicción

La detección de anomalías mediante pronóstico se basa en un enfoque en el que múltiples puntos en el pasado generan un pronóstico del siguiente punto con la adición de una variable aleatoria, que generalmente es ruido blanco.

Como puedes imaginar, los puntos pronosticados en el futuro generarán nuevos puntos y así sucesivamente. Su efecto obvio sobre el horizonte de pronóstico es que la señal se vuelve más suave.

La parte difícil de utilizar este método es que es necesario seleccionar el número de diferencias, el número de autorregresiones y los coeficientes de error de pronóstico. Cada vez que trabaja con una nueva señal, necesita crear un nuevo modelo de pronóstico.

Otro obstáculo es que su señal debe permanecer estacionaria después de la diferenciación. En términos simples, esto significa que su señal no debería depender del tiempo, lo cual es una limitación importante.

Podemos utilizar diferentes métodos de previsión como medias móviles, enfoque autorregresivo y ARIMA con sus diferentes variantes. El procedimiento de detección de anomalías con ARIMA es el siguiente:

Prediga el nuevo punto a partir de los datos anteriores y encuentre la diferencia de magnitud con los datos de entrenamiento.
Elija un umbral e identifique anomalías en función de este umbral de diferencia.

Para probar esta técnica, usaremos un módulo de series de tiempo popular llamado fbprophet. Este módulo aborda específicamente la estacionariedad y la estacionalidad, y se puede ajustar con ciertos hiperparámetros.

de fbprofeta importar Profeta

definitivamente fit_predict_modelo(marco de datos, ancho_intervalo = 0.99, rango_punto_cambio = 0.8):
   m = Profeta(daily_seasonality = Falso, estacionalidad_anual = Falso, estacionalidad_semanal = Falso, modo_estacionalidad = 'aditivo', ancho_intervalo = ancho_intervalo, rango_punto_cambio = rango_punto_cambio) m = m.fit(marco de datos) pronóstico = m.predict(marco de datos) pronóstico['hecho'] = marco de datos['tú'].reset_index(soltar = Verdadero)
   regreso pronóstico pred = fit_predict_model(t)

Ahora definamos la función de pronóstico. Una cosa importante a tener en cuenta aquí es que fbprophet agregará métricas adicionales como características para identificar mejor las anomalías. Por ejemplo, la variable de serie temporal prevista (por el modelo), los límites superior e inferior de la variable de serie temporal objetivo y la medida de tendencia.

Ahora necesitamos enviar la variable pred a otra función, que detectará anomalías en función de un umbral de límite inferior y superior en la variable de serie temporal.

definitivamente detectar_anomalías(pronóstico):
   pronosticado = pronóstico[['ds','tendencia', 'y eso', 'yhat_lower', 'yhat_upper', 'hecho']].copiar() predicho['anomalía'] = 0
   pronosticado.loc[pronosticado['hecho'] > pronosticado['yhat_upper'], 'anomalía'] = 1
   pronosticado.loc[pronosticado['hecho'] <pronosticado['yhat_lower'], 'anomalía'] = -1
1TP5Importancias de las anomalías
   pronóstico['importancia'] = 0
   pronosticado.loc[pronosticado['anomalía'] ==1, 'importancia'] = (pronóstico['hecho'] - predicho['yhat_upper'])/pronóstico['hecho'] pronosticado.loc[pronosticado['anomalía'] ==-1, 'importancia'] = (pronóstico['yhat_lower'] - predicho['hecho'])/pronóstico['hecho']

   regreso pred previsto = detectar_anomalías (pred)

Este algoritmo maneja bien diferentes parámetros de estacionalidad, como mensuales o anuales, y admite de forma nativa todas las métricas de series temporales.

Dado que esta técnica se basa en predicciones, tendrá dificultades en escenarios de datos limitados. La calidad de la predicción con datos limitados será menor, al igual que la precisión de la detección de anomalías.

Detección de agrupamiento

El enfoque es bastante sencillo. Las instancias de datos que no forman parte de clústeres definidos pueden marcarse potencialmente como anomalías.

Por motivos de visualización, utilizaremos un conjunto de datos diferente que corresponde a una serie de tiempo multivariada con una o más variables temporales. El conjunto de datos será un subconjunto del que se encuentra aquí (las columnas/características son las mismas).

Descripción del conjunto de datos: Los datos contienen información sobre compras y compras, así como información sobre la competitividad de precios.

Ahora, para tratar con k-medias primero necesitamos conocer el número de grupos que vamos a tratar. El método del codo funciona con bastante eficacia para esto.

El método del codo es una gráfica del número de conglomerados versus la varianza explicada/objetiva/puntuación.

Para implementar esto, usaremos la implementación K-means de scikit-learn.

datos = df[['Precio (dólares americanos', 'srch_booking_window', 'srch_saturday_night_bool']] n_cluster = rango(1, 20) kmeans = [KMeans(n_clusters=i).fit(datos) por I en n_cluster] puntuaciones = [kmeans[i].score(datos) por I en rango(len(kmeans))] fig, ax = plt.subplots(figsize=(10,6)) ax.plot(n_cluster, puntuaciones) plt.xlabel('Número de grupos') plt.ylabel('Puntaje') plt.título('Curva del codo') plt.mostrar();

En la curva en ángulo anterior, vemos que el gráfico se estabiliza después de 10 grupos, lo que implica que agregar grupos adicionales no explica mucho más de la varianza en nuestra variable relevante; en este caso, precio_usd.

Establecemos n_clusters = 10 y, al generar la salida de k-medias, usamos los datos para trazar los grupos 3D.

Ahora necesitamos saber la cantidad de componentes (funcionalidades) que debemos conservar.

datos = df[['Precio (dólares americanos', 'srch_booking_window', 'srch_saturday_night_bool']] X = datos.valores X_std = StandardScaler().fit_transform(X)
#Cálculo de vectores propios y valores propios de la matriz de covarianza
media_vec = np.media(X_std, eje=0) cov_mat = np.cov(X_std.T) eig_vals, eig_vecs = np.linalg.eig(cov_mat)
# Crear una lista de tuplas (valor propio, vector propio)
eig_pairs = [ (np.abs(eig_vals[i]),eig_vecs[:,i]) por I en rango(len(eig_vals))] eig_pairs.sort(clave = lambda x:x[0], reverso = Verdadero)
# Cálculo de la varianza explicada a partir de los valores propios
tot = suma(eig_vals) var_exp = [(i/tot)*100 por I en ordenado(eig_vals, reverso=Verdadero)] # Varianza explicada individual
cum_var_exp = np.cumsum(var_exp) # Varianza explicada acumulada
plt.figure(tamaño de figura=(10, 5)) plt.bar(rango(len(var_exp)), var_exp, alfa=0.3, alinear ='centro', etiqueta ='varianza individual explicada', color = 'tú') plt.step(rango(len(cum_var_exp)), cum_var_exp, donde='medio',etiqueta='varianza explicada acumulada') plt.ylabel('Relación de varianza explicada') plt.xlabel('Componentes principales') plt.leyenda(loc='mejor') plt.mostrar();

Vemos que el primer componente explica casi 50 % de la varianza. El segundo componente explica más de 30 %. Sin embargo, tenga en cuenta que casi ninguno de los componentes es realmente insignificante. Los primeros 2 componentes contienen más de 80 información %. Por tanto definiremos n_components=2.

La suposición detrás de la detección de anomalías basada en agrupamiento es que si agrupamos los datos, los datos normales pertenecerán a grupos, mientras que las anomalías no pertenecerán a ningún grupo o pertenecerán a grupos pequeños.

Utilizamos los siguientes pasos para encontrar y visualizar anomalías:

Calcula la distancia entre cada punto y su centro de gravedad más cercano. Las distancias mayores se consideran anomalías.
Usamos outliers_fraction para proporcionar información al algoritmo sobre la proporción de valores atípicos presentes en nuestro conjunto de datos, similar al algoritmo IsolationForest. Este es en gran medida un hiperparámetro que requiere que se configure correctamente una búsqueda de acierto/intento o de cuadrícula; como número inicial, estimemos, fracción_de_valores atípicos=0,1
Calcule el número_de_valores_atípicos utilizando la fracción_de_valores atípicos.
Establezca el umbral como la distancia mínima desde estos valores atípicos.
El resultado de la anomalía anomaly1 contiene el método anterior Cluster (0: normal, 1: anomalía).
Visualice anomalías con la vista de clúster.
Visualice anomalías con la vista Serie temporal.

# retorno Serie de distancia entre cada punto y su distancia con el centroide más cercano
definitivamente obtenerDistanciaPorPunto(modelo de datos):
   distancia = pd.Series()
   por I en ordenado(0,len(datos)): Xa = np.array(data.loc[i]) Xb = model.cluster_centers_[model.labels_[i]-1] distancia.en[i]=np.linalg.norm(Xa-Xb)
   regreso distancia valores_atípicos_fracción = 0.1
# obtiene la distancia entre cada punto y su centroide más cercano. Las distancias más grandes se consideran anomalías.
distancia = getDistanceByPoint(datos, kmeans[9]) número_de_valores atípicos = int(fracción_de_valores_atípicos*len(distancia)) umbral = distancia.nlargest(número_de_valores_atípicos).min()
# anomalía1 contiene el resultado de la anomalía del método anterior Clúster (0:normal, 1:anomalía)
df['anomalía1'] = (distancia >= umbral).astype(int) fig, ax = plt.subplots(figsize=(10,6)) colores = {0:'azul', 1:'rojo'} ax.scatter(df['característica_principal1'], df['principal_feature2'], c=df["anomalía1"].aplicar(lambda x: colores[x])) plt.xlabel('característica principal1') plt.ylabel('característica principal2') plt.mostrar();

Ahora, para ver las anomalías en comparación con las características del mundo real, procesamos el marco de datos que creamos en el paso anterior.

df = df.sort_values('fecha y hora') higo, hacha = plt.subplots(tamaño de higo=(10,6)) a = df.loc[df['anomalía1'] == 1, ['fecha y hora', 'Precio (dólares americanos']] #anomalía
ax.plot(pd.to_datetime(df['fecha y hora']), df['Precio (dólares americanos'], color='k',etiqueta='Normal') ax.scatter(pd.to_datetime(a['fecha y hora']),tiene['Precio (dólares americanos'], color='rojo', etiqueta ='Anomalía') ax.xaxis_date() plt.xlabel('Fecha y hora') plt.ylabel('precio en USD') plt.legend() fig.autofmt_xdate() plt.show()

Este método es capaz de encapsular los picos bastante bien, con algunos contratiempos, por supuesto. Parte del problema puede deberse a que outlier_fraction no ha jugado con muchos valores.

La mayor ventaja de esta técnica es similar a otras técnicas no supervisadas, es decir, puedes introducir tantas variables o características aleatorias como quieras para crear modelos más sofisticados.

La debilidad es que un número cada vez mayor de funciones pueden comenzar a afectar el rendimiento de su computadora con bastante rapidez. Además de eso, hay más hiperparámetros que ajustar y corregir, por lo que siempre existe el riesgo de una gran variación en el rendimiento del modelo.

Detección de codificador automático

Los codificadores automáticos son una técnica no supervisada que recrea datos de entrada mientras extrae sus características en diferentes dimensiones. En otras palabras, si utilizamos la representación latente de los datos de los codificadores automáticos, esto corresponde a la reducción de dimensionalidad. Muchas técnicas basadas en distancias (por ejemplo, KNN) sufren la maldición de la dimensionalidad al calcular las distancias de cada punto de datos en el espacio de características completo. Se debe reducir la alta dimensionalidad.

Existen muchas herramientas útiles, como el análisis de componentes principales (PCA), para detectar valores atípicos. ¿Por qué necesitamos codificadores automáticos? La razón es que PCA utiliza elálgebra lineal para transformar. Por el contrario, las técnicas de codificador automático pueden realizar transformaciones no lineales gracias a su función de activación no lineal y sus múltiples capas.

Es más eficiente entrenar varias capas con un codificador automático que entrenar una transformación enorme con PCA. Las técnicas de codificador automático muestran así sus ventajas cuando los problemas de datos son complejos y de naturaleza no lineal.

Podemos implementar codificadores automáticos con marcos populares como TensorFlow o Pytorch, pero, en aras de la simplicidad, usaremos un módulo de Python llamado PyOD, que construye codificadores automáticos internamente utilizando algunas entradas del usuario.

Para la parte de datos, usemos la función de utilidad generate_data() de PyOD para generar 25 variables, 500 observaciones y diez por ciento de valores atípicos.

importar entumecido as notario público.
importar panda as p.d.
de pyod.models.auto_encoder importar Codificador automático
de pyod.utils.data importar generar_datos contaminacion = 0.1  # porcentaje de valores atípicos
n_tren = 500  # número de puntos de entrenamiento
n_prueba = 500  # número de puntos de prueba
n_características = 25 # Número de funciones
tren_x, tren_y,1234) X_train = pd.DataFrame(X_train) X_test = pd.DataFrame(X_prueba)

de sklearn.preprocesamiento importar StandardScaler X_train = StandardScaler().fit_transform(X_train)

de sklearn.descomposición importar PCA pca = PCA(2) x_pca = pca.fit_transform(X_train) x_pca = pd.DataFrame(x_pca) x_pca.columns=['PC1','PC2'] cdict = {0: 'rojo', 1: 'azul'}
Parcela #
importar matplotlib.pyplot as plt plt.scatter(X_train[0], X_tren[1], c=y_tren, alfa=1) plt.título('Gráfico de dispersión') plt.xlabel('X') plt.ylabel('tú') plt.mostrar()

Ahora sintonicemos un codificador automático. [25, 2, 2, 25]. La capa de entrada y la capa de salida incluyen cada una 25 neuronas. Hay dos capas ocultas, cada una con dos neuronas.

clf = AutoEncoder(neuronas_ocultas =[25, 2, 2, 25]) clf.fit(X_tren)

Apliquemos el modelo entrenado por Clf para predecir la puntuación de anomalía para cada observación en los datos de prueba. ¿Cómo se define un valor atípico? Un valor atípico es un punto alejado de otros puntos, por lo que la puntuación del valor atípico se define por la distancia. La función PyOD .decision_function() calcula la distancia, o puntuación de anomalía, para cada punto de datos.

# Obtenga las puntuaciones atípicas de los datos del tren
y_train_scores = clf.decision_scores_
# Predice las puntuaciones de anomalía
y_test_scores = clf.decision_function(X_test)  Puntuaciones atípicas de #
y_test_scores = pd.Series(y_test_scores)
# ¡Tracéalo!
importar matplotlib.pyplot as plt plt.hist(y_test_scores, bins='auto') plt.título(“Histograma para puntuaciones de anomalías del modelo Clf1”) plt.mostrar()

Si utilizamos un histograma para contar la frecuencia según la puntuación de anomalía, veremos que las puntuaciones altas corresponden a una frecuencia baja: evidencia de valores atípicos. Elegimos 4,0 como punto de corte y aquellos >=4,0 como valores atípicos.

Asignemos observaciones con puntuaciones de anomalía inferiores a 4,0 al grupo 0 y al grupo 1 para aquellas superiores a 4,0. Calculemos también las estadísticas resumidas por clúster usando .groupby() . Este modelo identificó 50 valores atípicos (no se muestran).

df_test = X_test.copia() df_test['puntaje'] = y_test_scores df_test['grupo'] = np.donde(df_test['puntaje']4, 0, 1) prueba_df['grupo'].value_counts() df_test.groupby('grupo').significar()

El siguiente resultado muestra los valores promedio de las variables en cada cluster. Los valores del grupo “1” (el grupo anormal) son muy diferentes de los del grupo “0” (el grupo normal). Los valores de “puntuación” muestran la distancia promedio de estas observaciones a otras. Una “puntuación” alta significa que la observación está muy lejos de la norma.

De esta manera podemos distinguir y etiquetar datos típicos y anomalías perfectamente.

Los codificadores automáticos pueden manejar fácilmente grandes cantidades de datos. En cuanto a su comportamiento de no linealidad, puede encontrar patrones complejos en conjuntos de datos de alta dimensión.

Dado que se trata de una estrategia basada en el aprendizaje profundo, será particularmente difícil si hay menos datos. Los costes informáticos se dispararán si aumenta la profundidad de la red y al procesar big data.

Manejar anomalías con suavizado

Los métodos estadísticos le permiten ajustar el valor de su valor atípico para que coincida con la distribución original. Veamos uno de los métodos utilizados para suavizar anomalías.

La idea es mitigar la anomalía utilizando datos del DateTime anterior. Por ejemplo, para compensar un consumo repentino de electricidad debido a un evento en tu hogar, puedes tomar el promedio del consumo durante el mismo mes de años anteriores.

Implementemos lo mismo para obtener una imagen clara. Usaremos los mismos datos de ventas de bagre que usamos anteriormente. Podemos ajustar con la media usando el siguiente script.

datos_ajustados = lim_catfish_sales.copy() datos_ajustados.loc[curr_anomaly] = diciembre_data[(diciembre_data.index != curr_anomaly) & (diciembre_data.index < test_data.index[0])].significar()

plt.figure(tamaño de figura=(10,4)) plt.plot(lim_catfish_sales, color='ladrillo refractario', alfa=0.4) plt.plot(datos_ajustados) plt.title('Ventas de bagre en miles de libras', tamaño de fuente =20) plt.ylabel('Sucio', tamaño de fuente =16)
por año en rango(fecha_inicial.año,fecha_final.año): plt.axvline(pd.to_datetime(str(año)+'-01-01'), color='k', estilo de línea ='--', alfa=0.2) plt.axvline(curr_anomaly, color='k', alfa=0.7)

De esta forma, podrás proceder a aplicar pronósticos o análisis sin preocuparte demasiado por la asimetría de tus resultados.

Existen muchos métodos para manejar datos que no son series, pero desafortunadamente no se pueden usar directamente en Timeseries debido a la diferencia en las estructuras subyacentes. Los métodos de procesamiento que no son de series temporales implican muchos métodos basados en la distribución que no se pueden traducir simplemente a datos de series temporales.

Borrar anomalías

La última opción si ninguna de las dos soluciones anteriores genera debate en su solución es eliminar las anomalías. Esto no se recomienda (porque básicamente se está deshaciendo de información potencialmente valiosa) a menos que sea absolutamente necesario y no perjudique análisis futuros.

Puede utilizar la funcionalidad .drop() en pandas después de la identificación. Hará el trabajo pesado por usted.