大規模言語モデルの量子化手法の比較: GPTQ、GGUF、AWQ

大規模言語モデル (LLM) は過去 1 年間で急速に進化しており、この記事では (量子化) へのいくつかのアプローチを検討するとともに、シャーディングとさまざまなストレージおよび圧縮戦略を紹介します。

注: 各 LLM サンプルがロードされた後、OutOfMemory エラーを防ぐためにキャッシュをクリアすることをお勧めします。

 del model, tokenizer, pipe import torch torch.cuda.empty_cache()

Jupyter でビデオメモリを解放できない場合は、Jupyter ノートブックを再起動してください。

モデルの読み込み

LLM をロードする最も直接的で一般的な方法は、Transformer を使用することです。 HuggingFaceは直接使用できるパッケージを作成しました

pip install git+https://github.com/huggingface/transformers.git pip install accelerate bitsandbytes xformers

インストールが完了すると、次のパイプラインを使用して LLM を簡単にロードできます。

 from torch import bfloat16 from transformers import pipeline # Load in your LLM without any compression tricks pipe = pipeline( "text-generation", model="HuggingFaceH4/zephyr-7b-beta", torch_dtype=bfloat16, device_map="auto" )

ここではzephyr-7b-betaを例として使用します。

LLM をロードするこの方法では、通常、圧縮トリックは実行されません。使用例を見てみましょう

messages = [ { "role": "system", "content": "You are a friendly chatbot.", }, { "role": "user", "content": "Tell me a funny joke about Large Language Models." }, ] prompt = pipe.tokenizer.apply_chat_template( messages, tokenize=False, add_generation_prompt=True )

内部プロンプト テンプレートを使用して生成されるプロンプトは、次のように構成されます。

次に、ヒントを LLM に渡して答えを生成します。

 outputs = pipe( prompt, max_new_tokens=256, do_sample=True, temperature=0.1, top_p=0.95 ) print(outputs[0]["generated_text"])

これは最も簡単なワークフローですが、純粋な推論の場合、モデル全体が圧縮や量子化戦略なしでロードされるため、このアプローチは最も効率が低くなります。

シャーディング

定量的な戦略に入る前に、まず前提条件となる方法であるシャーディングを紹介しましょう。シャーディングを使用すると、モデルを小さな部分に分割し、各シャードにモデルの小さな部分を含めることができます。これにより、モデルの重みをさまざまなデバイスに分散することで、GPU メモリの制限に対処できます。

圧縮や量子化はありませんが、この方法は大規模なモデルをロードするための最も簡単なソリューションです。

たとえば、Zephyr-7B-β は実際にシャード化されています。モデルに移動して「ファイルとバージョン」リンクをクリックすると、モデルが 8 つの部分に分割されていることがわかります。

モデルのシャーディングは非常に簡単で、Accelerate パッケージを使用して直接実行できます。

 from accelerate import Accelerator # Shard our model into pieces of 1GB accelerator = Accelerator() accelerator.save_model( model=pipe.model, save_directory="/content/model", max_shard_size="4GB" )

これにより、モデルは4GBのシャードに分割されます

定量化

大規模な言語モデルは、一連の重みとアクティベーションによって表されます。これらの値は通常、通常の 32 ビット浮動小数点 (float32) データ型で表されます。

ビット数は、いくつの値を表現できるかを示します。 Float32 は 1.18e-38 から 3.4e38 までの値を表すことができますが、これは非常に多くの値です。ビット数が少ないほど、表せる値も少なくなります。

より低いビット サイズを選択すると、モデルの精度は低下しますが、表される値が少なくなるため、サイズとメモリ要件が削減されます。

量子化とは、LLM を元の Float32 表現からより小さな表現に変換することを指します。単純に小さいビットのバリアントを使用するのではなく、あまり多くの情報を失うことなく、大きいビット表現を小さいビット表現にマッピングしたいと考えています。

したがって、一般的には、これを実現するために 4bit-NormalFloat (NF4) と呼ばれる新しい形式がよく使用されます。このデータ型は、より大きなビットのデータ型を効率的に表現するためにいくつかの特別なトリックを実行します。次の 3 つのステップで構成されます。

正規化: モデルの重みを正規化して、重みが特定の範囲内に収まるようにします。これにより、より一般的な値をより効率的に表現できるようになります。

量子化: 重みを 4 ビットに量子化します。 NF4 では、量子化レベルは正規化された重みに対して均等に配置され、元の 32 ビットの重みを効果的に表します。

逆量子化: 重みは 4 ビットで保存されますが、計算中に逆量子化されるため、推論中のパフォーマンスが向上します。

量子化操作には Bitsandbytes ライブラリを直接使用できます。

 from transformers import BitsAndBytesConfig from torch import bfloat16 # Our 4-bit configuration to load the LLM with less GPU memory bnb_config = BitsAndBytesConfig( load_in_4bit=True, # 4-bit quantization bnb_4bit_quant_type='nf4', # Normalized float 4 bnb_4bit_use_double_quant=True, # Second quantization after the first bnb_4bit_compute_dtype=bfloat16 # Computation type )

上記の設定は、使用する量子化レベルを指定します。たとえば、重みを量子化するには 4 ビットが使用されますが、推論には 16 ビットが使用されます。

パイプラインにモデルをロードするのは簡単です。

 from transformers import AutoTokenizer, AutoModelForCausalLM, pipeline # Zephyr with BitsAndBytes Configuration tokenizer = AutoTokenizer.from_pretrained("HuggingFaceH4/zephyr-7b-alpha") model = AutoModelForCausalLM.from_pretrained( "HuggingFaceH4/zephyr-7b-alpha", quantization_cnotallow=bnb_config, device_map='auto', ) # Create a pipeline pipe = pipeline(model=model, tokenizer=tokenizer, task='text-generation')

