Khi thị trường tiền mã hóa biến động mạnh, việc đánh giá chính xác rủi ro danh mục quyền chọn là yếu tố sống còn. Bài viết này sẽ hướng dẫn bạn xây dựng hệ thống phân tích Greek Letters (Delta, Gamma, Vega, Theta, Rho) bằng Python, kết hợp API từ HolySheep AI — nền tảng với độ trễ dưới 50ms và hỗ trợ thanh toán WeChat/Alipay.

So Sánh Các Giải Pháp API Cho Phân Tích Quyền Chọn

Tiêu chíHolySheep AIAPI Binance Chính thứcCác Dịch Vụ Relay
Giá GPT-4.1$8/MTok$8/MTok$15-30/MTok
Độ trễ trung bình<50ms100-300ms200-500ms
Thanh toánWeChat/Alipay, USDTChỉ USDTUSD thường
Tỷ giá¥1 ≈ $1Phí chuyển đổiPhí 5-15%
Tín dụng miễn phíCó khi đăng kýKhôngKhông

Greek Letters Là Gì Và Tại Sao Quan Trọng?

Trong giao dịch quyền chọn, Greek Letters đo lường mức độ nhạy cảm của giá quyền chọn với các yếu tố thị trường:

Xây Dựng Hệ Thống Phân Tích Với HolySheep AI

Cài Đặt Môi Trường

# Cài đặt thư viện cần thiết
pip install requests pandas numpy scipy httpx


Hoặc sử dụng Poetry

poetry add requests pandas numpy scipy httpx

Module Tính Toán Greek Letters

import requests
import math
from typing import Dict, List, Optional
from dataclasses import dataclass
from datetime import datetime


Cấu hình HolySheep AI API

HOLYSHEEP_API_KEY = "YOUR_HOLYSHEEP_API_KEY"
HOLYSHEEP_BASE_URL = "https://api.holysheep.ai/v1"

@dataclass
class OptionContract:
    """Cấu trúc hợp đồng quyền chọn Binance"""
    symbol: str
    strike_price: float
    expiry_date: datetime
    option_type: str  # 'call' hoặc 'put'
    position_size: float  # Số hợp đồng (dương = long, âm = short)
    premium: float
    implied_volatility: float
    spot_price: float

class BlackScholesCalculator:
    """Tính toán Black-Scholes và Greek Letters"""
    
    def __init__(self, risk_free_rate: float = 0.05):
        self.r = risk_free_rate
    
    def normal_cdf(self, x: float) -> float:
        """Hàm phân phối tích lũy chuẩn (CDF)"""
        return 0.5 * (1 + math.erf(x / math.sqrt(2)))
    
    def normal_pdf(self, x: float) -> float:
        """Hàm mật độ xác suất chuẩn (PDF)"""
        return math.exp(-0.5 * x * x) / math.sqrt(2 * math.pi)
    
    def d1_d2(self, S: float, K: float, T: float, r: float, sigma: float) -> tuple:
        """Tính d1 và d2 cho Black-Scholes"""
        d1 = (math.log(S / K) + (r + 0.5 * sigma ** 2) * T) / (sigma * math.sqrt(T))
        d2 = d1 - sigma * math.sqrt(T)
        return d1, d2
    
    def calculate_greeks(self, option: OptionContract) -> Dict[str, float]:
        """Tính toán tất cả Greek Letters cho một quyền chọn"""
        S = option.spot_price
        K = option.strike_price
        T = (option.expiry_date - datetime.now()).days / 365.0
        r = self.r
        sigma = option.implied_volatility
        
        # Xử lý T gần bằng 0
        if T <= 0:
            return {'delta': 0, 'gamma': 0, 'vega': 0, 'theta': 0, 'rho': 0}
        
        d1, d2 = self.d1_d2(S, K, T, r, sigma)
        
        if option.option_type.lower() == 'call':
            delta = self.normal_cdf(d1)
            theta = (-S * sigma * self.normal_pdf(d1) / (2 * math.sqrt(T))
                    - r * K * math.exp(-r * T) * self.normal_cdf(d2)) / 365
            rho = K * T * math.exp(-r * T) * self.normal_cdf(d2) / 100
        else:  # put
            delta = self.normal_cdf(d1) - 1
            theta = (-S * sigma * self.normal_pdf(d1) / (2 * math.sqrt(T))
                    + r * K * math.exp(-r * T) * self.normal_cdf(-d2)) / 365
            rho = -K * T * math.exp(-r * T) * self.normal_cdf(-d2) / 100
        
        gamma = self.normal_pdf(d1) / (S * sigma * math.sqrt(T))
        vega = S * self.normal_pdf(d1) * math.sqrt(T) / 100
        
        return {
            'delta': delta * option.position_size,
            'gamma': gamma * option.position_size,
            'vega': vega * option.position_size,
            'theta': theta * option.position_size,
            'rho': rho * option.position_size
        }


