Deploying Accelerated Llama 3.2 from the Edge to the Cloud

Expanding the open-source Meta Llama collection of models, the Llama 3.2 collection includes vision language models (VLMs), small language models (SLMs), and an updated Llama Guard model with support for vision. When paired with the NVIDIA accelerated computing platform, Llama 3.2 offers developers, researchers, and enterprises valuable new capabilities and optimizations to realize their generative AI use cases.
Trained on
NVIDIA H100 Tensor Core GPUs
, the SLMs in 1B and 3B sizes are ideal for deploying Llama-based AI assistants across edge devices. The VLMs in 11B and 90B sizes support text and image inputs and output text. With multimodal support, the VLMs help developers build powerful applications requiring visual grounding, reasoning, and understanding. For example, they can build AI agents for image captioning, image-text retrieval, visual Q&A, and document Q&A, among others. The Llama Guard models now also support image input guardrails in addition to text input.
Llama 3.2 model architecture is an auto-regressive language model that uses an optimized transformer architecture. The instruction tuned versions use supervised fine-tuning (SFT) and reinforcement learning with human feedback (RLHF) to align with human preferences for helpfulness and safety. All models support a long context length of 128K tokens and are optimized for inference with support for grouped query attention (GQA).
NVIDIA is optimizing the Llama 3.2 collection of models to deliver high throughput and low latency across millions of GPUs worldwide—from data centers to local workstations with
NVIDIA RTX
, and at the edge with
NVIDIA Jetson
. This post describes the hardware and software optimizations, customizations, and ease-of-deployment capabilities.
Accelerating Llama 3.2 performance with NVIDIA TensorRT
NVIDIA is accelerating the Llama 3.2 model collection to reduce cost and latency while delivering unparalleled throughput and providing an optimal end-user experience.
NVIDIA TensorRT
includes
TensorRT
and
TensorRT-LLM
libraries for high-performance deep learning inference.
The Llama 3.2 1B and Llama 3.2 3B models are being accelerated for long-context support in TensorRT-LLM using the
scaled rotary position embedding (RoPE)
technique and several other
optimizations
, including KV caching and in-flight batching.
The Llama 3.2 11B and Llama 3.2 90B models are multimodal and include a vision encoder with a text decoder. The vision encoder is being accelerated by exporting the model into an ONNX graph and building the TensorRT engine.
ONNX
export creates a standard model definition with built-in operators and standard data types, focused on inferencing. TensorRT uses the ONNX graph to optimize the model for target GPUs by building the
TensorRT engine
. These engines offer a variety of hardware-level optimizations to maximize NVIDIA GPU utilization through layer and tensor fusion in conjunction with kernel auto-tuning.
The visual information from the vision encoder is fused into the Llama text decoder with a cross-attention mechanism that is supported in TensorRT-LLM. This enables the VLMs to efficiently generate text by taking into account visual reasoning and understanding in context with text input.
Easily deploy generative AI solutions using NVIDIA NIM
The TensorRT optimizations are available through production-ready deployments using
NVIDIA NIM
microservices. NIM microservices accelerate the deployment of generative AI models across NVIDIA-accelerated infrastructure anywhere, including cloud, data center, and workstations.
Llama 3.2 90B Vision Instruct
,
Llama 3.2 11B Vision Instruct
,
Llama 3.2 3B Instruct
, and
Llama 3.2 1B Instruct
are supported through NIM microservices for production deployments. NIM provides simplified management and orchestration of generative AI workloads, standard application programming interface (APIs), and enterprise support with production-ready containers. Offering strong and growing ecosystem support with over 175 partners integrating their solutions with NVIDIA NIM microservices, developers, researchers and enterprises around the world can maximize their return on investment for generative AI applications.
Customize and evaluate Llama 3.2 models with NVIDIA AI Foundry and NVIDIA NeMo
NVIDIA AI Foundry
provides an end-to-end platform for Llama 3.2 model customizations with access to advanced AI tools, computing resources, and AI expertise. Fine-tuned on proprietary data, the custom models enable enterprises to achieve better performance and accuracy in domain-specific tasks, gaining a competitive edge.
With
NVIDIA NeMo
, developers can curate their training data, leverage advanced tuning techniques including LoRA, SFT, DPO, and RLHF to customize the Llama 3.2 models, evaluate for accuracy, and add guardrails to ensure appropriate responses from the models. AI Foundry provides dedicated capacity on
NVIDIA DGX Cloud
, and is supported by NVIDIA AI experts. The output is a custom Llama 3.2 model packaged as an NVIDIA NIM inference microservice, which can be deployed anywhere.
Scale local inference with NVIDIA RTX and NVIDIA Jetson
Today, Llama 3.2 models are optimized on the 100M+ NVIDIA RTX PCs and workstations worldwide. For Windows deployments, NVIDIA has optimized this suite of models to work efficiently using the ONNX-GenAI runtime, with a DirectML backend. Get started with the
Llama 3.2 3B model on NVIDIA RTX
.
The new VLM and SLM models unlock new capabilities on NVIDIA RTX systems. To demonstrate, we created an example of a multimodal
retrieval-augmented generation (RAG)
pipeline that combines text and visual data processing (for images, plots, and charts, for example) for enhanced information retrieval and generation.
Learn how to run this pipeline on NVIDIA RTX Linux systems using the Llama 3.2 SLM and VLM
. Note that you’ll need a Linux workstation with an NVIDIA RTX professional GPU with 30+ GB of memory.
SLMs are tailored for local deployment on edge devices using techniques like distillation, pruning, and quantization to reduce memory, latency, and computational requirements while retaining accuracy for application-focused domains. To download and deploy the Llama 3.2 1B and 3B SLMs onboard your Jetson with optimized GPU inference and INT4/FP8 quantization, see the
SLM Tutorial on NVIDIA Jetson AI Lab
.
Multimodal models are increasingly useful in edge applications for their unique vision capabilities in video analytics and robotics. The
Llama 3.2 11B VLM is supported on embedded Jetson AGX Orin 64 GB
.
Advancing community AI models
An active open-source contributor, NVIDIA is committed to optimizing community software that helps users address their toughest challenges. Open-source AI models also promote transparency and enable users to broadly share work on AI safety and resilience.
The
Hugging Face inference-as-a-service
capabilities enable developers to rapidly deploy leading
large language models (LLMs)
such as the Llama 3 collection with optimization from NVIDIA NIM microservices running on
NVIDIA DGX Cloud
.
Get free access to NIM for research, development, and testing through the
NVIDIA Developer Program
.
Explore the NVIDIA AI inference platform further, including how
NVIDIA NIM
,
NVIDIA TensorRT-LLM
,
NVIDIA TensorRT,
and
NVIDIA Triton
use state-of-the-art techniques such as
LoRA
to accelerate the latest LLMs.

