|
|
import os |
|
|
|
|
|
from transformers import DataCollatorForSeq2Seq,LogitsProcessor,LogitsProcessorList, AutoModelForCausalLM |
|
|
import torch |
|
|
|
|
|
from tree.asts import ASC,Node |
|
|
|
|
|
class OutputControlLogitsProcessor(LogitsProcessor): |
|
|
def __init__(self, tokenizer,ast): |
|
|
self.tokenizer = tokenizer |
|
|
self.ast = ast |
|
|
self.trigger = tokenizer.encode('<e>')[-3:] |
|
|
|
|
|
def _get_valid_token_ids(self): |
|
|
valid_tokens = self.ast.return_next_token() |
|
|
valid_ids = [] |
|
|
|
|
|
if len(valid_tokens) == 0: |
|
|
return list(range(len(self.tokenizer.get_vocab()))) |
|
|
|
|
|
for token in valid_tokens: |
|
|
token_id = self.tokenizer.convert_tokens_to_ids(token) |
|
|
if token_id != self.tokenizer.unk_token_id: |
|
|
valid_ids.append(token_id) |
|
|
|
|
|
return valid_ids |
|
|
|
|
|
def __call__(self, input_ids, scores): |
|
|
if input_ids[0,-3:].tolist() != self.trigger: |
|
|
return scores |
|
|
|
|
|
last_token = input_ids[0, -1].item() |
|
|
last_token = self.tokenizer.decode([last_token], skip_special_tokens=False) |
|
|
|
|
|
self.ast.update_state(last_token) |
|
|
current_ids = self._get_valid_token_ids() |
|
|
|
|
|
mask = torch.full_like(scores, -float(1e10)) |
|
|
for ids in current_ids: |
|
|
mask[:, ids] = 0 |
|
|
|
|
|
filtered_scores = scores + mask |
|
|
|
|
|
return filtered_scores |
|
|
|
|
|
class RewardControlLogitsProcessor(LogitsProcessor): |
|
|
def __init__(self, tokenizer, open_tag='<v>',close_tag='</v>',lower=0,upper=100): |
|
|
self.tokenizer = tokenizer |
|
|
|
|
|
open_tag = tokenizer.encode(open_tag, add_special_tokens=False) |
|
|
close_tag = tokenizer.encode(close_tag, add_special_tokens=False) |
|
|
number_tokens = [tokenizer.encode(str(i), add_special_tokens=False) for i in ['接受','拒绝']] |
|
|
|
|
|
self.tag_tokens = {"open_tag": open_tag,"close_tag": close_tag,"label": number_tokens} |
|
|
self.get_tag_chain() |
|
|
|
|
|
def get_tag_chain(self): |
|
|
asc = ASC() |
|
|
current_node = asc.root |
|
|
for i,t in enumerate(self.tag_tokens['open_tag']): |
|
|
node = Node(t) |
|
|
current_node.children[t] = node |
|
|
current_node = node |
|
|
end_node = None |
|
|
end = '</v>' |
|
|
for i,t in enumerate(self.tag_tokens['close_tag']): |
|
|
if i == 0: |
|
|
end_node = Node(t) |
|
|
_end_node = end_node |
|
|
end = t |
|
|
else: |
|
|
node = Node(t) |
|
|
_end_node.children[t] = node |
|
|
_end_node = node |
|
|
if i == len(self.tag_tokens['close_tag']) - 1: |
|
|
node = Node('') |
|
|
node.end = True |
|
|
_end_node.children[t] = node |
|
|
|
|
|
for t in self.tag_tokens['label']: |
|
|
for c in t: |
|
|
node = Node(c) |
|
|
current_node.children[c] = node |
|
|
current_node = node |
|
|
current_node.children[end] = end_node |
|
|
|
|
|
self.asc = asc |
|
|
|
|
|
def __call__(self, input_ids, scores): |
|
|
if self.asc.current_node.end: |
|
|
return scores |
|
|
|
|
|
last_token = input_ids[0, -1].item() |
|
|
self.asc.update_state(last_token) |
|
|
|
|
|
mask = torch.full_like(scores, -float(1e8)) |
|
|
for ids in [list(self.asc.current_node.children.keys())]: |
|
|
mask[:, ids] = 0 |
|
|
filtered_scores = scores + mask |
|
|
|
|
|
return filtered_scores |
|
|
|
|
|
if __name__ == '__main__': |
|
|
from transformers import AutoTokenizer, AutoModelForCausalLM |
|
|
from tree.asts import AST |
|
|
|
|
|
|
|
|
model_name = '' |
|
|
tokenizer = AutoTokenizer.from_pretrained(model_name) |
|
|
model = AutoModelForCausalLM.from_pretrained(model_name) |
|
|
|
|
|
|
|
|
syntax_tree = AST('./codekey_proofread.txt') |
|
|
|
|
|
|
|
|
logits_processor = OutputControlLogitsProcessor(syntax_tree, tokenizer) |
|
|
|
|
|
input_text = "eqwmdsadas乱码" |
|
|
input_ids = tokenizer.encode(input_text, return_tensors="pt") |
|
|
|
|
|
output = model.generate( |
|
|
input_ids, |
|
|
max_length=50, |
|
|
do_sample=True, |
|
|
num_return_sequences=1, |
|
|
logits_processor=[logits_processor], |
|
|
pad_token_id=tokenizer.eos_token_id |
|
|
) |
|
|
|
|
|
|
|
|
decoded_output = tokenizer.decode(output[0], skip_special_tokens=False) |
|
|
print(decoded_output) |
|
|
|
