Artikel ini terinspirasi dari pengamatan saya tentang beberapa peringatan dan perangkap umum setelah mencoba menerapkan teknologi pembelajaran mesin pada masalah transaksi saat melakukan penelitian data di inventor platform kuantitatif.

Jika Anda belum membaca artikel saya sebelumnya, kami sarankan Anda untuk membaca panduan saya tentang lingkungan penelitian data otomatis dan metode sistematis untuk membuat strategi perdagangan yang dibangun di inventor quantification platform sebelum artikel ini.

Di sini adalah alamatnya:https://www.fmz.com/digest-topic/4187danhttps://www.fmz.com/digest-topic/4169 这两篇文章.

Mengembangkan Lingkungan Penelitian

Tutorial ini dirancang untuk digunakan oleh para amatir, insinyur, dan ilmuwan data dari semua tingkat keterampilan. Tidak peduli apakah Anda seorang industri besar atau seorang programmer muda, satu-satunya keterampilan yang Anda butuhkan adalah pengetahuan dasar tentang bahasa pemrograman Python dan pengetahuan yang cukup tentang operasi baris perintah (untuk mengatur proyek ilmu data).

• Menginstal Inventor Quantify Host dan mengatur Anaconda

发明者量化平台FMZ.COM除了提供优质的各大主流交易所的数据源，还提供一套丰富的API接口以帮助我们在完成数据的分析后进行自动化交易。这套接口包括查询账户信息，查询各个主流交易所的高，开，低，收价格，成交量，各种常用技术分析指标等实用工具，特别是对于实际交易过程中连接各大主流交易所的公共API接口，提供了强大的技术支持。

Semua fitur yang disebutkan di atas terbungkus ke dalam sistem yang mirip Docker, yang harus kita lakukan adalah membeli atau menyewa layanan komputasi awan kita sendiri, dan kemudian kita dapat mengimplementasikan sistem Docker.

Dalam nama resmi platform kuantitatif penemu, sistem Docker ini disebut sistem host.

Untuk informasi lebih lanjut tentang cara mengimplementasikan administrator dan robot, lihat artikel saya sebelumnya:https://www.fmz.com/bbs-topic/4140

Untuk pembaca yang ingin membeli host yang mendistribusikan server cloud mereka sendiri, baca artikel ini:https://www.fmz.com/bbs-topic/2848

Setelah berhasil menerapkan layanan cloud dan sistem administrator, selanjutnya kita akan menginstal python terbesar saat ini: Anaconda.

Untuk menerapkan semua lingkungan program yang diperlukan untuk artikel ini (dependencies, version management, dll.), cara termudah adalah dengan menggunakan Anaconda. Ini adalah ekosistem ilmu data Python yang dikemas dan manajer repositori dependen.

Karena kami menginstal Anaconda pada layanan cloud, kami merekomendasikan server cloud untuk menginstal versi Anaconda pada sistem Linux dengan baris perintah.

Untuk cara menginstal Anaconda, lihat panduan resmi Anaconda:https://www.anaconda.com/distribution/

Jika Anda seorang programmer Python yang berpengalaman dan merasa tidak perlu menggunakan Anaconda, itu sama sekali tidak masalah. Saya akan berasumsi Anda tidak perlu bantuan dalam menginstal dependensi yang diperlukan, Anda dapat langsung melewati bagian ini.

Membuat Strategi Perdagangan

Output akhir dari strategi transaksi harus menjawab pertanyaan berikut:

• Kearah: menentukan apakah aset itu murah, mahal, atau memiliki nilai yang adil.

• 开仓条件：如果资产价格便宜或者昂贵，你应该做多或者做空.

• Perdagangan neraca: Apakah Anda harus neraca jika harga aset yang wajar dan kami memiliki posisi di aset tersebut (pembelian atau penjualan sebelumnya)

• Jangkauan harga: harga untuk melakukan perdagangan terbuka (atau jangkauan)

• Jumlah: Jumlah dana yang diperdagangkan (misalnya jumlah mata uang digital atau jumlah tangan pada komoditas berjangka)

