님이 촬영 한 사진 Deepmind on Unsplash
행렬 곱셈은 신경망에서 과학적 컴퓨팅 루틴에 이르기까지 많은 시스템에서 사용되는 기본 연산입니다. 행렬 곱셈을 위한 효율적이고 증명 가능한 올바른 알고리즘을 찾는 것은 계산을 더 빠르고 효율적으로 만드는 데 큰 영향을 미칠 수 있지만 매우 어려운 작업입니다. 가능한 알고리즘의 공간은 엄청나며 인간이 설계한 휴리스틱 또는 조합 검색과 같은 알고리즘을 발견하는 전통적인 방법은 종종 차선책입니다.
Deepmind에서 최근 제안한 자동화된 검색을 위한 AI 기반 솔루션은 인간의 직관을 훨씬 뛰어넘습니다. 이 솔루션은 AlphaTensor라는 심층 강화 학습 에이전트로 구성됩니다. 알파 제로. 이 에이전트는 TensorGame이라는 싱글 플레이어 게임을 플레이하도록 훈련받았습니다. 이 게임의 목표는 매트릭스 곱셈을 위한 계산상 효율적인 알고리즘을 발견하는 것입니다.
AlphaTensor는 큰 행렬 곱셈을 더 작은 곱셈으로 분해하여 큰 행렬을 처리하는 데 특히 좋습니다. 또한 AlphaTensor는 특정 하드웨어 장치에서 미세 조정되면 행렬 곱셈을 위한 최첨단 성능을 달성하는 데 사용할 수 있습니다.
AlphaTensor는 딥 러닝 컴퓨팅을 가속화할 수 있는 큰 잠재력을 가지고 있습니다. 딥 러닝에서는 많은 시간이 소요되는 작업을 행렬 곱셈에 매핑할 수 있습니다. AlphaTensor를 사용하여 이러한 작업을 최적화하면 딥 러닝 모델의 전반적인 성능을 크게 향상시킬 수 있습니다.
최근 OpenAlphaTensor는 AlphaTensor의 최초 오픈 소스 구현, 딥 러닝 모델의 계산 능력에 혁명을 일으킬 수 있는 출시되었습니다.
행렬 곱셈 텐서
행렬 곱셈 최적화 전문가가 아닌 경우 행렬 곱셈과 같은 작업을 XNUMX차원 텐서에 매핑하는 방법을 이해하는 것이 간단하지 않을 수 있습니다. 나는 그것을 간단한 단어와 예를 들어 설명하려고 노력할 것입니다.
제품 C = A*B를 고려해 봅시다. 단순화를 위해 A와 B는 크기 N의 정사각형 행렬입니다. 곱셈 연산은 (N^3, N^2, N^2) 모양의 2D 텐서에 매핑될 수 있습니다. 첫 번째 텐서 차원은 평면화된 행렬 A, 두 번째 차원은 평면화된 행렬 B, 세 번째 차원은 평면화된 행렬 C를 나타냅니다.
텐서에는 각 항목에 대한 이진수 값(1 또는 0)만 있습니다. 텐서는 곱셈 연산을 나타내므로 행렬 A 및 B의 값과 독립적입니다.
텐서의 모든 항목은 연산 계수에 해당합니다. 예를 들어 C[1,1]을 계산하려면 A[1,1]과 B[1,1]을 모두 곱해야 합니다. 따라서 A[0,0,0], B[1,1] 및 C[1,1]에 해당하는 텐서 항목 [1,1]은 값이 1이 됩니다. 반대로 C[1,1을 계산하려면 ,2,1], A[1]은 필요하지 않습니다. 따라서 텐서 행 T[N+0, :, XNUMX]에는 XNUMX만 포함됩니다.
아래 이미지는 N=2에 대한 텐서의 예를 보여줍니다.
DeepMind의 이미지 종이 에 게시 자연
위 그림의 (b), (c)와 같이 3차원 텐서의 분해를 이용하여 곱을 계산하는 알고리즘을 구현할 수 있다. 보다 구체적으로, 아래 알고리즘은 텐서 분해(행렬 U, V, W)를 행렬 곱셈 알고리즘으로 변환하는 데 사용할 수 있습니다.
DeepMind에 도입된 행렬 곱 C=AB를 계산하기 위해 매개변수화된 메타 알고리즘 종이
TensorGame
행렬 곱셈을 위한 효율적인 알고리즘을 찾는 문제는 고려해야 할 가능한 알고리즘의 수가 행렬 곱셈의 작은 인스턴스에 대해서도 우주의 원자 수보다 훨씬 많기 때문에 매우 어렵습니다.
DeepMind는 이 문제를 싱글 플레이어 게임으로 변환하여 TensorGame이라고 불렀습니다. 이 게임에서 플레이어는 여러 항목의 행렬을 결합하여 곱하는 방법을 선택합니다. 올바른 곱셈 결과를 얻는 데 필요한 작업 수에 따라 점수가 할당됩니다. 제로 텐서에 도달하거나 최대 이동 횟수에 도달하면 게임이 종료됩니다. 최종 분해는 점근적 시간 복잡도 또는 실제 실행 시간과 같은 특정 최적화 기준 및 잔차 순위의 추정을 기반으로 평가됩니다.
TensorGame의 초기 위치는 임의로 표현된 Matrix Multiplication Tensor에 해당합니다.
게임의 각 단계 t에서 플레이어는 세 개의 벡터를 기록합니다.
, 순위 1 텐서를 지정합니다. . 게임 상태는 플레이어가 선택한 벡터를 빼서 업데이트됩니다.
어디에
행렬 곱셈 텐서입니다.게임이 p 단계로 끝나면 이는 Matrix Multiplication Tensor가
p rank-1 텐서로 분해 가능 , 즉 적어도 순위 p를 갖는다.그러면 TensorGame은 순위 분해 알고리즘으로 해석될 수 있고 AlphaTensor는 텐서의 순위를 추정하기 위한 알고리즘으로 볼 수 있습니다.
AlphaTensor 아키텍처
지금까지 우리는 TensorGame에 대해 배웠고 그 솔루션이 행렬 곱셈 알고리즘으로 어떻게 보이는지 명확히 했습니다. 이제 게임에 사용되는 알고리즘인 AlphaTensor의 주요 개념을 살펴보겠습니다.
AlphaTensor 아키텍처는 기본적으로 다음과 같은 인코더-디코더 Transformer 아키텍처입니다.
- 인코더는 게임 상태를 입력으로 사용합니다. , 모델이 수행한 n개의 이전 작업(일반적으로 n=7) 및 현재 작업의 시간 인덱스 t입니다. 정보는 모양이 (n+1, N^2, N^2, N^2)인 텐서에 함께 쌓입니다. 그런 다음 이 텐서는 모양이 (N^2, N^2, c)인 텐서로 재구성되고 변환됩니다(XNUMX개의 선형 레이어 사용). 여기서 c는 모델의 내부 차원입니다.
- 디코더는 자동 회귀 방식으로 인코더가 제공한 포함된 벡터에서 n_steps 작업을 생성합니다. 각 행동은 세 쌍둥이의 토큰에 해당합니다. 게임 텐서를 분해하는 삼중항 중 하나를 나타냅니다(즉, 순위 감소).
모델은 역전파와 모델 연기를 번갈아 가며 학습합니다. 모델 작동은 모델을 교육하는 데 사용되는 데이터를 생성하는 데 사용됩니다. 실제로 모델은 합성으로 생성된 데이터와 모델이 연기하는 동안 생성한 데이터를 혼합하여 학습합니다. 연기 단계는 행렬 연산에 해당하는 3D 텐서를 가져와서 n_actors 게임을 함으로써 수행됩니다. 각 액터는 표준 기반 또는 대체 기반으로 게임을 진행합니다(기반 변경은 주어진 확률로 적용됨). 그런 다음 결과가 수집되어 합성 데이터와 함께 훈련 단계에서 사용될 수 있습니다.
동작 단계는 AlphaZero의 MCTS(Monte Carlo Tree Search)를 기반으로 하며 큰 동작 공간을 지원하도록 수정되었습니다. 즉, 작업을 선택하기 전에 최대 5단계의 향후 탐색을 통해 모델 출력에서 n_sims 경로를 탐색합니다. 그런 다음 모델에 의해 생성된 확률은 생성된 경로를 고려하여 조정됩니다. 그런 다음 가장 유망한 미래 경로를 가진 행동이 선택되어 게임을 계속합니다.
모델을 교육하는 동안 보상은 실제로 음수 보상(페널티)입니다. 게임을 해결하는 데 필요한 추가 단계마다 절대값이 증가합니다. 모델이 TensorGame을 해결하기 위해 m 단계를 거치면 게임과 관련된 보상은 r=-m입니다. 모델이 max_rank 단계에서 TensorGame을 해결할 수 없는 경우 나머지 텐서의 순위를 추정하여 보상을 계산합니다. 순위는 텐서를 구성하는 행렬의 순위의 합으로 추정됩니다. 추정치는 텐서의 실제 순위에 대한 상한입니다.
모델을 미세 조정할 때 최종 상태의 페널티 보상은 모델에서 생성된 알고리즘의 대기 시간도 고려해야 합니다. 보상 공식은 rt'=rt+λbt가 됩니다. 여기서 rt는 앞서 설명한 보상 체계이고, bt는 벤치마크 보상입니다(최종 상태에서만 XNUMX이 아님). λ 사용자 지정 계수입니다.
AlphaTensor가 발견한 GPU 및 TPU용 알고리즘의 속도 향상(%), DeepMind의 논문에서 추출. 속도 향상은 동일한 하드웨어에서 표준(예: GPU용 cuBLAS) 행렬 곱셈과 비교하여 측정됩니다. Strassen-square 알고리즘. 출처: Deepmind.
최근에 출시한 오픈알파텐서, AlphaTensor의 최초 오픈 소스 구현. 이 섹션에서는 구현을 살펴보겠습니다. 이전에 논의한 바와 같이 AlphaTensor 아키텍처는 인코더-디코더 아키텍처가 있는 표준 변환기를 기반으로 매우 간단합니다. AlphaTensor의 가장 흥미로운 구성 요소는 인코더 부분의 첫 번째 레이어와 동작이 샘플링되는 방식입니다.
첫 번째 인코딩 레이어부터 시작하겠습니다.
# 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
위의 스니펫에서는 입력 텐서가 XNUMX개의 텐서로 분해된 다음 변환기 계층의 쿼리, 키 및 값 입력으로 사용되는 방법을 보여줍니다.
- 평면화된 행렬(A, B, C)을 나타내는 세 개의 텐서 차원에서 입력 텐서는 이전 작업을 나타내는 차원과 함께 각 차원을 따라 평면화됩니다. 이러한 방식으로 입력 텐서의 각 평면 복사본에서 선택한 차원은 선택한 차원의 모든 S 값에 대한 마지막 T-1 값과 실제 값의 집계입니다(여기서 S=N^2). 철학적으로 각 차원에 대해 해당 차원의 이전 작업에서 발생한 일에 초점을 맞추는 것과 같습니다.
- 스칼라는 차원 S^2의 세 가지 다른 공간에 매핑된 다음 이전 지점에서 얻은 텐서와 연결되도록 재구성됩니다. 개념적으로 스칼라는 차원 S^2의 포함 공간에 매핑된 다음 포함된 정보는 토큰화될 때 텍스트에 발생하는 것과 유사하게 S 벡터로 청크되고 함께 쌓입니다.
- 스칼라 토큰은 재구성된 입력 텐서와 연결된 다음 모델의 내부 차원에서 스칼라+채널 히스토리 포커스 정보를 매핑하기 위해 선형 레이어에 입력으로 제공됩니다.
이 세 단계는 모델에 스칼라에 대한 정보(TensorGame 시간 단계에서와 같이)와 각 채널의 이전 작업에 대한 초점을 모두 제공하는 방법으로 해석할 수 있습니다.
동작이 생성되는 방식과 관련하여 AlphaTensor가 텐서 순위를 낮추는 것을 목표로 삼중항 u, v, w를 출력으로 생성한다는 점은 흥미롭습니다. 3개의 벡터는 크기가 S이고 이들이 연결되기 때문에 모델은 크기가 3*S인 벡터를 생성해야 합니다. AlphaTensor는 RL 알고리즘으로 훈련되므로 가능한 모든 행동은 열거된 공간의 확률로 표현되어야 합니다. 즉, 모델은 다른 행동에 대한 확률을 생성합니다. 이는 3S 공간의 각 벡터가 다른 작업에 매핑되어야 함을 의미합니다. 그 결과 |F|^(2S) 크기의 행동 공간이 생성됩니다. 여기서 |F| u, v, w의 요소가 취할 수 있는 서로 다른 값의 수입니다. 일반적으로 값은 (-1, -0, 1, 2, 5)로 제한되므로 XNUMX개 요소의 카디널리티가 생성됩니다.
여기에 주요 과제가 있습니다. 크기가 5인 행렬의 행렬 곱에 대한 작업 확률을 생성하려면 5^75 * 4바이트의 메모리가 필요하며 이는 ~10^44GB의 메모리를 의미합니다. 분명히 우리는 그렇게 큰 행동 공간을 관리할 수 없습니다.
문제를 어떻게 해결합니까? 행동 확률의 메모리 풋프린트를 줄이기 위해 우리는 삼중항을 더 작은 청크로 나누고, "토큰화"하고, 청크를 변환기 아키텍처에서 생성된 토큰으로 취급할 수 있습니다. 즉, 토큰은 자동 회귀에서 디코더에 입력으로 제공됩니다. 방법. 위의 예에서 15중 항을 15개의 청크로 분할하여 메모리 소비를 5 * 75^(15/4) * 187.5, 즉 XNUMXKB로 줄일 수 있습니다.
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), )
위에서 전체 작업을 생성하기 위한 코드 스니펫을 보여줍니다. 코드에서 self.core는 디코더 레이어를 포함하고 텐서 e는 인코더 레이어의 출력을 나타냅니다. XNUMX은 다음과 같이 간주할 수 있습니다. NLP 모델의 토큰과 n_steps 청크를 나타내는 n_steps 작업은 점진적인 방식으로 생성됩니다.
모델은 세 가지 수량을 반환합니다.
- 생성된 작업
- 전체 행동과 관련된 확률
- 모델 값을 계산하는 데 사용될 첫 번째 작업(첫 번째 청크)을 생성하기 위해 생성된 로짓입니다.
n_samples 매개변수에 몇 마디 할 가치가 있습니다. 이 매개변수는 연기 단계에 사용되며 모델이 연기 프로세스에서 사용되는 몬테카를로 트리 검색 알고리즘에서 행동 공간을 탐색하는 데 사용되는 다양한 버전의 세 쌍둥이를 생성할 수 있습니다. n_samples 다른 작업은 모델에서 생성된 정책에 따라 샘플링됩니다.
연기 단계
전체 알고리즘에서 가장 까다로운 부분은 아마도 TensorGame을 해결하는 데 사용되는 연기 단계일 것입니다. 알고리즘은 AlphaTensor 논문에 자세히 설명되어 있지 않습니다. 단지 알려진 것으로 인용되고 제공된 여러 DeepMind의 이전 논문을 기반으로 하기 때문입니다. 여기서는 누락된 부분을 모두 재구성하고 구현 단계를 단계별로 설명하겠습니다.
다음 세 가지 구성 요소로 연기 단계를 구성할 수 있습니다.
- 몬테카를로 트리 검색
- 게임 시뮬레이션
- 향상된 정책 계산
하나씩 분석해 봅시다.
몬테카를로 트리 검색(MCTS)
MCTS(Monte Carlo Tree Search)는 게임 플레이, 특히 보드 게임과 비디오 게임에 널리 사용되는 인공 지능 기술입니다. 이 알고리즘은 잠재적인 움직임과 결과를 시뮬레이션하는 게임 트리를 생성하고 무작위 샘플링을 사용하여 각 움직임에 대한 예상 보상을 평가합니다. 그런 다음 알고리즘은 예상 보상이 가장 높은 이동을 반복적으로 선택하고 최종 상태 또는 지정된 중지 조건에 도달할 때까지 결과를 시뮬레이션합니다. 시뮬레이션은 각 이동에 대한 승리 확률을 추정하고 의사 결정 프로세스를 안내하는 데 사용됩니다. MCTS는 가능한 수와 결과가 많은 복잡한 게임에서 효과적인 것으로 나타났으며 AlphaGo와 같은 성공적인 게임 플레이 AI 시스템에 사용되었습니다.
AlphaTensor에서는 원본 MCTS의 수정된 버전이 사용됩니다. 특히, 전체 행동 공간에서 행동을 무작위로 선택하는 대신 모델에서 직접 생성한 하위 집합(앞서 제시한 n_samples를 통해)에서 행동을 선택합니다. 정책 업그레이드에 대한 수정 사항은 개선된 정책 계산 단계에서 적용됩니다.
우리 구현에서 우리는 Monte-Carlo 트리에 대한 모든 정보를 TensorGame 상태의 해시 버전을 키로 갖고 상태 자체와 관련된 정보를 값으로 갖는 사전에 보관하기로 결정했습니다. 각 Monte-Carlo 단계는 노드에서 시작하여 n_sim 미니 게임을 시뮬레이션하여 5개의 이동 범위로 미래를 탐색합니다. 노드가 이전 시뮬레이션에서 이미 탐색된 경우 이전 탐색 횟수를 고려하여 n_sim을 조정합니다. 각 노드에 대해 방문 횟수는 N_s_a 텐서에 저장됩니다. 이 텐서에는 노드 하위 작업당 방문 횟수(모델에서 샘플링한 항목 중)가 포함되어 있기 때문입니다.
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
위의 코드는 알고리즘 구현을 보여줍니다. 코드 단순성을 위해 정책 수정은 시뮬레이션_게임 함수에서 수행됩니다.
게임 시뮬레이션
simulation_game 함수는 TensorGame의 특정 상태를 나타내는 노드로 구성된 트리 탐색을 담당합니다. 또한 리프 노드를 만날 때마다 모델을 실행하고 모든 노드 정보를 state_dict 사전에 저장합니다. 구현에 대해 자세히 살펴보겠습니다.
@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)
각 시뮬레이션은 세 부분으로 나뉩니다.
- 선택
- 확장
- 백업
선택 부분에서 이미 생성된 트리 노드에서 시뮬레이션이 실행되고 다음 기능을 사용하여 다음 노드가 선택됩니다.
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()]
실제로 ucb 기능을 최대화하는 작업은 다음과 같습니다.
주어진 상태가 선택되었습니다. 여기서 Q는 모델에서 생성된 Q 값을 나타내고 π는 모델 정책을 사용하여 샘플링된 작업에 대한 무작위 분포를 나타냅니다. N(s, a)는 노드 s에서 행동 a까지의 노드 방문 횟수를 나타냅니다.
선택 단계가 리프 노드에 도달하면 시뮬레이션이 종료 조건에 도달하지 않은 경우(최대 탐색, 즉 미래 지평 또는 게임 종료 측면에서) 모델은 n_samples 대체 노드를 선택하는 데 사용됩니다(그들은 리프 노드가 됩니다). 연속 반복의 노드). 새 노드가 트리에 추가되기 때문에 확장 단계라고 합니다. 그런 다음 현재 시뮬레이션에서 더 이상 노드를 탐색하지 않지만 리프 q_value는 다음 시뮬레이션 단계인 백업으로 전송됩니다.
백업은 각 시뮬레이션의 마지막 단계입니다. 백업 중에 리프 노드가 최종 상태인 경우 최종 보상이 계산됩니다. 그렇지 않으면 리프 q 값이 예상 보상으로 사용됩니다. 그런 다음 보상은 상태 q_values를 업데이트하고 방문 카운터 N(s, a)를 업데이트하는 시뮬레이션 궤적에서 역전파됩니다. 아래 스니펫에서는 보상 역전파에 대한 코드를 보여줍니다.
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
향상된 정책 계산
모든 시뮬레이션이 실행되고 MCTS가 가까운 미래에 대한 흥미로운 스냅샷을 제공하면 예측된 노드와 관련된 정책을 업데이트하고 반환하여 교육 중에 사용할 수 있도록 해야 합니다. 개선된 정책은 에 설명된 방법에 따라 휴버트 외, 큰 작업 공간을 관리하는 데 사용됩니다. 실제로 작은 검색 공간의 경우 MCTS 중에 행동 공간에서 무작위로 행동을 샘플링하고 그 영향을 평가하는 것이 가능합니다. 훨씬 더 큰 작업 공간에서 유사한 접근 방식을 사용하면 모든 경로가 서로 다른 경로로 분기되며 의미 있는 통계를 얻은 다음 정책을 업데이트하려면 무한한 양의 경로가 필요합니다. 여기에서 우리는 분산을 피하기 위해 sample-MCTS를 사용하고 있기 때문에, 즉 n_samples 작업은 모델 정책에 따라 샘플링되고 MCTS는 트리를 탐색하는 동안 샘플링된 작업 중 하나를 선택하기 때문에 계산할 때 샘플 수정을 고려해야 합니다. 모델을 교육하는 동안 사용될 최종 업데이트된 정책입니다.
실제로 개선된 정책은 다음과 같이 계산됩니다.
어디에
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
구현 시 N_s_a 텐서에서 정책을 계산한 후 원래 작업 텐서에 다시 매핑해야 합니다. 실제로 N_s_a는 모델에서 샘플링된 작업만 고려하는 반면 최종 정책에는 탐색되지 않은 작업에 대한 확률도 포함되어야 합니다.
ChatGPT 학습 알고리즘과의 차이점
AlphaTensor는 DeepMind의 인공 지능 방법인 AlphaGo/AlphaZero 제품군의 최신 멤버입니다. 이러한 방법은 MCTS(Monte Carlo Tree Search) 알고리즘을 기반으로 하며, 점점 더 복잡해지는 작업을 처리하기 위해 DeepMind에 의해 개선되고 향상되었습니다. 놀라운 성능으로 많은 화제를 불러일으킨 또 다른 AI 시스템인 OpenAI의 ChatGPT는 RLHF(Reinforcement Learning with Human Feedback)라는 다른 접근 방식으로 훈련되었습니다.
RLHF는 일련의 서면 지침을 따르도록 언어 모델을 조정하는 데 사용되는 미세 조정 기술입니다. 인간의 선호도를 보상 신호로 사용하여 모델을 미세 조정함으로써 언어 모델의 동작을 '인간 가치'라는 보다 광범위한 개념이 아닌 특정 그룹의 사람들이 명시한 선호도에 맞춥니다.
반대로 MCTS는 게임에서 최적의 동작을 결정하는 데 사용되는 트리 기반 검색 알고리즘입니다. 잠재적인 움직임을 시뮬레이션하고 결과에 따라 각 움직임의 값을 업데이트하여 최상의 움직임을 선택하도록 안내합니다.
RLHF는 사람이 작성한 시연과 AI 모델 간의 사람이 레이블을 지정한 비교에서 데이터를 수집하고 특정 그룹의 선호도를 예측하는 보상 모델을 훈련합니다. 그런 다음 보상 모델을 사용하여 AI 모델을 미세 조정합니다. 반면에 MCTS는 시뮬레이션과 평가를 사용하여 최상의 결정을 결정합니다.
접근 방식은 다르지만 RLHF와 MCTS도 유사점이 있습니다. 두 인공 지능 기술 모두 의사 결정 및 문제 해결 방법을 사용하고 시행 착오 방식을 사용하여 다양한 옵션을 탐색하고 사용 가능한 정보를 기반으로 결정을 내립니다. 둘 다 더 많은 정보와 경험이 수집됨에 따라 시간이 지남에 따라 개선되는 반복 프로세스이기도 합니다.
RLHF와 MCTS 사이의 선택은 당면한 작업에 따라 다릅니다. RLHF는 모델 성능을 평가하기 위한 명확한 메트릭이 없을 때 이상적이며, MCTS는 미래에 대한 지식과 탐색이 모델에 상당한 이점을 제공하는 게임과 같은 작업에서 효과적인 것으로 입증되었습니다.
AlphaTensor 교육을 위한 코드 최적화
AlphaTensor 훈련 알고리즘을 구현하려면 훈련 속도와 메모리 소비 간의 완벽한 절충안을 찾아야 합니다. 모델 섹션에서 볼 수 있듯이 액션 토큰화를 고려하는 것만으로도 많은 메모리를 절약할 수 있지만 지나치게 공격적인 액션 공간 축소는 정확도 저하와 성능 저하로 이어질 수 있습니다. 후자는 모든 토큰이 모델 디코더에 의해 자동 회귀 방식으로 순차적으로 생성되기 때문에 발생합니다. 따라서 추론 시간은 작업 공간의 소프트맥스가 더 이상 병목 현상이 아닌 경우 작업당 토큰 수에 따라 선형적으로 증가합니다.
AlphaTensor 교육을 설정할 때 연기 프로세스를 처리하는 데 주요 어려움이 발견되었습니다. 텐서가 올바른 형식으로 저장되지 않으면 MCTS가 제어되지 않은 메모리 사용량 증가를 쉽게 유발할 수 있습니다. 반면에 각 시뮬레이션 중에 저장된 텐서의 수가 너무 많이 줄어들면 MCTS는 필요한 상태를 다시 계산하는 데 무한한 시간을 소비할 수 있습니다.
가능한 미래 시나리오를 살펴봄으로써 게임을 탐색하는 게임 시뮬레이션 단계의 예를 들어보겠습니다. 각 상태에 대해 모델에서 생성된 작업을 저장하지 않고 정책에서 작업을 샘플링하는 데 사용된 무작위 시드만 저장하기로 결정한 경우 트리 노드를 탐색할 때마다 정책을 다시 계산해야 하며 그런 다음 작업을 샘플링합니다. 분명히 우리는 MCTS 탐색 병렬화의 경우 시간을 절약하고 여러 프로세스 간의 모델 공유를 관리할 필요가 없도록 샘플링된 작업을 저장하기로 결정했습니다. 그러나 액션을 저장하는 것만으로는 충분히 효율적인 액션 단계를 얻을 수 없었습니다. 실제로 n_steps 액션을 (u, v, w) 삼중항으로 변환하고, 게임 텐서 상태를 줄이고, n_samples 액션에서 새로운 3D 텐서를 생성하는 시간은 전체 훈련에 쉽게 병목 현상이 될 수 있습니다. 둘째, 샘플링된 각 작업에 대해 가능한 모든 미래 상태를 저장하고 싶지 않았습니다. 이는 알고리즘에서 사용하는 메모리에 큰 영향을 미치기 때문입니다. n_samples=32, n=7, N=5로 설정하고 N은 우리가 줄이고자 하는 정사각 행렬 곱의 크기이고 n은 모델이 기억하는 이전 동작의 수임을 기억해 봅시다. 이 상황에서 각 상태 텐서는 (8, 25, 25, 25) 형식을 가지며, 여기에 32를 곱하면 32가 됩니다.8252525그래프의 각 노드에 대해 4바이트. 이제 확장 단계의 각 시뮬레이션이 새 노드(및 n_sim=200)를 생성한다는 점을 고려하면 최종 메모리 소비량은 200이 됩니다.328252525*4 = 첫 번째 MCTS 노드만 3.2GB입니다. 최악의 시나리오에서 작동하는 max_rank 노드(여기서 max_rank=150)를 탐색하는 동안 총 메모리 소비량은 150 * 3.2GB = RAM 메모리(또는 모든 텐서가 GPU에 저장된 경우 GPU 메모리)에서 480GB가 됩니다. . 128GB RAM과 48GB GPU 메모리가 장착된 워크스테이션에서 교육을 실행했기 때문에 메모리 소비를 줄여야 했습니다.
실행 시간을 늘리고 싶지 않았기 때문에 생성된 상태 텐서의 중복성을 활용하는 최적화를 채택했습니다. 실제로, 텐서는 n-1개의 이전 작업을 공통으로 갖고 있으며, 이는 한 번 저장될 수 있으며 저장된 각 텐서에 대해 반복되지 않습니다. 이로 인해 메모리가 2/7~28% 감소하며, 이는 최악의 경우 137GB를 저장할 수 있음을 의미합니다. 이 시점에서는 트리의 사용되지 않는 부분(예: 선택되지 않은 궤적)을 잘라내고 텐서를 CPU 메모리에 저장함으로써 훈련 중에 발생하는 메모리 오류를 방지할 수 있었습니다.
이제 OpenAlphaTensor가 오픈 소스가 되면서 추가 개발을 위한 몇 가지 흥미로운 방법이 열렸습니다.
자연스러운 진행은 대상 하드웨어 장치에서 OpenAlphaTensor를 미세 조정하는 것입니다. 이는 매우 경쟁력 있는 컴퓨팅 성능으로 이어질 것으로 예상됩니다. 다양한 하드웨어에서 OpenAlphaTensor의 성능에 대해 더 자세히 게시할 예정입니다. GitHub의. 이 기사를 작성할 당시 OpenAlphaTensor는 교육을 받고 있었습니다.
또 다른 중요한 발전은 사용자가 에지 장치에 최적화된 알고리즘을 구축할 수 있도록 하는 원격 컴파일 지원입니다. 이는 OpenAlphaTensor 모델을 서버에 저장하여 달성할 수 있으며 행렬 곱셈 알고리즘은 다른 하드웨어에서 평가됩니다.
대기 시간 기반 보상 보정을 계산하기 위해 다른 컴파일러에 대한 지원을 확장하는 것도 중요할 수 있습니다. 서로 다른 컴파일러는 주어진 하드웨어에서 서로 다른 최적화된 알고리즘으로 이어질 수 있습니다. 예를 들어, DeepMind 논문은 TPU 및 Nvidia GPU에서 JAX 및 XLA 컴파일러를 사용하여 유망한 결과를 보여주었습니다. Nvidia의 NCCL 또는 CPU의 LLVM을 사용하여 이를 평가하는 것은 흥미로울 것입니다.
마지막으로, 더 큰 매트릭스 크기를 지원하기 위해 모델 및 교육 알고리즘을 확장하는 것이 주요 공개 과제로 남아 있습니다. 현재 OpenAlphaTensor는 최대 행렬 크기 5를 지원하지만 더 큰 행렬 곱셈을 크기가 5보다 작은 작은 MM 그룹으로 분할하여 적용할 수 있습니다. 전체 MM은 이론적으로 더 나은 결과를 가져올 수 있습니다.
디에고 피오리 모든 개발자 툴킷의 일부로 AI 최적화를 만드는 데 전념하는 회사인 Nebuly AI의 CTO입니다.
- SEO 기반 콘텐츠 및 PR 배포. 오늘 증폭하십시오.
- 플라토 블록체인. Web3 메타버스 인텔리전스. 지식 증폭. 여기에서 액세스하십시오.
- 출처: 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
- :이다
- ][피
- $UP
- 1
- 3d
- 8
- a
- 할 수 있는
- 소개
- 위의
- 절대
- 가속하는
- 에 따르면
- 따라서
- 계정
- 달성
- 달성
- 동작
- 행위
- 실제로
- 추가
- 추가
- 조정
- 채택
- 전진
- 이점
- 후
- 에이전트
- 집합
- 적극적인
- AI
- AI 시스템
- 목표
- 연산
- 알고리즘
- All
- 허용
- 수
- 혼자
- 이미
- 대안
- 중
- 양
- 분석하다
- 과
- 다른
- 적용된
- 접근
- 구혼
- 아키텍처
- 있군요
- 기사
- 인조의
- 인공 지능
- AS
- 할당 된
- 관련
- At
- 자동화
- 가능
- 피하고
- 뒤로
- 백업
- 기반으로
- 원래
- 기초
- BE
- 때문에
- 된다
- 전에
- 존재
- 이하
- 기준
- BEST
- 더 나은
- 사이에
- 그 너머
- 판
- 보드 게임
- 묶인
- 더 넓은
- BT
- 빌드
- 내장
- by
- 라는
- CAN
- 케이스
- 원인
- 발생
- 어떤
- 도전
- 도전
- 이전 단계로 돌아가기
- 채널
- ChatGPT
- 아이
- 선택
- 선택
- 선택
- 인용
- 선명한
- 명확하게
- 암호
- 수집하다
- 결합
- 저지른
- 공통의
- 회사
- 비교
- 경쟁력
- 복잡한
- 복잡성
- 구성 요소들
- 구성
- 타협
- 계산
- 계산력
- 계산
- 컴퓨팅
- 개념
- 개념적으로
- 조건
- 자신
- 고려
- 고려
- 치고는
- 고려하다
- 소비
- 이 포함되어 있습니다
- 계속
- 대조
- 변환
- 핵심
- 동
- 대응
- 수
- 계수기
- CPU
- 생성
- 만들기
- 기준
- CTO (최고 기술 담당자)
- Current
- 현재
- 데이터
- 취급
- 결정하다
- 결정된
- 결정
- 의사 결정
- 결정
- 깊은
- 깊은 학습
- Deepmind
- 따라
- 기술 된
- 결정
- 개발자
- 개발
- 장치
- 디바이스
- DICT
- 다른
- 어려움
- 외형 치수
- 치수
- 직접
- 발견
- 발견
- 논의 된
- 분포
- 분할 된
- 아래 (down)
- 드롭
- ...동안
- e
- 마다
- 이전
- 용이하게
- Edge
- 유효한
- 효율적인
- 중
- 요소
- 요소
- 임베디드
- 종료
- 강화
- 거대한
- 충분히
- 항목
- 오류
- 견적
- 예상
- 에테르 (ETH)
- 평가
- 평가
- 평가
- 평가
- 조차
- 모든
- 예
- 예
- 흥미 진진한
- 실행
- 확장
- 기대하는
- 경험
- 설명
- 설명
- 공격
- 탐구
- 탐험
- 탐험 한
- 탐색
- 표현
- 확장
- 연장
- 매우
- 꽤
- 가족
- 빠른
- 피드백
- 를
- 그림
- 최후의
- 발견
- 먼저,
- 흙손
- 초점
- 따라
- 수행원
- 발자국
- 럭셔리
- 형태
- 체재
- 공식
- 발견
- 에
- 가득 찬
- 기능
- 기본적인
- 추가
- 추가 개발
- 미래
- 경기
- Games
- 생성
- 생성
- 생성
- 생성
- 얻을
- 점점
- 주기
- 주어진
- 기부
- 골
- 간다
- 좋은
- GPU
- GPU
- 그래프
- 큰
- 그룹
- 여러 떼
- 성장
- 성장
- 안내
- 손
- 처리
- 일이
- 발생
- 하드웨어
- 하드웨어 장치
- 하드웨어 장치
- 있다
- 데
- 여기에서 지금 확인해 보세요.
- 최고
- 수평선
- 방법
- How To
- 그러나
- HTTPS
- 거대한
- 사람의
- i
- 악
- 이상
- IDX
- 영상
- 영향
- 구현
- 이행
- 중대한
- 개선
- 개선하는
- in
- 증가
- 증가
- 더욱 더
- 독립
- 색인
- 정보
- 처음에는
- 입력
- 를 받아야 하는 미국 여행자
- 명령
- 인텔리전스
- 흥미있는
- 내부의
- 소개
- 직관
- IT
- 되풀이
- 그
- 그 자체
- JPG
- 너 겟츠
- 유지
- 키
- 지식
- 알려진
- 언어
- 넓은
- 큰
- 성
- 숨어 있음
- 최근
- 층
- 레이어
- 리드
- 배운
- 배우기
- 링크드인
- 명부
- 보기
- 찾고
- 롯
- 만든
- 본관
- 주요한
- 확인
- 유튜브 영상을 만드는 것은
- 관리
- 관리
- .
- 지도
- 매핑
- 매트릭스
- 문제
- 최고
- 의미
- 의미있는
- 방법
- 회원
- 메모리
- 방법
- 방법
- 메트릭
- 누락
- 혼합물
- 모델
- 모델
- 수정
- 모듈
- 배우기
- 보다 효율적으로
- 또한
- 가장
- 움직임
- 이동
- 곱
- 자연의
- 자연
- 가까운
- 필요한
- 필요
- 필요
- 부정
- 네트워크
- 신경
- 신경망
- 신제품
- 다음 것
- nlp
- 노드
- 노드
- 비전문가
- 개념
- 번호
- 엔비디아
- 획득
- of
- 제공
- on
- ONE
- 열 수
- 오픈 소스
- OpenAI
- 조작
- 행정부
- 최적의
- 최적화
- 최적화
- 최적화
- 옵션
- 실물
- 기타
- 그렇지 않으면
- 출력
- 전체
- 서
- 서류
- 매개 변수
- 부품
- 특별한
- 특별히
- 부품
- 사람들
- 완전한
- 성능
- 실행할 수 있는
- 상
- 개
- 플라톤
- 플라톤 데이터 인텔리전스
- 플라토데이터
- 연극
- 플레이어
- 연주
- 포인트 적립
- 정책
- 정책
- 위치
- 가능한
- 가능성
- 힘
- 실용적인
- 연습
- 예측
- 예측
- 환경 설정
- 제시
- 너무 이른
- 확률
- 아마
- 문제
- 방법
- 프로세스
- 생산
- 생산
- 프로덕트
- 진행
- 진보
- 장래가 촉망되는
- 제안 된
- 입증 가능하게
- 증명 된
- 게시
- 출판
- 램
- 닥치는대로의
- 순위
- 차라리
- 도달
- 도달하다
- 최근에
- 감소
- 감소
- 감소
- 세련된
- 강화 학습
- 출시
- 나머지
- 유적
- 주목할 만한
- 기억
- 먼
- 반복
- 대표
- 대표
- 필수
- 필요
- 책임
- 한정된
- 결과
- 결과
- 결과
- return
- 반품
- 혁명적 인
- 보상
- 열
- rt
- 달리기
- s
- 같은
- 찜하기
- 절약
- 대본
- 시나리오
- 계획
- 검색
- 둘째
- 섹션
- 씨
- 선택된
- 선택
- 선택
- 본인
- 세트
- 설정
- 몇몇의
- 셰이프
- 공유
- 짧은
- 영상을
- 표시
- 표시
- 쇼
- 신호
- 상당한
- 크게
- 비슷한
- 유사성
- 단순, 간단, 편리
- 간단
- 간단히
- 시뮬레이션
- 이후
- 사태
- 크기
- 크기
- 작은
- 작은
- 스냅 사진
- So
- 해결책
- 풀다
- 해결
- 일부
- 출처
- 스페이스 버튼
- 공간
- 구체적인
- 구체적으로
- 지정
- 속도
- 지출
- 지출
- 분열
- 광장
- 쌓인
- 단계
- 표준
- 스타트
- 시작
- 주 정부
- 최첨단
- 정해진
- 미국
- 통계
- 단계
- 단계
- 멎는
- 저장
- 저장
- 상점
- 똑 바른
- 성공한
- 이러한
- SUPPORT
- 지원
- 인조
- 합성 데이터
- 종합적으로
- 체계
- 시스템은
- 맞춤형
- 받아
- 소요
- 복용
- 목표
- 태스크
- 작업
- 기법
- 단말기
- 조건
- 그
- XNUMXD덴탈의
- 미래
- 그래프
- 정보
- 국가
- 그들의
- 그들
- 그것에 의하여
- 따라서
- Bowman의
- 제삼
- 세
- 삼차원의
- 을 통하여
- 시간
- 시간이 많이 걸리는
- 에
- 함께
- 토큰
- 토큰 화
- 토큰 화 된
- 토큰
- 너무
- 툴킷
- 상단
- 토치
- 금액
- 전통적인
- Train
- 훈련 된
- 트레이닝
- 기차
- 사선
- 변환
- 치료
- 참된
- 이해
- 우주
- 미사용의
- 업데이트
- 업데이트
- 업데이트
- 업데이트
- 업그레이드
- us
- 용법
- 사용
- 사용자
- 보통
- 가치
- 마케팅은:
- 여러
- 버전
- Video
- 비디오 게임
- 방문
- 방문
- W
- 방법..
- 뭐
- 어느
- 동안
- 크게
- 위키 백과
- 의지
- 승리
- 과
- 말
- 워크 스테이션
- 가치
- 겠지
- 쓰기
- 쓴
- X
- 제퍼 넷
- 제로