# Công cụ cho việc tạo Trang này liệt kê tất cả các hàm tiện ích được sử dụng bởi [generate()](/docs/transformers/main/vi/main_classes/text_generation#transformers.GenerationMixin.generate). ## Tạo đầu ra[[transformers.generation.GenerateDecoderOnlyOutput]] Đầu ra của [generate()](/docs/transformers/main/vi/main_classes/text_generation#transformers.GenerationMixin.generate) là một instance của một subclass của [ModelOutput](/docs/transformers/main/vi/main_classes/output#transformers.utils.ModelOutput). Đầu ra này là một cấu trúc dữ liệu chứa tất cả thông tin được trả về bởi [generate()](/docs/transformers/main/vi/main_classes/text_generation#transformers.GenerationMixin.generate), nhưng cũng có thể được sử dụng như tuple hoặc dictionary. Dưới đây là một ví dụ: ```python from transformers import GPT2Tokenizer, GPT2LMHeadModel tokenizer = GPT2Tokenizer.from_pretrained("openai-community/gpt2") model = GPT2LMHeadModel.from_pretrained("openai-community/gpt2") inputs = tokenizer("Hello, my dog is cute and ", return_tensors="pt") generation_output = model.generate(**inputs, return_dict_in_generate=True, output_scores=True) ``` Đối tượng `generation_output` là một [GenerateDecoderOnlyOutput](/docs/transformers/main/vi/internal/generation_utils#transformers.generation.GenerateDecoderOnlyOutput), như chúng ta có thể thấy trong tài liệu của lớp đó bên dưới, điều này có nghĩa là nó có các thuộc tính sau: - `sequences`: các chuỗi token được tạo ra - `scores` (tùy chọn): điểm dự đoán của đầu mô hình ngôn ngữ, cho mỗi bước sinh - `hidden_states` (tùy chọn): các trạng thái ẩn của mô hình, cho mỗi bước sinh - `attentions` (tùy chọn): trọng số chú ý của mô hình, cho mỗi bước sinh Ở đây chúng ta có `scores` vì đã truyền `output_scores=True`, nhưng không có `hidden_states` và `attentions` vì không truyền `output_hidden_states=True` hoặc `output_attentions=True`. Bạn có thể truy cập từng thuộc tính như bình thường, và nếu thuộc tính đó không được mô hình trả về, bạn sẽ nhận được `None`. Ví dụ, `generation_output.scores` là tất cả các điểm dự đoán đã được tạo ra bởi đầu mô hình ngôn ngữ, còn `generation_output.attentions` là `None`. Khi sử dụng đối tượng `generation_output` của chúng ta dưới dạng tuple, nó chỉ giữ lại các thuộc tính không có giá trị `None`. Ở đây, ví dụ, nó có hai phần tử, `loss` rồi đến `logits`, vì vậy ```python generation_output[:2] ``` sẽ trả về bộ ba `(generation_output.sequences, generation_output.scores)`, chẳng hạn. Khi sử dụng đối tượng `generation_output` của chúng ta như một từ điển, nó chỉ giữ lại các thuộc tính không có giá trị `None`. Ở đây, ví dụ, nó có hai khóa là `sequences` và `scores`. Chúng tôi liệt kê tại đây tất cả các kiểu đầu ra. #### transformers.generation.GenerateDecoderOnlyOutput[[transformers.generation.GenerateDecoderOnlyOutput]] ```python transformers.generation.GenerateDecoderOnlyOutput(sequences: LongTensor, scores: tuple[torch.Tensor] | None = None, logits: tuple[torch.Tensor] | None = None, attentions: tuple[tuple[torch.Tensor]] | None = None, hidden_states: tuple[tuple[torch.Tensor]] | None = None, past_key_values: transformers.cache_utils.Cache | None = None) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/utils.py#L183) **Tham số:** sequences (`torch.LongTensor` có hình dạng `(batch_size, sequence_length)`) : Các chuỗi được tạo ra. Chiều thứ hai (sequence_length) bằng `max_length` hoặc ngắn hơn nếu tất cả các batch kết thúc sớm do `eos_token_id`. scores (`tuple(torch.Tensor)` *tùy chọn*, được trả về khi `output_scores=True`) : Điểm dự đoán đã xử lý của đầu mô hình ngôn ngữ (điểm cho mỗi token trong từ vựng trước SoftMax) ở mỗi bước sinh. Tuple của `torch.Tensor` với tối đa `max_new_tokens` phần tử (một phần tử cho mỗi token được sinh), mỗi tensor có hình dạng `(batch_size, config.vocab_size)`. logits (`tuple(torch.Tensor)` *tùy chọn*, được trả về khi `output_logits=True`) : Điểm dự đoán chưa được xử lý của đầu mô hình ngôn ngữ (điểm cho mỗi token trong từ vựng trước SoftMax) ở mỗi bước sinh. Tuple của `torch.Tensor` với tối đa `max_new_tokens` phần tử (một phần tử cho mỗi token được sinh), mỗi tensor có hình dạng `(batch_size, config.vocab_size)`. attentions (`tuple(tuple(torch.Tensor))`, *tùy chọn*, được trả về khi `output_attentions=True`) : Tuple (một phần tử cho mỗi token được tạo ra) của các tuple (một phần tử cho mỗi lớp của bộ giải mã) của `torch.Tensor` có hình dạng `(batch_size, num_heads, generated_length, sequence_length)`. hidden_states (`tuple(tuple(torch.Tensor))`, *tùy chọn*, được trả về khi `output_hidden_states=True`) : Tuple (một phần tử cho mỗi token được tạo ra) của các tuple (một phần tử cho mỗi lớp của bộ giải mã) của `torch.Tensor` có hình dạng `(batch_size, generated_length, hidden_size)`. past_key_values (`Cache`, *tuỳ chọn*, được trả về khi `use_cache=True`) : Trả về bộ nhớ đệm của mô hình, được sử dụng để tăng tốc quá trình giải mã. Các mô hình khác nhau có định dạng bộ nhớ đệm khác nhau, hãy xem tài liệu của mô hình. Thông thường, đây là một instance của [Cache](/docs/transformers/main/vi/internal/generation_utils#transformers.Cache). Đầu ra của các mô hình sinh chỉ có bộ giải mã, khi sử dụng các phương pháp không phải beam. #### transformers.generation.GenerateEncoderDecoderOutput[[transformers.generation.GenerateEncoderDecoderOutput]] ```python transformers.generation.GenerateEncoderDecoderOutput(sequences: LongTensor, scores: tuple[torch.Tensor] | None = None, logits: tuple[torch.Tensor] | None = None, encoder_attentions: tuple[torch.Tensor] | None = None, encoder_hidden_states: tuple[torch.Tensor] | None = None, decoder_attentions: tuple[tuple[torch.Tensor]] | None = None, cross_attentions: tuple[tuple[torch.Tensor]] | None = None, decoder_hidden_states: tuple[tuple[torch.Tensor]] | None = None, past_key_values: transformers.cache_utils.Cache | None = None) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/utils.py#L219) **Tham số:** sequences (`torch.LongTensor` có hình dạng `(batch_size*num_return_sequences, sequence_length)`) : Các chuỗi được tạo ra. Chiều thứ hai (sequence_length) bằng `max_length` hoặc ngắn hơn nếu tất cả các batch kết thúc sớm do `eos_token_id`. scores (`tuple(torch.Tensor)` *tùy chọn*, được trả về khi `output_scores=True`) : Điểm dự đoán đã xử lý của đầu mô hình ngôn ngữ (điểm cho mỗi token trong từ vựng trước SoftMax) ở mỗi bước sinh. Tuple của `torch.Tensor` với tối đa `max_new_tokens` phần tử (một phần tử cho mỗi token được sinh), mỗi tensor có hình dạng `(batch_size, config.vocab_size)`. logits (`tuple(torch.Tensor)` *tùy chọn*, được trả về khi `output_logits=True`) : Điểm dự đoán chưa được xử lý của đầu mô hình ngôn ngữ (điểm cho mỗi token trong từ vựng trước SoftMax) ở mỗi bước sinh. Tuple của `torch.Tensor` với tối đa `max_new_tokens` phần tử (một phần tử cho mỗi token được sinh), mỗi tensor có hình dạng `(batch_size, config.vocab_size)`. encoder_attentions (`tuple(torch.Tensor)`, *tùy chọn*, được trả về khi `output_attentions=True`) : Bộ tuple của `torch.Tensor` (một cho mỗi lớp của bộ giải mã) có hình dạng `(batch_size, num_heads, sequence_length, sequence_length)`. encoder_hidden_states (`tuple(torch.Tensor)`, *tùy chọn*, được trả về khi `output_hidden_states=True`) : Bộ tuple của `torch.Tensor` (một cho đầu ra của embeddings + một cho đầu ra của mỗi lớp) có hình dạng `(batch_size, sequence_length, hidden_size)`. decoder_attentions (`tuple(tuple(torch.Tensor))`, *tùy chọn*, được trả về khi `output_attentions=True`) : Tuple (một phần tử cho mỗi token được tạo ra) của các tuple (một phần tử cho mỗi lớp của bộ giải mã) của `torch.Tensor` có hình dạng `(batch_size, num_heads, generated_length, sequence_length)`. cross_attentions (`tuple(tuple(torch.Tensor))`, *tùy chọn*, được trả về khi `output_attentions=True`) : Tuple (một phần tử cho mỗi token được tạo ra) của các tuple (một phần tử cho mỗi lớp của bộ giải mã) của `torch.Tensor` có hình dạng `(batch_size, num_heads, generated_length, sequence_length)`. decoder_hidden_states (`tuple(tuple(torch.Tensor))`, *tùy chọn*, được trả về khi `output_hidden_states=True`) : Tuple (một phần tử cho mỗi token được tạo ra) của các tuple (một phần tử cho mỗi lớp của bộ giải mã) của `torch.Tensor` có hình dạng `(batch_size, generated_length, hidden_size)`. past_key_values (`Cache`, *tuỳ chọn*, được trả về khi `use_cache=True`) : Trả về bộ nhớ đệm của mô hình, được sử dụng để tăng tốc quá trình giải mã. Các mô hình khác nhau có định dạng bộ nhớ đệm khác nhau, hãy xem tài liệu của mô hình. Thông thường, đây là một instance của [Cache](/docs/transformers/main/vi/internal/generation_utils#transformers.Cache). Đầu ra của các mô hình sinh mã hóa - giải mã, khi sử dụng các phương pháp không phải beam. #### transformers.generation.GenerateBeamDecoderOnlyOutput[[transformers.generation.GenerateBeamDecoderOnlyOutput]] ```python transformers.generation.GenerateBeamDecoderOnlyOutput(sequences: LongTensor, sequences_scores: typing.Optional[torch.Tensor] = None, scores: tuple[torch.Tensor] | None = None, logits: tuple[torch.Tensor] | None = None, beam_indices: typing.Optional[torch.LongTensor] = None, attentions: tuple[tuple[torch.Tensor]] | None = None, hidden_states: tuple[tuple[torch.Tensor]] | None = None, past_key_values: transformers.cache_utils.Cache | None = None) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/utils.py#L267) **Tham số:** sequences (`torch.LongTensor` có hình dạng `(batch_size*num_return_sequences, sequence_length)`) : Các chuỗi được tạo ra. Chiều thứ hai (sequence_length) bằng `max_length` hoặc ngắn hơn nếu tất cả các batch kết thúc sớm do `eos_token_id`. sequences_scores (`torch.Tensor` có shape `(batch_size*num_return_sequences)`, *tùy chọn*, được trả về khi `output_scores=True`) : Điểm beam cuối cùng của các `sequences` được tạo ra. scores (`tuple(torch.Tensor)` *tùy chọn*, được trả về khi `output_scores=True`) : Điểm chuyển tiếp beam cho từng token từ vựng ở mỗi bước sinh. Điểm chuyển tiếp beam bao gồm các xác suất log của các token có điều kiện dựa trên log softmax của các token đã sinh trước đó trong beam này. Tuple của `torch.Tensor` với tối đa `max_new_tokens` phần tử (một phần tử cho mỗi token đã sinh), với mỗi tensor có hình dạng `(batch_size*num_beams, config.vocab_size)`. logits (`tuple(torch.Tensor)` *tùy chọn*, được trả về khi `output_logits=True`) : Điểm dự đoán chưa được xử lý của đầu mô hình ngôn ngữ (điểm cho mỗi token trong từ vựng trước SoftMax) ở mỗi bước sinh. Tuple của `torch.Tensor` với tối đa `max_new_tokens` phần tử (một phần tử cho mỗi token được sinh), mỗi tensor có hình dạng `(batch_size*num_beams, config.vocab_size)`. beam_indices (`torch.LongTensor`, *tùy chọn*, được trả về khi `output_scores=True`) : Chỉ số beam của id token được tạo ra ở mỗi bước sinh. `torch.LongTensor` có hình dạng `(batch_size*num_return_sequences, sequence_length)`. attentions (`tuple(tuple(torch.Tensor))`, *tùy chọn*, được trả về khi `output_attentions=True`) : Tuple (một phần tử cho mỗi token được tạo ra) của các tuple (một phần tử cho mỗi lớp của bộ giải mã) của `torch.Tensor` có hình dạng `(batch_size*num_beams, num_heads, generated_length, sequence_length)`. hidden_states (`tuple(tuple(torch.Tensor))`, *tùy chọn*, được trả về khi `output_hidden_states=True`) : Tuple (một phần tử cho mỗi token được tạo) của các tuple (một phần tử cho mỗi lớp của bộ giải mã) của `torch.Tensor` có hình dạng `(batch_size*num_beams*num_return_sequences, generated_length, hidden_size)`. past_key_values (`Cache`, *tuỳ chọn*, được trả về khi `use_cache=True`) : Trả về bộ nhớ đệm của mô hình, được sử dụng để tăng tốc quá trình giải mã. Các mô hình khác nhau có định dạng bộ nhớ đệm khác nhau, hãy xem tài liệu của mô hình. Thông thường, đây là một instance của [Cache](/docs/transformers/main/vi/internal/generation_utils#transformers.Cache). Đầu ra của các mô hình sinh chỉ có bộ giải mã, khi sử dụng các phương pháp chùm. #### transformers.generation.GenerateBeamEncoderDecoderOutput[[transformers.generation.GenerateBeamEncoderDecoderOutput]] ```python transformers.generation.GenerateBeamEncoderDecoderOutput(sequences: LongTensor, sequences_scores: typing.Optional[torch.Tensor] = None, scores: tuple[torch.Tensor] | None = None, logits: tuple[torch.Tensor] | None = None, beam_indices: typing.Optional[torch.LongTensor] = None, encoder_attentions: tuple[torch.Tensor] | None = None, encoder_hidden_states: tuple[torch.Tensor] | None = None, decoder_attentions: tuple[tuple[torch.Tensor]] | None = None, cross_attentions: tuple[tuple[torch.Tensor]] | None = None, decoder_hidden_states: tuple[tuple[torch.Tensor]] | None = None, past_key_values: transformers.cache_utils.Cache | None = None) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/utils.py#L311) **Tham số:** sequences (`torch.LongTensor` có hình dạng `(batch_size*num_return_sequences, sequence_length)`) : Các chuỗi được tạo ra. Chiều thứ hai (sequence_length) bằng `max_length` hoặc ngắn hơn nếu tất cả các batch kết thúc sớm do `eos_token_id`. sequences_scores (`torch.Tensor` có shape `(batch_size*num_return_sequences)`, *tùy chọn*, được trả về khi `output_scores=True`) : Điểm beam cuối cùng của các `sequences` được tạo ra. scores (`tuple(torch.Tensor)` *tùy chọn*, được trả về khi `output_scores=True`) : Điểm chuyển tiếp beam cho từng token từ vựng ở mỗi bước sinh. Điểm chuyển tiếp beam bao gồm các xác suất log của các token có điều kiện dựa trên log softmax của các token đã sinh trước đó trong beam này. Tuple của `torch.Tensor` với tối đa `max_new_tokens` phần tử (một phần tử cho mỗi token đã sinh), với mỗi tensor có hình dạng `(batch_size*num_beams, config.vocab_size)`. logits (`tuple(torch.Tensor)` *tùy chọn*, được trả về khi `output_logits=True`) : Điểm dự đoán chưa được xử lý của đầu mô hình ngôn ngữ (điểm cho mỗi token trong từ vựng trước SoftMax) ở mỗi bước sinh. Tuple của `torch.Tensor` với tối đa `max_new_tokens` phần tử (một phần tử cho mỗi token được sinh), mỗi tensor có hình dạng `(batch_size*num_beams, config.vocab_size)`. beam_indices (`torch.LongTensor`, *tùy chọn*, được trả về khi `output_scores=True`) : Chỉ số beam của id token được tạo ra ở mỗi bước sinh. `torch.LongTensor` có hình dạng `(batch_size*num_return_sequences, sequence_length)`. encoder_attentions (`tuple(torch.Tensor)`, *tùy chọn*, được trả về khi `output_attentions=True`) : Bộ tuple của `torch.Tensor` (một cho mỗi lớp của bộ giải mã) có hình dạng `(batch_size, num_heads, sequence_length, sequence_length)`. encoder_hidden_states (`tuple(torch.Tensor)`, *tùy chọn*, được trả về khi `output_hidden_states=True`) : Bộ tuple của `torch.Tensor` (một cho đầu ra của embeddings + một cho đầu ra của mỗi lớp) có hình dạng `(batch_size*num_beams*num_return_sequences, sequence_length, hidden_size)`. decoder_attentions (`tuple(tuple(torch.Tensor))`, *tùy chọn*, được trả về khi `output_attentions=True`) : Tuple (một phần tử cho mỗi token được tạo) của các tuple (một phần tử cho mỗi lớp của bộ giải mã) của `torch.Tensor` có hình dạng `(batch_size*num_beams*num_return_sequences, num_heads, generated_length, sequence_length)`. cross_attentions (`tuple(tuple(torch.Tensor))`, *tùy chọn*, được trả về khi `output_attentions=True`) : Tuple (một phần tử cho mỗi token được tạo ra) của các tuple (một phần tử cho mỗi lớp của bộ giải mã) của `torch.Tensor` có hình dạng `(batch_size, num_heads, generated_length, sequence_length)`. decoder_hidden_states (`tuple(tuple(torch.Tensor))`, *tùy chọn*, được trả về khi `output_hidden_states=True`) : Tuple (một phần tử cho mỗi token được tạo) của các tuple (một phần tử cho mỗi lớp của bộ giải mã) của `torch.Tensor` có hình dạng `(batch_size*num_beams*num_return_sequences, generated_length, hidden_size)`. past_key_values (`Cache`, *tuỳ chọn*, được trả về khi `use_cache=True`) : Trả về bộ nhớ đệm của mô hình, được sử dụng để tăng tốc quá trình giải mã. Các mô hình khác nhau có định dạng bộ nhớ đệm khác nhau, hãy xem tài liệu của mô hình. Thông thường, đây là một instance của [Cache](/docs/transformers/main/vi/internal/generation_utils#transformers.Cache). Đầu ra của các mô hình sinh mã hóa - giải mã, khi sử dụng các phương pháp chùm. ## LogitsProcessor[[transformers.AlternatingCodebooksLogitsProcessor]] Một [LogitsProcessor](/docs/transformers/main/vi/internal/generation_utils#transformers.LogitsProcessor) có thể được sử dụng để sửa đổi điểm dự đoán của đầu mô hình ngôn ngữ cho quá trình sinh. #### transformers.AlternatingCodebooksLogitsProcessor[[transformers.AlternatingCodebooksLogitsProcessor]] ```python transformers.AlternatingCodebooksLogitsProcessor(input_start_len: int, semantic_vocab_size: int, codebook_size: int) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L2222) **Tham số:** input_start_len (`int`) : Độ dài của chuỗi đầu vào ban đầu. semantic_vocab_size (`int`) : Kích thước bảng từ vựng của phần ngữ nghĩa, tức là số lượng token liên quan đến bảng từ vựng ngữ nghĩa. codebook_size (`int`) : Số lượng token liên quan đến codebook. [LogitsProcessor](/docs/transformers/main/vi/internal/generation_utils#transformers.LogitsProcessor) thực thi việc tạo xen kẽ giữa hai codebook của Bark. Logits processor này chỉ tương thích với submodel fine của [Bark](https://huggingface.co/docs/transformers/en/model_doc/bark). Xem tài liệu mô hình để biết các ví dụ. #### __call__[[transformers.AlternatingCodebooksLogitsProcessor.__call__]] ```python __call__(input_ids: LongTensor, scores: Tensor) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L2251) #### transformers.ClassifierFreeGuidanceLogitsProcessor[[transformers.ClassifierFreeGuidanceLogitsProcessor]] ```python transformers.ClassifierFreeGuidanceLogitsProcessor(guidance_scale) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L2158) **Tham số:** guidance_scale (float) : Thang độ dẫn hướng cho classifier free guidance (CFG). CFG được kích hoạt bằng cách đặt `guidance_scale > 1`. Thang độ dẫn hướng cao hơn khuyến khích mô hình tạo ra các mẫu gắn kết chặt chẽ hơn với prompt đầu vào, thường phải đánh đổi bằng chất lượng kém hơn. [LogitsProcessor](/docs/transformers/main/vi/internal/generation_utils#transformers.LogitsProcessor) cho classifier free guidance (CFG). Các điểm số được chia theo chiều batch, trong đó nửa đầu tương ứng với logits có điều kiện (dự đoán từ prompt đầu vào) và nửa sau tương ứng với logits không điều kiện (dự đoán từ prompt rỗng hoặc 'null'). Bộ xử lý tính trung bình có trọng số giữa logits có điều kiện và không điều kiện, được tham số hóa bởi `guidance_scale`. Xem [bài báo](https://huggingface.co/papers/2306.05284) để biết thêm thông tin. Logits processor này chỉ tương thích với [MusicGen](https://huggingface.co/docs/transformers/main/en/model_doc/musicgen) Ví dụ: ```python >>> from transformers import AutoProcessor, MusicgenForConditionalGeneration >>> processor = AutoProcessor.from_pretrained("facebook/musicgen-small") >>> model = MusicgenForConditionalGeneration.from_pretrained("facebook/musicgen-small") >>> inputs = processor( ... text=["80s pop track with bassy drums and synth", "90s rock song with loud guitars and heavy drums"], ... padding=True, ... return_tensors="pt", ... ) >>> audio_values = model.generate(**inputs, do_sample=True, guidance_scale=3, max_new_tokens=256) ``` #### __call__[[transformers.ClassifierFreeGuidanceLogitsProcessor.__call__]] ```python __call__(input_ids: LongTensor, scores: Tensor) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L2206) **Tham số:** input_ids (`torch.LongTensor` có hình dạng `(batch_size, sequence_length)`) : Chỉ số của các token trong chuỗi đầu vào theo từ vựng. [Input IDs là gì?](../glossary#input-ids) scores (`torch.Tensor` có hình dạng `(batch_size, config.vocab_size)`) : Điểm dự đoán của đầu mô hình hóa ngôn ngữ. Đây có thể là logits cho từng từ vựng khi không sử dụng beam search hoặc log softmax cho từng token từ vựng khi sử dụng beam search **Trả về:** `torch.Tensor` có hình dạng `(batch_size, config.vocab_size)` Điểm dự đoán đã được xử lý. #### transformers.EncoderNoRepeatNGramLogitsProcessor[[transformers.EncoderNoRepeatNGramLogitsProcessor]] ```python transformers.EncoderNoRepeatNGramLogitsProcessor(encoder_ngram_size: int, encoder_input_ids: LongTensor) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L1173) **Tham số:** encoder_ngram_size (`int`) : Tất cả các ngram có kích thước `ngram_size` chỉ có thể xuất hiện trong các id đầu vào của encoder. encoder_input_ids (`int`) : Các encoder_input_ids không được lặp lại trong các id của decoder. [LogitsProcessor](/docs/transformers/main/vi/internal/generation_utils#transformers.LogitsProcessor) hoạt động tương tự như [NoRepeatNGramLogitsProcessor](/docs/transformers/main/vi/internal/generation_utils#transformers.NoRepeatNGramLogitsProcessor), nhưng chỉ được áp dụng để ngăn chặn sự lặp lại của các n-gram có sẵn trong prompt. Nó được thiết kế để thúc đẩy tính trò chuyện trong một mô hình ngôn ngữ, bằng cách ngăn chặn việc tạo ra các n-gram có mặt trong các vòng hội thoại trước đó. Ví dụ: ```py >>> from transformers import AutoTokenizer, AutoModelForCausalLM >>> model = AutoModelForCausalLM.from_pretrained("bigscience/bloomz-560m") >>> tokenizer = AutoTokenizer.from_pretrained("bigscience/bloomz-560m") >>> inputs = tokenizer("Alice: I love cats. What do you love?\nBob:", return_tensors="pt") >>> # With greedy decoding, we see Bob repeating Alice's opinion. If Bob was a chatbot, it would be a poor one. >>> outputs = model.generate(**inputs) >>> print(tokenizer.batch_decode(outputs, skip_special_tokens=True)[0]) Alice: I love cats. What do you love? Bob: I love cats. What do you >>> # With this logits processor, we can prevent Bob from repeating Alice's opinion. >>> outputs = model.generate(**inputs, encoder_no_repeat_ngram_size=2) >>> print(tokenizer.batch_decode(outputs, skip_special_tokens=True)[0]) Alice: I love cats. What do you love? Bob: My cats are very cute. ``` #### __call__[[transformers.EncoderNoRepeatNGramLogitsProcessor.__call__]] ```python __call__(input_ids: LongTensor, scores: Tensor) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L1222) **Tham số:** input_ids (`torch.LongTensor` có hình dạng `(batch_size, sequence_length)`) : Chỉ số của các token trong chuỗi đầu vào theo từ vựng. [Input IDs là gì?](../glossary#input-ids) scores (`torch.Tensor` có hình dạng `(batch_size, config.vocab_size)`) : Điểm dự đoán của đầu mô hình hóa ngôn ngữ. Đây có thể là logits cho từng từ vựng khi không sử dụng beam search hoặc log softmax cho từng token từ vựng khi sử dụng beam search **Trả về:** `torch.Tensor` có hình dạng `(batch_size, config.vocab_size)` Điểm dự đoán đã được xử lý. #### transformers.EncoderRepetitionPenaltyLogitsProcessor[[transformers.EncoderRepetitionPenaltyLogitsProcessor]] ```python transformers.EncoderRepetitionPenaltyLogitsProcessor(penalty: float, encoder_input_ids: LongTensor) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L440) **Tham số:** penalty (`float`) : Tham số cho hình phạt lặp lại. 1.0 nghĩa là không có hình phạt. Lớn hơn 1.0 sẽ thưởng cho các token của prompt. Nằm giữa 0.0 và 1.0 sẽ phạt các token của prompt. encoder_input_ids (`torch.LongTensor`) : encoder_input_ids cần được lặp lại trong các id của decoder. [LogitsProcessor](/docs/transformers/main/vi/internal/generation_utils#transformers.LogitsProcessor) hoạt động tương tự như [RepetitionPenaltyLogitsProcessor](/docs/transformers/main/vi/internal/generation_utils#transformers.RepetitionPenaltyLogitsProcessor), nhưng áp dụng một hình phạt *ngược* lên các token có mặt trong prompt. Nói cách khác, một hình phạt lớn hơn 1.0 sẽ tăng khả năng chọn các token đã xuất hiện trong prompt. Nó được thiết kế để tránh hiện tượng ảo giác trong các tác vụ dựa trên đầu vào, chẳng hạn như tóm tắt. Mặc dù ban đầu được dành cho các mô hình encoder-decoder, nó cũng có thể được sử dụng với các mô hình chỉ có decoder như LLM. Ví dụ: ```python >>> from transformers import AutoModelForCausalLM, AutoTokenizer >>> tokenizer = AutoTokenizer.from_pretrained("bigscience/bloomz-560m") >>> model = AutoModelForCausalLM.from_pretrained("bigscience/bloomz-560m") >>> inputs = tokenizer(["Alice and Bob. The third member's name was"], return_tensors="pt") >>> gen_out = model.generate(**inputs) >>> print(tokenizer.batch_decode(gen_out, skip_special_tokens=True)[0]) Alice and Bob. The third member's name was not mentioned. >>> # With the `encoder_repetition_penalty` argument we can trigger this logits processor in `generate`, which can >>> # promote the use of prompt tokens ("Bob" in this example) >>> gen_out = model.generate(**inputs, encoder_repetition_penalty=1.2) >>> print(tokenizer.batch_decode(gen_out, skip_special_tokens=True)[0]) Alice and Bob. The third member's name was Bob. The third member's name was Bob. ``` #### __call__[[transformers.EncoderRepetitionPenaltyLogitsProcessor.__call__]] ```python __call__(input_ids: LongTensor, scores: Tensor) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L486) **Tham số:** input_ids (`torch.LongTensor` có hình dạng `(batch_size, sequence_length)`) : Chỉ số của các token trong chuỗi đầu vào theo từ vựng. [Input IDs là gì?](../glossary#input-ids) scores (`torch.Tensor` có hình dạng `(batch_size, config.vocab_size)`) : Điểm dự đoán của đầu mô hình hóa ngôn ngữ. Đây có thể là logits cho từng từ vựng khi không sử dụng beam search hoặc log softmax cho từng token từ vựng khi sử dụng beam search **Trả về:** `torch.Tensor` có hình dạng `(batch_size, config.vocab_size)` Điểm dự đoán đã được xử lý. #### transformers.EpsilonLogitsWarper[[transformers.EpsilonLogitsWarper]] ```python transformers.EpsilonLogitsWarper(epsilon: float, filter_value: float = -inf, min_tokens_to_keep: int = 1) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L897) **Tham số:** epsilon (`float`) : Nếu được đặt thành > 0, chỉ các token có xác suất cao hơn hoặc bằng `epsilon` mới được giữ lại cho quá trình sinh. filter_value (`float`, *tuỳ chọn*, mặc định là -inf) : Tất cả các giá trị đã lọc sẽ được đặt thành giá trị float này. min_tokens_to_keep (`int`, *tuỳ chọn*, mặc định là 1) : Số lượng token tối thiểu không thể bị lọc. [LogitsProcessor](/docs/transformers/main/vi/internal/generation_utils#transformers.LogitsProcessor) thực hiện epsilon-sampling, tức là giới hạn trong các token có `prob >= epsilon`. Nếu không có token nào thỏa mãn ràng buộc này, sẽ lấy min_tokens_to_keep token lớn nhất. Xem [Truncation Sampling as Language Model Desmoothing](https://huggingface.co/papers/2210.15191) để biết thêm thông tin. Ví dụ: ```python >>> from transformers import AutoTokenizer, AutoModelForCausalLM, set_seed >>> set_seed(1) >>> model = AutoModelForCausalLM.from_pretrained("distilbert/distilgpt2") >>> tokenizer = AutoTokenizer.from_pretrained("distilbert/distilgpt2") >>> inputs = tokenizer("A sequence: 1, 2", return_tensors="pt") >>> # With sampling, the output is unexpected -- sometimes too unexpected. >>> outputs = model.generate(**inputs, do_sample=True) >>> print(tokenizer.batch_decode(outputs, skip_special_tokens=True)[0]) A sequence: 1, 2, 3 | < 4 (left-hand pointer) ; >>> # With epsilon sampling, the output gets restricted to high-probability tokens. Note that this is similar to >>> # Top P sampling, which restricts tokens based on their cumulative probability. >>> # Pro tip: The paper recommends using `epsilon_cutoff` values between 3e-4 and 9e-4 >>> outputs = model.generate(**inputs, do_sample=True, epsilon_cutoff=0.1) >>> print(tokenizer.batch_decode(outputs, skip_special_tokens=True)[0]) A sequence: 1, 2, 3, 4, 5, 6, 7, 8, 9 ``` #### __call__[[transformers.EpsilonLogitsWarper.__call__]] ```python __call__(input_ids: LongTensor, scores: Tensor) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L952) **Tham số:** input_ids (`torch.LongTensor` có hình dạng `(batch_size, sequence_length)`) : Chỉ số của các token trong chuỗi đầu vào theo từ vựng. [Input IDs là gì?](../glossary#input-ids) scores (`torch.Tensor` có hình dạng `(batch_size, config.vocab_size)`) : Điểm dự đoán của đầu mô hình hóa ngôn ngữ. Đây có thể là logits cho từng từ vựng khi không sử dụng beam search hoặc log softmax cho từng token từ vựng khi sử dụng beam search **Trả về:** `torch.Tensor` có hình dạng `(batch_size, config.vocab_size)` Điểm dự đoán đã được xử lý. #### transformers.EtaLogitsWarper[[transformers.EtaLogitsWarper]] ```python transformers.EtaLogitsWarper(epsilon: float, filter_value: float = -inf, min_tokens_to_keep: int = 1, device: str = 'cpu') ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L966) **Tham số:** epsilon (`float`) : Một giá trị float trong khoảng (0, 1). Tham số siêu được sử dụng để tính giá trị cắt động, `eta`. Các giá trị được đề xuất từ bài báo dao động từ 3e-4 đến 4e-3 tùy thuộc vào kích thước của mô hình. filter_value (`float`, *optional*, mặc định là -inf) : Tất cả các giá trị được xác định là thấp hơn giá trị cắt động, `eta`, sẽ được đặt thành giá trị float này. Tham số này hữu ích khi cần sửa đổi logits cho các token có xác suất rất thấp cần được loại trừ hoàn toàn khỏi quá trình sinh. min_tokens_to_keep (`int`, *optional*, mặc định là 1) : Xác định số lượng token tối thiểu phải được giữ lại cho quá trình sinh, bất kể xác suất của chúng. Ví dụ, nếu `min_tokens_to_keep` được đặt thành 1, ít nhất một token sẽ luôn được giữ lại cho quá trình sinh, ngay cả khi tất cả các token đều có xác suất dưới ngưỡng `eta`. device (`str`, *tùy chọn*, mặc định là `"cpu"`) : Thiết bị để cấp phát các tensor. [LogitsProcessor](/docs/transformers/main/vi/internal/generation_utils#transformers.LogitsProcessor) thực hiện eta-sampling, một kỹ thuật để lọc bỏ các token có xác suất thấp hơn một ngưỡng cắt động, `eta`, được tính toán dựa trên sự kết hợp của siêu tham số `epsilon` và entropy của các xác suất token, tức là `eta := min(epsilon, sqrt(epsilon * e^-entropy(probabilities)))`. Nếu không có token nào thỏa mãn ràng buộc này, nó sẽ lấy min_tokens_to_keep token lớn nhất. Nó giải quyết vấn đề chất lượng kém trong các mẫu văn bản dài do các mô hình ngôn ngữ neural tạo ra, dẫn đến văn bản mạch lạc và trôi chảy hơn. Xem [Truncation Sampling as Language Model Desmoothing](https://huggingface.co/papers/2210.15191) để biết thêm thông tin. Lưu ý: `do_sample` phải được đặt thành `True` để `LogitsProcessor` này hoạt động. Ví dụ: ```python >>> from transformers import AutoTokenizer, AutoModelForCausalLM, set_seed >>> set_seed(1) >>> model = AutoModelForCausalLM.from_pretrained("distilbert/distilgpt2") >>> tokenizer = AutoTokenizer.from_pretrained("distilbert/distilgpt2") >>> inputs = tokenizer("A sequence: 1, 2", return_tensors="pt") >>> # With sampling, the output is unexpected -- sometimes too unexpected. >>> outputs = model.generate(**inputs, do_sample=True) >>> print(tokenizer.batch_decode(outputs, skip_special_tokens=True)[0]) A sequence: 1, 2, 3 | < 4 (left-hand pointer) ; >>> # With eta sampling, the output gets restricted to high-probability tokens. You can see it as a dynamic form of >>> # epsilon sampling that adapts its cutoff probability based on the entropy (high entropy = lower cutoff). >>> # Pro tip: The paper recommends using `eta_cutoff` values between 3e-4 to 4e-3 >>> outputs = model.generate(**inputs, do_sample=True, eta_cutoff=0.1) >>> print(tokenizer.batch_decode(outputs, skip_special_tokens=True)[0]) A sequence: 1, 2, 3, 4, 5, 6, 7, 8, 9 ``` #### __call__[[transformers.EtaLogitsWarper.__call__]] ```python __call__(input_ids: LongTensor, scores: Tensor) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L1035) **Tham số:** input_ids (`torch.LongTensor` có hình dạng `(batch_size, sequence_length)`) : Chỉ số của các token trong chuỗi đầu vào theo từ vựng. [Input IDs là gì?](../glossary#input-ids) scores (`torch.Tensor` có hình dạng `(batch_size, config.vocab_size)`) : Điểm dự đoán của đầu mô hình hóa ngôn ngữ. Đây có thể là logits cho từng từ vựng khi không sử dụng beam search hoặc log softmax cho từng token từ vựng khi sử dụng beam search **Trả về:** `torch.Tensor` có hình dạng `(batch_size, config.vocab_size)` Điểm dự đoán đã được xử lý. #### transformers.ExponentialDecayLengthPenalty[[transformers.ExponentialDecayLengthPenalty]] ```python transformers.ExponentialDecayLengthPenalty(exponential_decay_length_penalty: tuple, eos_token_id: typing.Union[int, list[int], torch.Tensor], input_ids_seq_length: int) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L1712) **Tham số:** exponential_decay_length_penalty (`tuple(int, float)`) : Tuple này phải bao gồm: `(start_index, decay_factor)` trong đó `start_index` chỉ định vị trí bắt đầu của hình phạt và `decay_factor` đại diện cho hệ số suy giảm mũ eos_token_id (`Union[int, list[int], torch.Tensor]`) : id của token *end-of-sequence*. input_ids_seq_length (`int`) : Độ dài của chuỗi đầu vào. [LogitsProcessor](/docs/transformers/main/vi/internal/generation_utils#transformers.LogitsProcessor) tăng điểm của `eos_token_id` theo hàm mũ sau khi `start_index` đã được đạt tới. Điều này cho phép tạo ra các chuỗi ngắn hơn mà không cần cắt cứng, cho phép `eos_token` được dự đoán ở một vị trí có ý nghĩa. Ví dụ: ```python >>> from transformers import AutoTokenizer, AutoModelForCausalLM, set_seed >>> model = AutoModelForCausalLM.from_pretrained("openai-community/gpt2") >>> tokenizer = AutoTokenizer.from_pretrained("openai-community/gpt2") >>> text = "Just wanted to let you know, I" >>> inputs = tokenizer(text, return_tensors="pt") >>> # Let's consider that we want short sentences, so we limit `max_length=30`. However, we observe that the answer >>> # tends to end abruptly. >>> set_seed(1) >>> outputs = model.generate(**inputs, do_sample=True, temperature=0.9, max_length=30, pad_token_id=50256) >>> print(tokenizer.batch_decode(outputs)[0]) Just wanted to let you know, I received a link to an ebook, the book How To Start A Social Network which was published in 2010. Although >>> # To promote the appearance of the EOS token at the right time, we add the `exponential_decay_length_penalty = >>> # (start_index, decay_factor)`. Instead of cutting at max_tokens, the output comes to an end before and usually >>> # with more meaning. What happens is that starting from `start_index` the EOS token score will be increased >>> # by `decay_factor` exponentially. However, if you set a high decay factor, you may also end up with abruptly >>> # ending sequences. >>> set_seed(1) >>> outputs = model.generate( ... **inputs, ... do_sample=True, ... temperature=0.9, ... max_length=30, ... pad_token_id=50256, ... exponential_decay_length_penalty=(15, 1.6), ... ) >>> print(tokenizer.batch_decode(outputs)[0]) Just wanted to let you know, I received a link to an ebook, the book How To Start A Social Network which<|endoftext|> >>> # With a small decay factor, you will have a higher chance of getting a meaningful sequence. >>> set_seed(1) >>> outputs = model.generate( ... **inputs, ... do_sample=True, ... temperature=0.9, ... max_length=30, ... pad_token_id=50256, ... exponential_decay_length_penalty=(15, 1.01), ... ) >>> print(tokenizer.batch_decode(outputs)[0]) Just wanted to let you know, I received a link to an ebook, the book How To Start A Social Network which was published in 2010.<|endoftext|> ``` #### __call__[[transformers.ExponentialDecayLengthPenalty.__call__]] ```python __call__(input_ids: LongTensor, scores: Tensor) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L1798) **Tham số:** input_ids (`torch.LongTensor` có hình dạng `(batch_size, sequence_length)`) : Chỉ số của các token trong chuỗi đầu vào theo từ vựng. [Input IDs là gì?](../glossary#input-ids) scores (`torch.Tensor` có hình dạng `(batch_size, config.vocab_size)`) : Điểm dự đoán của đầu mô hình hóa ngôn ngữ. Đây có thể là logits cho từng từ vựng khi không sử dụng beam search hoặc log softmax cho từng token từ vựng khi sử dụng beam search **Trả về:** `torch.Tensor` có hình dạng `(batch_size, config.vocab_size)` Điểm dự đoán đã được xử lý. #### transformers.ForcedBOSTokenLogitsProcessor[[transformers.ForcedBOSTokenLogitsProcessor]] ```python transformers.ForcedBOSTokenLogitsProcessor(bos_token_id: int) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L1590) **Tham số:** bos_token_id (`int`) : id của token cần ép buộc làm token đầu tiên được tạo ra. [LogitsProcessor](/docs/transformers/main/vi/internal/generation_utils#transformers.LogitsProcessor) thực thi việc đặt token được chỉ định làm token đầu tiên được tạo ra. Được sử dụng với các mô hình encoder-decoder. Ví dụ: ```python >>> from transformers import AutoTokenizer, AutoModelForSeq2SeqLM >>> model = AutoModelForSeq2SeqLM.from_pretrained("google/flan-t5-small") >>> tokenizer = AutoTokenizer.from_pretrained("google/flan-t5-small") >>> inputs = tokenizer("Translate from English to German: I love cats.", return_tensors="pt") >>> # By default, it continues generating according to the model's logits >>> outputs = model.generate(**inputs, max_new_tokens=10) >>> print(tokenizer.batch_decode(outputs)[0]) Ich liebe Kitty. >>> # We can use `forced_bos_token_id` to force the start of generation with an encoder-decoder model >>> # (including forcing it to end straight away with an EOS token) >>> outputs = model.generate(**inputs, max_new_tokens=10, forced_bos_token_id=tokenizer.eos_token_id) >>> print(tokenizer.batch_decode(outputs)[0]) ``` #### __call__[[transformers.ForcedBOSTokenLogitsProcessor.__call__]] ```python __call__(input_ids: LongTensor, scores: Tensor) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L1625) **Tham số:** input_ids (`torch.LongTensor` có hình dạng `(batch_size, sequence_length)`) : Chỉ số của các token trong chuỗi đầu vào theo từ vựng. [Input IDs là gì?](../glossary#input-ids) scores (`torch.Tensor` có hình dạng `(batch_size, config.vocab_size)`) : Điểm dự đoán của đầu mô hình hóa ngôn ngữ. Đây có thể là logits cho từng từ vựng khi không sử dụng beam search hoặc log softmax cho từng token từ vựng khi sử dụng beam search **Trả về:** `torch.Tensor` có hình dạng `(batch_size, config.vocab_size)` Điểm dự đoán đã được xử lý. #### transformers.ForcedEOSTokenLogitsProcessor[[transformers.ForcedEOSTokenLogitsProcessor]] ```python transformers.ForcedEOSTokenLogitsProcessor(max_length: int, eos_token_id: typing.Union[int, list[int], torch.Tensor], device: str = 'cpu') ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L1635) **Tham số:** max_length (`int`) : Độ dài tối đa của chuỗi cần được tạo ra. eos_token_id (`Union[int, list[int], torch.Tensor]`) : id của token *end-of-sequence*. device (`str`, *tùy chọn*, mặc định là `"cpu"`) : Thiết bị để cấp phát các tensor. [LogitsProcessor](/docs/transformers/main/vi/internal/generation_utils#transformers.LogitsProcessor) thực thi việc đặt token được chỉ định làm token được tạo cuối cùng khi đạt đến `max_length`. Ví dụ: ```python >>> from transformers import AutoTokenizer, AutoModelForCausalLM >>> model = AutoModelForCausalLM.from_pretrained("distilbert/distilgpt2") >>> tokenizer = AutoTokenizer.from_pretrained("distilbert/distilgpt2") >>> inputs = tokenizer("A sequence: 1, 2, 3", return_tensors="pt") >>> # By default, it continues generating according to the model's logits >>> outputs = model.generate(**inputs, max_new_tokens=10) >>> print(tokenizer.batch_decode(outputs)[0]) A sequence: 1, 2, 3, 4, 5, 6, 7, 8 >>> # `forced_eos_token_id` ensures the generation ends with a EOS token >>> outputs = model.generate(**inputs, max_new_tokens=10, forced_eos_token_id=tokenizer.eos_token_id) >>> print(tokenizer.batch_decode(outputs)[0]) A sequence: 1, 2, 3, 4, 5, 6, 7,<|endoftext|> ``` #### __call__[[transformers.ForcedEOSTokenLogitsProcessor.__call__]] ```python __call__(input_ids: LongTensor, scores: Tensor) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L1681) **Tham số:** input_ids (`torch.LongTensor` có hình dạng `(batch_size, sequence_length)`) : Chỉ số của các token trong chuỗi đầu vào theo từ vựng. [Input IDs là gì?](../glossary#input-ids) scores (`torch.Tensor` có hình dạng `(batch_size, config.vocab_size)`) : Điểm dự đoán của đầu mô hình hóa ngôn ngữ. Đây có thể là logits cho từng từ vựng khi không sử dụng beam search hoặc log softmax cho từng token từ vựng khi sử dụng beam search **Trả về:** `torch.Tensor` có hình dạng `(batch_size, config.vocab_size)` Điểm dự đoán đã được xử lý. #### transformers.InfNanRemoveLogitsProcessor[[transformers.InfNanRemoveLogitsProcessor]] ```python transformers.InfNanRemoveLogitsProcessor() ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L1691) [LogitsProcessor](/docs/transformers/main/vi/internal/generation_utils#transformers.LogitsProcessor) loại bỏ tất cả các giá trị `nan` và `inf` để tránh phương pháp sinh bị lỗi. Lưu ý rằng chỉ nên sử dụng logits processor khi cần thiết vì nó có thể làm chậm phương pháp sinh. Logits processor này không có ví dụ `generate`, vì không nên có tổ hợp cờ nào phù hợp để sử dụng nó. #### __call__[[transformers.InfNanRemoveLogitsProcessor.__call__]] ```python __call__(input_ids: LongTensor, scores: Tensor) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L1700) **Tham số:** input_ids (`torch.LongTensor` có hình dạng `(batch_size, sequence_length)`) : Chỉ số của các token trong chuỗi đầu vào theo từ vựng. [Input IDs là gì?](../glossary#input-ids) scores (`torch.Tensor` có hình dạng `(batch_size, config.vocab_size)`) : Điểm dự đoán của đầu mô hình hóa ngôn ngữ. Đây có thể là logits cho từng từ vựng khi không sử dụng beam search hoặc log softmax cho từng token từ vựng khi sử dụng beam search **Trả về:** `torch.Tensor` có hình dạng `(batch_size, config.vocab_size)` Điểm dự đoán đã được xử lý. #### transformers.LogitNormalization[[transformers.LogitNormalization]] ```python transformers.LogitNormalization() ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L1814) [LogitsProcessor](/docs/transformers/main/vi/internal/generation_utils#transformers.LogitsProcessor) để chuẩn hóa các điểm số bằng log-softmax. Việc chuẩn hóa điểm số trong quá trình beam search, sau khi áp dụng các logits processors hoặc warpers, là rất quan trọng, vì thuật toán tìm kiếm được sử dụng trong thư viện này không thực hiện việc đó (nó chỉ thực hiện trước đó, nhưng chúng có thể cần được chuẩn hóa lại) trong khi vẫn giả định rằng các điểm số đã được chuẩn hóa khi so sánh các giả thuyết. Ví dụ: ```python >>> from transformers import AutoTokenizer, AutoModelForCausalLM >>> import torch >>> model = AutoModelForCausalLM.from_pretrained("distilbert/distilgpt2") >>> tokenizer = AutoTokenizer.from_pretrained("distilbert/distilgpt2") >>> inputs = tokenizer("A sequence: 1, 2, 3", return_tensors="pt") >>> # By default, the scores are not normalized -- the sum of their exponentials is NOT a normalized probability >>> # distribution, summing to 1 >>> outputs = model.generate(**inputs, return_dict_in_generate=True, output_scores=True) >>> print(torch.allclose(torch.sum(torch.exp(outputs.scores[-1])), torch.Tensor((1.000,)), rtol=1e-4)) False >>> # Normalizing them may have a positive impact on beam methods, or when using the scores on your application >>> outputs = model.generate(**inputs, renormalize_logits=True, return_dict_in_generate=True, output_scores=True) >>> print(torch.allclose(torch.sum(torch.exp(outputs.scores[-1])), torch.Tensor((1.000,)), rtol=1e-4)) True ``` #### __call__[[transformers.LogitNormalization.__call__]] ```python __call__(input_ids: LongTensor, scores: Tensor) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L1845) **Tham số:** input_ids (`torch.LongTensor` có hình dạng `(batch_size, sequence_length)`) : Chỉ số của các token trong chuỗi đầu vào theo từ vựng. [Input IDs là gì?](../glossary#input-ids) scores (`torch.Tensor` có hình dạng `(batch_size, config.vocab_size)`) : Điểm dự đoán của đầu mô hình hóa ngôn ngữ. Đây có thể là logits cho từng từ vựng khi không sử dụng beam search hoặc log softmax cho từng token từ vựng khi sử dụng beam search **Trả về:** `torch.Tensor` có hình dạng `(batch_size, config.vocab_size)` Điểm dự đoán đã được xử lý. #### transformers.LogitsProcessor[[transformers.LogitsProcessor]] ```python transformers.LogitsProcessor() ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L49) Lớp trừu tượng cơ sở cho tất cả các bộ xử lý logit có thể được áp dụng trong quá trình sinh. #### __call__[[transformers.LogitsProcessor.__call__]] ```python __call__(input_ids: LongTensor, scores: Tensor) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L56) **Tham số:** input_ids (`torch.LongTensor` có hình dạng `(batch_size, sequence_length)`) : Chỉ số của các token trong chuỗi đầu vào theo từ vựng. [Input IDs là gì?](../glossary#input-ids) scores (`torch.Tensor` có hình dạng `(batch_size, config.vocab_size)`) : Điểm dự đoán của đầu mô hình hóa ngôn ngữ. Đây có thể là logits cho từng từ vựng khi không sử dụng beam search hoặc log softmax cho từng token từ vựng khi sử dụng beam search **Trả về:** `torch.Tensor` có hình dạng `(batch_size, config.vocab_size)` Điểm dự đoán đã được xử lý. #### transformers.LogitsProcessorList[[transformers.LogitsProcessorList]] ```python transformers.LogitsProcessorList(iterable = ()) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L63) Lớp này có thể được sử dụng để tạo một danh sách [LogitsProcessor](/docs/transformers/main/vi/internal/generation_utils#transformers.LogitsProcessor) nhằm xử lý tensor đầu vào `scores` sau đó. Lớp này kế thừa từ list và thêm một phương thức *__call__* cụ thể để áp dụng từng [LogitsProcessor](/docs/transformers/main/vi/internal/generation_utils#transformers.LogitsProcessor) lên các đầu vào. #### __call__[[transformers.LogitsProcessorList.__call__]] ```python __call__(input_ids: LongTensor, scores: Tensor, **kwargs) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L70) **Tham số:** input_ids (`torch.LongTensor` có hình dạng `(batch_size, sequence_length)`) : Chỉ số của các token trong chuỗi đầu vào theo từ vựng. [Input IDs là gì?](../glossary#input-ids) scores (`torch.Tensor` có hình dạng `(batch_size, config.vocab_size)`) : Điểm dự đoán của đầu mô hình hóa ngôn ngữ. Đây có thể là logits cho từng từ vựng khi không sử dụng beam search hoặc log softmax cho từng token từ vựng khi sử dụng beam search kwargs (`dict[str, Any]`, *tùy chọn*) : Các kwargs bổ sung dành riêng cho một logits processor. **Trả về:** `torch.Tensor` có hình dạng `(batch_size, config.vocab_size)` Điểm dự đoán đã được xử lý. #### transformers.MinLengthLogitsProcessor[[transformers.MinLengthLogitsProcessor]] ```python transformers.MinLengthLogitsProcessor(min_length: int, eos_token_id: typing.Union[int, list[int], torch.Tensor], device: str = 'cpu') ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L101) **Tham số:** min_length (`int`) : Độ dài tối thiểu mà dưới ngưỡng này, điểm của `eos_token_id` được đặt thành `-float("Inf")`. eos_token_id (`Union[int, list[int], torch.Tensor]`) : id của token *end-of-sequence*. device (`str`, *tùy chọn*, mặc định là `"cpu"`) : Thiết bị để cấp phát các tensor. [LogitsProcessor](/docs/transformers/main/vi/internal/generation_utils#transformers.LogitsProcessor) thực thi độ dài tối thiểu bằng cách đặt xác suất EOS bằng 0. Lưu ý rằng, đối với các mô hình chỉ có decoder như hầu hết các LLM, độ dài bao gồm cả prompt. Ví dụ: ```python >>> from transformers import AutoModelForCausalLM, AutoTokenizer >>> tokenizer = AutoTokenizer.from_pretrained("bigscience/bloomz-560m") >>> model = AutoModelForCausalLM.from_pretrained("bigscience/bloomz-560m") >>> inputs = tokenizer("A number:", return_tensors="pt") >>> gen_out = model.generate(**inputs) >>> print(tokenizer.batch_decode(gen_out, skip_special_tokens=True)[0]) A number: one >>> # setting `min_length` to a value smaller than the uncontrolled output length has no impact >>> gen_out = model.generate(**inputs, min_length=3) >>> print(tokenizer.batch_decode(gen_out, skip_special_tokens=True)[0]) A number: one >>> # setting a larger `min_length` will force the model to generate beyond its natural ending point, which is not >>> # necessarily incorrect >>> gen_out = model.generate(**inputs, min_length=10) >>> print(tokenizer.batch_decode(gen_out, skip_special_tokens=True)[0]) A number: one thousand, nine hundred and ninety-four ``` #### __call__[[transformers.MinLengthLogitsProcessor.__call__]] ```python __call__(input_ids: LongTensor, scores: Tensor) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L154) **Tham số:** input_ids (`torch.LongTensor` có hình dạng `(batch_size, sequence_length)`) : Chỉ số của các token trong chuỗi đầu vào theo từ vựng. [Input IDs là gì?](../glossary#input-ids) scores (`torch.Tensor` có hình dạng `(batch_size, config.vocab_size)`) : Điểm dự đoán của đầu mô hình hóa ngôn ngữ. Đây có thể là logits cho từng từ vựng khi không sử dụng beam search hoặc log softmax cho từng token từ vựng khi sử dụng beam search **Trả về:** `torch.Tensor` có hình dạng `(batch_size, config.vocab_size)` Điểm dự đoán đã được xử lý. #### transformers.MinNewTokensLengthLogitsProcessor[[transformers.MinNewTokensLengthLogitsProcessor]] ```python transformers.MinNewTokensLengthLogitsProcessor(prompt_length_to_skip: int, min_new_tokens: int, eos_token_id: typing.Union[int, list[int], torch.Tensor], device: str = 'cpu') ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L164) **Tham số:** prompt_length_to_skip (`int`) : Độ dài của các token đầu vào. Không phải là đối số hợp lệ khi sử dụng với `generate` vì nó sẽ tự động gán độ dài đầu vào. min_new_tokens (`int`) : Độ dài tối thiểu của các token *mới* mà dưới ngưỡng này, điểm của `eos_token_id` được đặt thành `-float("Inf")`. eos_token_id (`Union[int, list[int], torch.Tensor]`) : id của token *end-of-sequence*. device (`str`, *tùy chọn*, mặc định là `"cpu"`) : Thiết bị để cấp phát các tensor. [LogitsProcessor](/docs/transformers/main/vi/internal/generation_utils#transformers.LogitsProcessor) thực thi độ dài tối thiểu của các token mới bằng cách đặt xác suất của token EOS (End-Of-Sequence) thành 0. Ngược lại với [MinLengthLogitsProcessor](/docs/transformers/main/vi/internal/generation_utils#transformers.MinLengthLogitsProcessor), bộ xử lý này bỏ qua prompt. Ví dụ: ```python >>> from transformers import AutoModelForCausalLM, AutoTokenizer >>> tokenizer = AutoTokenizer.from_pretrained("bigscience/bloomz-560m") >>> model = AutoModelForCausalLM.from_pretrained("bigscience/bloomz-560m") >>> inputs = tokenizer(["A number:"], return_tensors="pt") >>> gen_out = model.generate(**inputs) >>> print(tokenizer.batch_decode(gen_out, skip_special_tokens=True)[0]) A number: one >>> # setting `min_new_tokens` will force the model to generate beyond its natural ending point, which is not >>> # necessarily incorrect >>> gen_out = model.generate(**inputs, min_new_tokens=2) >>> print(tokenizer.batch_decode(gen_out, skip_special_tokens=True)[0]) A number: one thousand ``` #### __call__[[transformers.MinNewTokensLengthLogitsProcessor.__call__]] ```python __call__(input_ids: LongTensor, scores: Tensor) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L226) **Tham số:** input_ids (`torch.LongTensor` có hình dạng `(batch_size, sequence_length)`) : Chỉ số của các token trong chuỗi đầu vào theo từ vựng. [Input IDs là gì?](../glossary#input-ids) scores (`torch.Tensor` có hình dạng `(batch_size, config.vocab_size)`) : Điểm dự đoán của đầu mô hình hóa ngôn ngữ. Đây có thể là logits cho từng từ vựng khi không sử dụng beam search hoặc log softmax cho từng token từ vựng khi sử dụng beam search **Trả về:** `torch.Tensor` có hình dạng `(batch_size, config.vocab_size)` Điểm dự đoán đã được xử lý. #### transformers.MinPLogitsWarper[[transformers.MinPLogitsWarper]] ```python transformers.MinPLogitsWarper(min_p: float, filter_value: float = -inf, min_tokens_to_keep: int = 1) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L733) **Tham số:** min_p (`float`) : Xác suất tối thiểu của token, sẽ được nhân với xác suất của token có khả năng cao nhất. Giá trị này phải nằm trong khoảng từ 0 đến 1. Các giá trị điển hình nằm trong khoảng 0.01-0.2, có mức độ chọn lọc tương đương với việc đặt `top_p` trong khoảng 0.99-0.8 (sử dụng giá trị ngược lại so với các giá trị `top_p` thông thường). filter_value (`float`, *tuỳ chọn*, mặc định là -inf) : Tất cả các giá trị đã lọc sẽ được đặt thành giá trị float này. min_tokens_to_keep (`int`, *tuỳ chọn*, mặc định là 1) : Số lượng token tối thiểu không thể bị lọc. [LogitsProcessor](/docs/transformers/main/vi/internal/generation_utils#transformers.LogitsProcessor) thực hiện min-p, tức là giữ lại tất cả các token có xác suất cao hơn một ngưỡng xác suất tối thiểu, được quy đổi theo xác suất của token có khả năng cao nhất. Kết quả là bộ lọc trở nên khắt khe hơn khi có sự hiện diện của các token có xác suất cao, đây là dấu hiệu của một đầu ra tự tin mà chúng ta không nên lệch khỏi. Thường được sử dụng cùng với [TemperatureLogitsWarper](/docs/transformers/main/vi/internal/generation_utils#transformers.TemperatureLogitsWarper). Được dùng như một phương án thay thế cho [TopPLogitsWarper](/docs/transformers/main/vi/internal/generation_utils#transformers.TopPLogitsWarper) và [TopKLogitsWarper](/docs/transformers/main/vi/internal/generation_utils#transformers.TopKLogitsWarper). Được tạo bởi @menhguin và @kalomaze (tên người dùng github). Mã được điều chỉnh từ [PR bên ngoài này](https://github.com/oobabooga/text-generation-webui/pull/4449/files) Ví dụ: ```python >>> from transformers import AutoTokenizer, AutoModelForCausalLM, set_seed >>> set_seed(1) >>> model = AutoModelForCausalLM.from_pretrained("distilbert/distilgpt2") >>> tokenizer = AutoTokenizer.from_pretrained("distilbert/distilgpt2") >>> inputs = tokenizer("A sequence: 1, 2", return_tensors="pt") >>> # With sampling, the output is unexpected -- sometimes too unexpected. >>> outputs = model.generate(**inputs, do_sample=True) >>> print(tokenizer.batch_decode(outputs, skip_special_tokens=True)[0]) A sequence: 1, 2, 3 | < 4 (left-hand pointer) ; >>> # With `min_p` sampling, the output gets restricted to high-probability tokens. >>> # Pro tip: In practice, LLMs use `min_p` in the 0.01-0.2 range. >>> outputs = model.generate(**inputs, do_sample=True, min_p=0.1) >>> print(tokenizer.batch_decode(outputs, skip_special_tokens=True)[0]) A sequence: 1, 2, 3, 4, 5, 6, 7, 8, 9 ``` #### __call__[[transformers.MinPLogitsWarper.__call__]] ```python __call__(input_ids: LongTensor, scores: Tensor) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L790) #### transformers.NoBadWordsLogitsProcessor[[transformers.NoBadWordsLogitsProcessor]] ```python transformers.NoBadWordsLogitsProcessor(bad_words_ids: list, eos_token_id: typing.Union[int, list[int], torch.Tensor, NoneType] = None) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L1426) **Tham số:** bad_words_ids (`list[list[int]]`) : Danh sách các danh sách id token không được phép tạo ra. eos_token_id (`Union[int, list[int], torch.Tensor]`, *tùy chọn*) : id của token *end-of-sequence*. [LogitsProcessor](/docs/transformers/main/vi/internal/generation_utils#transformers.LogitsProcessor) đảm bảo rằng các chuỗi được chỉ định sẽ không bao giờ được chọn. Để lấy token ids của các từ không nên xuất hiện trong văn bản được tạo, hãy đảm bảo đặt `add_prefix_space=True` khi khởi tạo tokenizer, và sử dụng `tokenizer(bad_words, add_special_tokens=False).input_ids`. Tham số `add_prefix_space` chỉ được hỗ trợ cho một số tokenizer chậm, vì hành vi thêm tiền tố của các tokenizer nhanh đến từ `pre tokenizers`. Đọc thêm [tại đây](https://huggingface.co/docs/tokenizers/api/pre-tokenizers). Ví dụ: ```python >>> from transformers import AutoTokenizer, AutoModelForCausalLM >>> model = AutoModelForCausalLM.from_pretrained("openai-community/gpt2") >>> tokenizer = AutoTokenizer.from_pretrained("openai-community/gpt2") >>> inputs = tokenizer(["In a word, the cake is a"], return_tensors="pt") >>> output_ids = model.generate(inputs["input_ids"], max_new_tokens=5, pad_token_id=tokenizer.eos_token_id) >>> print(tokenizer.batch_decode(output_ids, skip_special_tokens=True)[0]) In a word, the cake is a bit of a mess. >>> # Now let's take the bad words out. Please note that the tokenizer is initialized differently >>> tokenizer_with_prefix_space = AutoTokenizer.from_pretrained("openai-community/gpt2", add_prefix_space=True) >>> def get_tokens_as_list(word_list): ... "Converts a sequence of words into a list of tokens" ... tokens_list = [] ... for word in word_list: ... tokenized_word = tokenizer_with_prefix_space([word], add_special_tokens=False).input_ids[0] ... tokens_list.append(tokenized_word) ... return tokens_list >>> bad_words_ids = get_tokens_as_list(word_list=["mess"]) >>> output_ids = model.generate( ... inputs["input_ids"], max_new_tokens=5, bad_words_ids=bad_words_ids, pad_token_id=tokenizer.eos_token_id ... ) >>> print(tokenizer.batch_decode(output_ids, skip_special_tokens=True)[0]) In a word, the cake is a bit of a surprise. ``` #### __call__[[transformers.NoBadWordsLogitsProcessor.__call__]] ```python __call__(input_ids: LongTensor, scores: Tensor) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L1318) **Tham số:** input_ids (`torch.LongTensor` có hình dạng `(batch_size, sequence_length)`) : Chỉ số của các token trong chuỗi đầu vào theo từ vựng. [Input IDs là gì?](../glossary#input-ids) scores (`torch.Tensor` có hình dạng `(batch_size, config.vocab_size)`) : Điểm dự đoán của đầu mô hình hóa ngôn ngữ. Đây có thể là logits cho từng từ vựng khi không sử dụng beam search hoặc log softmax cho từng token từ vựng khi sử dụng beam search **Trả về:** `torch.Tensor` có hình dạng `(batch_size, config.vocab_size)` Điểm dự đoán đã được xử lý. #### transformers.NoRepeatNGramLogitsProcessor[[transformers.NoRepeatNGramLogitsProcessor]] ```python transformers.NoRepeatNGramLogitsProcessor(ngram_size: int) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L1102) **Tham số:** ngram_size (`int`) : Tất cả các ngram có kích thước `ngram_size` chỉ có thể xuất hiện một lần. N-grams là các nhóm gồm "n" từ, ký tự hoặc token liên tiếp được lấy từ một chuỗi văn bản. Với câu: "She runs fast", các bi-gram (n=2) sẽ là ("she", "runs") và ("runs", "fast"). Trong tạo văn bản, việc tránh lặp lại các chuỗi từ giúp đầu ra đa dạng hơn. [LogitsProcessor](/docs/transformers/main/vi/internal/generation_utils#transformers.LogitsProcessor) này thực thi việc không lặp lại n-grams bằng cách đặt điểm của các token bị cấm thành âm vô cùng, loại bỏ những token đó khỏi quá trình xem xét khi xử lý điểm tiếp theo. Lưu ý rằng, đối với các mô hình chỉ có decoder như hầu hết các LLM, prompt cũng được tính đến để lấy các n-grams. [Fairseq](https://github.com/pytorch/fairseq/blob/a07cb6f40480928c9e0548b737aadd36ee66ac76/fairseq/sequence_generator.py#L345). Hãy sử dụng hình phạt n-gram một cách thận trọng. Ví dụ, việc áp dụng hình phạt cho 2-gram (bigram) trong một bài viết về thành phố New York có thể dẫn đến kết quả không mong muốn, trong đó tên thành phố chỉ xuất hiện một lần trong toàn bộ văn bản. [Tham khảo](https://huggingface.co/blog/how-to-generate) Ví dụ: ```py >>> from transformers import AutoTokenizer, AutoModelForCausalLM >>> model = AutoModelForCausalLM.from_pretrained("distilbert/distilgpt2") >>> tokenizer = AutoTokenizer.from_pretrained("distilbert/distilgpt2") >>> inputs = tokenizer(["Today I"], return_tensors="pt") >>> output = model.generate(**inputs) >>> print(tokenizer.decode(output[0], skip_special_tokens=True)) Today I'm not sure if I'm going to be able to do it. >>> # Now let's add ngram size using `no_repeat_ngram_size`. This stops the repetitions ("I'm") in the output. >>> output = model.generate(**inputs, no_repeat_ngram_size=2) >>> print(tokenizer.decode(output[0], skip_special_tokens=True)) Today I'm not sure if I can get a better understanding of the nature of this issue ``` #### __call__[[transformers.NoRepeatNGramLogitsProcessor.__call__]] ```python __call__(input_ids: LongTensor, scores: Tensor) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L1149) **Tham số:** input_ids (`torch.LongTensor` có hình dạng `(batch_size, sequence_length)`) : Chỉ số của các token trong chuỗi đầu vào theo từ vựng. [Input IDs là gì?](../glossary#input-ids) scores (`torch.Tensor` có hình dạng `(batch_size, config.vocab_size)`) : Điểm dự đoán của đầu mô hình hóa ngôn ngữ. Đây có thể là logits cho từng từ vựng khi không sử dụng beam search hoặc log softmax cho từng token từ vựng khi sử dụng beam search **Trả về:** `torch.Tensor` có hình dạng `(batch_size, config.vocab_size)` Điểm dự đoán đã được xử lý. #### transformers.PrefixConstrainedLogitsProcessor[[transformers.PrefixConstrainedLogitsProcessor]] ```python transformers.PrefixConstrainedLogitsProcessor(prefix_allowed_tokens_fn: Callable, num_beams: int) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L1515) **Tham số:** prefix_allowed_tokens_fn (`Callable[[int, torch.Tensor], list[int]]`) : Hàm này ràng buộc beam search chỉ cho phép các token được phép ở mỗi bước. Hàm này nhận 2 đối số `inputs_ids` và ID của batch `batch_id`. Nó phải trả về một danh sách các token được phép cho bước sinh tiếp theo, có điều kiện dựa trên các token đã sinh trước đó `inputs_ids` và ID của batch `batch_id`. [LogitsProcessor](/docs/transformers/main/vi/internal/generation_utils#transformers.LogitsProcessor) thực thi tạo văn bản có ràng buộc và hữu ích cho tạo văn bản có ràng buộc dựa trên tiền tố. Xem [Autoregressive Entity Retrieval](https://huggingface.co/papers/2010.00904) để biết thêm thông tin. Ví dụ: ```py >>> from transformers import AutoTokenizer, AutoModelForCausalLM >>> model = AutoModelForCausalLM.from_pretrained("bigscience/bloomz-560m") >>> tokenizer = AutoTokenizer.from_pretrained("bigscience/bloomz-560m") >>> inputs = tokenizer("Alice and Bob", return_tensors="pt") >>> # By default, it continues generating according to the model's logits >>> outputs = model.generate(**inputs, max_new_tokens=5) >>> print(tokenizer.batch_decode(outputs, skip_special_tokens=True)[0]) Alice and Bob are friends >>> # We can constrain it with `prefix_allowed_tokens_fn` to force a certain behavior based on a prefix. >>> # For instance, we can force an entire entity to be generated when its beginning is detected. >>> entity = tokenizer(" Bob Marley", return_tensors="pt").input_ids[0] # 3 tokens >>> def prefix_allowed_tokens_fn(batch_id, input_ids): ... ''' ... Attempts to generate 'Bob Marley' when 'Bob' is detected. ... In this case, `batch_id` is not used, but you can set rules for each batch member. ... ''' ... if input_ids[-1] == entity[0]: ... return [entity[1].item()] ... elif input_ids[-2] == entity[0] and input_ids[-1] == entity[1]: ... return [entity[2].item()] ... return list(range(tokenizer.vocab_size)) # If no match, allow all tokens >>> outputs = model.generate(**inputs, max_new_tokens=5, prefix_allowed_tokens_fn=prefix_allowed_tokens_fn) >>> print(tokenizer.batch_decode(outputs, skip_special_tokens=True)[0]) Alice and Bob Marley ``` #### __call__[[transformers.PrefixConstrainedLogitsProcessor.__call__]] ```python __call__(input_ids: LongTensor, scores: Tensor) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L1566) **Tham số:** input_ids (`torch.LongTensor` có hình dạng `(batch_size, sequence_length)`) : Chỉ số của các token trong chuỗi đầu vào theo từ vựng. [Input IDs là gì?](../glossary#input-ids) scores (`torch.Tensor` có hình dạng `(batch_size, config.vocab_size)`) : Điểm dự đoán của đầu mô hình hóa ngôn ngữ. Đây có thể là logits cho từng từ vựng khi không sử dụng beam search hoặc log softmax cho từng token từ vựng khi sử dụng beam search **Trả về:** `torch.Tensor` có hình dạng `(batch_size, config.vocab_size)` Điểm dự đoán đã được xử lý. #### transformers.RepetitionPenaltyLogitsProcessor[[transformers.RepetitionPenaltyLogitsProcessor]] ```python transformers.RepetitionPenaltyLogitsProcessor(penalty: float, prompt_ignore_length: typing.Union[int, torch.Tensor, NoneType] = None) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L306) **Tham số:** penalty (`float`) : Tham số cho hình phạt lặp lại. 1.0 nghĩa là không có hình phạt. Lớn hơn 1.0 sẽ hình phạt các token đã được tạo trước đó. Nằm giữa 0.0 và 1.0 sẽ thưởng cho các token đã được tạo trước đó. prompt_ignore_length (`int` hoặc `torch.LongTensor`, *tùy chọn*) : Số lượng token đầu cần bỏ qua, có thể được chỉ định riêng cho từng phần tử trong batch. [LogitsProcessor](/docs/transformers/main/vi/internal/generation_utils#transformers.LogitsProcessor) ngăn chặn việc lặp lại các token trước đó thông qua một hình phạt. Hình phạt này được áp dụng tối đa một lần cho mỗi token. Lưu ý rằng, đối với các mô hình chỉ có bộ giải mã như hầu hết các LLM, các token được xem xét bao gồm cả prompt theo mặc định. Trong [bài báo](https://huggingface.co/papers/1909.05858) gốc, các tác giả đề xuất sử dụng mức phạt khoảng 1.2 để đạt được sự cân bằng tốt giữa việc tạo ra nội dung trung thực và hạn chế sự lặp lại. Để phạt và giảm sự lặp lại, hãy sử dụng các giá trị `penalty` lớn hơn 1.0, trong đó giá trị cao hơn sẽ phạt mạnh hơn. Để thưởng và khuyến khích sự lặp lại, hãy sử dụng các giá trị `penalty` nằm giữa 0.0 và 1.0, trong đó giá trị thấp hơn sẽ thưởng mạnh hơn. Ví dụ: ```py >>> from transformers import AutoTokenizer, AutoModelForCausalLM, RepetitionPenaltyLogitsProcessor >>> # Initializing the model and tokenizer for it >>> model = AutoModelForCausalLM.from_pretrained("distilbert/distilgpt2") >>> tokenizer = AutoTokenizer.from_pretrained("distilbert/distilgpt2") >>> inputs = tokenizer(["I'm not going to"], return_tensors="pt") >>> # This shows a normal generate without any specific parameters >>> summary_ids = model.generate(**inputs) >>> print(tokenizer.batch_decode(summary_ids, skip_special_tokens=True)[0]) I'm not going to be able to do that. I'm going to be able to do that >>> # This generates a penalty for repeated tokens >>> penalized_ids = model.generate(**inputs, repetition_penalty=1.1) >>> print(tokenizer.batch_decode(penalized_ids, skip_special_tokens=True)[0]) I'm not going to be able to do that. I'll just have to go out and play >>> # We can also exclude the input prompt by creating an instance of this class >>> # with a `prompt_ignore_length` and passing it as a custom logit processor >>> rep_pen_processor = RepetitionPenaltyLogitsProcessor( ... penalty=1.1, ... prompt_ignore_length=inputs["input_ids"].shape[-1] ... ) >>> penalized_ids = model.generate(**inputs, logits_processor=[rep_pen_processor]) >>> print(tokenizer.batch_decode(penalized_ids, skip_special_tokens=True)[0]) I'm not going to be able to do that. I'm going to have to go through a lot of things, and ``` #### __call__[[transformers.RepetitionPenaltyLogitsProcessor.__call__]] ```python __call__(input_ids: LongTensor, scores: Tensor) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L373) **Tham số:** input_ids (`torch.LongTensor` có hình dạng `(batch_size, sequence_length)`) : Chỉ số của các token trong chuỗi đầu vào theo từ vựng. [Input IDs là gì?](../glossary#input-ids) scores (`torch.Tensor` có hình dạng `(batch_size, config.vocab_size)`) : Điểm dự đoán của đầu mô hình hóa ngôn ngữ. Đây có thể là logits cho từng từ vựng khi không sử dụng beam search hoặc log softmax cho từng token từ vựng khi sử dụng beam search **Trả về:** `torch.Tensor` có hình dạng `(batch_size, config.vocab_size)` Điểm dự đoán đã được xử lý. #### transformers.SequenceBiasLogitsProcessor[[transformers.SequenceBiasLogitsProcessor]] ```python transformers.SequenceBiasLogitsProcessor(sequence_bias: list) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L1242) **Tham số:** sequence_bias (`list[list[Union[list[int], float]]]`) : Danh sách các danh sách ánh xạ một chuỗi token đến số hạng bias của nó (ví dụ: `[[[10, 45], -2.0], [[64], -7.5]]`). Các bias dương làm tăng khả năng chuỗi được chọn, trong khi các bias âm thì ngược lại. Nếu một chuỗi có độ dài là 1, bias của nó sẽ luôn được áp dụng. Ngược lại, bias chỉ được áp dụng nếu chuỗi liên quan sắp được hoàn thành (trong bước chọn token sau khi bộ xử lý này được áp dụng). [LogitsProcessor](/docs/transformers/main/vi/internal/generation_utils#transformers.LogitsProcessor) áp dụng độ chệch cộng vào các chuỗi. Độ chệch được áp dụng cho token cuối cùng của một chuỗi khi token được sinh ra tiếp theo có thể hoàn thành nó. Do đó, để tận dụng tối đa việc chệch các chuỗi có nhiều hơn một token, hãy cân nhắc sử dụng các phương pháp beam (để xử lý một cách mềm mại các chuỗi hoàn thành một phần có độ chệch âm) và áp dụng độ chệch vào các tiền tố của chúng (để đảm bảo độ chệch được áp dụng sớm hơn). Ở cấp độ token, việc thiên vị một từ khác với việc thiên vị một từ có khoảng trắng phía trước. Nếu bạn muốn thiên vị "foo" ở giữa câu, bạn có thể sẽ muốn thêm một khoảng trắng tiền tố và thiên vị " foo" thay vào đó. Xem phần tokenizer của khóa học NLP của chúng tôi để tìm hiểu lý do: https://huggingface.co/learn/nlp-course/chapter2/4?fw=pt Ví dụ: ```python >>> from transformers import AutoTokenizer, AutoModelForCausalLM >>> model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen2.5-0.5B-Instruct") >>> tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen2.5-0.5B-Instruct") >>> inputs = tokenizer(["The full name of Donald is Donald"], return_tensors="pt") >>> summary_ids = model.generate(inputs["input_ids"], max_new_tokens=4, do_sample=False) >>> print(tokenizer.batch_decode(summary_ids, skip_special_tokens=True)[0]) The full name of Donald is Donald John Trump Sr. >>> def get_tokens(word): ... return tokenizer([word], add_special_tokens=False).input_ids[0] >>> # IMPORTANT: Remember our tip about adding spaces before words to bias them correctly. >>> sequence_bias = [[get_tokens("Trump"), -10.0],] # will fail to apply bias >>> biased_ids = model.generate( ... inputs["input_ids"], max_new_tokens=4, do_sample=False, sequence_bias=sequence_bias ... ) >>> print(tokenizer.batch_decode(biased_ids, skip_special_tokens=True)[0]) The full name of Donald is Donald John Trump Sr. >>> sequence_bias = [[get_tokens(" Trump"), -10.0],] # will work >>> biased_ids = model.generate( ... inputs["input_ids"], max_new_tokens=4, do_sample=False, sequence_bias=sequence_bias ... ) >>> print(tokenizer.batch_decode(biased_ids, skip_special_tokens=True)[0]) The full name of Donald is Donald John Harper. He >>> # We can also add a positive bias to nudge the model towards specific tokens or continuations. This technique >>> # is also more effective when paired up with beam search. >>> sequence_bias = [[get_tokens(" Donald Duck"), 10.0],] >>> biased_ids = model.generate( ... inputs["input_ids"], max_new_tokens=4, num_beams=4, do_sample=False, sequence_bias=sequence_bias ... ) >>> print(tokenizer.batch_decode(biased_ids, skip_special_tokens=True)[0]) The full name of Donald is Donald Duck. He is ``` #### __call__[[transformers.SequenceBiasLogitsProcessor.__call__]] ```python __call__(input_ids: LongTensor, scores: Tensor) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L1318) **Tham số:** input_ids (`torch.LongTensor` có hình dạng `(batch_size, sequence_length)`) : Chỉ số của các token trong chuỗi đầu vào theo từ vựng. [Input IDs là gì?](../glossary#input-ids) scores (`torch.Tensor` có hình dạng `(batch_size, config.vocab_size)`) : Điểm dự đoán của đầu mô hình hóa ngôn ngữ. Đây có thể là logits cho từng từ vựng khi không sử dụng beam search hoặc log softmax cho từng token từ vựng khi sử dụng beam search **Trả về:** `torch.Tensor` có hình dạng `(batch_size, config.vocab_size)` Điểm dự đoán đã được xử lý. #### transformers.SuppressTokensAtBeginLogitsProcessor[[transformers.SuppressTokensAtBeginLogitsProcessor]] ```python transformers.SuppressTokensAtBeginLogitsProcessor(begin_suppress_tokens, begin_index, device: str = 'cpu') ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L1851) [SuppressTokensAtBeginLogitsProcessor](/docs/transformers/main/vi/internal/generation_utils#transformers.SuppressTokensAtBeginLogitsProcessor) sẽ chặn một danh sách các token ngay khi hàm `generate` bắt đầu tạo ra văn bản bằng cách sử dụng các token `begin_index`. Điều này đảm bảo rằng các token được định nghĩa bởi `begin_suppress_tokens` sẽ không được tạo ra ở phần đầu. Ban đầu được tạo ra cho [Whisper](https://huggingface.co/docs/transformers/model_doc/whisper). Ví dụ: ```python >>> from transformers import AutoProcessor, WhisperForConditionalGeneration >>> from datasets import load_dataset >>> processor = AutoProcessor.from_pretrained("openai/whisper-tiny.en") >>> model = WhisperForConditionalGeneration.from_pretrained("openai/whisper-tiny.en") >>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation") >>> inputs = processor(ds[0]["audio"]["array"], return_tensors="pt") >>> # Whisper has `begin_suppress_tokens` set by default (= `[220, 50256]`). 50256 is the EOS token, so this means >>> # it can't generate and EOS token in the first iteration, but it can in the others. >>> outputs = model.generate(**inputs, return_dict_in_generate=True, output_scores=True) >>> print(outputs.scores[0][0, 50256]) tensor(-inf) >>> print(outputs.scores[-1][0, 50256]) # in other places we can see some probability mass for EOS tensor(29.9010) >>> # If we disable `begin_suppress_tokens`, we can generate EOS in the first iteration. >>> outputs = model.generate( ... **inputs, return_dict_in_generate=True, output_scores=True, begin_suppress_tokens=None ... ) >>> print(outputs.scores[0][0, 50256]) tensor(11.2027) ``` #### __call__[[transformers.SuppressTokensAtBeginLogitsProcessor.__call__]] ```python __call__(input_ids: LongTensor, scores: Tensor) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L1893) **Tham số:** input_ids (`torch.LongTensor` có hình dạng `(batch_size, sequence_length)`) : Chỉ số của các token trong chuỗi đầu vào theo từ vựng. [Input IDs là gì?](../glossary#input-ids) scores (`torch.Tensor` có hình dạng `(batch_size, config.vocab_size)`) : Điểm dự đoán của đầu mô hình hóa ngôn ngữ. Đây có thể là logits cho từng từ vựng khi không sử dụng beam search hoặc log softmax cho từng token từ vựng khi sử dụng beam search **Trả về:** `torch.Tensor` có hình dạng `(batch_size, config.vocab_size)` Điểm dự đoán đã được xử lý. #### transformers.SuppressTokensLogitsProcessor[[transformers.SuppressTokensLogitsProcessor]] ```python transformers.SuppressTokensLogitsProcessor(suppress_tokens, device: str = 'cpu') ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L1904) Bộ xử lý này có thể được sử dụng để chặn một danh sách các token. Bộ xử lý sẽ đặt log probs của chúng thành `-inf` để chúng không được tạo ra. Ban đầu được tạo cho [Whisper](https://huggingface.co/docs/transformers/model_doc/whisper). Ví dụ: ```python >>> from transformers import AutoProcessor, WhisperForConditionalGeneration >>> from datasets import load_dataset >>> processor = AutoProcessor.from_pretrained("openai/whisper-tiny.en") >>> model = WhisperForConditionalGeneration.from_pretrained("openai/whisper-tiny.en") >>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation") >>> inputs = processor(ds[0]["audio"]["array"], return_tensors="pt") >>> # Whisper has a long list of suppressed tokens. For instance, in this case, the token 1 is suppressed by default. >>> outputs = model.generate(**inputs, return_dict_in_generate=True, output_scores=True) >>> print(outputs.scores[1][0, 1]) # 1 (and not 0) is the first freely generated token tensor(-inf) >>> # If we disable `suppress_tokens`, we can generate it. >>> outputs = model.generate(**inputs, return_dict_in_generate=True, output_scores=True, suppress_tokens=None) >>> print(outputs.scores[1][0, 1]) tensor(6.0678) ``` #### __call__[[transformers.SuppressTokensLogitsProcessor.__call__]] ```python __call__(input_ids: LongTensor, scores: Tensor) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L1936) **Tham số:** input_ids (`torch.LongTensor` có hình dạng `(batch_size, sequence_length)`) : Chỉ số của các token trong chuỗi đầu vào theo từ vựng. [Input IDs là gì?](../glossary#input-ids) scores (`torch.Tensor` có hình dạng `(batch_size, config.vocab_size)`) : Điểm dự đoán của đầu mô hình hóa ngôn ngữ. Đây có thể là logits cho từng từ vựng khi không sử dụng beam search hoặc log softmax cho từng token từ vựng khi sử dụng beam search **Trả về:** `torch.Tensor` có hình dạng `(batch_size, config.vocab_size)` Điểm dự đoán đã được xử lý. #### transformers.SynthIDTextWatermarkLogitsProcessor[[transformers.SynthIDTextWatermarkLogitsProcessor]] ```python transformers.SynthIDTextWatermarkLogitsProcessor(ngram_len: int, keys: list, sampling_table_size: int, sampling_table_seed: int, context_history_size: int, device: device, skip_first_ngram_calls: bool = False, debug_mode: bool = False) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L2605) **Tham số:** ngram_len (`int`) : Độ dài ngram. keys (`list[int]`) : Một chuỗi các khóa watermarking, mỗi khóa tương ứng với một độ sâu. sampling_table_size (`int`) : Kích thước của bảng lấy mẫu. sampling_table_seed (`int`) : Hạt giống ngẫu nhiên để tạo bảng lấy mẫu. context_history_size (`int`) : Kích thước của tensor để theo dõi các ngữ cảnh đã thấy. device (`torch.device`) : Thiết bị cần sử dụng. skip_first_ngram_calls (`bool`, *tùy chọn*, mặc định là `False`) : Có bỏ qua các lần gọi ngram đầu tiên hay không. debug_mode (`bool`, *tùy chọn*, mặc định là `False`) : Logits được sửa đổi thành phân phối đều trước khi áp dụng thay đổi watermarking. Điều này dùng để kiểm tra việc triển khai. Logits processor thực hiện các kỹ thuật đánh dấu (watermarking) cho các mô hình tạo văn bản. Lớp này hỗ trợ việc áp dụng SynthID text watermarking, một phương pháp nhúng các tín hiệu không thể nhận biết vào văn bản được tạo ra để hỗ trợ phát hiện nội dung tổng hợp. Nó hoạt động bằng cách thao tác tinh tế trên xác suất lựa chọn token trong quá trình tạo văn bản theo cách có thể được khôi phục một cách đáng tin cậy sau đó để xác minh. Các tính năng chính: * **Quản lý trạng thái:** Duy trì trạng thái nội bộ để theo dõi các chuỗi token và tạo các khóa đánh dấu một cách động. * **Định danh khóa:** Tính toán các giá trị băm dựa trên các chuỗi token và các tham số đánh dấu để tạo ra các khóa duy nhất cho mỗi vị trí. * **Lấy mẫu giá trị G:** Sử dụng bảng lấy mẫu được tính trước để lấy mẫu các giá trị đánh dấu (giá trị g) dựa trên các khóa được tạo ra. * **Điều chỉnh điểm:** Áp dụng các giá trị g đã tính toán để thay đổi xác suất của token trong quá trình tạo, nhúng watermark * **Xử lý lặp ngữ cảnh:** Tích hợp logic để tránh đánh dấu các token trong các ngữ cảnh lặp lại, giữ được sự tự nhiên. * **Ẩn token EOS:** Hỗ trợ ẩn các token kết thúc câu để ngăn chúng được đưa vào watermark các phép tính. * **Các hàm tiện ích:** Cung cấp các hàm để tính trực tiếp các giá trị g, kiểm tra sự lặp lại ngữ cảnh, tạo Mặt nạ token EOS, và ước tính giá trị g trung bình kỳ vọng. Xem chi tiết tại địa chỉ bài báo: https://www.nature.com/articles/s41586-024-08025-4 Ví dụ: ```python >>> from transformers import AutoModelForCausalLM, AutoTokenizer, SynthIDTextWatermarkingConfig >>> tokenizer = AutoTokenizer.from_pretrained('google/gemma-2-2b', padding_side="left") >>> model = AutoModelForCausalLM.from_pretrained('google/gemma-2-2b') >>> # SynthID Text configuration >>> watermarking_config = SynthIDTextWatermarkingConfig( ... keys=[654, 400, 836, 123, 340, 443, 597, 160, 57], ... ngram_len=5, ... ) >>> # Generation with watermarking >>> tokenized_prompts = tokenizer(["Once upon a time, "], return_tensors="pt", padding=True) >>> output_sequences = model.generate( ... **tokenized_prompts, watermarking_config=watermarking_config, do_sample=True, max_new_tokens=10 ... ) >>> watermarked_text = tokenizer.batch_decode(output_sequences, skip_special_tokens=True) ``` #### __call__[[transformers.SynthIDTextWatermarkLogitsProcessor.__call__]] ```python __call__(input_ids: LongTensor, scores: Tensor) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L2743) **Tham số:** input_ids (`torch.LongTensor` có hình dạng `(batch_size, sequence_length)`) : Chỉ số của các token trong chuỗi đầu vào theo từ vựng. [Input IDs là gì?](../glossary#input-ids) scores (`torch.Tensor` có hình dạng `(batch_size, config.vocab_size)`) : Điểm dự đoán của đầu mô hình hóa ngôn ngữ. Đây có thể là logits cho từng từ vựng khi không sử dụng beam search hoặc log softmax cho từng token từ vựng khi sử dụng beam search **Trả về:** `torch.Tensor` có hình dạng `(batch_size, config.vocab_size)` Điểm dự đoán đã được xử lý. #### transformers.TemperatureLogitsWarper[[transformers.TemperatureLogitsWarper]] ```python transformers.TemperatureLogitsWarper(temperature: float) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L238) **Tham số:** temperature (`float`) : Giá trị float dương tuyệt đối được dùng để điều chỉnh phân phối logits. Giá trị nhỏ hơn `1` làm giảm tính ngẫu nhiên (và ngược lại), trong đó `0` tương đương với việc chuyển toàn bộ khối lượng xác suất sang token có khả năng cao nhất. [LogitsProcessor](/docs/transformers/main/vi/internal/generation_utils#transformers.LogitsProcessor) cho nhiệt độ (thang đo mũ của phân phối xác suất đầu ra), điều này có nghĩa là nó có thể kiểm soát tính ngẫu nhiên của các token được dự đoán. Thường được sử dụng cùng với [TopPLogitsWarper](/docs/transformers/main/vi/internal/generation_utils#transformers.TopPLogitsWarper) và [TopKLogitsWarper](/docs/transformers/main/vi/internal/generation_utils#transformers.TopKLogitsWarper). Hãy đảm bảo rằng `do_sample=True` được bao gồm trong các đối số của `generate`, nếu không giá trị nhiệt độ sẽ không có tác dụng. Ví dụ: ```python >>> import torch >>> from transformers import AutoTokenizer, AutoModelForCausalLM, set_seed >>> set_seed(0) # for reproducibility >>> tokenizer = AutoTokenizer.from_pretrained("openai-community/gpt2") >>> model = AutoModelForCausalLM.from_pretrained("openai-community/gpt2") >>> model.config.pad_token_id = model.config.eos_token_id >>> inputs = tokenizer(["Hugging Face Company is"], return_tensors="pt") >>> # With temperature=1.0, the default, we consistently get random outputs due to random sampling. >>> generate_kwargs = {"max_new_tokens": 10, "do_sample": True, "temperature": 1.0, "num_return_sequences": 2} >>> outputs = model.generate(**inputs, **generate_kwargs) >>> print(tokenizer.batch_decode(outputs, skip_special_tokens=True)) ['Hugging Face Company is one of these companies that is going to take a', "Hugging Face Company is a brand created by Brian A. O'Neil"] >>> # However, with temperature close to 0, it approximates greedy decoding strategies (invariant) >>> generate_kwargs["temperature"] = 0.0001 >>> outputs = model.generate(**inputs, **generate_kwargs) >>> print(tokenizer.batch_decode(outputs, skip_special_tokens=True)) ['Hugging Face Company is a company that has been around for over 20 years', 'Hugging Face Company is a company that has been around for over 20 years'] ``` #### __call__[[transformers.TemperatureLogitsWarper.__call__]] ```python __call__(input_ids: LongTensor, scores: Tensor) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L300) **Tham số:** input_ids (`torch.LongTensor` có hình dạng `(batch_size, sequence_length)`) : Chỉ số của các token trong chuỗi đầu vào theo từ vựng. [Input IDs là gì?](../glossary#input-ids) scores (`torch.Tensor` có hình dạng `(batch_size, config.vocab_size)`) : Điểm dự đoán của đầu mô hình hóa ngôn ngữ. Đây có thể là logits cho từng từ vựng khi không sử dụng beam search hoặc log softmax cho từng token từ vựng khi sử dụng beam search **Trả về:** `torch.Tensor` có hình dạng `(batch_size, config.vocab_size)` Điểm dự đoán đã được xử lý. #### transformers.TopHLogitsWarper[[transformers.TopHLogitsWarper]] ```python transformers.TopHLogitsWarper(top_h: float, filter_value: float = -inf) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L627) **Tham số:** top_h (`float`) : Hệ số tỷ lệ cho ngưỡng dựa trên entropy (`tau`). Phải nằm trong khoảng `(0, 1]`. filter_value (`float`, *tuỳ chọn*, mặc định là -inf) : Tất cả các giá trị đã lọc sẽ được đặt thành giá trị float này. [LogitsProcessor](/docs/transformers/main/vi/internal/generation_utils#transformers.LogitsProcessor) thực hiện Top-H sampling, một phương pháp giải mã chọn thích ứng một tập con các token có xác suất cao dựa trên các ràng buộc về entropy và xác suất tích lũy. Phương pháp này xác định động số lượng token cần giữ lại bằng cách phân tích sự khác biệt entropy của phân phối được chọn, từ đó cân bằng giữa khám phá và khai thác. Nó đảm bảo rằng văn bản được tạo ra duy trì được cả tính đa dạng lẫn tính nhất quán. Tham khảo: Để biết thêm chi tiết, xem *Top-H Decoding: Adapting the Creativity and Coherence with Bounded Entropy in Text Generation* (NeurIPS 2025): https://arxiv.org/abs/2509.02510 Ví dụ: ```python >>> from transformers import AutoTokenizer, AutoModelForCausalLM >>> model = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-3.1-8B") >>> tokenizer = AutoTokenizer.from_pretrained("meta-llama/Llama-3.1-8B") >>> inputs = tokenizer("A sequence: 1, 2", return_tensors="pt") >>> outputs = model.generate(**inputs, do_sample=True, top_h=0.4) >>> print(tokenizer.batch_decode(outputs, skip_special_tokens=True)[0]) A sequence: 1, 2, 3, 4, 5, 6, 7, 8, 9 ``` #### __call__[[transformers.TopHLogitsWarper.__call__]] ```python __call__(input_ids: LongTensor, scores: Tensor) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L678) **Tham số:** input_ids (`torch.LongTensor` có hình dạng `(batch_size, sequence_length)`) : ID của các token đầu vào. scores (`torch.Tensor` có hình dạng `(batch_size, vocab_size)`) : Logit thô từ mô hình. **Trả về:** `torch.Tensor` có hình dạng `(batch_size, vocab_size)` Logits đã được xử lý, trong đó các token không hợp lệ được che bằng `-inf`. Lọc logits bằng phương pháp lấy mẫu Top-H. #### transformers.TopKLogitsWarper[[transformers.TopKLogitsWarper]] ```python transformers.TopKLogitsWarper(top_k: int, filter_value: float = -inf, min_tokens_to_keep: int = 1) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L571) **Tham số:** top_k (`int`) : Số lượng token từ vựng có xác suất cao nhất cần giữ lại cho lọc top-k. filter_value (`float`, *tuỳ chọn*, mặc định là -inf) : Tất cả các giá trị đã lọc sẽ được đặt thành giá trị float này. min_tokens_to_keep (`int`, *tuỳ chọn*, mặc định là 1) : Số lượng token tối thiểu không thể bị lọc. [LogitsProcessor](/docs/transformers/main/vi/internal/generation_utils#transformers.LogitsProcessor) thực hiện top-k, tức là giới hạn trong k phần tử có xác suất cao nhất. Thường được sử dụng cùng với [TemperatureLogitsWarper](/docs/transformers/main/vi/internal/generation_utils#transformers.TemperatureLogitsWarper) và [TopPLogitsWarper](/docs/transformers/main/vi/internal/generation_utils#transformers.TopPLogitsWarper). Ví dụ: ```python >>> from transformers import AutoTokenizer, AutoModelForCausalLM, set_seed >>> set_seed(1) >>> model = AutoModelForCausalLM.from_pretrained("distilbert/distilgpt2") >>> tokenizer = AutoTokenizer.from_pretrained("distilbert/distilgpt2") >>> inputs = tokenizer("A sequence: A, B, C, D", return_tensors="pt") >>> # With sampling, the output is unexpected -- sometimes too unexpected. >>> outputs = model.generate(**inputs, do_sample=True) >>> print(tokenizer.batch_decode(outputs, skip_special_tokens=True)[0]) A sequence: A, B, C, D, E — S — O, P — R >>> # With `top_k` sampling, the output gets restricted the k most likely tokens. >>> # Pro tip: In practice, LLMs use `top_k` in the 5-50 range. >>> outputs = model.generate(**inputs, do_sample=True, top_k=2) >>> print(tokenizer.batch_decode(outputs, skip_special_tokens=True)[0]) A sequence: A, B, C, D, E, F, G, H, I ``` #### __call__[[transformers.TopKLogitsWarper.__call__]] ```python __call__(input_ids: LongTensor, scores: Tensor) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L618) **Tham số:** input_ids (`torch.LongTensor` có hình dạng `(batch_size, sequence_length)`) : Chỉ số của các token trong chuỗi đầu vào theo từ vựng. [Input IDs là gì?](../glossary#input-ids) scores (`torch.Tensor` có hình dạng `(batch_size, config.vocab_size)`) : Điểm dự đoán của đầu mô hình hóa ngôn ngữ. Đây có thể là logits cho từng từ vựng khi không sử dụng beam search hoặc log softmax cho từng token từ vựng khi sử dụng beam search **Trả về:** `torch.Tensor` có hình dạng `(batch_size, config.vocab_size)` Điểm dự đoán đã được xử lý. #### transformers.TopPLogitsWarper[[transformers.TopPLogitsWarper]] ```python transformers.TopPLogitsWarper(top_p: float, filter_value: float = -inf, min_tokens_to_keep: int = 1) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L502) **Tham số:** top_p (`float`) : Nếu được đặt < 1, chỉ tập hợp nhỏ nhất các token có xác suất cao nhất, với tổng xác suất bằng hoặc lớn hơn `top_p`, sẽ được giữ lại cho quá trình sinh. filter_value (`float`, *tuỳ chọn*, mặc định là -inf) : Tất cả các giá trị đã lọc sẽ được đặt thành giá trị float này. min_tokens_to_keep (`int`, *tuỳ chọn*, mặc định là 1) : Số lượng token tối thiểu không thể bị lọc. [LogitsProcessor](/docs/transformers/main/vi/internal/generation_utils#transformers.LogitsProcessor) thực hiện top-p, tức là giới hạn trong các token hàng đầu có tổng xác suất <= prob_cut_off. Thường được sử dụng cùng với [TemperatureLogitsWarper](/docs/transformers/main/vi/internal/generation_utils#transformers.TemperatureLogitsWarper) và [TopKLogitsWarper](/docs/transformers/main/vi/internal/generation_utils#transformers.TopKLogitsWarper). Ví dụ: ```python >>> from transformers import AutoTokenizer, AutoModelForCausalLM, set_seed >>> set_seed(1) >>> model = AutoModelForCausalLM.from_pretrained("distilbert/distilgpt2") >>> tokenizer = AutoTokenizer.from_pretrained("distilbert/distilgpt2") >>> inputs = tokenizer("A sequence: 1, 2", return_tensors="pt") >>> # With sampling, the output is unexpected -- sometimes too unexpected. >>> outputs = model.generate(**inputs, do_sample=True) >>> print(tokenizer.batch_decode(outputs, skip_special_tokens=True)[0]) A sequence: 1, 2, 3 | < 4 (left-hand pointer) ; >>> # With `top_p` sampling, the output gets restricted to high-probability tokens. >>> # Pro tip: In practice, LLMs use `top_p` in the 0.9-0.95 range. >>> outputs = model.generate(**inputs, do_sample=True, top_p=0.1) >>> print(tokenizer.batch_decode(outputs, skip_special_tokens=True)[0]) A sequence: 1, 2, 3, 4, 5, 6, 7, 8, 9 ``` #### __call__[[transformers.TopPLogitsWarper.__call__]] ```python __call__(input_ids: LongTensor, scores: Tensor) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L555) **Tham số:** input_ids (`torch.LongTensor` có hình dạng `(batch_size, sequence_length)`) : Chỉ số của các token trong chuỗi đầu vào theo từ vựng. [Input IDs là gì?](../glossary#input-ids) scores (`torch.Tensor` có hình dạng `(batch_size, config.vocab_size)`) : Điểm dự đoán của đầu mô hình hóa ngôn ngữ. Đây có thể là logits cho từng từ vựng khi không sử dụng beam search hoặc log softmax cho từng token từ vựng khi sử dụng beam search **Trả về:** `torch.Tensor` có hình dạng `(batch_size, config.vocab_size)` Điểm dự đoán đã được xử lý. #### transformers.TypicalLogitsWarper[[transformers.TypicalLogitsWarper]] ```python transformers.TypicalLogitsWarper(mass: float = 0.9, filter_value: float = -inf, min_tokens_to_keep: int = 1) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L809) **Tham số:** mass (`float`, *tuỳ chọn*, mặc định là 0.9) : Giá trị của typical_p nằm trong khoảng từ 0 đến 1 (bao gồm cả hai đầu), mặc định là 0.9. filter_value (`float`, *tuỳ chọn*, mặc định là -inf) : Tất cả các giá trị đã lọc sẽ được đặt thành giá trị float này. min_tokens_to_keep (`int`, *tuỳ chọn*, mặc định là 1) : Số lượng token tối thiểu không thể bị lọc. [LogitsProcessor](/docs/transformers/main/vi/internal/generation_utils#transformers.LogitsProcessor) thực hiện giải mã điển hình (typical decoding). Lấy cảm hứng từ cách con người sử dụng ngôn ngữ, nó ưu tiên các token có log xác suất gần với entropy của phân phối xác suất token. Điều này có nghĩa là các token có khả năng cao nhất có thể bị loại bỏ trong quá trình này. Xem [Giải mã điển hình cho tạo ngôn ngữ tự nhiên](https://huggingface.co/papers/2202.00666) để biết thêm thông tin. Ví dụ: ```python >>> from transformers import AutoTokenizer, AutoModelForCausalLM, set_seed >>> model = AutoModelForCausalLM.from_pretrained("bigscience/bloomz-560m") >>> tokenizer = AutoTokenizer.from_pretrained("bigscience/bloomz-560m") >>> inputs = tokenizer("1, 2, 3", return_tensors="pt") >>> # We can see that greedy decoding produces a sequence of numbers >>> outputs = model.generate(**inputs) >>> print(tokenizer.batch_decode(outputs, skip_special_tokens=True)[0]) 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, >>> # For this particular seed, we can see that sampling produces nearly the same low-information (= low entropy) >>> # sequence >>> set_seed(18) >>> outputs = model.generate(**inputs, do_sample=True) >>> print(tokenizer.batch_decode(outputs, skip_special_tokens=True)[0]) 1, 2, 3, 4, 5, 6, 7, 8, 9 and 10 >>> # With `typical_p` set, the most obvious sequence is no longer produced, which may be good for your problem >>> set_seed(18) >>> outputs = model.generate( ... **inputs, do_sample=True, typical_p=0.1, return_dict_in_generate=True, output_scores=True ... ) >>> print(tokenizer.batch_decode(outputs.sequences, skip_special_tokens=True)[0]) 1, 2, 3 and 5 >>> # We can see that the token corresponding to "4" (token 934) in the second position, the most likely token >>> # as seen with greedy decoding, was entirely blocked out >>> print(outputs.scores[1][0, 934]) tensor(-inf) ``` #### __call__[[transformers.TypicalLogitsWarper.__call__]] ```python __call__(input_ids: LongTensor, scores: Tensor) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L873) **Tham số:** input_ids (`torch.LongTensor` có hình dạng `(batch_size, sequence_length)`) : Chỉ số của các token trong chuỗi đầu vào theo từ vựng. [Input IDs là gì?](../glossary#input-ids) scores (`torch.Tensor` có hình dạng `(batch_size, config.vocab_size)`) : Điểm dự đoán của đầu mô hình hóa ngôn ngữ. Đây có thể là logits cho từng từ vựng khi không sử dụng beam search hoặc log softmax cho từng token từ vựng khi sử dụng beam search **Trả về:** `torch.Tensor` có hình dạng `(batch_size, config.vocab_size)` Điểm dự đoán đã được xử lý. #### transformers.UnbatchedClassifierFreeGuidanceLogitsProcessor[[transformers.UnbatchedClassifierFreeGuidanceLogitsProcessor]] ```python transformers.UnbatchedClassifierFreeGuidanceLogitsProcessor(guidance_scale: float, model, unconditional_ids: typing.Optional[torch.LongTensor] = None, unconditional_attention_mask: typing.Optional[torch.LongTensor] = None, use_cache: bool = True) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L2267) **Tham số:** guidance_scale (`float`) : Thang độ dẫn hướng cho classifier free guidance (CFG). CFG được kích hoạt bằng cách đặt `guidance_scale != 1`. Thang độ dẫn hướng cao hơn khuyến khích mô hình tạo ra các mẫu gắn kết chặt chẽ hơn với prompt đầu vào, thường phải đánh đổi bằng chất lượng kém hơn. Một giá trị nhỏ hơn 1 có tác dụng ngược lại, đồng thời khiến negative prompt được cung cấp qua negative_prompt_ids (nếu có) hoạt động như một positive prompt. model (`PreTrainedModel`) : Mô hình tính toán các điểm số không điều kiện. Được cho là giống với mô hình tính toán các điểm số có điều kiện. Cả hai mô hình phải sử dụng cùng một tokenizer. unconditional_ids (`torch.LongTensor` có shape `(batch_size, sequence_length)`, *tùy chọn*) : Chỉ số của các token trong chuỗi đầu vào thuộc từ điển cho nhánh không điều kiện. Nếu không được đặt, mặc định sẽ là token cuối cùng của prompt. unconditional_attention_mask (`torch.LongTensor` có hình dạng `(batch_size, sequence_length)`, *tùy chọn*) : Mặt nạ chú ý cho unconditional_ids. use_cache (`bool`, *tùy chọn*, mặc định là `True`) : Có nên lưu cache key/values trong quá trình forward pass của negative prompt hay không. Logits processor cho Classifier-Free Guidance (CFG). Processor tính trung bình có trọng số giữa các điểm số từ logits có điều kiện theo prompt và logits không điều kiện (hoặc âm) theo prompt, được tham số hóa bởi `guidance_scale`. Các điểm số không điều kiện được tính toán bên trong bằng cách đưa `unconditional_ids` vào `model`. Xem [bài báo](https://huggingface.co/papers/2306.17806) để biết thêm thông tin. Ví dụ: ```python >>> from transformers import AutoTokenizer, AutoModelForCausalLM >>> model = AutoModelForCausalLM.from_pretrained("openai-community/gpt2") >>> tokenizer = AutoTokenizer.from_pretrained("openai-community/gpt2") >>> inputs = tokenizer(["Today, a dragon flew over Paris, France,"], return_tensors="pt") >>> out = model.generate(inputs["input_ids"], guidance_scale=1.5) >>> tokenizer.batch_decode(out, skip_special_tokens=True)[0] 'Today, a dragon flew over Paris, France, killing at least 50 people and injuring more than 100' >>> # with a negative prompt >>> neg_inputs = tokenizer(["A very happy event happened,"], return_tensors="pt") >>> out = model.generate(inputs["input_ids"], guidance_scale=2, negative_prompt_ids=neg_inputs["input_ids"]) >>> tokenizer.batch_decode(out, skip_special_tokens=True)[0] 'Today, a dragon flew over Paris, France, killing at least 130 people. French media reported that' >>> # with a positive prompt >>> neg_inputs = tokenizer(["A very happy event happened,"], return_tensors="pt") >>> out = model.generate(inputs["input_ids"], guidance_scale=0, negative_prompt_ids=neg_inputs["input_ids"]) >>> tokenizer.batch_decode(out, skip_special_tokens=True)[0] "Today, a dragon flew over Paris, France, and I'm very happy to be here. I" ``` #### __call__[[transformers.UnbatchedClassifierFreeGuidanceLogitsProcessor.__call__]] ```python __call__(input_ids, scores) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L2373) #### transformers.WhisperTimeStampLogitsProcessor[[transformers.WhisperTimeStampLogitsProcessor]] ```python transformers.WhisperTimeStampLogitsProcessor(generate_config: GenerationConfig, begin_index: int, _detect_timestamp_from_logprob: bool | None = None) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L1944) **Tham số:** generate_config (`GenerateConfig`) : Cấu hình generate được sử dụng để tạo ra đầu ra. Các tham số sau là bắt buộc: eos_token_id (`int`, *tuỳ chọn*, mặc định là 50257): id của token *kết thúc chuỗi*. no_timestamps_token_id (`int`, *tuỳ chọn*, mặc định là 50363): id của token `"<|notimestamps|>"`. max_initial_timestamp_index (`int`, *tuỳ chọn*, mặc định là 1): Được sử dụng để đặt giá trị tối đa của timestamp ban đầu. Điều này được dùng để ngăn mô hình dự đoán các timestamp quá xa trong tương lai. begin_index (`int`) : Chỉ số token của token đầu tiên được mô hình tạo ra. _detect_timestamp_from_logprob (`bool`, *tùy chọn*) : Cho biết có thể dự đoán các mốc thời gian từ logprobs trên tất cả các mốc thời gian hay không. [LogitsProcessor](/docs/transformers/main/vi/internal/generation_utils#transformers.LogitsProcessor) điều chỉnh logits cho việc tạo ra các mốc thời gian trong bản chuyển tự. Khi các token đầu vào đạt đến một ngưỡng cụ thể, bộ xử lý sẽ đặt điểm của chúng thành âm vô cùng. Bộ xử lý đảm bảo rằng các token mốc thời gian xuất hiện theo từng cặp, bằng cách che đi các logits có thể phá vỡ mẫu ghép cặp này. Việc này được thực hiện để duy trì tính nhất quán và cấu trúc của các mốc thời gian được tạo ra. Nó cũng đảm bảo rằng khi xác suất dự đoán để lấy mẫu bất kỳ token mốc thời gian nào lớn hơn bất kỳ token không phải mốc thời gian nào, các logits không phải mốc thời gian đó sẽ được đặt thành âm vô cùng. Việc này được thực hiện để đảm bảo việc tạo ra các mốc thời gian thay vì các token tiềm năng khác. Xem [bài báo](https://huggingface.co/papers/2212.04356) để biết thêm thông tin. Ví dụ: ``` python >>> import torch >>> from transformers import AutoProcessor, WhisperForConditionalGeneration, GenerationConfig >>> from datasets import load_dataset >>> processor = AutoProcessor.from_pretrained("openai/whisper-tiny.en") >>> model = WhisperForConditionalGeneration.from_pretrained("openai/whisper-tiny.en") >>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation") >>> inputs = processor(ds[3]["audio"]["array"], return_tensors="pt") >>> input_features = inputs.input_features >>> #Displaying timestamps >>> generated_ids = model.generate(inputs=input_features, return_timestamps=True) >>> transcription = processor.batch_decode(generated_ids, decode_with_timestamps=True)[0] >>> print("Transcription:", transcription) Transcription: <|startoftranscript|><|0.00|> He has grave doubts whether Sir Frederick Layton's work is really Greek after all, and can<|6.44|><|6.44|> discover in it but little of rocky Ithaca.<|9.44|><|endoftext|> >>> #No timestamps & change EOS: >>> #This allows the user to select a specific token to terminate the sequence on, in this case it's the word "can"(460) >>> model.generation_config.eos_token_id = 460 >>> generated_ids = model.generate(inputs=input_features,return_timestamps=False) >>> transcription = processor.batch_decode(generated_ids, skip_special_tokens=True)[0] >>> print("Transcription:", transcription) Transcription: He has grave doubts whether Sir Frederick Layton's work is really Greek after all and can ``` #### __call__[[transformers.WhisperTimeStampLogitsProcessor.__call__]] ```python __call__(input_ids: LongTensor, scores: Tensor) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L2034) **Tham số:** input_ids (`torch.LongTensor` có hình dạng `(batch_size, sequence_length)`) : Chỉ số của các token trong chuỗi đầu vào theo từ vựng. [Input IDs là gì?](../glossary#input-ids) scores (`torch.Tensor` có hình dạng `(batch_size, config.vocab_size)`) : Điểm dự đoán của đầu mô hình hóa ngôn ngữ. Đây có thể là logits cho từng từ vựng khi không sử dụng beam search hoặc log softmax cho từng token từ vựng khi sử dụng beam search **Trả về:** `torch.Tensor` có hình dạng `(batch_size, config.vocab_size)` Điểm dự đoán đã được xử lý. #### transformers.WatermarkLogitsProcessor[[transformers.WatermarkLogitsProcessor]] ```python transformers.WatermarkLogitsProcessor(vocab_size, device, greenlist_ratio: float = 0.25, bias: float = 2.0, hashing_key: int = 15485863, seeding_scheme: str = 'lefthash', context_width: int = 1) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L2432) **Tham số:** vocab_size (`int`) : vocab_size của model tokenizer. Được dùng để tính tỷ lệ token "xanh". device (`str`) : Thiết bị nơi mô hình được cấp phát. greenlist_ratio (`float`, tùy chọn, *tùy chọn*, mặc định là 0.25) : Tỷ lệ giữa số lượng token "xanh" được sử dụng và kích thước từ vựng. Mặc định là 0.25. bias (`float`, tùy chọn, *optional*, mặc định là 2.0) : Độ chệch được cộng vào logits của các token "xanh" được chọn. Hãy cân nhắc giảm `bias` nếu chất lượng tạo văn bản bị suy giảm. Các giá trị được khuyến nghị nằm trong khoảng [0.5, 2.0]. Mặc định là 2.0. hashing_key (`int`, tùy chọn, *optional*, mặc định là 15485863) : Khóa được sử dụng để băm. Nếu bạn triển khai watermark này, chúng tôi khuyên bạn nên sử dụng một khóa riêng tư khác. Mặc định là 15485863 (số nguyên tố thứ một triệu). seeding_scheme (`str`, tùy chọn, *optional*, mặc định là `"lefthash"`) : Phương án gieo hạt (seeding scheme) được sử dụng để chọn các token "green". Chấp nhận các giá trị: - "lefthash" (mặc định): việc chọn token "green" phụ thuộc vào token cuối cùng (Thuật toán 2 trong bài báo) - "selfhash": việc chọn token "green" phụ thuộc vào chính token hiện tại (Thuật toán 3 trong bài báo) Nhược điểm của phương án này là nó xem xét tất cả các token tiếp theo có thể và có thể chậm hơn so với "lefthash". Độ dài ngữ cảnh của các token trước đó được sử dụng trong quá trình gieo hạt. Độ dài ngữ cảnh cao hơn làm cho việc đánh dấu (watermarking) trở nên bền vững hơn. context_width (`int`, *tuỳ chọn*, mặc định là 1) : Số lượng token trước đó được sử dụng khi đặt seed. Logits processor để thêm watermark cho văn bản được tạo ra. Bộ xử lý này thay đổi điểm số đầu ra của mô hình bằng cách thêm một độ lệch nhỏ vào một tập hợp ngẫu nhiên các token "xanh" trước khi tạo token tiếp theo. Quá trình chọn token "xanh" phụ thuộc vào `seeding_scheme` được sử dụng. Mã nguồn được dựa trên [repo gốc](https://github.com/jwkirchenbauer/lm-watermarking/tree/main). Văn bản do `LogitsProcessor` này tạo ra có thể được phát hiện bằng `WatermarkDetector`. Xem [__call__()](/docs/transformers/main/vi/internal/generation_utils#transformers.WatermarkDetector.__call__) để biết thêm chi tiết, Xem [bài báo](https://huggingface.co/papers/2306.04634) để biết thêm thông tin. Ví dụ: ```python >>> from transformers import AutoTokenizer, AutoModelForCausalLM, WatermarkingConfig >>> model = AutoModelForCausalLM.from_pretrained("openai-community/gpt2") >>> tokenizer = AutoTokenizer.from_pretrained("openai-community/gpt2") >>> inputs = tokenizer(["Alice and Bob are"], return_tensors="pt") >>> # normal generation >>> out = model.generate(inputs["input_ids"], max_length=20, do_sample=False) >>> tokenizer.batch_decode(out, skip_special_tokens=True)[0] 'Alice and Bob are both in the same room.\n\n"I\'m not sure if you\'re' >>> # watermarked generation >>> watermarking_config = WatermarkingConfig(bias=2.5, context_width=2, seeding_scheme="selfhash") >>> out = model.generate(inputs["input_ids"], watermarking_config=watermarking_config, max_length=20, do_sample=False) >>> tokenizer.batch_decode(out, skip_special_tokens=True)[0] 'Alice and Bob are both still alive and well and the story is pretty much a one-hour adventure' >>> # to detect watermarked text use the WatermarkDetector class >>> from transformers import WatermarkDetector >>> detector = WatermarkDetector(model_config=model.config, device="cpu", watermarking_config= watermarking_config) >>> detection_preds = detector(out) >>> detection_preds array([ True]) ``` #### __call__[[transformers.WatermarkLogitsProcessor.__call__]] ```python __call__(input_ids: LongTensor, scores: Tensor) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L2554) **Tham số:** input_ids (`torch.LongTensor` có hình dạng `(batch_size, sequence_length)`) : Chỉ số của các token trong chuỗi đầu vào theo từ vựng. [Input IDs là gì?](../glossary#input-ids) scores (`torch.Tensor` có hình dạng `(batch_size, config.vocab_size)`) : Điểm dự đoán của đầu mô hình hóa ngôn ngữ. Đây có thể là logits cho từng từ vựng khi không sử dụng beam search hoặc log softmax cho từng token từ vựng khi sử dụng beam search **Trả về:** `torch.Tensor` có hình dạng `(batch_size, config.vocab_size)` Điểm dự đoán đã được xử lý. ## StoppingCriteria[[transformers.StoppingCriteria]] [StoppingCriteria](/docs/transformers/main/vi/internal/generation_utils#transformers.StoppingCriteria) có thể được sử dụng để thay đổi thời điểm dừng tạo (ngoài token EOS). Lưu ý rằng tính năng này chỉ có sẵn trong các triển khai PyTorch của chúng tôi. #### transformers.StoppingCriteria[[transformers.StoppingCriteria]] ```python transformers.StoppingCriteria() ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/stopping_criteria.py#L48) Lớp trừu tượng cơ sở cho tất cả các tiêu chí dừng có thể được áp dụng trong quá trình tạo. Nếu tiêu chí dừng của bạn phụ thuộc vào đầu vào `scores`, hãy đảm bảo bạn truyền `return_dict_in_generate=True, output_scores=True` vào `generate`. #### __call__[[transformers.StoppingCriteria.__call__]] ```python __call__(input_ids: LongTensor, scores: tuple[torch.Tensor] | None, **kwargs) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/stopping_criteria.py#L55) **Tham số:** input_ids (`torch.LongTensor` có hình dạng `(batch_size, sequence_length)`) : Chỉ số của các token trong chuỗi đầu vào trong từ vựng. Các chỉ số này có thể được lấy bằng cách sử dụng [AutoTokenizer](/docs/transformers/main/vi/model_doc/auto#transformers.AutoTokenizer). Xem [PreTrainedTokenizer.encode()](/docs/transformers/main/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) và [PreTrainedTokenizer.__call__()](/docs/transformers/main/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) để biết thêm chi tiết. [Input IDs là gì?](../glossary#input-ids) scores (`tuple(torch.Tensor)`) : Điểm dự đoán của đầu mô hình ngôn ngữ, dưới dạng tuple với một tensor cho mỗi bước sinh, mỗi tensor có hình dạng `(batch_size, config.vocab_size)`. Đây có thể là điểm cho từng token trong bảng từ vựng trước SoftMax hoặc điểm cho từng token trong bảng từ vựng sau SoftMax. Nếu tiêu chí dừng này phụ thuộc vào đầu vào `scores`, hãy đảm bảo bạn truyền `return_dict_in_generate=True, output_scores=True` cho `generate`, nếu không `None` sẽ được truyền. kwargs (`dict[str, Any]`, *tùy chọn*) : Các kwargs tiêu chí dừng bổ sung. **Trả về:** `torch.BoolTensor`. (`torch.BoolTensor` có hình dạng `(batch_size, 1)`) `True` cho biết chúng ta dừng sinh cho một hàng cụ thể. `False` cho biết chúng ta nên tiếp tục. #### transformers.StoppingCriteriaList[[transformers.StoppingCriteriaList]] ```python transformers.StoppingCriteriaList(iterable = ()) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/stopping_criteria.py#L610) #### __call__[[transformers.StoppingCriteriaList.__call__]] ```python __call__(input_ids: LongTensor, scores: tuple[torch.Tensor] | None, **kwargs) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/stopping_criteria.py#L611) **Tham số:** input_ids (`torch.LongTensor` có hình dạng `(batch_size, sequence_length)`) : Chỉ số của các token trong chuỗi đầu vào trong từ vựng. Các chỉ số này có thể được lấy bằng cách sử dụng [AutoTokenizer](/docs/transformers/main/vi/model_doc/auto#transformers.AutoTokenizer). Xem [PreTrainedTokenizer.encode()](/docs/transformers/main/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) và [PreTrainedTokenizer.__call__()](/docs/transformers/main/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) để biết thêm chi tiết. [Input IDs là gì?](../glossary#input-ids) scores (`tuple(torch.Tensor)`) : Điểm dự đoán của đầu mô hình ngôn ngữ, dưới dạng tuple với một tensor cho mỗi bước sinh, mỗi tensor có hình dạng `(batch_size, config.vocab_size)`. Đây có thể là điểm cho từng token trong bảng từ vựng trước SoftMax hoặc điểm cho từng token trong bảng từ vựng sau SoftMax. Nếu tiêu chí dừng này phụ thuộc vào đầu vào `scores`, hãy đảm bảo bạn truyền `return_dict_in_generate=True, output_scores=True` cho `generate`, nếu không `None` sẽ được truyền. kwargs (`dict[str, Any]`, *tùy chọn*) : Các kwargs tiêu chí dừng bổ sung. **Trả về:** `torch.BoolTensor`. (`torch.BoolTensor` có hình dạng `(batch_size, 1)`) `True` cho biết chúng ta dừng sinh cho một hàng cụ thể. `False` cho biết chúng ta nên tiếp tục. #### transformers.MaxLengthCriteria[[transformers.MaxLengthCriteria]] ```python transformers.MaxLengthCriteria(max_length: int, max_position_embeddings: int | None = None) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/stopping_criteria.py#L60) **Tham số:** max_length (`int`) : Độ dài tối đa mà chuỗi đầu ra có thể có, tính bằng số token. max_position_embeddings (`int`, *tuỳ chọn*) : Độ dài tối đa của mô hình, được xác định bởi thuộc tính `config.max_position_embeddings` của mô hình. Lớp này có thể được sử dụng để dừng quá trình sinh khi tổng số token đã sinh vượt quá `max_length`. Lưu ý rằng đối với các transformer chỉ có decoder, con số này sẽ bao gồm cả các token được đưa vào ban đầu. #### __call__[[transformers.MaxLengthCriteria.__call__]] ```python __call__(input_ids: LongTensor, scores: tuple[torch.Tensor] | None, **kwargs) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/stopping_criteria.py#L76) **Tham số:** input_ids (`torch.LongTensor` có hình dạng `(batch_size, sequence_length)`) : Chỉ số của các token trong chuỗi đầu vào trong từ vựng. Các chỉ số này có thể được lấy bằng cách sử dụng [AutoTokenizer](/docs/transformers/main/vi/model_doc/auto#transformers.AutoTokenizer). Xem [PreTrainedTokenizer.encode()](/docs/transformers/main/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) và [PreTrainedTokenizer.__call__()](/docs/transformers/main/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) để biết thêm chi tiết. [Input IDs là gì?](../glossary#input-ids) scores (`tuple(torch.Tensor)`) : Điểm dự đoán của đầu mô hình ngôn ngữ, dưới dạng tuple với một tensor cho mỗi bước sinh, mỗi tensor có hình dạng `(batch_size, config.vocab_size)`. Đây có thể là điểm cho từng token trong bảng từ vựng trước SoftMax hoặc điểm cho từng token trong bảng từ vựng sau SoftMax. Nếu tiêu chí dừng này phụ thuộc vào đầu vào `scores`, hãy đảm bảo bạn truyền `return_dict_in_generate=True, output_scores=True` cho `generate`, nếu không `None` sẽ được truyền. kwargs (`dict[str, Any]`, *tùy chọn*) : Các kwargs tiêu chí dừng bổ sung. **Trả về:** `torch.BoolTensor`. (`torch.BoolTensor` có hình dạng `(batch_size, 1)`) `True` cho biết chúng ta dừng sinh cho một hàng cụ thể. `False` cho biết chúng ta nên tiếp tục. #### transformers.MaxTimeCriteria[[transformers.MaxTimeCriteria]] ```python transformers.MaxTimeCriteria(max_time: float, initial_timestamp: float | None = None) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/stopping_criteria.py#L89) **Tham số:** max_time (`float`) : Thời gian tối đa cho phép (tính bằng giây) cho quá trình sinh. initial_timestamp (`float`, *tuỳ chọn*, mặc định là `time.time()`) : Thời điểm bắt đầu của khoảng thời gian cho phép sinh. Lớp này có thể được sử dụng để dừng quá trình sinh khi toàn bộ quá trình sinh vượt quá một khoảng thời gian nhất định. Mặc định, thời gian sẽ bắt đầu được tính khi bạn khởi tạo hàm này. Bạn có thể ghi đè điều này bằng cách truyền vào `initial_timestamp`. #### __call__[[transformers.MaxTimeCriteria.__call__]] ```python __call__(input_ids: LongTensor, scores: tuple[torch.Tensor] | None, **kwargs) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/stopping_criteria.py#L106) **Tham số:** input_ids (`torch.LongTensor` có hình dạng `(batch_size, sequence_length)`) : Chỉ số của các token trong chuỗi đầu vào trong từ vựng. Các chỉ số này có thể được lấy bằng cách sử dụng [AutoTokenizer](/docs/transformers/main/vi/model_doc/auto#transformers.AutoTokenizer). Xem [PreTrainedTokenizer.encode()](/docs/transformers/main/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) và [PreTrainedTokenizer.__call__()](/docs/transformers/main/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) để biết thêm chi tiết. [Input IDs là gì?](../glossary#input-ids) scores (`tuple(torch.Tensor)`) : Điểm dự đoán của đầu mô hình ngôn ngữ, dưới dạng tuple với một tensor cho mỗi bước sinh, mỗi tensor có hình dạng `(batch_size, config.vocab_size)`. Đây có thể là điểm cho từng token trong bảng từ vựng trước SoftMax hoặc điểm cho từng token trong bảng từ vựng sau SoftMax. Nếu tiêu chí dừng này phụ thuộc vào đầu vào `scores`, hãy đảm bảo bạn truyền `return_dict_in_generate=True, output_scores=True` cho `generate`, nếu không `None` sẽ được truyền. kwargs (`dict[str, Any]`, *tùy chọn*) : Các kwargs tiêu chí dừng bổ sung. **Trả về:** `torch.BoolTensor`. (`torch.BoolTensor` có hình dạng `(batch_size, 1)`) `True` cho biết chúng ta dừng sinh cho một hàng cụ thể. `False` cho biết chúng ta nên tiếp tục. #### transformers.StopStringCriteria[[transformers.StopStringCriteria]] ```python transformers.StopStringCriteria(tokenizer: PreTrainedTokenizerBase, stop_strings: str | list[str]) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/stopping_criteria.py#L112) **Tham số:** tokenizer (`PreTrainedTokenizer`) : tokenizer liên quan của mô hình (cần thiết để trích xuất bảng từ vựng và mã hóa các chuỗi kết thúc) stop_strings (`Union[str, list[str]]`) : Một danh sách các chuỗi nên kết thúc quá trình sinh. Nếu một chuỗi được truyền vào, nó sẽ được xử lý như một danh sách có một phần tử duy nhất. Lớp này có thể được sử dụng để dừng quá trình sinh ra bất cứ khi nào các chuỗi ký tự cụ thể được tạo ra. Nó tiền xử lý các chuỗi ký tự cùng với bảng từ vựng của tokenizer để tìm các vị trí mà các token có thể hoàn thành hợp lệ các chuỗi dừng. Quá trình sinh sẽ dừng ngay khi một token được sinh ra hoàn thành bất kỳ chuỗi dừng nào. Chúng ta muốn bắt mọi trường hợp mà chuỗi dừng có mặt trong đầu ra đã giải mã, điều này có nghĩa là chúng ta cũng phải bắt các trường hợp có phần "lồi ra" ở một hoặc cả hai đầu. Để cụ thể hơn, đối với chuỗi dừng "stop", bất kỳ chuỗi token nào sau đây đều sẽ kích hoạt sự khớp: - ["st", "op"] - ["stop"] - ["st", "opera"] - ["sto", "pper"] - ["las", "topper"] - ["s", "to", "pped"] Lưu ý rằng một sự khớp chỉ được kích hoạt nếu chuỗi dừng nằm ở cuối chuỗi được tạo ra. Nói cách khác, các chuỗi sau sẽ không kích hoạt sự khớp: - ["dừng", "tại"] - ["st", "op", "at"] - ["st", "opera", "tion"] Lý do các chuỗi này không khớp là vì chuỗi dừng không chồng lấn với token cuối cùng. Nếu bạn có thể xóa một hoặc nhiều token từ cuối chuỗi mà không làm hỏng chuỗi dừng, thì tiêu chí này sẽ không khớp với chuỗi dừng đó. Đây là thiết kế có chủ đích; vì kiểm tra này được thực hiện sau khi mỗi token được tạo ra, chúng ta sẽ không bỏ sót một chuỗi dừng hợp lệ nếu nó được tạo ra, nhưng chúng ta không muốn dừng quá trình tạo chỉ vì chuỗi dừng tồn tại ở đâu đó trong input_ids quá khứ. Vậy quá trình khớp thực sự được thực hiện như thế nào? Chúng ta thực hiện theo một cách khá gây nhầm lẫn, vì chúng ta muốn toàn bộ quy trình khớp có thể biên dịch được với Torch hoặc XLA, điều này có nghĩa là chúng ta không thể sử dụng các phương thức chuỗi chuẩn. Tuy nhiên, với một số công sức, việc khớp chuỗi bằng các phép toán tensor thuần túy là hoàn toàn khả thi. Chúng ta sẽ bắt đầu bằng cách mô tả thuật toán mà chúng ta sử dụng với các phép toán chuỗi chuẩn, và sau đó ở cuối bài viết, chúng ta sẽ giải thích cách chuyển đổi điều này sang các phép toán tensor thuần túy. Chìa khóa của thuật toán là một quan sát: Vì chuỗi dừng phải chồng lấp với phần cuối của chuỗi token, chúng ta có thể bắt đầu từ cuối chuỗi và làm việc ngược lại. Cụ thể, chúng ta kiểm tra xem có sự chồng lấp giữa phần đầu của token cuối cùng và phần cuối của stop_string hay không, hay nói cách khác, stop_string[-i:] == token[:i] với một số i > 0. Nếu bạn xem các ví dụ dương ở trên, bạn sẽ thấy token cuối cùng trong tất cả chúng đều thỏa mãn tính chất này: - ["st", "op"] (phần chồng lên là "op", độ dài phần chồng lên == 2) - ["stop"] (trùng lặp là "stop", độ dài trùng lặp == 4) - ["st", "opera"] (phần chồng lên là "op", độ dài phần chồng lên == 2) - ["sto", "pper"] (phần trùng lặp là "p", độ dài phần trùng lặp == 1) - ["las", "topper"] (phần chồng lên là "top", độ dài phần chồng lên == 3) - ["s", "to", "pped"] (phần chồng lên là "p", độ dài phần chồng lên == 1) Việc xây dựng một chuỗi khớp không có tính chất này là bất khả thi (bạn có thể tự kiểm chứng điều này). Tuy nhiên, mặc dù sự chồng lấn giữa phần đầu của token cuối cùng và phần cuối của chuỗi dừng là cần thiết để có một sự khớp, nhưng nó không đủ. Chúng ta cũng cần kiểm tra xem phần còn lại của chuỗi token có nhất quán với chuỗi dừng hay không. Chúng ta thực hiện điều đó như thế nào? Hãy lấy ["s", "to", "pped"] làm ví dụ. Chúng ta biết rằng token cuối cùng, "pped", có phần trùng lặp là 1 với chuỗi dừng, "stop". Sau đó, chúng ta quay lại token trước đó, "to". Vì chúng ta đã khớp được 1 ký tự từ chuỗi dừng, phần còn lại cần kiểm tra là "sto". Chúng ta kiểm tra xem token tiếp theo "to" có khớp với phần cuối của phần còn lại hay không, và nó có khớp. Bây giờ chúng ta đã khớp được 3 ký tự từ chuỗi dừng, và phần còn lại cần khớp là "s". Chúng ta quay lại token trước đó một lần nữa, cũng là "s". Đây là một sự khớp, và do đó chúng ta đã khớp toàn bộ chuỗi dừng. Vậy thì khi các token vượt ra khỏi phần đầu của chuỗi dừng, quá trình hoạt động như thế nào? Hãy xem xét ví dụ ["las", "topper"]. Token cuối cùng, "topper", có phần chồng lấn 3 ký tự với chuỗi dừng, "stop". Do đó, phần còn lại của chuỗi dừng cần khớp là "s". Chúng ta quay lại token trước đó, "las". Vì phần còn lại cần khớp chỉ là "s", có độ dài 1, nên chúng ta chỉ xem xét 1 ký tự cuối cùng của token, tức là "s". Điều này khớp với chuỗi dừng, và do đó toàn bộ chuỗi được khớp. Vậy làm thế nào để tính toán các khớp này bằng các thao tác tensor? Rất đơn giản: chúng ta tiền xử lý hiệu quả thông tin cần thiết cho tất cả các token! Với mỗi token, chúng ta tính toán: - Phần chồng lấn với cuối chuỗi dừng, nếu có - Các vị trí bên trong chuỗi dừng mà tại đó token khớp, bao gồm cả các lần khớp vượt ra ngoài phần đầu. - Tổng độ dài của token Ví dụ, với token "pped", chúng ta sẽ tính được độ chồng lấp cuối là 1, không có vị trí khớp nội bộ nào, và độ dài là 4. Với token "to", chúng ta sẽ tính được không có độ chồng lấp cuối, một vị trí khớp nội bộ duy nhất là 1 (đếm từ cuối), và độ dài là 2. Với token "s", chúng ta sẽ tính được không có độ chồng lấp cuối, một vị trí khớp nội bộ duy nhất là 3 (lại đếm từ cuối) và độ dài là 1. Miễn là chúng ta có thông tin này, chúng ta có thể thực thi thuật toán ở trên mà không cần bất kỳ thao tác so sánh chuỗi nào. Chúng ta chỉ cần thực hiện các bước sau: - Kiểm tra xem token cuối cùng có trùng lặp cuối với chuỗi bắt đầu không - Tiếp tục quay ngược, theo dõi xem chúng ta đã khớp được bao nhiêu phần của chuỗi dừng cho đến nay - Tại mỗi điểm, kiểm tra xem token tiếp theo có vị trí hiện tại là một trong các vị trí hợp lệ của nó hay không - Tiếp tục cho đến khi một phần khớp thất bại, hoặc chúng ta khớp hoàn toàn toàn bộ chuỗi dừng Một lần nữa, hãy xem ["s", "to", "pped"] làm ví dụ. "pped" có độ chồng cuối là 1, nên chúng ta có thể bắt đầu khớp. Chúng ta đã khớp được 1 ký tự cho đến nay, nên chúng ta kiểm tra xem token tiếp theo "to" có 1 là một vị trí hợp lệ không (lại tính từ cuối). Có, nên chúng ta thêm độ dài của "to" vào bộ theo dõi vị trí. Chúng ta đã khớp được 3 ký tự, nên chúng ta kiểm tra xem token tiếp theo "s" có 3 là một vị trí hợp lệ không. Có, nên chúng ta thêm độ dài của nó vào bộ theo dõi vị trí. Bộ theo dõi vị trí bây giờ là 4, tức là độ dài của chuỗi dừng. Chúng ta đã khớp toàn bộ chuỗi dừng. Trong trường hợp thứ hai, ["las", "topper"], "topper" có độ chồng lấp cuối là 3, vì vậy chúng ta có thể bắt đầu khớp. Chúng ta đã khớp 3 ký tự cho đến nay, nên chúng ta kiểm tra xem token tiếp theo "las" có 3 là một vị trí hợp lệ hay không. Có, vì chúng ta cho phép các token khớp với các vị trí vượt ra ngoài phần đầu của chuỗi dừng. Chúng ta thêm độ dài của nó vào bộ theo dõi vị trí. Bộ theo dõi vị trí bây giờ là 6, lớn hơn độ dài của chuỗi dừng! Tuy nhiên, đừng hoảng sợ - điều này cũng được tính là một lần khớp với chuỗi dừng. Chúng ta đã khớp toàn bộ chuỗi dừng. Ví dụ: ```python >>> from transformers import AutoModelForCausalLM, AutoTokenizer >>> tokenizer = AutoTokenizer.from_pretrained("microsoft/phi-2") >>> model = AutoModelForCausalLM.from_pretrained("microsoft/phi-2") >>> inputs = tokenizer("The biggest states in the USA by land area:", return_tensors="pt") >>> gen_out = model.generate(**inputs) >>> print(tokenizer.batch_decode(gen_out, skip_special_tokens=True)[0]) The biggest states in the USA by land area: - Alaska - Texas - California >>> # Passing one or more stop strings will halt generation after those strings are emitted >>> # Note that generating with stop strings requires you to pass the tokenizer too >>> gen_out = model.generate(**inputs, stop_strings=["Texas"], tokenizer=tokenizer) >>> print(tokenizer.batch_decode(gen_out, skip_special_tokens=True)[0]) The biggest states in the USA by land area: - Alaska - Texas ``` #### __call__[[transformers.StopStringCriteria.__call__]] ```python __call__(input_ids: LongTensor, scores: tuple[torch.Tensor] | None, **kwargs) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/stopping_criteria.py#L475) **Tham số:** input_ids (`torch.LongTensor` có hình dạng `(batch_size, sequence_length)`) : Chỉ số của các token trong chuỗi đầu vào trong từ vựng. Các chỉ số này có thể được lấy bằng cách sử dụng [AutoTokenizer](/docs/transformers/main/vi/model_doc/auto#transformers.AutoTokenizer). Xem [PreTrainedTokenizer.encode()](/docs/transformers/main/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) và [PreTrainedTokenizer.__call__()](/docs/transformers/main/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) để biết thêm chi tiết. [Input IDs là gì?](../glossary#input-ids) scores (`tuple(torch.Tensor)`) : Điểm dự đoán của đầu mô hình ngôn ngữ, dưới dạng tuple với một tensor cho mỗi bước sinh, mỗi tensor có hình dạng `(batch_size, config.vocab_size)`. Đây có thể là điểm cho từng token trong bảng từ vựng trước SoftMax hoặc điểm cho từng token trong bảng từ vựng sau SoftMax. Nếu tiêu chí dừng này phụ thuộc vào đầu vào `scores`, hãy đảm bảo bạn truyền `return_dict_in_generate=True, output_scores=True` cho `generate`, nếu không `None` sẽ được truyền. kwargs (`dict[str, Any]`, *tùy chọn*) : Các kwargs tiêu chí dừng bổ sung. **Trả về:** `torch.BoolTensor`. (`torch.BoolTensor` có hình dạng `(batch_size, 1)`) `True` cho biết chúng ta dừng sinh cho một hàng cụ thể. `False` cho biết chúng ta nên tiếp tục. #### transformers.EosTokenCriteria[[transformers.EosTokenCriteria]] ```python transformers.EosTokenCriteria(eos_token_id: typing.Union[int, list[int], torch.Tensor]) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/stopping_criteria.py#L537) **Tham số:** eos_token_id (`Union[int, list[int], torch.Tensor]`) : id của token *end-of-sequence*. Lớp này có thể được sử dụng để dừng quá trình sinh khi token "end-of-sequence" được tạo ra. Mặc định, nó sử dụng `model.generation_config.eos_token_id`. #### __call__[[transformers.EosTokenCriteria.__call__]] ```python __call__(input_ids: LongTensor, scores: tuple[torch.Tensor] | None, new_token_length: int = 1, **kwargs) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/stopping_criteria.py#L554) **Tham số:** input_ids (`torch.LongTensor` có hình dạng `(batch_size, sequence_length)`) : Chỉ số của các token trong chuỗi đầu vào trong từ vựng. Các chỉ số này có thể được lấy bằng cách sử dụng [AutoTokenizer](/docs/transformers/main/vi/model_doc/auto#transformers.AutoTokenizer). Xem [PreTrainedTokenizer.encode()](/docs/transformers/main/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) và [PreTrainedTokenizer.__call__()](/docs/transformers/main/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) để biết thêm chi tiết. [Input IDs là gì?](../glossary#input-ids) scores (`tuple(torch.Tensor)`) : Điểm dự đoán của đầu mô hình ngôn ngữ, dưới dạng tuple với một tensor cho mỗi bước sinh, mỗi tensor có hình dạng `(batch_size, config.vocab_size)`. Đây có thể là điểm cho từng token trong bảng từ vựng trước SoftMax hoặc điểm cho từng token trong bảng từ vựng sau SoftMax. Nếu tiêu chí dừng này phụ thuộc vào đầu vào `scores`, hãy đảm bảo bạn truyền `return_dict_in_generate=True, output_scores=True` cho `generate`, nếu không `None` sẽ được truyền. new_token_length (`int`, *optional*, mặc định là `1`) : Số lượng token sẽ được kiểm tra cho các tiêu chí. `new_token_length` token mới nhất trên mỗi mục trong batch sẽ được kiểm tra. kwargs (`dict[str, Any]`, *tùy chọn*) : Các kwargs tiêu chí dừng bổ sung. **Trả về:** `torch.BoolTensor`. (`torch.BoolTensor` có hình dạng `(batch_size, 1)`) `True` cho biết chúng ta dừng sinh cho một hàng cụ thể. `False` cho biết chúng ta nên tiếp tục. ## Streamers[[transformers.TextStreamer]] #### transformers.TextStreamer[[transformers.TextStreamer]] ```python transformers.TextStreamer(tokenizer: PreTrainedTokenizerBase, skip_prompt: bool = False, **decode_kwargs: Any) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/streamers.py#L41) **Tham số:** tokenizer (`AutoTokenizer`) : Bộ phân từ được sử dụng để giải mã các token. skip_prompt (`bool`, *tùy chọn*, mặc định là `False`) : Có bỏ qua lời nhắc để `.generate()` hay không. Hữu ích, ví dụ, cho các chatbot. decode_kwargs (`dict`, *tùy chọn*) : Các đối số từ khóa bổ sung để truyền cho phương thức `decode` của tokenizer. Trình phát trực tiếp văn bản đơn giản, in các token ra stdout ngay khi các từ hoàn chỉnh được hình thành. Ví dụ: ```python >>> from transformers import AutoModelForCausalLM, AutoTokenizer, TextStreamer >>> tok = AutoTokenizer.from_pretrained("openai-community/gpt2") >>> model = AutoModelForCausalLM.from_pretrained("openai-community/gpt2") >>> inputs = tok(["An increasing sequence: one,"], return_tensors="pt") >>> streamer = TextStreamer(tok) >>> # Despite returning the usual output, the streamer will also print the generated text to stdout. >>> _ = model.generate(**inputs, streamer=streamer, max_new_tokens=20) An increasing sequence: one, two, three, four, five, six, seven, eight, nine, ten, eleven, ``` #### end[[transformers.TextStreamer.end]] ```python end() ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/streamers.py#L113) Xóa mọi bộ nhớ đệm còn lại và in một ký tự xuống dòng ra stdout. #### on_finalized_text[[transformers.TextStreamer.on_finalized_text]] ```python on_finalized_text(text: str, stream_end: bool = False) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/streamers.py#L127) In ra văn bản mới ra stdout. Nếu luồng đang kết thúc, cũng in xuống dòng mới. #### put[[transformers.TextStreamer.put]] ```python put(value) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/streamers.py#L79) Nhận các token, giải mã chúng và in ra stdout ngay khi chúng tạo thành các từ hoàn chỉnh. #### transformers.TextIteratorStreamer[[transformers.TextIteratorStreamer]] ```python transformers.TextIteratorStreamer(tokenizer: PreTrainedTokenizerBase, skip_prompt: bool = False, timeout: float | None = None, **decode_kwargs: Any) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/streamers.py#L156) **Tham số:** tokenizer (`AutoTokenizer`) : Bộ phân từ được sử dụng để giải mã các token. skip_prompt (`bool`, *tùy chọn*, mặc định là `False`) : Có bỏ qua lời nhắc để `.generate()` hay không. Hữu ích, ví dụ, cho các chatbot. timeout (`float`, *optional*) : Thời gian chờ cho hàng đợi văn bản. Nếu là `None`, hàng đợi sẽ bị chặn vô thời hạn. Hữu ích để xử lý ngoại lệ trong `.generate()`, khi nó được gọi trong một luồng riêng biệt. decode_kwargs (`dict`, *tùy chọn*) : Các đối số từ khóa bổ sung để truyền cho phương thức `decode` của tokenizer. Streamer lưu trữ văn bản sẵn sàng để in vào hàng đợi, để ứng dụng phía dưới sử dụng như một iterator. Điều này hữu ích cho các ứng dụng được hưởng lợi từ việc truy cập văn bản được tạo ra theo cách không chặn (ví dụ: trong một demo Gradio tương tác). Ví dụ: ```python >>> from transformers import AutoModelForCausalLM, AutoTokenizer, TextIteratorStreamer >>> from threading import Thread >>> tok = AutoTokenizer.from_pretrained("openai-community/gpt2") >>> model = AutoModelForCausalLM.from_pretrained("openai-community/gpt2") >>> inputs = tok(["An increasing sequence: one,"], return_tensors="pt") >>> streamer = TextIteratorStreamer(tok) >>> # Run the generation in a separate thread, so that we can fetch the generated text in a non-blocking way. >>> generation_kwargs = dict(inputs, streamer=streamer, max_new_tokens=20) >>> thread = Thread(target=model.generate, kwargs=generation_kwargs) >>> thread.start() >>> generated_text = "" >>> for new_text in streamer: ... generated_text += new_text >>> generated_text 'An increasing sequence: one, two, three, four, five, six, seven, eight, nine, ten, eleven,' ``` #### on_finalized_text[[transformers.TextIteratorStreamer.on_finalized_text]] ```python on_finalized_text(text: str, stream_end: bool = False) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/streamers.py#L208) Đặt văn bản mới vào hàng đợi. Nếu luồng đang kết thúc, hãy đặt thêm tín hiệu dừng vào hàng đợi. #### transformers.AsyncTextIteratorStreamer[[transformers.AsyncTextIteratorStreamer]] ```python transformers.AsyncTextIteratorStreamer(tokenizer: PreTrainedTokenizerBase, skip_prompt: bool = False, timeout: float | None = None, **decode_kwargs: Any) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/streamers.py#L225) **Tham số:** tokenizer (`AutoTokenizer`) : Bộ phân từ được sử dụng để giải mã các token. skip_prompt (`bool`, *tùy chọn*, mặc định là `False`) : Có bỏ qua lời nhắc để `.generate()` hay không. Hữu ích, ví dụ, cho các chatbot. timeout (`float`, *optional*) : Thời gian chờ cho hàng đợi văn bản. Nếu là `None`, hàng đợi sẽ bị chặn vô thời hạn. Hữu ích để xử lý ngoại lệ trong `.generate()`, khi nó được gọi trong một luồng riêng biệt. decode_kwargs (`dict`, *tùy chọn*) : Các đối số từ khóa bổ sung để truyền cho phương thức `decode` của tokenizer. **Lỗi:** ``TimeoutError`` - ``TimeoutError`` -- Nếu thời gian tạo token vượt quá giá trị timeout. Streamer lưu trữ văn bản sẵn sàng in vào hàng đợi, để ứng dụng hạ nguồn sử dụng như một bộ lặp bất đồng bộ. Điều này hữu ích cho các ứng dụng được hưởng lợi từ việc truy cập văn bản được tạo ra một cách bất đồng bộ (ví dụ: trong một demo Gradio tương tác). Ví dụ: ```python >>> from transformers import AutoModelForCausalLM, AutoTokenizer, AsyncTextIteratorStreamer >>> from threading import Thread >>> import asyncio >>> tok = AutoTokenizer.from_pretrained("openai-community/gpt2") >>> model = AutoModelForCausalLM.from_pretrained("openai-community/gpt2") >>> inputs = tok(["An increasing sequence: one,"], return_tensors="pt") >>> # Run the generation in a separate thread, so that we can fetch the generated text in a non-blocking way. >>> async def main(): ... # Important: AsyncTextIteratorStreamer must be initialized inside a coroutine! ... streamer = AsyncTextIteratorStreamer(tok) ... generation_kwargs = dict(inputs, streamer=streamer, max_new_tokens=20) ... thread = Thread(target=model.generate, kwargs=generation_kwargs) ... thread.start() ... generated_text = "" ... async for new_text in streamer: ... generated_text += new_text >>> print(generated_text) >>> asyncio.run(main()) An increasing sequence: one, two, three, four, five, six, seven, eight, nine, ten, eleven, ``` #### on_finalized_text[[transformers.AsyncTextIteratorStreamer.on_finalized_text]] ```python on_finalized_text(text: str, stream_end: bool = False) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/streamers.py#L285) Đặt văn bản mới vào hàng đợi. Nếu luồng đang kết thúc, hãy đặt thêm tín hiệu dừng vào hàng đợi. #### transformers.TextDiffusionStreamer[[transformers.TextDiffusionStreamer]] ```python transformers.TextDiffusionStreamer(tokenizer: PreTrainedTokenizerBase, skip_prompt: bool = False, sleep_time: float | None = None, **decode_kwargs: Any) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/streamers.py#L303) **Tham số:** tokenizer (`AutoTokenizer`) : Tokenizer được sử dụng để giải mã các token. skip_prompt (`bool`, *tùy chọn*, mặc định là `False`) : Có bỏ qua lời nhắc để `.generate()` hay không. Hữu ích, ví dụ, cho các chatbot. sleep_time (`float`, *tuỳ chọn*) : Thời gian ngủ giữa các bản nháp khuếch tán, có thể hữu ích để trực quan hóa các đầu ra trung gian. decode_kwargs (`dict`, *tùy chọn*) : Các đối số từ khóa bổ sung để truyền cho phương thức `decode` của tokenizer. Streamer in ra kết quả khuếch tán văn bản. Các bước khuếch tán trung gian (bản nháp) là tạm thời và sẽ bị ghi đè bởi các bản nháp tiếp theo, đồng thời bị xóa khi văn bản đã được xác nhận in ra. Nếu bạn đang chạy trong một môi trường như tmux, văn bản nháp có thể không tự ghi đè lên chính nó. Ví dụ: ```python >>> from transformers import DiffusionGemmaForBlockDiffusion, AutoProcessor, TextDiffusionStreamer >>> model = DiffusionGemmaForBlockDiffusion.from_pretrained( ... "google/diffusiongemma-26B-A4B-it", device_map="auto", ... ) >>> processor = AutoProcessor.from_pretrained("google/diffusiongemma-26B-A4B-it") >>> chat = [{"role": "user", "content": "Why is the sky blue?"},] >>> input_ids = processor.apply_chat_template( ... chat, tokenize=True, return_tensors="pt", add_generation_prompt=True ... ) >>> streamer = TextDiffusionStreamer(tokenizer=processor.tokenizer) >>> model.generate(input_ids.to(model.device), max_new_tokens=512, streamer=streamer) ``` #### end[[transformers.TextDiffusionStreamer.end]] ```python end() ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/streamers.py#L392) Xóa bộ nhớ đệm còn lại và in xuống dòng mới. #### put[[transformers.TextDiffusionStreamer.put]] ```python put(value) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/streamers.py#L387) Nhận các token đã xác nhận, xóa bản nháp và in chúng vĩnh viễn. #### put_draft[[transformers.TextDiffusionStreamer.put_draft]] ```python put_draft(value, **kwargs) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/streamers.py#L365) Nhận toàn bộ chuỗi token nháp, giải mã chúng và in ra bằng màu vàng. Ghi đè lên bản nháp trước đó. ## Bộ nhớ đệm[[transformers.CacheLayerMixin]] #### transformers.CacheLayerMixin[[transformers.CacheLayerMixin]] ```python transformers.CacheLayerMixin(**kwargs) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L23) Lớp trừu tượng cơ bản cho bộ nhớ đệm của một lớp duy nhất. #### cập nhật[[transformers.CacheLayerMixin.update]] ```python update(key_states: Tensor, value_states: Tensor, *args, **kwargs) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L52) #### get_seq_length[[transformers.CacheLayerMixin.get_seq_length]] ```python get_seq_length() ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L60) #### get_mask_sizes[[transformers.CacheLayerMixin.get_mask_sizes]] ```python get_mask_sizes(query_length: int) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L57) #### get_max_length[[transformers.CacheLayerMixin.get_max_length]] ```python get_max_length() ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L63) Trả về độ dài chuỗi tối đa mà lớp có thể chứa. Giá trị `-1` có nghĩa là không có giới hạn tối đa, hoặc giới hạn tối đa không xác định, chẳng hạn như một lớp chú ý động (dynamic attention) tăng trưởng vô hạn hoặc một lớp chú ý tuyến tính (linear attention) không có chiều độ dài chuỗi. #### reset[[transformers.CacheLayerMixin.reset]] ```python reset() ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L84) Đặt lại các giá trị cache trong khi giữ nguyên các đối tượng #### reorder_cache[[transformers.CacheLayerMixin.reorder_cache]] ```python reorder_cache(beam_idx: LongTensor) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L97) Sắp xếp lại bộ nhớ đệm của lớp này cho tìm kiếm chùm. #### lazy_initialization[[transformers.CacheLayerMixin.lazy_initialization]] ```python lazy_initialization(key_states: Tensor, value_states: Tensor) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L49) #### transformers.DynamicLayer[[transformers.DynamicLayer]] ```python transformers.DynamicLayer(**kwargs) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L104) Một lớp cache tăng trưởng động khi có thêm token được tạo ra. Đây là mặc định cho các mô hình sinh. Nó lưu trữ trạng thái key và value dưới dạng các tensor có hình dạng `[batch_size, num_heads, seq_len, head_dim]`. #### cập nhật[[transformers.DynamicLayer.update]] ```python update(key_states: Tensor, value_states: Tensor, *args, **kwargs) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L119) **Tham số:** key_states (`torch.Tensor`) : Các trạng thái khóa mới để lưu vào bộ nhớ đệm. value_states (`torch.Tensor`) : Các trạng thái giá trị mới cần lưu vào bộ nhớ đệm. **Trả về:** tuple[`torch.Tensor`, `torch.Tensor`] Trạng thái khóa và giá trị. Cập nhật bộ đệm key và value tại chỗ, và trả về các trạng thái key và value cần thiết. #### lazy_initialization[[transformers.DynamicLayer.lazy_initialization]] ```python lazy_initialization(key_states: Tensor, value_states: Tensor) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L113) #### crop[[transformers.DynamicLayer.crop]] ```python crop(tokens_to_remove: int) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L164) Xóa các token `tokens_to_remove` khỏi lớp cache hiện tại. #### batch_repeat_interleave[[transformers.DynamicLayer.batch_repeat_interleave]] ```python batch_repeat_interleave(repeats: int) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L183) Lặp lại cache `repeats` lần theo chiều batch. #### batch_select_indices[[transformers.DynamicLayer.batch_select_indices]] ```python batch_select_indices(indices: Tensor) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L189) Chỉ giữ lại `indices` trong chiều batch của cache. #### transformers.StaticLayer[[transformers.StaticLayer]] ```python transformers.StaticLayer(max_cache_len: int, **kwargs) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L403) **Tham số:** max_cache_len (`int`) : Số lượng token tối đa có thể được lưu trữ, dùng để phân bổ trước tensor. Một lớp cache tĩnh lưu trữ trạng thái key và value dưới dạng các tensor tĩnh có hình dạng `[batch_size, num_heads, max_cache_len, head_dim]`. Lớp này phân bổ các tensor nền đầy đủ một cách lười (lazy), sau đó thay đổi chúng tại chỗ (in-place). Được xây dựng để hỗ trợ `torch.compile`. #### cập nhật[[transformers.StaticLayer.update]] ```python update(key_states: Tensor, value_states: Tensor, *args, **kwargs) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L461) **Tham số:** key_states (`torch.Tensor`) : Các trạng thái khóa mới để lưu vào bộ nhớ đệm. value_states (`torch.Tensor`) : Các trạng thái giá trị mới cần lưu vào bộ nhớ đệm. **Trả về:** tuple[`torch.Tensor`, `torch.Tensor`] Trạng thái khóa và giá trị. Cập nhật bộ đệm key và value tại chỗ, và trả về các trạng thái key và value cần thiết. #### lazy_initialization[[transformers.StaticLayer.lazy_initialization]] ```python lazy_initialization(key_states: Tensor, value_states: Tensor) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L423) Khởi tạo trễ các tensor keys và values. Điều này cho phép lấy tất cả các thuộc tính (dtype, device, num_heads trong trường hợp TP, v.v.) trực tiếp tại thời điểm runtime, cực kỳ tiện lợi vì tránh được việc di chuyển device, dtype, v.v. sau này cho mỗi lần `update` (điều này cũng có thể làm hỏng các địa chỉ dynamo tĩnh). Nếu điều này không mong muốn, bạn có thể gọi `early_initialization(...)` trực tiếp trên Cache, điều này sẽ gọi hàm này trước thời điểm thực thi (điều này là bắt buộc, chẳng hạn đối với `torch.export`). Nó cũng là bắt buộc mỗi khi chính phần prefill nằm trong một vùng được biên dịch (ví dụ với chunked prefill). #### transformers.StaticSlidingWindowLayer[[transformers.StaticSlidingWindowLayer]] ```python transformers.StaticSlidingWindowLayer(max_cache_len: int, sliding_window: int, **kwargs) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L510) **Tham số:** max_cache_len (`int`) : Số lượng token tối đa có thể được lưu trữ, dùng để phân bổ trước tensor. sliding_window (`int`) : Kích thước của cửa sổ trượt. Một lớp cache tĩnh lưu trữ trạng thái key và value dưới dạng các tensor tĩnh có hình dạng `[batch_size, num_heads, min(max_cache_len, sliding_window), head_dim]`. Lớp này phân bổ các tensor nền đầy đủ một cách lười (lazy), sau đó thay đổi chúng tại chỗ (in-place). Được xây dựng để hỗ trợ `torch.compile`. #### cập nhật[[transformers.StaticSlidingWindowLayer.update]] ```python update(key_states: Tensor, value_states: Tensor, *args, **kwargs) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L531) **Tham số:** key_states (`torch.Tensor`) : Các trạng thái khóa mới để lưu vào bộ nhớ đệm. value_states (`torch.Tensor`) : Các trạng thái giá trị mới cần lưu vào bộ nhớ đệm. **Trả về:** tuple[`torch.Tensor`, `torch.Tensor`] Trạng thái khóa và giá trị. Cập nhật bộ đệm key và value tại chỗ, và trả về các trạng thái key và value cần thiết. #### lazy_initialization[[transformers.StaticSlidingWindowLayer.lazy_initialization]] ```python lazy_initialization(key_states: Tensor, value_states: Tensor) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L423) Khởi tạo trễ các tensor keys và values. Điều này cho phép lấy tất cả các thuộc tính (dtype, device, num_heads trong trường hợp TP, v.v.) trực tiếp tại thời điểm runtime, cực kỳ tiện lợi vì tránh được việc di chuyển device, dtype, v.v. sau này cho mỗi lần `update` (điều này cũng có thể làm hỏng các địa chỉ dynamo tĩnh). Nếu điều này không mong muốn, bạn có thể gọi `early_initialization(...)` trực tiếp trên Cache, điều này sẽ gọi hàm này trước thời điểm thực thi (điều này là bắt buộc, chẳng hạn đối với `torch.export`). Nó cũng là bắt buộc mỗi khi chính phần prefill nằm trong một vùng được biên dịch (ví dụ với chunked prefill). #### transformers.QuantoQuantizedLayer[[transformers.QuantoQuantizedLayer]] ```python transformers.QuantoQuantizedLayer(nbits: int = 4, axis_key: int = 0, axis_value: int = 0, q_group_size: int = 64, residual_length: int = 128) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L854) #### cập nhật[[transformers.QuantoQuantizedLayer.update]] ```python update(key_states: Tensor, value_states: Tensor, *args, **kwargs) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L781) **Tham số:** key_states (`torch.Tensor`) : Các trạng thái khóa mới để lưu vào bộ nhớ đệm. value_states (`torch.Tensor`) : Các trạng thái giá trị mới cần lưu vào bộ nhớ đệm. **Trả về:** tuple[`torch.Tensor`, `torch.Tensor`] Trạng thái khóa và giá trị. Cập nhật bộ đệm key và value tại chỗ, và trả về các trạng thái key và value cần thiết. #### lazy_initialization[[transformers.QuantoQuantizedLayer.lazy_initialization]] ```python lazy_initialization(key_states: Tensor, value_states: Tensor) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L113) #### transformers.HQQQuantizedLayer[[transformers.HQQQuantizedLayer]] ```python transformers.HQQQuantizedLayer(nbits: int = 4, axis_key: int = 0, axis_value: int = 0, q_group_size: int = 64, residual_length: int = 128) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L909) #### cập nhật[[transformers.HQQQuantizedLayer.update]] ```python update(key_states: Tensor, value_states: Tensor, *args, **kwargs) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L781) **Tham số:** key_states (`torch.Tensor`) : Các trạng thái khóa mới để lưu vào bộ nhớ đệm. value_states (`torch.Tensor`) : Các trạng thái giá trị mới cần lưu vào bộ nhớ đệm. **Trả về:** tuple[`torch.Tensor`, `torch.Tensor`] Trạng thái khóa và giá trị. Cập nhật bộ đệm key và value tại chỗ, và trả về các trạng thái key và value cần thiết. #### lazy_initialization[[transformers.HQQQuantizedLayer.lazy_initialization]] ```python lazy_initialization(key_states: Tensor, value_states: Tensor) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L113) #### transformers.Fp8QuantizedLayer[[transformers.Fp8QuantizedLayer]] ```python transformers.Fp8QuantizedLayer() ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L966) Một lớp lượng tử hóa lưu trữ trạng thái key và value ở định dạng số dấu phẩy động 8-bit. Thang đo theo tensor được đóng băng sau lần `update` đầu tiên, do đó các trạng thái mới được thêm vào nguyên bản: không có bộ đệm phần dư, không có tái lượng tử hóa. Một biến thể có độ hạt mịn hơn thuộc về đây thay vì dưới `QuantizedLayer`, vì việc nhóm theo chiều head giúp các trạng thái có thể được nối thêm và chỉ biến scale được lưu trữ thành một tensor. #### cập nhật[[transformers.Fp8QuantizedLayer.update]] ```python update(key_states: Tensor, value_states: Tensor, *args, **kwargs) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L994) **Tham số:** key_states (`torch.Tensor`) : Các trạng thái khóa mới để lưu vào bộ nhớ đệm. value_states (`torch.Tensor`) : Các trạng thái giá trị mới cần lưu vào bộ nhớ đệm. **Trả về:** tuple[`torch.Tensor`, `torch.Tensor`] Trạng thái khóa và giá trị. Cập nhật bộ đệm key và value tại chỗ, và trả về các trạng thái key và value cần thiết. #### lazy_initialization[[transformers.Fp8QuantizedLayer.lazy_initialization]] ```python lazy_initialization(key_states: Tensor, value_states: Tensor) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L978) #### transformers.Cache[[transformers.Cache]] ```python transformers.Cache(layers: list[transformers.cache_utils.CacheLayerMixin | transformers.cache_utils.LinearAttentionCacheLayerMixin | transformers.cache_utils.DummyLayer] | None = None, layer_class_to_replicate: type[transformers.cache_utils.CacheLayerMixin | transformers.cache_utils.LinearAttentionCacheLayerMixin] | None = None, offloading: bool = False, offload_only_non_sliding: bool = True) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L1453) **Tham số:** layers (`Optional`, *optional*) : Một danh sách các `CacheLayerMixin` hoặc `LinearAttentionCacheLayerMixin` đã được tạo trước. Nếu bị bỏ qua (`None`), thì `layer_class_to_replicate` sẽ được sử dụng. layer_class_to_replicate (`type[CacheLayerMixin | LinearAttentionCacheLayerMixin]`, *tuỳ chọn*) : Chỉ được sử dụng nếu `layers` bị bỏ qua (`None`), khi đó nó sẽ được dùng làm lớp cơ sở cho từng lớp, và các lớp sẽ được thêm vào một cách lười biếng ngay khi `update` được gọi với `layer_idx` lớn hơn danh sách các lớp hiện tại. offloading (`bool`, *tùy chọn*, mặc định là `False`) : Có thực hiện chuyển các lớp xuống `cpu` để tiết kiệm bộ nhớ GPU hay không. offload_only_non_sliding (`bool`, *tuỳ chọn*, mặc định là `True`) : Nếu `offloading` là `True`, tham số này quyết định xem có chỉ offload các lớp không trượt hay không (vì thường các lớp trượt có kích thước nhỏ nên không cần offload, và việc bỏ qua chúng sẽ nhanh hơn). `Cache` chủ yếu là một danh sách các đối tượng `CacheLayerMixin`, mỗi đối tượng tương ứng với một lớp của mô hình. Nó đóng vai trò là bộ chứa cho Cache của từng lớp. #### cập nhật[[transformers.Cache.update]] ```python update(key_states: Tensor, value_states: Tensor, layer_idx: int, *args, **kwargs) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L1540) **Tham số:** key_states (`torch.Tensor`) : Các trạng thái khóa mới để lưu vào bộ nhớ đệm. value_states (`torch.Tensor`) : Các trạng thái giá trị mới cần lưu vào bộ nhớ đệm. layer_idx (`int`) : Chỉ số của lớp để lưu trạng thái vào bộ nhớ đệm. **Trả về:** Một tuple chứa các trạng thái key và value đã được cập nhật. Cập nhật bộ nhớ đệm với `key_states` và `value_states` mới cho lớp `layer_idx`. #### early_initialization[[transformers.Cache.early_initialization]] ```python early_initialization(batch_size: int, num_heads: int | list[int], head_dim: int | list[int], dtype: dtype, device: device) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L1669) Khởi tạo tất cả các lớp trước (nếu không, chúng sẽ được khởi tạo theo kiểu lười biếng ở lần gọi `update` đầu tiên). Điều này hữu ích cho các công thức `export` của chúng ta, vì `export` cần mọi thứ được chuẩn bị sẵn từ trước. #### get_seq_length[[transformers.Cache.get_seq_length]] ```python get_seq_length(layer_idx: int = 0) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L1706) Trả về độ dài chuỗi của bộ nhớ đệm cho lớp được chỉ định. #### get_mask_sizes[[transformers.Cache.get_mask_sizes]] ```python get_mask_sizes(query_length: int, layer_idx: int) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L1776) Trả về một tuple (kv_length, kv_offset) tương ứng với độ dài và offset sẽ được trả về cho lớp được chỉ định tại `layer_idx`. Các mask sau đó được chuẩn bị theo các độ dài (kv_length, kv_offset) và mẫu cho từng lớp. #### get_max_length[[transformers.Cache.get_max_length]] ```python get_max_length(layer_idx: int | None = None) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L1730) Trả về độ dài tối đa của bộ nhớ đệm. Nếu `layer_idx` không được cung cấp (mặc định), hàm này trả về giá trị tối đa trên tất cả các lớp. Ngược lại, trả về giá trị tối đa được hỗ trợ cho lớp đã cho. Giá trị `-1` có nghĩa là không có giới hạn tối đa, hoặc giới hạn tối đa không xác định, ví dụ như các lớp chú ý động có thể tăng không giới hạn, hoặc các lớp chú ý tuyến tính không có chiều độ dài chuỗi. #### reset[[transformers.Cache.reset]] ```python reset() ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L1813) Đặt lại đệ quy tất cả các tensor của các lớp #### reorder_cache[[transformers.Cache.reorder_cache]] ```python reorder_cache(beam_idx: LongTensor) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L1818) Sắp xếp lại bộ nhớ đệm cho tìm kiếm chùm #### crop[[transformers.Cache.crop]] ```python crop(tokens_to_remove: int) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L1823) Xóa các token `tokens_to_remove` khỏi Cache hiện tại. Đối với các lớp không cần giữ toàn bộ trạng thái quá khứ trong bộ nhớ, chẳng hạn như các lớp cửa sổ trượt hoặc các lớp chú ý tuyến tính, thao tác này cũng sẽ giới hạn kích thước của các trạng thái được lưu cache trở lại kích thước hoạt động tối thiểu. Điều này có nghĩa là `crop(0)` không nhất thiết luôn là một thao tác không làm gì (no-op), vì nó vẫn có thể xóa các trạng thái vô dụng (tức là các trạng thái không cần thiết cho lần `forward` tiếp theo) khỏi Cache. #### batch_repeat_interleave[[transformers.Cache.batch_repeat_interleave]] ```python batch_repeat_interleave(repeats: int) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L1833) Lặp lại và xen kẽ bộ nhớ đệm #### batch_select_indices[[transformers.Cache.batch_select_indices]] ```python batch_select_indices(indices: Tensor) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L1838) Chọn các chỉ số từ bộ nhớ đệm #### transformers.DynamicCache[[transformers.DynamicCache]] ```python transformers.DynamicCache(ddp_cache_data: collections.abc.Iterable[tuple[typing.Optional[torch.Tensor], ...]] | None = None, config: transformers.configuration_utils.PreTrainedConfig | None = None, offloading: bool = False, offload_only_non_sliding: bool = False) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L1960) **Tham số:** ddp_cache_data (`Iterable[tuple[torch.Tensor, torch.Tensor]]`, *tùy chọn*) : Ban đầu được thêm vào để tương thích với `torch.distributed` (DDP). Tóm lại, nó là `map(gather_map, zip(*caches))`, tức là mỗi phần tử trong iterable chứa trạng thái key và value của một lớp đã được thu thập (gather) trên các bản sao (replicas) bởi torch.distributed (shape=[global batch size, num_heads, seq_len, head_dim]). Lưu ý: nó cũng cần là đối số thứ nhất để hoạt động chính xác config (`PreTrainedConfig`, *tùy chọn*) : Cấu hình của mô hình mà Cache này sẽ được sử dụng. Nếu được truyền vào, nó sẽ được dùng để kiểm tra cấu trúc lớp trượt hoặc lai, giúp giảm đáng kể yêu cầu bộ nhớ của các tensor được cache xuống `[batch_size, num_heads, min(seq_len, sliding_window), head_dim]`. offloading (`bool`, *tùy chọn*, mặc định là `False`) : Có thực hiện chuyển các lớp xuống `cpu` để tiết kiệm bộ nhớ GPU hay không. offload_only_non_sliding (`bool`, *tùy chọn*, mặc định là `False`) : Nếu `offloading` là `True`, tham số này quyết định xem có chỉ offload các lớp không trượt hay không (vì thường các lớp trượt có kích thước nhỏ nên không cần offload, và việc bỏ qua chúng sẽ nhanh hơn). Bộ đệm tăng trưởng động khi có thêm token được tạo ra. Đây là mặc định cho các mô hình sinh. Nó lưu trữ trạng thái key và value dưới dạng danh sách các `CacheLayer`, mỗi lớp một phần tử. Hình dạng mong đợi cho mỗi tensor trong các `CacheLayer` là `[batch_size, num_heads, seq_len, head_dim]`. Nếu một config được truyền vào, nó sẽ kiểm tra thêm cấu trúc bộ đệm trượt hoặc lai, giảm đáng kể yêu cầu bộ nhớ của các tensor được đệm xuống còn `[batch_size, num_heads, min(seq_len, sliding_window), head_dim]`. Xem `Cache` để biết chi tiết về các phương thức phổ biến được triển khai bởi tất cả các lớp cache. Ví dụ: ```python >>> from transformers import AutoTokenizer, AutoModelForCausalLM, DynamicCache >>> model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen2-0.5B-Instruct") >>> tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen2-0.5B-Instruct") >>> inputs = tokenizer(text="My name is Qwen2", return_tensors="pt") >>> # Prepare a cache class and pass it to model's forward >>> past_key_values = DynamicCache(config=model.config) >>> outputs = model(**inputs, past_key_values=past_key_values, use_cache=True) >>> outputs.past_key_values # access cache filled with key/values from generation ``` #### transformers.StaticCache[[transformers.StaticCache]] ```python transformers.StaticCache(config: PreTrainedConfig, max_cache_len: int, offloading: bool = False, offload_only_non_sliding: bool = True, **kwargs) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L2056) **Tham số:** config (`PreTrainedConfig`) : Cấu hình của mô hình mà Cache này sẽ được sử dụng. Nó sẽ được dùng để kiểm tra cấu trúc lớp trượt hoặc lai, và khởi tạo từng lớp tương ứng. max_cache_len (`int`) : Số lượng token tối đa mà Cache này nên giữ. offloading (`bool`, *tùy chọn*, mặc định là `False`) : Có thực hiện chuyển các lớp xuống `cpu` để tiết kiệm bộ nhớ GPU hay không. offload_only_non_sliding (`bool`, *tuỳ chọn*, mặc định là `True`) : Nếu `offloading` là `True`, tham số này quyết định xem có chỉ offload các lớp không trượt hay không (vì thường các lớp trượt có kích thước nhỏ nên không cần offload, và việc bỏ qua chúng sẽ nhanh hơn). Lớp Static Cache để sử dụng với `torch.compile(model)` và `torch.export()`. Nó sẽ kiểm tra `config` để tìm cấu trúc cache hybrid tiềm năng và khởi tạo từng lớp tương ứng. Xem `Cache` để biết chi tiết về các phương thức phổ biến được triển khai bởi tất cả các lớp cache. Ví dụ: ```python >>> from transformers import AutoTokenizer, AutoModelForCausalLM, StaticCache >>> model = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-2-7b-chat-hf") >>> tokenizer = AutoTokenizer.from_pretrained("meta-llama/Llama-2-7b-chat-hf") >>> inputs = tokenizer(text="My name is Llama", return_tensors="pt") >>> # Prepare a cache class and pass it to model's forward >>> # Leave empty space for 10 new tokens, which can be used when calling forward iteratively 10 times to generate >>> max_generated_length = inputs.input_ids.shape[1] + 10 >>> past_key_values = StaticCache(config=model.config, max_cache_len=max_generated_length) >>> outputs = model(**inputs, past_key_values=past_key_values, use_cache=True) >>> outputs.past_key_values # access cache filled with key/values from generation StaticCache() ``` #### transformers.QuantizedCache[[transformers.QuantizedCache]] ```python transformers.QuantizedCache(backend: str, config: PreTrainedConfig, nbits: int | None = None, axis_key: int | None = None, axis_value: int | None = None, q_group_size: int | None = None, residual_length: int | None = None) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L2113) **Tham số:** backend (`str`) : Backend lượng tử hóa cần sử dụng. Một trong số `("quanto", "hqq", "fp8")`. config (`PreTrainedConfig`) : Cấu hình của mô hình mà Cache này sẽ được sử dụng. nbits (`int`, *tuỳ chọn*, mặc định là 4) : Số bit cho lượng tử hóa. axis_key (`int`, *tuỳ chọn*, mặc định là 0) : Trục để lượng tử hóa các khóa. axis_value (`int`, *tuỳ chọn*, mặc định là 0) : Trục để lượng tử hóa các giá trị. q_group_size (`int`, *tuỳ chọn*, mặc định là 64) : Việc lượng tử hóa được thực hiện theo từng kênh dựa trên một tập `q_group_size` cho cả keys và values. residual_length (`int`, *tuỳ chọn*, mặc định là 128) : Dung lượng tối đa cho bộ nhớ đệm độ chính xác gốc. Bộ đệm lượng tử hóa tương tự như mô tả trong [bài báo KIVI: A Tuning-Free Asymmetric 2bit Quantization for KV Cache](https://huggingface.co/papers/2402.02750). Nó cho phép mô hình tạo ra chuỗi có độ dài lớn hơn mà không cần cấp phát quá nhiều bộ nhớ cho các key và value bằng cách áp dụng lượng tử hóa. Bộ đệm có hai loại lưu trữ, một cho độ chính xác gốc và một cho bộ đệm đã lượng tử hóa. Một `residual length` được đặt làm dung lượng tối đa cho bộ đệm độ chính xác gốc. Khi độ dài vượt quá dung lượng tối đa, bộ đệm độ chính xác gốc sẽ bị loại bỏ và chuyển sang bộ đệm lượng tử hóa. Việc lượng tử hóa được thực hiện theo từng kênh với một `q_group_size` đã đặt cho cả key và value, trái ngược với những gì được mô tả trong bài báo. Xem `Cache` để biết chi tiết về các phương thức phổ biến được triển khai bởi tất cả các lớp cache. Năm đối số cuối cùng cấu hình các backend integer theo nhóm. Backend `fp8` lượng tử hóa theo tensor và từ chối chúng. #### transformers.EncoderDecoderCache[[transformers.EncoderDecoderCache]] ```python transformers.EncoderDecoderCache(*caches) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L2199) **Tham số:** caches (`Iterable`) : Thường là một iterable có độ dài 2, chứa 2 đối tượng `Cache`, đối tượng đầu tiên cho self-attention, đối tượng thứ hai cho cross-attention. Tùy chọn, cũng có thể là một iterable có độ dài 1, chứa một `tuple[tuple[torch.Tensor]]` (thường được sử dụng để tương thích với torch dp và ddp). Lớp trừu tượng cơ bản cho tất cả các bộ nhớ đệm (cache) của bộ mã hóa-giải mã (encoder-decoder). Có thể được sử dụng để lưu trữ các tổ hợp của bộ nhớ đệm self-attention và cross-attention. Xem `Cache` để biết chi tiết về các phương thức phổ biến được triển khai bởi tất cả các lớp cache. Ví dụ: ```python >>> from transformers import AutoProcessor, AutoModelForCausalLM, DynamicCache, EncoderDecoderCache >>> model = AutoModelForCausalLM.from_pretrained("openai/whisper-small") >>> processor = AutoProcessor.from_pretrained("openai/whisper-small") >>> inputs = processor(audio=YOUR-AUDIO, return_tensors="pt") >>> # Prepare cache classes for encoder and decoder and pass it to model's forward >>> self_attention_cache = DynamicCache(config=self.config) >>> cross_attention_cache = DynamicCache(config=self.config) >>> past_key_values = EncoderDecoderCache(self_attention_cache, cross_attention_cache) >>> outputs = model(**inputs, past_key_values=past_key_values, use_cache=True) >>> outputs.past_key_values # access cache filled with key/values from generation EncoderDecoderCache() ``` #### batch_repeat_interleave[[transformers.EncoderDecoderCache.batch_repeat_interleave]] ```python batch_repeat_interleave(repeats: int) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L2316) Lặp lại cache `repeats` lần theo chiều batch. Được sử dụng trong contrastive search (trên Hub). #### batch_select_indices[[transformers.EncoderDecoderCache.batch_select_indices]] ```python batch_select_indices(indices: Tensor) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L2322) Chỉ giữ lại `indices` trong chiều batch của cache. Được sử dụng trong tìm kiếm tương phản (trên Hub). #### crop[[transformers.EncoderDecoderCache.crop]] ```python crop(tokens_to_remove: int) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L2309) Xóa các token `tokens_to_remove` khỏi lớp cache hiện tại. #### get_max_length[[transformers.EncoderDecoderCache.get_max_length]] ```python get_max_length(layer_idx: int | None = None) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L2284) Trả về độ dài chuỗi tối đa (tức là sức chứa tối đa) của đối tượng cache #### get_seq_length[[transformers.EncoderDecoderCache.get_seq_length]] ```python get_seq_length(layer_idx: int = 0) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L2280) Trả về độ dài chuỗi của các trạng thái được đệm. Có thể truyền tùy chọn một chỉ số lớp. #### reorder_cache[[transformers.EncoderDecoderCache.reorder_cache]] ```python reorder_cache(beam_idx: LongTensor) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L2294) Sắp xếp lại bộ nhớ đệm cho tìm kiếm chùm, dựa trên các chỉ mục chùm đã chọn. ## Công cụ đánh dấu[[transformers.WatermarkingConfig]] #### transformers.WatermarkingConfig[[transformers.WatermarkingConfig]] ```python transformers.WatermarkingConfig(greenlist_ratio: float = 0.25, bias: float = 2.0, hashing_key: int = 15485863, seeding_scheme: str = 'lefthash', context_width: int = 1) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/configuration_utils.py#L1460) Lớp chứa các đối số cho việc tạo watermark và cần được truyền vào `GenerationConfig` trong quá trình `generate`. Xem [bài báo này](https://huggingface.co/papers/2306.04634) để biết thêm chi tiết về các đối số. Nhận các khóa sau: - greenlist_ratio (`float`): Được sử dụng cho việc đánh dấu watermark. Tỷ lệ các token "xanh" được sử dụng so với kích thước từ vựng. Mặc định là 0.25. - bias (`float`): Được sử dụng với watermarking. Độ lệch được thêm vào logits của các token "xanh" được chọn. Mặc định là 2.0. - hashing_key (`int`): Khóa băm được sử dụng cho việc đánh dấu bản quyền (watermarking). Mặc định là 15485863 (số nguyên tố thứ một triệu). - seeding_scheme (`str`): Thuật toán được sử dụng cho việc thêm watermark. Chấp nhận các giá trị: - "lefthash" (mặc định): việc chọn các token "green" phụ thuộc vào token cuối cùng (Thuật toán 2 trong bài báo) - Việc chọn token "selfhash": "green" phụ thuộc vào chính token hiện tại (Thuật toán 3 trong bài báo). Nhược điểm của phương án này là nó xem xét tất cả các token tiếp theo có thể và có thể chậm hơn "lefthash". - context_width(`int`): Độ dài ngữ cảnh của các token trước đó được sử dụng trong seeding. Độ dài ngữ cảnh cao hơn làm cho việc đánh dấu mờ (watermarking) trở nên bền vững hơn. #### __call__[[transformers.WatermarkingConfig.__call__]] ```python __call__(*args, **kwargs) ``` Gọi self như một hàm. #### transformers.WatermarkDetector[[transformers.WatermarkDetector]] ```python transformers.WatermarkDetector(model_config: PreTrainedConfig, device: str, watermarking_config: typing.Union[ForwardRef('WatermarkingConfig'), dict], ignore_repeated_ngrams: bool = False, max_cache_size: int = 128) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/watermarking.py#L71) **Tham số:** model_config (`PreTrainedConfig`) : Cấu hình mô hình sẽ được sử dụng để lấy các đối số cụ thể của mô hình dùng khi tạo ra nội dung. device (`str`) : Thiết bị được sử dụng trong quá trình tạo văn bản có watermark. watermarking_config (Union[`WatermarkingConfig`, `Dict`]) : Cấu hình và các đối số watermarking hoàn toàn giống với những gì được sử dụng khi tạo văn bản. ignore_repeated_ngrams (`bool`, *tùy chọn*, mặc định là `False`) : Có nên chỉ đếm mỗi ngram duy nhất một lần hay không. max_cache_size (`int`, *tuỳ chọn*, mặc định là 128) : Kích thước tối đa được sử dụng cho bộ nhớ đệm LRU của các thuật toán gieo hạt/lấy mẫu được gọi cho mỗi token. Detector để phát hiện văn bản được tạo ra có watermark. Detector cần được cung cấp chính xác các cài đặt đã được sử dụng trong quá trình tạo văn bản để tái tạo quá trình tạo greenlist của watermark và từ đó phát hiện watermark. Điều này bao gồm thiết bị chính xác đã được sử dụng trong quá trình tạo văn bản, các đối số watermarking chính xác và kích thước từ điển của tokenizer chính xác. Mã được dựa trên [repo gốc](https://github.com/jwkirchenbauer/lm-watermarking/tree/main). Xem [bài báo](https://huggingface.co/papers/2306.04634) để biết thêm thông tin. Ví dụ: ```python >>> from transformers import AutoTokenizer, AutoModelForCausalLM, WatermarkDetector, WatermarkingConfig >>> model_id = "openai-community/gpt2" >>> model = AutoModelForCausalLM.from_pretrained(model_id) >>> tok = AutoTokenizer.from_pretrained(model_id) >>> tok.pad_token_id = tok.eos_token_id >>> tok.padding_side = "left" >>> inputs = tok(["This is the beginning of a long story", "Alice and Bob are"], padding=True, return_tensors="pt") >>> input_len = inputs["input_ids"].shape[-1] >>> # first generate text with watermark and without >>> watermarking_config = WatermarkingConfig(bias=2.5, seeding_scheme="selfhash") >>> out_watermarked = model.generate(**inputs, watermarking_config=watermarking_config, do_sample=False, max_length=20) >>> out = model.generate(**inputs, do_sample=False, max_length=20) >>> # now we can instantiate the detector and check the generated text >>> detector = WatermarkDetector(model_config=model.config, device="cpu", watermarking_config=watermarking_config) >>> detection_out_watermarked = detector(out_watermarked, return_dict=True) >>> detection_out = detector(out, return_dict=True) >>> detection_out_watermarked.prediction array([ True, True]) >>> detection_out.prediction array([False, False]) ``` #### __call__[[transformers.WatermarkDetector.__call__]] ```python __call__(input_ids: LongTensor, z_threshold: float = 3.0, return_dict: bool = False) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/watermarking.py#L193) **Tham số:** input_ids (`torch.LongTensor`) : Văn bản được tạo ra có chứa watermark. Nên loại bỏ prompt vì nó có thể ảnh hưởng đến việc phát hiện. z_threshold (`Dict`, *tùy chọn*, mặc định là `3.0`) : Thay đổi ngưỡng này sẽ thay đổi độ nhạy của bộ phát hiện. Ngưỡng z cao hơn cho độ nhạy thấp hơn và ngược lại với ngưỡng z thấp hơn. return_dict (`bool`, *tùy chọn*, mặc định là `False`) : Có trả về `~generation.WatermarkDetectorOutput` hay không. Nếu không, sẽ trả về các dự đoán dạng boolean, **Trả về:** `WatermarkDetectorOutput` hoặc `np.ndarray` Một `WatermarkDetectorOutput` nếu `return_dict=True`, ngược lại là một `np.ndarray`. ma #### transformers.BayesianDetectorConfig[[transformers.BayesianDetectorConfig]] ```python transformers.BayesianDetectorConfig(watermarking_depth: int | None = None, base_rate: float = 0.5, **kwargs) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/watermarking.py#L252) **Tham số:** watermarking_depth (`int`, *tuỳ chọn*) : Số lượng lớp giải đấu. base_rate (`float`, *optional*, mặc định là 0.5) : Xác suất tiên nghiệm P(w) rằng một văn bản đã được thêm watermark. Đây là lớp cấu hình để lưu trữ cấu hình của một [BayesianDetectorModel](/docs/transformers/main/vi/internal/generation_utils#transformers.BayesianDetectorModel). Nó được sử dụng để khởi tạo một mô hình Bayesian Detector theo các đối số được chỉ định. Các đối tượng cấu hình kế thừa từ [PreTrainedConfig](/docs/transformers/main/vi/main_classes/configuration#transformers.PreTrainedConfig) và có thể được sử dụng để kiểm soát đầu ra của mô hình. Đọc tài liệu từ [PreTrainedConfig](/docs/transformers/main/vi/main_classes/configuration#transformers.PreTrainedConfig) để biết thêm thông tin. #### transformers.BayesianDetectorModel[[transformers.BayesianDetectorModel]] ```python transformers.BayesianDetectorModel(config) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/watermarking.py#L359) **Tham số:** config ([BayesianDetectorConfig](/docs/transformers/main/vi/internal/generation_utils#transformers.BayesianDetectorConfig)) : Lớp cấu hình mô hình chứa tất cả các tham số của mô hình. Khởi tạo bằng tệp cấu hình sẽ không tải trọng số liên quan đến mô hình, chỉ tải cấu hình. Xem phương thức [from_pretrained()](/docs/transformers/main/vi/main_classes/model#transformers.PreTrainedModel.from_pretrained) để tải trọng số mô hình. Bộ phân loại Bayesian để phát hiện watermark. Detector này sử dụng quy tắc Bayes để tính điểm watermarking, đó là sigmoid của log của tỷ số giữa các xác suất hậu nghiệm P(watermarked|g_values) và P(unwatermarked|g_values). Vui lòng xem phần về BayesianScore trong bài báo để biết thêm chi tiết. URL bài báo: https://www.nature.com/articles/s41586-024-08025-4 Lưu ý rằng trình phát hiện này chỉ hoạt động với kỹ thuật đánh dấu bằng chữ ký (watermarking) dựa trên giải đấu (Tournament) không gây méo, sử dụng phân phối giá trị g theo Bernoulli(0.5). Mô hình này kế thừa từ [PreTrainedModel](/docs/transformers/main/vi/main_classes/model#transformers.PreTrainedModel). Xem tài liệu của lớp cha để biết các phương thức chung mà thư viện triển khai cho tất cả các mô hình của nó (chẳng hạn như tải xuống hoặc lưu trữ, thay đổi kích thước các nhúng đầu vào, cắt tỉa các đầu ra, v.v.) Mô hình này cũng là một lớp con của [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) trong PyTorch. Hãy sử dụng nó như một Module PyTorch thông thường và tham khảo tài liệu PyTorch cho mọi vấn đề liên quan đến cách sử dụng và hành vi chung. #### forward[[transformers.BayesianDetectorModel.forward]] ```python forward(g_values: Tensor, mask: Tensor, labels: typing.Optional[torch.Tensor] = None, loss_batch_weight = 1, return_dict = False) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/watermarking.py#L448) **Tham số:** g_values (`torch.Tensor` có hình dạng `(batch_size, seq_len, watermarking_depth, ...)`) : các giá trị g (có giá trị 0 hoặc 1) mask : Một mảng nhị phân có hình dạng [batch_size, seq_len] chỉ ra các giá trị g nào nên được sử dụng. Các giá trị g có giá trị mask là 0 sẽ bị loại bỏ. **Trả về:** p(watermarked | g_values), có hình dạng [batch_size]. Tính toán posterior có watermark P(watermarked|g_values). #### transformers.SynthIDTextWatermarkingConfig[[transformers.SynthIDTextWatermarkingConfig]] ```python transformers.SynthIDTextWatermarkingConfig(ngram_len: int, keys: list, context_history_size: int = 1024, sampling_table_seed: int = 0, sampling_table_size: int = 65536, skip_first_ngram_calls: bool = False, debug_mode: bool = False) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/configuration_utils.py#L1540) **Tham số:** ngram_len (`int`) : Độ dài ngram. keys (`list[int]`) : Một chuỗi các khóa watermarking, mỗi khóa tương ứng với một độ sâu. context_history_size (`int`, *tuỳ chọn*, mặc định là 1024) : Kích thước của tensor để theo dõi các ngữ cảnh đã thấy. sampling_table_seed (`int`, *tuỳ chọn*, mặc định là 0) : Hạt ngẫu nhiên để tạo bảng lấy mẫu. sampling_table_size (`int`, *tuỳ chọn*, mặc định là 65536) : Kích thước của bảng lấy mẫu. skip_first_ngram_calls (`bool`, *tùy chọn*, mặc định là `False`) : Có bỏ qua các lần gọi ngram đầu tiên hay không. debug_mode (`bool`, *tùy chọn*, mặc định là `False`) : Logits được sửa đổi thành phân phối đều trước khi áp dụng thay đổi watermarking. Điều này dùng để kiểm tra việc triển khai. Lớp chứa các đối số cho việc tạo watermark và cần được truyền vào `GenerationConfig` trong quá trình `generate`. Xem [bài báo này](https://www.nature.com/articles/s41586-024-08025-4) để biết thêm chi tiết về các đối số. Ví dụ: ```python >>> from transformers import AutoModelForCausalLM, AutoTokenizer, SynthIDTextWatermarkingConfig >>> tokenizer = AutoTokenizer.from_pretrained('google/gemma-2-2b', padding_side="left") >>> model = AutoModelForCausalLM.from_pretrained('google/gemma-2-2b') >>> # SynthID Text configuration >>> watermarking_config = SynthIDTextWatermarkingConfig( ... keys=[654, 400, 836, 123, 340, 443, 597, 160, 57], ... ngram_len=5, ... ) >>> # Generation with watermarking >>> tokenized_prompts = tokenizer(["Once upon a time, "], return_tensors="pt", padding=True) >>> output_sequences = model.generate( ... **tokenized_prompts, watermarking_config=watermarking_config, do_sample=True, max_new_tokens=10 ... ) >>> watermarked_text = tokenizer.batch_decode(output_sequences, skip_special_tokens=True) ``` #### transformers.SynthIDTextWatermarkDetector[[transformers.SynthIDTextWatermarkDetector]] ```python transformers.SynthIDTextWatermarkDetector(detector_module: BayesianDetectorModel, logits_processor: SynthIDTextWatermarkLogitsProcessor, tokenizer: Any) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/watermarking.py#L492) **Tham số:** detector_module ([BayesianDetectorModel](/docs/transformers/main/vi/internal/generation_utils#transformers.BayesianDetectorModel)) : đối tượng module detector Bayesian được khởi tạo với các tham số. Xem https://github.com/huggingface/transformers-research-projects/tree/main/synthid_text để biết cách sử dụng. logits_processor (`SynthIDTextWatermarkLogitsProcessor`) : Bộ xử lý logits được sử dụng để thêm watermark. tokenizer (`Any`) : Bộ phân từ (tokenizer) được sử dụng cho mô hình. Lớp phát hiện watermark văn bản SynthID. Lớp này phải được khởi tạo với module detector bayesian đã được huấn luyện, xem script kiểm tra trong examples/synthid_text/detector_training.py làm ví dụ về việc huấn luyện/lưu/tải module detector này. Thư mục cũng minh họa một trường hợp sử dụng ví dụ của detector này. Ví dụ: ```python >>> from transformers import ( ... AutoTokenizer, BayesianDetectorModel, SynthIDTextWatermarkLogitsProcessor, SynthIDTextWatermarkDetector ... ) >>> # Load the detector. See https://github.com/huggingface/transformers-research-projects/tree/main/synthid_text for training a detector. >>> detector_model = BayesianDetectorModel.from_pretrained("joaogante/dummy_synthid_detector") >>> logits_processor = SynthIDTextWatermarkLogitsProcessor( ... **detector_model.config.watermarking_config, device="cpu" ... ) >>> tokenizer = AutoTokenizer.from_pretrained(detector_model.config.model_name) >>> detector = SynthIDTextWatermarkDetector(detector_model, logits_processor, tokenizer) >>> # Test whether a certain string is watermarked >>> test_input = tokenizer(["This is a test input"], return_tensors="pt") >>> is_watermarked = detector(test_input.input_ids) ``` #### __call__[[transformers.SynthIDTextWatermarkDetector.__call__]] ```python __call__(tokenized_outputs: Tensor) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/watermarking.py#L539) ## Công cụ biên dịch[[transformers.CompileConfig]] #### transformers.CompileConfig[[transformers.CompileConfig]] ```python transformers.CompileConfig(fullgraph: bool = False, dynamic: bool | None = None, backend: str | collections.abc.Callable = 'inductor', mode: str = 'reduce-overhead', options: dict | None = None) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/configuration_utils.py#L1632) **Tham số:** fullgraph (`bool`, *tuỳ chọn*, mặc định là `False`) : Nếu là False (mặc định), sẽ cố gắng phát hiện các vùng có thể biên dịch để tối ưu hóa. Nếu là True, thì yêu cầu toàn bộ hàm phải có thể được bắt vào một đồ thị duy nhất. Nếu điều này không thể thực hiện được (tức là nếu có sự ngắt đồ thị), một lỗi sẽ được ném ra. dynamic (`bool` hoặc `None`, *tùy chọn*) : Có nên cố gắng sử dụng đồ thị hình dạng động hay không. backend (`str` hoặc `Callable`, *tùy chọn*, mặc định là `"inductor"`) : Backend sẽ được sử dụng. mode (`str`, *tùy chọn*, mặc định là `"reduce-overhead"`) : Kiểm soát sự cân bằng giữa hiệu suất và chi phí overhead. options (`dict`, *tùy chọn*) : Một từ điển các tùy chọn để truyền cho backend. Lớp chứa các đối số liên quan đến hành vi của `torch.compile` khi sử dụng biên dịch tự động trong `generate`. Xem [`torch.compile`](https://pytorch.org/docs/stable/generated/torch.compile.html) để biết thêm chi tiết về các đối số. Ví dụ: ```python >>> from transformers import AutoModelForCausalLM, AutoTokenizer, CompileConfig >>> tokenizer = AutoTokenizer.from_pretrained('google/gemma-2-2b') >>> model = AutoModelForCausalLM.from_pretrained('google/gemma-2-2b').cuda() >>> # Automatic compile configuration, used with static cache >>> compile_config = CompileConfig(dynamic=True) >>> # Generation with static cache and compile config >>> input = tokenizer.encode("Hello there, how", return_tensors="pt").cuda() >>> output = model.generate( ... input, do_sample=False, max_new_tokens=300, cache_implementation="static", compile_config=compile_config ... ) >>> output_text = tokenizer.batch_decode(output, skip_special_tokens=True)[0] ``` #### __call__[[transformers.CompileConfig.__call__]] ```python __call__(*args, **kwargs) ``` Gọi self như một hàm.