Cocok untuk model dampak harga | julibloggers.com – Beragampengetahuan

Oleh: Blog oleh Dean Markwick – Julia

Re -Post dari:

Sebagian besar struktur mikro pasar adalah dampak harga dan memahami bagaimana Anda memindahkan pasar setiap kali Anda berdagang. Dalam arti yang paling sederhana, semua transaksi meningkatkan penawaran dan permintaan properti bahkan dalam waktu kecil. Pasar menjawab perubahan ini, kemudian menanggapi umpan balik, lalu menjawab umpan balik itu, dll. Anda punya ide. Ini adalah efek interaksi yang bertingkat antara semua orang di pasar.

Nikmati jenis artikel ini? Setelah itu, Anda harus mendaftar untuk menerima buletin saya.

Dampak harga terjadi baik di level mikro dan makro. Pada tingkat mikro, setiap perdagangan bergerak sedikit berdasarkan kondisi pasar instan yang sering disebut ‘likuiditas’. Pada tingkat makro, transaksi terus menerus dalam arah dengan efek gabungan dan tumpang tindih. Bahkan, Anda tidak dapat memisahkan efek untuk model dampak pasar untuk bekerja untuk skala kecil dan besar.

Posting ini terinspirasi oleh dua sumber:

1. Manual Pemodelan Dampak Harga – Bab 7
2. Likuiditas acak sebagai proksi untuk dampak harga nonlinier

Keduanya termasuk model yang sangat mirip tetapi satu cukup mahal
Buku dan lainnya gratis di SSRN. Penulis yang sama terlibat
Hal yang sama sama.

Dalam hal data, ada dua rute yang bisa Anda turunkan.

1. Anda memiliki data Anda sendiri, pribadi, dapat dieksekusi dan dapat membangun kumpulan data untuk model.
2. Anda menggunakan transaksi yang tersedia dan menyesuaikan model untuk menjelaskan data anonim.

Dalam kasus pertama, Anda akan tahu kapan implementasi dimulai dan berhenti untuk dapat mencatat bagaimana harga berubah. Dalam kasus kedua, data akan terdiri dari banyak transaksi dan kurang jelas ketika beberapa orang tua mulai dan berhenti.

Kami akan mengikuti jalur kedua dan menggunakan data Bitcoin untuk mempertimbangkan model dampak harga yang berbeda.

Karena saya akan selalu menggunakan Julia dengan beberapa paket standar.

using LibPQ
using DataFrames, DataFramesMeta
using Dates
using Plots
using GLM, Statistics, Optim

Data akting harga bitcoin

Kami akan menggunakan set data bitcoin lama saya yang telah saya kumpulkan
Pada tahun 2021. Ini hanya bernilai lebih dari satu hari perdagangan bitcoin dan harga L1
Bahwa saya pergi ke QuestDB. Detail sepenuhnya dalam menggunakan QuestDB untuk membangun database komersial elektronik di Julia.

Pertama, kami terhubung ke database.

conn = LibPQ.Connection("""
             dbname=qdb
             host=127.0.0.1
             password=quest
             port=8812
             user=admin""");

Untuk setiap transaksi yang dinyatakan dalam database, kami juga ingin berpartisipasi dalam tawaran dan pasokan terbaik sebelumnya. Ini adalah tempatnya ASOF Partisipasi sangat membantu. Ini menggabungkan dua tabel dengan tanda waktu dengan menggunakan item tabel ke -2 untuk kedua kalinya sebelum tabel pertama. Kedengarannya lebih rumit dari kenyataan. Singkatnya, dibutuhkan papan komersial dan menambahkan harga dengan menggunakan harga tepat sebelum transaksi.

