कृपया ध्यान देंः यह मामला केवल अध्ययन और अनुसंधान के लिए है और निवेश के लिए सलाह नहीं है।

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

लॉन्ग शॉर्ट-टर्म मेमोरी (LSTM) एक डीप लर्निंग मॉडल है जो विशेष रूप से टाइम सीक्वेंस डेटा (या समय / स्थानिक / संरचनात्मक अनुक्रम के साथ डेटा, जैसे कि फिल्म, वाक्य आदि) के लिए उपयुक्त है, जो क्रिप्टोकरेंसी की कीमत की दिशा की भविष्यवाणी करने के लिए आदर्श मॉडल है।

यह लेख मुख्य रूप से भविष्य में बिटकॉइन की कीमतों की भविष्यवाणी करने के लिए एलएसटीएम के माध्यम से डेटा को संरेखित करने के बारे में है।

आयात करने के लिए आवश्यक लाइब्रेरी

import pandas as pd
import numpy as np

from sklearn.preprocessing import MinMaxScaler, LabelEncoder
from keras.models import Sequential
from keras.layers import LSTM, Dense, Dropout

from matplotlib import pyplot as plt
%matplotlib inline

डेटा विश्लेषण

लोड किया गया

बीटीसी के लिए दैनिक ट्रेडिंग डेटा पढ़ें

data = pd.read_csv(filepath_or_buffer="btc_data_day")

डेटा को देखने के लिए उपलब्ध है, वर्तमान में कुल 1380 डेटा हैं, डेटा को दिनांक, ओपन, हाई, लो, क्लोज, वॉल्यूम, बीटीसी, वॉल्यूम, मुद्रा और वजनित मूल्य से बना है। इसमें दिनांक को छोड़कर, अन्य सभी डेटा फ़्लोट 64 डेटा प्रकार के हैं।

data.info()

पहले 10 पंक्तियों को देखें

data.head(10)

डेटा दृश्य

matplotlib का उपयोग करें और वजनित मूल्य को रेखांकित करें और देखें कि डेटा कैसे वितरित किया गया है। हम डेटा 0 के एक हिस्से को देखते हैं और हमें यह सत्यापित करना होगा कि क्या डेटा में कोई असामान्यता है।

plt.plot(data['Weighted Price'], label='Price')
plt.ylabel('Price')
plt.legend()
plt.show()

असामान्य डेटा प्रोसेसिंग

और अगर हम देखेंगे कि हमारे डेटा में नैनो डेटा है, तो हम देखेंगे कि हमारे डेटा में नैनो डेटा नहीं है.

data.isnull().sum()

Date                 0
Open                 0
High                 0
Low                  0
Close                0
Volume (BTC)         0
Volume (Currency)    0
Weighted Price       0
dtype: int64

और फिर हम 0 के आंकड़े को देखते हैं, और हम देख सकते हैं कि हमारे आंकड़ों में 0 है, और हमें 0 के साथ क्या करना है

(data == 0).astype(int).any()

Date                 False
Open                  True
High                  True
Low                   True
Close                 True
Volume (BTC)          True
Volume (Currency)     True
Weighted Price        True
dtype: bool

data['Weighted Price'].replace(0, np.nan, inplace=True)
data['Weighted Price'].fillna(method='ffill', inplace=True)
data['Open'].replace(0, np.nan, inplace=True)
data['Open'].fillna(method='ffill', inplace=True)
data['High'].replace(0, np.nan, inplace=True)
data['High'].fillna(method='ffill', inplace=True)
data['Low'].replace(0, np.nan, inplace=True)
data['Low'].fillna(method='ffill', inplace=True)
data['Close'].replace(0, np.nan, inplace=True)
data['Close'].fillna(method='ffill', inplace=True)
data['Volume (BTC)'].replace(0, np.nan, inplace=True)
data['Volume (BTC)'].fillna(method='ffill', inplace=True)
data['Volume (Currency)'].replace(0, np.nan, inplace=True)
data['Volume (Currency)'].fillna(method='ffill', inplace=True)

(data == 0).astype(int).any()

Date                 False
Open                 False
High                 False
Low                  False
Close                False
Volume (BTC)         False
Volume (Currency)    False
Weighted Price       False
dtype: bool

और फिर हम देखेंगे कि यह कैसे फैला हुआ है, और इस बार यह बहुत ही लगातार है.

plt.plot(data['Weighted Price'], label='Price')
plt.ylabel('Price')
plt.legend()
plt.show()

प्रशिक्षण डेटासेट और परीक्षण डेटासेट विभाजन

डेटा को 0-1 में समेकित करें

data_set = data.drop('Date', axis=1).values
data_set = data_set.astype('float32')
mms = MinMaxScaler(feature_range=(0, 1))
data_set = mms.fit_transform(data_set)

परीक्षण डेटासेट और प्रशिक्षण डेटासेट को 2:8 से विभाजित करें

ratio = 0.8
train_size = int(len(data_set) * ratio)
test_size = len(data_set) - train_size
train, test = data_set[0:train_size,:], data_set[train_size:len(data_set),:]

हमारे प्रशिक्षण डेटासेट और परीक्षण डेटासेट बनाने के लिए एक दिन की विंडो अवधि का उपयोग करें।

def create_dataset(data):
    window = 1
    label_index = 6
    x, y = [], []
    for i in range(len(data) - window):
        x.append(data[i:(i + window), :])
        y.append(data[i + window, label_index])
    return np.array(x), np.array(y)

train_x, train_y = create_dataset(train)
test_x, test_y = create_dataset(test)