Ví dụ sử dụng

calculator = BlackScholesCalculator(risk_free_rate=0.04)

sample_option = OptionContract(
    symbol="BTC",
    strike_price=45000,
    expiry_date=datetime(2025, 3, 28),
    option_type="call",
    position_size=1.0,
    premium=2500,
    implied_volatility=0.65,
    spot_price=44000
)

greeks = calculator.calculate_greeks(sample_option)
print(f"Portfolio Greeks: {greeks}")

Module Gọi API Binance Qua HolySheep AI

import httpx
import asyncio
from typing import List, Dict, Any
import json

class BinanceOptionsFetcher:
    """Lấy dữ liệu quyền chọn Binance thông qua HolySheep AI"""
    
    def __init__(self, api_key: str):
        self.api_key = api_key
        self.base_url = HOLYSHEEP_BASE_URL
        self.client = httpx.AsyncClient(timeout=30.0)
    
    async def get_options_data(self, symbol: str = "BTC") -> Dict[str, Any]:
        """Lấy dữ liệu quyền chọn từ Binance API thông qua HolySheep proxy"""
        
        # Sử dụng HolySheep AI để phân tích và lọc dữ liệu
        prompt = f"""
        Phân tích dữ liệu quyền chọn {symbol} từ Binance:
        1. Liệt kê 10 quyền chọn call và 10 quyền chọn put có khối lượng giao dịch cao nhất
        2. Tính delta trung bình của các quyền chọn ATM (strike gần spot price)
        3. Ước tính portfolio Greeks (Delta, Gamma, Vega, Theta) dựa trên dữ liệu thị trường
        
        Trả về JSON format với các trường: symbol, strike, expiry, type, iv, volume, delta, gamma, vega, theta
        """
        
        payload = {
            "model": "gpt-4.1",
            "messages": [
                {
                    "role": "user",
                    "content": prompt
                }
            ],
            "temperature": 0.3,
            "max_tokens": 2000
        }
        
        headers = {
            "Authorization": f"Bearer {self.api_key}",
            "Content-Type": "application/json"
        }
        
        try:
            response = await self.client.post(
                f"{self.base_url}/chat/completions",
                headers=headers,
                json=payload
            )
            response.raise_for_status()
            result = response.json()
            
            # Parse kết quả từ AI response
            content = result['choices'][0]['message']['content']
            
            # Trích xuất JSON từ response
            if "```json" in content:
                json_start = content.find("```json") + 7
                json_end = content.find("```", json_start)
                json_content = content[json_start:json_end].strip()
            else:
                json_content = content
            
            return json.loads(json_content)
            
        except httpx.HTTPStatusError as e:
            return {"error": f"HTTP error: {e.response.status_code}"}
        except Exception as e:
            return {"error": str(e)}
    
    async def analyze_portfolio_risk(self, options_list: List[Dict]) -> Dict[str, Any]:
        """Phân tích rủi ro toàn bộ portfolio"""
        
        calculator = BlackScholesCalculator(risk_free_rate=0.04)
        
        total_greeks = {
            'delta': 0.0,
            'gamma': 0.0,
            'vega': 0.0,
            'theta': 0.0,
            'rho': 0.0
        }
        
        position_analysis = []
        
        for opt in options_list:
            option = OptionContract(
                symbol=opt['symbol'],
                strike_price=opt['strike'],
                expiry_date=datetime.fromisoformat(opt['expiry']),
                option_type=opt['type'],
                position_size=opt.get('size', 1.0),
                premium=opt.get('premium', 0),
                implied_volatility=opt['iv'],
                spot_price=opt.get('spot', 0)
            )
            
            greeks = calculator.calculate_greeks(option)
            position_analysis.append({
                'symbol': opt['symbol'],
                'strike': opt['strike'],
                'greeks': greeks
            })
            
            for key in total_greeks:
                total_greeks[key] += greeks[key]
        
        return {
            'portfolio_greeks': total_greeks,
            'positions': position_analysis,
            'timestamp': datetime.now().isoformat()
        }
    
    async def close(self):
        """Đóng HTTP client"""
        await self.client.aclose()


