Как вычислить производную с помощью Numpy?

Как рассчитать производную функции, например

у = х ² +1

используя numpy?

Скажем, мне нужно значение производной при x = 5 ...

У вас есть четыре варианта

1. Конечные различия
2. Автоматические деривативы
3. Символическая дифференциация
4. Вычисляйте производные вручную.

Конечные различия не требуют внешних инструментов, но подвержены числовым ошибкам и, если вы находитесь в многомерной ситуации, могут занять некоторое время.

Символическая дифференциация идеальна, если ваша проблема достаточно проста. В наши дни символические методы становятся все более надежными. SymPy - отличный проект для этого, который хорошо интегрируется с NumPy. Посмотрите на функции autowrap или lambdify или почитайте блог Дженсена по аналогичному вопросу .

Автоматические производные очень хороши, не подвержены числовым ошибкам, но требуют дополнительных библиотек (для этого есть несколько хороших вариантов в Google). Это самый надежный, но также самый сложный / сложный в настройке вариант. Если вы хорошо ограничиваетесь numpyсинтаксисом, то Theano может быть хорошим выбором.

Вот пример использования SymPy

In [1]: from sympy import *
In [2]: import numpy as np
In [3]: x = Symbol('x')
In [4]: y = x**2 + 1
In [5]: yprime = y.diff(x)
In [6]: yprime
Out[6]: 2⋅x

In [7]: f = lambdify(x, yprime, 'numpy')
In [8]: f(np.ones(5))
Out[8]: [ 2.  2.  2.  2.  2.]

Самый простой способ, который я могу придумать, - это использовать функцию градиента numpy :

x = numpy.linspace(0,10,1000)
dx = x[1]-x[0]
y = x**2 + 1
dydx = numpy.gradient(y, dx)

Таким образом, dydx будет вычисляться с использованием центральных разностей и будет иметь ту же длину, что и y, в отличие от numpy.diff, который использует прямые разности и возвращает вектор размера (n-1).

NumPy не предоставляет общих функций для вычисления производных. Однако он может обрабатывать простой частный случай многочленов:

>>> p = numpy.poly1d([1, 0, 1])
>>> print p
   2
1 x + 1
>>> q = p.deriv()
>>> print q
2 x
>>> q(5)
10

Если вы хотите вычислить производную численно, вы можете обойтись без использования центральных разностных коэффициентов для подавляющего большинства приложений. Для производной в одной точке формула будет выглядеть примерно так:

x = 5.0
eps = numpy.sqrt(numpy.finfo(float).eps) * (1.0 + x)
print (p(x + eps) - p(x - eps)) / (2.0 * eps * x)

если у вас есть массив xабсцисс с соответствующим массивом yзначений функций, вы можете вычислить приближения производных с

numpy.diff(y) / numpy.diff(x)

Предполагая, что вы хотите использовать numpy, вы можете численно вычислить производную функции в любой точке, используя строгое определение :

def d_fun(x):
    h = 1e-5 #in theory h is an infinitesimal
    return (fun(x+h)-fun(x))/h

Вы также можете использовать симметричную производную для лучших результатов:

def d_fun(x):
    h = 1e-5
    return (fun(x+h)-fun(x-h))/(2*h)

Используя ваш пример, полный код должен выглядеть примерно так:

def fun(x):
    return x**2 + 1

def d_fun(x):
    h = 1e-5
    return (fun(x+h)-fun(x-h))/(2*h)

Теперь вы можете численно найти производную по адресу x=5:

In [1]: d_fun(5)
Out[1]: 9.999999999621423

Закину на кучу другой метод ...

scipy.interpolateМногие интерполирующие сплайны могут предоставлять производные. Таким образом, при использовании линейного сплайна ( k=1) производная сплайна (с использованием derivative()метода) должна быть эквивалентна прямой разнице. Я не совсем уверен, но я считаю, что использование производной кубического сплайна было бы похоже на производную с центрированной разностью, поскольку для построения кубического сплайна используются значения до и после.

from scipy.interpolate import InterpolatedUnivariateSpline

# Get a function that evaluates the linear spline at any x
f = InterpolatedUnivariateSpline(x, y, k=1)

# Get a function that evaluates the derivative of the linear spline at any x
dfdx = f.derivative()

# Evaluate the derivative dydx at each x location...
dydx = dfdx(x)

Для расчета градиентов сообщество машинного обучения использует Autograd:

« Эффективно вычисляет производные numpy-кода ».

Установить:

pip install autograd

Вот пример:

import autograd.numpy as np
from autograd import grad

def fct(x):
    y = x**2+1
    return y

grad_fct = grad(fct)
print(grad_fct(1.0))

Он также может вычислять градиенты сложных функций, например многомерных функций.

В зависимости от требуемого уровня точности вы можете решить это самостоятельно, используя простое доказательство дифференциации:

>>> (((5 + 0.1) ** 2 + 1) - ((5) ** 2 + 1)) / 0.1
10.09999999999998
>>> (((5 + 0.01) ** 2 + 1) - ((5) ** 2 + 1)) / 0.01
10.009999999999764
>>> (((5 + 0.0000000001) ** 2 + 1) - ((5) ** 2 + 1)) / 0.0000000001
10.00000082740371

на самом деле мы не можем взять предел градиента, но это довольно весело. Вы должны быть осторожны, потому что

>>> (((5+0.0000000000000001)**2+1)-((5)**2+1))/0.0000000000000001
0.0

Вы можете использовать scipy, что довольно просто:

scipy.misc.derivative(func, x0, dx=1.0, n=1, args=(), order=3)

Найдите n-ю производную функции в точке.

В твоем случае:

from scipy.misc import derivative

def f(x):
    return x**2 + 1

derivative(f, 5, dx=1e-6)
# 10.00000000139778