Pembelajaran mesin dapat digunakan untuk menjawab setiap pertanyaan di atas, tetapi untuk sisa artikel ini, kami akan fokus menjawab pertanyaan pertama, yaitu arah perdagangan.

Metode strategis

Untuk membangun strategi, ada dua jenis pendekatan, yang satu berbasis model; yang lain berbasis data mining.

Dalam membangun strategi berbasis model, kita mulai dari model efisiensi rendah pasar, membangun ekspresi matematis (misalnya harga, laba) dan menguji efektivitasnya dalam periode waktu yang lebih lama. Model ini biasanya merupakan versi sederhana dari model yang benar-benar kompleks, yang perlu diverifikasi untuk makna dan stabilitas jangka panjangnya.

Di sisi lain, kita pertama-tama mencari pola harga dan mencoba menggunakan algoritma dalam metode penambangan data. Alasan mengapa pola-pola ini terjadi tidak penting, karena hanya pola-pola tertentu yang akan terus terulang di masa depan. Ini adalah metode analisis buta yang membutuhkan pemeriksaan ketat untuk mengidentifikasi pola yang benar dari pola acak.

Jelas, pembelajaran mesin dapat dengan mudah diterapkan pada metode penambangan data. Mari kita lihat bagaimana menggunakan pembelajaran mesin untuk membuat sinyal transaksi melalui penambangan data.

Contoh kode menggunakan alat retargeting dan API transaksi otomatis berbasis platform kuantifikasi inventor. Setelah menginstal host dan Anaconda di bagian di atas, Anda hanya perlu menginstal perpustakaan analisis ilmu data yang kami butuhkan dan model pembelajaran mesin terkenal scikit-learn. Kami tidak akan membahas apa pun di bagian ini.

pip install -U scikit-learn

Menggunakan pembelajaran mesin untuk membuat sinyal strategi perdagangan

• Penggalian data

Sebelum kita mulai, sebuah sistem masalah pembelajaran mesin standar adalah sebagai berikut:

Sistem masalah pembelajaran mesin

Fitur yang akan kita buat harus memiliki beberapa kemampuan prediktif (x), kita ingin memprediksi variabel target (y), dan menggunakan data sejarah untuk melatih model ML yang dapat memprediksi Y sedekat mungkin dengan nilai sebenarnya. Akhirnya, kita menggunakan model ini untuk memprediksi data baru yang tidak diketahui Y. Ini membawa kita ke langkah pertama:

Langkah 1: Tentukan Masalah Anda

• Apa yang ingin Anda prediksi? Apa yang menjadi prediksi yang baik? Bagaimana Anda menilai hasil prediksi Anda?

Jadi, dalam kerangka di atas, apa Y?

Apa yang ingin Anda prediksi?

Apakah Anda ingin memprediksi harga masa depan, pengembalian masa depan / Pnl, sinyal beli / jual, mengoptimalkan alokasi portofolio, dan mencoba untuk mengeksekusi transaksi secara efisien?

Misalkan kita mencoba memprediksi harga pada waktu berikutnya. Dalam hal ini, Y (t) = harga (t + 1). Sekarang kita dapat menyelesaikan kerangka kita dengan data sejarah.

Perhatikan bahwa Y (t) hanya diketahui dalam retrospeksi, tetapi ketika kita menggunakan model kita, kita tidak akan tahu harga waktu t (t + 1) ; kita menggunakan model kita untuk memprediksi Y (t) dan hanya membandingkannya dengan nilai aktual pada waktu t + 1; ini berarti Anda tidak dapat menggunakan Y sebagai karakteristik dalam model prediksi.

Setelah kita tahu target Y, kita juga dapat memutuskan bagaimana menilai prediksi kita. Ini sangat penting untuk membedakan antara model yang berbeda dari data yang akan kita coba. Berdasarkan masalah yang kita selesaikan, pilihlah indikator yang mengukur efisiensi model kita. Misalnya, jika kita memprediksi harga, kita dapat menggunakan kesalahan akar rata sebagai indikator. Beberapa indikator yang umum digunakan (average, MACD, dan diferensial, dll.) telah di-pre-encode di toolkit yang diukur oleh penemu, dan Anda dapat memanggil indikator-indikator ini secara global melalui antarmuka API.

