Technology

European Vanilla Call-Put Option Pricing ด้วย Python

2025-05-13 09:11:14

โพสต์นี้เป็นส่วนหนึ่งของซีรีส์ที่ใหญ่กว่าที่เกี่ยวกับการตั้งราคาออปชั่นด้วย Python เพื่อให้ได้ประโยชน์สูงสุดจากบทความนี้ คุณควรสามารถทำเครื่องหมายในช่องต่อไปนี้ได้:

ความรู้ที่ดีเกี่ยวกับการเขียนโปรแกรมด้วย Python
ความรู้พื้นฐานเกี่ยวกับสถิติ
การอนุมานสมการ Black-Scholes และสูตร Black-Scholes สำหรับราคาของ European Vanilla Call/Put Option (นี่จะเป็นหัวข้อของบทความในภายหลัง)

บทความในภายหลังจะสร้างตัวแก้ปัญหา Finite Difference และ Monte Carlo ที่พร้อมใช้งานในการผลิตเพื่อแก้ปัญหาสัญญาซื้อขายล่วงหน้าที่ซับซ้อนมากขึ้น

ทำไมต้องใช้ Python?

Python มีชื่อเสียงเป็นหลักในฐานะภาษาสคริปต์ ทำหน้าที่เป็น "กาว" ระหว่างฐานข้อมูลโค้ดอื่นๆ ทีมงาน QuantStart เชื่อว่า ด้วยเครื่องมือเช่น Numpy และ SciPy มันสามารถใช้ในการกำหนดราคาออปชั่นได้อย่างสมบูรณ์แบบ อย่างไรก็ตาม นี่ก็เป็นอีกหนึ่งภาษาที่ต้องเรียนรู้ - แล้วทำไมคุณถึงควรลงทุนเวลา? เราได้ระบุประโยชน์หลักไว้ด้านล่างนี้:

สำหรับงานเดียวกัน Python มักจะต้องเขียนโค้ดน้อยกว่ามากเมื่อเปรียบเทียบกับ Java หรือ C++
Python มีไลบรารีที่ยอดเยี่ยมในตัว - ปรัชญา "แบตเตอรี่รวมอยู่ด้วย" ที่เรียกว่า
Python เข้าใจได้ง่าย; บางคนเชื่อว่ามันเหมือนกับการอ่านโค้ดลวง.
โดยการรวมเครื่องมือเช่น NumPy, Numba และ Cython มันกำลังเร็วขึ้นเรื่อยๆ

บทความที่จะตามมาจะเน้นที่ความเรียบง่ายมากกว่าการปรับแต่ง เราจะปฏิบัติตามปรัชญาของแดเนียล ดัฟฟี่ที่ว่า "ก่อนอื่นเราทำให้มันทำงานได้ จากนั้นเราทำให้มันถูกต้อง แล้วเราจึงปรับให้เหมาะสม" เพื่อให้บรรลุเป้าหมายนี้ เราจะมุ่งเน้นไปที่ไวยากรณ์ที่ชัดเจนและชัดเจนในตอนแรก มันควรจะชัดเจนว่าเราได้ไปจากอัลกอริธึมไปสู่การใช้งานจริงอย่างไร โดยมีการขบคิดน้อยที่สุด หลังจากที่เรามีโค้ดทำงานแล้ว เราสามารถตรวจสอบให้แน่ใจว่ามันสร้างค่าที่ถูกต้องได้ สุดท้าย เราสามารถปรับแต่งให้เหมาะสมและนำไปใช้งานจริงได้

สูตรการกำหนดราคาแบบ Black-Scholes

ได้มีการชี้แจงไว้แล้วว่าผู้อ่านควรคุ้นเคยกับสูตร Black-Scholes สำหรับการกำหนดราคา European Vanilla Calls และ Puts เพื่อความสมบูรณ์ ราคาของ European Vanilla Call, C(S,t) มีดังนี้ โดยที่ S คือสินทรัพย์อ้างอิง K คือราคาตีราคา

คืออัตราดอกเบี้ยปราศจากความเสี่ยง, T คือระยะเวลาจนถึงวันหมดอายุ r และ $σ$ คือความผันผวน (คงที่) ของสินทรัพย์อ้างอิง S (N อธิบายไว้ด้านล่าง):

