Catatan ini diilhamkan oleh pemerhatian saya tentang beberapa amaran dan perangkap biasa selepas cuba menggunakan teknik pembelajaran mesin untuk masalah perdagangan semasa penyelidikan data saya di platform Inventor Quant.

Jika anda belum membaca artikel saya sebelum ini, kami mengesyorkan anda membaca panduan saya sebelum ini untuk persekitaran penyelidikan data automatik yang ditubuhkan pada Platform Kuantitatif Pencipta dan pendekatan sistematik untuk membangunkan strategi dagangan sebelum artikel ini.

Alamatnya ada di sini: https://www.fmz.com/digest-topic/4187 dan https://www.fmz.com/digest-topic/4169.

Mengenai penubuhan persekitaran penyelidikan

Tutorial ini direka bentuk untuk peminat, jurutera dan saintis data dari semua peringkat kemahiran Sama ada anda pakar industri atau pemula pengaturcaraan, satu-satunya kemahiran yang anda perlukan ialah pemahaman asas bahasa pengaturcaraan Python dan pengetahuan yang mencukupi tentang operasi baris arahan. (Keupayaan untuk menyediakan projek sains data adalah mencukupi)

• Memasang Inventor Quant Hoster dan Menyediakan Anaconda

Selain menyediakan sumber data berkualiti tinggi daripada bursa arus perdana utama, Inventor Quantitative Platform FMZ.COM juga menyediakan set antara muka API yang kaya untuk membantu kami melakukan transaksi automatik selepas menyelesaikan analisis data. Set antara muka ini termasuk alat praktikal seperti menanyakan maklumat akaun, menanya harga tinggi, pembukaan, rendah, penutupan, volum dagangan, pelbagai penunjuk analisis teknikal yang biasa digunakan bagi pelbagai bursa arus perdana, dsb., terutamanya untuk menyambung ke bursa arus perdana utama secara sebenar. proses perdagangan Antara muka API awam menyediakan sokongan teknikal yang berkuasa.

Semua ciri yang disebutkan di atas dirangkumkan dalam sistem yang serupa dengan Docker Apa yang perlu kita lakukan ialah membeli atau menyewa perkhidmatan pengkomputeran awan kita sendiri dan kemudian menggunakan sistem Docker.

Atas nama rasmi Platform Kuantitatif Inventor, sistem Docker ini dipanggil sistem hos.

Untuk mendapatkan maklumat lanjut tentang cara menggunakan hos dan robot, sila rujuk artikel saya sebelum ini: https://www.fmz.com/bbs-topic/4140

Pembaca yang ingin membeli hos penggunaan pelayan pengkomputeran awan mereka sendiri boleh merujuk artikel ini: https://www.fmz.com/bbs-topic/2848

Selepas berjaya menggunakan perkhidmatan pengkomputeran awan dan sistem hos, kami akan memasang alat Python yang paling berkuasa: Anaconda

Untuk mencapai semua persekitaran program yang berkaitan yang diperlukan untuk artikel ini (pustaka bergantung, pengurusan versi, dll.), cara paling mudah ialah menggunakan Anaconda. Ia adalah ekosistem sains data Python yang dibungkus dan pengurus pergantungan.

Memandangkan kami memasang Anaconda pada perkhidmatan awan, kami mengesyorkan anda memasang sistem Linux serta versi baris arahan Anaconda pada pelayan awan.

Untuk kaedah pemasangan Anaconda, sila rujuk panduan rasmi Anaconda: https://www.anaconda.com/distribution/

Jika anda seorang pengaturcara Python yang berpengalaman dan tidak merasakan keperluan untuk menggunakan Anaconda, itu tidak mengapa. Saya akan menganggap bahawa anda tidak memerlukan bantuan memasang kebergantungan yang diperlukan dan anda boleh melangkau bahagian ini.

Membangunkan strategi perdagangan

Output akhir strategi perdagangan harus menjawab soalan berikut:

