From 423698658147ca98085bc20cb6ab0fdf867a9c84 Mon Sep 17 00:00:00 2001 From: 1hb6s7t <120760709+1hb6s7t@users.noreply.github.com> Date: Fri, 7 Feb 2025 15:09:48 +0800 Subject: [PATCH 01/20] Add files via upload --- .../transformers/models/jukebox/__init__.py | 9 + .../models/jukebox/configuration_jukebox.py | 618 ++++ .../models/jukebox/modeling_jukebox.py | 2604 +++++++++++++++++ .../models/jukebox/tokenization_jukebox.py | 342 +++ 4 files changed, 3573 insertions(+) create mode 100644 mindnlp/transformers/models/jukebox/__init__.py create mode 100644 mindnlp/transformers/models/jukebox/configuration_jukebox.py create mode 100644 mindnlp/transformers/models/jukebox/modeling_jukebox.py create mode 100644 mindnlp/transformers/models/jukebox/tokenization_jukebox.py diff --git a/mindnlp/transformers/models/jukebox/__init__.py b/mindnlp/transformers/models/jukebox/__init__.py new file mode 100644 index 000000000..72b15e68f --- /dev/null +++ b/mindnlp/transformers/models/jukebox/__init__.py @@ -0,0 +1,9 @@ +from . import configuration_jukebox, modeling_jukebox, tokenization_jukebox +from .configuration_jukebox import * +from .modeling_jukebox import * +from .tokenization_jukebox import * + +__all__ = [] +__all__.extend(configuration_jukebox.__all__) +__all__.extend(modeling_jukebox.__all__) +__all__.extend(tokenization_jukebox.__all__) \ No newline at end of file diff --git a/mindnlp/transformers/models/jukebox/configuration_jukebox.py b/mindnlp/transformers/models/jukebox/configuration_jukebox.py new file mode 100644 index 000000000..6f981cd65 --- /dev/null +++ b/mindnlp/transformers/models/jukebox/configuration_jukebox.py @@ -0,0 +1,618 @@ +# coding=utf-8 +# Copyright 2022 The OpenAI Team Authors and HuggingFace Inc. team. +# +# 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. +"""Jukebox configuration""" + +import os +from typing import List, Union + +from mindnlp.utils import logging +from ...configuration_utils import PretrainedConfig + +logger = logging.get_logger(__name__) + + +_LARGE_ATTENTION = [ + "block_attn", + "transpose_block_attn", + "prev_block_attn", + "block_attn", + "transpose_block_attn", + "prev_block_attn", + "block_attn", + "transpose_block_attn", + "prev_block_attn", + "block_attn", + "transpose_block_attn", + "prev_block_attn", + "block_attn", + "transpose_block_attn", + "prev_block_attn", + "block_attn", + "transpose_block_attn", + "prev_block_attn", + "cross_attention", + "block_attn", + "transpose_block_attn", + "prev_block_attn", + "block_attn", + "transpose_block_attn", + "prev_block_attn", + "block_attn", + "transpose_block_attn", + "prev_block_attn", + "cross_attention", + "block_attn", + "transpose_block_attn", + "prev_block_attn", + "block_attn", + "transpose_block_attn", + "prev_block_attn", + "block_attn", + "transpose_block_attn", + "prev_block_attn", + "cross_attention", + "block_attn", + "transpose_block_attn", + "prev_block_attn", + "block_attn", + "transpose_block_attn", + "prev_block_attn", + "block_attn", + "transpose_block_attn", + "prev_block_attn", + "cross_attention", + "block_attn", + "transpose_block_attn", + "prev_block_attn", + "block_attn", + "transpose_block_attn", + "prev_block_attn", + "block_attn", + "transpose_block_attn", + "prev_block_attn", + "cross_attention", + "block_attn", + "transpose_block_attn", + "prev_block_attn", + "block_attn", + "transpose_block_attn", + "prev_block_attn", + "block_attn", + "transpose_block_attn", + "prev_block_attn", + "cross_attention", + "block_attn", + "transpose_block_attn", + "prev_block_attn", + "block_attn", + "transpose_block_attn", + "prev_block_attn", + "block_attn", + "transpose_block_attn", + "prev_block_attn", + "cross_attention", +] +_RawColumnPreviousRowAttention = ["block_attn", "transpose_block_attn", "prev_block_attn"] +_FullDenseAttention = ["dense_attention"] +_PrimePrimeDenseAttention = ["prime_attn", "prime_attn", "dense_attn"] + + +def full_dense_attention(layer): + return _FullDenseAttention[0] + + +def raw_column_previous_row_attention(layer): + return _RawColumnPreviousRowAttention[layer % 3] + + +def large_separated_enc_dec_w_lyrics(layer): + return _LARGE_ATTENTION[layer % 79] + + +def enc_dec_with_lyrics(layer): + if layer % 16 == 15: + return _PrimePrimeDenseAttention[layer % 3] + return _RawColumnPreviousRowAttention[layer % 3] + + +ATTENTION_PATTERNS = { + "full_dense_attention": full_dense_attention, + "raw_column_previous_row_attention": raw_column_previous_row_attention, # Alternate row, column and previous row attn + "large_separated_enc_dec_w_lyrics": large_separated_enc_dec_w_lyrics, # Used by large separated_enc_dec model with lyrics + "enc_dec_with_lyrics": enc_dec_with_lyrics, # Used by encoder_decoder model with lyrics +} + + +class JukeboxPriorConfig(PretrainedConfig): + """ + This is the configuration class to store the configuration of a [`JukeboxPrior`]. It is used to instantiate a + `JukeboxPrior` according to the specified arguments, defining the model architecture. Instantiating a + configuration with the defaults will yield a similar configuration to that of the top level prior from the + [openai/jukebox-1b-lyrics](https://huggingface.co/openai/jukebox + -1b-lyrics) architecture. + + Configuration objects inherit from [`PretrainedConfig`] and can be used to control the model outputs. Read the + documentation from [`PretrainedConfig`] for more information. + + + + Args: + act_fn (`str`, *optional*, defaults to `"quick_gelu"`): + Activation function. + alignment_head (`int`, *optional*, defaults to 2): + Head that is responsible of the alignment between lyrics and music. Only used to compute the lyric to audio + alignment + alignment_layer (`int`, *optional*, defaults to 68): + Index of the layer that is responsible of the alignment between lyrics and music. Only used to compute the + lyric to audio alignment + attention_multiplier (`float`, *optional*, defaults to 0.25): + Multiplier coefficient used to define the hidden dimension of the attention layers. 0.25 means that + 0.25*width of the model will be used. + attention_pattern (`str`, *optional*, defaults to `"enc_dec_with_lyrics"`): + Which attention pattern to use for the decoder/ + attn_dropout (`int`, *optional*, defaults to 0): + Dropout probability for the post-attention layer dropout in the decoder. + attn_res_scale (`bool`, *optional*, defaults to `False`): + Whether or not to scale the residuals in the attention conditioner block. + blocks (`int`, *optional*, defaults to 64): + Number of blocks used in the `block_attn`. A sequence of length seq_len is factored as `[blocks, seq_len // + blocks]` in the `JukeboxAttention` layer. + conv_res_scale (`int`, *optional*): + Whether or not to scale the residuals in the conditioner block. Since the top level prior does not have a + conditioner, the default value is to None and should not be modified. + num_layers (`int`, *optional*, defaults to 72): + Number of layers of the transformer architecture. + emb_dropout (`int`, *optional*, defaults to 0): + Embedding dropout used in the lyric decoder. + encoder_config (`JukeboxPriorConfig`, *optional*) : + Configuration of the encoder which models the prior on the lyrics. + encoder_loss_fraction (`float`, *optional*, defaults to 0.4): + Multiplication factor used in front of the lyric encoder loss. + hidden_size (`int`, *optional*, defaults to 2048): + Hidden dimension of the attention layers. + init_scale (`float`, *optional*, defaults to 0.2): + Initialization scales for the prior modules. + is_encoder_decoder (`bool`, *optional*, defaults to `True`): + Whether or not the prior is an encoder-decoder model. In case it is not, and `nb_relevant_lyric_tokens` is + greater than 0, the `encoder` args should be specified for the lyric encoding. + mask (`bool`, *optional*, defaults to `False`): + Whether or not to mask the previous positions in the attention. + max_duration (`int`, *optional*, defaults to 600): + Maximum supported duration of the generated song in seconds. + max_nb_genres (`int`, *optional*, defaults to 1): + Maximum number of genres that can be used to condition the model. + merged_decoder (`bool`, *optional*, defaults to `True`): + Whether or not the decoder and the encoder inputs are merged. This is used for the separated + encoder-decoder architecture + metadata_conditioning (`bool`, *optional*, defaults to `True)`: + Whether or not to condition on the artist and genre metadata. + metadata_dims (`List[int]`, *optional*, defaults to `[604, 7898]`): + Number of genres and the number of artists that were used to train the embedding layers of the prior + models. + min_duration (`int`, *optional*, defaults to 0): + Minimum duration of the generated audio on which the model was trained. + mlp_multiplier (`float`, *optional*, defaults to 1.0): + Multiplier coefficient used to define the hidden dimension of the MLP layers. 0.25 means that 0.25*width of + the model will be used. + music_vocab_size (`int`, *optional*, defaults to 2048): + Number of different music tokens. Should be similar to the `JukeboxVQVAEConfig.nb_discrete_codes`. + n_ctx (`int`, *optional*, defaults to 6144): + Number of context tokens for each prior. The context tokens are the music tokens that are attended to when + generating music tokens. + n_heads (`int`, *optional*, defaults to 2): + Number of attention heads. + nb_relevant_lyric_tokens (`int`, *optional*, defaults to 384): + Number of lyric tokens that are used when sampling a single window of length `n_ctx` + res_conv_depth (`int`, *optional*, defaults to 3): + Depth of the `JukeboxDecoderConvBock` used to upsample the previously sampled audio in the + `JukeboxMusicTokenConditioner`. + res_conv_width (`int`, *optional*, defaults to 128): + Width of the `JukeboxDecoderConvBock` used to upsample the previously sampled audio in the + `JukeboxMusicTokenConditioner`. + res_convolution_multiplier (`int`, *optional*, defaults to 1): + Multiplier used to scale the `hidden_dim` of the `JukeboxResConv1DBlock`. + res_dilation_cycle (`int`, *optional*): + Dilation cycle used to define the `JukeboxMusicTokenConditioner`. Usually similar to the ones used in the + corresponding level of the VQVAE. The first prior does not use it as it is not conditioned on upper level + tokens. + res_dilation_growth_rate (`int`, *optional*, defaults to 1): + Dilation grow rate used between each convolutionnal block of the `JukeboxMusicTokenConditioner` + res_downs_t (`List[int]`, *optional*, defaults to `[3, 2, 2]`): + Downsampling rates used in the audio conditioning network + res_strides_t (`List[int]`, *optional*, defaults to `[2, 2, 2]`): + Striding used in the audio conditioning network + resid_dropout (`int`, *optional*, defaults to 0): + Residual dropout used in the attention pattern. + sampling_rate (`int`, *optional*, defaults to 44100): + Sampling rate used for training. + spread (`int`, *optional*): + Spread used in the `summary_spread_attention` pattern + timing_dims (`int`, *optional*, defaults to 64): + Dimension of the timing embedding. + zero_out (`bool`, *optional*, defaults to `False`): + Whether or not to zero out convolution weights when initializing. + """ + + model_type = "jukebox_prior" + attribute_map = { + "max_position_embeddings": "n_positions", + "num_attention_heads": "n_head", + } + + def __init__( + self, + act_fn="quick_gelu", + level=0, + alignment_head=2, + alignment_layer=68, + attention_multiplier=0.25, + attention_pattern="enc_dec_with_lyrics", + attn_dropout=0, + attn_res_scale=False, + blocks=64, + conv_res_scale=None, + num_layers=72, + emb_dropout=0, + encoder_config=None, + encoder_loss_fraction=0.4, + hidden_size=2048, + init_scale=0.2, + is_encoder_decoder=True, + lyric_vocab_size=80, + mask=False, + max_duration=600, + max_nb_genres=1, + merged_decoder=True, + metadata_conditioning=True, + metadata_dims=[604, 7898], + min_duration=0, + mlp_multiplier=1.0, + music_vocab_size=2048, + n_ctx=6144, + n_heads=2, + nb_relevant_lyric_tokens=384, + res_conv_depth=3, + res_conv_width=128, + res_convolution_multiplier=1, + res_dilation_cycle=None, + res_dilation_growth_rate=1, + res_downs_t=[3, 2, 2], + res_strides_t=[2, 2, 2], + resid_dropout=0, + sampling_rate=44100, + spread=None, + timing_dims=64, + zero_out=False, + **kwargs, + ): + super().__init__(**kwargs) + + self.act_fn = act_fn + self.alignment_head = alignment_head + self.alignment_layer = alignment_layer + self.attention_multiplier = attention_multiplier + self.attention_pattern = attention_pattern + self.attn_dropout = attn_dropout + self.attn_res_scale = attn_res_scale + self.blocks = blocks + self.conv_res_scale = conv_res_scale + self.num_layers = num_layers + self.emb_dropout = emb_dropout + self.music_vocab_size = music_vocab_size + if encoder_config is not None: + self.encoder_config = JukeboxPriorConfig(**encoder_config) + else: + self.encoder_config = None + self.encoder_loss_fraction = encoder_loss_fraction + self.init_scale = init_scale + self.is_encoder_decoder = is_encoder_decoder + self.lyric_vocab_size = lyric_vocab_size + self.level = level + self.mask = mask + self.max_duration = max_duration + self.max_nb_genres = max_nb_genres + self.merged_decoder = merged_decoder + self.metadata_conditioning = metadata_conditioning + self.metadata_dims = metadata_dims + self.min_duration = min_duration + self.mlp_multiplier = mlp_multiplier + self.n_ctx = n_ctx + self.n_heads = n_heads + self.nb_relevant_lyric_tokens = nb_relevant_lyric_tokens + self.res_conv_depth = res_conv_depth + self.res_conv_width = res_conv_width + self.res_convolution_multiplier = res_convolution_multiplier + self.res_dilation_cycle = res_dilation_cycle + self.res_dilation_growth_rate = res_dilation_growth_rate + self.res_downs_t = res_downs_t + self.res_strides_t = res_strides_t + self.resid_dropout = resid_dropout + self.sampling_rate = sampling_rate + self.spread = spread + self.timing_dims = timing_dims + self.hidden_size = hidden_size + self.zero_out = zero_out + + @classmethod + def from_pretrained( + cls, pretrained_model_name_or_path: Union[str, os.PathLike], level=0, **kwargs + ) -> "PretrainedConfig": + cls._set_token_in_kwargs(kwargs) + + config_dict, kwargs = cls.get_config_dict(pretrained_model_name_or_path, **kwargs) + + # get the prior config dict if we are loading from JukeboxConfig + if config_dict.get("model_type") == "jukebox": + config_dict = config_dict[f"prior_{level}"] + + if "model_type" in config_dict and hasattr(cls, "model_type") and config_dict["model_type"] != cls.model_type: + logger.warning( + f"You are using a model of type {config_dict['model_type']} to instantiate a model of type " + f"{cls.model_type}. This is not supported for all configurations of models and can yield errors." + ) + + return cls.from_dict(config_dict, **kwargs) + + +class JukeboxVQVAEConfig(PretrainedConfig): + """ + This is the configuration class to store the configuration of a [`JukeboxVQVAE`]. It is used to instantiate a + `JukeboxVQVAE` according to the specified arguments, defining the model architecture. Instantiating a configuration + with the defaults will yield a similar configuration to that of the VQVAE from + [openai/jukebox-1b-lyrics](https://huggingface.co/openai/jukebox-1b-lyrics) architecture. + + Configuration objects inherit from [`PretrainedConfig`] and can be used to control the model outputs. Read the + documentation from [`PretrainedConfig`] for more information. + + Args: + act_fn (`str`, *optional*, defaults to `"relu"`): + Activation function of the model. + nb_discrete_codes (`int`, *optional*, defaults to 2048): + Number of codes of the VQVAE. + commit (`float`, *optional*, defaults to 0.02): + Commit loss multiplier. + conv_input_shape (`int`, *optional*, defaults to 1): + Number of audio channels. + conv_res_scale (`bool`, *optional*, defaults to `False`): + Whether or not to scale the residuals of the `JukeboxResConv1DBlock`. + embed_dim (`int`, *optional*, defaults to 64): + Embedding dimension of the codebook vectors. + hop_fraction (`List[int]`, *optional*, defaults to `[0.125, 0.5, 0.5]`): + Fraction of non-intersecting window used when continuing the sampling process. + levels (`int`, *optional*, defaults to 3): + Number of hierarchical levels that used in the VQVAE. + lmu (`float`, *optional*, defaults to 0.99): + Used in the codebook update, exponential moving average coefficient. For more detail refer to Appendix A.1 + of the original [VQVAE paper](https://arxiv.org/pdf/1711.00937v2.pdf) + multipliers (`List[int]`, *optional*, defaults to `[2, 1, 1]`): + Depth and width multipliers used for each level. Used on the `res_conv_width` and `res_conv_depth` + res_conv_depth (`int`, *optional*, defaults to 4): + Depth of the encoder and decoder block. If no `multipliers` are used, this is the same for each level. + res_conv_width (`int`, *optional*, defaults to 32): + Width of the encoder and decoder block. If no `multipliers` are used, this is the same for each level. + res_convolution_multiplier (`int`, *optional*, defaults to 1): + Scaling factor of the hidden dimension used in the `JukeboxResConv1DBlock`. + res_dilation_cycle (`int`, *optional*): + Dilation cycle value used in the `JukeboxResnet`. If an int is used, each new Conv1 block will have a depth + reduced by a power of `res_dilation_cycle`. + res_dilation_growth_rate (`int`, *optional*, defaults to 3): + Resnet dilation growth rate used in the VQVAE (dilation_growth_rate ** depth) + res_downs_t (`List[int]`, *optional*, defaults to `[3, 2, 2]`): + Downsampling rate for each level of the hierarchical VQ-VAE. + res_strides_t (`List[int]`, *optional*, defaults to `[2, 2, 2]`): + Stride used for each level of the hierarchical VQ-VAE. + sample_length (`int`, *optional*, defaults to 1058304): + Provides the max input shape of the VQVAE. Is used to compute the input shape of each level. + init_scale (`float`, *optional*, defaults to 0.2): + Initialization scale. + zero_out (`bool`, *optional*, defaults to `False`): + Whether or not to zero out convolution weights when initializing. + """ + + model_type = "jukebox_vqvae" + + def __init__( + self, + act_fn="relu", + nb_discrete_codes=2048, + commit=0.02, + conv_input_shape=1, + conv_res_scale=False, + embed_dim=64, + hop_fraction=[0.125, 0.5, 0.5], + levels=3, + lmu=0.99, + multipliers=[2, 1, 1], + res_conv_depth=4, + res_conv_width=32, + res_convolution_multiplier=1, + res_dilation_cycle=None, + res_dilation_growth_rate=3, + res_downs_t=[3, 2, 2], + res_strides_t=[2, 2, 2], + sample_length=1058304, + init_scale=0.2, + zero_out=False, + **kwargs, + ): + super().__init__(**kwargs) + + self.hop_fraction = hop_fraction + self.conv_input_shape = conv_input_shape + self.sample_length = sample_length + + # VQVAE parameters (all used) + self.levels = levels + self.embed_dim = embed_dim + self.nb_discrete_codes = nb_discrete_codes + self.res_conv_width = res_conv_width + self.res_conv_depth = res_conv_depth + self.res_convolution_multiplier = res_convolution_multiplier + self.res_dilation_growth_rate = res_dilation_growth_rate + self.res_dilation_cycle = res_dilation_cycle + self.multipliers = multipliers + self.res_downs_t = res_downs_t + self.res_strides_t = res_strides_t + self.lmu = lmu + self.commit = commit + self.conv_res_scale = conv_res_scale + self.act_fn = act_fn + self.init_scale = init_scale + self.zero_out = zero_out + + @classmethod + def from_pretrained(cls, pretrained_model_name_or_path: Union[str, os.PathLike], **kwargs) -> "PretrainedConfig": + cls._set_token_in_kwargs(kwargs) + + config_dict, kwargs = cls.get_config_dict(pretrained_model_name_or_path, **kwargs) + + # get the text config dict if we are loading from CLIPConfig + if config_dict.get("model_type") == "jukebox": + config_dict = config_dict["vqvae_config"] + + if "model_type" in config_dict and hasattr(cls, "model_type") and config_dict["model_type"] != cls.model_type: + logger.warning( + f"You are using a model of type {config_dict['model_type']} to instantiate a model of type " + f"{cls.model_type}. This is not supported for all configurations of models and can yield errors." + ) + + return cls.from_dict(config_dict, **kwargs) + + +class JukeboxConfig(PretrainedConfig): + """ + This is the configuration class to store the configuration of a [`JukeboxModel`]. + + Configuration objects inherit from [`PretrainedConfig`] and can be used to control the model outputs. Read the + documentation from [`PretrainedConfig`] for more information. Instantiating a configuration with the defaults will + yield a similar configuration to that of + [openai/jukebox-1b-lyrics](https://huggingface.co/openai/jukebox-1b-lyrics) architecture. + + + The downsampling and stride are used to determine downsampling of the input sequence. For example, downsampling = + (5,3), and strides = (2, 2) will downsample the audio by 2^5 = 32 to get the first level of codes, and 2**8 = 256 + to get the second level codes. This is mostly true for training the top level prior and the upsamplers. + + Args: + vqvae_config (`JukeboxVQVAEConfig`, *optional*): + Configuration for the `JukeboxVQVAE` model. + prior_config_list (`List[JukeboxPriorConfig]`, *optional*): + List of the configs for each of the `JukeboxPrior` of the model. The original architecture uses 3 priors. + nb_priors (`int`, *optional*, defaults to 3): + Number of prior models that will sequentially sample tokens. Each prior is conditional auto regressive + (decoder) model, apart from the top prior, which can include a lyric encoder. The available models were + trained using a top prior and 2 upsampler priors. + sampling_rate (`int`, *optional*, defaults to 44100): + Sampling rate of the raw audio. + timing_dims (`int`, *optional*, defaults to 64): + Dimensions of the JukeboxRangeEmbedding layer which is equivalent to traditional positional embedding + layer. The timing embedding layer converts the absolute and relative position in the currently sampled + audio to a tensor of length `timing_dims` that will be added to the music tokens. + min_duration (`int`, *optional*, defaults to 0): + Minimum duration of the audios to generate + max_duration (`float`, *optional*, defaults to 600.0): + Maximum duration of the audios to generate + max_nb_genres (`int`, *optional*, defaults to 5): + Maximum number of genres that can be used to condition a single sample. + metadata_conditioning (`bool`, *optional*, defaults to `True`): + Whether or not to use metadata conditioning, corresponding to the artist, the genre and the min/maximum + duration. + + Example: + + ```python + >>> from transformers import JukeboxModel, JukeboxConfig + + >>> # Initializing a Jukebox configuration + >>> configuration = JukeboxConfig() + + >>> # Initializing a model from the configuration + >>> model = JukeboxModel(configuration) + + >>> # Accessing the model configuration + >>> configuration = model.config + ``` + """ + + model_type = "jukebox" + + def __init__( + self, + vqvae_config=None, + prior_config_list=None, + nb_priors=3, + sampling_rate=44100, + timing_dims=64, + min_duration=0, + max_duration=600.0, + max_nb_genres=5, + metadata_conditioning=True, + **kwargs, + ): + if vqvae_config is None: + vqvae_config = {} + logger.info("vqvae_config is None. initializing the JukeboxVQVAE with default values.") + + self.vqvae_config = JukeboxVQVAEConfig(**vqvae_config) + if prior_config_list is not None: + self.prior_configs = [JukeboxPriorConfig(**prior_config) for prior_config in prior_config_list] + else: + self.prior_configs = [] + for prior_idx in range(nb_priors): + prior_config = kwargs.pop(f"prior_{prior_idx}", None) + if prior_config is None: + prior_config = {} + logger.info( + f"prior_{prior_idx}'s config is None. Initializing the JukeboxPriorConfig list with default" + " values." + ) + self.prior_configs.append(JukeboxPriorConfig(**prior_config)) + + self.hop_fraction = self.vqvae_config.hop_fraction + + self.nb_priors = nb_priors + + # Metadata conditioning + self.max_nb_genres = max_nb_genres + self.sampling_rate = sampling_rate + self.timing_dims = timing_dims + self.min_duration = min_duration + self.max_duration = max_duration + self.metadata_conditioning = metadata_conditioning + + super().__init__(**kwargs) + + @classmethod + def from_configs(cls, prior_configs: List[JukeboxPriorConfig], vqvae_config: JukeboxVQVAEConfig, **kwargs): + r""" + Instantiate a [`JukeboxConfig`] (or a derived class) from clip text model configuration and clip vision model + configuration. + + Returns: + [`JukeboxConfig`]: An instance of a configuration object + """ + prior_config_list = [config.to_dict() for config in prior_configs] + return cls(prior_config_list=prior_config_list, vqvae_config_dict=vqvae_config.to_dict(), **kwargs) + + def to_dict(self): + # Override the default to_dict to apply to_dict to the list of prior configs. + result = super().to_dict() + result["prior_config_list"] = [config.to_dict() for config in result.pop("prior_configs")] + return result +__all__ = [ + "JukeboxConfig", + "JukeboxPriorConfig", + "JukeboxVQVAEConfig", + ] diff --git a/mindnlp/transformers/models/jukebox/modeling_jukebox.py b/mindnlp/transformers/models/jukebox/modeling_jukebox.py new file mode 100644 index 000000000..fa77257e0 --- /dev/null +++ b/mindnlp/transformers/models/jukebox/modeling_jukebox.py @@ -0,0 +1,2604 @@ +# coding=utf-8 +# Copyright 2022 The OpenAI Team Authors and HuggingFace Inc. team. +# +# 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. +"""PyTorch Jukebox model.""" + +import math +import os +from typing import List, Optional, Tuple + +import numpy as np +import mindspore +import mindnlp.core.nn.functional as F +from mindnlp.core import nn, ops, no_grad, distributions +from mindnlp.core.nn import LayerNorm as FusedLayerNorm + +from ....common.activations import ACT2FN +from ....modeling_utils import PreTrainedModel +from ....utils import logging +from ....utils.logging import tqdm +from .configuration_jukebox import ATTENTION_PATTERNS, JukeboxConfig, JukeboxPriorConfig, JukeboxVQVAEConfig + + +logger = logging.get_logger(__name__) + + +def filter_logits(logits, top_k=0, top_p=0.0, filter_value=-float("Inf")): + """ + Filter a distribution of logits using top-k and/or nucleus (top-p) filtering + + Args: + logits (`mindspore.Tensor`): + logits distribution shape (vocabulary size) + top_k (`int`, *optional*, defaults to 0): + When `top_k >0` keep only top key tokens with highest probability (top-k filtering). + top_p (`int`, *optional*, defaults to 0): + When `top_p>0.0` keep the top tokens with cumulative probability >= `top_p` (nucleus filtering). + """ + logits = logits.clone() + top_k = min(top_k, logits.shape[-1]) # Safety check + + if top_k > 0: + # Remove all tokens with a probability less than the last token of the top-k + indices_to_remove = logits < ops.topk(logits, top_k, dim=-1)[0][..., -1:] + logits[indices_to_remove] = filter_value + + if top_p > 0.0: + sorted_logits, sorted_indices = ops.sort(logits, descending=True, dim=-1) + cumulative_probs = ops.cumsum(F.softmax(sorted_logits, dim=-1), dim=-1) + + # Remove tokens with cumulative probability above the threshold + sorted_indices_to_remove = cumulative_probs > top_p + # Shift the indices to the right to keep also the first token above the threshold + sorted_indices_to_remove[..., 1:] = sorted_indices_to_remove[..., :-1].clone() + sorted_indices_to_remove[..., 0] = 0 + + # indices_to_remove = sorted_indices[sorted_indices_to_remove] + indices_to_remove = ops.zeros_like(logits, dtype=mindspore.bool_).scatter_( + dim=-1, index=sorted_indices, src=sorted_indices_to_remove + ) + logits[indices_to_remove] = filter_value + return logits + + +def get_relevant_lyric_tokens(full_tokens, max_n_lyric_tokens, total_length, offset, duration): + """ + Extract only the relevant tokens based on the character position. A total of `max_n_lyric_tokens` tokens will be + returned. If the provided token sequence is smaller, it will be padded, otherwise, only characters ranging from the + midpoint - `max_n_lyric_tokens//2` to the midpoint + `max_n_lyric_tokens//2` will be returned. This *focuses* on + the most relevant tokens (in time) for the sequence. + + Args: + full_tokens (`List[int]`): + List containing the token ids of the entire lyrics. + total_length (`int`): + Total expected length of the music (not all of it is generated, see duration), in samples. + offset (`int`): + Starting sample in the music. If the offset is greater than 0, the lyrics will be shifted take that into + account + duration (`int`): + Expected duration of the generated music, in samples. The duration has to be smaller than the total length, + which represent the overall length of the signal, + """ + full_tokens = full_tokens[0] + if len(full_tokens) < max_n_lyric_tokens: + tokens = ops.cat( + [ops.zeros(max_n_lyric_tokens - len(full_tokens), dtype=mindspore.int64).to(full_tokens), full_tokens] + ) + indices = [-1] * (max_n_lyric_tokens - len(full_tokens)) + list(range(0, len(full_tokens))) + else: + midpoint = int(len(full_tokens) * (offset + duration / 2.0) / total_length) + midpoint = min(max(midpoint, max_n_lyric_tokens // 2), len(full_tokens) - max_n_lyric_tokens // 2) + tokens = full_tokens[midpoint - max_n_lyric_tokens // 2 : midpoint + max_n_lyric_tokens // 2] + indices = list(range(midpoint - max_n_lyric_tokens // 2, midpoint + max_n_lyric_tokens // 2)) + return tokens.unsqueeze(dim=0), indices + + +# Break total_length into hops/windows of size n_ctx separated by hop_length +def get_starts(total_length, n_ctx, hop_length): + starts = [] + for start in range(0, total_length - n_ctx + hop_length, hop_length): + if start + n_ctx >= total_length: + # Last hop could be smaller, we make it n_ctx to maximise context + start = total_length - n_ctx + starts.append(start) + return starts + + +def get_alignment(music_tokens, labels, prior, config): + level = prior.levels - 1 # Top level used + n_ctx = prior.n_ctx + tokens = music_tokens[level] + batch_size, total_length = tokens.shape[0], tokens.shape[1] + if total_length < n_ctx: + padding_length = n_ctx - total_length + tokens = ops.cat( + [tokens, ops.zeros(batch_size, n_ctx - total_length, dtype=tokens.dtype)], dim=1 + ) + total_length = tokens.shape[1] + else: + padding_length = 0 + + hop_length = int(config.hop_fraction[-level - 1] * prior.n_ctx) + alignment_head, alignment_layer = config.prior_alignment_head[0], config.prior_alignment_layer[0] + attn_layers = {alignment_layer} + alignment_hops = {} + indices_hops = {} + for start in tqdm(get_starts(total_length, n_ctx, hop_length), desc="Computing lyric to music alignment "): + end = start + n_ctx + # set metadata offset, sample_length and lyrics tokens + metadata, indices_hop = prior.get_metadata(labels, start, config.sample_length, get_indices=True, offset=0) + tokens_bs = ops.chunk(tokens, batch_size, dim=0) + metadata_bs = ops.chunk(metadata, batch_size, dim=0) + w_hops = [] + for tokens_i, metadata_i in zip(tokens_bs, metadata_bs): + w_hop = prior.forward_tokens(tokens_i[:, start:end], [], metadata_i, get_attn_weights=attn_layers) + w_hops.append(w_hop[0][:, alignment_head]) + del w_hop + weights = ops.cat(w_hops, dim=0) + del w_hops + alignment_hop = weights.float().cpu().numpy() + del weights + + # alignment_hop has shape (bs, n_ctx, nb_relevant_lyric_tokens) + # indices_hop is a list of len=bs, each entry of len hps.nb_relevant_lyric_tokens + indices_hops[start] = indices_hop + alignment_hops[start] = alignment_hop + + # Combine attn for each hop into attn for full range + # Use indices to place them into correct place for corresponding source tokens + alignments = [] + for item in range(batch_size): + # Note each item has different length lyrics + full_tokens = labels[0, 3:] + alignment = np.zeros((total_length, len(full_tokens) + 1)) + for start in reversed(get_starts(total_length, n_ctx, hop_length)): + end = start + n_ctx + alignment_hop = alignment_hops[start][item] + indices = indices_hops[start][item] + alignment[start:end, indices] = alignment_hop + alignment = alignment[: total_length - padding_length, :-1] # remove token padding, and last lyric index + alignments.append(alignment) + return alignments + + +def save_temp_audio(fname, lvl, metas, aud): + aud = ops.clamp(aud, -1, 1).cpu().numpy() + for i in list(range(aud.shape[0])): + if metas is not None: + artists, genres, lyrics = list(metas)[i].values() + path = f"{fname}/lvl_{lvl}-{artists}-{genres}-{lyrics[:5]}-{i}" + np.save(path, aud[i]) + else: + np.save(f"{fname}/lvl_{lvl}-sample-{i}", aud[i]) + + +def get_mask(mask, query_length, key_value_length, blocks, spread, sample, sample_t): + # returns a mask of shape 1 x 1 x query_length x key_value_length or None if masking is not needed. + if mask is None or query_length == 1: + return None + offset = sample_t - query_length if sample else max(key_value_length - query_length, 0) + if mask == "autoregressive": + # Masked dense + mask = ops.ones(query_length, key_value_length).tril(offset) + elif mask == "summary": + # Masked summary + mask = ops.ones(query_length, query_length).tril() + mask = ops.ones(query_length, query_length).tril() + mask = mask.view(query_length, blocks, query_length // blocks)[:, :-1, -key_value_length // blocks :] + mask = ( + ops.pad( + mask, + (0, 0, 1, 0), + value=1, + ) + .contiguous() + .view(query_length, key_value_length) + ) + elif mask == "prime": + mask = ops.ones(query_length, key_value_length).tril(offset) + return mask.view(1, 1, query_length, key_value_length) + + +class JukeboxConv1D(nn.Module): + def __init__(self, input_width, output_width): + super().__init__() + self.input_width = input_width + self.output_width = output_width + weight = ops.zeros(input_width, output_width) + bias = ops.zeros(output_width) + self.weight = nn.Parameter(weight) + self.bias = nn.Parameter(bias) + + def forward(self, hidden_states): + size_out = (*hidden_states.shape[:-1], self.output_width) + hidden_states = ops.addmm( + self.bias.type_as(hidden_states), + hidden_states.view(-1, hidden_states.shape[-1]), + self.weight.type_as(hidden_states), + ) + hidden_states = hidden_states.view(*size_out) + return hidden_states + + +class JukeboxResConv1DBlock(nn.Module): + def __init__(self, config, conv_width, depth=1, res_scale=1.0): + super().__init__() + hidden_dim = config.res_convolution_multiplier * conv_width + dilation = config.res_dilation_growth_rate**depth + padding = dilation + + self.res_scale = res_scale + self.activation = nn.ReLU() + self.conv1d_1 = nn.Conv1d(conv_width, hidden_dim, 3, 1, padding, dilation) + self.conv1d_2 = nn.Conv1d(hidden_dim, conv_width, 1, 1, 0) + + def forward(self, hidden_states): + residuals = hidden_states + hidden_states = self.activation(hidden_states) + hidden_states = self.conv1d_1(hidden_states) + hidden_states = self.activation(hidden_states) + hidden_states = self.conv1d_2(hidden_states) + return residuals + self.res_scale * hidden_states + + +class JukeboxResnet1D(nn.Module): + def __init__(self, config, conv_width, n_depth, reverse_dilation=False): + super().__init__() + self.dilation_cycle = config.res_dilation_cycle + res_scale = 1.0 if not config.conv_res_scale else 1.0 / math.sqrt(n_depth) + + blocks = [] + for depth in range(n_depth): + block_depth = depth if self.dilation_cycle is None else depth % self.dilation_cycle + blocks.append(JukeboxResConv1DBlock(config, conv_width, block_depth, res_scale)) + + if reverse_dilation: + blocks = blocks[::-1] + self.resnet_block = nn.ModuleList(blocks) + + def forward(self, hidden_states): + for block in self.resnet_block: + hidden_states = block(hidden_states) + return hidden_states + + +class JukeboxEncoderConvBlock(nn.Module): + def __init__(self, config, embed_dim, hidden_dim, depth, down_t, stride_t): + super().__init__() + blocks = [] + filter_t = stride_t * 2 + pad_t = stride_t // 2 + if down_t > 0: + for i in range(down_t): + blocks.append(nn.Conv1d(embed_dim if i == 0 else hidden_dim, hidden_dim, filter_t, stride_t, pad_t)) + blocks.append(JukeboxResnet1D(config, hidden_dim, depth)) + self.proj_out = nn.Conv1d(hidden_dim, config.embed_dim, 3, 1, 1) + self.downsample_block = nn.ModuleList(blocks) + + def forward(self, hidden_states): + for block in self.downsample_block: + hidden_states = block(hidden_states) + hidden_states = self.proj_out(hidden_states) + return hidden_states + + +class JukeboxEncoder(nn.Module): + def __init__(self, config, width, depth, levels, downs_t, strides_t): + super().__init__() + self.levels = levels + self.level_blocks = nn.ModuleList() + + iterator = zip(list(range(self.levels)), downs_t, strides_t) + for i, down_t, stride_t in iterator: + self.level_blocks.append( + JukeboxEncoderConvBlock( + config, config.conv_input_shape if i == 0 else config.embed_dim, width, depth, down_t, stride_t + ) + ) + + def forward(self, hidden_states): + all_hidden_states = [] + + # 64, 32, ... + for level in range(self.levels): + level_block = self.level_blocks[level] + hidden_states = level_block(hidden_states) + all_hidden_states.append(hidden_states) + + return all_hidden_states + + +class JukeboxDecoderConvBock(nn.Module): + def __init__(self, config, embed_dim, hidden_dim, depth, down_t, stride_t, reverse_dilation=True): + self.embed_dim = embed_dim + self.hidden_dim = hidden_dim + super().__init__() + blocks = [] + if down_t > 0: + filter_t = stride_t * 2 + pad_t = stride_t // 2 + self.proj_in = nn.Conv1d(embed_dim, hidden_dim, 3, 1, 1) + for i in range(down_t): + blocks.append(JukeboxResnet1D(config, hidden_dim, depth, reverse_dilation)) + blocks.append( + nn.ConvTranspose1d( + hidden_dim, hidden_dim if i < down_t - 1 else embed_dim, filter_t, stride_t, pad_t + ) + ) + self.upsample_block = nn.ModuleList(blocks) + + def forward(self, hidden_states): + hidden_states = self.proj_in(hidden_states) + for block in self.upsample_block: + hidden_states = block(hidden_states) + return hidden_states + + +class JukeboxDecoder(nn.Module): + def __init__(self, config, hidden_dim, depth, levels, downs_t, strides_t): + super().__init__() + self.levels = levels + self.level_blocks = nn.ModuleList() + for level, down_t, stride_t in zip(list(range(self.levels)), downs_t, strides_t): + self.level_blocks.append( + JukeboxDecoderConvBock(config, config.embed_dim, hidden_dim, depth, down_t, stride_t) + ) + + self.out = nn.Conv1d(config.embed_dim, config.conv_input_shape, 3, 1, 1) + + def forward(self, hidden_states, all_levels=True): + hidden_state = hidden_states[-1] + + # 32, 64 ... + for level in reversed(range(self.levels)): + level_block = self.level_blocks[level] + hidden_state = level_block(hidden_state) + + if level != 0 and all_levels: + hidden_state = hidden_state + hidden_states[level - 1] + + hidden_state = self.out(hidden_state) + return hidden_state + + +class JukeboxBottleneckBlock(nn.Module): + def __init__(self, config: JukeboxVQVAEConfig): + super().__init__() + self.nb_discrete_codes = config.nb_discrete_codes + self.codebook_width = config.embed_dim + self.mu = config.lmu + self.threshold = 1.0 + self.init = False + self.codebook_sum = None + self.codebook_elem = None + self.register_buffer("codebook", ops.zeros(self.nb_discrete_codes, self.codebook_width)) + + def _tile(self, hidden_states): + dim, embed_width = hidden_states.shape + if dim < self.nb_discrete_codes: + n_repeats = (self.nb_discrete_codes + dim - 1) // dim + std = 0.01 / np.sqrt(embed_width) + hidden_states = hidden_states.repeat(n_repeats, 1) + hidden_states = hidden_states + ops.randn_like(hidden_states) * std + return hidden_states + + def init_codebook(self, hidden_states): + nb_discrete_codes = self.nb_discrete_codes + self.init = True + codes = self._tile(hidden_states) + self.codebook = codes[ops.randperm(codes.shape[0])][:nb_discrete_codes] + self.codebook_sum = self.codebook + self.codebook_elem = ops.ones(nb_discrete_codes) + + def update_codebook(self, hidden_states, latent_states): + mu, codebook_width, nb_discrete_codes = self.mu, self.codebook_width, self.nb_discrete_codes + with no_grad(): + # Calculate new centres + # nb_discrete_codes, batch_size * seq_length + latent_states_onehot = ops.zeros(nb_discrete_codes, hidden_states.shape[0]) + latent_states_onehot.scatter_(0, latent_states.view(1, hidden_states.shape[0]), 1) + + _codebook_sum = ops.matmul(latent_states_onehot, hidden_states) + _codebook_elem = latent_states_onehot.sum(dim=-1) # nb_discrete_codes + codes = self._tile(hidden_states) + _random_codebook = codes[ops.randperm(codes.shape[0])][:nb_discrete_codes] + + # Update centres + old_codebook = self.codebook + self.codebook_sum = mu * self.codebook_sum + (1.0 - mu) * _codebook_sum + self.codebook_elem = mu * self.codebook_elem + (1.0 - mu) * _codebook_elem # nb_discrete_codes + usage = (self.codebook_elem.view(nb_discrete_codes, 1) >= self.threshold).float() + + norm_code = self.codebook_sum.view(nb_discrete_codes, codebook_width) / self.codebook_elem.view( + nb_discrete_codes, 1 + ) + self.codebook = usage * (norm_code) + (1 - usage) * _random_codebook + _codebook_prob = _codebook_elem / mindspore.ops.sum(_codebook_elem) # prob of each bin + entropy = -mindspore.ops.sum(_codebook_prob * ops.log(_codebook_prob + 1e-8)) # entropy ie how diverse + used_curr = (_codebook_elem >= self.threshold).sum() + usage = mindspore.ops.sum(usage) + dk = ops.norm(self.codebook - old_codebook) / np.sqrt(np.prod(old_codebook.shape)) + return {"entropy": entropy, "used_curr": used_curr, "usage": usage, "dk": dk} + + def preprocess(self, hidden_states): + hidden_states = hidden_states.permute(0, 2, 1).contiguous() + hidden_states = hidden_states.view(-1, hidden_states.shape[-1]) + + if hidden_states.shape[-1] == self.codebook_width: + prenorm = ops.norm(hidden_states - ops.mean(hidden_states)) / np.sqrt(np.prod(hidden_states.shape)) + elif hidden_states.shape[-1] == 2 * self.codebook_width: + x1, x2 = hidden_states[..., : self.codebook_width], hidden_states[..., self.codebook_width :] + prenorm = (ops.norm(x1 - ops.mean(x1)) / np.sqrt(np.prod(x1.shape))) + ( + ops.norm(x2 - ops.mean(x2)) / np.sqrt(np.prod(x2.shape)) + ) + + # Normalise + hidden_states = x1 + x2 + + return hidden_states, prenorm + + def postprocess(self, latent_states, dequantised_states, x_shape): + batch_size, time = x_shape + dequantised_states = dequantised_states.view(batch_size, time, -1).permute(0, 2, 1).contiguous() + latent_states = latent_states.view(batch_size, time) + return latent_states, dequantised_states + + def quantise(self, latent_states): + # Calculate latent code latent_states + codebook_weights = self.codebook.t() + distance = ( + mindspore.ops.sum(latent_states**2, dim=-1, keepdim=True) + - 2 * ops.matmul(latent_states, codebook_weights) + + mindspore.ops.sum(codebook_weights**2, dim=0, keepdim=True) + ) # (batch_size * latent_states , codebook_weights) + min_distance, music_tokens = ops.minimum(distance,dim=-1) + fit = ops.mean(min_distance) + return music_tokens, fit + + def dequantise(self, music_tokens): + dequantised_states = F.embedding(music_tokens, self.codebook) + return dequantised_states + + def encode(self, latent_states): + samples, _, seq_len = latent_states.shape + + # Preprocess. + latent_states, _ = self.preprocess(latent_states) + + # Quantise + music_tokens, _ = self.quantise(latent_states) + + # Postprocess. + music_tokens = music_tokens.view(samples, seq_len) + return music_tokens + + def decode(self, music_tokens): + samples, seq_len = music_tokens.shape + + # Dequantise + dequantised_states = self.dequantise(music_tokens) + + # Postprocess + dequantised_states = ( + dequantised_states.view(samples, seq_len, self.codebook_width).permute(0, 2, 1).contiguous() + ) + return dequantised_states + + def forward(self, hidden_states, update_codebook=True): + samples, _, seq_len = hidden_states.shape + + # Preprocess + hidden_states, prenorm = self.preprocess(hidden_states) + + # Init codebook if not inited + if update_codebook and not self.init: + self.init_codebook(hidden_states) + + # Quantise and dequantise through bottleneck + music_tokens, fit = self.quantise(hidden_states) + dequantised_states = self.dequantise(music_tokens) + + # Update embeddings + if update_codebook: + update_metrics = self.update_codebook(hidden_states, music_tokens) + else: + update_metrics = {} + + # Loss + commit_loss = ops.norm(dequantised_states.detach() - hidden_states) ** 2 / np.prod(hidden_states.shape) + + # Passthrough + dequantised_states = hidden_states + (dequantised_states - hidden_states).detach() + + # Postprocess + music_tokens, dequantised_states = self.postprocess(music_tokens, dequantised_states, (samples, seq_len)) + return music_tokens, dequantised_states, commit_loss, dict(fit=fit, pn=prenorm, **update_metrics) + + +class JukeboxBottleneck(nn.Module): + def __init__(self, config, levels): + super().__init__() + self.levels = levels + self.level_blocks = nn.ModuleList() + for level in range(self.levels): + self.level_blocks.append(JukeboxBottleneckBlock(config)) + + def encode(self, raw_audio): + music_tokens = [ + level_block.encode(hidden_states) for (level_block, hidden_states) in zip(self.level_blocks, raw_audio) + ] + return music_tokens + + def decode(self, music_tokens, start_level=0, end_level=None): + if end_level is None: + end_level = self.levels + quantised_audio = [ + level_block.decode(z) for (level_block, z) in zip(self.level_blocks[start_level:end_level], music_tokens) + ] + return quantised_audio + + def forward(self, input_audio): + music_tokens, quantised_states, commit_losses, metrics = [], [], [], [] + for level in range(self.levels): + level_block = self.level_blocks[-level - 1] + hidden_states = input_audio[level] + sampled_tokens, quantised_state, commit_loss, metric = level_block( + hidden_states, update_codebook=self.training + ) + music_tokens.append(sampled_tokens) + if not self.training: + # Be extra paranoid and make sure the encoder weights can't + # change from straight-through estimator + quantised_state = quantised_state.detach() + quantised_states.append(quantised_state) + commit_losses.append(commit_loss) + if self.training: + metrics.append(metric) + return music_tokens, quantised_states, commit_losses, metrics + + +JUKEBOX_START_DOCSTRING = r""" + + This model inherits from [`PreTrainedModel`]. Check the superclass documentation for the generic methods the + library implements for all its model (such as downloading or saving, resizing the input embeddings, pruning heads + etc.) + + This model is also a PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) subclass. + Use it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage + and behavior. + + Parameters: + config (`JukeboxConfig`): Model configuration class with all the parameters of the model. + Initializing with a config file does not load the weights associated with the model, only the + configuration. Check out the [`~PreTrainedModel.from_pretrained`] method to load the model weights. +""" + + +class JukeboxVQVAE(PreTrainedModel): + config_class = JukeboxVQVAEConfig + base_model_prefix = "vqvae" + + def _init_weights(self, module): + if isinstance(module, nn.Embedding): # embed_tokens + module.weight.data.normal_(mean=0.0, std=0.02 * self.config.init_scale) + elif isinstance(module, JukeboxConv1D): + if self.config.zero_out: + module.weight.data.zero_() + else: + module.weight.data.normal_(mean=0.0, std=0.02 * self.config.init_scale) + elif isinstance(module, JukeboxResConv1DBlock) and self.config.zero_out: + module.conv1d_2.weight.data.zero_() + module.conv1d_2.bias.data.zero_() + if isinstance(module, nn.LayerNorm): + module.bias.data.zero_() + module.weight.data.fill_(1.0) + if isinstance(module, nn.Linear) and module.bias is not None: + module.bias.data.zero_() + + def __init__(self, config: JukeboxVQVAEConfig): + super().__init__(config) + downs_t = config.res_downs_t + strides_t = config.res_strides_t + if not config.sample_length: + downsamples = [stride**down for stride, down in zip(strides_t, downs_t)] + top_raw_to_tokens = np.prod(downsamples) + config.sample_length = ( + config.sample_length_in_seconds * config.sampling_rate // top_raw_to_tokens + ) * top_raw_to_tokens + config.sample_length = config.sample_length.astype(int) + + self.nb_discrete_codes = config.nb_discrete_codes + self.commit = config.commit + self.sample_length = config.sample_length + + self.downsamples = [stride**down for stride, down in zip(strides_t, downs_t)] + self.hop_lengths = np.cumprod(self.downsamples) + self.levels = levels = config.levels + self.music_tokens_shapes = [ + (int(self.sample_length // self.hop_lengths[-level - 1])) for level in range(levels) + ] + + self.multipliers = config.multipliers if config.multipliers is not None else [1] * levels + + self.encoders = nn.ModuleList() + self.decoders = nn.ModuleList() + for level in range(levels): + width = config.res_conv_width * self.multipliers[level] + depth = config.res_conv_depth * self.multipliers[level] + self.encoders.append( + JukeboxEncoder(config, width, depth, level + 1, downs_t[: level + 1], strides_t[: level + 1]) + ) + self.decoders.append( + JukeboxDecoder(config, width, depth, level + 1, downs_t[: level + 1], strides_t[: level + 1]) + ) + + self.bottleneck = JukeboxBottleneck(config, levels) + + def _decode(self, music_tokens, start_level=0, end_level=None): + # Decode + if end_level is None: + end_level = self.levels + latent_states = self.bottleneck.decode(music_tokens, start_level=start_level, end_level=end_level) + # Use only lowest level + decoder, dequantised_state = self.decoders[start_level], latent_states[0:1] + dequantised_state = decoder(dequantised_state, all_levels=False) + dequantised_state = dequantised_state.permute(0, 2, 1) + return dequantised_state + + def decode(self, music_tokens, start_level=0, end_level=None, bs_chunks=1) -> mindspore.Tensor: + """ + Transforms the input `music_tokens` to their `raw_audio` representation. + + Args: + music_tokens (`mindspore.Tensor`): + Tensor of music tokens which will be decoded to raw audio by using the codebook. Each music token + should be an index to a corresponding `code` vector in the codebook. + start_level (`int`, *optional*): + Level at which the decoding process will start. Default to 0. + end_level (`int`, *optional*): + Level at which the decoding process will start. Default to None. + bs_chunks (int, *optional*): + Number of chunks to process at the same time. + """ + token_chunks = [ops.chunk(token, bs_chunks, dim=0) for token in music_tokens] + dequantised_states = [] + for i in range(bs_chunks): + music_tokens_i = [chunks[i] for chunks in token_chunks] + dequantised_state = self._decode(music_tokens_i, start_level=start_level, end_level=end_level) + dequantised_states.append(dequantised_state) + return ops.cat(dequantised_states, dim=0) + + def _encode(self, raw_audio, start_level=0, end_level=None): + # Encode + if end_level is None: + end_level = self.levels + input_audio = raw_audio.permute(0, 2, 1).float() + latent_states = [] + for level in range(self.levels): + encoder = self.encoders[level] + latent_state = encoder(input_audio) + latent_states.append(latent_state[-1]) + music_tokens = self.bottleneck.encode(latent_states) + return music_tokens[start_level:end_level] + + def encode(self, input_audio, start_level=0, end_level=None, bs_chunks=1): + """ + Transforms the `input_audio` to a discrete representation made out of `music_tokens`. + + Args: + input_audio (`mindspore.Tensor`): + Raw audio which will be encoded to its discrete representation using the codebook. The closest `code` + form the codebook will be computed for each sequence of samples. + start_level (`int`, *optional*, defaults to 0): + Level at which the encoding process will start. Default to 0. + end_level (`int`, *optional*): + Level at which the encoding process will start. Default to None. + bs_chunks (int, *optional*, defaults to 1): + Number of chunks of raw audio to process at the same time. + """ + audio_chunks = ops.chunk(input_audio, bs_chunks, dim=0) + music_tokens_list = [] + for chunk_i in audio_chunks: + music_tokens_i = self._encode(chunk_i, start_level=start_level, end_level=end_level) + music_tokens_list.append(music_tokens_i) + music_tokens = [ops.cat(music_tokens_level, dim=0) for music_tokens_level in zip(*music_tokens_list)] + return music_tokens + + def sample(self, n_samples): + music_tokens = [ + ops.randint(0, self.nb_discrete_codes, size=(n_samples, *music_tokens_shape)) + for music_tokens_shape in self.music_tokens_shapes + ] + return self.decode(music_tokens) + + def forward(self, raw_audio: mindspore.Tensor) -> Tuple[mindspore.Tensor, mindspore.Tensor]: + """ + Forward pass of the VQ-VAE, encodes the `raw_audio` to latent states, which are then decoded for each level. + The commit loss, which ensure that the encoder's computed embeddings are close to the codebook vectors, is + computed. + + Args: + raw_audio (`mindspore.Tensor`): + Audio input which will be encoded and decoded. + + Returns: + `Tuple[mindspore.Tensor, mindspore.Tensor]` + + + Example: + ```python + >>> from transformers import JukeboxVQVAE, set_seed + >>> import torch + + >>> model = JukeboxVQVAE.from_pretrained("openai/jukebox-1b-lyrics").eval() + >>> set_seed(0) + >>> zs = [torch.randint(100, (4, 1))] + >>> model.decode(zs).shape + torch.shape([4, 8, 1]) + ``` + """ + + # Encode/Decode + input_audio = raw_audio.permute(0, 2, 1).float() + latent_states = [] + for level in range(self.levels): + encoder = self.encoders[level] + latent_state = encoder(input_audio) + latent_states.append(latent_state[-1]) + + _, music_tokens, commit_losses, _ = self.bottleneck(latent_states) + dequantised_states = [] + for level in range(self.levels): + decoder = self.decoders[level] + dequantised_state = decoder(music_tokens[level : level + 1], all_levels=False) + dequantised_states.append(dequantised_state.permute(0, 2, 1)) + + commit_loss = sum(commit_losses) + loss = self.commit * commit_loss + + return dequantised_states, loss + + +class JukeboxMLP(nn.Module): + def __init__(self, config): + # a single channel is always used in original code + super().__init__() + embed_dim = config.hidden_size + hidden_dim = int(config.mlp_multiplier * embed_dim) + + self.c_fc = JukeboxConv1D(embed_dim, hidden_dim) + self.c_proj = JukeboxConv1D(hidden_dim, embed_dim) + self.act = ACT2FN[config.act_fn] + self.dropout = nn.Dropout(config.resid_dropout) + + def forward(self, hidden_states): + hidden_states = self.c_fc(hidden_states) + hidden_states = self.act(hidden_states) + hidden_states = self.c_proj(hidden_states) + hidden_states = self.dropout(hidden_states) + return hidden_states + + +class JukeboxLayerNorm(FusedLayerNorm): + def __init__(self, normalized_shape, eps=1e-5, elementwise_affine=True): + super().__init__(normalized_shape, eps=eps, elementwise_affine=elementwise_affine) + self.width = np.prod(normalized_shape) + self.max_numel = 65535 * self.width + + def forward(self, input): + if input.numel() > self.max_numel: + return F.layer_norm(input, self.normalized_shape, self.weight, self.bias, self.eps).type_as(input) + else: + return super().forward(input).type_as(input) + + +class JukeboxAttention(nn.Module): + def __init__(self, config, n_ctx, attn_func="dense_attn"): + super().__init__() + self.embed_dim = config.hidden_size + self.n_heads = config.n_heads + self.dropout = config.attn_dropout + hidden_dim = int(config.attention_multiplier * self.embed_dim) + + self.head_dim = hidden_dim // config.n_heads + self.n_ctx = n_ctx + self.hidden_dim = hidden_dim + self.scale = self.head_dim**-0.25 + self.mask = config.mask + + if attn_func == "cross_attention": + self.c_attn = JukeboxConv1D(self.embed_dim, hidden_dim) + self.c_enc_kv = JukeboxConv1D(self.embed_dim, hidden_dim * 2) + else: + self.c_attn = JukeboxConv1D(self.embed_dim, hidden_dim * 3) + + self.c_proj = JukeboxConv1D(hidden_dim, self.embed_dim) + self.attn_dropout = nn.Dropout(config.attn_dropout) + self.resid_dropout = nn.Dropout(config.resid_dropout) + + # Sequence of length seq_len is factored as [blocks, seq_len // blocks] + self.attn_func = attn_func + if attn_func == "cross_attention": + self.qkv = self.decode_qkv + elif attn_func == "prime_attn": + self.qkv = self.prime_qkv + else: + self.qkv = self.factored_qkv + + ATTENTION_MAP = { + "dense_attn": (self.dense_attn, "autoregressive"), + "block_attn": (self.block_attn, "autoregressive"), + "transpose_block_attn": (self.transpose_block_attn, "autoregressive"), + "prev_block_attn": (self.prev_block_attn, None), + "summary_attn": (self.summary_attn, "summary"), + "summary_spread_attn": (self.summary_spread_attn, "summary"), + "cross_attention": (self.dense_attn, None), + "prime_attn": (self.prime_attn, "prime"), + } + self.attn, self.attn_mask = ATTENTION_MAP[attn_func] + + self.blocks = config.blocks + self.spread = config.spread + if self.blocks is not None: + self.block_ctx = self.n_ctx // self.blocks + + self.sample_t = 0 + self.cache = {} + self.encoder_len = config.nb_relevant_lyric_tokens # length of the encoder input ids + self.record_attn = False + + def _attn(self, query_states, key_states, value_states, sample): + scale = self.scale + if self.training: + attention_weight = ops.matmul(query_states * scale, key_states * scale) + else: + attention_weight = ops.matmul(query_states, key_states) + attention_weight.mul_(scale * scale) + attn_weight_type = attention_weight.dtype + attention_weight = attention_weight.float() + if self.mask: + # Generate appropriate mask to mask out all positions before current + # Might take up lot of memory for dense, so can cache it + mask = get_mask( + self.attn_mask, + query_states.shape[-2], + key_states.shape[-1], + self.blocks, + self.spread, + attention_weight, + sample, + self.sample_t, + ) + if mask is not None: + attention_weight = attention_weight * mask + -1e9 * (1 - mask) + attention_prob = F.softmax(attention_weight, dim=-1).type(attn_weight_type) + if self.record_attn: + self.attention_prob = attention_prob + if self.attn_func == "prime_attn": + # only keep music queries and lyrics keys/values + self.attention_prob = self.attention_prob[:, :, self.encoder_len :, : self.encoder_len] + attention_prob = self.attn_dropout(attention_prob) + context_states = ops.matmul(attention_prob, value_states) + return context_states + + def merge_heads(self, hidden_states): + hidden_states = hidden_states.permute(0, 2, 1, 3).contiguous() + new_hidden_states_shape = (*hidden_states.shape[:-2], hidden_states.shape[-2] * hidden_states.shape[-1]) + return hidden_states.view(*new_hidden_states_shape) # in Tensorflow implem: fct merge_states + + def split_heads(self, hidden_states, is_key=False): + new_hidden_states_shape = ( + *hidden_states.shape[:-1], + self.n_heads, + hidden_states.shape[-1] // self.n_heads, + ) + hidden_states = hidden_states.view(*new_hidden_states_shape) # in Tensorflow implem: fct split_states + if is_key: + return hidden_states.permute(0, 2, 3, 1) + else: + return hidden_states.permute(0, 2, 1, 3) + + def dense_attn(self, query, key, value, sample): + query = self.split_heads(query) + key = self.split_heads(key, is_key=True) + value = self.split_heads(value) + context_states = self._attn(query, key, value, sample) + context_states = self.merge_heads(context_states) + return context_states + + def block_attn(self, query, key, value, sample): + block_ctx = self.block_ctx + batch_size, seq_len, embed_dim = value.shape # For sample, query_len= 1, key_len = value_len = sample_t + if sample: + return self.dense_attn(query, key, value, sample).view(batch_size, 1, embed_dim) + else: + query_length = query.shape[1] + query = query.view(batch_size * query_length // block_ctx, block_ctx, embed_dim) + if query_length < seq_len: + seq_len = query_length + key = key[:, -seq_len:].contiguous() + value = value[:, -seq_len:].contiguous() + key = key.view(batch_size * seq_len // block_ctx, block_ctx, embed_dim) + value = value.view(batch_size * seq_len // block_ctx, block_ctx, embed_dim) + return self.dense_attn(query, key, value, sample).view(batch_size, seq_len, embed_dim) + + def transpose_block_attn(self, query, key, value, sample): + block_ctx = self.block_ctx + batch_size, seq_len, embed_dim = value.shape # For sample, query_len= 1, key_len = value_len = sample_t + if sample: + block_len = (seq_len - 1) % block_ctx + key = key[:, block_len::block_ctx, :] + value = value[:, block_len::block_ctx, :] + return self.dense_attn(query, key, value, sample).view(batch_size, 1, embed_dim) + else: + query_length = query.shape[1] + query = query.view(batch_size, query_length // block_ctx, block_ctx, embed_dim) + query = query.transpose(1, 2).contiguous() + query = query.view(batch_size * block_ctx, query_length // block_ctx, embed_dim) + + key = key.view(batch_size, seq_len // block_ctx, block_ctx, embed_dim) + key = key.transpose(1, 2).contiguous() + key = key.view(batch_size * block_ctx, seq_len // block_ctx, embed_dim) + + value = value.view(batch_size, seq_len // block_ctx, block_ctx, embed_dim) + value = value.transpose(1, 2).contiguous() + value = value.view(batch_size * block_ctx, seq_len // block_ctx, embed_dim) + + block_attn = self.dense_attn(query, key, value, sample) + block_attn = block_attn.view(batch_size, block_ctx, query_length // block_ctx, embed_dim) + block_attn = block_attn.transpose(1, 2).contiguous() + block_attn = block_attn.view(batch_size, query_length, embed_dim) + + return block_attn + + def prev_block_attn(self, query, key, value, sample): + block_ctx = self.block_ctx + batch_size, seq_len, embed_dim = value.shape # For sample, query_len= 1, key_len = value_len = sample_t + if sample: + block = (seq_len - 1) // block_ctx + prev_l = (block - 1) * block_ctx + if block > 0: + key = key[:, prev_l : prev_l + block_ctx, :] + value = value[:, prev_l : prev_l + block_ctx, :] + else: + key = ops.zeros(batch_size, block_ctx, embed_dim, dtype=query.dtype) + value = ops.zeros(batch_size, block_ctx, embed_dim, dtype=query.dtype) + return self.dense_attn(query, key, value, sample).view(batch_size, 1, embed_dim) + else: + query_length = query.shape[1] + query = query.view(batch_size * query_length // block_ctx, block_ctx, embed_dim) + + key = key.view(batch_size, seq_len // block_ctx, block_ctx, embed_dim)[:, :-1, :, :] + key = ops.pad(key, (0, 0, 0, 0, 1, 0)) + key = key.view(batch_size * seq_len // block_ctx, block_ctx, embed_dim) + + value = value.view(batch_size, seq_len // block_ctx, block_ctx, embed_dim)[:, :-1, :, :] + value = ops.pad(value, (0, 0, 0, 0, 1, 0)) + value = value.view(batch_size * seq_len // block_ctx, block_ctx, embed_dim) + + if query_length < seq_len: + nb_query_blocks = query_length // block_ctx + nb_key_blocks = seq_len // block_ctx + seq_len = query_length + key = key.view(batch_size, nb_key_blocks, block_ctx, embed_dim)[:, -nb_query_blocks:] + key = key.contiguous().view(batch_size * nb_query_blocks, block_ctx, embed_dim) + + value = value.view(batch_size, nb_key_blocks, block_ctx, embed_dim)[:, -nb_query_blocks:] + value = value.contiguous().view(batch_size * nb_query_blocks, block_ctx, embed_dim) + + return self.dense_attn(query, key, value, sample).view(batch_size, seq_len, embed_dim) + + def summary_attn(self, query, key, value, sample): + blocks = self.blocks + block_ctx = self.block_ctx + batch_size, seq_len, embed_dim = value.shape # For sample, query_len= 1, key_len = value_len = sample_t + if sample: + key = key[:, block_ctx - 1 : blocks * block_ctx - 1 : block_ctx, :] + key = ops.pad(key, (0, 0, 1, 0)) + + value = value[:, block_ctx - 1 : blocks * block_ctx - 1 : block_ctx, :] + value = ops.pad(value, (0, 0, 1, 0)) + return self.dense_attn(query, key, value, sample).view(batch_size, 1, embed_dim) + else: + key = key.view(batch_size, blocks, seq_len // blocks, embed_dim)[:, :-1, -1, :] + key = ops.pad(key, (0, 0, 1, 0)) # batch_size, blocks, embed_dim + + value = value.view(batch_size, blocks, seq_len // blocks, embed_dim)[:, :-1, -1, :] + value = ops.pad(value, (0, 0, 1, 0)) # batch_size, blocks, embed_dim + return self.dense_attn(query, key, value, sample).view(batch_size, seq_len, embed_dim) + + def summary_spread_attn(self, query, key, value, sample): + blocks = self.blocks + spread = self.spread + + batch_size, seq_len, embed_dim = value.shape # For sample, query_len= 1, key_len = value_len = sample_t + if sample: + raise NotImplementedError + else: + key = key.view(batch_size, blocks, seq_len // blocks, embed_dim)[:, :-1, -spread:, :] + key = ops.pad(key, (0, 0, 0, 0, 1, 0)).contiguous() + key = key.view(batch_size, blocks * spread, embed_dim) + + value = value.view(batch_size, blocks, seq_len // blocks, embed_dim)[:, :-1, -spread:, :] + value = ops.pad(value, (0, 0, 0, 0, 1, 0)).contiguous() + value = value.view(batch_size, blocks * spread, embed_dim) + + return self.dense_attn(query, key, value, sample).view(batch_size, seq_len, embed_dim) + + def prime_attn(self, query, key, value, sample): + encoder_len = self._encoder_len + key = key[:, :encoder_len] + value = value[:, :encoder_len] + return self.dense_attn(query, key, value, sample) + + def factored_qkv(self, hidden_states, last_encoder_hidden_states=None, sample=False): + curr_ctx = hidden_states.shape[1] + if last_encoder_hidden_states is not None: + raise TypeError("last_encoder_hidden_states should be None") + + query, key, value = hidden_states.chunk(3, dim=2) + if sample: + self.sample_t += curr_ctx + key, value = self._append_cache(key, value) + l_cache = self._suff_cache_len() + if self._cache_len() > l_cache: + self._slice_cache(-l_cache) + if curr_ctx > 1: + if self.attn_func != "dense_attn": + query = self._pad_to_block_ctx(query, query=True) + key = self._pad_to_block_ctx(key) + value = self._pad_to_block_ctx(value) + sample = False + else: + key = self.cache["key"] + value = self.cache["value"] + return query, key, value, sample + + def prime_qkv(self, hidden_states, last_encoder_hidden_states=None, sample=False): + curr_ctx = hidden_states.shape[1] + if last_encoder_hidden_states is not None: + raise TypeError("last_encoder_hidden_states should be None") + query, key, value = hidden_states.chunk(3, dim=2) + if sample: + if self._cache_len() < self._encoder_len: + self._append_cache(key, value) + if self._cache_len() > self._encoder_len: + self._slice_cache(0, self._encoder_len) + key, value = self.cache["key"], self.cache["value"] + self.sample_t += curr_ctx + return query, key, value, sample + + def decode_qkv(self, hidden_states, last_encoder_hidden_states=None, sample=False): + curr_ctx = hidden_states.shape[1] + query = hidden_states + if sample: + if self.sample_t == 0: + self.cache["key"], self.cache["value"] = self.c_enc_kv( + last_encoder_hidden_states.type_as(hidden_states) + ).chunk(2, dim=2) + key, value = self.cache["key"], self.cache["value"] + self.sample_t += curr_ctx + else: + key, value = self.c_enc_kv(last_encoder_hidden_states.type_as(hidden_states)).chunk(2, dim=2) + return query, key, value, sample + + def forward(self, hidden_states, last_encoder_hidden_states=None, sample=False): + curr_ctx = hidden_states.shape[1] + hidden_states = self.c_attn(hidden_states) + query, key, value, sample = self.qkv( + hidden_states, last_encoder_hidden_states=last_encoder_hidden_states, sample=sample + ) + attention_scores = self.attn(query, key, value, sample) + if attention_scores.shape[1] != curr_ctx: + offset = self._offset(curr_ctx) + attention_scores = attention_scores[:, offset : offset + curr_ctx, :].contiguous() + attention_scores = self.c_proj(attention_scores) + return self.resid_dropout(attention_scores) + + @property + def _encoder_len(self): + encoder_len = self.encoder_len + encoder_blocks = (encoder_len // self.blocks) + 1 + return encoder_blocks * self.blocks + + def _offset(self, curr_ctx): + if self.attn_func == "dense_attn": + return 0 + return (self.sample_t - curr_ctx) % self.block_ctx + + def _pad_to_block_ctx(self, hidden_states, query=False): + seq_len = hidden_states.shape[1] + offset = self._offset(seq_len) if query else 0 + n_blocks = (seq_len + offset + self.block_ctx - 1) // self.block_ctx + pad = n_blocks * self.block_ctx - seq_len - offset + if pad == 0 and offset == 0: + return hidden_states + else: + return F.pad(hidden_states, (0, 0, offset, pad)) + + def _cache_len(self): + return 0 if "key" not in self.cache else self.cache["key"].shape[1] + + def _suff_cache_len(self): + """ + Precondition: + key and value are appended with the current context and self.sample_t reflects the 1-indexed sample + location in the context. + """ + previous_block_length = (self.sample_t - 1) % self.block_ctx + 1 + self.block_ctx + REQUIRED_CACHE_LEN = { + "dense_attn": self.sample_t, + "block_attn": (self.sample_t - 1) % self.block_ctx + 1, + "transpose_block_attn": self.sample_t, + "prev_block_attn": self.sample_t if self.sample_t <= self.block_ctx else previous_block_length, + "cross_attn": self.encoder_len, + "prime_attn": min(self.sample_t, self._encoder_len), + } + + return REQUIRED_CACHE_LEN[self.attn_func] + + def _slice_cache(self, start, end=None): + self.cache["key"] = self.cache["key"][:, start:end] + self.cache["value"] = self.cache["value"][:, start:end] + + def _append_cache(self, key, value): + if "key" not in self.cache: + self.cache["key"] = key + self.cache["value"] = value + else: + old_key, old_value = key, value + key = ops.cat([self.cache["key"], old_key], dim=1) + value = ops.cat([self.cache["value"], old_value], dim=1) + del self.cache["key"] + del self.cache["value"] + del old_key + del old_value + self.cache["key"] = key + self.cache["value"] = value + return self.cache["key"], self.cache["value"] + + def del_cache(self): + self.sample_t = 0 + if "key" in self.cache: + del self.cache["key"] + if "value" in self.cache: + del self.cache["value"] + self.cache = {} + + +class JukeboxBlock(nn.Module): + def __init__(self, config, n_ctx, attn_func="dense_attn"): + super().__init__() + self.width = config.hidden_size + self.attn = JukeboxAttention(config, n_ctx, attn_func=attn_func) + + self.layer_norm_0 = JukeboxLayerNorm(config.hidden_size) + self.mlp = JukeboxMLP(config) + self.layer_norm_1 = JukeboxLayerNorm(config.hidden_size) + self.res_scale = 1.0 / config.num_layers if config.attn_res_scale else 1.0 + self.attn_func = attn_func + + def forward(self, hidden_states, last_encoder_hidden_states, sample=False): + residuals = hidden_states + hidden_states = self.layer_norm_0(hidden_states) + hidden_states = self.attn(hidden_states, last_encoder_hidden_states, sample) + + output_states = self.layer_norm_1(residuals + hidden_states) + output_states = self.mlp(output_states) + if self.res_scale == 1.0: + output = residuals + hidden_states + output_states + else: + output = residuals + self.res_scale * (hidden_states + output_states) + return output + + +class JukeboxLayerStack(nn.Module): + def __init__(self, config, n_ctx): + super().__init__() + self.n_ctx = n_ctx + self.width = config.hidden_size + self.num_layers = config.num_layers + self.blocks = config.blocks + self.attention_pattern = config.attention_pattern + if self.blocks is not None: + self.block_ctx = n_ctx // self.blocks + self.encoder_len = config.nb_relevant_lyric_tokens + self.n_heads = config.n_heads + + # Orders of attn_func + attention_pattern = ATTENTION_PATTERNS[self.attention_pattern] + self._attn_mods = nn.ModuleList() + for depth in range(self.num_layers): + self._attn_mods.append(JukeboxBlock(config, n_ctx, attn_func=attention_pattern(depth))) + + self.saved_attn_weights = [] + + def set_record_attn(self, record_attn): + """ + Makes forward prop dump self-attention softmaxes to self.saved_attn_weights. + + Args: + record_attn (`Union[bool,set]`): + Either a set of layer indices indicating which layers to store, or a boolean value indicating Whether + to dump all. + """ + + def _should_record_attn(layer_idx): + if isinstance(record_attn, bool): + return record_attn + return layer_idx in record_attn + + for i, layer in enumerate(self._attn_mods): + layer.attn.record_attn = _should_record_attn(i) + + if not record_attn: + self.saved_attn_weights = [] + + def forward(self, hidden_states, last_encoder_hidden_states=None, sample=False): + # Blocks + for i, attn_layer in enumerate(self._attn_mods): + if attn_layer.attn_func == "cross_attention": # attend to the lyrics + hidden_states = attn_layer( + hidden_states, last_encoder_hidden_states=last_encoder_hidden_states, sample=sample + ) + else: + hidden_states = attn_layer(hidden_states, last_encoder_hidden_states=None, sample=sample) + if attn_layer.attn.record_attn: + self.saved_attn_weights.append(attn_layer.attn.c_attn.weight) + return hidden_states + + def del_cache(self): + for attn_layer in self._attn_mods: + attn_layer.attn.del_cache() + + +class JukeboxPositionalEmbedding(nn.Module): + def __init__(self, embed_dim, width): + super().__init__() + self.pos_emb = nn.Parameter(ops.empty((embed_dim, width))) + + def forward(self): + pos_emb = self.pos_emb + return pos_emb + + +class JukeboxConditionalAutoregressive(nn.Module): + def __init__( + self, + config, + n_ctx=None, + embed_dim=None, + audio_conditioning=False, + metadata_conditioning=False, + is_encoder=False, + ): + """ + Autoregressive model on either lyric tokens or music tokens, or both. The attention pattern should be properly + set fro each configuration. + + Args: + config (`JukeboxPriorConfig`): + Model configuration class with all the parameters of the model. Initializing with a config file does + not load the weights associated with the model, only the configuration. Check out the + [`~PreTrainedModel.from_pretrained`] method to load the model weights. + n_ctx (`int`, *optional*): + Number of tokens or lyrics tokens provided in a single pass. + embed_dim (`int`, *optional*): + Either equals to the dimension of the codebook, or the sum of n_vocab (lyrics) and codeboook dimension, + if the model combines lyrics and music tokens, or simply n_vocab if the model is a seperate encoder + audio_conditioning (`bool`, *optional*, defaults to `False`): + Whether or not the prior supports conditionning on audio. + metadata_conditioning (`bool`, *optional*, defaults to `False`): + Whether or not the prior supports conditionning on artitst, genres, lyrics and timing. + is_encoder (`bool`, *optional*, defaults to `False`): + Whether the model is an encoder only model. + """ + + super().__init__() + self.width = config.hidden_size + self.num_layers = config.num_layers + self.n_ctx = n_ctx if n_ctx is not None else config.n_ctx + self.embed_dim = embed_dim if embed_dim is not None else config.music_vocab_size + self.embed_tokens = nn.Embedding(self.embed_dim, config.hidden_size) + self.embed_tokens_dropout = nn.Dropout(config.emb_dropout) + self.metadata_conditioning = metadata_conditioning + self.audio_conditioning = audio_conditioning + if not metadata_conditioning: + self.start_token = nn.Parameter(ops.empty((1, config.hidden_size))) + self.pos_emb = JukeboxPositionalEmbedding(self.n_ctx, config.hidden_size) + self.pos_emb_dropout = nn.Dropout(config.emb_dropout) + + self.transformer = JukeboxLayerStack(config, n_ctx=self.n_ctx) + self.is_encoder = is_encoder + self.encoder_len = config.nb_relevant_lyric_tokens + + if config.merged_decoder: + # Merged piped model uses this setup + self.add_cond_after_transformer = False + self.share_embed_tokens_fc_proj_out = False + else: + self.add_cond_after_transformer = True + self.share_embed_tokens_fc_proj_out = True + + if not is_encoder: + self.fc_proj_out = nn.Linear(config.hidden_size, self.embed_dim, bias=False) + if self.share_embed_tokens_fc_proj_out: + self.fc_proj_out.weight = self.embed_tokens.weight + self.loss = nn.CrossEntropyLoss() + + def forward( + self, + tokens, + audio_conditioning=None, + metadata_conditioning=None, + last_encoder_hidden_states=None, + get_preds=False, + get_acts=False, + get_sep_loss=False, + ): + """ + Args: + tokens (`mindspore.tensor`): + Can represent music tokens, lyrics tokens or both, depending on the configuration. + """ + # Preprocess. + batch_size = tokens.shape[0] + with no_grad(): + tokens = tokens.view(batch_size, -1).long() + + if not self.audio_conditioning: + audio_conditioning = ops.zeros( + (batch_size, 1, self.width), + dtype=self.transformer._attn_mods[0].mlp.c_fc.weight.dtype, + ) + + target = tokens # Target + hidden_states = self.embed_tokens(tokens) + # Shift by 1, and fill in start token + hidden_states = ops.cat((hidden_states[:, -1:], hidden_states[:, :-1]), dim=1) + if self.metadata_conditioning: + hidden_states[:, 0] = metadata_conditioning.view(batch_size, self.width) + else: + hidden_states[:, 0] = self.start_token + + hidden_states = ( + self.embed_tokens_dropout(hidden_states) + self.pos_emb_dropout(self.pos_emb()) + audio_conditioning + ) # Pos emb and dropout + + hidden_states = self.transformer( + hidden_states, last_encoder_hidden_states=last_encoder_hidden_states + ) # Transformer + if self.add_cond_after_transformer: # Piped doesnt add x_cond + hidden_states = hidden_states + audio_conditioning + + activations = hidden_states + if self.is_encoder: + return hidden_states + + hidden_states = self.fc_proj_out(hidden_states) # Predictions + loss_fn = nn.CrossEntropyLoss() + if get_sep_loss: + lyric_hidden_states = hidden_states[:, : self.encoder_len].reshape(-1, self.embed_dim) + token_hidden_states = hidden_states[:, self.encoder_len :].reshape(-1, self.embed_dim) + + lyric_loss = loss_fn(lyric_hidden_states, target[:, : self.encoder_len].reshape(-1)) / np.log(2.0) + music_token_loss = loss_fn(token_hidden_states, target[:, self.encoder_len :].reshape(-1)) / np.log(2.0) + + loss = (lyric_loss, music_token_loss) # Note order! Lyric is first + else: + loss = loss_fn(hidden_states.view(-1, self.embed_dim), target.view(-1)) / np.log(2.0) # Loss + + if get_preds: + return loss, hidden_states + elif get_acts: + return loss, activations + else: + return loss, None + + def get_emb(self, sample_t, n_samples, tokens, audio_conditioning, metadata_conditioning): + if sample_t == 0: + hidden_states = ops.zeros(n_samples, 1, self.width, dtype=self.embed_tokens.weight.dtype).to( + self.embed_tokens.weight + ) + if self.metadata_conditioning: + hidden_states[:, 0] = metadata_conditioning.view(n_samples, self.width) + else: + hidden_states[:, 0] = self.start_token + else: + hidden_states = self.embed_tokens(tokens) + if audio_conditioning.shape == (n_samples, self.n_ctx, self.width): + cond = audio_conditioning[:, sample_t : sample_t + 1, :] + else: + cond = audio_conditioning + # Pos emb, dropout is identity at eval time + hidden_states = hidden_states + self.pos_emb()[sample_t : sample_t + 1] + cond + return hidden_states, cond + + def sample( + self, + n_samples, + audio_conditioning=None, + metadata_conditioning=None, + last_encoder_hidden_states=None, + temp=1.0, + top_k=0, + top_p=0.0, + get_preds=False, + sample_tokens=None, + ): + if sample_tokens is None: + sample_tokens = self.n_ctx + + if not self.audio_conditioning: + audio_conditioning = ops.zeros( + (n_samples, 1, self.width), dtype=self.transformer._attn_mods[0].mlp.c_fc.weight.dtype + ).to(self.fc_proj_out) + + with no_grad(): + sampled_tokens = [] + tokens = None + if get_preds: + preds = [] + + iter = tqdm(range(0, sample_tokens), leave=False) + for sample_t in iter: + iter.set_description(f"Ancestral sampling {sample_tokens} music tokens", refresh=True) + hidden_states, cond = self.get_emb( + sample_t, n_samples, tokens, audio_conditioning, metadata_conditioning + ) + + hidden_states = self.transformer( + hidden_states, last_encoder_hidden_states=last_encoder_hidden_states, sample=True + ) + if self.add_cond_after_transformer: + hidden_states = hidden_states + cond + hidden_states = self.fc_proj_out(hidden_states) # Predictions + if get_preds: + preds.append(hidden_states.clone()) + # Adjust logits + hidden_states = hidden_states / temp + hidden_states = filter_logits(hidden_states, top_k=top_k, top_p=top_p) + # Sample and replace hidden_states + tokens = distributions.Categorical(logits=hidden_states).sample() + sampled_tokens.append(tokens.clone()) + + del tokens + self.transformer.del_cache() + + tokens = ops.cat(sampled_tokens, dim=1) + if get_preds: + preds = ops.cat(preds, dim=1) + if get_preds: + return tokens, preds + else: + return tokens + + def split_chunks(self, length, chunk_size): + n_passes = (length + chunk_size - 1) // chunk_size + chunk_sizes = [*[chunk_size] * (n_passes - 1), (length - 1) % chunk_size + 1] + return chunk_sizes + + def primed_sample( + self, + n_samples, + lyric_and_music_tokens, + audio_conditioning=None, + metadata_conditioning=None, + last_encoder_hidden_states=None, + temp=1.0, + top_k=0, + top_p=0.0, + get_preds=False, + chunk_size=None, + sample_tokens=None, + ): + if sample_tokens is None: + sample_tokens = self.n_ctx + # Preprocess. + batch_size = lyric_and_music_tokens.shape[0] + with no_grad(): + lyric_and_music_tokens = lyric_and_music_tokens.view(batch_size, -1).long() + + sampled_audio = ops.split(lyric_and_music_tokens, 1, dim=1) + sampled_audio = list(sampled_audio) + + if not self.audio_conditioning: + audio_conditioning = ops.zeros( + (n_samples, 1, self.width), dtype=self.transformer._attn_mods[0].mlp.c_fc.weight.dtype + ).to(lyric_and_music_tokens) + + with no_grad(): + if get_preds: + preds = [] + + # Fill up key/value cache for past context by runing forward pass. + # We do so in chunks instead of doing the whole past in one forward pass to reduce max memory usage. + if chunk_size is None: + chunk_size = len(sampled_audio) + chunk_sizes = self.split_chunks(len(sampled_audio), chunk_size) + x_primes = [] + start = 0 + token = None + + for current_chunk_size in tqdm(chunk_sizes, desc="Preparing past key value", leave=False): + sampled_audio_prime, conds_prime = [], [] + for sample_t in range(start, start + current_chunk_size): + x_prime, cond_prime = self.get_emb( + sample_t, n_samples, token, audio_conditioning, metadata_conditioning + ) + token = sampled_audio[sample_t] + sampled_audio_prime.append(x_prime) + conds_prime.append(cond_prime) + start = start + current_chunk_size + x_prime, cond_prime = ops.cat(sampled_audio_prime, dim=1), ops.cat(conds_prime, dim=1) + del sampled_audio_prime + del conds_prime + if not get_preds: + del cond_prime + x_prime = self.transformer(x_prime, last_encoder_hidden_states=last_encoder_hidden_states, sample=True) + + if get_preds: + if self.add_cond_after_transformer: + x_prime = x_prime + cond_prime + del cond_prime + x_primes.append(x_prime) + else: + del x_prime + + if get_preds: + x_prime = ops.cat(x_primes, dim=1) + x_prime = self.fc_proj_out(x_prime) # Predictions + preds.append(x_prime) + + # the input of the encoder and decoder can be merged into (lyrics, music tokens) + input_tokens = sampled_audio[-1] + + itererator = tqdm( + range(len(sampled_audio), sample_tokens), + desc=f"Sampling {len(range(len(sampled_audio), sample_tokens))} music tokens", + leave=False, + ) + for sample_t in itererator: + hidden_states, cond = self.get_emb( + sample_t, n_samples, input_tokens, audio_conditioning, metadata_conditioning + ) + + hidden_states = self.transformer( + hidden_states, last_encoder_hidden_states=last_encoder_hidden_states, sample=True + ) + if self.add_cond_after_transformer: + hidden_states = hidden_states + cond + hidden_states = self.fc_proj_out(hidden_states) # Predictions + if get_preds: + preds.append(hidden_states) + # Adjust logits + hidden_states = hidden_states / temp + hidden_states = filter_logits(hidden_states, top_k=top_k, top_p=top_p) + # only music tokens are sampled + music_tokens = distributions.Categorical(logits=hidden_states).sample() + sampled_audio.append(music_tokens.clone()) + input_tokens = music_tokens + + del input_tokens, music_tokens + self.transformer.del_cache() + + music_tokens = ops.cat(sampled_audio, dim=1) + if get_preds: + preds = ops.cat(preds, dim=1) + if get_preds: + return music_tokens, preds + else: + return music_tokens + + +class JukeboxMusicTokenConditioner(nn.Module): + """ + The `JukeboxMusicTokenConditioner` takes music tokens as an input (coresponding to the codes of the VQVAE's + codebook) and upsamples it using a single layer of decoder convolution block (the same is used in the VQVAE). + """ + + def __init__(self, config, level): + super().__init__() + self.embed_tokens = nn.Embedding(config.music_vocab_size, config.hidden_size) + config.embed_dim = config.music_vocab_size # setting correct argument for the `JukeboxDecoder` + + self.upsampler = JukeboxDecoderConvBock( + config, + config.hidden_size, + config.res_conv_width, + config.res_conv_depth, + config.res_downs_t[level], + config.res_strides_t[level], + reverse_dilation=False, + ) + self.layer_norm = JukeboxLayerNorm(config.hidden_size) + + def forward(self, music_tokens, raw_audio_conditionning=None): + """ + Args: + music_tokens (`mindspore.Tensor`): + Music tokens form the uper level in range(nb_discrete_codes) + raw_audio_conditionning (`mindspore.Tensor`, *optional*): + Audio used when primed sampling, raw audio information that conditions the generation + """ + if raw_audio_conditionning is None: + raw_audio_conditionning = 0.0 + # Embed music_tokens + music_tokens = music_tokens.long() + hidden_states = self.embed_tokens(music_tokens) + hidden_states = hidden_states + raw_audio_conditionning + + # Run conditioner + hidden_states = hidden_states.permute(0, 2, 1) + hidden_states = self.upsampler(hidden_states) + hidden_states = hidden_states.permute(0, 2, 1) + hidden_states = self.layer_norm(hidden_states) + return hidden_states + + +class JukeboxRangeEmbedding(nn.Module): + """ + The `JukeboxRangeEmbedding` interpolate the given [pos_start, pos_end] to obtain an equivalent of time positional + embedding of length `n_ctx`. + + Binning process : For each pos in position tensor, find its bin [start,end) mapped to [0,1,...,bins-1] [start,end) + -> [0,1) -> [0, bins) -> floor -> [0,...,bins-1] NOTE: Open ended interval on right, so start <= pos < end, not <= + end + """ + + def __init__(self, n_time, embed_dim, range, out_width, clamp=False): + super().__init__() + self.n_time = n_time + self.embed_dim = embed_dim + self.emb = nn.Embedding(embed_dim, out_width) + self.pos_min, self.pos_max = range + self.clamp = clamp + + def forward(self, pos_start, pos_end=None): + # Check if [pos_start,pos_end] in [pos_min, pos_max) + if not len(pos_start.shape) == 2: + raise TypeError(f"Expected shape with 2 dims, got {pos_start.shape}") + if not (self.pos_min <= pos_start).all() and (pos_start < self.pos_max).all(): + raise TypeError(f"Range is [{self.pos_min},{self.pos_max}), got {pos_start}") + + pos_start = pos_start.float() + if pos_end is not None: + if self.clamp: + pos_end = pos_end.clamp(self.pos_min, self.pos_max) + + pos_end = pos_end.float() + # Interpolate so that [pos_start, ..., pos_end] <-> position tensor of length n_ctx + n_time = self.n_time + if n_time != 1: + interpolation = ( + ops.arange(0, n_time, dtype=mindspore.float32).view(1, n_time) / n_time + ) + position = pos_start + (pos_end - pos_start) * interpolation + else: + position = pos_start + + # Bin each value to bins_ + # [0,1) -> [0,1..,embed_dim) -> [0,1...,embed_dim-1 + normalised_position = (position - self.pos_min) / (self.pos_max - self.pos_min) + bins_ = (self.embed_dim * normalised_position).floor().long().detach() + return self.emb(bins_) + + +class JukeboxLabelConditioner(nn.Module): + def __init__(self, config, include_time_signal): + super().__init__() + + embed_dim = config.hidden_size + timing_dims = config.timing_dims + sampling_rate = config.sampling_rate + nb_genres, nb_artists = config.metadata_dims + music_tokens_shape = config.n_ctx + + self.max_nb_genres = config.max_nb_genres + self.bow_genre_emb = nn.Embedding(nb_genres, embed_dim) + self.artist_emb = nn.Embedding(nb_artists, embed_dim) + self.include_time_signal = include_time_signal + if self.include_time_signal: + total_length_range = (config.min_duration * sampling_rate, config.max_duration * sampling_rate) + absolute_pos_range = (0.0, config.max_duration * sampling_rate) + relative_pos_range = (0.0, 1.0) + self.total_length_emb = JukeboxRangeEmbedding(1, timing_dims, total_length_range, embed_dim) + self.absolute_pos_emb = JukeboxRangeEmbedding( + music_tokens_shape, timing_dims, absolute_pos_range, embed_dim + ) + self.relative_pos_emb = JukeboxRangeEmbedding( + music_tokens_shape, timing_dims, relative_pos_range, embed_dim, clamp=True + ) + + def forward(self, metadata): + total_length = metadata[:, 0:1] + offset = metadata[:, 1:2] + length = metadata[:, 2:3] + artist = metadata[:, 3:4] + genre = metadata[:, 4:] + + # Start embedding of length 1 + artist_emb = self.artist_emb(artist) + # Empty genre slots are denoted by -1. We mask these out. + mask = (genre >= 0).float().unsqueeze(2) + genre_emb = (self.bow_genre_emb(genre.clamp(0)) * mask).sum(dim=1, keepdim=True) + start_emb = genre_emb + artist_emb + + # Pos embedding of length n_ctx + if self.include_time_signal: + start, end = offset, offset + length + total_length = total_length.float() + start = start.float() + end = end.float() + pos_emb = ( + self.total_length_emb(total_length) + + self.absolute_pos_emb(start, end) + + self.relative_pos_emb(start / total_length, end / total_length) + ) + else: + pos_emb = None + return start_emb, pos_emb + + +class JukeboxPrior(PreTrainedModel): + """ + The JukeboxPrior class, which is a wrapper around the various conditioning and the transformer. JukeboxPrior can be + seen as language models trained on music. They model the next `music token` prediction task. If a (lyric) `encoderù + is defined, it also models the `next character` prediction on the lyrics. Can be conditionned on timing, artist, + genre, lyrics and codes from lower-levels Priors. + + Args: + config (`JukeboxPriorConfig`): + Model configuration class with all the parameters of the model. Initializing with a config file does not + load the weights associated with the model, only the configuration. Check out the + [`~PreTrainedModel.from_pretrained`] method to load the model weights. + level (`int`, *optional*): + Current level of the Prior. Should be in range `[0,nb_priors]`. + nb_priors (`int`, *optional*, defaults to 3): + Total number of priors. + vqvae_encoder (`Callable`, *optional*): + Encoding method of the VQVAE encoder used in the forward pass of the model. Passing functions instead of + the vqvae module to avoid getting the parameters. + vqvae_decoder (`Callable`, *optional*): + Decoding method of the VQVAE decoder used in the forward pass of the model. Passing functions instead of + the vqvae module to avoid getting the parameters. + """ + + config_class = JukeboxPriorConfig + + def _init_weights(self, module): + init_scale = self.config.init_scale + + if isinstance(module, nn.Embedding): + module.weight.data.normal_(mean=0.0, std=0.02 * init_scale) + elif isinstance(module, JukeboxConv1D): + if self.config.zero_out: + module.weight.data.zero_() + else: + module.weight.data.normal_(mean=0.0, std=0.02 * init_scale) + elif isinstance(module, JukeboxPositionalEmbedding): + module.pos_emb.data.normal_(mean=0.0, std=0.01 * init_scale) + elif isinstance(module, JukeboxRangeEmbedding): + module.emb.weight.data.normal_(mean=0.0, std=0.01 * init_scale) + elif isinstance(module, JukeboxConditionalAutoregressive) and hasattr(module, "lm_head"): + module.lm_head.weight.data.normal_(mean=0.0, std=0.02 * init_scale) + elif isinstance(module, JukeboxConditionalAutoregressive) and hasattr(module, "start_token"): + module.start_token.data.normal_(mean=0.0, std=0.01 * init_scale) + elif isinstance(module, JukeboxResConv1DBlock) and self.config.zero_out: + module.conv1d_2.weigth.data.zero_() + module.conv1d_2.bias.data.zero_() + if isinstance(module, nn.LayerNorm): + module.bias.data.zero_() + module.weight.data.fill_(1.0) + if isinstance(module, nn.Linear) and module.bias is not None: + module.bias.data.zero_() + + def __init__(self, config: JukeboxPriorConfig, level=None, nb_priors=3, vqvae_encoder=None, vqvae_decoder=None): + super().__init__(config) + # Passing functions instead of the vqvae module to avoid getting params, only used in the + # forward loop + self.vqvae_encoder = vqvae_encoder + self.vqvae_decoder = vqvae_decoder + + self.levels = nb_priors + self.level = level if level is not None else config.level + + self.base_model_prefix = f"priors.{self.level}" + + self.n_ctx = config.n_ctx + + self.lyric_conditioning = config.nb_relevant_lyric_tokens > 0 + self.nb_relevant_lyric_tokens = config.nb_relevant_lyric_tokens + self.encoder_loss_fraction = config.encoder_loss_fraction + + # Audio conditioning : conditioning on music tokens (either from audio or from previous levels or both) + self.audio_conditioning = self.level != 0 + self.cond_level = self.level - 1 + if self.audio_conditioning: + self.conditioner_blocks = JukeboxMusicTokenConditioner(config, self.level) + + # metadata conditioning : contioning on timing, genres, and artist + self.metadata_conditioning = config.metadata_conditioning + if self.metadata_conditioning: + self.metadata_embedding = JukeboxLabelConditioner(config, include_time_signal=not self.audio_conditioning) + + # define encoder-decoder or encoder and decoder + self.is_encoder_decoder = config.is_encoder_decoder + if config.is_encoder_decoder: + # encoder-decoder transformer + self.input_shapes = [config.nb_relevant_lyric_tokens, config.n_ctx] + self.embed_dim_shift = [0, config.lyric_vocab_size] + self.width = config.hidden_size + + self.nb_relevant_lyric_tokens = config.nb_relevant_lyric_tokens + + self.prior = JukeboxConditionalAutoregressive( + config, + n_ctx=config.nb_relevant_lyric_tokens + config.n_ctx, + embed_dim=config.lyric_vocab_size + config.music_vocab_size, + audio_conditioning=(self.audio_conditioning or self.metadata_conditioning), + metadata_conditioning=True, + ) + + else: + # Separate encoder-decoder transformer + encoder_config = config.encoder_config + + if self.nb_relevant_lyric_tokens != 0 and self.lyric_conditioning: + self.lyric_acts_width = encoder_config.hidden_size + self.encoder_width = config.hidden_size + self.encoder_dim = config.lyric_vocab_size + self.encoder = JukeboxConditionalAutoregressive( + encoder_config, + n_ctx=self.nb_relevant_lyric_tokens, + embed_dim=self.encoder_dim, + audio_conditioning=False, + metadata_conditioning=False, + is_encoder=True, + ) + self.encoder.proj_in = JukeboxConv1D(encoder_config.hidden_size, config.hidden_size) + self.encoder.final_layer_norm = JukeboxLayerNorm(config.hidden_size) + self.encoder.lm_head = nn.Linear(config.hidden_size, config.lyric_vocab_size, bias=False) + else: + self.nb_relevant_lyric_tokens = 0 + + # decoder model on the tokens + self.prior = JukeboxConditionalAutoregressive( + config, + audio_conditioning=(self.audio_conditioning or self.metadata_conditioning), + metadata_conditioning=self.metadata_conditioning, + ) + + self.next_token_prediction_loss_dims = config.n_ctx + self.total_loss_dims = self.nb_relevant_lyric_tokens + self.next_token_prediction_loss_dims + + self.downsamples = [stride**down for stride, down in zip(config.res_strides_t, config.res_downs_t)] + self.cond_downsample = self.downsamples[self.level] if self.level != 0 else None + self.raw_to_tokens = np.prod(self.downsamples[: nb_priors - self.level]) + self.sample_length = self.n_ctx * self.raw_to_tokens + + logger.info( + f"Level:{self.level}, Cond downsample:{self.cond_downsample}, Raw to tokens:{self.raw_to_tokens}, Sample" + f" length:{self.sample_length}" + ) + + def get_metadata(self, labels, start, total_length, offset, get_indices=False): + metadata = labels.clone() + metadata[:, 0] = total_length + # Set sample_length to match this level + metadata[:, 2] = int(self.sample_length) + + # Set offset + metadata[:, 1:2] = int(offset * self.raw_to_tokens) + int(start * self.raw_to_tokens) + # here since metadata has the full token_list, we just need to selected the ones that are relevant + + # Set lyric tokens + metadata, indices = self.set_metadata_lyric_tokens(metadata) + if get_indices: + return metadata, indices + else: + return metadata + + def set_metadata_lyric_tokens(self, labels): + """ + Processes the full labels to only retreive the relevant lyric tokens and keep the metadata conditioning tokens. + """ + if self.nb_relevant_lyric_tokens > 0: + tokens_list = ops.zeros( + (labels.shape[0], self.nb_relevant_lyric_tokens), dtype=mindspore.int64) + indices_list = [] # whats the index of each current character in original array + for idx in range(labels.shape[0]): + full_tokens = labels.clone()[:, 4 + self.metadata_embedding.max_nb_genres :] + total_length, offset, duration = labels[idx, 0], labels[idx, 1], labels[idx, 2] + tokens, indices = get_relevant_lyric_tokens( + full_tokens, self.nb_relevant_lyric_tokens, total_length, offset, duration + ) + tokens_list[idx, :] = tokens + indices_list.append(indices) + + return ( + ops.cat((labels[:, : 4 + self.metadata_embedding.max_nb_genres], tokens_list), dim=-1), + indices_list, + ) + else: + return labels, None + + def get_music_tokens_conds(self, music_tokens, start, end): + """ + Extracts current level's conditioning music tokens. + """ + if self.level != 0: + music_tokens_cond = music_tokens[self.level - 1] + music_tokens = music_tokens_cond[:, start // self.cond_downsample : end // self.cond_downsample] + missing_cond_len = self.n_ctx // self.cond_downsample - music_tokens_cond[-1].shape[-1] + if missing_cond_len > 0: + init_cond = ops.zeros(1, missing_cond_len).to(music_tokens_cond) + music_tokens_cond = ops.cat((music_tokens_cond, init_cond), dim=-1).long() + music_tokens_conds = [music_tokens_cond] + else: + music_tokens_conds = None + return music_tokens_conds + + def prior_preprocess(self, tokens, conds): + """ + Shifts the input tokens to account for the dictionary merge. The embed_dim_shift give by how much the music + tokens should be shifted by. It is equal to `lyric_vocab_size`. + """ + batch_size = tokens[0].shape[0] + for i in range(len(tokens)): + tokens[i] = (tokens[i] + int(self.embed_dim_shift[i])).view(batch_size, -1) + + for i in range(len(conds)): + if conds[i] is None: + conds[i] = ops.zeros( + (batch_size, self.input_shapes[i], self.width), dtype=tokens[0].dtype) + + return ops.cat(tokens, dim=1), ops.cat(conds, dim=1) + + def prior_postprocess(self, tokens): + """ + Shifts back the input tokens if the model uses an encoder decoder architecture. As the embedding layer is + shared, `prior_embed_dim_shift` shifts the music token ids by `lyric_vocab_size`. Only returns the music + tokens. + """ + batch_size = tokens.shape[0] + dims = (self.input_shapes[0], tokens.shape[1] - self.input_shapes[0]) + tokens = list(ops.split(tokens, dims, dim=1)) + + # Some of the input tokens might be shifted to take into account the voccabulary fusion + for i in range(len(tokens)): + bins_shift = int(self.embed_dim_shift[i]) + tokens[i] = (tokens[i] - bins_shift).view(batch_size, -1) + tokens[i] = ops.clamp(tokens[i], min=0) + # If not masking loss, model may have generated lyric/midi tokens which are now shifted <0 by bin_shift + return tokens[-1] + + def embed_tokens(self, music_tokens_conds): + """ + Embeds the upper level music tokens and upsamples them to provide as audio conditioning. + """ + music_tokens_conds = music_tokens_conds[: self.cond_level + 1] + audio_conditioning = None + for music_tokens_cond, conditioner_block in reversed(list(zip(music_tokens_conds, [self.conditioner_blocks]))): + audio_conditioning = conditioner_block(music_tokens_cond, audio_conditioning) + return audio_conditioning + + def encode(self, hidden_states, start_level=None, end_level=None, bs_chunks=1): + """ + Encodes the hidden states (raw audio) using the VQVAE's encoder. Returns latent_states. + """ + if start_level is None: + start_level = self.level + if end_level is None: + end_level = self.levels + # Get latents + with no_grad(): + latent_states = self.vqvae_encoder( + hidden_states, start_level=start_level, end_level=end_level, bs_chunks=bs_chunks + ) + return latent_states + + def decode(self, music_tokens, start_level=None, end_level=None, bs_chunks=1): + """ + Usamples the sequence of codebook vectors to a raw audio. + """ + if start_level is None: + start_level = self.level + if end_level is None: + end_level = self.levels + with no_grad(): + output = self.vqvae_decoder( + music_tokens, start_level=start_level, end_level=end_level, bs_chunks=bs_chunks + ) + return output + + def get_cond(self, music_tokens_conds, metadata): + """ + Converts the input tokens to input_embeddings. Splits the lyrics form the rest of the metadata. Lyric tokens + can be None. + """ + if metadata is not None: + n_labels = metadata.shape[1] - self.nb_relevant_lyric_tokens + metadata, lyric_tokens = metadata[:, :n_labels], metadata[:, n_labels:] + else: + metadata, lyric_tokens = None, None + metadata_conditioning, metadata_pos = ( + self.metadata_embedding(metadata) if self.metadata_conditioning else (None, None) + ) + audio_conditioning = self.embed_tokens(music_tokens_conds) if self.audio_conditioning else metadata_pos + return audio_conditioning, metadata_conditioning, lyric_tokens + + def sample( + self, + n_samples, + music_tokens=None, + music_tokens_conds=None, + metadata=None, + temp=1.0, + top_k=0, + top_p=0.0, + chunk_size=None, + sample_tokens=None, + ): + """ + Ancestral/Prime sampling a window of tokens using the provided conditioning and metadatas. + + Args: + n_samples (`int`): + Number of samples to generate. + music_tokens (`List[mindspore.Tensor]`, *optional*): + Previously gemerated tokens at the current level. Used as context for the generation. + music_tokens_conds (`List[mindspore.Tensor]`, *optional*): + Upper-level music tokens generated by the previous prior model. Is `None` if the generation is not + conditionned on the upper-level tokens. + metadata (`List[mindspore.Tensor]`, *optional*): + List containing the metatdata tensor with the artist, genre and the lyric tokens. + temp (`float`, *optional*, defaults to 1.0): + Sampling temperature. + top_k (`int`, *optional*, defaults to 0): + Top k probabilities used for filtering. + top_p (`float`, *optional*, defaults to 0.0): + Top p probabilities used for filtering. + chunk_size (`int`, *optional*): + Size of the chunks used to prepare the cache of the transformer. + sample_tokens (`int`, *optional*): + Number of tokens to sample. + + """ + no_past_context = music_tokens is None or music_tokens.shape[1] == 0 + name = {True: "Ancestral", False: "Primed"}[no_past_context] + logger.info(f"{name} sampling {n_samples} samples with temp={temp}, top_k={top_k}, top_p={top_p}") + + with no_grad(): + # Currently audio_conditioning only uses immediately above layer + audio_conditioning, metadata_conditioning, lyric_tokens = self.get_cond(music_tokens_conds, metadata) + if self.is_encoder_decoder: + if no_past_context: # the prime_sample function will be used with music_tokens set to None + lyric_and_music_tokens, audio_conditioning = self.prior_preprocess( + [lyric_tokens], [None, audio_conditioning] + ) + else: + lyric_and_music_tokens, audio_conditioning = self.prior_preprocess( + [lyric_tokens, music_tokens], [None, audio_conditioning] + ) + if sample_tokens is not None: + sample_tokens += self.nb_relevant_lyric_tokens + music_tokens = self.prior.primed_sample( + n_samples, + lyric_and_music_tokens, + audio_conditioning, + metadata_conditioning, + temp=temp, + top_k=top_k, + top_p=top_p, + chunk_size=chunk_size, + sample_tokens=sample_tokens, + ) + music_tokens = self.prior_postprocess(music_tokens) + else: + last_encoder_hidden_states = self.get_encoder_states(lyric_tokens, sample=True) + if no_past_context: + music_tokens = self.prior.sample( + n_samples, + audio_conditioning, + metadata_conditioning, + last_encoder_hidden_states, + temp=temp, + top_k=top_k, + top_p=top_p, + sample_tokens=sample_tokens, + ) + else: + music_tokens = self.prior.primed_sample( + n_samples, + music_tokens, + audio_conditioning, + metadata_conditioning, + last_encoder_hidden_states, + temp=temp, + top_k=top_k, + top_p=top_p, + chunk_size=chunk_size, + sample_tokens=sample_tokens, + ) + return music_tokens + + def get_encoder_states(self, lyric_tokens, sample=False): + """ + Retreive the last hidden_states of the lyric encoder that will be attended to by the decoder. Forwards through + the lyric encoder. + """ + if self.nb_relevant_lyric_tokens != 0 and self.lyric_conditioning: + if sample: + self.encoder = self.encoder.to(lyric_tokens) + lyric_acts = self.encoder(lyric_tokens, None, None, None) + lyric_acts = self.encoder.proj_in(lyric_acts) + last_encoder_hidden_states = self.encoder.final_layer_norm(lyric_acts) + else: + last_encoder_hidden_states = None + return last_encoder_hidden_states + + def get_encoder_loss(self, last_encoder_hidden_states, target_lyrics): + """ + Computes the loss for the lyric encoder: next lyric token prediction. + """ + if self.lyric_conditioning: + last_encoder_hidden_states = self.encoder.lm_head(last_encoder_hidden_states) + encoder_loss = nn.functional.cross_entropy( + last_encoder_hidden_states.view(-1, self.encoder_dim), target_lyrics.view(-1) + ) / np.log(2.0) + else: + encoder_loss = mindspore.tensor(0.0) + return encoder_loss + + def forward_tokens( + self, music_tokens, music_tokens_conds=[], metadata=None, get_preds=False, get_attn_weights=False + ): + """ + Applies a forward pass using the conditioning tokens. Different from the classic forward as it does not use the + vqvae's encoding layers. + """ + if get_attn_weights: + self.prior.transformer.set_record_attn(get_attn_weights) + audio_conditioning, metadata_conditioning, lyric_tokens = self.get_cond(music_tokens_conds, metadata) + + if self.is_encoder_decoder: # the preprocess returns the full tokens (Lyrics and Music tokens), shifted + tokens, audio_conditioning = self.prior_preprocess( + [lyric_tokens, music_tokens], [None, audio_conditioning] + ) + (encoder_loss, next_token_prediction_loss), preds = self.prior( + tokens, audio_conditioning, metadata_conditioning, get_sep_loss=True, get_preds=get_preds + ) + else: + last_encoder_hidden_states = self.get_encoder_states(lyric_tokens) + encoder_loss = self.get_encoder_loss(last_encoder_hidden_states, lyric_tokens) + next_token_prediction_loss, preds = self.prior( + music_tokens, + audio_conditioning, + metadata_conditioning, + last_encoder_hidden_states, + get_preds=get_preds, + ) + loss = self.encoder_loss_fraction * encoder_loss * self.nb_relevant_lyric_tokens / self.total_loss_dims + loss += next_token_prediction_loss * self.next_token_prediction_loss_dims / self.total_loss_dims + + metrics = { + "bpd": next_token_prediction_loss.clone().detach(), + "encoder_loss": encoder_loss.clone().detach(), + "next_token_prediction_loss": next_token_prediction_loss.clone().detach(), + } + if get_preds: + metrics["preds"] = preds.clone().detach() + if get_attn_weights: + saved_attn_weights = self.prior.transformer.saved_attn_weights + self.prior.transformer.set_record_attn(False) + return saved_attn_weights + else: + return loss, metrics + + def forward( + self, + hidden_states: mindspore.Tensor, + metadata: Optional[List[mindspore.Tensor]], + decode: Optional[bool] = False, + get_preds: Optional[bool] = False, + ) -> List[mindspore.Tensor]: + """ + Encode the hidden states using the `vqvae` encoder, and then predicts the next token in the `forward_tokens` + function. The loss is the sum of the `encoder` loss and the `decoder` loss. + + Args: + hidden_states (`mindspore.Tensor`): + Hidden states which should be raw audio + metadata (`List[mindspore.Tensor]`, *optional*): + List containing the metadata conditioning tensorwith the lyric and the metadata tokens. + decode (`bool`, *optional*, defaults to `False`): + Whether or not to decode the encoded to tokens. + get_preds (`bool`, *optional*, defaults to `False`): + Whether or not to return the actual predicitons of the model. + """ + batch_size = hidden_states.shape[0] + music_tokens, *music_tokens_conds = self.encode(hidden_states, bs_chunks=batch_size) + loss, metrics = self.forward_tokens( + music_tokens=music_tokens, + music_tokens_conds=music_tokens_conds, + metadata=metadata, + get_preds=get_preds, + ) + if decode: + dequantised_states = self.decode([music_tokens, *music_tokens_conds]) + else: + dequantised_states = None + return dequantised_states, loss, metrics + + +class JukeboxPreTrainedModel(PreTrainedModel): + """ + An abstract class to handle weights initialization and a simple interface for downloading and loading pretrained + models. + """ + + config_class = JukeboxConfig + base_model_prefix = "jukebox" + supports_gradient_checkpointing = False + + def _init_weights(self, module): + if isinstance(module, JukeboxPrior) or isinstance(module, JukeboxVQVAE): + module.apply(module._init_weights) + + def __init__(self, *inputs, **kwargs): + super().__init__(*inputs, **kwargs) + + +JUKEBOX_SAMPLING_INPUT_DOCSTRING = r""" + labels (`List[mindspore.Tensor]` of length `n_sample`, and shape `(self.levels, self.config.max_nb_genre + lyric_sequence_length)` : + List of metadata such as `artist_id`, `genre_id` and the full list of lyric tokens which are used to + condition the generation. + sampling_kwargs (`Dict[Any]`): + Various additional sampling arguments that are used by the `_sample` function. A detail list of the + arguments can bee seen in the [`_sample`] function documentation. +""" + + +class JukeboxModel(JukeboxPreTrainedModel): + _no_split_modules = ["JukeboxBlock"] + + def __init__(self, config): + super().__init__(config) + vqvae_config = config.vqvae_config + self.vqvae = JukeboxVQVAE(vqvae_config) + self.set_shared_params(config) + self.priors = nn.ModuleList( + [JukeboxPrior(config.prior_configs[level], level) for level in range(config.nb_priors)] + ) + + def set_shared_params(self, model_config): + """ + Initialises the parameters that are shared. This has to be done here because the list of `JukeboxPriorConfig` + is nest, and is thus unreachable in the `from_dict` function + """ + for config in model_config.prior_configs: + config.sampling_rate = model_config.sampling_rate + config.timing_dims = model_config.timing_dims + config.min_duration = model_config.min_duration + config.max_duration = model_config.max_duration + config.max_nb_genres = model_config.max_nb_genres + config.metadata_conditioning = model_config.metadata_conditioning + + def decode(self, music_tokens, start_level=0, end_level=None, bs_chunks=1): + return self.vqvae.decode(music_tokens, start_level, end_level, bs_chunks) + + def encode(self, input_audio, start_level=0, end_level=None, bs_chunks=1): + return self.vqvae.encode(input_audio, start_level, end_level, bs_chunks) + + def split_batch(self, obj, n_samples, split_size): + n_passes = (n_samples + split_size - 1) // split_size + if isinstance(obj, mindspore.Tensor): + return ops.split(obj, split_size, dim=0) + elif isinstance(obj, list): + return list(zip(*[ops.split(item, split_size, dim=0) for item in obj])) + elif obj is None: + return [None] * n_passes + else: + raise TypeError("Unknown input type") + + # Sample a partial window of length= self.priors[level].n_ctx: + iterator = get_starts(total_length, self.priors[level].n_ctx, hop_length) + for start in iterator: + music_tokens = self.sample_single_window( + music_tokens, labels, offset, sampling_kwargs, level, start, max_batch_size + ) + + else: + music_tokens = self.sample_partial_window( + music_tokens, labels, offset, sampling_kwargs, level, total_length, max_batch_size + ) + return music_tokens + + @no_grad() + def _sample( + self, + music_tokens, + labels, + sample_levels, + metas=None, + chunk_size=32, + sampling_temperature=0.98, + lower_batch_size=16, + max_batch_size=16, + sample_length_in_seconds=24, + compute_alignments=False, + sample_tokens=None, + offset=0, + save_results=True, + sample_length=None, + ) -> List[mindspore.Tensor]: + """ + Core sampling function used to generate music tokens. Iterates over the provided list of levels, while saving + the generated raw audio at each step. + + Args: + music_tokens (`List[mindspore.Tensor]`): + A sequence of music tokens of length `self.levels` which will be used as context to continue the + sampling process. Should have `self.levels` tensors, each corresponding to the generation at a certain + level. + labels (`List[mindspore.Tensor]`): + List of length `n_sample`, and shape `(self.levels, 4 + self.config.max_nb_genre + + lyric_sequence_length)` metadata such as `artist_id`, `genre_id` and the full list of lyric tokens + which are used to condition the generation. + sample_levels (`List[int]`): + List of the desired levels at which the sampling will be done. A level is equivalent to the index of + the prior in the list of priors + metas (`List[Any]`, *optional*): + Metadatas used to generate the `labels` + chunk_size (`int`, *optional*, defaults to 32): + Size of a chunk of audio, used to fill up the memory in chuncks to prevent OOM erros. Bigger chunks + means faster memory filling but more consumption. + sampling_temperature (`float`, *optional*, defaults to 0.98): + Temperature used to ajust the randomness of the sampling. + lower_batch_size (`int`, *optional*, defaults to 16): + Maximum batch size for the lower level priors + max_batch_size (`int`, *optional*, defaults to 16): + Maximum batch size for the top level priors + sample_length_in_seconds (`int`, *optional*, defaults to 24): + Desired length of the generation in seconds + compute_alignments (`bool`, *optional*, defaults to `False`): + Whether or not to compute the alignment between the lyrics and the audio using the top_prior + sample_tokens (`int`, *optional*): + Precise number of tokens that should be sampled at each level. This is mostly useful for running dummy + experiments + offset (`int`, *optional*, defaults to 0): + Audio offset used as conditioning, corresponds to the starting sample in the music. If the offset is + greater than 0, the lyrics will be shifted take that intoaccount + save_results (`bool`, *optional*, defaults to `True`): + Whether or not to save the intermediate results. If `True`, will generate a folder named with the start + time. + sample_length (`int`, *optional*): + Desired length of the generation in samples. + + Returns: mindspore.Tensor + + Example: + + ```python + >>> from transformers import AutoTokenizer, JukeboxModel, set_seed + >>> import torch + + >>> metas = dict(artist="Zac Brown Band", genres="Country", lyrics="I met a traveller from an antique land") + >>> tokenizer = AutoTokenizer.from_pretrained("openai/jukebox-1b-lyrics") + >>> model = JukeboxModel.from_pretrained("openai/jukebox-1b-lyrics", min_duration=0).eval() + + >>> labels = tokenizer(**metas)["input_ids"] + >>> set_seed(0) + >>> zs = [ops.zeros(1, 0, dtype=mindspore.int64) for _ in range(3)] + >>> zs = model._sample(zs, labels, [0], sample_length=40 * model.priors[0].raw_to_tokens, save_results=False) + >>> zs[0] + tensor([[1853, 1369, 1150, 1869, 1379, 1789, 519, 710, 1306, 1100, 1229, 519, + 353, 1306, 1379, 1053, 519, 653, 1631, 1467, 1229, 1229, 10, 1647, + 1254, 1229, 1306, 1528, 1789, 216, 1631, 1434, 653, 475, 1150, 1528, + 1804, 541, 1804, 1434]]) + ``` + """ + + top_prior = self.priors[0] + if sample_length is not None: + total_length = sample_length + else: + total_length = ( + int(sample_length_in_seconds * self.config.sampling_rate) // top_prior.raw_to_tokens + ) * top_prior.raw_to_tokens + + if sample_levels is None: + sample_levels = range(len(self.priors)) + + # total length of the signal, might be bit different from the actual generated length + self.total_length = total_length + for level in sample_levels: + sampling_kwargs = { + "temp": 0.99 if level == len(self.priors) - 1 else sampling_temperature, + "chunk_size": chunk_size, + "sample_tokens": sample_tokens, + } + # Set correct total_length, hop_length, labels and sampling_kwargs for level + + total_token_to_sample = total_length // self.priors[level].raw_to_tokens + hop_length = int(self.config.hop_fraction[level] * self.priors[level].n_ctx) + max_batch_size = lower_batch_size if level != sample_levels else max_batch_size + music_tokens = self.sample_level( + music_tokens, + labels[level], + offset, + sampling_kwargs, + level, + total_token_to_sample, + hop_length, + max_batch_size, + ) + + if save_results: + self.vqvae.to(music_tokens[level]) + # Decode sample + with no_grad(): + start_level = len(self.priors) - level - 1 # vqvae levels are reversed + raw_audio = self.vqvae.decode( + music_tokens[: level + 1], start_level=start_level, bs_chunks=music_tokens[level].shape[0] + ) + logdir = f"jukebox/level_{level}" + if not os.path.exists(logdir): + os.makedirs(logdir) + save_temp_audio(logdir, level, metas=metas, aud=raw_audio.float()) + if compute_alignments and self.priors[0] is not None and self.priors[0].nb_relevant_lyric_tokens > 0: + with no_grad(): + alignments = get_alignment(music_tokens, labels[0], self.priors[0], self.config) + mindspore.save_checkpoint({"alignments": alignments}, f"{logdir}/lyric_alignments.ckpt") + + return music_tokens + + def ancestral_sample(self, labels, n_samples=1, **sampling_kwargs) -> List[mindspore.Tensor]: + """ + Example: + + ```python + >>> from transformers import AutoTokenizer, JukeboxModel, set_seed + + >>> model = JukeboxModel.from_pretrained("openai/jukebox-1b-lyrics", min_duration=0).eval() + >>> tokenizer = AutoTokenizer.from_pretrained("openai/jukebox-1b-lyrics") + + >>> lyrics = "Hey, are you awake? Can you talk to me?" + >>> artist = "Zac Brown Band" + >>> genre = "Country" + >>> metas = tokenizer(artist=artist, genres=genre, lyrics=lyrics) + >>> set_seed(0) + >>> music_tokens = model.ancestral_sample(metas.input_ids, sample_length=400) + + >>> with no_grad(): + ... model.decode(music_tokens)[:, :10].squeeze(-1) + tensor([[-0.0219, -0.0679, -0.1050, -0.1203, -0.1271, -0.0936, -0.0396, -0.0405, + -0.0818, -0.0697]]) + ``` + """ + + sample_levels = sampling_kwargs.pop("sample_levels", list(range(len(self.priors)))) + music_tokens = [ + ops.zeros(n_samples, 0, dtype=mindspore.int64) for _ in range(len(self.priors)) + ] + music_tokens = self._sample(music_tokens, labels, sample_levels, **sampling_kwargs) + return music_tokens + + def continue_sample(self, music_tokens, labels, **sampling_kwargs) -> List[mindspore.Tensor]: + sample_levels = sampling_kwargs.pop("sample_levels", list(range(len(self.priors)))) + music_tokens = self._sample(music_tokens, labels, sample_levels, **sampling_kwargs) + return music_tokens + + def upsample(self, music_tokens, labels, **sampling_kwargs) -> List[mindspore.Tensor]: + sample_levels = sampling_kwargs.pop("sample_levels", list(range(len(self.priors) - 1))) + music_tokens = self._sample(music_tokens, labels, sample_levels, **sampling_kwargs) + return music_tokens + + def primed_sample(self, raw_audio, labels, **sampling_kwargs) -> List[mindspore.Tensor]: + sample_levels = sampling_kwargs.pop("sample_levels", list(range(len(self.priors)))) + self.vqvae.to(raw_audio).float() + with no_grad(): + music_tokens = self.vqvae.encode( + raw_audio, start_level=0, end_level=len(self.priors), bs_chunks=raw_audio.shape[0] + ) + music_tokens = self._sample(music_tokens, labels, sample_levels, **sampling_kwargs) + return music_tokens +__all__ = [ + "JukeboxModel", + "JukeboxPreTrainedModel", + "JukeboxVQVAE", + "JukeboxPrior", + ] diff --git a/mindnlp/transformers/models/jukebox/tokenization_jukebox.py b/mindnlp/transformers/models/jukebox/tokenization_jukebox.py new file mode 100644 index 000000000..6d0713c9c --- /dev/null +++ b/mindnlp/transformers/models/jukebox/tokenization_jukebox.py @@ -0,0 +1,342 @@ +# coding=utf-8 +# Copyright 2022 The Open AI Team Authors and The HuggingFace Inc. team. +# +# 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. +"""Tokenization classes for OpenAI Jukebox.""" + +import json +import os +import re +import unicodedata +from json.encoder import INFINITY +from typing import Any, Dict, List, Optional, Tuple + +import regex + +from ....tokenization_utils import AddedToken, PreTrainedTokenizer +from ....tokenization_utils_base import BatchEncoding +from ....utils import logging + + + +logger = logging.get_logger(__name__) + +VOCAB_FILES_NAMES = { + "artists_file": "artists.json", + "lyrics_file": "lyrics.json", + "genres_file": "genres.json", +} + + +class JukeboxTokenizer(PreTrainedTokenizer): + """ + Constructs a Jukebox tokenizer. Jukebox can be conditioned on 3 different inputs : + - Artists, unique ids are associated to each artist from the provided dictionary. + - Genres, unique ids are associated to each genre from the provided dictionary. + - Lyrics, character based tokenization. Must be initialized with the list of characters that are inside the + vocabulary. + + This tokenizer does not require training. It should be able to process a different number of inputs: + as the conditioning of the model can be done on the three different queries. If None is provided, defaults values will be used.: + + Depending on the number of genres on which the model should be conditioned (`n_genres`). + ```python + >>> from transformers import JukeboxTokenizer + + >>> tokenizer = JukeboxTokenizer.from_pretrained("openai/jukebox-1b-lyrics") + >>> tokenizer("Alan Jackson", "Country Rock", "old town road")["input_ids"] + [tensor([[ 0, 0, 0, 6785, 546, 41, 38, 30, 76, 46, 41, 49, + 40, 76, 44, 41, 27, 30]]), tensor([[ 0, 0, 0, 145, 0]]), tensor([[ 0, 0, 0, 145, 0]])] + ``` + + You can get around that behavior by passing `add_prefix_space=True` when instantiating this tokenizer or when you + call it on some text, but since the model was not pretrained this way, it might yield a decrease in performance. + + + + If nothing is provided, the genres and the artist will either be selected randomly or set to None + + + + This tokenizer inherits from [`PreTrainedTokenizer`] which contains most of the main methods. Users should refer to: + this superclass for more information regarding those methods. + + However the code does not allow that and only supports composing from various genres. + + Args: + artists_file (`str`): + Path to the vocabulary file which contains a mapping between artists and ids. The default file supports + both "v2" and "v3" + genres_file (`str`): + Path to the vocabulary file which contain a mapping between genres and ids. + lyrics_file (`str`): + Path to the vocabulary file which contains the accepted characters for the lyrics tokenization. + version (`List[str]`, `optional`, default to `["v3", "v2", "v2"]`) : + List of the tokenizer versions. The `5b-lyrics`'s top level prior model was trained using `v3` instead of + `v2`. + n_genres (`int`, `optional`, defaults to 1): + Maximum number of genres to use for composition. + max_n_lyric_tokens (`int`, `optional`, defaults to 512): + Maximum number of lyric tokens to keep. + unk_token (`str`, *optional*, defaults to `"<|endoftext|>"`): + The unknown token. A token that is not in the vocabulary cannot be converted to an ID and is set to be this + token instead. + """ + + vocab_files_names = VOCAB_FILES_NAMES + model_input_names = ["input_ids", "attention_mask"] + + def __init__( + self, + artists_file, + genres_file, + lyrics_file, + version=["v3", "v2", "v2"], + max_n_lyric_tokens=512, + n_genres=5, + unk_token="<|endoftext|>", + **kwargs, + ): + unk_token = AddedToken(unk_token, lstrip=False, rstrip=False) if isinstance(unk_token, str) else unk_token + self.version = version + self.max_n_lyric_tokens = max_n_lyric_tokens + self.n_genres = n_genres + self._added_tokens_decoder = {0: unk_token} + + with open(artists_file, encoding="utf-8") as vocab_handle: + self.artists_encoder = json.load(vocab_handle) + + with open(genres_file, encoding="utf-8") as vocab_handle: + self.genres_encoder = json.load(vocab_handle) + + with open(lyrics_file, encoding="utf-8") as vocab_handle: + self.lyrics_encoder = json.load(vocab_handle) + + oov = r"[^A-Za-z0-9.,:;!?\-'\"()\[\] \t\n]+" + # In v2, we had a n_vocab=80 and in v3 we missed + and so n_vocab=79 of characters. + if len(self.lyrics_encoder) == 79: + oov = oov.replace(r"\-'", r"\-+'") + + self.out_of_vocab = regex.compile(oov) + self.artists_decoder = {v: k for k, v in self.artists_encoder.items()} + self.genres_decoder = {v: k for k, v in self.genres_encoder.items()} + self.lyrics_decoder = {v: k for k, v in self.lyrics_encoder.items()} + super().__init__( + unk_token=unk_token, + n_genres=n_genres, + version=version, + max_n_lyric_tokens=max_n_lyric_tokens, + **kwargs, + ) + + @property + def vocab_size(self): + return len(self.artists_encoder) + len(self.genres_encoder) + len(self.lyrics_encoder) + + def get_vocab(self): + return { + "artists_encoder": self.artists_encoder, + "genres_encoder": self.genres_encoder, + "lyrics_encoder": self.lyrics_encoder, + } + + def _convert_token_to_id(self, list_artists, list_genres, list_lyrics): + """Converts the artist, genre and lyrics tokens to their index using the vocabulary. + The total_length, offset and duration have to be provided in order to select relevant lyrics and add padding to + the lyrics token sequence. + """ + artists_id = [self.artists_encoder.get(artist, 0) for artist in list_artists] + for genres in range(len(list_genres)): + list_genres[genres] = [self.genres_encoder.get(genre, 0) for genre in list_genres[genres]] + list_genres[genres] = list_genres[genres] + [-1] * (self.n_genres - len(list_genres[genres])) + + lyric_ids = [[self.lyrics_encoder.get(character, 0) for character in list_lyrics[0]], [], []] + return artists_id, list_genres, lyric_ids + + def _tokenize(self, lyrics): + """ + Converts a string into a sequence of tokens (string), using the tokenizer. Split in words for word-based + vocabulary or sub-words for sub-word-based vocabularies (BPE/SentencePieces/WordPieces). + + Do NOT take care of added tokens. Only the lyrics are split into character for the character-based vocabulary. + """ + # only lyrics are not tokenized, but character based is easily handled + return list(lyrics) + + def tokenize(self, artist, genre, lyrics, **kwargs): + """ + Converts three strings in a 3 sequence of tokens using the tokenizer + """ + artist, genre, lyrics = self.prepare_for_tokenization(artist, genre, lyrics) + lyrics = self._tokenize(lyrics) + return artist, genre, lyrics + + def prepare_for_tokenization( + self, artists: str, genres: str, lyrics: str, is_split_into_words: bool = False + ) -> Tuple[str, str, str, Dict[str, Any]]: + """ + Performs any necessary transformations before tokenization. + + Args: + artist (`str`): + The artist name to prepare. This will mostly lower the string + genres (`str`): + The genre name to prepare. This will mostly lower the string. + lyrics (`str`): + The lyrics to prepare. + is_split_into_words (`bool`, *optional*, defaults to `False`): + Whether or not the input is already pre-tokenized (e.g., split into words). If set to `True`, the + tokenizer assumes the input is already split into words (for instance, by splitting it on whitespace) + which it will tokenize. This is useful for NER or token classification. + """ + for idx in range(len(self.version)): + if self.version[idx] == "v3": + artists[idx] = artists[idx].lower() + genres[idx] = [genres[idx].lower()] + else: + artists[idx] = self._normalize(artists[idx]) + ".v2" + genres[idx] = [ + self._normalize(genre) + ".v2" for genre in genres[idx].split("_") + ] # split is for the full dictionary with combined genres + + if self.version[0] == "v2": + self.out_of_vocab = regex.compile(r"[^A-Za-z0-9.,:;!?\-'\"()\[\] \t\n]+") + vocab = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789.,:;!?-+'\"()[] \t\n" + self.vocab = {vocab[index]: index + 1 for index in range(len(vocab))} + self.vocab[""] = 0 + self.n_vocab = len(vocab) + 1 + self.lyrics_encoder = self.vocab + self.lyrics_decoder = {v: k for k, v in self.vocab.items()} + self.lyrics_decoder[0] = "" + else: + self.out_of_vocab = regex.compile(r"[^A-Za-z0-9.,:;!?\-+'\"()\[\] \t\n]+") + + lyrics = self._run_strip_accents(lyrics) + lyrics = lyrics.replace("\\", "\n") + lyrics = self.out_of_vocab.sub("", lyrics), [], [] + return artists, genres, lyrics + + def _run_strip_accents(self, text): + """Strips accents from a piece of text.""" + text = unicodedata.normalize("NFD", text) + output = [] + for char in text: + cat = unicodedata.category(char) + if cat == "Mn": + continue + output.append(char) + return "".join(output) + + def _normalize(self, text: str) -> str: + """ + Normalizes the input text. This process is for the genres and the artist + + Args: + text (`str`): + Artist or Genre string to normalize + """ + + accepted = ( + [chr(i) for i in range(ord("a"), ord("z") + 1)] + + [chr(i) for i in range(ord("A"), ord("Z") + 1)] + + [chr(i) for i in range(ord("0"), ord("9") + 1)] + + ["."] + ) + accepted = frozenset(accepted) + pattern = re.compile(r"_+") + text = "".join([c if c in accepted else "_" for c in text.lower()]) + text = pattern.sub("_", text).strip("_") + return text + + def convert_lyric_tokens_to_string(self, lyrics: List[str]) -> str: + return " ".join(lyrics) + + def __call__(self, artist, genres, lyrics="", return_tensors="pt") -> BatchEncoding: + """Convert the raw string to a list of token ids + + Args: + artist (`str`): + Name of the artist. + genres (`str`): + List of genres that will be mixed to condition the audio + lyrics (`str`, *optional*, defaults to `""`): + Lyrics used to condition the generation + """ + input_ids = [0, 0, 0] + artist = [artist] * len(self.version) + genres = [genres] * len(self.version) + + artists_tokens, genres_tokens, lyrics_tokens = self.tokenize(artist, genres, lyrics) + artists_id, genres_ids, full_tokens = self._convert_token_to_id(artists_tokens, genres_tokens, lyrics_tokens) + + attention_masks = [-INFINITY] * len(full_tokens[-1]) + input_ids = [ + self.convert_to_tensors( + [input_ids + [artists_id[i]] + genres_ids[i] + full_tokens[i]], tensor_type=return_tensors + ) + for i in range(len(self.version)) + ] + return BatchEncoding({"input_ids": input_ids, "attention_masks": attention_masks}) + + def save_vocabulary(self, save_directory: str, filename_prefix: Optional[str] = None) -> Tuple[str]: + """ + Saves the tokenizer's vocabulary dictionary to the provided save_directory. + + Args: + save_directory (`str`): + A path to the directory where to saved. It will be created if it doesn't exist. + + filename_prefix (`Optional[str]`, *optional*): + A prefix to add to the names of the files saved by the tokenizer. + + """ + if not os.path.isdir(save_directory): + logger.error(f"Vocabulary path ({save_directory}) should be a directory") + return + + artists_file = os.path.join( + save_directory, (filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["artists_file"] + ) + with open(artists_file, "w", encoding="utf-8") as f: + f.write(json.dumps(self.artists_encoder, ensure_ascii=False)) + + genres_file = os.path.join( + save_directory, (filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["genres_file"] + ) + with open(genres_file, "w", encoding="utf-8") as f: + f.write(json.dumps(self.genres_encoder, ensure_ascii=False)) + + lyrics_file = os.path.join( + save_directory, (filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["lyrics_file"] + ) + with open(lyrics_file, "w", encoding="utf-8") as f: + f.write(json.dumps(self.lyrics_encoder, ensure_ascii=False)) + + return (artists_file, genres_file, lyrics_file) + + def _convert_id_to_token(self, artists_index, genres_index, lyric_index): + """ + Converts an index (integer) in a token (str) using the vocab. + + Args: + artists_index (`int`): + Index of the artist in its corresponding dictionary. + genres_index (`Union[List[int], int]`): + Index of the genre in its corresponding dictionary. + lyric_index (`List[int]`): + List of character indices, which each correspond to a character. + """ + artist = self.artists_decoder.get(artists_index) + genres = [self.genres_decoder.get(genre) for genre in genres_index] + lyrics = [self.lyrics_decoder.get(character) for character in lyric_index] + return artist, genres, lyrics From c15208654757be4c9ff722bdeb8a1c9087c7d537 Mon Sep 17 00:00:00 2001 From: 1hb6s7t <120760709+1hb6s7t@users.noreply.github.com> Date: Fri, 7 Feb 2025 15:34:04 +0800 Subject: [PATCH 02/20] Update __init__.py --- mindnlp/transformers/models/jukebox/__init__.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/mindnlp/transformers/models/jukebox/__init__.py b/mindnlp/transformers/models/jukebox/__init__.py index 72b15e68f..2cbeac7b8 100644 --- a/mindnlp/transformers/models/jukebox/__init__.py +++ b/mindnlp/transformers/models/jukebox/__init__.py @@ -6,4 +6,4 @@ __all__ = [] __all__.extend(configuration_jukebox.__all__) __all__.extend(modeling_jukebox.__all__) -__all__.extend(tokenization_jukebox.__all__) \ No newline at end of file +__all__.extend(tokenization_jukebox.__all__) From 4e40e2b31daccd684ecee9f6df1b8f6303d1709d Mon Sep 17 00:00:00 2001 From: 1hb6s7t <120760709+1hb6s7t@users.noreply.github.com> Date: Fri, 7 Feb 2025 15:53:39 +0800 Subject: [PATCH 03/20] Update tokenization_jukebox.py --- mindnlp/transformers/models/jukebox/tokenization_jukebox.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/mindnlp/transformers/models/jukebox/tokenization_jukebox.py b/mindnlp/transformers/models/jukebox/tokenization_jukebox.py index 6d0713c9c..e2aca90b4 100644 --- a/mindnlp/transformers/models/jukebox/tokenization_jukebox.py +++ b/mindnlp/transformers/models/jukebox/tokenization_jukebox.py @@ -23,8 +23,8 @@ import regex -from ....tokenization_utils import AddedToken, PreTrainedTokenizer -from ....tokenization_utils_base import BatchEncoding +from ...tokenization_utils import AddedToken, PreTrainedTokenizer +from ...tokenization_utils_base import BatchEncoding from ....utils import logging From 501e28cf6f17a7b6b9fa8c430d959d7d3e54f5f9 Mon Sep 17 00:00:00 2001 From: 1hb6s7t <120760709+1hb6s7t@users.noreply.github.com> Date: Fri, 7 Feb 2025 15:56:17 +0800 Subject: [PATCH 04/20] Update modeling_jukebox.py --- mindnlp/transformers/models/jukebox/modeling_jukebox.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/mindnlp/transformers/models/jukebox/modeling_jukebox.py b/mindnlp/transformers/models/jukebox/modeling_jukebox.py index fa77257e0..ed7a55777 100644 --- a/mindnlp/transformers/models/jukebox/modeling_jukebox.py +++ b/mindnlp/transformers/models/jukebox/modeling_jukebox.py @@ -25,7 +25,7 @@ from mindnlp.core.nn import LayerNorm as FusedLayerNorm from ....common.activations import ACT2FN -from ....modeling_utils import PreTrainedModel +from ...modeling_utils import PreTrainedModel from ....utils import logging from ....utils.logging import tqdm from .configuration_jukebox import ATTENTION_PATTERNS, JukeboxConfig, JukeboxPriorConfig, JukeboxVQVAEConfig From a3cc956203b6f667bade660321f11c1c436609dd Mon Sep 17 00:00:00 2001 From: 1hb6s7t <120760709+1hb6s7t@users.noreply.github.com> Date: Fri, 7 Feb 2025 16:08:30 +0800 Subject: [PATCH 05/20] Update modeling_jukebox.py --- mindnlp/transformers/models/jukebox/modeling_jukebox.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/mindnlp/transformers/models/jukebox/modeling_jukebox.py b/mindnlp/transformers/models/jukebox/modeling_jukebox.py index ed7a55777..6a5a59911 100644 --- a/mindnlp/transformers/models/jukebox/modeling_jukebox.py +++ b/mindnlp/transformers/models/jukebox/modeling_jukebox.py @@ -463,7 +463,7 @@ def quantise(self, latent_states): - 2 * ops.matmul(latent_states, codebook_weights) + mindspore.ops.sum(codebook_weights**2, dim=0, keepdim=True) ) # (batch_size * latent_states , codebook_weights) - min_distance, music_tokens = ops.minimum(distance,dim=-1) + min_distance, music_tokens = ops.min(distance,axis=-1) fit = ops.mean(min_distance) return music_tokens, fit From b35113af79d3060b81efbdeeec59297114183178 Mon Sep 17 00:00:00 2001 From: 1hb6s7t <120760709+1hb6s7t@users.noreply.github.com> Date: Fri, 7 Feb 2025 16:14:59 +0800 Subject: [PATCH 06/20] Update modeling_jukebox.py --- mindnlp/transformers/models/jukebox/modeling_jukebox.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/mindnlp/transformers/models/jukebox/modeling_jukebox.py b/mindnlp/transformers/models/jukebox/modeling_jukebox.py index 6a5a59911..7da1f449e 100644 --- a/mindnlp/transformers/models/jukebox/modeling_jukebox.py +++ b/mindnlp/transformers/models/jukebox/modeling_jukebox.py @@ -2255,11 +2255,10 @@ class JukeboxPreTrainedModel(PreTrainedModel): supports_gradient_checkpointing = False def _init_weights(self, module): - if isinstance(module, JukeboxPrior) or isinstance(module, JukeboxVQVAE): + if isinstance(module, (JukeboxPrior, JukeboxVQVAE)): module.apply(module._init_weights) def __init__(self, *inputs, **kwargs): - super().__init__(*inputs, **kwargs) JUKEBOX_SAMPLING_INPUT_DOCSTRING = r""" From 576d767527476bb30a769d4e1b1ecf04c1529507 Mon Sep 17 00:00:00 2001 From: 1hb6s7t <120760709+1hb6s7t@users.noreply.github.com> Date: Fri, 7 Feb 2025 16:25:59 +0800 Subject: [PATCH 07/20] Update __init__.py --- mindnlp/transformers/models/jukebox/__init__.py | 1 + 1 file changed, 1 insertion(+) diff --git a/mindnlp/transformers/models/jukebox/__init__.py b/mindnlp/transformers/models/jukebox/__init__.py index 2cbeac7b8..786980182 100644 --- a/mindnlp/transformers/models/jukebox/__init__.py +++ b/mindnlp/transformers/models/jukebox/__init__.py @@ -1,3 +1,4 @@ +"""Jukebox model""" from . import configuration_jukebox, modeling_jukebox, tokenization_jukebox from .configuration_jukebox import * from .modeling_jukebox import * From 777f3b846aa30b51a14638f3231a6599e8e18567 Mon Sep 17 00:00:00 2001 From: 1hb6s7t <120760709+1hb6s7t@users.noreply.github.com> Date: Fri, 7 Feb 2025 16:38:15 +0800 Subject: [PATCH 08/20] Update modeling_jukebox.py --- .../transformers/models/jukebox/modeling_jukebox.py | 11 +---------- 1 file changed, 1 insertion(+), 10 deletions(-) diff --git a/mindnlp/transformers/models/jukebox/modeling_jukebox.py b/mindnlp/transformers/models/jukebox/modeling_jukebox.py index 7da1f449e..04eb22d2a 100644 --- a/mindnlp/transformers/models/jukebox/modeling_jukebox.py +++ b/mindnlp/transformers/models/jukebox/modeling_jukebox.py @@ -2259,16 +2259,7 @@ def _init_weights(self, module): module.apply(module._init_weights) def __init__(self, *inputs, **kwargs): - - -JUKEBOX_SAMPLING_INPUT_DOCSTRING = r""" - labels (`List[mindspore.Tensor]` of length `n_sample`, and shape `(self.levels, self.config.max_nb_genre + lyric_sequence_length)` : - List of metadata such as `artist_id`, `genre_id` and the full list of lyric tokens which are used to - condition the generation. - sampling_kwargs (`Dict[Any]`): - Various additional sampling arguments that are used by the `_sample` function. A detail list of the - arguments can bee seen in the [`_sample`] function documentation. -""" + super().__init__(*inputs, **kwargs) class JukeboxModel(JukeboxPreTrainedModel): From 20a5737835ccac3843075fe6de6db98f9f6471dc Mon Sep 17 00:00:00 2001 From: 1hb6s7t <120760709+1hb6s7t@users.noreply.github.com> Date: Fri, 7 Feb 2025 16:48:43 +0800 Subject: [PATCH 09/20] Update modeling_jukebox.py --- mindnlp/transformers/models/jukebox/modeling_jukebox.py | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/mindnlp/transformers/models/jukebox/modeling_jukebox.py b/mindnlp/transformers/models/jukebox/modeling_jukebox.py index 04eb22d2a..b1d611f65 100644 --- a/mindnlp/transformers/models/jukebox/modeling_jukebox.py +++ b/mindnlp/transformers/models/jukebox/modeling_jukebox.py @@ -463,7 +463,7 @@ def quantise(self, latent_states): - 2 * ops.matmul(latent_states, codebook_weights) + mindspore.ops.sum(codebook_weights**2, dim=0, keepdim=True) ) # (batch_size * latent_states , codebook_weights) - min_distance, music_tokens = ops.min(distance,axis=-1) + min_distance, music_tokens = ops.min(distance,dim=-1) fit = ops.mean(min_distance) return music_tokens, fit @@ -2258,9 +2258,6 @@ def _init_weights(self, module): if isinstance(module, (JukeboxPrior, JukeboxVQVAE)): module.apply(module._init_weights) - def __init__(self, *inputs, **kwargs): - super().__init__(*inputs, **kwargs) - class JukeboxModel(JukeboxPreTrainedModel): _no_split_modules = ["JukeboxBlock"] From 662e04043e2a7e51ccbe197adac05d64e0425422 Mon Sep 17 00:00:00 2001 From: 1hb6s7t <120760709+1hb6s7t@users.noreply.github.com> Date: Fri, 7 Feb 2025 18:06:53 +0800 Subject: [PATCH 10/20] Update modeling_jukebox.py --- mindnlp/transformers/models/jukebox/modeling_jukebox.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/mindnlp/transformers/models/jukebox/modeling_jukebox.py b/mindnlp/transformers/models/jukebox/modeling_jukebox.py index b1d611f65..1a507e925 100644 --- a/mindnlp/transformers/models/jukebox/modeling_jukebox.py +++ b/mindnlp/transformers/models/jukebox/modeling_jukebox.py @@ -12,7 +12,7 @@ # 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. -"""PyTorch Jukebox model.""" +"""Mindspore Jukebox model.""" import math import os From 1555cd80ab6c8c64a2781af4798c0016adf08562 Mon Sep 17 00:00:00 2001 From: 1hb6s7t <120760709+1hb6s7t@users.noreply.github.com> Date: Sat, 8 Feb 2025 21:13:25 +0800 Subject: [PATCH 11/20] Add files via upload --- .../transformers/models/jukebox/__init__.py | 10 - .../__pycache__/__init__.cpython-39.pyc | Bin 0 -> 174 bytes ...deling_jukebox.cpython-39-pytest-7.2.0.pyc | Bin 0 -> 14269 bytes ...zation_jukebox.cpython-39-pytest-7.2.0.pyc | Bin 0 -> 10226 bytes .../models/jukebox/test_modeling_jukebox.py | 395 ++++++++++++++++++ .../jukebox/test_tokenization_jukebox.py | 210 ++++++++++ 6 files changed, 605 insertions(+), 10 deletions(-) create mode 100644 mindnlp/transformers/models/jukebox/__pycache__/__init__.cpython-39.pyc create mode 100644 mindnlp/transformers/models/jukebox/__pycache__/test_modeling_jukebox.cpython-39-pytest-7.2.0.pyc create mode 100644 mindnlp/transformers/models/jukebox/__pycache__/test_tokenization_jukebox.cpython-39-pytest-7.2.0.pyc create mode 100644 mindnlp/transformers/models/jukebox/test_modeling_jukebox.py create mode 100644 mindnlp/transformers/models/jukebox/test_tokenization_jukebox.py diff --git a/mindnlp/transformers/models/jukebox/__init__.py b/mindnlp/transformers/models/jukebox/__init__.py index 786980182..e69de29bb 100644 --- a/mindnlp/transformers/models/jukebox/__init__.py +++ b/mindnlp/transformers/models/jukebox/__init__.py @@ -1,10 +0,0 @@ -"""Jukebox model""" -from . import configuration_jukebox, modeling_jukebox, tokenization_jukebox -from .configuration_jukebox import * -from .modeling_jukebox import * -from .tokenization_jukebox import * - -__all__ = [] -__all__.extend(configuration_jukebox.__all__) -__all__.extend(modeling_jukebox.__all__) -__all__.extend(tokenization_jukebox.__all__) diff --git a/mindnlp/transformers/models/jukebox/__pycache__/__init__.cpython-39.pyc b/mindnlp/transformers/models/jukebox/__pycache__/__init__.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..825224ba96f877394ee5f56cd9d3a76e2d04b4d5 GIT binary patch literal 174 zcmYe~<>g`k0)_1nX(0MBh(HF6K#l_t7qb9~6oz01O-8?!3`HPe1o11_*(xTqIJKxa z#>mvtz$C^cwK%&ZzaS@7o0MQ0W?KZ(@H{>Pfy0{ zQB)=4OZZi{B#;Q8#FGwW>JoJl=S>GQp+qPXPJ}b{iF%3ir6ZY!L_?`gV`7RP+NFry zl4nz*2~U5zDbt*2mK1?>OJ-_fYNj>OnwgfErYd^)WJRmfg1Z$hs0Vtd@AB?a6Eh?> zq=kVESFkfRb(0dSFQVs4M@)5m);2RA^E%T_E15B~nw8H9J(=2(GSjK8Y29fS`u08( zs7fKKq;oq_HE8K}($aMeX>TrXflK6+zHR!}+}Ue$nx3xY)(bNyoTgG)XKtIGH3xLj z#Xi*j`H(pQU+ZZAUCK1!(Y=sFtM2PovmQ-N_%#nC>eYOjUkiNRo2WA|@*C7d5YHf< zAv{BPhVcyJS&wHuo)J7FcsAhKfM+9~jd)JMa|)hKcsAkLT*9~D*^K;DJX`Q=#d9j2 z)9`G?bGkN7o4#8~%+O|NGx40M&C+J$IZJEP4#0D^_8x5xo^9G($UEw^mPWsHtCUTr zZrQpRRR(6}@_II99@gs$?$D)M4^8(Av&(w3F_G$uen8}QW}_cSWi_X6MXoPvi~gT| z)uSk@qZ!?frlPh;?aF zvQROrp=w`tTUxiQXj(U{Xs$bI*}1GPt8B7KVP>Otj~>-@OBZ%~)cthmDM55*aWvJvN69r|JnHkHYvNp}#al{UL|DGs~G%o>*4yH1S1hq90jW^!HIP{kd+i$yU6 zV!P$tx^|pwkAo^n2W?=kQ|ZO5hGur=gl0uk`8=u}D~Z?kN3*Gn9yP7#x`BQU)J#EA zA3`rE0X{94?V4O}8~JAXqo?J>HW2me(Y2=0WB0paLsR*bDGro;J92U)(XF~=YC43G zNts!zJ-QKkBnN?+?Mn4a+I8LT2q5m9Wu?;5(}do&ZEIcP=hO)@H zO6yQTXc(Laq$+e9qV9&0q;{5=k9rdU$jG$pM8MFqLbnnDSIJ`wiyy30l%f()6!QVt zzuCd;T6kE|0w-YBLD$W^7hn-^<}{{`1zmAE3;qq+;$9YPVBKDVCrAP>tQ4bc3l1wMb2n#H-dYq{+Ie!@aGlxj`7F)Xwsp8W} zVI0yZF9slioC|Hf08lNUJ&r%U&A|BxSgObca%gZ; zs<nt=cX8ENMO!1eH zL($?qzD4Q8NhHDXOufGhipPVbnw>PYoWum?Nt}>Q%Im~3PS!Ag1zEee3TKy%NpVoW({`j zz2w5I3s?;!xr!V&u$xJgn|lc^Lv6E*I-X&{)10gUf@9EtnP>Btu;45*<9wULB#wYY ze2BQU0LANA;04ZH%9hs=mm=rG$>sNK=uW1NB*?HEi%A?qN_4R9nViavOnsjP_mXZK zaK*=f6LVP5PJSOlUt$Z5JqurNcyP&R!FcFb*DYWC!p#Naz}rR76|aA#V7xW@+vnGA zy}e*4xeI)ced3OS@spp{Upaaq5@zl<7d_dD#3we{^FRAGXwG`&*?BMi>DGdAO2o71 zlIdW$=6xSM@vK*d3$IT5_$j~i9dSjO`22!#_neDf+i>@}1>@3-65qT3WxHUU(|YU4 zKO4~EMzZcZvo<)F#f_n7?>yu8_goV<_I8{wHTB4iapTB;KYG>4Vl-~d@}1gv=-0j) zH$MBxDFa8{aw~{$y=&`vKL+L#KmU)p&*yH78<(YD{jbsAel2cnT>XXf7kulkxN*Q> zYT4!`_r{H5KlRjkA1pi&H@1J}vKM=lLfp8}I_awa3?Ol7*GK;OB=19UPv2eDz1k z9p8-`z=v!yWhX7V1(MPJ2UpwCkw`tJ084#_F-R$8<|rnquUC`8<%s+koW~FHGaHcNH(9o zs$l#IOg+f^D%;{dg+PJ-S?T{vJ}rLlxl4(V?G==PXF?e z&m7lrN5S~xCU*DsxDkQcZdkpiV4QLB(LZ=Bb5nWBua6rKK0IT=CjXsr(FxNq?kLa< zZYmgxqJK+)vi+`E2%61*7A+E4KV)#k~dNPfLGs>%l+2vtYciNT2o6>0g2zq?;GV z&^V7JIF5j>zeq<{Tug8naV#w!Ot64pE&&%vv4wy&M1tVM0L25DsuUEt;uWLBNjh0@ zDzj%2$aZBldJsv{1s75IgC9}gc$5|RTJr&HWmp|ldOaiRkUFS#V>Lt0dy{&(s;RS- zA~{h(X^99pNbu%aD~{c=8HY@3%d#VnS#rddmAbXf&gHl8&LNx5ADY3LRTo=q z9Hgu*Xew)U=R}6|vN>x@>GUiqk`jkQQ?i6@&-Xix=wlwIm!uqmbtQ)mAFC*8L~T_E z4w~$A-afX@7#UK2@VKrF=Rmr)(ko@CshVexXV|NGr8Jdc-v}gV`!#i!ipv{ZTkKZs zfEL)Lu2goZL*7BPw{Floh^q}l)#{K7Qs%v(Rt1+F!99LZD8u1FFR}a%*N-T}krB>N z1HO%hX9Vk9nSX^_sKPBYDK}upahn2eP5a;$u5b%a$_?0Y+?v6y#pR|cym0D}`=n7^ z#9&gBTAxVSIHI34MyOcUcn}0VX6FC^1H=4C>yS#}YKraYg&6jDuJCO4Q6XcVBGp(FeTkzctLi6uSRuSTjRPuf8uG_; z(S8G8W#Fhu^@4hsv~YcphL*K2Pv^Q)Y3q0-$_$D$F=>Zru0c}j$+Vs|>>ej#;l?J3 zGjLzpwnQ3)MUH!PstB^uR)Q`7C&cSDX;%W z6G)d%Bwe}>(j^l~mq=2~k1huyt<(wNmQhbzj%T38AGj0JFh7_1v^9FeAk8{g1H9#Bt_rrty&2ao2#z+l~o zXNz|zI20NRqfU!GwYRl*TJQ8h={VQ|>V{?A86%24b9fd^arTI+)#DS{<14jQtrwDY zCa>4FpL$`qI@wY;`&n)4fU$L?`8T-cFM1*GcVY8l8|sS;L7t$pf=G=K7I3!{&x63g zvHRACt{m>z=zsQMzoHKeVjjnji#uUEUOlUc_W@Ppq9>R1SKaO3?D(iB;Y-1`5E^jTyw_8 z)hi@2RxfQ|e2i>)J`^7ZNMLJ_#~uQHOkB=2<)u)*`i7wAzVp_R$ zEIK0Z7)#O}rz=jg^e(lEa0}YD76QP-z^}l=c*3d=-exAA^E@rsDa?O6=qkAQX0e5!uLzEmHw~d)`V;@4r?+0(Z(xtRMS%4i z-XR}00+B%esGK)T*WY%I8~@PXSDyQ#Oi*FW4ch}PUC92Q+i-(gQ3ZiU~N zHlmJTTgZOE!$>OhXoiNUlAA;8^|O?j%7~}iBmIkKcqTSH^nPlu+sDwvK91=jw<_fx zaR0h?{9#k%)yzz+ZBnPi{e)}qK5Qy9$H)DFbXAUj$Mzj5Y%cU{7q;_ogFUIdE{0fv zzDt}(z!h0sLvSs@=LzU5#1{Z+HV^AJu3n4n#uCTdm9j;ag+6#QVh~%$BbyKz`<;mg`4Yd52uKB8LN1G^8qwQ+#($Tb`muc_T$SdPo11uJ+EpOCv-ka`=g zUBShT7>3kUaT8PW#CZi%p8|-D-^#j+U`5}=7fJbLf>DB-3HGl|(<&>>sT)o`aaD3v z$BK0;S8;PI6?A;@%2h1JA(dNAx!gGF*-~A`D@Rx=hgA2Uf!1mSD5->Jrn&&%fw}vh zc3H0@c7PL1CK#|!S4PDFjUbvE^bG)3g76fE@2wP&^kpP<%f&KE+r3kj8zK z##Dj_0E*HrtU~JVP+IRoF(9or$}mbGQQ~R)zm{{$1#q}*q#>8_WZ4T`TH>(^J=VD^6ewR`$jPXp!gz{o$Ffh z8LnpECU}*lj}rG5Q+#E}UFyGul(`Wk=H@!!PGSLBnI}Mx%qt15L#beEg2bYk;BkUS z2*}EO4t2|3elk}dCFNwktV%3N{(eAgx%nFBN!sy45KnO}WbJ0D!RAk~2NzGU;9mi1 zES5O=f|7WcDXF*n#8tG~+zW-4{M;H;^<-41lWYBD#hT!wK2FcyY6=!gX3y6 z`N0|oUR-v`=;lA-aHTlh|G`E4nV1mwBEB3%8#}RMqC1lX(c~q3aXHmx2SJ*kpJ0IC zqXgsBif7$3s8;m0JjO@%7bx0Ke+CZ1%d=5Eo9i=rq9?E4jJK^bInmE|Z&$32;>GDK zg3tTD<S<4U-x!EI!)Oj!yPhsuFs zd9%|n+*orjG-bF6>fc;*FH~xyCTJYc5W+=-3E^ki1_Qos8`XgCWNnlJzqZ>3?v31= zPT4!jaZDSyDXwXwzS0Kp`xysHDU(tgQ_F40Td7Fxt<;$LpmT$_cVo#sjLTSZkS{p6 z@#CuQ#5`g<2prX{;;I3qY(?WN<=Y2?c&$V8;>8XRqcOu?zSJSD7)zvvcnNN0J;Q!j9d2ti4dB7O<@#*AEHojiKSR!HcYf(nN&bweVl=xr zweIaJuHHS3Y7-)GP3pkneNW>=CLOUE;x6|8n*?_g&e-Be~Tf%+HU%6+c0K{_y zPZK;tAgx7Sr_#BI?+`psP+f&&O73v(MZxR%${@p->(ptuNDbC}Lr8~kk=hba!!rcy z#b!Cdt$k+N#?LjJ$O-xWWF$IoYM-3e7t4q_%QE{w`j;3?q* z`?4l}k%JfyyPs$)MSk1+Y%^`Ovw-hR$($=S?g<69s!F1%Kyy8t;?O6Pr4wB4Ua23?n^kKz cz&xz%t^NpJ1PMS*@CujLqqd%>to5k>4V)s=#PQ^!l`W%NN9nI<_7@+Btc-5%8Ilad&c(Q*`4Li zY+Of)R0*E@7xW>iDph&q59lAVuT>wW5B&pLRqZ*SvFA90<7RoR6JOtZ&+qR!_s;Cm zhR2T0dGfRN@t-%B7d`KJObhbaYI_G=udeKxg{iPR8$DPlf_@cc!ANikn3!PH5de;{G@l)@Qw&S(z zw=3CpJVW0XcP6~Wxf>_MeO1zxRvDLrZ|_x`C_oMmF2NIzB4dSFNnb%m#ABj@C_Gn zG#|tgqxiR;rI8H%{zJxA1OssEq$##XYv z73>O>`N-W$ZpDiNK-eFO=_)9ZOp}cmh>ERbu$h~uD}u?E;)CISw!ST56(ZHHkOico zqHn~}o3&jHat}4JCD{(sMHLluJDH2}ARG=w^o?5J>TWOy`*D!u!S&m_8hjE8f**)S zii-ZtP5p;iwypa6yTOgjZ42XW99&H{w~E~gPBA$Q6Zb-`|5`?L!CIUrQ7j0GNuWwXQNjkDT57Xd=9FOhAU`_c!OCeYboz;@Ul}d4u&oq{@m5P*; zC5XGYkTh&aL4`X9j4ZUr9lW+V}v*|^hKl+>g zeSdE?bJ%LLeRukfcW>rS>t6Scob!|3ooOBKx9)35qO`qp2k!AW7Z}sgYnODYk-a7!NL7shO9Tm+QGxRIWYn$L(yG-+op(!{p`9 zs;h13%-T`~-gq_{3`a#TiSn2JE_VrHHYEP{JTLi|=qhJLU-_X9KhxodIxNfJj_K_A z{h518mvVo5?rEK!*4dLf`>D=O>@VH7bcSr8GhLPoIyu^o?(EPuLQVo?as>FBq#mXg}q4`;z)j^l<%Cc0upJ<0@(L! zmdAjEV9-*dYZy2nK{Kl0(<(WT8A8P_4lyHMWiEeR`=S+AIey5jq(G3xjk=I3{LCbL zQonnuEb>SC7btThHWW+*Q@7SadKy`%Q|o?QyM{?i6d|w&hzy1mGbCH zD|8~VQX!Z+GbQdRM^ih6)B z3_W`>3;B*2fe3d=Vv zBy$ZLEC~?x7M8^U)j$LYf(CJpUjq`8g@A+sd$ctq%r%xskTP?_Y&85cU^STXq6}`L zy5hEIpmB7Pako($I8LJQ6er2F0bwB+vxUzY#4eGO8T4TdeV8=6HB9A&NrNs?x};*v z2p@eU&%B}%Yd1Rxxt63WmPaqYRh?* zKs|#!Qd#0N9uNl+vE-(Kg;XGh2X!!2_y*HyHH6O`SWX$~MyZK4u)-RdMin;5FMQ}z z56Vlbev-%?@5O{*RoB2&jhDD)#$hps@DB`Nv2>d%e6HWaN|>>0Z!+jZmHA@OnKkYg zB43&~-ZLs;HDrd+#}W^)fqxuMW`w{1GX$8a0}J2oKTGIqYWJ{s(PF@&9;Mi@c z@w7C~LTMxv@gUFKcux94($!jVqj=m6({x?>8S#V8cq)(64fm$%QDx)VV!t&gqB_l2 zpS=8=k1k(Yx%_tT`ll-&eY*0%bMFZ2Kch=;-27CO<~LtC_xkCxH{Xu)?IIiA-1Bg$ zFWtA;-PDit`AuE@){lJt|5&ZaaIwSy8|xDu?5iXh5@K~_k^@0N69_S-U=IN=L(*^<_rcDLkD7=^<^ zdx068@4X`()FR$==OV4d<|xa03=(;WJ#QSWJQtRQQl>98Q=ipUH7KnIN*;Y=(8{M#@)oMap^v1h zb%T?Ql(9z~R_KNw)W-Q}yziMwBT!8Y4QrDF!9{^XM8tqsR=}2h2!I2Xuq;6QqomLR zF7Oec9Sv|k+T>x`M<2dmmjPd323>OqYuG>n5GOh~cI9G&*eFcm<)shx1ZWr#KE~}V z*ki{E9Z!+PKXOTcD7BnhY}i1;E;6(r0o7`flLCP~W-uE=e7PtN{Cb#+Q58fYAy zWZZ4k29A?UJjF>eZ9rHE#%$qp2C+-z1Y@;c^~Q6(o-|}esm|wnz0XHsT2b~oOLa%6x1LHD$-Sj+ zw{_t2P7Nx3uo^jtnoh=A|3;Ur07^ AM*si- literal 0 HcmV?d00001 diff --git a/mindnlp/transformers/models/jukebox/test_modeling_jukebox.py b/mindnlp/transformers/models/jukebox/test_modeling_jukebox.py new file mode 100644 index 000000000..d37ab8905 --- /dev/null +++ b/mindnlp/transformers/models/jukebox/test_modeling_jukebox.py @@ -0,0 +1,395 @@ +# coding=utf-8 +# Copyright 2022 The HuggingFace Team. All rights reserved. +# +# 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 unittest +from unittest import skip + +from mindnlp.utils.testing_utils import ( + is_mindspore_available, + require_mindspore, + slow, +) +from mindnlp.engine import set_seed +import mindnlp.core + +if is_mindspore_available(): + import mindspore + from mindspore import ops + from mindnlp.transformers import JukeboxModel, JukeboxPrior, JukeboxTokenizer + + +@require_mindspore +class Jukebox1bModelTester(unittest.TestCase): + all_model_classes = (JukeboxModel,) if is_mindspore_available() else () + model_id = "openai/jukebox-1b-lyrics" + metas = { + "artist": "Zac Brown Band", + "genres": "Country", + "lyrics": """I met a traveller from an antique land, + Who said "Two vast and trunkless legs of stone + Stand in the desert. . . . Near them, on the sand, + Half sunk a shattered visage lies, whose frown, + And wrinkled lip, and sneer of cold command, + Tell that its sculptor well those passions read + Which yet survive, stamped on these lifeless things, + The hand that mocked them, and the heart that fed; + And on the pedestal, these words appear: + My name is Ozymandias, King of Kings; + Look on my Works, ye Mighty, and despair! + Nothing beside remains. Round the decay + Of that colossal Wreck, boundless and bare + The lone and level sands stretch far away + """, + } + # fmt: off + EXPECTED_OUTPUT_2 = [ + 1864, 1536, 1213, 1870, 1357, 1536, 519, 880, 1323, 789, 1082, 534, + 1000, 1445, 1105, 1130, 967, 515, 1434, 1620, 534, 1495, 283, 1445, + 333, 1307, 539, 1631, 1528, 375, 1434, 673, 627, 710, 778, 1883, + 1405, 1276, 1455, 1228 + ] + + EXPECTED_OUTPUT_2_PT_2 = [ + 1489, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, + 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, + 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, + 653, 653, 653, 653 + ] + + EXPECTED_OUTPUT_1 = [ + 1125, 1751, 697, 1776, 1141, 1476, 391, 697, 1125, 684, 867, 416, + 844, 1372, 1274, 717, 1274, 844, 1299, 1419, 697, 1370, 317, 1125, + 191, 1440, 1370, 1440, 1370, 282, 1621, 1370, 368, 349, 867, 1872, + 1262, 869, 1728, 747 + ] + EXPECTED_OUTPUT_1_PT_2 = [ + 416, 416, 1125, 1125, 416, 416, 416, 416, 416, 416, 416, 416, + 416, 416, 416, 416, 416, 416, 416, 416, 416, 416, 416, 416, + 416, 416, 416, 416, 416, 416, 416, 416, 416, 416, 416, 416, + 416, 416, 416, 416 + ] + + EXPECTED_OUTPUT_0 = [ + 1755, 842, 307, 1843, 1022, 1395, 234, 1554, 806, 739, 1022, 442, + 616, 556, 268, 1499, 933, 457, 1440, 1837, 755, 985, 308, 902, + 293, 1443, 1671, 1141, 1533, 555, 1562, 1061, 287, 417, 1022, 2008, + 1186, 1015, 1777, 268 + ] + EXPECTED_OUTPUT_0_PT_2 = [ + 854, 842, 1353, 114, 1353, 842, 185, 842, 185, 114, 591, 842, + 185, 417, 185, 842, 307, 842, 591, 842, 185, 842, 307, 842, + 591, 842, 1353, 842, 185, 842, 591, 842, 591, 114, 591, 842, + 185, 842, 591, 89 + ] + + EXPECTED_Y_COND = [1058304, 0, 786432, 7169, 507, 76, 27, 40, 30, 76] + + EXPECTED_PRIMED_0 = [ + 390, 1160, 1002, 1907, 1788, 1788, 1788, 1907, 1002, 1002, 1854, 1002, + 1002, 1002, 1002, 1002, 1002, 1160, 1160, 1606, 596, 596, 1160, 1002, + 1516, 596, 1002, 1002, 1002, 1907, 1788, 1788, 1788, 1854, 1788, 1907, + 1907, 1788, 596, 1626 + ] + EXPECTED_PRIMED_1 = [ + 1236, 1668, 1484, 1920, 1848, 1409, 139, 864, 1828, 1272, 1599, 824, + 1672, 139, 555, 1484, 824, 1920, 555, 596, 1579, 1599, 1231, 1599, + 1637, 1407, 212, 824, 1599, 116, 1433, 824, 258, 1599, 1433, 1895, + 1063, 1433, 1433, 1599 + ] + EXPECTED_PRIMED_2 = [ + 1684, 1873, 1119, 1189, 395, 611, 1901, 972, 890, 1337, 1392, 1927, + 96, 972, 672, 780, 1119, 890, 158, 771, 1073, 1927, 353, 1331, + 1269, 1459, 1333, 1645, 812, 1577, 1337, 606, 353, 981, 1466, 619, + 197, 391, 302, 1930 + ] + EXPECTED_VQVAE_ENCODE = [ + 390, 1160, 1002, 1907, 1788, 1788, 1788, 1907, 1002, 1002, 1854, 1002, + 1002, 1002, 1002, 1002, 1002, 1160, 1160, 1606, 596, 596, 1160, 1002, + 1516, 596, 1002, 1002, 1002, 1907, 1788, 1788, 1788, 1854, 1788, 1907, + 1907, 1788, 596, 1626 + ] + EXPECTED_VQVAE_DECODE = [ + -0.0492, -0.0524, -0.0565, -0.0640, -0.0686, -0.0684, -0.0677, -0.0664, + -0.0605, -0.0490, -0.0330, -0.0168, -0.0083, -0.0075, -0.0051, 0.0025, + 0.0136, 0.0261, 0.0386, 0.0497, 0.0580, 0.0599, 0.0583, 0.0614, + 0.0740, 0.0889, 0.1023, 0.1162, 0.1211, 0.1212, 0.1251, 0.1336, + 0.1502, 0.1686, 0.1883, 0.2148, 0.2363, 0.2458, 0.2507, 0.2531 + ] + EXPECTED_AUDIO_COND = [ + 0.0256, -0.0544, 0.1600, -0.0032, 0.1066, 0.0825, -0.0013, 0.3440, + 0.0210, 0.0412, -0.1777, -0.0892, -0.0164, 0.0285, -0.0613, -0.0617, + -0.0137, -0.0201, -0.0175, 0.0215, -0.0627, 0.0520, -0.0730, 0.0970, + -0.0100, 0.0442, -0.0586, 0.0207, -0.0015, -0.0082 + ] + EXPECTED_META_COND = [ + 0.0415, 0.0877, 0.0022, -0.0055, 0.0751, 0.0334, 0.0324, -0.0068, + 0.0011, 0.0017, -0.0676, 0.0655, -0.0143, 0.0399, 0.0303, 0.0743, + -0.0168, -0.0394, -0.1113, 0.0124, 0.0442, 0.0267, -0.0003, -0.1536, + -0.0116, -0.1837, -0.0180, -0.1026, -0.0777, -0.0456 + ] + EXPECTED_LYRIC_COND = [ + 76, 27, 40, 30, 76, 46, 44, 47, 40, 37, 38, 31, 45, 45, 76, 38, 31, 33, + 45, 76, 41, 32, 76, 45, 46, 41, 40, 31, 78, 76 + ] + # fmt: on + + def prepare_inputs(self): + tokenizer = JukeboxTokenizer.from_pretrained(self.model_id) + tokens = tokenizer(**self.metas)["input_ids"] + return tokens + + #@slow + def test_sampling(self): + model = JukeboxModel.from_pretrained(self.model_id, min_duration=0).set_train(False) + labels = self.prepare_inputs() + + set_seed(0) + zs = [ops.zeros((1, 0), dtype=mindspore.int64) for _ in range(3)] + zs = model._sample(zs, labels, [0], sample_length=40 * model.priors[0].raw_to_tokens, save_results=False) + self.assertIn(zs[0][0].detach().tolist(), [self.EXPECTED_OUTPUT_2, self.EXPECTED_OUTPUT_2_PT_2]) + + set_seed(0) + zs = model._sample(zs, labels, [1], sample_length=40 * model.priors[1].raw_to_tokens, save_results=False) + self.assertIn(zs[1][0].detach().tolist(), [self.EXPECTED_OUTPUT_1, self.EXPECTED_OUTPUT_1_PT_2]) + + set_seed(0) + zs = model._sample(zs, labels, [2], sample_length=40 * model.priors[2].raw_to_tokens, save_results=False) + self.assertIn(zs[2][0].detach().tolist(), [self.EXPECTED_OUTPUT_0, self.EXPECTED_OUTPUT_0_PT_2]) + + #@slow + def test_conditioning(self): + model = JukeboxModel.from_pretrained(self.model_id, min_duration=0).set_train(False) + + labels = self.prepare_inputs() + set_seed(0) + zs = [ops.zeros((1, 0), dtype=mindspore.int64) for _ in range(3)] + + top_prior = model.priors[0] + start = 0 + music_token_conds = top_prior.get_music_tokens_conds(zs, start=start, end=start + top_prior.n_ctx) + metadata = top_prior.get_metadata(labels[0].clone(), start, 1058304, 0) + + self.assertIsNone(music_token_conds) + self.assertListEqual(metadata.numpy()[0][:10].tolist(), self.EXPECTED_Y_COND) + + audio_conditioning, metadata_conditioning, lyric_tokens = top_prior.get_cond(music_token_conds, metadata) + self.assertTrue(mindnlp.core.ops.allclose( + audio_conditioning[0][0][:30].detach(), mindspore.tensor(self.EXPECTED_AUDIO_COND), atol=1e-4, rtol=1e-4 + )) + self.assertTrue(mindnlp.core.ops.allclose( + metadata_conditioning[0][0][:30].detach(), mindspore.tensor(self.EXPECTED_META_COND), atol=1e-4, rtol=1e-4 + )) + self.assertTrue(mindnlp.core.ops.allclose( + lyric_tokens[0, :30].detach(), mindspore.tensor(self.EXPECTED_LYRIC_COND), atol=1e-4, rtol=1e-4 + )) + + #@slow + def test_primed_sampling(self): + model = JukeboxModel.from_pretrained(self.model_id, min_duration=0).set_train(False) + set_seed(0) + waveform = ops.rand((1, 5120, 1)) + tokens = list(self.prepare_inputs()) + + zs = [model.vqvae.encode(waveform, start_level=2, bs_chunks=waveform.shape[0])[0], None, None] + zs = model._sample( + zs, tokens, sample_levels=[0], save_results=False, sample_length=40 * model.priors[0].raw_to_tokens + ) + self.assertTrue(mindnlp.core.ops.allclose(zs[0][0][:40], mindspore.tensor(self.EXPECTED_PRIMED_0))) + + upper_2 = ops.cat((zs[0], ops.zeros(1, 2048 - zs[0].shape[-1])), dim=-1).long() + zs = [upper_2, model.vqvae.encode(waveform, start_level=1, bs_chunks=waveform.shape[0])[0], None] + zs = model._sample( + zs, tokens, sample_levels=[1], save_results=False, sample_length=40 * model.priors[1].raw_to_tokens + ) + self.assertTrue(mindnlp.core.ops.allclose(zs[1][0][:40], mindspore.tensor(self.EXPECTED_PRIMED_1))) + + upper_1 = ops.cat((zs[1], ops.zeros(1, 2048 - zs[1].shape[-1])), dim=-1).long() + zs = [upper_2, upper_1, model.vqvae.encode(waveform, start_level=0, bs_chunks=waveform.shape[0])[0]] + zs = model._sample( + zs, tokens, sample_levels=[2], save_results=False, sample_length=40 * model.priors[2].raw_to_tokens + ) + self.assertTrue(mindnlp.core.ops.allclose(zs[2][0][:40], mindspore.tensor(self.EXPECTED_PRIMED_2))) + + #@slow + def test_vqvae(self): + model = JukeboxModel.from_pretrained(self.model_id, min_duration=0).set_train(False) + set_seed(0) + x = ops.rand((1, 5120, 1)) + + zs = model.vqvae.encode(x, start_level=2, bs_chunks=x.shape[0]) + self.assertTrue(mindnlp.core.ops.allclose(zs[0][0], mindspore.tensor(self.EXPECTED_VQVAE_ENCODE))) + + x = model.vqvae.decode(zs, start_level=2, bs_chunks=x.shape[0]) + self.assertTrue(mindnlp.core.ops.allclose(x[0, :40, 0], mindspore.tensor(self.EXPECTED_VQVAE_DECODE), atol=1e-4, rtol=1e-4)) + + +@require_mindspore +class Jukebox5bModelTester(unittest.TestCase): + all_model_classes = (JukeboxModel,) if is_mindspore_available() else () + model_id = "openai/jukebox-5b-lyrics" + metas = { + "artist": "Zac Brown Band", + "genres": "Country", + "lyrics": """I met a traveller from an antique land, + Who said "Two vast and trunkless legs of stone + Stand in the desert. . . . Near them, on the sand, + Half sunk a shattered visage lies, whose frown, + And wrinkled lip, and sneer of cold command, + Tell that its sculptor well those passions read + Which yet survive, stamped on these lifeless things, + The hand that mocked them, and the heart that fed; + And on the pedestal, these words appear: + My name is Ozymandias, King of Kings; + Look on my Works, ye Mighty, and despair! + Nothing beside remains. Round the decay + Of that colossal Wreck, boundless and bare + The lone and level sands stretch far away + """, + } + + # fmt: off + EXPECTED_OUTPUT_2 = [ + 1489, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, + 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, + 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, + 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, + 1489, 1489, 1489, 1489, 1150, 1853, 1509, 1150, 1357, 1509, 6, 1272 + ] + EXPECTED_OUTPUT_2_PT_2 = [ + 1489, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, + 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, + 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, + 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, + 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653 + ] + + EXPECTED_OUTPUT_1 = [ + 1125, 416, 1125, 1125, 1125, 1125, 1125, 416, 416, 416, 416, 416, + 416, 416, 416, 416, 416, 416, 416, 416, 416, 416, 416, 416, + 416, 416, 416, 416, 416, 416, 416, 416, 416, 416, 416, 416, + 416, 416, 416, 416, 416, 416, 416, 416, 416, 416, 416, 416, + 416, 416, 416, 416, 416, 416, 416, 416, 416, 416, 416, 416 + ] + EXPECTED_OUTPUT_1_PT_2 = [ + 416, 416, 1125, 1125, 416, 416, 416, 416, 416, 416, 416, 416, 416, + 416, 416, 416, 416, 416, 416, 416, 416, 416, 416, 416, 416, 416, + 416, 416, 416, 416, 416, 416, 416, 416, 416, 416, 416, 416, 416, + 416, 416, 416, 416, 416, 416, 416, 416, 416, 416, 416, 416, 416, + 416, 416, 416, 416, 416, 416, 416, 416 + ] + + EXPECTED_OUTPUT_0 = [ + 1755, 1061, 234, 1755, 1061, 1755, 185, 290, 307, 307, 616, 616, + 616, 616, 616, 616, 307, 290, 417, 1755, 234, 1755, 185, 290, + 290, 290, 307, 616, 616, 616, 616, 616, 290, 234, 234, 1755, + 234, 234, 1755, 234, 185, 185, 307, 616, 616, 616, 616, 290, + 1755, 1755, 1755, 234, 234, 1755, 1572, 290, 307, 616, 34, 616 + ] + EXPECTED_OUTPUT_0_PT_2 = [ + 854, 842, 1353, 114, 1353, 842, 185, 842, 185, 114, 591, 842, 185, + 417, 185, 842, 307, 842, 591, 842, 185, 842, 185, 842, 591, 842, + 1353, 842, 185, 842, 591, 842, 591, 114, 591, 842, 185, 842, 591, + 89, 591, 842, 591, 842, 591, 417, 1372, 842, 1372, 842, 34, 842, + 185, 89, 591, 842, 185, 842, 591, 632 + ] + + EXPECTED_GPU_OUTPUTS_2 = [ + 1489, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, + 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, + 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, + 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, + 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653 + ] + EXPECTED_GPU_OUTPUTS_2_PT_2 = [ + 1489, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, + 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, + 653, 653, 653, 653, 653, 653, 653, 1853, 1177, 1536, 1228, + 710, 475, 1489, 1229, 1224, 231, 1224, 252, 1434, 653, 475, + 1106, 1877, 1599, 1228, 1600, 1683, 1182, 1853, 475, 1864, + 252, 1229, 1434, 2001 + ] + + EXPECTED_GPU_OUTPUTS_1 = [ + 1125, 1125, 416, 1125, 1125, 416, 1125, 1125, 416, 416, 1125, 416, + 416, 416, 416, 416, 416, 416, 416, 416, 416, 416, 416, 416, + 416, 416, 416, 416, 416, 416, 416, 416, 416, 416, 416, 416, + 416, 416, 416, 416, 416, 416, 416, 416, 416, 416, 416, 416, + 416, 416, 416, 416, 416, 416, 416, 416, 416, 416, 416, 416 + ] + EXPECTED_GPU_OUTPUTS_0 = [ + 491, 1755, 34, 1613, 1755, 417, 992, 1613, 222, 842, 1353, 1613, + 844, 632, 185, 1613, 844, 632, 185, 1613, 185, 842, 677, 1613, + 185, 114, 1353, 1613, 307, 89, 844, 1613, 307, 1332, 234, 1979, + 307, 89, 1353, 616, 34, 842, 185, 842, 34, 842, 185, 842, + 307, 114, 185, 89, 34, 1268, 185, 89, 34, 842, 185, 89 + ] + # fmt: on + + def prepare_inputs(self, model_id): + tokenizer = JukeboxTokenizer.from_pretrained(model_id) + tokens = tokenizer(**self.metas)["input_ids"] + return tokens + + #@slow + def test_sampling(self): + model = JukeboxModel.from_pretrained(self.model_id, min_duration=0).set_train(False) + labels = self.prepare_inputs(self.model_id) + + set_seed(0) + zs = [ops.zeros((1, 0), dtype=mindspore.int64) for _ in range(3)] + zs = model._sample(zs, labels, [0], sample_length=60 * model.priors[0].raw_to_tokens, save_results=False) + self.assertIn(zs[0][0].detach().tolist(), [self.EXPECTED_OUTPUT_2, self.EXPECTED_OUTPUT_2_PT_2]) + + set_seed(0) + zs = model._sample(zs, labels, [1], sample_length=60 * model.priors[1].raw_to_tokens, save_results=False) + self.assertIn(zs[1][0].detach().tolist(), [self.EXPECTED_OUTPUT_1, self.EXPECTED_OUTPUT_1_PT_2]) + + set_seed(0) + zs = model._sample(zs, labels, [2], sample_length=60 * model.priors[2].raw_to_tokens, save_results=False) + self.assertIn(zs[2][0].detach().tolist(), [self.EXPECTED_OUTPUT_0, self.EXPECTED_OUTPUT_0_PT_2]) + + #@slow + @skip("Not enough GPU memory on CI runners") + def test_slow_sampling(self): + model = JukeboxModel.from_pretrained(self.model_id, min_duration=0).set_train(False) + labels = [i for i in self.prepare_inputs(self.model_id)] + + set_seed(0) + model.priors[0] + zs = [ops.zeros((1, 0), dtype=mindspore.int64) for _ in range(3)] + zs = model._sample(zs, labels, [0], sample_length=60 * model.priors[0].raw_to_tokens, save_results=False) + self.assertTrue(mindnlp.core.ops.allclose(zs[0][0], mindspore.tensor(self.EXPECTED_GPU_OUTPUTS_2))) + model.priors[0] + + set_seed(0) + model.priors[1] + zs = model._sample(zs, labels, [1], sample_length=60 * model.priors[1].raw_to_tokens, save_results=False) + self.assertTrue(mindnlp.core.ops.allclose(zs[1][0], mindspore.tensor(self.EXPECTED_GPU_OUTPUTS_1))) + model.priors[1] + + set_seed(0) + model.priors[2] + zs = model._sample(zs, labels, [2], sample_length=60 * model.priors[2].raw_to_tokens, save_results=False) + self.assertTrue(mindnlp.core.ops.allclose(zs[2][0], mindspore.tensor(self.EXPECTED_GPU_OUTPUTS_0))) + + #@slow + def test_fp16_slow_sampling(self): + prior_id = "ArthurZ/jukebox_prior_0" + model = JukeboxPrior.from_pretrained(prior_id, min_duration=0).set_train(False).half() + + labels = self.prepare_inputs(prior_id)[0] + metadata = model.get_metadata(labels, 0, 7680, 0) + set_seed(0) + outputs = model.sample(1, metadata=metadata, sample_tokens=60) + self.assertIn(outputs[0].tolist(), [self.EXPECTED_GPU_OUTPUTS_2, self.EXPECTED_GPU_OUTPUTS_2_PT_2]) diff --git a/mindnlp/transformers/models/jukebox/test_tokenization_jukebox.py b/mindnlp/transformers/models/jukebox/test_tokenization_jukebox.py new file mode 100644 index 000000000..e971dde44 --- /dev/null +++ b/mindnlp/transformers/models/jukebox/test_tokenization_jukebox.py @@ -0,0 +1,210 @@ +# coding=utf-8 +# Copyright 2022 The HuggingFace Team. All rights reserved. +# +# 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 unittest + +from mindnlp.transformers import JukeboxTokenizer +from mindnlp.utils.testing_utils import require_mindspore + +class JukeboxTokenizationTest(unittest.TestCase): + tokenizer_class = JukeboxTokenizer + metas = { + "artist": "Zac Brown Band", + "genres": "Country", + "lyrics": """I met a traveller from an antique land, + Who said "Two vast and trunkless legs of stone + Stand in the desert. . . . Near them, on the sand, + Half sunk a shattered visage lies, whose frown, + And wrinkled lip, and sneer of cold command, + Tell that its sculptor well those passions read + Which yet survive, stamped on these lifeless things, + The hand that mocked them, and the heart that fed; + And on the pedestal, these words appear: + My name is Ozymandias, King of Kings; + Look on my Works, ye Mighty, and despair! + Nothing beside remains. Round the decay + Of that colossal Wreck, boundless and bare + The lone and level sands stretch far away + """, + } + + @require_mindspore + def test_1b_lyrics_tokenizer(self): + """ + how to run the same test with openAI + ... + """ + import mindspore + from mindnlp.core import ops + + tokenizer = JukeboxTokenizer.from_pretrained("openai/jukebox-1b-lyrics") + tokens = tokenizer(**self.metas)["input_ids"] + # fmt: off + EXPECTED_OUTPUT = [ + mindspore.tensor([[ + 0, 0, 0, 7169, 507, 9, 76, 39, 31, 46, 76, 27, + 76, 46, 44, 27, 48, 31, 38, 38, 31, 44, 76, 32, + 44, 41, 39, 76, 27, 40, 76, 27, 40, 46, 35, 43, + 47, 31, 76, 38, 27, 40, 30, 64, 78, 76, 76, 76, + 76, 76, 76, 76, 76, 23, 34, 41, 76, 45, 27, 35, + 30, 76, 71, 20, 49, 41, 76, 48, 27, 45, 46, 76, + 27, 40, 30, 76, 46, 44, 47, 40, 37, 38, 31, 45, + 45, 76, 38, 31, 33, 45, 76, 41, 32, 76, 45, 46, + 41, 40, 31, 78, 76, 76, 76, 76, 76, 76, 76, 76, + 19, 46, 27, 40, 30, 76, 35, 40, 76, 46, 34, 31, + 76, 30, 31, 45, 31, 44, 46, 63, 76, 63, 76, 63, + 76, 63, 76, 14, 31, 27, 44, 76, 46, 34, 31, 39, + 64, 76, 41, 40, 76, 46, 34, 31, 76, 45, 27, 40, + 30, 64, 78, 76, 76, 76, 76, 76, 76, 76, 76, 8, + 27, 38, 32, 76, 45, 47, 40, 37, 76, 27, 76, 45, + 34, 27, 46, 46, 31, 44, 31, 30, 76, 48, 35, 45, + 27, 33, 31, 76, 38, 35, 31, 45, 64, 76, 49, 34, + 41, 45, 31, 76, 32, 44, 41, 49, 40, 64, 78, 76, + 76, 76, 76, 76, 76, 76, 76, 1, 40, 30, 76, 49, + 44, 35, 40, 37, 38, 31, 30, 76, 38, 35, 42, 64, + 76, 27, 40, 30, 76, 45, 40, 31, 31, 44, 76, 41, + 32, 76, 29, 41, 38, 30, 76, 29, 41, 39, 39, 27, + 40, 30, 64, 78, 76, 76, 76, 76, 76, 76, 76, 76, + 20, 31, 38, 38, 76, 46, 34, 27, 46, 76, 35, 46, + 45, 76, 45, 29, 47, 38, 42, 46, 41, 44, 76, 49, + 31, 38, 38, 76, 46, 34, 41, 45, 31, 76, 42, 27, + 45, 45, 35, 41, 40, 45, 76, 44, 31, 27, 30, 78, + 76, 76, 76, 76, 76, 76, 76, 76, 23, 34, 35, 29, + 34, 76, 51, 31, 46, 76, 45, 47, 44, 48, 35, 48, + 31, 64, 76, 45, 46, 27, 39, 42, 31, 30, 76, 41, + 40, 76, 46, 34, 31, 45, 31, 76, 38, 35, 32, 31, + 38, 31, 45, 45, 76, 46, 34, 35, 40, 33, 45, 64, + 78, 76, 76, 76, 76, 76, 76, 76, 76, 20, 34, 31, + 76, 34, 27, 40, 30, 76, 46, 34, 27, 46, 76, 39, + 41, 29, 37, 31, 30, 76, 46, 34, 31, 39, 64, 76, + 27, 40, 30, 76, 46, 34, 31, 76, 34, 31, 27, 44, + 46, 76, 46, 34, 27, 46, 76, 32, 31, 30, 66, 78, + 76, 76, 76, 76, 76, 76, 76, 76, 1, 40, 30, 76, + 41, 40, 76, 46, 34, 31, 76, 42, 31, 30, 31, 45, + 46, 27, 38, 64, 76, 46, 34, 31, 45, 31, 76, 49, + 41, 44, 30, 45, 76, 27, 42, 42, 31, 27, 44, 65, + 78, 76, 76, 76, 76, 76, 76, 76, 76, 13, 51, 76, + 40, 27, 39, 31, 76, 35, 45, 76, 15, 52, 51, 39, + 27, 40, 30, 35, 27, 45, 64, 76, 11, 35, 40, 33, + 76, 41, 32, 76, 11, 35, 40, 33, 45, 66, 78, 76, + 76, 76, 76, 76, 76, 76, 76, 12, 41, 41, 37, 76, + 41, 40, 76, 39, 51, 76, 23, 41, 44, 37, 45, 64, + 76, 51, 31, 76, 13, 35, 33, 34, 46, 51, 64, 76, + 27, 40, 30, 76, 30, 31, 45, 42, 27, 35, 44, 67, + 78, 76, 76, 76, 76, 76, 76, 76, 76, 14, 41, 46, + 34, 35, 40, 33, 76, 28, 31, 45, 35, 30, 31, 76, + 44, 31, 39, 27, 35, 40, 45, 63, 76, 18, 41, 47, + 40, 30, 76, 46, 34, 31, 76, 30, 31, 29, 27, 51, + 78, 76, 76, 76, 76, 76, 76, 76, 76, 15, 32, 76, + 46, 34, 27, 46, 76, 29, 41, 38, 41, 45, 45, 27, + 38, 76, 23, 44, 31, 29, 37, 64, 76, 28, 41, 47, + 40, 30, 38, 31, 45, 45, 76, 27, 40, 30, 76, 28, + 27, 44, 31, 78, 76, 76, 76, 76, 76, 76, 76, 76, + 20, 34, 31, 76, 38, 41, 40, 31, 76, 27, 40, 30, + 76, 38, 31, 48, 31, 38, 76, 45, 27, 40, 30, 45, + 76, 45, 46, 44, 31, 46, 29, 34, 76, 32, 27, 44, + 76, 27, 49, 27, 51, 78, 76, 76, 76, 76, 76, 76, + 76, 76]]), + mindspore.tensor([[0, 0, 0, 1069, 11]]), + mindspore.tensor([[0, 0, 0, 1069, 11]]), + ] + # fmt: on + self.assertTrue(ops.allclose(tokens[0], EXPECTED_OUTPUT[0])) + self.assertTrue(ops.allclose(tokens[1], EXPECTED_OUTPUT[1])) + self.assertTrue(ops.allclose(tokens[2], EXPECTED_OUTPUT[2])) + + @require_mindspore + def test_5b_lyrics_tokenizer(self): + """ + The outputs are similar that open AI but do not have the same format as this one is adapted to the HF integration. + """ + import mindspore + from mindnlp.core import ops + + tokenizer = JukeboxTokenizer.from_pretrained("openai/jukebox-5b-lyrics") + tokens = tokenizer(**self.metas)["input_ids"] + # fmt: off + EXPECTED_OUTPUT = [ + mindspore.tensor([[ + 0, 0, 0, 1069, 11, -1, -1, -1, -1, 9, 77, 39, + 31, 46, 77, 27, 77, 46, 44, 27, 48, 31, 38, 38, + 31, 44, 77, 32, 44, 41, 39, 77, 27, 40, 77, 27, + 40, 46, 35, 43, 47, 31, 77, 38, 27, 40, 30, 64, + 79, 77, 77, 77, 77, 77, 77, 77, 77, 23, 34, 41, + 77, 45, 27, 35, 30, 77, 72, 20, 49, 41, 77, 48, + 27, 45, 46, 77, 27, 40, 30, 77, 46, 44, 47, 40, + 37, 38, 31, 45, 45, 77, 38, 31, 33, 45, 77, 41, + 32, 77, 45, 46, 41, 40, 31, 79, 77, 77, 77, 77, + 77, 77, 77, 77, 19, 46, 27, 40, 30, 77, 35, 40, + 77, 46, 34, 31, 77, 30, 31, 45, 31, 44, 46, 63, + 77, 63, 77, 63, 77, 63, 77, 14, 31, 27, 44, 77, + 46, 34, 31, 39, 64, 77, 41, 40, 77, 46, 34, 31, + 77, 45, 27, 40, 30, 64, 79, 77, 77, 77, 77, 77, + 77, 77, 77, 8, 27, 38, 32, 77, 45, 47, 40, 37, + 77, 27, 77, 45, 34, 27, 46, 46, 31, 44, 31, 30, + 77, 48, 35, 45, 27, 33, 31, 77, 38, 35, 31, 45, + 64, 77, 49, 34, 41, 45, 31, 77, 32, 44, 41, 49, + 40, 64, 79, 77, 77, 77, 77, 77, 77, 77, 77, 1, + 40, 30, 77, 49, 44, 35, 40, 37, 38, 31, 30, 77, + 38, 35, 42, 64, 77, 27, 40, 30, 77, 45, 40, 31, + 31, 44, 77, 41, 32, 77, 29, 41, 38, 30, 77, 29, + 41, 39, 39, 27, 40, 30, 64, 79, 77, 77, 77, 77, + 77, 77, 77, 77, 20, 31, 38, 38, 77, 46, 34, 27, + 46, 77, 35, 46, 45, 77, 45, 29, 47, 38, 42, 46, + 41, 44, 77, 49, 31, 38, 38, 77, 46, 34, 41, 45, + 31, 77, 42, 27, 45, 45, 35, 41, 40, 45, 77, 44, + 31, 27, 30, 79, 77, 77, 77, 77, 77, 77, 77, 77, + 23, 34, 35, 29, 34, 77, 51, 31, 46, 77, 45, 47, + 44, 48, 35, 48, 31, 64, 77, 45, 46, 27, 39, 42, + 31, 30, 77, 41, 40, 77, 46, 34, 31, 45, 31, 77, + 38, 35, 32, 31, 38, 31, 45, 45, 77, 46, 34, 35, + 40, 33, 45, 64, 79, 77, 77, 77, 77, 77, 77, 77, + 77, 20, 34, 31, 77, 34, 27, 40, 30, 77, 46, 34, + 27, 46, 77, 39, 41, 29, 37, 31, 30, 77, 46, 34, + 31, 39, 64, 77, 27, 40, 30, 77, 46, 34, 31, 77, + 34, 31, 27, 44, 46, 77, 46, 34, 27, 46, 77, 32, + 31, 30, 66, 79, 77, 77, 77, 77, 77, 77, 77, 77, + 1, 40, 30, 77, 41, 40, 77, 46, 34, 31, 77, 42, + 31, 30, 31, 45, 46, 27, 38, 64, 77, 46, 34, 31, + 45, 31, 77, 49, 41, 44, 30, 45, 77, 27, 42, 42, + 31, 27, 44, 65, 79, 77, 77, 77, 77, 77, 77, 77, + 77, 13, 51, 77, 40, 27, 39, 31, 77, 35, 45, 77, + 15, 52, 51, 39, 27, 40, 30, 35, 27, 45, 64, 77, + 11, 35, 40, 33, 77, 41, 32, 77, 11, 35, 40, 33, + 45, 66, 79, 77, 77, 77, 77, 77, 77, 77, 77, 12, + 41, 41, 37, 77, 41, 40, 77, 39, 51, 77, 23, 41, + 44, 37, 45, 64, 77, 51, 31, 77, 13, 35, 33, 34, + 46, 51, 64, 77, 27, 40, 30, 77, 30, 31, 45, 42, + 27, 35, 44, 67, 79, 77, 77, 77, 77, 77, 77, 77, + 77, 14, 41, 46, 34, 35, 40, 33, 77, 28, 31, 45, + 35, 30, 31, 77, 44, 31, 39, 27, 35, 40, 45, 63, + 77, 18, 41, 47, 40, 30, 77, 46, 34, 31, 77, 30, + 31, 29, 27, 51, 79, 77, 77, 77, 77, 77, 77, 77, + 77, 15, 32, 77, 46, 34, 27, 46, 77, 29, 41, 38, + 41, 45, 45, 27, 38, 77, 23, 44, 31, 29, 37, 64, + 77, 28, 41, 47, 40, 30, 38, 31, 45, 45, 77, 27, + 40, 30, 77, 28, 27, 44, 31, 79, 77, 77, 77, 77, + 77, 77, 77, 77, 20, 34, 31, 77, 38, 41, 40, 31, + 77, 27, 40, 30, 77, 38, 31, 48, 31, 38, 77, 45, + 27, 40, 30, 45, 77, 45, 46, 44, 31, 46, 29, 34, + 77, 32, 27, 44, 77, 27, 49, 27, 51, 79, 77, 77, + 77, 77, 77, 77, 77, 77]]), + mindspore.tensor([[0, 0, 0, 1069, 11, -1, -1, -1, -1]]), + mindspore.tensor([[0, 0, 0, 1069, 11, -1, -1, -1, -1]]), + ] + # fmt: on + self.assertTrue(ops.allclose(tokens[0], EXPECTED_OUTPUT[0])) + self.assertTrue(ops.allclose(tokens[1], EXPECTED_OUTPUT[1])) + self.assertTrue(ops.allclose(tokens[2], EXPECTED_OUTPUT[2])) From 48222f662af4f19e1bf8ec8f03543151966cb546 Mon Sep 17 00:00:00 2001 From: 1hb6s7t <120760709+1hb6s7t@users.noreply.github.com> Date: Sat, 8 Feb 2025 21:22:32 +0800 Subject: [PATCH 12/20] Add files via upload From 2216d6c09eca7bb468304923c63665f35bbf8534 Mon Sep 17 00:00:00 2001 From: 1hb6s7t <120760709+1hb6s7t@users.noreply.github.com> Date: Sat, 8 Feb 2025 21:24:57 +0800 Subject: [PATCH 13/20] Delete mindnlp/transformers/models/jukebox/test_tokenization_jukebox.py --- .../jukebox/test_tokenization_jukebox.py | 210 ------------------ 1 file changed, 210 deletions(-) delete mode 100644 mindnlp/transformers/models/jukebox/test_tokenization_jukebox.py diff --git a/mindnlp/transformers/models/jukebox/test_tokenization_jukebox.py b/mindnlp/transformers/models/jukebox/test_tokenization_jukebox.py deleted file mode 100644 index e971dde44..000000000 --- a/mindnlp/transformers/models/jukebox/test_tokenization_jukebox.py +++ /dev/null @@ -1,210 +0,0 @@ -# coding=utf-8 -# Copyright 2022 The HuggingFace Team. All rights reserved. -# -# 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 unittest - -from mindnlp.transformers import JukeboxTokenizer -from mindnlp.utils.testing_utils import require_mindspore - -class JukeboxTokenizationTest(unittest.TestCase): - tokenizer_class = JukeboxTokenizer - metas = { - "artist": "Zac Brown Band", - "genres": "Country", - "lyrics": """I met a traveller from an antique land, - Who said "Two vast and trunkless legs of stone - Stand in the desert. . . . Near them, on the sand, - Half sunk a shattered visage lies, whose frown, - And wrinkled lip, and sneer of cold command, - Tell that its sculptor well those passions read - Which yet survive, stamped on these lifeless things, - The hand that mocked them, and the heart that fed; - And on the pedestal, these words appear: - My name is Ozymandias, King of Kings; - Look on my Works, ye Mighty, and despair! - Nothing beside remains. Round the decay - Of that colossal Wreck, boundless and bare - The lone and level sands stretch far away - """, - } - - @require_mindspore - def test_1b_lyrics_tokenizer(self): - """ - how to run the same test with openAI - ... - """ - import mindspore - from mindnlp.core import ops - - tokenizer = JukeboxTokenizer.from_pretrained("openai/jukebox-1b-lyrics") - tokens = tokenizer(**self.metas)["input_ids"] - # fmt: off - EXPECTED_OUTPUT = [ - mindspore.tensor([[ - 0, 0, 0, 7169, 507, 9, 76, 39, 31, 46, 76, 27, - 76, 46, 44, 27, 48, 31, 38, 38, 31, 44, 76, 32, - 44, 41, 39, 76, 27, 40, 76, 27, 40, 46, 35, 43, - 47, 31, 76, 38, 27, 40, 30, 64, 78, 76, 76, 76, - 76, 76, 76, 76, 76, 23, 34, 41, 76, 45, 27, 35, - 30, 76, 71, 20, 49, 41, 76, 48, 27, 45, 46, 76, - 27, 40, 30, 76, 46, 44, 47, 40, 37, 38, 31, 45, - 45, 76, 38, 31, 33, 45, 76, 41, 32, 76, 45, 46, - 41, 40, 31, 78, 76, 76, 76, 76, 76, 76, 76, 76, - 19, 46, 27, 40, 30, 76, 35, 40, 76, 46, 34, 31, - 76, 30, 31, 45, 31, 44, 46, 63, 76, 63, 76, 63, - 76, 63, 76, 14, 31, 27, 44, 76, 46, 34, 31, 39, - 64, 76, 41, 40, 76, 46, 34, 31, 76, 45, 27, 40, - 30, 64, 78, 76, 76, 76, 76, 76, 76, 76, 76, 8, - 27, 38, 32, 76, 45, 47, 40, 37, 76, 27, 76, 45, - 34, 27, 46, 46, 31, 44, 31, 30, 76, 48, 35, 45, - 27, 33, 31, 76, 38, 35, 31, 45, 64, 76, 49, 34, - 41, 45, 31, 76, 32, 44, 41, 49, 40, 64, 78, 76, - 76, 76, 76, 76, 76, 76, 76, 1, 40, 30, 76, 49, - 44, 35, 40, 37, 38, 31, 30, 76, 38, 35, 42, 64, - 76, 27, 40, 30, 76, 45, 40, 31, 31, 44, 76, 41, - 32, 76, 29, 41, 38, 30, 76, 29, 41, 39, 39, 27, - 40, 30, 64, 78, 76, 76, 76, 76, 76, 76, 76, 76, - 20, 31, 38, 38, 76, 46, 34, 27, 46, 76, 35, 46, - 45, 76, 45, 29, 47, 38, 42, 46, 41, 44, 76, 49, - 31, 38, 38, 76, 46, 34, 41, 45, 31, 76, 42, 27, - 45, 45, 35, 41, 40, 45, 76, 44, 31, 27, 30, 78, - 76, 76, 76, 76, 76, 76, 76, 76, 23, 34, 35, 29, - 34, 76, 51, 31, 46, 76, 45, 47, 44, 48, 35, 48, - 31, 64, 76, 45, 46, 27, 39, 42, 31, 30, 76, 41, - 40, 76, 46, 34, 31, 45, 31, 76, 38, 35, 32, 31, - 38, 31, 45, 45, 76, 46, 34, 35, 40, 33, 45, 64, - 78, 76, 76, 76, 76, 76, 76, 76, 76, 20, 34, 31, - 76, 34, 27, 40, 30, 76, 46, 34, 27, 46, 76, 39, - 41, 29, 37, 31, 30, 76, 46, 34, 31, 39, 64, 76, - 27, 40, 30, 76, 46, 34, 31, 76, 34, 31, 27, 44, - 46, 76, 46, 34, 27, 46, 76, 32, 31, 30, 66, 78, - 76, 76, 76, 76, 76, 76, 76, 76, 1, 40, 30, 76, - 41, 40, 76, 46, 34, 31, 76, 42, 31, 30, 31, 45, - 46, 27, 38, 64, 76, 46, 34, 31, 45, 31, 76, 49, - 41, 44, 30, 45, 76, 27, 42, 42, 31, 27, 44, 65, - 78, 76, 76, 76, 76, 76, 76, 76, 76, 13, 51, 76, - 40, 27, 39, 31, 76, 35, 45, 76, 15, 52, 51, 39, - 27, 40, 30, 35, 27, 45, 64, 76, 11, 35, 40, 33, - 76, 41, 32, 76, 11, 35, 40, 33, 45, 66, 78, 76, - 76, 76, 76, 76, 76, 76, 76, 12, 41, 41, 37, 76, - 41, 40, 76, 39, 51, 76, 23, 41, 44, 37, 45, 64, - 76, 51, 31, 76, 13, 35, 33, 34, 46, 51, 64, 76, - 27, 40, 30, 76, 30, 31, 45, 42, 27, 35, 44, 67, - 78, 76, 76, 76, 76, 76, 76, 76, 76, 14, 41, 46, - 34, 35, 40, 33, 76, 28, 31, 45, 35, 30, 31, 76, - 44, 31, 39, 27, 35, 40, 45, 63, 76, 18, 41, 47, - 40, 30, 76, 46, 34, 31, 76, 30, 31, 29, 27, 51, - 78, 76, 76, 76, 76, 76, 76, 76, 76, 15, 32, 76, - 46, 34, 27, 46, 76, 29, 41, 38, 41, 45, 45, 27, - 38, 76, 23, 44, 31, 29, 37, 64, 76, 28, 41, 47, - 40, 30, 38, 31, 45, 45, 76, 27, 40, 30, 76, 28, - 27, 44, 31, 78, 76, 76, 76, 76, 76, 76, 76, 76, - 20, 34, 31, 76, 38, 41, 40, 31, 76, 27, 40, 30, - 76, 38, 31, 48, 31, 38, 76, 45, 27, 40, 30, 45, - 76, 45, 46, 44, 31, 46, 29, 34, 76, 32, 27, 44, - 76, 27, 49, 27, 51, 78, 76, 76, 76, 76, 76, 76, - 76, 76]]), - mindspore.tensor([[0, 0, 0, 1069, 11]]), - mindspore.tensor([[0, 0, 0, 1069, 11]]), - ] - # fmt: on - self.assertTrue(ops.allclose(tokens[0], EXPECTED_OUTPUT[0])) - self.assertTrue(ops.allclose(tokens[1], EXPECTED_OUTPUT[1])) - self.assertTrue(ops.allclose(tokens[2], EXPECTED_OUTPUT[2])) - - @require_mindspore - def test_5b_lyrics_tokenizer(self): - """ - The outputs are similar that open AI but do not have the same format as this one is adapted to the HF integration. - """ - import mindspore - from mindnlp.core import ops - - tokenizer = JukeboxTokenizer.from_pretrained("openai/jukebox-5b-lyrics") - tokens = tokenizer(**self.metas)["input_ids"] - # fmt: off - EXPECTED_OUTPUT = [ - mindspore.tensor([[ - 0, 0, 0, 1069, 11, -1, -1, -1, -1, 9, 77, 39, - 31, 46, 77, 27, 77, 46, 44, 27, 48, 31, 38, 38, - 31, 44, 77, 32, 44, 41, 39, 77, 27, 40, 77, 27, - 40, 46, 35, 43, 47, 31, 77, 38, 27, 40, 30, 64, - 79, 77, 77, 77, 77, 77, 77, 77, 77, 23, 34, 41, - 77, 45, 27, 35, 30, 77, 72, 20, 49, 41, 77, 48, - 27, 45, 46, 77, 27, 40, 30, 77, 46, 44, 47, 40, - 37, 38, 31, 45, 45, 77, 38, 31, 33, 45, 77, 41, - 32, 77, 45, 46, 41, 40, 31, 79, 77, 77, 77, 77, - 77, 77, 77, 77, 19, 46, 27, 40, 30, 77, 35, 40, - 77, 46, 34, 31, 77, 30, 31, 45, 31, 44, 46, 63, - 77, 63, 77, 63, 77, 63, 77, 14, 31, 27, 44, 77, - 46, 34, 31, 39, 64, 77, 41, 40, 77, 46, 34, 31, - 77, 45, 27, 40, 30, 64, 79, 77, 77, 77, 77, 77, - 77, 77, 77, 8, 27, 38, 32, 77, 45, 47, 40, 37, - 77, 27, 77, 45, 34, 27, 46, 46, 31, 44, 31, 30, - 77, 48, 35, 45, 27, 33, 31, 77, 38, 35, 31, 45, - 64, 77, 49, 34, 41, 45, 31, 77, 32, 44, 41, 49, - 40, 64, 79, 77, 77, 77, 77, 77, 77, 77, 77, 1, - 40, 30, 77, 49, 44, 35, 40, 37, 38, 31, 30, 77, - 38, 35, 42, 64, 77, 27, 40, 30, 77, 45, 40, 31, - 31, 44, 77, 41, 32, 77, 29, 41, 38, 30, 77, 29, - 41, 39, 39, 27, 40, 30, 64, 79, 77, 77, 77, 77, - 77, 77, 77, 77, 20, 31, 38, 38, 77, 46, 34, 27, - 46, 77, 35, 46, 45, 77, 45, 29, 47, 38, 42, 46, - 41, 44, 77, 49, 31, 38, 38, 77, 46, 34, 41, 45, - 31, 77, 42, 27, 45, 45, 35, 41, 40, 45, 77, 44, - 31, 27, 30, 79, 77, 77, 77, 77, 77, 77, 77, 77, - 23, 34, 35, 29, 34, 77, 51, 31, 46, 77, 45, 47, - 44, 48, 35, 48, 31, 64, 77, 45, 46, 27, 39, 42, - 31, 30, 77, 41, 40, 77, 46, 34, 31, 45, 31, 77, - 38, 35, 32, 31, 38, 31, 45, 45, 77, 46, 34, 35, - 40, 33, 45, 64, 79, 77, 77, 77, 77, 77, 77, 77, - 77, 20, 34, 31, 77, 34, 27, 40, 30, 77, 46, 34, - 27, 46, 77, 39, 41, 29, 37, 31, 30, 77, 46, 34, - 31, 39, 64, 77, 27, 40, 30, 77, 46, 34, 31, 77, - 34, 31, 27, 44, 46, 77, 46, 34, 27, 46, 77, 32, - 31, 30, 66, 79, 77, 77, 77, 77, 77, 77, 77, 77, - 1, 40, 30, 77, 41, 40, 77, 46, 34, 31, 77, 42, - 31, 30, 31, 45, 46, 27, 38, 64, 77, 46, 34, 31, - 45, 31, 77, 49, 41, 44, 30, 45, 77, 27, 42, 42, - 31, 27, 44, 65, 79, 77, 77, 77, 77, 77, 77, 77, - 77, 13, 51, 77, 40, 27, 39, 31, 77, 35, 45, 77, - 15, 52, 51, 39, 27, 40, 30, 35, 27, 45, 64, 77, - 11, 35, 40, 33, 77, 41, 32, 77, 11, 35, 40, 33, - 45, 66, 79, 77, 77, 77, 77, 77, 77, 77, 77, 12, - 41, 41, 37, 77, 41, 40, 77, 39, 51, 77, 23, 41, - 44, 37, 45, 64, 77, 51, 31, 77, 13, 35, 33, 34, - 46, 51, 64, 77, 27, 40, 30, 77, 30, 31, 45, 42, - 27, 35, 44, 67, 79, 77, 77, 77, 77, 77, 77, 77, - 77, 14, 41, 46, 34, 35, 40, 33, 77, 28, 31, 45, - 35, 30, 31, 77, 44, 31, 39, 27, 35, 40, 45, 63, - 77, 18, 41, 47, 40, 30, 77, 46, 34, 31, 77, 30, - 31, 29, 27, 51, 79, 77, 77, 77, 77, 77, 77, 77, - 77, 15, 32, 77, 46, 34, 27, 46, 77, 29, 41, 38, - 41, 45, 45, 27, 38, 77, 23, 44, 31, 29, 37, 64, - 77, 28, 41, 47, 40, 30, 38, 31, 45, 45, 77, 27, - 40, 30, 77, 28, 27, 44, 31, 79, 77, 77, 77, 77, - 77, 77, 77, 77, 20, 34, 31, 77, 38, 41, 40, 31, - 77, 27, 40, 30, 77, 38, 31, 48, 31, 38, 77, 45, - 27, 40, 30, 45, 77, 45, 46, 44, 31, 46, 29, 34, - 77, 32, 27, 44, 77, 27, 49, 27, 51, 79, 77, 77, - 77, 77, 77, 77, 77, 77]]), - mindspore.tensor([[0, 0, 0, 1069, 11, -1, -1, -1, -1]]), - mindspore.tensor([[0, 0, 0, 1069, 11, -1, -1, -1, -1]]), - ] - # fmt: on - self.assertTrue(ops.allclose(tokens[0], EXPECTED_OUTPUT[0])) - self.assertTrue(ops.allclose(tokens[1], EXPECTED_OUTPUT[1])) - self.assertTrue(ops.allclose(tokens[2], EXPECTED_OUTPUT[2])) From 30d2d9299f5f4f1f546d93a6e44765a762e51206 Mon Sep 17 00:00:00 2001 From: 1hb6s7t <120760709+1hb6s7t@users.noreply.github.com> Date: Sat, 8 Feb 2025 21:25:11 +0800 Subject: [PATCH 14/20] Delete mindnlp/transformers/models/jukebox/test_modeling_jukebox.py --- .../models/jukebox/test_modeling_jukebox.py | 395 ------------------ 1 file changed, 395 deletions(-) delete mode 100644 mindnlp/transformers/models/jukebox/test_modeling_jukebox.py diff --git a/mindnlp/transformers/models/jukebox/test_modeling_jukebox.py b/mindnlp/transformers/models/jukebox/test_modeling_jukebox.py deleted file mode 100644 index d37ab8905..000000000 --- a/mindnlp/transformers/models/jukebox/test_modeling_jukebox.py +++ /dev/null @@ -1,395 +0,0 @@ -# coding=utf-8 -# Copyright 2022 The HuggingFace Team. All rights reserved. -# -# 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 unittest -from unittest import skip - -from mindnlp.utils.testing_utils import ( - is_mindspore_available, - require_mindspore, - slow, -) -from mindnlp.engine import set_seed -import mindnlp.core - -if is_mindspore_available(): - import mindspore - from mindspore import ops - from mindnlp.transformers import JukeboxModel, JukeboxPrior, JukeboxTokenizer - - -@require_mindspore -class Jukebox1bModelTester(unittest.TestCase): - all_model_classes = (JukeboxModel,) if is_mindspore_available() else () - model_id = "openai/jukebox-1b-lyrics" - metas = { - "artist": "Zac Brown Band", - "genres": "Country", - "lyrics": """I met a traveller from an antique land, - Who said "Two vast and trunkless legs of stone - Stand in the desert. . . . Near them, on the sand, - Half sunk a shattered visage lies, whose frown, - And wrinkled lip, and sneer of cold command, - Tell that its sculptor well those passions read - Which yet survive, stamped on these lifeless things, - The hand that mocked them, and the heart that fed; - And on the pedestal, these words appear: - My name is Ozymandias, King of Kings; - Look on my Works, ye Mighty, and despair! - Nothing beside remains. Round the decay - Of that colossal Wreck, boundless and bare - The lone and level sands stretch far away - """, - } - # fmt: off - EXPECTED_OUTPUT_2 = [ - 1864, 1536, 1213, 1870, 1357, 1536, 519, 880, 1323, 789, 1082, 534, - 1000, 1445, 1105, 1130, 967, 515, 1434, 1620, 534, 1495, 283, 1445, - 333, 1307, 539, 1631, 1528, 375, 1434, 673, 627, 710, 778, 1883, - 1405, 1276, 1455, 1228 - ] - - EXPECTED_OUTPUT_2_PT_2 = [ - 1489, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, - 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, - 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, - 653, 653, 653, 653 - ] - - EXPECTED_OUTPUT_1 = [ - 1125, 1751, 697, 1776, 1141, 1476, 391, 697, 1125, 684, 867, 416, - 844, 1372, 1274, 717, 1274, 844, 1299, 1419, 697, 1370, 317, 1125, - 191, 1440, 1370, 1440, 1370, 282, 1621, 1370, 368, 349, 867, 1872, - 1262, 869, 1728, 747 - ] - EXPECTED_OUTPUT_1_PT_2 = [ - 416, 416, 1125, 1125, 416, 416, 416, 416, 416, 416, 416, 416, - 416, 416, 416, 416, 416, 416, 416, 416, 416, 416, 416, 416, - 416, 416, 416, 416, 416, 416, 416, 416, 416, 416, 416, 416, - 416, 416, 416, 416 - ] - - EXPECTED_OUTPUT_0 = [ - 1755, 842, 307, 1843, 1022, 1395, 234, 1554, 806, 739, 1022, 442, - 616, 556, 268, 1499, 933, 457, 1440, 1837, 755, 985, 308, 902, - 293, 1443, 1671, 1141, 1533, 555, 1562, 1061, 287, 417, 1022, 2008, - 1186, 1015, 1777, 268 - ] - EXPECTED_OUTPUT_0_PT_2 = [ - 854, 842, 1353, 114, 1353, 842, 185, 842, 185, 114, 591, 842, - 185, 417, 185, 842, 307, 842, 591, 842, 185, 842, 307, 842, - 591, 842, 1353, 842, 185, 842, 591, 842, 591, 114, 591, 842, - 185, 842, 591, 89 - ] - - EXPECTED_Y_COND = [1058304, 0, 786432, 7169, 507, 76, 27, 40, 30, 76] - - EXPECTED_PRIMED_0 = [ - 390, 1160, 1002, 1907, 1788, 1788, 1788, 1907, 1002, 1002, 1854, 1002, - 1002, 1002, 1002, 1002, 1002, 1160, 1160, 1606, 596, 596, 1160, 1002, - 1516, 596, 1002, 1002, 1002, 1907, 1788, 1788, 1788, 1854, 1788, 1907, - 1907, 1788, 596, 1626 - ] - EXPECTED_PRIMED_1 = [ - 1236, 1668, 1484, 1920, 1848, 1409, 139, 864, 1828, 1272, 1599, 824, - 1672, 139, 555, 1484, 824, 1920, 555, 596, 1579, 1599, 1231, 1599, - 1637, 1407, 212, 824, 1599, 116, 1433, 824, 258, 1599, 1433, 1895, - 1063, 1433, 1433, 1599 - ] - EXPECTED_PRIMED_2 = [ - 1684, 1873, 1119, 1189, 395, 611, 1901, 972, 890, 1337, 1392, 1927, - 96, 972, 672, 780, 1119, 890, 158, 771, 1073, 1927, 353, 1331, - 1269, 1459, 1333, 1645, 812, 1577, 1337, 606, 353, 981, 1466, 619, - 197, 391, 302, 1930 - ] - EXPECTED_VQVAE_ENCODE = [ - 390, 1160, 1002, 1907, 1788, 1788, 1788, 1907, 1002, 1002, 1854, 1002, - 1002, 1002, 1002, 1002, 1002, 1160, 1160, 1606, 596, 596, 1160, 1002, - 1516, 596, 1002, 1002, 1002, 1907, 1788, 1788, 1788, 1854, 1788, 1907, - 1907, 1788, 596, 1626 - ] - EXPECTED_VQVAE_DECODE = [ - -0.0492, -0.0524, -0.0565, -0.0640, -0.0686, -0.0684, -0.0677, -0.0664, - -0.0605, -0.0490, -0.0330, -0.0168, -0.0083, -0.0075, -0.0051, 0.0025, - 0.0136, 0.0261, 0.0386, 0.0497, 0.0580, 0.0599, 0.0583, 0.0614, - 0.0740, 0.0889, 0.1023, 0.1162, 0.1211, 0.1212, 0.1251, 0.1336, - 0.1502, 0.1686, 0.1883, 0.2148, 0.2363, 0.2458, 0.2507, 0.2531 - ] - EXPECTED_AUDIO_COND = [ - 0.0256, -0.0544, 0.1600, -0.0032, 0.1066, 0.0825, -0.0013, 0.3440, - 0.0210, 0.0412, -0.1777, -0.0892, -0.0164, 0.0285, -0.0613, -0.0617, - -0.0137, -0.0201, -0.0175, 0.0215, -0.0627, 0.0520, -0.0730, 0.0970, - -0.0100, 0.0442, -0.0586, 0.0207, -0.0015, -0.0082 - ] - EXPECTED_META_COND = [ - 0.0415, 0.0877, 0.0022, -0.0055, 0.0751, 0.0334, 0.0324, -0.0068, - 0.0011, 0.0017, -0.0676, 0.0655, -0.0143, 0.0399, 0.0303, 0.0743, - -0.0168, -0.0394, -0.1113, 0.0124, 0.0442, 0.0267, -0.0003, -0.1536, - -0.0116, -0.1837, -0.0180, -0.1026, -0.0777, -0.0456 - ] - EXPECTED_LYRIC_COND = [ - 76, 27, 40, 30, 76, 46, 44, 47, 40, 37, 38, 31, 45, 45, 76, 38, 31, 33, - 45, 76, 41, 32, 76, 45, 46, 41, 40, 31, 78, 76 - ] - # fmt: on - - def prepare_inputs(self): - tokenizer = JukeboxTokenizer.from_pretrained(self.model_id) - tokens = tokenizer(**self.metas)["input_ids"] - return tokens - - #@slow - def test_sampling(self): - model = JukeboxModel.from_pretrained(self.model_id, min_duration=0).set_train(False) - labels = self.prepare_inputs() - - set_seed(0) - zs = [ops.zeros((1, 0), dtype=mindspore.int64) for _ in range(3)] - zs = model._sample(zs, labels, [0], sample_length=40 * model.priors[0].raw_to_tokens, save_results=False) - self.assertIn(zs[0][0].detach().tolist(), [self.EXPECTED_OUTPUT_2, self.EXPECTED_OUTPUT_2_PT_2]) - - set_seed(0) - zs = model._sample(zs, labels, [1], sample_length=40 * model.priors[1].raw_to_tokens, save_results=False) - self.assertIn(zs[1][0].detach().tolist(), [self.EXPECTED_OUTPUT_1, self.EXPECTED_OUTPUT_1_PT_2]) - - set_seed(0) - zs = model._sample(zs, labels, [2], sample_length=40 * model.priors[2].raw_to_tokens, save_results=False) - self.assertIn(zs[2][0].detach().tolist(), [self.EXPECTED_OUTPUT_0, self.EXPECTED_OUTPUT_0_PT_2]) - - #@slow - def test_conditioning(self): - model = JukeboxModel.from_pretrained(self.model_id, min_duration=0).set_train(False) - - labels = self.prepare_inputs() - set_seed(0) - zs = [ops.zeros((1, 0), dtype=mindspore.int64) for _ in range(3)] - - top_prior = model.priors[0] - start = 0 - music_token_conds = top_prior.get_music_tokens_conds(zs, start=start, end=start + top_prior.n_ctx) - metadata = top_prior.get_metadata(labels[0].clone(), start, 1058304, 0) - - self.assertIsNone(music_token_conds) - self.assertListEqual(metadata.numpy()[0][:10].tolist(), self.EXPECTED_Y_COND) - - audio_conditioning, metadata_conditioning, lyric_tokens = top_prior.get_cond(music_token_conds, metadata) - self.assertTrue(mindnlp.core.ops.allclose( - audio_conditioning[0][0][:30].detach(), mindspore.tensor(self.EXPECTED_AUDIO_COND), atol=1e-4, rtol=1e-4 - )) - self.assertTrue(mindnlp.core.ops.allclose( - metadata_conditioning[0][0][:30].detach(), mindspore.tensor(self.EXPECTED_META_COND), atol=1e-4, rtol=1e-4 - )) - self.assertTrue(mindnlp.core.ops.allclose( - lyric_tokens[0, :30].detach(), mindspore.tensor(self.EXPECTED_LYRIC_COND), atol=1e-4, rtol=1e-4 - )) - - #@slow - def test_primed_sampling(self): - model = JukeboxModel.from_pretrained(self.model_id, min_duration=0).set_train(False) - set_seed(0) - waveform = ops.rand((1, 5120, 1)) - tokens = list(self.prepare_inputs()) - - zs = [model.vqvae.encode(waveform, start_level=2, bs_chunks=waveform.shape[0])[0], None, None] - zs = model._sample( - zs, tokens, sample_levels=[0], save_results=False, sample_length=40 * model.priors[0].raw_to_tokens - ) - self.assertTrue(mindnlp.core.ops.allclose(zs[0][0][:40], mindspore.tensor(self.EXPECTED_PRIMED_0))) - - upper_2 = ops.cat((zs[0], ops.zeros(1, 2048 - zs[0].shape[-1])), dim=-1).long() - zs = [upper_2, model.vqvae.encode(waveform, start_level=1, bs_chunks=waveform.shape[0])[0], None] - zs = model._sample( - zs, tokens, sample_levels=[1], save_results=False, sample_length=40 * model.priors[1].raw_to_tokens - ) - self.assertTrue(mindnlp.core.ops.allclose(zs[1][0][:40], mindspore.tensor(self.EXPECTED_PRIMED_1))) - - upper_1 = ops.cat((zs[1], ops.zeros(1, 2048 - zs[1].shape[-1])), dim=-1).long() - zs = [upper_2, upper_1, model.vqvae.encode(waveform, start_level=0, bs_chunks=waveform.shape[0])[0]] - zs = model._sample( - zs, tokens, sample_levels=[2], save_results=False, sample_length=40 * model.priors[2].raw_to_tokens - ) - self.assertTrue(mindnlp.core.ops.allclose(zs[2][0][:40], mindspore.tensor(self.EXPECTED_PRIMED_2))) - - #@slow - def test_vqvae(self): - model = JukeboxModel.from_pretrained(self.model_id, min_duration=0).set_train(False) - set_seed(0) - x = ops.rand((1, 5120, 1)) - - zs = model.vqvae.encode(x, start_level=2, bs_chunks=x.shape[0]) - self.assertTrue(mindnlp.core.ops.allclose(zs[0][0], mindspore.tensor(self.EXPECTED_VQVAE_ENCODE))) - - x = model.vqvae.decode(zs, start_level=2, bs_chunks=x.shape[0]) - self.assertTrue(mindnlp.core.ops.allclose(x[0, :40, 0], mindspore.tensor(self.EXPECTED_VQVAE_DECODE), atol=1e-4, rtol=1e-4)) - - -@require_mindspore -class Jukebox5bModelTester(unittest.TestCase): - all_model_classes = (JukeboxModel,) if is_mindspore_available() else () - model_id = "openai/jukebox-5b-lyrics" - metas = { - "artist": "Zac Brown Band", - "genres": "Country", - "lyrics": """I met a traveller from an antique land, - Who said "Two vast and trunkless legs of stone - Stand in the desert. . . . Near them, on the sand, - Half sunk a shattered visage lies, whose frown, - And wrinkled lip, and sneer of cold command, - Tell that its sculptor well those passions read - Which yet survive, stamped on these lifeless things, - The hand that mocked them, and the heart that fed; - And on the pedestal, these words appear: - My name is Ozymandias, King of Kings; - Look on my Works, ye Mighty, and despair! - Nothing beside remains. Round the decay - Of that colossal Wreck, boundless and bare - The lone and level sands stretch far away - """, - } - - # fmt: off - EXPECTED_OUTPUT_2 = [ - 1489, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, - 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, - 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, - 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, - 1489, 1489, 1489, 1489, 1150, 1853, 1509, 1150, 1357, 1509, 6, 1272 - ] - EXPECTED_OUTPUT_2_PT_2 = [ - 1489, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, - 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, - 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, - 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, - 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653 - ] - - EXPECTED_OUTPUT_1 = [ - 1125, 416, 1125, 1125, 1125, 1125, 1125, 416, 416, 416, 416, 416, - 416, 416, 416, 416, 416, 416, 416, 416, 416, 416, 416, 416, - 416, 416, 416, 416, 416, 416, 416, 416, 416, 416, 416, 416, - 416, 416, 416, 416, 416, 416, 416, 416, 416, 416, 416, 416, - 416, 416, 416, 416, 416, 416, 416, 416, 416, 416, 416, 416 - ] - EXPECTED_OUTPUT_1_PT_2 = [ - 416, 416, 1125, 1125, 416, 416, 416, 416, 416, 416, 416, 416, 416, - 416, 416, 416, 416, 416, 416, 416, 416, 416, 416, 416, 416, 416, - 416, 416, 416, 416, 416, 416, 416, 416, 416, 416, 416, 416, 416, - 416, 416, 416, 416, 416, 416, 416, 416, 416, 416, 416, 416, 416, - 416, 416, 416, 416, 416, 416, 416, 416 - ] - - EXPECTED_OUTPUT_0 = [ - 1755, 1061, 234, 1755, 1061, 1755, 185, 290, 307, 307, 616, 616, - 616, 616, 616, 616, 307, 290, 417, 1755, 234, 1755, 185, 290, - 290, 290, 307, 616, 616, 616, 616, 616, 290, 234, 234, 1755, - 234, 234, 1755, 234, 185, 185, 307, 616, 616, 616, 616, 290, - 1755, 1755, 1755, 234, 234, 1755, 1572, 290, 307, 616, 34, 616 - ] - EXPECTED_OUTPUT_0_PT_2 = [ - 854, 842, 1353, 114, 1353, 842, 185, 842, 185, 114, 591, 842, 185, - 417, 185, 842, 307, 842, 591, 842, 185, 842, 185, 842, 591, 842, - 1353, 842, 185, 842, 591, 842, 591, 114, 591, 842, 185, 842, 591, - 89, 591, 842, 591, 842, 591, 417, 1372, 842, 1372, 842, 34, 842, - 185, 89, 591, 842, 185, 842, 591, 632 - ] - - EXPECTED_GPU_OUTPUTS_2 = [ - 1489, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, - 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, - 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, - 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, - 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653 - ] - EXPECTED_GPU_OUTPUTS_2_PT_2 = [ - 1489, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, - 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, - 653, 653, 653, 653, 653, 653, 653, 1853, 1177, 1536, 1228, - 710, 475, 1489, 1229, 1224, 231, 1224, 252, 1434, 653, 475, - 1106, 1877, 1599, 1228, 1600, 1683, 1182, 1853, 475, 1864, - 252, 1229, 1434, 2001 - ] - - EXPECTED_GPU_OUTPUTS_1 = [ - 1125, 1125, 416, 1125, 1125, 416, 1125, 1125, 416, 416, 1125, 416, - 416, 416, 416, 416, 416, 416, 416, 416, 416, 416, 416, 416, - 416, 416, 416, 416, 416, 416, 416, 416, 416, 416, 416, 416, - 416, 416, 416, 416, 416, 416, 416, 416, 416, 416, 416, 416, - 416, 416, 416, 416, 416, 416, 416, 416, 416, 416, 416, 416 - ] - EXPECTED_GPU_OUTPUTS_0 = [ - 491, 1755, 34, 1613, 1755, 417, 992, 1613, 222, 842, 1353, 1613, - 844, 632, 185, 1613, 844, 632, 185, 1613, 185, 842, 677, 1613, - 185, 114, 1353, 1613, 307, 89, 844, 1613, 307, 1332, 234, 1979, - 307, 89, 1353, 616, 34, 842, 185, 842, 34, 842, 185, 842, - 307, 114, 185, 89, 34, 1268, 185, 89, 34, 842, 185, 89 - ] - # fmt: on - - def prepare_inputs(self, model_id): - tokenizer = JukeboxTokenizer.from_pretrained(model_id) - tokens = tokenizer(**self.metas)["input_ids"] - return tokens - - #@slow - def test_sampling(self): - model = JukeboxModel.from_pretrained(self.model_id, min_duration=0).set_train(False) - labels = self.prepare_inputs(self.model_id) - - set_seed(0) - zs = [ops.zeros((1, 0), dtype=mindspore.int64) for _ in range(3)] - zs = model._sample(zs, labels, [0], sample_length=60 * model.priors[0].raw_to_tokens, save_results=False) - self.assertIn(zs[0][0].detach().tolist(), [self.EXPECTED_OUTPUT_2, self.EXPECTED_OUTPUT_2_PT_2]) - - set_seed(0) - zs = model._sample(zs, labels, [1], sample_length=60 * model.priors[1].raw_to_tokens, save_results=False) - self.assertIn(zs[1][0].detach().tolist(), [self.EXPECTED_OUTPUT_1, self.EXPECTED_OUTPUT_1_PT_2]) - - set_seed(0) - zs = model._sample(zs, labels, [2], sample_length=60 * model.priors[2].raw_to_tokens, save_results=False) - self.assertIn(zs[2][0].detach().tolist(), [self.EXPECTED_OUTPUT_0, self.EXPECTED_OUTPUT_0_PT_2]) - - #@slow - @skip("Not enough GPU memory on CI runners") - def test_slow_sampling(self): - model = JukeboxModel.from_pretrained(self.model_id, min_duration=0).set_train(False) - labels = [i for i in self.prepare_inputs(self.model_id)] - - set_seed(0) - model.priors[0] - zs = [ops.zeros((1, 0), dtype=mindspore.int64) for _ in range(3)] - zs = model._sample(zs, labels, [0], sample_length=60 * model.priors[0].raw_to_tokens, save_results=False) - self.assertTrue(mindnlp.core.ops.allclose(zs[0][0], mindspore.tensor(self.EXPECTED_GPU_OUTPUTS_2))) - model.priors[0] - - set_seed(0) - model.priors[1] - zs = model._sample(zs, labels, [1], sample_length=60 * model.priors[1].raw_to_tokens, save_results=False) - self.assertTrue(mindnlp.core.ops.allclose(zs[1][0], mindspore.tensor(self.EXPECTED_GPU_OUTPUTS_1))) - model.priors[1] - - set_seed(0) - model.priors[2] - zs = model._sample(zs, labels, [2], sample_length=60 * model.priors[2].raw_to_tokens, save_results=False) - self.assertTrue(mindnlp.core.ops.allclose(zs[2][0], mindspore.tensor(self.EXPECTED_GPU_OUTPUTS_0))) - - #@slow - def test_fp16_slow_sampling(self): - prior_id = "ArthurZ/jukebox_prior_0" - model = JukeboxPrior.from_pretrained(prior_id, min_duration=0).set_train(False).half() - - labels = self.prepare_inputs(prior_id)[0] - metadata = model.get_metadata(labels, 0, 7680, 0) - set_seed(0) - outputs = model.sample(1, metadata=metadata, sample_tokens=60) - self.assertIn(outputs[0].tolist(), [self.EXPECTED_GPU_OUTPUTS_2, self.EXPECTED_GPU_OUTPUTS_2_PT_2]) From 1e4aa43f446d4f4070c0ce0c305d707db233c7d4 Mon Sep 17 00:00:00 2001 From: 1hb6s7t <120760709+1hb6s7t@users.noreply.github.com> Date: Sat, 8 Feb 2025 21:26:21 +0800 Subject: [PATCH 15/20] Add files via upload --- ...modeling_jukebox.cpython-39-pytest-7.2.0.pyc | Bin 0 -> 14269 bytes ...nization_jukebox.cpython-39-pytest-7.2.0.pyc | Bin 0 -> 10226 bytes 2 files changed, 0 insertions(+), 0 deletions(-) create mode 100644 tests/transformers/models/jukebox/__pycache__/test_modeling_jukebox.cpython-39-pytest-7.2.0.pyc create mode 100644 tests/transformers/models/jukebox/__pycache__/test_tokenization_jukebox.cpython-39-pytest-7.2.0.pyc diff --git a/tests/transformers/models/jukebox/__pycache__/test_modeling_jukebox.cpython-39-pytest-7.2.0.pyc b/tests/transformers/models/jukebox/__pycache__/test_modeling_jukebox.cpython-39-pytest-7.2.0.pyc new file mode 100644 index 0000000000000000000000000000000000000000..fe6f433cffecd083c033b18b5e49cb73039a8b5b GIT binary patch literal 14269 zcmeHO37A|}m42_buBxu?bay&yV^V|=QzSG=SY(M5m;?+aovp)CMv6+m*RNlvw%qqR zp_^{DgheqZf(xL~4Mc5F7Exp`kWB_qK-?ZPqk_nkh@*p!%Am~u-&b2NiG0I1^Esb( zb)9$bx#ymH@44rkyPQ|4hK8_$KW*cej2li?l$V*Q{qrMp0>0MQ0W?KZ(@H{>Pfy0{ zQB)=4OZZi{B#;Q8#FGwW>JoJl=S>GQp+qPXPJ}b{iF%3ir6ZY!L_?`gV`7RP+NFry zl4nz*2~U5zDbt*2mK1?>OJ-_fYNj>OnwgfErYd^)WJRmfg1Z$hs0Vtd@AB?a6Eh?> zq=kVESFkfRb(0dSFQVs4M@)5m);2RA^E%T_E15B~nw8H9J(=2(GSjK8Y29fS`u08( zs7fKKq;oq_HE8K}($aMeX>TrXflK6+zHR!}+}Ue$nx3xY)(bNyoTgG)XKtIGH3xLj z#Xi*j`H(pQU+ZZAUCK1!(Y=sFtM2PovmQ-N_%#nC>eYOjUkiNRo2WA|@*C7d5YHf< zAv{BPhVcyJS&wHuo)J7FcsAhKfM+9~jd)JMa|)hKcsAkLT*9~D*^K;DJX`Q=#d9j2 z)9`G?bGkN7o4#8~%+O|NGx40M&C+J$IZJEP4#0D^_8x5xo^9G($UEw^mPWsHtCUTr zZrQpRRR(6}@_II99@gs$?$D)M4^8(Av&(w3F_G$uen8}QW}_cSWi_X6MXoPvi~gT| z)uSk@qZ!?frlPh;?aF zvQROrp=w`tTUxiQXj(U{Xs$bI*}1GPt8B7KVP>Otj~>-@OBZ%~)cthmDM55*aWvJvN69r|JnHkHYvNp}#al{UL|DGs~G%o>*4yH1S1hq90jW^!HIP{kd+i$yU6 zV!P$tx^|pwkAo^n2W?=kQ|ZO5hGur=gl0uk`8=u}D~Z?kN3*Gn9yP7#x`BQU)J#EA zA3`rE0X{94?V4O}8~JAXqo?J>HW2me(Y2=0WB0paLsR*bDGro;J92U)(XF~=YC43G zNts!zJ-QKkBnN?+?Mn4a+I8LT2q5m9Wu?;5(}do&ZEIcP=hO)@H zO6yQTXc(Laq$+e9qV9&0q;{5=k9rdU$jG$pM8MFqLbnnDSIJ`wiyy30l%f()6!QVt zzuCd;T6kE|0w-YBLD$W^7hn-^<}{{`1zmAE3;qq+;$9YPVBKDVCrAP>tQ4bc3l1wMb2n#H-dYq{+Ie!@aGlxj`7F)Xwsp8W} zVI0yZF9slioC|Hf08lNUJ&r%U&A|BxSgObca%gZ; zs<nt=cX8ENMO!1eH zL($?qzD4Q8NhHDXOufGhipPVbnw>PYoWum?Nt}>Q%Im~3PS!Ag1zEee3TKy%NpVoW({`j zz2w5I3s?;!xr!V&u$xJgn|lc^Lv6E*I-X&{)10gUf@9EtnP>Btu;45*<9wULB#wYY ze2BQU0LANA;04ZH%9hs=mm=rG$>sNK=uW1NB*?HEi%A?qN_4R9nViavOnsjP_mXZK zaK*=f6LVP5PJSOlUt$Z5JqurNcyP&R!FcFb*DYWC!p#Naz}rR76|aA#V7xW@+vnGA zy}e*4xeI)ced3OS@spp{Upaaq5@zl<7d_dD#3we{^FRAGXwG`&*?BMi>DGdAO2o71 zlIdW$=6xSM@vK*d3$IT5_$j~i9dSjO`22!#_neDf+i>@}1>@3-65qT3WxHUU(|YU4 zKO4~EMzZcZvo<)F#f_n7?>yu8_goV<_I8{wHTB4iapTB;KYG>4Vl-~d@}1gv=-0j) zH$MBxDFa8{aw~{$y=&`vKL+L#KmU)p&*yH78<(YD{jbsAel2cnT>XXf7kulkxN*Q> zYT4!`_r{H5KlRjkA1pi&H@1J}vKM=lLfp8}I_awa3?Ol7*GK;OB=19UPv2eDz1k z9p8-`z=v!yWhX7V1(MPJ2UpwCkw`tJ084#_F-R$8<|rnquUC`8<%s+koW~FHGaHcNH(9o zs$l#IOg+f^D%;{dg+PJ-S?T{vJ}rLlxl4(V?G==PXF?e z&m7lrN5S~xCU*DsxDkQcZdkpiV4QLB(LZ=Bb5nWBua6rKK0IT=CjXsr(FxNq?kLa< zZYmgxqJK+)vi+`E2%61*7A+E4KV)#k~dNPfLGs>%l+2vtYciNT2o6>0g2zq?;GV z&^V7JIF5j>zeq<{Tug8naV#w!Ot64pE&&%vv4wy&M1tVM0L25DsuUEt;uWLBNjh0@ zDzj%2$aZBldJsv{1s75IgC9}gc$5|RTJr&HWmp|ldOaiRkUFS#V>Lt0dy{&(s;RS- zA~{h(X^99pNbu%aD~{c=8HY@3%d#VnS#rddmAbXf&gHl8&LNx5ADY3LRTo=q z9Hgu*Xew)U=R}6|vN>x@>GUiqk`jkQQ?i6@&-Xix=wlwIm!uqmbtQ)mAFC*8L~T_E z4w~$A-afX@7#UK2@VKrF=Rmr)(ko@CshVexXV|NGr8Jdc-v}gV`!#i!ipv{ZTkKZs zfEL)Lu2goZL*7BPw{Floh^q}l)#{K7Qs%v(Rt1+F!99LZD8u1FFR}a%*N-T}krB>N z1HO%hX9Vk9nSX^_sKPBYDK}upahn2eP5a;$u5b%a$_?0Y+?v6y#pR|cym0D}`=n7^ z#9&gBTAxVSIHI34MyOcUcn}0VX6FC^1H=4C>yS#}YKraYg&6jDuJCO4Q6XcVBGp(FeTkzctLi6uSRuSTjRPuf8uG_; z(S8G8W#Fhu^@4hsv~YcphL*K2Pv^Q)Y3q0-$_$D$F=>Zru0c}j$+Vs|>>ej#;l?J3 zGjLzpwnQ3)MUH!PstB^uR)Q`7C&cSDX;%W z6G)d%Bwe}>(j^l~mq=2~k1huyt<(wNmQhbzj%T38AGj0JFh7_1v^9FeAk8{g1H9#Bt_rrty&2ao2#z+l~o zXNz|zI20NRqfU!GwYRl*TJQ8h={VQ|>V{?A86%24b9fd^arTI+)#DS{<14jQtrwDY zCa>4FpL$`qI@wY;`&n)4fU$L?`8T-cFM1*GcVY8l8|sS;L7t$pf=G=K7I3!{&x63g zvHRACt{m>z=zsQMzoHKeVjjnji#uUEUOlUc_W@Ppq9>R1SKaO3?D(iB;Y-1`5E^jTyw_8 z)hi@2RxfQ|e2i>)J`^7ZNMLJ_#~uQHOkB=2<)u)*`i7wAzVp_R$ zEIK0Z7)#O}rz=jg^e(lEa0}YD76QP-z^}l=c*3d=-exAA^E@rsDa?O6=qkAQX0e5!uLzEmHw~d)`V;@4r?+0(Z(xtRMS%4i z-XR}00+B%esGK)T*WY%I8~@PXSDyQ#Oi*FW4ch}PUC92Q+i-(gQ3ZiU~N zHlmJTTgZOE!$>OhXoiNUlAA;8^|O?j%7~}iBmIkKcqTSH^nPlu+sDwvK91=jw<_fx zaR0h?{9#k%)yzz+ZBnPi{e)}qK5Qy9$H)DFbXAUj$Mzj5Y%cU{7q;_ogFUIdE{0fv zzDt}(z!h0sLvSs@=LzU5#1{Z+HV^AJu3n4n#uCTdm9j;ag+6#QVh~%$BbyKz`<;mg`4Yd52uKB8LN1G^8qwQ+#($Tb`muc_T$SdPo11uJ+EpOCv-ka`=g zUBShT7>3kUaT8PW#CZi%p8|-D-^#j+U`5}=7fJbLf>DB-3HGl|(<&>>sT)o`aaD3v z$BK0;S8;PI6?A;@%2h1JA(dNAx!gGF*-~A`D@Rx=hgA2Uf!1mSD5->Jrn&&%fw}vh zc3H0@c7PL1CK#|!S4PDFjUbvE^bG)3g76fE@2wP&^kpP<%f&KE+r3kj8zK z##Dj_0E*HrtU~JVP+IRoF(9or$}mbGQQ~R)zm{{$1#q}*q#>8_WZ4T`TH>(^J=VD^6ewR`$jPXp!gz{o$Ffh z8LnpECU}*lj}rG5Q+#E}UFyGul(`Wk=H@!!PGSLBnI}Mx%qt15L#beEg2bYk;BkUS z2*}EO4t2|3elk}dCFNwktV%3N{(eAgx%nFBN!sy45KnO}WbJ0D!RAk~2NzGU;9mi1 zES5O=f|7WcDXF*n#8tG~+zW-4{M;H;^<-41lWYBD#hT!wK2FcyY6=!gX3y6 z`N0|oUR-v`=;lA-aHTlh|G`E4nV1mwBEB3%8#}RMqC1lX(c~q3aXHmx2SJ*kpJ0IC zqXgsBif7$3s8;m0JjO@%7bx0Ke+CZ1%d=5Eo9i=rq9?E4jJK^bInmE|Z&$32;>GDK zg3tTD<S<4U-x!EI!)Oj!yPhsuFs zd9%|n+*orjG-bF6>fc;*FH~xyCTJYc5W+=-3E^ki1_Qos8`XgCWNnlJzqZ>3?v31= zPT4!jaZDSyDXwXwzS0Kp`xysHDU(tgQ_F40Td7Fxt<;$LpmT$_cVo#sjLTSZkS{p6 z@#CuQ#5`g<2prX{;;I3qY(?WN<=Y2?c&$V8;>8XRqcOu?zSJSD7)zvvcnNN0J;Q!j9d2ti4dB7O<@#*AEHojiKSR!HcYf(nN&bweVl=xr zweIaJuHHS3Y7-)GP3pkneNW>=CLOUE;x6|8n*?_g&e-Be~Tf%+HU%6+c0K{_y zPZK;tAgx7Sr_#BI?+`psP+f&&O73v(MZxR%${@p->(ptuNDbC}Lr8~kk=hba!!rcy z#b!Cdt$k+N#?LjJ$O-xWWF$IoYM-3e7t4q_%QE{w`j;3?q* z`?4l}k%JfyyPs$)MSk1+Y%^`Ovw-hR$($=S?g<69s!F1%Kyy8t;?O6Pr4wB4Ua23?n^kKz cz&xz%t^NpJ1PMS*@CujLqqd%>to5k>4V)s=#PQ^!l`W%NN9nI<_7@+Btc-5%8Ilad&c(Q*`4Li zY+Of)R0*E@7xW>iDph&q59lAVuT>wW5B&pLRqZ*SvFA90<7RoR6JOtZ&+qR!_s;Cm zhR2T0dGfRN@t-%B7d`KJObhbaYI_G=udeKxg{iPR8$DPlf_@cc!ANikn3!PH5de;{G@l)@Qw&S(z zw=3CpJVW0XcP6~Wxf>_MeO1zxRvDLrZ|_x`C_oMmF2NIzB4dSFNnb%m#ABj@C_Gn zG#|tgqxiR;rI8H%{zJxA1OssEq$##XYv z73>O>`N-W$ZpDiNK-eFO=_)9ZOp}cmh>ERbu$h~uD}u?E;)CISw!ST56(ZHHkOico zqHn~}o3&jHat}4JCD{(sMHLluJDH2}ARG=w^o?5J>TWOy`*D!u!S&m_8hjE8f**)S zii-ZtP5p;iwypa6yTOgjZ42XW99&H{w~E~gPBA$Q6Zb-`|5`?L!CIUrQ7j0GNuWwXQNjkDT57Xd=9FOhAU`_c!OCeYboz;@Ul}d4u&oq{@m5P*; zC5XGYkTh&aL4`X9j4ZUr9lW+V}v*|^hKl+>g zeSdE?bJ%LLeRukfcW>rS>t6Scob!|3ooOBKx9)35qO`qp2k!AW7Z}sgYnODYk-a7!NL7shO9Tm+QGxRIWYn$L(yG-+op(!{p`9 zs;h13%-T`~-gq_{3`a#TiSn2JE_VrHHYEP{JTLi|=qhJLU-_X9KhxodIxNfJj_K_A z{h518mvVo5?rEK!*4dLf`>D=O>@VH7bcSr8GhLPoIyu^o?(EPuLQVo?as>FBq#mXg}q4`;z)j^l<%Cc0upJ<0@(L! zmdAjEV9-*dYZy2nK{Kl0(<(WT8A8P_4lyHMWiEeR`=S+AIey5jq(G3xjk=I3{LCbL zQonnuEb>SC7btThHWW+*Q@7SadKy`%Q|o?QyM{?i6d|w&hzy1mGbCH zD|8~VQX!Z+GbQdRM^ih6)B z3_W`>3;B*2fe3d=Vv zBy$ZLEC~?x7M8^U)j$LYf(CJpUjq`8g@A+sd$ctq%r%xskTP?_Y&85cU^STXq6}`L zy5hEIpmB7Pako($I8LJQ6er2F0bwB+vxUzY#4eGO8T4TdeV8=6HB9A&NrNs?x};*v z2p@eU&%B}%Yd1Rxxt63WmPaqYRh?* zKs|#!Qd#0N9uNl+vE-(Kg;XGh2X!!2_y*HyHH6O`SWX$~MyZK4u)-RdMin;5FMQ}z z56Vlbev-%?@5O{*RoB2&jhDD)#$hps@DB`Nv2>d%e6HWaN|>>0Z!+jZmHA@OnKkYg zB43&~-ZLs;HDrd+#}W^)fqxuMW`w{1GX$8a0}J2oKTGIqYWJ{s(PF@&9;Mi@c z@w7C~LTMxv@gUFKcux94($!jVqj=m6({x?>8S#V8cq)(64fm$%QDx)VV!t&gqB_l2 zpS=8=k1k(Yx%_tT`ll-&eY*0%bMFZ2Kch=;-27CO<~LtC_xkCxH{Xu)?IIiA-1Bg$ zFWtA;-PDit`AuE@){lJt|5&ZaaIwSy8|xDu?5iXh5@K~_k^@0N69_S-U=IN=L(*^<_rcDLkD7=^<^ zdx068@4X`()FR$==OV4d<|xa03=(;WJ#QSWJQtRQQl>98Q=ipUH7KnIN*;Y=(8{M#@)oMap^v1h zb%T?Ql(9z~R_KNw)W-Q}yziMwBT!8Y4QrDF!9{^XM8tqsR=}2h2!I2Xuq;6QqomLR zF7Oec9Sv|k+T>x`M<2dmmjPd323>OqYuG>n5GOh~cI9G&*eFcm<)shx1ZWr#KE~}V z*ki{E9Z!+PKXOTcD7BnhY}i1;E;6(r0o7`flLCP~W-uE=e7PtN{Cb#+Q58fYAy zWZZ4k29A?UJjF>eZ9rHE#%$qp2C+-z1Y@;c^~Q6(o-|}esm|wnz0XHsT2b~oOLa%6x1LHD$-Sj+ zw{_t2P7Nx3uo^jtnoh=A|3;Ur07^ AM*si- literal 0 HcmV?d00001 From 3cc22d95036b3ab5e39e648183cdcd74bd645b57 Mon Sep 17 00:00:00 2001 From: 1hb6s7t <120760709+1hb6s7t@users.noreply.github.com> Date: Fri, 14 Feb 2025 16:42:04 +0800 Subject: [PATCH 16/20] Delete mindnlp/transformers/models/jukebox directory --- .../transformers/models/jukebox/__init__.py | 0 .../__pycache__/__init__.cpython-39.pyc | Bin 174 -> 0 bytes ...deling_jukebox.cpython-39-pytest-7.2.0.pyc | Bin 14269 -> 0 bytes ...zation_jukebox.cpython-39-pytest-7.2.0.pyc | Bin 10226 -> 0 bytes .../models/jukebox/configuration_jukebox.py | 618 ---- .../models/jukebox/modeling_jukebox.py | 2591 ----------------- .../models/jukebox/tokenization_jukebox.py | 342 --- 7 files changed, 3551 deletions(-) delete mode 100644 mindnlp/transformers/models/jukebox/__init__.py delete mode 100644 mindnlp/transformers/models/jukebox/__pycache__/__init__.cpython-39.pyc delete mode 100644 mindnlp/transformers/models/jukebox/__pycache__/test_modeling_jukebox.cpython-39-pytest-7.2.0.pyc delete mode 100644 mindnlp/transformers/models/jukebox/__pycache__/test_tokenization_jukebox.cpython-39-pytest-7.2.0.pyc delete mode 100644 mindnlp/transformers/models/jukebox/configuration_jukebox.py delete mode 100644 mindnlp/transformers/models/jukebox/modeling_jukebox.py delete mode 100644 mindnlp/transformers/models/jukebox/tokenization_jukebox.py diff --git a/mindnlp/transformers/models/jukebox/__init__.py b/mindnlp/transformers/models/jukebox/__init__.py deleted file mode 100644 index e69de29bb..000000000 diff --git a/mindnlp/transformers/models/jukebox/__pycache__/__init__.cpython-39.pyc b/mindnlp/transformers/models/jukebox/__pycache__/__init__.cpython-39.pyc deleted file mode 100644 index 825224ba96f877394ee5f56cd9d3a76e2d04b4d5..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 174 zcmYe~<>g`k0)_1nX(0MBh(HF6K#l_t7qb9~6oz01O-8?!3`HPe1o11_*(xTqIJKxa z#>mvtz$C^cwK%&ZzaS@7o0MQ0W?KZ(@H{>Pfy0{ zQB)=4OZZi{B#;Q8#FGwW>JoJl=S>GQp+qPXPJ}b{iF%3ir6ZY!L_?`gV`7RP+NFry zl4nz*2~U5zDbt*2mK1?>OJ-_fYNj>OnwgfErYd^)WJRmfg1Z$hs0Vtd@AB?a6Eh?> zq=kVESFkfRb(0dSFQVs4M@)5m);2RA^E%T_E15B~nw8H9J(=2(GSjK8Y29fS`u08( zs7fKKq;oq_HE8K}($aMeX>TrXflK6+zHR!}+}Ue$nx3xY)(bNyoTgG)XKtIGH3xLj z#Xi*j`H(pQU+ZZAUCK1!(Y=sFtM2PovmQ-N_%#nC>eYOjUkiNRo2WA|@*C7d5YHf< zAv{BPhVcyJS&wHuo)J7FcsAhKfM+9~jd)JMa|)hKcsAkLT*9~D*^K;DJX`Q=#d9j2 z)9`G?bGkN7o4#8~%+O|NGx40M&C+J$IZJEP4#0D^_8x5xo^9G($UEw^mPWsHtCUTr zZrQpRRR(6}@_II99@gs$?$D)M4^8(Av&(w3F_G$uen8}QW}_cSWi_X6MXoPvi~gT| z)uSk@qZ!?frlPh;?aF zvQROrp=w`tTUxiQXj(U{Xs$bI*}1GPt8B7KVP>Otj~>-@OBZ%~)cthmDM55*aWvJvN69r|JnHkHYvNp}#al{UL|DGs~G%o>*4yH1S1hq90jW^!HIP{kd+i$yU6 zV!P$tx^|pwkAo^n2W?=kQ|ZO5hGur=gl0uk`8=u}D~Z?kN3*Gn9yP7#x`BQU)J#EA zA3`rE0X{94?V4O}8~JAXqo?J>HW2me(Y2=0WB0paLsR*bDGro;J92U)(XF~=YC43G zNts!zJ-QKkBnN?+?Mn4a+I8LT2q5m9Wu?;5(}do&ZEIcP=hO)@H zO6yQTXc(Laq$+e9qV9&0q;{5=k9rdU$jG$pM8MFqLbnnDSIJ`wiyy30l%f()6!QVt zzuCd;T6kE|0w-YBLD$W^7hn-^<}{{`1zmAE3;qq+;$9YPVBKDVCrAP>tQ4bc3l1wMb2n#H-dYq{+Ie!@aGlxj`7F)Xwsp8W} zVI0yZF9slioC|Hf08lNUJ&r%U&A|BxSgObca%gZ; zs<nt=cX8ENMO!1eH zL($?qzD4Q8NhHDXOufGhipPVbnw>PYoWum?Nt}>Q%Im~3PS!Ag1zEee3TKy%NpVoW({`j zz2w5I3s?;!xr!V&u$xJgn|lc^Lv6E*I-X&{)10gUf@9EtnP>Btu;45*<9wULB#wYY ze2BQU0LANA;04ZH%9hs=mm=rG$>sNK=uW1NB*?HEi%A?qN_4R9nViavOnsjP_mXZK zaK*=f6LVP5PJSOlUt$Z5JqurNcyP&R!FcFb*DYWC!p#Naz}rR76|aA#V7xW@+vnGA zy}e*4xeI)ced3OS@spp{Upaaq5@zl<7d_dD#3we{^FRAGXwG`&*?BMi>DGdAO2o71 zlIdW$=6xSM@vK*d3$IT5_$j~i9dSjO`22!#_neDf+i>@}1>@3-65qT3WxHUU(|YU4 zKO4~EMzZcZvo<)F#f_n7?>yu8_goV<_I8{wHTB4iapTB;KYG>4Vl-~d@}1gv=-0j) zH$MBxDFa8{aw~{$y=&`vKL+L#KmU)p&*yH78<(YD{jbsAel2cnT>XXf7kulkxN*Q> zYT4!`_r{H5KlRjkA1pi&H@1J}vKM=lLfp8}I_awa3?Ol7*GK;OB=19UPv2eDz1k z9p8-`z=v!yWhX7V1(MPJ2UpwCkw`tJ084#_F-R$8<|rnquUC`8<%s+koW~FHGaHcNH(9o zs$l#IOg+f^D%;{dg+PJ-S?T{vJ}rLlxl4(V?G==PXF?e z&m7lrN5S~xCU*DsxDkQcZdkpiV4QLB(LZ=Bb5nWBua6rKK0IT=CjXsr(FxNq?kLa< zZYmgxqJK+)vi+`E2%61*7A+E4KV)#k~dNPfLGs>%l+2vtYciNT2o6>0g2zq?;GV z&^V7JIF5j>zeq<{Tug8naV#w!Ot64pE&&%vv4wy&M1tVM0L25DsuUEt;uWLBNjh0@ zDzj%2$aZBldJsv{1s75IgC9}gc$5|RTJr&HWmp|ldOaiRkUFS#V>Lt0dy{&(s;RS- zA~{h(X^99pNbu%aD~{c=8HY@3%d#VnS#rddmAbXf&gHl8&LNx5ADY3LRTo=q z9Hgu*Xew)U=R}6|vN>x@>GUiqk`jkQQ?i6@&-Xix=wlwIm!uqmbtQ)mAFC*8L~T_E z4w~$A-afX@7#UK2@VKrF=Rmr)(ko@CshVexXV|NGr8Jdc-v}gV`!#i!ipv{ZTkKZs zfEL)Lu2goZL*7BPw{Floh^q}l)#{K7Qs%v(Rt1+F!99LZD8u1FFR}a%*N-T}krB>N z1HO%hX9Vk9nSX^_sKPBYDK}upahn2eP5a;$u5b%a$_?0Y+?v6y#pR|cym0D}`=n7^ z#9&gBTAxVSIHI34MyOcUcn}0VX6FC^1H=4C>yS#}YKraYg&6jDuJCO4Q6XcVBGp(FeTkzctLi6uSRuSTjRPuf8uG_; z(S8G8W#Fhu^@4hsv~YcphL*K2Pv^Q)Y3q0-$_$D$F=>Zru0c}j$+Vs|>>ej#;l?J3 zGjLzpwnQ3)MUH!PstB^uR)Q`7C&cSDX;%W z6G)d%Bwe}>(j^l~mq=2~k1huyt<(wNmQhbzj%T38AGj0JFh7_1v^9FeAk8{g1H9#Bt_rrty&2ao2#z+l~o zXNz|zI20NRqfU!GwYRl*TJQ8h={VQ|>V{?A86%24b9fd^arTI+)#DS{<14jQtrwDY zCa>4FpL$`qI@wY;`&n)4fU$L?`8T-cFM1*GcVY8l8|sS;L7t$pf=G=K7I3!{&x63g zvHRACt{m>z=zsQMzoHKeVjjnji#uUEUOlUc_W@Ppq9>R1SKaO3?D(iB;Y-1`5E^jTyw_8 z)hi@2RxfQ|e2i>)J`^7ZNMLJ_#~uQHOkB=2<)u)*`i7wAzVp_R$ zEIK0Z7)#O}rz=jg^e(lEa0}YD76QP-z^}l=c*3d=-exAA^E@rsDa?O6=qkAQX0e5!uLzEmHw~d)`V;@4r?+0(Z(xtRMS%4i z-XR}00+B%esGK)T*WY%I8~@PXSDyQ#Oi*FW4ch}PUC92Q+i-(gQ3ZiU~N zHlmJTTgZOE!$>OhXoiNUlAA;8^|O?j%7~}iBmIkKcqTSH^nPlu+sDwvK91=jw<_fx zaR0h?{9#k%)yzz+ZBnPi{e)}qK5Qy9$H)DFbXAUj$Mzj5Y%cU{7q;_ogFUIdE{0fv zzDt}(z!h0sLvSs@=LzU5#1{Z+HV^AJu3n4n#uCTdm9j;ag+6#QVh~%$BbyKz`<;mg`4Yd52uKB8LN1G^8qwQ+#($Tb`muc_T$SdPo11uJ+EpOCv-ka`=g zUBShT7>3kUaT8PW#CZi%p8|-D-^#j+U`5}=7fJbLf>DB-3HGl|(<&>>sT)o`aaD3v z$BK0;S8;PI6?A;@%2h1JA(dNAx!gGF*-~A`D@Rx=hgA2Uf!1mSD5->Jrn&&%fw}vh zc3H0@c7PL1CK#|!S4PDFjUbvE^bG)3g76fE@2wP&^kpP<%f&KE+r3kj8zK z##Dj_0E*HrtU~JVP+IRoF(9or$}mbGQQ~R)zm{{$1#q}*q#>8_WZ4T`TH>(^J=VD^6ewR`$jPXp!gz{o$Ffh z8LnpECU}*lj}rG5Q+#E}UFyGul(`Wk=H@!!PGSLBnI}Mx%qt15L#beEg2bYk;BkUS z2*}EO4t2|3elk}dCFNwktV%3N{(eAgx%nFBN!sy45KnO}WbJ0D!RAk~2NzGU;9mi1 zES5O=f|7WcDXF*n#8tG~+zW-4{M;H;^<-41lWYBD#hT!wK2FcyY6=!gX3y6 z`N0|oUR-v`=;lA-aHTlh|G`E4nV1mwBEB3%8#}RMqC1lX(c~q3aXHmx2SJ*kpJ0IC zqXgsBif7$3s8;m0JjO@%7bx0Ke+CZ1%d=5Eo9i=rq9?E4jJK^bInmE|Z&$32;>GDK zg3tTD<S<4U-x!EI!)Oj!yPhsuFs zd9%|n+*orjG-bF6>fc;*FH~xyCTJYc5W+=-3E^ki1_Qos8`XgCWNnlJzqZ>3?v31= zPT4!jaZDSyDXwXwzS0Kp`xysHDU(tgQ_F40Td7Fxt<;$LpmT$_cVo#sjLTSZkS{p6 z@#CuQ#5`g<2prX{;;I3qY(?WN<=Y2?c&$V8;>8XRqcOu?zSJSD7)zvvcnNN0J;Q!j9d2ti4dB7O<@#*AEHojiKSR!HcYf(nN&bweVl=xr zweIaJuHHS3Y7-)GP3pkneNW>=CLOUE;x6|8n*?_g&e-Be~Tf%+HU%6+c0K{_y zPZK;tAgx7Sr_#BI?+`psP+f&&O73v(MZxR%${@p->(ptuNDbC}Lr8~kk=hba!!rcy z#b!Cdt$k+N#?LjJ$O-xWWF$IoYM-3e7t4q_%QE{w`j;3?q* z`?4l}k%JfyyPs$)MSk1+Y%^`Ovw-hR$($=S?g<69s!F1%Kyy8t;?O6Pr4wB4Ua23?n^kKz cz&xz%t^NpJ1PMS*@CujLqqd%>to5k>4V)s=#PQ^!l`W%NN9nI<_7@+Btc-5%8Ilad&c(Q*`4Li zY+Of)R0*E@7xW>iDph&q59lAVuT>wW5B&pLRqZ*SvFA90<7RoR6JOtZ&+qR!_s;Cm zhR2T0dGfRN@t-%B7d`KJObhbaYI_G=udeKxg{iPR8$DPlf_@cc!ANikn3!PH5de;{G@l)@Qw&S(z zw=3CpJVW0XcP6~Wxf>_MeO1zxRvDLrZ|_x`C_oMmF2NIzB4dSFNnb%m#ABj@C_Gn zG#|tgqxiR;rI8H%{zJxA1OssEq$##XYv z73>O>`N-W$ZpDiNK-eFO=_)9ZOp}cmh>ERbu$h~uD}u?E;)CISw!ST56(ZHHkOico zqHn~}o3&jHat}4JCD{(sMHLluJDH2}ARG=w^o?5J>TWOy`*D!u!S&m_8hjE8f**)S zii-ZtP5p;iwypa6yTOgjZ42XW99&H{w~E~gPBA$Q6Zb-`|5`?L!CIUrQ7j0GNuWwXQNjkDT57Xd=9FOhAU`_c!OCeYboz;@Ul}d4u&oq{@m5P*; zC5XGYkTh&aL4`X9j4ZUr9lW+V}v*|^hKl+>g zeSdE?bJ%LLeRukfcW>rS>t6Scob!|3ooOBKx9)35qO`qp2k!AW7Z}sgYnODYk-a7!NL7shO9Tm+QGxRIWYn$L(yG-+op(!{p`9 zs;h13%-T`~-gq_{3`a#TiSn2JE_VrHHYEP{JTLi|=qhJLU-_X9KhxodIxNfJj_K_A z{h518mvVo5?rEK!*4dLf`>D=O>@VH7bcSr8GhLPoIyu^o?(EPuLQVo?as>FBq#mXg}q4`;z)j^l<%Cc0upJ<0@(L! zmdAjEV9-*dYZy2nK{Kl0(<(WT8A8P_4lyHMWiEeR`=S+AIey5jq(G3xjk=I3{LCbL zQonnuEb>SC7btThHWW+*Q@7SadKy`%Q|o?QyM{?i6d|w&hzy1mGbCH zD|8~VQX!Z+GbQdRM^ih6)B z3_W`>3;B*2fe3d=Vv zBy$ZLEC~?x7M8^U)j$LYf(CJpUjq`8g@A+sd$ctq%r%xskTP?_Y&85cU^STXq6}`L zy5hEIpmB7Pako($I8LJQ6er2F0bwB+vxUzY#4eGO8T4TdeV8=6HB9A&NrNs?x};*v z2p@eU&%B}%Yd1Rxxt63WmPaqYRh?* zKs|#!Qd#0N9uNl+vE-(Kg;XGh2X!!2_y*HyHH6O`SWX$~MyZK4u)-RdMin;5FMQ}z z56Vlbev-%?@5O{*RoB2&jhDD)#$hps@DB`Nv2>d%e6HWaN|>>0Z!+jZmHA@OnKkYg zB43&~-ZLs;HDrd+#}W^)fqxuMW`w{1GX$8a0}J2oKTGIqYWJ{s(PF@&9;Mi@c z@w7C~LTMxv@gUFKcux94($!jVqj=m6({x?>8S#V8cq)(64fm$%QDx)VV!t&gqB_l2 zpS=8=k1k(Yx%_tT`ll-&eY*0%bMFZ2Kch=;-27CO<~LtC_xkCxH{Xu)?IIiA-1Bg$ zFWtA;-PDit`AuE@){lJt|5&ZaaIwSy8|xDu?5iXh5@K~_k^@0N69_S-U=IN=L(*^<_rcDLkD7=^<^ zdx068@4X`()FR$==OV4d<|xa03=(;WJ#QSWJQtRQQl>98Q=ipUH7KnIN*;Y=(8{M#@)oMap^v1h zb%T?Ql(9z~R_KNw)W-Q}yziMwBT!8Y4QrDF!9{^XM8tqsR=}2h2!I2Xuq;6QqomLR zF7Oec9Sv|k+T>x`M<2dmmjPd323>OqYuG>n5GOh~cI9G&*eFcm<)shx1ZWr#KE~}V z*ki{E9Z!+PKXOTcD7BnhY}i1;E;6(r0o7`flLCP~W-uE=e7PtN{Cb#+Q58fYAy zWZZ4k29A?UJjF>eZ9rHE#%$qp2C+-z1Y@;c^~Q6(o-|}esm|wnz0XHsT2b~oOLa%6x1LHD$-Sj+ zw{_t2P7Nx3uo^jtnoh=A|3;Ur07^ AM*si- diff --git a/mindnlp/transformers/models/jukebox/configuration_jukebox.py b/mindnlp/transformers/models/jukebox/configuration_jukebox.py deleted file mode 100644 index 6f981cd65..000000000 --- a/mindnlp/transformers/models/jukebox/configuration_jukebox.py +++ /dev/null @@ -1,618 +0,0 @@ -# coding=utf-8 -# Copyright 2022 The OpenAI Team Authors and HuggingFace Inc. team. -# -# 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. -"""Jukebox configuration""" - -import os -from typing import List, Union - -from mindnlp.utils import logging -from ...configuration_utils import PretrainedConfig - -logger = logging.get_logger(__name__) - - -_LARGE_ATTENTION = [ - "block_attn", - "transpose_block_attn", - "prev_block_attn", - "block_attn", - "transpose_block_attn", - "prev_block_attn", - "block_attn", - "transpose_block_attn", - "prev_block_attn", - "block_attn", - "transpose_block_attn", - "prev_block_attn", - "block_attn", - "transpose_block_attn", - "prev_block_attn", - "block_attn", - "transpose_block_attn", - "prev_block_attn", - "cross_attention", - "block_attn", - "transpose_block_attn", - "prev_block_attn", - "block_attn", - "transpose_block_attn", - "prev_block_attn", - "block_attn", - "transpose_block_attn", - "prev_block_attn", - "cross_attention", - "block_attn", - "transpose_block_attn", - "prev_block_attn", - "block_attn", - "transpose_block_attn", - "prev_block_attn", - "block_attn", - "transpose_block_attn", - "prev_block_attn", - "cross_attention", - "block_attn", - "transpose_block_attn", - "prev_block_attn", - "block_attn", - "transpose_block_attn", - "prev_block_attn", - "block_attn", - "transpose_block_attn", - "prev_block_attn", - "cross_attention", - "block_attn", - "transpose_block_attn", - "prev_block_attn", - "block_attn", - "transpose_block_attn", - "prev_block_attn", - "block_attn", - "transpose_block_attn", - "prev_block_attn", - "cross_attention", - "block_attn", - "transpose_block_attn", - "prev_block_attn", - "block_attn", - "transpose_block_attn", - "prev_block_attn", - "block_attn", - "transpose_block_attn", - "prev_block_attn", - "cross_attention", - "block_attn", - "transpose_block_attn", - "prev_block_attn", - "block_attn", - "transpose_block_attn", - "prev_block_attn", - "block_attn", - "transpose_block_attn", - "prev_block_attn", - "cross_attention", -] -_RawColumnPreviousRowAttention = ["block_attn", "transpose_block_attn", "prev_block_attn"] -_FullDenseAttention = ["dense_attention"] -_PrimePrimeDenseAttention = ["prime_attn", "prime_attn", "dense_attn"] - - -def full_dense_attention(layer): - return _FullDenseAttention[0] - - -def raw_column_previous_row_attention(layer): - return _RawColumnPreviousRowAttention[layer % 3] - - -def large_separated_enc_dec_w_lyrics(layer): - return _LARGE_ATTENTION[layer % 79] - - -def enc_dec_with_lyrics(layer): - if layer % 16 == 15: - return _PrimePrimeDenseAttention[layer % 3] - return _RawColumnPreviousRowAttention[layer % 3] - - -ATTENTION_PATTERNS = { - "full_dense_attention": full_dense_attention, - "raw_column_previous_row_attention": raw_column_previous_row_attention, # Alternate row, column and previous row attn - "large_separated_enc_dec_w_lyrics": large_separated_enc_dec_w_lyrics, # Used by large separated_enc_dec model with lyrics - "enc_dec_with_lyrics": enc_dec_with_lyrics, # Used by encoder_decoder model with lyrics -} - - -class JukeboxPriorConfig(PretrainedConfig): - """ - This is the configuration class to store the configuration of a [`JukeboxPrior`]. It is used to instantiate a - `JukeboxPrior` according to the specified arguments, defining the model architecture. Instantiating a - configuration with the defaults will yield a similar configuration to that of the top level prior from the - [openai/jukebox-1b-lyrics](https://huggingface.co/openai/jukebox - -1b-lyrics) architecture. - - Configuration objects inherit from [`PretrainedConfig`] and can be used to control the model outputs. Read the - documentation from [`PretrainedConfig`] for more information. - - - - Args: - act_fn (`str`, *optional*, defaults to `"quick_gelu"`): - Activation function. - alignment_head (`int`, *optional*, defaults to 2): - Head that is responsible of the alignment between lyrics and music. Only used to compute the lyric to audio - alignment - alignment_layer (`int`, *optional*, defaults to 68): - Index of the layer that is responsible of the alignment between lyrics and music. Only used to compute the - lyric to audio alignment - attention_multiplier (`float`, *optional*, defaults to 0.25): - Multiplier coefficient used to define the hidden dimension of the attention layers. 0.25 means that - 0.25*width of the model will be used. - attention_pattern (`str`, *optional*, defaults to `"enc_dec_with_lyrics"`): - Which attention pattern to use for the decoder/ - attn_dropout (`int`, *optional*, defaults to 0): - Dropout probability for the post-attention layer dropout in the decoder. - attn_res_scale (`bool`, *optional*, defaults to `False`): - Whether or not to scale the residuals in the attention conditioner block. - blocks (`int`, *optional*, defaults to 64): - Number of blocks used in the `block_attn`. A sequence of length seq_len is factored as `[blocks, seq_len // - blocks]` in the `JukeboxAttention` layer. - conv_res_scale (`int`, *optional*): - Whether or not to scale the residuals in the conditioner block. Since the top level prior does not have a - conditioner, the default value is to None and should not be modified. - num_layers (`int`, *optional*, defaults to 72): - Number of layers of the transformer architecture. - emb_dropout (`int`, *optional*, defaults to 0): - Embedding dropout used in the lyric decoder. - encoder_config (`JukeboxPriorConfig`, *optional*) : - Configuration of the encoder which models the prior on the lyrics. - encoder_loss_fraction (`float`, *optional*, defaults to 0.4): - Multiplication factor used in front of the lyric encoder loss. - hidden_size (`int`, *optional*, defaults to 2048): - Hidden dimension of the attention layers. - init_scale (`float`, *optional*, defaults to 0.2): - Initialization scales for the prior modules. - is_encoder_decoder (`bool`, *optional*, defaults to `True`): - Whether or not the prior is an encoder-decoder model. In case it is not, and `nb_relevant_lyric_tokens` is - greater than 0, the `encoder` args should be specified for the lyric encoding. - mask (`bool`, *optional*, defaults to `False`): - Whether or not to mask the previous positions in the attention. - max_duration (`int`, *optional*, defaults to 600): - Maximum supported duration of the generated song in seconds. - max_nb_genres (`int`, *optional*, defaults to 1): - Maximum number of genres that can be used to condition the model. - merged_decoder (`bool`, *optional*, defaults to `True`): - Whether or not the decoder and the encoder inputs are merged. This is used for the separated - encoder-decoder architecture - metadata_conditioning (`bool`, *optional*, defaults to `True)`: - Whether or not to condition on the artist and genre metadata. - metadata_dims (`List[int]`, *optional*, defaults to `[604, 7898]`): - Number of genres and the number of artists that were used to train the embedding layers of the prior - models. - min_duration (`int`, *optional*, defaults to 0): - Minimum duration of the generated audio on which the model was trained. - mlp_multiplier (`float`, *optional*, defaults to 1.0): - Multiplier coefficient used to define the hidden dimension of the MLP layers. 0.25 means that 0.25*width of - the model will be used. - music_vocab_size (`int`, *optional*, defaults to 2048): - Number of different music tokens. Should be similar to the `JukeboxVQVAEConfig.nb_discrete_codes`. - n_ctx (`int`, *optional*, defaults to 6144): - Number of context tokens for each prior. The context tokens are the music tokens that are attended to when - generating music tokens. - n_heads (`int`, *optional*, defaults to 2): - Number of attention heads. - nb_relevant_lyric_tokens (`int`, *optional*, defaults to 384): - Number of lyric tokens that are used when sampling a single window of length `n_ctx` - res_conv_depth (`int`, *optional*, defaults to 3): - Depth of the `JukeboxDecoderConvBock` used to upsample the previously sampled audio in the - `JukeboxMusicTokenConditioner`. - res_conv_width (`int`, *optional*, defaults to 128): - Width of the `JukeboxDecoderConvBock` used to upsample the previously sampled audio in the - `JukeboxMusicTokenConditioner`. - res_convolution_multiplier (`int`, *optional*, defaults to 1): - Multiplier used to scale the `hidden_dim` of the `JukeboxResConv1DBlock`. - res_dilation_cycle (`int`, *optional*): - Dilation cycle used to define the `JukeboxMusicTokenConditioner`. Usually similar to the ones used in the - corresponding level of the VQVAE. The first prior does not use it as it is not conditioned on upper level - tokens. - res_dilation_growth_rate (`int`, *optional*, defaults to 1): - Dilation grow rate used between each convolutionnal block of the `JukeboxMusicTokenConditioner` - res_downs_t (`List[int]`, *optional*, defaults to `[3, 2, 2]`): - Downsampling rates used in the audio conditioning network - res_strides_t (`List[int]`, *optional*, defaults to `[2, 2, 2]`): - Striding used in the audio conditioning network - resid_dropout (`int`, *optional*, defaults to 0): - Residual dropout used in the attention pattern. - sampling_rate (`int`, *optional*, defaults to 44100): - Sampling rate used for training. - spread (`int`, *optional*): - Spread used in the `summary_spread_attention` pattern - timing_dims (`int`, *optional*, defaults to 64): - Dimension of the timing embedding. - zero_out (`bool`, *optional*, defaults to `False`): - Whether or not to zero out convolution weights when initializing. - """ - - model_type = "jukebox_prior" - attribute_map = { - "max_position_embeddings": "n_positions", - "num_attention_heads": "n_head", - } - - def __init__( - self, - act_fn="quick_gelu", - level=0, - alignment_head=2, - alignment_layer=68, - attention_multiplier=0.25, - attention_pattern="enc_dec_with_lyrics", - attn_dropout=0, - attn_res_scale=False, - blocks=64, - conv_res_scale=None, - num_layers=72, - emb_dropout=0, - encoder_config=None, - encoder_loss_fraction=0.4, - hidden_size=2048, - init_scale=0.2, - is_encoder_decoder=True, - lyric_vocab_size=80, - mask=False, - max_duration=600, - max_nb_genres=1, - merged_decoder=True, - metadata_conditioning=True, - metadata_dims=[604, 7898], - min_duration=0, - mlp_multiplier=1.0, - music_vocab_size=2048, - n_ctx=6144, - n_heads=2, - nb_relevant_lyric_tokens=384, - res_conv_depth=3, - res_conv_width=128, - res_convolution_multiplier=1, - res_dilation_cycle=None, - res_dilation_growth_rate=1, - res_downs_t=[3, 2, 2], - res_strides_t=[2, 2, 2], - resid_dropout=0, - sampling_rate=44100, - spread=None, - timing_dims=64, - zero_out=False, - **kwargs, - ): - super().__init__(**kwargs) - - self.act_fn = act_fn - self.alignment_head = alignment_head - self.alignment_layer = alignment_layer - self.attention_multiplier = attention_multiplier - self.attention_pattern = attention_pattern - self.attn_dropout = attn_dropout - self.attn_res_scale = attn_res_scale - self.blocks = blocks - self.conv_res_scale = conv_res_scale - self.num_layers = num_layers - self.emb_dropout = emb_dropout - self.music_vocab_size = music_vocab_size - if encoder_config is not None: - self.encoder_config = JukeboxPriorConfig(**encoder_config) - else: - self.encoder_config = None - self.encoder_loss_fraction = encoder_loss_fraction - self.init_scale = init_scale - self.is_encoder_decoder = is_encoder_decoder - self.lyric_vocab_size = lyric_vocab_size - self.level = level - self.mask = mask - self.max_duration = max_duration - self.max_nb_genres = max_nb_genres - self.merged_decoder = merged_decoder - self.metadata_conditioning = metadata_conditioning - self.metadata_dims = metadata_dims - self.min_duration = min_duration - self.mlp_multiplier = mlp_multiplier - self.n_ctx = n_ctx - self.n_heads = n_heads - self.nb_relevant_lyric_tokens = nb_relevant_lyric_tokens - self.res_conv_depth = res_conv_depth - self.res_conv_width = res_conv_width - self.res_convolution_multiplier = res_convolution_multiplier - self.res_dilation_cycle = res_dilation_cycle - self.res_dilation_growth_rate = res_dilation_growth_rate - self.res_downs_t = res_downs_t - self.res_strides_t = res_strides_t - self.resid_dropout = resid_dropout - self.sampling_rate = sampling_rate - self.spread = spread - self.timing_dims = timing_dims - self.hidden_size = hidden_size - self.zero_out = zero_out - - @classmethod - def from_pretrained( - cls, pretrained_model_name_or_path: Union[str, os.PathLike], level=0, **kwargs - ) -> "PretrainedConfig": - cls._set_token_in_kwargs(kwargs) - - config_dict, kwargs = cls.get_config_dict(pretrained_model_name_or_path, **kwargs) - - # get the prior config dict if we are loading from JukeboxConfig - if config_dict.get("model_type") == "jukebox": - config_dict = config_dict[f"prior_{level}"] - - if "model_type" in config_dict and hasattr(cls, "model_type") and config_dict["model_type"] != cls.model_type: - logger.warning( - f"You are using a model of type {config_dict['model_type']} to instantiate a model of type " - f"{cls.model_type}. This is not supported for all configurations of models and can yield errors." - ) - - return cls.from_dict(config_dict, **kwargs) - - -class JukeboxVQVAEConfig(PretrainedConfig): - """ - This is the configuration class to store the configuration of a [`JukeboxVQVAE`]. It is used to instantiate a - `JukeboxVQVAE` according to the specified arguments, defining the model architecture. Instantiating a configuration - with the defaults will yield a similar configuration to that of the VQVAE from - [openai/jukebox-1b-lyrics](https://huggingface.co/openai/jukebox-1b-lyrics) architecture. - - Configuration objects inherit from [`PretrainedConfig`] and can be used to control the model outputs. Read the - documentation from [`PretrainedConfig`] for more information. - - Args: - act_fn (`str`, *optional*, defaults to `"relu"`): - Activation function of the model. - nb_discrete_codes (`int`, *optional*, defaults to 2048): - Number of codes of the VQVAE. - commit (`float`, *optional*, defaults to 0.02): - Commit loss multiplier. - conv_input_shape (`int`, *optional*, defaults to 1): - Number of audio channels. - conv_res_scale (`bool`, *optional*, defaults to `False`): - Whether or not to scale the residuals of the `JukeboxResConv1DBlock`. - embed_dim (`int`, *optional*, defaults to 64): - Embedding dimension of the codebook vectors. - hop_fraction (`List[int]`, *optional*, defaults to `[0.125, 0.5, 0.5]`): - Fraction of non-intersecting window used when continuing the sampling process. - levels (`int`, *optional*, defaults to 3): - Number of hierarchical levels that used in the VQVAE. - lmu (`float`, *optional*, defaults to 0.99): - Used in the codebook update, exponential moving average coefficient. For more detail refer to Appendix A.1 - of the original [VQVAE paper](https://arxiv.org/pdf/1711.00937v2.pdf) - multipliers (`List[int]`, *optional*, defaults to `[2, 1, 1]`): - Depth and width multipliers used for each level. Used on the `res_conv_width` and `res_conv_depth` - res_conv_depth (`int`, *optional*, defaults to 4): - Depth of the encoder and decoder block. If no `multipliers` are used, this is the same for each level. - res_conv_width (`int`, *optional*, defaults to 32): - Width of the encoder and decoder block. If no `multipliers` are used, this is the same for each level. - res_convolution_multiplier (`int`, *optional*, defaults to 1): - Scaling factor of the hidden dimension used in the `JukeboxResConv1DBlock`. - res_dilation_cycle (`int`, *optional*): - Dilation cycle value used in the `JukeboxResnet`. If an int is used, each new Conv1 block will have a depth - reduced by a power of `res_dilation_cycle`. - res_dilation_growth_rate (`int`, *optional*, defaults to 3): - Resnet dilation growth rate used in the VQVAE (dilation_growth_rate ** depth) - res_downs_t (`List[int]`, *optional*, defaults to `[3, 2, 2]`): - Downsampling rate for each level of the hierarchical VQ-VAE. - res_strides_t (`List[int]`, *optional*, defaults to `[2, 2, 2]`): - Stride used for each level of the hierarchical VQ-VAE. - sample_length (`int`, *optional*, defaults to 1058304): - Provides the max input shape of the VQVAE. Is used to compute the input shape of each level. - init_scale (`float`, *optional*, defaults to 0.2): - Initialization scale. - zero_out (`bool`, *optional*, defaults to `False`): - Whether or not to zero out convolution weights when initializing. - """ - - model_type = "jukebox_vqvae" - - def __init__( - self, - act_fn="relu", - nb_discrete_codes=2048, - commit=0.02, - conv_input_shape=1, - conv_res_scale=False, - embed_dim=64, - hop_fraction=[0.125, 0.5, 0.5], - levels=3, - lmu=0.99, - multipliers=[2, 1, 1], - res_conv_depth=4, - res_conv_width=32, - res_convolution_multiplier=1, - res_dilation_cycle=None, - res_dilation_growth_rate=3, - res_downs_t=[3, 2, 2], - res_strides_t=[2, 2, 2], - sample_length=1058304, - init_scale=0.2, - zero_out=False, - **kwargs, - ): - super().__init__(**kwargs) - - self.hop_fraction = hop_fraction - self.conv_input_shape = conv_input_shape - self.sample_length = sample_length - - # VQVAE parameters (all used) - self.levels = levels - self.embed_dim = embed_dim - self.nb_discrete_codes = nb_discrete_codes - self.res_conv_width = res_conv_width - self.res_conv_depth = res_conv_depth - self.res_convolution_multiplier = res_convolution_multiplier - self.res_dilation_growth_rate = res_dilation_growth_rate - self.res_dilation_cycle = res_dilation_cycle - self.multipliers = multipliers - self.res_downs_t = res_downs_t - self.res_strides_t = res_strides_t - self.lmu = lmu - self.commit = commit - self.conv_res_scale = conv_res_scale - self.act_fn = act_fn - self.init_scale = init_scale - self.zero_out = zero_out - - @classmethod - def from_pretrained(cls, pretrained_model_name_or_path: Union[str, os.PathLike], **kwargs) -> "PretrainedConfig": - cls._set_token_in_kwargs(kwargs) - - config_dict, kwargs = cls.get_config_dict(pretrained_model_name_or_path, **kwargs) - - # get the text config dict if we are loading from CLIPConfig - if config_dict.get("model_type") == "jukebox": - config_dict = config_dict["vqvae_config"] - - if "model_type" in config_dict and hasattr(cls, "model_type") and config_dict["model_type"] != cls.model_type: - logger.warning( - f"You are using a model of type {config_dict['model_type']} to instantiate a model of type " - f"{cls.model_type}. This is not supported for all configurations of models and can yield errors." - ) - - return cls.from_dict(config_dict, **kwargs) - - -class JukeboxConfig(PretrainedConfig): - """ - This is the configuration class to store the configuration of a [`JukeboxModel`]. - - Configuration objects inherit from [`PretrainedConfig`] and can be used to control the model outputs. Read the - documentation from [`PretrainedConfig`] for more information. Instantiating a configuration with the defaults will - yield a similar configuration to that of - [openai/jukebox-1b-lyrics](https://huggingface.co/openai/jukebox-1b-lyrics) architecture. - - - The downsampling and stride are used to determine downsampling of the input sequence. For example, downsampling = - (5,3), and strides = (2, 2) will downsample the audio by 2^5 = 32 to get the first level of codes, and 2**8 = 256 - to get the second level codes. This is mostly true for training the top level prior and the upsamplers. - - Args: - vqvae_config (`JukeboxVQVAEConfig`, *optional*): - Configuration for the `JukeboxVQVAE` model. - prior_config_list (`List[JukeboxPriorConfig]`, *optional*): - List of the configs for each of the `JukeboxPrior` of the model. The original architecture uses 3 priors. - nb_priors (`int`, *optional*, defaults to 3): - Number of prior models that will sequentially sample tokens. Each prior is conditional auto regressive - (decoder) model, apart from the top prior, which can include a lyric encoder. The available models were - trained using a top prior and 2 upsampler priors. - sampling_rate (`int`, *optional*, defaults to 44100): - Sampling rate of the raw audio. - timing_dims (`int`, *optional*, defaults to 64): - Dimensions of the JukeboxRangeEmbedding layer which is equivalent to traditional positional embedding - layer. The timing embedding layer converts the absolute and relative position in the currently sampled - audio to a tensor of length `timing_dims` that will be added to the music tokens. - min_duration (`int`, *optional*, defaults to 0): - Minimum duration of the audios to generate - max_duration (`float`, *optional*, defaults to 600.0): - Maximum duration of the audios to generate - max_nb_genres (`int`, *optional*, defaults to 5): - Maximum number of genres that can be used to condition a single sample. - metadata_conditioning (`bool`, *optional*, defaults to `True`): - Whether or not to use metadata conditioning, corresponding to the artist, the genre and the min/maximum - duration. - - Example: - - ```python - >>> from transformers import JukeboxModel, JukeboxConfig - - >>> # Initializing a Jukebox configuration - >>> configuration = JukeboxConfig() - - >>> # Initializing a model from the configuration - >>> model = JukeboxModel(configuration) - - >>> # Accessing the model configuration - >>> configuration = model.config - ``` - """ - - model_type = "jukebox" - - def __init__( - self, - vqvae_config=None, - prior_config_list=None, - nb_priors=3, - sampling_rate=44100, - timing_dims=64, - min_duration=0, - max_duration=600.0, - max_nb_genres=5, - metadata_conditioning=True, - **kwargs, - ): - if vqvae_config is None: - vqvae_config = {} - logger.info("vqvae_config is None. initializing the JukeboxVQVAE with default values.") - - self.vqvae_config = JukeboxVQVAEConfig(**vqvae_config) - if prior_config_list is not None: - self.prior_configs = [JukeboxPriorConfig(**prior_config) for prior_config in prior_config_list] - else: - self.prior_configs = [] - for prior_idx in range(nb_priors): - prior_config = kwargs.pop(f"prior_{prior_idx}", None) - if prior_config is None: - prior_config = {} - logger.info( - f"prior_{prior_idx}'s config is None. Initializing the JukeboxPriorConfig list with default" - " values." - ) - self.prior_configs.append(JukeboxPriorConfig(**prior_config)) - - self.hop_fraction = self.vqvae_config.hop_fraction - - self.nb_priors = nb_priors - - # Metadata conditioning - self.max_nb_genres = max_nb_genres - self.sampling_rate = sampling_rate - self.timing_dims = timing_dims - self.min_duration = min_duration - self.max_duration = max_duration - self.metadata_conditioning = metadata_conditioning - - super().__init__(**kwargs) - - @classmethod - def from_configs(cls, prior_configs: List[JukeboxPriorConfig], vqvae_config: JukeboxVQVAEConfig, **kwargs): - r""" - Instantiate a [`JukeboxConfig`] (or a derived class) from clip text model configuration and clip vision model - configuration. - - Returns: - [`JukeboxConfig`]: An instance of a configuration object - """ - prior_config_list = [config.to_dict() for config in prior_configs] - return cls(prior_config_list=prior_config_list, vqvae_config_dict=vqvae_config.to_dict(), **kwargs) - - def to_dict(self): - # Override the default to_dict to apply to_dict to the list of prior configs. - result = super().to_dict() - result["prior_config_list"] = [config.to_dict() for config in result.pop("prior_configs")] - return result -__all__ = [ - "JukeboxConfig", - "JukeboxPriorConfig", - "JukeboxVQVAEConfig", - ] diff --git a/mindnlp/transformers/models/jukebox/modeling_jukebox.py b/mindnlp/transformers/models/jukebox/modeling_jukebox.py deleted file mode 100644 index 1a507e925..000000000 --- a/mindnlp/transformers/models/jukebox/modeling_jukebox.py +++ /dev/null @@ -1,2591 +0,0 @@ -# coding=utf-8 -# Copyright 2022 The OpenAI Team Authors and HuggingFace Inc. team. -# -# 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. -"""Mindspore Jukebox model.""" - -import math -import os -from typing import List, Optional, Tuple - -import numpy as np -import mindspore -import mindnlp.core.nn.functional as F -from mindnlp.core import nn, ops, no_grad, distributions -from mindnlp.core.nn import LayerNorm as FusedLayerNorm - -from ....common.activations import ACT2FN -from ...modeling_utils import PreTrainedModel -from ....utils import logging -from ....utils.logging import tqdm -from .configuration_jukebox import ATTENTION_PATTERNS, JukeboxConfig, JukeboxPriorConfig, JukeboxVQVAEConfig - - -logger = logging.get_logger(__name__) - - -def filter_logits(logits, top_k=0, top_p=0.0, filter_value=-float("Inf")): - """ - Filter a distribution of logits using top-k and/or nucleus (top-p) filtering - - Args: - logits (`mindspore.Tensor`): - logits distribution shape (vocabulary size) - top_k (`int`, *optional*, defaults to 0): - When `top_k >0` keep only top key tokens with highest probability (top-k filtering). - top_p (`int`, *optional*, defaults to 0): - When `top_p>0.0` keep the top tokens with cumulative probability >= `top_p` (nucleus filtering). - """ - logits = logits.clone() - top_k = min(top_k, logits.shape[-1]) # Safety check - - if top_k > 0: - # Remove all tokens with a probability less than the last token of the top-k - indices_to_remove = logits < ops.topk(logits, top_k, dim=-1)[0][..., -1:] - logits[indices_to_remove] = filter_value - - if top_p > 0.0: - sorted_logits, sorted_indices = ops.sort(logits, descending=True, dim=-1) - cumulative_probs = ops.cumsum(F.softmax(sorted_logits, dim=-1), dim=-1) - - # Remove tokens with cumulative probability above the threshold - sorted_indices_to_remove = cumulative_probs > top_p - # Shift the indices to the right to keep also the first token above the threshold - sorted_indices_to_remove[..., 1:] = sorted_indices_to_remove[..., :-1].clone() - sorted_indices_to_remove[..., 0] = 0 - - # indices_to_remove = sorted_indices[sorted_indices_to_remove] - indices_to_remove = ops.zeros_like(logits, dtype=mindspore.bool_).scatter_( - dim=-1, index=sorted_indices, src=sorted_indices_to_remove - ) - logits[indices_to_remove] = filter_value - return logits - - -def get_relevant_lyric_tokens(full_tokens, max_n_lyric_tokens, total_length, offset, duration): - """ - Extract only the relevant tokens based on the character position. A total of `max_n_lyric_tokens` tokens will be - returned. If the provided token sequence is smaller, it will be padded, otherwise, only characters ranging from the - midpoint - `max_n_lyric_tokens//2` to the midpoint + `max_n_lyric_tokens//2` will be returned. This *focuses* on - the most relevant tokens (in time) for the sequence. - - Args: - full_tokens (`List[int]`): - List containing the token ids of the entire lyrics. - total_length (`int`): - Total expected length of the music (not all of it is generated, see duration), in samples. - offset (`int`): - Starting sample in the music. If the offset is greater than 0, the lyrics will be shifted take that into - account - duration (`int`): - Expected duration of the generated music, in samples. The duration has to be smaller than the total length, - which represent the overall length of the signal, - """ - full_tokens = full_tokens[0] - if len(full_tokens) < max_n_lyric_tokens: - tokens = ops.cat( - [ops.zeros(max_n_lyric_tokens - len(full_tokens), dtype=mindspore.int64).to(full_tokens), full_tokens] - ) - indices = [-1] * (max_n_lyric_tokens - len(full_tokens)) + list(range(0, len(full_tokens))) - else: - midpoint = int(len(full_tokens) * (offset + duration / 2.0) / total_length) - midpoint = min(max(midpoint, max_n_lyric_tokens // 2), len(full_tokens) - max_n_lyric_tokens // 2) - tokens = full_tokens[midpoint - max_n_lyric_tokens // 2 : midpoint + max_n_lyric_tokens // 2] - indices = list(range(midpoint - max_n_lyric_tokens // 2, midpoint + max_n_lyric_tokens // 2)) - return tokens.unsqueeze(dim=0), indices - - -# Break total_length into hops/windows of size n_ctx separated by hop_length -def get_starts(total_length, n_ctx, hop_length): - starts = [] - for start in range(0, total_length - n_ctx + hop_length, hop_length): - if start + n_ctx >= total_length: - # Last hop could be smaller, we make it n_ctx to maximise context - start = total_length - n_ctx - starts.append(start) - return starts - - -def get_alignment(music_tokens, labels, prior, config): - level = prior.levels - 1 # Top level used - n_ctx = prior.n_ctx - tokens = music_tokens[level] - batch_size, total_length = tokens.shape[0], tokens.shape[1] - if total_length < n_ctx: - padding_length = n_ctx - total_length - tokens = ops.cat( - [tokens, ops.zeros(batch_size, n_ctx - total_length, dtype=tokens.dtype)], dim=1 - ) - total_length = tokens.shape[1] - else: - padding_length = 0 - - hop_length = int(config.hop_fraction[-level - 1] * prior.n_ctx) - alignment_head, alignment_layer = config.prior_alignment_head[0], config.prior_alignment_layer[0] - attn_layers = {alignment_layer} - alignment_hops = {} - indices_hops = {} - for start in tqdm(get_starts(total_length, n_ctx, hop_length), desc="Computing lyric to music alignment "): - end = start + n_ctx - # set metadata offset, sample_length and lyrics tokens - metadata, indices_hop = prior.get_metadata(labels, start, config.sample_length, get_indices=True, offset=0) - tokens_bs = ops.chunk(tokens, batch_size, dim=0) - metadata_bs = ops.chunk(metadata, batch_size, dim=0) - w_hops = [] - for tokens_i, metadata_i in zip(tokens_bs, metadata_bs): - w_hop = prior.forward_tokens(tokens_i[:, start:end], [], metadata_i, get_attn_weights=attn_layers) - w_hops.append(w_hop[0][:, alignment_head]) - del w_hop - weights = ops.cat(w_hops, dim=0) - del w_hops - alignment_hop = weights.float().cpu().numpy() - del weights - - # alignment_hop has shape (bs, n_ctx, nb_relevant_lyric_tokens) - # indices_hop is a list of len=bs, each entry of len hps.nb_relevant_lyric_tokens - indices_hops[start] = indices_hop - alignment_hops[start] = alignment_hop - - # Combine attn for each hop into attn for full range - # Use indices to place them into correct place for corresponding source tokens - alignments = [] - for item in range(batch_size): - # Note each item has different length lyrics - full_tokens = labels[0, 3:] - alignment = np.zeros((total_length, len(full_tokens) + 1)) - for start in reversed(get_starts(total_length, n_ctx, hop_length)): - end = start + n_ctx - alignment_hop = alignment_hops[start][item] - indices = indices_hops[start][item] - alignment[start:end, indices] = alignment_hop - alignment = alignment[: total_length - padding_length, :-1] # remove token padding, and last lyric index - alignments.append(alignment) - return alignments - - -def save_temp_audio(fname, lvl, metas, aud): - aud = ops.clamp(aud, -1, 1).cpu().numpy() - for i in list(range(aud.shape[0])): - if metas is not None: - artists, genres, lyrics = list(metas)[i].values() - path = f"{fname}/lvl_{lvl}-{artists}-{genres}-{lyrics[:5]}-{i}" - np.save(path, aud[i]) - else: - np.save(f"{fname}/lvl_{lvl}-sample-{i}", aud[i]) - - -def get_mask(mask, query_length, key_value_length, blocks, spread, sample, sample_t): - # returns a mask of shape 1 x 1 x query_length x key_value_length or None if masking is not needed. - if mask is None or query_length == 1: - return None - offset = sample_t - query_length if sample else max(key_value_length - query_length, 0) - if mask == "autoregressive": - # Masked dense - mask = ops.ones(query_length, key_value_length).tril(offset) - elif mask == "summary": - # Masked summary - mask = ops.ones(query_length, query_length).tril() - mask = ops.ones(query_length, query_length).tril() - mask = mask.view(query_length, blocks, query_length // blocks)[:, :-1, -key_value_length // blocks :] - mask = ( - ops.pad( - mask, - (0, 0, 1, 0), - value=1, - ) - .contiguous() - .view(query_length, key_value_length) - ) - elif mask == "prime": - mask = ops.ones(query_length, key_value_length).tril(offset) - return mask.view(1, 1, query_length, key_value_length) - - -class JukeboxConv1D(nn.Module): - def __init__(self, input_width, output_width): - super().__init__() - self.input_width = input_width - self.output_width = output_width - weight = ops.zeros(input_width, output_width) - bias = ops.zeros(output_width) - self.weight = nn.Parameter(weight) - self.bias = nn.Parameter(bias) - - def forward(self, hidden_states): - size_out = (*hidden_states.shape[:-1], self.output_width) - hidden_states = ops.addmm( - self.bias.type_as(hidden_states), - hidden_states.view(-1, hidden_states.shape[-1]), - self.weight.type_as(hidden_states), - ) - hidden_states = hidden_states.view(*size_out) - return hidden_states - - -class JukeboxResConv1DBlock(nn.Module): - def __init__(self, config, conv_width, depth=1, res_scale=1.0): - super().__init__() - hidden_dim = config.res_convolution_multiplier * conv_width - dilation = config.res_dilation_growth_rate**depth - padding = dilation - - self.res_scale = res_scale - self.activation = nn.ReLU() - self.conv1d_1 = nn.Conv1d(conv_width, hidden_dim, 3, 1, padding, dilation) - self.conv1d_2 = nn.Conv1d(hidden_dim, conv_width, 1, 1, 0) - - def forward(self, hidden_states): - residuals = hidden_states - hidden_states = self.activation(hidden_states) - hidden_states = self.conv1d_1(hidden_states) - hidden_states = self.activation(hidden_states) - hidden_states = self.conv1d_2(hidden_states) - return residuals + self.res_scale * hidden_states - - -class JukeboxResnet1D(nn.Module): - def __init__(self, config, conv_width, n_depth, reverse_dilation=False): - super().__init__() - self.dilation_cycle = config.res_dilation_cycle - res_scale = 1.0 if not config.conv_res_scale else 1.0 / math.sqrt(n_depth) - - blocks = [] - for depth in range(n_depth): - block_depth = depth if self.dilation_cycle is None else depth % self.dilation_cycle - blocks.append(JukeboxResConv1DBlock(config, conv_width, block_depth, res_scale)) - - if reverse_dilation: - blocks = blocks[::-1] - self.resnet_block = nn.ModuleList(blocks) - - def forward(self, hidden_states): - for block in self.resnet_block: - hidden_states = block(hidden_states) - return hidden_states - - -class JukeboxEncoderConvBlock(nn.Module): - def __init__(self, config, embed_dim, hidden_dim, depth, down_t, stride_t): - super().__init__() - blocks = [] - filter_t = stride_t * 2 - pad_t = stride_t // 2 - if down_t > 0: - for i in range(down_t): - blocks.append(nn.Conv1d(embed_dim if i == 0 else hidden_dim, hidden_dim, filter_t, stride_t, pad_t)) - blocks.append(JukeboxResnet1D(config, hidden_dim, depth)) - self.proj_out = nn.Conv1d(hidden_dim, config.embed_dim, 3, 1, 1) - self.downsample_block = nn.ModuleList(blocks) - - def forward(self, hidden_states): - for block in self.downsample_block: - hidden_states = block(hidden_states) - hidden_states = self.proj_out(hidden_states) - return hidden_states - - -class JukeboxEncoder(nn.Module): - def __init__(self, config, width, depth, levels, downs_t, strides_t): - super().__init__() - self.levels = levels - self.level_blocks = nn.ModuleList() - - iterator = zip(list(range(self.levels)), downs_t, strides_t) - for i, down_t, stride_t in iterator: - self.level_blocks.append( - JukeboxEncoderConvBlock( - config, config.conv_input_shape if i == 0 else config.embed_dim, width, depth, down_t, stride_t - ) - ) - - def forward(self, hidden_states): - all_hidden_states = [] - - # 64, 32, ... - for level in range(self.levels): - level_block = self.level_blocks[level] - hidden_states = level_block(hidden_states) - all_hidden_states.append(hidden_states) - - return all_hidden_states - - -class JukeboxDecoderConvBock(nn.Module): - def __init__(self, config, embed_dim, hidden_dim, depth, down_t, stride_t, reverse_dilation=True): - self.embed_dim = embed_dim - self.hidden_dim = hidden_dim - super().__init__() - blocks = [] - if down_t > 0: - filter_t = stride_t * 2 - pad_t = stride_t // 2 - self.proj_in = nn.Conv1d(embed_dim, hidden_dim, 3, 1, 1) - for i in range(down_t): - blocks.append(JukeboxResnet1D(config, hidden_dim, depth, reverse_dilation)) - blocks.append( - nn.ConvTranspose1d( - hidden_dim, hidden_dim if i < down_t - 1 else embed_dim, filter_t, stride_t, pad_t - ) - ) - self.upsample_block = nn.ModuleList(blocks) - - def forward(self, hidden_states): - hidden_states = self.proj_in(hidden_states) - for block in self.upsample_block: - hidden_states = block(hidden_states) - return hidden_states - - -class JukeboxDecoder(nn.Module): - def __init__(self, config, hidden_dim, depth, levels, downs_t, strides_t): - super().__init__() - self.levels = levels - self.level_blocks = nn.ModuleList() - for level, down_t, stride_t in zip(list(range(self.levels)), downs_t, strides_t): - self.level_blocks.append( - JukeboxDecoderConvBock(config, config.embed_dim, hidden_dim, depth, down_t, stride_t) - ) - - self.out = nn.Conv1d(config.embed_dim, config.conv_input_shape, 3, 1, 1) - - def forward(self, hidden_states, all_levels=True): - hidden_state = hidden_states[-1] - - # 32, 64 ... - for level in reversed(range(self.levels)): - level_block = self.level_blocks[level] - hidden_state = level_block(hidden_state) - - if level != 0 and all_levels: - hidden_state = hidden_state + hidden_states[level - 1] - - hidden_state = self.out(hidden_state) - return hidden_state - - -class JukeboxBottleneckBlock(nn.Module): - def __init__(self, config: JukeboxVQVAEConfig): - super().__init__() - self.nb_discrete_codes = config.nb_discrete_codes - self.codebook_width = config.embed_dim - self.mu = config.lmu - self.threshold = 1.0 - self.init = False - self.codebook_sum = None - self.codebook_elem = None - self.register_buffer("codebook", ops.zeros(self.nb_discrete_codes, self.codebook_width)) - - def _tile(self, hidden_states): - dim, embed_width = hidden_states.shape - if dim < self.nb_discrete_codes: - n_repeats = (self.nb_discrete_codes + dim - 1) // dim - std = 0.01 / np.sqrt(embed_width) - hidden_states = hidden_states.repeat(n_repeats, 1) - hidden_states = hidden_states + ops.randn_like(hidden_states) * std - return hidden_states - - def init_codebook(self, hidden_states): - nb_discrete_codes = self.nb_discrete_codes - self.init = True - codes = self._tile(hidden_states) - self.codebook = codes[ops.randperm(codes.shape[0])][:nb_discrete_codes] - self.codebook_sum = self.codebook - self.codebook_elem = ops.ones(nb_discrete_codes) - - def update_codebook(self, hidden_states, latent_states): - mu, codebook_width, nb_discrete_codes = self.mu, self.codebook_width, self.nb_discrete_codes - with no_grad(): - # Calculate new centres - # nb_discrete_codes, batch_size * seq_length - latent_states_onehot = ops.zeros(nb_discrete_codes, hidden_states.shape[0]) - latent_states_onehot.scatter_(0, latent_states.view(1, hidden_states.shape[0]), 1) - - _codebook_sum = ops.matmul(latent_states_onehot, hidden_states) - _codebook_elem = latent_states_onehot.sum(dim=-1) # nb_discrete_codes - codes = self._tile(hidden_states) - _random_codebook = codes[ops.randperm(codes.shape[0])][:nb_discrete_codes] - - # Update centres - old_codebook = self.codebook - self.codebook_sum = mu * self.codebook_sum + (1.0 - mu) * _codebook_sum - self.codebook_elem = mu * self.codebook_elem + (1.0 - mu) * _codebook_elem # nb_discrete_codes - usage = (self.codebook_elem.view(nb_discrete_codes, 1) >= self.threshold).float() - - norm_code = self.codebook_sum.view(nb_discrete_codes, codebook_width) / self.codebook_elem.view( - nb_discrete_codes, 1 - ) - self.codebook = usage * (norm_code) + (1 - usage) * _random_codebook - _codebook_prob = _codebook_elem / mindspore.ops.sum(_codebook_elem) # prob of each bin - entropy = -mindspore.ops.sum(_codebook_prob * ops.log(_codebook_prob + 1e-8)) # entropy ie how diverse - used_curr = (_codebook_elem >= self.threshold).sum() - usage = mindspore.ops.sum(usage) - dk = ops.norm(self.codebook - old_codebook) / np.sqrt(np.prod(old_codebook.shape)) - return {"entropy": entropy, "used_curr": used_curr, "usage": usage, "dk": dk} - - def preprocess(self, hidden_states): - hidden_states = hidden_states.permute(0, 2, 1).contiguous() - hidden_states = hidden_states.view(-1, hidden_states.shape[-1]) - - if hidden_states.shape[-1] == self.codebook_width: - prenorm = ops.norm(hidden_states - ops.mean(hidden_states)) / np.sqrt(np.prod(hidden_states.shape)) - elif hidden_states.shape[-1] == 2 * self.codebook_width: - x1, x2 = hidden_states[..., : self.codebook_width], hidden_states[..., self.codebook_width :] - prenorm = (ops.norm(x1 - ops.mean(x1)) / np.sqrt(np.prod(x1.shape))) + ( - ops.norm(x2 - ops.mean(x2)) / np.sqrt(np.prod(x2.shape)) - ) - - # Normalise - hidden_states = x1 + x2 - - return hidden_states, prenorm - - def postprocess(self, latent_states, dequantised_states, x_shape): - batch_size, time = x_shape - dequantised_states = dequantised_states.view(batch_size, time, -1).permute(0, 2, 1).contiguous() - latent_states = latent_states.view(batch_size, time) - return latent_states, dequantised_states - - def quantise(self, latent_states): - # Calculate latent code latent_states - codebook_weights = self.codebook.t() - distance = ( - mindspore.ops.sum(latent_states**2, dim=-1, keepdim=True) - - 2 * ops.matmul(latent_states, codebook_weights) - + mindspore.ops.sum(codebook_weights**2, dim=0, keepdim=True) - ) # (batch_size * latent_states , codebook_weights) - min_distance, music_tokens = ops.min(distance,dim=-1) - fit = ops.mean(min_distance) - return music_tokens, fit - - def dequantise(self, music_tokens): - dequantised_states = F.embedding(music_tokens, self.codebook) - return dequantised_states - - def encode(self, latent_states): - samples, _, seq_len = latent_states.shape - - # Preprocess. - latent_states, _ = self.preprocess(latent_states) - - # Quantise - music_tokens, _ = self.quantise(latent_states) - - # Postprocess. - music_tokens = music_tokens.view(samples, seq_len) - return music_tokens - - def decode(self, music_tokens): - samples, seq_len = music_tokens.shape - - # Dequantise - dequantised_states = self.dequantise(music_tokens) - - # Postprocess - dequantised_states = ( - dequantised_states.view(samples, seq_len, self.codebook_width).permute(0, 2, 1).contiguous() - ) - return dequantised_states - - def forward(self, hidden_states, update_codebook=True): - samples, _, seq_len = hidden_states.shape - - # Preprocess - hidden_states, prenorm = self.preprocess(hidden_states) - - # Init codebook if not inited - if update_codebook and not self.init: - self.init_codebook(hidden_states) - - # Quantise and dequantise through bottleneck - music_tokens, fit = self.quantise(hidden_states) - dequantised_states = self.dequantise(music_tokens) - - # Update embeddings - if update_codebook: - update_metrics = self.update_codebook(hidden_states, music_tokens) - else: - update_metrics = {} - - # Loss - commit_loss = ops.norm(dequantised_states.detach() - hidden_states) ** 2 / np.prod(hidden_states.shape) - - # Passthrough - dequantised_states = hidden_states + (dequantised_states - hidden_states).detach() - - # Postprocess - music_tokens, dequantised_states = self.postprocess(music_tokens, dequantised_states, (samples, seq_len)) - return music_tokens, dequantised_states, commit_loss, dict(fit=fit, pn=prenorm, **update_metrics) - - -class JukeboxBottleneck(nn.Module): - def __init__(self, config, levels): - super().__init__() - self.levels = levels - self.level_blocks = nn.ModuleList() - for level in range(self.levels): - self.level_blocks.append(JukeboxBottleneckBlock(config)) - - def encode(self, raw_audio): - music_tokens = [ - level_block.encode(hidden_states) for (level_block, hidden_states) in zip(self.level_blocks, raw_audio) - ] - return music_tokens - - def decode(self, music_tokens, start_level=0, end_level=None): - if end_level is None: - end_level = self.levels - quantised_audio = [ - level_block.decode(z) for (level_block, z) in zip(self.level_blocks[start_level:end_level], music_tokens) - ] - return quantised_audio - - def forward(self, input_audio): - music_tokens, quantised_states, commit_losses, metrics = [], [], [], [] - for level in range(self.levels): - level_block = self.level_blocks[-level - 1] - hidden_states = input_audio[level] - sampled_tokens, quantised_state, commit_loss, metric = level_block( - hidden_states, update_codebook=self.training - ) - music_tokens.append(sampled_tokens) - if not self.training: - # Be extra paranoid and make sure the encoder weights can't - # change from straight-through estimator - quantised_state = quantised_state.detach() - quantised_states.append(quantised_state) - commit_losses.append(commit_loss) - if self.training: - metrics.append(metric) - return music_tokens, quantised_states, commit_losses, metrics - - -JUKEBOX_START_DOCSTRING = r""" - - This model inherits from [`PreTrainedModel`]. Check the superclass documentation for the generic methods the - library implements for all its model (such as downloading or saving, resizing the input embeddings, pruning heads - etc.) - - This model is also a PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) subclass. - Use it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage - and behavior. - - Parameters: - config (`JukeboxConfig`): Model configuration class with all the parameters of the model. - Initializing with a config file does not load the weights associated with the model, only the - configuration. Check out the [`~PreTrainedModel.from_pretrained`] method to load the model weights. -""" - - -class JukeboxVQVAE(PreTrainedModel): - config_class = JukeboxVQVAEConfig - base_model_prefix = "vqvae" - - def _init_weights(self, module): - if isinstance(module, nn.Embedding): # embed_tokens - module.weight.data.normal_(mean=0.0, std=0.02 * self.config.init_scale) - elif isinstance(module, JukeboxConv1D): - if self.config.zero_out: - module.weight.data.zero_() - else: - module.weight.data.normal_(mean=0.0, std=0.02 * self.config.init_scale) - elif isinstance(module, JukeboxResConv1DBlock) and self.config.zero_out: - module.conv1d_2.weight.data.zero_() - module.conv1d_2.bias.data.zero_() - if isinstance(module, nn.LayerNorm): - module.bias.data.zero_() - module.weight.data.fill_(1.0) - if isinstance(module, nn.Linear) and module.bias is not None: - module.bias.data.zero_() - - def __init__(self, config: JukeboxVQVAEConfig): - super().__init__(config) - downs_t = config.res_downs_t - strides_t = config.res_strides_t - if not config.sample_length: - downsamples = [stride**down for stride, down in zip(strides_t, downs_t)] - top_raw_to_tokens = np.prod(downsamples) - config.sample_length = ( - config.sample_length_in_seconds * config.sampling_rate // top_raw_to_tokens - ) * top_raw_to_tokens - config.sample_length = config.sample_length.astype(int) - - self.nb_discrete_codes = config.nb_discrete_codes - self.commit = config.commit - self.sample_length = config.sample_length - - self.downsamples = [stride**down for stride, down in zip(strides_t, downs_t)] - self.hop_lengths = np.cumprod(self.downsamples) - self.levels = levels = config.levels - self.music_tokens_shapes = [ - (int(self.sample_length // self.hop_lengths[-level - 1])) for level in range(levels) - ] - - self.multipliers = config.multipliers if config.multipliers is not None else [1] * levels - - self.encoders = nn.ModuleList() - self.decoders = nn.ModuleList() - for level in range(levels): - width = config.res_conv_width * self.multipliers[level] - depth = config.res_conv_depth * self.multipliers[level] - self.encoders.append( - JukeboxEncoder(config, width, depth, level + 1, downs_t[: level + 1], strides_t[: level + 1]) - ) - self.decoders.append( - JukeboxDecoder(config, width, depth, level + 1, downs_t[: level + 1], strides_t[: level + 1]) - ) - - self.bottleneck = JukeboxBottleneck(config, levels) - - def _decode(self, music_tokens, start_level=0, end_level=None): - # Decode - if end_level is None: - end_level = self.levels - latent_states = self.bottleneck.decode(music_tokens, start_level=start_level, end_level=end_level) - # Use only lowest level - decoder, dequantised_state = self.decoders[start_level], latent_states[0:1] - dequantised_state = decoder(dequantised_state, all_levels=False) - dequantised_state = dequantised_state.permute(0, 2, 1) - return dequantised_state - - def decode(self, music_tokens, start_level=0, end_level=None, bs_chunks=1) -> mindspore.Tensor: - """ - Transforms the input `music_tokens` to their `raw_audio` representation. - - Args: - music_tokens (`mindspore.Tensor`): - Tensor of music tokens which will be decoded to raw audio by using the codebook. Each music token - should be an index to a corresponding `code` vector in the codebook. - start_level (`int`, *optional*): - Level at which the decoding process will start. Default to 0. - end_level (`int`, *optional*): - Level at which the decoding process will start. Default to None. - bs_chunks (int, *optional*): - Number of chunks to process at the same time. - """ - token_chunks = [ops.chunk(token, bs_chunks, dim=0) for token in music_tokens] - dequantised_states = [] - for i in range(bs_chunks): - music_tokens_i = [chunks[i] for chunks in token_chunks] - dequantised_state = self._decode(music_tokens_i, start_level=start_level, end_level=end_level) - dequantised_states.append(dequantised_state) - return ops.cat(dequantised_states, dim=0) - - def _encode(self, raw_audio, start_level=0, end_level=None): - # Encode - if end_level is None: - end_level = self.levels - input_audio = raw_audio.permute(0, 2, 1).float() - latent_states = [] - for level in range(self.levels): - encoder = self.encoders[level] - latent_state = encoder(input_audio) - latent_states.append(latent_state[-1]) - music_tokens = self.bottleneck.encode(latent_states) - return music_tokens[start_level:end_level] - - def encode(self, input_audio, start_level=0, end_level=None, bs_chunks=1): - """ - Transforms the `input_audio` to a discrete representation made out of `music_tokens`. - - Args: - input_audio (`mindspore.Tensor`): - Raw audio which will be encoded to its discrete representation using the codebook. The closest `code` - form the codebook will be computed for each sequence of samples. - start_level (`int`, *optional*, defaults to 0): - Level at which the encoding process will start. Default to 0. - end_level (`int`, *optional*): - Level at which the encoding process will start. Default to None. - bs_chunks (int, *optional*, defaults to 1): - Number of chunks of raw audio to process at the same time. - """ - audio_chunks = ops.chunk(input_audio, bs_chunks, dim=0) - music_tokens_list = [] - for chunk_i in audio_chunks: - music_tokens_i = self._encode(chunk_i, start_level=start_level, end_level=end_level) - music_tokens_list.append(music_tokens_i) - music_tokens = [ops.cat(music_tokens_level, dim=0) for music_tokens_level in zip(*music_tokens_list)] - return music_tokens - - def sample(self, n_samples): - music_tokens = [ - ops.randint(0, self.nb_discrete_codes, size=(n_samples, *music_tokens_shape)) - for music_tokens_shape in self.music_tokens_shapes - ] - return self.decode(music_tokens) - - def forward(self, raw_audio: mindspore.Tensor) -> Tuple[mindspore.Tensor, mindspore.Tensor]: - """ - Forward pass of the VQ-VAE, encodes the `raw_audio` to latent states, which are then decoded for each level. - The commit loss, which ensure that the encoder's computed embeddings are close to the codebook vectors, is - computed. - - Args: - raw_audio (`mindspore.Tensor`): - Audio input which will be encoded and decoded. - - Returns: - `Tuple[mindspore.Tensor, mindspore.Tensor]` - - - Example: - ```python - >>> from transformers import JukeboxVQVAE, set_seed - >>> import torch - - >>> model = JukeboxVQVAE.from_pretrained("openai/jukebox-1b-lyrics").eval() - >>> set_seed(0) - >>> zs = [torch.randint(100, (4, 1))] - >>> model.decode(zs).shape - torch.shape([4, 8, 1]) - ``` - """ - - # Encode/Decode - input_audio = raw_audio.permute(0, 2, 1).float() - latent_states = [] - for level in range(self.levels): - encoder = self.encoders[level] - latent_state = encoder(input_audio) - latent_states.append(latent_state[-1]) - - _, music_tokens, commit_losses, _ = self.bottleneck(latent_states) - dequantised_states = [] - for level in range(self.levels): - decoder = self.decoders[level] - dequantised_state = decoder(music_tokens[level : level + 1], all_levels=False) - dequantised_states.append(dequantised_state.permute(0, 2, 1)) - - commit_loss = sum(commit_losses) - loss = self.commit * commit_loss - - return dequantised_states, loss - - -class JukeboxMLP(nn.Module): - def __init__(self, config): - # a single channel is always used in original code - super().__init__() - embed_dim = config.hidden_size - hidden_dim = int(config.mlp_multiplier * embed_dim) - - self.c_fc = JukeboxConv1D(embed_dim, hidden_dim) - self.c_proj = JukeboxConv1D(hidden_dim, embed_dim) - self.act = ACT2FN[config.act_fn] - self.dropout = nn.Dropout(config.resid_dropout) - - def forward(self, hidden_states): - hidden_states = self.c_fc(hidden_states) - hidden_states = self.act(hidden_states) - hidden_states = self.c_proj(hidden_states) - hidden_states = self.dropout(hidden_states) - return hidden_states - - -class JukeboxLayerNorm(FusedLayerNorm): - def __init__(self, normalized_shape, eps=1e-5, elementwise_affine=True): - super().__init__(normalized_shape, eps=eps, elementwise_affine=elementwise_affine) - self.width = np.prod(normalized_shape) - self.max_numel = 65535 * self.width - - def forward(self, input): - if input.numel() > self.max_numel: - return F.layer_norm(input, self.normalized_shape, self.weight, self.bias, self.eps).type_as(input) - else: - return super().forward(input).type_as(input) - - -class JukeboxAttention(nn.Module): - def __init__(self, config, n_ctx, attn_func="dense_attn"): - super().__init__() - self.embed_dim = config.hidden_size - self.n_heads = config.n_heads - self.dropout = config.attn_dropout - hidden_dim = int(config.attention_multiplier * self.embed_dim) - - self.head_dim = hidden_dim // config.n_heads - self.n_ctx = n_ctx - self.hidden_dim = hidden_dim - self.scale = self.head_dim**-0.25 - self.mask = config.mask - - if attn_func == "cross_attention": - self.c_attn = JukeboxConv1D(self.embed_dim, hidden_dim) - self.c_enc_kv = JukeboxConv1D(self.embed_dim, hidden_dim * 2) - else: - self.c_attn = JukeboxConv1D(self.embed_dim, hidden_dim * 3) - - self.c_proj = JukeboxConv1D(hidden_dim, self.embed_dim) - self.attn_dropout = nn.Dropout(config.attn_dropout) - self.resid_dropout = nn.Dropout(config.resid_dropout) - - # Sequence of length seq_len is factored as [blocks, seq_len // blocks] - self.attn_func = attn_func - if attn_func == "cross_attention": - self.qkv = self.decode_qkv - elif attn_func == "prime_attn": - self.qkv = self.prime_qkv - else: - self.qkv = self.factored_qkv - - ATTENTION_MAP = { - "dense_attn": (self.dense_attn, "autoregressive"), - "block_attn": (self.block_attn, "autoregressive"), - "transpose_block_attn": (self.transpose_block_attn, "autoregressive"), - "prev_block_attn": (self.prev_block_attn, None), - "summary_attn": (self.summary_attn, "summary"), - "summary_spread_attn": (self.summary_spread_attn, "summary"), - "cross_attention": (self.dense_attn, None), - "prime_attn": (self.prime_attn, "prime"), - } - self.attn, self.attn_mask = ATTENTION_MAP[attn_func] - - self.blocks = config.blocks - self.spread = config.spread - if self.blocks is not None: - self.block_ctx = self.n_ctx // self.blocks - - self.sample_t = 0 - self.cache = {} - self.encoder_len = config.nb_relevant_lyric_tokens # length of the encoder input ids - self.record_attn = False - - def _attn(self, query_states, key_states, value_states, sample): - scale = self.scale - if self.training: - attention_weight = ops.matmul(query_states * scale, key_states * scale) - else: - attention_weight = ops.matmul(query_states, key_states) - attention_weight.mul_(scale * scale) - attn_weight_type = attention_weight.dtype - attention_weight = attention_weight.float() - if self.mask: - # Generate appropriate mask to mask out all positions before current - # Might take up lot of memory for dense, so can cache it - mask = get_mask( - self.attn_mask, - query_states.shape[-2], - key_states.shape[-1], - self.blocks, - self.spread, - attention_weight, - sample, - self.sample_t, - ) - if mask is not None: - attention_weight = attention_weight * mask + -1e9 * (1 - mask) - attention_prob = F.softmax(attention_weight, dim=-1).type(attn_weight_type) - if self.record_attn: - self.attention_prob = attention_prob - if self.attn_func == "prime_attn": - # only keep music queries and lyrics keys/values - self.attention_prob = self.attention_prob[:, :, self.encoder_len :, : self.encoder_len] - attention_prob = self.attn_dropout(attention_prob) - context_states = ops.matmul(attention_prob, value_states) - return context_states - - def merge_heads(self, hidden_states): - hidden_states = hidden_states.permute(0, 2, 1, 3).contiguous() - new_hidden_states_shape = (*hidden_states.shape[:-2], hidden_states.shape[-2] * hidden_states.shape[-1]) - return hidden_states.view(*new_hidden_states_shape) # in Tensorflow implem: fct merge_states - - def split_heads(self, hidden_states, is_key=False): - new_hidden_states_shape = ( - *hidden_states.shape[:-1], - self.n_heads, - hidden_states.shape[-1] // self.n_heads, - ) - hidden_states = hidden_states.view(*new_hidden_states_shape) # in Tensorflow implem: fct split_states - if is_key: - return hidden_states.permute(0, 2, 3, 1) - else: - return hidden_states.permute(0, 2, 1, 3) - - def dense_attn(self, query, key, value, sample): - query = self.split_heads(query) - key = self.split_heads(key, is_key=True) - value = self.split_heads(value) - context_states = self._attn(query, key, value, sample) - context_states = self.merge_heads(context_states) - return context_states - - def block_attn(self, query, key, value, sample): - block_ctx = self.block_ctx - batch_size, seq_len, embed_dim = value.shape # For sample, query_len= 1, key_len = value_len = sample_t - if sample: - return self.dense_attn(query, key, value, sample).view(batch_size, 1, embed_dim) - else: - query_length = query.shape[1] - query = query.view(batch_size * query_length // block_ctx, block_ctx, embed_dim) - if query_length < seq_len: - seq_len = query_length - key = key[:, -seq_len:].contiguous() - value = value[:, -seq_len:].contiguous() - key = key.view(batch_size * seq_len // block_ctx, block_ctx, embed_dim) - value = value.view(batch_size * seq_len // block_ctx, block_ctx, embed_dim) - return self.dense_attn(query, key, value, sample).view(batch_size, seq_len, embed_dim) - - def transpose_block_attn(self, query, key, value, sample): - block_ctx = self.block_ctx - batch_size, seq_len, embed_dim = value.shape # For sample, query_len= 1, key_len = value_len = sample_t - if sample: - block_len = (seq_len - 1) % block_ctx - key = key[:, block_len::block_ctx, :] - value = value[:, block_len::block_ctx, :] - return self.dense_attn(query, key, value, sample).view(batch_size, 1, embed_dim) - else: - query_length = query.shape[1] - query = query.view(batch_size, query_length // block_ctx, block_ctx, embed_dim) - query = query.transpose(1, 2).contiguous() - query = query.view(batch_size * block_ctx, query_length // block_ctx, embed_dim) - - key = key.view(batch_size, seq_len // block_ctx, block_ctx, embed_dim) - key = key.transpose(1, 2).contiguous() - key = key.view(batch_size * block_ctx, seq_len // block_ctx, embed_dim) - - value = value.view(batch_size, seq_len // block_ctx, block_ctx, embed_dim) - value = value.transpose(1, 2).contiguous() - value = value.view(batch_size * block_ctx, seq_len // block_ctx, embed_dim) - - block_attn = self.dense_attn(query, key, value, sample) - block_attn = block_attn.view(batch_size, block_ctx, query_length // block_ctx, embed_dim) - block_attn = block_attn.transpose(1, 2).contiguous() - block_attn = block_attn.view(batch_size, query_length, embed_dim) - - return block_attn - - def prev_block_attn(self, query, key, value, sample): - block_ctx = self.block_ctx - batch_size, seq_len, embed_dim = value.shape # For sample, query_len= 1, key_len = value_len = sample_t - if sample: - block = (seq_len - 1) // block_ctx - prev_l = (block - 1) * block_ctx - if block > 0: - key = key[:, prev_l : prev_l + block_ctx, :] - value = value[:, prev_l : prev_l + block_ctx, :] - else: - key = ops.zeros(batch_size, block_ctx, embed_dim, dtype=query.dtype) - value = ops.zeros(batch_size, block_ctx, embed_dim, dtype=query.dtype) - return self.dense_attn(query, key, value, sample).view(batch_size, 1, embed_dim) - else: - query_length = query.shape[1] - query = query.view(batch_size * query_length // block_ctx, block_ctx, embed_dim) - - key = key.view(batch_size, seq_len // block_ctx, block_ctx, embed_dim)[:, :-1, :, :] - key = ops.pad(key, (0, 0, 0, 0, 1, 0)) - key = key.view(batch_size * seq_len // block_ctx, block_ctx, embed_dim) - - value = value.view(batch_size, seq_len // block_ctx, block_ctx, embed_dim)[:, :-1, :, :] - value = ops.pad(value, (0, 0, 0, 0, 1, 0)) - value = value.view(batch_size * seq_len // block_ctx, block_ctx, embed_dim) - - if query_length < seq_len: - nb_query_blocks = query_length // block_ctx - nb_key_blocks = seq_len // block_ctx - seq_len = query_length - key = key.view(batch_size, nb_key_blocks, block_ctx, embed_dim)[:, -nb_query_blocks:] - key = key.contiguous().view(batch_size * nb_query_blocks, block_ctx, embed_dim) - - value = value.view(batch_size, nb_key_blocks, block_ctx, embed_dim)[:, -nb_query_blocks:] - value = value.contiguous().view(batch_size * nb_query_blocks, block_ctx, embed_dim) - - return self.dense_attn(query, key, value, sample).view(batch_size, seq_len, embed_dim) - - def summary_attn(self, query, key, value, sample): - blocks = self.blocks - block_ctx = self.block_ctx - batch_size, seq_len, embed_dim = value.shape # For sample, query_len= 1, key_len = value_len = sample_t - if sample: - key = key[:, block_ctx - 1 : blocks * block_ctx - 1 : block_ctx, :] - key = ops.pad(key, (0, 0, 1, 0)) - - value = value[:, block_ctx - 1 : blocks * block_ctx - 1 : block_ctx, :] - value = ops.pad(value, (0, 0, 1, 0)) - return self.dense_attn(query, key, value, sample).view(batch_size, 1, embed_dim) - else: - key = key.view(batch_size, blocks, seq_len // blocks, embed_dim)[:, :-1, -1, :] - key = ops.pad(key, (0, 0, 1, 0)) # batch_size, blocks, embed_dim - - value = value.view(batch_size, blocks, seq_len // blocks, embed_dim)[:, :-1, -1, :] - value = ops.pad(value, (0, 0, 1, 0)) # batch_size, blocks, embed_dim - return self.dense_attn(query, key, value, sample).view(batch_size, seq_len, embed_dim) - - def summary_spread_attn(self, query, key, value, sample): - blocks = self.blocks - spread = self.spread - - batch_size, seq_len, embed_dim = value.shape # For sample, query_len= 1, key_len = value_len = sample_t - if sample: - raise NotImplementedError - else: - key = key.view(batch_size, blocks, seq_len // blocks, embed_dim)[:, :-1, -spread:, :] - key = ops.pad(key, (0, 0, 0, 0, 1, 0)).contiguous() - key = key.view(batch_size, blocks * spread, embed_dim) - - value = value.view(batch_size, blocks, seq_len // blocks, embed_dim)[:, :-1, -spread:, :] - value = ops.pad(value, (0, 0, 0, 0, 1, 0)).contiguous() - value = value.view(batch_size, blocks * spread, embed_dim) - - return self.dense_attn(query, key, value, sample).view(batch_size, seq_len, embed_dim) - - def prime_attn(self, query, key, value, sample): - encoder_len = self._encoder_len - key = key[:, :encoder_len] - value = value[:, :encoder_len] - return self.dense_attn(query, key, value, sample) - - def factored_qkv(self, hidden_states, last_encoder_hidden_states=None, sample=False): - curr_ctx = hidden_states.shape[1] - if last_encoder_hidden_states is not None: - raise TypeError("last_encoder_hidden_states should be None") - - query, key, value = hidden_states.chunk(3, dim=2) - if sample: - self.sample_t += curr_ctx - key, value = self._append_cache(key, value) - l_cache = self._suff_cache_len() - if self._cache_len() > l_cache: - self._slice_cache(-l_cache) - if curr_ctx > 1: - if self.attn_func != "dense_attn": - query = self._pad_to_block_ctx(query, query=True) - key = self._pad_to_block_ctx(key) - value = self._pad_to_block_ctx(value) - sample = False - else: - key = self.cache["key"] - value = self.cache["value"] - return query, key, value, sample - - def prime_qkv(self, hidden_states, last_encoder_hidden_states=None, sample=False): - curr_ctx = hidden_states.shape[1] - if last_encoder_hidden_states is not None: - raise TypeError("last_encoder_hidden_states should be None") - query, key, value = hidden_states.chunk(3, dim=2) - if sample: - if self._cache_len() < self._encoder_len: - self._append_cache(key, value) - if self._cache_len() > self._encoder_len: - self._slice_cache(0, self._encoder_len) - key, value = self.cache["key"], self.cache["value"] - self.sample_t += curr_ctx - return query, key, value, sample - - def decode_qkv(self, hidden_states, last_encoder_hidden_states=None, sample=False): - curr_ctx = hidden_states.shape[1] - query = hidden_states - if sample: - if self.sample_t == 0: - self.cache["key"], self.cache["value"] = self.c_enc_kv( - last_encoder_hidden_states.type_as(hidden_states) - ).chunk(2, dim=2) - key, value = self.cache["key"], self.cache["value"] - self.sample_t += curr_ctx - else: - key, value = self.c_enc_kv(last_encoder_hidden_states.type_as(hidden_states)).chunk(2, dim=2) - return query, key, value, sample - - def forward(self, hidden_states, last_encoder_hidden_states=None, sample=False): - curr_ctx = hidden_states.shape[1] - hidden_states = self.c_attn(hidden_states) - query, key, value, sample = self.qkv( - hidden_states, last_encoder_hidden_states=last_encoder_hidden_states, sample=sample - ) - attention_scores = self.attn(query, key, value, sample) - if attention_scores.shape[1] != curr_ctx: - offset = self._offset(curr_ctx) - attention_scores = attention_scores[:, offset : offset + curr_ctx, :].contiguous() - attention_scores = self.c_proj(attention_scores) - return self.resid_dropout(attention_scores) - - @property - def _encoder_len(self): - encoder_len = self.encoder_len - encoder_blocks = (encoder_len // self.blocks) + 1 - return encoder_blocks * self.blocks - - def _offset(self, curr_ctx): - if self.attn_func == "dense_attn": - return 0 - return (self.sample_t - curr_ctx) % self.block_ctx - - def _pad_to_block_ctx(self, hidden_states, query=False): - seq_len = hidden_states.shape[1] - offset = self._offset(seq_len) if query else 0 - n_blocks = (seq_len + offset + self.block_ctx - 1) // self.block_ctx - pad = n_blocks * self.block_ctx - seq_len - offset - if pad == 0 and offset == 0: - return hidden_states - else: - return F.pad(hidden_states, (0, 0, offset, pad)) - - def _cache_len(self): - return 0 if "key" not in self.cache else self.cache["key"].shape[1] - - def _suff_cache_len(self): - """ - Precondition: - key and value are appended with the current context and self.sample_t reflects the 1-indexed sample - location in the context. - """ - previous_block_length = (self.sample_t - 1) % self.block_ctx + 1 + self.block_ctx - REQUIRED_CACHE_LEN = { - "dense_attn": self.sample_t, - "block_attn": (self.sample_t - 1) % self.block_ctx + 1, - "transpose_block_attn": self.sample_t, - "prev_block_attn": self.sample_t if self.sample_t <= self.block_ctx else previous_block_length, - "cross_attn": self.encoder_len, - "prime_attn": min(self.sample_t, self._encoder_len), - } - - return REQUIRED_CACHE_LEN[self.attn_func] - - def _slice_cache(self, start, end=None): - self.cache["key"] = self.cache["key"][:, start:end] - self.cache["value"] = self.cache["value"][:, start:end] - - def _append_cache(self, key, value): - if "key" not in self.cache: - self.cache["key"] = key - self.cache["value"] = value - else: - old_key, old_value = key, value - key = ops.cat([self.cache["key"], old_key], dim=1) - value = ops.cat([self.cache["value"], old_value], dim=1) - del self.cache["key"] - del self.cache["value"] - del old_key - del old_value - self.cache["key"] = key - self.cache["value"] = value - return self.cache["key"], self.cache["value"] - - def del_cache(self): - self.sample_t = 0 - if "key" in self.cache: - del self.cache["key"] - if "value" in self.cache: - del self.cache["value"] - self.cache = {} - - -class JukeboxBlock(nn.Module): - def __init__(self, config, n_ctx, attn_func="dense_attn"): - super().__init__() - self.width = config.hidden_size - self.attn = JukeboxAttention(config, n_ctx, attn_func=attn_func) - - self.layer_norm_0 = JukeboxLayerNorm(config.hidden_size) - self.mlp = JukeboxMLP(config) - self.layer_norm_1 = JukeboxLayerNorm(config.hidden_size) - self.res_scale = 1.0 / config.num_layers if config.attn_res_scale else 1.0 - self.attn_func = attn_func - - def forward(self, hidden_states, last_encoder_hidden_states, sample=False): - residuals = hidden_states - hidden_states = self.layer_norm_0(hidden_states) - hidden_states = self.attn(hidden_states, last_encoder_hidden_states, sample) - - output_states = self.layer_norm_1(residuals + hidden_states) - output_states = self.mlp(output_states) - if self.res_scale == 1.0: - output = residuals + hidden_states + output_states - else: - output = residuals + self.res_scale * (hidden_states + output_states) - return output - - -class JukeboxLayerStack(nn.Module): - def __init__(self, config, n_ctx): - super().__init__() - self.n_ctx = n_ctx - self.width = config.hidden_size - self.num_layers = config.num_layers - self.blocks = config.blocks - self.attention_pattern = config.attention_pattern - if self.blocks is not None: - self.block_ctx = n_ctx // self.blocks - self.encoder_len = config.nb_relevant_lyric_tokens - self.n_heads = config.n_heads - - # Orders of attn_func - attention_pattern = ATTENTION_PATTERNS[self.attention_pattern] - self._attn_mods = nn.ModuleList() - for depth in range(self.num_layers): - self._attn_mods.append(JukeboxBlock(config, n_ctx, attn_func=attention_pattern(depth))) - - self.saved_attn_weights = [] - - def set_record_attn(self, record_attn): - """ - Makes forward prop dump self-attention softmaxes to self.saved_attn_weights. - - Args: - record_attn (`Union[bool,set]`): - Either a set of layer indices indicating which layers to store, or a boolean value indicating Whether - to dump all. - """ - - def _should_record_attn(layer_idx): - if isinstance(record_attn, bool): - return record_attn - return layer_idx in record_attn - - for i, layer in enumerate(self._attn_mods): - layer.attn.record_attn = _should_record_attn(i) - - if not record_attn: - self.saved_attn_weights = [] - - def forward(self, hidden_states, last_encoder_hidden_states=None, sample=False): - # Blocks - for i, attn_layer in enumerate(self._attn_mods): - if attn_layer.attn_func == "cross_attention": # attend to the lyrics - hidden_states = attn_layer( - hidden_states, last_encoder_hidden_states=last_encoder_hidden_states, sample=sample - ) - else: - hidden_states = attn_layer(hidden_states, last_encoder_hidden_states=None, sample=sample) - if attn_layer.attn.record_attn: - self.saved_attn_weights.append(attn_layer.attn.c_attn.weight) - return hidden_states - - def del_cache(self): - for attn_layer in self._attn_mods: - attn_layer.attn.del_cache() - - -class JukeboxPositionalEmbedding(nn.Module): - def __init__(self, embed_dim, width): - super().__init__() - self.pos_emb = nn.Parameter(ops.empty((embed_dim, width))) - - def forward(self): - pos_emb = self.pos_emb - return pos_emb - - -class JukeboxConditionalAutoregressive(nn.Module): - def __init__( - self, - config, - n_ctx=None, - embed_dim=None, - audio_conditioning=False, - metadata_conditioning=False, - is_encoder=False, - ): - """ - Autoregressive model on either lyric tokens or music tokens, or both. The attention pattern should be properly - set fro each configuration. - - Args: - config (`JukeboxPriorConfig`): - Model configuration class with all the parameters of the model. Initializing with a config file does - not load the weights associated with the model, only the configuration. Check out the - [`~PreTrainedModel.from_pretrained`] method to load the model weights. - n_ctx (`int`, *optional*): - Number of tokens or lyrics tokens provided in a single pass. - embed_dim (`int`, *optional*): - Either equals to the dimension of the codebook, or the sum of n_vocab (lyrics) and codeboook dimension, - if the model combines lyrics and music tokens, or simply n_vocab if the model is a seperate encoder - audio_conditioning (`bool`, *optional*, defaults to `False`): - Whether or not the prior supports conditionning on audio. - metadata_conditioning (`bool`, *optional*, defaults to `False`): - Whether or not the prior supports conditionning on artitst, genres, lyrics and timing. - is_encoder (`bool`, *optional*, defaults to `False`): - Whether the model is an encoder only model. - """ - - super().__init__() - self.width = config.hidden_size - self.num_layers = config.num_layers - self.n_ctx = n_ctx if n_ctx is not None else config.n_ctx - self.embed_dim = embed_dim if embed_dim is not None else config.music_vocab_size - self.embed_tokens = nn.Embedding(self.embed_dim, config.hidden_size) - self.embed_tokens_dropout = nn.Dropout(config.emb_dropout) - self.metadata_conditioning = metadata_conditioning - self.audio_conditioning = audio_conditioning - if not metadata_conditioning: - self.start_token = nn.Parameter(ops.empty((1, config.hidden_size))) - self.pos_emb = JukeboxPositionalEmbedding(self.n_ctx, config.hidden_size) - self.pos_emb_dropout = nn.Dropout(config.emb_dropout) - - self.transformer = JukeboxLayerStack(config, n_ctx=self.n_ctx) - self.is_encoder = is_encoder - self.encoder_len = config.nb_relevant_lyric_tokens - - if config.merged_decoder: - # Merged piped model uses this setup - self.add_cond_after_transformer = False - self.share_embed_tokens_fc_proj_out = False - else: - self.add_cond_after_transformer = True - self.share_embed_tokens_fc_proj_out = True - - if not is_encoder: - self.fc_proj_out = nn.Linear(config.hidden_size, self.embed_dim, bias=False) - if self.share_embed_tokens_fc_proj_out: - self.fc_proj_out.weight = self.embed_tokens.weight - self.loss = nn.CrossEntropyLoss() - - def forward( - self, - tokens, - audio_conditioning=None, - metadata_conditioning=None, - last_encoder_hidden_states=None, - get_preds=False, - get_acts=False, - get_sep_loss=False, - ): - """ - Args: - tokens (`mindspore.tensor`): - Can represent music tokens, lyrics tokens or both, depending on the configuration. - """ - # Preprocess. - batch_size = tokens.shape[0] - with no_grad(): - tokens = tokens.view(batch_size, -1).long() - - if not self.audio_conditioning: - audio_conditioning = ops.zeros( - (batch_size, 1, self.width), - dtype=self.transformer._attn_mods[0].mlp.c_fc.weight.dtype, - ) - - target = tokens # Target - hidden_states = self.embed_tokens(tokens) - # Shift by 1, and fill in start token - hidden_states = ops.cat((hidden_states[:, -1:], hidden_states[:, :-1]), dim=1) - if self.metadata_conditioning: - hidden_states[:, 0] = metadata_conditioning.view(batch_size, self.width) - else: - hidden_states[:, 0] = self.start_token - - hidden_states = ( - self.embed_tokens_dropout(hidden_states) + self.pos_emb_dropout(self.pos_emb()) + audio_conditioning - ) # Pos emb and dropout - - hidden_states = self.transformer( - hidden_states, last_encoder_hidden_states=last_encoder_hidden_states - ) # Transformer - if self.add_cond_after_transformer: # Piped doesnt add x_cond - hidden_states = hidden_states + audio_conditioning - - activations = hidden_states - if self.is_encoder: - return hidden_states - - hidden_states = self.fc_proj_out(hidden_states) # Predictions - loss_fn = nn.CrossEntropyLoss() - if get_sep_loss: - lyric_hidden_states = hidden_states[:, : self.encoder_len].reshape(-1, self.embed_dim) - token_hidden_states = hidden_states[:, self.encoder_len :].reshape(-1, self.embed_dim) - - lyric_loss = loss_fn(lyric_hidden_states, target[:, : self.encoder_len].reshape(-1)) / np.log(2.0) - music_token_loss = loss_fn(token_hidden_states, target[:, self.encoder_len :].reshape(-1)) / np.log(2.0) - - loss = (lyric_loss, music_token_loss) # Note order! Lyric is first - else: - loss = loss_fn(hidden_states.view(-1, self.embed_dim), target.view(-1)) / np.log(2.0) # Loss - - if get_preds: - return loss, hidden_states - elif get_acts: - return loss, activations - else: - return loss, None - - def get_emb(self, sample_t, n_samples, tokens, audio_conditioning, metadata_conditioning): - if sample_t == 0: - hidden_states = ops.zeros(n_samples, 1, self.width, dtype=self.embed_tokens.weight.dtype).to( - self.embed_tokens.weight - ) - if self.metadata_conditioning: - hidden_states[:, 0] = metadata_conditioning.view(n_samples, self.width) - else: - hidden_states[:, 0] = self.start_token - else: - hidden_states = self.embed_tokens(tokens) - if audio_conditioning.shape == (n_samples, self.n_ctx, self.width): - cond = audio_conditioning[:, sample_t : sample_t + 1, :] - else: - cond = audio_conditioning - # Pos emb, dropout is identity at eval time - hidden_states = hidden_states + self.pos_emb()[sample_t : sample_t + 1] + cond - return hidden_states, cond - - def sample( - self, - n_samples, - audio_conditioning=None, - metadata_conditioning=None, - last_encoder_hidden_states=None, - temp=1.0, - top_k=0, - top_p=0.0, - get_preds=False, - sample_tokens=None, - ): - if sample_tokens is None: - sample_tokens = self.n_ctx - - if not self.audio_conditioning: - audio_conditioning = ops.zeros( - (n_samples, 1, self.width), dtype=self.transformer._attn_mods[0].mlp.c_fc.weight.dtype - ).to(self.fc_proj_out) - - with no_grad(): - sampled_tokens = [] - tokens = None - if get_preds: - preds = [] - - iter = tqdm(range(0, sample_tokens), leave=False) - for sample_t in iter: - iter.set_description(f"Ancestral sampling {sample_tokens} music tokens", refresh=True) - hidden_states, cond = self.get_emb( - sample_t, n_samples, tokens, audio_conditioning, metadata_conditioning - ) - - hidden_states = self.transformer( - hidden_states, last_encoder_hidden_states=last_encoder_hidden_states, sample=True - ) - if self.add_cond_after_transformer: - hidden_states = hidden_states + cond - hidden_states = self.fc_proj_out(hidden_states) # Predictions - if get_preds: - preds.append(hidden_states.clone()) - # Adjust logits - hidden_states = hidden_states / temp - hidden_states = filter_logits(hidden_states, top_k=top_k, top_p=top_p) - # Sample and replace hidden_states - tokens = distributions.Categorical(logits=hidden_states).sample() - sampled_tokens.append(tokens.clone()) - - del tokens - self.transformer.del_cache() - - tokens = ops.cat(sampled_tokens, dim=1) - if get_preds: - preds = ops.cat(preds, dim=1) - if get_preds: - return tokens, preds - else: - return tokens - - def split_chunks(self, length, chunk_size): - n_passes = (length + chunk_size - 1) // chunk_size - chunk_sizes = [*[chunk_size] * (n_passes - 1), (length - 1) % chunk_size + 1] - return chunk_sizes - - def primed_sample( - self, - n_samples, - lyric_and_music_tokens, - audio_conditioning=None, - metadata_conditioning=None, - last_encoder_hidden_states=None, - temp=1.0, - top_k=0, - top_p=0.0, - get_preds=False, - chunk_size=None, - sample_tokens=None, - ): - if sample_tokens is None: - sample_tokens = self.n_ctx - # Preprocess. - batch_size = lyric_and_music_tokens.shape[0] - with no_grad(): - lyric_and_music_tokens = lyric_and_music_tokens.view(batch_size, -1).long() - - sampled_audio = ops.split(lyric_and_music_tokens, 1, dim=1) - sampled_audio = list(sampled_audio) - - if not self.audio_conditioning: - audio_conditioning = ops.zeros( - (n_samples, 1, self.width), dtype=self.transformer._attn_mods[0].mlp.c_fc.weight.dtype - ).to(lyric_and_music_tokens) - - with no_grad(): - if get_preds: - preds = [] - - # Fill up key/value cache for past context by runing forward pass. - # We do so in chunks instead of doing the whole past in one forward pass to reduce max memory usage. - if chunk_size is None: - chunk_size = len(sampled_audio) - chunk_sizes = self.split_chunks(len(sampled_audio), chunk_size) - x_primes = [] - start = 0 - token = None - - for current_chunk_size in tqdm(chunk_sizes, desc="Preparing past key value", leave=False): - sampled_audio_prime, conds_prime = [], [] - for sample_t in range(start, start + current_chunk_size): - x_prime, cond_prime = self.get_emb( - sample_t, n_samples, token, audio_conditioning, metadata_conditioning - ) - token = sampled_audio[sample_t] - sampled_audio_prime.append(x_prime) - conds_prime.append(cond_prime) - start = start + current_chunk_size - x_prime, cond_prime = ops.cat(sampled_audio_prime, dim=1), ops.cat(conds_prime, dim=1) - del sampled_audio_prime - del conds_prime - if not get_preds: - del cond_prime - x_prime = self.transformer(x_prime, last_encoder_hidden_states=last_encoder_hidden_states, sample=True) - - if get_preds: - if self.add_cond_after_transformer: - x_prime = x_prime + cond_prime - del cond_prime - x_primes.append(x_prime) - else: - del x_prime - - if get_preds: - x_prime = ops.cat(x_primes, dim=1) - x_prime = self.fc_proj_out(x_prime) # Predictions - preds.append(x_prime) - - # the input of the encoder and decoder can be merged into (lyrics, music tokens) - input_tokens = sampled_audio[-1] - - itererator = tqdm( - range(len(sampled_audio), sample_tokens), - desc=f"Sampling {len(range(len(sampled_audio), sample_tokens))} music tokens", - leave=False, - ) - for sample_t in itererator: - hidden_states, cond = self.get_emb( - sample_t, n_samples, input_tokens, audio_conditioning, metadata_conditioning - ) - - hidden_states = self.transformer( - hidden_states, last_encoder_hidden_states=last_encoder_hidden_states, sample=True - ) - if self.add_cond_after_transformer: - hidden_states = hidden_states + cond - hidden_states = self.fc_proj_out(hidden_states) # Predictions - if get_preds: - preds.append(hidden_states) - # Adjust logits - hidden_states = hidden_states / temp - hidden_states = filter_logits(hidden_states, top_k=top_k, top_p=top_p) - # only music tokens are sampled - music_tokens = distributions.Categorical(logits=hidden_states).sample() - sampled_audio.append(music_tokens.clone()) - input_tokens = music_tokens - - del input_tokens, music_tokens - self.transformer.del_cache() - - music_tokens = ops.cat(sampled_audio, dim=1) - if get_preds: - preds = ops.cat(preds, dim=1) - if get_preds: - return music_tokens, preds - else: - return music_tokens - - -class JukeboxMusicTokenConditioner(nn.Module): - """ - The `JukeboxMusicTokenConditioner` takes music tokens as an input (coresponding to the codes of the VQVAE's - codebook) and upsamples it using a single layer of decoder convolution block (the same is used in the VQVAE). - """ - - def __init__(self, config, level): - super().__init__() - self.embed_tokens = nn.Embedding(config.music_vocab_size, config.hidden_size) - config.embed_dim = config.music_vocab_size # setting correct argument for the `JukeboxDecoder` - - self.upsampler = JukeboxDecoderConvBock( - config, - config.hidden_size, - config.res_conv_width, - config.res_conv_depth, - config.res_downs_t[level], - config.res_strides_t[level], - reverse_dilation=False, - ) - self.layer_norm = JukeboxLayerNorm(config.hidden_size) - - def forward(self, music_tokens, raw_audio_conditionning=None): - """ - Args: - music_tokens (`mindspore.Tensor`): - Music tokens form the uper level in range(nb_discrete_codes) - raw_audio_conditionning (`mindspore.Tensor`, *optional*): - Audio used when primed sampling, raw audio information that conditions the generation - """ - if raw_audio_conditionning is None: - raw_audio_conditionning = 0.0 - # Embed music_tokens - music_tokens = music_tokens.long() - hidden_states = self.embed_tokens(music_tokens) - hidden_states = hidden_states + raw_audio_conditionning - - # Run conditioner - hidden_states = hidden_states.permute(0, 2, 1) - hidden_states = self.upsampler(hidden_states) - hidden_states = hidden_states.permute(0, 2, 1) - hidden_states = self.layer_norm(hidden_states) - return hidden_states - - -class JukeboxRangeEmbedding(nn.Module): - """ - The `JukeboxRangeEmbedding` interpolate the given [pos_start, pos_end] to obtain an equivalent of time positional - embedding of length `n_ctx`. - - Binning process : For each pos in position tensor, find its bin [start,end) mapped to [0,1,...,bins-1] [start,end) - -> [0,1) -> [0, bins) -> floor -> [0,...,bins-1] NOTE: Open ended interval on right, so start <= pos < end, not <= - end - """ - - def __init__(self, n_time, embed_dim, range, out_width, clamp=False): - super().__init__() - self.n_time = n_time - self.embed_dim = embed_dim - self.emb = nn.Embedding(embed_dim, out_width) - self.pos_min, self.pos_max = range - self.clamp = clamp - - def forward(self, pos_start, pos_end=None): - # Check if [pos_start,pos_end] in [pos_min, pos_max) - if not len(pos_start.shape) == 2: - raise TypeError(f"Expected shape with 2 dims, got {pos_start.shape}") - if not (self.pos_min <= pos_start).all() and (pos_start < self.pos_max).all(): - raise TypeError(f"Range is [{self.pos_min},{self.pos_max}), got {pos_start}") - - pos_start = pos_start.float() - if pos_end is not None: - if self.clamp: - pos_end = pos_end.clamp(self.pos_min, self.pos_max) - - pos_end = pos_end.float() - # Interpolate so that [pos_start, ..., pos_end] <-> position tensor of length n_ctx - n_time = self.n_time - if n_time != 1: - interpolation = ( - ops.arange(0, n_time, dtype=mindspore.float32).view(1, n_time) / n_time - ) - position = pos_start + (pos_end - pos_start) * interpolation - else: - position = pos_start - - # Bin each value to bins_ - # [0,1) -> [0,1..,embed_dim) -> [0,1...,embed_dim-1 - normalised_position = (position - self.pos_min) / (self.pos_max - self.pos_min) - bins_ = (self.embed_dim * normalised_position).floor().long().detach() - return self.emb(bins_) - - -class JukeboxLabelConditioner(nn.Module): - def __init__(self, config, include_time_signal): - super().__init__() - - embed_dim = config.hidden_size - timing_dims = config.timing_dims - sampling_rate = config.sampling_rate - nb_genres, nb_artists = config.metadata_dims - music_tokens_shape = config.n_ctx - - self.max_nb_genres = config.max_nb_genres - self.bow_genre_emb = nn.Embedding(nb_genres, embed_dim) - self.artist_emb = nn.Embedding(nb_artists, embed_dim) - self.include_time_signal = include_time_signal - if self.include_time_signal: - total_length_range = (config.min_duration * sampling_rate, config.max_duration * sampling_rate) - absolute_pos_range = (0.0, config.max_duration * sampling_rate) - relative_pos_range = (0.0, 1.0) - self.total_length_emb = JukeboxRangeEmbedding(1, timing_dims, total_length_range, embed_dim) - self.absolute_pos_emb = JukeboxRangeEmbedding( - music_tokens_shape, timing_dims, absolute_pos_range, embed_dim - ) - self.relative_pos_emb = JukeboxRangeEmbedding( - music_tokens_shape, timing_dims, relative_pos_range, embed_dim, clamp=True - ) - - def forward(self, metadata): - total_length = metadata[:, 0:1] - offset = metadata[:, 1:2] - length = metadata[:, 2:3] - artist = metadata[:, 3:4] - genre = metadata[:, 4:] - - # Start embedding of length 1 - artist_emb = self.artist_emb(artist) - # Empty genre slots are denoted by -1. We mask these out. - mask = (genre >= 0).float().unsqueeze(2) - genre_emb = (self.bow_genre_emb(genre.clamp(0)) * mask).sum(dim=1, keepdim=True) - start_emb = genre_emb + artist_emb - - # Pos embedding of length n_ctx - if self.include_time_signal: - start, end = offset, offset + length - total_length = total_length.float() - start = start.float() - end = end.float() - pos_emb = ( - self.total_length_emb(total_length) - + self.absolute_pos_emb(start, end) - + self.relative_pos_emb(start / total_length, end / total_length) - ) - else: - pos_emb = None - return start_emb, pos_emb - - -class JukeboxPrior(PreTrainedModel): - """ - The JukeboxPrior class, which is a wrapper around the various conditioning and the transformer. JukeboxPrior can be - seen as language models trained on music. They model the next `music token` prediction task. If a (lyric) `encoderù - is defined, it also models the `next character` prediction on the lyrics. Can be conditionned on timing, artist, - genre, lyrics and codes from lower-levels Priors. - - Args: - config (`JukeboxPriorConfig`): - Model configuration class with all the parameters of the model. Initializing with a config file does not - load the weights associated with the model, only the configuration. Check out the - [`~PreTrainedModel.from_pretrained`] method to load the model weights. - level (`int`, *optional*): - Current level of the Prior. Should be in range `[0,nb_priors]`. - nb_priors (`int`, *optional*, defaults to 3): - Total number of priors. - vqvae_encoder (`Callable`, *optional*): - Encoding method of the VQVAE encoder used in the forward pass of the model. Passing functions instead of - the vqvae module to avoid getting the parameters. - vqvae_decoder (`Callable`, *optional*): - Decoding method of the VQVAE decoder used in the forward pass of the model. Passing functions instead of - the vqvae module to avoid getting the parameters. - """ - - config_class = JukeboxPriorConfig - - def _init_weights(self, module): - init_scale = self.config.init_scale - - if isinstance(module, nn.Embedding): - module.weight.data.normal_(mean=0.0, std=0.02 * init_scale) - elif isinstance(module, JukeboxConv1D): - if self.config.zero_out: - module.weight.data.zero_() - else: - module.weight.data.normal_(mean=0.0, std=0.02 * init_scale) - elif isinstance(module, JukeboxPositionalEmbedding): - module.pos_emb.data.normal_(mean=0.0, std=0.01 * init_scale) - elif isinstance(module, JukeboxRangeEmbedding): - module.emb.weight.data.normal_(mean=0.0, std=0.01 * init_scale) - elif isinstance(module, JukeboxConditionalAutoregressive) and hasattr(module, "lm_head"): - module.lm_head.weight.data.normal_(mean=0.0, std=0.02 * init_scale) - elif isinstance(module, JukeboxConditionalAutoregressive) and hasattr(module, "start_token"): - module.start_token.data.normal_(mean=0.0, std=0.01 * init_scale) - elif isinstance(module, JukeboxResConv1DBlock) and self.config.zero_out: - module.conv1d_2.weigth.data.zero_() - module.conv1d_2.bias.data.zero_() - if isinstance(module, nn.LayerNorm): - module.bias.data.zero_() - module.weight.data.fill_(1.0) - if isinstance(module, nn.Linear) and module.bias is not None: - module.bias.data.zero_() - - def __init__(self, config: JukeboxPriorConfig, level=None, nb_priors=3, vqvae_encoder=None, vqvae_decoder=None): - super().__init__(config) - # Passing functions instead of the vqvae module to avoid getting params, only used in the - # forward loop - self.vqvae_encoder = vqvae_encoder - self.vqvae_decoder = vqvae_decoder - - self.levels = nb_priors - self.level = level if level is not None else config.level - - self.base_model_prefix = f"priors.{self.level}" - - self.n_ctx = config.n_ctx - - self.lyric_conditioning = config.nb_relevant_lyric_tokens > 0 - self.nb_relevant_lyric_tokens = config.nb_relevant_lyric_tokens - self.encoder_loss_fraction = config.encoder_loss_fraction - - # Audio conditioning : conditioning on music tokens (either from audio or from previous levels or both) - self.audio_conditioning = self.level != 0 - self.cond_level = self.level - 1 - if self.audio_conditioning: - self.conditioner_blocks = JukeboxMusicTokenConditioner(config, self.level) - - # metadata conditioning : contioning on timing, genres, and artist - self.metadata_conditioning = config.metadata_conditioning - if self.metadata_conditioning: - self.metadata_embedding = JukeboxLabelConditioner(config, include_time_signal=not self.audio_conditioning) - - # define encoder-decoder or encoder and decoder - self.is_encoder_decoder = config.is_encoder_decoder - if config.is_encoder_decoder: - # encoder-decoder transformer - self.input_shapes = [config.nb_relevant_lyric_tokens, config.n_ctx] - self.embed_dim_shift = [0, config.lyric_vocab_size] - self.width = config.hidden_size - - self.nb_relevant_lyric_tokens = config.nb_relevant_lyric_tokens - - self.prior = JukeboxConditionalAutoregressive( - config, - n_ctx=config.nb_relevant_lyric_tokens + config.n_ctx, - embed_dim=config.lyric_vocab_size + config.music_vocab_size, - audio_conditioning=(self.audio_conditioning or self.metadata_conditioning), - metadata_conditioning=True, - ) - - else: - # Separate encoder-decoder transformer - encoder_config = config.encoder_config - - if self.nb_relevant_lyric_tokens != 0 and self.lyric_conditioning: - self.lyric_acts_width = encoder_config.hidden_size - self.encoder_width = config.hidden_size - self.encoder_dim = config.lyric_vocab_size - self.encoder = JukeboxConditionalAutoregressive( - encoder_config, - n_ctx=self.nb_relevant_lyric_tokens, - embed_dim=self.encoder_dim, - audio_conditioning=False, - metadata_conditioning=False, - is_encoder=True, - ) - self.encoder.proj_in = JukeboxConv1D(encoder_config.hidden_size, config.hidden_size) - self.encoder.final_layer_norm = JukeboxLayerNorm(config.hidden_size) - self.encoder.lm_head = nn.Linear(config.hidden_size, config.lyric_vocab_size, bias=False) - else: - self.nb_relevant_lyric_tokens = 0 - - # decoder model on the tokens - self.prior = JukeboxConditionalAutoregressive( - config, - audio_conditioning=(self.audio_conditioning or self.metadata_conditioning), - metadata_conditioning=self.metadata_conditioning, - ) - - self.next_token_prediction_loss_dims = config.n_ctx - self.total_loss_dims = self.nb_relevant_lyric_tokens + self.next_token_prediction_loss_dims - - self.downsamples = [stride**down for stride, down in zip(config.res_strides_t, config.res_downs_t)] - self.cond_downsample = self.downsamples[self.level] if self.level != 0 else None - self.raw_to_tokens = np.prod(self.downsamples[: nb_priors - self.level]) - self.sample_length = self.n_ctx * self.raw_to_tokens - - logger.info( - f"Level:{self.level}, Cond downsample:{self.cond_downsample}, Raw to tokens:{self.raw_to_tokens}, Sample" - f" length:{self.sample_length}" - ) - - def get_metadata(self, labels, start, total_length, offset, get_indices=False): - metadata = labels.clone() - metadata[:, 0] = total_length - # Set sample_length to match this level - metadata[:, 2] = int(self.sample_length) - - # Set offset - metadata[:, 1:2] = int(offset * self.raw_to_tokens) + int(start * self.raw_to_tokens) - # here since metadata has the full token_list, we just need to selected the ones that are relevant - - # Set lyric tokens - metadata, indices = self.set_metadata_lyric_tokens(metadata) - if get_indices: - return metadata, indices - else: - return metadata - - def set_metadata_lyric_tokens(self, labels): - """ - Processes the full labels to only retreive the relevant lyric tokens and keep the metadata conditioning tokens. - """ - if self.nb_relevant_lyric_tokens > 0: - tokens_list = ops.zeros( - (labels.shape[0], self.nb_relevant_lyric_tokens), dtype=mindspore.int64) - indices_list = [] # whats the index of each current character in original array - for idx in range(labels.shape[0]): - full_tokens = labels.clone()[:, 4 + self.metadata_embedding.max_nb_genres :] - total_length, offset, duration = labels[idx, 0], labels[idx, 1], labels[idx, 2] - tokens, indices = get_relevant_lyric_tokens( - full_tokens, self.nb_relevant_lyric_tokens, total_length, offset, duration - ) - tokens_list[idx, :] = tokens - indices_list.append(indices) - - return ( - ops.cat((labels[:, : 4 + self.metadata_embedding.max_nb_genres], tokens_list), dim=-1), - indices_list, - ) - else: - return labels, None - - def get_music_tokens_conds(self, music_tokens, start, end): - """ - Extracts current level's conditioning music tokens. - """ - if self.level != 0: - music_tokens_cond = music_tokens[self.level - 1] - music_tokens = music_tokens_cond[:, start // self.cond_downsample : end // self.cond_downsample] - missing_cond_len = self.n_ctx // self.cond_downsample - music_tokens_cond[-1].shape[-1] - if missing_cond_len > 0: - init_cond = ops.zeros(1, missing_cond_len).to(music_tokens_cond) - music_tokens_cond = ops.cat((music_tokens_cond, init_cond), dim=-1).long() - music_tokens_conds = [music_tokens_cond] - else: - music_tokens_conds = None - return music_tokens_conds - - def prior_preprocess(self, tokens, conds): - """ - Shifts the input tokens to account for the dictionary merge. The embed_dim_shift give by how much the music - tokens should be shifted by. It is equal to `lyric_vocab_size`. - """ - batch_size = tokens[0].shape[0] - for i in range(len(tokens)): - tokens[i] = (tokens[i] + int(self.embed_dim_shift[i])).view(batch_size, -1) - - for i in range(len(conds)): - if conds[i] is None: - conds[i] = ops.zeros( - (batch_size, self.input_shapes[i], self.width), dtype=tokens[0].dtype) - - return ops.cat(tokens, dim=1), ops.cat(conds, dim=1) - - def prior_postprocess(self, tokens): - """ - Shifts back the input tokens if the model uses an encoder decoder architecture. As the embedding layer is - shared, `prior_embed_dim_shift` shifts the music token ids by `lyric_vocab_size`. Only returns the music - tokens. - """ - batch_size = tokens.shape[0] - dims = (self.input_shapes[0], tokens.shape[1] - self.input_shapes[0]) - tokens = list(ops.split(tokens, dims, dim=1)) - - # Some of the input tokens might be shifted to take into account the voccabulary fusion - for i in range(len(tokens)): - bins_shift = int(self.embed_dim_shift[i]) - tokens[i] = (tokens[i] - bins_shift).view(batch_size, -1) - tokens[i] = ops.clamp(tokens[i], min=0) - # If not masking loss, model may have generated lyric/midi tokens which are now shifted <0 by bin_shift - return tokens[-1] - - def embed_tokens(self, music_tokens_conds): - """ - Embeds the upper level music tokens and upsamples them to provide as audio conditioning. - """ - music_tokens_conds = music_tokens_conds[: self.cond_level + 1] - audio_conditioning = None - for music_tokens_cond, conditioner_block in reversed(list(zip(music_tokens_conds, [self.conditioner_blocks]))): - audio_conditioning = conditioner_block(music_tokens_cond, audio_conditioning) - return audio_conditioning - - def encode(self, hidden_states, start_level=None, end_level=None, bs_chunks=1): - """ - Encodes the hidden states (raw audio) using the VQVAE's encoder. Returns latent_states. - """ - if start_level is None: - start_level = self.level - if end_level is None: - end_level = self.levels - # Get latents - with no_grad(): - latent_states = self.vqvae_encoder( - hidden_states, start_level=start_level, end_level=end_level, bs_chunks=bs_chunks - ) - return latent_states - - def decode(self, music_tokens, start_level=None, end_level=None, bs_chunks=1): - """ - Usamples the sequence of codebook vectors to a raw audio. - """ - if start_level is None: - start_level = self.level - if end_level is None: - end_level = self.levels - with no_grad(): - output = self.vqvae_decoder( - music_tokens, start_level=start_level, end_level=end_level, bs_chunks=bs_chunks - ) - return output - - def get_cond(self, music_tokens_conds, metadata): - """ - Converts the input tokens to input_embeddings. Splits the lyrics form the rest of the metadata. Lyric tokens - can be None. - """ - if metadata is not None: - n_labels = metadata.shape[1] - self.nb_relevant_lyric_tokens - metadata, lyric_tokens = metadata[:, :n_labels], metadata[:, n_labels:] - else: - metadata, lyric_tokens = None, None - metadata_conditioning, metadata_pos = ( - self.metadata_embedding(metadata) if self.metadata_conditioning else (None, None) - ) - audio_conditioning = self.embed_tokens(music_tokens_conds) if self.audio_conditioning else metadata_pos - return audio_conditioning, metadata_conditioning, lyric_tokens - - def sample( - self, - n_samples, - music_tokens=None, - music_tokens_conds=None, - metadata=None, - temp=1.0, - top_k=0, - top_p=0.0, - chunk_size=None, - sample_tokens=None, - ): - """ - Ancestral/Prime sampling a window of tokens using the provided conditioning and metadatas. - - Args: - n_samples (`int`): - Number of samples to generate. - music_tokens (`List[mindspore.Tensor]`, *optional*): - Previously gemerated tokens at the current level. Used as context for the generation. - music_tokens_conds (`List[mindspore.Tensor]`, *optional*): - Upper-level music tokens generated by the previous prior model. Is `None` if the generation is not - conditionned on the upper-level tokens. - metadata (`List[mindspore.Tensor]`, *optional*): - List containing the metatdata tensor with the artist, genre and the lyric tokens. - temp (`float`, *optional*, defaults to 1.0): - Sampling temperature. - top_k (`int`, *optional*, defaults to 0): - Top k probabilities used for filtering. - top_p (`float`, *optional*, defaults to 0.0): - Top p probabilities used for filtering. - chunk_size (`int`, *optional*): - Size of the chunks used to prepare the cache of the transformer. - sample_tokens (`int`, *optional*): - Number of tokens to sample. - - """ - no_past_context = music_tokens is None or music_tokens.shape[1] == 0 - name = {True: "Ancestral", False: "Primed"}[no_past_context] - logger.info(f"{name} sampling {n_samples} samples with temp={temp}, top_k={top_k}, top_p={top_p}") - - with no_grad(): - # Currently audio_conditioning only uses immediately above layer - audio_conditioning, metadata_conditioning, lyric_tokens = self.get_cond(music_tokens_conds, metadata) - if self.is_encoder_decoder: - if no_past_context: # the prime_sample function will be used with music_tokens set to None - lyric_and_music_tokens, audio_conditioning = self.prior_preprocess( - [lyric_tokens], [None, audio_conditioning] - ) - else: - lyric_and_music_tokens, audio_conditioning = self.prior_preprocess( - [lyric_tokens, music_tokens], [None, audio_conditioning] - ) - if sample_tokens is not None: - sample_tokens += self.nb_relevant_lyric_tokens - music_tokens = self.prior.primed_sample( - n_samples, - lyric_and_music_tokens, - audio_conditioning, - metadata_conditioning, - temp=temp, - top_k=top_k, - top_p=top_p, - chunk_size=chunk_size, - sample_tokens=sample_tokens, - ) - music_tokens = self.prior_postprocess(music_tokens) - else: - last_encoder_hidden_states = self.get_encoder_states(lyric_tokens, sample=True) - if no_past_context: - music_tokens = self.prior.sample( - n_samples, - audio_conditioning, - metadata_conditioning, - last_encoder_hidden_states, - temp=temp, - top_k=top_k, - top_p=top_p, - sample_tokens=sample_tokens, - ) - else: - music_tokens = self.prior.primed_sample( - n_samples, - music_tokens, - audio_conditioning, - metadata_conditioning, - last_encoder_hidden_states, - temp=temp, - top_k=top_k, - top_p=top_p, - chunk_size=chunk_size, - sample_tokens=sample_tokens, - ) - return music_tokens - - def get_encoder_states(self, lyric_tokens, sample=False): - """ - Retreive the last hidden_states of the lyric encoder that will be attended to by the decoder. Forwards through - the lyric encoder. - """ - if self.nb_relevant_lyric_tokens != 0 and self.lyric_conditioning: - if sample: - self.encoder = self.encoder.to(lyric_tokens) - lyric_acts = self.encoder(lyric_tokens, None, None, None) - lyric_acts = self.encoder.proj_in(lyric_acts) - last_encoder_hidden_states = self.encoder.final_layer_norm(lyric_acts) - else: - last_encoder_hidden_states = None - return last_encoder_hidden_states - - def get_encoder_loss(self, last_encoder_hidden_states, target_lyrics): - """ - Computes the loss for the lyric encoder: next lyric token prediction. - """ - if self.lyric_conditioning: - last_encoder_hidden_states = self.encoder.lm_head(last_encoder_hidden_states) - encoder_loss = nn.functional.cross_entropy( - last_encoder_hidden_states.view(-1, self.encoder_dim), target_lyrics.view(-1) - ) / np.log(2.0) - else: - encoder_loss = mindspore.tensor(0.0) - return encoder_loss - - def forward_tokens( - self, music_tokens, music_tokens_conds=[], metadata=None, get_preds=False, get_attn_weights=False - ): - """ - Applies a forward pass using the conditioning tokens. Different from the classic forward as it does not use the - vqvae's encoding layers. - """ - if get_attn_weights: - self.prior.transformer.set_record_attn(get_attn_weights) - audio_conditioning, metadata_conditioning, lyric_tokens = self.get_cond(music_tokens_conds, metadata) - - if self.is_encoder_decoder: # the preprocess returns the full tokens (Lyrics and Music tokens), shifted - tokens, audio_conditioning = self.prior_preprocess( - [lyric_tokens, music_tokens], [None, audio_conditioning] - ) - (encoder_loss, next_token_prediction_loss), preds = self.prior( - tokens, audio_conditioning, metadata_conditioning, get_sep_loss=True, get_preds=get_preds - ) - else: - last_encoder_hidden_states = self.get_encoder_states(lyric_tokens) - encoder_loss = self.get_encoder_loss(last_encoder_hidden_states, lyric_tokens) - next_token_prediction_loss, preds = self.prior( - music_tokens, - audio_conditioning, - metadata_conditioning, - last_encoder_hidden_states, - get_preds=get_preds, - ) - loss = self.encoder_loss_fraction * encoder_loss * self.nb_relevant_lyric_tokens / self.total_loss_dims - loss += next_token_prediction_loss * self.next_token_prediction_loss_dims / self.total_loss_dims - - metrics = { - "bpd": next_token_prediction_loss.clone().detach(), - "encoder_loss": encoder_loss.clone().detach(), - "next_token_prediction_loss": next_token_prediction_loss.clone().detach(), - } - if get_preds: - metrics["preds"] = preds.clone().detach() - if get_attn_weights: - saved_attn_weights = self.prior.transformer.saved_attn_weights - self.prior.transformer.set_record_attn(False) - return saved_attn_weights - else: - return loss, metrics - - def forward( - self, - hidden_states: mindspore.Tensor, - metadata: Optional[List[mindspore.Tensor]], - decode: Optional[bool] = False, - get_preds: Optional[bool] = False, - ) -> List[mindspore.Tensor]: - """ - Encode the hidden states using the `vqvae` encoder, and then predicts the next token in the `forward_tokens` - function. The loss is the sum of the `encoder` loss and the `decoder` loss. - - Args: - hidden_states (`mindspore.Tensor`): - Hidden states which should be raw audio - metadata (`List[mindspore.Tensor]`, *optional*): - List containing the metadata conditioning tensorwith the lyric and the metadata tokens. - decode (`bool`, *optional*, defaults to `False`): - Whether or not to decode the encoded to tokens. - get_preds (`bool`, *optional*, defaults to `False`): - Whether or not to return the actual predicitons of the model. - """ - batch_size = hidden_states.shape[0] - music_tokens, *music_tokens_conds = self.encode(hidden_states, bs_chunks=batch_size) - loss, metrics = self.forward_tokens( - music_tokens=music_tokens, - music_tokens_conds=music_tokens_conds, - metadata=metadata, - get_preds=get_preds, - ) - if decode: - dequantised_states = self.decode([music_tokens, *music_tokens_conds]) - else: - dequantised_states = None - return dequantised_states, loss, metrics - - -class JukeboxPreTrainedModel(PreTrainedModel): - """ - An abstract class to handle weights initialization and a simple interface for downloading and loading pretrained - models. - """ - - config_class = JukeboxConfig - base_model_prefix = "jukebox" - supports_gradient_checkpointing = False - - def _init_weights(self, module): - if isinstance(module, (JukeboxPrior, JukeboxVQVAE)): - module.apply(module._init_weights) - - -class JukeboxModel(JukeboxPreTrainedModel): - _no_split_modules = ["JukeboxBlock"] - - def __init__(self, config): - super().__init__(config) - vqvae_config = config.vqvae_config - self.vqvae = JukeboxVQVAE(vqvae_config) - self.set_shared_params(config) - self.priors = nn.ModuleList( - [JukeboxPrior(config.prior_configs[level], level) for level in range(config.nb_priors)] - ) - - def set_shared_params(self, model_config): - """ - Initialises the parameters that are shared. This has to be done here because the list of `JukeboxPriorConfig` - is nest, and is thus unreachable in the `from_dict` function - """ - for config in model_config.prior_configs: - config.sampling_rate = model_config.sampling_rate - config.timing_dims = model_config.timing_dims - config.min_duration = model_config.min_duration - config.max_duration = model_config.max_duration - config.max_nb_genres = model_config.max_nb_genres - config.metadata_conditioning = model_config.metadata_conditioning - - def decode(self, music_tokens, start_level=0, end_level=None, bs_chunks=1): - return self.vqvae.decode(music_tokens, start_level, end_level, bs_chunks) - - def encode(self, input_audio, start_level=0, end_level=None, bs_chunks=1): - return self.vqvae.encode(input_audio, start_level, end_level, bs_chunks) - - def split_batch(self, obj, n_samples, split_size): - n_passes = (n_samples + split_size - 1) // split_size - if isinstance(obj, mindspore.Tensor): - return ops.split(obj, split_size, dim=0) - elif isinstance(obj, list): - return list(zip(*[ops.split(item, split_size, dim=0) for item in obj])) - elif obj is None: - return [None] * n_passes - else: - raise TypeError("Unknown input type") - - # Sample a partial window of length= self.priors[level].n_ctx: - iterator = get_starts(total_length, self.priors[level].n_ctx, hop_length) - for start in iterator: - music_tokens = self.sample_single_window( - music_tokens, labels, offset, sampling_kwargs, level, start, max_batch_size - ) - - else: - music_tokens = self.sample_partial_window( - music_tokens, labels, offset, sampling_kwargs, level, total_length, max_batch_size - ) - return music_tokens - - @no_grad() - def _sample( - self, - music_tokens, - labels, - sample_levels, - metas=None, - chunk_size=32, - sampling_temperature=0.98, - lower_batch_size=16, - max_batch_size=16, - sample_length_in_seconds=24, - compute_alignments=False, - sample_tokens=None, - offset=0, - save_results=True, - sample_length=None, - ) -> List[mindspore.Tensor]: - """ - Core sampling function used to generate music tokens. Iterates over the provided list of levels, while saving - the generated raw audio at each step. - - Args: - music_tokens (`List[mindspore.Tensor]`): - A sequence of music tokens of length `self.levels` which will be used as context to continue the - sampling process. Should have `self.levels` tensors, each corresponding to the generation at a certain - level. - labels (`List[mindspore.Tensor]`): - List of length `n_sample`, and shape `(self.levels, 4 + self.config.max_nb_genre + - lyric_sequence_length)` metadata such as `artist_id`, `genre_id` and the full list of lyric tokens - which are used to condition the generation. - sample_levels (`List[int]`): - List of the desired levels at which the sampling will be done. A level is equivalent to the index of - the prior in the list of priors - metas (`List[Any]`, *optional*): - Metadatas used to generate the `labels` - chunk_size (`int`, *optional*, defaults to 32): - Size of a chunk of audio, used to fill up the memory in chuncks to prevent OOM erros. Bigger chunks - means faster memory filling but more consumption. - sampling_temperature (`float`, *optional*, defaults to 0.98): - Temperature used to ajust the randomness of the sampling. - lower_batch_size (`int`, *optional*, defaults to 16): - Maximum batch size for the lower level priors - max_batch_size (`int`, *optional*, defaults to 16): - Maximum batch size for the top level priors - sample_length_in_seconds (`int`, *optional*, defaults to 24): - Desired length of the generation in seconds - compute_alignments (`bool`, *optional*, defaults to `False`): - Whether or not to compute the alignment between the lyrics and the audio using the top_prior - sample_tokens (`int`, *optional*): - Precise number of tokens that should be sampled at each level. This is mostly useful for running dummy - experiments - offset (`int`, *optional*, defaults to 0): - Audio offset used as conditioning, corresponds to the starting sample in the music. If the offset is - greater than 0, the lyrics will be shifted take that intoaccount - save_results (`bool`, *optional*, defaults to `True`): - Whether or not to save the intermediate results. If `True`, will generate a folder named with the start - time. - sample_length (`int`, *optional*): - Desired length of the generation in samples. - - Returns: mindspore.Tensor - - Example: - - ```python - >>> from transformers import AutoTokenizer, JukeboxModel, set_seed - >>> import torch - - >>> metas = dict(artist="Zac Brown Band", genres="Country", lyrics="I met a traveller from an antique land") - >>> tokenizer = AutoTokenizer.from_pretrained("openai/jukebox-1b-lyrics") - >>> model = JukeboxModel.from_pretrained("openai/jukebox-1b-lyrics", min_duration=0).eval() - - >>> labels = tokenizer(**metas)["input_ids"] - >>> set_seed(0) - >>> zs = [ops.zeros(1, 0, dtype=mindspore.int64) for _ in range(3)] - >>> zs = model._sample(zs, labels, [0], sample_length=40 * model.priors[0].raw_to_tokens, save_results=False) - >>> zs[0] - tensor([[1853, 1369, 1150, 1869, 1379, 1789, 519, 710, 1306, 1100, 1229, 519, - 353, 1306, 1379, 1053, 519, 653, 1631, 1467, 1229, 1229, 10, 1647, - 1254, 1229, 1306, 1528, 1789, 216, 1631, 1434, 653, 475, 1150, 1528, - 1804, 541, 1804, 1434]]) - ``` - """ - - top_prior = self.priors[0] - if sample_length is not None: - total_length = sample_length - else: - total_length = ( - int(sample_length_in_seconds * self.config.sampling_rate) // top_prior.raw_to_tokens - ) * top_prior.raw_to_tokens - - if sample_levels is None: - sample_levels = range(len(self.priors)) - - # total length of the signal, might be bit different from the actual generated length - self.total_length = total_length - for level in sample_levels: - sampling_kwargs = { - "temp": 0.99 if level == len(self.priors) - 1 else sampling_temperature, - "chunk_size": chunk_size, - "sample_tokens": sample_tokens, - } - # Set correct total_length, hop_length, labels and sampling_kwargs for level - - total_token_to_sample = total_length // self.priors[level].raw_to_tokens - hop_length = int(self.config.hop_fraction[level] * self.priors[level].n_ctx) - max_batch_size = lower_batch_size if level != sample_levels else max_batch_size - music_tokens = self.sample_level( - music_tokens, - labels[level], - offset, - sampling_kwargs, - level, - total_token_to_sample, - hop_length, - max_batch_size, - ) - - if save_results: - self.vqvae.to(music_tokens[level]) - # Decode sample - with no_grad(): - start_level = len(self.priors) - level - 1 # vqvae levels are reversed - raw_audio = self.vqvae.decode( - music_tokens[: level + 1], start_level=start_level, bs_chunks=music_tokens[level].shape[0] - ) - logdir = f"jukebox/level_{level}" - if not os.path.exists(logdir): - os.makedirs(logdir) - save_temp_audio(logdir, level, metas=metas, aud=raw_audio.float()) - if compute_alignments and self.priors[0] is not None and self.priors[0].nb_relevant_lyric_tokens > 0: - with no_grad(): - alignments = get_alignment(music_tokens, labels[0], self.priors[0], self.config) - mindspore.save_checkpoint({"alignments": alignments}, f"{logdir}/lyric_alignments.ckpt") - - return music_tokens - - def ancestral_sample(self, labels, n_samples=1, **sampling_kwargs) -> List[mindspore.Tensor]: - """ - Example: - - ```python - >>> from transformers import AutoTokenizer, JukeboxModel, set_seed - - >>> model = JukeboxModel.from_pretrained("openai/jukebox-1b-lyrics", min_duration=0).eval() - >>> tokenizer = AutoTokenizer.from_pretrained("openai/jukebox-1b-lyrics") - - >>> lyrics = "Hey, are you awake? Can you talk to me?" - >>> artist = "Zac Brown Band" - >>> genre = "Country" - >>> metas = tokenizer(artist=artist, genres=genre, lyrics=lyrics) - >>> set_seed(0) - >>> music_tokens = model.ancestral_sample(metas.input_ids, sample_length=400) - - >>> with no_grad(): - ... model.decode(music_tokens)[:, :10].squeeze(-1) - tensor([[-0.0219, -0.0679, -0.1050, -0.1203, -0.1271, -0.0936, -0.0396, -0.0405, - -0.0818, -0.0697]]) - ``` - """ - - sample_levels = sampling_kwargs.pop("sample_levels", list(range(len(self.priors)))) - music_tokens = [ - ops.zeros(n_samples, 0, dtype=mindspore.int64) for _ in range(len(self.priors)) - ] - music_tokens = self._sample(music_tokens, labels, sample_levels, **sampling_kwargs) - return music_tokens - - def continue_sample(self, music_tokens, labels, **sampling_kwargs) -> List[mindspore.Tensor]: - sample_levels = sampling_kwargs.pop("sample_levels", list(range(len(self.priors)))) - music_tokens = self._sample(music_tokens, labels, sample_levels, **sampling_kwargs) - return music_tokens - - def upsample(self, music_tokens, labels, **sampling_kwargs) -> List[mindspore.Tensor]: - sample_levels = sampling_kwargs.pop("sample_levels", list(range(len(self.priors) - 1))) - music_tokens = self._sample(music_tokens, labels, sample_levels, **sampling_kwargs) - return music_tokens - - def primed_sample(self, raw_audio, labels, **sampling_kwargs) -> List[mindspore.Tensor]: - sample_levels = sampling_kwargs.pop("sample_levels", list(range(len(self.priors)))) - self.vqvae.to(raw_audio).float() - with no_grad(): - music_tokens = self.vqvae.encode( - raw_audio, start_level=0, end_level=len(self.priors), bs_chunks=raw_audio.shape[0] - ) - music_tokens = self._sample(music_tokens, labels, sample_levels, **sampling_kwargs) - return music_tokens -__all__ = [ - "JukeboxModel", - "JukeboxPreTrainedModel", - "JukeboxVQVAE", - "JukeboxPrior", - ] diff --git a/mindnlp/transformers/models/jukebox/tokenization_jukebox.py b/mindnlp/transformers/models/jukebox/tokenization_jukebox.py deleted file mode 100644 index e2aca90b4..000000000 --- a/mindnlp/transformers/models/jukebox/tokenization_jukebox.py +++ /dev/null @@ -1,342 +0,0 @@ -# coding=utf-8 -# Copyright 2022 The Open AI Team Authors and The HuggingFace Inc. team. -# -# 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. -"""Tokenization classes for OpenAI Jukebox.""" - -import json -import os -import re -import unicodedata -from json.encoder import INFINITY -from typing import Any, Dict, List, Optional, Tuple - -import regex - -from ...tokenization_utils import AddedToken, PreTrainedTokenizer -from ...tokenization_utils_base import BatchEncoding -from ....utils import logging - - - -logger = logging.get_logger(__name__) - -VOCAB_FILES_NAMES = { - "artists_file": "artists.json", - "lyrics_file": "lyrics.json", - "genres_file": "genres.json", -} - - -class JukeboxTokenizer(PreTrainedTokenizer): - """ - Constructs a Jukebox tokenizer. Jukebox can be conditioned on 3 different inputs : - - Artists, unique ids are associated to each artist from the provided dictionary. - - Genres, unique ids are associated to each genre from the provided dictionary. - - Lyrics, character based tokenization. Must be initialized with the list of characters that are inside the - vocabulary. - - This tokenizer does not require training. It should be able to process a different number of inputs: - as the conditioning of the model can be done on the three different queries. If None is provided, defaults values will be used.: - - Depending on the number of genres on which the model should be conditioned (`n_genres`). - ```python - >>> from transformers import JukeboxTokenizer - - >>> tokenizer = JukeboxTokenizer.from_pretrained("openai/jukebox-1b-lyrics") - >>> tokenizer("Alan Jackson", "Country Rock", "old town road")["input_ids"] - [tensor([[ 0, 0, 0, 6785, 546, 41, 38, 30, 76, 46, 41, 49, - 40, 76, 44, 41, 27, 30]]), tensor([[ 0, 0, 0, 145, 0]]), tensor([[ 0, 0, 0, 145, 0]])] - ``` - - You can get around that behavior by passing `add_prefix_space=True` when instantiating this tokenizer or when you - call it on some text, but since the model was not pretrained this way, it might yield a decrease in performance. - - - - If nothing is provided, the genres and the artist will either be selected randomly or set to None - - - - This tokenizer inherits from [`PreTrainedTokenizer`] which contains most of the main methods. Users should refer to: - this superclass for more information regarding those methods. - - However the code does not allow that and only supports composing from various genres. - - Args: - artists_file (`str`): - Path to the vocabulary file which contains a mapping between artists and ids. The default file supports - both "v2" and "v3" - genres_file (`str`): - Path to the vocabulary file which contain a mapping between genres and ids. - lyrics_file (`str`): - Path to the vocabulary file which contains the accepted characters for the lyrics tokenization. - version (`List[str]`, `optional`, default to `["v3", "v2", "v2"]`) : - List of the tokenizer versions. The `5b-lyrics`'s top level prior model was trained using `v3` instead of - `v2`. - n_genres (`int`, `optional`, defaults to 1): - Maximum number of genres to use for composition. - max_n_lyric_tokens (`int`, `optional`, defaults to 512): - Maximum number of lyric tokens to keep. - unk_token (`str`, *optional*, defaults to `"<|endoftext|>"`): - The unknown token. A token that is not in the vocabulary cannot be converted to an ID and is set to be this - token instead. - """ - - vocab_files_names = VOCAB_FILES_NAMES - model_input_names = ["input_ids", "attention_mask"] - - def __init__( - self, - artists_file, - genres_file, - lyrics_file, - version=["v3", "v2", "v2"], - max_n_lyric_tokens=512, - n_genres=5, - unk_token="<|endoftext|>", - **kwargs, - ): - unk_token = AddedToken(unk_token, lstrip=False, rstrip=False) if isinstance(unk_token, str) else unk_token - self.version = version - self.max_n_lyric_tokens = max_n_lyric_tokens - self.n_genres = n_genres - self._added_tokens_decoder = {0: unk_token} - - with open(artists_file, encoding="utf-8") as vocab_handle: - self.artists_encoder = json.load(vocab_handle) - - with open(genres_file, encoding="utf-8") as vocab_handle: - self.genres_encoder = json.load(vocab_handle) - - with open(lyrics_file, encoding="utf-8") as vocab_handle: - self.lyrics_encoder = json.load(vocab_handle) - - oov = r"[^A-Za-z0-9.,:;!?\-'\"()\[\] \t\n]+" - # In v2, we had a n_vocab=80 and in v3 we missed + and so n_vocab=79 of characters. - if len(self.lyrics_encoder) == 79: - oov = oov.replace(r"\-'", r"\-+'") - - self.out_of_vocab = regex.compile(oov) - self.artists_decoder = {v: k for k, v in self.artists_encoder.items()} - self.genres_decoder = {v: k for k, v in self.genres_encoder.items()} - self.lyrics_decoder = {v: k for k, v in self.lyrics_encoder.items()} - super().__init__( - unk_token=unk_token, - n_genres=n_genres, - version=version, - max_n_lyric_tokens=max_n_lyric_tokens, - **kwargs, - ) - - @property - def vocab_size(self): - return len(self.artists_encoder) + len(self.genres_encoder) + len(self.lyrics_encoder) - - def get_vocab(self): - return { - "artists_encoder": self.artists_encoder, - "genres_encoder": self.genres_encoder, - "lyrics_encoder": self.lyrics_encoder, - } - - def _convert_token_to_id(self, list_artists, list_genres, list_lyrics): - """Converts the artist, genre and lyrics tokens to their index using the vocabulary. - The total_length, offset and duration have to be provided in order to select relevant lyrics and add padding to - the lyrics token sequence. - """ - artists_id = [self.artists_encoder.get(artist, 0) for artist in list_artists] - for genres in range(len(list_genres)): - list_genres[genres] = [self.genres_encoder.get(genre, 0) for genre in list_genres[genres]] - list_genres[genres] = list_genres[genres] + [-1] * (self.n_genres - len(list_genres[genres])) - - lyric_ids = [[self.lyrics_encoder.get(character, 0) for character in list_lyrics[0]], [], []] - return artists_id, list_genres, lyric_ids - - def _tokenize(self, lyrics): - """ - Converts a string into a sequence of tokens (string), using the tokenizer. Split in words for word-based - vocabulary or sub-words for sub-word-based vocabularies (BPE/SentencePieces/WordPieces). - - Do NOT take care of added tokens. Only the lyrics are split into character for the character-based vocabulary. - """ - # only lyrics are not tokenized, but character based is easily handled - return list(lyrics) - - def tokenize(self, artist, genre, lyrics, **kwargs): - """ - Converts three strings in a 3 sequence of tokens using the tokenizer - """ - artist, genre, lyrics = self.prepare_for_tokenization(artist, genre, lyrics) - lyrics = self._tokenize(lyrics) - return artist, genre, lyrics - - def prepare_for_tokenization( - self, artists: str, genres: str, lyrics: str, is_split_into_words: bool = False - ) -> Tuple[str, str, str, Dict[str, Any]]: - """ - Performs any necessary transformations before tokenization. - - Args: - artist (`str`): - The artist name to prepare. This will mostly lower the string - genres (`str`): - The genre name to prepare. This will mostly lower the string. - lyrics (`str`): - The lyrics to prepare. - is_split_into_words (`bool`, *optional*, defaults to `False`): - Whether or not the input is already pre-tokenized (e.g., split into words). If set to `True`, the - tokenizer assumes the input is already split into words (for instance, by splitting it on whitespace) - which it will tokenize. This is useful for NER or token classification. - """ - for idx in range(len(self.version)): - if self.version[idx] == "v3": - artists[idx] = artists[idx].lower() - genres[idx] = [genres[idx].lower()] - else: - artists[idx] = self._normalize(artists[idx]) + ".v2" - genres[idx] = [ - self._normalize(genre) + ".v2" for genre in genres[idx].split("_") - ] # split is for the full dictionary with combined genres - - if self.version[0] == "v2": - self.out_of_vocab = regex.compile(r"[^A-Za-z0-9.,:;!?\-'\"()\[\] \t\n]+") - vocab = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789.,:;!?-+'\"()[] \t\n" - self.vocab = {vocab[index]: index + 1 for index in range(len(vocab))} - self.vocab[""] = 0 - self.n_vocab = len(vocab) + 1 - self.lyrics_encoder = self.vocab - self.lyrics_decoder = {v: k for k, v in self.vocab.items()} - self.lyrics_decoder[0] = "" - else: - self.out_of_vocab = regex.compile(r"[^A-Za-z0-9.,:;!?\-+'\"()\[\] \t\n]+") - - lyrics = self._run_strip_accents(lyrics) - lyrics = lyrics.replace("\\", "\n") - lyrics = self.out_of_vocab.sub("", lyrics), [], [] - return artists, genres, lyrics - - def _run_strip_accents(self, text): - """Strips accents from a piece of text.""" - text = unicodedata.normalize("NFD", text) - output = [] - for char in text: - cat = unicodedata.category(char) - if cat == "Mn": - continue - output.append(char) - return "".join(output) - - def _normalize(self, text: str) -> str: - """ - Normalizes the input text. This process is for the genres and the artist - - Args: - text (`str`): - Artist or Genre string to normalize - """ - - accepted = ( - [chr(i) for i in range(ord("a"), ord("z") + 1)] - + [chr(i) for i in range(ord("A"), ord("Z") + 1)] - + [chr(i) for i in range(ord("0"), ord("9") + 1)] - + ["."] - ) - accepted = frozenset(accepted) - pattern = re.compile(r"_+") - text = "".join([c if c in accepted else "_" for c in text.lower()]) - text = pattern.sub("_", text).strip("_") - return text - - def convert_lyric_tokens_to_string(self, lyrics: List[str]) -> str: - return " ".join(lyrics) - - def __call__(self, artist, genres, lyrics="", return_tensors="pt") -> BatchEncoding: - """Convert the raw string to a list of token ids - - Args: - artist (`str`): - Name of the artist. - genres (`str`): - List of genres that will be mixed to condition the audio - lyrics (`str`, *optional*, defaults to `""`): - Lyrics used to condition the generation - """ - input_ids = [0, 0, 0] - artist = [artist] * len(self.version) - genres = [genres] * len(self.version) - - artists_tokens, genres_tokens, lyrics_tokens = self.tokenize(artist, genres, lyrics) - artists_id, genres_ids, full_tokens = self._convert_token_to_id(artists_tokens, genres_tokens, lyrics_tokens) - - attention_masks = [-INFINITY] * len(full_tokens[-1]) - input_ids = [ - self.convert_to_tensors( - [input_ids + [artists_id[i]] + genres_ids[i] + full_tokens[i]], tensor_type=return_tensors - ) - for i in range(len(self.version)) - ] - return BatchEncoding({"input_ids": input_ids, "attention_masks": attention_masks}) - - def save_vocabulary(self, save_directory: str, filename_prefix: Optional[str] = None) -> Tuple[str]: - """ - Saves the tokenizer's vocabulary dictionary to the provided save_directory. - - Args: - save_directory (`str`): - A path to the directory where to saved. It will be created if it doesn't exist. - - filename_prefix (`Optional[str]`, *optional*): - A prefix to add to the names of the files saved by the tokenizer. - - """ - if not os.path.isdir(save_directory): - logger.error(f"Vocabulary path ({save_directory}) should be a directory") - return - - artists_file = os.path.join( - save_directory, (filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["artists_file"] - ) - with open(artists_file, "w", encoding="utf-8") as f: - f.write(json.dumps(self.artists_encoder, ensure_ascii=False)) - - genres_file = os.path.join( - save_directory, (filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["genres_file"] - ) - with open(genres_file, "w", encoding="utf-8") as f: - f.write(json.dumps(self.genres_encoder, ensure_ascii=False)) - - lyrics_file = os.path.join( - save_directory, (filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["lyrics_file"] - ) - with open(lyrics_file, "w", encoding="utf-8") as f: - f.write(json.dumps(self.lyrics_encoder, ensure_ascii=False)) - - return (artists_file, genres_file, lyrics_file) - - def _convert_id_to_token(self, artists_index, genres_index, lyric_index): - """ - Converts an index (integer) in a token (str) using the vocab. - - Args: - artists_index (`int`): - Index of the artist in its corresponding dictionary. - genres_index (`Union[List[int], int]`): - Index of the genre in its corresponding dictionary. - lyric_index (`List[int]`): - List of character indices, which each correspond to a character. - """ - artist = self.artists_decoder.get(artists_index) - genres = [self.genres_decoder.get(genre) for genre in genres_index] - lyrics = [self.lyrics_decoder.get(character) for character in lyric_index] - return artist, genres, lyrics From 46a0bd469270d3e7da66853cc32bc294da636c5c Mon Sep 17 00:00:00 2001 From: 1hb6s7t <120760709+1hb6s7t@users.noreply.github.com> Date: Fri, 14 Feb 2025 16:48:04 +0800 Subject: [PATCH 17/20] Delete tests/transformers/models/jukebox/__pycache__ directory --- ...modeling_jukebox.cpython-39-pytest-7.2.0.pyc | Bin 14269 -> 0 bytes ...nization_jukebox.cpython-39-pytest-7.2.0.pyc | Bin 10226 -> 0 bytes 2 files changed, 0 insertions(+), 0 deletions(-) delete mode 100644 tests/transformers/models/jukebox/__pycache__/test_modeling_jukebox.cpython-39-pytest-7.2.0.pyc delete mode 100644 tests/transformers/models/jukebox/__pycache__/test_tokenization_jukebox.cpython-39-pytest-7.2.0.pyc diff --git a/tests/transformers/models/jukebox/__pycache__/test_modeling_jukebox.cpython-39-pytest-7.2.0.pyc b/tests/transformers/models/jukebox/__pycache__/test_modeling_jukebox.cpython-39-pytest-7.2.0.pyc deleted file mode 100644 index fe6f433cffecd083c033b18b5e49cb73039a8b5b..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 14269 zcmeHO37A|}m42_buBxu?bay&yV^V|=QzSG=SY(M5m;?+aovp)CMv6+m*RNlvw%qqR zp_^{DgheqZf(xL~4Mc5F7Exp`kWB_qK-?ZPqk_nkh@*p!%Am~u-&b2NiG0I1^Esb( zb)9$bx#ymH@44rkyPQ|4hK8_$KW*cej2li?l$V*Q{qrMp0>0MQ0W?KZ(@H{>Pfy0{ zQB)=4OZZi{B#;Q8#FGwW>JoJl=S>GQp+qPXPJ}b{iF%3ir6ZY!L_?`gV`7RP+NFry zl4nz*2~U5zDbt*2mK1?>OJ-_fYNj>OnwgfErYd^)WJRmfg1Z$hs0Vtd@AB?a6Eh?> zq=kVESFkfRb(0dSFQVs4M@)5m);2RA^E%T_E15B~nw8H9J(=2(GSjK8Y29fS`u08( zs7fKKq;oq_HE8K}($aMeX>TrXflK6+zHR!}+}Ue$nx3xY)(bNyoTgG)XKtIGH3xLj z#Xi*j`H(pQU+ZZAUCK1!(Y=sFtM2PovmQ-N_%#nC>eYOjUkiNRo2WA|@*C7d5YHf< zAv{BPhVcyJS&wHuo)J7FcsAhKfM+9~jd)JMa|)hKcsAkLT*9~D*^K;DJX`Q=#d9j2 z)9`G?bGkN7o4#8~%+O|NGx40M&C+J$IZJEP4#0D^_8x5xo^9G($UEw^mPWsHtCUTr zZrQpRRR(6}@_II99@gs$?$D)M4^8(Av&(w3F_G$uen8}QW}_cSWi_X6MXoPvi~gT| z)uSk@qZ!?frlPh;?aF zvQROrp=w`tTUxiQXj(U{Xs$bI*}1GPt8B7KVP>Otj~>-@OBZ%~)cthmDM55*aWvJvN69r|JnHkHYvNp}#al{UL|DGs~G%o>*4yH1S1hq90jW^!HIP{kd+i$yU6 zV!P$tx^|pwkAo^n2W?=kQ|ZO5hGur=gl0uk`8=u}D~Z?kN3*Gn9yP7#x`BQU)J#EA zA3`rE0X{94?V4O}8~JAXqo?J>HW2me(Y2=0WB0paLsR*bDGro;J92U)(XF~=YC43G zNts!zJ-QKkBnN?+?Mn4a+I8LT2q5m9Wu?;5(}do&ZEIcP=hO)@H zO6yQTXc(Laq$+e9qV9&0q;{5=k9rdU$jG$pM8MFqLbnnDSIJ`wiyy30l%f()6!QVt zzuCd;T6kE|0w-YBLD$W^7hn-^<}{{`1zmAE3;qq+;$9YPVBKDVCrAP>tQ4bc3l1wMb2n#H-dYq{+Ie!@aGlxj`7F)Xwsp8W} zVI0yZF9slioC|Hf08lNUJ&r%U&A|BxSgObca%gZ; zs<nt=cX8ENMO!1eH zL($?qzD4Q8NhHDXOufGhipPVbnw>PYoWum?Nt}>Q%Im~3PS!Ag1zEee3TKy%NpVoW({`j zz2w5I3s?;!xr!V&u$xJgn|lc^Lv6E*I-X&{)10gUf@9EtnP>Btu;45*<9wULB#wYY ze2BQU0LANA;04ZH%9hs=mm=rG$>sNK=uW1NB*?HEi%A?qN_4R9nViavOnsjP_mXZK zaK*=f6LVP5PJSOlUt$Z5JqurNcyP&R!FcFb*DYWC!p#Naz}rR76|aA#V7xW@+vnGA zy}e*4xeI)ced3OS@spp{Upaaq5@zl<7d_dD#3we{^FRAGXwG`&*?BMi>DGdAO2o71 zlIdW$=6xSM@vK*d3$IT5_$j~i9dSjO`22!#_neDf+i>@}1>@3-65qT3WxHUU(|YU4 zKO4~EMzZcZvo<)F#f_n7?>yu8_goV<_I8{wHTB4iapTB;KYG>4Vl-~d@}1gv=-0j) zH$MBxDFa8{aw~{$y=&`vKL+L#KmU)p&*yH78<(YD{jbsAel2cnT>XXf7kulkxN*Q> zYT4!`_r{H5KlRjkA1pi&H@1J}vKM=lLfp8}I_awa3?Ol7*GK;OB=19UPv2eDz1k z9p8-`z=v!yWhX7V1(MPJ2UpwCkw`tJ084#_F-R$8<|rnquUC`8<%s+koW~FHGaHcNH(9o zs$l#IOg+f^D%;{dg+PJ-S?T{vJ}rLlxl4(V?G==PXF?e z&m7lrN5S~xCU*DsxDkQcZdkpiV4QLB(LZ=Bb5nWBua6rKK0IT=CjXsr(FxNq?kLa< zZYmgxqJK+)vi+`E2%61*7A+E4KV)#k~dNPfLGs>%l+2vtYciNT2o6>0g2zq?;GV z&^V7JIF5j>zeq<{Tug8naV#w!Ot64pE&&%vv4wy&M1tVM0L25DsuUEt;uWLBNjh0@ zDzj%2$aZBldJsv{1s75IgC9}gc$5|RTJr&HWmp|ldOaiRkUFS#V>Lt0dy{&(s;RS- zA~{h(X^99pNbu%aD~{c=8HY@3%d#VnS#rddmAbXf&gHl8&LNx5ADY3LRTo=q z9Hgu*Xew)U=R}6|vN>x@>GUiqk`jkQQ?i6@&-Xix=wlwIm!uqmbtQ)mAFC*8L~T_E z4w~$A-afX@7#UK2@VKrF=Rmr)(ko@CshVexXV|NGr8Jdc-v}gV`!#i!ipv{ZTkKZs zfEL)Lu2goZL*7BPw{Floh^q}l)#{K7Qs%v(Rt1+F!99LZD8u1FFR}a%*N-T}krB>N z1HO%hX9Vk9nSX^_sKPBYDK}upahn2eP5a;$u5b%a$_?0Y+?v6y#pR|cym0D}`=n7^ z#9&gBTAxVSIHI34MyOcUcn}0VX6FC^1H=4C>yS#}YKraYg&6jDuJCO4Q6XcVBGp(FeTkzctLi6uSRuSTjRPuf8uG_; z(S8G8W#Fhu^@4hsv~YcphL*K2Pv^Q)Y3q0-$_$D$F=>Zru0c}j$+Vs|>>ej#;l?J3 zGjLzpwnQ3)MUH!PstB^uR)Q`7C&cSDX;%W z6G)d%Bwe}>(j^l~mq=2~k1huyt<(wNmQhbzj%T38AGj0JFh7_1v^9FeAk8{g1H9#Bt_rrty&2ao2#z+l~o zXNz|zI20NRqfU!GwYRl*TJQ8h={VQ|>V{?A86%24b9fd^arTI+)#DS{<14jQtrwDY zCa>4FpL$`qI@wY;`&n)4fU$L?`8T-cFM1*GcVY8l8|sS;L7t$pf=G=K7I3!{&x63g zvHRACt{m>z=zsQMzoHKeVjjnji#uUEUOlUc_W@Ppq9>R1SKaO3?D(iB;Y-1`5E^jTyw_8 z)hi@2RxfQ|e2i>)J`^7ZNMLJ_#~uQHOkB=2<)u)*`i7wAzVp_R$ zEIK0Z7)#O}rz=jg^e(lEa0}YD76QP-z^}l=c*3d=-exAA^E@rsDa?O6=qkAQX0e5!uLzEmHw~d)`V;@4r?+0(Z(xtRMS%4i z-XR}00+B%esGK)T*WY%I8~@PXSDyQ#Oi*FW4ch}PUC92Q+i-(gQ3ZiU~N zHlmJTTgZOE!$>OhXoiNUlAA;8^|O?j%7~}iBmIkKcqTSH^nPlu+sDwvK91=jw<_fx zaR0h?{9#k%)yzz+ZBnPi{e)}qK5Qy9$H)DFbXAUj$Mzj5Y%cU{7q;_ogFUIdE{0fv zzDt}(z!h0sLvSs@=LzU5#1{Z+HV^AJu3n4n#uCTdm9j;ag+6#QVh~%$BbyKz`<;mg`4Yd52uKB8LN1G^8qwQ+#($Tb`muc_T$SdPo11uJ+EpOCv-ka`=g zUBShT7>3kUaT8PW#CZi%p8|-D-^#j+U`5}=7fJbLf>DB-3HGl|(<&>>sT)o`aaD3v z$BK0;S8;PI6?A;@%2h1JA(dNAx!gGF*-~A`D@Rx=hgA2Uf!1mSD5->Jrn&&%fw}vh zc3H0@c7PL1CK#|!S4PDFjUbvE^bG)3g76fE@2wP&^kpP<%f&KE+r3kj8zK z##Dj_0E*HrtU~JVP+IRoF(9or$}mbGQQ~R)zm{{$1#q}*q#>8_WZ4T`TH>(^J=VD^6ewR`$jPXp!gz{o$Ffh z8LnpECU}*lj}rG5Q+#E}UFyGul(`Wk=H@!!PGSLBnI}Mx%qt15L#beEg2bYk;BkUS z2*}EO4t2|3elk}dCFNwktV%3N{(eAgx%nFBN!sy45KnO}WbJ0D!RAk~2NzGU;9mi1 zES5O=f|7WcDXF*n#8tG~+zW-4{M;H;^<-41lWYBD#hT!wK2FcyY6=!gX3y6 z`N0|oUR-v`=;lA-aHTlh|G`E4nV1mwBEB3%8#}RMqC1lX(c~q3aXHmx2SJ*kpJ0IC zqXgsBif7$3s8;m0JjO@%7bx0Ke+CZ1%d=5Eo9i=rq9?E4jJK^bInmE|Z&$32;>GDK zg3tTD<S<4U-x!EI!)Oj!yPhsuFs zd9%|n+*orjG-bF6>fc;*FH~xyCTJYc5W+=-3E^ki1_Qos8`XgCWNnlJzqZ>3?v31= zPT4!jaZDSyDXwXwzS0Kp`xysHDU(tgQ_F40Td7Fxt<;$LpmT$_cVo#sjLTSZkS{p6 z@#CuQ#5`g<2prX{;;I3qY(?WN<=Y2?c&$V8;>8XRqcOu?zSJSD7)zvvcnNN0J;Q!j9d2ti4dB7O<@#*AEHojiKSR!HcYf(nN&bweVl=xr zweIaJuHHS3Y7-)GP3pkneNW>=CLOUE;x6|8n*?_g&e-Be~Tf%+HU%6+c0K{_y zPZK;tAgx7Sr_#BI?+`psP+f&&O73v(MZxR%${@p->(ptuNDbC}Lr8~kk=hba!!rcy z#b!Cdt$k+N#?LjJ$O-xWWF$IoYM-3e7t4q_%QE{w`j;3?q* z`?4l}k%JfyyPs$)MSk1+Y%^`Ovw-hR$($=S?g<69s!F1%Kyy8t;?O6Pr4wB4Ua23?n^kKz cz&xz%t^NpJ1PMS*@CujLqqd%>to5k>4V)s=#PQ^!l`W%NN9nI<_7@+Btc-5%8Ilad&c(Q*`4Li zY+Of)R0*E@7xW>iDph&q59lAVuT>wW5B&pLRqZ*SvFA90<7RoR6JOtZ&+qR!_s;Cm zhR2T0dGfRN@t-%B7d`KJObhbaYI_G=udeKxg{iPR8$DPlf_@cc!ANikn3!PH5de;{G@l)@Qw&S(z zw=3CpJVW0XcP6~Wxf>_MeO1zxRvDLrZ|_x`C_oMmF2NIzB4dSFNnb%m#ABj@C_Gn zG#|tgqxiR;rI8H%{zJxA1OssEq$##XYv z73>O>`N-W$ZpDiNK-eFO=_)9ZOp}cmh>ERbu$h~uD}u?E;)CISw!ST56(ZHHkOico zqHn~}o3&jHat}4JCD{(sMHLluJDH2}ARG=w^o?5J>TWOy`*D!u!S&m_8hjE8f**)S zii-ZtP5p;iwypa6yTOgjZ42XW99&H{w~E~gPBA$Q6Zb-`|5`?L!CIUrQ7j0GNuWwXQNjkDT57Xd=9FOhAU`_c!OCeYboz;@Ul}d4u&oq{@m5P*; zC5XGYkTh&aL4`X9j4ZUr9lW+V}v*|^hKl+>g zeSdE?bJ%LLeRukfcW>rS>t6Scob!|3ooOBKx9)35qO`qp2k!AW7Z}sgYnODYk-a7!NL7shO9Tm+QGxRIWYn$L(yG-+op(!{p`9 zs;h13%-T`~-gq_{3`a#TiSn2JE_VrHHYEP{JTLi|=qhJLU-_X9KhxodIxNfJj_K_A z{h518mvVo5?rEK!*4dLf`>D=O>@VH7bcSr8GhLPoIyu^o?(EPuLQVo?as>FBq#mXg}q4`;z)j^l<%Cc0upJ<0@(L! zmdAjEV9-*dYZy2nK{Kl0(<(WT8A8P_4lyHMWiEeR`=S+AIey5jq(G3xjk=I3{LCbL zQonnuEb>SC7btThHWW+*Q@7SadKy`%Q|o?QyM{?i6d|w&hzy1mGbCH zD|8~VQX!Z+GbQdRM^ih6)B z3_W`>3;B*2fe3d=Vv zBy$ZLEC~?x7M8^U)j$LYf(CJpUjq`8g@A+sd$ctq%r%xskTP?_Y&85cU^STXq6}`L zy5hEIpmB7Pako($I8LJQ6er2F0bwB+vxUzY#4eGO8T4TdeV8=6HB9A&NrNs?x};*v z2p@eU&%B}%Yd1Rxxt63WmPaqYRh?* zKs|#!Qd#0N9uNl+vE-(Kg;XGh2X!!2_y*HyHH6O`SWX$~MyZK4u)-RdMin;5FMQ}z z56Vlbev-%?@5O{*RoB2&jhDD)#$hps@DB`Nv2>d%e6HWaN|>>0Z!+jZmHA@OnKkYg zB43&~-ZLs;HDrd+#}W^)fqxuMW`w{1GX$8a0}J2oKTGIqYWJ{s(PF@&9;Mi@c z@w7C~LTMxv@gUFKcux94($!jVqj=m6({x?>8S#V8cq)(64fm$%QDx)VV!t&gqB_l2 zpS=8=k1k(Yx%_tT`ll-&eY*0%bMFZ2Kch=;-27CO<~LtC_xkCxH{Xu)?IIiA-1Bg$ zFWtA;-PDit`AuE@){lJt|5&ZaaIwSy8|xDu?5iXh5@K~_k^@0N69_S-U=IN=L(*^<_rcDLkD7=^<^ zdx068@4X`()FR$==OV4d<|xa03=(;WJ#QSWJQtRQQl>98Q=ipUH7KnIN*;Y=(8{M#@)oMap^v1h zb%T?Ql(9z~R_KNw)W-Q}yziMwBT!8Y4QrDF!9{^XM8tqsR=}2h2!I2Xuq;6QqomLR zF7Oec9Sv|k+T>x`M<2dmmjPd323>OqYuG>n5GOh~cI9G&*eFcm<)shx1ZWr#KE~}V z*ki{E9Z!+PKXOTcD7BnhY}i1;E;6(r0o7`flLCP~W-uE=e7PtN{Cb#+Q58fYAy zWZZ4k29A?UJjF>eZ9rHE#%$qp2C+-z1Y@;c^~Q6(o-|}esm|wnz0XHsT2b~oOLa%6x1LHD$-Sj+ zw{_t2P7Nx3uo^jtnoh=A|3;Ur07^ AM*si- From 1e34fc43b91d3440154b15ab1808cd1e80235232 Mon Sep 17 00:00:00 2001 From: 1hb6s7t <120760709+1hb6s7t@users.noreply.github.com> Date: Fri, 14 Feb 2025 16:48:34 +0800 Subject: [PATCH 18/20] Add files via upload From 14f8ba3c809cfcbeb3ad33af4577fb90fa253300 Mon Sep 17 00:00:00 2001 From: 1hb6s7t <120760709+1hb6s7t@users.noreply.github.com> Date: Fri, 14 Feb 2025 16:50:42 +0800 Subject: [PATCH 19/20] Add files via upload --- .../ViTMAE/ViT_MAE_visualization_ demo.ipynb | 211 ++++++++++++++++++ 1 file changed, 211 insertions(+) create mode 100644 applications/ViTMAE/ViT_MAE_visualization_ demo.ipynb diff --git a/applications/ViTMAE/ViT_MAE_visualization_ demo.ipynb b/applications/ViTMAE/ViT_MAE_visualization_ demo.ipynb new file mode 100644 index 000000000..4a832616e --- /dev/null +++ b/applications/ViTMAE/ViT_MAE_visualization_ demo.ipynb @@ -0,0 +1,211 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "8c18207a", + "metadata": {}, + "source": [ + "# 可视化演示：掩码自编码器（MAE）\n", + "在本Notebook中，我们将可视化一个基于非常简单的目标（即掩码块预测）进行预训练的视觉变换器（ViT）的部分预测结果。该模型需要为被遮罩的图像块重建像素值.\n", + "\n", + "原论文:https://arxiv.org/abs/2111.06377\n", + "\n", + "原始代码仓库: https://github.com/facebookresearch/mae" + ] + }, + { + "cell_type": "markdown", + "id": "fc92086b", + "metadata": {}, + "source": [ + "# 图像预处理\n", + "此处我们应用了基础的图像处理技术，具体包括将图像尺寸调整为224x224像素，并对各颜色通道进行归一化处理。" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "d9e06841-0c9a-40d1-a672-668a69942e62", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/ma-user/anaconda3/envs/MindSpore/lib/python3.9/site-packages/mindnlp/transformers/models/vit/feature_extraction_vit.py:28: FutureWarning: The class ViTFeatureExtractor is deprecated. Please use ViTImageProcessor instead.\n", + " warnings.warn(\n" + ] + }, + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# 需要 GPU 或Ascend 资源下运行案例代码，不然运行速度很慢且可能看不到生成效果\n", + "from mindnlp.core import nn, ops\n", + "from mindnlp.transformers import ViTFeatureExtractor, ViTMAEForPreTraining\n", + "import requests\n", + "import mindspore as ms\n", + "from PIL import Image\n", + "\n", + "feature_extractor = ViTFeatureExtractor.from_pretrained(\"facebook/vit-mae-base\")\n", + "url = \"https://user-images.githubusercontent.com/11435359/147738734-196fd92f-9260-48d5-ba7e-bf103d29364d.jpg\"\n", + "image = Image.open(requests.get(url, stream=True).raw)\n", + "image" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "1952a4ec-d2df-4658-b640-31b231a8b94c", + "metadata": {}, + "outputs": [], + "source": [ + "pixel_values = feature_extractor(image, return_tensors=\"ms\").pixel_values" + ] + }, + { + "cell_type": "markdown", + "id": "4f49f230", + "metadata": {}, + "source": [ + "# 可视化解析\n", + "随后，我们将像素值输入模型进行前向传递。编码器（采用标准视觉Transformer架构）会首先对视觉块进行特征编码。在掩码块位置处加入可学习的掩码标记后，解码器（同样采用Transformer架构）基于已编码的视觉块特征和掩码标记，执行像素值的重建任务。\n", + "\n", + "研究团队通过实验发现，当对图像块进行高比例掩码（75%）时，模型展现出最优性能表现" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "5f030df9-9376-4e71-b20d-d33d057ebb13", + "metadata": {}, + "outputs": [], + "source": [ + "from mindnlp.core import nn, ops\n", + "from mindnlp.transformers import ViTFeatureExtractor, ViTMAEForPreTraining\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "\n", + "imagenet_mean = np.array(feature_extractor.image_mean)\n", + "imagenet_std = np.array(feature_extractor.image_std)\n", + "\n", + "def visualize(pixel_values, model):\n", + "\n", + " total_params = sum(p.size for p in model.get_parameters()) # 使用MindSpore的参数统计方式\n", + " outputs = model(pixel_values)\n", + " \n", + " logits = outputs.logits\n", + " logits_np = logits.asnumpy()\n", + "\n", + " \n", + " mask = outputs.mask\n", + " mask_np = mask.asnumpy()\n", + "\n", + " y = model.unpatchify(logits)\n", + " y_nhwc = ops.einsum('nchw->nhwc', y)[0].asnumpy()\n", + "\n", + " expanded_mask = mask.unsqueeze(-1)\n", + " expanded_mask_np = expanded_mask.asnumpy()\n", + "\n", + " tiled_mask = ops.tile(mask.unsqueeze(-1), (1, 1, 3*(16**2))) \n", + " tiled_mask_np = tiled_mask.asnumpy()\n", + " \n", + " \n", + " unpatched_mask = model.unpatchify(tiled_mask)\n", + " unpatched_mask_np = unpatched_mask.asnumpy()\n", + " \n", + " mask_nhwc = ops.einsum('nchw->nhwc', unpatched_mask)[0].asnumpy()\n", + " x_nhwc = ops.einsum('nchw->nhwc', pixel_values)[0].asnumpy()\n", + "\n", + "\n", + " im_masked = x_nhwc * (1 - mask_nhwc)\n", + " im_paste = im_masked + y_nhwc * mask_nhwc\n", + "\n", + " def denorm(tensor):\n", + " return np.clip((tensor * imagenet_std + imagenet_mean) * 255, 0, 255)\n", + " \n", + " plt.figure(figsize=(24, 6))\n", + " \n", + " plt.subplot(1, 4, 1)\n", + " plt.imshow(denorm(x_nhwc)/255)\n", + " plt.title(\"Original\")\n", + " plt.axis('off')\n", + " \n", + " plt.subplot(1, 4, 2)\n", + " plt.imshow(denorm(im_masked)/255)\n", + " plt.title(\"Masked\")\n", + " plt.axis('off')\n", + " \n", + " plt.subplot(1, 4, 3)\n", + " plt.imshow(denorm(y_nhwc)/255)\n", + " plt.title(\"Reconstruction\")\n", + " plt.axis('off')\n", + " \n", + " plt.subplot(1, 4, 4)\n", + " plt.imshow(denorm(im_paste)/255)\n", + " plt.title(\"Reconstruction + Visible\")\n", + " plt.axis('off')\n", + " \n", + " plt.tight_layout()\n", + " plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "769d201b-023e-479f-a393-b12b861216ad", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from mindnlp.transformers import ViTFeatureExtractor, ViTMAEForPreTraining\n", + "\n", + "model = ViTMAEForPreTraining.from_pretrained(\"facebook/vit-mae-base\")\n", + "\n", + "visualize(pixel_values, model)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "MindSpore", + "language": "python", + "name": "mindspore" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 1f5a67f5479f19d3bc4d695ed75d2e2bd3c2751a Mon Sep 17 00:00:00 2001 From: 1hb6s7t <120760709+1hb6s7t@users.noreply.github.com> Date: Thu, 27 Feb 2025 15:34:16 +0800 Subject: [PATCH 20/20] Add files via upload --- .../OneFormer/Inference_with_OneFormer.ipynb | 458 ++++++++++++++++++ 1 file changed, 458 insertions(+) create mode 100644 applications/OneFormer/Inference_with_OneFormer.ipynb diff --git a/applications/OneFormer/Inference_with_OneFormer.ipynb b/applications/OneFormer/Inference_with_OneFormer.ipynb new file mode 100644 index 000000000..911306d4c --- /dev/null +++ b/applications/OneFormer/Inference_with_OneFormer.ipynb @@ -0,0 +1,458 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "f58b9dcf", + "metadata": {}, + "source": [ + "# 推理与OneFormer：通用图像分割\n", + "原论文：https://arxiv.org/abs/2211.06220\n", + "OneFormer在Mask2Former框架中集成了一个文本模块，以在各自的子任务（实例、语义或panoptic）上约束模型。这样可以得到更准确的结果，但代价是增加了延迟。" + ] + }, + { + "cell_type": "markdown", + "id": "7a37a1f9", + "metadata": {}, + "source": [ + "## 设置环境\n", + "Mindspore 2.5.0\n", + "\n", + "Mindnlp 0.4.0\n", + "\n", + "python 3.9.0" + ] + }, + { + "cell_type": "markdown", + "id": "c6085611", + "metadata": {}, + "source": [ + "## 图像加载\n", + "\n", + "接下来，我们加载一个我们想要执行推理的图像。这里我们加载熟悉的猫图像，这是COCO数据集的一部分。" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "bf9de159-3e3c-4ef1-b54c-ab2623fe8526", + "metadata": {}, + "outputs": [], + "source": [ + "from PIL import Image\n", + "import requests\n", + "\n", + "url = 'http://images.cocodataset.org/val2017/000000039769.jpg'\n", + "image = Image.open(requests.get(url, stream=True).raw)\n", + "image" + ] + }, + { + "cell_type": "markdown", + "id": "7863d8a8", + "metadata": {}, + "source": [ + "## 为模型准备图像\n", + "\n", + "我们可以使用处理器准备图像。OneFormer利用了一个处理器，它内部由一个图像处理器（用于图像模态）和一个标记器（用于文本模态）组成。OneFormer实际上是一个多模态模型，因为它结合了图像和文本来解决图像分割。" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3e936c0d-d6cd-426d-bf9e-e05dff42e145", + "metadata": {}, + "outputs": [], + "source": [ + "from mindnlp.transformers import AutoProcessor\n", + "\n", + "# the Auto API loads a OneFormerProcessor for us, based on the checkpoint\n", + "processor = AutoProcessor.from_pretrained(\"shi-labs/oneformer_coco_swin_large\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5f159b71-4f30-43b9-834d-e53cb6c20153", + "metadata": {}, + "outputs": [], + "source": [ + "# prepare image for the model\n", + "panoptic_inputs = processor(images=image, task_inputs=[\"panoptic\"], return_tensors=\"ms\")\n", + "for k,v in panoptic_inputs.items():\n", + " print(k,v.shape)" + ] + }, + { + "cell_type": "markdown", + "id": "c3b95c44", + "metadata": {}, + "source": [ + "可以看到，这个模型有一个额外的“task_inputs”，这是MaskFormer和Mask2Former所没有的。这些文本输入允许模型区分实例/语义/全景分割。\n", + "\n", + "\n", + "\n", + "我们可以将任务输入解码回文本：" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f74a380a-7245-4c3b-bd4c-ee65481b8eb5", + "metadata": {}, + "outputs": [], + "source": [ + "processor.tokenizer.batch_decode(panoptic_inputs.task_inputs)" + ] + }, + { + "cell_type": "markdown", + "id": "11d76bcc", + "metadata": {}, + "source": [ + "## 加载模型\n", + "\n", + "\n", + "\n", + "接下来，让我们从mindnlp/transformers加载一个模型。在这里，我们用一个swing -large的主干加载OneFormer模型，该主干是在COCO数据集上训练的。" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "c53c4c55-17ea-4be2-a761-ec793413a9bc", + "metadata": {}, + "outputs": [], + "source": [ + "from mindnlp.transformers import AutoModelForUniversalSegmentation\n", + "\n", + "model = AutoModelForUniversalSegmentation.from_pretrained(\"shi-labs/oneformer_coco_swin_large\")" + ] + }, + { + "cell_type": "markdown", + "id": "8dcdf3b9", + "metadata": {}, + "source": [ + "## 前向传播\n", + "\n", + "\n", + "\n", + "mindnlp中的前向传播是这样完成的：" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e5399787-05ac-4e55-95e8-bc712e5efc1c", + "metadata": {}, + "outputs": [], + "source": [ + "from mindnlp.core import ops, no_grad\n", + "\n", + "# forward pass\n", + "with no_grad():\n", + " outputs = model(**panoptic_inputs)" + ] + }, + { + "cell_type": "markdown", + "id": "b00c6dbf", + "metadata": {}, + "source": [ + "# 可视化\n", + "\n", + "\n", + "\n", + "接下来，我们可以对原始输出进行后处理，并将预测可视化。" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e740410c-7081-407a-9a06-03e159f14e04", + "metadata": {}, + "outputs": [], + "source": [ + "panoptic_segmentation = processor.post_process_panoptic_segmentation(outputs, target_sizes=[image.size[::-1]])[0]\n", + "print(panoptic_segmentation.keys())" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b36ee706-a401-4d39-87ea-63d77fcd299a", + "metadata": {}, + "outputs": [], + "source": [ + "from collections import defaultdict\n", + "import matplotlib.pyplot as plt\n", + "from matplotlib import cm\n", + "import matplotlib.patches as mpatches\n", + "import numpy as np\n", + "from mindspore import Tensor\n", + "\n", + "def draw_panoptic_segmentation(segmentation, segments_info):\n", + "\n", + " if isinstance(segmentation, Tensor):\n", + " segmentation_np = segmentation.asnumpy()\n", + " else:\n", + " segmentation_np = np.array(segmentation)\n", + " \n", + " if not np.issubdtype(segmentation_np.dtype, np.integer):\n", + " segmentation_np = segmentation_np.astype(np.int32)\n", + " \n", + " # Get the maximum segment ID using numpy\n", + " max_segment = np.max(segmentation_np)\n", + " viridis = cm.get_cmap('viridis', max_segment + 1) \n", + " \n", + " fig, ax = plt.subplots()\n", + " ax.imshow(segmentation_np)\n", + " \n", + " instances_counter = defaultdict(int)\n", + " handles = []\n", + " \n", + " for segment in segments_info:\n", + " segment_id = segment['id']\n", + " segment_label_id = segment['label_id']\n", + " segment_label = model.config.id2label[segment_label_id] \n", + " label = f\"{segment_label}-{instances_counter[segment_label_id]}\"\n", + " instances_counter[segment_label_id] += 1\n", + " color = viridis(segment_id)\n", + " handles.append(mpatches.Patch(color=color, label=label))\n", + " \n", + " ax.legend(handles=handles)\n", + " plt.savefig('cats_panoptic.png')\n", + "draw_panoptic_segmentation(**panoptic_segmentation)\n" + ] + }, + { + "cell_type": "markdown", + "id": "f24c019a", + "metadata": {}, + "source": [ + "可以看出，该模型能够正确区分两只不同的猫以及两个不同的遥控器。" + ] + }, + { + "cell_type": "markdown", + "id": "8acb48fc", + "metadata": {}, + "source": [ + "## 推理：语义分割\n", + "我们还可以使用相同的模型对猫咪图像进行语义分割！我们只需要更改任务输入（即模型的文本输入），将其改为“此任务为语义”。" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c5496e90-37f4-4fe7-a8db-521b60f2ea37", + "metadata": {}, + "outputs": [], + "source": [ + "# prepare image for the model\n", + "semantic_inputs = processor(images=image, task_inputs=[\"semantic\"], return_tensors=\"ms\")\n", + "for k,v in semantic_inputs.items():\n", + " print(k,v.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "ab5497ee-1c8d-4740-bf22-65d2de5eac2c", + "metadata": {}, + "outputs": [], + "source": [ + "# forward pass\n", + "with no_grad():\n", + " outputs = model(**semantic_inputs)" + ] + }, + { + "cell_type": "markdown", + "id": "6cd6bb98", + "metadata": {}, + "source": [ + "让我们对结果进行后处理并可视化：" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b0400d2e-d921-422b-b8d9-b08f872251f7", + "metadata": {}, + "outputs": [], + "source": [ + "semantic_segmentation = processor.post_process_semantic_segmentation(outputs)[0]\n", + "semantic_segmentation.shape" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "73b6a7f7-aaf9-408e-bcf9-b21dbf38e937", + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import matplotlib.patches as mpatches\n", + "from matplotlib.colors import ListedColormap, LinearSegmentedColormap\n", + "from matplotlib import cm\n", + "\n", + "\n", + "def draw_semantic_segmentation(segmentation):\n", + "\n", + " if not isinstance(segmentation, np.ndarray):\n", + " segmentation = np.array(segmentation)\n", + " \n", + " segmentation = segmentation.astype(np.int32)\n", + " \n", + " max_label = np.max(segmentation) \n", + " viridis = cm.get_cmap('viridis', max_label)\n", + " \n", + " labels_ids = np.unique(segmentation).tolist()\n", + " \n", + " fig, ax = plt.subplots()\n", + " ax.imshow(segmentation, cmap=viridis) \n", + " handles = []\n", + " \n", + " for label_id in labels_ids:\n", + " label = model.config.id2label[label_id]\n", + " color = viridis(label_id / max_label) \n", + " handles.append(mpatches.Patch(color=color, label=label))\n", + " \n", + " ax.legend(handles=handles)\n", + "\n", + "draw_semantic_segmentation(semantic_segmentation)" + ] + }, + { + "cell_type": "markdown", + "id": "a65f1ace", + "metadata": {}, + "source": [ + "可以看到，在语义分割中，不会区分单个实例（可数的事物，如猫咪或遥控器）。相反，只会为“猫咪”类别等生成一个单一的掩码。" + ] + }, + { + "cell_type": "markdown", + "id": "78bdb604", + "metadata": {}, + "source": [ + "## 推理：实例分割\n", + "\n", + "同样，我们可以使用相同的模型进行实例分割，我们只需要更改文本输入即可。" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0ce50c61-ef57-4773-979f-a115f847b0a2", + "metadata": {}, + "outputs": [], + "source": [ + "# prepare image for the model\n", + "instance_inputs = processor(images=image, task_inputs=[\"instance\"], return_tensors=\"ms\")\n", + "for k,v in instance_inputs.items():\n", + " print(k,v.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "08d35d25-df61-4025-8a75-32828818f0e8", + "metadata": {}, + "outputs": [], + "source": [ + "# forward pass\n", + "with no_grad():\n", + " outputs = model(**instance_inputs)" + ] + }, + { + "cell_type": "markdown", + "id": "06b9ecbe", + "metadata": {}, + "source": [ + "让我们对结果进行后处理并可视化：" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f1049e52-8fc0-45c6-9ee9-4d4b80d9dd2d", + "metadata": {}, + "outputs": [], + "source": [ + "instance_segmentation = processor.post_process_instance_segmentation(outputs)[0]\n", + "instance_segmentation.keys()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0155c6e6-add1-44ac-9845-f80a2fe6e063", + "metadata": {}, + "outputs": [], + "source": [ + "from collections import defaultdict\n", + "import matplotlib.pyplot as plt\n", + "from matplotlib import cm\n", + "import matplotlib.patches as mpatches\n", + "import numpy as np # 确保导入 numpy\n", + "\n", + "def draw_instance_segmentation(segmentation, segments_info):\n", + " # 转换数据类型（如果是张量或 object 类型）\n", + " if hasattr(segmentation, 'asnumpy'): # 处理 MindSpore 张量\n", + " segmentation = segmentation.asnumpy()\n", + " segmentation = np.array(segmentation, dtype=np.int32) # 强制转换为 int32\n", + " \n", + " # 获取颜色映射\n", + " max_segment_id = np.max(segmentation) # 使用 NumPy 的 max\n", + " viridis = cm.get_cmap('viridis', max_segment_id)\n", + " \n", + " fig, ax = plt.subplots()\n", + " ax.imshow(segmentation) # 现在 segmentation 是数值类型\n", + " \n", + " instances_counter = defaultdict(int)\n", + " handles = []\n", + " for segment in segments_info:\n", + " segment_id = segment['id']\n", + " segment_label_id = segment['label_id']\n", + " segment_label = model.config.id2label[segment_label_id]\n", + " label = f\"{segment_label}-{instances_counter[segment_label_id]}\"\n", + " instances_counter[segment_label_id] += 1\n", + " color = viridis(segment_id)\n", + " handles.append(mpatches.Patch(color=color, label=label))\n", + " \n", + " ax.legend(handles=handles)\n", + " plt.savefig('cats_panoptic.png')\n", + "\n", + "# 调用函数（确保 instance_segmentation 包含正确的键）\n", + "draw_instance_segmentation(**instance_segmentation)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "MindSpore", + "language": "python", + "name": "mindspore" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}