Foto: Deepmind on Unsplash
Maatrikskorrutamine on põhiline toiming, mida kasutatakse paljudes süsteemides, alates närvivõrkudest kuni teadusliku andmetöötluse rutiinideni. Tõhusate ja tõestatavalt õigete algoritmide leidmine maatriksi korrutamiseks võib avaldada tohutut mõju arvutamise kiiremaks ja tõhusamaks muutmisele, kuid see on väga keeruline ülesanne. Võimalike algoritmide ruum on tohutu ja traditsioonilised meetodid algoritmide avastamiseks, nagu inimese loodud heuristika või kombinatoorne otsing, on sageli ebaoptimaalsed.
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 AlfaZero. See agent on koolitatud mängima ühe mängijaga mängu TensorGame, mille eesmärk on leida maatriksi korrutamise arvutuslikult tõhusad algoritmid.
AlphaTensor on eriti hea suurte maatriksite käsitlemisel, jagades suured maatrikskorrutused väiksemateks korrutisteks. Lisaks saab AlphaTensorit kasutada maatriksi korrutamise tipptasemel jõudluse saavutamiseks, kui see on konkreetse riistvaraseadmega peenhäälestatud.
AlphaTensoril on suur potentsiaal süvaõppe andmetöötluse kiirendamiseks. Süvaõppes saab palju aeganõudvaid toiminguid kaardistada maatrikskorrutistega. Kasutades nende toimingute optimeerimiseks AlphaTensorit, saab süvaõppe mudelite üldist jõudlust oluliselt parandada.
Hiljuti OpenAlphaTensor, AlphaTensori esimene avatud lähtekoodiga rakendusilmus, mis võib muuta süvaõppe mudelite arvutusvõimsust.
Maatriksi korrutamise tensor
Maatriksi korrutamise optimeerimise mitteekspertidele ei pruugi olla lihtne aru saada, kuidas saab sellist toimingut nagu maatrikskorrutamist kaardistada kolmemõõtmelise tensoriga. Püüan seda seletada lihtsate sõnade ja näidetega.
Vaatleme korrutist C = A*B, kus lihtsuse mõttes on nii A kui ka B ruutmaatriksid suurusega N. Korrutustehte saab kaardistada kujundi 3D-tensoriga (N^2, N^2, N^2). Esimene tensori mõõde esindab lamestatud maatriksit A, teine mõõde lamestatud maatriksit B ja kolmas mõõde lamestatud maatriksit C.
Tensoril on iga kirje jaoks ainult kahendväärtused (kas 1 või 0). Pange tähele, et tensor tähistab korrutustehet, seega ei sõltu see maatriksite A ja B väärtustest.
Tensori iga kirje vastab tehte koefitsiendile. Näiteks C[1,1] arvutamiseks on vaja korrutada nii A[1,1] kui ka B[1,1]. Seetõttu on tensori kirje [0,0,0], mis vastab A[1,1], B[1,1] ja C[1,1] väärtustele 1. Seevastu C[1,1 arvutamiseks ,2,1], A[1] pole vaja. Seega sisaldab tensorida T[N+0, :, XNUMX] ainult nulle.
Alloleval pildil on näide tenosist, kui N=2.
Image from DeepMind's paber avaldatakse loodus
Nagu on näidatud ülaltoodud joonisel (b) ja (c), on võimalik rakendada algoritmi korrutise arvutamiseks, kasutades 3D-tensori lagunemist. Täpsemalt saab allolevat algoritmi kasutada tensori lagunemise (maatriksid U, V, W) teisendamiseks maatriksi korrutusalgoritmiks.
Meta-algorithm parameterized for computing the matrix product C=AB introduced in DeepMind's paber
TensorGame
Tõhusate maatriksikorrutamise algoritmide leidmise probleem on äärmiselt keeruline, kuna arvessevõetavate algoritmide arv on palju suurem kui universumi aatomite arv isegi väikeste maatriksikorrutamise juhtude korral.
DeepMind muutis selle probleemi ühe mängijaga mänguks ja nimetas selle TensorGame'iks. Selles mängus valib mängija, kuidas kombineerida erinevaid maatriksite kirjeid nende korrutamiseks. Hinne määratakse õige korrutamistulemuse saavutamiseks vajalike tehtete arvu alusel. Mäng lõpeb, kui nulltensor on saavutatud või kui on tehtud maksimaalne arv käike. Lõplikku faktoriseerimist hinnatakse jääkjärjestuse hinnangu ja teatud optimeerimiskriteeriumide, näiteks asümptootilise aja keerukuse või praktilise käitusaja põhjal.
TensorGame'i algpositsioon vastab maatriksi korrutamise tensorile, mis on väljendatud mingil juhuslikul alusel.
Mängu igas etapis t kirjutab mängija üles kolm vektorit
, mis määrab 1. järgu tensorid . Mängu olekut värskendatakse, lahutades mängija valitud vektorid:
kus
on maatriksi korrutamise tensor.Kui mäng lõpeb p sammuga, tähendab see, et maatriksi korrutamise tensor
saab lagundada p järgu-1 tensoriteks st sellel on vähemalt auaste p.TensorGame'i saab seejärel tõlgendada järgu jaotamise algoritmina ja AlphaTensorit võib vaadelda kui tensori järgu hindamise algoritmi.
AlphaTensori arhitektuur
Siiani oleme õppinud tundma TensorGame'i ja selgitanud, kuidas selle lahendust saab vaadelda maatrikskorrutusalgoritmina. Uurime nüüd mängus kasutatava algoritmi AlphaTensori põhikontseptsioone.
AlphaTensori arhitektuur on põhimõtteliselt kodeerija-dekoodri transformaatori arhitektuur, kus:
- kodeerija võtab sisendiks mängu oleku , mudeli poolt tehtud n varasemat tegevust (tavaliselt n=7) ja praeguse toimingu ajaindeks t. Teave on virnastatud tensorisse kujuga (n+1, N^2, N^2, N^2). Seejärel kujundatakse see tensor ümber ja teisendatakse (kasutades kolme lineaarset kihti) kuju tensoriks (N^2, N^2, c), kus c on mudeli sisemõõde.
- dekooder genereerib n_steps toimingud kodeerija antud manustatud vektorist autoregressiivsel viisil. Iga tegevus vastab kolmikute märgile esindab ühte kolmik, mis lagundab mängu tensorit (st vähendab selle järjestust)
Modelli treenitakse vaheldumisi tagasilevitamise ja modellinäitlemise teel. Mudeli toimimist kasutatakse andmete genereerimiseks, mida kasutatakse mudeli koolitamiseks. Praktikas treenitakse mudelit sünteetiliselt genereeritud andmete ja mudeli poolt tegutsemise käigus genereeritud andmete seguga. Näitlemise samm tehakse nii, et võetakse maatrikstehtele vastav 3D-tensor ja mängitakse sellel n_actors mänge. Iga näitleja mängib mängu kas standard- või alternatiivsetel alustel (aluse muutust rakendatakse etteantud tõenäosusega). Seejärel kogutakse tulemused kokku ja neid saab sünteetiliste andmetega treeningetapis kasutada.
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.
Modelli koolitamise ajal on tasu tegelikult negatiivne tasu (karistus). Selle absoluutväärtus suureneb iga mängu lahendamiseks vajaliku täiendava sammuga. Kui mudel võtab TensorGame'i lahendamiseks m sammu, on mänguga seotud tasu r=-m. Kui mudel ei suuda lahendada TensorGame'i max_rank sammudega, arvutatakse tasu allesjäänud tensori auastme hindamise teel. Astet hinnatakse tensori moodustavate maatriksite ridade summana. Hinnang on tensori tõelise järgu ülempiir.
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 λ on kasutaja määratud koefitsient.
GPU ja TPU jaoks kohandatud AlphaTensori avastatud algoritmide kiirendamised (%), mis on eraldatud DeepMindi paberist. Kiirendusi mõõdetakse standardse (nt GPU jaoks cuBLAS) maatriksi korrutamise suhtes samal riistvaral ja võrreldakse Strasseni ruudu algoritm. Allikas: Deepmind.
Vabanesin hiljuti OpenAlphaTensor, AlphaTensori esimene avatud lähtekoodiga rakendus. Selles jaotises käsitlen rakendamist. Nagu me varem arutasime, on AlphaTensori arhitektuur üsna lihtne, mis põhineb kodeerija-dekoodri arhitektuuriga standardtrafol. AlphaTensori kõige huvitavamad komponendid on kodeerija osa esimene kiht ja toimingute valimimise viis.
Alustame esimese kodeerimiskihiga.
# 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
Ülaltoodud lõigus näitame, kuidas sisendtensor jaotatakse kolmeks tensoriks, mida seejärel kasutatakse trafokihi päringu-, võtme- ja väärtussisenditena.
- Lamendatud maatriksite (A, B, C) kolme tensori dimensiooni ulatuses tasandatakse sisendtensor piki igat mõõdet koos eelmisi toiminguid tähistava mõõtmega. Sel viisil on igas sisendtensori lamestatud koopias valitud dimensioon viimaste T-1 väärtuste ja tegeliku väärtuse koondväärtus valitud dimensiooni kõigi S väärtuste jaoks, kus S=N^2. Filosoofiliselt keskendume justkui iga dimensiooni puhul sellele, mis toimus selles dimensioonis eelmistes tegevustes.
- Skalaarid kaardistatakse kolmes erinevas ruumis mõõtmetega S ^ 2 ja seejärel kujundatakse need ümber, et ühendada need eelmises punktis saadud tensoritega. Kontseptuaalselt vastendatakse skalaarid mõõtmega S^2 manustamisruumi ning seejärel jaotatakse manustatud teave S vektoriteks ja virnatakse kokku, sarnaselt sellele, mis juhtub tekstiga märgistamisel.
- Skalaarsed märgid ühendatakse restruktureeritud sisendtensoriga ja antakse seejärel sisendiks lineaarsele kihile skalaaride + kanali ajaloo fookuse teabe kaardistamiseks mudeli sisemises mõõtmes.
Neid kolme sammu saab tõlgendada kui viisi, kuidas anda mudelile nii teavet skalaaride kohta (nagu TensorGame'i ajaetapis) kui ka keskendumist iga kanali eelmistele toimingutele.
Seoses toimingute loomise viisiga on huvitav märkida, et AlphaTensor genereerib väljundina kolmiku u, v, w, mille eesmärk on vähendada tensoriastet. Kolm vektorit on suurusega S ja kuna need on ühendatud, peab mudel tootma vektori suurusega 3*S. AlphaTensor on treenitud RL-algoritmiga, nii et kõik võimalikud toimingud peavad olema väljendatud tõenäosuste kujul loendatavas ruumis, st mudel toodab tõenäosuse erinevate tegevuste üle. See tähendab, et iga vektor 3S-ruumis tuleks vastendada erineva toiminguga. Selle tulemuseks on tegevusruum suurusega |F|^(3S), kus |F| on erinevate väärtuste arv, mille u, v, w element võib võtta. Tavaliselt on väärtused piiratud (-2, -1, 0, 1, 2), mille tulemuseks on 5 elemendi kardinaalsus.
Siin tuleb suur väljakutse: 5. suuruse maatriksite maatrikskorrutise tegevuse tõenäosuste genereerimiseks vajame 5^75 * 4 baiti suurust mälu, mis tähendaks ~10^44 GB mälu. On selge, et me ei saa nii suurt tegevusruumi hallata.
Kuidas me probleemi lahendame? Tegevuse tõenäosuste mälujälje vähendamiseks saame kolmikud jagada väiksemateks tükkideks, need "märgistada" ja käsitleda tükke trafo arhitektuuris genereeritud žetoonidena, st märgid antakse dekoodri sisendiks autoregressiivselt. tee. Ülaltoodud näites saame kolmikud jagada 15 tükiks, vähendades mälutarbimist 15 * 5^(75/15) * 4-ni ehk 187.5 KB-ni.
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), )
Eespool näitame koodilõiku täieliku toimingu genereerimiseks. Koodis sisaldab self.core dekoodri kihti ja tensor e tähistab kodeerija kihi väljundit. Nulli võib pidada Token NLP mudelites ja n_steps toimingud, mis esindavad n_steps tükke, genereeritakse järk-järgult.
Mudel tagastab kolm suurust:
- Loodud toimingud
- Täieliku tegevusega seotud tõenäosus
- Esimese toimingu (esimese tüki) genereerimiseks loodud logitid, mida kasutatakse mudeli väärtuse arvutamiseks.
Parameetrile n_samples tasub paar sõna kulutada. Parameetrit kasutatakse tegutsemisetapi jaoks ja see võimaldab mudelil genereerida kolmikute erinevaid versioone, mida seejärel kasutatakse tegevusruumi uurimiseks Monte Carlo puuotsingu algoritmis, mida kasutatakse tegutsemisprotsessis. Erinevate toimingute n_samples valimid valitakse vastavalt mudeli loodud poliitikale.
Näitleja samm
Kogu algoritmi kõige keerulisem osa on tõenäoliselt TensorGame'i lahendamiseks kasutatav tegutsemise samm. Algoritmi ei ole AlphaTensori dokumendis põhjalikult selgitatud, kuna see põhineb mitmel DeepMindi varasemal paberil, mis on lihtsalt tsiteeritud ja antud teadaolevana. Siin rekonstrueerin kõik puuduvad tükid ja selgitan samm-sammult meie rakendamist.
Näitlemise etapid saame korraldada kolmes erinevas komponendis:
- Monte-Carlo puuotsing
- Mängu simulatsioon
- Täiustatud poliitika arvutamine
Analüüsime neid ükshaaval.
Monte-Carlo puuotsing (MCTS)
Monte Carlo Tree Search (MCTS) on mängude mängimiseks laialdaselt kasutatav tehisintellekti tehnika, eriti lauamängudes ja videomängudes. Algoritm loob mängupuu, mis simuleerib võimalikke käike ja tulemusi ning kasutab juhuslikku valimit, et hinnata iga käigu eest oodatavat tasu. Algoritm valib seejärel iteratiivselt suurima oodatava tasuga käigu ja simuleerib tulemusi, kuni see jõuab lõppolekusse või määratud peatumistingimusse. Simulatsioone kasutatakse iga käigu võidu tõenäosuse hindamiseks ja otsustusprotsessi suunamiseks. MCTS on osutunud tõhusaks keerulistes mängudes, kus võimalike käikude ja tulemuste arv on suur, ning seda on kasutatud edukates mängude tehisintellektisüsteemides, nagu AlphaGo.
AlphaTensoris kasutatakse algse MCTS-i muudetud versiooni. Täpsemalt, selle asemel, et tegevust kogu tegevusruumist juhuslikult valida, valitakse toiming mudeli poolt otse genereeritud alamhulga hulgast (eelpool esitatud n_samples kaudu). Seejärel rakendatakse poliitika täienduse parandus sammus Täiustatud poliitika arvutamine.
Meie juurutamisel otsustasime säilitada kogu teabe Monte-Carlo puu kohta sõnastikus, mille võtmeks on TensorGame'i oleku räsiversioon ja väärtustena olekuga seotud teave. Iga Monte-Carlo samm algab sõlmest ja simuleerib n_sim minimänge, uurides tulevikku 5 käiguga. Kui sõlme on eelmistes simulatsioonides juba uuritud, kohandatakse n_sim, võttes arvesse eelmiste uurimiste arvu. Iga sõlme külastuste arv salvestatakse tensorisse N_s_a, kuna see tensor sisaldab külastuste arvu sõlme alamtoimingu kohta (mudel nende hulgas).
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
Ülaltoodud kood näitab meie algoritmi rakendamist. Koodi lihtsuse huvides tehakse poliitika korrigeerimine funktsioonis simulate_game.
Mängu simulatsioon
Funktsioon simulate_game vastutab TensorGame'i konkreetset olekut esindavatest sõlmedest koosneva puu uurimise eest. Samuti käitab see mudelit iga kord, kui lehesõlme kohtab, ja salvestab kogu sõlmeteabe state_dict sõnastikku. Vaatame üksikasjalikult selle rakendamist:
@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)
Iga simulatsioon on jagatud kolmeks osaks:
- Valik
- Laiendamine
- Varundamine
Valikuosas käivitatakse simulatsioon juba loodud puusõlmedel ja järgmine sõlm valitakse järgmise funktsiooni abil:
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()]
Praktikas toiming, mis maksimeerib ucb funktsiooni:
antud oleku jaoks on valitud. Siin Q tähistab mudeli loodud Q väärtusi ja π tähistab juhuslikku jaotust mudelipoliitika abil valimiga valitud toimingute vahel. N(s, a) tähistab sõlme külastuste arvu toimingule a sõlmest s.
Kui valikufaas jõuab lehesõlmeni ja kui simulatsioon ei ole jõudnud lõppseisundisse (maksimaalse uurimise, st tulevikuhorisondi või mängu lõpu osas), kasutatakse mudelit n_samples alternatiivsete sõlmede valimiseks (need on leht sõlmed järjestikuses iteratsioonis). Seda nimetatakse laiendusfaasiks, kuna puule lisatakse uued sõlmed. Seejärel ei uurita praeguses simulatsioonis enam ühtegi sõlme, vaid lehe q_väärtus saadetakse järgmisele simulatsioonietapile: varukoopia.
Varundamine on iga simulatsiooni viimane etapp. Varundamise ajal, kui lehe sõlm oli terminali olek, arvutatakse lõplik tasu; vastasel juhul kasutatakse hinnangulise tasuna lehe q väärtust. Seejärel levitatakse tasu simulatsioonitrajektooril tagasi, värskendades nii olekuid q_values kui ka külastusloendurit N(s, a). Allolevas koodilõigul näitame preemia tagasilevimise koodi.
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
Täiustatud poliitika arvutamine
Kui kõik simulatsioonid on läbi viidud ja MCTS pakub huvitavat hetkepilti lähitulevikust, on aeg uuendada prognoositud sõlmedega seotud poliitikat ja need tagastada, et neid saaks treeningu ajal kasutada. Täiustatud poliitika, järgides punktis kirjeldatud meetodit Hubert et al, kasutatakse suurte tegevusruumide haldamiseks. Tegelikult on väikese otsinguruumi puhul MCTS-i ajal võimalik tegevusruumist juhuslikult proov võtta ja hinnata selle mõju. Sarnane lähenemine palju suuremas tegevusruumis tooks kaasa selle, et kõik trajektoorid lahknevad erinevatel radadel ning vajaks sisuka statistika saamiseks ja seejärel poliitika ajakohastamiseks lõpmatult palju trajektoore. Kuna siin kasutame dispersiooni vältimiseks näidis-MCTS-i, st n_samples toimingud valitakse vastavalt mudelipoliitikale ja seejärel valib MCTS lihtsalt puu uurimisel ühe valimi toimingutest, peame arvutamisel arvestama valimi parandusega. lõplik värskendatud poliitika, mida mudeli koolitamisel kasutatakse.
Praktikas arvutatakse täiustatud poliitika järgmiselt
kus
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
Pange tähele, et meie juurutamisel peame pärast poliitika arvutamist N_s_a tensorist vastandama selle tagasi algsele tegevustensorile. Tegelikult arvestab N_s_a lihtsalt mudeliga valitud toiminguid, samas kui lõplik poliitika peab sisaldama tõenäosusi ka uurimata toimingute jaoks.
Erinevused seoses ChatGPT koolitusalgoritmiga
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 on peenhäälestustehnika, mida kasutatakse keelemudelite häälestamiseks kirjalike juhiste järgi. See kasutab mudeli peenhäälestamiseks preemiasignaalina inimeste eelistusi, viies keelemudeli käitumise vastavusse konkreetse inimrühma väljakuulutatud eelistustega, mitte mingi laiema „inimväärtuste” mõistega.
Seevastu MCTS on puupõhine otsingualgoritm, mida kasutatakse mängude optimaalsete käikude määramiseks. See simuleerib võimalikke liigutusi ja värskendab iga käigu väärtusi vastavalt nende tulemustele, suunates parima käigu valiku.
RLHF kogub andmeid inimeste kirjutatud demonstratsioonidest ja tehisintellekti mudelite inimeste märgistatud võrdlustest ning treenib tasumudelit, et ennustada teatud inimrühma eelistusi. Seejärel kasutatakse tasu mudelit tehisintellekti mudelite viimistlemiseks. MCTS seevastu kasutab parima otsuse tegemiseks simulatsioone ja hindamisi.
Kuigi need on erinevad lähenemisviisid, on RLHF-il ja MCTS-il ka sarnasusi. Mõlemad tehisintellekti tehnikad kasutavad otsustus- ja probleemide lahendamise meetodeid ning mõlemad kasutavad katse-eksituse meetodit, et uurida erinevaid võimalusi ja teha otsuseid olemasoleva teabe põhjal. Mõlemad on ka iteratiivsed protsessid, mis aja jooksul paranevad, kui kogutakse rohkem teavet ja kogemusi.
Valik RLHF ja MCTS vahel sõltub käsilolevast ülesandest. RLHF on ideaalne, kui mudeli jõudluse hindamiseks pole selget mõõdikut, samas kui MCTS on osutunud tõhusaks mängulaadsetes ülesannetes, kus teadmised ja tuleviku uurimine annavad mudelile olulise eelise.
Koodi optimeerimine AlphaTensor treeningu jaoks
Treeningalgoritmi AlphaTensor rakendamine nõuab täiusliku kompromissi leidmist treeningkiiruse ja mälukulu vahel. Nagu on näha jaotises Mudel, võib lihtsalt toimingu tokeniseerimise arvessevõtmine säästa palju mälu, kuid liiga agressiivne tegevusruumi vähendamine võib põhjustada nii täpsuse languse kui ka aeglasema jõudluse. Viimane juhtub seetõttu, et mudeli dekooder genereerib kõik märgid järjestikku autoregressiivsel viisil. Seetõttu kasvab järeldusaeg lineaarselt märkide arvuga toimingu kohta, kui tegevusruumi softmax ei ole enam kitsaskoht.
AlphaTensori koolituse üles seadmisel leiti peamised raskused näitlejaprotsessiga toimetulekul. Kui tensoreid ei salvestata õiges vormingus, võib MCTS kergesti põhjustada kontrollimatut mälukasutuse kasvu. Teisest küljest, kui iga simulatsiooni ajal salvestatud tensorite arvu vähendatakse liiga palju, võib MCTS kulutada lõputult palju aega vajalike olekute ümberarvutamiseks.
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 baiti iga graafiku sõlme kohta. Arvestades nüüd, et iga simulatsioon laiendusfaasis genereerib uue sõlme (ja n_sim=200), oleks meil lõplik mälutarbimine 200328252525*4 = 3.2 GB ainuüksi esimese MCTS-sõlme jaoks. Halvima stsenaariumi korral põhjustaks see toimivate max_rank sõlmede uurimisel (kus max_rank = 150) RAM-mälus (või GPU mälus, kui kõik tensorid salvestataks GPU-le) mälu kokku 150 * 3.2 GB = 480 GB. . Läbisime koolituse oma tööjaamas 128 GB muutmälu ja 48 GB GPU mäluga, seega pidime mälukulu vähendama.
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.
Kuna OpenAlphaTensor on nüüd avatud lähtekoodiga, avaneb mitmeid põnevaid võimalusi edasiseks arendamiseks.
Loomulik areng on OpenAlphaTensori peenhäälestus sihtriistvaraseadmetel. Eeldatakse, et see toob kaasa väga konkurentsivõimelise arvutustulemuse. Avaldan rohkem OpenAlphaTensori toimivuse kohta erineval riistvaral GitHub. Selle artikli kirjutamise ajal oli OpenAlphaTensor koolitusel.
Teine oluline edasiminek oleks kaugkompileerimise tugi, mis võimaldab kasutajatel luua servaseadmete jaoks optimeeritud algoritme. Seda saab saavutada OpenAlphaTensori mudeli serverisse salvestamisega, samal ajal kui maatriksi korrutamisalgoritmi hinnatakse erineval riistvaral.
Samuti võib olla oluline laiendada erinevate kompilaatorite tuge, et arvutada latentsuspõhine tasu parandus. Erinevad kompilaatorid võivad teatud riistvara jaoks viia erinevate optimeeritud algoritmideni. Näiteks DeepMindi paber näitas paljutõotavaid tulemusi, kasutades JAX-i ja XLA-kompilaatorit TPU ja Nvidia GPU-del. Oleks huvitav seda hinnata, kasutades NCCL-i Nvidias või LLVM-i protsessoritel.
Lõpuks jääb suureks avatud väljakutseks mudeli ja koolitusalgoritmi laiendamine suuremate maatriksisuuruste toetamiseks. Praegu toetab OpenAlphaTensor maatriksi maksimaalset suurust 5, kuid seda saab rakendada, jagades suuremad maatriksikorrutused väikesteks MM-ide rühmadeks, mille suurus on väiksem kui 5. See lähenemine on ebaoptimaalne ja teostab redutseerimise otse suurel tensoril, mis vastab täielik MM võib teoreetiliselt viia paremate tulemusteni.
Diego Fiori is the CTO of Nebuly AI, a company committed to making AI optimization part of every developer's toolkit.
- SEO-põhise sisu ja PR-levi. Võimenduge juba täna.
- Platoblockchain. Web3 metaversiooni intelligentsus. Täiustatud teadmised. Juurdepääs siia.
- Allikas: 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
- :on
- ][lk
- $ UP
- 1
- 3d
- 8
- a
- Võimalik
- MEIST
- üle
- absoluutne
- kiirendades
- Vastavalt
- vastavalt
- konto
- täpsus
- Saavutada
- saavutada
- tegevus
- meetmete
- tegelikult
- lisatud
- Täiendavad lisad
- Kohandatud
- vastu
- edendama
- ADEelis
- pärast
- Agent
- koondamine
- agressiivne
- AI
- Tehisintellekti süsteemid
- Eesmärgid
- algoritm
- algoritme
- Materjal: BPA ja flataatide vaba plastik
- Lubades
- võimaldab
- üksi
- juba
- alternatiiv
- vahel
- summa
- analüüsima
- ja
- Teine
- rakendatud
- lähenemine
- lähenemisviisid
- arhitektuur
- OLEME
- artikkel
- kunstlik
- tehisintellekti
- AS
- määratud
- seotud
- At
- Automatiseeritud
- saadaval
- vältides
- tagasi
- Varundamine
- põhineb
- Põhimõtteliselt
- alus
- BE
- sest
- muutub
- enne
- on
- alla
- võrrelda
- BEST
- Parem
- vahel
- Peale
- juhatus
- Lauamängud
- seotud
- laiem
- BT
- ehitama
- ehitatud
- by
- kutsutud
- CAN
- ei saa
- juhul
- Põhjus
- põhjustatud
- kindel
- väljakutse
- raske
- muutma
- Kanal
- ChatGPT
- laps
- valik
- valimine
- valitud
- Tsiteeritud
- selge
- selgelt
- kood
- kogub
- ühendama
- toime pandud
- ühine
- ettevõte
- võrreldes
- konkurentsivõimeline
- keeruline
- keerukus
- komponendid
- koostatud
- kompromiss
- arvutamine
- arvutusjõud
- Arvutama
- arvutustehnika
- mõisted
- Kontseptuaalselt
- seisund
- usaldus
- Arvestama
- kaaluda
- arvestades
- arvab
- tarbimine
- sisaldab
- jätkama
- kontrast
- ümber
- tuum
- Vastav
- vastab
- võiks
- Võidelda
- Protsessor
- loob
- loomine
- kriteeriumid
- CTO
- Praegune
- Praegu
- andmed
- tegelema
- otsustama
- otsustatud
- otsus
- Otsuse tegemine
- otsused
- sügav
- sügav õpe
- Deepmind
- sõltub
- kirjeldatud
- Määrama
- arendaja
- & Tarkvaraarendus
- seade
- seadmed
- DIKT
- erinev
- raskusi
- mõõde
- mõõdud
- otse
- avastama
- avastades
- arutatud
- jaotus
- jagatud
- alla
- Drop
- ajal
- e
- iga
- Ajalugu
- kergesti
- serv
- Tõhus
- tõhus
- kumbki
- element
- elemendid
- varjatud
- lõppeb
- tõhustatud
- tohutu
- piisavalt
- kanne
- viga
- hinnata
- Hinnanguliselt
- Eeter (ETH)
- hindama
- hinnatud
- hindamine
- hindamised
- Isegi
- Iga
- näide
- näited
- põnev
- täitmine
- laiendamine
- oodatav
- kogemus
- Selgitama
- selgitas
- ärakasutamine
- uurimine
- uurima
- uurida
- Avastades
- väljendatud
- laiendama
- laiendades
- äärmiselt
- õiglaselt
- pere
- kiiremini
- tagasiside
- vähe
- Joonis
- lõplik
- leidmine
- esimene
- Float
- Keskenduma
- järgima
- Järel
- Jalajälg
- eest
- vorm
- formaat
- valem
- avastatud
- Alates
- täis
- funktsioon
- põhiline
- edasi
- edasine areng
- tulevik
- mäng
- Mängud
- tekitama
- loodud
- genereerib
- teeniva
- saama
- saamine
- Andma
- antud
- andmine
- eesmärk
- Goes
- hea
- GPU
- GPU
- graafik
- suur
- Grupp
- Grupi omad
- Kasvab
- Kasv
- suunata
- käsi
- Käsitsemine
- juhtus
- juhtub
- riistvara
- riistvaraseade
- riistvaraseadmed
- Olema
- võttes
- siin
- kõrgeim
- silmapiir
- Kuidas
- Kuidas
- aga
- HTTPS
- tohutu
- inim-
- i
- Ma teen
- ideaalne
- idx
- pilt
- mõju
- rakendada
- täitmine
- oluline
- parandama
- paranenud
- in
- Suurendama
- Tõstab
- üha rohkem
- sõltumatud
- indeks
- info
- esialgne
- sisend
- selle asemel
- juhised
- Intelligentsus
- huvitav
- sisemine
- sisse
- intuitsioon
- IT
- iteratsioon
- ITS
- ise
- jpg
- KDnuggets
- hoidma
- Võti
- teadmised
- teatud
- keel
- suur
- suurem
- viimane
- Hilinemine
- hiljemalt
- kiht
- kihid
- viima
- õppinud
- õppimine
- nimekiri
- Vaata
- otsin
- Partii
- tehtud
- põhiline
- peamine
- tegema
- Tegemine
- juhtima
- juhtiv
- palju
- kaart
- kaardistus
- maatriks
- küsimus
- maksimaalne
- tähendus
- tähendusrikas
- vahendid
- liige
- Mälu
- meetod
- meetodid
- meetriline
- puuduvad
- segu
- mudel
- mudelid
- modifitseeritud
- moodul
- rohkem
- tõhusam
- Pealegi
- kõige
- liikuma
- käike
- korrutatakse
- Natural
- loodus
- Lähedal
- vajalik
- Vajadus
- vaja
- negatiivne
- võrgustikud
- Neural
- närvivõrgud
- Uus
- järgmine
- nlp
- sõlme
- sõlmed
- mitteeksperdid
- Mõiste
- number
- Nvidia
- saadud
- of
- Pakkumised
- on
- ONE
- avatud
- avatud lähtekoodiga
- OpenAI
- töö
- Operations
- optimaalselt
- optimeerimine
- optimeerima
- optimeeritud
- Valikud
- originaal
- Muu
- muidu
- väljund
- üldine
- Paber
- dokumendid
- parameeter
- osa
- eriline
- eriti
- osad
- Inimesed
- täiuslik
- jõudlus
- esitades
- faas
- tükki
- Platon
- Platoni andmete intelligentsus
- PlatoData
- mängima
- mängija
- mängimine
- Punkt
- Poliitika
- poliitika
- positsioon
- võimalik
- potentsiaal
- võim
- Praktiline
- tava
- ennustada
- ennustada
- eelistusi
- esitatud
- eelmine
- tõenäosus
- tõenäoliselt
- Probleem
- protsess
- Protsessid
- tootma
- Toodetud
- Toode
- progressioon
- progressiivne
- paljutõotav
- pakutud
- tõestatavalt
- tõestatud
- avaldama
- avaldatud
- RAM
- juhuslik
- auastmed
- pigem
- jõudis
- Jõuab
- hiljuti
- vähendama
- Lühendatud
- vähendamine
- puhastatud
- tugevdamise õppimine
- vabastatud
- ülejäänud
- jäänused
- tähelepanuväärne
- meeles pidama
- kauge
- korduv
- esindavad
- esindab
- nõutav
- Vajab
- vastutav
- piiratud
- kaasa
- tulemuseks
- Tulemused
- tagasipöördumine
- Tulu
- murranguliseks muuta
- Premeerima
- ROW
- rt
- jooks
- s
- sama
- Säästa
- säästmine
- stsenaarium
- stsenaariumid
- kava
- Otsing
- Teine
- Osa
- seeme
- väljavalitud
- valides
- valik
- SELF
- komplekt
- kehtestamine
- mitu
- kuju
- jagamine
- Lühike
- peaks
- näitama
- näidatud
- Näitused
- Signaali
- märkimisväärne
- märgatavalt
- sarnane
- sarnasused
- lihtne
- lihtsus
- lihtsalt
- simuleerimine
- alates
- olukord
- SUURUS
- suurused
- väike
- väiksem
- Snapshot
- So
- lahendus
- LAHENDAGE
- Lahendamine
- mõned
- allikas
- Ruum
- tühikud
- konkreetse
- eriti
- määratletud
- kiirus
- kulutama
- Kulutused
- jagada
- ruut
- laotud
- Stage
- standard
- algus
- algab
- riik
- modernne
- väljendatud
- Ühendriigid
- statistika
- Samm
- Sammud
- peatumine
- salvestada
- ladustatud
- kauplustes
- lihtne
- edukas
- selline
- toetama
- Toetab
- sünteetiline
- sünteetilised andmed
- sünteetiliselt
- süsteem
- süsteemid
- kohandatud
- Võtma
- võtab
- võtmine
- sihtmärk
- Ülesanne
- ülesanded
- tehnikat
- terminal
- tingimused
- et
- .
- Tulevik
- Graafik
- teave
- Riik
- oma
- Neile
- sellega
- seetõttu
- Need
- Kolmas
- kolm
- kolmemõõtmeline
- Läbi
- aeg
- aega võttev
- et
- kokku
- sümboolne
- Tokeniseerimine
- märgistatud
- märgid
- liiga
- Käsiraamat
- ülemine
- tõrvik
- Summa
- traditsiooniline
- Rong
- koolitatud
- koolitus
- rongid
- trajektoor
- ümber
- käsitlema
- tõsi
- mõistma
- Universum
- kasutamata
- Värskendused
- ajakohastatud
- Uudised
- ajakohastamine
- upgrade
- us
- Kasutus
- kasutama
- Kasutajad
- tavaliselt
- väärtus
- Väärtused
- eri
- versioon
- Video
- Videomängude
- visiit
- Külastusi
- W
- Tee..
- M
- mis
- kuigi
- laialdaselt
- Wikipedia
- will
- võit
- koos
- sõnad
- töökoht
- väärt
- oleks
- kirjutamine
- kirjalik
- X
- sephyrnet
- null