이 기사는 Huawei Cloud 커뮤니티 " 대형 모델 LLM의 분산 교육 "(저자: Hua Shanghua_Lancer) 에서 공유되었습니다 .
언어 모델 매개변수와 필요한 훈련 데이터의 양이 급격히 증가함에 따라 단일 시스템의 제한된 리소스로는 더 이상 대규모 언어 모델 훈련 요구 사항을 충족할 수 없습니다. 대규모 컴퓨팅 및 메모리 리소스 요구 사항의 문제를 해결하려면 분산 교육(Distributed Training) 시스템을 설계해야 합니다.
분산 훈련 시스템 환경에서는 모델 훈련 작업을 여러 하위 작업으로 분할하고 하위 작업을 여러 컴퓨팅 장치에 분산하여 리소스 병목 현상을 해결해야 합니다. 하지만 수만 개의 컴퓨팅 가속 칩이 포함된 클러스터를 사용하여 수천억 또는 심지어 수조 개의 모델 매개변수가 있는 대규모 언어 모델을 훈련하려면 어떻게 해야 할까요? 여기에는 클러스터 아키텍처, 병렬 전략, 모델 아키텍처, 메모리 최적화 및 컴퓨팅 최적화와 같은 일련의 기술이 포함됩니다.
분산 머신러닝 시스템의 기본 개념, 분산 학습 클러스터 아키텍처, 분산 학습 병렬 전략 등을 자세히 소개하고, DeepSpeed를 예로 들어 대규모 언어 모델을 클러스터에서 학습하는 방법을 소개하겠습니다.
1. 분산훈련 개요
분산 훈련은 기계 학습 또는 딥 러닝 모델 훈련 작업을 여러 하위 작업으로 분해하고 여러 컴퓨팅 장치에서 병렬로 훈련하는 것을 의미합니다. 그림 1은 단일 컴퓨팅 장치와 다중 컴퓨팅 장치의 예를 제공합니다. 여기서 컴퓨팅 장치는 중앙 처리 장치(CPU), 그래픽 처리 장치(GPU) 또는 텐서 처리 장치(Tensor Process Unit)일 수 있습니다. TPU)는 신경망 프로세서(Neural network Processor Unit, NPU)일 수도 있다.
메모리는 동일한 서버 내의 여러 컴퓨팅 장치 간에 공유되지 않을 수 있으므로 이러한 컴퓨팅 장치가 하나의 서버에 있든 여러 서버에 있든 관계없이 해당 시스템 아키텍처는 분산 시스템 범주에 속합니다. 모델 훈련 작업에는 종종 하나의 컴퓨팅 장치를 사용하여 완료할 수 있는 입력으로 많은 수의 훈련 샘플이 있거나, 전체 모델 훈련 작업을 하위 작업으로 분할하고 다른 컴퓨팅 장치에 배포하여 병렬 컴퓨팅을 달성할 수 있습니다.
그 후, 최종적으로 단일 컴퓨팅 장치와 동등한 계산 결과를 얻기 위해서는 각 컴퓨팅 장치의 출력을 결합해야 합니다. 각 컴퓨팅 장치는 하위 작업만 담당하면 되고 여러 컴퓨팅 장치가 병렬로 실행될 수 있으므로 전체 계산을 더 빠르게 완료하고 궁극적으로 전체 컴퓨팅 프로세스를 가속화할 수 있습니다.
그림 1 단일 컴퓨팅 장치 컴퓨팅 및 다중 컴퓨팅 장치의 예
사람들이 분산 훈련 시스템을 설계하도록 유도하는 가장 중요한 이유 중 하나는 단일 컴퓨팅 장치의 컴퓨팅 성능이 더 이상 모델 훈련을 지원하기에 충분하지 않기 때문입니다. 그림 2는 기계 학습 모델의 컴퓨팅 성능 요구 사항과 단일 컴퓨팅 장치가 동일한 기간 동안 제공할 수 있는 컴퓨팅 성능을 보여줍니다. 그림에서 볼 수 있듯이 머신러닝 모델은 2013년 AlexNet을 시작으로 2022년 5,400억 개의 매개변수를 갖춘 Palm 모델까지 18개월마다 56회의 속도로 발전하고 있습니다. 모델 매개변수 규모가 증가함에 따라 훈련 데이터 양에 대한 요구 사항도 기하급수적으로 증가하여 컴퓨팅 성능에 대한 수요가 강화됩니다.
그러나 최근 몇 년간 CPU 컴퓨팅 파워의 증가폭은 무어의 법칙보다 훨씬 낮습니다. 컴퓨팅 가속 장치(예: GPU, TPU 등)가 머신러닝 모델에 많은 양의 컴퓨팅 파워를 제공하고 있음에도 불구하고 그 성장률은 여전히 낮습니다. 18개월마다 두 배로 증가한다는 무어의 법칙을 초과하지 않았습니다. 기계 학습 모델의 개발을 충족하려면 분산 교육 시스템만이 모델의 증가하는 컴퓨팅 성능 요구 사항을 충족할 수 있습니다.
그림 2 머신러닝 모델 매개변수의 성장과 컴퓨팅 하드웨어의 컴퓨팅 파워 성장 비교
분산 훈련의 전반적인 목표는 전체 훈련 속도를 높이고 모델 훈련의 전체 시간을 줄이는 것입니다. 총 훈련 속도는 다음 공식을 사용하여 간략하게 추정할 수 있습니다.
총 훈련 속도 ∝ 단일 장치 컴퓨팅 속도 × 총 컴퓨팅 장치 수 × 다중 장치 가속 비율
그 중 단일 장치의 컴퓨팅 속도는 주로 단일 컴퓨팅 가속 칩의 컴퓨팅 속도와 데이터 I/O 기능에 따라 결정됩니다. 단일 장치의 학습 효율성을 최적화하기 위한 주요 기술 수단에는 혼합 정밀 교육, 운영자가 포함됩니다. 융합, 그래디언트 축적 등 분산 훈련 시스템의 컴퓨팅 장치 수가 많을수록 이론상 최대 컴퓨팅 속도는 높아집니다. 그러나 통신 효율성의 영향을 받아 컴퓨팅 장치 수가 늘어나면 속도가 빨라집니다. 가속 비율의 감소는 계산에 의해 결정되며, 최적화를 위한 알고리즘과 네트워크 토폴로지를 결합하여 통신 효율성이 결정됩니다. 분산 훈련 병렬 전략의 주요 목표는 다중 장치 가속 비율을 향상시키는 것입니다. 분산 훈련 시스템.
대규모 언어 모델 매개변수의 양과 사용되는 데이터의 양이 매우 크기 때문에 분산 학습 아키텍처를 사용하여 학습을 완료합니다. 문서 [5]에서는 NVIDIA V100 GPU를 사용하는 GPT-3의 학습 프로세스만 소개합니다. 문서 [31]에서는 OPT가 992개의 NVIDIA A100 80G GPU를 사용하고 완전 공유 데이터 병렬 처리(Fully Shared Data Parallel) [129] 및 Megatron-LM Tensor Parallelism [130]을 채택한다고 소개합니다. , 전체 훈련 시간은 거의 2개월입니다.
BLOOM[33] 모델 연구자들은 사용된 하드웨어 및 시스템 아키텍처에 대한 자세한 내용을 공개했습니다. 모델 훈련에는 총 3.5개월이 걸렸으며 48개의 컴퓨팅 노드를 사용했습니다. 각 노드에는 8개의 NVIDIA A100 80G GPU(총 384개의 GPU)가 포함되어 있으며 노드 내 GPU 간 통신을 위해 4*NVLink를 사용합니다. 노드는 4개의 Omni-Path 100Gbps 네트워크 카드로 구축된 향상된 8차원 하이퍼큐브 글로벌 토폴로지 네트워크를 사용하여 서로 통신합니다.
문헌[37]은 LLaMA 모델 훈련에 사용되는 클러스터의 특정 구성 및 네트워크 토폴로지를 제공하지 않지만 다양한 매개변수 규모에 대한 총 GPU 시간을 제공합니다. LLaMA 모델 훈련은 A100-80GB GPU를 사용하고, LLaMA-7B 모델 훈련에는 82432 GPU 시간이 필요하고, LLaMA-13B 모델 훈련에는 135168 GPU 시간이 필요하며, LLaMA-33B 모델 훈련에는 530432 GPU 시간이 필요하고, LLaMA-65B 모델 훈련 비용은 최대 1022362 GPU입니다. 시간. LLaMA가 사용하는 학습 데이터의 양은 OPT 및 BLOOM 모델에 비해 훨씬 많기 때문에 모델 매개변수의 수는 위의 두 모델에 비해 훨씬 적지만 필요한 계산량은 여전히 엄청납니다.
분산 훈련 시스템을 사용하면 대규모 언어 모델의 훈련 주기가 단일 컴퓨팅 장치의 수십 년에서 수천 개의 컴퓨팅 장치를 사용하는 수십 일로 단축될 수 있습니다. 그러나 분산 훈련 시스템은 클러스터의 모든 리소스를 완전히 활용하여 훈련 프로세스를 가속화하고 훈련 주기를 단축하기 위해 컴퓨팅 벽, 비디오 메모리 벽 및 통신 벽과 같은 다양한 과제를 극복해야 합니다.
• 계산 벽: 단일 컴퓨팅 장치가 제공할 수 있는 컴퓨팅 성능과 대규모 언어 모델에 필요한 총 계산량 사이에는 큰 차이가 있습니다. 2022년 3월에 출시된 NVIDIA H100 SXM은 단일 카드 FP16 컴퓨팅 성능이 2000 TFLOP에 불과한 반면, GPT-3에는
314 ZFLOP의 총 컴퓨팅 성능이 필요합니다. 둘 사이의 차이는 8자리입니다.
• 비디오 메모리 벽: 단일 컴퓨팅 장치는 대규모 언어 모델의 매개변수를 완전히 저장할 수 없습니다. GPT-3에는 1,750억 개의 매개변수가 포함되어 있습니다. FP16 형식으로 저장하려면 700GB의 컴퓨팅 장치 메모리 공간이 필요하며 NVIDIA H100 GPU에는 80GB의 비디오 메모리만 있습니다.
• 통신 벽: 분산 훈련 시스템의 컴퓨팅 장치 간에 빈번한 매개변수 전송 및 동기화가 필요합니다. 통신 지연 및 대역폭 제한으로 인해 이는 교육 과정에서 병목 현상이 발생할 수 있습니다. GPT-3 훈련 과정에서 분산 시스템에 128개의 모델 복사본이 있는 경우 각 반복 중에 최소 89.6TB의 그래디언트 데이터를 전송해야 합니다. 2023년 8월 현재 단일 InfiniBand 링크는 800Gb/s 이하의 대역폭만 제공할 수 있습니다. 컴퓨팅 벽과 비디오 메모리 벽은 단일 컴퓨팅 장치의 제한된 컴퓨팅 및 저장 기능과 모델의 거대한 컴퓨팅 및 저장 요구 사항 간의 충돌로 인해 발생합니다. 이 문제는 분산 학습 방법을 사용하여 해결할 수 있지만 분산 학습은 통신 벽이라는 문제에 직면하게 됩니다. 여러 기계와 카드를 훈련시키면서 이러한 문제가 점차 나타났습니다. 대형 모델의 매개변수가 증가하면 해당 클러스터 크기도 증가하며 이러한 문제는 더욱 두드러집니다. 동시에 대규모 클러스터를 장기간 훈련하는 경우 장비 오류로 인해 훈련 프로세스가 영향을 받거나 중단될 수 있으며, 이로 인해 분산 시스템에 대한 수요도 높아집니다.
2. 분산 훈련 병렬 전략
분산 학습 시스템의 목표는 단일 노드 모델 학습을 동등한 분산 병렬 모델 학습으로 변환하는 것입니다. 대규모 언어 모델의 경우 학습 프로세스는 데이터 및 손실 함수를 기반으로 하는 최적화 알고리즘을 사용하여 신경망 모델 매개변수를 업데이트하는 프로세스입니다. 단일 노드 모델 훈련 시스템의 구조는 그림 3에 나와 있으며 주로 데이터와 모델의 두 부분으로 구성됩니다. 학습 프로세스는 여러 데이터 미니 배치(Mini-batch)에 의해 완료됩니다.
그림의 데이터는 작은 데이터 배치를 나타냅니다. 훈련 시스템은 작은 배치의 데이터를 사용하여 손실 함수 및 최적화 알고리즘을 기반으로 기울기를 생성하여 모델 매개변수를 수정합니다. 대규모 언어 모델을 위한 다층 신경망의 실행 과정은 계산 그래프(Computational Graph)로 표현될 수 있습니다. 이 그래프에는 여러 개의 상호 연결된 연산자(연산자)가 있으며, 각 연산자는 신경망 계층(신경망 계층)을 구현하며 매개변수는 훈련 중에 이 계층에서 업데이트된 가중치를 나타냅니다.
그림 3 단일 장치 모델 훈련 시스템
계산 그래프의 실행 프로세스는 순방향 계산과 역방향 계산의 두 단계로 나눌 수 있습니다. 순방향 계산 프로세스는 첫 번째 연산자로 데이터를 읽어 해당 출력 구조를 계산한 다음 마지막 연산자가 끝날 때까지 순방향 계산 프로세스를 반복하는 것입니다. 역방향 계산 과정은 최적화 함수와 손실을 기반으로 하며 각 연산자는 차례로 기울기를 계산하고 기울기를 사용하여 로컬 매개변수를 업데이트합니다. 역 계산이 완료되고 데이터 미니 배치 계산이 완료된 후 시스템은 다음 데이터 미니 배치를 읽고 다음 라운드의 모델 매개변수 업데이트를 계속합니다.
단일 장치 모델 훈련 시스템의 과정을 보면, 병렬 가속이 수행되면 데이터와 모델이라는 두 가지 차원에서 고려할 수 있음을 알 수 있습니다. 첫째, 데이터를 분할(Partition)할 수 있고, 동일한 모델을 여러 장치에 복사할 수 있으며, 서로 다른 데이터 샤드를 병렬로 실행할 수 있습니다. 이 방법을 일반적으로 데이터 병렬성(DP)이라고 합니다. 모델을 분할할 수도 있고 모델의 연산자를 여러 장치에 분산하여 각각 완성할 수도 있습니다. 이 방법을 일반적으로 모델 병렬성(MP)이라고 합니다. 매우 대규모의 언어 모델을 훈련할 때 더 높은 수준의 병렬 처리를 달성하기 위해 데이터와 모델을 동시에 분할해야 하는 경우가 많습니다. 이 방법을 종종 하이브리드 병렬 처리(HP)라고 합니다.
2.1. 데이터 병렬성
데이터 병렬 시스템에서 각 컴퓨팅 장치는 전체 신경망 모델(모델 복제본)의 완전한 복사본을 갖습니다. 반복 시 각 컴퓨팅 장치에는 데이터 샘플 배치의 하위 집합만 할당되며 샘플 배치를 기반으로 합니다. 데이터의 하위 집합은 네트워크 모델의 순방향 계산에 사용됩니다. 배치의 훈련 샘플 수가 N이고, 병렬 계산에 M개의 컴퓨팅 장치가 사용되고, 각 컴퓨팅 장치에는 N/M개의 샘플이 할당된다고 가정합니다. 순방향 계산이 완료된 후 각 컴퓨팅 장치는 로컬 샘플을 기반으로 손실 오류를 계산하여 기울기 Gi(i는 가속기 카드 번호)를 얻고 로컬 기울기 Gi를 브로드캐스팅합니다. 모든 컴퓨팅 장치는 다른 가속 카드에서 제공하는 기울기 값을 집계한 다음 평균 기울기(ΣNi=1Gi)/N을 사용하여 모델을 업데이트하여 배치 훈련을 완료해야 합니다. 그림 4는 두 개의 컴퓨팅 장치로 구성된 데이터 병렬 훈련 시스템의 예를 보여줍니다.
그림 4 2노드 데이터 병렬 훈련 시스템의 예
데이터 병렬 훈련 시스템은 컴퓨팅 장비를 추가하여 전체 훈련 처리량과 초당 글로벌 배치 크기(Global Batch Size Per Second)를 효과적으로 향상시킬 수 있습니다. 단일 컴퓨팅 장치 훈련과 비교할 때 주요 차이점은 각 컴퓨팅 장치의 최종 결과가 모든 프로세스의 기울기의 평균이 되도록 역방향 계산의 기울기를 모든 컴퓨팅 장치에서 동기화해야 한다는 것입니다.
일반적인 신경망 프레임워크에는 TensorFlow DistributedStrategy, PyTorch Distributed, Horovod DistributedOptimizer 등을 포함한 특정 데이터 병렬 처리 구현이 있습니다. Transformer 아키텍처를 기반으로 하는 대규모 언어 모델의 각 연산자는 배치 데이터가 아닌 단일 데이터에 의존하므로 데이터 병렬 처리는 계산 논리에 영향을 미치지 않습니다. 일반적으로 각 훈련 장치의 순방향 계산은 독립적이며 계산 논리에 영향을 주지 않습니다. . 동기화 문제와 관련이 있습니다. 데이터 병렬 훈련은 가속 비율이 가장 높지만 각 장치에 모델 복사본을 백업해야 하며 비교적 많은 양의 비디오 메모리를 소비합니다.
단일 서버에서 여러 가속기 카드 훈련을 구현하기 위해 PyTorch DistributedDataParallel을 사용하는 코드는 다음과 같습니다. 먼저 DistributedSampler 클래스를 구성하여 데이터 세트의 샘플을 무작위로 중단하고 이를 다른 컴퓨팅 장치에 배포합니다.
클래스 DistributedSampler(샘플러):
def __init__(self, 데이터세트, num_replicas=없음, 순위=없음, shuffle=True, 시드=0):
num_replicas가 없음인 경우:
dist.is_available()이 아닌 경우:
raise RuntimeError("사용 가능한 배포 패키지가 필요합니다.")
num_replicas = dist.get_world_size()
순위가 없음인 경우:
dist.is_available()이 아닌 경우:
raise RuntimeError("사용 가능한 배포 패키지가 필요합니다.")
순위 = dist.get_rank()
self.dataset = 데이터세트 #dataset
self.num_replicas = num_replicas # 프로세스 수는 기본적으로 world_size(GPU 수)로 설정됩니다.
self.rank = 순위 # 현재 속한 프로세스/GPU
self.epoch = 0
self.num_samples = int(math.ceil(len(self.dataset) * 1.0 / self.num_replicas))
#프로세스당 샘플 수
self.total_size = self.num_samples * self.num_replicas #데이터 세트의 총 샘플 수
self.shuffle = shuffle # 데이터 세트를 섞을지 여부
self.seed = 씨앗
def __iter__(self):
# 1. 셔플 처리: 데이터 세트의 순서를 방해합니다.
self.shuffle인 경우:
# 시대와 시드를 기반으로 난독화
g = 토치.생성기()
# 여기서 self.seed는 고정된 값입니다. set_epoch로 self.epoch를 변경하면 초기화 시드가 변경될 수 있습니다.
# 이를 통해 각 에포크의 데이터 세트 순서를 서로 다르게 섞을 수 있으므로 각 에포크에서는
# 각 GPU는 서로 다른 데이터를 가져오므로 더 나은 훈련이 가능합니다.
g.manual_seed(self.seed + self.epoch)
인덱스 = torch.randperm(len(self.dataset), 생성기=g).tolist()
또 다른:
인덱스 = 목록(범위(len(self.dataset)))
# 데이터 보충
인덱스 += 인덱스[:(self.total_size - len(인덱스))]
len(indices) == self.total_size를 주장합니다.
# 데이터 할당
인덱스 = 인덱스[self.rank:self.total_size:self.num_replicas]
len(indices) == self.num_samples 주장
iter(인덱스) 반환
def __len__(자체):
self.num_samples를 반환합니다.
def set_epoch(self, epoch):
self.epoch = 에포크
DistributedSampler를 사용하여 다음과 같이 완전한 교육 프로그램 샘플 main.py를 구성합니다.
인수 가져오기
우리를 수입하다
수입 차단
수입 시간
수입 경고
numpy를 np로 가져오기
warnings.filterwarnings('무시')
수입 토치
torch.nn을 nn으로 가져오기
torch.nn.parallel 가져오기
torch.backends.cudnn을 cudnn으로 가져오기
torch.distributed를 dist로 가져오기
import torch.optim
torch.utils.data 가져오기
import torch.utils.data.distributed
torch.utils.data.distributed import DistributedSampler에서
모델에서 DeepLab 가져오기
데이터 세트 가져오기에서 Cityscapes
파서 = argparse.ArgumentParser(설명='DeepLab')
parser.add_argument('-j', '--workers', 기본값=4, 유형=int, Metavar='N',
help='데이터 로딩 작업자 수(기본값: 4)')
parser.add_argument('--epochs', 기본값=100, 유형=int, Metavar='N',
help='실행할 총 에포크 수')
parser.add_argument('--start-epoch', 기본값=0, 유형=int, Metavar='N',
help='수동 에포크 번호(다시 시작할 때 유용함)')
파서.add_argument('-b', '--batch-size', 기본값=3, 유형=int,
메타변수='N')
parser.add_argument('--local_rank', default=0, type=int, help='분산 훈련을 위한 노드 순위')
args = 파서.parse_args()
torch.distributed.init_process_group(backend="nccl") #초기화
print("학습에 GPU 사용: {}".format(args.local_rank))
# 모델 생성
모델 = DeepLab()
torch.cuda.set_device(args.local_rank) #현재 그래픽 카드
model = model.cuda() # 모델이 그래픽 카드에 배치됩니다.
모델 = torch.nn.parallel.DistributedDataParallel(model, device_ids=[args.local_rank],
output_device=args.local_rank, find_unused_parameters=True) # 데이터 병렬성
기준 = nn.CrossEntropyLoss().cuda()
최적화 프로그램 = torch.optim.SGD(model.parameters(), args.lr,
모멘텀=args.momentum, Weight_decay=args.weight_decay)
train_dataset = Cityscapes()
train_sampler = DistributedSampler(train_dataset) # 데이터 분산
train_loader = torch.utils.data.DataLoader(train_dataset, 배치_크기=args.batch_size,
shuffle=False, num_workers=args.workers, pin_memory=True, 샘플러=train_sampler)
다음 명령줄을 통해 위 프로그램을 시작합니다.
CUDA_VISIBLE_DEVICES=0,1 python -m torch.distributed.launch --nproc_per_node=2 main.py
2.2 모델 병렬성
모델 병렬화는 단일 노드의 메모리 부족 문제를 해결하는 데 자주 사용됩니다. 1,750억 개의 매개변수를 포함하는 GPT-3 모델을 예로 들어 보겠습니다. 모델의 각 매개변수가 32비트 부동 소수점 숫자로 표현된다면 모델은 700GB(즉, 175G × 4바이트)의 메모리를 차지해야 합니다. 16비트 부동 소수점 숫자로 표시되며 각 모델 사본에는 350GB의 메모리가 필요합니다. 엔비디아가 2022년 3월 출시한 H100 가속기 카드는 비디오 메모리 80GB만 지원해 모델 전체를 여기에 완전히 담을 수는 없다. 모델 병렬성은 계산 그래프의 관점에서 다음 두 가지 형태로 나눌 수 있습니다.
(1) 모델의 계층에 따라 서로 다른 장치로 분할합니다. 즉, 계층 간 병렬성 또는 연산자 간 병렬성(Inter-operator Parallelism), 파이프라인 병렬성(Pipeline Parallelism, PP)이라고도 합니다.
(2) 계산 계층의 매개변수를 서로 다른 장치, 즉 계층 내 병렬성 또는 연산자 내 병렬성(Intra-operator Parallelism)으로 분할합니다. 이는 텐서 병렬성(Tensor Parallelism, TP)이라고도 합니다.
그림 4.9에는 2노드 모델 병렬 훈련 시스템의 샘플이 나와 있습니다. 왼쪽은 파이프라인 병렬성이고, 모델의 여러 레이어는 여러 장치로 분할되어 있으며, 오른쪽은 텐서 병렬성이며, 동일한 레이어의 다른 매개변수입니다. 장치에서 여러 장치로 분할됩니다.
파이프라인 병렬성
파이프라인 병렬 처리(PP)는 모델의 각 계층을 세그먼트로 처리하고 각 세그먼트를 서로 다른 컴퓨팅 장치에 배포하여 이전 및 후속 단계가 파이프라인 및 배치에서 작동할 수 있도록 하는 병렬 컴퓨팅 전략입니다. 파이프라인 병렬화는 일반적으로 단일 컴퓨팅 장치의 메모리 부족 문제를 효과적으로 해결하기 위해 대규모 모델의 병렬 시스템에 적용됩니다. 그림 4.6은 순방향 계산과 역방향 계산을 포함하여 4개의 컴퓨팅 장치로 구성된 파이프라인 병렬 시스템을 보여줍니다. 그 중 F1, F2, F3 및 F4는 각각 서로 다른 장치에 있는 4개의 정방향 경로를 나타내고, B4, B3, B2 및 B1은 역시 4개의 서로 다른 장치에 있는 역방향 경로를 나타냅니다. 그러나 그림에서 볼 수 있듯이 계산 그래프의 다운스트림 장치(Downstream Device)는 자체 계산을 시작하기 전에 업스트림 장치(Upstream Device)가 계산을 완료할 때까지 오랫동안 유휴 상태를 유지해야 합니다. 작업.
그림 5 2노드 모델 병렬 훈련 시스템의 예
이러한 상황으로 인해 장치의 평균 사용량이 크게 감소하여 파이프라인 버블이라고도 알려진 모델 병렬성 버블이 형성되었습니다.
그림 6 파이프라인 병렬 예
순진한 파이프라인 전략에 의해 생성된 병렬 버블은 시스템이 컴퓨팅 리소스를 완전히 활용하지 못하게 하고 시스템의 전반적인 컴퓨팅 효율성을 감소시킵니다. 병렬 버블을 줄이기 위해 문헌[131]에서는 미니 배치를 더 작은 마이크로 배치로 나누고 파이프라인 병렬 방식을 사용하여 한 번에 하나의 마이크로 배치를 처리하는 GPipe 방법을 제안했습니다.
현재 단계의 계산이 완료되고 결과가 얻은 후 마이크로 배치의 결과가 다운스트림 장치로 전송되고 동시에 다음 마이크로 배치의 데이터가 처리되기 시작합니다. 어느 정도 평행한 거품. 그림 7GPipe 정책 파이프라인 병렬 예시. 그림에 표시된 대로 순방향 F1 계산은 F11, F12, F13, F14로 구분됩니다. 컴퓨팅 장치 1에서 F11의 계산이 완료된 후 컴퓨팅 장치 2에서 F21의 계산이 시작됩니다. 동시에 F12는 컴퓨팅 장치 1 계산에서 병렬로 시작됩니다. 원래 파이프라인 병렬 방법과 비교하여 GPipe 파이프라인 방법은 병렬 버블을 효과적으로 줄일 수 있습니다.
그림 7 GPipe 정책 파이프라인 병렬 예
GPipe 전략은 특정 병렬 버블을 줄일 수 있지만 역방향 계산은 미니 배치의 모든 순방향 계산이 완료된 후에만 시작할 수 있습니다. 따라서 여전히 많은 병렬 버블이 생성되어 시스템의 병렬 효율성이 감소합니다. Megatron-LM[132]은 하나의 순방향 채널과 하나의 역방향 채널로 구성된 1F1B 파이프라인 전략을 제안했습니다. 1F1B 파이프라인 전략은 작업 스케줄링 메커니즘을 도입하여 다운스트림 장치가 업스트림 계산을 기다리는 동안 다른 병렬 작업을 실행할 수 있도록 하여 장치 활용도를 향상시킵니다. 1F1B는 그림 8과 같이 비인터리브와 인터리브의 두 가지 스케줄링 방법을 제공합니다.
1F1B 비인터리브 스케줄링 모드는 세 단계로 나눌 수 있습니다. 첫 번째는 컴퓨팅 장치에서 다양한 수의 순방향 계산이 수행되는 워밍업 단계입니다. 다음 단계는 순방향-역방향 단계로, 컴퓨팅 장치가 순방향 계산을 수행한 후 역방향 계산을 순차적으로 수행합니다. 마지막 단계는 컴퓨팅 장치가 마지막 역방향 계산을 완료하는 역방향 단계입니다. GPipe 전략과 비교하여 비인터리브 스케줄링 모드는 메모리 절약 측면에서 더 나은 성능을 발휘합니다. 그러나 한 라운드의 계산을 완료하려면 GPipe 전략과 동일한 시간이 필요합니다.
1F1B 인터리브 스케줄링 모드에서는 마이크로 배치 수가 파이프라인 단계의 정수배가 되어야 합니다. 각 장치는 더 이상 여러 연속 레이어의 계산만을 담당하지 않지만 모델 너겟이라고 하는 여러 레이어의 하위 집합을 처리할 수 있습니다. 특히 이전 모델에서는 장치 1이 계층 1~4를 담당하고, 장치 2가 계층 5~8을 담당하는 식이었습니다. 그러나 새 모드에서는 장치 1이 계층 1, 2, 9, 10을 처리할 수 있고 장치 2가 계층 3, 4, 11, 12 등을 처리할 수 있습니다. 이 모드에서는 각 장치가 파이프라인의 여러 단계에 할당됩니다. 예를 들어, 장치 1은 준비 단계, 순방향 계산 단계 및 역방향 계산 단계의 일부 작업 하위 집합에 포함될 수 있습니다. 각 장치는 서로 다른 단계에서 컴퓨팅 작업을 병렬로 수행할 수 있으므로 파이프라인 병렬성을 더 잘 활용할 수 있습니다. 이 모드는 메모리 소비 측면에서 좋은 성능을 발휘할 뿐만 아니라 계산 효율성도 향상시켜 대형 모델용 병렬 시스템이 컴퓨팅 작업을 보다 효율적으로 완료할 수 있도록 해줍니다.
그림 8 1F1B 파이프라인 병렬 전략 예
PyTorch에는 파이프라인을 구현하기 위한 API 함수 Pipe도 포함되어 있습니다. 구체적인 구현은 "torch.distributed.pipeline.sync.Pipe" 클래스를 참조하세요. 이 API를 사용하면 다음과 같이 두 개의 서로 다른 컴퓨팅 장치에 배치된 두 개의 선형 레이어가 포함된 샘플을 구성할 수 있습니다.
{#
0단계. 먼저 RPC 프레임워크를 초기화해야 합니다.
os.environ['MASTER_ADDR'] = 'localhost'
os.environ['MASTER_PORT'] = '29500'
torch.distributed.rpc.init_rpc('작업자', 순위=0, world_size=1)
# 1단계: 두 개의 선형 레이어를 포함하는 모델 구축
fc1 = nn.Linear(16, 8).cuda(0)
fc2 = nn.Linear(8, 4).cuda(1)
# 2단계: 두 레이어를 nn.Sequential로 래핑
모델 = nn.Sequential(fc1, fc2)
# 3단계: 파이프 빌드(torch.distributed.pipeline.sync.Pipe)
모델 = 파이프(모델, 청크=8)
# 훈련/추론을 수행
입력 = torch.rand(16, 16).cuda(0)
출력_rref = 모델(입력)
}
텐서 병렬성
텐서 병렬성(TP)은 모델의 특정 구조 및 연산자 유형에 따라 매개변수를 여러 장치로 분할하는 방법과 분할 후 수학적 일관성을 보장하는 방법이라는 두 가지 문제를 해결해야 합니다. 대규모 언어 모델은 Transformer 구조를 기반으로 하며, Transformer 구조는 주로 임베디드 표현(Embedding), 행렬 곱셈(MatMul) 및 교차 엔트로피 손실(Cross Entropy Loss) 계산의 세 가지 연산자로 구성됩니다.
이 세 가지 유형의 연산자는 매우 다르며 해당 텐서 병렬 전략[130]은 매개변수를 다른 장치로 분할하도록 설계되어야 합니다. Embedding 연산자의 경우 총 어휘 수가 매우 많으면 단일 컴퓨팅 장치의 비디오 메모리가 Embedding 레이어 매개변수를 수용할 수 없습니다. 예를 들어 어휘 수가 64000이고 임베딩 표현 차원이 5120이며 유형이 32비트 정밀도 부동 소수점 숫자를 사용하는 경우 전체 매개변수 계층에 필요한 비디오 메모리는 약 64000 × 5120 × 4/1024입니다. /1024 = 1250MB이고 역그라디언트도 동일합니다. 1250MB가 필요하며 저장에만 거의 2.5GB가 필요합니다.
프리젠테이션 계층에 포함된 매개변수는 단어 차원에 따라 구분될 수 있으며, 각 컴퓨팅 장치는 단어 벡터의 일부만 저장하고 각 장치의 부분 단어 벡터를 요약하여 완전한 단어 벡터를 얻습니다. 그림 4.9는 단일 노드 임베딩과 2노드 텐서 병렬 처리의 개략도를 보여줍니다.
단일 노드에서 Embedding 작업을 수행하고, bz는 배치 크기(batch size)이고, Embedding의 매개변수 크기는 [word_size, Hidden_size]이며, [bz, Hidden_size] 텐서가 계산됩니다. 그림 4.9의 임베딩 텐서 병렬 예제는 임베딩 매개변수를 word_size 차원을 따라 두 개의 블록으로 나눕니다. 각 블록의 크기는 [word_size/2, Hidden_size]이며 각각 두 개의 장치에 저장됩니다. 각 노드가 자신의 단어 목록을 쿼리할 때 찾을 수 없으면 단어의 표현은 0입니다. 해당 장치를 쿼리한 후 마지막으로 AllReduce_Sum 통신을 통해 [bz, Hidden_size] 결과 텐서를 얻습니다. , 우리는 완전한 전체 결과에서 여기의 출력 결과가 단일 컴퓨팅 장치에서 실행된 결과와 일치한다는 것을 알 수 있습니다.
그림 9 2노드 임베딩 연산자 텐서 병렬 예제
행렬 곱셈의 텐서 병렬성(MatMul)은 행렬 블록 곱셈 원리를 최대한 활용해야 합니다. 예를 들어, 다음 행렬 곱셈 Y = X ×A를 구현하려면 X는 차원 M × N의 입력 행렬이고, A는 차원 N ×K의 매개변수 행렬이고, Y는 차원 M ×K의 결과 행렬입니다. 매개변수 매트릭스 A가 매우 크거나 단일 카드의 비디오 메모리 용량을 초과하는 경우 매개변수 매트릭스 A를 여러 카드로 나눌 수 있으며 집단 통신을 통해 결과를 수집하여 최종 결과가 수학적으로 이루어지도록 할 수 있습니다. 단일 컴퓨팅 장치에 해당합니다. 계산 결과입니다. 매개변수 행렬 A를 분할하는 방법에는 두 가지가 있습니다.
(1) 매개변수 행렬 A는 열로 절단되고, 행렬 A는 열로 절단됩니다. A = [A1,A2]
(2) 매개변수 행렬 A는 행으로 절단되고, 행렬 A는 행으로 절단됩니다.
그림 10은 매개변수 매트릭스를 열로 분할하는 예를 보여줍니다. 매개변수 매트릭스 A는 두 개의 컴퓨팅 장치에 각각 A1과 A2를 배치합니다. 두 컴퓨팅 장치는 각각 Y1 = X ×A1 및 Y2 = X ×A2를 계산합니다. 계산이 완료된 후 여러 컴퓨팅 장치가 서로 통신하여 다른 컴퓨팅 장치에서 계산 결과를 얻고 이를 결합하여 최종 결과 행렬 Y를 얻습니다. 이 결과는 단일 컴퓨팅 장치의 계산 결과와 수학적으로 동일합니다.
그림 10 2노드 행렬 곱셈 연산자 텐서를 열별로 병렬 분할하는 예
그림 11은 매개변수 행렬을 열과 행으로 나누는 예를 보여줍니다. 행렬 곱셈 규칙을 충족하려면 입력 행렬 X를 열 X = [X1|X2]로 나누어야 합니다. 동시에, 행렬은 블록으로 분할되어 두 개의 컴퓨팅 장치에 배치됩니다. 각 컴퓨팅 장치는 Y1 =X1 ×A1 및 Y2 = X2 ×A2를 각각 계산합니다. 계산이 완료된 후 여러 컴퓨팅 장치가 통신하여 다른 카드의 계산 결과를 얻고 줄여 최종 결과 행렬 Y를 얻을 수 있습니다. 마찬가지로 이러한 분할 방법은 수학적 계산의 동등성을 보장할 수 있을 뿐만 아니라 단일 컴퓨팅 장치가 비디오 메모리를 수용할 수 없는 문제를 해결하고 분할을 통해 단일 컴퓨팅 장치가 매개변수 A를 수용할 수 있도록 보장할 수도 있습니다.
Transformer의 FFN 구조에는 두 개의 완전 연결(FC) 레이어가 포함되어 있습니다. 즉, 두 개의 행렬 곱셈이 있으며, 이 두 개의 행렬 곱셈은 그림 4.12에 표시된 것처럼 위의 두 가지 분할 방법을 채택합니다. 첫 번째 FC 레이어의 매개변수 행렬은 열 단위로 블록으로 절단되고, 두 번째 FC 레이어의 매개변수 행렬은 행 단위로 블록으로 절단됩니다. 이러한 방식으로 첫 번째 FC 계층의 출력은 두 번째 FC 계층의 데이터 입력 요구 사항(열로 분할)을 정확히 충족하므로 첫 번째 FC 계층 이후의 요약 통신 작업을 생략할 수 있습니다. 다중 헤드 self-attention 메커니즘의 텐서 병렬성은 FFN과 유사합니다. 여러 개의 독립 헤드가 있기 때문에 FFN보다 병렬성을 달성하는 것이 그림 4.13에 나와 있습니다. 자세한 내용은 [130]을 참고하세요.
분류 네트워크의 마지막 계층은 일반적으로 Softmax 및 Cross_entropy 연산자를 사용하여 교차 엔트로피 손실(Cross Entropy Loss)을 계산합니다. 범주 수가 너무 많으면 단일 컴퓨팅 장치의 메모리가 로짓 행렬을 저장하고 계산할 수 없게 됩니다. 이러한 유형의 연산자에 대해서는 카테고리 차원에 따라 구분할 수 있으며, 동시에 중간 결과 통신을 통해 최종 전역 교차 엔트로피 손실을 얻을 수 있습니다.
그림 11 2노드 행렬 곱셈 연산자 텐서의 행별 병렬 분할 예
그림 12 FNN 구조 텐서 병렬 다이어그램
가장 먼저 계산할 것은 소프트맥스 값이며, 공식은 다음과 같습니다.
그 중 p는 텐서 병렬성의 장치 번호를 나타냅니다. Softmax 계산 결과를 얻은 후 Target 레이블을 카테고리별로 동시에 나누어 각 장치가 손실의 일부를 가져오도록 하고 마지막으로 모든 카테고리의 손실을 가져오기 위해 또 다른 통신을 수행합니다. 전체 프로세스에서는 교차 엔트로피 손실 계산을 완료하기 위해 세 번의 소량의 통신만 필요합니다. PyTorch는 세분화된 텐서 수준 병렬 API인 DistributedTensor를 제공합니다. 또한 "nn.Module"에서 텐서 병렬 처리를 수행하기 위한 대략적인 모델 수준 API를 제공합니다. 다음 코드 줄을 사용하여 대규모 텐서를 분할할 수 있습니다.
수입 토치
torch.distributed._tensor에서 DTensor, DeviceMesh, Shard, distribution_tensor 가져오기
# 사용 가능한 장치(다중 호스트 또는 단일 호스트)로 장치 메시를 구성합니다.
device_mesh = DeviceMesh("cuda", [0, 1, 2, 3])
# 행 단위 샤딩을 수행하려는 경우
rowwise_placement=[샤드(0)]
# Col-wise 샤딩을 원한다면
colwise_placement=[샤드(1)]
big_tensor = torch.randn(888, 12)
# 반환된 분산 텐서는 배치에 지정된 차원에 걸쳐 샤딩됩니다.
rowwise_tensor = distribution_tensor(big_tensor, device_mesh=device_mesh, 배치=rowwise_placement)
이미 "torch.Tensor"를 매개변수로 갖고 있는 "nn.Linear"와 같은 모듈의 경우 모델 수준에서 텐서 병렬 처리를 수행하기 위해 모듈 수준 API "distribute_module"도 제공됩니다. 참조 코드는 다음과 같습니다.
수입 토치
torch.distributed._tensor에서 DeviceMesh, Shard, distribution_tensor,distribute_module을 가져옵니다.
클래스 MyModule(nn.Module):
def __init__(self):
슈퍼().__init__()
self.fc1 = nn.Linear(8, 8)
self.fc2 = nn.Linear(8, 8)
self.relu = nn.ReLU()
def 전달(자체, 입력):
return self.relu(self.fc1(입력) + self.fc2(입력))
mesh = DeviceMesh(device_type="cuda", mesh=[[0, 1], [2, 3]])
def shard_params(mod_name, mod, mesh):
rowwise_placement = [샤드(0)]
def to_dist_tensor(t): distribution_tensor(t, mesh, rowwise_placement)를 반환합니다.
mod._apply(to_dist_tensor)
sharded_module = distribution_module(MyModule(), mesh, partition_fn=shard_params)
def shard_fc(mod_name, mod, mesh):
rowwise_placement = [샤드(0)]
mod_name == "fc1"인 경우:
mod.weight = torch.nn.Parameter(distribute_tensor(mod.weight, mesh, rowwise_placement))
sharded_module = distribution_module(MyModule(), mesh, partition_fn=shard_fc)
2.3 하이브리드 병렬성
하이브리드 병렬성(HP)은 데이터 병렬성, 파이프라인 병렬성, 텐서 병렬성 등 여러 병렬 전략을 혼합한 것입니다. 다양한 병렬 전략을 결합함으로써 하이브리드 병렬 처리는 다양한 병렬 전략을 최대한 활용하여 컴퓨팅 성능과 효율성을 극대화할 수 있습니다.
수천억 규모의 대규모 언어 모델의 경우 일반적으로 각 서버 내에서 텐서 병렬 전략이 사용됩니다. 이 전략에는 많은 양의 네트워크 통신이 포함되므로 내부의 서로 다른 컴퓨팅 장치 간의 고속 통신 대역폭을 활용할 필요가 있습니다. 섬기는 사람. 파이프라인 병렬 처리를 통해 모델의 여러 계층이 여러 단계로 나뉘며 각 단계는 서로 다른 기계로 계산됩니다. 이러한 방식으로 여러 기계의 컴퓨팅 성능을 최대한 활용할 수 있으며, 기계 간 고속 통신을 통해 계산 결과와 중간 데이터를 전송할 수 있어 전반적인 컴퓨팅 속도와 효율성을 향상시킬 수 있습니다.
마지막으로 데이터 병렬 전략이 외부 레이어에 중첩되어 동시성 수를 늘리고 전반적인 훈련 속도를 향상시킵니다. 데이터 병렬성을 통해 훈련 데이터는 병렬 처리를 위해 여러 서버 그룹에 배포되고, 각 서버 그룹은 서로 다른 데이터 배치를 처리합니다. 이를 통해 여러 서버의 컴퓨팅 리소스를 최대한 활용하고 훈련의 동시성을 높여 전반적인 훈련 속도를 높일 수 있습니다.
BLOOM은 교육을 위해 Megatron-DeepSpeed[104] 프레임워크를 사용하며 주로 두 부분으로 구성됩니다. Megatron-LM은 텐서 병렬 기능과 데이터 로딩 프리미티브를 제공하고 DeepSpeed는 ZeRO 최적화 프로그램, 모델 파이프라인 및 기존 분산 교육 구성 요소를 제공합니다. 이러한 방식으로 데이터, 텐서 및 파이프라인의 3차원 병렬성을 달성할 수 있습니다. BLOOM 모델 훈련에 사용되는 병렬 컴퓨팅 구조는 그림 14에 나와 있습니다.
BLOOM 모델 훈련에서는 48개의 NVIDIA DGX-A100 서버 클러스터를 사용합니다. 각 DGX-A100 서버에는 8개의 NVIDIA A100 80GB GPU(총 384개)가 포함되어 있습니다. BLOOM 훈련에서 채택한 전략은 먼저 데이터 병렬화를 위해 클러스터를 48개의 그룹으로 나누는 것입니다.
다음으로 파이프라인 병렬화를 위해 전체 모델을 12단계로 나눕니다. 각 단계의 모델은 텐서 병렬성을 위해 4개의 GPU로 나누어집니다. 동시에 BLOOM은 모델의 비디오 메모리 점유를 더욱 줄이기 위해 ZeRO(Zero Redundancy Optimizer)[134]도 사용합니다. 위의 네 단계를 통해 수백 개의 GPU의 효율적인 병렬 컴퓨팅을 달성할 수 있습니다.
그림 14 BLOOM 모델 훈련에 사용된 병렬 컴퓨팅 구조
2.4 컴퓨팅 장치 메모리 최적화
현재의 대규모 언어 모델 훈련에서는 일반적으로 Adam 최적화 알고리즘을 사용하는데, 여기에는 각 매개변수의 기울기 외에 1차 모멘텀(Momentum)과 2차 모멘텀(Variance)이 필요합니다. Adam 최적화 알고리즘은 일반적으로 SGD 알고리즘보다 우수하고 안정적이지만 컴퓨팅 장치에서 훨씬 더 많은 메모리를 소비합니다.
메모리 사용량을 줄이기 위해 대부분의 시스템에서는 Mixed Precision Training 방식을 채택했습니다. 즉, FP16(16비트 부동 소수점) 또는 BF16(Bfloat16) 및 FP32(32비트 부동 소수점) 형식의 값이 모두 있습니다. . FP32, FP16 및 BF16은 그림 4.15와 같이 표시됩니다. FP32에서 비트 31은 부호 비트이고 비트 30~23은 지수를 나타내는 데 사용되며 비트 22~0은 가수를 나타내는 데 사용됩니다. FP16에서 비트 15는 부호 비트이고 비트 14~10은 지수를 나타내는 데 사용되며 비트 9~9는 가수를 나타내는 데 사용됩니다. BF16에서 비트 15는 부호 비트이고, 비트 14~7은 지수를 나타내는 데 사용되고, 비트 6~0은 가수를 나타내는 데 사용됩니다. FP16의 값 범위는 FP32의 값 범위보다 훨씬 작기 때문에 계산 과정에서 오버플로 및 언더플로가 쉽게 발생할 수 있습니다. FP16과 비교하여 BF16은 더 큰 값 범위를 위해 정밀도를 교환합니다. 그러나 FP16과 BF16은 FP32에 비해 정확도가 낮기 때문에 훈련 과정에서 기울기가 사라지고 모델이 불안정해지는 문제가 발생할 수 있습니다.
따라서 이러한 문제를 해결하려면 동적 손실 스케일링(Dynamic Loss Scaling) 및 혼합 정밀도 최적화기(Mixed Precision Optimizer)와 같은 일부 기술을 사용해야 합니다. 혼합 정밀도 최적화 프로세스는 그림 4.16에 나와 있습니다. Adam 최적화 상태에는 FP32에 저장된 모델 매개변수의 백업이 포함되어 있으며, 1차 모멘텀과 2차 모멘텀도 FP32 형식으로 저장됩니다. 모델 매개변수 개수를 Φ로 하고, 모델 매개변수와 기울기를 FP16 형식으로 저장한다고 가정하면, 총 2Φ + 2Φ + (4Φ + 4Φ + 4Φ) = 16Φ 바이트의 저장 공간이 필요합니다.
그 중 아담 상태가 75%를 차지합니다. 동적 손실 스케일링 역전파 전에는 손실 변화(dLoss)가 수동으로 2K배 증가하므로 역전파 중에 얻은 활성화 함수 기울기가 오버플로되지 않으며 가중치 기울기가 2K배만큼 감소하고 정상 값으로 복원됩니다. 예를 들어 75억 개의 매개변수가 포함된 모델의 경우 FP16 형식을 사용하는 경우 컴퓨팅 장치 메모리는 15GB만 필요하지만 모델 상태는 훈련 단계에서 실제로 120GB를 소비합니다.
컴퓨팅 카드가 차지하는 메모리에는 모델 상태 외에도 활성화 값(Activation), 다양한 임시 버퍼(Buffers), 사용할 수 없는 비디오 메모리 조각(Fragmentation) 등을 포함한 잔여 상태(Residual States)가 있습니다. 활성화 값은 체크포인팅(Activation Checkpointing)을 사용하여 활성화 값의 메모리 공간을 크게 줄일 수 있으므로 모델 상태, 특히 Adam 옵티마이저 상태를 어떻게 줄이는 것이 메모리 공간 문제를 해결하는 열쇠입니다.
그림 16 혼합 정밀도 최적화 프로세스
이상은 분산 머신러닝 시스템, 분산 학습 클러스터 아키텍처, 분산 학습 병렬 전략에 대한 간략한 소개입니다. DeepSpeed는 클러스터에서 대규모 언어 모델을 학습하는 방법에 대한 예입니다. 다음 기사에서 알려드리겠습니다. 관심과 지지를 보내주시면 감사하겠습니다. 여러분의 지지가 제 창작의 원동력입니다.
참고 내용:
(1) 수집丨대형 언어 모델 훈련 관련 데이터 세트 30개 공유 - Zhihu https://zhuanlan.zhihu.com/p/612243919.
(2) 대규모 언어 모델 훈련 데이터에 대한 네 가지 일반적인 처리 방법 - Zhihu.
(3) "대규모 언어 모델: 이론에서 실제까지" Zhang Qi 외 —Beijing: Electronic Industry Press
(4) 대규모 언어 모델 검토 - 중국 인민대학교 http://ai.ruc.edu.cn/research/science/20230605100.html.
화웨이 클라우드의 신기술에 대해 빨리 알아보고 팔로우하려면 클릭하세요~
1990년대에 태어난 프로그래머가 비디오 포팅 소프트웨어를 개발하여 1년도 안 되어 700만 개 이상의 수익을 올렸습니다. 결말은 매우 처참했습니다! 고등학생들이 성인식으로 자신만의 오픈소스 프로그래밍 언어 만든다 - 네티즌 날카로운 지적: 만연한 사기로 러스트데스크 의존, 가사 서비스 타오바오(taobao.com)가 가사 서비스를 중단하고 웹 버전 최적화 작업 재개 자바 17은 가장 일반적으로 사용되는 Java LTS 버전입니다. Windows 10 시장 점유율 70%에 도달, Windows 11은 계속해서 Open Source Daily를 지원합니다. Google은 Docker가 지원하는 오픈 소스 Rabbit R1을 지원합니다. Electric, 개방형 플랫폼 종료 Apple, M4 칩 출시 Google, Android 범용 커널(ACK) 삭제 RISC-V 아키텍처 지원 Yunfeng은 Alibaba에서 사임하고 향후 Windows 플랫폼에서 독립 게임을 제작할 계획