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. Redaktörens anmärkning: Den här artikeln är endast i informationssyfte och utgör inte investeringsrådgivning. Kryptovalutor är spekulativa, komplexa och innebär höga risker. Detta kan innebära hög prisvolatilitet och potentiell förlust av din initiala investering. Du bör överväga din ekonomiska situation, investeringssyften och rådgöra med en finansiell rådgivare innan du fattar några investeringsbeslut. HackerNoon-redaktionen har endast verifierat berättelsen för grammatisk korrekthet och stöder eller garanterar inte riktigheten, tillförlitligheten eller fullständigheten av informationen som anges i denna artikel. #DYOR Varför transformatorer, varför DRL och varför du bör bry dig 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. Transformers: 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. Dubbel DQN (DDQN): uppmuntrar utforskning genom att lägga till parametriserat brus direkt till nätverksvikterna. Noisy Nets 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. LoRA 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. Test-Time Training (TTT): Koden är på Klona den, kör den, dissekera den. Du kanske gillar det. https://github.com/pmatheus/themoneyhack 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å . 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 , 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: Transformer-modellen TransformerNetwork 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 (ett linjärt lager förbättrat med brus och potentiella lågrankade anpassningar), reser genom staplade -moduler som fångar tidsmässig och relativ positionsinformation, och slutligen sammanfattas till åtgärder av . 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. input_fc TransformerEncoderLayerRelative output_fc Om Transformer-modellen ger agentens "ögon" och "öron", simulerar världen den interagerar med. Den här miljöklassen, som heter , 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: TradingEnv-klassen TradingEnv 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 , 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 och 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: DiscreteDDQNAgent online_net target_net 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 . Med jämna mellanrum utför den en mjuk uppdatering av 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. online_net target_net 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 . 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. Test-Time Training (TTT) 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 och (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: activate_lora() deactivate_lora() 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? 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. Multipelkapitalfördubblingar: 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. Stabila, låga förluster och tydliga policyer: Potential på nästa nivå 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å. Orderbook-Level Data: 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. Multi-Timeframe Integration: 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." Robusthet mot regimskiften: 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.
