Bài đăng này được lấy cảm hứng từ quan sát của tôi về một số cảnh báo và cạm bẫy phổ biến sau khi cố gắng áp dụng các kỹ thuật học máy vào các vấn đề giao dịch trong quá trình nghiên cứu dữ liệu tại nền tảng Inventor Quant.

Nếu bạn chưa đọc bài viết trước của tôi, chúng tôi khuyên bạn nên đọc hướng dẫn trước đây của tôi về môi trường nghiên cứu dữ liệu tự động được thiết lập trên Nền tảng định lượng Inventor và phương pháp tiếp cận có hệ thống để phát triển các chiến lược giao dịch trước khi đọc bài viết này.

Địa chỉ ở đây: https://www.fmz.com/digest-topic/4187 và https://www.fmz.com/digest-topic/4169.

Về việc thành lập môi trường nghiên cứu

Hướng dẫn này được thiết kế cho những người đam mê, kỹ sư và nhà khoa học dữ liệu ở mọi cấp độ kỹ năng. Cho dù bạn là chuyên gia trong ngành hay người mới bắt đầu lập trình, kỹ năng duy nhất bạn cần là hiểu biết cơ bản về ngôn ngữ lập trình Python và kiến ​​thức đầy đủ về các thao tác dòng lệnh. (Có khả năng thiết lập một dự án khoa học dữ liệu là đủ)

• Cài đặt Inventor Quant Hoster và Thiết lập Anaconda

Ngoài việc cung cấp các nguồn dữ liệu chất lượng cao từ các sàn giao dịch chính thống, Inventor Quantitative Platform FMZ.COM còn cung cấp một bộ giao diện API phong phú để giúp chúng tôi thực hiện các giao dịch tự động sau khi hoàn tất phân tích dữ liệu. Bộ giao diện này bao gồm các công cụ thực tế như truy vấn thông tin tài khoản, truy vấn giá cao, giá mở cửa, giá thấp, giá đóng cửa, khối lượng giao dịch, nhiều chỉ báo phân tích kỹ thuật thường dùng của nhiều sàn giao dịch chính thống, v.v., đặc biệt là để kết nối với các sàn giao dịch chính thống lớn trong thực tế quy trình giao dịch. Giao diện API công khai cung cấp hỗ trợ kỹ thuật mạnh mẽ.

Tất cả các tính năng được đề cập ở trên đều được đóng gói trong một hệ thống tương tự như Docker. Tất cả những gì chúng ta phải làm là mua hoặc thuê dịch vụ điện toán đám mây của riêng mình và sau đó triển khai hệ thống Docker.

Trong tên chính thức của Inventor Quantitative Platform, hệ thống Docker này được gọi là hệ thống lưu trữ.

Để biết thêm thông tin về cách triển khai máy chủ và rô-bốt, vui lòng tham khảo bài viết trước của tôi: https://www.fmz.com/bbs-topic/4140

Bạn đọc muốn mua máy chủ triển khai điện toán đám mây riêng có thể tham khảo bài viết này: https://www.fmz.com/bbs-topic/2848

Sau khi triển khai thành công dịch vụ điện toán đám mây và hệ thống máy chủ, chúng ta sẽ cài đặt công cụ Python mạnh mẽ nhất: Anaconda

Để có được tất cả các môi trường chương trình có liên quan cần thiết cho bài viết này (thư viện phụ thuộc, quản lý phiên bản, v.v.), cách dễ nhất là sử dụng Anaconda. Đây là hệ sinh thái khoa học dữ liệu Python được đóng gói và trình quản lý phụ thuộc.

Vì chúng tôi đang cài đặt Anaconda trên dịch vụ đám mây nên chúng tôi khuyên bạn nên cài đặt hệ thống Linux cùng với phiên bản dòng lệnh của Anaconda trên máy chủ đám mây.

Để biết phương pháp cài đặt Anaconda, vui lòng tham khảo hướng dẫn chính thức của Anaconda: https://www.anaconda.com/distribution/

Nếu bạn là một lập trình viên Python có kinh nghiệm và không cảm thấy cần phải sử dụng Anaconda thì hoàn toàn không sao cả. Tôi sẽ cho rằng bạn không cần trợ giúp cài đặt các phụ thuộc cần thiết và bạn có thể bỏ qua phần này.

Phát triển chiến lược giao dịch

Kết quả cuối cùng của một chiến lược giao dịch phải trả lời được những câu hỏi sau:

• Hướng dẫn: Xác định xem tài sản có rẻ, đắt hay được định giá hợp lý.

• Điều kiện mở cửa: Nếu giá tài sản rẻ hoặc đắt, bạn nên mua vào hoặc bán ra.

• Đóng giao dịch: Nếu giá tài sản hợp lý và chúng ta có vị thế trong tài sản đó (mua hoặc bán trước đó), bạn có nên đóng vị thế không?

• Phạm vi giá: Mức giá (hoặc phạm vi) mà giao dịch được mở

• Số lượng: Số lượng tiền được giao dịch (ví dụ: số lượng tiền kỹ thuật số hoặc số lô hàng hóa tương lai)

Học máy có thể được sử dụng để trả lời từng câu hỏi này, nhưng trong phần còn lại của bài viết này, chúng ta sẽ tập trung vào việc trả lời câu hỏi đầu tiên, đó là hướng đi của ngành.

Cách tiếp cận chiến lược

Có hai loại phương pháp xây dựng chiến lược: một là dựa trên mô hình và hai là dựa trên khai thác dữ liệu. Về cơ bản, đây là hai cách tiếp cận đối lập nhau.

Trong xây dựng chiến lược dựa trên mô hình, chúng ta bắt đầu với một mô hình về tình trạng kém hiệu quả của thị trường, xây dựng các biểu thức toán học (ví dụ: giá cả, lợi nhuận) và kiểm tra tính hiệu quả của chúng trong khoảng thời gian dài hơn. Mô hình này thường là phiên bản đơn giản hóa của một mô hình phức tạp thực sự và tầm quan trọng cũng như tính ổn định của nó trong dài hạn cần phải được xác minh. Các chiến lược theo xu hướng thông thường, hồi quy trung bình và chênh lệch giá đều thuộc loại này.

