ホーム>プログラミング関連>AI ソースコード
ダウンロード

CAPPR：迅速な確率後の完了

選択肢のリストからLLMを選択します。
または、プロンプトが与えられた完了の確率を計算しますが、これは役立ちます。
オープンソースLLMSからさらに絞り出します。

使用法

GGUFモデルを使用します
 from llama_cpp import Llama
from cappr . llama_cpp . classify import predict

model = Llama ( "./TinyLLama-v0.Q8_0.gguf" , verbose = False )

prompt = """Gary told Spongebob a story:
There once was a man from Peru; who dreamed he was eating his shoe. He
woke with a fright, in the middle of the night, to find that his dream
had come true.

The moral of the story is to"""

completions = (
  "look at the bright side" ,
  "use your imagination" ,
  "eat shoes" ,
)

pred = predict ( prompt , completions , model )
print ( pred )
# use your imagination

GGUFモデルの使用に関する詳細については、ドキュメントのこのページを参照してください。

ハグするフェイストランスモデルを使用します
 from transformers import AutoModelForCausalLM , AutoTokenizer
from cappr . huggingface . classify import predict

model_name = "gpt2"
model = AutoModelForCausalLM . from_pretrained ( model_name )
tokenizer = AutoTokenizer . from_pretrained ( model_name )

prompt = "Which planet is closer to the Sun: Mercury or Earth?"
completions = ( "Mercury" , "Earth" )

pred = predict ( prompt , completions , model_and_tokenizer = ( model , tokenizer ))
print ( pred )
# Mercury

transformersモデルの使用に関する詳細については、ドキュメントのこのページを参照してください。

時間を節約するための指示をキャッシュします

多くのプロンプトは、同じ一連の命令から始まります。たとえば、システムプロンプトに加えて、いくつかの例の入出力ペアがあります。一般的な命令でモデルを繰り返し実行する代わりに、将来の計算がより速くなるようにキャッシュします。

cappr.huggingface.classify.cache_modelを使用した例を次に示します。 

 from transformers import AutoModelForCausalLM , AutoTokenizer
from cappr . huggingface . classify import cache_model , predict

# Load model and tokenizer
model = AutoModelForCausalLM . from_pretrained ( "gpt2" )
tokenizer = AutoTokenizer . from_pretrained ( "gpt2" )
model_and_tokenizer = ( model , tokenizer )

# Create data
prompt_prefix = '''Instructions: complete the sequence.
Here are examples:
A, B, C => D
1, 2, 3 => 4

Complete this sequence:'''

prompts = [ "X, Y =>" , "10, 9, 8 =>" ]
completions = [ "7" , "Z" , "Hi" ]

# Cache prompt_prefix because it's used for all prompts
cached_model_and_tokenizer = cache_model (
    model_and_tokenizer , prompt_prefix
)

# Compute
preds = predict (
    prompts , completions , cached_model_and_tokenizer
)
print ( preds )
# ['Z', '7']
トークンレベルのログプロビリティを計算します

cappr.huggingface.classify.log_probs_conditionalを使用した例を次に示します。 

 from transformers import AutoModelForCausalLM , AutoTokenizer
from cappr . huggingface . classify import log_probs_conditional

# Load model and tokenizer
model = AutoModelForCausalLM . from_pretrained ( "gpt2" )
tokenizer = AutoTokenizer . from_pretrained ( "gpt2" )

# Create data
prompts = [ "x y" , "a b c" ]
completions = [ "z" , "d e" ]

# Compute
log_probs_completions = log_probs_conditional (
    prompts , completions , model_and_tokenizer = ( model , tokenizer )
)

# Outputs (rounded) next to their symbolic representation

print ( log_probs_completions [ 0 ])
# [[-4.5],        [[log Pr(z | x, y)],
#  [-5.6, -3.2]]   [log Pr(d | x, y),    log Pr(e | x, y, d)]]

print ( log_probs_completions [ 1 ])
# [[-9.7],        [[log Pr(z | a, b, c)],
#  [-0.2, -0.03]]  [log Pr(d | a, b, c), log Pr(e | a, b, c, d)]]

cappr.utils.classify.agg_log_probs使用して、これらのログプロビリティを効率的に集約します。

少し高度なデモについては、 ./demos/huggingface/dpo.ipynb huggingface/dpo.ipynbを参照してください。

段階的な完了から最終回答を抽出します

ステップバイステップとチェーンのプロンプトは、より複雑なタスクについてLLMを「推論」するための非常に効果的な方法です。ただし、構造化された出力が必要な場合は、ステップバイステップの完了は扱いにくいです。 CAPPRを使用して、考えられる回答のリストを考慮して、これらのタイプの完了から最終回答を抽出します。

このアイデアは、ドキュメントで動作していることをご覧ください。

