A student is exploring how to use gradient descent to fit a straight line to a small dataset.
The dataset shows **years of experience** versus **salary (in thousands)**, and the goal is to find the best-fitting line using an iterative update rule.

Your task is to adjust the slope ($$m$$**) and intercept ($$b$$) so that the line closely follows the data points.

**The expression you are trying to minimize is**:
 
$$
\frac{1}{n}\sum^n_{i=1}(y_i - (mx_i + b))^2
$$

**The gradient descent update rules for minimizing this function are**:

$$
m \larr m - \alpha \frac{\partial J}{\partial m} \\[6 pt]
b \larr b - \alpha \frac{\partial J}{\partial b}
$$
 
Where:
- $$\alpha$$ is the learning rate (step size);
- $$\frac{\partial J}{\partial m}$$ is the partial derivative of the loss function with respect to $$m$$;
- $$\frac{\partial J}{\partial b}$$ is the partial derivative of the loss function with respect to $$b$$.

This loss measures how far off your predicted points are from the actual data. (P.S. Smaller values mean the line fits the data better.)

In order to find values $$m$$ and $$b$$, use gradient descent.


import unittest
import numpy as np
import user_code  # ÑÑÑÐ´ÐµÐ½ÑÑÑÐºÐ¸Ð¹ ÐºÐ¾Ð´

def _dynamic(tc, ok, ok_msg, fail_msg):
    tc._testMethodName = ok_msg if ok else fail_msg
    (tc.assertTrue if ok else tc.fail)(tc._testMethodName)

class TestGradientDescent(unittest.TestCase):

    def test_hyperparameters(self):
        alpha = getattr(user_code, "alpha", None)
        iterations = getattr(user_code, "iterations", None)

        reasons = []
        if alpha is None or not (0 < alpha < 1):
            reasons.append(f"alpha should be a small positive value, got {alpha}")
        if iterations is None or iterations < 10:
            reasons.append(f"iterations should be >= 100, got {iterations}")

        _dynamic(self, not reasons,
                 "PASS: hyperparameters are reasonable",
                 "FAIL: " + "; ".join(reasons))

    def test_predictions_shape(self):
        x = user_code.x
        y_final = getattr(user_code, "y_final", None)
        ok = isinstance(y_final, np.ndarray) and y_final.shape == x.shape
        _dynamic(self, ok,
                 "PASS: y_final shape matches x",
                 f"FAIL: y_final has wrong shape {None if y_final is None else y_final.shape}")

    def test_learned_parameters(self):
        m = getattr(user_code, "m", None)
        b = getattr(user_code, "b", None)

        # ÐÑÑÐºÑÐ²Ð°Ð½Ð° Ð»ÑÐ½ÑÑ: y â 5x + 25
        reasons = []
        if m is None or not np.isclose(m, 5.0, rtol=0.1):
            reasons.append(f"slope m expected â 5.0, got {m}")
        if b is None or not np.isclose(b, 25.0, rtol=0.1):
            reasons.append(f"intercept b expected â 25.0, got {b}")

        _dynamic(self, not reasons,
                 "PASS: learned m and b are correct",
                 "FAIL: " + "; ".join(reasons))


test_code.py

Master the mathematical foundations essential for data science. Explore core concepts in functions, calculus, linear algebra, probability, and dimensionality reduction. Build both theoretical understanding and practical coding experience to strengthen your ability to analyze data, model complex systems, and apply advanced techniques in machine learning.

Explore the foundation of mathematical functions. Learn different types of algebraic and transcendental functions, their properties, and how to implement them in Python to solve real-world problems.

Master the concepts of sets and series, from basic operations to practical applications. Gain hands-on experience implementing set operations and working with arithmetic and geometric series in Python.

Develop a solid understanding of limits, derivatives, integrals, and partial derivatives. Connect theory to practice by implementing these concepts in Python and applying them to optimization through gradient descent.

Build strong knowledge of vectors, matrices, and transformations. Learn decomposition methods and eigenvalue analysis, while reinforcing concepts with Python coding challenges and practical data science applications.

Dive into probability theory and statistics. Study conditional probability, Bayes' theorem, and statistical measures. Implement key concepts in Python, simulate distributions, and strengthen your skills through challenges and quizzes.

Challenge: Fitting a Line with Gradient Descent

Solução

Awesome!

Challenge: Fitting a Line with Gradient Descent

Solução

Awesome!