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.
DeepmindNedavno predlagana rešitev za avtomatizirano iskanje, ki temelji na umetni inteligenci, daleč presega človeško intuicijo. Rešitev je sestavljena iz agenta za globoko krepitev učenja, imenovanega AlphaTensor, zgrajenega na vrhu 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.
Slika iz DeepMinda 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.
Metaalgoritem, parametriziran za izračun matričnega produkta C=AB, predstavljen v 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.
Igralni korak temelji na AlphaZero's Monte Carlo Tree Search (MCTS), spremenjenem za podporo velikih akcijskih prostorov. Skratka, pred izbiro dejanja se poti n_sims raziščejo iz izhoda modela z največ 5 koraki prihodnjega raziskovanja. Verjetnosti, ki jih ustvari model, se nato prilagodijo ob upoštevanju ustvarjenih poti. Nato se za nadaljevanje igre izbere dejanje z najbolj obetavno potjo(-ami) v prihodnost.
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.
Pri natančnem prilagajanju modela mora kazenska nagrada v stanju terminala upoštevati tudi zakasnitev algoritma, ki ga ustvari model. Formula za nagrajevanje postane rt'=rt+λbt, kjer je rt prej opisana shema nagrajevanja, bt primerjalna nagrada (različna od nič samo v končnem stanju) in λ 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 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[3] actions = state_dict[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 je najnovejši član družine metod umetne inteligence AlphaGo/AlphaZero podjetja DeepMind. Te metode temeljijo na algoritmu Monte Carlo Tree Search (MCTS), ki ga je DeepMind izpopolnil in izboljšal za reševanje vedno bolj zapletenih nalog. Drug sistem umetne inteligence, OpenAI's ChatGPT, ki je povzročil veliko hrupa zaradi svoje izjemne zmogljivosti, je bil usposobljen z drugačnim pristopom, imenovanim 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.
Vzemimo primer koraka simulacije igre, kjer se igra raziskuje s pregledovanjem možnih prihodnjih scenarijev. Če za vsako stanje ne shranimo dejanj, ki jih je ustvaril model, in se odločimo shraniti samo naključno seme, uporabljeno za vzorčenje dejanj iz pravilnika, bi morali vsakič, ko raziščemo vozlišče drevesa, znova izračunati pravilnik in nato poskusite dejanja. Jasno je, da smo se odločili shraniti vzorčena dejanja, da bi prihranili čas in se izognili upravljanju souporabe modela med različnimi procesi v primeru paralelizacije raziskovanja MCTS. Vendar samo shranjevanje dejanj ni bilo dovolj, da bi dobili dovolj učinkovit igralski korak. Pravzaprav bi bil čas za pretvorbo dejanj n_steps v triplet (u, v, w), zmanjšanje stanja tenzorja igre in ustvarjanje novih 3D tenzorjev iz dejanj n_samples zlahka ozko grlo za celotno usposabljanje. Drugič, nismo želeli shraniti vseh možnih prihodnjih stanj za vsako vzorčeno dejanje, saj bi to imelo velik vpliv na pomnilnik, ki ga uporablja algoritem. Recimo, da smo nastavili n_samples=32, n=7 in N=5, in zapomnimo si, da je N velikost produkta kvadratne matrike, ki ga želimo zmanjšati, in n število prejšnjih dejanj, ki si jih je zapomnil model. V tej situaciji bi imel vsak tenzor stanja obliko (8, 25, 25, 25), kar bi pomnoženo z 32 dalo 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.
Ker nismo želeli povečati časa izvajanja, smo sprejeli optimizacijo, ki izkorišča redundanco v proizvedenih tenzorjih stanja. Pravzaprav imajo tenzorji n-1 skupnih prejšnjih dejanj, ki jih je mogoče shraniti enkrat in se ne ponavljajo za vsak shranjen tenzor. Rezultat tega je zmanjšanje pomnilnika za 2/7~28 %, kar pomeni, da je v najslabšem primeru mogoče shraniti 137 GB. Na tej točki smo se s preprostim obrezovanjem neuporabljenega dela drevesa (kot so neizbrane trajektorije) in shranjevanjem tenzorjev v pomnilnik CPE lahko izognili kakršni koli napaki v spominu med usposabljanjem.
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 je tehnični direktor podjetja Nebuly AI, podjetja, ki se zavzema za to, da postane optimizacija AI del kompleta orodij vsakega razvijalca.
- 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č