Summary  
This chapter demonstrates how to implement simple linear regression in Python using scikit-learn by fitting a LinearRegression model to paired numeric data, extracting its slope and intercept, and using it to predict values and plot the regression line.

General domain of usage  
Education

**Video: Introduction to Simple Linear Regression**

This video introduces you to the concept of simple linear regression, explaining how it is used to model the relationship between two variables. You will learn about the process of fitting a linear regression model, interpreting the slope and intercept, and understanding how these results can inform your analysis.

Simple linear regression is a foundational statistical method that helps you understand the relationship between two continuous variables: one independent (predictor) and one dependent (response). The goal is to model the dependent variable as a linear function of the independent variable. The general form of the model is:

$$
y = β₀ + β₁x + ε
$$

where $$y$$ is the dependent variable, $$x$$ is the independent variable, $$β₀$$ is the intercept, $$β₁$$ is the slope, and $$ε$$ is the error term.

To fit a linear regression model in Python using scikit-learn, follow these key steps:

1. **Prepare your data**: organize your predictor ($$x$$) and response ($$y$$) variables, typically in arrays or pandas Series;
2. **Import and instantiate the model**: use `LinearRegression` from scikit-learn;
3. **Fit the model**: call the `fit()` method with your data to estimate the best-fitting line;
4. **Interpret the results**: extract the slope (`coef_`) and intercept (`intercept_`) to understand the relationship.

The **slope** ($$β₁$$) tells you how much `y` is expected to change for a one-unit increase in `x`. The **intercept** ($$β₀$$) represents the expected value of `y` when `x` is zero. By examining these parameters, you can assess both the direction and strength of the relationship.

Visualizing the regression line alongside the data points can help you interpret the model's fit and the nature of the relationship between the variables.

import numpy as np
import matplotlib.pyplot as plt
from sklearn.linear_model import LinearRegression

# Sample data: hours studied vs exam score
hours_studied = np.array([1, 2, 3, 4, 5, 6]).reshape(-1, 1)
exam_score = np.array([50, 55, 65, 70, 75, 80])

# Create and fit the linear regression model
model = LinearRegression()
model.fit(hours_studied, exam_score)

# Extract slope and intercept
slope = model.coef_[0]
intercept = model.intercept_

print("Slope:", slope)
print("Intercept:", intercept)

# Predict values and plot the regression line
predicted_scores = model.predict(hours_studied)

plt.scatter(hours_studied, exam_score, color='blue', label='Actual Data')
plt.plot(hours_studied, predicted_scores, color='red', label='Regression Line')
plt.xlabel('Hours Studied')
plt.ylabel('Exam Score')
plt.title('Simple Linear Regression: Hours Studied vs Exam Score')
plt.legend()
plt.show()

import unittest
import ast
import re
import io
import sys
import numpy as np
from sklearn.linear_model import LinearRegression

class TestTask(unittest.TestCase):
    def test_default_values(self):
        with open('user_code.py', 'r') as f:
            code = f.read()
            
        ns = {}
        try:
            exec(code, ns)
            slope = ns.get('slope')
            intercept = ns.get('intercept')
            
            expected_slope = 1.8714285714285714
            expected_intercept = 7.0
            
            is_correct = False
            if slope is not None and intercept is not None:
                is_correct = np.isclose(slope, expected_slope, atol=0.01) and \
                             np.isclose(intercept, expected_intercept, atol=0.01)
        except Exception:
            is_correct = False
            slope = None
            intercept = None
            
        _dynamic_test(
            self,
            is_correct,
            "Correctly computes the slope and intercept for the default dataset.",
            f"Expected slope ~1.87 and intercept ~7.0. Got slope: {slope}, intercept: {intercept}. Check your model.fit() parameters.",
        )

    def test_dynamic_values(self):
        with open('user_code.py', 'r') as f:
            code = f.read()
            
        # Підміняємо масиви для перевірки динамічності (лінійна залежність y = 3x + 5)
        code = change_var(code, 'ad_spend', 'np.array([0, 1, 2, 3, 4, 5])')
        code = change_var(code, 'sales_revenue', 'np.array([5, 8, 11, 14, 17, 20])')
        
        ns = {}
        try:
            exec(code, ns)
            slope = ns.get('slope')
            intercept = ns.get('intercept')
            
            expected_slope = 3.0
            expected_intercept = 5.0
            
            is_correct = False
            if slope is not None and intercept is not None:
                is_correct = np.isclose(slope, expected_slope, atol=0.01) and \
                             np.isclose(intercept, expected_intercept, atol=0.01)
        except Exception:
            is_correct = False
            
        _dynamic_test(
            self,
            is_correct,
            "Linear regression dynamically fits arbitrary numeric input arrays.",
            "Failed to evaluate dynamically. Ensure you pass the dynamic variables into model.fit() instead of hardcoding.",
        )

    def test_printed_output(self):
        with open('user_code.py', 'r') as f:
            code = f.read()
            
        f_io = io.StringIO()
        sys_stdout = sys.stdout
        sys.stdout = f_io
        try:
            exec(code, {})
        except Exception:
            pass
        finally:
            sys.stdout = sys_stdout
            
        output = f_io.getvalue()
        
        found = '1.87' in output and '7.0' in output
        
        _dynamic_test(
            self,
            found,
            "The final slope and intercept are printed successfully.",
            "The results were not printed properly. Make sure the print statements remain intact.",
        )

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 gsub_spaces(text):
    text = re.sub(r"\s+", "", text)
    text = text.replace("'", "")
    text = text.replace('"', "")
    return text

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 chr(10).join(lines) if changed else code

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

test_main.py

This course provides a comprehensive introduction to statistical methods using Python. You will learn how to apply core statistical concepts, perform hypothesis testing, analyze data distributions, and interpret results using Python's scientific libraries. The course emphasizes practical application through real-world examples and hands-on exercises.

A comprehensive section covering the core concepts and practical applications of statistical methods using Python.

Simple Linear Regression

Oplossing