高速化された Llama 3.2 をエッジからクラウドへデプロイする

Reading Time:
2
minutes
オープンソースの Meta Llama モデルのコレクションを拡張した Llama 3.2 コレクションには、視覚言語モデル (VLM)、小規模言語モデル (SLM)、ビジョンのサポートが追加された Llama Guard モデルが含まれています。NVIDIA のアクセラレーテッド コンピューティング プラットフォームと組み合わせることで、Llama 3.2 は開発者、研究者、企業に、生成 AI のユース ケースを実現するための有益な新機能と最適化を提供します。
NVIDIA H100 Tensor コア GPU
でトレーニングされた 1B および 3B サイズの SLM は、エッジ デバイスに Llama ベースの AI アシスタントを展開するのに最適です。11B および 90B サイズの VLM は、テキストと画像の入力とテキストの出力をサポートします。マルチモーダルをサポートする VLM は、グラウンディング (Visual grounding)、推論 (Reasoning)、理解を必要とする強力なアプリケーションを開発するのに役立ちます。例えば、画像キャプショニング、画像テキスト検索、ビジュアル Q&A、文書 Q&A などを担当する AI エージェントを構築することができます。Llama Guard モデルは、テキスト入力に加えて、画像入力のガードレールもサポートするようになりました。
Llama 3.2 モデル アーキテクチャは、最適化された Transformer アーキテクチャを使用する自己回帰言語モデルです。指示チューニング版では、教師ありファインチューニング (SFT) と、人間のフィードバックによる強化学習 (RLHF) を使用して、人間の好みに合わせた有用性と安全性を実現しています。すべてのモデルは 128K トークンの長いコンテキスト長をサポートし、グループ化されたクエリ アテンション (GQA) のサポートと共に推論に最適化されています。
NVIDIA は、Llama 3.2 のモデル コレクションを最適化しており、データ センターから
NVIDIA RTX
搭載のローカル ワークステーション、そして
NVIDIA Jetson
搭載のエッジに至るまで、世界中の数百万の GPU で高スループットと低遅延を実現しています。この記事では、ハードウェアとソフトウェアの最適化、カスタマイズ、デプロイを容易にする機能について説明します。
NVIDIA TensorRT による Llama 3.2 のパフォーマンスの高速化
NVIDIA は、Llama 3.2 モデル コレクションを高速化し、コストとレイテンシを低減しながら、比類のないスループットと最適なエンド ユーザー体験を提供しています。
NVIDIA TensorRT
には、高性能なディープラーニング推論用の
TensorRT
および
TensorRT-LLM
ライブラリが含まれています。
Llama 3.2 1B および Llama 3.2 3B モデルは、TensorRT-LLM の長コンテキスト サポートのために、
Scaled Rotary Position Embedding (RoPE)
技術と KV キャッシュおよびインフライト バッチングなど、その他、
複数の最適化手法
を使用して高速化されています。
Llama 3.2 11B と Llama 3.2 90B はマルチモーダルで、テキスト デコーダーを備えたビジョン エンコーダーが搭載されています。ビジョン エンコーダーは、モデルを ONNX グラフにエクスポートし、TensorRT エンジンを構築することで加速されています。
ONNX
のエクスポートでは、推論に重点を置いた組み込みの演算子と標準データ型を用いた標準モデル定義が作成されます。TensorRT は ONNX グラフを使用し、
TensorRT エンジン
を構築することで、ターゲット GPU にモデルを最適化します。これらのエンジンは、カーネル自動チューニングとレイヤー、テンソルの融合を通じて、NVIDIA GPU の利用を最大限に高めるために、ハードウェア レベルで多様な最適化を提供します。
ビジョン エンコーダーから取得した視覚情報は、TensorRT-LLM でサポートされているクロス アテンションのメカニズムを使用して Llama テキスト デコーダーに融合されます。これにより VLM は、テキスト入力のコンテキストにおける理解と視覚的な推論 (Reasoning) を考慮に入れて、効率的にテキストを生成できるようになります。
NVIDIA NIM を使用して生成 AI ソリューションを容易にデプロイ
TensorRT の最適化は、
NVIDIA NIM
マイクロサービスを使用した本番環境へのデプロイを通じて利用できます。NIM マイクロサービスは、クラウド、データ センター、ワークステーションなど、NVIDIA がアクセラレートするインフラ全体で生成 AI モデルのデプロイを加速します。
Llama 3.2 90B Vision Instruct
、
Llama 3.2 11B Vision Instruct
、
Llama 3.2 3B Instruct
および
Llama 3.2 1B Instruct
は、NIM マイクロサービスを通じた本番環境へのデプロイに対応しています。NIM は、生成 AI ワークロードの簡素化された管理とオーケストレーション、標準的なアプリケーション プログラミング インターフェイス (API) および本番環境に対応したコンテナーによるエンタープライズ サポートを提供します。175 社を超えるパートナーが自社のソリューションを NVIDIA NIM マイクロサービスと統合し、強力で拡大を続けるエコシステム サポートを提供することで、世界中の開発者、研究者、企業は、生成 AI アプリケーションに対する投資収益率を最大化できます。
NVIDIA AI Foundry と NVIDIA NeMo による Llama 3.2 モデルのカスタマイズと評価
NVIDIA AI Foundry
は、高度な AI ツール、コンピューティング リソース、AI の専門知識にアクセスできる、Llama 3.2 モデルのカスタマイズに適したエンドツーエンドのプラットフォームを提供します。独自のデータに基づいてファインチューニングしたカスタム モデルにより、企業は特定ドメインにおける業務でより優れたパフォーマンスと精度を達成し、競争力を高めることができます。
NVIDIA NeMo
を使用することで、開発者はトレーニング データをキュレーションして LoRA、SFT、DPO、RLHF などの高度なチューニング技術を活用して、Llama 3.2 モデルをカスタマイズし、精度を評価し、ガードレールを追加して、モデルから適切な応答が得られるようになります。AI Foundry は、
NVIDIA DGX Cloud
上で専用のリソースを提供し、そして NVIDIA AI の専門家によってサポートされています。出力は、NVIDIA NIM 推論マイクロサービスとしてパッケージ化されたカスタム Llama 3.2 モデルで、どこにでもデプロイすることができます。
NVIDIA RTX および NVIDIA Jetson によるローカル推論のスケーリング
現在、Llama 3.2 モデルは、世界中の 1 億台を超える NVIDIA RTX 搭載 PC およびワークステーションで最適化されています。Windows でのデプロイ用に NVIDIA はこのモデル スイートを最適化し、DirectML バックエンドで ONNX-GenAI ランタイムを使用して効率的に動作するようにしました。
NVIDIA RTX で Llama 3.2 3B モデル
を使用してみましょう。
新しい VLM と SLM モデルは、NVIDIA RTX システムに新たな可能性をもたらします。実証するために、テキストと視覚データ処理 (例えば画像、グラフ、表など) を組み合わせ、情報検索と生成を強化するマルチモーダル
検索拡張生成 (RAG)
パイプラインの例を作成しました。
Llama 3.2 SLM と VLM を使用して NVIDIA RTX Linux システム上でこのパイプラインを実行する方法についてご覧ください
。30 GB 以上のメモリを搭載する NVIDIA RTX プロフェッショナル GPU を搭載した Linux ワークステーションが必要となります。
SLM は、アプリケーションに特化したドメインの精度を確保しながらメモリ、レイテンシおよび演算要件を削減するために、蒸留、プルーニング、量子化などの技術を使用して、エッジ デバイスへのローカル デプロイに合わせてカスタマイズされています。最適化された GPU の推論と INT4/FP8 量子化を備えた Jetson に、Llama 3.2 1B および 3B SLM をダウンロードしてデプロイするには、
NVIDIA Jetson AI Lab の SLM チュートリアル
を参照してください。
マルチモーダル モデルは、ビデオ分析やロボティクスにおける独自のビジョン機能により、エッジ アプリケーションで有用性が高まってきています。
Llama 3.2 11B VLM は、組み込みの Jetson AGX Orin 64 GB でサポートされています
。
コミュニティ AI モデルの進化
オープンソースに積極的に貢献している NVIDIA では、ユーザーが直面する最も困難な課題で支援できるように、コミュニティ ソフトウェアの最適化に取り組んでいます。オープンソースの AI モデルは透明性を促進し、ユーザーは AI の安全性とレジリエンスに関する作業を広く共有することが可能になります。
Hugging Face の推論サービス (Inference-as-a-Service)
機能により、開発者は
NVIDIA DGX Cloud
上で動作する NVIDIA NIM マイクロサービスで最適化された Llama 3 コレクションなどの
大規模言語モデル (LLM)
を迅速にデプロイすることができます。
NVIDIA 開発者プログラム
を通じて、研究、開発、テスト用の NIM への無料アクセスを利用できます。
NVIDIA NIM
、
NVIDIA TensorRT-LLM
、
NVIDIA TensorRT
、
NVIDIA Triton
などのNVIDIA AI 推論プラットフォームが、
LoRA
でチューニングした最新の LLM の高速化など、どのように最先端の技術を使用しているのかについては詳細を是非調べてみてください。
関連情報
GTC セッション:
LLM クラスター アーキテクチャの青写真: 世界最大規模のデプロイに向けたスケーリング (Supermicro による講演)
NGC コンテナー:
Llama-3-Swallow-70B-Instruct-v0.1
NGC コンテナー:
Llama-3.1-405b-instruct
SDK:
Llama3 8B Instruct NIM


