| """This file contains implementation for MaskGIT model. |
| |
| Copyright (2024) Bytedance Ltd. and/or its affiliates |
| |
| 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. |
| |
| Reference: |
| https://github.com/huggingface/open-muse |
| https://github.com/baaivision/MUSE-Pytorch |
| https://github.com/sail-sg/MDT/blob/main/masked_diffusion/models.py |
| """ |
|
|
| import torch |
| from torch import nn |
| import numpy as np |
| import math |
| import torch.utils.checkpoint |
| from tqdm import tqdm |
| from transformers import BertConfig, BertModel |
| from einops import rearrange |
|
|
| import json |
| from huggingface_hub import PyTorchModelHubMixin |
| from omegaconf import OmegaConf |
| from pathlib import Path |
|
|
| """This file contains some base class implementation for models. |
| |
| This file may have been modified by Bytedance Ltd. and/or its affiliates (“Bytedance's Modifications”). |
| All Bytedance's Modifications are Copyright (year) Bytedance Ltd. and/or its affiliates. |
| |
| Reference: |
| https://github.com/huggingface/open-muse/blob/main/muse/modeling_utils.py |
| """ |
| import os |
| from typing import Union, Callable, Dict, Optional |
|
|
| import torch |
| from transformer.embedding import SinePositionalEmbedding |
| from transformer.transformer import LayerNorm, TransformerEncoder, TransformerEncoderLayer |
|
|
| class BaseModel(torch.nn.Module): |
|
|
| def __init__(self): |
| super().__init__() |
|
|
| def save_pretrained_weight( |
| self, |
| save_directory: Union[str, os.PathLike], |
| save_function: Callable = None, |
| state_dict: Optional[Dict[str, torch.Tensor]] = None, |
| ): |
| """Saves a model and its configuration file to a directory. |
| |
| Args: |
| save_directory: A string or os.PathLike, directory to which to save. |
| Will be created if it doesn't exist. |
| save_function: A Callable function, the function to use to save the state dictionary. |
| Useful on distributed training like TPUs when one need to replace `torch.save` by |
| another method. Can be configured with the environment variable `DIFFUSERS_SAVE_MODE`. |
| state_dict: A dictionary from str to torch.Tensor, the state dictionary to save. |
| If `None`, the model's state dictionary will be saved. |
| """ |
| if os.path.isfile(save_directory): |
| print(f"Provided path ({save_directory}) should be a directory, not a file") |
| return |
|
|
| if save_function is None: |
| save_function = torch.save |
|
|
| os.makedirs(save_directory, exist_ok=True) |
|
|
| model_to_save = self |
|
|
| if state_dict is None: |
| state_dict = model_to_save.state_dict() |
| weights_name = "pytorch_model.bin" |
|
|
| save_function(state_dict, os.path.join(save_directory, weights_name)) |
|
|
| print(f"Model weights saved in {os.path.join(save_directory, weights_name)}") |
|
|
| def load_pretrained_weight( |
| self, |
| pretrained_model_path: Union[str, os.PathLike], |
| strict_loading: bool = True, |
| torch_dtype: Optional[torch.dtype] = None |
| ): |
| r"""Instantiates a pretrained pytorch model from a pre-trained model configuration. |
| |
| The model is set in evaluation mode by default using `model.eval()` (Dropout modules are deactivated). To train |
| the model, you should first set it back in training mode with `model.train()`. |
| |
| Args: |
| pretrained_model_path: A string or os.PathLike, a path to a *directory* or *file* containing model weights. |
| |
| Raises: |
| ValueError: If pretrained_model_path does not exist. |
| """ |
| |
| if os.path.isfile(pretrained_model_path): |
| model_file = pretrained_model_path |
| |
| |
| elif os.path.isdir(pretrained_model_path): |
| pretrained_model_path = os.path.join(pretrained_model_path, "pytorch_model.bin") |
| if os.path.isfile(pretrained_model_path): |
| model_file = pretrained_model_path |
| else: |
| raise ValueError(f"{pretrained_model_path} does not exist") |
| else: |
| raise ValueError(f"{pretrained_model_path} does not exist") |
|
|
| |
| checkpoint = torch.load(model_file, map_location="cpu") |
| |
| msg = self.load_state_dict(checkpoint, strict=strict_loading) |
| |
| print(f"loading weight from {model_file}, msg: {msg}") |
| |
| if torch_dtype is not None and not isinstance(torch_dtype, torch.dtype): |
| raise ValueError( |
| f"{torch_dtype} needs to be of type `torch.dtype`, e.g. `torch.float16`, but is {type(torch_dtype)}." |
| ) |
| elif torch_dtype is not None: |
| self.to(torch_dtype) |
|
|
| |
| self.eval() |
|
|
| def num_parameters(self, only_trainable: bool = False, exclude_embeddings: bool = False) -> int: |
| """Gets the number of parameters in the module. |
| |
| Args: |
| only_trainable: A boolean, whether to only include trainable parameters. |
| exclude_embeddings: A boolean, whether to exclude parameters associated with embeddings. |
| |
| Returns: |
| An integer, the number of parameters. |
| """ |
|
|
| if exclude_embeddings: |
| embedding_param_names = [ |
| f"{name}.weight" |
| for name, module_type in self.named_modules() |
| if isinstance(module_type, torch.nn.Embedding) |
| ] |
| non_embedding_parameters = [ |
| parameter for name, parameter in self.named_parameters() if name not in embedding_param_names |
| ] |
| return sum(p.numel() for p in non_embedding_parameters if p.requires_grad or not only_trainable) |
| else: |
| return sum(p.numel() for p in self.parameters() if p.requires_grad or not only_trainable) |
|
|
| class ImageBert(BaseModel, PyTorchModelHubMixin, tags=["arxiv:2304.12244"], pipeline_tag="text_to_image", |
| license="mit"): |
| def __init__(self, config): |
|
|
|
|
| super().__init__() |
| self.config = config |
| self.target_codebook_size = config.model.vq_model.codebook_size |
| self.condition_dim = config.model.generator.condition_dim |
| self.image_seq_len = config.model.generator.image_seq_len |
| self.mask_token_id = self.target_codebook_size |
| self.hidden_size = config.model.generator.hidden_size |
| self.num_hidden_layers = config.model.generator.num_hidden_layers |
| self.num_attention_heads = config.model.generator.num_attention_heads |
| self.intermediate_size = config.model.generator.intermediate_size |
| self.cond_proj = nn.Linear(self.condition_dim, self.hidden_size) |
|
|
| self.word_embeddings = nn.Embedding(self.target_codebook_size+1, self.hidden_size) |
| norm_first = False |
| self.encoder = TransformerEncoder( |
| TransformerEncoderLayer( |
| d_model=self.hidden_size, |
| nhead=16, |
| dim_feedforward=2048, |
| dropout=0.1, |
| batch_first=True, |
| norm_first=False, ), |
| num_layers=12, |
| norm=LayerNorm(self.hidden_size) if norm_first else None, ) |
| self.num_head = 16 |
| self.position = SinePositionalEmbedding( |
| self.hidden_size, dropout=0.1, scale=False, alpha=True) |
|
|
|
|
|
|
| self.lm_head = nn.Linear(self.hidden_size, self.target_codebook_size, bias=True) |
|
|
|
|
| def _save_pretrained(self, save_directory: Path) -> None: |
| """Save weights and config to a local directory.""" |
| |
| |
| dict_config = OmegaConf.to_container(self.config) |
| |
| file_path = Path(save_directory) / "config.json" |
| with open(file_path, 'w') as json_file: |
| json.dump(dict_config, json_file, indent=4) |
| super()._save_pretrained(save_directory) |
|
|
| def forward(self, input_ids=None, condition=None, cond_drop_prob=0.1): |
| |
| |
| |
| |
| |
| drop_label_mask = torch.rand(condition.shape[0], dtype=torch.float) < cond_drop_prob |
| condition[drop_label_mask] = 0 |
|
|
| condition = self.cond_proj(condition) |
| inputs_embeds = self.word_embeddings(input_ids) |
| inputs_embeds = inputs_embeds + condition |
|
|
|
|
| x = self.position(inputs_embeds) |
| model_output, _ = self.encoder( |
| (x, None), src_key_padding_mask=None) |
|
|
| return self.lm_head(model_output) |
|
|
| |
| @torch.no_grad() |
| def generate(self, |
| condition, |
| guidance_scale=3.0, |
| guidance_decay="constant", |
| guidance_scale_pow=3.0, |
| randomize_temperature=4.5, |
| softmax_temperature_annealing=False, |
| num_sample_steps=8): |
| if guidance_decay not in ["constant", "linear", "power-cosine"]: |
| |
| |
| |
| raise ValueError(f"Unsupported guidance decay {guidance_decay}") |
| device = condition.device |
| image_seq_len = condition.shape[1] |
| ids = torch.full((condition.shape[0], image_seq_len), |
| self.mask_token_id, device=device) |
|
|
| cfg_scale = guidance_scale if guidance_decay == "constant" else 0. |
|
|
| for step in tqdm(range(num_sample_steps)): |
| ratio = 1. * (step + 1) / num_sample_steps |
| annealed_temp = randomize_temperature * (1.0 - ratio) |
| is_mask = (ids == self.mask_token_id) |
|
|
| if guidance_decay == "power-cosine": |
| |
| guidance_scale_pow = torch.ones((1), device=device) * guidance_scale_pow |
| scale_step = (1 - torch.cos(((step / num_sample_steps) ** guidance_scale_pow) * torch.pi)) * 1 / 2 |
| cfg_scale = (guidance_scale - 1) * scale_step + 1 |
|
|
| if cfg_scale != 0: |
| cond_logits = self.forward( |
| ids, condition, cond_drop_prob=0.0 |
| ) |
| uncond_logits = self.forward( |
| ids, condition, cond_drop_prob=1.0 |
| ) |
| if guidance_decay == "power-cosine": |
| logits = uncond_logits + (cond_logits - uncond_logits) * cfg_scale |
| else: |
| logits = cond_logits + (cond_logits - uncond_logits) * cfg_scale |
| else: |
| logits = self.forward( |
| ids, condition, cond_drop_prob=0.0 |
| ) |
|
|
| if softmax_temperature_annealing: |
| softmax_temperature = 0.5 + 0.8 * (1 - ratio) |
| logits = logits / softmax_temperature |
|
|
| |
| def log(t, eps=1e-20): |
| return torch.log(t.clamp(min=eps)) |
|
|
| def gumbel_noise(t): |
| noise = torch.zeros_like(t).uniform_(0, 1) |
| return -log(-log(noise)) |
|
|
| def add_gumbel_noise(t, temperature): |
| return t + temperature * gumbel_noise(t) |
|
|
| sampled_ids = add_gumbel_noise(logits, annealed_temp).argmax(dim=-1) |
| sampled_logits = torch.squeeze( |
| torch.gather(logits, dim=-1, index=torch.unsqueeze(sampled_ids, -1)), -1) |
| sampled_ids = torch.where(is_mask, sampled_ids, ids) |
| sampled_logits = torch.where(is_mask, sampled_logits, +np.inf).float() |
| |
| mask_ratio = np.arccos(ratio) / (math.pi * 0.5) |
|
|
| mask_len = torch.Tensor([np.floor(image_seq_len * mask_ratio)]).to(device) |
| mask_len = torch.maximum(torch.Tensor([1]).to(device), |
| torch.minimum(torch.sum(is_mask, dim=-1, keepdims=True) - 1, |
| mask_len))[0].squeeze() |
| confidence = add_gumbel_noise(sampled_logits, annealed_temp) |
| sorted_confidence, _ = torch.sort(confidence, axis=-1) |
| cut_off = sorted_confidence[:, mask_len.long() - 1:mask_len.long()] |
| masking = (confidence <= cut_off) |
| if step == num_sample_steps - 1: |
| ids = sampled_ids |
| else: |
| ids = torch.where(masking, self.mask_token_id, sampled_ids) |
|
|
| if guidance_decay == "linear": |
| cfg_scale = ratio * guidance_scale |
| return ids |
|
|
| def masking_input_tokens(self, input_tokens): |
| batch_size, seq_len = input_tokens.shape |
| device = input_tokens.device |
|
|
| timesteps = torch.zeros((batch_size,), device=device).float().uniform_(0, 1.0) |
| mask_ratio = torch.acos(timesteps) / (math.pi * 0.5) |
| mask_ratio = torch.clamp(mask_ratio, min=1e-6, max=1.) |
| num_token_masked = (seq_len * mask_ratio).round().clamp(min=1) |
| batch_randperm = torch.rand(batch_size, seq_len, device=device).argsort(dim=-1) |
| masks = batch_randperm < rearrange(num_token_masked, 'b -> b 1') |
| masked_tokens = torch.where(masks, self.mask_token_id, input_tokens) |
| return masked_tokens, masks |
|
|
|
|
| class MLMLoss(torch.nn.Module): |
| def __init__(self, |
| config): |
| super().__init__() |
| self.label_smoothing = config.losses.label_smoothing |
| self.loss_weight_unmasked_token = config.losses.loss_weight_unmasked_token |
| self.criterion = torch.nn.CrossEntropyLoss(label_smoothing=self.label_smoothing, |
| reduction="none") |
|
|
| def forward(self, inputs: torch.Tensor, targets: torch.Tensor, |
| weights=None): |
| inputs = rearrange(inputs, "b n c -> b c n") |
| loss = self.criterion(inputs, targets) |
| weights = weights.to(loss) |
| loss_weights = ( |
| 1.0 - weights) * self.loss_weight_unmasked_token + weights |
| loss = (loss * loss_weights).sum() / (loss_weights.sum() + 1e-8) |
| |
| correct_tokens = ((torch.argmax(inputs, dim=1) == targets) * weights).sum(dim=1) / (weights.sum(1) + 1e-8) |
| return loss, {"loss": loss, "correct_tokens": correct_tokens.mean()} |
|
|
|
|
| if __name__ == '__main__': |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| conf = { |
| "model": { |
| "vq_model": { |
| "codebook_size": 512, |
| "token_size": 12, |
| "use_l2_norm": True, |
| "commitment_cost": 0.25, |
| "vit_enc_model_size": "base", |
| "vit_dec_model_size": "base", |
| "vit_enc_patch_size": 16, |
| "vit_dec_patch_size": 16, |
| "num_latent_tokens": 64, |
| "finetune_decoder": True |
| }, |
| "generator": { |
| "model_type": "ViT", |
| "hidden_size": 512, |
| "num_hidden_layers": 12, |
| "num_attention_heads": 16, |
| "intermediate_size": 2048, |
| "dropout": 0.1, |
| "attn_drop": 0.1, |
| "num_steps": 8, |
| "class_label_dropout": 0.1, |
| "image_seq_len": 100, |
| "condition_dim": 192, |
| "randomize_temperature": 1.0, |
| "guidance_scale": 4.5, |
| "guidance_decay": "constant" |
| } |
|
|
| }, |
| "losses": { |
| "label_smoothing": 0.1, |
| "loss_weight_unmasked_token": 0.1 |
| } |
|
|
| } |
| config = OmegaConf.create(conf) |
| loss_module = MLMLoss(config) |
| model = ImageBert(config) |
| print(model) |
| print("n params", sum(p.numel() for p in model.parameters() if p.requires_grad)/1e6, "M") |
| input_tokens = torch.randint(0, 512, (2, 100)) |
| masked_tokens, masks = model.masking_input_tokens( |
| input_tokens) |
| conditions = torch.randn(2, 100, 192) |
| logits = model(masked_tokens, conditions, |
| cond_drop_prob=0.1) |
| print(logits.shape) |
|
|
| loss, loss_dict = loss_module(logits, input_tokens, weights=masks) |
| print(loss, loss_dict) |
| ids = model.generate( |
| conditions |
| ) |
| print(ids) |
