Pendekatan Pembelajaran Mendalam Ini Boleh Membantu Menggandakan Keuntungan Anda dalam Pelaburan Kripto

Laporan ini membentangkan pendekatan baru untuk perdagangan mata wang kripto menggunakan ejen Pembelajaran Pengukuhan Dalam (DRL) berasaskan Transformer. Sistem ini memanfaatkan seni bina moden yang diilhamkan oleh NLP (Transformers), DQN Berganda (DDQN), Rangkaian Bising dan Penyesuaian Peringkat Rendah (LoRA) untuk Latihan Masa Ujian (TTT). Dengan menggabungkan komponen ini, ejen menunjukkan kebolehsuaian yang lebih baik, pembentukan dasar yang stabil dan keuntungan yang dipertingkatkan dengan ketara pada data sejarah BTC/USDT. Walaupun awal, keputusan ini mencadangkan kaedah boleh diperluaskan kepada set data yang lebih kompleks (cth, peringkat buku pesanan) dan berbilang kelas aset, menyediakan asas berskala untuk strategi perdagangan gred institusi.

Mengapa Transformers, Mengapa DRL, dan Mengapa Anda Perlu Peduli

• Transformers: Dilahirkan di dunia NLP, mereka cemerlang dalam mentafsir urutan. Pasaran hanyalah teka-teki siri masa. Transformers membacanya seperti cerita, menjangkakan kelainan plot (pergerakan harga) jauh sebelum kuantiti purata anda berkelip.

• DQN Berganda (DDQN): Tiada lagi anggaran nilai Q sebelah pihak. DDQN mengurangkan anggaran terlalu tinggi yang terkenal itu, memberikan dasar perdagangan anda kredibiliti yang diperlukan untuk mengendalikan perangkap lembu jantan yang rumit dan serbuan beruang.

• Noisy Nets menggalakkan penerokaan dengan menambahkan hingar berparameter terus pada pemberat rangkaian.

• LoRA membenarkan latihan masa ujian (TTT) dengan overhed minimum, membolehkan model menyesuaikan dengan pantas kepada keadaan pasaran baharu tanpa kitaran latihan semula penuh.

• Latihan Masa Ujian (TTT): Pasaran berubah, berkembang, mengejutkan. TTT membolehkan model ini menyesuaikan diri dengan pantas, melaraskan strategi pertengahan penerbangan seolah-olah ia membaca tajuk berita esok hari ini.

  
  

Kod dihidupkan https://github.com/pmatheus/themoneyhack Klonkannya, jalankannya, rungkaikannya. Anda mungkin menyukainya.

Dalam rangka kerja ini mewujudkan sistem di mana ejen pembelajaran berinteraksi dengan persekitaran dagangan simulasi, dipandu oleh seni bina berasaskan Transformer moden. Pada terasnya, sistem ini berusaha untuk menambah baik keputusan perdagangan dari semasa ke semasa, memperhalusi strateginya melalui pembelajaran pengukuhan dan menyesuaikan diri dengan cepat kepada keadaan pasaran baharu.

