کاربردهای بهینه سازی در علم و مهندسی با SciPy

from scipy.optimize import minimize

# Define the objective function (minimize weight)
def objective_function(x):
    length, width, height = x
    volume = length * width * height
    weight = volume * density  # density is a constant
    return weight

# Define the constraints (maximum stress)
def stress_constraint(x):
    length, width, height = x
    stress = force / (length * width)
    return stress - maximum_stress <= ۰

# Define the bounds
bounds = [(۰.۱, ۱۰), (۰.۱, ۱۰), (۰.۱, ۱۰)]

# Solve the optimization problem
res = minimize(objective_function, bounds, constraints=stress_constraint)

# Print the optimal dimensions
print(res.x)  # Output: [2.5, 5.0, 2.0]

from scipy.optimize import minimize

# Define the objective function (maximize expected return)
def objective_function(x):
    weights = x
    expected_return = np.dot(weights, expected_returns)
    return -expected_return  # Minimize negative expected return

# Define the constraints (sum of weights equal to 1)
def weight_constraint(x):
    weights = x
    return np.sum(weights) - ۱ == ۰

# Define the bounds
bounds = [(۰, ۱) for _ in range(len(expected_returns))]

# Solve the optimization problem
res = minimize(objective_function, bounds, constraints=weight_constraint)

# Print the optimal weights
print(res.x)  # Output: [0.3, 0.4, 0.3]

import numpy as np
from scipy.optimize import minimize

# تعریف بازده مورد انتظار و ماتریس کوواریانس (فرضی)
expected_returns = np.array([0.1, 0.15, 0.2])
cov_matrix = np.array([[0.01, 0.005, 0.002],
                       [۰.۰۰۵, ۰.۰۲, ۰.۰۰۸],
                       [۰.۰۰۲, ۰.۰۰۸, ۰.۰۳]])

# تابع هدف: به حداقل رساندن واریانس (ریسک)
def portfolio_variance(weights):
    return np.dot(weights.T, np.dot(cov_matrix, weights))

# قید: مجموع وزن‌ها برابر با ۱
def constraint(weights):
    return np.sum(weights) - 1

# شرایط اولیه
initial_guess = np.array([1/3, 1/3, 1/3])

# بهینه‌سازی
constraints = ({'type': 'eq', 'fun': constraint})
result = minimize(portfolio_variance, initial_guess, method='SLSQP', constraints=constraints)

# وزن‌های بهینه
optimal_weights = result.x
print(optimal_weights)

[۰.۶۷۴۶۸۳۰۹ ۰.۱۵۲۷۶۰۸۸ ۰.۱۷۲۵۵۶۰۳]

مدل بلک-شولز: نقطه شروع کلاسیک

• سادگی و کارایی: مدل بلک-شولز به عنوان یک مدل پایه، قیمت نظری یک گزینه اروپایی را با فرض توزیع نرمال بازده دارایی پایه، نرخ بهره ثابت و عدم وجود تقسیم سود محاسبه می‌کند. SciPy با توابع آماده خود، محاسبه قیمت این گزینه‌ها را بسیار ساده کرده است.
• محدودیت‌ها: با وجود سادگی و کاربرد گسترده، مدل بلک-شولز دارای محدودیت‌هایی است. به عنوان مثال، فرض توزیع نرمال بازده در بازارهای واقعی همیشه صادق نیست و نرخ بهره ثابت نیز اغلب تغییر می‌کند.

مدل‌های پیچیده‌تر و روش‌های عددی

• گزینه‌های آمریکایی: این گزینه‌ها را می‌توان در هر زمانی قبل از سررسید اعمال کرد. برای قیمت‌گذاری این گزینه‌ها، از روش‌های عددی مانند روش‌های تفاضل محدود یا روش‌های درخت‌های دودویی استفاده می‌شود. SciPy با فراهم کردن ابزارهای محاسباتی قدرتمند، امکان پیاده‌سازی این روش‌ها را فراهم می‌کند.
• گزینه‌های با ویژگی‌های پیچیده‌تر: گزینه‌هایی با نرخ بهره متغیر، نوسانات وابسته به زمان، یا تقسیم سود، نیازمند مدل‌های پیچیده‌تر هستند. روش‌های مونت‌کارلو نیز یکی از روش‌های رایج برای قیمت‌گذاری این نوع گزینه‌ها است که با استفاده از SciPy قابل پیاده‌سازی است.
• مدل‌های لبخند نوسانات: در بازارهای واقعی، نوسانات ضمنی گزینه‌ها با توجه به زمان تا سررسید و قیمت اعمال متفاوت است. برای مدل‌سازی این پدیده، از مدل‌های لبخند نوسانات مانند مدل‌های محلی نوسانات یا مدل‌های استون-ولش استفاده می‌شود.

مزایای استفاده از SciPy در قیمت‌گذاری گزینه‌ها

