Denna djupgående inlärningsmetod kan hjälpa till att fördubbla dina vinster i kryptoinvesteringar

Den här rapporten presenterar ett nytt tillvägagångssätt för handel med kryptovalutor med hjälp av en transformatorbaserad agent för Deep Reinforcement Learning (DRL). Systemet utnyttjar moderna NLP-inspirerade arkitekturer (Transformers), Double DQN (DDQN), Noisy Networks och Low-Rank Adaptation (LoRA) för Test-Time Training (TTT). Genom att kombinera dessa komponenter visar agenten förbättrad anpassningsförmåga, stabil policybildning och avsevärt förbättrad lönsamhet på historiska BTC/USDT-data. Även om de är preliminära antyder dessa resultat att metoden kan utökas till mer komplexa datauppsättningar (t.ex. orderboknivå) och flera tillgångsklasser, vilket ger en skalbar grund för handelsstrategier av institutionell kvalitet.

Varför transformatorer, varför DRL och varför du bör bry dig

• Transformers: De är födda i NLP-världen och briljerar med att dechiffrera sekvenser. Marknader är helt enkelt tidsseriepussel. Transformers läser dem som berättelser och förutser vändningar (prisrörelser) långt innan din genomsnittliga kvant blinkar.

• Dubbel DQN (DDQN): Inga fler ensidiga Q-värdesuppskattningar. DDQN skär ner på dessa ökända överskattningar, vilket ger din handelspolicy den trovärdighet den behöver för att hantera knepiga tjurfällor och björnräder.

• Noisy Nets uppmuntrar utforskning genom att lägga till parametriserat brus direkt till nätverksvikterna.

• LoRA tillåter testtidsträning (TTT) med minimal overhead, vilket gör att modellen snabbt kan anpassa sig till nya marknadsförhållanden utan en fullständig omskolningscykel.

• Test-Time Training (TTT): Marknader förändras, utvecklas, överraska. TTT låter den här modellen anpassa sig snabbt och justerar strategier under flygningen som om den läser morgondagens rubriker idag.

  
  

Koden är på https://github.com/pmatheus/themoneyhack Klona den, kör den, dissekera den. Du kanske gillar det.

I detta ramverk skapar ett system där en lärande agent interagerar med en simulerad handelsmiljö, styrd av en modern transformatorbaserad arkitektur. I grunden strävar systemet efter att förbättra handelsbeslut över tiden, förfina sin strategi genom förstärkningsinlärning och snabbt anpassa sig till nya marknadsförhållanden.

Tänk först på Transformer-modellen . Traditionellt har Transformers revolutionerat områden som naturlig språkbehandling genom att tolka sekvenser av ord eller tokens. Här tillämpas samma principer för tidsserieprisdata. Istället för ord intar modellen historiska marknadsegenskaper - priser, volymer, tekniska indikatorer - och försöker extrahera meningsfulla tidsmässiga beroenden. Klassen TransformerNetwork , definierad i koden, exemplifierar detta tillvägagångssätt. Lägg märke till hur konstruktören projicerar råa indatafunktioner till en högre dimensionell representation och sedan skickar dem genom flera transformatorkodarlager:

 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

Det här utdraget belyser flödet: råa tillstånd går in genom input_fc (ett linjärt lager förbättrat med brus och potentiella lågrankade anpassningar), reser genom staplade TransformerEncoderLayerRelative -moduler som fångar tidsmässig och relativ positionsinformation, och slutligen sammanfattas till åtgärder av output_fc . Denna design gör det möjligt för modellen att väga händelser vid olika tidpunkter, identifiera återkommande mönster eller anomalier som kan föreslå lönsamma möjligheter.

Om Transformer-modellen ger agentens "ögon" och "öron", simulerar TradingEnv-klassen världen den interagerar med. Den här miljöklassen, som heter TradingEnv , definierar vad det innebär att vidta en åtgärd – som att öppna eller stänga positioner – och hur belöningar tilldelas. Inuti miljön observerar agenten prisförändringar, tekniska indikatorer och dess nuvarande innehav. Följande utdrag visar hur miljön konstruerar tillstånd från marknadsdata och agentpositioner:

 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

Här bildar miljön en rik tillståndsinbäddning som inkluderar positionsinformation och ett historiskt fönster av funktioner. Genom att tillhandahålla detta fönsterperspektiv kan transformatorn modellera tidsmässiga mönster. Varje steg i miljön uppdaterar positioner, beräknar vinst eller förlust och returnerar ett nytt tillstånd och belöning för agenten. Detta cykliska utbyte främjar en återkopplingsslinga och låter agenten lära sig vad som fungerar och inte.

Beslutsmotorn finns i klassen DiscreteDDQNAgent , som implementerar en dubbel DQN-metod. Dubbel DQN hjälper till att hantera den välkända överskattningsbias i Q-learning genom att använda separata nätverk för val av åtgärder och värdeuppskattning. Agenten underhåller online_net och target_net instanser av den Transformer-baserade modellen och använder en replay-buffert för att prova tidigare erfarenheter. Under träningen uppdaterar den sina parametrar genom att minimera skillnaden mellan förutspådda Q-värden och mål-Q-värden härledda från målnätverket:

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