Advancing the Accuracy-Efficiency Frontier with Llama-3.1-Nemotron-51B

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


Transforming Financial Analysis with NVIDIA NIM

In financial services, portfolio managers and research analysts diligently sift through vast amounts of data to gain a competitive edge in investments. Making informed decisions requires access to the most pertinent data and the ability to quickly synthesize and interpret that data.
Traditionally, sell-side analysts and fundamental portfolio managers have focused on a small subset of companies, meticulously examining financial statements, earning calls, and corporate filings. Systematically analyzing financial documents across a larger trading universe can uncover additional insights. Due to the technical and algorithmic difficulty of such tasks, systematic analysis of transcripts over a wide trading universe was, until recently, only accessible to sophisticated quant-trading firms.
The performance achieved on these tasks using traditional
natural language processing (NLP)
methods such as bag-of-words, sentiment dictionaries, and word statistics, often falls short when compared to the capabilities of
large language models (LLMs)
in financial NLP tasks. Besides financial applications, LLMs have demonstrated superior performance in domains like medical document understanding, news article summarization, and legal document retrieval.
By leveraging AI and NVIDIA technology, sell-side analysts, fundamental traders, and retail traders can significantly accelerate their research workflow, extract more nuanced insights from financial documents, and cover more companies and industries. By adopting these advanced AI tools, the financial services sector can enhance its data analysis capabilities, saving time and improving the accuracy of investment decisions. According to the NVIDIA
2024 State of AI in Financial Services
survey report, 37% of respondents are exploring generative AI and LLMs for report generation, synthesis, and investment research to reduce repetitive manual work.
In this post, we’ll walk you through an end-to-end demo on how to build an AI assistant to extract insights from earnings call transcripts using
NVIDIA NIM
inference microservices to implement a
retrieval-augmented generation (RAG)
system. We’ll highlight how leveraging advanced AI technologies can accelerate workflows, uncover hidden insights, and ultimately enhance decision-making processes in the financial services industry.
Analyzing earnings call transcripts with NIM microservices
Earnings calls in particular are a vital source for investors and analysts, providing a platform for companies to communicate important financial and business information. These calls offer insights into the industry, the company’s products, competitors, and most importantly, its business prospects.
By analyzing earnings call transcripts, investors can glean valuable information about a company’s future earnings and valuation. Earnings call transcripts have successfully been used to generate alpha for over two decades. For more details, see
Natural Language Processing – Part I: Primer
and
Natural Language Processing – Part II: Stock Selection
.
Step 1: The data
In this demo, we use transcripts from NASDAQ earnings calls from 2016 to 2020 for our analysis. This
Earnings Call Transcripts dataset
can be downloaded from Kaggle.
For our evaluation, we used a subset of 10 companies from which we then randomly selected 63 transcripts for manual annotation. For all transcripts, we answered the following set of questions:
What are the company’s primary revenue streams and how have they changed over the past year?
What are the company’s major cost components and how have they fluctuated in the reporting period?
What capital expenditures were made and how are these supporting the company’s growth?
What dividends or stock buybacks were executed?
What significant risks are mentioned in the transcript?
This makes for a total of 315 question-answer pairs. All questions are answered using a structured
JSON format
. For example:
Question: What are the company’s primary revenue streams and how have they changed over the past year?
Answer:
{
  "Google Search and Other advertising": {
	"year_on_year_change": "-10%",
	"absolute_revenue": "21.3 billion",
	"currency": "USD"
  },
  "YouTube advertising": {
	"year_on_year_change": "6%",
	"absolute_revenue": "3.8 billion",
	"currency": "USD"
  },
  "Network advertising": {
	"year_on_year_change": "-10%",
	"absolute_revenue": "4.7 billion",
	"currency": "USD"
  },
  "Google Cloud": {
	"year_on_year_change": "43%",
	"absolute_revenue": "3 billion",
	"currency": "USD"
  },
  "Other revenues": {
	"year_on_year_change": "26%",
	"absolute_revenue": "5.1 billion",
	"currency": "USD"
  }
}
Using JSON enables evaluating model performance in a manner that does not rely on subjective language understanding methods, such as
LLM-as-a-judge
, which might introduce unwanted biases into the evaluation.
Step 2: NVIDIA NIM
This demo uses
NVIDIA NIM
, a set of microservices designed to speed up enterprise
generative AI
deployment. For more details, see
NVIDIA NIM Offers Optimized Inference Microservices for Deploying AI Models at Scale
. Supporting a wide range of AI models, including NVIDIA-optimized community and commercial partner models, NIM ensures seamless, scalable AI inferencing, on-premises or in the cloud, leveraging industry-standard APIs.
When ready for production, NIM microservices are deployed with a single command for easy integration into enterprise-grade AI applications using standard APIs and just a few lines of code. Built on robust foundations including inference engines like
NVIDIA TensorRT
, TensorRT-LLM, and PyTorch, NIM is engineered to facilitate seamless AI inferencing with best performance out-of-the-box based on the underlying hardware. Self-hosting models with NIM supports the protection of customer and enterprise data, which is a common requirement in RAG applications.
Step 3: Setting up on NVIDIA API catalog
NIM microservices can be accessed using the NVIDIA API catalog. All it takes to set up is registering an NVIDIA API key (From the
API catalog
, click Get API Key.) For the purposes of this post, we’ll store it in an environment variable:
export NVIDIA_API_KEY=YOUR_KEY
LangChain provides a package for
convenient NGC integration
. This tutorial will use endpoints to run embedding, reranking, and chat models with NIM microservices. To reproduce the code, you’ll need to install the following Python dependencies:
langchain-nvidia-ai-endpoints==0.1.2
faiss-cpu==1.7.4
langchain==0.2.5
unstructured[all-docs]==0.11.2
Step 4: Building a RAG pipeline with NIM microservices
RAG is a method that enhances language models by combining retrieval of relevant documents from a large corpus with text generation.
The first step of RAG is to vectorize your collection of documents. This involves taking a series of documents, splitting them into smaller chunks, using an embedder model to turn each of these chunks into a neural network embedding (a vector), and storing them in a
vector database
.
We’ll do this for each of the earning calls transcripts:
import os
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.document_loaders import TextLoader
from langchain.vectorstores import FAISS
from langchain_nvidia_ai_endpoints import NVIDIAEmbeddings