Pertimbangkan dahulu model Transformer . Secara tradisinya, Transformers telah merevolusikan bidang seperti pemprosesan bahasa semula jadi dengan mentafsir urutan perkataan atau token. Di sini, prinsip yang sama digunakan pada data harga siri masa. Daripada perkataan, model itu menggunakan ciri pasaran sejarah — harga, volum, penunjuk teknikal — dan cuba mengekstrak kebergantungan temporal yang bermakna. Kelas TransformerNetwork , yang ditakrifkan dalam kod, menunjukkan pendekatan ini. Perhatikan cara pembina menayangkan ciri input mentah ke dalam perwakilan dimensi yang lebih tinggi dan kemudian menghantarnya melalui berbilang lapisan pengekod Transformer:

 class TransformerNetwork(nn.Module): def __init__(self, state_dim, output_dim, lookback, nhead=8, num_layers=4, model_dim=512, lora_r=8, lora_alpha=1.0, lora_active=False, sigma_init=hyperparameters['SIGMA_INIT']): super(TransformerNetwork, self).__init__() self.model_dim = model_dim self.lookback = lookback self.lora_active = lora_active self.input_fc = NoisyLoRALinear(state_dim, self.model_dim, r=lora_r, alpha=lora_alpha, lora_active=lora_active, sigma_init=sigma_init) encoder_layer = TransformerEncoderLayerRelative(d_model=model_dim, nhead=nhead, lora_r=lora_r, alpha=lora_alpha, lora_active=lora_active, sigma_init=sigma_init) self.transformer = TransformerEncoderRelative(encoder_layer, num_layers=num_layers) self.output_fc = NoisyLoRALinear(self.model_dim, output_dim, r=lora_r, alpha=lora_alpha, lora_active=lora_active, sigma_init=sigma_init) self._initialize_weights() def forward(self, x): x = self.input_fc(x) x = x.permute(1, 0, 2) x = self.transformer(x) x = x.mean(dim=0) output = self.output_fc(x) return output

Coretan ini menyerlahkan aliran: keadaan mentah masuk melalui input_fc (lapisan linear dipertingkatkan dengan bunyi bising dan potensi penyesuaian peringkat rendah), melalui modul TransformerEncoderLayerRelative bertindan yang menangkap maklumat kedudukan temporal dan relatif, dan akhirnya diringkaskan menjadi tindakan oleh output_fc . Reka bentuk ini membolehkan model menimbang peristiwa pada titik masa yang berbeza, mengenal pasti corak berulang atau anomali yang mungkin mencadangkan peluang yang menguntungkan.

Jika model Transformer menyediakan "mata" dan "telinga" ejen, kelas TradingEnv mensimulasikan dunia yang berinteraksi dengannya. Kelas persekitaran ini, bernama TradingEnv , mentakrifkan maksud mengambil tindakan—seperti membuka atau menutup kedudukan—dan cara ganjaran diberikan. Di dalam persekitaran, ejen memerhati perubahan harga, penunjuk teknikal, dan pegangan semasanya. Petikan berikut menunjukkan cara persekitaran membina keadaan daripada data pasaran dan kedudukan ejen:

 def get_state(self): states = [] current_timestamp = self.tech_array.iloc[self.time]['timestamp'] weight_long = float(self.stocks_long * self.current_price / self.total_asset) if self.total_asset > 0 else 0.0 weight_short = float(self.stocks_short * self.current_price / self.total_asset) if self.total_asset > 0 else 0.0 for _ in range(self.lookback): row = self.precomputed_tech.get(current_timestamp) if row is not None: features = row.drop(['timestamp', 'date']).astype(np.float32).values state_row = np.concatenate(([weight_long, weight_short], features)).astype(np.float32) else: state_row = np.zeros(self.state_dim, dtype=np.float32) states.append(state_row) current_timestamp -= self.get_timeframe_in_seconds() states = states[::-1] # ensure chronological order state = torch.tensor(np.array(states, dtype=np.float32), dtype=torch.float32).unsqueeze(0).to(self.device) return state

Di sini, persekitaran membentuk pembenaman keadaan kaya yang merangkumi maklumat kedudukan dan tetingkap ciri sejarah. Dengan menyediakan perspektif berjendela ini, Transformer boleh memodelkan corak temporal. Setiap langkah dalam persekitaran mengemas kini kedudukan, mengira untung atau rugi, dan mengembalikan keadaan dan ganjaran baharu untuk ejen. Pertukaran kitaran ini memupuk gelung maklum balas, membenarkan ejen mempelajari perkara yang berkesan dan perkara yang tidak.