バッチで実行し、確率を予測します
 from transformers import AutoModelForCausalLM , AutoTokenizer
from cappr . huggingface . classify import predict_proba

# Load a model and its tokenizer
model_name = "gpt2"
model = AutoModelForCausalLM . from_pretrained ( model_name )
tokenizer = AutoTokenizer . from_pretrained ( model_name )

prompts = [
    "Stephen Curry is a" ,
    "Martina Navratilova was a" ,
    "Dexter, from the TV Series Dexter's Laboratory, is a" ,
    "LeBron James is a" ,
]

# Each of the prompts could be completed with one of these:
class_names = ( "basketball player" , "tennis player" , "scientist" )
prior =       (      1 / 6 ,                1 / 6 ,            2 / 3    )
# Say I expect most of my data to have scientists

# Run CAPPr
pred_probs = predict_proba (
    prompts = prompts ,
    completions = class_names ,
    model_and_tokenizer = ( model , tokenizer ),
    batch_size = 2 ,  # whatever fits on your CPU/GPU
    prior = prior ,
)

# pred_probs[i,j] = probability that prompts[i] is classified as class_names[j]
print ( pred_probs . round ( 1 ))
# [[0.5 0.3 0.2]
#  [0.3 0.6 0.2]
#  [0.1 0.1 0.8]
#  [0.8 0.2 0. ]]

# For each prompt, which completion is most likely?
pred_class_idxs = pred_probs . argmax ( axis = - 1 )
preds = [ class_names [ pred_class_idx ] for pred_class_idx in pred_class_idxs ]
print ( preds )
# ['basketball player',
#  'tennis player',
#  'scientist',
#  'basketball player']
各プロンプトには、可能な完了の可能性が異なるバッチで実行されます

繰り返しますが、確率を予測しましょう。 

 from transformers import AutoModelForCausalLM , AutoTokenizer
from cappr . huggingface . classify import predict_proba_examples
from cappr import Example

# Load a model and its tokenizer
model_name = "gpt2"
model = AutoModelForCausalLM . from_pretrained ( model_name )
tokenizer = AutoTokenizer . from_pretrained ( model_name )

# Create a sequence of Example objects representing your classification tasks
examples = [
    Example (
        prompt = "Jodie Foster played" ,
        completions = ( "Clarice Starling" , "Trinity in The Matrix" ),
    ),
    Example (
        prompt = "Batman, from Batman: The Animated Series, was played by" ,
        completions = ( "Pete Holmes" , "Kevin Conroy" , "Spongebob!" ),
        prior =      (     1 / 3      ,      2 / 3     ,      0      ),
    ),
]

# Run CAPPr
pred_probs = predict_proba_examples (
    examples , model_and_tokenizer = ( model , tokenizer )
)

# pred_probs[i][j] = probability that examples[i].prompt is classified as
# examples[i].completions[j]
print ([ example_pred_probs . round ( 2 ) for example_pred_probs in pred_probs ])
# [array([0.7, 0.3]),
#  array([0.03, 0.97, 0.  ])]

# For each example, which completion is most likely?
pred_class_idxs = [
    example_pred_probs . argmax () for example_pred_probs in pred_probs
]
preds = [
    example . completions [ pred_class_idx ]
    for example , pred_class_idx in zip ( examples , pred_class_idxs )
]
print ( preds )
# ['Clarice Starling',
#  'Kevin Conroy']

わずかに難しい分類タスクのデモンストレーションについては、 demosを参照してください。

CAPPRの場合、GPTQモデルは最も計算上パフォーマンスがあります。これらのモデルは、 cappr.huggingface.classifyと互換性があります。これらのモデルを使用する詳細については、ドキュメントのこのページを参照してください。

ドキュメント

https://cappr.readthedocs.io

インストール

ドキュメントのこのページを参照してください。

関連作業

ドキュメントのこのページを参照してください。

モチベーション

エンジニアリングの複雑さを軽減します。

詳細については、ドキュメントのこのページを参照してください。

パフォーマンス

統計パフォーマンス

計算パフォーマンス

それがどのように機能するか

prompt文字列、 end_of_prompt文字列（空白または空）、および文字列が文字列になるように候補のcompletion文字列を入力します。 

{ prompt }{ end_of_prompt }{ completion }

- 自然に流れる考えです。 CAPPRは、 - を計算することでpromptに従う可能性が高いcompletionを選択します。

完了
後
プロンプト
Pr Obability

- Crossが検証された私の質問で具体化されています。

ローカル開発

ドキュメントのこのページを参照してください。

トト

ここにトッドを捨てています：

コードの変更

リセーチ実験

OFCの問題を自由に提起してください

拡大する
追加情報
関連アプリ
おすすめ
関連情報 すべて