Summary  
This chapter covers how to compute a rolling mean to reveal the underlying trend in a series, detect anomalies by thresholding deviations from that trend, and highlight both on a plot.  

General domain of usage  
Time series analysis

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

# Generate example time series data
np.random.seed(0)
dates = pd.date_range(start="2022-01-01", periods=60, freq="D")
values = np.cumsum(np.random.normal(loc=0.5, scale=2, size=60))
series = pd.Series(values, index=dates)

# Calculate a trend line using rolling mean
trend = series.rolling(window=7, center=True).mean()

# Identify anomalies: points that deviate from the trend by more than 1.5 standard deviations
deviation = np.abs(series - trend)
threshold = 1.5 * deviation.std()
anomalies = series[deviation > threshold]

# Plot the time series, trend line, and highlight anomalies
plt.figure(figsize=(12, 6))
plt.plot(series.index, series.values, label="Original Series")
plt.plot(trend.index, trend.values, color="orange", linewidth=2, label="Trend (7-day MA)")
plt.scatter(anomalies.index, anomalies.values, color="red", label="Anomalies", zorder=5)
plt.title("Time Series with Trend Line and Anomalies Highlighted")
plt.xlabel("Date")
plt.ylabel("Value")
plt.legend()
plt.tight_layout()
plt.show()

When analyzing time series data, visual techniques are crucial for understanding the underlying structure and for detecting unusual patterns. One common approach to reveal the overall direction of a time series is to add a **trend line**. A trend line, such as a moving average, smooths out short-term fluctuations and highlights longer-term patterns or shifts in the data. This can help you quickly assess whether values are generally increasing, decreasing, or remaining stable over time.

Detecting **anomalies**—points that deviate significantly from the expected pattern—is another important aspect of time series analysis. Anomalies may indicate errors, rare events, or important changes in the process being measured. Visually, anomalies can be highlighted on a plot by marking points that differ from the trend by more than a certain threshold, such as a multiple of the standard deviation. This makes it easier to spot outliers and investigate their causes.

By combining trend lines and anomaly highlighting in your visualizations, you gain deeper insights into the behavior of your time series data, making it easier to identify patterns, forecast future movements, and detect unexpected events.

import unittest
import ast
import re   
import importlib
import sys
import matplotlib
matplotlib.use("Agg") # Prevent plots from popping up during tests
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd

class TestTask(unittest.TestCase):
    def setUp(self):
        # Prepare a simple, clean time series for testing
        self.dates = pd.date_range(start="2023-01-01", periods=10, freq="D")
        self.values = np.arange(10, dtype=float)
        self.series = pd.Series(self.values, index=self.dates)
        
        # Disable plt.show() completely during tests so it doesn't block
        def fake_show(*args, **kwargs):
            pass
        self._original_show = plt.show
        plt.show = fake_show
        
        # Load user module
        self.module = importlib.import_module("user_code")
        importlib.reload(self.module)

    def tearDown(self):
        plt.show = self._original_show
        plt.close('all')

    def test_1_function_exists(self):
        func = getattr(self.module, 'plot_series_with_trend', None)
        _dynamic_test(
            self, 
            func is not None, 
            "Function plot_series_with_trend must be defined.", 
            "Function plot_series_with_trend is missing."
        )

    def test_2_lines_plotted(self):
        plt.clf()
        plt.close('all')
        
        func = getattr(self.module, 'plot_series_with_trend', None)
        if not func:
             _dynamic_test(self, False, "Original series and trend line are plotted.", "Function is missing.")
             return
             
        try:
            func(self.series)
            ax = plt.gca()
            lines = ax.get_lines()
            
            # We expect exactly 2 lines (original and trend)
            has_two_lines = len(lines) >= 2
            
            _dynamic_test(
                self,
                has_two_lines,
                "Original series and trend line are plotted.",
                f"Expected 2 lines on the plot, found {len(lines)}."
            )
        except Exception as e:
            _dynamic_test(self, False, "Original series and trend line are plotted.", f"Function raised an error: {e}")

    def test_3_labels_and_title(self):
        plt.clf()
        plt.close('all')
        
        func = getattr(self.module, 'plot_series_with_trend', None)
        try:
            func(self.series)
            ax = plt.gca()
            
            has_xlabel = bool(ax.get_xlabel())
            has_ylabel = bool(ax.get_ylabel())
            has_title = bool(ax.get_title())
            
            condition = has_xlabel and has_ylabel and has_title
            _dynamic_test(
                self,
                condition,
                "Axis labels and title are set on the plot.",
                f"Missing elements. xlabel: {has_xlabel}, ylabel: {has_ylabel}, title: {has_title}"
            )
        except Exception as e:
            _dynamic_test(self, False, "Axis labels and title are set on the plot.", f"Function raised an error: {e}")

    def test_4_legend_added(self):
        plt.clf()
        plt.close('all')
        
        func = getattr(self.module, 'plot_series_with_trend', None)
        try:
            func(self.series)
            ax = plt.gca()
            
            # ax.get_legend() returns None if no legend is present
            has_legend = ax.get_legend() is not None
            
            _dynamic_test(
                self,
                has_legend,
                "Legend is added to the plot.",
                "Legend is missing from the plot."
            )
        except Exception as e:
            _dynamic_test(self, False, "Legend is added to the plot.", f"Function raised an error: {e}")


def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)

def normalize_text(text):
    text = text.lower()
    text = re.sub(r"\s{2,}", " ", text)
    text = re.sub(r"\s*([,:?])\s*", r"\1 ", text)
    return text.strip()

def change_var(code: str, var_name: str, value: str) -> str:
    tree = ast.parse(code)
    lines = code.splitlines()
    changed = False
    
    assign_nodes = [
        (i, node)
        for i, node in enumerate(tree.body)
        if isinstance(node, ast.Assign)
        and any(isinstance(target, ast.Name) and target.id == var_name for target in node.targets)
    ]

    if not assign_nodes:
        return code

    for i, node in reversed(assign_nodes):
        start_line = node.lineno - 1
        line = lines[start_line]
        indent = ' ' * (len(line) - len(line.lstrip()))
        lines[start_line] = f"{indent}{var_name} = {value}"
        next_line = len(lines)
        for next_node in tree.body[i+1:]:
            if hasattr(next_node, 'lineno'):
                next_line = next_node.lineno - 1
                break
        if next_line > start_line + 1:
            lines[start_line+1:next_line] = []
        changed = True

    return '\\n'.join(lines) if changed else code

if __name__ == "__main__":
    unittest.main()

test_main.py

Establish foundational skills by manipulating datetime objects, indexing temporal data, utilizing interpolation techniques to impute missing anomalies, ultimately generating chronological visualizations.

Comprehensive coverage of time series fundamentals, from understanding data structure to visualization and handling missing values.

Highlighting Trends and Anomalies

Oplossing