मॉडल को परिभाषित करें और प्रशिक्षित करें

इस बार हम एक साधारण मॉडल का उपयोग कर रहे हैं, और यह मॉडल इस प्रकार है 1. LSTM2. Dense。

यहाँ एलएसटीएम के इनपुट आकार के बारे में स्पष्टीकरण की आवश्यकता है, इनपुट आकार का इनपुट आयाम है ((batch_size, time steps, features)) । इसमें, time steps का मान डेटा इनपुट के समय की समय खिड़की का अंतराल है, यहाँ हम 1 दिन का उपयोग समय खिड़की के रूप में करते हैं, और हमारे डेटा दिन के डेटा हैं, इसलिए हमारे time steps यहाँ 1 हैं ।

लंबी अल्पकालिक स्मृति (LSTM) एक विशेष प्रकार का RNN है, जो मुख्य रूप से लंबे अनुक्रम प्रशिक्षण के दौरान ग्रेडिएंट विलुप्त होने और ग्रेडिएंट विस्फोट की समस्याओं को हल करने के लिए है।

एलएसटीएम के नेटवर्क ढांचे के आरेख से, यह देखा जा सकता है कि एलएसटीएम वास्तव में एक छोटा सा मॉडल है जिसमें 3 सिग्मोइड सक्रियण फ़ंक्शन, 2 तन्हा सक्रियण फ़ंक्शन, 3 गुणा और 1 जोड़ शामिल हैं।

सेल स्थिति

कोशिका अवस्था LSTM के केंद्र में है, वह ऊपर की रेखा में सबसे ऊपर है, और उस काले रेखा के नीचे कुछ दरवाजे हैं, जिन्हें हम बाद में प्रस्तुत करेंगे। कोशिका अवस्था प्रत्येक दरवाजे के परिणामों के आधार पर अद्यतन की जाएगी। नीचे हम उन दरवाजों को प्रस्तुत करते हैं, ताकि आप कोशिका अवस्था की प्रक्रिया को समझ सकें।

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

भूल का द्वार

LSTM का पहला कदम यह निर्धारित करना है कि कौन सी जानकारी को कोशिका की स्थिति को त्यागने की आवश्यकता है। यह एक सिग्मोइड इकाई द्वारा संसाधित किया जाता है जिसे भूलने के द्वार कहा जाता है।

हम देख सकते हैं कि विस्मृति द्वार \(h_{l-1}\) और \(x_{t}\) जानकारी को देखते हुए 0-1 के बीच एक वेक्टर को आउटपुट करता है, जिसमें 0-1 का मान यह दर्शाता है कि सेल स्थिति \(C_{t-1}\) में कौन सी जानकारी को रखा गया है या कितना फेंक दिया गया है। 0 को नहीं रखा गया है और 1 को रखा गया है।

\(f_{t} =\sigma\left(W_{f} \cdot\left[h_{t-1}, x_{t}\right]+b_{f}\right)\)

प्रवेश द्वार

अगला कदम यह तय करना है कि कौन सी नई जानकारी को सेल स्टेटस में जोड़ा जाना है, और यह कदम इनपुट गेट खोलने के द्वारा किया जाता है।

हम देखते हैं कि \(h_{l-1}\) और \(x_{t}\) का संदेश एक भूलने के दरवाजे (sigmoid) और इनपुट दरवाजे (tanh) में डाला जाता है। क्योंकि भूलने के दरवाजे का आउटपुट 0-1 का मान है, इसलिए, यदि भूलने के दरवाजे का आउटपुट 0 है, तो इनपुट दरवाजे के बाद का परिणाम \(C_{i}\) वर्तमान सेल स्थिति में नहीं जोड़ा जाएगा, यदि यह 1 है, तो यह सब सेल स्थिति में जोड़ा जाएगा, इसलिए यहां भूलने के दरवाजे का कार्य इनपुट दरवाजे के परिणाम को चयनित रूप से सेल स्थिति में जोड़ना है।

\(C_{t}=f_{t} * C_{t-1}+i_{t} *\tilde{C}_{t}\)

बाहर निकलें

सेल की स्थिति को अपडेट करने के बाद, यह निर्धारित करने के लिए कि आउटपुट सेल की स्थिति क्या है, \(h_{l-1}\) और \(x_{t}\) इनपुट के योग के आधार पर निर्णय लेने की आवश्यकता है। यहां इनपुट को आउटपुट गेट नामक सिग्मोइड परत से आंका जाना चाहिए, फिर सेल की स्थिति को टैन्ह परत से आंका जाना चाहिए, जो -1 से 1 के बीच का एक वेक्टर प्राप्त करता है। यह वेक्टर और आउटपुट गेट की प्राप्त शर्तों को गुणा करके अंतिम आरएनएन इकाई का आउटपुट प्राप्त होता है।

def create_model():
    model = Sequential()
    model.add(LSTM(50, input_shape=(train_x.shape[1], train_x.shape[2])))
    model.add(Dense(1))
    model.compile(loss='mae', optimizer='adam')
    model.summary()
    return model

model = create_model()

history = model.fit(train_x, train_y, epochs=80, batch_size=64, validation_data=(test_x, test_y), verbose=1, shuffle=False)

plt.plot(history.history['loss'], label='train')
plt.plot(history.history['val_loss'], label='test')
plt.legend()
plt.show()

train_x, train_y = create_dataset(train)
test_x, test_y = create_dataset(test)

भविष्यवाणी

predict = model.predict(test_x)
plt.plot(predict, label='predict')
plt.plot(test_y, label='ground true')
plt.legend()
plt.show()

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