• Arahan: Tentukan sama ada aset itu murah, mahal atau bernilai saksama.

• Syarat pembukaan: Jika harga aset murah atau mahal, anda harus pergi panjang atau pendek.

• Tutup perdagangan: Jika harga aset adalah adil dan kami mempunyai kedudukan dalam aset itu (beli atau jual sebelumnya), adakah anda perlu menutup kedudukan itu?

• Julat Harga: Harga (atau julat) di mana perdagangan dibuka

• Kuantiti: Jumlah dana yang didagangkan (cth. jumlah mata wang digital atau bilangan lot niaga hadapan komoditi)

Pembelajaran mesin boleh digunakan untuk menjawab setiap soalan ini, tetapi untuk seluruh artikel ini, kami akan menumpukan pada menjawab soalan pertama, iaitu hala tuju perdagangan.

Pendekatan Strategik

Terdapat dua jenis pendekatan untuk membina strategi, satu berasaskan model dan satu lagi berasaskan perlombongan data. Kedua-dua ini pada dasarnya adalah pendekatan yang bertentangan.

Dalam pembinaan strategi berasaskan model, kita bermula dengan model ketidakcekapan pasaran, membina ungkapan matematik (cth., harga, pulangan) dan menguji keberkesanannya dalam tempoh masa yang lebih lama. Model ini biasanya merupakan versi ringkas bagi model kompleks sebenar, dan kepentingan serta kestabilannya dalam jangka panjang perlu disahkan. Aliran biasa yang mengikuti, strategi pengembalian min dan arbitraj termasuk dalam kategori ini.

Sebaliknya, kami mula-mula mencari corak harga dan cuba menggunakan algoritma dalam kaedah perlombongan data. Apa yang menyebabkan corak ini tidak penting, kerana yang pasti corak tersebut akan terus berulang pada masa hadapan. Ini adalah kaedah analisis buta dan kami memerlukan pemeriksaan rapi untuk mengenal pasti corak sebenar daripada corak rawak. “Percubaan dan ralat”, “Corak carta bar” dan “Regression jisim ciri” tergolong dalam kategori ini.

Jelas sekali, pembelajaran mesin sesuai dengan kaedah perlombongan data. Mari lihat bagaimana pembelajaran mesin boleh digunakan untuk mencipta isyarat dagangan melalui perlombongan data.

Contoh kod menggunakan alat ujian belakang dan antara muka API dagangan automatik berdasarkan Platform Kuantitatif Pencipta. Selepas menggunakan hoster dan memasang Anaconda di bahagian di atas, anda hanya perlu memasang pustaka analisis sains data yang kami perlukan dan model pembelajaran mesin yang terkenal scikit-learn Kami tidak akan menerangkan secara terperinci tentang bahagian ini.

pip install -U scikit-learn

Menggunakan pembelajaran mesin untuk mencipta isyarat strategi dagangan

• Perlombongan Data

Sebelum kita bermula, masalah pembelajaran mesin standard kelihatan seperti ini:

Rangka Kerja Masalah Pembelajaran Mesin

Ciri yang akan kami cipta mesti mempunyai sedikit kuasa ramalan (X), kami ingin meramalkan pembolehubah sasaran (Y), dan menggunakan data sejarah untuk melatih model ML yang boleh meramalkan Y sehampir mungkin dengan nilai sebenar. Akhir sekali, kami menggunakan model ini untuk membuat ramalan pada data baharu yang Y tidak diketahui. Ini membawa kita ke langkah pertama:

Langkah 1: Sediakan masalah anda

• Apa yang anda ingin ramalkan? Apakah ramalan yang baik? Bagaimanakah anda menilai keputusan ramalan?

Iaitu, dalam rangka kerja kami di atas, apakah Y?

Apa yang anda ingin ramalkan?

