def tensor_repr(fra_data, dtype=None):
"""Creates a tensor representation of the FRA."""
dtype = dtype or tf.float64
res = dict()
res["fixing_date"] = tf.convert_to_tensor(fra_data["fixing_date"],
dtype=tf.int32)
res["fixed_rate"] = tf.convert_to_tensor(fra_data["fixed_rate"],
dtype=dtype)
config = fra_data["config"]
res["config"] = config
res["batch_names"] = fra_data["batch_names"]
currency_list = cashflow_streams.to_list(fra_data["currency"])
discount_curve_type = []
for currency in currency_list:
if config is not None:
if currency in config.discounting_curve:
discount_curve = config.discounting_curve[currency]
discount_curve_type.append(discount_curve)
else:
risk_free = curve_types_lib.RiskFreeCurve(currency=currency)
discount_curve_type.append(risk_free)
else:
# Default discounting is the risk free curve
risk_free = curve_types_lib.RiskFreeCurve(currency=currency)
discount_curve_type.append(risk_free)
discount_curve_type, mask = cashflow_streams.process_curve_types(
discount_curve_type)
res["discount_curve_mask"] = tf.convert_to_tensor(mask, dtype=tf.int32)
res["discount_curve_type"] = discount_curve_type
# Get reset frequency
reset_frequency = tf.convert_to_tensor(fra_data["rate_term"][1], tf.int32)
res["rate_term"] = {
"type": fra_data["rate_term"][0],
"frequency": reset_frequency
}
rate_index = cashflow_streams.to_list(fra_data["rate_index"])
rate_index_curves = []
for currency, r_ind in zip(currency_list, rate_index):
rate_index_curves.append(
curve_types_lib.RateIndexCurve(currency=currency, index=r_ind))
[rate_index_curves,
reference_mask] = cashflow_streams.process_curve_types(rate_index_curves)
res["reference_mask"] = tf.convert_to_tensor(reference_mask, tf.int32)
res["rate_index_curves"] = rate_index_curves
# Extract unique rate indices
res["rate_index"] = [curve.index for curve in rate_index_curves]
res["notional_amount"] = tf.convert_to_tensor(fra_data["notional_amount"],
dtype=dtype)
res["settlement_days"] = tf.convert_to_tensor(fra_data["settlement_days"],
dtype=tf.int32,
name="settlement_days")
res["calendar"] = fra_data["calendar"]
# Extract unique currencies
res["currency"] = [curve.currency for curve in discount_curve_type]
res["daycount_convention"] = fra_data["daycount_convention"]
res["business_day_convention"] = fra_data["business_day_convention"]
res["short_position"] = tf.convert_to_tensor(fra_data["short_position"],
dtype=tf.bool)
return res
def floating_leg_tensor_repr(leg, config, dtype):
"""Creates tensor representation for a floating leg of a swap."""
res = {}
coupon_spec = {}
currency_list = cashflow_streams.to_list(leg.currency)
discount_curve_type = []
for currency in currency_list:
if config is not None:
if currency in config.discounting_curve:
discount_curve = config.discounting_curve[currency]
discount_curve_type.append(discount_curve)
else:
risk_free = curve_types_lib.RiskFreeCurve(currency=currency)
discount_curve_type.append(risk_free)
else:
# Default discounting is the risk free curve
risk_free = curve_types_lib.RiskFreeCurve(currency=currency)
discount_curve_type.append(risk_free)
discount_curve_type, mask = cashflow_streams.process_curve_types(
discount_curve_type)
res["discount_curve_mask"] = tf.convert_to_tensor(mask, dtype=tf.int32)
res["discount_curve_type"] = discount_curve_type
# Get coupon frequency
coupon_frequency = tf.convert_to_tensor(leg.coupon_frequency[1],
tf.int32,
name="floating_coupon_frequency")
coupon_spec["coupon_frequency"] = {
"type": leg.coupon_frequency[0],
"frequency": coupon_frequency
}
# Get reset frequency
reset_frequency = tf.convert_to_tensor(leg.reset_frequency[1], tf.int32)
coupon_spec["reset_frequency"] = {
"type": leg.reset_frequency[0],
"frequency": reset_frequency
}
floating_rate_type = cashflow_streams.to_list(leg.floating_rate_type)
rate_index_curves = []
for currency, floating_rate_type in zip(currency_list, floating_rate_type):
rate_index_curves.append(
curve_types_lib.RateIndexCurve(currency=currency,
index=floating_rate_type))
[rate_index_curves,
reference_mask] = cashflow_streams.process_curve_types(rate_index_curves)
res["reference_mask"] = tf.convert_to_tensor(reference_mask, tf.int32)
res["rate_index_curves"] = rate_index_curves
coupon_spec["notional_amount"] = tf.convert_to_tensor(leg.notional_amount,
dtype=dtype)
coupon_spec["settlement_days"] = tf.convert_to_tensor(
leg.settlement_days, dtype=tf.int32, name="settlement_days")
coupon_spec["calendar"] = leg.calendar
coupon_spec["currency"] = [curve.currency for curve in discount_curve_type]
coupon_spec["daycount_convention"] = leg.daycount_convention
coupon_spec["businessday_rule"] = leg.businessday_rule
coupon_spec["floating_rate_type"] = floating_rate_type
coupon_spec["spread"] = tf.convert_to_tensor(leg.spread, dtype=dtype)
res["coupon_spec"] = coupon_spec
return res
def tensor_repr(am_option_data: Dict[str, Any],
dtype: Optional[types.Dtype] = None):
"""Creates a tensor representation of an American option."""
dtype = dtype or tf.float64
res = dict()
res["expiry_date"] = tf.convert_to_tensor(am_option_data["expiry_date"],
dtype=tf.int32,
name="expiry_date")
am_option_config = am_option_data["config"]
res["config"] = None
if am_option_config is not None:
res["config"] = config_to_dict(am_option_config)
res["batch_names"] = am_option_data["batch_names"]
res["is_call_option"] = tf.convert_to_tensor(
am_option_data["is_call_option"],
dtype=tf.bool,
name="is_call_options")
currency = am_option_data["currency"]
if not isinstance(currency, (list, tuple)):
currency = [currency]
discount_curve_type = []
for cur in currency:
if res["config"] is not None:
if cur in res["config"]["discounting_curve"]:
discount_curve = res["config"]["discounting_curve"][cur]
discount_curve_type.append(discount_curve)
else:
risk_free = curve_types_lib.RiskFreeCurve(currency=cur)
discount_curve_type.append(risk_free)
else:
# Default discounting is the risk free curve
risk_free = curve_types_lib.RiskFreeCurve(currency=cur)
discount_curve_type.append(risk_free)
discount_curve_type, mask = cashflow_streams.process_curve_types(
discount_curve_type)
res["discount_curve_mask"] = tf.convert_to_tensor(mask, dtype=tf.int32)
res["discount_curve_type"] = discount_curve_type
# Get equity mask
equity_list = cashflow_streams.to_list(am_option_data["equity"])
[
equity,
equity_mask,
] = equity_utils.process_equities(equity_list)
res["equity_mask"] = tf.convert_to_tensor(equity_mask, tf.int32)
res["equity"] = equity
res["contract_amount"] = tf.convert_to_tensor(
am_option_data["contract_amount"], dtype=dtype)
res["strike"] = tf.convert_to_tensor(am_option_data["strike"], dtype=dtype)
res["calendar"] = am_option_data["calendar"]
res["currency"] = [curve.currency for curve in discount_curve_type]
res["business_day_convention"] = am_option_data["business_day_convention"]
res["short_position"] = tf.convert_to_tensor(
am_option_data["short_position"], dtype=tf.bool)
return res
def fixed_leg_tensor_repr(leg, config, dtype):
"""Creates tensor representation for a fixed leg of a swap."""
res = {}
coupon_spec = {}
currency_list = cashflow_streams.to_list(leg.currency)
discount_curve_type = []
for currency in currency_list:
if config is not None:
if currency in config.discounting_curve:
discount_curve = config.discounting_curve[currency]
discount_curve_type.append(discount_curve)
else:
risk_free = curve_types_lib.RiskFreeCurve(currency=currency)
discount_curve_type.append(risk_free)
else:
# Default discounting is the risk free curve
risk_free = curve_types_lib.RiskFreeCurve(currency=currency)
discount_curve_type.append(risk_free)
discount_curve_type, mask = cashflow_streams.process_curve_types(
discount_curve_type)
res["discount_curve_mask"] = tf.convert_to_tensor(mask, dtype=tf.int32)
res["discount_curve_type"] = discount_curve_type
coupon_frequency = tf.convert_to_tensor(leg.coupon_frequency[1], tf.int32)
coupon_spec["coupon_frequency"] = {
"type": leg.coupon_frequency[0],
"frequency": coupon_frequency
}
coupon_spec["fixed_rate"] = tf.convert_to_tensor(leg.fixed_rate,
dtype=dtype)
coupon_spec["notional_amount"] = tf.convert_to_tensor(leg.notional_amount,
dtype=dtype)
coupon_spec["settlement_days"] = tf.convert_to_tensor(leg.settlement_days,
dtype=tf.int32)
coupon_spec["calendar"] = leg.calendar
coupon_spec["currency"] = [curve.currency for curve in discount_curve_type]
coupon_spec["daycount_convention"] = leg.daycount_convention
coupon_spec["businessday_rule"] = leg.businessday_rule
res["coupon_spec"] = coupon_spec
return res
def __init__(self,
start_date: Union[dateslib.DateTensor, List[List[int]]],
maturity_date: Union[dateslib.DateTensor, List[List[int]]],
pay_leg: Union[coupon_specs.FixedCouponSpecs,
coupon_specs.FloatCouponSpecs],
receive_leg: Union[coupon_specs.FixedCouponSpecs,
coupon_specs.FloatCouponSpecs],
pay_leg_schedule_fn=None,
pay_leg_schedule=None,
receive_leg_schedule_fn=None,
receive_leg_schedule=None,
config: Union[InterestRateSwapConfig, Dict[str, Any]] = None,
batch_names: Optional[tf.Tensor] = None,
dtype: Optional[types.Dtype] = None,
name: Optional[str] = None):
"""Initializes a batch of IRS contracts.
Args:
start_date: A `DateTensor` of `batch_shape` specifying the dates for the
inception (start of the accrual) of the swap contracts. `batch_shape`
corresponds to the number of instruments being created.
maturity_date: A `DateTensor` broadcastable with `start_date` specifying
the maturity dates for each contract.
pay_leg: An instance of `FixedCouponSpecs` or `FloatCouponSpecs`
specifying the coupon payments for the payment leg of the swap.
receive_leg: An instance of `FixedCouponSpecs` or `FloatCouponSpecs`
specifying the coupon payments for the receiving leg of the swap.
pay_leg_schedule_fn: A callable that accepts `start_date`, `end_date`,
`coupon_frequency`, `settlement_days`, `first_coupon_date`, and
`penultimate_coupon_date` as `Tensor`s and returns coupon payment
days. Constructs schedule for the pay leg of the swap.
Default value: `None`.
pay_leg_schedule: A `DateTensor` of coupon payment dates for the pay leg.
receive_leg_schedule_fn: A callable that accepts `start_date`,
`end_date`, `coupon_frequency`, `settlement_days`, `first_coupon_date`,
and `penultimate_coupon_date` as `Tensor`s and returns coupon payment
days. Constructs schedule for the receive leg of the swap.
Default value: `None`.
receive_leg_schedule: A `DateTensor` of coupon payment dates for the
receive leg.
config: Optional `InterestRateSwapConfig` or a dictionary.
If dictionary, then the keys should be the same as the field names of
`InterestRateSwapConfig`.
batch_names: A string `Tensor` of instrument names. Should be of shape
`batch_shape + [2]` specying name and instrument type. This is useful
when the `from_protos` method is used and the user needs to identify
which instruments got batched together.
dtype: `tf.Dtype` of the input and output real `Tensor`s.
Default value: None which maps to the default dtype inferred by
TensorFlow.
name: Python str. The name to give to the ops created by this class.
Default value: `None` which maps to 'interest_rate_swap'.
"""
self._name = name or "interest_rate_swap"
with tf.name_scope(self._name):
if batch_names is not None:
self._names = tf.convert_to_tensor(batch_names,
name="batch_names")
else:
self._names = None
self._dtype = dtype or tf.float64
self._model = None # Ignore
self._config = _process_config(config)
if isinstance(pay_leg, dict):
self._discount_curve_type = pay_leg["discount_curve_type"]
self._start_date = start_date
else:
currencies = cashflow_streams.to_list(pay_leg.currency)
self._discount_curve_type = []
if pay_leg.currency != receive_leg.currency:
raise ValueError(
"Pay and receive legs should have the same currency")
for currency in currencies:
if currency in self._config.discounting_curve:
discount_curve = self._config.discounting_curve[
currency]
self._discount_curve_type.append(discount_curve)
else:
# Default discounting is the risk free curve
risk_free = curve_types_lib.RiskFreeCurve(
currency=currency)
self._discount_curve_type.append(risk_free)
if isinstance(start_date, tf.Tensor):
self._start_date = dateslib.dates_from_tensor(start_date)
else:
self._start_date = dateslib.convert_to_date_tensor(start_date)
if isinstance(start_date, tf.Tensor):
self._maturity_date = dateslib.dates_from_tensor(maturity_date)
else:
self._maturity_date = dateslib.convert_to_date_tensor(
maturity_date)
self._pay_leg_schedule_fn = pay_leg_schedule_fn
self._receive_leg_schedule_fn = receive_leg_schedule_fn
self._pay_leg_schedule = pay_leg_schedule
self._receive_leg_schedule = receive_leg_schedule
self._pay_leg = _setup_leg(self._start_date, self._maturity_date,
self._discount_curve_type, pay_leg,
self._pay_leg_schedule_fn,
self._pay_leg_schedule)
self._receive_leg = _setup_leg(self._start_date,
self._maturity_date,
self._discount_curve_type,
receive_leg,
self._receive_leg_schedule_fn,
self._receive_leg_schedule)
self._batch_shape = self._pay_leg.batch_shape
def __init__(self,
short_position: types.BoolTensor,
currency: types.CurrencyProtoType,
expiry_date: types.DateTensor,
equity: List[str],
contract_amount: types.FloatTensor,
strike: types.FloatTensor,
is_call_option: List[bool],
business_day_convention: types.BusinessDayConventionProtoType,
calendar: types.BankHolidaysProtoType,
settlement_days: Optional[types.IntTensor] = 0,
american_option_config: AmericanOptionConfig = None,
batch_names: Optional[types.StringTensor] = None,
dtype: Optional[types.Dtype] = None,
name: Optional[str] = None):
"""Initializes the batch of American Equity Options.
Args:
short_position: Whether the price is computed for the contract holder.
Default value: `True` which means that the price is for the contract
holder.
currency: The denominated currency.
expiry_date: A `DateTensor` specifying the dates on which the options
expire.
equity: A string name of the underlyings.
contract_amount: A `Tensor` of real dtype and shape compatible with
with `short_position`.
strike: `Tensor` of real dtype and shape compatible with
with `short_position`. Option strikes.
is_call_option: A bool `Tensor` of shape compatible with with
`short_position`. Indicates which options are of call type.
business_day_convention: A business count convention.
calendar: A calendar to specify the weekend mask and bank holidays.
settlement_days: An integer `Tensor` of the shape broadcastable with the
shape of `fixing_date`.
american_option_config: Optional `AmericanOptionConfig`.
batch_names: A string `Tensor` of instrument names. Should be of shape
`batch_shape + [2]` specying name and instrument type. This is useful
when the `from_protos` method is used and the user needs to identify
which instruments got batched together.
dtype: `tf.Dtype` of the input and output real `Tensor`s.
Default value: `None` which maps to `float64`.
name: Python str. The name to give to the ops created by this class.
Default value: `None` which maps to 'AmericanOption'.
"""
self._name = name or "AmericanOption"
with tf.name_scope(self._name):
if batch_names is not None:
self._names = tf.convert_to_tensor(batch_names,
name="batch_names")
else:
self._names = None
self._dtype = dtype or tf.float64
ones = tf.constant(1, dtype=self._dtype)
self._short_position = tf.where(short_position,
ones,
-ones,
name="short_position")
self._contract_amount = tf.convert_to_tensor(
contract_amount, dtype=self._dtype, name="contract_amount")
self._strike = tf.convert_to_tensor(strike,
dtype=self._dtype,
name="strike")
self._is_call_option = tf.convert_to_tensor(is_call_option,
dtype=tf.bool,
name="strike")
settlement_days = tf.convert_to_tensor(settlement_days)
# Business day roll convention and the end of month flag
roll_convention, eom = market_data_utils.get_business_day_convention(
business_day_convention)
# TODO(b/160446193): Calendar is ignored at the moment
calendar = dateslib.create_holiday_calendar(
weekend_mask=dateslib.WeekendMask.SATURDAY_SUNDAY)
self._expiry_date = dateslib.convert_to_date_tensor(expiry_date)
self._settlement_days = settlement_days
self._roll_convention = roll_convention
# Get discount and reference curves
self._currency = cashflow_streams.to_list(currency)
self._equity = cashflow_streams.to_list(equity)
if len(self._currency) != len(self._equity):
if len(self._currency) > 1 and len(self._equity) > 1:
raise ValueError(
"Number of currencies and equities should be the same "
"but it is {0} and {1}".format(len(self._currency),
len(self._equity)))
self._discount_curve_type = []
self._model = "BS-LSM" # default pricing model is LSM under Black-Scholes
self._num_exercise_times = 100
self._num_samples = 96000
self._seed = [42, 42]
if american_option_config is not None:
self._model = american_option_config.model
self._seed = american_option_config.seed
self._num_calibration_samples = None
for currency in self._currency:
if american_option_config is not None:
[
self._num_samples, self._num_exercise_times,
self._num_calibration_samples
] = [
american_option_config.num_samples,
american_option_config.num_exercise_times,
american_option_config.num_calibration_samples
]
try:
discount_curve_type = american_option_config.discounting_curve[
currency]
except (KeyError, TypeError):
discount_curve_type = curve_types.RiskFreeCurve(
currency=currency)
self._discount_curve_type.append(discount_curve_type)
else:
# Default discounting is the risk free curve
risk_free = curve_types.RiskFreeCurve(currency=currency)
self._discount_curve_type.append(risk_free)
# Get masks for discount curves and vol surfaces
[self._discount_curve_type,
self._discount_curve_mask] = cashflow_streams.process_curve_types(
self._discount_curve_type)
[
self._equity,
self._equity_mask,
] = equity_utils.process_equities(self._equity)
# Get batch shape
self._batch_shape = tf.shape(strike)
def __init__(self,
short_position: types.BoolTensor,
currency: types.CurrencyProtoType,
fixing_date: types.DateTensor,
fixed_rate: types.FloatTensor,
notional_amount: types.FloatTensor,
daycount_convention: types.DayCountConventionsProtoType,
business_day_convention: types.BusinessDayConventionProtoType,
calendar: types.BankHolidaysProtoType,
rate_term: period_pb2.Period,
rate_index: rate_indices.RateIndex,
settlement_days: Optional[types.IntTensor] = 0,
fra_config: ForwardRateAgreementConfig = None,
batch_names: Optional[types.StringTensor] = None,
dtype: Optional[types.Dtype] = None,
name: Optional[str] = None):
"""Initializes the batch of FRA contracts.
Args:
short_position: Whether the contract holder lends or borrows the money.
Default value: `True` which means that the contract holder lends the
money at the fixed rate.
currency: The denominated currency.
fixing_date: A `DateTensor` specifying the dates on which forward
rate will be fixed.
fixed_rate: A `Tensor` of real dtype specifying the fixed rate
payment agreed at the initiation of the individual contracts. The shape
should be broadcastable with `fixed_rate`.
notional_amount: A `Tensor` of real dtype broadcastable with fixed_rate
specifying the notional amount for each contract. When the notional is
specified as a scalar, it is assumed that all contracts have the same
notional.
daycount_convention: A `DayCountConvention` to determine how cashflows
are accrued for each contract. Daycount is assumed to be the same for
all contracts in a given batch.
business_day_convention: A business count convention.
calendar: A calendar to specify the weekend mask and bank holidays.
rate_term: A tenor of the rate (usually Libor) that determines the
floating cashflow.
rate_index: A type of the floating leg. An instance of
`core.rate_indices.RateIndex`.
settlement_days: An integer `Tensor` of the shape broadcastable with the
shape of `fixing_date`.
fra_config: Optional `ForwardRateAgreementConfig`.
batch_names: A string `Tensor` of instrument names. Should be of shape
`batch_shape + [2]` specying name and instrument type. This is useful
when the `from_protos` method is used and the user needs to identify
which instruments got batched together.
dtype: `tf.Dtype` of the input and output real `Tensor`s.
Default value: `None` which maps to `float64`.
name: Python str. The name to give to the ops created by this class.
Default value: `None` which maps to 'forward_rate_agreement'.
"""
self._name = name or "forward_rate_agreement"
with tf.name_scope(self._name):
if batch_names is not None:
self._names = tf.convert_to_tensor(batch_names,
name="batch_names")
else:
self._names = None
self._dtype = dtype or tf.float64
ones = tf.constant(1, dtype=self._dtype)
self._short_position = tf.where(short_position,
ones,
-ones,
name="short_position")
self._notional_amount = tf.convert_to_tensor(
notional_amount, dtype=self._dtype, name="notional_amount")
self._fixed_rate = tf.convert_to_tensor(fixed_rate,
dtype=self._dtype,
name="fixed_rate")
settlement_days = tf.convert_to_tensor(settlement_days)
# Business day roll convention and the end of month flag
roll_convention, eom = market_data_utils.get_business_day_convention(
business_day_convention)
# TODO(b/160446193): Calendar is ignored at the moment
calendar = dateslib.create_holiday_calendar(
weekend_mask=dateslib.WeekendMask.SATURDAY_SUNDAY)
self._fixing_date = dateslib.convert_to_date_tensor(fixing_date)
self._accrual_start_date = calendar.add_business_days(
self._fixing_date,
settlement_days,
roll_convention=roll_convention)
self._day_count_fn = market_data_utils.get_daycount_fn(
daycount_convention)
period = market_data_utils.get_period(rate_term)
self._accrual_end_date = calendar.add_period_and_roll(
self._accrual_start_date,
period,
roll_convention=roll_convention)
if eom:
self._accrual_end_date = self._accrual_end_date.to_end_of_month(
)
self._daycount_fractions = self._day_count_fn(
start_date=self._accrual_start_date,
end_date=self._accrual_end_date,
dtype=self._dtype)
self._settlement_days = settlement_days
self._roll_convention = roll_convention
# Get discount and reference curves
rate_index_curve = curve_types.RateIndexCurve(currency=currency,
index=rate_index)
reference_curve_type = rate_index_curve
if fra_config is not None:
try:
self._discount_curve_type = fra_config.discounting_index[
currency]
except KeyError:
risk_free = curve_types.RiskFreeCurve(currency=currency)
self._discount_curve_type = curve_types.CurveType(
type=risk_free)
else:
# Default discounting is the risk free curve
risk_free = curve_types.RiskFreeCurve(currency=currency)
self._discount_curve_type = risk_free
self._reference_curve_type = reference_curve_type
self._batch_shape = self._daycount_fractions.shape.as_list()[:-1]
def __init__(self,
short_position: types.BoolTensor,
currency: types.CurrencyProtoType,
fixing_date: types.DateTensor,
fixed_rate: types.FloatTensor,
notional_amount: types.FloatTensor,
daycount_convention: types.DayCountConventionsProtoType,
business_day_convention: types.BusinessDayConventionProtoType,
calendar: types.BankHolidaysProtoType,
rate_term: period_pb2.Period,
rate_index: rate_indices.RateIndex,
settlement_days: Optional[types.IntTensor] = 0,
discount_curve_type: curve_types_lib.CurveType = None,
discount_curve_mask: types.IntTensor = None,
rate_index_curves: curve_types_lib.RateIndexCurve = None,
reference_mask: types.IntTensor = None,
config: Union[ForwardRateAgreementConfig, Dict[str,
Any]] = None,
batch_names: Optional[types.StringTensor] = None,
dtype: Optional[types.Dtype] = None,
name: Optional[str] = None):
"""Initializes the batch of FRA contracts.
Args:
short_position: Whether the contract holder lends or borrows the money.
Default value: `True` which means that the contract holder lends the
money at the fixed rate.
currency: The denominated currency.
fixing_date: A `DateTensor` specifying the dates on which forward
rate will be fixed.
fixed_rate: A `Tensor` of real dtype specifying the fixed rate
payment agreed at the initiation of the individual contracts. The shape
should be broadcastable with `fixed_rate`.
notional_amount: A `Tensor` of real dtype broadcastable with fixed_rate
specifying the notional amount for each contract. When the notional is
specified as a scalar, it is assumed that all contracts have the same
notional.
daycount_convention: A `DayCountConvention` to determine how cashflows
are accrued for each contract. Daycount is assumed to be the same for
all contracts in a given batch.
business_day_convention: A business count convention.
calendar: A calendar to specify the weekend mask and bank holidays.
rate_term: A tenor of the rate (usually Libor) that determines the
floating cashflow.
rate_index: A type of the floating leg. An instance of
`core.rate_indices.RateIndex`.
settlement_days: An integer `Tensor` of the shape broadcastable with the
shape of `fixing_date`.
discount_curve_type: An optional instance of `CurveType` or a list of
those. If supplied as a list and `discount_curve_mask` is not supplied,
the size of the list should be the same as the number of priced
instruments. Defines discount curves for the instruments.
Default value: `None`, meaning that discount curves are inferred
from `currency` and `config`.
discount_curve_mask: An optional integer `Tensor` of values ranging from
`0` to `len(discount_curve_type) - 1` and of shape `batch_shape`.
Identifies a mapping between `discount_curve_type` list and the
underlying instruments.
Default value: `None`.
rate_index_curves: An instance of `RateIndexCurve` or a list of those.
If supplied as a list and `reference_mask` is not supplid,
the size of the list should be the same as the number of priced
instruments. Defines the index curves for each instrument. If not
supplied, `coupon_spec.floating_rate_type` is used to identify the
curves.
Default value: `None`.
reference_mask: An optional integer `Tensor` of values ranging from
`0` to `len(rate_index_curves) - 1` and of shape `batch_shape`.
Identifies a mapping between `rate_index_curves` list and the underlying
instruments.
Default value: `None`.
config: Optional `ForwardRateAgreementConfig` or a dictionary.
If dictionary, then the keys should be the same as the field names of
`ForwardRateAgreementConfig`.
batch_names: A string `Tensor` of instrument names. Should be of shape
`batch_shape + [2]` specying name and instrument type. This is useful
when the `from_protos` method is used and the user needs to identify
which instruments got batched together.
dtype: `tf.Dtype` of the input and output real `Tensor`s.
Default value: `None` which maps to `float64`.
name: Python str. The name to give to the ops created by this class.
Default value: `None` which maps to 'forward_rate_agreement'.
"""
self._name = name or "forward_rate_agreement"
with tf.name_scope(self._name):
if batch_names is not None:
self._names = tf.convert_to_tensor(batch_names,
name="batch_names")
else:
self._names = None
self._dtype = dtype or tf.float64
ones = tf.constant(1, dtype=self._dtype)
self._short_position = tf.where(short_position,
ones,
-ones,
name="short_position")
self._notional_amount = tf.convert_to_tensor(
notional_amount, dtype=self._dtype, name="notional_amount")
self._fixed_rate = tf.convert_to_tensor(fixed_rate,
dtype=self._dtype,
name="fixed_rate")
settlement_days = tf.convert_to_tensor(settlement_days)
# Business day roll convention and the end of month flag
roll_convention, eom = market_data_utils.get_business_day_convention(
business_day_convention)
# TODO(b/160446193): Calendar is ignored at the moment
calendar = dateslib.create_holiday_calendar(
weekend_mask=dateslib.WeekendMask.SATURDAY_SUNDAY)
if isinstance(fixing_date, types.IntTensor):
self._fixing_date = dateslib.dates_from_tensor(fixing_date)
else:
self._fixing_date = dateslib.convert_to_date_tensor(
fixing_date)
self._accrual_start_date = calendar.add_business_days(
self._fixing_date,
settlement_days,
roll_convention=roll_convention)
self._day_count_fn = market_data_utils.get_daycount_fn(
daycount_convention)
period = rate_term
if isinstance(rate_term, period_pb2.Period):
period = market_data_utils.get_period(rate_term)
if isinstance(rate_term, dict):
period = market_data_utils.period_from_dict(rate_term)
self._accrual_end_date = calendar.add_period_and_roll(
self._accrual_start_date,
period,
roll_convention=roll_convention)
if eom:
self._accrual_end_date = self._accrual_end_date.to_end_of_month(
)
self._daycount_fractions = self._day_count_fn(
start_date=self._accrual_start_date,
end_date=self._accrual_end_date,
dtype=self._dtype)
self._settlement_days = settlement_days
self._roll_convention = roll_convention
# Get discount and reference curves
self._currency = cashflow_streams.to_list(currency)
self._rate_index = cashflow_streams.to_list(rate_index)
# Get a mask for the reference curves
if rate_index_curves is None:
rate_index_curves = []
if len(self._currency) != len(self._rate_index):
raise ValueError(
"When rate_index_curves` is not supplied, number of currencies "
"and rate indices should be the same `but it is {0} and "
"{1}".format(len(self._currency),
len(self._rate_index)))
for currency, rate_index in zip(self._currency,
self._rate_index):
rate_index_curves.append(
curve_types_lib.RateIndexCurve(currency=currency,
index=rate_index))
[self._reference_curve_type, self._reference_mask
] = cashflow_streams.process_curve_types(rate_index_curves,
reference_mask)
# Get a mask for the discount curves
self._config = _process_config(config)
if discount_curve_type is None:
curve_list = []
for currency in self._currency:
if currency in self._config.discounting_curve:
discount_curve_type = self._config.discounting_curve[
currency]
else:
# Default discounting is the risk free curve
discount_curve_type = curve_types_lib.RiskFreeCurve(
currency=currency)
curve_list.append(discount_curve_type)
else:
curve_list = cashflow_streams.to_list(discount_curve_type)
# Get masks for discount and reference curves
[self._discount_curve_type, self._mask
] = cashflow_streams.process_curve_types(curve_list,
discount_curve_mask)
# Get batch shape
self._batch_shape = self._daycount_fractions.shape.as_list()[:-1]
def __init__(self,
start_date: Union[dateslib.DateTensor, List[List[int]]],
maturity_date: Union[dateslib.DateTensor, List[List[int]]],
pay_leg: Union[coupon_specs.FixedCouponSpecs,
coupon_specs.FloatCouponSpecs],
receive_leg: Union[coupon_specs.FixedCouponSpecs,
coupon_specs.FloatCouponSpecs],
swap_config: InterestRateSwapConfig = None,
batch_names: Optional[tf.Tensor] = None,
dtype: Optional[types.Dtype] = None,
name: Optional[str] = None):
"""Initializes a batch of IRS contracts.
Args:
start_date: A `DateTensor` of `batch_shape` specifying the dates for the
inception (start of the accrual) of the swap contracts. `batch_shape`
corresponds to the number of instruments being created.
maturity_date: A `DateTensor` broadcastable with `start_date` specifying
the maturity dates for each contract.
pay_leg: An instance of `FixedCouponSpecs` or `FloatCouponSpecs`
specifying the coupon payments for the payment leg of the swap.
receive_leg: An instance of `FixedCouponSpecs` or `FloatCouponSpecs`
specifying the coupon payments for the receiving leg of the swap.
swap_config: Optional `InterestRateSwapConfig`.
batch_names: A string `Tensor` of instrument names. Should be of shape
`batch_shape + [2]` specying name and instrument type. This is useful
when the `from_protos` method is used and the user needs to identify
which instruments got batched together.
dtype: `tf.Dtype` of the input and output real `Tensor`s.
Default value: None which maps to the default dtype inferred by
TensorFlow.
name: Python str. The name to give to the ops created by this class.
Default value: `None` which maps to 'interest_rate_swap'.
"""
self._name = name or "interest_rate_swap"
with tf.name_scope(self._name):
if batch_names is not None:
self._names = tf.convert_to_tensor(batch_names,
name="batch_names")
else:
self._names = None
self._dtype = dtype or tf.float64
self._model = None # Ignore
currencies = cashflow_streams.to_list(pay_leg.currency)
self._discount_curve_type = []
if pay_leg.currency != receive_leg.currency:
raise ValueError(
"Pay and receive legs should have the same currency")
for currency in currencies:
if swap_config is not None:
try:
discount_curve = swap_config.discounting_curve[
currency]
self._discount_curve_type.append(discount_curve)
except KeyError:
risk_free = curve_types_lib.RiskFreeCurve(
currency=currency)
self._discount_curve_type.append(risk_free)
else:
# Default discounting is the risk free curve
risk_free = curve_types_lib.RiskFreeCurve(
currency=currency)
self._discount_curve_type.append(risk_free)
self._start_date = dateslib.convert_to_date_tensor(start_date)
self._maturity_date = dateslib.convert_to_date_tensor(
maturity_date)
self._pay_leg = self._setup_leg(pay_leg)
self._receive_leg = self._setup_leg(receive_leg)
if self._receive_leg.batch_shape != self._pay_leg.batch_shape:
raise ValueError(
"Batch shapes of pay and receive legs should be the "
"same.")
self._batch_shape = self._pay_leg.batch_shape
def __init__(self,
short_position: types.BoolTensor,
currency: Union[types.CurrencyProtoType,
List[types.CurrencyProtoType]],
expiry_date: types.DateTensor,
equity: List[str],
contract_amount: types.FloatTensor,
strike: types.FloatTensor,
is_call_option: List[bool],
business_day_convention: types.BusinessDayConventionProtoType,
calendar: types.BankHolidaysProtoType,
settlement_days: Optional[types.IntTensor] = 0,
discount_curve_type: curve_types_lib.CurveType = None,
discount_curve_mask: types.IntTensor = None,
equity_mask: types.IntTensor = None,
config: Union[AmericanOptionConfig, Dict[str, Any]] = None,
batch_names: Optional[types.StringTensor] = None,
dtype: Optional[types.Dtype] = None,
name: Optional[str] = None):
"""Initializes the batch of American Equity Options.
Args:
short_position: Whether the price is computed for the contract holder.
Default value: `True` which means that the price is for the contract
holder.
currency: The denominated currency.
expiry_date: A `DateTensor` specifying the dates on which the options
expire.
equity: A string name of the underlyings.
contract_amount: A `Tensor` of real dtype and shape compatible with
with `short_position`.
strike: `Tensor` of real dtype and shape compatible with
with `short_position`. Option strikes.
is_call_option: A bool `Tensor` of shape compatible with with
`short_position`. Indicates which options are of call type.
business_day_convention: A business count convention.
calendar: A calendar to specify the weekend mask and bank holidays.
settlement_days: An integer `Tensor` of the shape broadcastable with the
shape of `fixing_date`.
discount_curve_type: An optional instance of `CurveType` or a list of
those. If supplied as a list and `discount_curve_mask` is not supplied,
the size of the list should be the same as the number of priced
instruments. Defines discount curves for the instruments.
Default value: `None`, meaning that discount curves are inferred
from `currency` and `config`.
discount_curve_mask: An optional integer `Tensor` of values ranging from
`0` to `len(discount_curve_type) - 1` and of shape `batch_shape`.
Identifies a mapping between `discount_curve_type` list and the
underlying instruments.
Default value: `None`.
equity_mask: An optional integer `Tensor` of values ranging from
`0` to `len(equity) - 1` and of shape `batch_shape`. Identifies
a mapping between `equity` list and the underlying instruments.
Default value: `None`.
config: Optional `AmericanOptionConfig` or a dictionary. If dictionary,
then the keys should be the same as the field names of
`AmericanOptionConfig`.
batch_names: A string `Tensor` of instrument names. Should be of shape
`batch_shape + [2]` specying name and instrument type. This is useful
when the `from_protos` method is used and the user needs to identify
which instruments got batched together.
dtype: `tf.Dtype` of the input and output real `Tensor`s.
Default value: `None` which maps to `float64`.
name: Python str. The name to give to the ops created by this class.
Default value: `None` which maps to 'AmericanOption'.
"""
self._name = name or "AmericanOption"
with tf.name_scope(self._name):
if batch_names is not None:
self._names = tf.convert_to_tensor(batch_names,
name="batch_names")
else:
self._names = None
self._dtype = dtype or tf.float64
ones = tf.constant(1, dtype=self._dtype)
self._short_position = tf.where(
short_position, ones, -ones, name="short_position")
self._contract_amount = tf.convert_to_tensor(
contract_amount, dtype=self._dtype, name="contract_amount")
self._strike = tf.convert_to_tensor(strike, dtype=self._dtype,
name="strike")
self._is_call_option = tf.convert_to_tensor(
is_call_option, dtype=tf.bool, name="strike")
settlement_days = tf.convert_to_tensor(settlement_days)
# Business day roll convention and the end of month flag
roll_convention, eom = market_data_utils.get_business_day_convention(
business_day_convention)
# TODO(b/160446193): Calendar is ignored at the moment
calendar = dateslib.create_holiday_calendar(
weekend_mask=dateslib.WeekendMask.SATURDAY_SUNDAY)
if isinstance(expiry_date, types.IntTensor):
self._expiry_date = dateslib.dates_from_tensor(expiry_date)
else:
self._expiry_date = dateslib.convert_to_date_tensor(expiry_date)
self._settlement_days = settlement_days
self._roll_convention = roll_convention
# Get discount and reference curves
self._currency = cashflow_streams.to_list(currency)
self._equity = cashflow_streams.to_list(equity)
if len(self._currency) != len(self._equity):
if len(self._currency) > 1 and len(self._equity) > 1:
raise ValueError(
"Number of currencies and equities should be the same "
"but it is {0} and {1}".format(len(self._currency),
len(self._equity)))
config = _process_config(config)
[
self._model,
self._num_samples,
self._seed,
self._num_exercise_times,
self._num_calibration_samples
] = _get_config_values(config)
if discount_curve_type is None:
discount_curve_type = []
for currency in self._currency:
if currency in config.discounting_curve:
curve_type = config.discounting_curve[currency]
else:
# Default discounting curve
curve_type = curve_types_lib.RiskFreeCurve(
currency=currency)
discount_curve_type.append(curve_type)
# Get masks for discount curves and vol surfaces
[
self._discount_curve_type,
self._discount_curve_mask
] = cashflow_streams.process_curve_types(discount_curve_type,
discount_curve_mask)
[
self._equity,
self._equity_mask,
] = equity_utils.process_equities(self._equity, equity_mask)
# Get batch shape
self._batch_shape = tf.shape(strike)
