Hands-on Practical: Calculating Derivatives with Python

While understanding the rules of differentiation and practicing manual calculations is fundamental, applying these concepts in machine learning often involves complex functions or requires repeated calculations within larger algorithms. Fortunately, Python provides powerful libraries to compute derivatives automatically, both symbolically (providing exact analytical expressions) and numerically (approximating the derivative's value). Here is how to use these tools.

Symbolic Differentiation with SymPy

SymPy is a Python library for symbolic mathematics. It allows us to define mathematical expressions with symbols and perform operations like differentiation, integration, and equation solving, all while maintaining exact symbolic representations. This is incredibly useful for finding the exact form of a derivative.

First, ensure you have SymPy installed (pip install sympy). Let's start by defining a symbolic variable and a function.

import sympy

# Define 'x' as a symbolic variable
x = sympy.symbols('x')

# Define a function, for example, f(x) = x^3 + 2*x^2 - 5*x + 1
f = x**3 + 2*x**2 - 5*x + 1

print(f"Original function: f(x) = {f}")

Now, we can use SymPy's diff function to compute the derivative of $f(x)$ with respect to $x$.

# Calculate the derivative of f with respect to x
f_prime = sympy.diff(f, x)

print(f"Derivative: f'(x) = {f_prime}")

SymPy correctly applies the differentiation rules (power rule, sum rule) to give us the exact analytical derivative: $f'(x) = 3x^2 + 4x - 5$.

We can also use SymPy to evaluate the derivative at a specific point. Let's find the slope of the tangent line at $x = 2$.

# Evaluate the derivative at x = 2
value_at_2 = f_prime.subs(x, 2)

print(f"Value of the derivative at x = 2: f'(2) = {value_at_2}")

The result, $f'(2) = 3(2)^2 + 4(2) - 5 = 12 + 8 - 5 = 15$, gives us the instantaneous rate of change of the function $f(x)$ at the point $x=2$.

SymPy can handle more complex functions involving trigonometric, exponential, and logarithmic components as well.

import sympy
import numpy as np # Often used alongside SymPy

# Define x as a symbol
x = sympy.symbols('x')

# Define a more complex function: g(x) = sin(x) * exp(-x^2 / 2)
g = sympy.sin(x) * sympy.exp(-x**2 / 2)
print(f"\nAnother function: g(x) = {g}")

# Calculate its derivative
g_prime = sympy.diff(g, x)
print(f"Derivative: g'(x) = {g_prime}")

# Evaluate the derivative at x = 0
# Use evalf() for numerical evaluation if needed
value_at_0 = g_prime.subs(x, 0).evalf()
print(f"Value of the derivative at x = 0: g'(0) = {value_at_0}")

Symbolic differentiation is perfect when you need the exact mathematical expression for the derivative or high precision.

Numerical Differentiation with SciPy

Sometimes, we might not have an analytical expression for a function (it could be the result of a complex simulation or an external system), or the symbolic derivation might be computationally very expensive. In such cases, we can approximate the derivative numerically.

The core idea is to use the definition of the derivative, $f'(x) = \lim_{h \to 0} \frac{f(x+h) - f(x)}{h}$, but instead of taking the limit, we use a very small, non-zero value for $h$. A common and often more accurate approach is the central difference formula:

$f'(x) \approx \frac{f(x+h) - f(x-h)}{2h}$

The SciPy library (usually installed alongside NumPy, pip install scipy) provides convenient functions for numerical differentiation. scipy.derivative is a good option.

Let's use the same function $f(x) = x^3 + 2x^2 - 5x + 1$ and approximate its derivative at $x = 2$.

import numpy as np
from scipy.misc import derivative # Or from scipy import derivative in newer versions

# Define the function f(x) as a regular Python function
def f_numeric(x):
  return x**3 + 2*x**2 - 5*x + 1

# Point at which to evaluate the derivative
point = 2.0

# Step size (h in the formula). Smaller values generally give more accuracy,
# but too small can lead to floating-point errors.
step_size = 1e-6

# Calculate the numerical derivative using SciPy
f_prime_numeric = derivative(f_numeric, point, dx=step_size)

print(f"\nNumerical approximation of f'(x) at x = {point}")
print(f"f'({point}) ≈ {f_prime_numeric}")

# Compare with the exact value from SymPy
exact_value = 15
print(f"Exact value: f'({point}) = {exact_value}")
print(f"Approximation Error: {abs(f_prime_numeric - exact_value)}")

As you can see, the numerical approximation is very close to the exact value (15) we found using SymPy. The small difference is due to the approximation inherent in the finite difference method and potential floating-point inaccuracies.

Numerical differentiation is particularly valuable when working with functions where a direct symbolic representation isn't available or practical. However, be mindful of the choice of step size (dx) and potential precision limitations.

Connecting to Optimization

Why is calculating derivatives so important in machine learning? As discussed earlier in this chapter and in Chapter 1, optimization involves finding the parameters (like weights and biases in a model) that minimize a cost or loss function. This cost function typically measures how poorly the model performs.

The derivative (or its multivariable counterpart, the gradient, which we'll see in the next chapter) tells us the slope of the cost function. By calculating the derivative, optimization algorithms like gradient descent know which direction to adjust the parameters to decrease the cost, effectively "descending" the slope towards a minimum. Being able to compute these derivatives efficiently, either symbolically or numerically, is therefore essential for training many machine learning models.

This practical ability to compute derivatives using Python libraries like SymPy and SciPy frees us from tedious manual calculations and allows us to focus on building and optimizing machine learning models. As we move to functions with multiple variables, these computational techniques will become even more significant.