Kerangka kerja ML untuk memprediksi harga masa depan

Untuk demonstrasi, kami akan membuat model prediksi untuk memprediksi nilai dasar yang diharapkan di masa depan dari indikator investasi asumsi, di mana:

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))

Karena ini adalah masalah regresi, kita akan mengevaluasi model pada RMSE (kesalahan akar persamaan); kita juga akan menggunakan Total Pnl sebagai kriteria evaluasi.

Catatan: Untuk pengetahuan matematika terkait RMSE, silakan lihat artikel terkait di Ensiklopedia

• 我们的目标：创建一个模型，使预测值尽可能接近Y.

Langkah 2: Kumpulkan data yang dapat diandalkan

Mengumpulkan dan membersihkan data yang dapat membantu Anda menyelesaikan masalah yang ada

Jika kita memprediksi harga, kita bisa menggunakan data harga indikator investasi, data volume transaksi indikator investasi, data serupa indikator investasi terkait, indikator indeks ekuitas indikator pasar keseluruhan, harga aset terkait lainnya.

Anda perlu mengatur akses data untuk ini, dan memastikan data Anda akurat dan tidak salah, dan memecahkan data yang hilang ("masalah yang sangat umum"); sementara memastikan data Anda tidak bias dan sepenuhnya mewakili semua kondisi pasar ("misalnya, skenario laba rugi yang sama"), untuk menghindari penyimpangan dalam model. Anda mungkin juga perlu membersihkan data untuk mendapatkan dividen, pembagian indikator investasi, kontinuitas, dll.

Jika Anda menggunakan platform inventor kuantitatif.FMZ.COMDengan menggunakan platform kuantitatif, kita dapat mengakses data global gratis dari Google, Yahoo, NSE, dan Quandl; data mendalam dari komoditas domestik seperti CTP dan EOS; data dari pertukaran mata uang digital utama seperti Binance, OKEX, Huobi, dan BitMex. Platform kuantitatif penemu juga membersihkan dan menyaring data ini terlebih dahulu, seperti pemisahan indikator investasi dan data tren mendalam, dan menyajikan kepada pengembang strategi dalam format yang mudah dipahami oleh pekerja kuantitatif.

Untuk mempermudah demonstrasi artikel ini, kami menggunakan data berikut sebagai indikator investasi virtual dari Auquan MQK, dan kami juga menggunakan alat pengukuran yang sangat berguna yang disebut Auquans Toolbox, untuk informasi lebih lanjut, lihat: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)

Dengan kode di atas, Auquans Toolbox telah mengunduh dan memuat data ke dalam kamus data. Kami sekarang perlu menyiapkan data dalam format yang kami sukai. Fungsi ds.getBookDataByFeature (,) mengembalikan kamus dari data, masing-masing memiliki satu data. Kami membuat data baru untuk saham dengan semua fitur tersebut.

Langkah 3: Pembagian data

• Membuat training set dari data, cross-validate dan uji data tersebut

Ini adalah langkah yang sangat penting!Sebelum kita melanjutkan, kita harus membagi data menjadi training datasets untuk melatih model Anda; test datasets untuk menilai kinerja model.

Memisahkan data menjadi training dan test set

Karena data pelatihan digunakan untuk mengevaluasi parameter model, maka model Anda mungkin akan terlalu menyesuaikan data pelatihan ini, dan data pelatihan akan menyesatkan kinerja model. Jika Anda tidak menyimpan data uji terpisah dan menggunakan semua data untuk melatih, Anda tidak akan tahu seberapa baik atau buruk model Anda melakukan terhadap data baru yang tidak terlihat. Ini adalah salah satu alasan utama mengapa model ML yang terlatih gagal dengan data real-time: orang melatih semua data yang tersedia dan bersemangat dengan indikator data pelatihan, tetapi model tidak dapat membuat prediksi yang berarti terhadap data real-time yang tidak terlatih.

Memisahkan data menjadi training set, verification set, dan test set

