Makakatulong ang Deep-learning Approach na ito na Doblehin ang Iyong Mga Nakuha sa Crypto Investments

Ang ulat na ito ay nagpapakita ng isang bagong diskarte sa cryptocurrency trading gamit ang isang Transformer-based Deep Reinforcement Learning (DRL) agent. Ang system ay gumagamit ng mga modernong NLP-inspired na arkitektura (Transformers), Double DQN (DDQN), Noisy Networks, at Low-Rank Adaptation (LoRA) para sa Test-Time Training (TTT). Sa pamamagitan ng pagsasama-sama ng mga bahaging ito, ipinapakita ng ahente ang pinahusay na kakayahang umangkop, matatag na pagbuo ng patakaran, at makabuluhang pinahusay na kakayahang kumita sa makasaysayang data ng BTC/USDT. Bagama't paunang, ang mga resultang ito ay nagmumungkahi na ang pamamaraan ay maaaring palawigin sa mas kumplikadong mga dataset (hal., orderbook-level) at maramihang mga klase ng asset, na nagbibigay ng nasusukat na pundasyon para sa mga diskarte sa pangangalakal na antas ng institusyonal.

Bakit Mga Transformer, Bakit DRL, at Bakit Dapat Mong Pangalagaan

• Mga Transformer: Ipinanganak sa mundo ng NLP, mahusay sila sa pag-decipher ng mga sequence. Ang mga merkado ay simpleng mga puzzle ng serye ng oras. Binabasa sila ng mga transformer na parang mga kuwento, na naghihintay ng mga plot twist (paglipat ng presyo) bago magpikit ang iyong average na dami.

• Double DQN (DDQN): Wala nang one-sided na Q-value na pagtatantya. Binabawasan ng DDQN ang mga kilalang-kilalang labis na pagtatantya, na nagbibigay sa iyong patakaran sa pangangalakal ng kredibilidad na kailangan nito upang mahawakan ang mga nakakalito na bull traps at bear raid.

• Hinihikayat ng Noisy Nets ang paggalugad sa pamamagitan ng direktang pagdaragdag ng parameterized na ingay sa mga timbang ng network.

• Pinapayagan ng LoRA ang test-time training (TTT) na may kaunting overhead, na nagbibigay-daan sa modelo na mabilis na umangkop sa mga bagong kundisyon ng merkado nang walang buong cycle ng muling pagsasanay.

• Pagsasanay sa Oras ng Pagsubok (TTT): Ang mga merkado ay nagbabago, nagbabago, nakakagulat. Hinahayaan ng TTT ang modelong ito na mabilis na umangkop, na nagsasaayos ng mga diskarte sa kalagitnaan ng paglipad na parang binabasa nito ang mga headline bukas ngayon.

  
  

Naka-on ang code https://github.com/pmatheus/themoneyhack I-clone ito, patakbuhin ito, i-dissect ito. Baka magustuhan mo.

Sa balangkas na ito ay lumilikha ng isang sistema kung saan ang isang ahente ng pag-aaral ay nakikipag-ugnayan sa isang simulate na kapaligiran ng kalakalan, na ginagabayan ng isang modernong arkitektura na nakabatay sa Transformer. Sa kaibuturan nito, hinahangad ng system na pahusayin ang mga desisyon sa pangangalakal sa paglipas ng panahon, pinipino ang diskarte nito sa pamamagitan ng pag-aaral ng reinforcement at mabilis na pag-angkop sa mga bagong kondisyon ng merkado.

Isaalang-alang muna ang modelo ng Transformer . Ayon sa kaugalian, binago ng mga Transformer ang mga larangan tulad ng natural na pagproseso ng wika sa pamamagitan ng pagbibigay-kahulugan sa mga pagkakasunud-sunod ng mga salita o mga token. Dito, inilalapat ang parehong mga prinsipyo sa data ng presyo ng time-series. Sa halip na mga salita, ang modelo ay gumagamit ng mga makasaysayang tampok sa merkado — mga presyo, dami, teknikal na tagapagpahiwatig — at nagtatangkang kumuha ng mga makabuluhang temporal na dependencies. Ang klase TransformerNetwork , na tinukoy sa code, ay nagpapakita ng diskarteng ito. Pansinin kung paano pino-project ng constructor ang mga feature ng raw input sa isang mas mataas na dimensional na representasyon at pagkatapos ay ipapasa ang mga ito sa maraming mga layer ng Transformer encoder:

 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