Den här koden avslöjar en noggrann träningsrutin: agenten provar upprepade gånger minibatcher av tidigare övergångar, beräknar DDQN-förlusten och uppdaterar online_net . Med jämna mellanrum utför den en mjuk uppdatering av target_net för att långsamt spåra förbättringar. Genom att kombinera en Transformers mönsterigenkänningskapacitet med den stabila inlärningsdynamiken hos Double DQN, blir agenten gradvis mer skicklig på att välja lönsamma affärer.

Marknadsförhållandena står dock aldrig stilla. Förändringar i volatilitet, regulatoriska förändringar eller plötsliga likviditetshändelser kan göra gårdagens vinnare till dagens förlorare. För att hantera sådana skift introduceras konceptet Test-Time Training (TTT) . Istället för att enbart förlita sig på uppdateringar som utförs efter att ha samlat in stora mängder erfarenhet, tillåter TTT vissa delar av nätverket att anpassa sig dynamiskt när nya tillstånd anländer, även under slutledning. Denna snabba anpassning gör det möjligt för agenten att omkalibrera sina strategier i farten, anpassa sig till oförutsedda omständigheter utan att vänta på en fullständig omskolningscykel.

I denna kod underlättas TTT genom att selektivt träna parametrar under slutledning och fokusera på en liten delmängd av parametrar. Agenten kan till exempel modifiera en del av sitt nätverk för att snabbt absorbera nya mönster. Metoderna activate_lora() och deactivate_lora() (visas inte nu eftersom vi fokuserar på Transformer-, Env-, DDQN- och TTT-logik) slår på och av dessa adaptiva parametrar. Även om det kodavsnittet specifikt refererar till LoRA (lågrankad anpassning), gäller samma filosofi: TTT innebär att vissa delar av modellen kan läras vid testtillfället. När TTT-läget är aktivt uppdaterar en specialiserad optimerare dessa parametrar på plats:

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

Denna extra uppdateringsrutin, utlöst vid testtillfället, visar systemets anpassningsförmåga. Agenten maskerar avsiktligt vissa indatafunktioner och försöker rekonstruera dem, vilket förbättrar sin interna representation av den nuvarande marknadsregimen. Genom att göra det kan den snabbt reagera på dataskiften och upprätthålla lönsamma strategier i ett ständigt föränderligt landskap.

Sammanfattningsvis skapar samspelet mellan dessa komponenter en robust och flexibel handelsmaskin. Den transformatorbaserade modellen ger en rik, kontextkänslig förståelse av marknadssignaler. TradingEnv simulerar realistiska förhållanden och återkopplingsslingor. Dubbel DQN-ramverket säkerställer stabil inlärning av handlingsvärden, som gradvis förfinar handelsbeslut. Slutligen tillåter TTT agenten att förbli smidig och justera dess interna parametrar när den konfronteras med nya mönster. Tillsammans sätter dessa element scenen för ett system som är både sofistikerat i mönsterigenkänning och motståndskraftigt inför osäkerhet på marknaden, vilket erbjuder en övertygande vision för nästa generations handelsstrategier.

Vad är resultatet?

• Multipelkapitalfördubblingar: På historiska dagliga BTC/USDT-data tog den här agenten inte bara ut små vinster – den fördubblade sitt startkapital flera gånger. Om det inte är ett väckarklocka så vet jag inte vad det är.
• Stabila, låga förluster och tydliga policyer: TensorBoard-loggarna visar förluster utjämnade till imponerande låga nivåer, och Q-värdefördelningar för olika handelsåtgärder bildade distinkta, meningsfulla mönster. Översättning: Modellen är inte bara att gissa – den lär sig ett konsekvent lönsamt tillvägagångssätt.

Potential på nästa nivå

• Orderbook-Level Data: Just nu dansar vi med OHLCV. Ge mig orderbok djup, så ska jag ge dig alfa som praktiskt taget är kärnkraft. Din interna likviditetspool förtjänar en modell som kan förutse och utnyttja prisrörelser på mikrosekundnivå.
• Multi-Timeframe Integration: Intraday scalping eller långsiktiga positionsaffärer? Med transformatorer kan vi smälta samman flera granulariteter - 1-minutersdiagram med dagliga trender - och avslöja signaler som ingen enskild tidsram kan erbjuda.
• Robusthet mot regimskiften: Marknader bryter mönster hela tiden. Med LoRA och TTT kan denna agent anpassa sig snabbare än en koffeinhaltig praktikant som drar en helnatt. Volatilitetspik över natten? Fed meddelande? Modellen säger: "Bring it on."

Kommentera, engagera, ge ett erbjudande 🤯

Låt inte detta vara en flyktig kuriosa. Kommentera, kritisera, ställ frågor. Om du undrar hur du ska svänga din strategi, eller hur du integrerar en flexibel DRL-lösning i din befintliga stack, lämna en kommentar.