Mặt khác, trước tiên chúng tôi tìm kiếm các mẫu giá và thử sử dụng các thuật toán trong phương pháp khai thác dữ liệu. Nguyên nhân gây ra những mô hình này không quan trọng, vì điều chắc chắn là những mô hình này sẽ tiếp tục lặp lại trong tương lai. Đây là phương pháp phân tích mù và chúng ta cần kiểm tra chặt chẽ để xác định các mẫu thực sự từ các mẫu ngẫu nhiên. “Thử nghiệm và sai sót”, “Mẫu biểu đồ thanh” và “Hồi quy khối lượng tính năng” thuộc về thể loại này.

Rõ ràng, máy học dễ dàng áp dụng vào các phương pháp khai thác dữ liệu. Hãy cùng xem cách máy học có thể được sử dụng để tạo ra tín hiệu giao dịch thông qua khai thác dữ liệu.

Các ví dụ về mã sử dụng công cụ kiểm tra ngược và giao diện API giao dịch tự động dựa trên Nền tảng quan trọng Inventor. Sau khi triển khai hoster và cài đặt Anaconda ở phần trên, bạn chỉ cần cài đặt thư viện phân tích khoa học dữ liệu mà chúng ta cần và mô hình học máy nổi tiếng scikit-learn. Chúng tôi sẽ không đi sâu vào chi tiết về phần này.

pip install -U scikit-learn

Sử dụng máy học để tạo tín hiệu chiến lược giao dịch

• Khai thác dữ liệu

Trước khi bắt đầu, một bài toán học máy tiêu chuẩn trông như thế này:

Khung vấn đề học máy

Các tính năng chúng ta sẽ tạo phải có một số sức mạnh dự đoán (X), chúng ta muốn dự đoán biến mục tiêu (Y) và sử dụng dữ liệu lịch sử để đào tạo mô hình ML có thể dự đoán Y càng gần với giá trị thực tế càng tốt. Cuối cùng, chúng tôi sử dụng mô hình này để đưa ra dự đoán về dữ liệu mới khi Y chưa được biết. Điều này dẫn chúng ta đến bước đầu tiên:

Bước 1: Thiết lập vấn đề của bạn

• Bạn muốn dự đoán điều gì? Dự báo tốt là gì? Bạn đánh giá kết quả dự đoán như thế nào?

Nghĩa là, trong khuôn khổ trên, Y là gì?

Bạn muốn dự đoán điều gì?

Bạn có muốn dự đoán giá trong tương lai, lợi nhuận/Pnl trong tương lai, tín hiệu mua/bán, tối ưu hóa phân bổ danh mục đầu tư và cố gắng thực hiện giao dịch hiệu quả, v.v. không?

Giả sử chúng ta đang cố gắng dự đoán giá tại mốc thời gian tiếp theo. Trong trường hợp này, Y(t) = Giá(t+1). Bây giờ chúng ta có thể hoàn thiện khuôn khổ của mình bằng dữ liệu lịch sử

Lưu ý rằng Y(t) chỉ được biết trong quá trình kiểm tra ngược, nhưng khi chúng ta sử dụng mô hình của mình, chúng ta sẽ không biết giá tại thời điểm t (t+1). Chúng tôi sử dụng mô hình của mình để đưa ra dự đoán Y(dự đoán, t) và chỉ so sánh nó với giá trị thực tế tại thời điểm t+1. Điều này có nghĩa là bạn không thể sử dụng Y làm tính năng trong mô hình dự đoán.

Khi đã biết mục tiêu Y, chúng ta cũng có thể quyết định cách đánh giá các dự đoán của mình. Điều này rất quan trọng để phân biệt các mô hình khác nhau mà chúng ta sẽ thử nghiệm trên dữ liệu của mình. Tùy thuộc vào vấn đề chúng ta đang giải quyết, hãy chọn một số liệu để đo lường hiệu quả của mô hình. Ví dụ, nếu chúng ta đang dự đoán giá, chúng ta có thể sử dụng sai số bình phương trung bình làm phép đo. Một số chỉ báo thường dùng (đường trung bình động, MACD và điểm phương sai, v.v.) đã được mã hóa sẵn trong hộp công cụ Inventor Quant và bạn có thể gọi các chỉ báo này trên toàn cầu thông qua giao diện API.

Khung ML để dự đoán giá trong tương lai

Để chứng minh, chúng tôi sẽ tạo một mô hình dự báo để dự đoán giá trị cơ sở dự kiến ​​trong tương lai của mục tiêu đầu tư giả định, trong đó:

basis = Price of Stock — Price of Future

basis(t)=S(t)−F(t)

Y(t) = future expected value of basis = Average(basis(t+1),basis(t+2),basis(t+3),basis(t+4),basis(t+5))

Vì đây là bài toán hồi quy nên chúng ta sẽ đánh giá mô hình trên RMSE (Rốt sai số trung bình bình phương). Chúng tôi cũng sẽ sử dụng Tổng Pnl làm tiêu chí đánh giá

Lưu ý: Để biết kiến ​​thức toán học có liên quan về RMSE, vui lòng tham khảo nội dung có liên quan của Bách khoa toàn thư Baidu

• Mục tiêu của chúng tôi: tạo ra một mô hình khiến các giá trị dự đoán càng gần với Y càng tốt.

Bước 2: Thu thập dữ liệu đáng tin cậy

Thu thập và làm sạch dữ liệu có thể giúp bạn giải quyết vấn đề hiện tại

Bạn cần xem xét dữ liệu nào để có sức mạnh dự đoán cho biến mục tiêu Y? Nếu chúng ta dự đoán giá, bạn có thể sử dụng dữ liệu giá mục tiêu, dữ liệu khối lượng giao dịch mục tiêu, dữ liệu tương tự cho các mục tiêu liên quan, các chỉ số thị trường chung như mức chỉ số mục tiêu, giá của các tài sản liên quan khác, v.v.

Bạn sẽ cần thiết lập quyền truy cập dữ liệu cho dữ liệu này và đảm bảo dữ liệu của bạn chính xác và giải quyết dữ liệu bị thiếu (một vấn đề rất phổ biến). Ngoài ra, hãy đảm bảo dữ liệu của bạn không thiên vị và phản ánh đầy đủ mọi điều kiện thị trường (ví dụ: cùng số lượng kịch bản thắng/thua) để tránh sai lệch trong mô hình của bạn. Bạn cũng có thể cần phải làm sạch dữ liệu về cổ tức, chia tách danh mục đầu tư, tiếp tục, v.v.