# Initialise the embedder that converts text to vectors
transcript_embedder = NVIDIAEmbeddings(model='nvidia/nv-embed-v1',
                                       truncate='END'
                                       )

# The document we will be chunking and vectorizing
transcript_fp = "Transcripts/GOOGL/2020-Feb-03-GOOGL.txt"
raw_document = TextLoader(transcript_fp).load()
# Split the document into chunks of 1500 characters each
text_splitter = RecursiveCharacterTextSplitter(chunk_size=3000,
                                               chunk_overlap=200)
documents = text_splitter.split_documents(raw_document)
# Vectorise each chunk into a separate entry in the database
vectorstore = FAISS.from_documents(documents, transcript_embedder)
vector_store_path = "vector_db/google_transcript_2020_feb.pkl"
try:
    os.remove(vector_store_path)
except OSError:
    pass
vectorstore.save_local(vector_store_path)
Once the vectorized database is built, the simplest RAG flow for the earning calls transcripts is as follows:
A user inputs a
query.
For example, “What are the company’s main revenue sources?”
The
embedder
model embeds the query into a vector and then searches through the vectorized database of the documents for the Top-K (Top-30, for example) most relevant chunks.
A
reranker
model, also known as a cross-encoder, then outputs a similarity score for each query-document pair. Additionally, metadata can also be used to help improve the accuracy of the reranking step. This score is used to reorder the Top-K documents retrieved by the embedder by relevance to the user query. Further filtering can then be applied, retaining only the Top-N (Top-10, for example) documents.
The Top-N most relevant documents are then passed onto an
LLM
alongside the user query. The retrieved documents are used as context to ground the model’s answer.
Figure 2. A simplified RAG workflow that involves three main steps: embedding and retrieval, reranking, and context-grounded LLM answer generation
Note that modifications can be made to improve a model’s answer accuracy, but for now we’ll continue with the simplest robust approach.
Consider the following user query and desired JSON format:
question = "What are the company’s primary revenue streams and how have they changed over the past year?"

json_template = """
{"revenue_streams": [
    {
        "name": "<Revenue Stream Name 1>",
        "amount": <Current Year Revenue Amount 1>,
        "currency": "<Currency 1>",
        "percentage_change": <Change in Revenue Percentage 1>
    },
    {
        "name": "<Revenue Stream Name 2>",
        "amount": <Current Year Revenue Amount 2>,
        "currency": "<Currency 2>",
        "percentage_change": <Change in Revenue Percentage 2>
    },
    // Add more revenue streams as needed
]
}
"""

user_query = question + json_template
The JSON template will be used so that, further down the pipeline, the LLM knows to output its answer in valid JSON, rather than in plain text. As mentioned in Step 1, using JSON enables the automated evaluation of model answers in an objective manner. Note that this could be removed if a more conversational style is preferred.
To contextualize the user query, initialize the Embedder and the Reranker for the retrieval and ordering of the relevant documents:
from langchain_nvidia_ai_endpoints import NVIDIARerank
from langchain.retrievers.contextual_compression import ContextualCompressionRetriever

# How many retrieved documents to keep at each step
top_k_documents_retriever = 30
top_n_documents_reranker = 5
# Initialie retriever for vector database
retriever = vectorstore.as_retriever(search_type='similarity',
                                     search_kwargs={'k': top_k_documents_retriever})
# Add a reranker to reorder documents by relevance to user query
reranker = NVIDIARerank(model="ai-rerank-qa-mistral-4b",
                         top_n=top_n_documents_reranker)
retriever = ContextualCompressionRetriever(base_compressor=reranker,
                                           base_retriever=retriever)
