तंत्रिका नेटवर्क और डिजिटल मुद्राओं के लिए क्वांटिफाइड लेनदेन श्रृंखला ((1) LSTM बिटकॉइन की कीमत का पूर्वानुमान

1.简单介绍

गहरे तंत्रिका नेटवर्क इन वर्षों में तेजी से लोकप्रिय हो रहे हैं, कई क्षेत्रों में हल करने के लिए एक मजबूत क्षमता का प्रदर्शन किया है; समय अनुक्रम के पूर्वानुमान पर, आम तौर पर इस्तेमाल किया तंत्रिका नेटवर्क की कीमत RNN है, क्योंकि RNN न केवल वर्तमान डेटा इनपुट है, लेकिन यह भी ऐतिहासिक डेटा इनपुट है, और निश्चित रूप से, जब हम आरएनएन मूल्य भविष्यवाणी के बारे में बात करते हैं, तो हम अक्सर आरएनएन के एक प्रकार के बारे में बात कर रहे हैंः LSTM; इस लेख में pytorch के आधार पर बिटकॉइन मूल्य का अनुमान लगाने के लिए मॉडल का निर्माण किया जाएगा; हालांकि ऑनलाइन संबंधित जानकारी बहुत अधिक है, लेकिन यह पर्याप्त नहीं है, pytorch का उपयोग करना भी अपेक्षाकृत कम है, एक सकारात्मक लेख भी आवश्यक है, अंततः परिणाम एक व्यक्तिगत मूल्य नेटवर्क का उपयोग करना है। यह ट्यूटोरियल एफएमजेड के आविष्कारक डिजिटल मुद्राओं के लिए क्वांटिफाइड ट्रेडिंग प्लेटफॉर्म द्वारा प्रस्तुत किया गया है।www.fmz.com), QQ समूह में आपका स्वागत हैः 863946592 ।

2.数据和参考

एक प्रासंगिक मूल्य भविष्यवाणी का उदाहरणःhttps://yq.aliyun.com/articles/538484RNN मॉडल के बारे में अधिक जानकारी के लिएःhttps://zhuanlan.zhihu.com/p/27485750RNN के इनपुट और आउटपुट को समझेंःhttps://www.zhihu.com/question/41949741/answer/318771336pytorch के बारे मेंः आधिकारिक दस्तावेजhttps://pytorch.org/docsअन्य जानकारी के लिए स्वयं खोजें । इस लेख को पढ़ने के लिए कुछ पूर्व ज्ञान की आवश्यकता है, जैसे कि पांडा / रेंगने वाले / डेटा प्रसंस्करण आदि, लेकिन इससे कोई फर्क नहीं पड़ता।

3.pytorch LSTM मॉडल के पैरामीटर

LSTM के पैरामीटरः

पहली बार जब मैंने दस्तावेजों में इन संकीर्ण पैरामीटरों को देखा, तो मेरी प्रतिक्रिया थीःधीरे-धीरे पढ़ते हुए, आप शायद समझ गए होंगे।

input_size: इनपुट वेक्टर x का विशेषता आकार, यदि समापन मूल्य के साथ समापन मूल्य का अनुमान लगाया जाता है, तो इनपुट_साइज = 1; यदि समापन मूल्य के साथ उच्च खोलने और कम करने का अनुमान लगाया जाता है, तो इनपुट_साइज = 4hidden_sizeनिहित परत का आकारःnum_layersआरएनएन की परतेंःbatch_first: यदि True के लिए आयाम दर्ज करने के लिए पहला batch_size है, तो यह पैरामीटर भी भ्रमित करने वाला है, जिसे नीचे विस्तार से बताया गया है।

इनपुट डेटा पैरामीटरः