Nếu bạn đang sử dụng Nền tảng định lượng Inventor (FMZ.COM), chúng tôi có thể truy cập dữ liệu toàn cầu miễn phí từ Google, Yahoo, NSE và Quandl; dữ liệu chuyên sâu từ các hợp đồng tương lai hàng hóa trong nước như CTP và Yisheng; Binance, OKEX, Huobi và BitMex Nền tảng định lượng Inventor cũng làm sạch và lọc trước dữ liệu này, chẳng hạn như dữ liệu phân chia mục tiêu đầu tư và dữ liệu thị trường chuyên sâu, và trình bày cho các nhà phát triển chiến lược theo định dạng dễ hiểu đối với những người làm việc định lượng.

Để thuận tiện cho bài viết này, chúng tôi sử dụng dữ liệu sau làm mục tiêu đầu tư ảo ‘MQK’. Chúng tôi cũng sử dụng một công cụ định lượng rất tiện lợi có tên là Auquan’s Toolbox. Để biết thêm thông tin, vui lòng tham khảo: https://github.com/Auquan / auquan-toolbox-python

# Load the data
from backtester.dataSource.quant_quest_data_source import QuantQuestDataSource
cachedFolderName = '/Users/chandinijain/Auquan/qq2solver-data/historicalData/'
dataSetId = 'trainingData1'
instrumentIds = ['MQK']
ds = QuantQuestDataSource(cachedFolderName=cachedFolderName,
                                    dataSetId=dataSetId,
                                    instrumentIds=instrumentIds)
def loadData(ds):
    data = None
    for key in ds.getBookDataByFeature().keys():
        if data is None:
            data = pd.DataFrame(np.nan, index = ds.getBookDataByFeature()[key].index, columns=[])
        data[key] = ds.getBookDataByFeature()[key]
    data['Stock Price'] =  ds.getBookDataByFeature()['stockTopBidPrice'] + ds.getBookDataByFeature()['stockTopAskPrice'] / 2.0
    data['Future Price'] = ds.getBookDataByFeature()['futureTopBidPrice'] + ds.getBookDataByFeature()['futureTopAskPrice'] / 2.0
    data['Y(Target)'] = ds.getBookDataByFeature()['basis'].shift(-5)
    del data['benchmark_score']
    del data['FairValue']
    return data
data = loadData(ds)

Với mã trên, Toolbox của Auquan đã tải xuống và đưa dữ liệu vào từ điển khung dữ liệu. Bây giờ chúng ta cần chuẩn bị dữ liệu theo định dạng mà chúng ta thích. Hàm ds.getBookDataByFeature() trả về một từ điển các khung dữ liệu, mỗi khung dữ liệu cho một tính năng. Chúng tôi tạo khung dữ liệu mới cho cổ phiếu với đầy đủ tính năng.

Bước 3: Phân chia dữ liệu

• Tạo các tập huấn luyện từ dữ liệu, xác thực chéo và kiểm tra các tập này

Đây là một bước rất quan trọng! Trước khi tiến hành, chúng ta nên chia dữ liệu thành một tập dữ liệu đào tạo để đào tạo mô hình và một tập dữ liệu thử nghiệm để đánh giá hiệu suất của mô hình. Tỷ lệ phân chia được đề xuất là: 60-70% tập huấn luyện và 30-40% tập kiểm tra

Chia dữ liệu thành các tập huấn luyện và thử nghiệm

Vì dữ liệu đào tạo được sử dụng để đánh giá các tham số mô hình nên mô hình của bạn có thể quá phù hợp với dữ liệu đào tạo này và dữ liệu đào tạo có thể làm sai lệch hiệu suất của mô hình. Nếu bạn không lưu giữ bất kỳ dữ liệu thử nghiệm riêng biệt nào và sử dụng toàn bộ dữ liệu để đào tạo, bạn sẽ không biết mô hình của mình sẽ hoạt động tốt hay kém trên dữ liệu mới, chưa từng thấy. Đây là một trong những lý do chính khiến các mô hình ML được đào tạo không thành công trên dữ liệu trực tiếp: mọi người đào tạo trên tất cả dữ liệu có sẵn và bị kích thích bởi số liệu dữ liệu đào tạo, nhưng mô hình không thể đưa ra bất kỳ dự đoán có ý nghĩa nào trên dữ liệu trực tiếp mà nó không được đào tạo.

Chia dữ liệu thành các tập huấn luyện, xác thực và kiểm tra

Có vấn đề với cách tiếp cận này. Nếu chúng ta liên tục đào tạo trên dữ liệu đào tạo, đánh giá hiệu suất trên dữ liệu thử nghiệm và tối ưu hóa mô hình cho đến khi hài lòng với hiệu suất, thì chúng ta sẽ ngầm đưa dữ liệu thử nghiệm vào làm một phần của dữ liệu đào tạo. Cuối cùng, mô hình của chúng tôi có thể hoạt động tốt trên tập dữ liệu đào tạo và thử nghiệm này, nhưng không có gì đảm bảo rằng nó có thể dự đoán tốt dữ liệu mới.

Để giải quyết vấn đề này, chúng ta có thể tạo một tập dữ liệu xác thực riêng biệt. Bây giờ bạn có thể đào tạo trên dữ liệu, đánh giá hiệu suất trên dữ liệu xác thực, tối ưu hóa cho đến khi bạn hài lòng với hiệu suất và cuối cùng là thử nghiệm trên dữ liệu thử nghiệm. Theo cách này, dữ liệu thử nghiệm sẽ không bị nhiễm bẩn và chúng tôi sẽ không sử dụng bất kỳ thông tin nào từ dữ liệu thử nghiệm để cải thiện mô hình của mình.

Hãy nhớ rằng, sau khi đã kiểm tra hiệu suất trên dữ liệu thử nghiệm, đừng quay lại và cố gắng tối ưu hóa mô hình thêm nữa. Nếu bạn thấy mô hình của mình không mang lại kết quả tốt, hãy loại bỏ hoàn toàn mô hình và bắt đầu lại. Tỷ lệ phân chia được đề xuất có thể là 60% dữ liệu đào tạo, 20% dữ liệu xác thực và 20% dữ liệu thử nghiệm.

Đối với vấn đề này, chúng tôi có ba tập dữ liệu có sẵn và chúng tôi sẽ sử dụng một tập làm tập huấn luyện, tập thứ hai làm tập xác thực và tập thứ ba làm tập kiểm tra.

# Training Data
dataSetId =  'trainingData1'
ds_training = QuantQuestDataSource(cachedFolderName=cachedFolderName,
                                    dataSetId=dataSetId,
                                    instrumentIds=instrumentIds)
