Summary  
This chapter explains how to compute the gradient vector of a multivariate function by calculating its partial derivatives to obtain both the direction and magnitude of steepest ascent, and shows how to implement code that visualizes this vector field.

General domain of usage  
Optimization

**Video: Introduction to the gradient vector and its interpretation as the direction of steepest ascent**

This video introduces the concept of the gradient vector in multivariate calculus. You will learn how the gradient points in the direction of the steepest increase of a function and how its magnitude represents the rate of that increase. 

The **gradient vector** is a fundamental concept in multivariate calculus, representing the **direction and rate of the steepest ascent** of a scalar-valued function of several variables. If you have a function $$f(x, y, ..., n)$$, the **gradient** of $$f$$ at any point is a vector composed of the **partial derivatives** of $$f$$ with respect to each variable. Mathematically, for a function $$f(x, y)$$, the gradient is defined as:

$$
∇f(x, y) = \left[\frac{∂f}{∂x}, \frac{∂f}{∂y}\right]
$$

where $$\frac{\raisebox{1pt}{$∂f$}}{\raisebox{-1pt}{$∂x$}}$$ and $$\frac{\raisebox{1pt}{$∂f$}}{\raisebox{-1pt}{$∂y$}}$$ are the **partial derivatives** of $$f$$ with respect to $$x$$ and $$y$$, respectively. The gradient vector always points in the direction where the function increases most rapidly, and its length tells you how fast the function increases in that direction.

**Some important properties of the gradient vector include:**

- The gradient is perpendicular (normal) to the level curves (contours) of the function;
- If the gradient at a point is zero, that point is a critical point (which could be a maximum, minimum, or saddle point);
- The gradient can be generalized to functions of more than two variables by including all partial derivatives as components of the vector.

To compute the gradient, you simply calculate all the **first-order partial derivatives** with respect to each variable at the point of interest.

import numpy as np
import matplotlib.pyplot as plt

# Define the sample function
def f(x, y):
    return x**2 + y**2

# Compute the gradient of f
def grad_f(x, y):
    df_dx = 2 * x
    df_dy = 2 * y
    return np.array([df_dx, df_dy])

# Create a grid of points
x = np.linspace(-2, 2, 20)
y = np.linspace(-2, 2, 20)
X, Y = np.meshgrid(x, y)

# Compute gradient at each point
U = 2 * X
V = 2 * Y

plt.figure(figsize=(6, 6))
plt.quiver(X, Y, U, V, color="blue", angles='xy')
plt.title("Gradient Vector Field for f(x, y) = x² + y²")
plt.xlabel("x")
plt.ylabel("y")
plt.grid(True)
plt.show()

import unittest
import ast
import re
import io
import sys
import sympy as sp

class TestTask(unittest.TestCase):
    def test_default_values(self):
        with open('user_code.py', 'r') as f:
            code = f.read()
            
        ns = {}
        exec(code, ns)
        
        grad_x = ns.get('grad_x')
        grad_y = ns.get('grad_y')
        
        is_correct = False
        if grad_x is not None and grad_y is not None:
            is_correct = abs(float(grad_x) - 3.0) < 1e-7 and abs(float(grad_y) - 4.0) < 1e-7
            
        _dynamic_test(
            self,
            is_correct,
            "Correctly computes grad_x and grad_y for default values (1, 2).",
            f"Expected grad_x = 3.0, grad_y = 4.0. Got grad_x = {grad_x}, grad_y = {grad_y}",
        )

    def test_dynamic_values(self):
        with open('user_code.py', 'r') as f:
            code = f.read()
            
        code = change_var(code, 'val_x', '0')
        code = change_var(code, 'val_y', '-1')
        
        ns = {}
        try:
            exec(code, ns)
            grad_x = ns.get('grad_x')
            grad_y = ns.get('grad_y')
            
            is_correct = False
            if grad_x is not None and grad_y is not None:
                is_correct = abs(float(grad_x) - 0.0) < 1e-7 and abs(float(grad_y) - (-2.0)) < 1e-7
        except Exception:
            is_correct = False
            
        _dynamic_test(
            self,
            is_correct,
            "Gradient computation works dynamically for arbitrary points.",
            "Failed to compute the gradient dynamically. Make sure you use val_x and val_y in your .subs() method.",
        )

    def test_used_sympy(self):
        with open('user_code.py', 'r') as f:
            code = f.read()
            
        code_clean = gsub_spaces(code)
        
        used_diff = "diff(" in code_clean
        used_subs = "subs(" in code_clean
        
        _dynamic_test(
            self,
            used_diff and used_subs,
            "SymPy library functions (diff, subs) were utilized.",
            "Expected to find the use of SymPy's diff() and subs() methods.",
        )

    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 = '3.0' in output and '4.0' in output
        
        _dynamic_test(
            self,
            found,
            "The result is printed successfully.",
            "The result was not printed properly. Make sure to print the final tuple.",
        )

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

Dive into the essential concepts of multivariate calculus, focusing on the tools and techniques most relevant for data science. This course builds on your linear algebra knowledge and prepares you for advanced topics in probability, statistics, and optimization.

Comprehensive exploration of multivariate calculus concepts and their applications in data science.

The Gradient Vector

Ratkaisu