# Retrieve documents, rerank them and pick top-N
retrieved_docs = retriever.invoke(user_query)
# Join all retrieved documents into a single string
context = ""
for doc in retrieved_docs:
    context += doc.page_content + "\n\n"
Then, when the relevant documents are retrieved, they can be passed onto the LLM alongside the user query. We are using the
Llama 3 70B
NIM:
from langchain_nvidia_ai_endpoints import ChatNVIDIA

PROMPT_FORMAT = """"
Given the following context:

####################
{context}
####################

Answer the following question:
{question}

using the following JSON structure:

{json_template}

For amounts don't forget to always state if it's in billions or millions and "N/A" if not present.
Only use information and JSON keys that are explicitly mentioned in the transcript.
If you don't have information for any of the keys use "N/A" as a value.
Answer only with JSON. Every key and value in the JSON should be a string.
"""

llm = ChatNVIDIA(model="ai-llama3-70b",
                 max_tokens=600,
                 temperature=0
                )

llm_input = PROMPT_FORMAT.format(**{"context": context,
                                    "question": question,
                                    "json_template": json_template
                                   })
answer = llm.invoke(llm_input)
print(answer.content)
Running this code will produce a JSON-structured answer to the user query. The code can now be easily modified to read in multiple transcripts and answer varying user queries.
Step 5: Evaluation
To evaluate the performance of the retrieval step, use the annotated question-answer pairs previously described to compare the ground-truth JSON with the predicted JSON, key-by-key. Consider the following ground-truth example:
"Google Cloud": {
    "year_on_year_change": "43%",
    "absolute_revenue": "3 billion",
    "currency": "N/A"
}
The prediction looks like this:
"Google Cloud": {
	"year_on_year_change": "43%",
	"absolute_revenue": "N/A",
	"currency": "USD"
}
The three possible outcomes are:
True positive (TP)
: There is no value to extract, and the ground truth and the prediction match. For the previous example, the prediction for
year_on_year_change
is TP.
False Positive (FP)
: The ground truth value is
“N/A”
. In other words, there is no value to extract, but the prediction hallucinates a value. For the previous example, the prediction for
currency
is FP.
False Negative (FN)
: There is a ground truth value to extract, however, the prediction fails to capture that value. For the previous example, the prediction for
absolute_revenue
is FP.
With these outcomes measured, next calculate the following three main metrics:
Recall
= TP/ (TP + FN): Higher recall implies our model is returning more and more of the relevant results.
Precision
= TP / (TP + FP): Higher precision implies our model returns a higher ratio of relevant results versus irrelevant ones.
F1-score
= (2 * Precision * Recall) / (Precision + Recall): The F1-score is a harmonic mean of precision and recall.
A user might want to be partially flexible with the matching of non-numeric values when doing string comparisons for some of the attributes. For example, consider a question about revenue sources, where one of the ground-truth answers is “Data Centers” and the model outputs “Data Center”. An exact match evaluation would treat this as a mismatch. To achieve more robust evaluation in such cases, use fuzzy matching with the Python default
difflib
:
import difflib

def get_ratio_match(gt_string, pred_string):
   if len(gt_string) < len(pred_string):
       min_len = len(gt_string)
   else:
       min_len = len(pred_string)
   matcher = difflib.SequenceMatcher(None, gt_string, pred_string, autojunk=False)
   _, _, longest_match = matcher.find_longest_match(0, min_len, 0, min_len)
   # Return the ratio of match with ground truth
   return longest_match / min_len
For evaluation, consider any string attributes to be a match if their similarity ratio is above 90%.
Table 1 presents results for two of the most-used open-source model families (Mistral AI Mixtral models and Meta Llama 3 models) on our manually annotated data. For both model families, there is noticeable performance deterioration when lowering the number of parameters. Visit the
NVIDIA API catalog
to experience these NIM microservices.
Method
F1
Precision
Recall
Llama 3 70B
84.4%
91.3%
78.5%
Llama 3 8B
75.8%
85.2%
68.2%
Mixtral 8x22B
84.4%
91.9%
78.0%
Mixtral 8x7B
62.2%
80.2%
50.7%
Table 1. Performance of Llama and Mixtral models on JSON-structured information extraction and question-answering from earning call transcripts
Mixtral-8x22B seems to have roughly equivalent performance to Llama 3 70B. However, for both model families, reducing the number of parameters does result in a significant decrease in performance. A decrease is most accentuated for Recall. This presents a frequent trade-off between choosing to have better accuracy at the cost of larger hardware requirements.
In most cases, model accuracy can be improved without increasing the number of parameters, by fine-tuning either the Embedder, Reranker, or the LLM using domain-specific data (in this case, earning call transcripts).
The Embedder is the smallest and therefore the quickest and most cost-effective to fine-tune. For detailed instructions, refer to the
NVIDIA NeMo documentation
. Additionally,
NVIDIA NeMo
simplifies and enhances the efficiency of fine-tuning an effective version of the LLM.
Key implications for users
This demo is designed to extract insights from earnings call transcripts. By leveraging advanced AI technologies like NIM, it’s now possible to quickly and accurately retrieve information from earnings call transcripts. The AI product assists multiple categories of financial researchers, analysts, advisors, and fundamental portfolio managers during the most intensive processes of documentation and data analysis, enabling financial professionals to spend more time on strategic decision-making or with clients.
In the asset management sector, for example, portfolio managers can use the assistant to quickly synthesize insights from a vast number of earnings calls, improving investment strategies and outcomes. In the insurance industry, the AI assistant can analyze financial health and risk factors from company reports, enhancing underwriting and risk assessment processes. In fundamental and retail trading, the assistant can help with systematic information extraction to identify market trends and sentiment shifts, enabling the use of more detailed information for future trades.
Even in banking, it can be used to assess the financial stability of potential loan recipients by analyzing their earnings calls. Ultimately, this technology enhances efficiency, accuracy, and the ability to make data-driven decisions, giving users a competitive edge in their respective markets.
Visit the
NVIDIA API catalog
to see all the available NIM microservices and experiment with
LangChain’s convenient integration
to see what works best for your own data.

NVIDIA NIM による財務分析の変革