training_data = loadData(ds_training)
# Validation Data
dataSetId =  'trainingData2'
ds_validation = QuantQuestDataSource(cachedFolderName=cachedFolderName,
                                    dataSetId=dataSetId,
                                    instrumentIds=instrumentIds)
validation_data = loadData(ds_validation)
# Test Data
dataSetId =  'trainingData3'
ds_test = QuantQuestDataSource(cachedFolderName=cachedFolderName,
                                    dataSetId=dataSetId,
                                    instrumentIds=instrumentIds)
out_of_sample_test_data = loadData(ds_test)

Đối với mỗi giá trị này, chúng tôi thêm biến mục tiêu Y, được định nghĩa là giá trị trung bình của năm giá trị cơ sở tiếp theo

def prepareData(data, period):
    data['Y(Target)'] = data['basis'].rolling(period).mean().shift(-period)
    if 'FairValue' in data.columns:
        del data['FairValue']
    data.dropna(inplace=True)
period = 5
prepareData(training_data, period)
prepareData(validation_data, period)
prepareData(out_of_sample_test_data, period)

Bước 4: Kỹ thuật tính năng

Phân tích hành vi của dữ liệu và tạo ra các tính năng có khả năng dự đoán

Bây giờ việc xây dựng thực tế của dự án đã bắt đầu. Nguyên tắc vàng của việc lựa chọn tính năng là sức mạnh dự đoán chủ yếu đến từ các tính năng, không phải từ mô hình. Bạn sẽ thấy rằng việc lựa chọn tính năng có tác động lớn hơn nhiều đến hiệu suất so với việc lựa chọn kiểu máy. Một số lưu ý về việc lựa chọn tính năng:

• Không nên tùy ý chọn một tập hợp lớn các tính năng mà không tìm hiểu mối quan hệ của chúng với biến mục tiêu.

• Mối quan hệ ít hoặc không có với biến mục tiêu có thể dẫn đến tình trạng quá khớp

• Các tính năng bạn chọn có thể có mối tương quan cao với nhau, trong trường hợp đó, một số lượng tính năng nhỏ hơn cũng có thể giải thích mục tiêu.

• Tôi thường tạo ra một số tính năng có ý nghĩa trực quan và xem xét cách biến mục tiêu tương quan với các tính năng này, cũng như cách chúng tương quan với nhau để quyết định sử dụng tính năng nào.

• Bạn cũng có thể thử xếp hạng các tính năng ứng viên dựa trên Hệ số thông tin tối đa (MIC), thực hiện Phân tích thành phần chính (PCA) và các phương pháp khác.

Chuyển đổi/Chuẩn hóa tính năng:

Các mô hình ML có xu hướng hoạt động tốt với chuẩn hóa. Tuy nhiên, việc chuẩn hóa trở nên khó khăn khi xử lý dữ liệu chuỗi thời gian vì phạm vi dữ liệu trong tương lai là không xác định. Dữ liệu của bạn có thể nằm ngoài phạm vi chuẩn hóa, khiến mô hình bị sai. Nhưng bạn vẫn có thể thử tạo ra một mức độ tĩnh tại nhất định:

• Tỷ lệ: Chia các tính năng theo độ lệch chuẩn hoặc phạm vi liên tứ phân vị

• Căn giữa: Trừ giá trị trung bình lịch sử khỏi giá trị hiện tại

• Chuẩn hóa: Hai khoảng thời gian nhìn lại của (x - trung bình) / stdev ở trên

• Chuẩn hóa thông thường: Chuẩn hóa dữ liệu trong phạm vi từ -1 đến +1 và định tâm lại trong khoảng thời gian nhìn lại (x-min)/(max-min)

Lưu ý rằng vì chúng ta sử dụng giá trị trung bình chạy lịch sử, độ lệch chuẩn, giá trị cực đại hoặc cực tiểu trong giai đoạn nhìn lại nên giá trị chuẩn hóa của tính năng sẽ biểu thị các giá trị thực tế khác nhau tại các thời điểm khác nhau. Ví dụ, nếu giá trị hiện tại của một tính năng là 5 và giá trị trung bình 30 kỳ đang chạy là 4,5, thì giá trị này sẽ được chuyển đổi thành 0,5 sau khi căn giữa. Sau đó, nếu trung bình động 30 kỳ trở thành 3, giá trị 3,5 sẽ trở thành 0,5. Đây có thể là lý do tại sao mô hình sai. Vì vậy, việc điều chỉnh rất khó khăn và bạn phải tìm ra điều gì thực sự cải thiện hiệu suất của mô hình (nếu có).

Đối với lần lặp đầu tiên trong bài toán của mình, chúng tôi đã tạo ra một số lượng lớn các tính năng bằng cách sử dụng các tham số trộn. Sau đó chúng ta sẽ thử xem liệu chúng ta có thể giảm số lượng tính năng hay không

def difference(dataDf, period):
    return dataDf.sub(dataDf.shift(period), fill_value=0)
def ewm(dataDf, halflife):
    return dataDf.ewm(halflife=halflife, ignore_na=False,
                      min_periods=0, adjust=True).mean()
def rsi(data, period):
    data_upside = data.sub(data.shift(1), fill_value=0)
    data_downside = data_upside.copy()
    data_downside[data_upside > 0] = 0
    data_upside[data_upside < 0] = 0
    avg_upside = data_upside.rolling(period).mean()
    avg_downside = - data_downside.rolling(period).mean()
    rsi = 100 - (100 * avg_downside / (avg_downside + avg_upside))
    rsi[avg_downside == 0] = 100
    rsi[(avg_downside == 0) & (avg_upside == 0)] = 0
