Hãy sử dụng học tăng cường trong trí tuệ nhân tạo để tạo ra một robot giao dịch tiền điện tử

Trong bài viết này, chúng ta sẽ tạo và áp dụng một khuôn khổ học tăng cường để tìm hiểu cách tạo bot giao dịch Bitcoin. Trong hướng dẫn này, chúng ta sẽ sử dụng phòng tập thể dục của OpenAI và robot PPO từ thư viện stable-baselines, một nhánh của thư viện OpenAI baselines.

Xin chân thành cảm ơn OpenAI và DeepMind đã cung cấp phần mềm nguồn mở cho các nhà nghiên cứu học sâu trong vài năm qua. Nếu bạn chưa thấy những thành tựu tuyệt vời mà họ đã đạt được với các công nghệ như AlphaGo, OpenAI Five và AlphaStar, có thể bạn đã sống cô lập trong năm qua, nhưng bạn nên xem thử.

Đào tạo AlphaStar https://deepmind.com/blog/alphastar-mastering-real-time-strategy-game-starcraft-ii/

Mặc dù chúng tôi không tạo ra được điều gì ấn tượng, nhưng giao dịch bằng robot Bitcoin vẫn không phải là nhiệm vụ dễ dàng trong giao dịch hàng ngày. Tuy nhiên, như Teddy Roosevelt đã từng nói,

Những thứ có được quá dễ dàng thì không có giá trị.

Vì vậy, không chỉ học cách giao dịch cho chính mình…mà còn để robot giao dịch thay chúng ta.

kế hoạch

1. Tạo môi trường phòng tập thể dục để robot của chúng tôi thực hiện học máy

2. Tạo ra một môi trường trực quan đơn giản và thanh lịch

3. Đào tạo robot của chúng tôi để học một chiến lược giao dịch có lợi nhuận

Nếu bạn chưa quen với cách tạo môi trường phòng tập từ đầu hoặc cách đơn giản là kết xuất hình ảnh trực quan của những môi trường này. Bạn có thể thoải mái tìm kiếm bài viết như thế này trên Google trước khi tiếp tục. Hai hành động này sẽ không khó ngay cả với những lập trình viên mới bắt đầu.

Bắt đầu

Trong hướng dẫn này, chúng ta sẽ sử dụng bộ dữ liệu Kaggle do Zielak tạo ra. Nếu bạn muốn tải xuống mã nguồn, bạn có thể tìm thấy mã nguồn đó trong kho lưu trữ Github của tôi, cùng với tệp dữ liệu .csv. Được rồi, chúng ta bắt đầu thôi.

Đầu tiên, hãy nhập tất cả các thư viện cần thiết. Hãy đảm bảo cài đặt bất kỳ thư viện nào bạn còn thiếu bằng pip.

import gym
import pandas as pd
import numpy as np
from gym import spaces
from sklearn import preprocessing

Tiếp theo, chúng ta hãy tạo lớp cho môi trường. Chúng ta cần truyền vào một khung dữ liệu pandas, cũng như một initial_balance tùy chọn và một lookback_window_size sẽ quyết định số bước thời gian trong quá khứ mà robot sẽ quan sát ở mỗi bước. Chúng tôi mặc định mức hoa hồng cho mỗi giao dịch là 0,075%, mức giá hiện tại trên Bitmex và mặc định tham số serial là false, nghĩa là khung dữ liệu của chúng tôi sẽ được duyệt theo từng phần ngẫu nhiên theo mặc định.

Chúng tôi cũng gọi dropna() và reset_index() trên dữ liệu, trước tiên là để xóa các hàng có giá trị NaN và sau đó là để thiết lập lại chỉ mục cho số khung vì chúng tôi đã xóa dữ liệu.

class BitcoinTradingEnv(gym.Env):
  """A Bitcoin trading environment for OpenAI gym"""
  metadata = {'render.modes': ['live', 'file', 'none']}
  scaler = preprocessing.MinMaxScaler()
  viewer = None
def __init__(self, df, lookback_window_size=50, 
                         commission=0.00075,  
                         initial_balance=10000
                         serial=False):
    super(BitcoinTradingEnv, self).__init__()
self.df = df.dropna().reset_index()
    self.lookback_window_size = lookback_window_size
    self.initial_balance = initial_balance
    self.commission = commission
    self.serial = serial
