LocalVolatilityStock¶

class pfhedge.instruments.LocalVolatilityStock(sigma_fn, cost=0.0, dt=0.004, dtype=None, device=None)[source]¶

A stock of which spot prices follow the local volatility model.

See also

pfhedge.stochastic.generate_local_volatility_process(): The stochastic process.

Parameters

sigma_fn (callable) – The local volatility function. Its signature is sigma_fn(time: Tensor, spot: Tensor) -> Tensor.
cost (float, default=0.0) – The transaction cost rate.
dt (float, default=1/250) – The intervals of the time steps.
dtype (torch.device, optional) – Desired device of returned tensor. Default: If None, uses a global default (see torch.set_default_tensor_type()).
device (torch.device, optional) – Desired device of returned tensor. Default: if None, uses the current device for the default tensor type (see torch.set_default_tensor_type()). device will be the CPU for CPU tensor types and the current CUDA device for CUDA tensor types.

Buffers:

spot (torch.Tensor): The spot prices of the instrument. This attribute is set by a method simulate(). The shape is $(N, T)$ where $N$ is the number of simulated paths and $T$ is the number of time steps.

property default_init_state¶: Returns the default initial state of simulation.

simulate(n_paths=1, time_horizon=0.08, init_state=None)[source]¶

Simulate the spot price and add it as a buffer named spot.

The shape of the spot is $(N, T)$ , where $N$ is the number of simulated paths and $T$ is the number of time steps. The number of time steps is determinded from dt and time_horizon.

Parameters

n_paths (int, default=1) – The number of paths to simulate.
time_horizon (float, default=20/250) – The period of time to simulate the price.
init_state (tuple[torch.Tensor | float], optional) – The initial state of the instrument. This is specified by a tuple $(S (0),)$ where $S (0)$ is the initial value of the spot price. If None (default), it uses the default value (See default_init_state). It also accepts a float or a torch.Tensor.

Examples

>>> from pfhedge.instruments import LocalVolatilityStock
...
>>> def sigma_fn(time: Tensor, spot: Tensor) -> Tensor:
...     a, b, sigma = 0.0001, 0.0004, 0.10
...     sqrt_term = (spot.log().square() + sigma ** 2).sqrt()
...     return ((a + b * sqrt_term) / time.clamp(min=1/250)).sqrt()
...
>>> _ = torch.manual_seed(42)
>>> stock = LocalVolatilityStock(sigma_fn)
>>> stock.simulate(n_paths=2, time_horizon=5 / 250)
>>> stock.spot
tensor([[1.0000, 1.0040, 1.0055, 1.0075, 1.0091, 1.0024],
        [1.0000, 1.0261, 1.0183, 1.0223, 1.0242, 1.0274]])
>>> stock.volatility
tensor([[0.1871, 0.1871, 0.1323, 0.1081, 0.0936, 0.0837],
        [0.1871, 0.1880, 0.1326, 0.1084, 0.0939, 0.0841]])

to(*args, **kwargs)¶

Moves and/or casts the buffers of the instrument.

This can be called as

to(device=None, dtype=None)¶

to(tensor)¶

to(instrument)¶

Its signature is similar to torch.nn.Module.to(). It only accepts floating point dtypes. See Instrument dtype and device for details.

Note

This method modifies the instrument in-place.