return rsi
def create_features(data):
    basis_X = pd.DataFrame(index = data.index, columns =  [])
    
    basis_X['mom3'] = difference(data['basis'],4)
    basis_X['mom5'] = difference(data['basis'],6)
    basis_X['mom10'] = difference(data['basis'],11)
    
    basis_X['rsi15'] = rsi(data['basis'],15)
    basis_X['rsi10'] = rsi(data['basis'],10)
    
    basis_X['emabasis3'] = ewm(data['basis'],3)
    basis_X['emabasis5'] = ewm(data['basis'],5)
    basis_X['emabasis7'] = ewm(data['basis'],7)
    basis_X['emabasis10'] = ewm(data['basis'],10)
    basis_X['basis'] = data['basis']
    basis_X['vwapbasis'] = data['stockVWAP']-data['futureVWAP']
    
    basis_X['swidth'] = data['stockTopAskPrice'] -
                        data['stockTopBidPrice']
    basis_X['fwidth'] = data['futureTopAskPrice'] -
                        data['futureTopBidPrice']
    
    basis_X['btopask'] = data['stockTopAskPrice'] -
                         data['futureTopAskPrice']
    basis_X['btopbid'] = data['stockTopBidPrice'] -
                         data['futureTopBidPrice']

    basis_X['totalaskvol'] = data['stockTotalAskVol'] -
                             data['futureTotalAskVol']
    basis_X['totalbidvol'] = data['stockTotalBidVol'] -
                             data['futureTotalBidVol']
    
    basis_X['emabasisdi7'] = basis_X['emabasis7'] -
                             basis_X['emabasis5'] + 
                             basis_X['emabasis3']
    
    basis_X = basis_X.fillna(0)
    
    basis_y = data['Y(Target)']
    basis_y.dropna(inplace=True)
    
    print("Any null data in y: %s, X: %s"
            %(basis_y.isnull().values.any(), 
             basis_X.isnull().values.any()))
    print("Length y: %s, X: %s"
            %(len(basis_y.index), len(basis_X.index)))
    
    return basis_X, basis_y
basis_X_train, basis_y_train = create_features(training_data)
basis_X_test, basis_y_test = create_features(validation_data)

Bước 5: Lựa chọn mô hình

Chọn mô hình thống kê/ML phù hợp cho vấn đề đã chọn

Việc lựa chọn mô hình phụ thuộc vào cách xây dựng vấn đề. Bạn đang giải quyết một bài toán học có giám sát (mỗi điểm X trong ma trận đặc trưng được ánh xạ tới một biến mục tiêu Y) hay một bài toán học không giám sát (không có ánh xạ nào được đưa ra và mô hình cố gắng học các mẫu chưa biết)? Bạn đang giải bài toán hồi quy (dự đoán giá thực tế tại thời điểm trong tương lai) hay bài toán phân loại (chỉ dự đoán hướng (tăng/giảm) của giá tại thời điểm trong tương lai).

Học có giám sát hoặc không giám sát

Hồi quy hoặc Phân loại

Một số thuật toán học có giám sát phổ biến có thể giúp bạn bắt đầu:

• LinearRegression(tham số, hồi quy)

• Hồi quy logistic (tham số, phân loại)

• Thuật toán K-nearest neighbor (KNN) (dựa trên trường hợp, hồi quy)

• SVM, SVR (tham số, phân loại và hồi quy)

• Cây quyết định

• Rừng quyết định

Tôi khuyên bạn nên bắt đầu bằng một mô hình đơn giản, chẳng hạn như hồi quy tuyến tính hoặc hồi quy logistic, và xây dựng các mô hình phức tạp hơn từ đó nếu cần. Bạn cũng nên đọc phần toán học đằng sau mô hình thay vì sử dụng nó một cách mù quáng như một hộp đen.

Bước 6: Đào tạo, xác thực và tối ưu hóa (lặp lại các bước 4-6)

Đào tạo và tối ưu hóa mô hình của bạn bằng cách sử dụng các tập dữ liệu đào tạo và xác thực

Bây giờ bạn đã sẵn sàng để xây dựng mô hình của mình. Ở giai đoạn này, bạn thực sự chỉ lặp lại mô hình và các tham số mô hình. Đào tạo mô hình của bạn trên dữ liệu đào tạo, đo hiệu suất của nó trên dữ liệu xác thực, sau đó quay lại, tối ưu hóa, đào tạo lại và đánh giá. Nếu bạn không hài lòng với hiệu suất của một mô hình, hãy thử sử dụng một mô hình khác. Bạn thực hiện giai đoạn này nhiều lần cho đến khi có được mô hình mà bạn hài lòng.

Chỉ khi bạn có được mô hình mà mình thích thì mới tiến hành bước tiếp theo.

Đối với vấn đề minh họa của chúng ta, hãy bắt đầu bằng một hồi quy tuyến tính đơn giản

from sklearn import linear_model
from sklearn.metrics import mean_squared_error, r2_score
def linear_regression(basis_X_train, basis_y_train,
                      basis_X_test,basis_y_test):
    
    regr = linear_model.LinearRegression()
    # Train the model using the training sets
    regr.fit(basis_X_train, basis_y_train)
    # Make predictions using the testing set
    basis_y_pred = regr.predict(basis_X_test)
    # The coefficients
    print('Coefficients: \n', regr.coef_)
    
    # The mean squared error
    print("Mean squared error: %.2f"
          % mean_squared_error(basis_y_test, basis_y_pred))
    
    # Explained variance score: 1 is perfect prediction
    print('Variance score: %.2f' % r2_score(basis_y_test,
                                            basis_y_pred))
    # Plot outputs
    plt.scatter(basis_y_pred, basis_y_test,  color='black')
    plt.plot(basis_y_test, basis_y_test, color='blue', linewidth=3)
    plt.xlabel('Y(actual)')
    plt.ylabel('Y(Predicted)')
    plt.show()
    
    return regr, basis_y_pred
_, basis_y_pred = linear_regression(basis_X_train, basis_y_train, 
                                    basis_X_test,basis_y_test)

Hồi quy tuyến tính không chuẩn hóa

('Coefficients: \n', array([ -1.0929e+08, 4.1621e+07, 1.4755e+07, 5.6988e+06, -5.656e+01, -6.18e-04, -8.2541e-05,4.3606e-02, -3.0647e-02, 1.8826e+07, 8.3561e-02, 3.723e-03, -6.2637e-03, 1.8826e+07, 1.8826e+07, 6.4277e-02, 5.7254e-02, 3.3435e-03, 1.6376e-02, -7.3588e-03, -8.1531e-04, -3.9095e-02, 3.1418e-02, 3.3321e-03, -1.3262e-06, -1.3433e+07, 3.5821e+07, 2.6764e+07, -8.0394e+06, -2.2388e+06, -1.7096e+07]))
Mean squared error: 0.02
Variance score: 0.96

Hãy xem các hệ số mô hình. Chúng ta không thể thực sự so sánh chúng hoặc nói cái nào quan trọng vì tất cả đều nằm ở các thang đo khác nhau. Hãy thử chuẩn hóa để đưa chúng về cùng một tỷ lệ và cũng tạo ra tính ổn định.