input: विशिष्ट इनपुट किया गया डेटा, एक तीन आयामी टेन्सर है, जिसका विशिष्ट आकार हैः ((seq_len, batch, input_size)); इसमें, sec_len अनुक्रमणिका की लंबाई, यानी LSTM को विचार करने की आवश्यकता है कि ऐतिहासिक डेटा कितना समय है, ध्यान दें कि यह केवल डेटा के प्रारूप को संदर्भित करता है, न कि LSTM की आंतरिक संरचना, एक ही LSTM मॉडल में विभिन्न sec_len डेटा इनपुट किया जा सकता है, जो सभी अनुमानित परिणाम दे सकते हैं; बैच का आकार, जो विभिन्न डेटा समूहों का प्रतिनिधित्व करता है; इनपुट_साइज पहले के इनपुट_साइज है।h_0: प्रारंभिक छिपी हुई स्थिति, जिसका आकार ((num_layers * num_directions, batch, hidden_size) है, यदि दो-तरफ़ा नेटवर्क num_directions=2c_0: प्रारंभिक सेल स्थिति, आकार समान, निर्दिष्ट नहीं किया जा सकता है.

आउटपुट पैरामीटरः

output: आउटपुट आकार (seq_len, batch, num_directions * hidden_size), ध्यान और मॉडल पैरामीटर batch_first से संबंधित हैh_n: t = seq_len क्षण में h स्थिति, h_0 के समान आकारc_n: t = seq_len क्षण में स्थिति c, आकार समान c_0

4.LSTM输入输出的简单例子

सबसे पहले, आवश्यक पैकेज आयात करें

import pandas as pd
import numpy as np
import torch
import torch.nn as nn
import matplotlib.pyplot as plt

एलएसटीएम मॉडल को परिभाषित करना

LSTM = nn.LSTM(input_size=5, hidden_size=10, num_layers=2, batch_first=True)

डेटा इनपुट के लिए तैयार

x = torch.randn(3,4,5)
# x的值为:
tensor([[[ 0.4657,  1.4398, -0.3479,  0.2685,  1.6903],
         [ 1.0738,  0.6283, -1.3682, -0.1002, -1.7200],
         [ 0.2836,  0.3013, -0.3373, -0.3271,  0.0375],
         [-0.8852,  1.8098, -1.7099, -0.5992, -0.1143]],

        [[ 0.6970,  0.6124, -0.1679,  0.8537, -0.1116],
         [ 0.1997, -0.1041, -0.4871,  0.8724,  1.2750],
         [ 1.9647, -0.3489,  0.7340,  1.3713,  0.3762],
         [ 0.4603, -1.6203, -0.6294, -0.1459, -0.0317]],

        [[-0.5309,  0.1540, -0.4613, -0.6425, -0.1957],
         [-1.9796, -0.1186, -0.2930, -0.2619, -0.4039],
         [-0.4453,  0.1987, -1.0775,  1.3212,  1.3577],
         [-0.5488,  0.6669, -0.2151,  0.9337, -1.1805]]])

x का आकार है ((3,4,5) जैसा कि हमने पहले परिभाषित किया है।batch_first=True, इस समय बैच_साइज़ 3 है, sqe_len 4 है, और input_size 5 है; x[0] पहले बैच का प्रतिनिधित्व करता है।

यदि batch_first को डिफ़ॉल्ट रूप से False के रूप में परिभाषित नहीं किया गया है, तो इस समय डेटा का प्रतिनिधित्व पूरी तरह से अलग है, बैच का आकार 4, sqe_len 3, और input_size 5 है। इस समय x[0] सभी बैचों का प्रतिनिधित्व करता है जब t = 0 डेटा, क्रमशः अनुमान लगाया जाता है। व्यक्ति को लगता है कि यह सेटिंग सहज ज्ञान युक्त नहीं है, इसलिए पैरामीटर जोड़े गए हैं।batch_first=True.

यह भी आसान है कि डेटा को दोनों के बीच परिवर्तित किया जा सकेःx.permute(1,0,2)

इनपुट और आउटपुट

एलएसटीएम के इनपुट और आउटपुट के आकार को समझने में मदद करने के लिए नीचे दिए गए चित्रों का उपयोग करना आसान हैः
स्रोतःhttps://www.zhihu.com/question/41949741/answer/318771336

x = torch.randn(3,4,5)
h0 = torch.randn(2, 3, 10)
c0 = torch.randn(2, 3, 10)
output, (hn, cn) = LSTM(x, (h0, c0))
print(output.size()) #在这里思考一下,如果batch_first=False输出的大小会是多少?
print(hn.size())
print(cn.size())
#结果
torch.Size([3, 4, 10])
torch.Size([2, 3, 10])
torch.Size([2, 3, 10])

देखा गया आउटपुट परिणाम, पिछले पैरामीटर की व्याख्या के अनुरूप है। ध्यान दें किhn.size))) का दूसरा मान 3 है, और batch_size का आकार संगत है, यह दर्शाता है किhn में कोई मध्यवर्ती स्थिति संग्रहीत नहीं है, केवल अंतिम चरण संग्रहीत है। चूंकि हमारे एलएसटीएम नेटवर्क में दो परतें हैं, इसलिए अंतिम परत का आउटपुट आउटपुट का मान है, और आउटपुट का आकार [3, 4, 10] है, जो t = 0, 1, 2, 3 के सभी समय के परिणामों को संग्रहीत करता है, इसलिएः