Ada masalah dengan pendekatan ini. Jika kita berulang kali melatih data pelatihan, menilai kinerja data uji dan mengoptimalkan model kita sampai kita merasa puas dengan kinerja, kita secara implisit memasukkan data uji sebagai bagian dari data pelatihan. Akhirnya, model kita mungkin berkinerja baik pada kumpulan data pelatihan dan uji, tetapi tidak menjamin bahwa itu dapat memprediksi data baru dengan baik.

Untuk memecahkan masalah ini, kita dapat membuat satu set data verifikasi yang terpisah. Sekarang, Anda dapat melatih data, mengevaluasi kinerja data verifikasi, mengoptimalkan sampai Anda puas dengan kinerja, dan akhirnya menguji data uji. Dengan cara ini, data uji tidak akan terkontaminasi, dan kami tidak akan menggunakan informasi apa pun dari data uji untuk memperbaiki model kami.

Ingatlah bahwa setelah Anda memeriksa kinerja data pengujian, jangan kembali dan mencoba untuk mengoptimalkan model lebih lanjut. Jika Anda menemukan bahwa model Anda tidak memberikan hasil yang baik, buang model itu sepenuhnya dan mulai lagi. Saran untuk memecahnya menjadi 60% data pelatihan, 20% data verifikasi, dan 20% data pengujian.

Untuk masalah kami, kami memiliki tiga set data yang tersedia, dan kami akan menggunakan satu sebagai set pelatihan, yang kedua sebagai set verifikasi, dan yang ketiga sebagai set pengujian kami.

# 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)

Untuk masing-masing, kita menambahkan variabel target Y, yang didefinisikan sebagai rata-rata dari lima nilai basis berikutnya.

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)

Langkah 4: Desain Fitur

Menganalisis perilaku data dan menciptakan karakteristik yang dapat diprediksi

Sekarang, mulailah membangun teknik yang sebenarnya. Aturan emas dari pemilihan fitur adalah bahwa kemampuan memprediksi sebagian besar berasal dari fitur, bukan dari model. Anda akan menemukan bahwa pilihan fitur memiliki dampak yang jauh lebih besar pada kinerja daripada pilihan model.

• Jangan memilih satu set fitur secara acak tanpa meneliti hubungannya dengan variabel target.

• Ada sedikit atau tidak ada hubungan dengan variabel target yang dapat menyebabkan overfitting

• Karakteristik yang Anda pilih mungkin sangat terkait satu sama lain, dan dalam hal ini, sejumlah kecil karakteristik juga dapat menjelaskan tujuan.

• Saya biasanya membuat beberapa fitur yang sangat intuitif untuk melihat bagaimana variabel target berhubungan dengan fitur-fitur tersebut, dan bagaimana mereka berhubungan untuk memutuskan fitur mana yang akan digunakan.

• Anda juga dapat mencoba mengurutkan karakteristik kandidat berdasarkan koefisien informasi terbesar (MIC), melakukan analisis komponen utama (PCA) dan metode lain.

Pergeseran / normalisasi karakteristik:

Model ML sering kali berkinerja baik dalam hal standarisasi. Namun, standarisasi sulit dilakukan ketika menangani data deret waktu karena jangkauan data di masa depan tidak diketahui. Data Anda mungkin berada di luar jangkauan standarisasi dan menyebabkan kesalahan model.

• Skala: Fitur pembagian berdasarkan standar diferensiasi atau rentang empat digit

• Perumahan: Mengurangi rata-rata historis dari nilai saat ini