Enjin pembuat keputusan berada dalam kelas DiscreteDDQNAgent , yang melaksanakan pendekatan DQN Berganda. DQN Berganda membantu menangani bias anggaran berlebihan yang terkenal dalam pembelajaran-Q dengan menggunakan rangkaian berasingan untuk pemilihan tindakan dan anggaran nilai. Ejen mengekalkan contoh online_net dan target_net bagi model berasaskan Transformer dan menggunakan penimbal ulang tayang untuk mencuba pengalaman lalu. Semasa latihan, ia mengemas kini parameternya dengan meminimumkan perbezaan antara nilai-Q yang diramalkan dan nilai-Q sasaran yang diperoleh daripada rangkaian sasaran:

 def update(self): self.online_net.train() if len(self.memory) < self.batch_size: return None states, actions, rewards, next_states, dones = self.memory.sample(self.batch_size) q_values = self.online_net(states).gather(1, actions.unsqueeze(1)).squeeze(1) with torch.no_grad(): next_q_values = self.target_net(next_states).gather(1, self.online_net(next_states).argmax(dim=1).unsqueeze(1)).squeeze(1) target_q_values = rewards + self.gamma * next_q_values * (1 - dones) ddqn_loss = self.loss_fn(q_values, target_q_values.detach()) self.optimizer.zero_grad() ddqn_loss.backward() torch.nn.utils.clip_grad_norm_(self.online_net.parameters(), max_norm=1.0) self.optimizer.step() self.soft_update() return ddqn_loss.item()

Kod ini mendedahkan rutin latihan yang berhati-hati: ejen berulang kali mengambil sampel kumpulan mini peralihan yang lalu, mengira kerugian DDQN dan mengemas kini online_net . Secara berkala, ia melakukan kemas kini lembut target_net untuk menjejaki penambahbaikan secara perlahan. Dengan menggabungkan keupayaan pengecaman corak Transformer dengan dinamik pembelajaran stabil Double DQN, ejen secara beransur-ansur menjadi lebih mahir dalam memilih perdagangan yang menguntungkan.

Keadaan pasaran, bagaimanapun, tidak pernah berhenti. Peralihan dalam turun naik, perubahan kawal selia atau peristiwa mudah tunai secara tiba-tiba boleh menjadikan pemenang semalam menjadi rugi hari ini. Untuk mengendalikan anjakan tersebut, konsep Latihan Masa Ujian (TTT) diperkenalkan. Daripada bergantung semata-mata pada kemas kini yang dilakukan selepas mengumpul sejumlah besar pengalaman, TTT membenarkan bahagian tertentu rangkaian menyesuaikan diri secara dinamik apabila keadaan baharu tiba, walaupun semasa inferens. Penyesuaian pantas ini membolehkan ejen menentukur semula strateginya dengan cepat, menyesuaikan diri dengan keadaan yang tidak dijangka tanpa menunggu kitaran latihan semula penuh.

Dalam kod ini, TTT difasilitasi oleh parameter latihan secara terpilih semasa inferens dan memfokuskan pada subset kecil parameter. Ejen boleh, sebagai contoh, mengubah suai sebahagian daripada rangkaiannya untuk menyerap corak baharu dengan cepat. Kaedah activate_lora() dan deactivate_lora() (tidak ditunjukkan sekarang kerana kami menumpukan pada Transformer, Env, DDQN dan logik TTT) togol hidup dan matikan parameter penyesuaian ini. Walaupun coretan kod itu secara khusus merujuk kepada LoRA (penyesuaian peringkat rendah), falsafah yang sama digunakan: TTT bermaksud membolehkan bahagian tertentu model belajar pada masa ujian. Apabila mod TTT aktif, pengoptimum khusus mengemas kini parameter ini di tempat kejadian:

 def update_auxiliary(self, state): self.autoencoder.train() self.online_net.train() # Ensure noise and adaptive params are active masked_state, target_state = self.mask_input(state) masked_state_flat = masked_state.view(state.size(0), -1) target_state_flat = target_state.view(state.size(0), -1) reconstructed = self.autoencoder(masked_state_flat) aux_loss = F.mse_loss(reconstructed, target_state_flat) self.autoencoder_optimizer.zero_grad() self.ttt_optimizer.zero_grad() aux_loss.backward() torch.nn.utils.clip_grad_norm_(self.autoencoder.parameters(), max_norm=1.0) torch.nn.utils.clip_grad_norm_(filter(lambda p: p.requires_grad, self.online_net.parameters()), max_norm=1.0) self.autoencoder_optimizer.step() self.ttt_optimizer.step() self.autoencoder.eval() return aux_loss.item()

