In machine learning, derivatives are used for solving optimization problems. Optimization algorithms such as gradient descent use derivatives to decide whether to increase or decrease the weights in order to get closer and closer to the maximum or minimum of a function. This post covers how these functions are used in Python.
Symbolic differentiation manipulates a given equation, using various rules, to produce the derivative of that equation. If you know the equation that you want to take the derivative of, you can do symbolic differentiation in Python. Let’s use this equation as an example:
f(x) = 2x2+5
In order to do symbolic differentiation, we’ll need a library called SymPy. SymPy is a Python library for symbolic mathematics. It aims to be a full-featured computer algebra system (CAS). First, import SymPy:
from sympy import *
Make a symbol
Variables are not defined automatically in SymPy. They need to be defined explicitly using
symbols takes a string of variable names separated by spaces or commas, and creates Symbols out of them. Symbol is basically just the SymPy term for a variable.
Our example function f(x) = 2x2+5 has one variable x, so let’s create a variable for it:
x = symbols('x')
If the equation you’re working with has multiple variables, you can define them all in one line:
x, y, z = symbols('x y z')
Symbols can be used to create symbolic expressions in Python code.
>>> x**2 + y x2+y >>> x**2 + sin(y) x2+sin(y)
Write symbolic expression
So, using our Symbol x that we just defined, let’s create a symbolic expression in Python for our example function f(x) = 2x2+5:
f = 2*x**2+5
Take the derivative
Now, we’ll finally take the derivative of the function. To compute derivates, use the
diff function. The first parameter of the diff function should be the function you want to take the derivative of. The second parameter should be the variable you are taking the derivative with respect to.
x = symbols('x') f = 2*x**2+5 df = diff(f, x)
The output for the
df should look like this:
>>> f 2*x**2+5 >>> df 4*x
You can take the nth derivative by adding an optional third argument, the number of times you want to differentiate. For example, taking the 3rd derivative:
d3fd3x = diff(f, x, 3)
Substituting values into expressions
So we are able to make symbolic functions and compute their derivatives, but how do we use these functions? We need to be able to plug a value into these equations and get a solution.
We can substitute values into symbolic equations using the
subs method. The
subs method replaces all instances of a variable with a given value.
subs returns a new expression; it doesn’t modify the original one. Here we substitute 4 for the variable
>>> df.subs(x, 4) 16
To evaluate a numerical expression into a floating point number, use
>>> df.subs(x, 4).evalf() 16.0
To perform multiple substitutions at once, pass a list of
(old, new) pairs to
subs. Here’s an example:
>>> expr = x**3 + 4*x*y - z >>> expr.subs([(x, 2), (y, 4), (z, 0)]) 40
The lambdify function
If you are only evaluating an expression at one or two points,
evalf work well. But if you intend to evaluate an expression at many points, you should convert your SymPy expression to a numerical expression, which gives you more options for evaluating expressions, including using other libraries like NumPy and SciPy.
The easiest way to convert a symbolic expression into a numerical expression is to use the
lambdify function takes in a Symbol and the function you are converting. It returns the converted function. Once the function is converted to numeric, you can Let’s convert the function and derivative function from our example.
>>> f = lambdify(x, f)
>>> df = lambdify(x, df)
Here’s an example of using
lambdify with NumPy:
>>> import numpy >>> test_numbers = numpy.arange(10) >>> expr = sin(x) >>> f(test_numbers) [ 0. 0.84147098 0.90929743 0.14112001 -0.7568025 -0.95892427 -0.2794155 0.6569866 0.98935825 0.41211849]
The application of these functions in a data science solution will be covered in another post.