• Integrasi: dua periode retrospektif dari ((x - mean) / stdev di atas

• Atribusi biasa: Standarisasi data menjadi kisaran -1 hingga +1 dan penentuan kembali pusat pada periode regression ((x-min) / ((max-min))

Perhatikan bahwa karena kita menggunakan rata-rata berturut-turut historis, standar deviasi, maksimum atau minimum yang melebihi periode retrospektif, maka nilai standarisasi atribut akan menunjukkan nilai aktual yang berbeda pada waktu yang berbeda. Misalnya, jika nilai saat ini dari suatu karakteristik adalah 5, rata-rata 30 siklus berturut-turut adalah 4.5, maka akan dikonversi menjadi 0.5 setelah berada di sana. Setelah itu, jika rata-rata 30 siklus berturut-turut berubah menjadi 3, maka nilai 3.5 akan menjadi 0.5;; ini mungkin penyebab kesalahan model.

Untuk iterasi pertama dalam masalah kita, kita menggunakan parameter campuran untuk menciptakan sejumlah besar fitur. Kami akan mencoba untuk melihat apakah jumlah fitur dapat dikurangi nanti.

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)

Langkah 5: Memilih model

Memilih model statistik/ML yang tepat berdasarkan pertanyaan yang dipilih

Pemilihan model tergantung pada bagaimana masalah dibuat. Apakah Anda memecahkan masalah pengawasan (setiap titik X dalam matriks karakteristik dipetakan ke variabel target Y) atau masalah pembelajaran tanpa pengawasan (tidak ada pemetaan yang diberikan, model mencoba mempelajari pola yang tidak diketahui)?

Belajar dengan pengawasan atau tanpa pengawasan

Kembali or Klasifikasi

Beberapa algoritma pembelajaran pengawasan yang umum dapat membantu Anda memulai:

• Regresi linier (parameter, regresi)

• Logistic regression (parameter, klasifikasi)

• Algoritma K-neighbor (KNN) (Berdasarkan contoh, regresi)

• SVM, SVR (parameter, klasifikasi dan regresi)

• Pohon Keputusan

• Hutan Keputusan

Saya sarankan untuk mulai dengan model sederhana, seperti linear atau logical regression, dan membangun model yang lebih kompleks dari sana sesuai kebutuhan. Saya juga sarankan Anda membaca matematika di balik model, bukan menggunakannya secara membabi buta sebagai kotak hitam.

Langkah 6: Pelatihan, Verifikasi, dan Optimasi (ulang langkah 4-6)

Latih dan optimalkan model Anda dengan menggunakan pelatihan dan verifikasi dataset

Sekarang, Anda siap untuk membangun model akhir. Pada tahap ini, Anda benar-benar hanya mengulangi model dan parameter model. Latih model Anda pada data pelatihan, ukur kinerja pada data verifikasi, dan kemudian kembali, optimalkan, latih kembali, dan evaluasi. Jika Anda tidak puas dengan kinerja model, cobalah menggunakan model lain.

Hanya setelah Anda memiliki model yang Anda sukai, kemudian lanjutkan ke langkah berikutnya.

Untuk masalah demonstrasi kita, mari kita mulai dengan regression linear sederhana.

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)

Regresi linier tanpa homogenisasi

('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

Lihatlah koefisien model. Kita tidak bisa benar-benar membandingkannya atau mengatakan mana yang penting, karena mereka semua berada pada skala yang berbeda. Mari kita coba mengintegrasikan untuk membuat mereka sesuai dengan proporsi yang sama dan juga memaksakan beberapa keseimbangan.

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]

Kembali linear dari integrasi

Mean squared error: 0.05
Variance score: 0.90

Model ini tidak meningkatkan model sebelumnya, tetapi juga tidak lebih buruk. Sekarang kita dapat membandingkan koefisien secara praktis dan melihat koefisien mana yang benar-benar penting.

Mari kita lihat faktornya.

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

Hasilnya adalah:

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

Kita dapat dengan jelas melihat bahwa beberapa karakteristik memiliki koefisien yang lebih tinggi dibandingkan dengan karakteristik lain, dan mungkin memiliki kemampuan prediktif yang lebih kuat.

Mari kita lihat hubungan antara karakteristik yang berbeda.

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()

Hubungan antara karakteristik

Daerah merah gelap menunjukkan variabel yang sangat relevan. Mari kita membuat / mengubah beberapa fitur lagi dan mencoba memperbaiki model kita.

例如，我可以轻松地丢弃像emabasisdi7这样的特征，这些特征只是其他特征的线性组合.

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

Lihat, kinerja model kami tidak berubah, kami hanya membutuhkan beberapa fitur untuk menjelaskan variabel target kami. Saya sarankan Anda mencoba lebih banyak fitur di atas, mencoba kombinasi baru, dll, dan melihat apa yang dapat meningkatkan model kami.