Itinatampok ng snippet na ito ang daloy: pumapasok ang mga raw na estado sa pamamagitan ng input_fc (isang linear na layer na pinahusay na may ingay at potensyal na mga adaptasyon na mababa ang ranggo), naglalakbay sa mga stacked na TransformerEncoderLayerRelative na module na kumukuha ng temporal at relatibong positional na impormasyon, at sa wakas ay ibinubuod sa mga aksyon sa pamamagitan ng output_fc . Ang disenyong ito ay nagbibigay-daan sa modelo na timbangin ang mga kaganapan sa iba't ibang mga punto ng oras, pagtukoy ng mga umuulit na pattern o mga anomalya na maaaring magmungkahi ng mga mapagkakakitaang pagkakataon.

Kung ang modelo ng Transformer ay nagbibigay ng "mata" at "tainga" ng ahente, ginagaya ng klase ng TradingEnv ang mundo kung saan ito nakikipag-ugnayan. Ang environment class na ito, na pinangalanang TradingEnv , ay tumutukoy kung ano ang ibig sabihin ng gumawa ng aksyon—gaya ng pagbubukas o pagsasara ng mga posisyon—at kung paano itinalaga ang mga reward. Sa loob ng kapaligiran, ang ahente ay nagmamasid sa mga pagbabago sa presyo, mga teknikal na tagapagpahiwatig, at ang mga kasalukuyang hawak nito. Ipinapakita ng sumusunod na sipi kung paano bumubuo ang kapaligiran ng mga estado mula sa data ng merkado at mga posisyon ng ahente:

 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

Dito, ang kapaligiran ay bumubuo ng isang rich state embedding na kinabibilangan ng impormasyon sa posisyon at isang makasaysayang window ng mga feature. Sa pamamagitan ng pagbibigay ng windowed na pananaw na ito, ang Transformer ay maaaring magmodelo ng mga temporal na pattern. Ang bawat hakbang sa kapaligiran ay nag-a-update ng mga posisyon, kinakalkula ang kita o pagkawala, at nagbabalik ng bagong estado at gantimpala para sa ahente. Ang cyclical exchange na ito ay nagpapalakas ng feedback loop, na nagpapahintulot sa ahente na malaman kung ano ang gumagana at kung ano ang hindi.

Ang makinang gumagawa ng desisyon ay nasa klase ng DiscreteDDQNAgent , na nagpapatupad ng Double DQN approach. Nakakatulong ang Double DQN na tugunan ang kilalang bias sa labis na pagtatantya sa Q-learning sa pamamagitan ng paggamit ng magkakahiwalay na network para sa pagpili ng aksyon at pagtatantya ng halaga. Ang ahente ay nagpapanatili ng online_net at target_net na mga instance ng Transformer-based na modelo at gumagamit ng replay buffer upang mag-sample ng mga nakaraang karanasan. Sa panahon ng pagsasanay, ina-update nito ang mga parameter nito sa pamamagitan ng pagliit ng pagkakaiba sa pagitan ng mga hinulaang Q-values at target na Q-values na nagmula sa target na network:

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

Ang code na ito ay nagpapakita ng isang maingat na gawain sa pagsasanay: ang ahente ay paulit-ulit na nagsa-sample ng mga mini-batch ng mga nakaraang transition, kino-compute ang pagkawala ng DDQN, at ina-update ang online_net . Paminsan-minsan, nagsasagawa ito ng soft update ng target_net upang dahan-dahang subaybayan ang mga pagpapabuti. Sa pamamagitan ng pagsasama-sama ng mga kakayahan sa pagkilala ng pattern ng Transformer sa stable na learning dynamics ng Double DQN, unti-unting nagiging mas dalubhasa ang ahente sa pagpili ng mga kumikitang trade.

Gayunpaman, ang mga kondisyon ng merkado ay hindi tumitigil. Ang mga pagbabago sa pagkasumpungin, pagbabago sa regulasyon, o biglaang mga kaganapan sa pagkatubig ay maaaring gawing mga talunan ngayon ang mga nanalo kahapon. Upang mahawakan ang mga ganitong pagbabago, ipinakilala ang konsepto ng Test-Time Training (TTT) . Sa halip na umasa lamang sa mga update na ginawa pagkatapos mangolekta ng malaking dami ng karanasan, pinapayagan ng TTT ang ilang bahagi ng network na dynamic na umangkop sa pagdating ng mga bagong estado, kahit na sa panahon ng hinuha. Ang mabilis na pagbagay na ito ay nagbibigay-daan sa ahente na i-recalibrate ang mga diskarte nito sa mabilisang pag-aayos, na umaayon sa mga hindi inaasahang pangyayari nang hindi naghihintay ng isang buong ikot ng muling pagsasanay.

