Detecting and Isolating Time Series Components Using Python: An AI Expert‘s Guide

Time series data is central to many artificial intelligence and machine learning applications – from demand forecasting to anomaly detection to predictive maintenance. But raw time series are complex, with multiple underlying patterns that can obscure the signal in the data.

To generate accurate forecasts and extract meaningful insights, data scientists need to be able to break a time series down into its constituent components – trend, seasonality, cyclical patterns, and irregular fluctuations. Doing this allows them to understand the key drivers of the series, estimate the parameters of each component, and generate simpler datasets to use as features for ML models.

In this in-depth guide, we‘ll walk through powerful techniques to programmatically detect and isolate these time series components using Python. While we‘ll focus on intuitive explanations, we‘ll also dive into the statistical theory and share real results. By the end, you‘ll have a toolbox of approaches for dissecting any time series dataset. Let‘s get started!

The Importance of Time Series Components for AI and ML

Most time series are influenced by multiple factors operating at different time scales and magnitudes. For example, retail sales data will have:

• Long-term trends based on population growth and economic development
• Annual seasonality driven by holidays and weather
• Shorter-term cycles that reflect changing consumer tastes or business conditions
• Weekly seasonality due to day-of-week effects
• Residual noise from unmodeled factors and measurement error

Here‘s a quick visual example. The chart below shows five years of monthly retail sales for a clothing store:

You can see a clear upward trend, annual seasonality with peaks around December, and plenty of month-to-month noise. If we tried to use this raw data as an input to a demand forecasting model, the model would have to identify and account for all these patterns simultaneously, which is a very complex task.

Instead, we can use techniques like time series decomposition to estimate and extract these components separately. For example, here‘s the same data decomposed into trend, seasonal, and irregular components using an additive model:

We can now analyze the trend in isolation, study the seasonal patterns, and even remove the noise to get a cleaner signal. We can also use the individual components as separate input features to a forecasting model, which allows it to learn different patterns for each component.

This is just one example – but in general, isolating time series components makes it much easier to:

• Understand what is driving changes in the series over time
• Create more informative features for machine learning models
• Improve forecast accuracy by modeling each component separately
• Detect anomalies, change points, and regime shifts
• Perform missing data imputation and interpolation
• Visualize and communicate patterns in the data

With this context in mind, let‘s dive into specific techniques for detecting and extracting time series components in Python.

Detecting Trend and Seasonality

The first step in any time series decomposition is to determine whether the series actually has a trend and/or seasonal component. While you can sometimes eyeball this from a plot, statistical tests provide a more rigorous check.

For trend, we can use the Mann-Kendall test, which checks whether there is a monotonic upward or downward trend over time. The null hypothesis is that there is no trend. Here‘s how to run it using the pymannkendall library:

from pymannkendall import original_test

result = original_test(df[‘Sales‘])
print(result)

Mann Kendall Test
-----------------
Trend: increasing
p-value: 1.5563e-7
z-score: 5.1341
Tau: 0.6667  

The very low p-value and positive z-score and Tau values suggest that there is a significant increasing trend in this data.

For seasonality, a common test is the Friedman test, which checks whether the distribution of values is the same across all seasonal periods. The null hypothesis is that there are no seasonal differences. We can run it using the statsmodels library:

from statsmodels.stats.diagnostic import friedmanchisquare

result = friedmanchisquare(*[df.loc[df.index.month==i, ‘Sales‘].values for i in range(1,13)])
print(f"Friedman test p-value: {result.pvalue:.3f}")

Friedman test p-value: 0.000

The extremely low p-value indicates strong evidence of seasonality.

We can also check for seasonality visually using a seasonal subseries plot, which shows the distribution of values for each seasonal period:

import seaborn as sns

sns.boxplot(data=df, x=df.index.month, y=‘Sales‘)

The clear differences in distribution between months, with higher values at the end of the year, confirm the presence of annual seasonality.

Decomposing a Time Series

Once we‘ve established that a time series has trend and/or seasonal components, we can formally decompose it into these parts plus an irregular component. There are two main decomposition models:

1. Additive: Assumes components sum to the original series

$y_t = Trend_t + Seasonal_t + Irregular_t$

2. Multiplicative: Assumes components multiply to the original series

$y_t = Trend_t Seasonal_t Irregular_t$

Additive models are appropriate when the magnitude of seasonal and irregular fluctuations is relatively constant over time. Multiplicative models are better when the size of fluctuations scales up with the overall level of the series.

We can use the seasonal_decompose function from statsmodels to perform classical decomposition:

from statsmodels.tsa.seasonal import seasonal_decompose

additive = seasonal_decompose(df[‘Sales‘], model=‘additive‘, period=12)
multiplicative = seasonal_decompose(df[‘Sales‘], model=‘multiplicative‘, period=12)

additive.plot()
multiplicative.plot()

The additive model shows a more linear trend and constant seasonal swings, while the multiplicative model has an exponential trend and growing seasonal fluctuations. For this data, the multiplicative model looks like a better fit.

Here are the estimated components from the multiplicative model:

Month	Trend	Seasonal Factor	Irregular Factor
1	5184	0.780	1.033
2	5222	0.753	0.967
…
11	6024	1.149	0.990
12	6063	1.513	0.989

We can see that the seasonal factors range from 0.753 in February up to 1.513 in December, indicating that December sales are over 50% higher than the annual average, while February sales are about 25% lower, after adjusting for trend.

The irregular factors are all close to 1, suggesting that the model has accounted for most of the predictable variation in the series, leaving only small random fluctuations.

Advanced Decomposition Techniques

While classical decomposition is a good starting point, it has some limitations. It can struggle with non-linear trends, shifting seasonal patterns, and outliers. Some more advanced techniques that can handle these challenges include:

• STL Decomposition: "Seasonal and Trend decomposition using LOESS", a versatile and robust method that uses local regression to estimate non-linear trends and can handle missing data
• Dynamic Harmonic Regression: Represents the time series as a combination of sinusoidal waves with time-varying coefficients, useful for modeling complex seasonal patterns
• Unobserved Components Models: Flexible state space models that represent the time series as a combination of different components like trend, seasonality, cycles, and autoregression terms

Here‘s an example of using STL decomposition in statsmodels:

import statsmodels.api as sm

stl = sm.tsa.STL(df[‘Sales‘], period=12).fit()
stl.plot()

The STL model estimates a slightly curved trend and more detailed seasonal patterns compared to the classical approach.

Frequency Domain Analysis

Another way to think about time series components is in terms of frequency – how often different patterns repeat over time. We can use frequency domain techniques like Fourier analysis and wavelet analysis to decompose a series into components at different frequencies.

The main idea is that any time series can be represented as a weighted sum of sinusoidal waves with different frequencies, amplitudes, and phases. The Fourier transform converts the series from the time domain to the frequency domain, showing the strength of different frequencies.

Here‘s an example using scipy:

from scipy.fft import fft

frequencies = fft(df[‘Sales‘])
plt.plot(np.abs(frequencies[:len(frequencies)//2]))

The large spike at frequency 1/12 confirms the presence of an annual seasonal cycle, while the smaller spikes at other frequencies suggest potential weekly seasonality, shorter-term cycles, or even a non-linear trend.

We can use the inverse Fourier transform to reconstruct the series from a subset of the frequency components – for example, just the low-frequency components to isolate trend and seasonality:

from scipy.fft import ifft

filtered = ifft(np.concatenate([frequencies[:20], [0]*(len(frequencies)-20)])).real
plt.plot(df.index, df[‘Sales‘], df.index,filtered)

This provides a smoothed version of the series with only the strongest periodic components.

Machine Learning Approaches

While statistical methods are the foundation of time series decomposition, machine learning techniques can also be useful, especially for more complex series.

For example, we can use unsupervised learning methods like clustering to group together similar seasonal periods or to identify different trend regimes. Here‘s an example using K-means clustering on the seasonal component:

from sklearn.cluster import KMeans

seasonal = additive.seasonal
kmeans = KMeans(n_clusters=3).fit(seasonal.values.reshape(-1, 1))
sns.scatterplot(x=df.index, y=seasonal, hue=kmeans.labels_)

The clusters identify three distinct seasonal patterns – the high demand in December, the low demand in January-February, and the moderate demand in the rest of the year. This could be useful for detecting and adjusting for holiday effects or other seasonal regime changes.

Neural networks can also be used for time series component extraction. For example, a convolutional neural network can learn filters that extract different frequency components from the series. An autoencoder or other dimensionality reduction technique can compress the series into a lower-dimensional representation that captures the main patterns.

Here‘s a simple example using a 1D convolutional autoencoder in Keras:

from keras.models import Sequential
from keras.layers import Conv1D, MaxPooling1D, UpSampling1D

model = Sequential()
model.add(Conv1D(16, 3, activation=‘relu‘, padding=‘same‘, input_shape=(len(df), 1)))
model.add(MaxPooling1D(2, padding=‘same‘))
model.add(Conv1D(8, 3, activation=‘relu‘, padding=‘same‘))
model.add(MaxPooling1D(2, padding=‘same‘))
model.add(Conv1D(8, 3, activation=‘relu‘, padding=‘same‘))
model.add(UpSampling1D(2))
model.add(Conv1D(16, 3, activation=‘relu‘, padding=‘same‘))
model.add(UpSampling1D(2))
model.add(Conv1D(1, 3, activation=‘sigmoid‘, padding=‘same‘))

model.compile(optimizer=‘adam‘, loss=‘mse‘)
model.fit(df[‘Sales‘].values.reshape(-1, len(df), 1), df[‘Sales‘].values.reshape(-1, len(df), 1), epochs=100)

The autoencoder learns a compressed representation of the series in the bottleneck layer, which captures the main trend and seasonal patterns. We can visualize this representation:

encoded = Sequential(model.layers[:4])
encoded_sales = encoded.predict(df[‘Sales‘].values.reshape(-1, len(df), 1))

plt.plot(encoded_sales.reshape(-1))

The autoencoded series looks like a smoothed and slightly shifted version of the original data, keeping the essential patterns while filtering out noise.

These are just a couple of examples of how machine learning can be applied to time series component analysis. Other potential techniques include matrix factorization, dictionary learning, and generative models like variational autoencoders or GANs.

Conclusion

We‘ve covered a wide range of techniques for detecting and isolating the trend, seasonal, cyclical, and irregular components of time series data using Python, from simple statistical methods to advanced machine learning models.

For most applications, a combination of visual inspection, statistical tests, and classical or STL decomposition will be sufficient to identify and extract the key components. But for more complex series with non-linear, shifting, or overlapping patterns, techniques like dynamic harmonic regression, clustering, or neural networks may provide additional insights.

No matter what approach you use, the key is to critically evaluate the assumptions behind each method, carefully inspect and validate the resulting components, and iterate between different techniques to find the most meaningful and interpretable decomposition.

Time series component analysis is a powerful tool for any data scientist working with temporal data. By understanding the different factors driving changes in a series over time, you can develop more accurate forecasts, identify significant patterns and anomalies, and extract richer features for downstream machine learning tasks. I hope this guide has given you a comprehensive overview of the key concepts and a practical toolkit of Python techniques for mastering time series decomposition. Happy analyzing!