# Actions of the format Buy 1/10, Sell 3/10, Hold, etc.
    self.action_space = spaces.MultiDiscrete([3, 10])
# Observes the OHCLV values, net worth, and trade history
    self.observation_space = spaces.Box(low=0, high=1, shape=(10, lookback_window_size + 1), dtype=np.float16)

Action_space của chúng ta được biểu diễn ở đây dưới dạng một tập hợp gồm 3 tùy chọn (mua, bán hoặc giữ) và một tập hợp khác gồm 10 số tiền (¹⁄₁₀, ²⁄₁₀, ³⁄₁₀, v.v.). Khi chọn hành động mua, chúng ta sẽ mua số lượng * giá trị cân bằng của BTC. Để bán, chúng tôi sẽ bán số lượng * self.btc_held trị giá BTC. Tất nhiên, hành động giữ lại sẽ bỏ qua số tiền và không có tác dụng gì cả.

Không gian quan sát của chúng tôi được định nghĩa là một tập hợp các số thực liên tục giữa 0 và 1, có hình dạng (10, lookback_window_size + 1). + 1 được sử dụng để tính bước thời gian hiện tại. Đối với mỗi bước thời gian trong cửa sổ, chúng ta sẽ quan sát giá trị OHCLV. Giá trị tài sản ròng của chúng tôi bằng số lượng BTC đã mua hoặc bán và tổng số tiền USD mà chúng tôi đã chi hoặc nhận được từ số BTC đó.

Tiếp theo, chúng ta cần viết phương thức reset để khởi tạo môi trường.

def reset(self):
  self.balance = self.initial_balance
  self.net_worth = self.initial_balance
  self.btc_held = 0
self._reset_session()
self.account_history = np.repeat([
    [self.net_worth],
    [0],
    [0],
    [0],
    [0]
  ], self.lookback_window_size + 1, axis=1)
self.trades = []
return self._next_observation()

Ở đây chúng ta sử dụng self._reset_session và self._next_observation, chúng tôi vẫn chưa định nghĩa chúng. Trước tiên chúng ta hãy định nghĩa chúng.

Phiên giao dịch

Một phần quan trọng trong môi trường của chúng ta là khái niệm về phiên giao dịch. Nếu chúng tôi triển khai bot này bên ngoài thị trường, có lẽ chúng tôi sẽ không bao giờ chạy nó quá vài tháng. Vì lý do này, chúng tôi sẽ giới hạn số khung hình liên tiếp trong self.df, tức là số khung hình mà robot của chúng tôi có thể nhìn thấy cùng một lúc.

Trong phương thức _reset_session, trước tiên chúng ta đặt lại current_step thành 0. Tiếp theo, chúng ta sẽ đặt steps_left thành một số ngẫu nhiên từ 1 đến MAX_TRADING_SESSION, mà chúng ta sẽ xác định ở đầu chương trình.

MAX_TRADING_SESSION = 100000 ＃ ~2个月

Tiếp theo, nếu chúng ta muốn lặp lại các khung liên tục, chúng ta phải thiết lập để lặp lại toàn bộ khung, nếu không, chúng ta sẽ đặt frame_start thành một điểm ngẫu nhiên trong self.df và tạo một khung dữ liệu mới có tên là active_df chỉ là self. Một lát cắt của df từ frame_start đến frame_start + steps_left.

def _reset_session(self):
  self.current_step = 0
if self.serial:
    self.steps_left = len(self.df) - self.lookback_window_size - 1
    self.frame_start = self.lookback_window_size
  else:
    self.steps_left = np.random.randint(1, MAX_TRADING_SESSION)
    self.frame_start = np.random.randint(self.lookback_window_size, len(self.df) - self.steps_left)
self.active_df = self.df[self.frame_start - self.lookback_window_size:self.frame_start + self.steps_left]

Một tác dụng phụ quan trọng của việc lặp lại số lượng khung dữ liệu trong phương pháp cắt ngẫu nhiên là robot của chúng ta sẽ có nhiều dữ liệu độc đáo hơn để sử dụng khi đào tạo trong thời gian dài. Ví dụ, nếu chúng ta chỉ lặp lại số lượng khung dữ liệu theo cách tuần tự (tức là theo thứ tự từ 0 đến len(df)), thì chúng ta sẽ chỉ có số điểm dữ liệu duy nhất bằng số lượng khung dữ liệu. Không gian quan sát của chúng ta thậm chí chỉ có thể áp dụng một số lượng trạng thái rời rạc tại mỗi bước thời gian.

