Guide to Analyzing Time Series Data: Plotting and Stationarity Checks

Analyzing time series data for trends and forecasting starts with visualization and ensuring the data is stationary (i.e., constant mean, variance, and autocovariance over time). Non-stationary data can lead to unreliable forecasts. I'll guide you step-by-step using Python with libraries like Pandas, Matplotlib, and Statsmodels. Assume you have a dataset (e.g., a CSV with a date column and a value column). If not, I'll suggest sample data.

Step 1: Load and Prepare Your Data

• Load data: Use Pandas to read your time series (e.g., from CSV, Excel, or API).


• Set index: Ensure the date/time column is the index and parsed as datetime.


• Handle missing values: Interpolate or drop NaNs if needed.

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from statsmodels.tsa.stattools import adfuller
from statsmodels.graphics.tsaplots import plot_acf, plot_pacf
# Sample data (replace with pd.read_csv('your_file.csv', parse_dates=['date'], index_col='date'))
dates = pd.date_range(start='2020-01-01', periods=100, freq='D')
data = pd.Series(np.cumsum(np.random.randn(100)) + 10, index=dates)  # Non-stationary example (random walk with trend)
df = pd.DataFrame({'value': data})
# Basic prep
df = df.asfreq('D')  # Set frequency if needed
df = df.fillna(method='ffill')  # Handle missing values
print(df.head())

This creates a simple non-stationary series (cumulative sum mimics trends like stock prices).

Step 2: Plot the Time Series

• Why? Visual inspection reveals trends (upward/downward drift), seasonality (cycles), or irregularities.


• Plot the raw series, rolling statistics (e.g., mean/std for variance changes), and decomposition if seasonal.

# Basic plot
plt.figure(figsize=(12, 6))
plt.plot(df.index, df['value'], label='Time Series')
plt.title('Time Series Plot')
plt.xlabel('Date')
plt.ylabel('Value')
plt.legend()
plt.show()
# Rolling statistics for trend/seasonality check (window=12 for monthly data; adjust as needed)
rolling_mean = df['value'].rolling(window=12).mean()
rolling_std = df['value'].rolling(window=12).std()
plt.figure(figsize=(12, 6))
plt.plot(df.index, df['value'], label='Original')
plt.plot(df.index, rolling_mean, label='Rolling Mean')
plt.plot(df.index, rolling_std, label='Rolling Std')
plt.title('Time Series with Rolling Statistics')
plt.xlabel('Date')
plt.ylabel('Value')
plt.legend()
plt.show()
# Optional: Seasonal decomposition (requires statsmodels)
from statsmodels.tsa.seasonal import seasonal_decompose
decomp = seasonal_decompose(df['value'], model='additive', period=12)  # Adjust period for your frequency
decomp.plot()
plt.show()

What to Look For:

• Trend: Steady increase/decrease? (E.g., upward slope indicates positive trend.)


• Seasonality: Repeating patterns? (E.g., peaks every 12 months.)


• Variance: Constant spread, or increasing/decreasing?

Step 3: Check for Stationarity

• Why? Many forecasting models (e.g., ARIMA) assume stationarity. If non-stationary, apply transformations like differencing or log-scaling.


• Methods:


• Visual: From plots (e.g., if rolling mean is flat, it's likely stationary).


• Statistical Test: Augmented Dickey-Fuller (ADF) test. Null hypothesis: Non-stationary (p-value > 0.05 indicates non-stationarity).


• Autocorrelation Function (ACF): High lags suggest non-stationarity.

# ADF Test
def check_stationarity(ts, title='Original Series'):
    result = adfuller(ts.dropna())
    print(f'{title} ADF Test:')
    print(f'ADF Statistic: {result[0]:.4f}')
    print(f'p-value: {result[1]:.4f}')
    print(f'Critical Values: {result[4]}')
    print('Stationary' if result[1] < 0.05 else 'Non-stationary')
    print()
# Test original series
check_stationarity(df['value'], 'Original')
# If non-stationary, transform (e.g., first differencing)
df['diff'] = df['value'].diff().dropna()
check_stationarity(df['diff'], 'Differenced Series')
# ACF/PACF plots for autocorrelation
fig, axes = plt.subplots(2, 1, figsize=(12, 8))
plot_acf(df['value'], ax=axes[0], lags=20)
plot_acf(df['diff'], ax=axes[1], lags=20)
plt.show()

Interpreting Results:

• ADF p-value < 0.05: Reject null → Stationary (proceed to modeling).


• p-value ≥ 0.05: Non-stationary → Difference the series (e.g., df.diff()) or take logs (np.log(df)), then re-test.


• ACF: Slow decay (high correlation at many lags) → Non-stationary.

Next Steps for Trends and Forecasting

• If stationary: Fit models like ARIMA (from statsmodels.tsa.arima.model import ARIMA).


• Trend Removal: Use df['trendremoved'] = df['value'] - rollingmean or STL decomposition.


• Forecasting: Once stationary, use Prophet, ARIMA, or LSTM for predictions.


• Tools: Install via pip install pandas matplotlib statsmodels.


• Tips: For large datasets, downsample if needed. Always validate on hold-out data.