hn[-1][0] == output[0][-1] #第一个batch在hn最后一层的输出等于第一个batch在t=3时output的结果
hn[-1][1] == output[1][-1]
hn[-1][2] == output[2][-1]

5.准备比特币行情数据

बहुत कुछ पहले ही कहा गया है, लेकिन यह समझना महत्वपूर्ण है कि एलएसटीएम के इनपुट और आउटपुट को समझना महत्वपूर्ण है, अन्यथा इंटरनेट से कुछ कोड निकालने में गलती हो सकती है, क्योंकि एलएसटीएम की समय अनुक्रम पर मजबूत क्षमता के कारण, मॉडल गलत होने पर भी अंत में अच्छे परिणाम प्राप्त कर सकता है।

डेटा प्राप्त करना

डेटा का उपयोग Bitfinex एक्सचेंज के BTC_USD ट्रेडिंग जोड़े के बाजार डेटा से किया जाता है।

import requests
import json

resp = requests.get('https://q.fmz.com/chart/history?symbol=bitfinex.btc_usd&resolution=15&from=0&to=0&from=1525622626&to=1562658565')
data = resp.json()
df = pd.DataFrame(data,columns = ['t','o','h','l','c','v'])
print(df.head(5))

डेटा प्रारूप इस प्रकार हैः

डेटा का पूर्व प्रसंस्करण

df.index = df['t'] # index设为时间戳
df = (df-df.mean())/df.std() # 数据的标准化,否则模型的Loss会非常大,不利于收敛
df['n'] = df['c'].shift(-1) # n为下一个周期的收盘价,是我们预测的目标
df = df.dropna()
df = df.astype(np.float32) # 改变下数据格式适应pytorch

डेटा को मानकीकृत करने का तरीका बहुत कठोर है और कुछ समस्याएं हो सकती हैं, केवल प्रदर्शन के लिए, डेटा मानकीकरण जैसे कि रिटर्न का उपयोग किया जा सकता है।

प्रशिक्षण डेटा तैयार करें

seq_len = 10 # 输入10个周期的数据
train_size = 800 # 训练集batch_size
def create_dataset(data, seq_len):
    dataX, dataY=[], []
    for i in range(0,len(data)-seq_len, seq_len):
        dataX.append(data[['o','h','l','c','v']][i:i+seq_len].values)
        dataY.append(data['n'][i:i+seq_len].values)
    return np.array(dataX), np.array(dataY)
data_X, data_Y = create_dataset(df, seq_len)
train_x = torch.from_numpy(data_X[:train_size].reshape(-1,seq_len,5)) #变化形状,-1代表的值会自动计算
train_y = torch.from_numpy(data_Y[:train_size].reshape(-1,seq_len,1))