Tuy nhiên, bằng cách lặp lại ngẫu nhiên qua các lát cắt của tập dữ liệu, chúng ta có thể tạo ra một tập hợp kết quả giao dịch có ý nghĩa hơn cho từng bước thời gian trong tập dữ liệu ban đầu, tức là kết hợp các hành động giao dịch và hành động giá đã thấy trước đó để tạo ra dữ liệu độc đáo hơn. Để tôi giải thích điều này bằng một ví dụ.

Tại bước thời gian thứ 10 sau khi thiết lập lại môi trường nối tiếp, robot của chúng ta sẽ luôn chạy đồng thời trong tập dữ liệu và sẽ có 3 lựa chọn sau mỗi bước thời gian: Mua, Bán hoặc Giữ. Đối với mỗi một trong ba lựa chọn này, đều có một lựa chọn khác: 10%, 20%, … hoặc 100% số tiền thực hiện cụ thể. Điều này có nghĩa là robot của chúng ta có thể gặp phải bất kỳ tình huống nào trong số 103 lũy thừa 10, tổng cộng là 1030 tình huống.

Bây giờ quay lại môi trường cắt ngẫu nhiên của chúng ta. Ở bước thời gian 10, robot của chúng ta có thể ở bất kỳ bước thời gian len(df) nào trong số khung dữ liệu. Giả sử cùng một lựa chọn được đưa ra sau mỗi bước thời gian, điều này có nghĩa là robot có thể trải qua bất kỳ trạng thái duy nhất nào của len(df)30 trong cùng 10 bước thời gian.

Mặc dù điều này có thể gây ra tiếng ồn đáng kể cho các tập dữ liệu lớn, tôi tin rằng nó sẽ cho phép robot học được nhiều hơn từ lượng dữ liệu hạn chế mà chúng ta có. Chúng tôi vẫn sẽ lặp lại dữ liệu thử nghiệm theo cách tuần tự để có được dữ liệu mới nhất, có vẻ như là ‘thời gian thực’ để hiểu chính xác hơn về hiệu quả của thuật toán.

Qua con mắt của một con robot

Việc có cái nhìn tổng quan trực quan về môi trường xung quanh thường rất hữu ích để hiểu được các loại chức năng mà robot của chúng ta sẽ sử dụng. Ví dụ, đây là hình ảnh trực quan về không gian quan sát được được hiển thị bằng OpenCV.

Quan sát môi trường trực quan hóa OpenCV

Mỗi hàng trong hình ảnh đại diện cho một hàng trong không gian quan sát của chúng ta. 4 dòng đầu tiên có tần số tương tự, đường màu đỏ biểu thị dữ liệu OHCL và các chấm màu cam và vàng ngay bên dưới biểu thị thể tích. Thanh màu xanh dao động bên dưới là vốn chủ sở hữu của bot, trong khi các thanh nhạt hơn bên dưới biểu thị các giao dịch của bot.

Nếu bạn quan sát kỹ, bạn thậm chí có thể tự tạo biểu đồ nến. Bên dưới thanh âm lượng là giao diện giống mã Morse hiển thị lịch sử giao dịch. Có vẻ như bot của chúng ta có thể học đầy đủ từ dữ liệu trong không gian quan sát, vậy nên chúng ta hãy tiếp tục. Ở đây chúng ta sẽ định nghĩa phương thức _next_observation trong đó chúng ta sẽ chia tỷ lệ dữ liệu quan sát được từ 0 đến 1.

• Điều quan trọng là chỉ mở rộng dữ liệu mà robot đã quan sát được cho đến nay để tránh sai lệch dự đoán.

def _next_observation(self):
  end = self.current_step + self.lookback_window_size + 1
obs = np.array([
    self.active_df['Open'].values[self.current_step:end],  
    self.active_df['High'].values[self.current_step:end],
    self.active_df['Low'].values[self.current_step:end],
    self.active_df['Close'].values[self.current_step:end],
    self.active_df['Volume_(BTC)'].values[self.current_step:end],])
