Celup dalam siklus | julibloggers.com – Beragampengetahuan

Oleh: Blog oleh Dean Markwick – Julia

Re -Post dari:

Ditelam dalam siklus (atau enkripsi) adalah konversi mendasar untuk variabel nunmeric siklik. Temukan cara kerjanya.

Saat ini saya menghadiri serangkaian kuliah keuangan yang mendalam (diajarkan oleh Stefan Zohan untuk mempersiapkan buku baru saya). Latihan tanah air mengambil rangkaian waktu dasar dan menerapkan berbagai teknik pembelajaran yang mendalam. Dalam proses melakukan pekerjaan rumah ini, saya menemukan siklus yang dicelupkan dan cara mereka digunakan untuk mengubah transformasi menjadi siklus menjadi sesuatu yang dapat dipahami oleh model.

Pertimbangkan artikel blog ini saya membaca buku catatan kaggle ini: Enkripsi fitur siklus untuk belajar dalam, mengubahnya menjadi Julia dan menggunakan beberapa contoh untuk meyakinkan pekerjaan untuk mencelupkan dalam siklus dan sangat berguna.

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

Variabel siklus sangat cocok di bidang keuangan. Misalnya, minggu dalam seminggu Anda dapat menggunakan koefisien (label langsung) atau angka (MON = 1, TUE = 2, dll.) Dalam model. Menggunakan satu elemen, model Anda saat ini terdiri dari 5 parameter tambahan. Jika Anda menggunakan nomor tersebut, Anda harus menentukan bentuk hubungan (linier atau menggunakan gram). Setiap orang mengalami pasang surut, tetapi ada juga bagian dari kurangnya informasi: Hari -hari minggu ini membentuk siklus di mana 1 berikut dari 5. Bagaimana kita dapat mengubah ini menjadi sesuatu yang akan dipahami oleh model?

Seperti namanya, mencelupkan dalam siklus mengarah ke siklus dan fungsi alami adalah dosa dan cos trigonometri. Kami mengambil satu variabel jalan dan mengubahnya menjadi dua arah