अंतिम train_x और train_y के आकार क्रमशःः torch.Size (([800, 10, 5]), torch.Size (([800, 10, 1]) । चूंकि हमारा मॉडल 10 चक्रों के डेटा के आधार पर अगले चक्र के समापन मूल्य की भविष्यवाणी करता है, इसलिए सैद्धांतिक रूप से 800 बैचों के लिए 800 पूर्वानुमानित समापन मूल्य के लिए पर्याप्त है । लेकिन train_y में प्रत्येक बैच में 10 डेटा हैं, और वास्तव में प्रत्येक बैच की भविष्यवाणी का मध्य परिणाम केवल अंतिम नहीं है । अंतिम हानि की गणना करते समय, सभी 10 भविष्यवाणियों के परिणामों को अंतिम हानि और train_y में वास्तविक मूल्य की तुलना के लिए ध्यान में रखा जा सकता है । सैद्धांतिक रूप से, केवल अंतिम भविष्यवाणियों के परिणामों की गणना की जा सकती है । इस समस्या का एक मोटा चित्रण करना उचित है । क्योंकि वास्तविक LSTM मॉडल में seqlen_seqlen पैरामीटर शामिल नहीं है, मॉडल विभिन्न आयामों के लिए उपयुक्त है, और इसलिए मैं मध्य भविष्यवाणियों की गणना की ओर झुकाव रखता हूं ।

ध्यान दें कि प्रशिक्षण डेटा तैयार करते समय, खिड़कियों का स्थानांतरण कूदता है, पहले से उपयोग किए गए डेटा का उपयोग नहीं किया जाता है, और निश्चित रूप से खिड़कियों को व्यक्तिगत रूप से भी स्थानांतरित किया जा सकता है, जिससे प्रशिक्षण सभाएं बहुत अधिक हो जाती हैं। लेकिन यह महसूस होता है कि इस तरह के आसन्न बैच डेटा बहुत दोहराए जाते हैं, इसलिए वर्तमान विधि को अपनाया जाता है।

6.构造LSTM模型

अंततः बनाया गया मॉडल इस प्रकार है, जिसमें एक दो-स्तरीय एलएसटीएम, एक रैखिक परत शामिल है।

class LSTM(nn.Module):
    def __init__(self, input_size, hidden_size, output_size=1, num_layers=2):
        super(LSTM, self).__init__()
        self.rnn = nn.LSTM(input_size,hidden_size,num_layers,batch_first=True)
        self.reg = nn.Linear(hidden_size,output_size) # 线性层,把LSTM的结果输出成一个值

    def forward(self, x):
        x, _ = self.rnn(x) # 如果不理解前向传播中数据维度的变化,可单独调试
        x = self.reg(x)
        return x
        
net = LSTM(5, 10) # input_size为5,代表了高开低收和交易量. 隐含层为10.

7.开始训练模型

एक बार जब हम अपने बच्चों को पढ़ाते हैं, तो हम अपने बच्चों को पढ़ाते हैं।

criterion = nn.MSELoss() # 使用了简单的均方差损失函数
optimizer = torch.optim.Adam(net.parameters(),lr=0.01) # 优化函数,lr可调
for epoch in range(600): # 由于速度很快,这里的epoch多一些
    out = net(train_x) # 由于数据量很小, 直接拿全量数据计算
    loss = criterion(out, train_y)
    optimizer.zero_grad()
    loss.backward() # 反向传播损失
    optimizer.step() # 更新参数
    print('Epoch: {:<3}, Loss:{:.6f}'.format(epoch+1, loss.item()))

प्रशिक्षण के परिणाम इस प्रकार हैं:

8.模型评价

मॉडल का अनुमानः

p = net(torch.from_numpy(data_X))[:,-1,0] # 这里只取最后一个预测值作为比较
plt.figure(figsize=(12,8))
plt.plot(p.data.numpy(), label= 'predict')
plt.plot(data_Y[:,-1], label = 'real')
plt.legend()
plt.show()

जैसा कि चित्र से पता चलता है, प्रशिक्षण डेटा (पहले 800) का मिलान बहुत अधिक है, लेकिन बाद में बिटकॉइन की कीमत में वृद्धि हुई है, मॉडल ने इन आंकड़ों को नहीं देखा है, और भविष्यवाणी करने के लिए कोई प्रयास नहीं किया है। इससे यह भी पता चलता है कि पहले डेटा मानकीकरण में समस्याएं थीं। हालांकि अनुमानित कीमतें हमेशा सटीक नहीं होती हैं, लेकिन गिरावट की भविष्यवाणी करने की सटीकता के बारे में क्या?

r = data_Y[:,-1][800:1000]
y = p.data.numpy()[800:1000]
r_change = np.array([1 if i > 0 else 0 for i in r[1:200] - r[:199]])
y_change = np.array([1 if i > 0 else 0 for i in y[1:200] - r[:199]])
print((r_change == y_change).sum()/float(len(r_change)))

नतीजतन, गिरावट की भविष्यवाणी 81.4% सटीकता तक पहुंच गई, जो मेरी अपेक्षाओं से अधिक थी।

बेशक, इस मॉडल का कोई वास्तविक मूल्य नहीं है, लेकिन यह सरल है, और इसके साथ ही, डिजिटल मुद्राओं में क्वांटिफाइंग के लिए और अधिक प्रारंभिक पाठ्यक्रमों के साथ आने वाले न्यूरल नेटवर्क का परिचय।