[PYTHON] Numpy를 사용하여 파생 상품을 계산하려면 어떻게해야합니까?

Numpy를 사용하여 파생 상품을 계산하려면 어떻게해야합니까?

함수의 파생어는 어떻게 계산합니까? 예를 들면 다음과 같습니다.

numpy 사용 하시겠습니까?

예를 들어 x = 5에서 파생 값을 원한다고 가정 해 봅시다.

해결법

1. ==============================

   1.네 가지 옵션이 있습니다.

   네 가지 옵션이 있습니다.

   유한 차이는 외부 도구가 필요 없지만 수치 오류가 발생하기 쉽고 다변량 상황에 처한 경우 다소 시간이 걸릴 수 있습니다.

   문제가 충분히 간단하다면 상징적 인 차별화가 이상적입니다. 요즘에는 상징적 인 방법이 상당히 강력 해지고 있습니다. SymPy는 NumPy와 잘 통합되는 훌륭한 프로젝트입니다. autowrap 또는 lambdify 함수를 보거나 유사한 질문에 대한 Jensen의 블로그 포스트를 확인하십시오.

   자동 파생물은 매우 시원하며 숫자 오류가 발생하지 않지만 추가 라이브러리가 필요합니다 (Google의 경우 몇 가지 좋은 옵션이 있습니다). 이것은 가장 견고하지만 가장 정교하고 선택하기 어려운 선택입니다. 당신이 멍청한 구문으로 자신을 제한한다면, 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.]
   

2. ==============================

   2.NumPy는 파생 상품을 계산하기위한 일반 기능을 제공하지 않습니다. 그러나 다항식의 간단한 특수한 경우를 처리 할 수 ​​있습니다.

   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)
   

   함수 값의 해당 배열 y가있는 가로 좌표의 배열 x가있는 경우 다음과 같이 파생 함수의 근사를 계산할 수 있습니다.

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

3. ==============================

   3.내가 생각할 수있는 가장 직접적인 방법은 numpy의 그래디언트 함수를 사용하는 것입니다.

   내가 생각할 수있는 가장 직접적인 방법은 numpy의 그래디언트 함수를 사용하는 것입니다.

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

   이 방법으로 dydx는 중앙 차이를 사용하여 계산되며 앞으로 차이를 사용하고 (n-1) 크기 벡터를 반환하는 numpy.diff와는 달리 y와 길이가 같습니다.

4. ==============================

   4.numpy를 사용한다고 가정하면 엄격한 정의를 사용하여 언제든지 함수의 파생어를 수치로 계산할 수 있습니다.

   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
   

5. ==============================

   5.더미에 다른 방법을 던지 겠어.

   더미에 다른 방법을 던지 겠어.

   scipy.interpolate의 많은 보간 스플라인은 미분을 제공 할 수 있습니다. 따라서 선형 스플라인 (k = 1)을 사용하면 스플라인 파생물 (미분 () 메서드 사용)이 전진 차와 같아야합니다. 완전히 확신 할 수는 없지만 입방 스플라인 파생물을 사용하는 것은 전후의 값을 사용하기 때문에 중심의 차이 파생 상품과 유사 할 것입니다.

   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)
   

6. ==============================

   6.요구되는 정밀도 수준에 따라 차별화의 간단한 증거를 사용하여 스스로 해결할 수 있습니다.

   요구되는 정밀도 수준에 따라 차별화의 간단한 증거를 사용하여 스스로 해결할 수 있습니다.

   >>> (((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
   

7. ==============================

   7.그라디언트를 계산하기 위해 기계 학습 커뮤니티는 Autograd를 사용합니다.

   그라디언트를 계산하기 위해 기계 학습 커뮤니티는 Autograd를 사용합니다.

   설치하기 위해서:

   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))
   

   또한 복잡한 함수의 그라데이션을 계산할 수 있습니다. 다 변수 함수.

from https://stackoverflow.com/questions/9876290/how-do-i-compute-derivative-using-numpy by cc-by-sa and MIT license