Sử dụng

async def main():
    fetcher = BinanceOptionsFetcher(api_key=HOLYSHEEP_API_KEY)
    
    # Lấy dữ liệu quyền chọn BTC
    options_data = await fetcher.get_options_data("BTC")
    
    if "error" not in options_data:
        risk_analysis = await fetcher.analyze_portfolio_risk(options_data)
        print(f"Portfolio Greeks: {json.dumps(risk_analysis['portfolio_greeks'], indent=2)}")
    else:
        print(f"Lỗi: {options_data['error']}")
    
    await fetcher.close()


Chạy

asyncio.run(main())

Tính Toán Rủi Ro Delta-Neutral

Chiến lược Delta-Neutral nhằm mục đích cân bằng tổng Delta về gần 0 để loại bỏ rủi ro từ biến động giá tài sản cơ sở:

import numpy as np
from scipy.optimize import minimize

class DeltaNeutralStrategy:
    """Chiến lược Delta-Neutral cho portfolio quyền chọn"""
    
    def __init__(self, calculator: BlackScholesCalculator):
        self.calculator = calculator
    
    def calculate_portfolio_delta(
        self, 
        options: List[OptionContract], 
        spot_price: float
    ) -> float:
        """Tính tổng Delta của portfolio"""
        total_delta = 0.0
        for opt in options:
            opt.spot_price = spot_price
            greeks = self.calculator.calculate_greeks(opt)
            total_delta += greeks['delta']
        return total_delta
    
    def find_hedge_ratio(
        self, 
        target_delta: float,
        current_options: List[OptionContract],
        hedge_option: OptionContract,
        spot_price: float
    ) -> float:
        """
        Tìm số lượng hợp đồng cần hedge để đạt delta-neutral
        
        Args:
            target_delta: Delta mục tiêu (thường = 0)
            current_options: Danh sách quyền chọn hiện có
            hedge_option: Quyền chọn dùng để hedge
            spot_price: Giá spot hiện tại
        
        Returns:
            Số lượng hợp đồng hedge cần thiết
        """
        # Tính delta hiện tại của portfolio
        portfolio_delta = self.calculate_portfolio_delta(current_options, spot_price)
        
        # Tính delta của mỗi đơn vị hedge option
        hedge_option.spot_price = spot_price
        hedge_greeks = self.calculator.calculate_greeks(hedge_option)
        hedge_delta_per_unit = hedge_greeks['delta']
        
        if hedge_delta_per_unit == 0:
            return 0
        
        # Số lượng cần hedge = (target - current) / hedge_delta_per_unit
        needed_hedge = (target_delta - portfolio_delta) / hedge_delta_per_unit
        
        return -needed_hedge  # Âm vì hedge ngược direction
    
    def backtest_delta_neutral(
        self,
        options: List[OptionContract],
        spot_prices: np.ndarray,
        rebalance_freq: int = 1
    ) -> Dict[str, np.ndarray]:
        """
        Backtest chiến lược Delta-Neutral
        
        Args:
            options: Danh sách quyền chọn ban đầu
            spot_prices: Mảng giá spot theo thời gian
            rebalance_freq: Tần suất rebalance (ngày)
        """
        n_steps = len(spot_prices)
        portfolio_values = np.zeros(n_steps)
        deltas = np.zeros(n_steps)
        hedge_ratios = np.zeros(n_steps)
        
        current_options = options.copy()
        
        for i, spot in enumerate(spot_prices):
            # Cập nhật spot price cho tất cả options
            for opt in current_options:
                opt.spot_price = spot
            
            # Tính portfolio delta
            current_delta = self.calculate_portfolio_delta(current_options, spot)
            deltas[i] = current_delta
            
            # Rebalance nếu đủ điều kiện
            if i % rebalance_freq == 0 and i > 0:
                # Tính P&L từ option
                pnl = sum(
                    self.calculator.calculate_greeks(opt)['delta'] * (spot - prev_spot)
                    for opt, prev_spot in zip(current_options, spot_prices[:i])
                )
                portfolio_values[i] = portfolio_values[i-1] + pnl
                
                # Recalculate hedge ratio
                if current_options:
                    hedge = current_options[0]
                    hedge_ratios[i] = self.find_hedge_ratio(0, current_options[1:], hedge, spot)
            else:
                portfolio_values[i] = portfolio_values[i-1] if i > 0 else 0
        
        return {
            'portfolio_value': portfolio_values,
            'deltas': deltas,
            'hedge_ratios': hedge_ratios,
            'final_pnl': portfolio_values[-1],
            'sharpe_ratio': np.mean(portfolio_values) / np.std(portfolio_values) if np.std(portfolio_values) > 0 else 0
        }