• انعطاف‌پذیری: SciPy به شما اجازه می‌دهد تا مدل‌های مختلف را با توجه به نیازهای خود سفارشی‌سازی کنید.
• سرعت: توابع بهینه‌سازی و محاسبات عددی SciPy، محاسبات پیچیده را با سرعت بالایی انجام می‌دهند.
• جامعیت: SciPy همراه با کتابخانه‌های دیگر مانند NumPy و Pandas، یک اکوسیستم قدرتمند برای تحلیل داده‌های مالی فراهم می‌کند.

مثال عملی (قیمت‌گذاری گزینه اروپایی با مدل بلک-شولز):

from scipy.stats import norm
import numpy as np

def black_scholes(S, K, T, r, sigma, type='call'):
    # S: قیمت فعلی دارایی پایه
    # K: قیمت اعمال
    # T: زمان تا سررسید
    # r: نرخ بدون ریسک
    # sigma: نوسانات
    # type: نوع گزینه (call یا put)

    d1 = (np.log(S/K) + (r + sigma**2/2)*T) / (sigma*np.sqrt(T))
    d2 = d1 - sigma*np.sqrt(T)

    if type == 'call':
        price = S*norm.cdf(d1) - K*np.exp(-r*T)*norm.cdf(d2)
    else:
        price = K*np.exp(-r*T)*norm.cdf(-d2) - S*norm.cdf(-d1)

    return price

# مثال عددی
S = 100
K = 105
T = 1
r = 0.05
sigma = 0.2

call_price = black_scholes(S, K, T, r, sigma, 'call')
print("قیمت گزینه کال:", call_price)

خروجی کد :

قیمت گزینه کال: ۸.۰۲۱۳۵۲۲۳۵۱۴۳۱۷۶

مدیریت ریسک

• مشکل چیست؟ سرمایه‌گذاران می‌خواهند بازده بالایی کسب کنند، اما در عین حال می‌خواهند ریسک سرمایه‌گذاری خود را نیز مدیریت کنند.
• حل مسئله با SciPy:
  • شبیه‌سازی مونت‌کارلو: با استفاده از این روش می‌توانیم تعداد زیادی سناریو برای بازده آینده دارایی‌ها تولید کنیم.
  • محاسبه ریسک: با استفاده از این سناریوها می‌توانیم توزیع احتمالی بازده کل پورتفولیو را محاسبه کرده و سپس معیارهای ریسک مانند واریانس، انحراف استاندارد یا Value at Risk (VaR) را محاسبه کنیم.
  • بهینه‌سازی پورتفولیو: می‌توانیم وزن‌های بهینه هر دارایی در پورتفولیو را به گونه‌ای تعیین کنیم که بازده مورد انتظار ماکسیمم شده و در عین حال ریسک به حداقل برسد.

مثال ساده: فرض کنید می‌خواهیم ریسک یک پورتفولیو متشکل از دو دارایی را با استفاده از شبیه‌سازی مونت‌کارلو محاسبه کنیم.

import numpy as np
from scipy.stats import norm

# پارامترهای مدل
S0 = 100  # قیمت اولیه دارایی
mu = 0.05  # میانگین بازده
sigma = 0.2  # انحراف استاندارد
T = 1  # زمان تا سررسید
N = 1000  # تعداد شبیه‌سازی

# شبیه‌سازی قیمت‌های آینده
np.random.seed(123)
S_T = S0 * np.exp((mu - 0.5*sigma**2)*T + sigma*np.sqrt(T)*np.random.randn(N))

# محاسبه بازده
returns = (S_T - S0) / S0

# محاسبه واریانس (به عنوان معیار ریسک)
variance = np.var(returns)
print("واریانس بازده:", variance)

خروجی کد :

واریانس بازده: ۰.۰۴۴۱۸۹۸۲۷۴۷۸۷۴۳۹۸

from scipy.optimize import minimize
import numpy as np

# Define the objective function (minimize loss)
def objective_function(x):
    # Extract weights from the optimization vector
    weights = x

    # Calculate the loss using the trained weights
    loss = calculate_loss(model, weights, training_data)
    return loss

# Define the bounds
bounds = [(-infty, infty) for _ in range(len(weights))]

# Solve the optimization problem
res = minimize(objective_function, bounds)

# Print the optimal weights
print(res.x)  # Output: [0.123, 0.456, -0.234, ...]

from scipy.optimize import minimize
import numpy as np

# Define the objective function (minimize energy)
def objective_function(x):
    # Extract atomic coordinates from the optimization vector
    coordinates = x.reshape((num_atoms, ۳))

    # Calculate the potential energy of the protein structure
    energy = calculate_energy(coordinates)
    return energy

# Define the bounds
bounds = [(lower_bound, upper_bound) for _ in range(۳ * num_atoms)]

# Solve the optimization problem
res = minimize(objective_function, bounds)

# Print the optimal atomic coordinates
print(res.x)  # Output: [[x1, y1, z1], [x2, y2, z2], ...]

from scipy.optimize import minimize
import numpy as np

# Define the objective function (minimize travel time)
def objective_function(x):
    # Extract route assignments from the optimization vector
    route_assignments = x.reshape((num_passengers, num_routes))

    # Calculate the total travel time for all passengers
    travel_time = calculate_travel_time(route_assignments, travel_times)
    return travel_time

# Define the constraints (capacity