def normalize(basis_X, basis_y, period):
    basis_X_norm = (basis_X - basis_X.rolling(period).mean())/
                    basis_X.rolling(period).std()
    basis_X_norm.dropna(inplace=True)
    basis_y_norm = (basis_y - 
                    basis_X['basis'].rolling(period).mean())/
                    basis_X['basis'].rolling(period).std()
    basis_y_norm = basis_y_norm[basis_X_norm.index]
    
    return basis_X_norm, basis_y_norm
norm_period = 375
basis_X_norm_test, basis_y_norm_test = normalize(basis_X_test,basis_y_test, norm_period)
basis_X_norm_train, basis_y_norm_train = normalize(basis_X_train, basis_y_train, norm_period)
regr_norm, basis_y_pred = linear_regression(basis_X_norm_train, basis_y_norm_train, basis_X_norm_test, basis_y_norm_test)
basis_y_pred = basis_y_pred * basis_X_test['basis'].rolling(period).std()[basis_y_norm_test.index] + basis_X_test['basis'].rolling(period).mean()[basis_y_norm_test.index]

Hồi quy tuyến tính chuẩn hóa

Mean squared error: 0.05
Variance score: 0.90

Mô hình này không cải tiến hơn mô hình trước nhưng cũng không tệ hơn. Bây giờ chúng ta có thể so sánh các hệ số và xem hệ số nào thực sự có ý nghĩa.

Chúng ta hãy xem xét các hệ số

for i in range(len(basis_X_train.columns)):
    print('%.4f, %s'%(regr_norm.coef_[i], basis_X_train.columns[i]))

Kết quả là:

19.8727, emabasis4
-9.2015, emabasis5
8.8981, emabasis7
-5.5692, emabasis10
-0.0036, rsi15
-0.0146, rsi10
0.0196, mom10
-0.0035, mom5
-7.9138, basis
0.0062, swidth
0.0117, fwidth
2.0883, btopask
2.0311, btopbid
0.0974, bavgask
0.0611, bavgbid
0.0007, topaskvolratio
0.0113, topbidvolratio
-0.0220, totalaskvolratio
0.0231, totalbidvolratio

Chúng ta có thể thấy rõ rằng một số tính năng có hệ số cao hơn so với các tính năng khác và có khả năng dự đoán mạnh hơn.

Hãy xem xét mối tương quan giữa các tính năng khác nhau.

import seaborn

c = basis_X_train.corr()
plt.figure(figsize=(10,10))
seaborn.heatmap(c, cmap='RdYlGn_r', mask = (np.abs(c) <= 0.8))
plt.show()

Sự tương quan giữa các tính năng

Các vùng màu đỏ sẫm biểu thị các biến có mối tương quan cao. Hãy tạo/sửa đổi một số tính năng một lần nữa và cố gắng cải thiện mô hình của chúng ta.

Ví dụ, tôi có thể dễ dàng loại bỏ các tính năng như emabasisdi7 vốn chỉ là tổ hợp tuyến tính của các tính năng khác.

def create_features_again(data):
    basis_X = pd.DataFrame(index = data.index, columns =  [])
    basis_X['mom10'] = difference(data['basis'],11)
    basis_X['emabasis2'] = ewm(data['basis'],2)
    basis_X['emabasis5'] = ewm(data['basis'],5)
    basis_X['emabasis10'] = ewm(data['basis'],10)
    basis_X['basis'] = data['basis']
    basis_X['totalaskvolratio'] = (data['stockTotalAskVol']
                                 - data['futureTotalAskVol'])/
                                   100000
    basis_X['totalbidvolratio'] = (data['stockTotalBidVol']
                                 - data['futureTotalBidVol'])/
                                   100000
    basis_X = basis_X.fillna(0)
    
    basis_y = data['Y(Target)']
    basis_y.dropna(inplace=True)
    return basis_X, basis_y
basis_X_test, basis_y_test = create_features_again(validation_data)
basis_X_train, basis_y_train = create_features_again(training_data)
_, basis_y_pred = linear_regression(basis_X_train, basis_y_train, basis_X_test,basis_y_test)
basis_y_regr = basis_y_pred.copy()

('Coefficients: ', array([ 0.03246139,
0.49780982, -0.22367172,  0.20275786,  0.50758852,
-0.21510795, 0.17153884]))
Mean squared error: 0.02
Variance score: 0.96

Bạn thấy đấy, không có thay đổi nào trong hiệu suất mô hình của chúng ta, chúng ta chỉ cần một vài tính năng để giải thích biến mục tiêu. Tôi đề nghị bạn thử nhiều tính năng nêu trên hơn, thử những kết hợp mới, v.v. để xem điều gì có thể cải thiện mô hình của chúng ta.

Chúng ta cũng có thể thử các mô hình phức tạp hơn để xem liệu việc thay đổi mô hình có thể cải thiện hiệu suất hay không.

• Thuật toán K-nearest neighbor (KNN)

from sklearn import neighbors
n_neighbors = 5
model = neighbors.KNeighborsRegressor(n_neighbors, weights='distance')
model.fit(basis_X_train, basis_y_train)
basis_y_pred = model.predict(basis_X_test)
basis_y_knn = basis_y_pred.copy()

• SVR

from sklearn.svm import SVR
model = SVR(kernel='rbf', C=1e3, gamma=0.1)
model.fit(basis_X_train, basis_y_train)
basis_y_pred = model.predict(basis_X_test)
basis_y_svr = basis_y_pred.copy()

• Cây quyết định

model=ensemble.ExtraTreesRegressor()
model.fit(basis_X_train, basis_y_train)
basis_y_pred = model.predict(basis_X_test)
basis_y_trees = basis_y_pred.copy()

Bước 7: Kiểm tra lại dữ liệu thử nghiệm

Kiểm tra hiệu suất trên dữ liệu mẫu thực tế

Hiệu suất kiểm tra ngược trên tập dữ liệu kiểm tra (chưa chỉnh sửa)

Đây là thời điểm quan trọng. Chúng tôi bắt đầu từ bước cuối cùng bằng cách chạy mô hình tối ưu cuối cùng trên dữ liệu thử nghiệm mà chúng tôi đã để riêng lúc đầu và chưa động đến cho đến giờ.

