홈페이지>프로그래밍 관련>AI 소스 코드
다운로드

CAPPR : 신속한 확률 후 완료

선택 목록에서 LLM을 선택하십시오.
또는 프롬프트가 주어지면 완료 확률을 계산합니다.
오픈 소스 LLM에서 더 많이 짜십시오.

용법

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 참조하십시오.

단계별 완료에서 최종 답변을 추출하십시오

단계별로 생각한 사슬의 프롬프트는 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://capp.readthedocs.io

설치

문서 의이 페이지를 참조하십시오.

관련 작업

문서 의이 페이지를 참조하십시오.

동기 부여

엔지니어링 복잡성을 줄입니다.

자세한 내용은 문서 의이 페이지를 참조하십시오.

성능

통계 성능

계산 성능

작동 방식

prompt 문자열, end_of_prompt 문자열 (공백 또는 비어 있음) 및 문자열과 같은 후보 completion 문자열 세트를 입력합니다. 

{ prompt }{ end_of_prompt }{ completion }

- 자연스럽게 흐르는 생각입니다. CAPPR은 completion 를 선택합니다 prompt

완성
후에
즉각적인
PR 비만

- 십자가에 대한 내 질문에 대체 된대로 검증되었습니다.

지역 개발

문서 의이 페이지를 참조하십시오.

TODO

나는 여기에 Todos를 버리고있다 :

코드 변경

Reseach 실험

C의 문제를 자유롭게 제기하십시오

확장하다
추가 정보
관련 애플리케이션
추천
관련 정보 전체