scaled_history = self.scaler.fit_transform(self.account_history)
obs = np.append(obs, scaled_history[:, -(self.lookback_window_size + 1):], axis=0)
return obs

Hãy hành động

Bây giờ chúng ta đã thiết lập được không gian quan sát, đã đến lúc viết hàm bước và thực hiện các hành động mà robot dự định thực hiện. Bất cứ khi nào self.steps_left == 0 cho phiên giao dịch hiện tại của chúng ta, chúng ta sẽ bán số BTC đang nắm giữ và gọi reset session(). Nếu không, chúng ta sẽ đặt phần thưởng thành vốn chủ sở hữu hiện tại hoặc đặt thành Đúng nếu hết tiền.

def step(self, action):
  current_price = self._get_current_price() + 0.01
  self._take_action(action, current_price)
  self.steps_left -= 1
  self.current_step += 1
if self.steps_left == 0:
    self.balance += self.btc_held * current_price
    self.btc_held = 0
    self._reset_session()
obs = self._next_observation()
  reward = self.net_worth
  done = self.net_worth <= 0
return obs, reward, done, {}

Thực hiện hành động giao dịch đơn giản như lấy giá hiện tại, xác định hành động cần thực hiện và số lượng mua hoặc bán. Hãy nhanh chóng viết _take_action để chúng ta có thể kiểm tra môi trường của mình.

def _take_action(self, action, current_price):
  action_type = action[0]
  amount = action[1] / 10
btc_bought = 0
  btc_sold = 0
  cost = 0
  sales = 0
if action_type < 1:
    btc_bought = self.balance / current_price * amount
    cost = btc_bought * current_price * (1 + self.commission)
    self.btc_held += btc_bought
    self.balance -= cost
elif action_type < 2:
    btc_sold = self.btc_held * amount
    sales = btc_sold * current_price  * (1 - self.commission)
    self.btc_held -= btc_sold
    self.balance += sales

Cuối cùng, theo phương pháp tương tự, chúng ta sẽ thêm giao dịch vào self.trades và cập nhật vốn chủ sở hữu và lịch sử tài khoản của mình.

if btc_sold > 0 or btc_bought > 0:
    self.trades.append({
      'step': self.frame_start+self.current_step,
      'amount': btc_sold if btc_sold > 0 else btc_bought,
      'total': sales if btc_sold > 0 else cost,
      'type': "sell" if btc_sold > 0 else "buy"
    })
self.net_worth = self.balance + self.btc_held * current_price
  self.account_history = np.append(self.account_history, [
    [self.net_worth],
    [btc_bought],
    [cost],
    [btc_sold],
    [sales]
  ], axis=1)

Robot của chúng tôi hiện có thể khởi động một môi trường mới, bước qua môi trường đó và thực hiện các hành động ảnh hưởng đến môi trường đó. Đã đến lúc theo dõi hoạt động giao dịch của họ.

Xem robot của chúng tôi giao dịch

Phương thức render của chúng ta có thể đơn giản như gọi print(self.net_worth), nhưng điều đó không đủ thú vị. Thay vào đó, chúng ta sẽ vẽ một biểu đồ nến đơn giản với thanh khối lượng và một biểu đồ riêng cho vốn chủ sở hữu của chúng ta.

Chúng tôi sẽ lấy mã trong StockTradingGraph.py từ bài viết trước của tôi và chỉnh sửa lại cho phù hợp với môi trường Bitcoin. Bạn có thể lấy mã từ Github của tôi.

Thay đổi đầu tiên chúng ta sẽ thực hiện là thay đổi self.df[ ‘Ngày’] Cập nhật vào self.df[‘Timestamp’] và xóa tất cả các lệnh gọi đến date2num vì ngày của chúng ta đã ở định dạng dấu thời gian Unix. Tiếp theo, trong phương thức kết xuất, chúng ta sẽ cập nhật nhãn ngày để in ra ngày mà con người có thể đọc được thay vì một con số.

from datetime import datetime

Đầu tiên, chúng ta sẽ nhập thư viện datetime, sau đó sử dụng utcfromtimestampmethod để lấy chuỗi UTC từ mỗi dấu thời gian và strftime để biến nó thành chuỗi theo định dạng Y-m-d H:M.

date_labels = np.array([datetime.utcfromtimestamp(x).strftime('%Y-%m-%d %H:%M') for x in self.df['Timestamp'].values[step_range]])