Rutin kemas kini tambahan ini, yang dicetuskan pada masa ujian, menunjukkan kebolehsuaian sistem. Ejen itu sengaja menyembunyikan beberapa ciri input dan cuba membina semulanya, menambah baik perwakilan dalaman rejim pasaran semasa. Dengan berbuat demikian, ia boleh bertindak balas dengan cepat kepada peralihan data dan mengekalkan strategi yang menguntungkan dalam landskap yang sentiasa berubah.

Ringkasnya, interaksi antara komponen ini mewujudkan mesin dagangan yang teguh dan fleksibel. Model berasaskan Transformer menyediakan pemahaman yang kaya dan sensitif konteks tentang isyarat pasaran. TradingEnv mensimulasikan keadaan realistik dan gelung maklum balas. Rangka kerja Double DQN memastikan pembelajaran nilai tindakan yang stabil, memperhalusi keputusan perdagangan secara beransur-ansur. Akhir sekali, TTT membenarkan ejen kekal tangkas, melaraskan parameter dalamannya apabila berhadapan dengan corak baharu. Bersama-sama, elemen ini menetapkan peringkat untuk sistem yang canggih dalam pengecaman corak dan berdaya tahan dalam menghadapi ketidaktentuan pasaran, menawarkan visi yang menarik untuk strategi dagangan generasi akan datang.

Apakah Hasilnya?

• Penggandaan Modal Berganda: Pada data sejarah BTC/USDT harian, ejen ini bukan sahaja memperoleh keuntungan kecil — ia menggandakan modal permulaannya beberapa kali. Jika itu bukan panggilan bangun, saya tidak tahu apa itu.
• Stabil, Kerugian Rendah & Polisi Jelas: Log TensorBoard menunjukkan kerugian yang terlicin ke tahap yang sangat rendah, dan pengagihan nilai Q untuk tindakan perdagangan yang berbeza membentuk corak yang berbeza dan bermakna. Terjemahan: Model ini bukan sekadar meneka — ia mempelajari pendekatan yang menguntungkan secara konsisten.

Potensi Peringkat Seterusnya

• Data Tahap Buku Pesanan: Sekarang, kami menari dengan OHLCV. Beri saya kedalaman buku pesanan, dan saya akan berikan anda alfa yang boleh dikatakan nuklear. Kumpulan kecairan dalaman anda layak mendapat model yang boleh menjangka dan mengeksploitasi pergerakan harga peringkat mikrosaat.
• Integrasi Berbilang Jangka Masa: Scalping intrahari atau dagangan kedudukan jangka panjang? Dengan transformer, kami boleh menggabungkan berbilang butiran — carta 1 minit dengan aliran harian — mendedahkan isyarat yang tidak boleh ditawarkan oleh satu rangka masa.
• Kekukuhan kepada Anjakan Rejim: Pasaran memecahkan corak sepanjang masa. Dengan LoRA dan TTT, ejen ini boleh menyesuaikan diri dengan lebih pantas daripada pelatih berkafein yang bekerja sepanjang malam. Kemeruapan semalaman meningkat? Pengumuman Fed? Model itu berkata, "Bawakannya."

Komen, Libatkan, Tawarkan Tawaran 🤯

Jangan biarkan ini menjadi rasa ingin tahu yang sekejap. Komen, kritik, tanya soalan. Jika anda tertanya-tanya cara memutar strategi anda, atau cara menyepadukan penyelesaian DRL yang fleksibel ke dalam timbunan sedia ada anda tinggalkan komen.