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

Focuses on the core concepts of statistical analysis using Python, including descriptive statistics, correlation, and hypothesis testing. Excludes environmental science-specific modeling and data, providing a general foundation in statistical methods for beginners.

Challenge: Predict Ozone Levels

Løsning

Challenge: Predict Ozone Levels

Løsning