Reading Time:
4
minutes
金融サービスでは、ポートフォリオ マネージャーやリサーチ アナリストが膨大な量のデータを丹念に精査し、投資で競争力を高めています。情報に基づいた意思決定を行うには、最も関連性の高いデータにアクセスし、そのデータを迅速に統合して解釈する能力が必要です。
従来、セルサイド アナリストやファンダメンタル ポートフォリオ マネージャーは、財務諸表、収益報告、企業提出書類を綿密に調べ、一部の企業に焦点を当ててきました。より広範な取引対象範囲にわたって財務文書を体系的に分析することで、さらなる洞察を得ることができます。このようなタスクは技術的およびアルゴリズム的に難しいため、広範な取引対象範囲にわたるトランスクリプトの体系的な分析は、最近まで、高度なクオンツ トレーディング (quant-trading) 会社にしかできませんでした。
これらのタスクで、バッグオブワード、感情辞書、単語統計などの従来の
自然言語処理 (NLP)
手法を使用して達成されるパフォーマンスは、金融 NLP タスクにおける
大規模言語モデル (LLM)
の機能と比較すると、しばしば不十分です。金融アプリケーション以外にも、LLM は医療文書の理解、ニュース記事の要約、法的文書の検索などの分野で優れたパフォーマンスを発揮しています。
AI と NVIDIA のテクノロジを活用することで、セルサイド アナリスト、ファンダメンタル トレーダー、リテール トレーダーはリサーチ ワークフローを大幅に加速し、金融文書からより微妙な洞察を抽出し、より多くの企業や業界をカバーできます。これらの高度な AI ツールを導入することで、金融サービス部門はデータ分析機能を強化し、時間を節約し、投資決定の精度を向上させることができます。
NVIDIA の 2024 年金融サービス
における AI の現状調査レポートによると、回答者の 37% (中国を除く) が、反復的な手作業を減らすために、レポート生成、統合合成、投資調査のための生成 AI と LLM を検討しています。
この記事では、
NVIDIA NIM
推論マイクロサービスを使用して収益報告のトランスクリプトから洞察を抽出する AI アシスタントを構築し、
検索拡張生成 (RAG)
システムを実装する方法について、エンドツーエンドのデモで説明します。高度な AI テクノロジを活用することで、ワークフローを加速し、隠れた洞察を明らかにし、最終的に金融サービス業界の意思決定プロセスを強化する方法を紹介します。
NIM による収益報告の記録の分析
特に、決算発表の電話会議は投資家やアナリストにとって重要な情報源であり、企業が重要な財務情報や事業情報を伝達するプラットフォームを提供します。これらの電話会議は、業界、企業の製品、競合他社、そして最も重要な事業見通しについての洞察を提供します。
決算発表の電話会議の記録を分析することで、投資家は企業の将来の収益と評価に関する貴重な情報を収集できます。決算発表の電話会議の記録は、20 年以上にわたってアルファを生み出すために効果的に使用されてきました。詳細については、
「自然言語処理 – パート I: 入門」
(2017 年 9 月) および
「自然言語処理 – パート II: 銘柄選択」
(2018 年 9 月)を参照してください。
ステップ 1: データ
このデモでは、2016 年から 2020 年までの NASDAQ の収益報告のトランスクリプトを分析に使用します。この
収益報告のトランスクリプト データセット
は、Kaggle からダウンロードできます。
評価では、10 社のサブセットを使用し、そこから 63 件のトランスクリプトをランダムに選択して手動で注釈を付けました。すべてのトランスクリプトについて、次の一連の質問に答えました:
会社の主な収益源は何ですか。過去 1 年間でどのように変化しましたか?
会社の主なコスト要素は何ですか。報告期間中にどのように変動しましたか?
どのような設備投資が行われ、それがどのように会社の成長を支えていますか?
どのような配当または株式買い戻しが実行されましたか?
トランスクリプトで言及されている重要なリスクは何ですか?
これにより、合計 315 の質問と回答のペアが作成されます。すべての質問への回答は、構造化された
JSON フォーマット
を使用して行われます。
たとえば:
質問: 会社の主な収入源は何ですか? また、過去 1 年間でどのように変化しましたか? (What are the company’s primary revenue streams and how have they changed over the past year?)
回答:
{
  "Google Search and Other advertising": {
    "year_on_year_change": "-10%",
    "absolute_revenue": "21.3 billion",
    "currency": "USD"
  },
  "YouTube advertising": {
    "year_on_year_change": "6%",
    "absolute_revenue": "3.8 billion",
    "currency": "USD"
  },
  "Network advertising": {
    "year_on_year_change": "-10%",
    "absolute_revenue": "4.7 billion",
    "currency": "USD"
  },
  "Google Cloud": {
    "year_on_year_change": "43%",
    "absolute_revenue": "3 billion",
    "currency": "USD"
  },
  "Other revenues": {
    "year_on_year_change": "26%",
    "absolute_revenue": "5.1 billion",
    "currency": "USD"
  }
}
JSON を使用すると、評価に望ましくないバイアスを導入する可能性のある「
LLM 断言
」などの主観的な言語理解方法に依存せずにモデルのパフォーマンスを評価できます。
ステップ 2: NVIDIA NIM
このデモでは、エンタープライズ生成 AI の導入を高速化するために設計されたマイクロサービス セットである
NVIDIA NIM
を使用します。詳細については、
「NVIDIA NIM は AI モデルの大規模な導入向けに最適化された推論マイクロサービスを提供します」
を参照してください。
NVIDIA 向けに最適化されたコミュニティ モデルや商用パートナー モデルなど、幅広い AI モデルをサポートする NIM は、業界標準の API を活用して、オンプレミスまたはクラウドでシームレスでスケーラブルな AI 推論を実現します。実稼働の準備ができたら、NIM は 1 つのコマンドで導入され、標準 API とわずか数行のコードを使用してエンタープライズ グレードの AI アプリケーションに簡単に統合できます。
NVIDIA TensorRT
、TensorRT-LLM、PyTorch などの推論エンジンを含む堅牢な基盤上に構築された NIM は、基盤となるハードウェアに基づいてすぐに最高のパフォーマンスでシームレスな AI 推論を実現するように設計されています。NIM を使用したセルフホスティング (self-hosting) モデルは、RAG アプリケーションで一般的な要件である顧客データと企業データの保護をサポートします。
ステップ 3: NVIDIA API カタログでの設定
NIM には、
NVIDIA API カタログ
を使用してアクセスできます。設定に必要なのは、NVIDIA API キーを登録することだけです (API カタログから、[API キーの取得] をクリックします)。この記事では、これを環境変数に保存します。
export NVIDIA_API_KEY=YOUR_KEY
LangChain は、
便利な NGC 統合
用のパッケージを提供しています。このチュートリアルでは、エンドポイントを使用して、NIM で埋め込み、リランキング、チャット モデルを実行します。コードを再現するには、次の Python 依存関係をインストールする必要があります。
langchain-nvidia-ai-endpoints==0.1.2
faiss-cpu==1.7.4
langchain==0.2.5
unstructured[all-docs]==0.11.2
ステップ 4: NIM を使用した RAG パイプラインの構築
RAG は、大規模なコーパスからの関連文書の取得とテキスト生成を組み合わせることで言語モデルを強化する方法です。
RAG の最初のステップは、文書のコレクションをベクトル化することです。これには、一連の文書を取得し、それらを小さなチャンクに分割し、埋め込みモデルを使用してこれらの各チャンクをニューラル ネットワーク埋め込み (ベクトル) に変換し、
ベクトル データベース
に保存することが含まれます。各収益報告通話のトランスクリプトに対してこれらの操作を実行します。
import os
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.document_loaders import TextLoader
from langchain.vectorstores import FAISS
from langchain_nvidia_ai_endpoints import NVIDIAEmbeddings