我们还可以尝试更复杂的模型，看看模型的变化是否可以提高性能.

• Algoritma K-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()

• Pohon Keputusan

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()

Langkah 7: Uji ulang data tes

Memeriksa kinerja data sampel yang sebenarnya

Kinerja retesting pada dataset uji ( belum disentuh)

Ini adalah saat yang penting. Kami mulai menjalankan model optimasi akhir kami dari langkah terakhir dari data pengujian, dan kami menyisihkannya di awal, data yang belum terpengaruh sejauh ini.

Ini memberi Anda harapan yang realistis tentang bagaimana model Anda akan menjalankan data baru dan yang belum terlihat saat Anda mulai berdagang secara real-time. Oleh karena itu, penting untuk memastikan Anda memiliki dataset yang bersih yang tidak digunakan untuk melatih atau memverifikasi model.

Jika Anda tidak menyukai hasil retest dari data pengujian, Anda dapat membuang model dan memulai kembali. Jangan pernah kembali untuk mengoptimalkan kembali model Anda, yang akan menyebabkan overfit!

Dan di sini kita akan menggunakan toolbox Auquan.

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)

Hasil retest, Pnl dihitung dalam dolar (Pnl tidak termasuk biaya transaksi dan biaya lainnya)

Langkah 8: Cara lain untuk memperbaiki model

Verifikasi bergulir, pembelajaran kelompok, Bagging dan Boosting

Selain mengumpulkan lebih banyak data, membuat fitur yang lebih baik, atau mencoba lebih banyak model, ini adalah beberapa hal yang dapat Anda coba untuk memperbaiki.

1. Verifikasi bergulir

Verifikasi bergulir

Kondisi pasar jarang tetap sama. Misalkan Anda memiliki data satu tahun dan Anda berlatih dengan data Januari-Agustus, dan Anda menguji model Anda dengan data September-Desember, Anda mungkin akhirnya berlatih untuk serangkaian kondisi pasar yang sangat spesifik. Mungkin tidak ada fluktuasi pasar di paruh pertama, beberapa berita ekstrem menyebabkan pasar naik drastis pada bulan September, model Anda tidak dapat mempelajari pola ini dan akan memberi Anda prediksi sampah.

Mungkin lebih baik untuk mencoba verifikasi rolling forward, pelatihan Januari-Februari, verifikasi Maret, re-training April-Mei, verifikasi Juni, dan sebagainya.

2. Belajar bersama

Belajar Bersama

Beberapa model mungkin bekerja dengan baik dalam memprediksi beberapa skenario, sementara model mungkin sangat overfit dalam memprediksi skenario lain atau dalam situasi tertentu. Salah satu cara untuk mengurangi kesalahan dan overfit adalah dengan menggunakan kumpulan model yang berbeda. Prediksi Anda akan menjadi rata-rata yang diprediksi oleh banyak model, dan kesalahan dari berbagai model mungkin akan diimbangi atau dikurangi. Beberapa metode pengumpulan yang umum adalah Bagging dan Boosting.

Pengemasan

Meningkatkan

Saya akan melewatkan metode ini untuk perkenalan singkat, tetapi Anda dapat mencari informasi lebih lanjut secara online.

Jadi mari kita coba metode pengumpulan untuk masalah kita.

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

Kami telah mengumpulkan banyak pengetahuan dan informasi sejauh ini. Mari kita lihat secara singkat:

• Mengatasi Masalah Anda

• Mengumpulkan data yang dapat diandalkan dan membersihkan data

• Membongkar data menjadi training, verification, dan test sets

• Membuat ciri dan menganalisis perilakunya

• Memilih model pelatihan yang tepat berdasarkan perilaku

• Gunakan data pelatihan untuk melatih model Anda dan membuat prediksi

• Memeriksa dan mengoptimalkan kembali kinerja pada verifikasi

• Memverifikasi kinerja akhir dari testset