Adakah anda ingin meramalkan harga masa hadapan, pulangan masa hadapan/Pnl, isyarat beli/jual, mengoptimumkan peruntukan portfolio dan cuba melaksanakan dagangan dengan cekap dsb?

Katakan kita cuba meramalkan harga pada cap waktu seterusnya. Dalam kes ini, Y(t) = Harga(t+1). Kini kami boleh melengkapkan rangka kerja kami dengan data sejarah

Ambil perhatian bahawa Y(t) hanya diketahui dalam ujian belakang, tetapi apabila kita menggunakan model kita, kita tidak akan mengetahui harga pada masa t (t+1). Kami menggunakan model kami untuk membuat ramalan Y(diramalkan, t) dan membandingkannya dengan nilai sebenar hanya pada masa t+1. Ini bermakna anda tidak boleh menggunakan Y sebagai ciri dalam model ramalan.

Sebaik sahaja kami mengetahui sasaran Y kami, kami juga boleh memutuskan cara menilai ramalan kami. Ini penting untuk membezakan model berbeza yang akan kami cuba pada data kami. Bergantung pada masalah yang kami selesaikan, pilih metrik untuk mengukur kecekapan model kami. Contohnya, jika kita meramalkan harga, kita boleh menggunakan ralat purata kuasa dua akar sebagai metrik. Beberapa penunjuk yang biasa digunakan (purata bergerak, MACD dan skor varians, dsb.) telah diprakodkan dalam kotak alat Kuan Pencipta, dan anda boleh memanggil penunjuk ini secara global melalui antara muka API.

Rangka kerja ML untuk meramalkan harga masa hadapan

Untuk menunjukkan, kami akan mencipta model ramalan untuk meramalkan nilai asas jangkaan masa hadapan bagi sasaran pelaburan hipotesis, 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))

Memandangkan ini adalah masalah regresi, kami akan menilai model pada RMSE (Root Mean Squared Error). Kami juga akan menggunakan Jumlah Pnl sebagai kriteria penilaian

Nota: Untuk pengetahuan matematik yang berkaitan tentang RMSE, sila rujuk kandungan Ensiklopedia Baidu yang berkaitan

• Matlamat kami: mencipta model yang menjadikan nilai ramalan sedekat mungkin dengan Y.

Langkah 2: Kumpul data yang boleh dipercayai

Kumpul dan bersihkan data yang boleh membantu anda menyelesaikan masalah yang dihadapi

Apakah data yang perlu anda pertimbangkan untuk mempunyai kuasa ramalan bagi pembolehubah sasaran Y? Jika kami meramalkan harga, anda boleh menggunakan data harga sasaran, data volum dagangan sasaran, data serupa untuk sasaran berkaitan, penunjuk pasaran keseluruhan seperti tahap indeks sasaran, harga aset lain yang berkaitan, dsb.

Anda perlu menyediakan kebenaran akses data untuk data ini dan memastikan data anda tepat dan menyelesaikan data yang hilang (masalah yang sangat biasa). Juga pastikan data anda tidak berat sebelah dan mewakili semua keadaan pasaran (cth., bilangan senario menang/kalah yang sama) untuk mengelakkan berat sebelah dalam model anda. Anda juga mungkin perlu membersihkan data untuk dividen, pembahagian portfolio, kesinambungan, dsb.

Jika anda menggunakan Inventor Quantitative Platform (FMZ.COM), kami boleh mengakses data global percuma daripada Google, Yahoo, NSE dan Quandl data mendalam daripada niaga hadapan komoditi domestik seperti CTP dan Yisheng, OKEX, Huobi dan BitMex; Platform Kuantitatif Inventor juga pra-membersihkan dan menapis data ini, seperti pemisahan sasaran pelaburan dan data pasaran yang mendalam, dan membentangkannya kepada pembangun strategi dalam format yang mudah difahami oleh pekerja kuantitatif.