trades = execute(conn, 
    "WITH
trades AS ( 
   SELECT * FROM coinbase_trades
   ),
prices as (
  select * from coinbase_bbo
)
select * from trades ASOF JOIN prices") |> DataFrame
dropmissing!(trades);
trades = @transform(trades, :mid = 0.5*(:ask .+ :bid))

Untuk meja -meja kecil ini, itu cukup banyak dihitung dan kami
Dapat mengembalikan bingkai data Julia. Selain itu, kami menghitung harga rata -rata untuk setiap baris.

Dari semua model dampak harga, kami merangkum data ini:

1. Grup data dari waktu ke waktu (kedua atau menit, dll.)
2. Hitung nomor bersih, jumlah total uang absolut dan harga terbuka dan tertutup dari ember.
3. Hitung profitabilitas dengan menggunakan harga tertutup.

function aggregate_data(trades, smp)
    tradesAgg = @combine(groupby(@transform(trades, :ts = floor.(:timestamp, smp)), :ts), 
             :q = sum(:size .* :side), 
             :absq = sum(:size), 
             :o = first(:mid), 
             :c = last(:mid));
    tradesAgg[!, "price_return"] .= [NaN; (tradesAgg.c[2:end]./ tradesAgg.c[1:(end-1)]) .- 1]
    tradesAgg[!, "ofi"] .= tradesAgg.q ./ tradesAgg.absq

    tradesAgg
end

Kami akan mendorong data selama 10 detik.

aggData  = aggregate_data(trades, Dates.Second(10))

Seperti biasa, mari kita membagi data ini menjadi set pelatihan dan pengujian.

aggDataTrain = aggData[1:7500, :]
aggDataTest = aggData[7501:end, :];

Ini hanya pembagian waktu yang sederhana.

plot(aggDataTrain.ts, aggDataTrain.c, label = "Train")
plot!(aggDataTest.ts, aggDataTest.c, label = "Test")

Perhitungan fluktuasi dan adv

Semua model membutuhkan perhitungan dan ADV yang mudah menguap. Data saya hanya berjalan lebih dari satu hari, sehingga perlu disesuaikan untuk itu.

Untuk ADV, kami mengambil jumlah dari total volume yang diperdagangkan dan membagi dari waktu ke waktu dikonversi menjadi hari.

deltaT = maximum(trades.timestamp) - minimum(trades.timestamp)
deltaTDays = (deltaT.value * 1e-3)/(24*60*60)
adv = sum(trades.size)/deltaTDays
aggDataTrain[!, "ADV"] .= adv
aggDataTest[!, "ADV"] .= adv;

Untuk fluktuasi, kami mengambil akar kuadrat dari jumlah kuadrat selama 5 menit. Mungkin itu harus setiap tahun jika kita membandingkan parameter pada aset yang berbeda.

min5Agg = aggregate_data(trades, Dates.Minute(5))
volatility = sqrt(sum(min5Agg.price_return[2:end] .* min5Agg.price_return[2:end]))
aggDataTrain[!, "Vol"] .= volatility;
aggDataTest[!, "Vol"] .= volatility;

Adv dan fluktuasi memiliki efek normal pada aset. Jadi, jika kita memiliki banyak koin, kita dapat menggunakan model yang sama bahkan jika satu orang adalah koin perdagangan tinggi seperti BTC atau ETH dibandingkan dengan mata uang yang lebih rendah (istirahat mereka?!). Ini akan memberi kami parameter model yang sebanding untuk mengevaluasi efek dampak.

Karena sampel data kami sangat kecil, kami hanya menghitung 1 volatilitas dan 1 ADV. Bahkan, Anda menghitung fluktuasi/ADV berdasarkan bergulir dan kemudian melakukan kapal/pengujian.

Model Dampak Pasar

Artikel dan buku yang menggambarkan model dampak pasar yang berbeda, semua mengikuti bentuk fungsi yang serupa. Saya telah memilih empat dari mereka untuk menggambarkan model yang cocok untuk model.

• Ketidakseimbangan model dalam urutan (OFI)
• Model Obizhaeva-Wang (OW)
• Model yang diberikan propaganda cekung
• Model formal formal

Untuk semua model, kami akan menentukan bentuk dampak pasar
\ (\ Delta i \) dan gunakan harga kembali pada saat yang sama untuk menemukan
Parameter terbaik dari model.

Gagasan keseluruhannya adalah pengembalian di setiap kotak adalah rasionya
ke volume yang diperdagangkan di kotak itu ditambah nomor
Kontribusi dari episode sebelumnya – peluruhan yang tepat.

Ketidakseimbangan Garis Barang

Ini adalah model paling sederhana karena hanya menggunakan ketidakseimbangan
Ember untuk memprediksi keuntungan. Untuk OFI, kami hanya menggunakan transaksi
Ketidakseimbangan, berat bersih dibagi dengan volume total dalam ember.

\[\Delta I = \lambda \sigma \fracq_t \textADV\]

Karena tidak ada ketergantungan laba sebelumnya, kita dapat menggunakan regresi linier sederhana untuk memperkirakan $ \ lambda $.

aggDataTrain[!, "x_ofi"] = aggDataTrain.Vol .* (aggDataTrain.ofi ./ aggDataTrain.ADV)
aggDataTest[!, "x_ofi"] = aggDataTest.Vol .* (aggDataTest.ofi ./ aggDataTest.ADV)

ofiModel = lm(@formula(price_return ~ x_ofi + 0), aggDataTrain[2:end, :])

Model ini telah mengembalikan nilai \ (\ lambda = 59 \) yang signifikan dan memiliki model \ (r^2 \) adalah 11% dan model RMSE kami adalah 0,0003. Dorong dan mulai dengan baik!

Catatan di sampingnya, saya menulis tentang ketidakseimbangan urutan sebelum ketidakseimbangan garis – sinyal transaksi frekuensi tinggi.

Model Obizhaeva-Wang (OW)

Model OW adalah model dampak pasar dan Anda akan melihat model ini secara teratur pada berbagai mikro -dokumen. Ini menunjukkan ketergantungan linier antara aliran pesanan yang ditandatangani dan dampak harga tetapi sekali lagi dinormalisasi terhadap fluktuasi dan fluktuasi.

\[\Delta I = -\beta I_t + \lambda \sigma \fracq_tADV\]

Sekali lagi, kami membuat variabel \ (x \) dalam bingkai data tertentu untuk model ini tetapi ini akan membutuhkan perhatian khusus agar sesuai.

aggDataTrain[!, "x_ow"] = aggDataTrain.Vol .* (aggDataTrain.q ./ aggDataTrain.ADV);
aggDataTest[!, "x_ow"] = aggDataTest.Vol .* (aggDataTest.q ./ aggDataTest.ADV);

Dari formula dampak pasar, kita dapat melihat bahwa hubungan itu
Rekursif. Dampak pada saat itu \ (t \) tergantung pada dampaknya pada saat itu
\ (T-1 \). Berapa banyak dampak sebelumnya dikendalikan
Oleh \ (\ beta \) dan dalam artikel mereka memperbaikinya di \ (\ frac \ log 2 \ beta
= 60 \ Document Minutes \). Ini berarti bahwa kita harus mencocokkan model seperti:

1. Perhitungan \ (i \) Buat perkiraan \ (\ lambda \)
2. Sesuaikan pengembalian harga dengan efek ini
3. Pada awalnya, harga pengembalian dana dibandingkan dengan variabel \ (x \).
4. Ulangi dengan perkiraan baru \ (\ lambda \) sampai konvergensi.

Ini adalah optimalisasi angka 1 sederhana di mana kami meminimalkan RMSE.

function calcImpact(x, beta, lambda)
    impact = zeros(length(x))
    impact[1] = x[1]
    for i in 2:length(impact)
        impact[i] = (1-beta)*impact[i-1] + lambda*x[i]
    end
    impact
end
	
function fitLambda(x, y, beta, lambda)
    I = calcImpact(x, beta, lambda)
    y2 = y .+ (beta .* I)
    model = lm(reshape(x, (length(x), 1))[2:end, :], y2[2:end])
    model
end

rmse(x) = sqrt(mean(residuals(x) .^2))

Kami mulai dengan \ (\ lambda = 1 \) dan biarkan orang mengoptimalkan pekerjaan.

res = optimize(x -> rmse(fitLambda(aggDataTrain[!, "x_ow"], aggDataTrain[!, "price_return"], 0.01, x[1])), [1.0])

Itu konvergen! Kami menarik nilai yang berbeda dari fungsi target dan menunjukkan bahwa proses ini dapat ditemukan dengan minimum.

lambdaRes = rmse.(fitLambda.([aggDataTrain[!, "x_ow"]], [aggDataTrain[!, "price_return"]], 0.01, 0:1:20))
plot(0:1:20, lambdaRes, label = :none, xlabel = L"\lambda", ylabel = "RMSE", title = "OW Model")
vline!(Optim.minimizer(res), label = "Optimised Value")

Setelah itu, kami menggambar model dan perkiraan yang paling tepat (r^2 \).
Kami memiliki hubungan cembung yang indah selalu merupakan pertanda baik.

owModel = fitLambda(aggDataTrain[!, "x_ow"], aggDataTrain[!, "price_return"], 0.01, first(Optim.minimizer(res)))

Di mana \ (r^2 = 11 \%\). Oleh karena itu, hampir seperti model Ofi. Untuk RMSE di luar sampel, kami mendapatkan 0,0006.

Model propaganda cekung

Model ini mematuhi keyakinan bahwa dampak pasar adalah hukum kekuasaan dan
Kekuatan itu hampir 0,5. Gunakan akar kuadrat dari jumlah total
Transaksi dan arah bersih memberi kita variabel \ (x \).

\[\Delta I = -\beta I_t + \lambda \sigma \textsign (q_t) \sqrt
\frac q_t \textADV\]

aggDataTrain[!, "x_cp"] = aggDataTrain.Vol .* sign.(aggDataTrain.q) .* sqrt.((aggDataTrain.absq ./ aggDataTrain.ADV));
aggDataTest[!, "x_cp"] = aggDataTest.Vol .* sign.(aggDataTest.q) .* sqrt.((aggDataTest.absq ./ aggDataTest.ADV));

Sekali lagi, kami dioptimalkan dengan metode yang sama seperti di atas.

res = optimize(x -> rmse(fitLambda(aggDataTrain[!, "x_cp"], aggDataTrain[!, "price_return"], 0.01, x[1])), [1.0])
lambdaRes = rmse.(fitLambda.([aggDataTrain[!, "x_cp"]], [aggDataTrain[!, "price_return"]], 0.01, 0:0.1:1))
plot(0:0.1:1, lambdaRes, label = :none, xlabel = L"\lambda", ylabel = "RMSE", title = "Concave Propagator Model")
vline!(Optim.minimizer(res), label = "Optimised Value")

Sukses lainnya! Kali ini \ (r^2 \) adalah 17% sehingga peningkatan pada dua model lainnya. Tidak memiliki model RMSE 0,0008.

Pengurangan Model Formal

Artikel menunjukkan bahwa ketika jumlah transaksi dan waktu meningkat
Meningkatkan fungsi mempengaruhi konvergensi pasar menjadi bentuk linier
Ketergantungan pada fluktuasi acak dari garis pesanan.

\[\Delta I = -\beta I_t + \lambda \sigma \fracq_t\sqrtv_t \cdot \textADV\]

Untuk ini, kita perlu menghitung parameter likuiditas acak, \ (v_t \), hanya pergerakan rata -rata bobot pasar absolut.

function calcLiquidity(absq, beta)
    v = zeros(length(absq))
    v[1] = absq[1]
    for i in 2:length(v)
        v[i] = (1-beta)*v[i-1] + absq[i]
    end
    return v
end

v = calcLiquidity(aggDataTrain[!, "absq"], 0.01)
vTest = calcLiquidity(aggDataTest[!, "absq"], 0.01)

plot(aggDataTrain.ts, v, label = "Stochastic Liquidity")
plot!(aggDataTest.ts, vTest, label = "Test Set")

Tambahkan ini ke bingkai data kami dan hitung variabel (x \) sangat sederhana.

aggDataTrain[!, "v"] = v
aggDataTest[!, "v"] = vTest

aggDataTrain[!, "x_rf"] = aggDataTrain.Vol .* aggDataTrain.q ./ sqrt.((aggDataTrain.ADV .* aggDataTrain[!, "v"]));
aggDataTest[!, "x_rf"] = aggDataTest.Vol .* aggDataTest.q ./
sqrt.((aggDataTest.ADV .* aggDataTest[!, "v"]));

Dan lagi, kami mengulangi proses yang sesuai.

lambdaVals = 0:0.1:5
res = optimize(x -> rmse(fitLambda(aggDataTrain[!, "x_rf"], aggDataTrain[!, "price_return"], 0.01, x[1])), [1.0])
lambdaRes = rmse.(fitLambda.([aggDataTrain[!, "x_rf"]], [aggDataTrain[!, "price_return"]], 0.01, lambdaVals))
plot(lambdaVals, lambdaRes, label = :none, xlabel = L"\lambda", ylabel = "RMSE", title = "Reduced Form Model")
vline!(Optim.minimizer(res), label = "Optimised Value")

Model ini memberikan satu \ (r^2 = 10%\) dan rmse selain sampel adalah 0,0009.

Dengan keempat model yang dilengkapi, kita sekarang dapat mempertimbangkan perbedaan statistik dan bagaimana keadaan pengembangan dampak sepanjang hari.

Oleh karena itu, model transmisi cekung memiliki level tertinggi \ (r^2 \) diikuti oleh bentuk bentuk penurunan. Model OFI dan OW sedikit lebih rendah (R^2 \).
Tapi, melihat nilai RMSE dari efisiensi eksternal
Jelas bahwa model Ofi tampaknya menjadi yang terbaik.

Ketika kita menarik hasil hasil dari 4 model yang sering kita lihat
Mereka setuju, hanya dengan model Ofi adalah yang paling berbeda. Ini
Perbedaannya berasal dari kurangnya waktu yang membusuk dari episode sebelumnya.

Kesimpulan

Secara umum, saya tidak berpikir hasil ini adalah informasi, kumpulan data saya sangat kecil
Dibandingkan dengan kertas (1 hari dibandingkan dengan bulan). Sebaliknya, gunakan ini sebagai lebih dari
Panduan tentang cara menyesuaikan model -model ini. Kami bahkan tidak menemukan
Mengoptimalkan nilai peluruhan waktu (\ (\ beta \)) untuk bitcoin dapat dimungkinkan
Perbedaan yang signifikan dari set data kertas pada stok. Karena itu
Ada banyak hal yang harus dilakukan!

Terkait