\[\beginalign*
x & = \sin \left( \frac2 \pi t\textmax

Jika kami menerapkan konversi ini ke hari minggu kami, kami akan pergi dari \ (t \ in [0, 4]\) Pergi ke lingkaran di \ (x \) dan \ (y \).

Saya teringat akan koordinat ekstrem dan sekarang kita dapat melihat bahwa yang kedua adalah jarak yang sama dari Jumat ketiga.
Yang penting, variabel baru ini unik untuk -1 dan 1 selalu berguna saat membangun model.
Semua masuk, ini terlihat seperti transformasi yang masuk akal, sekarang untuk melihat apakah ia memiliki perbedaan luar biasa dalam kinerja pemodelan.

Celup dalam siklus aktual – volume harian

Silakan memodelkan volume perdagangan harian saham. Perasaan itu masuk akal bahwa hari dalam seminggu (Senin-enam), bulan bulan itu (1-31) dan bulan (1-12) akan mempengaruhi uang yang diperdagangkan. Bulan -bulan musim panas mungkin lebih tenang, pada akhir bulan mungkin lebih sibuk (kembali ke akhir bulan) dan keenam bisa lebih tenang. Ketiga variabel waktu ini adalah siklus sehingga mencelupkan siklus akan membantu.

Kami memiliki 3 opsi terpisah:

1. Semuanya seperti angka (3 parameter gratis)
2. Hari minggu dan bulan sebagai faktor (5 + 12 + 1 parameter gratis)
3. Celup dalam tiga variabel (3 × 2 = 6 parameter)

Oleh karena itu, keseimbangan antara jumlah parameter dan fleksibilitas model.

Kami akan menggunakan model linier sederhana, bukan aneh.

Karena kita akan selalu berada di Julia.

using Dates, AlpacaMarkets, Plots, StatsBase, GLM
using DataFramesMeta, CategoricalArrays, ShiftedArrays

Untuk mengunduh data, kami akan menggunakan API Alpacamarkets saya dan mendapatkan lebih banyak data.

aaplRaw, npt = AlpacaMarkets.stock_bars("AAPL", "1Day"; startTime=Date("2000-01-01"), endTime = today() - Day(2), adjustment = "all", limit = 10000)

Beberapa pembersihan dan format dasar.

aapl = aaplRaw[:, [:t, :v]]
aapl[!, "t"] = DateTime.(chop.(aapl[!, "t"]))

Julia memudahkan untuk menambahkan variabel faktor dan versi digital. Ketika nilai -nilai numerik dimulai pada level 1, kami mengurangi satu sehingga mereka mulai dari 0.

aapl[:, :DayName] = CategoricalArray(dayname.(aapl.t))
aapl[:, :MonthName] = CategoricalArray(monthname.(aapl.t))

aapl[:, :DayOfMonth] = dayofmonth.(aapl.t) .- 1
aapl[:, :DayOfWeek] = dayofweek.(aapl.t) .- 1
aapl[:, :MonthOfYear] = month.(aapl.t) .- 1;

Kami menormalkan massa menjadi jutaan saham dan membuat perbedaan.

aapl = aaplRaw[:, [:t, :v]]
aapl[:, :vNorm] = aapl[:, :v] .* 1e-6;
aapl[:, :delta_vNorm] = aapl[:, :vNorm] .- ShiftedArrays.lag(aapl[:, :vNorm]);

Adalah massa yang biasa (vNorm) Jangan diam, kita bisa melihat tren yang jelas bahwa perubahan, lebih baik daripada pemodelan perbedaan berat per hari.

plot(plot(aapl.t, aapl.vNorm, title = "Volume", label = :none), 
     plot(aapl.t, aapl.delta_vNorm, title = "Volume Difference", label = :none), layout=(2,1))

Untuk menerapkan pengkodean dalam siklus, kita perlu mengambil kolom dan mengubahnya menjadi dua.

function cyclical_encode(df, col, max)
    df[:, Symbol("$(col)_sin")] = sin.(2 .* pi .* df[:, Symbol(col)]/max)
    df[:, Symbol("$(col)_cos")] = cos.(2 .* pi .* df[:, Symbol(col)]/max)
    df
end

for col in ["DayOfWeek", "DayOfMonth", "MonthOfYear"]
    aapl = cyclical_encode(aapl, col, maximum(aapl[:, col]))
end

Jika Anda belum melihatnya dulu $ Seperti python f-string dan memungkinkan Anda menggunakan variabel rantai.

Kami melakukan tes kereta/kereta yang normal.

aaplTrain = aapl[1:2000,:]
aaplTest = aapl[2001:end,:];

Sekarang untuk membangun tiga model.

Model angka langsung dalam angka.

numModel = lm(@formula(delta_vNorm ~ DayOfWeek + MonthOfYear + DayOfMonth), aaplTrain)

Model faktor mewakili hari dalam seminggu dan hari dalam sebulan sebagai kategori sehingga masing -masing jenis memiliki parameter terpisah.

factorModel = lm(@formula(delta_vNorm ~ DayName + MonthName + DayOfMonth + 0), aaplTrain)

Model tertanam membuat konversi sinusue/cos dari masing -masing variabel.

embeddingModel = lm(@formula(delta_vNorm ~ DayOfWeek_sin + DayOfWeek_cos + DayOfMonth_sin + DayOfMonth_cos + MonthOfYear_sin + MonthOfYear_cos), aaplTrain);

Untuk mengevaluasi seberapa baik model melakukannya, kami melihat RMSE (dalam sampel dan keluar dari sampel), AIC (dalam sampel) dan \ (r^2 \) (dalam sampel dan di luar sampel).

Menariknya, model tertanam melakukan yang terburuk dalam model dan keluar dari model.

Ketika kita menarik efek hari ini, mudah untuk melihat apa yang telah kita pelajari.

params = Dict(zip(coefnames(embedingExample), coef(embedingExample)))

x = 0:0.1:4
ySin = params["DayOfWeek_sin"] * sin.(2 .* pi .* x ./ maximum(x))
yCos = params["DayOfWeek_cos"] * cos.(2 .* pi .* x ./ maximum(x))


p = plot(x, ySin, label = "Sin")
plot!(p, x, yCos, label = "Cos")
plot!(p, x, yCos .+ ySin, label = "Combined")

Ini menunjukkan bahwa perubahan volume yang lebih rendah adalah pada hari Selasa dan mengubah volume lebih tinggi pada hari Kamis.

Berdasarkan kinerja model, ini bukan program yang bagus untuk konversi tertanam. Mari kita beralih ke contoh lain di mana sifat siklus bisa lebih jelas.

Celup dalam siklus yang sebenarnya – volume hari ini

Contoh lain adalah aliran transaksi hari itu. Dalam hal ini, sekarang variabel yang akan kita selip dalam siklus. Untuk ini, kami menggunakan transaksi BTCUSD dari alpacamarkets.jl dan mensintesisnya di siang hari.

btcRaw, token = AlpacaMarkets.crypto_bars("BTC/USD", "1H"; startTime=Date("2025-01-01"), limit = 10000)

res = [btcRaw]
while !(isnothing(token) || isempty(token))
    println(token)
    newtrades, token = AlpacaMarkets.crypto_bars("BTC/USD", "1H"; startTime=Date("2025-01-01"), limit = 10000, page_token = token)
    println((minimum(newtrades.t), maximum(newtrades.t)))
    append!(res, [newtrades])
    sleep(AlpacaMarkets.SLEEP_TIME[])
end
res = vcat(res...);

Sidenote, saya perlu menutupi fungsi ini dalam paket.

Kami mendapatkan data mentah ke keadaan yang sesuai.

btc = res[:, [:t, :v]]
btc[!, "t"] = DateTime.(chop.(btc[!, "t"]));

btc = @transform(btc, :Date = Date.(:t), :Time = Time.(:t), :DayOfWeek = dayofweek.(:t), :Hour = hour.(:t))
trainDates = unique(btc.Date)[1:140]
testDates = setdiff(unique(btc.Date), trainDates)

trainDataRaw = btc[findall(in(trainDates), btc.Date), :];
testDataRaw = btc[findall(in(testDates), btc.Date), :];

trainData = @combine(groupby(trainDataRaw, [:Hour]), :v = sum(:v))
trainData = @transform(trainData, :total_v = sum(:v), :frac = :v./sum(:v))

testData = @combine(groupby(testDataRaw, [:Hour]), :v = sum(:v))
testData = @transform(testData, :total_v = sum(:v), :frac = :v./sum(:v))

sort!(trainData, :Hour);
sort!(testData, :Hour);

Sekali lagi, dengan menggunakan model linier, kami cocok untuk variabel yang dicelupkan ke dalam rasio volume yang diperdagangkan setiap jam.

embedModelIntra = lm(@formula(frac ~ Hour_sin + Hour_cos), trainData)

Saat membandingkan hasilnya, kami saat ini hanya meninjau catatan harian transaksi untuk kapal dan kit uji ditutupi dengan model.

Model itu sangat baik untuk memilih puncak di sore hari tetapi melewatkan puncaknya pagi -pagi sekali. RMSE dari model ini adalah 0,029 dibandingkan dengan 0,026 dari penggunaan langsung fraksi pelatihan, jadi sekali lagi, model terenkripsi lebih buruk.
Ini adalah faktor terbatas untuk tertanam ini, kami memiliki frekuensi sinus/cos padahal sebenarnya masalah ini membutuhkan lebih banyak kebebasan, yaitu, banyak komponen

\[\sum _i c^1_i \sin \left(\frac2 \pi \omega _i x\max (x)\right) + c^2_i \cos \left(\frac2 \pi \omega _i x\max (x)\right).\]

Ini sekarang gram dengan trigomonik spline sehingga kita dapat melihat enkripsi dalam siklus sebagai 1-pspline.

Kesimpulan

Ini adalah transisi variabel yang menarik seperti waktu dan memberi Anda rute untuk menghaluskan kepala dan akhir siklus.

Dalam model mainan ini, tertanam tidak meningkatkan kinerja tetapi mungkin lebih cocok dalam arsitektur pembelajaran yang mendalam, di mana ada lebih banyak parameter dan lebih banyak interaksi. Dalam semua model di atas, ada lebih banyak platform yang harus dilakukan sebelum kita mulai meningkatkan kinerja dari variabel waktu.

Terkait