Untuk kemudahan artikel ini, kami menggunakan data berikut sebagai sasaran pelaburan maya ‘MQK’ Kami juga menggunakan alat kuantitatif yang sangat mudah dipanggil Kotak Alat Auquan Untuk maklumat lanjut, sila rujuk: 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 kod di atas, Kotak Alat Auquan telah memuat turun dan memuatkan data ke dalam kamus bingkai data. Kami kini perlu menyediakan data dalam format yang kami suka. Fungsi ds.getBookDataByFeature() mengembalikan kamus bingkai data, satu bingkai data bagi setiap ciri. Kami mencipta bingkai data baharu untuk stok dengan semua ciri.

Langkah 3: Pisahkan data

• Cipta set latihan daripada data, sahkan silang dan uji set ini

Ini adalah langkah yang sangat penting! Sebelum kami meneruskan, kami harus membahagikan data kepada set data latihan, untuk melatih model anda dan set data ujian, untuk menilai prestasi model. Pembahagian yang disyorkan ialah: 60-70% set latihan dan 30-40% set ujian

Pisahkan data kepada set latihan dan ujian

Memandangkan data latihan digunakan untuk menilai parameter model, model anda mungkin terlalu sesuai dengan data latihan ini dan data latihan mungkin mengelirukan prestasi model. Jika anda tidak menyimpan sebarang data ujian yang berasingan dan menggunakan semua data untuk latihan, anda tidak akan tahu sejauh mana prestasi model anda pada data baharu yang tidak kelihatan. Ini adalah salah satu sebab utama model ML terlatih gagal pada data langsung: orang ramai melatih semua data yang tersedia dan teruja dengan metrik data latihan, tetapi model itu gagal membuat sebarang ramalan bermakna pada data langsung yang tidak dilatih. .

Pisahkan data kepada set latihan, pengesahan dan ujian

Terdapat masalah dengan pendekatan ini. Jika kami berulang kali melatih data latihan, menilai prestasi pada data ujian dan mengoptimumkan model kami sehingga kami berpuas hati dengan prestasi, kami secara tersirat memasukkan data ujian sebagai sebahagian daripada data latihan. Akhirnya, model kami mungkin berprestasi baik pada set data latihan dan ujian ini, tetapi tidak ada jaminan bahawa ia akan dapat meramal data baharu dengan baik.

Untuk menangani isu ini, kami boleh membuat set data pengesahan yang berasingan. Kini anda boleh melatih data, menilai prestasi pada data pengesahan, mengoptimumkan sehingga anda berpuas hati dengan prestasi, dan akhirnya menguji data ujian. Dengan cara ini, data ujian tidak akan tercemar dan kami tidak akan menggunakan sebarang maklumat daripada data ujian untuk menambah baik model kami.

Ingat, sebaik sahaja anda menyemak prestasi pada data ujian, jangan kembali dan cuba mengoptimumkan model dengan lebih lanjut. Jika anda mendapati model anda tidak memberikan hasil yang baik, buang model sepenuhnya dan mulakan semula. Pemisahan yang dicadangkan boleh menjadi 60% data latihan, 20% data pengesahan dan 20% data ujian.

Untuk masalah kami, kami mempunyai tiga set data yang tersedia dan kami akan menggunakan satu sebagai set latihan, yang kedua sebagai set pengesahan dan yang ketiga sebagai set ujian 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)

Pada setiap satu daripada ini, kami menambah pembolehubah sasaran Y, yang ditakrifkan sebagai min bagi lima nilai asas seterusnya

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: Kejuruteraan Ciri

Menganalisis kelakuan data dan mencipta ciri dengan kuasa ramalan

Kini pembinaan sebenar projek itu bermula. Peraturan emas pemilihan ciri ialah kuasa ramalan datang terutamanya daripada ciri, bukan daripada model. Anda akan mendapati bahawa pilihan ciri mempunyai kesan yang lebih besar terhadap prestasi daripada pilihan model. Beberapa nota mengenai pemilihan ciri:

