cappr

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

ใช้โมเดล Hugging Face Transformers

 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

แยกคำตอบสุดท้ายจากการเสร็จสิ้นทีละขั้นตอน

การแจ้งเตือนแบบทีละขั้นตอนและความคิดที่มีความคิดเป็นวิธีที่มีประสิทธิภาพสูงในการรับ 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 เลือก completion ซึ่งส่วนใหญ่มีแนวโน้มที่จะติดตามโดยการคำนวณ - - การ prompt - - -

c
หลังจาก
P Rompt
ความเชื่อมั่น ในการ ประชาสัมพันธ์

- ตามคำถามของฉันเกี่ยวกับการตรวจสอบ Cross

การพัฒนาท้องถิ่น

ดูหน้านี้ของเอกสาร

สิ่งที่ต้องทำ

ฉันกำลังทิ้ง Todos ที่นี่:

การเปลี่ยนแปลงรหัส

Reseach การทดลอง

อย่าลังเลที่จะยกประเด็น OFC