Eric Campbell 5 min read Data Science

How to Detect Trend in a Time Series in Python

A trend represents the long-term directional movement in time series data—upward, downward, or stationary. Unlike seasonal patterns that repeat at fixed intervals, trends capture sustained changes...

Key Insights

  • Trend detection combines visual inspection (moving averages, decomposition plots) with statistical tests (Mann-Kendall, ADF) to objectively identify directional patterns in time series data
  • STL decomposition separates trend from seasonality and noise, making it superior to simple moving averages for real-world data with complex patterns
  • A multi-method approach—visual, statistical, and regression-based—provides the most reliable trend detection, as no single technique works optimally for all time series characteristics

A trend represents the long-term directional movement in time series data—upward, downward, or stationary. Unlike seasonal patterns that repeat at fixed intervals, trends capture sustained changes over time. Detecting trends matters because they inform forecasting models, reveal business performance trajectories, and help identify when a system’s behavior has fundamentally changed.

The challenge lies in distinguishing genuine trends from random fluctuations. A stock price might spike for a week, but that doesn’t constitute a trend. Conversely, gradual warming over decades represents a clear trend despite year-to-year volatility. Python provides multiple approaches to make this distinction objective and quantifiable.

Preparing Sample Data

Start with both synthetic and real-world data to understand trend detection mechanics.

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from datetime import datetime, timedelta

# Create synthetic time series with known trend
np.random.seed(42)
dates = pd.date_range(start='2020-01-01', periods=365, freq='D')

# Upward trend + seasonality + noise
trend = np.linspace(100, 150, 365)
seasonal = 10 * np.sin(np.linspace(0, 4*np.pi, 365))
noise = np.random.normal(0, 3, 365)
values = trend + seasonal + noise

ts_synthetic = pd.Series(values, index=dates)

# Load real-world data (example: Bitcoin prices)
# For this example, we'll simulate it
dates_real = pd.date_range(start='2023-01-01', periods=180, freq='D')
btc_prices = 30000 + np.cumsum(np.random.normal(50, 500, 180))
ts_real = pd.Series(btc_prices, index=dates_real)

print(f"Synthetic series: {len(ts_synthetic)} points")
print(f"Real-world series: {len(ts_real)} points")

Having controlled synthetic data lets you verify that your detection methods work correctly before applying them to messy real-world scenarios.

Visual Trend Detection

Human pattern recognition excels at spotting trends visually. Moving averages smooth out noise to reveal underlying direction.

from statsmodels.tsa.seasonal import seasonal_decompose

# Plot raw data with moving averages
fig, axes = plt.subplots(2, 1, figsize=(12, 8))

# Synthetic data with moving averages
axes[0].plot(ts_synthetic.index, ts_synthetic.values, 
             alpha=0.5, label='Original')
axes[0].plot(ts_synthetic.index, 
             ts_synthetic.rolling(window=30).mean(),
             color='red', linewidth=2, label='30-day MA')
axes[0].plot(ts_synthetic.index, 
             ts_synthetic.rolling(window=90).mean(),
             color='green', linewidth=2, label='90-day MA')
axes[0].set_title('Synthetic Time Series with Moving Averages')
axes[0].legend()
axes[0].grid(True, alpha=0.3)

# Seasonal decomposition
decomposition = seasonal_decompose(ts_synthetic, 
                                   model='additive', 
                                   period=30)
axes[1].plot(decomposition.trend.index, decomposition.trend.values,
             color='purple', linewidth=2)
axes[1].set_title('Extracted Trend Component')
axes[1].grid(True, alpha=0.3)

plt.tight_layout()
plt.savefig('trend_visual.png', dpi=150)

Moving averages provide quick insights: when shorter-period MAs consistently stay above longer-period MAs, you have an upward trend. Seasonal decomposition goes further by mathematically separating the trend from cyclical patterns.

Statistical Trend Tests

Visual inspection introduces subjectivity. Statistical tests provide objective, quantifiable evidence.