$C (S, t) = S N (d_{1}) - K e^{- r T} N (d_{2})$

ด้วย $d_{1}$ และ $d_{2}$ ที่กำหนดไว้ดังนี้:

$d_{1} = \frac{l o g (S / K) + (r + \frac{σ^{2}}{2}) T}{σ \sqrt{T}}$

$d_{2} = d_{1} - σ \sqrt{T}$

ขอบคุณกฎความเท่าเทียมของออปชั่นซื้อขาย เราสามารถกำหนดราคาออปชั่นขายแบบวานิลลาของยุโรป P(S,t) ด้วยสูตรต่อไปนี้:

$P (S, t) = K e^{- r T} - S + C (S, t) = K e^{- r T} - S + (S N (d_{1}) - K e^{- r T} N (d_{2}))$

ฟังก์ชันที่เหลือที่เรายังไม่ได้อธิบายคือ N นี่คือฟังก์ชันการแจกแจงสะสมของการแจกแจงปกติแบบมาตรฐาน สูตรสำหรับ N คือ:

$N (x) = \frac{1}{\sqrt{2 π}} \int_{- \infty}^{x} e^{- t^{2} / 2} d t$

นอกจากนี้ เราต้องการให้มีวิธีแก้ปัญหาในรูปแบบปิดสำหรับ "Greeks" ซึ่งเป็นความไวของราคาออปชั่นต่อปัจจัยและพารามิเตอร์พื้นฐาน ด้วยเหตุนี้เราจึงต้องการสูตรสำหรับฟังก์ชันความหนาแน่นของความน่าจะเป็นของการแจกแจงปกติมาตรฐานซึ่งมีดังนี้:

$f (x) = \frac{1}{\sqrt{2 π}} e^{- x^{2} / 2}$

งานของเราตอนนี้คือการใช้ Python เพื่อดำเนินการฟังก์ชันเหล่านี้และให้ค่าแก่เราเพื่อหาค่าปิดของราคาของ European Vanilla Call หรือ Put พร้อมกับความไวที่เกี่ยวข้อง

การนำฟังก์ชันทางสถิติไปใช้ใน Python

เปิดไฟล์ Python ใหม่ใน IDE ที่คุณชื่นชอบและตั้งชื่อว่า statistics.py เราต้องการฟังก์ชันทางคณิตศาสตร์บางอย่าง ดังนั้นเราจะใช้ไลบรารี math และนำเข้าลอการิธึมธรรมชาติ ฟังก์ชันเอ็กซ์โพเนนเชียล และค่าคงที่ทางคณิตศาสตร์ $π$ :

from math import exp, log, pi

ฟังก์ชันแรกที่ต้องกำหนดคือฟังก์ชันความหนาแน่นของความน่าจะเป็นของการแจกแจงปกติแบบมาตรฐาน:

def norm_pdf(x):
    """
    Standard normal probability density function
    """
    return (1.0/((2*pi)**0.5))*exp(-0.5*x*x)

ฟังก์ชันนี้ค่อนข้างอธิบายตัวเองได้ดี ฟังก์ชันถัดไปที่จะเขียนโค้ดคือ CDF ของการแจกแจงปกติ อย่างไรก็ตาม มันมีการหาค่าปริพันธ์ที่มี $- \infty$ เป็นหนึ่งในขอบเขต - แล้วเราจะประมาณค่ามันบนคอมพิวเตอร์ได้อย่างไร? วิธีที่ใช้ (26.2.17) มาจากหนังสือเรียนที่มีชื่อเสียงของ Abramovitz & Stegun เกี่ยวกับฟังก์ชันทางคณิตศาสตร์ บทความในวิกิพีเดียเกี่ยวกับการแจกแจงปกติให้ข้อมูลเพิ่มเติมเกี่ยวกับวิธีการนี้และวิธีการอื่นๆ นี่คือรายการโค้ด Python สำหรับอัลกอริธึม:

def norm_cdf(x):
    """
    An approximation to the cumulative distribution
    function for the standard normal distribution:
    N(x) = \frac{1}{sqrt(2*\pi)} \int^x_{-\infty} e^{-\frac{1}{2}s^2} ds
    """
    k = 1.0/(1.0+0.2316419*x)
    k_sum = k * (0.319381530 + k * (-0.356563782 + \
        k * (1.781477937 + k * (-1.821255978 + 1.330274429 * k))))

    if x >= 0.0:
        return (1.0 - (1.0 / ((2 * pi)**0.5)) * exp(-0.5 * x * x) * k_sum)
    else:
        return 1.0 - norm_cdf(-x)

สังเกตว่าฟังก์ชันนี้เรียกตัวเองหาก x เป็นลบ

ตอนนี้เรามีฟังก์ชันทางสถิติสองตัวที่จำเป็นสำหรับการคำนวณราคาตัวเลือกแบบ European vanilla calls and puts

การใช้งาน Python สำหรับราคาหมายเรียก-หมายขายแบบยุโรปในรูปแบบปิด

เราต้องสร้างไฟล์ที่สอง ซึ่งเราจะเรียกว่า closed_form.py มันควรอยู่ในไดเรกทอรีไฟล์เดียวกับไฟล์ statistics.py เพื่อให้การนำเข้าตามไวยากรณ์ต่อไปนี้ทำงานได้อย่างถูกต้อง:

from math import exp, log, sqrt
from statistics import norm_pdf, norm_cfd

อ้างอิงกลับไปยังสูตร Black-Scholes สำหรับราคาของการโทร, C(S,t), เราสามารถเห็นได้ว่ามันต้องการฟังก์ชันแยกกันสองฟังก์ชันที่ชื่อ $d_{j}$ , $j \in {1, 2}$ . $d_{j}$ รับ S, T, K, r และ $σ$ (v ในโค้ด) เป็นอาร์กิวเมนต์ เป็นไปได้ที่จะเขียน $d_{j}$ เป็นฟังก์ชันเดียวที่รับพารามิเตอร์เพิ่มเติม j รหัสสำหรับฟังก์ชันนี้มีให้ด้านล่าง:

def d_j(j, S, K, r, v, T):
    """
    d_j = \frac{log(\frac{S}{K})+(r+(-1)^{j-1} \frac{1}{2}v^2)T}{v sqrt(T)}
    """
    return (log(S/K) + (r + ((-1)**(j-1))*0.5*v*v)*T)/(v*(T**0.5))

สิ่งที่เหลืออยู่ตอนนี้คือการเขียนโค้ดฟังก์ชันสำหรับ C(S,t) และ P(S,t) โค้ด Python สำหรับ C(S,t) มีดังนี้:

def vanilla_call_price(S, K, r, v, T):
    """
    Price of a European call option struck at K, with
    spot S, constant rate r, constant vol v (over the
    life of the option) and time to maturity T
    """
    return S * norm_cdf(d_j(1, S, K, r, v, T)) - \
        K*exp(-r*T) * norm_cdf(d_j(2, S, K, r, v, T))

สุดท้ายแล้ว รหัสสำหรับ P(S,t):

def vanilla_put_price(S, K, r, v, T):
    """
    Price of a European put option struck at K, with
    spot S, constant rate r, constant vol v (over the
    life of the option) and time to maturity T
    """
    return -S * norm_cdf(-d_j(1, S, K, r, v, T)) + \
        K*exp(-r*T) * norm_cdf(-d_j(2, S, K, r, v, T))

สิ่งนี้สรุปการเขียนโค้ดสูตรสำหรับฟังก์ชันการแจกแจงทางสถิติใน statistics.py และราคาตัวเลือกแบบว European vanilla ที่ปิดใน closed_form.py ในขั้นตอนนี้เป็นการรอบคอบที่จะตรวจสอบว่าอสมการให้ผลลัพธ์ที่ถูกต้องและเป็นไปตามขอบเขตที่รู้จักของราคา (เช่น Put-Call Parity) นั่นจะเป็นหัวข้อของบทความในอนาคต

อ้างอิง : European Vanilla Call-Put Option Pricing with Python

จาก https://www.quantstart.com/articles/European-Vanilla-Call-Put-Option-Pricing-with-Python/