Cuối cùng, chúng ta sẽ sử dụng self.df[‘Volume’] được đổi thành self.df[‘Volume_(BTC)’] để khớp với tập dữ liệu của chúng tôi và sau khi hoàn thành, chúng tôi đã sẵn sàng. Quay lại BitcoinTradingEnv, bây giờ chúng ta có thể viết phương thức render để hiển thị biểu đồ.

def render(self, mode='human', **kwargs):
  if mode == 'human':
    if self.viewer == None:
      self.viewer = BitcoinTradingGraph(self.df,
                                        kwargs.get('title', None))
self.viewer.render(self.frame_start + self.current_step,
                       self.net_worth,
                       self.trades,
                       window_size=self.lookback_window_size)

Nhìn! Bây giờ chúng ta có thể xem robot giao dịch Bitcoin.

Hình dung các giao dịch của robot của chúng tôi với Matplotlib

Nhãn ma màu xanh lá cây biểu thị việc mua BTC và nhãn ma màu đỏ biểu thị việc bán. Nhãn màu trắng ở góc trên bên phải là giá trị tài sản ròng hiện tại của robot và nhãn ở góc dưới bên phải là giá hiện tại của Bitcoin. Đơn giản và thanh lịch. Bây giờ, đã đến lúc đào tạo bot của chúng ta và xem chúng ta có thể kiếm được bao nhiêu tiền!

Thời gian đào tạo

Một lời chỉ trích mà tôi nhận được trong bài viết trước là việc thiếu kiểm chứng chéo và không phân chia dữ liệu thành tập huấn luyện và tập kiểm tra. Mục đích của việc này là để kiểm tra độ chính xác của mô hình cuối cùng trên dữ liệu mới mà nó chưa từng thấy trước đây. Mặc dù đây không phải là trọng tâm của bài viết đó nhưng nó chắc chắn rất quan trọng. Vì chúng ta đang làm việc với dữ liệu chuỗi thời gian nên chúng ta không có nhiều lựa chọn khi thực hiện xác thực chéo.

Ví dụ, một dạng xác thực chéo phổ biến được gọi là xác thực k lần, trong đó bạn chia dữ liệu thành k nhóm bằng nhau, tách một trong các nhóm làm nhóm thử nghiệm và sử dụng phần dữ liệu còn lại làm nhóm đào tạo. . Tuy nhiên, dữ liệu chuỗi thời gian phụ thuộc rất nhiều vào thời gian, nghĩa là dữ liệu sau phụ thuộc rất nhiều vào dữ liệu trước đó. Vì vậy, k-fold sẽ không hiệu quả vì robot của chúng ta sẽ học hỏi từ dữ liệu trong tương lai trước khi giao dịch, đây là một lợi thế không công bằng.

Những sai sót tương tự cũng xảy ra với hầu hết các chiến lược xác thực chéo khác khi áp dụng vào dữ liệu chuỗi thời gian. Do đó, chúng ta chỉ cần sử dụng một phần trong tổng số khung dữ liệu làm tập huấn luyện bắt đầu từ số khung đầu tiên đến một chỉ mục tùy ý và sử dụng phần dữ liệu còn lại làm tập kiểm tra.

slice_point = int(len(df) - 100000)
train_df = df[:slice_point]
test_df = df[slice_point:]

Tiếp theo, vì môi trường của chúng ta chỉ được thiết lập để xử lý một khung dữ liệu duy nhất nên chúng ta sẽ tạo hai môi trường, một cho dữ liệu đào tạo và một cho dữ liệu thử nghiệm.

train_env = DummyVecEnv([lambda: BitcoinTradingEnv(train_df, commission=0, serial=False)])
test_env = DummyVecEnv([lambda: BitcoinTradingEnv(test_df, commission=0, serial=True)])

Bây giờ, việc đào tạo mô hình của chúng ta đơn giản như tạo một robot với môi trường của chúng ta và gọi model.learn.

model = PPO2(MlpPolicy,
             train_env,
             verbose=1, 
             tensorboard_log="./tensorboard/")
model.learn(total_timesteps=50000)

Ở đây, chúng tôi sử dụng Tensorboard để có thể dễ dàng hình dung biểu đồ TensorFlow và xem một số số liệu định lượng về robot của mình. Ví dụ, đây là sơ đồ phần thưởng giảm giá cho nhiều robot đạt hơn 200.000 bước thời gian:

