QuantLib-Python债券回溯定价：收益率曲线构建与应用-Python教程-PHP中文网

QuantLib-Python债券回溯定价：收益率曲线构建与应用

本文详细阐述了在QuantLib-Python中，如何利用已构建的零息收益率曲线对债券进行回溯定价。文章首先分析了在使用DiscountingBondEngine时常见的TypeError，并提供了解决方案：即需将收益率曲线封装为ql.YieldTermStructureHandle对象。此外，还强调了bondYield方法正确参数设置的重要性，并提供了完整的修正代码示例，旨在帮助用户准确验证通过债券引导生成的收益率曲线。

在量化金融领域，构建准确的收益率曲线是定价和风险管理的基础。通常，我们可以通过一系列市场交易的债券（包括零息债券和附息债券）来“引导”（bootstrap）出一条零息收益率曲线。引导完成后，一个重要的验证步骤是使用这条新构建的收益率曲线对原始输入债券进行回溯定价，并将其计算出的价格与市场报价进行比较，以确保曲线的准确性。然而，在quantlib-python中执行这一过程时，用户可能会遇到特定的类型错误。

理解QuantLib中的TypeError与Handle机制

问题中出现的TypeError: in method 'new_DiscountingBondEngine', argument 1 of type 'Handle< YieldTermStructure > const &'错误，清晰地指出了ql.DiscountingBondEngine构造函数所期望的参数类型。它需要一个Handle<YieldTermStructure>类型的对象，而不是直接的YieldTermStructure对象（例如由ql.PiecewiseCubicZero返回的曲线对象）。

在QuantLib中，Handle（句柄）是一种重要的设计模式，用于管理对象的所有权和生命周期，并允许在不重新创建依赖对象的情况下动态更新底层对象。例如，一个定价引擎可能依赖于一个收益率曲线。如果收益率曲线发生变化（例如，数据更新导致曲线重新构建），所有依赖于该曲线的定价引擎可以通过句柄自动获取最新的曲线，而无需手动更新每个引擎。

因此，要解决上述TypeError，我们需要将引导出的curve对象封装在一个ql.YieldTermStructureHandle中，然后再将其传递给ql.DiscountingBondEngine。

修正bondYield方法参数

除了定价引擎的类型错误，代码中对bond.bondYield()的调用也可能不完整。bondYield方法在QuantLib中用于计算债券的收益率，它通常需要指定收益率的计算惯例，包括：

立即学习“Python免费学习笔记（深入）”；

Starry.ai

AI艺术绘画生成器

查看详情

Day Count Convention (计日惯例)：例如ql.Actual365Fixed()。
Compounding (复利方式)：例如ql.Compounded（复利）或ql.Simple（单利）。
Frequency (复利频率)：例如ql.Annual（年复利）、ql.Semiannual（半年复利）等。

如果这些参数未指定，bondYield可能会使用默认值，或者在某些情况下引发错误，导致计算结果不符合预期或无法计算。为了确保计算的准确性和一致性，建议明确指定这些参数，使其与债券的票息支付频率和市场惯例相匹配。例如，对于半年付息的债券，通常会使用半年复利(ql.Semiannual)。

完整的修正代码示例

以下是经过修正的QuantLib-Python代码，它解决了上述两个问题，并展示了如何正确地引导收益率曲线、回溯定价债券以及计算其收益率：

# Importing Libraries:
import pandas as pd
import matplotlib.pyplot as plt
import QuantLib as ql

# Setting Evaluation Date:
today = ql.Date(21, ql.November, 2023)
ql.Settings.instance().evaluationDate = today

# Calendar and Day Count:
calendar = ql.NullCalendar()
day_count = ql.Actual365Fixed() # 计日惯例，用于收益率曲线和债券计算

# Settlement Days:
zero_coupon_settlement_days = 4
coupon_bond_settlement_days = 3

# Face Value
faceAmount = 100

# Bond Data: (Issue Date, Maturity, Coupon Rate, Quoted Price, Settlement Days)
data = [
    ('11-09-2023', '11-12-2023', 0, 99.524, zero_coupon_settlement_days),
    ('11-09-2023', '11-03-2024', 0, 96.539, zero_coupon_settlement_days),
    ('11-09-2023', '10-06-2024', 0, 93.552, zero_coupon_settlement_days),
    ('11-09-2023', '09-09-2024', 0, 89.510, zero_coupon_settlement_days),
    ('22-08-2022', '22-08-2024', 9.0, 96.406933, coupon_bond_settlement_days),
    ('27-06-2022', '27-06-2025', 10.0, 88.567570, coupon_bond_settlement_days),
    ('27-06-2022', '27-06-2027', 11.0, 71.363073, coupon_bond_settlement_days),
    ('22-08-2022', '22-08-2029', 12.0, 62.911623, coupon_bond_settlement_days),
    ('27-06-2022', '27-06-2032', 13.0, 55.976845, coupon_bond_settlement_days),
    ('22-08-2022', '22-08-2037', 14.0, 52.656596, coupon_bond_settlement_days)
]