Điều này giúp bạn có kỳ vọng thực tế về cách mô hình của bạn sẽ hoạt động trên dữ liệu mới và chưa từng thấy khi bạn bắt đầu giao dịch trực tiếp. Do đó, cần đảm bảo rằng bạn có một tập dữ liệu sạch chưa được sử dụng để đào tạo hoặc xác thực mô hình.

Nếu bạn không thích kết quả kiểm tra ngược trên dữ liệu kiểm tra của mình, hãy bỏ mô hình và bắt đầu lại. Đừng bao giờ quay lại và tối ưu hóa lại mô hình của bạn, điều này sẽ dẫn đến tình trạng quá khớp! (Người ta cũng khuyến nghị nên tạo một tập dữ liệu thử nghiệm mới, vì tập dữ liệu này hiện đã bị nhiễm bẩn; khi loại bỏ mô hình, chúng ta đã biết ngầm một số thông tin về tập dữ liệu đó).

Ở đây chúng ta vẫn sẽ sử dụng Auquan’s Toolbox

import backtester
from backtester.features.feature import Feature
from backtester.trading_system import TradingSystem
from backtester.sample_scripts.fair_value_params import FairValueTradingParams
class Problem1Solver():
def getTrainingDataSet(self):
        return "trainingData1"
def getSymbolsToTrade(self):
        return ['MQK']
def getCustomFeatures(self):
        return {'my_custom_feature': MyCustomFeature}
def getFeatureConfigDicts(self):
                            
        expma5dic = {'featureKey': 'emabasis5',
                 'featureId': 'exponential_moving_average',
                 'params': {'period': 5,
                              'featureName': 'basis'}}
        expma10dic = {'featureKey': 'emabasis10',
                 'featureId': 'exponential_moving_average',
                 'params': {'period': 10,
                              'featureName': 'basis'}}                     
        expma2dic = {'featureKey': 'emabasis3',
                 'featureId': 'exponential_moving_average',
                 'params': {'period': 3,
                              'featureName': 'basis'}}
        mom10dic = {'featureKey': 'mom10',
                 'featureId': 'difference',
                 'params': {'period': 11,
                              'featureName': 'basis'}}
        
        return [expma5dic,expma2dic,expma10dic,mom10dic]    
    
    def getFairValue(self, updateNum, time, instrumentManager):
        # holder for all the instrument features
        lbInstF = instrumentManager.getlookbackInstrumentFeatures()
        mom10 = lbInstF.getFeatureDf('mom10').iloc[-1]
        emabasis2 = lbInstF.getFeatureDf('emabasis2').iloc[-1]
        emabasis5 = lbInstF.getFeatureDf('emabasis5').iloc[-1]
        emabasis10 = lbInstF.getFeatureDf('emabasis10').iloc[-1] 
        basis = lbInstF.getFeatureDf('basis').iloc[-1]
        totalaskvol = lbInstF.getFeatureDf('stockTotalAskVol').iloc[-1] - lbInstF.getFeatureDf('futureTotalAskVol').iloc[-1]
        totalbidvol = lbInstF.getFeatureDf('stockTotalBidVol').iloc[-1] - lbInstF.getFeatureDf('futureTotalBidVol').iloc[-1]
        
        coeff = [ 0.03249183, 0.49675487, -0.22289464, 0.2025182, 0.5080227, -0.21557005, 0.17128488]
        newdf['MQK'] = coeff[0] * mom10['MQK'] + coeff[1] * emabasis2['MQK'] +\
                      coeff[2] * emabasis5['MQK'] + coeff[3] * emabasis10['MQK'] +\
                      coeff[4] * basis['MQK'] + coeff[5] * totalaskvol['MQK']+\
                      coeff[6] * totalbidvol['MQK']
                    
        newdf.fillna(emabasis5,inplace=True)
        return newdf
problem1Solver = Problem1Solver()
tsParams = FairValueTradingParams(problem1Solver)
tradingSystem = TradingSystem(tsParams)
tradingSystem.startTrading(onlyAnalyze=False, 
                           shouldPlot=True,
                           makeInstrumentCsvs=False)

Kết quả kiểm tra ngược, Pnl được tính bằng đô la Mỹ (Pnl không bao gồm chi phí giao dịch và các loại phí khác)

Bước 8: Những cách khác để cải thiện mô hình

Xác thực lăn, Học tập tổng hợp, Đóng gói và Tăng cường

Bên cạnh việc thu thập thêm dữ liệu, tạo ra các tính năng tốt hơn hoặc thử nhiều mô hình hơn, sau đây là một số điều bạn có thể thử để cải thiện.

1. Xác minh liên tục

Xác thực lăn

Điều kiện thị trường hiếm khi giữ nguyên. Giả sử bạn có dữ liệu của một năm và bạn sử dụng dữ liệu từ tháng 1 đến tháng 8 để đào tạo và dữ liệu từ tháng 9 đến tháng 12 để thử nghiệm mô hình của mình, bạn có thể sẽ đào tạo cho một tập hợp các điều kiện thị trường rất cụ thể. Có thể thị trường không có biến động trong nửa đầu năm và một số tin tức cực đoan đã khiến thị trường tăng mạnh vào tháng 9. Mô hình của bạn sẽ không thể học được mô hình này và sẽ đưa ra cho bạn kết quả dự đoán rác.

Có thể sẽ tốt hơn nếu thử triển khai xác thực, đào tạo vào tháng 1-tháng 2, xác thực vào tháng 3, đào tạo lại vào tháng 4-tháng 5, xác thực vào tháng 6, v.v.

2. Học theo nhóm

Học tập theo nhóm

Một số mô hình có thể hoạt động tốt trong việc dự đoán một số tình huống nhất định, nhưng có thể lại quá chính xác khi dự đoán các tình huống khác hoặc trong một số tình huống nhất định. Một cách để giảm lỗi và hiện tượng quá khớp là sử dụng một tập hợp các mô hình khác nhau. Dự đoán của bạn sẽ là dự đoán trung bình của nhiều mô hình và lỗi của các mô hình khác nhau có thể được bù trừ hoặc giảm bớt. Một số phương pháp tổng hợp phổ biến là Bagging và Boosting.

Bagging

Boosting

Để ngắn gọn, tôi sẽ bỏ qua các phương pháp này, nhưng bạn có thể tìm thêm thông tin về chúng trực tuyến.

Hãy thử một phương pháp tổng hợp cho vấn đề của chúng ta

basis_y_pred_ensemble = (basis_y_trees + basis_y_svr +
                         basis_y_knn + basis_y_regr)/4