Wow, có vẻ như bot của chúng ta khá có lãi! Robot tốt nhất của chúng tôi thậm chí có thể đạt được khả năng giữ thăng bằng tốt hơn 1000 lần sau 200.000 bước, và phần còn lại trung bình cải thiện ít nhất 30 lần!

Đúng lúc này tôi nhận ra có lỗi trong môi trường… Sau khi sửa lỗi đó, đây là bản đồ phần thưởng mới:

Như bạn có thể thấy, một số robot của chúng tôi đã hoạt động rất tốt, nhưng số còn lại thì tự phá sản. Tuy nhiên, một bot hoạt động tốt có thể đạt được số dư ban đầu gấp 10 lần hoặc thậm chí 60 lần. Tôi phải thừa nhận rằng tất cả các bot có lợi nhuận đều được đào tạo và thử nghiệm mà không cần hoa hồng, vì vậy việc các bot của chúng tôi kiếm được tiền thật là không thực tế. Nhưng ít nhất chúng ta đã tìm ra hướng đi!

Hãy thử nghiệm các bot của chúng ta trong môi trường thử nghiệm (với dữ liệu mới mà chúng chưa từng thấy trước đây) và xem chúng hoạt động như thế nào.

Bot được đào tạo của chúng tôi bị phá sản khi giao dịch dữ liệu thử nghiệm mới

Rõ ràng là chúng ta vẫn còn nhiều việc phải làm. Chỉ cần chuyển đổi mô hình để sử dụng A2C cơ sở ổn định thay vì robot PPO2 hiện tại, chúng ta có thể cải thiện đáng kể hiệu suất trên tập dữ liệu này. Cuối cùng, theo gợi ý của Sean O’Gorman, chúng ta có thể cập nhật hàm phần thưởng một chút để thêm phần thưởng vào giá trị tài sản ròng thay vì chỉ đạt được giá trị tài sản ròng cao rồi để nguyên như vậy.

reward = self.net_worth - prev_net_worth

Chỉ riêng hai thay đổi này đã cải thiện đáng kể hiệu suất trên tập dữ liệu thử nghiệm và như bạn có thể thấy bên dưới, cuối cùng chúng ta cũng có thể đạt được lợi nhuận trên dữ liệu mới không có trong tập dữ liệu đào tạo.

Nhưng chúng ta có thể làm tốt hơn. Để cải thiện những kết quả này, chúng ta cần tối ưu hóa các siêu tham số và đào tạo bot trong thời gian dài hơn. Đã đến lúc GPU của bạn hoạt động và đạt hiệu suất tối đa!

Bài viết này đã khá dài và chúng ta vẫn còn nhiều chi tiết cần xem xét nên chúng ta sẽ tạm dừng ở đây. Trong bài đăng tiếp theo, chúng ta sẽ sử dụng Tối ưu hóa Bayes để phân vùng các siêu tham số tốt nhất cho không gian vấn đề của mình và chuẩn bị cho việc đào tạo/kiểm tra trên GPU bằng CUDA.

kết luận

Trong bài viết này, chúng tôi sẽ tạo ra một bot giao dịch Bitcoin có lợi nhuận từ đầu bằng cách sử dụng phương pháp học tăng cường. Chúng ta có thể thực hiện các nhiệm vụ sau:

1. Tạo môi trường giao dịch Bitcoin từ đầu bằng cách sử dụng phòng tập của OpenAI.

2. Sử dụng Matplotlib để xây dựng hình ảnh trực quan về môi trường.

3. Đào tạo và kiểm tra bot của chúng tôi bằng cách xác thực chéo đơn giản.

4. Điều chỉnh một chút robot của chúng tôi để đạt được lợi nhuận

Mặc dù robot giao dịch của chúng tôi không mang lại lợi nhuận như mong muốn nhưng chúng tôi vẫn đang đi đúng hướng. Lần tới, chúng tôi sẽ đảm bảo bot của mình có thể đánh bại thị trường một cách nhất quán và chúng tôi sẽ xem bot giao dịch của mình hoạt động như thế nào trên dữ liệu trực tiếp. Hãy theo dõi bài viết tiếp theo của tôi và Chúc Bitcoin trường tồn!