def test_dtype(self, dtype):
liability = EuropeanOption(BrownianStock(dtype=dtype))
assert liability.dtype == dtype
liability.simulate()
assert liability.payoff().dtype == dtype
liability = EuropeanOption(BrownianStock()).to(dtype=dtype)
liability.simulate()
assert liability.payoff().dtype == dtype
def test_compute_loss(self):
torch.manual_seed(42)
deriv = EuropeanOption(BrownianStock())
hedger = Hedger(Naked(),
["log_moneyness", "expiry_time", "volatility"])
result = hedger.compute_loss(deriv)
expect = EntropicRiskMeasure()(-deriv.payoff())
assert torch.allclose(result, expect)
def test_repr(self):
liability = EuropeanOption(BrownianStock(), maturity=1.0)
expect = "EuropeanOption(BrownianStock(...), maturity=1.00e+00)"
assert repr(liability) == expect
liability = EuropeanOption(BrownianStock(), maturity=1.0, call=False)
expect = "EuropeanOption(BrownianStock(...), call=False, maturity=1.00e+00)"
assert repr(liability) == expect
liability = EuropeanOption(BrownianStock(), maturity=1.0, strike=2.0)
expect = "EuropeanOption(BrownianStock(...), strike=2.0, maturity=1.00e+00)"
assert repr(liability) == expect
def test_payoff(self):
liability = EuropeanOption(BrownianStock(), strike=2.0)
liability.underlier.prices = torch.tensor([
[1.0, 1.0, 1.0, 1.0],
[1.0, 1.0, 1.0, 1.0],
[1.9, 2.0, 2.1, 3.0],
])
result = liability.payoff()
expect = torch.tensor([0.0, 0.0, 0.1, 1.0])
assert torch.allclose(result, expect)
def test_compute_pnl(self):
torch.manual_seed(42)
deriv = EuropeanOption(BrownianStock())
hedger = Hedger(Naked(), ["zero"])
pnl = hedger.compute_pnl(deriv)
payoff = deriv.payoff()
assert torch.allclose(pnl, -payoff)
result = hedger.compute_pnl(deriv)
expect = -deriv.payoff()
assert torch.allclose(result, expect)
def test_shape(self):
torch.distributions.Distribution.set_default_validate_args(False)
deriv = EuropeanOption(BrownianStock())
N = 2
M_1 = 5
M_2 = 6
H_in = 3
x = torch.empty((N, M_1, M_2, H_in))
m = Hedger(MultiLayerPerceptron(), ["zero"])
assert m(x).size() == torch.Size((N, M_1, M_2, 1))
model = BlackScholes(deriv)
m = Hedger(model, model.features())
x = torch.empty((N, M_1, M_2, len(model.features())))
assert m(x).size() == torch.Size((N, M_1, M_2, 1))
model = WhalleyWilmott(deriv)
m = Hedger(model, model.features())
x = torch.empty((N, M_1, M_2, len(model.features())))
assert m(x).size() == torch.Size((N, M_1, M_2, 1))
model = Naked()
m = Hedger(model, ["zero"])
x = torch.empty((N, M_1, M_2, 10))
assert m(x).size() == torch.Size((N, M_1, M_2, 1))
def test_repr(self):
hedger = Hedger(Linear(2, 1), ["moneyness", "expiry_time"])
assert repr(hedger) == (
"Hedger(\n"
" features=['moneyness', 'expiry_time'],\n"
" (model): Linear(in_features=2, out_features=1, bias=True)\n"
" (criterion): EntropicRiskMeasure()\n"
")")
liability = EuropeanOption(BrownianStock())
model = BlackScholes(liability)
hedger = Hedger(model, model.features())
assert repr(hedger) == (
"Hedger(\n"
" features=['log_moneyness', 'expiry_time', 'volatility'],\n"
" (model): BSEuropeanOption()\n"
" (criterion): EntropicRiskMeasure()\n"
")")
hedger = Hedger(naked, ["moneyness", "expiry_time"])
assert repr(hedger) == ("Hedger(\n"
" model=naked,\n"
" features=['moneyness', 'expiry_time'],\n"
" (criterion): EntropicRiskMeasure()\n"
")")
def test_repr(self):
m = BSEuropeanOption()
assert repr(m) == "BSEuropeanOption()"
liability = EuropeanOption(BrownianStock(), strike=1.1, call=False)
m = BSEuropeanOption(liability)
assert repr(m) == "BSEuropeanOption(call=False, strike=1.1)"
def test(self):
liability = EuropeanOption(BrownianStock())
liability.simulate()
module = torch.nn.Linear(2, 1)
x1, x2 = Moneyness(), ExpiryTime()
f = ModuleOutput(module, [x1, x2]).of(liability)
result = f[0]
expect = module(torch.cat([x1[0], x2[0]], 1))
assert torch.allclose(result, expect)
result = f[1]
expect = module(torch.cat([x1[1], x2[1]], 1))
assert torch.allclose(result, expect)
result = f[2]
expect = module(torch.cat([x1[2], x2[2]], 1))
assert torch.allclose(result, expect)
def test_init(self):
liability = EuropeanOption(BrownianStock())
m = BlackScholes(liability)
assert m.__class__ == BSEuropeanOption
assert m.strike == 1.0
assert m.call
liability = EuropeanOption(BrownianStock(), strike=2.0, call=False)
m = BlackScholes(liability)
assert m.__class__ == BSEuropeanOption
assert m.strike == 2.0
assert not m.call
liability = LookbackOption(BrownianStock())
m = BlackScholes(liability)
assert m.__class__ == BSLookbackOption
assert m.strike == 1.0
assert m.call
def test_parity(self, volatility, strike, maturity, n_paths, init_price):
"""
Test put-call parity.
"""
stock = BrownianStock(volatility)
co = EuropeanOption(stock, strike=strike, maturity=maturity, call=True)
po = EuropeanOption(stock,
strike=strike,
maturity=maturity,
call=False)
co.simulate(n_paths=n_paths, init_price=init_price)
po.simulate(n_paths=n_paths, init_price=init_price)
s = stock.prices[-1, :]
c = co.payoff()
p = po.payoff()
assert ((c - p) == s - strike).all()
def test(self):
liability = EuropeanOption(BrownianStock())
liability.underlier.prices = torch.tensor([
[1.0, 2.0, 3.0, 1.0],
[1.5, 1.0, 4.0, 1.1],
[2.0, 1.0, 5.0, 1.2],
[3.0, 1.0, 6.0, 1.3],
])
f = Barrier(2.0, up=True).of(liability)
result = f[0]
expect = torch.tensor([0.0, 1.0, 1.0, 0.0]).reshape(-1, 1)
assert torch.allclose(result, expect)
result = f[1]
expect = torch.tensor([0.0, 1.0, 1.0, 0.0]).reshape(-1, 1)
assert torch.allclose(result, expect)
result = f[2]
expect = torch.tensor([1.0, 1.0, 1.0, 0.0]).reshape(-1, 1)
assert torch.allclose(result, expect)
result = f[3]
expect = torch.tensor([1.0, 1.0, 1.0, 0.0]).reshape(-1, 1)
assert torch.allclose(result, expect)
liability = EuropeanOption(BrownianStock())
liability.underlier.prices = torch.tensor([
[3.0, 1.0, 6.0, 1.3],
[2.0, 1.0, 5.0, 1.2],
[1.5, 1.0, 4.0, 1.1],
[1.0, 2.0, 3.0, 1.0],
])
f = Barrier(2.0, up=False).of(liability)
result = f[0]
expect = torch.tensor([0.0, 1.0, 0.0, 1.0]).reshape(-1, 1)
assert torch.allclose(result, expect)
result = f[1]
expect = torch.tensor([1.0, 1.0, 0.0, 1.0]).reshape(-1, 1)
assert torch.allclose(result, expect)
result = f[2]
expect = torch.tensor([1.0, 1.0, 0.0, 1.0]).reshape(-1, 1)
assert torch.allclose(result, expect)
result = f[3]
expect = torch.tensor([1.0, 1.0, 0.0, 1.0]).reshape(-1, 1)
assert torch.allclose(result, expect)
def test_example(self):
from pfhedge import Hedger
from pfhedge.instruments import BrownianStock
from pfhedge.instruments import EuropeanOption
liability = EuropeanOption(BrownianStock())
model = BSEuropeanOption()
hedger = Hedger(model, model.features())
price = hedger.price(liability)
assert torch.allclose(price, torch.tensor(0.0221), atol=1e-4)
def test_repr(self):
liability = EuropeanOption(BrownianStock())
m = WhalleyWilmott(liability)
assert repr(m) == ("WhalleyWilmott(\n"
" (bs): BSEuropeanOption()\n"
" (clamp): Clamp()\n"
")")
liability = EuropeanOption(BrownianStock())
m = WhalleyWilmott(liability, a=2)
assert repr(m) == ("WhalleyWilmott(\n"
" a=2\n"
" (bs): BSEuropeanOption()\n"
" (clamp): Clamp()\n"
")")
liability = LookbackOption(BrownianStock())
m = WhalleyWilmott(liability)
assert repr(m) == ("WhalleyWilmott(\n"
" (bs): BSLookbackOption()\n"
" (clamp): Clamp()\n"
")")
def test(self, volatility):
liability = EuropeanOption(BrownianStock(volatility=volatility))
liability.underlier.prices = torch.arange(1.0, 7.0).reshape(3, 2)
f = Volatility().of(liability)
result = f[0]
expect = torch.full((2, 1), volatility)
assert torch.allclose(result, expect)
result = f[1]
expect = torch.full((2, 1), volatility)
assert torch.allclose(result, expect)
result = f[2]
expect = torch.full((2, 1), volatility)
assert torch.allclose(result, expect)
def test_forward(self):
m = BSEuropeanOption()
x = torch.tensor([0.0, 1.0, 0.2]).reshape(1, -1)
result = m(x).item()
assert np.isclose(result, 0.5398278962)
m = BSEuropeanOption(call=False)
x = torch.tensor([0.0, 1.0, 0.2]).reshape(1, -1)
result = m(x).item()
assert np.isclose(result, -0.4601721)
liability = EuropeanOption(BrownianStock(), call=False)
m = BSEuropeanOption(liability)
x = torch.tensor([0.0, 1.0, 0.2]).reshape(1, -1)
result = m(x).item()
assert np.isclose(result, -0.4601721)
def test(self):
torch.manual_seed(42)
liability = EuropeanOption(BrownianStock())
liability.underlier.prices = torch.arange(1.0, 7.0).reshape(3, 2)
f = Zero().of(liability)
result = f[0]
expect = torch.zeros((2, 1))
assert torch.allclose(result, expect)
result = f[1]
expect = torch.zeros((2, 1))
assert torch.allclose(result, expect)
result = f[2]
expect = torch.zeros((2, 1))
assert torch.allclose(result, expect)
def test(self):
maturity = 3 / 365
dt = 1 / 365
liability = EuropeanOption(BrownianStock(dt=dt), maturity=maturity)
liability.underlier.prices = torch.arange(1.0, 7.0).reshape(3, 2)
f = ExpiryTime().of(liability)
result = f[0]
expect = torch.full((2, 1), 3 / 365)
assert torch.allclose(result, expect)
result = f[1]
expect = torch.full((2, 1), 2 / 365)
assert torch.allclose(result, expect)
result = f[2]
expect = torch.full((2, 1), 1 / 365)
assert torch.allclose(result, expect)
def test_shape(self):
torch.distributions.Distribution.set_default_validate_args(False)
deriv = EuropeanOption(BrownianStock())
m = WhalleyWilmott(deriv)
N = 10
H_in = len(m.features())
M_1 = 11
M_2 = 12
x = torch.empty((N, H_in))
assert m(x).size() == torch.Size((N, 1))
x = torch.empty((N, M_1, H_in))
assert m(x).size() == torch.Size((N, M_1, 1))
x = torch.empty((N, M_1, M_2, H_in))
assert m(x).size() == torch.Size((N, M_1, M_2, 1))
def test(self, strike):
liability = EuropeanOption(BrownianStock(), strike=strike)
liability.underlier.prices = torch.arange(1.0, 7.0).reshape(3, 2)
# tensor([[1., 2.],
# [3., 4.],
# [5., 6.]])
f = LogMoneyness().of(liability)
result = f[0]
expect = torch.tensor([[1.0], [2.0]]) / strike
expect = torch.log(expect)
assert torch.allclose(result, expect)
result = f[1]
expect = torch.tensor([[3.0], [4.0]]) / strike
expect = torch.log(expect)
assert torch.allclose(result, expect)
result = f[2]
expect = torch.tensor([[5.0], [6.0]]) / strike
expect = torch.log(expect)
assert torch.allclose(result, expect)
def test(self, strike):
liability = EuropeanOption(BrownianStock(), strike=strike)
liability.underlier.prices = torch.tensor([
[1.0, 2.0, 3.0],
[2.0, 3.0, 2.0],
[1.5, 4.0, 1.0],
])
f = MaxLogMoneyness().of(liability)
result = f[0]
expect = torch.tensor([[1.0], [2.0], [3.0]]) / strike
expect = torch.log(expect)
assert torch.allclose(result, expect)
result = f[1]
expect = torch.tensor([[2.0], [3.0], [3.0]]) / strike
expect = torch.log(expect)
assert torch.allclose(result, expect)
result = f[2]
expect = torch.tensor([[2.0], [4.0], [3.0]]) / strike
expect = torch.log(expect)
assert torch.allclose(result, expect)
def test(self, volatility):
torch.manual_seed(42)
liability = EuropeanOption(BrownianStock(volatility))
liability.underlier.prices = torch.arange(1.0, 7.0).reshape(3, 2)
hedger = Hedger(Linear(2, 1), ["moneyness", "expiry_time"])
hedger.features = [
feature.of(liability) for feature in hedger.features
]
f = PrevHedge().of(liability, hedger)
result = f[0]
expect = torch.zeros((2, 1))
assert torch.allclose(result, expect)
h = hedger(torch.cat([feature[0] for feature in hedger.features], 1))
result = f[1]
expect = h.reshape(-1, 1)
assert torch.allclose(result, expect)
h = hedger(torch.cat([feature[1] for feature in hedger.features], 1))
result = f[2]
expect = h.reshape(-1, 1)
assert torch.allclose(result, expect)
def test_net():
liability = EuropeanOption(BrownianStock(cost=1e-4))
model = MultiLayerPerceptron()
hedger = Hedger(model, ["log_moneyness", "expiry_time", "volatility", "prev_hedge"])
_ = hedger.fit(liability, n_paths=100, n_epochs=10)
_ = hedger.price(liability)
def test_ww():
liability = EuropeanOption(BrownianStock(cost=1e-4))
model = WhalleyWilmott(liability)
hedger = Hedger(model, model.features())
_ = hedger.price(liability)
def test_bs():
liability = EuropeanOption(BrownianStock(cost=1e-4))
model = BlackScholes(liability)
hedger = Hedger(model, model.features())
_ = hedger.price(liability)
def test_dtype(self, dtype):
liability = EuropeanOption(BrownianStock()).to(dtype)
m = Linear(2, 1).to(liability.dtype)
f = ModuleOutput(m, [Moneyness(), ExpiryTime()])
self.assert_same_dtype(f, liability, dtype)
def test_dtype(self, dtype):
liability = EuropeanOption(BrownianStock())
self.assert_same_dtype(Barrier(1.0), liability, dtype)
def test_dtype(self, dtype):
liability = EuropeanOption(BrownianStock())
self.assert_same_dtype(LogMoneyness(), liability, dtype)
import torch
sys.path.append("..")
from pfhedge import Hedger # noqa: E402
from pfhedge.instruments import BrownianStock # noqa: E402
from pfhedge.instruments import EuropeanOption # noqa: E402
from pfhedge.nn import ExpectedShortfall
from pfhedge.nn import MultiLayerPerceptron # noqa: E402
if __name__ == "__main__":
torch.manual_seed(42)
# Prepare a derivative to hedge
deriv = EuropeanOption(BrownianStock(cost=1e-4))
# Expected shortfall with the quantile level of 10%
expected_shortfall = ExpectedShortfall(0.1)
# Create your hedger
model = MultiLayerPerceptron()
hedger = Hedger(
model,
["log_moneyness", "expiry_time", "volatility", "prev_hedge"],
criterion=expected_shortfall,
)
# Fit and price
hedger.fit(deriv, n_paths=10000, n_epochs=200)
price = hedger.price(deriv, n_paths=10000)
def test_device(self, device):
liability = EuropeanOption(BrownianStock(device=device))
assert liability.device == torch.device(device)