# Initialise the embedder that converts text to vectors
transcript_embedder = NVIDIAEmbeddings(model='nvidia/nv-embed-v1',
                                       truncate='END'
                                       )

# The document we will be chunking and vectorizing
transcript_fp = "Transcripts/GOOGL/2020-Feb-03-GOOGL.txt"
raw_document = TextLoader(transcript_fp).load()
# Split the document into chunks of 1500 characters each
text_splitter = RecursiveCharacterTextSplitter(chunk_size=3000,
                                               chunk_overlap=200)
documents = text_splitter.split_documents(raw_document)
# Vectorise each chunk into a separate entry in the database
vectorstore = FAISS.from_documents(documents, transcript_embedder)
vector_store_path = "vector_db/google_transcript_2020_feb.pkl"
try:
    os.remove(vector_store_path)
except OSError:
    pass
vectorstore.save_local(vector_store_path)
ベクトル化されたデータベースが構築されると、収益報告の記録の最も単純な RAG フローは次のようになります。
ユーザーが
クエリ (query)
を入力します。たとえば、「会社の主な収益源は何ですか?」(What are the company’s main revenue sources?)
埋め込みモデル (embedder)
はクエリをベクトルに埋め込み、ドキュメントのベクトル化されたデータベースを検索して、最も関連性の高い上位 K (例えば、上位 30 など) のチャンクを探します。
次に、クロスエンコーダーとも呼ばれる
リランキング (reranker)
モデルが、クエリとドキュメントの各ペアの類似性スコアを出力します。さらに、メタデータを使用して、再ランク付けステップの精度を向上させることもできます。このスコアは、埋め込みによって取得された上位 K のドキュメントを、ユーザー クエリとの関連性で並べ替えるために使用されます。その後、さらにフィルタリングを適用して、上位 N (例えば、上位 10 など) のドキュメントのみを保持できます。
次に、最も関連性の高い上位 N のドキュメントが、ユーザークエリとともに
LLM
に渡されます。取得されたドキュメントは、モデルの回答を基盤付けるコンテキストとして使用されます。
図1. 埋め込みと検索、リランキング、コンテキストに基づいた LLM 回答生成という 3 つの主要なステップを含む簡略化された RAG ワークフロー
モデルの回答精度を向上させるために変更を加えることもできますが、今のところは最もシンプルで堅牢なアプローチを続けます。
次のユーザー クエリと必要な JSON フォーマットを検討してください。
question = "What are the company’s primary revenue streams and how have they changed over the past year?"

# 会社の主な収入源は何ですか? また、過去 1 年間でどのように変化しましたか?

json_template = """
{"revenue_streams": [
    {
        "name": "<Revenue Stream Name 1>",
        "amount": <Current Year Revenue Amount 1>,
        "currency": "<Currency 1>",
        "percentage_change": <Change in Revenue Percentage 1>
    },
    {
        "name": "<Revenue Stream Name 2>",
        "amount": <Current Year Revenue Amount 2>,
        "currency": "<Currency 2>",
        "percentage_change": <Change in Revenue Percentage 2>
    },
    // Add more revenue streams as needed
]
}
"""

user_query = question + json_template
JSON テンプレートは、パイプラインのさらに先で、LLM がプレーン テキストではなく有効な JSON フォーマットで回答を出力することを認識できるように使用されます。ステップ 1 で述べたように、JSON を使用すると、客観的な方法でモデル回答を自動的に評価できます。より「会話的なスタイル」が望ましい場合は、これを削除できることに注意してください。
ユーザー クエリをコンテキスト化するには、関連するドキュメントを取得して順序付けするために、Embedder (埋め込みモデル) と Reranker (リランキングモデル) を初期化します:
from langchain_nvidia_ai_endpoints import NVIDIARerank
from langchain.retrievers.contextual_compression import ContextualCompressionRetriever

# 1 How many retrieved documents to keep at each step, 各ステップで取得されたドキュメントをいくつ保存するかの設定：
top_k_documents_retriever = 30
top_n_documents_reranker = 5
# 2 Initialize retriever for vector database, ベクトルデータベースの取得を初期化する:
retriever = vectorstore.as_retriever(search_type='similarity',
                                     search_kwargs={'k': top_k_documents_retriever})
# 3 Add a reranker to reorder documents by relevance to user query, ユーザークエリとの関連性に基づいてドキュメントを並べ替えるリランキング機能を追加する:
reranker = NVIDIARerank(model="ai-rerank-qa-mistral-4b",
                         top_n=top_n_documents_reranker)
retriever = ContextualCompressionRetriever(base_compressor=reranker,
                                           base_retriever=retriever)
# 4 Retrieve documents, rerank them and pick top-N, ドキュメントを取得し、リランキングして上位Nを選択する:
retrieved_docs = retriever.invoke(user_query)
# 5 Join all retrieved documents into a single string, 取得したすべてのドキュメントを1つの文字列に結合する:
context = ""
for doc in retrieved_docs:
    context += doc.page_content + "\n\n"
次に、関連するドキュメントが取得されると、ユーザー クエリとともに LLM に渡されます。ここでは、
Llama 3 70B
NIM を使用しています。
from langchain_nvidia_ai_endpoints import ChatNVIDIA

PROMPT_FORMAT = """"
Given the following context:

####################
{context}
####################

Answer the following question:
{question}

using the following JSON structure:

{json_template}

For amounts don't forget to always state if it's in billions or millions and "N/A" if not present.
Only use information and JSON keys that are explicitly mentioned in the transcript.
If you don't have information for any of the keys use "N/A" as a value.
Answer only with JSON. Every key and value in the JSON should be a string.
"""

llm = ChatNVIDIA(model="ai-llama3-70b",
                 max_tokens=600,
                 temperature=0
                )

llm_input = PROMPT_FORMAT.format(**{"context": context,
                                    "question": question,
                                    "json_template": json_template
                                   })