Apakah itu terlalu awal? Tapi belum selesai, Anda sekarang hanya memiliki model prediksi yang dapat diandalkan. Ingat apa yang benar-benar kita inginkan dalam strategi kami?

• Mengembangkan sinyal berdasarkan model prediksi untuk mengidentifikasi arah perdagangan

• Mengembangkan strategi khusus untuk mengidentifikasi posisi terbuka

• Sistem pelaksanaan untuk mengidentifikasi posisi dan harga

Yang paling penting, kita harus menggunakan platform kuantitatif penemu.FMZ.COMDi Inventor Quantum Platform, ada banyak strategi alternatif yang sudah matang dan lengkap, yang dilengkapi dengan metode pembelajaran mesin yang akan membuat strategi spesifik Anda menjadi lebih baik. Strategi Square terletak di:https://www.fmz.com/square

Catatan penting tentang biaya transaksi：你的模型会告诉你所选资产何时是做多或做空。然而，它没有考虑费用/交易成本/可用交易量/止损等。交易成本通常会使有利可图的交易成为亏损。例如，预期价格上涨0.05美元的资产是买入，但如果你必须支付0.10美元进行此交易，你将最终获得净亏损$0.05。在你考虑经纪人佣金，交换费和点差后，我们上面看起来很棒的盈利图实际上是这样的：

Hasil retest setelah biaya transaksi dan deviasi titik, Pnl adalah dolar AS

Biaya transaksi dan perbedaan lebih dari 90% dari PNL kami! Kami akan membahas ini secara rinci di artikel berikutnya.

Akhirnya, mari kita lihat beberapa jebakan umum.

Apa yang harus dan tidak harus dilakukan

• Jangan terlalu beradaptasi dengan segala cara!

• Jangan melatih kembali setelah setiap titik data: ini adalah kesalahan umum yang dilakukan oleh orang-orang dalam pengembangan pembelajaran mesin. Jika model Anda perlu melatih kembali setelah setiap titik data, maka itu mungkin bukan model yang sangat baik. Artinya, itu perlu melatih kembali secara teratur, hanya dengan frekuensi yang wajar (misalnya, jika Anda melakukan prediksi di siang hari, Anda harus melatih kembali pada akhir minggu)

• Hindari bias, terutama bias prospektif: ini adalah alasan lain mengapa model tidak bekerja, pastikan Anda tidak menggunakan informasi apa pun tentang masa depan. Dalam kebanyakan kasus, ini berarti tidak menggunakan variabel target Y sebagai fitur dalam model. Anda dapat menggunakannya selama retrospektif, tetapi tidak akan dapat digunakan saat model benar-benar berjalan, yang akan membuat model Anda tidak dapat digunakan.

• Perhatian terhadap data mining bias: Karena kami sedang mencoba melakukan serangkaian pemodelan pada data kami untuk menentukan kesesuaian, jika tidak ada alasan khusus, pastikan Anda menjalankan tes yang ketat untuk memisahkan pola acak dari pola nyata yang mungkin terjadi. Misalnya, regresi linier sangat baik menjelaskan pola tren naik, yang kemungkinan besar akan menjadi bagian kecil dari pergeseran acak yang lebih besar!

Hindari ketergantungan yang berlebihan

Saya pikir ini sangat penting dan saya harus mengulanginya.

• Terlalu cocok adalah perangkap paling berbahaya dalam strategi trading

• Sebuah algoritma yang rumit mungkin sangat baik dalam retrospeksi, tetapi sangat gagal pada data baru yang tidak terlihat, algoritma ini tidak benar-benar mengungkapkan tren data apa pun dan tidak memiliki kemampuan prediktif yang nyata; itu sangat cocok dengan data yang dilihatnya.

• Buatlah sistem Anda sesederhana mungkin. Jika Anda menemukan bahwa Anda membutuhkan banyak fitur yang rumit untuk menafsirkan data, Anda mungkin terlalu cocok.

• Pisahkan data yang tersedia menjadi data pelatihan dan data pengujian, dan selalu verifikasi kinerja data sampel yang sebenarnya sebelum menggunakan model untuk melakukan transaksi secara real-time.

Berkaitan

Lebih banyak