Kuva Deepmind on Unsplash
Matriisikertominen on perustoiminto, jota käytetään monissa järjestelmissä hermoverkoista tieteellisiin laskentarutiineihin. Tehokkaiden ja todistettavasti oikeiden algoritmien löytämisellä matriisikertolaskulle voi olla valtava vaikutus laskennan tekemiseen nopeammaksi ja tehokkaammaksi, mutta se on erittäin haastava tehtävä. Mahdollisten algoritmien tila on valtava, ja perinteiset algoritmien löytämismenetelmät, kuten ihmisen suunnittelema heuristiikka tai kombinatorinen haku, ovat usein epäoptimaalisia.
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 alfanolla. Tämä agentti on koulutettu pelaamaan yksinpeliä, TensorGamea, jossa tavoitteena on löytää laskennallisesti tehokkaita algoritmeja matriisin kertomiseen.
AlphaTensor on erityisen hyvä käsittelemään suuria matriiseja jakamalla suuret matriisikertoimet pienemmiksi kertolaskuiksi. Lisäksi AlphaTensorilla voidaan saavuttaa huippuluokan suorituskyky matriisin kertomisessa, kun se on hienosäädetty tietyllä laitteistolla.
AlphaTensorilla on suuret mahdollisuudet nopeuttaa syvän oppimisen tietojenkäsittelyä. Syväoppimisessa monia aikaa vieviä operaatioita voidaan kartoittaa matriisikertoiksi. Käyttämällä AlphaTensoria näiden toimintojen optimointiin, syväoppimismallien yleistä suorituskykyä voidaan parantaa merkittävästi.
Äskettäin OpenAlphaTensor, AlphaTensorin ensimmäinen avoimen lähdekoodin toteutus, julkaistiin, mikä voisi mullistaa syväoppimismallien laskentatehon.
Matriisin kertolaskutensori
Matriisin kertolaskuoptimoinnin ei-asiantuntijoille ei ehkä ole yksinkertaista ymmärtää, kuinka operaatio, kuten matriisikertominen, voidaan kuvata kolmiulotteisessa tensorissa. Yritän selittää sen yksinkertaisin sanoin ja esimerkein.
Tarkastellaan tuloa C = A*B, jossa yksinkertaisuuden vuoksi sekä A että B ovat neliömatriiseja, joiden koko on N. Kertolasku voidaan kuvata muodon (N^3, N^2, N^2) 2D-tensoriin. Ensimmäinen tensorimitta edustaa litistettyä matriisia A, toinen ulottuvuus litistettyä matriisia B ja kolmas ulottuvuus litistettyä matriisia C.
Tensorilla on vain binääriarvot (joko 1 tai 0) jokaiselle merkinnälle. Huomaa, että tensori edustaa kertolaskua, joten se on riippumaton matriisien A ja B arvoista.
Jokainen tensorin syöttö vastaa operaation kerrointa. Esimerkiksi C[1,1]:n laskemiseksi on välttämätöntä kertoa sekä A[1,1] että B[1,1]. Siksi tensorimerkinnällä [0,0,0], joka vastaa arvoja A[1,1], B[1,1] ja C[1,1], on arvo 1. Sitä vastoin C[1,1:n laskemiseksi ,2,1], A[1] ei tarvita. Siten tensorivi T[N+0, :, XNUMX] sisältää vain nollia.
Alla olevassa kuvassa on esimerkki tensorista, jossa N=2.
Image from DeepMind's paperi julkaistu luonto
Kuten yllä olevan kuvan kohdissa (b) ja (c) näkyy, on mahdollista toteuttaa algoritmi tuotteen laskemiseksi käyttämällä 3D-tensorin hajotusta. Tarkemmin sanottuna alla olevaa algoritmia voidaan käyttää tensorihajotelman (matriisit U, V, W) muuntamiseen matriisin kertolaskualgoritmiksi.
Meta-algorithm parameterized for computing the matrix product C=AB introduced in DeepMind's paperi
TensorGame
Tehokkaiden algoritmien löytäminen matriisin kertolaskua varten on äärimmäisen haastava, koska mahdollisten algoritmien määrä on paljon suurempi kuin universumin atomien määrä, jopa pienissä matriisin kertolaskutapauksissa.
DeepMind muutti tämän ongelman yhden pelaajan peliksi ja kutsui sitä TensorGameksi. Tässä pelissä pelaaja valitsee, kuinka yhdistää erilaisia matriisien merkintöjä kertoakseen ne. Pistemäärä annetaan oikean kertolaskutuloksen saavuttamiseksi tarvittavien operaatioiden lukumäärän perusteella. Peli päättyy, kun nollatensori saavutetaan tai kun suurin määrä siirtoja on tehty. Lopullinen tekijöiden jako arvioidaan jäännösjärjestyksen arvioinnin ja tiettyjen optimointikriteerien, kuten asymptoottisen aikakompleksisuuden tai käytännön suoritusajan perusteella.
TensorGame-pelin alkusijainti vastaa matriisikerto-tensoria, joka ilmaistaan jollain satunnaisella perusteella.
Pelin jokaisessa vaiheessa t pelaaja kirjoittaa muistiin kolme vektoria
, joka määrittää rank-1 tensorit . Pelin tila päivitetään vähentämällä pelaajan valitsemat vektorit:
jossa
on matriisikertotensori.Jos peli päättyy p-askeleeseen, tämä tarkoittaa, että matriisikerto-tensori
voidaan hajottaa p rank-1 tensoreihin , eli sillä on vähintään arvo p.TensorGame voidaan sitten tulkita rank-hajotusalgoritmiksi ja AlphaTensor voidaan nähdä algoritmina tensorin arvon arvioimiseksi.
AlphaTensor-arkkitehtuuri
Tähän mennessä olemme oppineet TensorGamesta ja selventäneet, kuinka sen ratkaisu voidaan nähdä matriisikerto-algoritmina. Tutustutaan nyt AlphaTensorin pääkonsepteihin, peliin käytettävään algoritmiin.
AlphaTensor-arkkitehtuuri on pohjimmiltaan enkooderi-dekooderi-muuntaja-arkkitehtuuri, jossa:
- kooderi ottaa syötteeksi pelin tilan , mallin n aikaisempaa toimintoa (yleensä n=7) ja nykyisen toiminnon aikaindeksiä t. Tiedot pinotaan yhteen tensoriin, jolla on muoto (n+1, N^2, N^2, N^2). Tämä tensori muotoillaan sitten uudelleen ja muunnetaan (käyttäen kolmea lineaarista kerrosta) muototensoriksi (N^2, N^2, c), jossa c on mallin sisämitta.
- dekooderi generoi n_steps-toiminnot kooderin antamasta upotetusta vektorista autoregressiivisellä tavalla. Jokainen toiminto vastaa kolmosten merkkiä edustaa yhtä kolmosista, joka hajottaa pelin tensorin (eli laskee sen arvoa)
Mallia koulutetaan vuorotellen takaisin-etenemistä ja mallinäyttelemistä. Mallitoimintaa käytetään datan luomiseen, jota sitten käytetään mallin kouluttamiseen. Käytännössä mallia opetetaan synteettisesti tuotetun datan ja mallin näyttelemisen aikana tuottaman tiedon sekoituksella. Näyttelijävaihe tehdään ottamalla matriisioperaatiota vastaava 3D-tensori ja pelaamalla sillä n_actors pelejä. Jokainen näyttelijä pelaa peliä joko vakioperusteisesti tai vaihtoehtoisesti (perustan muutosta sovelletaan tietyllä todennäköisyydellä). Tulokset kerätään sitten ja niitä voidaan käyttää harjoitusvaiheessa synteettisten tietojen kanssa.
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.
Mallia koulutettaessa palkkio on itse asiassa negatiivinen palkinto (rangaistus). Sen absoluuttinen arvo kasvaa jokaisen pelin ratkaisemiseen vaadittavan lisävaiheen myötä. Jos malli ottaa m askelta ratkaistakseen TensorGame-pelin, peliin liittyvä palkinto on r=-m. Jos malli ei pysty ratkaisemaan TensorGamea max_rank-askelilla, palkkio lasketaan arvioimalla jäljellä olevan tensorin sijoitus. Rank on estimoitu tensorin muodostavien matriisien rivien summana. Arviointi on tensorin todellisen arvon yläraja.
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 käyttäjän määrittelemä kerroin.
Grafiikkasuorittimelle ja TPU:lle räätälöityjen AlphaTensorin löytämien algoritmien nopeudet (%) DeepMindin paperista. Nopeutuksia mitataan suhteessa vakiomatriisin kertolaskuun (esim. cuBLAS GPU:lle) samalla laitteistolla ja verrataan Strassen-neliön algoritmi. Lähde: Deepmind.
Vapautin hiljattain OpenAlphaTensor, AlphaTensorin ensimmäinen avoimen lähdekoodin toteutus. Tässä osiossa käyn läpi toteutuksen. Kuten aiemmin keskustelimme, AlphaTensor-arkkitehtuuri on melko yksinkertaista, joka perustuu standardimuuntajaan, jossa on kooderi-dekooderiarkkitehtuuri. AlphaTensorin mielenkiintoisimmat komponentit ovat enkooderiosan ensimmäinen kerros ja tapa, jolla toiminnot näytteistetään.
Aloitetaan ensimmäisestä koodauskerroksesta.
# 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
Yllä olevassa katkelmassa näytämme, kuinka tulotensori hajotetaan kolmeen tensoriin, joita sitten käytetään muuntajakerroksen kysely-, avain- ja arvosyötteinä.
- Kolmen litistettyjä matriiseja edustavien tensorimittojen poikki (A, B, C) syötetensori litistetään kutakin ulottuvuutta pitkin yhdessä edellisiä toimintoja edustavan dimension kanssa. Tällä tavalla jokaisessa syötetensorin litistetyssä kopiossa valittu dimensio on viimeisten T-1-arvojen ja todellisen arvon aggregaatio valitun ulottuvuuden kaikille S-arvoille, missä S=N^2. Filosofisesti on ikään kuin keskitymme kunkin ulottuvuuden osalta siihen, mitä tapahtui aiemmissa toimissa kyseisessä ulottuvuudessa.
- Skalaarit kartoitetaan kolmeen eri tilaan, joiden ulottuvuus on S^2, ja muotoillaan sitten uudelleen ketjutettavaksi edellisessä pisteessä saatujen tensorien kanssa. Käsitteellisesti skalaarit kartoitetaan upotusavaruuteen, jonka ulottuvuus on S^2, ja sitten upotettu tieto paloitetaan S-vektoriksi ja pinotaan yhteen, samalla tavalla kuin tekstille tapahtuu tokenoituna.
- Skalaarimerkit ketjutetaan uudelleen strukturoidun syöttötensorin kanssa ja annetaan sitten syötteenä lineaariselle kerrokselle skalaarien + kanavahistorian kohdistustietojen kartoittamiseksi mallin sisäisessä ulottuvuudessa.
Nämä kolme vaihetta voidaan tulkita tapaksi antaa mallille sekä tietoa skalaareista (kuten TensorGame-aikavaiheessa) että keskittyä kunkin kanavan edellisiin toimiin.
Mitä tulee toimintojen tuottamiseen, on mielenkiintoista huomata, että AlphaTensor generoi ulostulona tripletin u, v, w, jonka tarkoituksena on alentaa tensoriarvoa. Kolmen vektorin koko on S ja koska ne ovat ketjutettuja, mallin on tuotettava vektori, jonka koko on 3*S. AlphaTensor on koulutettu RL-algoritmilla, joten kaikki mahdolliset toiminnot on ilmaistava todennäköisyyksinä numeroidussa avaruudessa, eli malli tuottaa todennäköisyyden eri toimien päälle. Tämä tarkoittaa, että jokainen 3S-avaruuden vektori tulee kuvata eri toimintoon. Tämä johtaa toiminta-avaruuteen, jonka koko on |F|^(3S), jossa |F| on eri arvojen lukumäärä, jonka elementti u, v, w voi ottaa. Yleensä arvot on rajoitettu (-2, -1, 0, 1, 2), mikä johtaa 5 elementin kardinaalisuuteen.
Tässä tulee suuri haaste: toimintatodennäköisyyksien generoimiseksi matriisitulolle kooltaan 5 matriisien tarvitsemme 5^75 * 4 tavun muistin, mikä tarkoittaisi ~10^44 Gt muistia. On selvää, ettemme voi hallita niin suurta toimintatilaa.
Miten ratkaisemme ongelman? Toiminnan todennäköisyyksien muistijalanjäljen vähentämiseksi voimme jakaa kolmiot pienemmiksi paloiksi, "tokenoida" ne ja käsitellä palasia generoituina tokeneina muuntajaarkkitehtuurissa, eli tokenit annetaan sisääntulona dekooderille autoregressiivisessä muodossa. tapa. Yllä olevassa esimerkissä voimme jakaa kolmiot 15 osaan, jolloin muistin kulutus pienenee 15 * 5^(75/15) * 4:ään eli 187.5 KB:hen.
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), )
Yllä näytämme koodinpätkän koko toiminnon luomiseksi. Koodissa self.core sisältää dekooderikerroksen ja tensori e edustaa enkooderikerroksen lähtöä. Nollaa voidaan pitää Token NLP-malleissa ja n_steps-osia edustavat n_steps-toiminnot luodaan progressiivisesti.
Malli palauttaa kolme määrää:
- Luodut toiminnot
- Täyteen toimintaan liittyvä todennäköisyys
- Ensimmäisen toiminnon (ensimmäisen palan) luomiseen tuotetut logitit, joita käytetään mallin arvon laskemiseen.
Parametriin n_samples kannattaa puhua muutama sana. Parametria käytetään toimintavaiheessa, ja sen avulla malli voi luoda erilaisia versioita kolmosista, joita sitten käytetään toimintatilan tutkimiseen toimimisprosessissa käytetyssä Monte Carlo Tree Search -algoritmissa. n_samples eri toiminnot otetaan näytteitä mallin luoman käytännön mukaisesti.
Näyttelijävaihe
Hankalin osa koko algoritmissa on luultavasti TensorGame-pelin ratkaisemiseen käytetty toimimisvaihe. Algoritmia ei selitetä syvällisesti AlphaTensor-paperissa, koska se perustuu useisiin DeepMindin aikaisempiin kirjoituksiin, jotka on vain lainattu ja annettu tunnetuksi. Tässä rekonstruoin kaikki puuttuvat osat ja selitän askel askeleelta toteutuksemme.
Voimme järjestää näyttelemisen vaiheet kolmeen eri osaan:
- Monte-Carlon puuhaku
- Pelin simulaatio
- Parannettu käytäntölaskenta
Analysoidaan niitä yksitellen.
Monte-Carlon puuhaku (MCTS)
Monte Carlo Tree Search (MCTS) on laajalti käytetty tekoälytekniikka pelien pelaamiseen, erityisesti lautapeleissä ja videopeleissä. Algoritmi luo pelipuun, joka simuloi mahdollisia liikkeitä ja tuloksia ja käyttää satunnaista otantaa arvioidakseen kunkin liikkeen odotetun palkkion. Algoritmi valitsee sitten iteratiivisesti siirron, jolla on suurin odotettu palkkio, ja simuloi tuloksia, kunnes se saavuttaa päätetilan tai määritellyn pysäytysehdon. Simulaatioilla arvioidaan jokaisen liikkeen voiton todennäköisyys ja ohjataan päätöksentekoprosessia. MCTS:n on osoitettu olevan tehokas monimutkaisissa peleissä, joissa mahdollisten liikkeiden ja tulosten määrä on suuri, ja sitä on käytetty menestyksekkäissä pelin tekoälyjärjestelmissä, kuten AlphaGo.
AlphaTensorissa käytetään alkuperäisen MCTS:n muokattua versiota. Erityisesti sen sijaan, että toiminto valitaan satunnaisesti koko toiminta-avaruudesta, toiminto valitaan mallin suoraan generoimasta osajoukosta (edellä esiteltyjen n_samples-näytteiden kautta). Käytännön päivitykseen tehty korjaus otetaan sitten käyttöön Parannetun käytännön laskentavaiheessa.
Toteutuksessamme päätimme säilyttää kaiken Monte-Carlo-puun tiedon sanakirjassa, jonka avaimena on TensorGame-tilan hash-versio ja arvoina itse tilaan liittyvä tieto. Jokainen Monte Carlo -vaihe alkaa solmusta ja simuloi n_sim-minipelejä, tutkien tulevaisuutta 5 liikkeen horisontissa. Jos solmu on jo tutkittu aikaisemmissa simulaatioissa, n_sim säädetään ottaen huomioon aikaisempien tutkimusten lukumäärä. Jokaisen solmun käyntien määrä tallennetaan N_s_a-tensoriin, koska tämä tensori sisältää käyntien lukumäärän solmun alitoimintoa kohden (mallin näytteiden joukossa).
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
Yllä oleva koodi näyttää algoritmin toteutuksen. Koodin yksinkertaisuuden vuoksi käytäntökorjaus suoritetaan simulate_game-funktiossa.
Pelin simulointi
Simulate_game-funktio on vastuussa puun tutkimisesta, joka koostuu solmuista, jotka edustavat tiettyä TensorGame-tilaa. Se myös suorittaa mallin aina, kun lehtisolmu kohtaa, ja se tallentaa kaikki solmutiedot state_dict-sanakirjaan. Katsotaanpa syvällisesti sen toteutusta:
@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)
Jokainen simulaatio on jaettu kolmeen osaan:
- Valinta
- Laajeneminen
- Varmuuskopiointi
Valintaosassa simulaatio ajetaan jo luoduille puusolmuille ja valitaan seuraava solmu seuraavalla funktiolla:
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()]
Käytännössä ucb-funktion maksimointi:
annetulle tilalle on valittu. Tässä Q edustaa mallin luomia Q-arvoja ja π edustaa satunnaisjakaumaa mallikäytännön avulla otettujen toimien välillä. N(s, a) edustaa solmun käyntien määrää toimintoon a solmusta s.
Kun valintavaihe saavuttaa lehtisolmun, jos simulaatio ei ole saavuttanut päätetilaa (joko maksimitutkimuksen eli tulevaisuuden horisontin tai pelin päättymisen suhteen), mallia käytetään sitten valitsemaan n_samples vaihtoehtoisia solmuja (ne ovat lehtiä solmut peräkkäisessä iteraatiossa). Tätä kutsutaan laajennusvaiheeksi, koska puuhun lisätään uusia solmuja. Tämän jälkeen nykyisessä simulaatiossa ei tutkita enempää solmua, vaan lehti q_value lähetetään seuraavaan simulaatiovaiheeseen: varmuuskopiointi.
Varmuuskopiointi on jokaisen simulaation viimeinen vaihe. Varmuuskopioinnin aikana, jos lehtisolmu oli päätetila, lopullinen palkkio lasketaan; muussa tapauksessa lehden q-arvoa käytetään arvioituna palkkiona. Sitten palkkio levitetään takaisin simulaatioradalla päivittämällä sekä tilat q_values että päivittämällä käyntilaskurit N(s, a). Alla olevassa koodinpätkässä näytämme palkkion takaisin-etenemisen koodin.
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
Parannettu käytäntölaskenta
Kun kaikki simulaatiot on suoritettu ja MCTS tarjoaa mielenkiintoisen tilannekuvan lähitulevaisuudesta, on aika päivittää ennustettuihin solmuihin liittyvä käytäntö ja palauttaa ne, jotta niitä voidaan käyttää harjoituksen aikana. Parannettu käytäntö kohdassa kuvattua menetelmää noudattaen Hubert et ai, käytetään suurten toimintatilojen hallintaan. Itse asiassa pienessä hakutilassa on mahdollista MCTS:n aikana ottaa toiminto satunnaisesti toimintatilasta ja arvioida sen vaikutus. Samankaltainen lähestymistapa paljon laajemmassa toimintatilassa johtaisi siihen, että kaikki liikeradat poikkesivat eri poluilla ja tarvitsisi äärettömän määrän liikeratoja mielekkäiden tilastojen saamiseksi ja sitten politiikan päivittämiseen. Koska tässä käytetään näyte-MCTS:ää hajonnan välttämiseksi, eli n_samples-toimintoa näytteistetään mallipolitiikan mukaisesti ja sitten MCTS vain valitsee yhden näytetoiminnoista puuta tutkiessaan, meidän on otettava huomioon otoskorjaus laskettaessa. lopullinen päivitetty käytäntö, jota käytetään mallin koulutuksessa.
Käytännössä parannettu politiikka lasketaan muodossa
jossa
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
Huomaa, että toteutuksessamme sen jälkeen, kun olemme laskeneet käytännön N_s_a-tensorista, meidän on kartoitettava se takaisin alkuperäiseen toimintatensoriin. Itse asiassa N_s_a vain ottaa huomioon mallin otokset, kun taas lopullisen politiikan tulee sisältää todennäköisyydet myös tutkimattomille toimille.
Erot suhteessa ChatGPT-koulutusalgoritmiin
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 hienosäätötekniikka, jota käytetään kielimallien virittämiseen noudattamaan kirjallisia ohjeita. Se käyttää ihmisten mieltymyksiä palkitsemissignaalina mallin hienosäätämiseen ja siten sovittaa kielimallin käyttäytymisen tietyn ihmisryhmän ilmoitettujen mieltymysten kanssa pikemminkin kuin jonkin laajemman käsityksen "inhimillisistä arvoista".
Sitä vastoin MCTS on puupohjainen hakualgoritmi, jota käytetään määrittämään optimaaliset liikkeet peleissä. Se simuloi mahdollisia liikkeitä ja päivittää kunkin liikkeen arvot niiden tulosten perusteella ohjaten parhaan liikkeen valintaa.
RLHF kerää tietoja ihmisten kirjoittamista demonstraatioista ja ihmisten merkitsemistä tekoälymallien vertailuista ja kouluttaa palkkiomallin ennustamaan tietyn ihmisryhmän mieltymyksiä. Palkkiomallia käytetään sitten tekoälymallien hienosäätämiseen. MCTS sen sijaan käyttää simulaatioita ja arvioita parhaan päätöksen määrittämiseen.
Vaikka ne ovat erilaisia lähestymistapoja, RLHF:llä ja MCTS:llä on myös yhtäläisyyksiä. Molemmat tekoälytekniikat käyttävät päätöksenteko- ja ongelmanratkaisumenetelmiä, ja molemmat käyttävät yrityksen ja erehdyksen lähestymistapaa tutkiakseen erilaisia vaihtoehtoja ja tehdäkseen päätöksiä saatavilla olevan tiedon perusteella. Molemmat ovat myös iteratiivisia prosesseja, jotka paranevat ajan myötä, kun tietoa ja kokemusta kerätään.
Valinta RLHF:n ja MCTS:n välillä riippuu käsillä olevasta tehtävästä. RLHF on ihanteellinen, kun mallin suorituskyvyn arvioimiseksi ei ole selkeää mittaria, kun taas MCTS on osoittautunut tehokkaaksi pelimaisissa tehtävissä, joissa tulevaisuuden tuntemus ja tutkiminen antavat mallille merkittävän edun.
Koodioptimointi AlphaTensor-harjoitteluun
AlphaTensor-harjoitusalgoritmin toteuttaminen edellyttää täydellisen kompromissin löytämistä harjoitusnopeuden ja muistin kulutuksen välillä. Kuten Malli-osiossa nähdään, pelkkä toimintotunnisteen huomioon ottaminen voi säästää paljon muistia, mutta liian aggressiivinen toimintatilan vähentäminen voi johtaa sekä tarkkuuden laskuun että hitaampaan suorituskykyyn. Jälkimmäinen tapahtuu, koska mallidekooderi luo kaikki merkit peräkkäin autoregressiivisellä tavalla. Siksi päättelyaika kasvaa lineaarisesti merkkien lukumäärän kanssa toimintoa kohti, kun toimintatilan softmax ei ole enää pullonkaula.
AlphaTensor-koulutusta luotaessa suurimmat vaikeudet löytyivät näyttelemisen prosessista. Jos tensoreita ei ole tallennettu oikeassa muodossa, MCTS voi helposti aiheuttaa hallitsematonta muistin käytön kasvua. Toisaalta, jos kunkin simulaation aikana tallennettujen tensorien määrää vähennetään liikaa, MCTS voi käyttää äärettömän paljon aikaa tarvittavien tilojen uudelleen laskemiseen.
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 tavua kutakin kaavion solmua kohden. Nyt kun otetaan huomioon, että jokainen laajennusvaiheen simulaatio luo uuden solmun (ja n_sim=200), lopullinen muistinkulutus olisi 200328252525*4 = 3.2 Gt pelkästään ensimmäiselle MCTS-solmulle. Pahimmassa tapauksessa, kun tutkitaan toimivia max_rank-solmuja (jossa max_rank = 150), tämä johtaisi kokonaismuistinkulutukseen 150 * 3.2 Gt = 480 Gt RAM-muistissa (tai GPU-muistissa, jos kaikki tensorit on tallennettu GPU:lle). . Suoritimme koulutuksen työasemallamme 128 Gt RAM-muistilla ja 48 Gt GPU-muistilla, joten jouduimme vähentämään muistin kulutusta.
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.
Kun OpenAlphaTensor on nyt avoimen lähdekoodin, avautuu useita jännittäviä mahdollisuuksia jatkokehitykseen.
Luonnollinen edistysaskel on OpenAlphaTensorin hienosäätö kohdelaitteistoissa. Tämän odotetaan johtavan erittäin kilpailukykyiseen laskennalliseen suorituskykyyn. Julkaisen lisää OpenAlphaTensorin suorituskyvystä eri laitteilla GitHub. Tätä artikkelia kirjoitettaessa OpenAlphaTensor oli koulutuksessa.
Toinen tärkeä edistysaskel olisi etäkääntämisen tuki, jonka avulla käyttäjät voivat rakentaa reunalaitteille optimoituja algoritmeja. Tämä voidaan saavuttaa tallentamalla OpenAlphaTensor-malli palvelimelle, kun taas matriisin kertolaskualgoritmia arvioidaan eri laitteilla.
Saattaa myös olla tärkeää laajentaa tukea eri kääntäjille latenssipohjaisen palkkiokorjauksen laskemiseksi. Eri kääntäjät voivat johtaa erilaisiin optimoituihin algoritmeihin tietyllä laitteistolla. Esimerkiksi DeepMind-paperi osoitti lupaavia tuloksia käyttämällä JAX:ia ja XLA-kääntäjää TPU- ja Nvidia-grafiikkasuorittimissa. Olisi mielenkiintoista arvioida tämä käyttämällä NCCL:ää Nvidiassa tai LLVM:ää prosessoreissa.
Lopuksi, mallin ja opetusalgoritmin laajentaminen tukemaan suurempia matriisikokoja on edelleen suuri avoin haaste. Tällä hetkellä OpenAlphaTensor tukee matriisin maksimikokoa 5, mutta sitä voidaan soveltaa jakamalla suurempia matriisikertoiluja pienten MM:ien ryhmiin, joiden koko on pienempi kuin 5. Tämä lähestymistapa ei ole optimaalinen, ja pelkistys suoritetaan suoraan suurelle tensorille, joka vastaa täysi MM voisi teoriassa johtaa parempiin tuloksiin.
Diego Fiori is the CTO of Nebuly AI, a company committed to making AI optimization part of every developer's toolkit.
- SEO-pohjainen sisällön ja PR-jakelu. Vahvista jo tänään.
- Platoblockchain. Web3 Metaverse Intelligence. Tietoa laajennettu. Pääsy tästä.
- Lähde: 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
- ][s
- $ YLÖS
- 1
- 3d
- 8
- a
- pystyy
- Meistä
- edellä
- absoluuttinen
- kiihtyvä
- Mukaan
- sen mukaisesti
- Tili
- tarkkuus
- Saavuttaa
- saavutettu
- Toiminta
- toimet
- todella
- lisä-
- lisä-
- Oikaistu
- hyväksytty
- edistää
- Etu
- Jälkeen
- Agentti
- aggregaatti
- aggressiivinen
- AI
- AI-järjestelmät
- tavoitteet
- algoritmi
- algoritmit
- Kaikki
- Salliminen
- mahdollistaa
- yksin
- jo
- vaihtoehto
- keskuudessa
- määrä
- analysoida
- ja
- Toinen
- sovellettu
- lähestymistapa
- lähestymistavat
- arkkitehtuuri
- OVAT
- artikkeli
- keinotekoinen
- tekoäly
- AS
- osoitettu
- liittyvä
- At
- Automatisoitu
- saatavissa
- välttämällä
- takaisin
- Varmuuskopiointi
- perustua
- Pohjimmiltaan
- perusta
- BE
- koska
- tulee
- ennen
- ovat
- alle
- benchmark
- PARAS
- Paremmin
- välillä
- Jälkeen
- hallitus
- Lautapelit
- sidottu
- laajempaa
- BT
- rakentaa
- rakennettu
- by
- nimeltään
- CAN
- ei voi
- tapaus
- Aiheuttaa
- aiheutti
- tietty
- haaste
- haastava
- muuttaa
- Kanava
- ChatGPT
- lapsi
- valinta
- valita
- valittu
- mainittu
- selkeä
- selvästi
- koodi
- kerää
- yhdistää
- sitoutunut
- Yhteinen
- yritys
- verrattuna
- kilpailukykyinen
- monimutkainen
- monimutkaisuus
- osat
- kokoonpanossa
- kompromissi
- laskeminen
- laskentateho
- Laskea
- tietojenkäsittely
- käsitteet
- käsitteellisesti
- ehto
- luottamus
- Harkita
- harkittu
- ottaen huomioon
- pitää
- kulutus
- sisältää
- jatkaa
- kontrasti
- muunnetaan
- Ydin
- vastaava
- vastaa
- voisi
- Laskuri
- prosessori
- luo
- Luominen
- kriteerit
- CTO
- Nykyinen
- Tällä hetkellä
- tiedot
- tekemisissä
- päättää
- päätti
- päätös
- Päätöksenteko
- päätökset
- syvä
- syvä oppiminen
- Deepmind
- riippuu
- on kuvattu
- Määrittää
- Kehittäjä
- Kehitys
- laite
- Laitteet
- DICT
- eri
- vaikeudet
- Ulottuvuus
- mitat
- suoraan
- löytää
- löytämässä
- keskusteltiin
- jakelu
- jaettu
- alas
- Pudota
- aikana
- e
- kukin
- Aikaisemmin
- helposti
- reuna
- Tehokas
- tehokas
- myöskään
- elementti
- elementtejä
- upotettu
- päättyy
- tehostettu
- valtava
- tarpeeksi
- merkintä
- virhe
- arvio
- arvioidaan
- Eetteri (ETH)
- arvioida
- arvioitu
- arviointiin
- arvioinnit
- Jopa
- Joka
- esimerkki
- Esimerkit
- jännittävä
- teloitus
- laajeneminen
- odotettu
- experience
- Selittää
- selitti
- hyödyntää
- tutkimus
- tutkia
- tutkitaan
- Tutkiminen
- ilmaistuna
- laajentaa
- ulottuu
- erittäin
- melko
- perhe
- nopeampi
- palaute
- harvat
- Kuva
- lopullinen
- löytäminen
- Etunimi
- kellua
- Keskittää
- seurata
- jälkeen
- Jalanjälki
- varten
- muoto
- muoto
- kaava
- löytyi
- alkaen
- koko
- toiminto
- perus-
- edelleen
- edelleen kehittäminen
- tulevaisuutta
- peli
- Games
- tuottaa
- syntyy
- synnyttää
- tuottaa
- saada
- saada
- Antaa
- tietty
- Antaminen
- tavoite
- Goes
- hyvä
- GPU
- GPU
- kaavio
- suuri
- Ryhmä
- Ryhmän
- kasvaa
- Kasvu
- ohjaavat
- käsi
- Käsittely
- tapahtui
- tapahtuu
- Tarvikkeet
- laitteistolaite
- laitteita
- Olla
- ottaa
- tätä
- suurin
- horisontti
- Miten
- Miten
- Kuitenkin
- HTTPS
- valtava
- ihmisen
- i
- Minä
- ihanteellinen
- IDX
- kuva
- Vaikutus
- toteuttaa
- täytäntöönpano
- tärkeä
- parantaa
- parani
- in
- Kasvaa
- Lisäykset
- yhä useammin
- itsenäinen
- indeksi
- tiedot
- ensimmäinen
- panos
- sen sijaan
- ohjeet
- Älykkyys
- mielenkiintoinen
- sisäinen
- käyttöön
- intuitio
- IT
- iteraatio
- SEN
- itse
- jpg
- KDnuggets
- Pitää
- avain
- tuntemus
- tunnettu
- Kieli
- suuri
- suurempi
- Sukunimi
- Viive
- uusin
- kerros
- kerrokset
- johtaa
- oppinut
- oppiminen
- Lista
- katso
- näköinen
- Erä
- tehty
- tärkein
- merkittävä
- tehdä
- Tekeminen
- hoitaa
- toimitusjohtaja
- monet
- kartta
- kartoitus
- Matriisi
- asia
- maksimi
- merkitys
- mielekäs
- välineet
- jäsen
- Muisti
- menetelmä
- menetelmät
- metrinen
- puuttuva
- seos
- malli
- mallit
- muokattu
- moduuli
- lisää
- tehokkaampi
- Lisäksi
- eniten
- liikkua
- liikkuu
- kerrottuna
- Luonnollinen
- luonto
- Lähellä
- välttämätön
- Tarve
- tarvitaan
- negatiivinen
- verkot
- hermo-
- hermoverkkoihin
- Uusi
- seuraava
- NLP
- solmu
- solmut
- ei-asiantuntijat
- Käsite
- numero
- Nvidia
- saatu
- of
- Tarjoukset
- on
- ONE
- avata
- avoimen lähdekoodin
- OpenAI
- toiminta
- Operations
- optimaalinen
- optimointi
- Optimoida
- optimoitu
- Vaihtoehdot
- alkuperäinen
- Muut
- muuten
- ulostulo
- yleinen
- Paperi
- paperit
- parametri
- osa
- erityinen
- erityisesti
- osat
- Ihmiset
- täydellinen
- suorituskyky
- esittävä
- vaihe
- kappaletta
- Platon
- Platonin tietotieto
- PlatonData
- Pelaa
- soitin
- pelaa
- Kohta
- politiikkaa
- politiikka
- sijainti
- mahdollinen
- mahdollinen
- teho
- Käytännön
- harjoitusta.
- ennustaa
- ennusti
- mieltymykset
- esitetty
- edellinen
- todennäköisyys
- todennäköisesti
- Ongelma
- prosessi
- Prosessit
- tuottaa
- valmistettu
- Tuotteet
- eteneminen
- progressiivinen
- lupaava
- ehdotettu
- todistettavasti
- todistettu
- julkaista
- julkaistu
- RAM
- satunnainen
- rivit
- pikemminkin
- saavutettu
- saavuttaa
- äskettäin
- vähentää
- Vähentynyt
- vähentämällä
- puhdistettu
- vahvistaminen oppiminen
- julkaistu
- jäljellä oleva
- jäännökset
- huomattava
- muistaa
- kaukosäädin
- toistuva
- edustavat
- edustaa
- tarvitaan
- Vaatii
- vastuullinen
- rajoitettu
- johtua
- Saatu ja
- tulokset
- palata
- Tuotto
- mullistaa
- Palkinto
- RIVI
- rt
- ajaa
- s
- sama
- Säästä
- tallentaa
- skenaario
- skenaariot
- järjestelmä
- Haku
- Toinen
- Osa
- siemenet
- valittu
- valitsemalla
- valinta
- SELF
- setti
- asetus
- useat
- Shape
- jakaminen
- Lyhyt
- shouldnt
- näyttää
- esitetty
- Näytä
- signaali
- merkittävä
- merkittävästi
- samankaltainen
- yhtäläisyyksiä
- Yksinkertainen
- yksinkertaisuus
- yksinkertaisesti
- simulointi
- koska
- tilanne
- Koko
- koot
- pieni
- pienempiä
- Kuva
- So
- ratkaisu
- SOLVE
- Solving
- jonkin verran
- lähde
- Tila
- tilat
- erityinen
- erityisesti
- määritelty
- nopeus
- viettää
- menot
- jakaa
- neliö
- pinottu
- Vaihe
- standardi
- Alkaa
- alkaa
- Osavaltio
- huippu-
- totesi
- Valtiot
- tilasto
- Vaihe
- Askeleet
- pysäyttäminen
- verkkokaupasta
- tallennettu
- varastot
- suora
- onnistunut
- niin
- tuki
- Tukee
- synteettinen
- synteettinen data
- synteettisesti
- järjestelmä
- järjestelmät
- Räätälöity
- ottaa
- vie
- ottaen
- Kohde
- Tehtävä
- tehtävät
- tekniikat
- terminaali
- ehdot
- että
- -
- Tulevaisuus
- Kaavio
- tiedot
- Valtion
- heidän
- Niitä
- siten
- siksi
- Nämä
- kolmas
- kolmella
- kolmiulotteinen
- Kautta
- aika
- aikaavievä
- että
- yhdessä
- symbolinen
- tokenization
- tokenized
- tokens
- liian
- työkalupakki
- ylin
- taskulamppu
- Yhteensä
- perinteinen
- Juna
- koulutettu
- koulutus
- junat
- kehityskaari
- transformoitu
- kohdella
- totta
- ymmärtää
- CasinoUniverse
- käyttämätön
- Päivitykset
- päivitetty
- Päivitykset
- päivittäminen
- parantaa
- us
- Käyttö
- käyttää
- Käyttäjät
- yleensä
- arvo
- arvot
- eri
- versio
- Video
- Videopelit
- Vierailla
- Vierailut
- W
- Tapa..
- Mitä
- joka
- vaikka
- laajalti
- wikipedia
- tulee
- voittaa
- with
- sanoja
- työasema
- arvoinen
- olisi
- kirjoittaminen
- kirjallinen
- X
- zephyrnet
- nolla-