answer = llm.invoke(llm_input)
print(answer.content)
このコードを実行すると、ユーザー クエリに対する JSON 構造の回答が生成されます。コードを簡単に変更して、複数のトランスクリプトを読み込んでさまざまなユーザー クエリに回答できるようになりました。
ステップ 5: 評価
検索ステップのパフォーマンスを評価するには、前述の注釈付きの質問と回答のペアを使用して、真実の JSON と予測された JSON をキーごとに比較します。次の真実の例を考えてみましょう。
"Google Cloud": {
    "year_on_year_change": "43%",
    "absolute_revenue": "3 billion",
    "currency": "N/A"
}
予測の出力は次のようになります:
"Google Cloud": {
    "year_on_year_change": "43%",
    "absolute_revenue": "N/A",
    "currency": "USD"
}
考えられる出力の評価結果は 3 つあります。
真陽性 (TP, True Positive)
: 参考の答えと予測が一致しています。前の例では、
year_on_year_change
の予測 (“43%”) は TP です。
偽陽性 (FP, False Positive)
: 参考の答えの値は
"N/A"
です。つまり、抽出する値はありませんが、予測では値が幻覚的に表示されます。前の例では、
currency
の予測 (“USD”) は FP です。
偽陰性 (FN, False Negative)
: 抽出する参考の答えの値がありますが、予測ではその値を取得できませんでした。前の例では、
absolute_revenue
の予測 (“N/A”) は FP です。
これらの結果を測定したら、次に、次の 3 つの主要なメトリックを計算します。
再現率 (Recall)
= TP/ (TP + FN): 再現率が高いほど、モデルが関連する結果をより多く返していることを意味します。
精度 (Precision)
= TP / (TP + FP): 精度が高いほど、モデルが関連する結果と無関係な結果の比率が高くなっていることを意味します。
F1 スコア (F1-score)
= (2 * 適合率 * 再現率) / (適合率 + 再現率): F1 スコアは、適合率と再現率の調和平均です。
ユーザーは、一部の属性について文字列比較を行う際に、数値以外の値のマッチングを部分的に柔軟にしたい場合があります。たとえば、収益源に関する質問を考えてみましょう。ここで、参考の回答の 1 つが複数形の「データ センター」(“Data Centers”) で、モデルが単数形の「データ センター」(“Data Center”)を出力します。完全一致評価では、これは「不一致」として扱われます。このような場合に、より堅牢な評価を実現するには、Python のデフォルトの
difflib
でファジー マッチング (fuzzy matching) を使用します。
import difflib

def get_ratio_match(gt_string, pred_string):
   if len(gt_string) < len(pred_string):
       min_len = len(gt_string)
   else:
       min_len = len(pred_string)
   matcher = difflib.SequenceMatcher(None, gt_string, pred_string, autojunk=False)
   _, _, longest_match = matcher.find_longest_match(0, min_len, 0, min_len)
   # Return the ratio of match with ground truth
   return longest_match / min_len
評価では、類似度が 90% を超える文字列属性は一致していると見なします。
表 1 は、手動で注釈を付けたデータに対する、最もよく使用される 2 つのオープンソース モデル ファミリ (
Mistral AI Mixtral モデル
と
Meta Llama 3 モデル
) の結果を示しています。どちらのモデル ファミリでも、パラメーターの数を減らすとパフォーマンスが著しく低下します。これらの NIM を体験するには、
NVIDIA API カタログ
にアクセスしてください。
Method
F1
Precision
Recall
Llama 3 70B
84.4%
91.3%
78.5%
Llama 3 8B
75.8%
85.2%
68.2%
Mixtral 8x22B
84.4%
91.9%
78.0%
Mixtral 8x7B
62.2%
80.2%
50.7%
表1. 収益報告電話会議の記録からのJSON構造化情報抽出と質問応答におけるLlamaおよびMixtralモデルのパフォーマンス
Mixtral-8x22B は、Llama 3 70B とほぼ同等のパフォーマンスを持っているようです。ただし、どちらのモデル ファミリでも、パラメーターの数を減らすとパフォーマンスが大幅に低下します。低下は Recall で最も顕著です。これは、ハードウェア要件の増加を犠牲にして精度を向上させることを選択するというトレードオフを頻繁に示しています。
ほとんどの場合、ドメイン固有のデータ (この場合は、収益通話のトランスクリプト) を使用して、Embedder、Reranker、または LLM のいずれかを微調整することで、パラメーターの数を増やすことなくモデルの精度を向上させることができます。
Embedder は最も小さいため、微調整が最も迅速かつコスト効率に優れています。詳細な手順については、
NVIDIA NeMo のドキュメント
を参照してください。さらに、
NVIDIA NeMo
は、LLM の有効なバージョンを微調整する効率を簡素化し、強化します。
ユーザー向け重要な意味合い
このデモは、収益報告の記録から洞察を抽出するように設計されています。NIM などの高度な AI テクノロジを活用することで、収益報告の記録から情報を迅速かつ正確に取得できるようになりました。AI 製品は、文書化とデータ分析の最も集中的なプロセス中に、複数のカテゴリの金融研究者、アナリスト、アドバイザー、ファンダメンタル ポートフォリオ マネージャーを支援し、金融専門家が戦略的な意思決定や顧客対応に多くの時間を費やせるようにします。
たとえば、資産管理セクターでは、ポートフォリオ マネージャーはアシスタントを使用して、膨大な数の収益報告から洞察をすばやく統合し、投資戦略と結果を改善できます。保険業界では、AI アシスタントが企業レポートから財務の健全性とリスク要因を分析し、引受とリスク評価のプロセスを強化できます。ファンダメンタル トレーディングと小売取引では、アシスタントが体系的な情報抽出を支援して市場のトレンドと感情の変化を特定し、将来の取引でより詳細な情報を使用できるようにします。
銀行でも、収益報告を分析することで、潜在的なローン受領者の財務安定性を評価するために使用できます。最終的に、このテクノロジーは効率、精度、データに基づく意思決定能力を高め、ユーザーにそれぞれの市場での競争上の優位性をもたらします。
NVIDIA API カタログ
にアクセスして、利用可能なすべての NIM を確認し、
LangChain の便利な統合
を試して、自分のデータに最適なものを味見してください。
関連情報
GTC セッション:
SQL からチャットへ: NVIDIA でエンタープライズ データ分析を変革する方法
NGC コンテナー:
DiffDock
NGC コンテナー:
NMT Megatron Riva 1b
ウェビナー:
資本市場における次世代分析: 取引実行とリスク管理
ウェビナー:
金融サービス向けの大規模な AI モデル推論の加速