Milşteyn yöntemi

Matematiğin bir alt dalı olan stokastik analizde **Milşteyn yöntemi** (ya da **Milstein yöntemi**) stokastik diferansiyel denklemlere yaklaşık sayısal çözümler üretmek için geliştirilmiş yöntemlerden biridir. Yöntem adını, bu yaklaşıklığı 1974'te yayınlayan Grigori Milşteyn'den (Мильштейн, Г. Н.) almaktadır.

## Yöntemin açıklaması
*W**t*, Wiener süreci olsun. Başlangıç koşulu *X*0&nbsp;=&nbsp;*x*0 olan ve 
:\mathrm{d} X_t = a(X_t, t) \, \mathrm{d} t + b(X_t, t) \, \mathrm{d} W_t,
hâlindeki stokastik bir diferansiyel denklemi [0,&nbsp;*T*] aralığında sayısal olarak çözmek istediğimizi varsayalım. Stokastik diferansiyel denklemin teorik çözümü X ile gösterilsin. X'in **Milstein yaklaşıklığı** aşağıdaki gibi kurulup tanımlanan ve bir Markov zinciri olan Ydir.

* [0,&nbsp;*T*] aralığını *N* tane eşit altaralığa bölelim. Her altaralığın uzunluğu \Delta t>0 ile gösterilsin. O zaman,
::0 = \tau_{0} 
:olacaktır.
* *Y*0&nbsp;=&nbsp;*x*0 tanımlansın.
*  0&nbsp;≤&nbsp;*n*&nbsp;≤&nbsp;*N-1* için \Delta W_n = W_{\tau_{n + 1}} - W_{\tau_n} olmak üzere, *Y**n* terimleri yinelemeli olarak
: Y_{n + 1} = Y_n + a(Y_n) \Delta t + b(Y_n) \Delta W_n + \frac{1}{2} b(Y_n) b'(Y_n) \left( (\Delta W_n)^2 - \Delta t \right)
:olarak tanımlansın. Burada, b' ile türev, yani, b(x) fonksiyonunun   x'e göre türevi, kastedilmiştir. Bahsi geçen Δ*W**n* rasgele değişkenleri bağımsız ve özdeş dağılmış normal rastgele değişkenlerdir. Her birinin beklenen değeri sıfırdır ve her biri Δ*t* varyansına sahiptir.

## Yöntemin arkasındaki fikir
Yöntemin arkasındaki esas fikir b(X_t) terimine Ito formülünü uygulayıp daha Euler yaklaşımlığını iyileştirmektir. Elbette, burada, bu terimdeki b fonksiyonun Ito formülünün koşullarına uyması beklenmektedir. 
Ito formülü ile 