• Jangan sewenang-wenangnya memilih set ciri yang besar tanpa meneroka hubungannya dengan pembolehubah sasaran.

• Sedikit atau tiada perhubungan dengan pembolehubah sasaran boleh membawa kepada pemasangan berlebihan

• Ciri yang anda pilih mungkin sangat berkorelasi antara satu sama lain, dalam hal ini, bilangan ciri yang lebih kecil juga mungkin menjelaskan sasaran

• Saya biasanya mencipta beberapa ciri yang masuk akal intuitif dan melihat bagaimana pembolehubah sasaran dikaitkan dengan ciri ini, serta cara ia dikaitkan antara satu sama lain untuk memutuskan yang mana satu untuk digunakan.

• Anda juga boleh cuba menilai ciri calon berdasarkan Pekali Maklumat Maksimum (MIC), melaksanakan Analisis Komponen Utama (PCA) dan kaedah lain.

Transformasi Ciri/Penormalan:

Model ML cenderung berprestasi baik dengan normalisasi. Walau bagaimanapun, penormalan adalah rumit apabila berurusan dengan data siri masa kerana julat data masa hadapan tidak diketahui. Data anda mungkin berada di luar julat yang dinormalkan, menyebabkan model menjadi salah. Tetapi anda masih boleh cuba memaksa beberapa tahap pegun:

• Penskalaan: Pisahkan ciri mengikut sisihan piawai atau julat antara kuartil

• Pemusatan: Tolak purata sejarah daripada nilai semasa

• Normalisasi: Dua tempoh lihat balik di atas (x - min) / stdev

• Normalisasi Konvensional: Normalisasi data kepada julat -1 hingga +1 dan pusat semula dalam tempoh lihat balik (x-min)/(maks-min)

Ambil perhatian bahawa memandangkan kami menggunakan min larian sejarah, sisihan piawai, nilai maksimum atau minimum sepanjang tempoh lihat kembali, nilai normal ciri tersebut akan mewakili nilai sebenar yang berbeza pada masa yang berbeza. Sebagai contoh, jika nilai semasa ciri ialah 5 dan purata 30 tempoh berjalan ialah 4.5, ia akan ditukar kepada 0.5 selepas pemusatan. Kemudian, jika purata larian 30 tempoh menjadi 3, nilai 3.5 akan menjadi 0.5. Ini boleh menjadi sebab mengapa model itu salah Jadi, penyelarasan adalah rumit dan anda perlu memikirkan apa yang sebenarnya meningkatkan prestasi model (jika ada).

Untuk lelaran pertama dalam masalah kami, kami mencipta sejumlah besar ciri menggunakan parameter pencampuran. Nanti kita akan cuba lihat sama ada kita boleh mengurangkan bilangan ciri

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: Pemilihan model

Pilih model statistik/ML yang sesuai untuk masalah yang dipilih

Pemilihan model bergantung kepada bagaimana masalah dirumuskan. Adakah anda menyelesaikan masalah yang diselia (setiap titik X dalam matriks ciri dipetakan kepada pembolehubah sasaran Y) atau masalah pembelajaran tanpa pengawasan (tiada pemetaan diberikan dan model cuba mempelajari corak yang tidak diketahui)? Adakah anda menyelesaikan regresi (meramalkan harga sebenar pada masa hadapan) atau masalah klasifikasi (meramalkan hanya arah (kenaikan/penurunan) harga pada masa hadapan).

Pembelajaran diselia atau tidak diselia

Regresi atau Klasifikasi

Beberapa algoritma pembelajaran seliaan biasa boleh membantu anda bermula:

• Regresi Linear(parameter, regresi)

• Regresi logistik (parameter, klasifikasi)

• Algoritma K-nerest neighbor (KNN) (berasaskan contoh, regresi)

• SVM, SVR (parameter, klasifikasi dan regresi)

• Pokok Keputusan

• Hutan Keputusan