Ví dụ sử dụng

strategy = DeltaNeutralStrategy(BlackScholesCalculator())


Tạo danh sách options mẫu

sample_options = [
    OptionContract("BTC", 44000, datetime(2025, 3, 28), "call", 2.0, 2500, 0.65, 44000),
    OptionContract("BTC", 45000, datetime(2025, 3, 28), "call", -1.5, 2000, 0.60, 44000),
    OptionContract("BTC", 43000, datetime(2025, 3, 28), "put", 1.0, 1800, 0.70, 44000),
]


Tính hedge ratio

hedge_option = OptionContract("BTC", 44000, datetime(2025, 3, 28), "put", 1.0, 2200, 0.65, 44000)
hedge_needed = strategy.find_hedge_ratio(0, sample_options, hedge_option, 44000)

print(f"Cần {hedge_needed:.4f} hợp đồng put ATM để delta-neutral")

Dashboard Trực Quan Hóa Rủi Ro

import matplotlib.pyplot as plt
from matplotlib.figure import Figure
import base64
from io import BytesIO

class RiskDashboard:
    """Tạo dashboard trực quan cho phân tích rủi ro Greek Letters"""
    
    def __init__(self, calculator: BlackScholesCalculator):
        self.calculator = calculator
    
    def generate_risk_report(
        self, 
        options: List[OptionContract],
        spot_range: tuple = (35000, 55000),
        iv_range: tuple = (0.3, 1.0)
    ) -> str:
        """Tạo báo cáo rủi ro dạng HTML với biểu đồ"""
        
        fig = Figure(figsize=(16, 12))
        
        # 1. Delta vs Spot Price
        ax1 = fig.add_subplot(2, 3, 1)
        spot_prices = np.linspace(spot_range[0], spot_range[1], 100)
        for opt in options:
            deltas = []
            for spot in spot_prices:
                opt.spot_price = spot
                greeks = self.calculator.calculate_greeks(opt)
                deltas.append(greeks['delta'])
            ax1.plot(spot_prices, deltas, label=f"{opt.option_type} {opt.strike_price}")
        ax1.set_xlabel('Spot Price ($)')
        ax1.set_ylabel('Delta')
        ax1.set_title('Delta vs Spot Price')
        ax1.legend()
        ax1.grid(True, alpha=0.3)
        ax1.axhline(y=0, color='black', linestyle='--', alpha=0.5)
        
        # 2. Gamma vs Spot Price
        ax2 = fig.add_subplot(2, 3, 2)
        for opt in options:
            gammas = []
            for spot in spot_prices:
                opt.spot_price = spot
                greeks = self.calculator.calculate_greeks(opt)
                gammas.append(greeks['gamma'])
            ax2.plot(spot_prices, gammas, label=f"{opt.option_type} {opt.strike_price}")
        ax2.set_xlabel('Spot Price ($)')
        ax2.set_ylabel('Gamma')
        ax2.set_title('Gamma vs Spot Price')
        ax2.legend()
        ax2.grid(True, alpha=0.3)
        
        # 3. Vega vs IV
        ax3 = fig.add_subplot(2, 3, 3)
        ivs = np.linspace(iv_range[0], iv_range[1], 50)
        for opt in options:
            vegas = []
            for iv in ivs:
                opt.implied_volatility = iv
                greeks = self.calculator.calculate_greeks(opt)
                vegas.append(greeks['vega'])
            ax3.plot(ivs * 100, vegas, label=f"{opt.option_type} {opt.strike_price}")
        ax3.set_xlabel('Implied Volatility (%)')
        ax3.set_ylabel('Vega')
        ax3.set_title('Vega vs IV')
        ax3.legend()
        ax3.grid(True, alpha=0.3)
        
        # 4. Portfolio Greeks Summary
        ax4 = fig.add_subplot(2, 3, 4)
        total_greeks = {'Delta': 0, 'Gamma': 0, 'Vega': 0, 'Theta': 0, 'Rho': 0}
        for opt in options:
            greeks = self.calculator.calculate_greeks(opt)
            total_greeks['Delta'] += greeks['delta']
            total_greeks['Gamma'] += greeks['gamma']
            total_greeks['Vega'] += greeks['vega']
            total_greeks['Theta'] += greeks['theta']
            total_greeks['Rho'] += greeks['rho']
        
        colors = ['#3498db', '#e74c3c', '#2ecc71', '#f39c12', '#9b59b6']
        bars = ax4.bar(total_greeks.keys(), total_greeks.values(), color=colors)
        ax4.set_title('Portfolio Greeks Summary')
        ax4.set_ylabel('Value')
        ax4.grid(True, alpha=0.3, axis='y')
        
        for bar, value in zip(bars, total_greeks.values()):
            height = bar.get_height()
            ax4.text(bar.get_x() + bar.get_width()/2., height,
                    f'{value:.2f}', ha='center', va='bottom', fontsize=9)
        
        # 5. P&L Scenarios
        ax5 = fig.add_subplot(2, 3, 5)
        pnl_by_move = {'+10%': 0, '+5%': 0, '0%': 0, '-5%': 0, '-10%': 0}
        current_spot = options[0].spot_price if options else 44000
        
        for pct, label in [(0.10, '+10%'), (0.05, '+5%'), (0, '0%'), 
                          (-0.05, '-5%'), (-0.10, '-10%')]:
            new_spot = current_spot * (1 + pct)
            pnl = 0
            for opt in options:
                opt.spot_price = new_spot
                greeks = self.calculator.calculate_greeks(opt)
                pnl += greeks['delta'] * current_spot * pct
            pnl_by_move[label] = pnl
        
        ax5.bar(pnl_by_move.keys(), pnl_by_move.values(), color=['green' if v > 0 else 'red' for v in pnl_by_move.values()])
        ax5.set_title('P&L Scenarios')
        ax5.set_ylabel('Estimated P&L ($)')
        ax5.grid(True, alpha=0.3, axis='y')
        
        # 6. Risk Metrics
        ax6 = fig.add_subplot(2, 3, 6)
        ax6.axis('off')
        
        # Tính VaR đơn giản
        returns_std = np.std(list(pnl_by_move.values()))
        var_95 = 1.645 * returns_std
        
        metrics_text = f"""
        ╔══════════════════════════════════════╗
        ║       PORTFOLIO RISK METRICS         ║
        ╠══════════════════════════════════════╣
        ║ Total Delta: {total_greeks['Delta']:>12.4f}         ║
        ║ Total Gamma: {total_greeks['Gamma']:>12.4f}         ║
        ║ Total Vega:  {total_greeks['Vega']:>12.4f}         ║
        ║ Total Theta: {total_greeks['Theta']:>12.4f}         ║
        ╠══════════════════════════════════════╣
        ║ VaR (95%):    ${abs(var_95):>12,.2f}         ║
        ║ Max Loss:     ${min(pnl_by_move.values()):>12,.2f}         ║
        ║ Max Gain:     ${max(pnl_by_move.values()):>12,.2f}         ║
        ╚══════════════════════════════════════╝
        """
        ax6.text(0.1, 0.5, metrics_text, fontsize=10, family='monospace',
                verticalalignment='center', transform=ax6.transAxes,
                bbox=dict(boxstyle='round', facecolor='wheat', alpha=0.5))
        
        plt.tight_layout()
        
        # Convert to base64
        buf = BytesIO()
        fig.savefig(buf, format='png', dpi=150, bbox_inches='tight')
        buf.seek(0)
        img_base64 = base64.b64encode(buf.read()).decode('utf-8')
        buf.close()
        
        return img_base64


