In environmental science, predicting air quality indicators such as **ozone levels** is crucial for understanding pollution dynamics and informing public health decisions. You will use a simple `linear regression` model to predict ozone levels based on `temperature` data, a common approach for exploring how weather conditions relate to air pollution.

Begin by importing the necessary libraries and preparing your data. You have a small dataset of daily temperature and ozone measurements, which allows you to practice building and evaluating a predictive model.


import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib
import numpy as np
import sys
import io
import matplotlib
matplotlib.use('Agg')

class TestTask(unittest.TestCase):
    def setUp(self):
        self.df =  __import__('user_code').df
        self.X = self.df[["temperature"]]
        self.y = self.df["ozone"]
        self.expected_coef = 3.081
        self.expected_intercept = -34.23
        self.expected_mse = 7.35
        self.expected_r2 = 0.98

    def test_model_exists_and_fitted(self):
        import user_code
        importlib.reload(user_code)
        model = getattr(user_code, 'model', None)
        _dynamic_test(
            self,
            model is not None,
            "Model variable exists.",
            "Model variable 'model' is not defined."
        )
        if model is not None:
            coef = getattr(model, 'coef_', None)
            intercept = getattr(model, 'intercept_', None)
            _dynamic_test(
                self,
                coef is not None and intercept is not None,
                "Model is fitted and has coef_ and intercept_.",
                "Model does not have coef_ or intercept_ (is it fitted?)."
            )

    def test_model_coefficients_reasonable(self):
        import user_code
        importlib.reload(user_code)
        model = getattr(user_code, 'model', None)
        _dynamic_test(
            self,
            model is not None,
            "Model exists for coefficient check.",
            "Model missing for coefficient check."
        )
        if model is not None and hasattr(model, 'coef_'):
            # Allow small tolerance for floating point
            tol = 0.15
            _dynamic_test(
                self,
                abs(model.coef_[0] - self.expected_coef) < tol,
                f"Model coefficient is correct: {model.coef_[0]:.2f}",
                f"Model coefficient is not as expected. Got {model.coef_[0]:.2f}, expected around {self.expected_coef:.2f}"
            )
            _dynamic_test(
                self,
                abs(model.intercept_ - self.expected_intercept) < 1.0,
                f"Model intercept is correct: {model.intercept_:.2f}",
                f"Model intercept is not as expected. Got {model.intercept_:.2f}, expected around {self.expected_intercept:.2f}"
            )

    def test_y_pred_correct_shape_and_values(self):
        import user_code
        importlib.reload(user_code)
        y_pred = getattr(user_code, 'y_pred', None)
        _dynamic_test(
            self,
            y_pred is not None,
            "y_pred exists.",
            "y_pred variable is not defined."
        )
        if y_pred is not None:
            _dynamic_test(
                self,
                len(y_pred) == len(self.y),
                "y_pred has correct length.",
                f"y_pred has incorrect length: {len(y_pred)} vs {len(self.y)}"
            )
            # Check first and last value close to expected
            expected_first = 34.56
            expected_last = 24.39
            _dynamic_test(
                self,
                abs(y_pred[0] - expected_first) < 0.2 and abs(y_pred[-1] - expected_last) < 0.2,
                f"y_pred values are correct at endpoints.",
                f"y_pred endpoints not as expected: got {y_pred[0]:.2f}, {y_pred[-1]:.2f}"
            )

    def test_metrics_printed(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        sys.stdout = f
        importlib.reload(user_code)
        output = f.getvalue()
        sys.stdout = sys.__stdout__
        output = normalize_text(output)
        mse_ok = "mean squared error: 7.35" in output
        r2_ok = "r^2 score: 0.98" in output
        _dynamic_test(
            self,
            mse_ok,
            "Mean squared error is printed and correct.",
            f"Mean squared error is not printed or incorrect. Output: {output}"
        )
        _dynamic_test(
            self,
            r2_ok,
            "R^2 score is printed and correct.",
            f"R^2 score is not printed or incorrect. Output: {output}"
        )

    def test_plot_created(self):
        import user_code
        import matplotlib.pyplot as plt
        plt.clf()
        importlib.reload(user_code)
        fig = plt.gcf()
        ax = plt.gca()
        lines = ax.get_lines()
        points = [c for c in ax.collections if hasattr(c, 'get_offsets')]
        _dynamic_test(
            self,
            len(lines) >= 1 and len(points) >= 1,
            "Plot includes both scatter points and regression line.",
            f"Plot missing scatter or regression line. Lines: {len(lines)}, Points: {len(points)}"
        )

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
    # Collect all assignment nodes to modify
    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 nothing to change, return unmodified code
    if not assign_nodes:
        return code

    # Perform replacements for all matching assignments (from last to first to not break line offsets)
    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

Explore how Python can be leveraged to address real-world environmental science problems. This course guides students through data analysis, visualization, and modeling techniques relevant to environmental research, using hands-on tasks and engaging theory chapters.

Learn how to access, clean, and explore environmental datasets using Python. Gain foundational skills for working with real-world environmental data.

Delve into statistical techniques for analyzing environmental data, including descriptive statistics, correlation, and hypothesis testing.

Apply Python to model and predict environmental processes, such as pollution dispersion and climate trends, using real datasets.

Challenge: Predict Ozone Levels

Oplossing

Challenge: Predict Ozone Levels

Oplossing