Saya mengesyorkan bermula dengan model mudah, seperti regresi linear atau logistik, dan membina model yang lebih kompleks dari sana seperti yang diperlukan. Anda juga disyorkan untuk membaca matematik di sebalik model dan bukannya menggunakannya secara membuta tuli sebagai kotak hitam.

Langkah 6: Latihan, pengesahan dan pengoptimuman (ulang langkah 4-6)

Latih dan optimumkan model anda menggunakan set data latihan dan pengesahan

Kini anda sudah bersedia untuk membina model anda. Pada peringkat ini, anda benar-benar hanya mengulangi model dan parameter model. Latih model anda pada data latihan, ukur prestasinya pada data pengesahan, kemudian kembali, optimumkan, latih semula dan nilai. Jika anda tidak berpuas hati dengan prestasi model, cuba gunakan model lain. Anda melalui fasa ini beberapa kali sehingga anda akhirnya mempunyai model yang anda sukai.

Hanya apabila anda mempunyai model yang anda suka, kemudian teruskan ke langkah seterusnya.

Untuk masalah demonstrasi kita, mari kita mulakan dengan regresi linear mudah

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 linear tanpa normalisasi

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

Lihat pekali model. Kita tidak boleh benar-benar membandingkannya atau mengatakan yang mana yang penting kerana semuanya jatuh pada skala yang berbeza. Mari cuba menormalkan untuk membawanya ke dalam skala yang sama dan juga menguatkuasakan beberapa pegun.

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]

Regresi Linear Ternormal

Mean squared error: 0.05
Variance score: 0.90

Model ini bukan penambahbaikan berbanding model sebelumnya, tetapi ia juga tidak lebih teruk. Sekarang kita sebenarnya boleh membandingkan pekali dan melihat mana yang sebenarnya penting.

Mari kita lihat pekali

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

Hasilnya ialah:

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 melihat dengan jelas bahawa sesetengah ciri mempunyai pekali yang lebih tinggi berbanding dengan ciri lain dan berkemungkinan mempunyai kuasa ramalan yang lebih kuat.

Mari kita lihat korelasi antara ciri yang berbeza.

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

Korelasi antara ciri

Kawasan merah gelap menunjukkan pembolehubah yang sangat berkorelasi. Mari buat/ubah suai beberapa ciri sekali lagi dan cuba perbaiki model kami.

Sebagai contoh, saya boleh dengan mudah membuang ciri seperti emabasisdi7 yang merupakan gabungan linear ciri lain.

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, tiada perubahan dalam prestasi model kami, kami hanya memerlukan beberapa ciri untuk menerangkan pembolehubah sasaran kami. Saya cadangkan anda mencuba lebih banyak ciri di atas, cuba kombinasi baharu dan lain-lain untuk melihat perkara yang boleh menambah baik model kami.

Kami juga boleh mencuba model yang lebih kompleks untuk melihat sama ada perubahan pada model boleh meningkatkan prestasi.

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

• Pokok 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 balik data ujian

Semak prestasi pada data sampel sebenar

Prestasi ujian belakang pada set data ujian (tidak disentuh).

Ini adalah saat kritikal. Kami bermula dari langkah terakhir dengan menjalankan model pengoptimuman terakhir kami pada data ujian yang kami ketepikan pada mulanya dan belum menyentuh setakat ini.

Ini memberikan anda jangkaan realistik tentang prestasi model anda pada data baharu dan tidak kelihatan apabila anda mula berdagang secara langsung. Oleh itu, adalah perlu untuk memastikan bahawa anda mempunyai set data bersih yang belum digunakan untuk melatih atau mengesahkan model.

Jika anda tidak menyukai keputusan ujian belakang pada data ujian anda, buang model itu dan mulakan semula. Jangan sekali-kali berundur dan mengoptimumkan semula model anda, ini akan menyebabkan pemasangan berlebihan! (Ia juga disyorkan untuk mencipta set data ujian baharu, memandangkan set data ini kini tercemar; apabila membuang model, kami sudah mengetahui sesuatu secara tersirat tentang set data).