Sử dụng dashboard

dashboard = RiskDashboard(BlackScholesCalculator())
chart_image = dashboard.generate_risk_report(sample_options)

html_report = f"""
<html>
<head>
    <title>Portfolio Risk Report - Greek Letters Analysis</title>
    <style>
        body {{ font-family: Arial, sans-serif; margin: 20px; }}
        .container {{ max-width: 1200px; margin: 0 auto; }}
        h1 {{ color: #2c3e50; }}
        .chart {{ text-align: center; margin: 20px 0; }}
    </style>
</head>
<body>
    <div class="container">
        <h1>Portfolio Risk Report - Greek Letters Analysis</h1>
        <p>Generated: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}</p>
        <div class="chart">
            <img src="data:image/png;base64,{chart_image}" alt="Risk Dashboard">
        </div>
    </div>
</body>
</html>
"""

print("Dashboard HTML đã được tạo thành công!")

Lỗi Thường Gặp Và Cách Khắc Phục

1. Lỗi "401 Unauthorized" Khi Gọi HolySheep API

# ❌ SAI - Key không đúng định dạng
headers = {
    "Authorization": f"Bearer YOUR_HOLYSHEEP_API_KEY",  # Sai!
    "Content-Type": "application/json"
}


✅ ĐÚNG - Sử dụng biến môi trường

