在本篇博文中，我们将获取50EFT期权的日行情数据和50ETF的日行情数据，作为环境的状态数据，可以在强化学习环境SopEnv中逐日显示出来。
数据集对象定义
我们定义50ETF日行情数据集类D50etfDataset，在其中统一管理50ETF行情和50ETF期权行情数据以及Greeks信息、VIX恐慌指数等信息。D50etfDataset是PyTorch中Dataset的子类，该类中有两个我们必须提供实现代码的方法，分别为__len__获取数据集中样本数量，__getitem__获取指定索引的样本数据，大家看到这两个方法都是双下划线开头，表明我们通常不使用这两个方法，而是通过后面要介绍的DataLoader来获取数据集中的数据。我们这里先给出一个这个类的实现框架：
import numpy as np
import torch
import torch.utils.data.dataset as Dataset
class D50etfDataset(Dataset.Dataset):
def init(self):
self.X, self.y = self._load_dataset()
def __len__(self):
return self.X.shape[0]
def __getitem__(self, index):
return self.X[index], self.y[index]
def _load_dataset(self):
X = np.array([
[1.1, 1.2, 1.3, 1.4, 1.5],
[2.1, 2.2, 2.3, 2.4, 2.5],
[3.1, 3.2, 3.3, 3.4, 3.5],
[4.1, 4.2, 4.3, 4.4, 4.5],
[5.1, 5.2, 5.3, 5.4, 5.5],
[6.1, 6.2, 6.3, 6.4, 6.5],
[7.1, 7.2, 7.3, 7.4, 7.5],
[8.1, 8.2, 8.3, 8.4, 8.5],
[9.1, 9.2, 9.3, 9.4, 9.5]
])
y = np.array([1, 1, 1, 0, 0, 0, 1, 1, 1])
return torch.from_numpy(X), torch.from_numpy(y)
在这里我们在_load_dataset方法中，本来是要从DataSource类中从取出日行情数据来进行初始化，但是这里用写死的简单数据来进行试验。
我们编写一个单元测试用例，来测试一下这个数据集类：
import unittest
import torch.utils.data.dataloader as DataLoader
from apps.sop.d_50etf_dataset import D50etfDataset
class TD50etfDataset(unittest.TestCase):
@classmethod
def setUp(cls):
pass
@classmethod
def tearDown(cls):
pass
def test_getitem(self):
ds = D50etfDataset()
dataloader = DataLoader.DataLoader(ds, batch_size= 2,
shuffle = True, num_workers= 4)
for idx, (X, y) in enumerate(dataloader):
print('{0}: {1} => {2}; {3};'.format(idx, X, y, type(y)))
print('数量：{0};'.format(ds.__len__()))
X, y = ds.__getitem__(3)
print('样本：{0} => {1};'.format(X, y))
运行结果如下所示：
test_getitem (uts.apps.sop.t_d_50etf_dataset.TD50etfDataset) … 0: tensor([[9.1000, 9.2000, 9.3000, 9.4000, 9.5000],
[3.1000, 3.2000, 3.3000, 3.4000, 3.5000]], dtype=torch.float64) => tensor([1, 1], dtype=torch.int32); <class ‘torch.Tensor’>;
1: tensor([[5.1000, 5.2000, 5.3000, 5.4000, 5.5000],
[4.1000, 4.2000, 4.3000, 4.4000, 4.5000]], dtype=torch.float64) => tensor([0, 0], dtype=torch.int32); <class ‘torch.Tensor’>;
2: tensor([[7.1000, 7.2000, 7.3000, 7.4000, 7.5000],
[1.1000, 1.2000, 1.3000, 1.4000, 1.5000]], dtype=torch.float64) => tensor([1, 1], dtype=torch.int32); <class ‘torch.Tensor’>;
3: tensor([[8.1000, 8.2000, 8.3000, 8.4000, 8.5000],
[6.1000, 6.2000, 6.3000, 6.4000, 6.5000]], dtype=torch.float64) => tensor([1, 0], dtype=torch.int32); <class ‘torch.Tensor’>;
4: tensor([[2.1000, 2.2000, 2.3000, 2.4000, 2.5000]], dtype=torch.float64) => tensor([1], dtype=torch.int32); <class ‘torch.Tensor’>;
数量：9;
样本：tensor([4.1000, 4.2000, 4.3000, 4.4000, 4.5000], dtype=torch.float64) => 0;
ok
Ran 1 test in 1.436s
OK
获取50ETF期权行情数据
我们要交易50ETF期权，就需要获取50ETF日行情数据，我们定义D50etfOptionDataSource类：
import numpy as np
import akshare as ak
class Sh50etfOptionDataSource(object):
CALL_OPTION_IDX = 0
PUT_OPTION_IDX = 1
CALL_OPTION = 101 # 认购期权
PUT_OPTION = 102 # 认沽期权
def __init__(self):
self.refl = ''
self.symbol = '50ETF'
self.underlying = '510050'
def get_data(self):
print('获取50ETF期权日行情数据')
option_dict = {}
expire_months = self.get_expire_months()
option_codes = self.get_option_codes(expire_months[1])
dates_set = set()
for option_code in option_codes[Sh50etfOptionDataSource.\
CALL_OPTION_IDX]:
option_dict[option_code] = self.get_option_daily_quotation(
option_code, Sh50etfOptionDataSource.CALL_OPTION
)
for option_code in option_codes[Sh50etfOptionDataSource.\
PUT_OPTION_IDX]:
option_dict[option_code] = self.get_option_daily_quotation(
option_code, Sh50etfOptionDataSource.PUT_OPTION
)
return option_dict
def get_expire_months(self):
''' 获取合约到期月份 '''
return ak.option_sina_sse_list(
symbol=self.symbol, exchange="null")
def get_option_codes(self, trade_date):
'''
获取指定月份的期权合约列表
'''
return ak.option_sina_sse_codes(trade_date=trade_date,
underlying=self.underlying)
def get_option_daily_quotation(self, option_code, option_type):
df = ak.option_sina_sse_daily(code=option_code)
X = []
dates = df['日期']
opens = df['开盘']
highs = df['最高']
lows = df['最低']
closes = df['收盘']
volumes = df['成交']
for i in range(len(dates)):
if Sh50etfOptionDataSource.CALL_OPTION == option_type:
X.append([
dates[i], 0.0, 0.0, 0.0,
opens[i], highs[i],
lows[i], closes[i], volumes[i]
])
elif Sh50etfOptionDataSource.CALL_OPTION == option_type:
X.append([
dates[i], 1.0, 0.0, 0.0,
opens[i], highs[i],
lows[i], closes[i], volumes[i]
])
return np.array(X)
第17行：定义一个字典用来存50ETF行情数据，键值为合约编号，值为numpy的数组，每一行代表该天所有合约的行情数据；
第18行：获取合约到期月份列表，例如在8月调用时，会返回8月、9月、12月、次年3月；
第19行：由于次月到期的期权合约交易最活跃，因此我们只获取次月到期的期权合约编号列表；
第20行：我们的主循环是按日期进行循环的，我们将所有日期加入到date_set中，然后进行排序，作为系统日历的日期；
第21~25行：循环认购期权合约编号，以其为键，值为每一行的期权合约行情数据，其中第1列为日期，第2到4列为期权类型，目前0,0,0代表认购期权，1,0,0代表认沽期权，剩余列分别为：开盘、最高、最低、收盘、交易量数据；
第26~30行：同理处理认沽期权；
测试用例如下所示：
import unittest
from apps.sop.sh50etf_option_data_source import Sh50etfOptionDataSource
class TSh50etfOptionDataSource(unittest.TestCase):
@classmethod
def setUp(cls):
pass
@classmethod
def tearDown(cls):
pass
def test_get_expire_months(self):
ds = Sh50etfOptionDataSource()
expire_months = ds.get_expire_months()
print(expire_months)
def test_get_option_codes(self):
ds = Sh50etfOptionDataSource()
trade_date = '202009'
option_contracts = ds.get_option_codes(trade_date)
print(option_contracts)
def test_get_option_daily_quotation(self):
ds = Sh50etfOptionDataSource()
option_code = '10002423'
X = ds.get_option_daily_quotation(option_code)
print('X: {0};'.format(X.shape))
print(X)
def test_get_data(self):
ds = Sh50etfOptionDataSource()
option_dict = ds.get_data()
for key in option_dict.keys():
ocs = option_dict[key]
print(ocs)
break
下面我们将所获取到数据转化为数据集形式，同时从其中找出日期列表，我们来定义Sh50etfDataset类：
class Sh50etfDataset(Dataset.Dataset):
def init(self):
self.X, self.y, self.r = self._load_dataset()
def __len__(self):
return self.X.shape[0]
def __getitem__(self, index):
return self.X[index], self.y[index], self.r[index]
def _load_dataset(self):
d_50etf = Sh50etfOptionDataSource()
option_dict = d_50etf.get_data()
# 获取日期列表
date_set = set()
self.key_list = []
for key in option_dict.keys():
self.key_list.append(key)
for oc in option_dict[key]:
date_set.add(oc[0])
self.dates = list(date_set)
list.sort(self.dates, reverse=False)
list.sort(self.key_list, reverse=False)
raw_X = []
for idx in range(len(self.dates)):
date_row = []
for key in self.key_list:
oc = option_dict[key]
if len(oc) > idx:
date_row += [float(oc[idx][1]), float(oc[idx][2]),
float(oc[idx][3]), float(oc[idx][4]),
float(oc[idx][5]), float(oc[idx][5]),
float(oc[idx][6]), float(oc[idx][7])]
else:
date_row += [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
raw_X.append(date_row)
X = np.array(raw_X, dtype=np.float32)
y = np.zeros((len(self.dates),))
r = np.zeros((len(self.dates),))
return torch.from_numpy(X), torch.from_numpy(y), torch.from_numpy(r)
第2~9行：继承自pytorch的Dataset基类，并提供了__len__和__getitem__方法实现；
第11行：定义调用Sh50etfOptionDataSource和Sh50etfIndexDataSource来获取数据，形成可以用于强化学习的数据集。我们在这里先介绍调用Sh50etfOptionDataSource类来获取期权数据；
第12、13行：调用Sh50etfOptionDataSource来获取如下格式的期权日行情数据：
{
期权合约编号1: [
‘2020-06-01’, 0.0, 0.0, 0.0, 1.1, 2.1, 3.1, 4.1, 888,
‘2020-06-02’, 0.0, 0.0,0.0, 1.1. 2.1, 3.1, 4.1, 888,
…
],
…
}
其为一个字典，键为期权合约编号，值为其日行情列表，每一行为一个日行情数据，其中第1列为日期，第2至4列代表是认购还是认沽合约，后面列依次为开盘、最高、最低、收盘、交易量，此处为原始数据，并没有进行归一化；
第15~23行：求出日期列表和合约列表，都进行从小到大排序；
第25~36行：将当天的所有期权合约行情数据，按照合约编号从小到大依次排列，作为一个数据集的样本；
第37行：将样本设计矩阵（Design Matrix）变为numpy数组；
第38行：y为监督学习的标签，在强化学习中代表所采取的行动；
第39行：对于强化学习，r代表在上一时间点采取行动后，环境返回给Agent的奖励信号；
第40行：以Tensor对象形式返回样本集、标签集（行动集）和奖励集；
测试程序如下所示：
class TSh50etfDataset(unittest.TestCase):
@classmethod
def setUp(cls):
pass
@classmethod
def tearDown(cls):
pass
def test_getitem(self):
ds = Sh50etfDataset()
dataloader = DataLoader.DataLoader(ds, batch_size= 2,
shuffle = True, num_workers= 4)
for idx, (X, y) in enumerate(dataloader):
print('{0}: {1} => {2}; {3};'.format(idx, X, y, type(y)))
print('数量：{0};'.format(ds.__len__()))
X, y = ds.__getitem__(3)
print('样本：{0} => {1};'.format(X, y))
def test__load_dataset(self):
ds = Sh50etfDataset()
print('X: {0};'.format(ds.X.shape))
print('y: {0};'.format(ds.y.shape))
运行命令
python -m unittest uts.apps.sop.t_sh50etf_dataset.TSh50etfDataset.test__load_data -v
运行结果如下所示：
test__load_dataset (uts.apps.sop.t_sh50etf_dataset.TSh50etfDataset) … 获取50ETF期权日行情数据
X: torch.Size([141, 368]);
y: torch.Size([141]);
ok
这表示我们共有141个日期，每个日期共有368个期权合约的行情数据。
更新环境主循环
我们现在终于有真实的行情数据，我们现在来修改一下主循环的逻辑，依次显示各个交易日，如下所示：
class SopEnv(gym.Env):
def startup(self, args={}):
self.ds = Sh50etfDataset()
self.reset()
obs, reward, done, info = self._next_observation(), 0, False, {}
for dt in self.ds.dates:
print(’{0}: ‘.format(dt))
action = {}
obs, reward, done, info = self.step(action)
X = obs[‘X’].cpu().numpy()
y = obs[‘y’].cpu().numpy()
r = obs[‘r’].cpu().numpy()
print(’ X:{0}; y:{1}; r:{2}’.format(X.shape,
y, r
))
self.tick += 1
def _next_observation(self):
X, y, r = self.ds.__getitem__(self.tick)
return {'X': X, 'y': y, 'r': r}
运行程序可以得到如下结果：
重置环境到初始状态
2020-01-23:
X:(368,); y:0.0; r:0.0
2020-02-03:
X:(368,); y:0.0; r:0.0
我们目前获取了期权合约的行情数据，在实际应用中，我们需要获取期权合约的Black-Scholes估计价格、恐慌指数VIX和希腊字母Greeks信息。由于Black-Scholes和VIX需要额外计算，但是可以直接获取到Greeks信息，因此我们可以把Greeks加入到每个合约的行情数据后面。这个可以作为系统未来的一个可以扩充的功能点，我们在这里就先不实现了。
在下一篇博文中，我们将获取50ETF期权的标的物50ETF指数日行情数据，并且将其加入到合约日行情数据中。
扫一扫
1822
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
