ეს ანგარიში წარმოგიდგენთ ახალ მიდგომას კრიპტოვალუტით ვაჭრობისადმი ტრანსფორმერზე დაფუძნებული Deep Reinforcement Learning (DRL) აგენტის გამოყენებით. სისტემა იყენებს თანამედროვე NLP ინსპირირებულ არქიტექტურებს (ტრანსფორმერები), ორმაგ DQN (DDQN), ხმაურიანი ქსელები და დაბალი რანგის ადაპტაცია (LoRA) ტესტის დროში ტრენინგისთვის (TTT). ამ კომპონენტების კომბინაციით, აგენტი აჩვენებს გაუმჯობესებულ ადაპტირებას, სტაბილურ პოლიტიკის ფორმირებას და მნიშვნელოვნად გაზრდილ მომგებიანობას ისტორიულ BTC/USDT მონაცემებზე. მიუხედავად იმისა, რომ წინასწარია, ეს შედეგები ვარაუდობს, რომ მეთოდი შეიძლება გაფართოვდეს უფრო რთულ მონაცემთა ნაკრებებზე (მაგ., შეკვეთების წიგნის დონეზე) და აქტივების მრავალ კლასზე, რაც უზრუნველყოფს ინსტიტუციური დონის სავაჭრო სტრატეგიების მასშტაბურ საფუძველს. რედაქტორის შენიშვნა: ეს სტატია მხოლოდ საინფორმაციო მიზნებისთვისაა და არ წარმოადგენს საინვესტიციო რჩევას. კრიპტოვალუტები არის სპეკულაციური, რთული და შეიცავს მაღალ რისკებს. ეს შეიძლება ნიშნავს მაღალი ფასების ცვალებადობას და თქვენი საწყისი ინვესტიციის პოტენციურ დაკარგვას. თქვენ უნდა გაითვალისწინოთ თქვენი ფინანსური მდგომარეობა, საინვესტიციო მიზნები და გაიაროთ კონსულტაცია ფინანსურ მრჩეველთან რაიმე საინვესტიციო გადაწყვეტილების მიღებამდე. HackerNoon-ის სარედაქციო გუნდმა გადაამოწმა ამბავი მხოლოდ გრამატიკული სიზუსტისთვის და არ ადასტურებს ან გარანტიას არ აძლევს ამ სტატიაში მითითებული ინფორმაციის სიზუსტეს, სანდოობას ან სისრულეს. #DYOR რატომ ტრანსფორმატორები, რატომ DRL და რატომ უნდა იზრუნოთ დაბადებულები NLP სამყაროში, ისინი გამოირჩევიან მიმდევრობის გაშიფვრაში. ბაზრები უბრალოდ დროის სერიების თავსატეხებია. ტრანსფორმატორები კითხულობენ მათ, როგორც ისტორიები, ელიან სიუჟეტური ცვლილებების მოლოდინში (ფასის მოძრაობებს) სანამ თქვენი საშუალო რაოდენობა მოციმციმეს. ტრანსფორმერები: აღარ არის Q-მნიშვნელობის ცალმხრივი შეფასება. DDQN ამცირებს ამ ყბადაღებულ ზედმეტ შეფასებას, რაც თქვენს სავაჭრო პოლიტიკას აძლევს სანდოობას, რომელიც მას სჭირდება ხარის რთული ხაფანგებისა და დათვების დარბევისთვის. ორმაგი DQN (DDQN): ხელს უწყობს დათვალიერებას პარამეტრირებული ხმაურის პირდაპირ ქსელის წონებზე დამატებით. Noisy Nets საშუალებას აძლევს ტესტის დროში ვარჯიშს (TTT) მინიმალური ზედნადებით, რაც საშუალებას აძლევს მოდელს სწრაფად მოერგოს ახალ საბაზრო პირობებს სრული გადამზადების ციკლის გარეშე. LoRA ბაზრები იცვლება, ვითარდება, გაოცება. TTT საშუალებას აძლევს ამ მოდელს სწრაფად მოერგოს, არეგულირებს სტრატეგიებს ფრენის დროს, თითქოს დღეს კითხულობს ხვალინდელ სათაურებს. ტესტ-დროის ტრენინგი (TTT): კოდი ჩართულია კლონირება, გაშვება, ამოკვეთა. შეიძლება მოგეწონოს. https://github.com/pmatheus/themoneyhack ამ ჩარჩოში იქმნება სისტემა, სადაც სასწავლო აგენტი ურთიერთქმედებს სიმულირებულ სავაჭრო გარემოსთან, ხელმძღვანელობს თანამედროვე ტრანსფორმერზე დაფუძნებული არქიტექტურით. თავის არსში, სისტემა ცდილობს გააუმჯობესოს სავაჭრო გადაწყვეტილებები დროთა განმავლობაში, დახვეწოს თავისი სტრატეგია გაძლიერებული სწავლის გზით და სწრაფად მოერგოს ახალ საბაზრო პირობებს. ჯერ განვიხილოთ . ტრადიციულად, ტრანსფორმერებმა მოახდინეს რევოლუცია ისეთი სფეროებში, როგორიცაა ბუნებრივი ენის დამუშავება სიტყვების ან ნიშნების თანმიმდევრობის ინტერპრეტაციით. აქ იგივე პრინციპები გამოიყენება დროის სერიების ფასების მონაცემებზე. სიტყვების ნაცვლად, მოდელი იღებს ბაზრის ისტორიულ მახასიათებლებს - ფასებს, მოცულობას, ტექნიკურ ინდიკატორებს - და ცდილობს მნიშვნელოვანი დროებითი დამოკიდებულებების ამოღებას. კოდში განსაზღვრული კლასი ასახავს ამ მიდგომას. დააკვირდით, როგორ აპროექტებს კონსტრუქტორი ნედლი შეყვანის მახასიათებლებს უფრო მაღალი განზომილებიანი წარმოდგენით და შემდეგ გადასცემს მათ ტრანსფორმატორის ენკოდერის მრავალ ფენაში: ტრანსფორმატორის მოდელი 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 ეს ფრაგმენტი ხაზს უსვამს ნაკადს: ნედლეული მდგომარეობები შედიან ით (ხაზოვანი შრე გაძლიერებული ხმაურით და პოტენციური დაბალი დონის ადაპტაციით), მოგზაურობს დაწყობილ მოდულებში, რომლებიც იჭერენ დროებით და შედარებით პოზიციურ ინფორმაციას და ბოლოს აჯამებენ მოქმედებებში . ეს დიზაინი საშუალებას აძლევს მოდელს აწონ-დაწონოს მოვლენები დროის სხვადასხვა მომენტში, გამოავლინოს განმეორებადი შაბლონები ან ანომალიები, რომლებიც შეიძლება მიუთითებდეს მომგებიან შესაძლებლობებზე. input_fc TransformerEncoderLayerRelative output_fc თუ ტრანსფორმატორის მოდელი უზრუნველყოფს აგენტის „თვალებს“ და „ყურებს“, ახდენს სამყაროს სიმულაციას, რომელთანაც ის ურთიერთქმედებს. გარემოს ეს კლასი, სახელად , განსაზღვრავს რას ნიშნავს მოქმედების განხორციელება, როგორიცაა პოზიციების გახსნა ან დახურვა, და როგორ ენიჭება ჯილდოები. გარემოს შიგნით აგენტი აკვირდება ფასების ცვლილებებს, ტექნიკურ მაჩვენებლებს და მის ამჟამინდელ მფლობელობას. შემდეგი ნაწყვეტი გვიჩვენებს, თუ როგორ აყალიბებს გარემო მდგომარეობებს ბაზრის მონაცემებიდან და აგენტის პოზიციებიდან: TradingEnv კლასი 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 აქ გარემო ქმნის მდიდარ მდგომარეობას, რომელიც მოიცავს პოზიციის ინფორმაციას და მახასიათებლების ისტორიულ ფანჯარას. ამ ფანჯრის პერსპექტივის უზრუნველყოფით, ტრანსფორმერს შეუძლია დროებითი შაბლონების მოდელირება. გარემოში ყოველი ნაბიჯი განაახლებს პოზიციებს, ითვლის მოგებას ან ზარალს და უბრუნებს ახალ მდგომარეობას და ჯილდოს აგენტისთვის. ეს ციკლური გაცვლა ხელს უწყობს უკუკავშირის ციკლს, რაც საშუალებას აძლევს აგენტს გაიგოს რა მუშაობს და რა არა. გადაწყვეტილების მიმღები ძრავა მდებარეობს კლასში, რომელიც ახორციელებს Double DQN მიდგომას. ორმაგი DQN გვეხმარება Q- სწავლაში ცნობილი გადაჭარბებული შეფასების მიკერძოების მოგვარებაში მოქმედების შერჩევისა და ღირებულების შეფასებისთვის ცალკეული ქსელების გამოყენებით. აგენტი ინახავს ტრანსფორმერზე დაფუძნებული მოდელის და მაგალითებს და იყენებს განმეორებითი ბუფერს წარსული გამოცდილების შესამოწმებლად. ტრენინგის დროს, ის აახლებს თავის პარამეტრებს, მინიმალურად ამცირებს განსხვავებას პროგნოზირებულ Q-მნიშვნელობებსა და სამიზნე Q-მნიშვნელობებს შორის, რომლებიც მიღებულია სამიზნე ქსელიდან: 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() ეს კოდი ავლენს ფრთხილად ტრენინგის რუტინას: აგენტი არაერთხელ ამოწმებს წარსული გადასვლების მინი პარტიებს, ითვლის DDQN დანაკარგს და აახლებს ს. პერიოდულად, ის ახორციელებს ის რბილ განახლებას, რათა ნელ-ნელა თვალყური ადევნოს გაუმჯობესებას. Transformer-ის შაბლონის ამოცნობის შესაძლებლობების გაერთიანებით Double DQN-ის სტაბილურ სწავლის დინამიკასთან, აგენტი თანდათან უფრო კომპეტენტური ხდება მომგებიანი გარიგებების არჩევაში. online_net target_net თუმცა, ბაზრის პირობები არასოდეს ჩერდება. ცვალებადობამ, მარეგულირებელმა ცვლილებებმა ან ლიკვიდობის უეცარმა მოვლენებმა შეიძლება გუშინდელი გამარჯვებულები დღევანდელ წაგებულებად აქციოს. ამგვარი ცვლილებების მოსაგვარებლად, შემოღებულია კონცეფცია. იმის ნაცვლად, რომ დაეყრდნოს მხოლოდ განახლებებს, რომლებიც შესრულებულია დიდი გამოცდილების შეგროვების შემდეგ, TTT საშუალებას აძლევს ქსელის გარკვეულ ნაწილებს დინამიურად მოერგოს ახალი მდგომარეობების ჩამოსვლას, თუნდაც დასკვნის დროს. ეს სწრაფი ადაპტაცია აგენტს საშუალებას აძლევს გადაარჩინოს თავისი სტრატეგიები ფრენის დროს, მოერგოს გაუთვალისწინებელ გარემოებებს სრული გადამზადების ციკლის მოლოდინის გარეშე. ტესტის დროში ტრენინგის (TTT) ამ კოდში, TTT ხელს უწყობს პარამეტრების შერჩევით სწავლებას დასკვნის დროს და ფოკუსირებას ახდენს პარამეტრების მცირე ქვეჯგუფზე. აგენტს შეუძლია, მაგალითად, შეცვალოს თავისი ქსელის ნაწილი, რათა სწრაფად აითვისოს ახალი შაბლონები. მეთოდები და (ახლა არ არის ნაჩვენები, რადგან ჩვენ ფოკუსირებას ვაკეთებთ Transformer, Env, DDQN და TTT ლოგიკაზე) ამ ადაპტაციურ პარამეტრებს ჩართავთ და გამორთავთ. მიუხედავად იმისა, რომ კოდის ფრაგმენტი კონკრეტულად მიუთითებს LoRA-ზე (დაბალი რანგის ადაპტაცია), იგივე ფილოსოფია მოქმედებს: TTT ნიშნავს მოდელის გარკვეულ ნაწილებს, რომ ისწავლონ ტესტის დროს. როდესაც TTT რეჟიმი აქტიურია, სპეციალიზებული ოპტიმიზატორი ადგილზე განაახლებს ამ პარამეტრებს: 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() ეს დამხმარე განახლების რუტინა, რომელიც ამოქმედდა ტესტის დროს, აჩვენებს სისტემის ადაპტირებას. აგენტი განზრახ ნიღბავს შეყვანის ზოგიერთ მახასიათებელს და ცდილობს მათ რეკონსტრუქციას, გააუმჯობესოს მისი შიდა წარმომადგენლობა მიმდინარე ბაზრის რეჟიმის შესახებ. ამით მას შეუძლია სწრაფად რეაგირება მონაცემთა ცვლაზე და შეინარჩუნოს მომგებიანი სტრატეგიები მუდმივად ცვალებად ლანდშაფტში. საერთო ჯამში, ამ კომპონენტებს შორის ურთიერთქმედება ქმნის ძლიერ და მოქნილ სავაჭრო მანქანას. ტრანსფორმერზე დაფუძნებული მოდელი უზრუნველყოფს ბაზრის სიგნალების მდიდარ, კონტექსტზე მგრძნობიარე გაგებას. TradingEnv სიმულაციას უკეთებს რეალისტურ პირობებს და უკუკავშირის მარყუჟებს. ორმაგი DQN ჩარჩო უზრუნველყოფს სამოქმედო ღირებულებების სტაბილურ სწავლას, სავაჭრო გადაწყვეტილებების თანდათანობით დახვეწას. დაბოლოს, TTT საშუალებას აძლევს აგენტს დარჩეს მოქნილი, დაარეგულიროს მისი შიდა პარამეტრები ახალი შაბლონების წინაშე. ეს ელემენტები ერთად ქმნიან საფუძველს სისტემისთვის, რომელიც დახვეწილია შაბლონების ამოცნობაში და გამძლეა ბაზრის გაურკვევლობის პირობებში, სთავაზობს დამაჯერებელ ხედვას შემდეგი თაობის სავაჭრო სტრატეგიებისთვის. რა არის შედეგი? ისტორიული ყოველდღიური BTC/USDT მონაცემებით, ამ აგენტმა მხოლოდ მცირე მოგება არ მოიპოვა - მან რამდენჯერმე გააორმაგა თავისი საწყისი კაპიტალი. თუ ეს არ არის გაღვიძების ზარი, არ ვიცი რა არის. მრავალჯერადი კაპიტალის გაორმაგება: TensorBoard-ის ჟურნალები აჩვენებს დანაკარგებს შთამბეჭდავად დაბალ დონემდე და Q-მნიშვნელობის განაწილებამ სხვადასხვა სავაჭრო ქმედებებისთვის შექმნა განსხვავებული, მნიშვნელოვანი ნიმუშები. თარგმანი: მოდელი არ არის მხოლოდ გამოცნობა - ის სწავლობს მუდმივად მომგებიან მიდგომას. სტაბილური, დაბალი დანაკარგები და მკაფიო პოლიტიკა: შემდეგი დონის პოტენციალი ახლა ჩვენ ვცეკვავთ OHLCV-ით. მომეცი შეკვეთების წიგნის სიღრმე და მე მოგცემთ ალფას, რომელიც პრაქტიკულად ბირთვულია. თქვენი შიდა ლიკვიდურობის ფონდი იმსახურებს მოდელს, რომელსაც შეუძლია წინასწარ განსაზღვროს და გამოიყენოს მიკროწამების დონის ფასების მოძრაობა. შეკვეთების წიგნის დონის მონაცემები: ყოველდღიური სკალპინგი თუ გრძელვადიანი ვაჭრობა? ტრანსფორმატორების საშუალებით ჩვენ შეგვიძლია გავაერთიანოთ მრავალი გრანულარობა - 1 წუთიანი დიაგრამები ყოველდღიური ტენდენციებით - გამოვავლინოთ სიგნალები, რომლებსაც ვერც ერთი ვადები ვერ გვთავაზობს. Multi-Timeframe ინტეგრაცია: ბაზრები მუდმივად არღვევენ შაბლონებს. LoRA-სა და TTT-თან ერთად, ამ აგენტს შეუძლია უფრო სწრაფად ადაპტირება, ვიდრე კოფეინირებული სტაჟიორი, რომელიც მთელი ღამის განმავლობაში ატარებს. არასტაბილურობის მატება ღამით? ფედერალური ფედერალური განცხადება? მოდელი ამბობს: „ჩამოიტანე“. გამძლეობა რეჟიმის ცვლის მიმართ: დაწერეთ კომენტარი, ჩაერთეთ, შესთავაზეთ გარიგება 🤯 არ დაუშვათ, რომ ეს იყოს წარმავალი ცნობისმოყვარეობა. კომენტარები, კრიტიკა, დასვით კითხვები. თუ გაინტერესებთ, როგორ შეცვალოთ თქვენი სტრატეგია, ან როგორ ჩართოთ მოქნილი DRL გადაწყვეტა თქვენს არსებულ სტეკში, დატოვეთ კომენტარი.