\begin{align}
\mathrm{d} b(X_t) 
&= b'(X_t)\mathrm{d}X_t + \frac{1}{2} b*(X_t) b^2(X_t)dt\\
&=\left[b'(X_t)a(X_t) + \frac{1}{2} b*(X_t) b^2(X_t)\right]dt+ b'(X_t) b(X_t)dW_t\\
&=\mu_b(X_t) dt + \sigma_b(X_t) dW_t\\
\end{align}

elde edilir.
t\le u\le t+\Delta t şartını sağlayan bir u sayısı için, Euler-Maruyama yöntemi kullanılarak, yukarıda elde edilen \mathrm{d} b(X_t) ifadesine yaklaşım sağlanır. Diğer deyişle,

\begin{align}
b(X_u) &\approx b(X_t) \mu_b(X_t) [u-t] + \sigma_b(X_t) [W_u-W_t]\\
&=  b(X_t)\left[b'(X_t)a(X_t) + \frac{1}{2} b''(X_t) b^2(X_t)\right][u-t] + b'(X_t) b(X_t)  [W_u-W_t]
\end{align}

yazılabilir. W_u-W_t terimi olasılıkta O(\sqrt{u-t}) olduğundan ve bu yaklaşıklıktaki sürüklenme O(u-t) olduğundan, O(u-t) büyümesine sahip terimler düşürülüp

\begin{align}
b(X_u) &\approx b(X_t) + b'(X_t) b(X_t)  [W_u-W_t], \quad u\in[t, t+\Delta t]
\end{align}

yazılır. Bu yüzden, 

\begin{align}
\int_{t}^{t+\Delta t}b(X_u)dW_u &\approx \int_{t}^{t+\Delta t} b(X_t) + b'(X_t) b(X_t)  [W_u-W_t] dW(u)\\
&=b(X_t)[W_{t+\Delta t}-W_t]+  b'(X_t) b(X_t) \int_{t}^{t+\Delta t} [W_u-W_t] dW(u)\\
&=b(X_t)[W_{t+\Delta t}-W_t]+  \frac{1}{2} b'(X_t) b(X_t) [(W_{t+\Delta t}-W_t)^2-\Delta t].\\
\end{align}

elde edilir. O zaman, Euler yaklaşımlığını biraz daha düzelterek

\begin{align}
X_{t + \Delta t} \approx X_t + a(X_t)\Delta t + b(X_t)[W_{t + \Delta t}-W_t]+ \frac{1}{2} b'(X_t) b(X_t) [(W_{t+\Delta t}-W_t)^2-\Delta t]
\end{align}

yazılır.

### Programlama uygulaması

\begin{cases}
dY_t= \mu Y \, {\mathrm d}t + \sigma Y \, {\mathrm d}W_t \\
Y_0=Y_\text{ilk}
\end{cases}
biçiminde verilmiş olan bir geometrik Brown hareketini sayısal olarak çözmek için Milşteyn yöntemi kullanılabilir.

Rastgele sayıların NumPy tarafından verildiği bir Python programlama kodu aşağıdaki gibi verilebilir:


```numpy
# -*- coding: utf-8 -*-
import numpy as np
import matplotlib.pyplot as plt
from textwrap import wrap

class Model:
    """Stokastik modelin  sabitleri."""
    MU = 0.05
    SIGMA = 0.2

def dW(dt):
    """Normal rastgele değişken çekilişi"""
    return np.random.normal(loc=0.0, scale=np.sqrt(dt))

def simulasyon(t_i:int, t_s:int, adim_sayisi:int):
    """bir simülasyon yolağı"""
    T_ILK = t_i
    T_SON = t_s
    N = adim_sayisi 
    DT = float(T_SON - T_ILK) / N
    Tler = np.arange(T_ILK, T_SON + DT, DT)
    assert Tler.size == N + 1

    Y_ILK = 1

    yler = np.zeros(Tler.size)
    yler[0] = Y_ILK
    for i in range(1, Tler.size):
        t = (i - 1) * DT
        y = yler[i - 1]
        dw = dW(DT)

        #Milstein yontemindeki gibi terimleri topla
        yler[i] = y + \
            Model.MU * y * DT + \
            Model.SIGMA * y * dw + \
            (Model.SIGMA**2 / 2) * y * (dw**2 - DT)

    return Tler, yler

#Birkaç simülasyonun aynı grafikte çizimi
sim_sayisi=100
# [0, 1] aralığında 5000 zaman adımında hesaplıyoruz
t_i=0#
t_s=1
adim_sayisi=5000
for _ in range(sim_sayisi):
    plt.plot(*simulasyon(t_i, t_s, adim_sayisi))

plt.xlabel("zaman (s)")
plt.ylabel("y")
plt.title("\n".join(wrap(
r"$\mu=$ {} ve $\sigma=$ {} parametreleri verilen bir geometrik Brown hareketinin [{},{}] aralığında {} zaman adımlı Milşteyn yöntemiyle yapılan yaklaşıklamalarının {} yolaklı simülasyonu".format(Model.MU, Model.SIGMA, t_i, t_s, adim_sayisi, sim_sayisi))), fontsize='small')
plt.savefig('Milstein.png', format="png")
plt.show()
```


## Ayrıca bakınız
* Euler-Maruyama yöntemi

## Kaynakça