Download code/s1/qwen_nar.py from rcell233/magvits_data: direct link, hf CLI and curl.
- Browser
- Download file 13.4 kB
-
https://huggingface.co/datasets/rcell233/magvits_data/resolve/main/code/s1/qwen_nar.py
- Command line
-
hf download hf://datasets/rcell233/magvits_data/code/s1/qwen_nar.py
-
curl -L -o qwen_nar.py https://huggingface.co/datasets/rcell233/magvits_data/resolve/main/code/s1/qwen_nar.py
13.4 kB
| # Copyright (c) 2024 Alibaba Inc | |
| # | |
| # Licensed under the Apache License, Version 2.0 (the "License"); | |
| # you may not use this file except in compliance with the License. | |
| # You may obtain a copy of the License at | |
| # | |
| # http://www.apache.org/licenses/LICENSE-2.0 | |
| # | |
| # Unless required by applicable law or agreed to in writing, software | |
| # distributed under the License is distributed on an "AS IS" BASIS, | |
| # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
| # See the License for the specific language governing permissions and | |
| # limitations under the License. | |
| import torch.nn as nn | |
| import torch | |
| from transformers import AutoModelForCausalLM, AutoTokenizer | |
| from transformers import Qwen2ForCausalLM, Qwen2Config | |
| from torch.nn.utils.rnn import pad_sequence, unpad_sequence | |
| from tqdm import tqdm | |
| def topk_sampling(weighted_scores, decoded_tokens, top_k=1024): | |
| zeros = weighted_scores.new_ones(weighted_scores.shape) * float('-inf') | |
| values,indices = torch.topk(weighted_scores,top_k) | |
| zeros.scatter_(-1, indices, values) | |
| return random_sampling(zeros,decoded_tokens) | |
| # Repetition Aware Sampling in VALL-E 2 | |
| def ras_sampling(weighted_scores, decoded_tokens, top_p=0.8, top_k=50, win_size=10, tau_r=0.1): | |
| top_ids = nucleus_sampling(weighted_scores, top_p=top_p, top_k=top_k) | |
| rep_num = (torch.tensor(decoded_tokens[-win_size:]).to(weighted_scores.device) == top_ids).sum().item() | |
| if rep_num >= win_size * tau_r: | |
| top_ids = random_sampling(weighted_scores, decoded_tokens) | |
| return top_ids | |
| def caras_sampling(weighted_scores, decoded_tokens, top_p=0.8, top_k=25, win_size=10, tau_r=0.1): | |
| weighted_scores, cfg_weighted_scores = weighted_scores | |
| top_ids = nucleus_sampling(weighted_scores, top_p=top_p, top_k=top_k) | |
| rep_num = (torch.tensor(decoded_tokens[-win_size:]).to(weighted_scores.device) == top_ids).sum().item() | |
| if rep_num >= win_size * tau_r: | |
| top_ids = random_sampling(cfg_weighted_scores, decoded_tokens) | |
| return top_ids | |
| def nucleus_sampling(weighted_scores, top_p=0.8, top_k=25): | |
| prob, indices = [], [] | |
| cum_prob = 0.0 | |
| sorted_value, sorted_idx = weighted_scores.softmax(dim=0).sort(descending=True, stable=True) | |
| for i in range(len(sorted_idx)): | |
| # sampling both top-p and numbers. | |
| if cum_prob < top_p and len(prob) < top_k: | |
| cum_prob += sorted_value[i] | |
| prob.append(sorted_value[i]) | |
| indices.append(sorted_idx[i]) | |
| else: | |
| break | |
| prob = torch.tensor(prob).to(weighted_scores) | |
| indices = torch.tensor(indices, dtype=torch.long).to(weighted_scores.device) | |
| top_ids = indices[prob.multinomial(1, replacement=True)] | |
| return top_ids | |
| def random_sampling(weighted_scores, decoded_tokens): | |
| top_ids = weighted_scores.softmax(dim=0).multinomial(1, replacement=True) | |
| return top_ids | |
| def th_accuracy(pad_outputs: torch.Tensor, pad_targets: torch.Tensor, | |
| ignore_label: int) -> torch.Tensor: | |
| """Calculate accuracy. | |
| Args: | |
| pad_outputs (Tensor): Prediction tensors (B * Lmax, D). | |
| pad_targets (LongTensor): Target label tensors (B, Lmax). | |
| ignore_label (int): Ignore label id. | |
| Returns: | |
| torch.Tensor: Accuracy value (0.0 - 1.0). | |
| """ | |
| pad_pred = pad_outputs.view(pad_targets.size(0), pad_targets.size(1), | |
| pad_outputs.size(1)).argmax(2) | |
| mask = pad_targets != ignore_label | |
| numerator = torch.sum( | |
| pad_pred.masked_select(mask) == pad_targets.masked_select(mask)) | |
| denominator = torch.sum(mask) | |
| return (numerator / denominator).detach() | |
| def subsequent_mask( | |
| size: int, | |
| device: torch.device = torch.device("cpu"), | |
| ) -> torch.Tensor: | |
| """Create mask for subsequent steps (size, size). | |
| This mask is used only in decoder which works in an auto-regressive mode. | |
| This means the current step could only do attention with its left steps. | |
| In encoder, fully attention is used when streaming is not necessary and | |
| the sequence is not long. In this case, no attention mask is needed. | |
| When streaming is need, chunk-based attention is used in encoder. See | |
| subsequent_chunk_mask for the chunk-based attention mask. | |
| Args: | |
| size (int): size of mask | |
| str device (str): "cpu" or "cuda" or torch.Tensor.device | |
| dtype (torch.device): result dtype | |
| Returns: | |
| torch.Tensor: mask | |
| Examples: | |
| >>> subsequent_mask(3) | |
| [[1, 0, 0], | |
| [1, 1, 0], | |
| [1, 1, 1]] | |
| """ | |
| arange = torch.arange(size, device=device) | |
| mask = arange.expand(size, size) | |
| arange = arange.unsqueeze(-1) | |
| mask = mask <= arange | |
| return mask | |
| def subsequent_chunk_mask( | |
| size: int, | |
| chunk_size: int, | |
| num_left_chunks: int = -1, | |
| device: torch.device = torch.device("cpu"), | |
| ) -> torch.Tensor: | |
| """Create mask for subsequent steps (size, size) with chunk size, | |
| this is for streaming encoder | |
| Args: | |
| size (int): size of mask | |
| chunk_size (int): size of chunk | |
| num_left_chunks (int): number of left chunks | |
| <0: use full chunk | |
| >=0: use num_left_chunks | |
| device (torch.device): "cpu" or "cuda" or torch.Tensor.device | |
| Returns: | |
| torch.Tensor: mask | |
| Examples: | |
| >>> subsequent_chunk_mask(4, 2) | |
| [[1, 1, 0, 0], | |
| [1, 1, 0, 0], | |
| [1, 1, 1, 1], | |
| [1, 1, 1, 1]] | |
| """ | |
| ret = torch.zeros(size, size, device=device, dtype=torch.bool) | |
| for i in range(size): | |
| if num_left_chunks < 0: | |
| start = 0 | |
| else: | |
| start = max((i // chunk_size - num_left_chunks) * chunk_size, 0) | |
| ending = min((i // chunk_size + 1) * chunk_size, size) | |
| ret[i, start:ending] = True | |
| return ret | |
| def add_optional_chunk_mask(xs: torch.Tensor, | |
| masks: torch.Tensor, | |
| use_dynamic_chunk: bool, | |
| use_dynamic_left_chunk: bool, | |
| decoding_chunk_size: int, | |
| static_chunk_size: int, | |
| num_decoding_left_chunks: int, | |
| enable_full_context: bool = True): | |
| """ Apply optional mask for encoder. | |
| Args: | |
| xs (torch.Tensor): padded input, (B, L, D), L for max length | |
| mask (torch.Tensor): mask for xs, (B, 1, L) | |
| use_dynamic_chunk (bool): whether to use dynamic chunk or not | |
| use_dynamic_left_chunk (bool): whether to use dynamic left chunk for | |
| training. | |
| decoding_chunk_size (int): decoding chunk size for dynamic chunk, it's | |
| 0: default for training, use random dynamic chunk. | |
| <0: for decoding, use full chunk. | |
| >0: for decoding, use fixed chunk size as set. | |
| static_chunk_size (int): chunk size for static chunk training/decoding | |
| if it's greater than 0, if use_dynamic_chunk is true, | |
| this parameter will be ignored | |
| num_decoding_left_chunks: number of left chunks, this is for decoding, | |
| the chunk size is decoding_chunk_size. | |
| >=0: use num_decoding_left_chunks | |
| <0: use all left chunks | |
| enable_full_context (bool): | |
| True: chunk size is either [1, 25] or full context(max_len) | |
| False: chunk size ~ U[1, 25] | |
| Returns: | |
| torch.Tensor: chunk mask of the input xs. | |
| """ | |
| # Whether to use chunk mask or not | |
| if use_dynamic_chunk: | |
| max_len = xs.size(1) | |
| if decoding_chunk_size < 0: | |
| chunk_size = max_len | |
| num_left_chunks = -1 | |
| elif decoding_chunk_size > 0: | |
| chunk_size = decoding_chunk_size | |
| num_left_chunks = num_decoding_left_chunks | |
| else: | |
| # chunk size is either [1, 25] or full context(max_len). | |
| # Since we use 4 times subsampling and allow up to 1s(100 frames) | |
| # delay, the maximum frame is 100 / 4 = 25. | |
| chunk_size = torch.randint(1, max_len, (1, )).item() | |
| num_left_chunks = -1 | |
| if chunk_size > max_len // 2 and enable_full_context: | |
| chunk_size = max_len | |
| else: | |
| chunk_size = chunk_size % 25 + 1 | |
| if use_dynamic_left_chunk: | |
| max_left_chunks = (max_len - 1) // chunk_size | |
| num_left_chunks = torch.randint(0, max_left_chunks, | |
| (1, )).item() | |
| chunk_masks = subsequent_chunk_mask(xs.size(1), chunk_size, | |
| num_left_chunks, | |
| xs.device) # (L, L) | |
| chunk_masks = chunk_masks.unsqueeze(0) # (1, L, L) | |
| chunk_masks = masks & chunk_masks # (B, L, L) | |
| elif static_chunk_size > 0: | |
| num_left_chunks = num_decoding_left_chunks | |
| chunk_masks = subsequent_chunk_mask(xs.size(1), static_chunk_size, | |
| num_left_chunks, | |
| xs.device) # (L, L) | |
| chunk_masks = chunk_masks.unsqueeze(0) # (1, L, L) | |
| chunk_masks = masks & chunk_masks # (B, L, L) | |
| else: | |
| chunk_masks = masks | |
| return chunk_masks | |
| def make_pad_mask(lengths: torch.Tensor, max_len: int = 0) -> torch.Tensor: | |
| """Make mask tensor containing indices of padded part. | |
| See description of make_non_pad_mask. | |
| Args: | |
| lengths (torch.Tensor): Batch of lengths (B,). | |
| Returns: | |
| torch.Tensor: Mask tensor containing indices of padded part. | |
| Examples: | |
| >>> lengths = [5, 3, 2] | |
| >>> make_pad_mask(lengths) | |
| masks = [[0, 0, 0, 0 ,0], | |
| [0, 0, 0, 1, 1], | |
| [0, 0, 1, 1, 1]] | |
| """ | |
| batch_size = lengths.size(0) | |
| max_len = max_len if max_len > 0 else lengths.max().item() | |
| seq_range = torch.arange(0, | |
| max_len, | |
| dtype=torch.int64, | |
| device=lengths.device) | |
| seq_range_expand = seq_range.unsqueeze(0).expand(batch_size, max_len) | |
| seq_length_expand = lengths.unsqueeze(-1) | |
| mask = seq_range_expand >= seq_length_expand | |
| return mask | |
| qwen_conf = { | |
| "architectures": [ | |
| "Qwen2ForCausalLM" | |
| ], | |
| "attention_dropout": 0.0, | |
| "bos_token_id": 151643, | |
| "eos_token_id": 151643, | |
| "hidden_act": "silu", | |
| "hidden_size": 512, | |
| "initializer_range": 0.02, | |
| "intermediate_size": 2048, | |
| "max_position_embeddings": 32768, | |
| "max_window_layers": 24, | |
| "model_type": "qwen2", | |
| "num_attention_heads": 16, | |
| "num_hidden_layers": 24, | |
| "num_key_value_heads": 2, | |
| "rms_norm_eps": 1e-06, | |
| "rope_theta": 1000000.0, | |
| "sliding_window": 32768, | |
| "tie_word_embeddings": False, | |
| "torch_dtype": "bfloat16", | |
| "transformers_version": "4.40.1", | |
| "use_cache": True, | |
| "use_mrope": False, | |
| "use_sliding_window": False, | |
| "vocab_size": 1024 | |
| } | |
| DTYPES = { | |
| "bf16": torch.bfloat16, | |
| "fp16": torch.float16, | |
| } | |
| IGNORE_ID = -100 | |
| MAX_TEXT_TOKEN = 1024 | |
| BERT_DIM = 1024 | |
| SPK_EMB_DIM = 256 | |
| class QwenEmbeddingEncoder(nn.Module): | |
| def __init__( | |
| self, | |
| n_vocab, | |
| dtype: str = "bf16" | |
| ): | |
| super(QwenEmbeddingEncoder, self).__init__() | |
| self.dtype = DTYPES.get(dtype, torch.float32) | |
| config = Qwen2Config(**qwen_conf) | |
| self.model = AutoModelForCausalLM.from_config(config) | |
| self.hidden_size = self.model.config.hidden_size | |
| self.model.model.embed_tokens = None | |
| self.model.lm_head = nn.Linear(self.hidden_size, n_vocab) | |
| def forward( | |
| self, | |
| input_embeds: torch.Tensor, | |
| input_masks: torch.Tensor, | |
| ): | |
| # if input_masks is not None: | |
| # input_masks = input_masks.squeeze(1).long() | |
| # else: | |
| # input_masks = torch.ones(input_embeds.size(0), input_embeds.size(1), device=input_embeds.device, dtype=torch.long) | |
| batch_size, seq_len = input_embeds.shape[:2] | |
| num_heads = self.model.config.num_attention_heads | |
| # # 生成三维掩码 [batch_size, seq_len, seq_len] | |
| # mask_3d = input_masks.unsqueeze(1) * input_masks.unsqueeze(2) | |
| # mask_4d = mask_3d.unsqueeze(1).expand(-1, num_heads, -1, -1) | |
| # 转换为加法掩码:无效位置为-inf,有效位置为0 | |
| attn_bias = torch.zeros(batch_size, num_heads, seq_len, seq_len, device=input_embeds.device, dtype=input_embeds.dtype) | |
| # attn_bias.masked_fill_(mask_4d == 0, float('-inf')) | |
| outs = self.model( | |
| inputs_embeds=input_embeds, | |
| attention_mask=attn_bias, | |
| output_hidden_states=True, | |
| return_dict=True, | |
| ) | |
| return outs.logits | |
| if __name__ == "__main__": | |
| model = QwenEmbeddingEncoder(n_vocab=1000) | |
| print('model.lm_head.weight', model.model.get_output_embeddings().weight.size()) | |
| print('n params:', sum([p.numel() for p in model.parameters()])/1e6, 'M') | |
| input_embeds = torch.randn(2, 5, 512) | |
| ilens = torch.tensor([5, 3]) | |
| outs, input_masks = model(input_embeds, ilens) | |
| y = torch.randn(2, 5, 1000) | |
| loss = (outs-y).pow(2).sum() | |
| loss.backward() | |
| for name, param in model.named_parameters(): | |
| if param.grad is None: | |
| print(name, 'has no grad') | |
| # print(outs.size(), input_masks) |