Foto: Deepmind on Unsplash
Matrično množenje je temeljna operacija, ki se uporablja v številnih sistemih, od nevronskih mrež do znanstvenih računalniških rutin. Iskanje učinkovitih in dokazljivo pravilnih algoritmov za matrično množenje lahko močno vpliva na hitrejše in učinkovitejše računanje, vendar je zelo zahtevna naloga. Prostor možnih algoritmov je ogromen in tradicionalne metode za odkrivanje algoritmov, kot so hevristike, ki jih je oblikoval človek, ali kombinatorično iskanje, so pogosto neoptimalne.
Deepmind's recently proposed AI-based solution for automated search goes far beyond human intuition. The solution consists of a deep reinforcement learning agent called AlphaTensor, built on top of alphazero. Ta agent je usposobljen za igranje igre za enega igralca, TensorGame, kjer je cilj odkriti računsko učinkovite algoritme za množenje matrik.
AlphaTensor je še posebej dober pri ravnanju z velikimi matrikami z razgradnjo velikih množenj matrik na manjša množenja. Poleg tega je AlphaTensor mogoče uporabiti za doseganje najsodobnejše zmogljivosti za matrično množenje, ko je natančno nastavljen na določeni strojni napravi.
AlphaTensor ima velik potencial za pospeševanje globokega učenja računalništva. Pri globokem učenju je mogoče številne zamudne operacije preslikati v matrična množenja. Z uporabo AlphaTensorja za optimizacijo teh operacij je mogoče znatno izboljšati celotno učinkovitost modelov globokega učenja.
Pred kratkim je OpenAlphaTensor, prva odprtokodna implementacija AlphaTensor, ki bi lahko revolucioniral računalniško moč modelov globokega učenja.
Tenzor množenja matrike
Za nestrokovnjake v optimizaciji množenja matrik morda ne bo enostavno razumeti, kako je mogoče operacijo, kot je množenje matrik, preslikati v tridimenzionalni tenzor. Poskušal bom razložiti s preprostimi besedami in primeri.
Oglejmo si produkt C = A*B, kjer sta zaradi enostavnosti A in B kvadratni matriki velikosti N. Operacijo množenja je mogoče preslikati v 3D tenzor oblike (N^2, N^2, N^2). Prva tenzorska dimenzija predstavlja sploščeno matriko A, druga dimenzija sploščeno matriko B in tretja dimenzija sploščeno matriko C.
Tenzor ima samo binarne vrednosti (bodisi 1 ali 0) za vsak vnos. Upoštevajte, da tenzor predstavlja operacijo množenja, zato je neodvisen od vrednosti matrik A in B.
Vsak vnos tenzorja ustreza koeficientu operacije. Na primer, za izračun C[1,1] je treba pomnožiti A[1,1] in B[1,1]. Zato bo imel tenzorski vnos [0,0,0], ki ustreza A[1,1], B[1,1] in C[1,1], vrednost 1. Nasprotno pa za izračun C[1,1 ,2,1], A[1] ni potreben. Tako bo tenzorska vrstica T[N+0, :, XNUMX] vsebovala samo ničle.
Spodnja slika prikazuje primer tenzorja za N=2.
Image from DeepMind's papirja objavljeno v Narava
Kot je prikazano v (b) in (c) na zgornji sliki, je možno implementirati algoritem za izračun produkta z uporabo dekompozicije 3D tenzorja. Natančneje, spodnji algoritem se lahko uporabi za pretvorbo tenzorske dekompozicije (matrike U, V, W) v algoritem množenja matrik.
Meta-algorithm parameterized for computing the matrix product C=AB introduced in DeepMind's papirja
TensorGame
Problem iskanja učinkovitih algoritmov za matrično množenje je izjemno zahteven, ker je število možnih algoritmov, ki jih je treba upoštevati, veliko večje od števila atomov v vesolju, tudi za majhne primere matričnega množenja.
DeepMind je to težavo pretvoril v igro za enega igralca in jo poimenoval TensorGame. V tej igri igralec izbere, kako združiti različne vnose matrik, da jih pomnoži. Rezultat se dodeli na podlagi števila operacij, potrebnih za doseganje pravilnega rezultata množenja. Igra se konča, ko je dosežen ničelni tenzor ali ko je narejeno največje število potez. Končna faktorizacija se ovrednoti na podlagi ocene preostalega ranga in določenih kriterijev optimizacije, kot sta asimptotična časovna kompleksnost ali praktični čas izvajanja.
Začetni položaj v TensorGame ustreza Tenzorju množenja matrike, izraženem na neki naključni podlagi.
V vsakem koraku t igre igralec zapiše tri vektorje
, ki določa tenzorje ranga 1 . Stanje igre se posodobi z odštevanjem vektorjev, ki jih izbere igralec:
Kje
je tenzor množenja matrik.Če se igra konča v p korakih, to pomeni, da je tenzor množenja matrike
lahko razgradimo na p tenzorje ranga 1 , tj. ima vsaj rang p.TensorGame je nato mogoče interpretirati kot algoritem za razgradnjo ranga, AlphaTensor pa kot algoritem za ocenjevanje ranga tenzorja.
Arhitektura AlphaTensor
Doslej smo spoznali igro TensorGame in pojasnili, kako je njeno rešitev mogoče videti kot algoritem množenja matrike. Raziščimo zdaj glavne koncepte AlphaTensorja, algoritma, ki se uporablja za igro.
Arhitektura AlphaTensor je v bistvu arhitektura transformatorja kodirnika-dekoderja, kjer:
- kodirnik vzame kot vhod stanje igre , n prejšnjih dejanj, ki jih je izvedel model (običajno n=7), in časovni indeks t trenutnega dejanja. Informacije so zložene skupaj v tenzor z obliko (n+1, N^2, N^2, N^2). Ta tenzor se nato preoblikuje in transformira (z uporabo treh linearnih plasti) v tenzor oblike (N^2, N^2, c), kjer je c notranja dimenzija modela.
- dekoder generira dejanja n_steps iz vdelanega vektorja, ki ga poda kodirnik na samoregresiven način. Vsako dejanje ustreza žetonu trojčkov ki predstavlja enega od trojčkov, ki razgradijo tenzor igre (tj. zmanjšajo njegov rang)
Model se uri z izmeničnim povratnim širjenjem in delovanjem modela. Delovanje modela se uporablja za ustvarjanje podatkov, ki se nato uporabijo za usposabljanje modela. V praksi se model uri z mešanico sintetično generiranih podatkov in podatkov, ki jih model generira med delovanjem. Korak igranja se izvede tako, da se vzame 3D tenzor, ki ustreza matrični operaciji, in se na njem igrajo igre n_actors. Vsak igralec igra igro na standardni osnovi ali na alternativni osnovi (sprememba osnove se uporabi z dano verjetnostjo). Rezultati se nato zberejo in jih je mogoče uporabiti v koraku usposabljanja s sintetičnimi podatki.
The acting step is based on AlphaZero's Monte Carlo Tree Search (MCTS), modified to support large action spaces. In short, before choosing the action, n_sims paths are explored from the model output with a maximum future exploration of 5 steps. The probabilities generated by the model are then adjusted taking into account the generated paths. Then the action with the most promising future path(s) is chosen to continue the game.
Med usposabljanjem modela je nagrada pravzaprav negativna nagrada (kazen). Njegova absolutna vrednost se poveča z vsakim dodatnim korakom, potrebnim za rešitev igre. Če model naredi m korakov za rešitev TensorGame, je nagrada, povezana z igro, r=-m. Če model ne more rešiti TensorGame v korakih max_rank, se nagrada izračuna z oceno ranga preostalega tenzorja. Rang je ocenjen kot vsota rangov matrik, ki sestavljajo tenzor. Ocena je zgornja meja pravega ranga tenzorja.
When fine-tuning the model, the penalty reward at the terminal state should also take into account the latency of the algorithm produced by the model. The reward formula becomes rt'=rt+λbt, where rt is the reward scheme described earlier, bt is the benchmark reward (non-zero only at the terminal state), and λ je uporabniško določen koeficient.
Pospešitve (%) algoritmov, ki jih je odkril AlphaTensor, prilagojenih za GPE in TPU, izvlečeno iz papirja DeepMinda. Pospešitve se merijo glede na standardno (npr. cuBLAS za GPE) matrično množenje na isti strojni opremi in primerjajo z Algoritem Strassenovega kvadrata. vir: Deepmind.
Pred kratkim sem izdal OpenAlphaTensor, prva odprtokodna implementacija AlphaTensor. V tem razdelku se bom sprehodil skozi izvedbo. Kot smo že omenili, je arhitektura AlphaTensor dokaj enostavna in temelji na standardnem transformatorju z arhitekturo kodirnika-dekoderja. Najbolj zanimivi komponenti AlphaTensorja sta prva plast v delu kodirnika in način vzorčenja dejanj.
Začnimo s prvo plastjo kodiranja.
# x.size = (N, T, S, S, S)
# scalars.size = (N, s)
batch_size = x.shape[0]
S = x.shape[-1]
T = x.shape[1]
x1 = x.permute(0, 2, 3, 4, 1).reshape(batch_size, S, S, S * T)
x2 = x.permute(0, 4, 2, 3, 1).reshape(batch_size, S, S, S * T)
x3 = x.permute(0, 3, 4, 2, 1).reshape(batch_size, S, S, S * T)
input_list = [x1, x2, x3]
for i in range(3): temp = self.linears_1[i](scalars).reshape(batch_size, S, S, 1) input_list[i] = torch.cat([input_list[i], temp], dim=-1) input_list[i] = self.linears_2[i](input_list[i])
x1, x2, x3 = input_list
V zgornjem delčku prikazujemo, kako je vhodni tenzor razčlenjen na tri tenzorje, ki se nato uporabijo kot vhodi poizvedbe, ključa in vrednosti transformatorske plasti.
- V treh dimenzijah tenzorja, ki predstavljajo sploščene matrike (A, B, C), je vhodni tenzor sploščen vzdolž vsake dimenzije skupaj z dimenzijo, ki predstavlja prejšnja dejanja. Na ta način je v vsaki sploščeni kopiji vhodnega tenzorja izbrana dimenzija agregacija zadnjih vrednosti T-1 in dejanske vrednosti za vse vrednosti S izbrane dimenzije, kjer je S=N^2. Filozofsko gledano je tako, kot da se za vsako dimenzijo osredotočimo na to, kar se je zgodilo v prejšnjih dejanjih v tej dimenziji.
- Skalarji so preslikani v treh različnih prostorih dimenzije S^2 in nato preoblikovani, da so povezani s tenzorji, pridobljenimi v prejšnji točki. Konceptualno so skalarji preslikani v vdelani prostor dimenzije S^2, nato pa so vdelane informacije razdeljene v S vektorjev in zložene skupaj, podobno kot se zgodi z besedilom, ko je tokenizirano.
- Skalarni žetoni so združeni s prestrukturiranim vhodnim tenzorjem in nato podani kot vhod v linearno plast za preslikavo informacij o fokusu skalarjev+zgodovine kanala v notranji dimenziji modela.
Te tri korake je mogoče razlagati kot način podajanja modelu informacij o skalarjih (kot v časovnem koraku TensorGame) in osredotočenosti na prejšnja dejanja za vsak kanal.
V zvezi z načinom, kako so dejanja proizvedena, je zanimivo omeniti, da AlphaTensor kot izhod ustvari trojček u, v, w, katerega namen je zmanjšati rang tenzorja. Trije vektorji imajo velikost S in ker so povezani, mora model ustvariti vektor velikosti 3*S. AlphaTensor se usposablja z algoritmom RL, zato morajo biti vsa možna dejanja izražena v smislu verjetnosti v oštevilčenem prostoru, kar pomeni, da model ustvari verjetnost za različna dejanja. To pomeni, da mora biti vsak vektor v prostoru 3S preslikan v drugo dejanje. Posledica tega je akcijski prostor velikosti |F|^(3S), kjer je |F| je število različnih vrednosti, ki jih lahko sprejme element u, v, w. Običajno so vrednosti omejene na (-2, -1, 0, 1, 2), kar ima za posledico kardinalnost 5 elementov.
Tukaj nastopi velik izziv: za generiranje verjetnosti dejanja za matrični produkt matrik velikosti 5 bi potrebovali pomnilnik 5^75 * 4 bajtov, kar bi pomenilo ~10^44 GB pomnilnika. Jasno je, da tako velikega akcijskega prostora ne moremo upravljati.
Kako rešimo problem? Da zmanjšamo pomnilniški odtis verjetnosti dejanja, lahko trojčke razdelimo na manjše dele, jih "tokeniziramo" in obravnavamo dele kot ustvarjene žetone v transformatorski arhitekturi, tj. način. V zgornjem primeru lahko trojčke razdelimo na 15 kosov, s čimer zmanjšamo porabo pomnilnika na 15 * 5^(75/15) * 4, tj. 187.5 KB.
def _eval_forward(self, e: torch.Tensor): bs = e.shape[0] future_g = ( torch.zeros((bs, self.n_samples, self.n_steps)).long().to(e.device) ) ps = torch.ones((bs, self.n_samples)).to(e.device) e = e.unsqueeze(1).repeat(1, self.n_samples, 1, 1) future_g = future_g.view(-1, self.n_steps) ps = ps.view(-1) e = e.view(-1, e.shape[-2], e.shape[-1]) for i in range(self.n_steps): o_s, z_s = self.core(future_g[:, : i + 1], e) future_g[:, i], p_i = sample_from_logits(o_s[:, i]) ps *= p_i future_g = future_g.view(bs, self.n_samples, self.n_steps) ps = ps.view(bs, self.n_samples) return ( future_g, ps, z_s[:, 0].view(bs, self.n_samples, *z_s.shape[2:]).mean(1), )
Zgoraj prikazujemo delček kode za generiranje celotnega dejanja. V kodi self.core vsebuje dekodirni sloj, tenzor e pa predstavlja izhod kodirnega sloja. Nič se lahko šteje za žeton v modelih NLP in dejanja n_steps, ki predstavljajo kose n_steps, se generirajo progresivno.
Model vrne tri količine:
- Ustvarjena dejanja
- Verjetnost, povezana s popolnim dejanjem
- Logiti, proizvedeni za generiranje prvega dejanja (prvega kosa), ki bo uporabljen za izračun vrednosti modela.
Vredno je nameniti nekaj besed parametru n_samples. Parameter se uporablja za korak delovanja in omogoča modelu, da ustvari različne različice trojčkov, ki bodo nato uporabljeni za raziskovanje akcijskega prostora v algoritmu iskanja po drevesih Monte Carlo, uporabljenem v procesu delovanja. Različna dejanja n_samples so vzorčena glede na pravilnik, ki ga ustvari model.
Igralski korak
Najbolj zapleten del celotnega algoritma je verjetno korak delovanja, ki se uporablja za reševanje TensorGame. Algoritem v dokumentu AlphaTensor ni podrobno razložen, saj temelji na več prejšnjih dokumentih DeepMinda, ki so samo citirani in navedeni kot znani. Tukaj bom rekonstruiral vse manjkajoče dele in korak za korakom razložil našo izvedbo.
Igralske korake lahko organiziramo v treh različnih komponentah:
- Iskanje drevesa Monte-Carlo
- Simulacija igre
- Izboljšano izračunavanje pravilnika
Analizirajmo jih enega za drugim.
Monte-Carlo Tree Search (MCTS)
Monte Carlo Tree Search (MCTS) je široko uporabljena tehnika umetne inteligence za igranje iger, zlasti v družabnih igrah in video igrah. Algoritem ustvari drevo igre, ki simulira potencialne poteze in rezultate ter uporablja naključno vzorčenje za oceno pričakovane nagrade za vsako potezo. Algoritem nato iterativno izbere potezo z najvišjo pričakovano nagrado in simulira rezultate, dokler ne doseže končnega stanja ali določenega stanja ustavitve. Simulacije se uporabljajo za oceno verjetnosti zmage za vsako potezo in vodenje postopka odločanja. MCTS se je izkazal za učinkovitega v zapletenih igrah, kjer je število možnih potez in izidov veliko, in je bil uporabljen v uspešnih sistemih AI za igranje iger, kot je AlphaGo.
V AlphaTensorju je uporabljena spremenjena različica originalnega MCTS. Zlasti namesto naključnega izbiranja dejanja iz celotnega prostora dejanj je dejanje izbrano med podmnožico, ki jo generira neposredno model (prek n_vzorcev, predstavljenih prej). Popravek nadgradnje pravilnika se nato uporabi v koraku izračuna izboljšanega pravilnika.
V naši implementaciji smo se odločili, da bomo vse informacije o drevesu Monte-Carlo hranili v slovarju, ki ima kot ključ razpršeno različico stanja TensorGame in vrednosti informacije, povezane s samim stanjem. Vsak korak Monte-Carlo se začne z vozliščem in simulira mini igre n_sim ter raziskuje prihodnost z obzorjem 5 potez. Če je bilo vozlišče že raziskano v prejšnjih simulacijah, se n_sim prilagodi glede na število prejšnjih raziskovanj. Za vsako vozlišče je število obiskov shranjeno v tenzorju N_s_a, saj ta tenzor vsebuje število obiskov na podrejeno dejanje vozlišča (med tistimi, ki jih vzorči model).
def monte_carlo_tree_search( model: torch.nn.Module, state: torch.Tensor, n_sim: int, t_time: int, n_steps: int, game_tree: Dict, state_dict: Dict,
): """Runs the monte carlo tree search algorithm. Args: model (torch.nn.Module): The model to use for the simulation. state (torch.Tensor): The initial state. n_sim (int): The number of simulations to run. t_time (int): The current time step. n_steps (int): The maximum number of steps to simulate. game_tree (Dict): The game tree. state_dict (Dict): The dictionary containing the states. """ state_hash = to_hash(extract_present_state(state)) if state_hash in state_dict: with torch.no_grad(): N_s_a = state_dict[state_hash][3] n_sim -= int(N_s_a.sum()) n_sim = max(n_sim, 0) for _ in range(n_sim): simulate_game(model, state, t_time, n_steps, game_tree, state_dict) # return next state possible_states_dict, _, repetitions, N_s_a, q_values, _ = state_dict[ state_hash ] possible_states = _recompose_possible_states(possible_states_dict) next_state_idx = select_future_state( possible_states, q_values, N_s_a, repetitions, return_idx=True ) next_state = possible_states[next_state_idx] return next_state
Zgornja koda prikazuje našo implementacijo algoritma. Zaradi poenostavitve kode se popravek pravilnika izvede v funkciji simulate_game.
Igra Simulacija
Funkcija simulate_game je odgovorna za raziskovanje drevesa, sestavljenega iz vozlišč, ki predstavljajo določeno stanje TensorGame. Prav tako zažene model, kadar koli naleti na listno vozlišče, in shrani vse informacije o vozlišču v slovarju state_dict. Oglejmo si poglobljeno njegovo izvajanje:
@torch.no_grad()
def simulate_game( model, state: torch.Tensor, t_time: int, max_steps: int, game_tree: Dict, states_dict: Dict, horizon: int = 5,
): """Simulates a game from a given state. Args: model: The model to use for the simulation. state (torch.Tensor): The initial state. t_time (int): The current time step. max_steps (int): The maximum number of steps to simulate. game_tree (Dict): The game tree. states_dict (Dict): The states dictionary. horizon (int): The horizon to use for the simulation. """ idx = t_time max_steps = min(max_steps, t_time + horizon) state_hash = to_hash(extract_present_state(state)) trajectory = [] # selection while state_hash in game_tree: ( possible_states_dict, old_idx_to_new_idx, repetition_map, N_s_a, q_values, actions, ) = states_dict[state_hash] possible_states = _recompose_possible_states(possible_states_dict) state_idx = select_future_state( possible_states, q_values, N_s_a, repetition_map, return_idx=True ) trajectory.append((state_hash, state_idx)) # state_hash, action_idx future_state = extract_present_state(possible_states[state_idx]) state = possible_states[state_idx] state_hash = to_hash(future_state) idx += 1 # expansion if idx = max_steps: trajectory.append((state_hash, None)) if not game_is_finished(extract_present_state(state)): state = state.to(model.device) scalars = get_scalars(state, idx).to(state.device) actions, probs, q_values = model(state, scalars) ( possible_states, cloned_idx_to_idx, repetitions, not_dupl_indexes, ) = extract_children_states_from_actions( state, actions, ) not_dupl_actions = actions[:, not_dupl_indexes].to("cpu") not_dupl_q_values = torch.zeros(not_dupl_actions.shape[:-1]).to( "cpu" ) N_s_a = torch.zeros_like(not_dupl_q_values).to("cpu") present_state = extract_present_state(state) states_dict[to_hash(present_state)] = ( _reduce_memory_consumption_before_storing(possible_states), cloned_idx_to_idx, repetitions, N_s_a, not_dupl_q_values, not_dupl_actions, ) game_tree[to_hash(present_state)] = [ to_hash(extract_present_state(fut_state)) for fut_state in possible_states ] leaf_q_value = q_values else: leaf_q_value = -int(torch.linalg.matrix_rank(state).sum()) # backup backward_pass(trajectory, states_dict, leaf_q_value=leaf_q_value)
Vsaka simulacija je razdeljena na tri dele:
- izbor
- Širitev
- backup
V izbirnem delu se simulacija izvaja na že ustvarjenih drevesnih vozliščih in naslednje vozlišče je izbrano z naslednjo funkcijo:
def select_future_state( possible_states: List[torch.Tensor], q_values: torch.Tensor, N_s_a: torch.Tensor, repetitions: Dict[int, list], c_1: float = 1.25, c_2: float = 19652, return_idx: bool = False,
) -> torch.Tensor: """Select the future state maximizing the upper confidence bound."""
# q_values (1, K, 1) pi = torch.tensor( [ len(repetitions[i]) for i in range(len(possible_states)) if i in repetitions ] ).to(q_values.device) ucb = q_values.reshape(-1) + pi * torch.sqrt( torch.sum(N_s_a) / (1 + N_s_a) ) * (c_1 + torch.log((torch.sum(N_s_a) + c_2 + 1) / c_2)) if return_idx: return ucb.argmax() return possible_states[ucb.argmax()]
V praksi dejanje, ki maksimira funkcijo ucb:
za dano stanje je izbrano. Tukaj Q predstavlja vrednosti Q, ki jih ustvari model, π pa naključno porazdelitev med dejanji, vzorčenimi s politiko modela. N(s, a) predstavlja število obiskov vozlišča do dejanja a iz vozlišča s.
Ko izbirna faza doseže listno vozlišče, če simulacija ni dosegla končnega stanja (v smislu največjega raziskovanja, tj. prihodnjega obzorja ali konca igre), se model nato uporabi za izbiro n_samples alternativnih vozlišč (listna vozlišča v zaporedni ponovitvi). To se imenuje faza razširitve, saj se drevesu dodajo nova vozlišča. Nato v trenutni simulaciji ni raziskano nobeno nadaljnje vozlišče, vendar je list q_value poslan v naslednji korak simulacije: varnostna kopija.
Varnostno kopiranje je zadnja faza vsake simulacije. Če je bilo listno vozlišče v stanju terminala med varnostnim kopiranjem, se izračuna končna nagrada; drugače se kot ocenjena nagrada uporabi vrednost lista q. Nato se nagrada prenese nazaj na trajektorijo simulacije, pri čemer se posodobita stanja q_values in števec obiskov N(s, a). V spodnjem delčku prikazujemo kodo za povratno širjenje nagrade.
def backward_pass(trajectory, states_dict, leaf_q_value: torch.Tensor): """Backward pass of the montecarlo algorithm"""
reward = 0 for idx, (state, action_idx) in enumerate(reversed(trajectory)): if action_idx is None: # leaf node reward += leaf_q_value else: ( _, old_idx_to_new_idx, _, N_s_a, q_values, _, ) = states_dict[state] if isinstance(reward, torch.Tensor): reward = reward.to(q_values.device) action_idx = int(action_idx) if action_idx in old_idx_to_new_idx: not_dupl_index = old_idx_to_new_idx[int(action_idx)] else: not_dupl_index = action_idx reward -= 1 q_values[:, not_dupl_index] = ( N_s_a[:, not_dupl_index] * q_values[:, not_dupl_index] + reward ) / (N_s_a[:, not_dupl_index] + 1) N_s_a[:, not_dupl_index] += 1
Izboljšano izračunavanje politik
Ko so vse simulacije izvedene in MCTS ponudi zanimiv posnetek bližnje prihodnosti, je čas, da posodobite pravilnik, povezan s predvidenimi vozlišči, in jih vrnete, tako da jih je mogoče uporabiti med usposabljanjem. Izboljšan pravilnik po metodi, opisani v Hubert et al, se uporablja za upravljanje velikih akcijskih prostorov. Pravzaprav je pri majhnem iskalnem prostoru mogoče med MCTS naključno vzorčiti dejanje iz akcijskega prostora in oceniti njegov učinek. Podoben pristop v veliko večjem akcijskem prostoru bi privedel do tega, da bi se vse krivulje razhajale po različnih poteh in potrebovalo bi neskončno veliko trajektorij za pridobitev smiselne statistike in nato posodobitev politike. Ker tukaj uporabljamo sample-MCTS za izogibanje disperziji, tj. n_samples dejanj je vzorčenih v skladu s politiko modela in nato MCTS samo izbere eno od vzorčenih dejanj med raziskovanjem drevesa, moramo pri računanju upoštevati vzorčni popravek končni posodobljen pravilnik, ki bo uporabljen med usposabljanjem modela.
V praksi se izboljšana politika izračuna kot
Kje
def compute_improved_policy( state_dict: Dict, states: List[str], model_n_steps: int, model_n_logits: int, N_bar: int,
): """Compute the improved policy given the state_dict, the list of states. The improved policy is computed as (N_s_a / N_s_a.sum())^(1/tau) where tau is (log(N_s_a.sum()) / log(N_bar)) if N_s_a.sum() > N_bar else 1. """ policies = torch.zeros(len(states), model_n_steps, model_n_logits) N_bar = torch.tensor(N_bar) for idx, state in enumerate(states): N_s_a = state_dict[state][3] actions = state_dict[state][5] if N_s_a.sum() > N_bar: tau = (torch.log(N_s_a.sum()) / torch.log(N_bar)).item() else: tau = 1 N_s_a = N_s_a ** (1 / tau) improved_policy = N_s_a / N_s_a.sum() for sample_id in range(actions.shape[1]): action_ids = actions[0, sample_id] for step_id, action_id in enumerate(action_ids): policies[idx, step_id, action_id] += improved_policy[ 0, sample_id ] return policies
Upoštevajte, da moramo v naši izvedbi po izračunu pravilnika iz tenzorja N_s_a le-tega preslikati nazaj v izvirni akcijski tenzor. Pravzaprav N_s_a samo upošteva dejanja, ki jih vzorči model, medtem ko mora končna politika vsebovati verjetnosti tudi za neraziskana dejanja.
Razlike glede algoritma za usposabljanje ChatGPT
AlphaTensor is the latest member of the AlphaGo/AlphaZero family of artificial intelligence methods by DeepMind. These methods are based on the Monte Carlo Tree Search (MCTS) algorithm, which has been refined and enhanced by DeepMind to tackle increasingly complex tasks. Another AI system, OpenAI's ChatGPT, which has caused a lot of buzz for its remarkable performance, was trained with a different approach, called Reinforcement Learning with Human Feedback (RLHF).
RLHF je tehnika natančnega prilagajanja, ki se uporablja za prilagajanje jezikovnih modelov, da sledijo nizu pisnih navodil. Človeške preference uporablja kot signal za nagrajevanje za natančno nastavitev modela, s čimer uskladi vedenje jezikovnega modela z navedenimi preferencami določene skupine ljudi, namesto s kakšnim širšim pojmom 'človeških vrednot'.
Nasprotno pa je MCTS drevesni iskalni algoritem, ki se uporablja za določanje optimalnih potez v igrah. Simulira možne poteze in posodablja vrednosti vsake poteze glede na njihove rezultate, kar vodi k izbiri najboljše poteze.
RLHF zbira podatke iz človeško napisanih demonstracij in človeško označenih primerjav med modeli umetne inteligence ter usposablja model nagrajevanja za napovedovanje preferenc dane skupine ljudi. Model nagrajevanja se nato uporabi za natančno nastavitev modelov AI. MCTS na drugi strani uporablja simulacije in vrednotenja za določitev najboljše odločitve.
Čeprav gre za različna pristopa, imata RLHF in MCTS tudi podobnosti. Obe tehniki umetne inteligence uporabljata metode odločanja in reševanja problemov ter obe uporabljata pristop poskusov in napak za raziskovanje različnih možnosti in sprejemanje odločitev na podlagi razpoložljivih informacij. Oba sta tudi ponavljajoča se procesa, ki se sčasoma izboljšata, ko se zbere več informacij in izkušenj.
Izbira med RLHF in MCTS je odvisna od naloge. RLHF je idealen, kadar ni jasne metrike za ocenjevanje zmogljivosti modela, medtem ko se je MCTS izkazal za učinkovitega pri nalogah, podobnih igram, kjer znanje in raziskovanje prihodnosti dajeta modelu pomembno prednost.
Optimizacija kode za usposabljanje AlphaTensor
Implementacija vadbenega algoritma AlphaTensor zahteva iskanje popolnega kompromisa med hitrostjo vadbe in porabo pomnilnika. Kot je razvidno iz razdelka Model, lahko preprosto upoštevanje tokenizacije dejanj prihrani veliko pomnilnika, vendar lahko preveč agresivno zmanjševanje prostora za dejanja privede do zmanjšanja natančnosti in počasnejšega delovanja. Slednje se zgodi, ker vse žetone generira zaporedno na avtoregresiven način dekoder modela. Zato čas sklepanja raste linearno s številom žetonov na dejanje, ko softmax na prostoru dejanja ni več ozko grlo.
Pri vzpostavitvi treninga AlphaTensor so bile glavne težave pri obravnavanju igralskega procesa. Če tenzorji niso shranjeni v pravilni obliki, lahko MCTS zlahka povzroči nenadzorovano rast porabe pomnilnika. Po drugi strani pa, če se število tenzorjev, shranjenih med vsako simulacijo, preveč zmanjša, lahko MCTS porabi neskončno količino časa za ponovno izračunavanje zahtevanih stanj.
Let's take an example of the game simulation step, where the game is explored by looking at possible future scenarios. For each state, if we don't save the actions generated by the model and we decide to save only the random seed used to sample the actions from the policy, then each time we explore a tree node we would have to recompute the policy and then sample the actions. Clearly, we decided to store the sampled actions to save time and to avoid having to manage model sharing between different processes in the case of MCTS exploration parallelization. However, just saving the actions was not enough to get a sufficiently efficient acting step. In fact, the time for converting the n_steps actions into the (u, v, w) triplet, reducing the game tensor state and creating the new3D tensors from the n_samples actions would easily be a bottleneck for the whole training. Secondly, we didn't want to store all possible future states for each sampled action, as this would have a huge impact on the memory used by the algorithm. Suppose we set n_samples=32, n=7 and N=5, and let's remember that N is the size of the square matrix product we want to reduce and n is the number of previous actions remembered by the model. In this situation, each state tensor would have the form (8, 25, 25, 25), which multiplied by 32 would result in 3282525254 bajti za vsako vozlišče v grafu. Glede na to, da vsaka simulacija v fazi razširitve ustvari novo vozlišče (in n_sim=200), bi imeli končno porabo pomnilnika 200328252525*4 = 3.2 GB samo za prvo vozlišče MCTS. V najslabšem primeru bi to med raziskovanjem delujočih vozlišč max_rank (kjer je max_rank=150) povzročilo skupno porabo pomnilnika 150 * 3.2 GB = 480 GB v pomnilniku RAM (ali pomnilniku GPE, če bi bili vsi tenzorji shranjeni v GPE) . Usposabljanje smo izvajali na naši delovni postaji s 128 GB RAM-a in 48 GB GPU pomnilnika, zato smo morali zmanjšati porabo pomnilnika.
Since we didn't want to increase the execution time, we adopted an optimization that exploits the redundancy in the state tensors produced. In fact, the tensors have n-1 previous actions in common, which can then be stored once and not repeated for each stored tensor. This results in a memory reduction of 2/7~28%, meaning that in the worst-case 137GB can be stored. At this point, by simply pruning the unused part of the tree (such as the unselected trajectories) and storing the tensors in CPU memory, we were able to avoid any memory error during training.
Ker je OpenAlphaTensor zdaj odprtokoden, se odpira več razburljivih poti za nadaljnji razvoj.
Naraven napredek je fina nastavitev OpenAlphaTensor na ciljnih napravah strojne opreme. Pričakuje se, da bo to vodilo do zelo konkurenčne računalniške zmogljivosti. Objavil bom več o delovanju OpenAlphaTensor na različni strojni opremi GitHub. V času pisanja tega članka je bil OpenAlphaTensor na usposabljanju.
Drug pomemben napredek bi bila podpora za oddaljeno kompilacijo, ki bi uporabnikom omogočala izdelavo algoritmov, optimiziranih za robne naprave. To je mogoče doseči s shranjevanjem modela OpenAlphaTensor na strežnik, medtem ko se algoritem množenja matrike ovrednoti na drugi strojni opremi.
Prav tako bi lahko bilo pomembno razširiti podporo za različne prevajalnike za izračun popravka nagrade na podlagi zakasnitve. Različni prevajalniki lahko vodijo do različnih optimiziranih algoritmov na določeni strojni opremi. Dokument DeepMind je na primer pokazal obetavne rezultate z uporabo prevajalnika JAX in XLA na grafičnih procesorjih TPU in Nvidia. Zanimivo bi bilo to oceniti z uporabo NCCL na Nvidia ali LLVM na CPU.
Nazadnje, razširitev modela in algoritma za usposabljanje za podporo večjih velikosti matrik ostaja velik odprt izziv. Trenutno OpenAlphaTensor podpira največjo velikost matrike 5, vendar ga je mogoče uporabiti z razdelitvijo večjih množenj matrike v skupine majhnih MM z velikostjo, manjšo od 5. Ta pristop ni optimalen in izvaja redukcijo neposredno na velikem tenzorju, ki ustreza popolna MM bi lahko teoretično vodila do boljših rezultatov.
Diego Fiori is the CTO of Nebuly AI, a company committed to making AI optimization part of every developer's toolkit.
- Distribucija vsebine in PR s pomočjo SEO. Okrepite se še danes.
- Platoblockchain. Web3 Metaverse Intelligence. Razširjeno znanje. Dostopite tukaj.
- vir: https://www.kdnuggets.com/2023/03/first-open-source-implementation-deepmind-alphatensor.html?utm_source=rss&utm_medium=rss&utm_campaign=first-open-source-implementation-of-deepminds-alphatensor
- : je
- ][str
- $GOR
- 1
- 3d
- 8
- a
- Sposobna
- O meni
- nad
- absolutna
- pospeševanje
- Po
- ustrezno
- Račun
- natančnost
- Doseči
- doseže
- Ukrep
- dejavnosti
- dejansko
- dodano
- Dodatne
- Prilagojen
- sprejet
- napredovanje
- Prednost
- po
- Agent
- združevanje
- agresivni
- AI
- AI sistemi
- Cilje
- algoritem
- algoritmi
- vsi
- Dovoli
- omogoča
- sam
- že
- alternativa
- med
- znesek
- analizirati
- in
- Še ena
- uporabna
- pristop
- pristopi
- Arhitektura
- SE
- članek
- umetni
- Umetna inteligenca
- AS
- dodeljena
- povezan
- At
- Avtomatizirano
- Na voljo
- izogibanje
- nazaj
- backup
- temeljijo
- V bistvu
- Osnova
- BE
- ker
- postane
- pred
- počutje
- spodaj
- merilo
- BEST
- Boljše
- med
- Poleg
- svet
- Namizne igre
- zavezuje
- širši
- BT
- izgradnjo
- zgrajena
- by
- se imenuje
- CAN
- ne more
- primeru
- Vzrok
- povzročilo
- nekatere
- izziv
- izziv
- spremenite
- Channel
- ChatGPT
- otrok
- izbira
- izbiri
- izbran
- praksa
- jasno
- jasno
- Koda
- zbira
- združujejo
- storjeno
- Skupno
- podjetje
- v primerjavi z letom
- konkurenčno
- kompleksna
- kompleksnost
- deli
- sestavljajo
- Kompromis
- računanje
- računska moč
- Izračunajte
- računalništvo
- koncepti
- Konceptualno
- stanje
- zaupanje
- Razmislite
- šteje
- upoštevamo
- meni
- poraba
- Vsebuje
- naprej
- kontrast
- pretvori
- Core
- Ustrezno
- ustreza
- bi
- Števec
- CPU
- ustvari
- Ustvarjanje
- Merila
- CTO
- Trenutna
- Trenutno
- datum
- deliti
- odloča
- odločil
- Odločitev
- Odločanje
- odločitve
- globoko
- globoko učenje
- Deepmind
- odvisno
- opisano
- Ugotovite,
- Razvojni
- Razvoj
- naprava
- naprave
- DICT
- drugačen
- Težave
- Dimenzije
- dimenzije
- neposredno
- odkriti
- odkrivanje
- razpravljali
- distribucija
- deljeno
- navzdol
- Drop
- med
- e
- vsak
- prej
- enostavno
- Edge
- Učinkovito
- učinkovite
- bodisi
- element
- elementi
- vgrajeni
- konča
- okrepljeno
- ogromno
- dovolj
- Vpis
- Napaka
- oceniti
- ocenjeni
- Eter (ETH)
- oceniti
- ocenili
- ocenjevanje
- vrednotenja
- Tudi
- Tudi vsak
- Primer
- Primeri
- zanimivo
- izvedba
- Širitev
- Pričakuje
- izkušnje
- Pojasnite
- razložiti
- izkorišča
- raziskovanje
- raziskuje
- Raziskano
- Raziskovati
- izražena
- razširiti
- razširitev
- izredno
- pošteno
- družina
- hitreje
- povratne informacije
- Nekaj
- Slika
- končna
- iskanje
- prva
- Plavaj
- Osredotočite
- sledi
- po
- Odtis
- za
- obrazec
- format
- Formula
- je pokazala,
- iz
- polno
- funkcija
- temeljna
- nadalje
- nadaljnji razvoj
- Prihodnost
- igra
- Games
- ustvarjajo
- ustvarila
- ustvarja
- ustvarjajo
- dobili
- pridobivanje
- Daj
- dana
- Giving
- Cilj
- goes
- dobro
- GPU
- Grafične kartice
- graf
- veliko
- skupina
- Skupine
- raste
- Rast
- vodi
- strani
- Ravnanje
- se je zgodilo
- se zgodi
- strojna oprema
- strojna naprava
- strojne naprave
- Imajo
- ob
- tukaj
- najvišja
- obzorje
- Kako
- Kako
- Vendar
- HTTPS
- velika
- človeškega
- i
- Bom
- idealen
- idx
- slika
- vpliv
- izvajati
- Izvajanje
- Pomembno
- izboljšanje
- izboljšalo
- in
- Povečajte
- Poveča
- vedno
- Neodvisni
- Indeks
- Podatki
- začetna
- vhod
- Namesto
- Navodila
- Intelligence
- Zanimivo
- notranji
- Uvedeno
- intuicija
- IT
- ponovitev
- ITS
- sam
- jpg
- KDnuggets
- Imejte
- Ključne
- znanje
- znano
- jezik
- velika
- večja
- Zadnja
- Latenca
- Zadnji
- plast
- plasti
- vodi
- naučili
- učenje
- Seznam
- Poglej
- si
- Sklop
- je
- Glavne
- velika
- Znamka
- Izdelava
- upravljanje
- upravljanje
- več
- map
- kartiranje
- Matrix
- Matter
- največja
- kar pomeni,
- smiselna
- pomeni
- član
- Spomin
- Metoda
- Metode
- meritev
- manjka
- mešanico
- Model
- modeli
- spremembe
- modul
- več
- učinkovitejše
- Poleg tega
- Najbolj
- premikanje
- premika
- pomnoži
- naravna
- Narava
- Blizu
- potrebno
- Nimate
- potrebna
- negativna
- omrežij
- Nevronski
- nevronske mreže
- Novo
- Naslednja
- nlp
- Vozel
- vozlišča
- nestrokovnjaki
- Pojem
- Številka
- Nvidia
- pridobljeni
- of
- Ponudbe
- on
- ONE
- odprite
- open source
- OpenAI
- Delovanje
- operacije
- optimalna
- optimizacija
- Optimizirajte
- optimizirana
- možnosti
- izvirno
- Ostalo
- drugače
- izhod
- Splošni
- Papir
- članki
- parameter
- del
- zlasti
- zlasti
- deli
- ljudje
- popolna
- performance
- izvajati
- faza
- kosov
- platon
- Platonova podatkovna inteligenca
- PlatoData
- Predvajaj
- predvajalnik
- igranje
- Točka
- politike
- politika
- Stališče
- mogoče
- potencial
- moč
- Praktično
- praksa
- napovedati
- napovedano
- nastavitve
- predstavljeni
- prejšnja
- verjetnost
- verjetno
- problem
- Postopek
- Procesi
- proizvodnjo
- Proizvedeno
- Izdelek
- napredovanje
- postopno
- obetaven
- predlagano
- dokazljivo
- dokazano
- objavijo
- objavljeno
- RAM
- naključno
- uvršča
- precej
- dosegel
- Doseže
- Pred kratkim
- zmanjša
- Zmanjšana
- zmanjšanje
- rafinirano
- okrepljeno učenje
- sprosti
- Preostalih
- ostanki
- izjemno
- ne pozabite
- daljinsko
- ponovi
- predstavlja
- predstavlja
- obvezna
- zahteva
- odgovorna
- omejeno
- povzroči
- rezultat
- Rezultati
- vrnitev
- vrne
- revolucijo
- Nagrada
- ROW
- rt
- Run
- s
- Enako
- Shrani
- shranjevanje
- Scenarij
- scenariji
- shema
- Iskalnik
- drugi
- Oddelek
- seme
- izbran
- izbiranje
- izbor
- SAMO
- nastavite
- nastavitev
- več
- Oblikujte
- delitev
- Kratke Hlače
- shouldnt
- Prikaži
- pokazale
- Razstave
- Signal
- pomemben
- bistveno
- Podoben
- podobnosti
- Enostavno
- preprostost
- preprosto
- Simulacija
- saj
- Razmere
- Velikosti
- velikosti
- majhna
- manj
- Posnetek
- So
- Rešitev
- SOLVE
- Reševanje
- nekaj
- vir
- Vesolje
- prostori
- specifična
- posebej
- določeno
- hitrost
- preživeti
- Poraba
- po delih
- kvadrat
- zloženi
- Stage
- standardna
- Začetek
- začne
- Država
- state-of-the-art
- navedla
- Države
- Statistika
- Korak
- Koraki
- ustavljanje
- trgovina
- shranjeni
- trgovine
- naravnost
- uspešno
- taka
- podpora
- Podpira
- sintetična
- sintetični podatki
- sintetično
- sistem
- sistemi
- prilagojene
- Bodite
- meni
- ob
- ciljna
- Naloga
- Naloge
- tehnike
- terminal
- Pogoji
- da
- O
- Prihodnost
- Graf
- informacije
- Država
- njihove
- Njih
- s tem
- zato
- te
- tretja
- 3
- Tridimenzionalni
- skozi
- čas
- zamudno
- do
- skupaj
- žeton
- Tokenizacija
- tokenizirano
- Boni
- tudi
- Orodje
- vrh
- baklo
- Skupaj za plačilo
- tradicionalna
- Vlak
- usposobljeni
- usposabljanje
- vlaki
- usmeritev
- preoblikovati
- zdravljenje
- Res
- razumeli
- Vesolje
- neuporabljeno
- Nadgradnja
- posodobljeno
- posodobitve
- posodabljanje
- nadgradnja
- us
- Uporaba
- uporaba
- Uporabniki
- navadno
- vrednost
- Vrednote
- različnih
- različica
- Video
- video igre
- obisk
- Obiskov
- W
- način..
- Kaj
- ki
- medtem
- pogosto
- Wikipedia
- bo
- zmago
- z
- besede
- delovno mesto
- vredno
- bi
- pisanje
- pisni
- X
- zefirnet
- nič