# Create Bond Helpers for Bootstrapping
helpers = []
for issue_date_str, maturity_str, coupon_rate, price, settlement_days in data:
    # QuantLib期望报价是QuoteHandle类型
    price_handle = ql.QuoteHandle(ql.SimpleQuote(price))
    issue_date = ql.Date(issue_date_str, '%d-%m-%Y')
    maturity = ql.Date(maturity_str, '%d-%m-%Y')

    # 附息债券的付息频率通常为半年，MakeSchedule默认即为Semiannual
    schedule = ql.MakeSchedule(issue_date, maturity, ql.Period(ql.Semiannual), calendar,
                                ql.Following, ql.Following, ql.DateGeneration.Backward, False)

    # FixedRateBondHelper用于引导曲线
    helper = ql.FixedRateBondHelper(price_handle, settlement_days, faceAmount, schedule, 
                                    [coupon_rate / 100], day_count, ql.Unadjusted, faceAmount) # 票面价值和未调整的日期规则
    helpers.append(helper)

# Bootstrapping the Zero Curve
# 使用PiecewiseCubicZero从helper中引导出零息曲线
curve = ql.PiecewiseCubicZero(today, helpers, day_count)

# Enable Extrapolation:
curve.enableExtrapolation()

# *** 核心修正：创建YieldTermStructureHandle ***
# 将引导出的曲线封装到YieldTermStructureHandle中，供PricingEngine使用
curveHandle = ql.YieldTermStructureHandle(curve)

# Zero Rate and Discount Rate Calculation (示例，与原问题无关，但保留)
date_example = ql.Date(28, ql.May, 2024)
zero_rate_example = curve.zeroRate(date_example, day_count, ql.Annual).rate()
forward_rate_example = curve.forwardRate(date_example, date_example + ql.Period(1, ql.Years), day_count, ql.Annual).rate()
discount_rate_example = curve.discount(date_example)
print(f"Zero rate as at {date_example}: {zero_rate_example*100:.4f}%")
print(f"Forward rate as at {date_example}: {forward_rate_example*100:.4f}%")
print(f"Discount factor as at {date_example}: {discount_rate_example:.4f}")

# Print the Zero Rates, Forward Rates and Discount Factors at node dates (示例，与原问题无关，但保留)
node_data = {'Date': [], 'Zero Rates': [], 'Forward Rates': [], 'Discount Factors': []}
for dt in curve.dates():
    node_data['Date'].append(dt)
    node_data['Zero Rates'].append(curve.zeroRate(dt, day_count, ql.Annual).rate())
    node_data['Forward Rates'].append(curve.forwardRate(dt, dt + ql.Period(1, ql.Years), day_count, ql.Annual).rate())
    node_data['Discount Factors'].append(curve.discount(dt))
node_dataframe = pd.DataFrame(node_data)
print("\nNode Dates Data:")
print(node_dataframe)
# node_dataframe.to_excel('NodeRates.xlsx') # 导出到Excel

# Plotting Zero Rates (示例，与原问题无关，但保留)
curve_dates = [today + ql.Period(i, ql.Years) for i in range(15)]
curve_zero_rates = [curve.zeroRate(date, day_count, ql.Annual).rate() for date in curve_dates]
numeric_dates = [(date - today) / 365 for date in curve_dates]

plt.figure(figsize=(10, 6))
plt.plot(numeric_dates, curve_zero_rates, marker='', linestyle='-', color='b', label='Zero Rates')
plt.title('Zero Rates Curve')
plt.xlabel('Years from Today')
plt.ylabel('Rate')
plt.legend()
plt.grid(True)
plt.xticks(rotation=0)
plt.tight_layout()
plt.show()

# Create a DataFrame to store bond results
bond_results = {'Issue Date': [],
                'Maturity Date': [],
                'Coupon Rate': [],
                'Quoted Price': [], # 区分报价和计算价格
                'Settlement Days': [],
                'Calculated Price': [], # 新增：通过曲线计算出的价格
                'Yield': [],
                'Clean Price': [],
                'Dirty Price': []}