Sa code na ito, ang TTT ay pinapadali ng piling mga parameter ng pagsasanay sa panahon ng inference at tumutuon sa isang maliit na subset ng mga parameter. Maaaring baguhin ng ahente, halimbawa, ang isang bahagi ng network nito upang mabilis na makuha ang mga bagong pattern. Ang mga pamamaraan activate_lora() at deactivate_lora() (hindi ipinapakita ngayon dahil nakatuon kami sa Transformer, Env, DDQN, at TTT logic) i-toggle ang mga adaptive na parameter na ito sa on at off. Bagama't partikular na tinutukoy ng code snippet na iyon ang LoRA (low-rank adaptation), ang parehong pilosopiya ay nalalapat: Ang ibig sabihin ng TTT ay pagpapagana sa ilang bahagi ng modelo na matuto sa oras ng pagsubok. Kapag aktibo ang TTT mode, agad na ina-update ng isang dalubhasang optimizer ang mga parameter na ito:

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

Ang auxiliary update routine na ito, na na-trigger sa oras ng pagsubok, ay nagpapakita ng kakayahang umangkop ng system. Sinadya ng ahente na i-mask ang ilang mga tampok ng pag-input at sinusubukang buuin muli ang mga ito, pagpapabuti ng panloob na representasyon nito ng kasalukuyang rehimen ng merkado. Sa paggawa nito, maaari itong mabilis na tumugon sa mga paglilipat ng data at mapanatili ang mga kumikitang estratehiya sa isang pabago-bagong tanawin.

Sa kabuuan, ang interplay sa mga bahaging ito ay lumilikha ng isang matatag at nababaluktot na trading machine. Ang modelong batay sa Transformer ay nagbibigay ng isang mayaman, sensitibo sa konteksto na pag-unawa sa mga signal ng merkado. Ginagaya ng TradingEnv ang mga makatotohanang kundisyon at mga loop ng feedback. Tinitiyak ng Double DQN framework ang matatag na pag-aaral ng mga halaga ng aksyon, unti-unting pinipino ang mga desisyon sa kalakalan. Sa wakas, pinapayagan ng TTT ang ahente na manatiling maliksi, inaayos ang mga panloob na parameter nito kapag nahaharap sa mga pattern ng nobela. Magkasama, ang mga elementong ito ay nagtatakda ng yugto para sa isang sistema na parehong sopistikado sa pagkilala sa pattern at nababanat sa harap ng kawalan ng katiyakan sa merkado, na nag-aalok ng isang nakakahimok na pananaw para sa susunod na henerasyong mga diskarte sa pangangalakal.

Ano ang kinalabasan?

• Maramihang Pagdoble ng Kapital: Sa makasaysayang pang-araw-araw na data ng BTC/USDT, ang ahente na ito ay hindi lamang nakakuha ng maliliit na kita — dinoble nito ang paunang kapital nito nang maraming beses. Kung hindi iyon isang wake-up call, hindi ko alam kung ano iyon.
• Matatag, Mababang Pagkalugi at Malinaw na Mga Patakaran: Ang mga log ng TensorBoard ay nagpapakita ng mga pagkalugi na na-smooth out sa kahanga-hangang mababang antas, at ang mga pamamahagi ng Q-value para sa iba't ibang mga aksyon sa pangangalakal ay bumuo ng mga natatanging, makabuluhang pattern. Pagsasalin: Ang modelo ay hindi lamang nanghuhula — ito ay natututo ng isang patuloy na kumikitang diskarte.

Potensyal sa Susunod na Antas

• Data ng Orderbook-Level: Sa ngayon, sumasayaw kami kasama ang OHLCV. Bigyan mo ako ng lalim ng orderbook, at bibigyan kita ng alpha na halos nuclear. Ang iyong panloob na liquidity pool ay karapat-dapat sa isang modelo na maaaring mahulaan at mapakinabangan ang mga microsecond-level na paggalaw ng presyo.
• Multi-Timeframe Integration: Intraday scalping o pangmatagalang posisyong pangangalakal? Sa mga transformer, maaari naming pagsamahin ang maramihang mga granularity — 1 minutong mga chart na may mga pang-araw-araw na trend — paglalantad ng mga signal na walang iisang timeframe ang maaaring mag-alok.
• Katatagan sa Pagbabago ng Rehimen: Ang mga merkado ay sumisira sa mga pattern sa lahat ng oras. Sa LoRA at TTT, mas mabilis na makakaangkop ang ahenteng ito kaysa sa isang caffeinated na intern na humihila ng all-nighter. Magdamag na volatility spike? Anunsyo ng Fed? Sabi ng modelo, "Isuot mo ito."

Magkomento, Makipag-ugnayan, Mag-alok ng Deal 🤯

Huwag hayaan itong maging isang panandaliang pag-usisa. Magkomento, magpuna, magtanong. Kung iniisip mo kung paano i-pivot ang iyong diskarte, o kung paano isama ang isang flexible na solusyon sa DRL sa iyong umiiral na stack mag-iwan ng komento.