Di sini kita masih akan menggunakan Kotak Alat 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)

Keputusan backtest, Pnl dikira dalam dolar AS (Pnl tidak termasuk kos transaksi dan yuran lain)

Langkah 8: Cara lain untuk menambah baik model

Rolling Validation, Ensemble Learning, Bagging and Boosting

Selain mengumpul lebih banyak data, mencipta ciri yang lebih baik atau mencuba lebih banyak model, berikut ialah beberapa perkara yang boleh anda cuba perbaiki.

1. Pengesahan bergulir

Pengesahan Berguling

Keadaan pasaran jarang kekal malar. Katakan anda mempunyai data bernilai setahun, dan anda menggunakan data dari Januari hingga Ogos untuk latihan, dan data dari September hingga Disember untuk menguji model anda, anda mungkin menamatkan latihan untuk set keadaan pasaran yang sangat khusus. Mungkin tiada turun naik pasaran pada separuh pertama tahun ini, dan beberapa berita melampau menyebabkan pasaran meningkat secara mendadak pada bulan September Model anda tidak akan dapat mempelajari corak ini dan akan memberi anda hasil ramalan sampah.

Mungkin lebih baik untuk mencuba pengesahan rolling ke hadapan, latihan pada bulan Januari-Februari, pengesahan pada bulan Mac, latihan semula pada April-Mei, pengesahan pada bulan Jun dan seterusnya.

2. Pembelajaran Ensembel

Pembelajaran Ensembel

Sesetengah model mungkin berfungsi dengan baik dalam meramalkan senario tertentu, tetapi mungkin berlebihan dalam meramalkan senario lain atau dalam situasi tertentu. Satu cara untuk mengurangkan ralat dan overfitting adalah dengan menggunakan ensemble model yang berbeza. Ramalan anda ialah purata ramalan yang dibuat oleh banyak model dan ralat model yang berbeza mungkin diimbangi atau dikurangkan. Beberapa kaedah ensemble biasa ialah Bagging dan Boosting.

Bagging

Boosting

Demi ringkasnya, saya akan melangkau kaedah ini, tetapi anda boleh mendapatkan lebih banyak maklumat mengenainya dalam talian.

Mari cuba kaedah ensemble 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 mengumpul banyak pengetahuan dan maklumat setakat ini. Mari kita semak semula:

• Selesaikan masalah anda

• Mengumpul data yang boleh dipercayai dan membersihkan data

• Pisahkan data kepada set latihan, pengesahan dan ujian

• Cipta ciri dan analisa tingkah lakunya

• Pilih model latihan yang sesuai berdasarkan tingkah laku

• Gunakan data latihan untuk melatih model anda dan membuat ramalan

• Semak prestasi pada set pengesahan dan optimumkan semula

• Sahkan prestasi akhir pada set ujian

Agak menarik, bukan? Anda kini hanya mempunyai model ramalan yang boleh dipercayai. Ingat apa yang kita mahukan dalam strategi kita? Jadi anda belum memerlukan:

• Membangunkan isyarat berasaskan model ramalan untuk mengenal pasti arah perdagangan

• Membangunkan strategi khusus untuk mengenal pasti kedudukan pembukaan dan penutupan

• Sistem pelaksanaan untuk mengenal pasti kedudukan dan harga

Semua perkara di atas memerlukan penggunaan Platform Kuantitatif Pencipta (FMZ.COM Dalam Platform Kuantitatif Pencipta, terdapat antara muka API yang sangat dikemaskan dan lengkap, serta fungsi pesanan dan transaksi yang boleh dipanggil secara global, jadi anda tidak memerlukannya). untuk menyambung dan menambahnya satu demi satu antara muka API pertukaran yang berbeza, dalam Dataran Strategi Platform Kuantitatif Pencipta, terdapat banyak strategi alternatif yang matang dan lengkap Dengan kaedah pembelajaran mesin artikel ini, strategi khusus anda akan menjadi lebih berkuasa . The Strategy Square terletak di: https:// www.fmz.com/square