import pymannkendall as mk
from statsmodels.tsa.stattools import adfuller

def mann_kendall_test(series):
    """
    Mann-Kendall test detects monotonic trends.
    Returns: trend direction and significance
    """
    result = mk.original_test(series.dropna())
    
    return {
        'trend': result.trend,
        'p_value': result.p,
        'tau': result.Tau,
        'significant': result.p < 0.05
    }

def adf_test(series):
    """
    Augmented Dickey-Fuller test for stationarity.
    Low p-value = reject null hypothesis = stationary (no trend)
    """
    result = adfuller(series.dropna(), autolag='AIC')
    
    return {
        'adf_statistic': result[0],
        'p_value': result[1],
        'stationary': result[1] < 0.05,
        'critical_values': result[4]
    }

# Test synthetic series
mk_result = mann_kendall_test(ts_synthetic)
adf_result = adf_test(ts_synthetic)

print("Mann-Kendall Test Results:")
print(f"  Trend: {mk_result['trend']}")
print(f"  P-value: {mk_result['p_value']:.6f}")
print(f"  Significant: {mk_result['significant']}")

print("\nAugmented Dickey-Fuller Test:")
print(f"  Stationary: {adf_result['stationary']}")
print(f"  P-value: {adf_result['p_value']:.6f}")

The Mann-Kendall test excels at detecting monotonic trends without assuming linearity. The ADF test checks for stationarity—if data is stationary, there’s no trend. Use both: Mann-Kendall tells you if a trend exists; ADF confirms whether the series wanders or mean-reverts.

Decomposition Methods

STL (Seasonal and Trend decomposition using Loess) outperforms classical decomposition for irregular patterns.

from statsmodels.tsa.seasonal import STL

# STL decomposition
stl = STL(ts_synthetic, seasonal=31, trend=91)
result = stl.fit()

# Plot all components
fig, axes = plt.subplots(4, 1, figsize=(12, 10))

axes[0].plot(result.observed)
axes[0].set_ylabel('Observed')
axes[0].grid(True, alpha=0.3)

axes[1].plot(result.trend)
axes[1].set_ylabel('Trend')
axes[1].grid(True, alpha=0.3)

axes[2].plot(result.seasonal)
axes[2].set_ylabel('Seasonal')
axes[2].grid(True, alpha=0.3)

axes[3].plot(result.resid)
axes[3].set_ylabel('Residual')
axes[3].grid(True, alpha=0.3)

plt.tight_layout()

# Extract trend strength
trend_strength = 1 - (result.resid.var() / 
                      (result.resid + result.trend).var())
print(f"Trend Strength: {trend_strength:.3f}")

Compare additive versus multiplicative models: use additive when seasonal variations stay constant; use multiplicative when they grow proportionally with the trend level. For most financial and business data, multiplicative models fit better.

Regression-Based Trend Analysis

Quantify trend direction and strength with regression coefficients.

from scipy.stats import linregress

def analyze_trend_regression(series):
    """
    Fit linear regression to quantify trend.
    Returns slope, R-squared, and trend classification.
    """
    # Create numeric x-axis (days from start)
    x = np.arange(len(series))
    y = series.values
    
    # Remove NaN values
    mask = ~np.isnan(y)
    x_clean = x[mask]
    y_clean = y[mask]
    
    # Linear regression
    slope, intercept, r_value, p_value, std_err = linregress(x_clean, y_clean)
    
    # Polynomial fit (degree 2) for comparison
    poly_coeffs = np.polyfit(x_clean, y_clean, 2)
    poly_fit = np.polyval(poly_coeffs, x_clean)
    
    # Calculate residuals for polynomial
    poly_r_squared = 1 - (np.sum((y_clean - poly_fit)**2) / 
                          np.sum((y_clean - np.mean(y_clean))**2))
    
    # Classify trend
    if p_value > 0.05:
        trend_class = 'no_trend'
    elif slope > 0:
        trend_class = 'upward'
    else:
        trend_class = 'downward'
    
    return {
        'slope': slope,
        'r_squared': r_value**2,
        'p_value': p_value,
        'trend_classification': trend_class,
        'poly_r_squared': poly_r_squared,
        'daily_change': slope,
        'total_change': slope * len(series)
    }

