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) = 2x ^{2}+5*

#### Import SymPy

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`

. `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) = 2x ^{2}+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 x^{2}+y >>> x**2 + sin(y) x^{2}+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) = 2x ^{2}+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 `f`

and `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 `x`

in `df`

:

>>> df.subs(x, 4) 16

To evaluate a numerical expression into a floating point number, use `evalf`

.

>>> 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, `subs`

and `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.

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)

>>> f(3)

23

>>> df(3)

12

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.