Today, NVIDIA released a unique language model that delivers an unmatched accuracy-efficiency performance. Llama 3.1-Nemotron-51B, derived from Meta’s Llama-3.1-70B, uses a novel neural architecture search (NAS) approach that results in a highly accurate and efficient model.
The model fits on a single NVIDIA H100 GPU at high workloads, making it much more accessible and affordable. The excellent accuracy-efficiency sweet spot exhibited by the new model stems from changes to the model’s architecture that lead to a significantly lower memory footprint, reduced memory bandwidth, and reduced FLOPs while maintaining excellent accuracy. We demonstrate that this approach can be generalized by creating another smaller and faster variant from the reference model.
In July 2024, Meta released Llama-3.1-70B, a leading state-of-the-art large language model (LLM). Today we announce
Llama 3.1-Nemotron-51B-Instruct
, developed using NAS and knowledge distillation derived from the reference model, Llama-3.1-70B.
Superior throughput and workload efficiency
The Nemotron model yields 2.2x faster inference compared to the reference model while maintaining nearly the same accuracy. The model opens a new set of opportunities with a reduced memory footprint, which enables running 4x larger workloads on a single GPU during inference.
Accuracy
Efficiency
MT Bench
MMLU
Text generation
(128/1024)
Summarization/ RAG (2048/128)
Llama-3.1- Nemotron-51B- Instruct
8.99
80.2%
6472
653
Llama 3.1-70B- Instruct
8.93
81.66%
2975
339
Llama 3.1-70B- Instruct (single GPU)
—
—
1274
301
Llama 3-70B
8.94
80.17%
2975
339
Table 1. Overview of the Llama-3.1-Nemotron-51B-Instruct accuracy and efficiency.
Note: Speed is reported in tokens per second per GPU, Measured on machines equipped with 8 X NVIDIA H100 SXM GPUs, with FP8 quantization using
TRT-LLM
as the runtime engine. For each model with the optimal number of GPUs through tensor parallelism (unless otherwise stated). The numbers in the brackets show the (input/output sequence lengths).
We discuss the detailed performance metrics later in this post.
Optimized accuracy per dollar
Foundation models display incredible quality in solving complex tasks: reasoning, summarization, and more. However, a major challenge in the adoption of ‌top models is their inference cost.
As the field of generative AI evolves, the balance between accuracy and efficiency (directly impacting cost) will become the decisive factor in model selection. Moreover, the capability to run a model on a single GPU significantly streamlines its deployment, opening opportunities for new applications to run anywhere, from edge systems to data centers to the cloud, as well as facilitating serving multiple models via Kubernetes and
NIM blueprints
.
Consequently, we engineered Llama 3.1-Nemotron-51B-Instruct to achieve this optimal tradeoff (Figure 1). Throughput is inversely proportional to price, so the best tradeoff is obtained by models on the efficient frontier displayed in the chart. Figure 1 shows that the model pushes beyond the current efficient frontier, making it the model that provides the best accuracy per dollar.
Figure 1. Accuracy vs. Throughput performance of Llama-3.1-Nemotron-51B compared to frontier models. Throughput was measured through NIM with concurrency 25 (serving throughput).
The model quality is defined as the weighted average of MT-Bench and MMLU (10*MT-Bench + MMLU)/2, plotted compared to model throughput per a single NVIDIA H100 80GB GPU. Gray dots represent state-of-the-art models, while the dashed line represents the ‘efficient frontier’.
Simplifying inference with NVIDIA NIM
The Nemotron model is optimized with TensorRT-LLM engines for higher inference performance and packaged as an NVIDIA NIM microservice to streamline and accelerate the deployment of generative AI models across NVIDIA accelerated infrastructure anywhere, including cloud, data center, and workstations.
NIM uses inference optimization engines, industry-standard APIs, and prebuilt containers to provide high-throughput AI inference that scales with demand.
Try out
Llama-3.1-Nemotron-51B NIM microservice
through the API from
ai.nvidia.com
with free NVIDIA credits.
Building the model with NAS
Inference and hardware-aware methods for designing neural architectures have been successfully used in many domains. However, LLMs are still constructed as repeated identical blocks, with little regard for inference cost overheads incurred by this simplification. To tackle these challenges, we developed efficient NAS technology and training methods that can be used to create non-standard transformer models designed for efficient inference on specific GPUs.
Our technology can select neural architectures that optimize various constraints. The range includes enormous design spaces that include a zoo of non-standard transformer models using alternative attention and FFN blocks of varying efficiency degrees, up to a complete block elimination in the extreme case.
We then use our block-distillation (Figure 2) framework to train all these block variants for all layers of a (large) parent LLM in parallel. In a basic version of block-distillation, training data is passed through the reference model  (also known as a teacher).
For each block, its input is taken from the teacher and injected into the matching block of the student. The outputs of the teacher and student for the block are compared and the student block is trained so that the student block mimics the functionality of the teacher block. A more advanced scenario where a single student block mimics multiple teacher blocks is depicted on the right side in Figure 2.
Figure 2. Block distillation where blue reference model blocks are multiple variants for the yellow student models that mimic the block-wise teacher functionality
Next, we use our Puzzle algorithm to efficiently score each alternative replacement puzzle piece and search our enormous design space for the most accurate models, while adhering to a set of inference constraints, such as memory size and required throughput.
Finally, by using knowledge distillation (KD) loss for both block scoring and training, we demonstrate the potential to narrow the accuracy gap between our model and the reference model using a much more efficient architecture with a tiny fraction of the reference model training costs. Using our methods on Llama-3.1-70B as the reference model, we built ​​Llama-3.1-Nemotron-51B-Instruct, a 51B model that breaks the efficient frontier of LLMs on a single NVIDIA H100 GPU (Figure 1).
The ​​Llama-3.1-Nemotron-51B-Instruct architecture is unique in its irregular block structure with many layers in which the attention and FFN are reduced or pruned, resulting in better utilization of H100 and highlighting the importance of optimizing LLMs for inference. Figure 3 schematically depicts the irregular structure of the resulting architecture and highlights the resulting compute saving, which amounts to the green area in the Figure.
Figure 3. Runtime of Puzzle chosen blocks (layers) for attention layers (blue) and FFN layers (red) across the 80 layers of the reference model. Green areas correspond to overall runtime savings.
Our innovative techniques enable us to develop models that redefine the efficient frontier of LLMs. Crucially, we can cost-effectively design multiple models from a single reference model, each optimized for specific hardware and inference scenarios. This capability empowers us to maintain best-in-class performance for LLM inference across our current and future hardware platforms.
Detailed results
Here are the model accuracy and performance metrics for our model.
Model accuracy
Table 2 lists all the benchmarks that we evaluated, comparing our model and the reference model Llama-3.1-70B. The
Accuracy preserved
column is the ratio between our model’s score and that of the teacher.
Benchmark
Llama-3.1 70B-instruct
Llama-3.1-Nemotron-51B- Instruct
Accuracy preserved
winogrande
85.08%
84.53%
99.35%
arc_challenge
70.39%
69.20%
98.30%
MMLU
81.66%
80.20%
98.21%
hellaswag
86.44%
85.58%
99.01%
gsm8k
92.04%
91.43%
99.34%
truthfulqa
59.86%
58.63%
97.94%
xlsum_english
33.86%
31.61%
93.36%
MMLU Chat
81.76%
80.58%
98.55%
gsm8k Chat
81.58%
81.88%
100.37%
Instruct HumanEval (n=20)
75.85%
73.84%
97.35%
MT Bench
8.93
8.99
100.67%
Table 2. Accuracy comparison of the Nemotron model to the Llama-3.1-70B-Instruct model across several industry benchmarks
Performance
Table 3 shows the number of tokens per second per GPU (NVIDIA H100 80-GB GPU). You can see that for a range of relevant scenarios, short and long inputs as well as outputs, our model doubles the throughput of the teacher model, making it cost-effective across multiple use cases.
TPX describes the number of GPUs on which the process runs in parallel. We also list the performance of Llama 3.1-70B on a single GPU to demonstrate the value of our model in such a setting.
Scenario
Input/Output Sequence Length
Llama-3.1- Nemotron-Instruct
Llama-3.1-70B-Instruct
Ratio
Llama (TP1)
Chatbot
128/128
5478 (TP1)
2645 (TP1)
2.07
2645
Text generation
128/1024
6472 (TP1)
2975 (TP4)
2.17
1274
Long text generation
128/2048
4910 (TP2)
2786 (TP4)
1.76
646
System 2 reasoning
128/4096
3855 (TP2)
1828 (TP4)
2.11
313
Summarization/ RAG
2048/128
653 (TP1)
339 (TP4)
1.92
300
Stress test 1
2048/2048
2622 (TP2)
1336 (TP4)
1.96
319
Table 3. Throughput comparison of the number of tokens generated by the models for popular use cases. All numbers are in tokens per second per GPU.
The main factor in determining the cost of running a model is
throughput
, the total number of tokens that the system can generate in one second. However, in some scenarios (for example, chatbots), the rate at which a single end user receives the response from the model is important for the user experience. This is quantified by the tokens per second per user, termed the user-side throughput.
Figure 4 shows this user-side throughput plotted against the throughput at different batch sizes. As seen in all batch sizes, our model is superior to Llama-3.1-70B.
Figure 4. Server throughput vs. user-side throughput, plotted at different batch sizes for the Nemotron model and for Llama-3.1-70B
Tailoring LLMs for diverse needs
The NAS approach offers you flexibility in selecting the optimal balance between accuracy and efficiency. To demonstrate this versatility, we created another variant from the same reference model, this time prioritizing speed and cost. Llama-3.1-Nemotron-40B-Instruct was developed using the same methodology but with a modified speed requirement during the puzzle phase.
This model achieves a 3.2x speed increase compared to the parent model, with a moderate decrease in accuracy. Table 4 shows competitive performance metrics.
Accuracy
Speed
MT bench
MMLU
Text generation
(128/1024)
Summarization/ RAG (2048/128)
Llama-3.1- Nemotron-40B-Instruct
8.69
77.10%
9568
862
Llama-3.1- Nemotron-51B-Instruct
8.99
80.20%
6472
653
Llama 3.1-70B-Instruct
8.93
81.72%
2975
339
Table 4. Overview of the Llama-3.1-Nemotron-40B-Instruct accuracy and efficiency
Summary
Llama 3.1-Nemotron-51B-Instruct
provides a new set of opportunities for users and companies that want to use highly accurate foundation models, but do so in a cost-controlled manner. By providing the best tradeoff between accuracy and efficiency, we believe the model is an attractive option for builders. Moreover, these results demonstrate the effectiveness of the NAS approach and intend to extend the method to other models.
Reading Time:
3
minutes
本日、NVIDIA は、比類のない精度と効率を実現する独自の言語モデルを発表しました。 Llama 3.1-Nemotron-51B は、 Meta の Llama-3.1-70B の派生モデルであり、新しい Neural Architecture Search (NAS) アプローチによって、高精度かつ効率的なモデルとなっています。
このモデルは高負荷のワークロードでもひとつの NVIDIA H100 GPU に収まるため、より利用しやすく、かつ価格が手頃なモデルとなっています。モデルのアーキテクチャを変更することで、このモデルは精度と効率性の優れたバランスを保っており、高い精度を維持しながら、メモリ使用量やメモリ帯域幅、FLOPs が大幅に削減されています。このアプローチは、さらに小型で高速な別モデルをリファレンス モデルから作成することで、汎用的な手法であることを実証しています。
2024 年 7 月、Meta は先進的な大規模言語モデル (LLM) である Llama-3.1-70B をリリースしました。本日、NVIDIA は
Llama 3.1-Nemotron-51B-Instruct
を発表します。これはリファレンス モデルの Llama-3.1-70B をもとにNAS と知識蒸留を使用することで開発されました。
優れたスループットとワークロードの効率
Nemotron モデルは、ほぼ同じ精度を維持しながら、リファレンス モデルと比較して 2.2 倍高速な推論が可能です。このモデルは、推論時にひとつの GPU で 4 倍のワークロードを実行可能なほどメモリ使用量を削減しており、これによって新たな用途や可能性が望まれます。
精度
効率性
MT Bench
MMLU
テキスト生成 (128/1024)
要約 / RAG (2048/128)
Llama-3.1- Nemotron-51B- Instruct
8.99
80.2%
6472
653
Llama 3.1-70B- Instruct
8.93
81.66%
2975
339
Llama 3.1-70B- Instruct (GPUは１基のみ)
—
—
1274
301
Llama 3-70B
8.94
80.17%
2975
339
表 1. Llama-3.1-Nemotron-51B-Instruct の精度と効率性の概要
注: 速度は GPU 1 基当たりの秒間トークン数で報告されています。8 基の NVIDIA H100 SXM GPU を搭載したマシンで測定。
TRT-LLM
をランタイム エンジンとして使用し、FP8 量子化を適用。各モデルに対して、テンソル並列化 (Tensor Parallelism) による最適な数の GPU を使用 (別途記載のない場合)。括弧内の数字は (入力シーケンスの長さ/出力シーケンスの長さ) を示しています。
詳細なパフォーマンス指標については、この記事で後述します。
コスト当たりの精度を最適化
基盤モデルは、推論や要約などの複雑なタスクを解決する際に、卓越した能力を示しています。しかし、どの上位モデルを使うかを選択する際に大きな課題となっているのが、推論コストです。
生成 AI 分野の進歩に伴い、精度と効率性(直接的にコストに影響)のバランスが、モデルを選択する際の決定的な要因となるでしょう。さらに、１基の GPU でモデルを実行できることで、デプロイが大幅に簡素化され、エッジ システムからデータ センター、クラウドに至るまでどこでも新たなアプリケーションを実行する機会が開拓されます。加えて、Kubernetes と
NVIDIA Blueprint
による複数のモデルの提供も容易になります。
そこで、最良のトレードオフを達成するために Llama 3.1-Nemotron-51B-Instruct を作成しました (図 1 )。スループットは価格に反比例するため、最良のトレードオフはグラフに示されている ”Efficient frontier” (効率的であることを示す境界線) 上のモデルが実現しています。図 1 は、今回のモデルである Llama 3.1-Nemotron-51B-Instruct が現在の Efficient frontier をさらに押し上げ、コスト当たりの精度が最も高いモデルであることを示しています。
図 1. Efficient frontier上のモデルと比較した Llama-3.1-Nemotron-51B の精度とスループットのパフォーマンス。スループットは、NIM で同時実行数 25 (サービング スループット) を用いて測定。
モデルの品質は、MT-Bench と MMLU (10*MT-Bench + MMLU)/2 の加重平均として定義され、NVIDIA H100 80GB GPU 1 基当たりのモデル スループットと比較してプロットされています。グレーの点は最先端のモデルを表し、直線は「Efficient frontier」を表しています。
NVIDIA NIM による推論の簡素化
Nemotron モデルは、TensorRT-LLM エンジンで最適化され、より高い推論性能を発揮します。また NVIDIA NIM マイクロサービスとしてパッケージ化されており、クラウド、データ センター、ワークステーションなど、NVIDIA により高速化されたインフラ全体で生成 AI モデルのデプロイを効率化および加速します。
NIM は、推論最適化エンジン、業界標準の API、および構築済みのコンテナを使用して、需要に応じてスケールできる高スループットなAIの推論を可能としています。
Llama-3.1-Nemotron-51B の NIM マイクロサービス
を、
ai.nvidia.com
の API を通じて、無料の NVIDIA クレジットで是非お試しください。
NAS によるモデルの構築
推論およびハードウェアを考慮したニューラル ネットワークのアーキテクチャを構築する手法は、多くの分野で成功を収めてきました。しかし、LLM は依然として同一ブロックを繰り返し使用して構成されており、この簡素化により発生する推論コストのオーバーヘッドはほとんど考慮されていません。これらの課題に取り組むために、NVIDIA は、特定の GPU 上で効率的な推論が可能な Transformer モデルを作成する NAS 技術と学習方法を開発しました。
NVIDIA の技術では、多様な制約を最適化するニューラル ネットワークのアーキテクチャを選択することができます。アーキテクチャの探索範囲は膨大であり、さまざまな Attention や FFN ブロック、極端なケースだとブロックの完全な排除まで含まれます。
次に、ブロック蒸留 (Block-distillation) フレームワーク (図 2) を使用して、NAS によって見つけたブロックたちを学習します。ブロック蒸留では、生徒 (Student) モデルの各ブロックを教師 (Teacher) モデル の全レイヤーに対して並列で学習します。基本的なブロック蒸留では、学習データはリファレンス モデル (＝教師モデル) を通して渡されます。
生徒モデルの各ブロックは教師モデルの該当するブロックから入力を受け取ります。生徒モデルと教師モデルのブロックの出力が比較され、生徒モデルのブロックは教師モデルのブロックの機能を模倣するように学習されます。また、図 2 の右側のように、生徒モデルの 1 つのブロックが教師モデルの複数のブロックを模倣するように学習する、より発展的なシナリオも考えられます。
図 2. ブロック蒸留では、青色のリファレンス モデル のブロックたちを生徒モデルのブロックにとっての複数のバリエーションとして扱う。生徒モデルのブロックは教師モデルの機能をブロック単位で模倣。
次に、NVIDIA の Puzzle アルゴリズムを使用することで、メモリ サイズや必要なスループットなどの推論における制約を遵守しながら、代替の交換パズル ピースを効率的にスコア付けし、最も正確なモデルを膨大な設計スペースから検索します。
最後に、ブロックのスコアリングとトレーニングの両方に知識蒸留 (KD) 損失を使用することにより、リファレンス モデルの学習コストと比べてごく一部のコストで、はるかに効率的なアーキテクチャがリファレンス モデルとの精度のギャップを縮める可能性を示しました。Llama-3.1-70B をリファレンス モデルとして NVIDIA の方法を使用して、ひとつの NVIDIA H100 GPU に収まるLLM の”Efficient frontier”を上回る Llama-3.1-Nemotron-51B-Instruct （パラメーター数: 51B）を構築しました (図 1)。
Llama-3.1-Nemotron-51B-Instruct アーキテクチャは、削減または枝刈りされたアテンション層と FFN 層を多く含む不規則なブロック構造が特徴で、その結果 H100 の利用率を向上させ、推論のために LLM を最適化する重要性が示されました。図 3 は、結果として生じるアーキテクチャの不規則な構造を概略的に示しています。図中の緑色部分は計算処理がどれほど削減されるかを強調して示しています。
図 3. リファレンス モデルの 80 層にわたるアテンション レイヤー (青) と FFN レイヤー (赤) における、 Puzzle アルゴリズムによって選択されたブロック (またはレイヤー) のランタイム。図の緑色の部分は全体的なランタイムの削減に相当。
NVIDIA の革新的な技術により、LLM の ”Efficient frontier” を再定義するモデルの開発が可能になります。重要なのは、ひとつのリファレンス モデルから複数のモデルを費用対効果に優れた方法で設計し、その結果として各モデルを特定のハードウェアおよび推論のシナリオに最適化できることです。この機能により、現在および将来のハードウェア プラットフォーム全体で、同じ規模の LLM たちの中で最高の推論パフォーマンスを維持することができます。
詳細な結果
NVIDIA のモデルの精度とパフォーマンスは以下の通りです。
精度
表 2 では、NVIDIA のモデルとリファレンス モデルである Llama-3.1-70B を比較し、評価したすべてのベンチマークについて記載しています。
維持された精度の割合
の列は、NVIDIA モデルのスコアと教師モデルのスコアとの比率です。
ベンチマーク
Llama-3.1 70B-instruct
Llama-3.1-Nemotron-51B- Instruct
維持された精度の割合
winogrande
85.08%
84.53%
99.35%
arc_challenge
70.39%
69.20%
98.30%
MMLU
81.66%
80.20%
98.21%
hellaswag
86.44%
85.58%
99.01%
gsm8k
92.04%
91.43%
99.34%
truthfulqa
59.86%
58.63%
97.94%
xlsum_english
33.86%
31.61%
93.36%
MMLU Chat
81.76%
80.58%
98.55%
gsm8k Chat
81.58%
81.88%
100.37%
Instruct HumanEval (n=20)
75.85%
73.84%
97.35%
MT Bench
8.93
8.99
100.67%
表 2. 複数の業界標準のベンチマークにおける Nemotron モデルと Llama-3.1-70B-Instruct モデルの精度比較
パフォーマンス
表 3 は、GPU (NVIDIA H100 80GB GPU) 1 基あたりのトークン数を示しています。関連するシナリオの範囲、短い入力と長い入力および出力に関して、NVIDIA のモデルは教師モデルのスループットを 2 倍に高め、複数のユース ケースで費用対効果が高いことがわかります。
TPX は、プロセスを並列処理する GPU の数を表します。また、このような設定における NVIDIA のモデルの価値を示すため、単一の GPU 上の Llama 3.1-70B のパフォーマンスも記載しています。
シナリオ
入出力シーケンス長
Llama-3.1- Nemotron-Instruct
Llama-3.1-70B-Instruct
比率
Llama (TP1)
チャットボット
128/128
5478 (TP1)
2645 (TP1)
2.07
2645
テキスト生成
128/1024
6472 (TP1)
2975 (TP4)
2.17
1274
長いテキスト生成
128/2048
4910 (TP2)
2786 (TP4)
1.76
646
システム 2 の推論
128/4096
3855 (TP2)
1828 (TP4)
2.11
313
要約 / RAG
2048/128
653 (TP1)
339 (TP4)
1.92
300
ストレス テスト 1
2048/2048
2622 (TP2)
1336 (TP4)
1.96
319
表 3. 一般的なユース ケースのモデルにより生成されたトークン数のスループット比較。すべての数値は、GPU ごとの 1 秒あたりのトークン数を示します。
モデルの実行コストを決定する主な要因は、システムが 1 秒間に生成できるトークンの合計数であるスループットです。しかし、いくつかのシナリオ (チャットボットなど) では、1 人のエンドユーザーがモデルからの応答を受け取る速度というのがユーザー体験の観点から重要になります。これはユーザーごとの 1 秒間のトークン数で定量化され、ユーザー側のスループット (User-side throughput) と呼ばれます。
図 4 は、このユーザー側のスループットを、異なるバッチ サイズのスループットに対してプロットしたものです。全てのバッチ サイズで確認できるように、NVIDIA のモデルは Llama-3.1-70B よりも優れています。
図 4. Nemotron モデルと Llama-3.1-70B の異なるバッチ サイズでプロットしたサーバーのスループットとユーザー側のスループット
多様なニーズに合わせた LLM のカスタマイズ
NAS アプローチには、精度と効率性の最適なバランスを選択できる柔軟性があります。この汎用性を示すため、同じリファレンス モデルから別のモデルを作成しました。ここでは速度とコストを優先しました。Llama-3.1-Nemotron-40B-Instruct は同じ手法を用いて開発されましたが、パズル段階における速度の要件が変更されています。
このモデルは、親モデルと比較して 3.2 倍の速度向上を達成しますが、精度は若干低下しています。表 4 からもこのモデルが十分なパフォーマンスを示していることがわかります。
精度
速度
MT bench
MMLU
テキスト生成 (128/1024)
要約 / RAG (2048/128)
Llama-3.1- Nemotron-40B-Instruct
8.69
77.10%
9568
862
Llama-3.1- Nemotron-51B-Instruct
8.99
80.20%
6472
653
Llama 3.1-70B-Instruct
8.93
81.72%
2975
339
表 4. Llama-3.1-Nemotron-40B-Instruct の精度と効率の概要
まとめ
Llama 3.1-Nemotron-51B-Instruct
は、高精度の基盤モデルを使いつつ、コストを抑えたいユーザーや企業にとって、新たなチャンスとなります。このモデルは精度と効率性の最適なバランスを備えており、開発者にとって魅力的な選択肢になると思います。さらに、ここで示した結果は NAS アプローチの有効性を示しており、他のモデルに対してもこの方法を拡張することにもつながります。
関連情報
GTC セッション:
地震データ処理ワークフローに対する AI アシスタント統合を先駆けて実現
GTC セッション:
大規模言語モデルの最適化: LLama2 7B のプルーニングとファインチューニングに向けた実験的アプローチ
NGC コンテナー:
Llama-3.1-405b-instruct
NGC コンテナー:
Llama-3-Swallow-70B-Instruct-v0.1
SDK:
Llama3 8B Instruct NIM