# Analyze both series
synthetic_trend = analyze_trend_regression(ts_synthetic)
real_trend = analyze_trend_regression(ts_real)

print("Synthetic Series Trend:")
print(f"  Classification: {synthetic_trend['trend_classification']}")
print(f"  Daily change: {synthetic_trend['daily_change']:.4f}")
print(f"  R-squared: {synthetic_trend['r_squared']:.4f}")

print("\nReal Series Trend:")
print(f"  Classification: {real_trend['trend_classification']}")
print(f"  Daily change: {real_trend['daily_change']:.2f}")
print(f"  R-squared: {real_trend['r_squared']:.4f}")

R-squared values above 0.7 indicate strong linear trends. Lower values suggest either no trend or non-linear patterns requiring polynomial fits.

Practical Considerations and Best Practices

Handle missing data before trend detection—forward-fill for short gaps, interpolate for longer ones, or use methods robust to missing values like STL.

Choose detection methods based on data frequency: hourly data needs different seasonal periods than monthly data. For high-frequency data (seconds, minutes), consider detrending before applying tests to avoid spurious results from autocorrelation.

Always interpret results in domain context. A statistically significant trend might be practically meaningless if the slope is tiny relative to data variance.

def detect_trend_complete(series, name='Series'):
    """
    Complete trend detection workflow.
    Combines multiple methods for robust classification.
    """
    results = {
        'series_name': name,
        'length': len(series),
        'missing_pct': series.isna().sum() / len(series) * 100
    }
    
    # Handle missing data
    series_clean = series.fillna(method='ffill').fillna(method='bfill')
    
    # Statistical tests
    mk = mann_kendall_test(series_clean)
    adf = adf_test(series_clean)
    
    # Regression analysis
    reg = analyze_trend_regression(series_clean)
    
    # Decomposition (if enough data)
    if len(series_clean) > 60:
        stl = STL(series_clean, seasonal=13, trend=31).fit()
        trend_strength = 1 - (stl.resid.var() / 
                             (stl.resid + stl.trend).var())
    else:
        trend_strength = None
    
    # Consensus classification
    votes = []
    if mk['significant']:
        votes.append(mk['trend'])
    if not adf['stationary']:
        votes.append('increasing' if reg['slope'] > 0 else 'decreasing')
    if reg['p_value'] < 0.05:
        votes.append(reg['trend_classification'])
    
    # Majority vote
    if len(votes) >= 2:
        consensus = max(set(votes), key=votes.count)
    else:
        consensus = 'inconclusive'
    
    results.update({
        'mann_kendall': mk['trend'],
        'mk_p_value': mk['p_value'],
        'stationary': adf['stationary'],
        'regression_slope': reg['slope'],
        'r_squared': reg['r_squared'],
        'trend_strength': trend_strength,
        'consensus': consensus
    })
    
    return results

# Apply to both series
synthetic_results = detect_trend_complete(ts_synthetic, 'Synthetic')
real_results = detect_trend_complete(ts_real, 'Bitcoin')

print("\n=== COMPLETE ANALYSIS ===")
for key, value in synthetic_results.items():
    print(f"{key}: {value}")

This workflow combines visual, statistical, and regression methods into a single function that returns a consensus classification. Use it as a starting template and adjust thresholds based on your domain requirements.

The key to reliable trend detection is triangulation: don’t trust any single method. When Mann-Kendall, ADF, regression, and visual inspection all agree, you can confidently act on the detected trend. When they disagree, investigate further—your data might have structural breaks, regime changes, or non-linear patterns requiring specialized techniques.

Liked this? There's more.

Every week: one practical technique, explained simply, with code you can use immediately.