# Calculate bond prices and yields
for issue_date_str, maturity_str, coupon_rate, price, settlement_days in data:
    # 重新创建债券对象，因为每次循环都需要一个新的实例
    issue_date = ql.Date(issue_date_str, '%d-%m-%Y')
    maturity = ql.Date(maturity_str, '%d-%m-%Y')
    schedule = ql.MakeSchedule(issue_date, maturity, ql.Period(ql.Semiannual), calendar,
                                ql.Following, ql.Following, ql.DateGeneration.Backward, False)

    # 零息债券和附息债券的构造略有不同
    if coupon_rate == 0:
        bond = ql.ZeroCouponBond(settlement_days, calendar, faceAmount, maturity, ql.NullCalendar(), ql.Following)
    else:
        bond = ql.FixedRateBond(settlement_days, faceAmount, schedule, [coupon_rate / 100], day_count, ql.Unadjusted, faceAmount)

    # *** 核心修正：使用封装好的curveHandle ***
    bondEngine = ql.DiscountingBondEngine(curveHandle)
    bond.setPricingEngine(bondEngine)

    # 计算债券的公允价格（Clean Price）和全价（Dirty Price）
    # bond.cleanPrice() 和 bond.dirtyPrice() 会使用设置的定价引擎计算
    bondCleanPrice = bond.cleanPrice()
    bondDirtyPrice = bond.dirtyPrice()

    # *** 核心修正：为bondYield方法提供完整参数 ***
    # 假设债券收益率按年复利（Annual），半年付息
    # 对于附息债券，通常使用与付息频率相匹配的复利频率
    # 对于零息债券，通常按Annual复利
    if coupon_rate == 0:
        bondYield = bond.bondYield(day_count, ql.Compounded, ql.Annual)
    else:
        # 对于半年付息的附息债券，通常计算半年复利的收益率
        bondYield = bond.bondYield(day_count, ql.Compounded, ql.Semiannual)

    # 验证：计算出的Clean Price应该接近原始报价
    # 对于引导曲线，理论上计算出的Clean Price应该与原始报价非常接近

    # Append the results to the DataFrame
    bond_results['Issue Date'].append(issue_date)
    bond_results['Maturity Date'].append(maturity)
    bond_results['Coupon Rate'].append(coupon_rate)
    bond_results['Quoted Price'].append(price) # 原始报价
    bond_results['Settlement Days'].append(settlement_days)
    bond_results['Calculated Price'].append(bondCleanPrice) # 通过曲线计算出的价格
    bond_results['Yield'].append(bondYield)
    bond_results['Clean Price'].append(bondCleanPrice)
    bond_results['Dirty Price'].append(bondDirtyPrice)

# Create a DataFrame from the bond results
bond_results_df = pd.DataFrame(bond_results)

# Print the results
print("\nBond Repricing Results:")
print(bond_results_df)

# 验证计算价格与原始报价的差异
bond_results_df['Price Difference'] = bond_results_df['Calculated Price'] - bond_results_df['Quoted Price']
print("\nBond Repricing Results with Price Difference:")
print(bond_results_df[['Maturity Date', 'Coupon Rate', 'Quoted Price', 'Calculated Price', 'Price Difference']])

登录后复制

注意事项与总结

Handle的重要性：QuantLib中的Handle机制是其设计哲学的一部分，它允许对象之间建立松散耦合的依赖关系。当底层对象（如收益率曲线）发生变化时，所有持有其Handle的依赖对象（如定价引擎）都能自动感知并更新。在处理YieldTermStructure、Quote等核心对象时，务必注意其是否需要通过Handle进行封装。
bondYield参数：债券收益率的计算惯例在全球范围内多种多样。在调用bondYield方法时，明确指定dayCount、compounding和frequency参数至关重要，以确保计算结果符合目标市场的惯例。对于半年付息的债券，通常使用ql.Semiannual作为频率。
零息债券和附息债券的构造：在代码中，需要根据coupon_rate来判断是构造ql.ZeroCouponBond还是ql.FixedRateBond。零息债券没有付息频率，其MakeSchedule的逻辑与附息债券不同。
价格验证：引导曲线的目的是使通过曲线计算出的债券价格与市场报价尽可能接近。在回溯定价后，应仔细比较Calculated Price与Quoted Price的差异。如果差异过大，可能需要检查引导过程中的数据质量、helper的设置或曲线插值方法。
代码可读性与模块化：对于复杂的金融计算，将代码分解为更小的、可管理的函数或类，可以提高代码的可读性和可维护性。

通过遵循这些指导原则并正确使用QuantLib的API，用户可以有效地构建、验证和应用收益率曲线，为后续的金融产品定价和风险分析奠定坚实基础。

以上就是QuantLib-Python债券回溯定价：收益率曲线构建与应用的详细内容，更多请关注php中文网其它相关文章！