Mean squared error: 0.02
Variance score: 0.95

Chúng tôi đã tích lũy được rất nhiều kiến ​​thức và thông tin cho đến nay. Chúng ta hãy cùng xem lại nhanh:

• Giải quyết vấn đề của bạn

• Thu thập dữ liệu đáng tin cậy và làm sạch dữ liệu

• Chia dữ liệu thành các tập huấn luyện, xác thực và kiểm tra

• Tạo các tính năng và phân tích hành vi của chúng

• Chọn mô hình đào tạo phù hợp dựa trên hành vi

• Sử dụng dữ liệu đào tạo để đào tạo mô hình của bạn và đưa ra dự đoán

• Kiểm tra hiệu suất trên bộ xác thực và tối ưu hóa lại

• Xác minh hiệu suất cuối cùng trên bộ thử nghiệm

Khá thú vị phải không? Nhưng vẫn chưa kết thúc đâu. Bây giờ bạn chỉ có một mô hình dự đoán đáng tin cậy. Bạn còn nhớ chúng ta thực sự muốn gì trong chiến lược của mình không? Vì vậy, bạn chưa cần:

• Phát triển các tín hiệu dựa trên mô hình dự đoán để xác định hướng giao dịch

• Phát triển các chiến lược cụ thể để xác định vị trí mở và đóng

• Hệ thống thực hiện để xác định vị trí và giá

Tất cả những điều trên đều yêu cầu sử dụng Inventor Quantitative Platform (FMZ.COM). Trong Inventor Quantitative Platform, có một giao diện API được đóng gói chặt chẽ và hoàn chỉnh, cũng như các hàm lệnh và giao dịch có thể gọi toàn cục, do đó bạn không cần để kết nối và thêm chúng từng cái một. Giao diện API của các sàn giao dịch khác nhau, trong Strategy Square của Inventor Quantitative Platform, có rất nhiều chiến lược thay thế hoàn thiện và trưởng thành. Với phương pháp học máy của bài viết này, chiến lược cụ thể của bạn sẽ mạnh mẽ hơn . Strategy Square nằm tại địa chỉ: https:// www.fmz.com/square

Một lưu ý quan trọng về chi phí giao dịch:Mô hình của bạn sẽ cho bạn biết khi nào nên mua hoặc bán tài sản mà bạn chọn. Tuy nhiên, nó không tính đến phí/chi phí giao dịch/khối lượng khả dụng/dừng lỗ, v.v. Chi phí giao dịch thường có thể biến một giao dịch có lợi nhuận thành một giao dịch thua lỗ. Ví dụ, một tài sản dự kiến ​​sẽ tăng giá 0,05 đô la là một tài sản nên mua, nhưng nếu bạn phải trả 0,10 đô la để thực hiện giao dịch này, bạn sẽ phải chịu khoản lỗ ròng là 0,05 đô la. Biểu đồ lợi nhuận tuyệt đẹp ở trên thực tế trông như thế này sau khi bạn tính đến hoa hồng môi giới, phí giao dịch và chênh lệch giá:

Kết quả kiểm tra ngược sau khi tính phí giao dịch và chênh lệch, Pnl là USD

Phí giao dịch và chênh lệch giá chiếm hơn 90% Pnl của chúng tôi! Chúng tôi sẽ thảo luận chi tiết về những điều này trong các bài viết sau.

Cuối cùng, chúng ta hãy xem xét một số cạm bẫy thường gặp.

Nên và không nên làm

• Tránh trang bị quá mức cần thiết!

• Không đào tạo lại sau mỗi điểm dữ liệu: Đây là một lỗi phổ biến mà mọi người mắc phải trong quá trình phát triển máy học. Nếu mô hình của bạn cần được đào tạo lại sau mỗi điểm dữ liệu thì có lẽ đó không phải là một mô hình tốt. Nghĩa là, nó cần được đào tạo lại định kỳ, thường xuyên tùy theo mức độ hợp lý (ví dụ, vào cuối mỗi tuần nếu thực hiện dự báo trong ngày)

• Tránh thiên vị, đặc biệt là thiên vị nhìn về phía trước: Đây là một lý do khác khiến các mô hình không hiệu quả. Đảm bảo bạn không sử dụng bất kỳ thông tin nào từ tương lai. Trong hầu hết trường hợp, điều này có nghĩa là không sử dụng biến mục tiêu Y làm tính năng trong mô hình của bạn. Bạn có thể sử dụng tính năng này trong quá trình kiểm tra ngược, nhưng nó sẽ không khả dụng khi thực sự chạy mô hình của bạn, điều này sẽ khiến mô hình của bạn trở nên vô dụng.

• Hãy cẩn thận với sự thiên vị trong khai thác dữ liệu: Vì chúng ta đang cố gắng thực hiện một loạt mô hình trên dữ liệu của mình để xác định xem nó có phù hợp hay không, nếu không có lý do cụ thể nào cho việc đó, hãy đảm bảo bạn chạy các thử nghiệm nghiêm ngặt để tách các mẫu ngẫu nhiên khỏi các mẫu thực có thể xảy ra . Ví dụ, mô hình xu hướng tăng có thể được giải thích rõ bằng hồi quy tuyến tính, nhưng nó có thể chỉ là một phần nhỏ trong chuyển động ngẫu nhiên lớn hơn!

Tránh quá phù hợp

Điều này quan trọng đến mức tôi cảm thấy cần phải nhắc lại lần nữa.

• Quá mức là cái bẫy nguy hiểm nhất trong các chiến lược giao dịch

• Một thuật toán phức tạp có thể hoạt động cực kỳ tốt trong việc kiểm tra ngược nhưng lại thất bại thảm hại khi sử dụng dữ liệu mới chưa biết. Thuật toán không thực sự tiết lộ bất kỳ xu hướng nào trong dữ liệu và không có khả năng dự đoán thực sự. Nó rất phù hợp với dữ liệu mà nó nhìn thấy

• Giữ hệ thống của bạn đơn giản nhất có thể. Nếu bạn thấy mình cần nhiều tính năng phức tạp để giải thích dữ liệu của mình, bạn có thể đang quá phù hợp

• Chia dữ liệu có sẵn của bạn thành dữ liệu đào tạo và dữ liệu thử nghiệm, và luôn xác minh hiệu suất trên dữ liệu mẫu thực trước khi sử dụng mô hình để giao dịch trực tiếp.