Nota penting tentang kos transaksi: Model anda akan memberitahu anda bila hendak pergi panjang atau pendek pada aset pilihan anda. Walau bagaimanapun, ia tidak mengambil kira yuran/kos urus niaga/ volum tersedia/henti rugi dsb. Kos urus niaga selalunya boleh mengubah perdagangan yang menguntungkan menjadi kerugian. Sebagai contoh, aset yang dijangka meningkat dalam harga sebanyak \(0.05 ialah belian, tetapi jika anda perlu membayar \)0.10 untuk membuat dagangan ini, anda akan mengalami kerugian bersih sebanyak $0.05. Graf keuntungan kami yang kelihatan hebat di atas sebenarnya kelihatan seperti ini selepas anda mengambil kira komisen broker, yuran pertukaran dan spread:

Keputusan backtest selepas yuran transaksi dan spread, Pnl ialah USD

Yuran transaksi dan spread menyumbang lebih daripada 90% daripada Pnl kami! Kami akan membincangkan perkara ini secara terperinci dalam artikel seterusnya.

Akhir sekali, mari kita lihat beberapa perangkap biasa.

Perkara yang boleh dan tidak boleh dilakukan

• Elakkan overfitting dengan sekuat tenaga anda!

• Jangan latih semula selepas setiap titik data: Ini adalah kesilapan biasa yang dilakukan orang dalam pembangunan pembelajaran mesin. Jika model anda perlu dilatih semula selepas setiap titik data, maka model itu mungkin bukan model yang sangat baik. Iaitu, ia perlu dilatih semula secara berkala, sekerap yang ia masuk akal (cth., pada penghujung setiap minggu jika melakukan ramalan intrahari)

• Elakkan berat sebelah, terutamanya berat sebelah pandang ke hadapan: Ini adalah satu lagi sebab model tidak berfungsi. Pastikan anda tidak menggunakan sebarang maklumat dari masa hadapan. Selalunya, ini bermakna tidak menggunakan pembolehubah sasaran Y sebagai ciri dalam model anda. Anda boleh menggunakannya semasa ujian belakang, tetapi ia tidak akan tersedia apabila benar-benar menjalankan model anda, yang akan menjadikan model anda tidak berguna.

• Berhati-hati dengan kecenderungan perlombongan data: Memandangkan kami cuba melakukan satu siri pemodelan pada data kami untuk menentukan sama ada ia sesuai, jika tiada sebab tertentu untuknya, pastikan anda menjalankan ujian yang ketat untuk memisahkan corak rawak daripada corak sebenar yang mungkin berlaku. . Sebagai contoh, corak arah aliran menaik dijelaskan dengan baik oleh regresi linear, tetapi ia berkemungkinan merupakan sebahagian kecil daripada berjalan rawak yang lebih besar!

Elakkan overfitting

Perkara ini sangat penting sehingga saya rasa ia perlu disebut semula.

• Overfitting adalah perangkap yang paling berbahaya dalam strategi perdagangan

• Algoritma yang kompleks mungkin berprestasi sangat baik dalam ujian belakang tetapi gagal dengan teruk pada data ghaib baharu Algoritma tidak benar-benar mendedahkan sebarang aliran dalam data dan tidak mempunyai kuasa ramalan sebenar. Ia sangat sesuai dengan data yang dilihatnya

• Pastikan sistem anda semudah mungkin. Jika anda mendapati diri anda memerlukan banyak ciri yang kompleks untuk menerangkan data anda, anda mungkin terlalu menyesuaikan diri

• Bahagikan data anda yang tersedia kepada data latihan dan ujian, dan sentiasa sahkan prestasi pada data sampel sebenar sebelum menggunakan model untuk dagangan langsung.