次に、前と同じプロンプトを使用します。

 outputs = pipe( prompt, max_new_tokens=256, do_sample=True, temperature=0.7, top_p=0.95 ) print(outputs[0]["generated_text"])

量子化は、パフォーマンスを同様に保ちながらモデルのメモリ要件を削減できる強力な手法です。これにより、小型の GPU でも LLM の読み込み、使用、微調整を高速化できます。

事前量子化 (GPTQ、AWQ、GGUF)

シャーディングと量子化の技術を検討しました。しかし、モデルをロードするたびに量子化が実行され、非常に時間のかかる操作になります。量子化されたモデルを直接保存し、使用時に直接ロードする方法はありますか？

TheBloke は HuggingFace のユーザーです。一連の量子化操作を実行してくれます。大規模なモデルを使用したことがある人なら、きっとよくご存知だと思います。

これらの定量モデルには、GPTQ、GGUF、AWQ など多くの形式が含まれます。それらを紹介しましょう。

1. GPTQ: GPTモデルのトレーニング後の量子化

GPTQ は、GPU 推論とパフォーマンスに重点を置いた 4 ビットのトレーニング後量子化 (PTQ) 方式です。

この方法の背後にある考え方は、重みの平均二乗誤差を最小限に抑えることで、すべての重みを 4 ビットに圧縮することです。推論中は、メモリを低く抑えながらパフォーマンスを向上させるために、重みを float16 に動的に逆量子化します。

HuggingFace Transformers に gptq クラス モデルをロードする必要があります。

 pip install optimum pip install auto-gptq --extra-index-url https://huggingface.github.io/autogptq-index/whl/cu118/

次に、「TheBloke/zephyr-7B-beta-GPTQ」などのロードする必要があるモデルを見つけてロードします。

 from transformers import AutoModelForCausalLM, AutoTokenizer, pipeline # Load LLM and Tokenizer model_id = "TheBloke/zephyr-7B-beta-GPTQ" tokenizer = AutoTokenizer.from_pretrained(model_id, use_fast=True) model = AutoModelForCausalLM.from_pretrained( model_id, device_map="auto", trust_remote_code=False, revisinotallow="main" ) # Create a pipeline pipe = pipeline(model=model, tokenizer=tokenizer, task='text-generation')

いくつかの追加の依存関係をインストールしましたが、以前と同じパイプラインを使用できるため、コードを変更する必要がなく、これが GPTQ を使用する大きな利点です。

GPTQ は GPU の使用に最適化されているため、最も一般的に使用される圧縮方法です。しかし、GPU がこのような大規模なモデルを処理できない場合は、GPTQ から始めて、GGUF などの CPU 中心の方法に切り替える価値は間違いなくあります。

2. GPT生成の統合フォーマット

GPTQ は圧縮に優れていますが、それを実行するためのハードウェアがない場合は、他の方法を使用する必要があります。

GGUF (旧称 GGML) は、CPU を使用して LLM を実行できるだけでなく、一部のレイヤーを GPU にロードして速度を向上させる量子化方法です。

CPU を使用した推論は一般に GPU を使用するよりも遅くなりますが、CPU または Apple デバイスでモデルを実行したい場合には非常に適した形式です。

GGUF の使い方は非常に簡単です。まず ctransformers パッケージをインストールする必要があります。

 pip install ctransformers[cuda]

次にモデル「TheBloke/zephyr-7B-beta-GGUF」をロードします。

 from ctransformers import AutoModelForCausalLM from transformers import AutoTokenizer, pipeline # Load LLM and Tokenizer # Use `gpu_layers` to specify how many layers will be offloaded to the GPU. model = AutoModelForCausalLM.from_pretrained( "TheBloke/zephyr-7B-beta-GGUF", model_file="zephyr-7b-beta.Q4_K_M.gguf", model_type="mistral", gpu_layers=50, hf=True ) tokenizer = AutoTokenizer.from_pretrained( "HuggingFaceH4/zephyr-7b-beta", use_fast=True ) # Create a pipeline pipe = pipeline(model=model, tokenizer=tokenizer, task='text-generation')

モデルをロードした後、次のプロンプトを実行できます。

 outputs = pipe(prompt, max_new_tokens=256) print(outputs[0]["generated_text"])

CPU と GPU の両方を活用したい場合、GGUF は非常に優れた形式です。

3. AWQ: アクティベーションを考慮した重み量子化

上記 2 つに加えて、GPTQ に似た量子化方式である AWQ (Activation-Aware Weight Quantization) という新しい形式があります。 AWQ と GPTQ には手法としていくつかの違いがありますが、最も重要なのは、AWQ ではすべての重みが LLM のパフォーマンスに対して同等に重要であるとは限らないと想定していることです。

つまり、量子化プロセス中に重みの小さな部分がスキップされ、量子化損失を軽減するのに役立ちます。そのため、彼らの論文では、GPTQ と比較して、同様の、場合によってはそれ以上のパフォーマンスを維持しながら、大幅な高速化が実現されていると述べています。

この方法はまだ比較的新しいため、GPTQ や GGUF ほどには採用されていません。

AWQ では vLLM パッケージを使用します。

 pip install vllm

vLLM を使用すると、モデルを直接ロードできます。

 from vllm import LLM, SamplingParams # Load the LLM sampling_params = SamplingParams(temperature=0.0, top_p=1.0, max_tokens=256) llm = LLM( model="TheBloke/zephyr-7B-beta-AWQ", quantizatinotallow='awq', dtype='half', gpu_memory_utilizatinotallow=.95, max_model_len=4096 )

次に、.generate を使用してモデルを実行します。

 output = llm.generate(prompt, sampling_params) print(output[0].outputs[0].text)

それでおしまい。