import os
HOLYSHEEP_API_KEY = os.environ.get("HOLYSHEEP_API_KEY")

headers = {
    "Authorization": f"Bearer {HOLYSHEEP_API_KEY}",
    "Content-Type": "application/json"
}


Kiểm tra key hợp lệ

if not HOLYSHEEP_API_KEY or len(HOLYSHEEP_API_KEY) < 20:
    raise ValueError("API Key không hợp lệ. Vui lòng kiểm tra tại https://www.holysheep.ai/register")

Nguyên nhân: API key bị hardcode hoặc chưa được export đúng cách. Giải pháp: Sử dụng biến môi trường và kiểm tra độ dài key.

2. Lỗi "Rate Limit Exceeded" Khi Gọi API Liên Tục

import time
from functools import wraps

def rate_limit(max_calls: int = 60, period: int = 60):
    """Decorator để giới hạn số lần gọi API"""
    def decorator(func):
        calls = []
        def wrapper(*args, **kwargs):
            now = time.time()
            # Loại bỏ các request cũ hơn period giây
            calls[:] = [t for t in calls if now - t < period]
            
            if len(calls) >= max_calls:
                sleep_time = period - (now - calls[0])
                if sleep_time > 0:
                    print(f"Rate limit reached. Sleeping {sleep_time:.2f}s...")
                    time.sleep(sleep_time)
            
            calls.append(now)
            return func(*args, **kwargs)
        return wrapper
    return decorator


Áp dụng cho API call

@rate_limit(max_calls=30, period=60)  # 30 calls mỗi 60 giây
async def get_options_with_retry(symbol: str, max_retries: int = 3):
    """Lấy dữ liệu options với retry logic"""
    
    for attempt in range(max_retries):
        try:
            response = await client.post(
                f"{HOLYSHEEP_BASE_URL}/chat/completions",
                headers=headers,
                json=payload
            )
            
            if response.status_code == 429:
                wait_time = 2 ** attempt  # Exponential backoff
                print(f"Rate limited. Waiting {wait_time}s...")
                await asyncio.sleep(wait_time)
                continue
                
            response.raise_for_status()
            return response.json()
            
        except httpx.HTTPStatusError as e:
            if attempt == max_retries - 1:
                raise
            await asyncio.sleep(1)
    
    return None

Nguyên nhân: Gọi API quá nhiều lần trong thời gian ngắn. Giải pháp: Sử dụng caching và exponential backoff.

3. Lỗi Tính Toán Greek Letters Với T ≈ 0

# ❌ SAI - Không xử lý edge case
def calculate_greeks_unsafe(option):
    T = (option.expiry_date - datetime.now()).days / 365.0
    d1 = (math.log(S / K) + (r + 0.5 * sigma ** 2) * T) / (sigma * math.sqrt(T))
    # Khi T = 0: division by zero!


✅ ĐÚNG - Xử lý đầy đủ edge cases

def calculate_greeks_safe(option, spot_price: float) -> Dict[str, float]:
    """Tính Greek Letters với xử lý edge cases"""
    
    T = (option.expiry_date - datetime.now()).total_seconds() / (365.25 * 24 * 3600)
    
    # Xử lý các edge cases
    if T <= 0:
        # Quyền chọn đã hết hạn hoặc sắp hết hạn
        if option.option_type == 'call':
            intrinsic = max(spot_price - option.strike_price, 0)
        else:
            intrinsic = max(option.strike_price - spot_price, 0)
        
        return {
            'delta': 1.0 if option.option_type == 'call' and spot_price > option.strike_price else 
                     (-1.0 if option.option_type == 'put' and spot_price < option.strike_price else 0),
            'gamma': 0.0,
            'vega': 0.0,
            'theta': -intrinsic,  # Mất toàn bộ giá trị
            'rho': 0.0
        }
    
    # Xử lý IV = 0
    if option.implied_volatility <= 0:
        return {
            'delta': 1.0 if option.option_type == 'call' else -1.0,
            'gamma': 0.0,
            'vega': 0.0,
            'theta': 0.0,
            'rho': 0.0
        }

Tài nguyên liên quan
Bài viết liên quan