Hubert class TFHubertWeightNormConv1D(tf.keras.layers.Conv1D): \"\"\"Adapted from https://www.tensorflow.org/probability/api_docs/python/tfp/layers/weight_norm/WeightNorm\"\"\" def __init__(self, filters, kernel_size, groups,","= tf.expand_dims(input_values, -1) for conv_layer in self.conv_layers: hidden_states = conv_layer(hidden_states) return hidden_states class","guaranteed during the training. Args: func (`callable`): The callable function of the TensorFlow","Mask to nullify selected heads of the self-attention modules. Mask values selected in","from transformers.models.wav2vec2.modeling_tf_wav2vec2._scatter_values_on_batch_indices def _scatter_values_on_batch_indices(values, batch_indices, output_shape): \"\"\" Scatter function as in PyTorch with","are position IDs?](../glossary#position-ids) head_mask (`np.ndarray` or `tf.Tensor` of shape `(num_heads,)` or `(num_layers, num_heads)`,","representation. This is useful if you want more control over how to convert","hidden_states = hidden_states + self.feed_forward(hidden_states) hidden_states = self.final_layer_norm(hidden_states) outputs = (hidden_states,) if output_attentions:","def call( self, input_values: tf.Tensor, attention_mask: Optional[tf.Tensor] = None, token_type_ids: Optional[tf.Tensor] = None,","None, output_attentions: Optional[bool] = False, output_hidden_states: Optional[bool] = False, return_dict: Optional[bool] = True,","bool = False, ) -> Union[TFBaseModelOutput, Tuple[tf.Tensor]]: \"\"\" Returns: Example: ```python >>> from","bool = False, ) -> Tuple[tf.Tensor]: attn_residual = hidden_states hidden_states = self.layer_norm(hidden_states) hidden_states,","use_bias=bias, name=\"out_proj\") def _shape(self, tensor: tf.Tensor, seq_len: int, bsz: int): return tf.transpose(tf.reshape(tensor, (bsz,","num_masked_spans * mask_length > sequence_length: num_masked_spans = sequence_length // mask_length # SpecAugment mask","be smaller than `sequence_length`, but got `mask_length`: {mask_length} and `sequence_length`: {sequence_length}`\" ) #","is_instance_norm = (input_shape[self.axis] // self.groups) == 1 if not is_instance_norm: outputs = tf.reshape(normalized_inputs,","TFHubertFeatureEncoder(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs: Any) -> None: super().__init__(**kwargs) if config.feat_extract_norm ==","= self.projection(hidden_states) hidden_states = self.dropout(hidden_states, training=training) return hidden_states # Copied from transformers.models.bart.modeling_tf_bart.TFBartAttention with","second option, there are three possibilities you can use to gather all the","(attn_weights,) return outputs # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2EncoderLayerStableLayerNorm with Wav2Vec2->Hubert class TFHubertEncoderLayerStableLayerNorm(tf.keras.layers.Layer): def __init__(self,","modeling` head on top for Connectionist Temporal Classification (CTC).\"\"\", HUBERT_START_DOCSTRING, ) class TFHubertForCTC(TFHubertPreTrainedModel):","first positional argument : - a single Tensor with `input_values` only and nothing","loss is only computed for the tokens with labels in `[0, ..., config.vocab_size]`","but is {shape_list(attn_output)}\", ) attn_output = tf.transpose( tf.reshape(attn_output, (bsz, self.num_heads, tgt_len, self.head_dim)), (0,","training=training) return hidden_states # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2EncoderLayer with Wav2Vec2->Hubert class TFHubertEncoderLayer(tf.keras.layers.Layer): def __init__(self,","scale self.beta_initializer = tf.keras.initializers.get(beta_initializer) self.gamma_initializer = tf.keras.initializers.get(gamma_initializer) self.beta_regularizer = tf.keras.regularizers.get(beta_regularizer) self.gamma_regularizer = tf.keras.regularizers.get(gamma_regularizer)","Optional[bool] = False, ) -> Tuple[tf.Tensor, Optional[tf.Tensor]]: \"\"\"Input shape: Batch x Time x","shape `({0})`, *optional*): Segment token indices to indicate first and second portions of","= self.hubert( input_values=inputs[\"input_values\"], attention_mask=inputs[\"attention_mask\"], token_type_ids=inputs[\"token_type_ids\"], position_ids=inputs[\"position_ids\"], head_mask=inputs[\"head_mask\"], inputs_embeds=inputs[\"inputs_embeds\"], output_attentions=inputs[\"output_attentions\"], output_hidden_states=inputs[\"output_hidden_states\"], return_dict=inputs[\"return_dict\"], training=inputs[\"training\"], )","class TFHubertEncoder(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs): super().__init__(**kwargs) self.config = config self.pos_conv_embed =","self.axis = axis self.epsilon = epsilon self.center = center self.scale = scale self.beta_initializer",") hidden_states = layer_outputs[0] if output_attentions: all_self_attentions = all_self_attentions + (layer_outputs[1],) hidden_states =",">>> input_values = processor(ds[\"speech\"][0], return_tensors=\"tf\").input_values # Batch size 1 >>> hidden_states = model(input_values).last_hidden_state","are three possibilities you can use to gather all the input Tensors in","int, dropout: float = 0.0, is_decoder: bool = False, bias: bool = True,","is used as a cross-attention layer # for the decoder is_cross_attention = key_value_states","with Wav2Vec2->Hubert class TFHubertEncoderStableLayerNorm(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs): super().__init__(**kwargs) self.config = config","num_heads self.dropout = tf.keras.layers.Dropout(dropout) self.head_dim = embed_dim // num_heads if (self.head_dim * num_heads)","np.random.uniform(0, 1) if training and (dropout_probability < self.config.layerdrop): # skip the layer continue","and # limitations under the License. \"\"\" TensorFlow Hubert model.\"\"\" import inspect import","= input_shape[self.axis] if self.groups == -1: self.groups = dim def _check_size_of_dimensions(self, input_shape): dim","weights associated with the model, only the configuration. Check out the [`~PreTrainedModel.from_pretrained`] method","Union[TFBaseModelOutput, Tuple[tf.Tensor]]: all_hidden_states = () if output_hidden_states else None all_self_attentions = () if","mode, in graph mode the value will always be set to True. training","ds = ds.map(map_to_array) >>> input_values = processor(ds[\"speech\"][0], return_tensors=\"tf\").input_values # Batch size 1 >>>","output_hidden_states=output_hidden_states, return_dict=return_dict, training=training, ) inputs[\"output_hidden_states\"] = ( inputs[\"output_hidden_states\"] if inputs[\"output_hidden_states\"] else self.config.output_hidden_states )","r\"\"\" This model inherits from [`TFPreTrainedModel`]. Check the superclass documentation for the generic","outputs += (attn_weights,) return outputs # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2EncoderLayerStableLayerNorm with Wav2Vec2->Hubert class TFHubertEncoderLayerStableLayerNorm(tf.keras.layers.Layer):",">>> processor = Wav2Vec2Processor.from_pretrained(\"facebook/hubert-base-960h\") >>> model = TFHubertForCTC.from_pretrained(\"facebook/hubert-base-960h\") >>> def map_to_array(batch): ... speech,","(unless no_overlap is True) mask_length: size of the mask min_masks: minimum number of","= None beta = None if self.scale: gamma = tf.reshape(self.gamma, broadcast_shape) if self.center:","`np.ndarray` of shape `(batch_size, sequence_length)`, *optional*): Labels for computing the masked language modeling","None, output_attentions: Optional[bool] = None, output_hidden_states: Optional[bool] = None, return_dict: Optional[bool] = None,","name=\"k_proj\") self.q_proj = tf.keras.layers.Dense(embed_dim, use_bias=bias, name=\"q_proj\") self.v_proj = tf.keras.layers.Dense(embed_dim, use_bias=bias, name=\"v_proj\") self.out_proj =","other modes than eager. if tf.executing_eagerly(): tf.debugging.assert_equal( shape_list(attention_mask), [bsz, 1, tgt_len, src_len], message=f\"Attention","(attn_weights,) return outputs # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2Encoder with Wav2Vec2->Hubert class TFHubertEncoder(tf.keras.layers.Layer): def __init__(self,","if mask_time_indices is not None: # apply SpecAugment along time axis with given","\"The `decoder_cached_states` argument is deprecated and will be removed in a future version,","Transformers v5.\" \"Please use the equivalent `freeze_feature_encoder` method instead.\", FutureWarning, ) self.freeze_feature_encoder() def","# # Unless required by applicable law or agreed to in writing, software","indices_shape = shape_list(batch_indices) # broadcast batch dim to indices_shape broad_casted_batch_dims = tf.reshape( tf.broadcast_to(tf.expand_dims(tf.range(indices_shape[0]),","initializer=\"zeros\", trainable=True) def call(self, inputs): if not self.initialized: self._init_norm() self.initialized = True self._normalize_kernel()","of input sequence tokens in the vocabulary. Indices can be obtained using [`BertTokenizer`].","hidden_states = self.conv(hidden_states) hidden_states = self.layer_norm(hidden_states) hidden_states = self.activation(hidden_states) return hidden_states # Copied","input_shape[self.axis] // self.groups group_shape.insert(self.axis, self.groups) group_shape = tf.stack(group_shape) reshaped_inputs = tf.reshape(inputs, group_shape) return","`[0, 1]`: - 1 for tokens that are **not masked**, - 0 for","to be bigger than 0.\") if mask_length > sequence_length: raise ValueError( f\"`mask_length` has","either express or implied. # See the License for the specific language governing","= self.pos_conv_embed(hidden_states) hidden_states = hidden_states + position_embeddings hidden_states = self.dropout(hidden_states, training=training) for i,","HUBERT_INPUTS_DOCSTRING = r\"\"\" Args: input_values (`np.ndarray`, `tf.Tensor`, `List[tf.Tensor]` ``Dict[str, tf.Tensor]` or `Dict[str, np.ndarray]`",") self.layer_norm = tf.keras.layers.LayerNormalization(name=\"layer_norm\", epsilon=config.layer_norm_eps) self.activation = get_tf_activation(config.feat_extract_activation) def call(self, hidden_states: tf.Tensor) ->","tf.Tensor) of all cross attention key/value_states. # Further calls to cross_attention layer can","a regular TF 2.0 Keras Model and refer to the TF 2.0 documentation","BatchEncoding from ...utils import ( ModelOutput, add_start_docstrings, add_start_docstrings_to_model_forward, logging, replace_return_docstrings, ) from .configuration_hubert","tf.keras.layers.Dense( units=config.hidden_size, kernel_initializer=get_initializer(config.initializer_range), bias_initializer=\"zeros\", name=\"projection\", ) self.dropout = tf.keras.layers.Dropout(rate=config.feat_proj_dropout) def call(self, hidden_states: tf.Tensor,","the License. # You may obtain a copy of the License at #","None, training: Optional[bool] = False, ) -> Tuple[tf.Tensor, Optional[tf.Tensor]]: \"\"\"Input shape: Batch x","config.conv_dim[layer_id] self.conv = tf.keras.layers.Conv1D( filters=self.out_conv_dim, kernel_size=config.conv_kernel[layer_id], strides=config.conv_stride[layer_id], use_bias=config.conv_bias, name=\"conv\", ) self.activation = get_tf_activation(config.feat_extract_activation)","= tf.Variable(tf.transpose(self.kernel), name=\"weight_v\", trainable=True) self.weight_v = self.kernel self.weight_g = self.add_weight( name=\"weight_g\", shape=(int(self.weight_v.shape[self.filter_axis]), 1,","creating a SavedModel TF calls the method with LayerCall.__call__(args, **kwargs) # So to","to return the hidden states of all layers. See `hidden_states` under returned tensors","TFHubertPositionalConvEmbedding(config, name=\"pos_conv_embed\") self.layer_norm = tf.keras.layers.LayerNormalization(epsilon=config.layer_norm_eps, name=\"layer_norm\") self.dropout = tf.keras.layers.Dropout(config.hidden_dropout) self.layer = [ TFHubertEncoderLayerStableLayerNorm(config,","real output lengths according to convolution formula output_lengths = self._get_feat_extract_output_lengths(tf.reduce_sum(inputs[\"attention_mask\"], -1)) attention_mask =","self, hidden_states: tf.Tensor, attention_mask: Optional[tf.Tensor] = None, output_attentions: Optional[bool] = False, training: bool","and will be ignored.\" ) continue else: raise ValueError(f\"Data of type {type(v)} is","Wav2Vec2Processor, TFHubertForCTC >>> from datasets import load_dataset >>> import soundfile as sf >>>","in eager mode, in graph mode the value in the config will be","explicit_padding, **kwargs): super().__init__( filters=filters, kernel_size=kernel_size, groups=groups, padding=\"valid\", use_bias=True, bias_initializer=\"he_normal\", **kwargs, ) self.explicit_padding =","bsz) value_states = self._shape(self.v_proj(key_value_states), -1, bsz) elif past_key_value is not None: # reuse","gamma = tf.reshape(self.gamma, broadcast_shape) if self.center: beta = tf.reshape(self.beta, broadcast_shape) return gamma, beta","should have a defined dimension \" \"but the layer received an input with","_reshape_into_groups(self, inputs, input_shape, tensor_input_shape): group_shape = [tensor_input_shape[i] for i in range(len(input_shape))] is_instance_norm =","* tf.transpose(self.weight_g) self.kernel = tf.transpose(kernel) def build(self, input_shape): if not self.built: input_shape =",">>> import tensorflow as tf >>> from transformers import Wav2Vec2Processor, TFHubertForCTC >>> from","None if attention_mask is not None: hidden_states = hidden_states * tf.expand_dims(attention_mask, -1) attention_mask","# if cross_attention save Tuple(tf.Tensor, tf.Tensor) of all cross attention key/value_states. # Further","name=\"conv\", ) self.padding = TFHubertSamePadLayer(config.num_conv_pos_embeddings) self.activation = get_tf_activation(config.feat_extract_activation) def call(self, hidden_states: tf.Tensor) ->","input_values_processing(func, config, input_values, **kwargs): \"\"\" Process the input of each TensorFlow model including","hidden_states = self.projection(hidden_states) hidden_states = self.dropout(hidden_states, training=training) return hidden_states # Copied from transformers.models.bart.modeling_tf_bart.TFBartAttention","__init__(self, config: HubertConfig, *inputs, **kwargs): super().__init__(config, *inputs, **kwargs) self.config = config self.hubert =","return hidden_states def call( self, input_values: tf.Tensor, attention_mask: Optional[tf.Tensor] = None, token_type_ids: Optional[tf.Tensor]","1 indicates the head is **not masked**, - 0 indicates the head is","(tf.Tensor, bool, int, ModelOutput, tuple, list, dict, np.ndarray) for k, v in kwargs.items():","be disabled in other modes than eager. if tf.executing_eagerly(): tf.debugging.assert_equal( shape_list(attention_mask), [bsz, 1,","self.head_dim)), (0, 2, 1, 3)) def call( self, hidden_states: tf.Tensor, key_value_states: Optional[tf.Tensor] =","layer_module( hidden_states=hidden_states, attention_mask=attention_mask, output_attentions=output_attentions, training=training, ) hidden_states = layer_outputs[0] if output_attentions: all_self_attentions =","\"ones\", beta_regularizer: tf.keras.regularizers.Regularizer = None, gamma_regularizer: tf.keras.regularizers.Regularizer = None, beta_constraint: tf.keras.constraints.Constraint = None,","TFHubertNoLayerNormConvLayer(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, layer_id: int = 0, **kwargs: Any) -> None:","{(bsz, self.num_heads, tgt_len, self.head_dim)}, but is {shape_list(attn_output)}\", ) attn_output = tf.transpose( tf.reshape(attn_output, (bsz,","def _add_gamma_weight(self, input_shape): dim = input_shape[self.axis] shape = (dim,) if self.scale: self.gamma =","at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed","axis with given mask_time_indices hidden_states = tf.where( tf.cast(mask_time_indices[:, :, tf.newaxis], tf.bool), self.masked_spec_embed[tf.newaxis, tf.newaxis,","batch >>> ds = load_dataset(\"hf-internal-testing/librispeech_asr_dummy\", \"clean\", split=\"validation\") >>> ds = ds.map(map_to_array) >>> input_values","-1] ) # transform batch_indices to pair_indices pair_indices = tf.transpose(tf.concat([broad_casted_batch_dims, tf.reshape(batch_indices, [1, -1])],","self._get_reshaped_weights(input_shape) normalized_inputs = tf.nn.batch_normalization( reshaped_inputs, mean=mean, variance=variance, scale=gamma, offset=beta, variance_epsilon=self.epsilon, ) return normalized_inputs","= self.layer_norm(hidden_states) hidden_states = self.projection(hidden_states) hidden_states = self.dropout(hidden_states, training=training) return hidden_states # Copied","self.pos_conv_embed(hidden_states) hidden_states = hidden_states + position_embeddings hidden_states = self.layer_norm(hidden_states) hidden_states = self.dropout(hidden_states, training=training)","== 0 else 0 def call(self, hidden_states): if self.num_pad_remove > 0: hidden_states =","[What are attention masks?](../glossary#attention-mask) token_type_ids (`np.ndarray` or `tf.Tensor` of shape `({0})`, *optional*): Segment","dim = input_shape[self.axis] shape = (dim,) if self.center: self.beta = self.add_weight( shape=shape, name=\"beta\",","np.ndarray]` and each example must have the shape `({0})`): Indices of input sequence","indices. Mask values selected in `[0, 1]`: - 1 for tokens that are","self.weight_g = self.add_weight( name=\"weight_g\", shape=(int(self.weight_v.shape[self.filter_axis]), 1, 1), initializer=\"ones\", dtype=self.weight_v.dtype, trainable=True, ) self.bias =","out the [`~PreTrainedModel.from_pretrained`] method to load the model weights. \"\"\" HUBERT_INPUTS_DOCSTRING = r\"\"\"","list(signature.keys()) output = {} allowed_types = (tf.Tensor, bool, int, ModelOutput, tuple, list, dict,","tf.cast(mask_time_indices[:, :, tf.newaxis], tf.bool), self.masked_spec_embed[tf.newaxis, tf.newaxis, :], hidden_states, ) # apply SpecAugment along","hidden_states = self.conv(hidden_states) hidden_states = self.activation(hidden_states) return hidden_states # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2LayerNormConvLayer with","self.hubert( input_values=inputs[\"input_values\"], attention_mask=inputs[\"attention_mask\"], token_type_ids=inputs[\"token_type_ids\"], position_ids=inputs[\"position_ids\"], head_mask=inputs[\"head_mask\"], inputs_embeds=inputs[\"inputs_embeds\"], output_attentions=inputs[\"output_attentions\"], output_hidden_states=inputs[\"output_hidden_states\"], return_dict=inputs[\"return_dict\"], training=inputs[\"training\"], ) return","class TFHubertFeatureEncoder(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs: Any) -> None: super().__init__(**kwargs) if config.feat_extract_norm","in format (batch_dim, indixes) \"\"\" indices_shape = shape_list(batch_indices) # broadcast batch dim to","an embedded representation. This is useful if you want more control over how","= tf.keras.layers.Dropout(rate=config.feat_proj_dropout) def call(self, hidden_states: tf.Tensor, training: bool = False) -> tf.Tensor: hidden_states",">>> hidden_states = model(input_values).last_hidden_state ```\"\"\" inputs = input_values_processing( func=self.call, config=self.config, input_values=input_values, attention_mask=attention_mask, token_type_ids=token_type_ids,","self.num_heads, tgt_len, src_len)) attn_weights = tf.nn.softmax(attn_weights, axis=-1) if layer_head_mask is not None: #","+ z, num_samples) return indices # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2._scatter_values_on_batch_indices def _scatter_values_on_batch_indices(values, batch_indices, output_shape):","the first argument of the model call function: `model(inputs)`. If you choose this","eager. if tf.executing_eagerly(): tf.debugging.assert_equal( shape_list(layer_head_mask), [self.num_heads], message=f\"Head mask for a single layer should","superclass documentation for the generic methods the library implements for all its model","tgt_seq_len, src_seq_len]`. \"\"\" src_len = shape_list(mask)[1] tgt_len = tgt_len if tgt_len is not","may not use this file except in compliance with the License. # You","the value will always be set to True. training (`bool`, *optional*, defaults to","not self.initialized: self._init_norm() self.initialized = True self._normalize_kernel() padded_inputs = tf.pad(inputs, ((0, 0), (self.explicit_padding,","divided by length of mask span to mask approximately this percentage of all","attn_output = tf.transpose( tf.reshape(attn_output, (bsz, self.num_heads, tgt_len, self.head_dim)), (0, 2, 1, 3) )","groups=config.num_conv_pos_embedding_groups, explicit_padding=config.num_conv_pos_embeddings // 2, name=\"conv\", ) self.padding = TFHubertSamePadLayer(config.num_conv_pos_embeddings) self.activation = get_tf_activation(config.feat_extract_activation) def","get query proj query_states = self.q_proj(hidden_states) * self.scaling # get key, value proj","config self.hubert = TFHubertMainLayer(config, name=\"hubert\") @add_start_docstrings_to_model_forward(HUBERT_INPUTS_DOCSTRING) @replace_return_docstrings(output_type=TFBaseModelOutput, config_class=_CONFIG_FOR_DOC) def call( self, input_values: tf.Tensor,","if uni-directional self-attention (decoder) save Tuple(tf.Tensor, tf.Tensor) of # all previous decoder key/value_states.","num masked indices <= sequence_length if num_masked_spans * mask_length > sequence_length: num_masked_spans =","hidden_states = hidden_states[:, : -self.num_pad_remove, :] return hidden_states class TFHubertFeatureEncoder(tf.keras.layers.Layer): def __init__(self, config:","tf.Tensor, training: bool = False) -> tf.Tensor: hidden_states = self.layer_norm(hidden_states) hidden_states = self.projection(hidden_states)","else: self.gamma = None def _add_beta_weight(self, input_shape): dim = input_shape[self.axis] shape = (dim,)","IDs?](../glossary#position-ids) head_mask (`np.ndarray` or `tf.Tensor` of shape `(num_heads,)` or `(num_layers, num_heads)`, *optional*): Mask","all matter related to general usage and behavior. <Tip> TF 2.0 models accepts","// self.groups broadcast_shape.insert(self.axis, self.groups) else: broadcast_shape[self.axis] = self.groups return broadcast_shape # Copied from","= tf.keras.layers.Dropout(config.hidden_dropout) self.layer = [TFHubertEncoderLayer(config, name=f\"layers.{i}\") for i in range(config.num_hidden_layers)] def call( self,","broad_casted_batch_dims = tf.reshape( tf.broadcast_to(tf.expand_dims(tf.range(indices_shape[0]), axis=-1), indices_shape), [1, -1] ) # transform batch_indices to","position_ids=inputs[\"position_ids\"], head_mask=inputs[\"head_mask\"], inputs_embeds=inputs[\"inputs_embeds\"], output_attentions=inputs[\"output_attentions\"], output_hidden_states=inputs[\"output_hidden_states\"], return_dict=inputs[\"return_dict\"], training=inputs[\"training\"], ) hidden_states = outputs[0] hidden_states =","Example: ```python >>> import tensorflow as tf >>> from transformers import Wav2Vec2Processor, TFHubertForCTC","*inputs, **kwargs): super().__init__(config, *inputs, **kwargs) logger.warning( f\"\\n{self.__class__.__name__} has backpropagation operations that are NOT","allow to use the .name property so we check for a real Tensor","not to use the model in training mode (some modules like dropout modules","@add_start_docstrings( \"\"\"TFHubert Model with a `language modeling` head on top for Connectionist Temporal","subclass. Use it as a regular TF 2.0 Keras Model and refer to","def call( self, hidden_states: tf.Tensor, key_value_states: Optional[tf.Tensor] = None, past_key_value: Optional[Tuple[Tuple[tf.Tensor]]] = None,","Check the superclass documentation for the generic methods the library implements for all","has been depreciated \" \"and will be removed in Transformers v5. \" f\"Use","{type(input_values)} is not allowed only {allowed_types} is accepted for {parameter_names[0]}.\" ) for name",") -> Union[TFBaseModelOutput, Tuple[tf.Tensor]]: all_hidden_states = () if output_hidden_states else None all_self_attentions =","super().build(input_shape) self.kernel = tf.Variable(tf.transpose(self.kernel), name=\"weight_v\", trainable=True) self.weight_v = self.kernel self.weight_g = self.add_weight( name=\"weight_g\",","all_hidden_states = () if output_hidden_states else None all_self_attentions = () if output_attentions else","(dropout_probability < self.config.layerdrop): # skip the layer continue layer_outputs = layer_module( hidden_states=hidden_states, attention_mask=attention_mask,","by number of timesteps divided by length of mask span to mask approximately","vocab_size: {self.config.vocab_size}\") attention_mask = ( inputs[\"attention_mask\"] if inputs[\"attention_mask\"] is not None else tf.ones_like(inputs[\"input_values\"],","hidden_states # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2PositionalConvEmbedding with Wav2Vec2->Hubert class TFHubertPositionalConvEmbedding(tf.keras.layers.Layer): def __init__(self, config: HubertConfig,","does not load the weights associated with the model, only the configuration. Check","input_values.pop(\"inputs\") if \"decoder_cached_states\" in input_values: warnings.warn( \"The `decoder_cached_states` argument is deprecated and will","to use the model in training mode (some modules like dropout modules have","transformers import Wav2Vec2Processor, TFHubertModel >>> from datasets import load_dataset >>> import soundfile as","bsz) if self.is_decoder: # if cross_attention save Tuple(tf.Tensor, tf.Tensor) of all cross attention","tf.Tensor) of # all previous decoder key/value_states. Further calls to uni-directional self-attention #","name=\"masked_spec_embed\" ) super().build(input_shape) def _get_feat_extract_output_lengths(self, input_lengths: tf.Tensor): \"\"\" Computes the output length of","False, training: bool = False, ) -> Tuple[tf.Tensor]: attn_residual = hidden_states hidden_states =","v is not None) return TFBaseModelOutput( last_hidden_state=hidden_states, hidden_states=all_hidden_states, attentions=all_self_attentions, ) # Copied from","documentation for all matter related to general usage and behavior. <Tip> TF 2.0","call function: `model(inputs)`. If you choose this second option, there are three possibilities","= self._mask_hidden_states(hidden_states, mask_time_indices=mask_time_indices) encoder_outputs = self.encoder( hidden_states, attention_mask=attention_mask, output_attentions=inputs[\"output_attentions\"], output_hidden_states=inputs[\"output_hidden_states\"], return_dict=inputs[\"return_dict\"], training=inputs[\"training\"], )","get_tf_activation(config.feat_extract_activation) def call(self, hidden_states: tf.Tensor) -> tf.Tensor: hidden_states = self.conv(hidden_states) hidden_states = self.layer_norm(hidden_states)","only {allowed_types} is accepted for {parameter_names[0]}.\" ) for name in parameter_names: if name","input_shape[-2] += self.explicit_padding * 2 super().build(input_shape) self.kernel = tf.Variable(tf.transpose(self.kernel), name=\"weight_v\", trainable=True) self.weight_v =","= config self.pos_conv_embed = TFHubertPositionalConvEmbedding(config, name=\"pos_conv_embed\") self.layer_norm = tf.keras.layers.LayerNormalization(epsilon=config.layer_norm_eps, name=\"layer_norm\") self.dropout = tf.keras.layers.Dropout(config.hidden_dropout)","extracted features along time axis and/or along feature axis according to [SpecAugment](https://arxiv.org/abs/1904.08779). \"\"\"","layer_outputs[0] if output_attentions: all_self_attentions = all_self_attentions + (layer_outputs[1],) hidden_states = self.layer_norm(hidden_states) if output_hidden_states:","# Further calls to cross_attention layer can then reuse all cross-attention # key/value_states","\"\"\" Computes the output length of the convolutional layers \"\"\" def _conv_out_length(input_length, kernel_size,","a defined dimension \" \"but the layer received an input with shape \"","mask_prob: float, mask_length: int, min_masks: int = 0, ) -> tf.Tensor: \"\"\" Computes","defaults to `False``): Whether or not to use the model in training mode","0))) output = super().call(padded_inputs) return output # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2NoLayerNormConvLayer with Wav2Vec2->Hubert class","Any) -> None: super().__init__(**kwargs) self.conv = TFHubertWeightNormConv1D( filters=config.hidden_size, kernel_size=config.num_conv_pos_embeddings, groups=config.num_conv_pos_embedding_groups, explicit_padding=config.num_conv_pos_embeddings // 2,","Tuple(tf.Tensor, tf.Tensor) of all cross attention key/value_states. # Further calls to cross_attention layer","input_shape): broadcast_shape = self._create_broadcast_shape(input_shape) gamma = None beta = None if self.scale: gamma","ignored.\" ) continue else: raise ValueError(f\"Data of type {type(v)} is not allowed only","Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2EncoderStableLayerNorm with Wav2Vec2->Hubert class TFHubertEncoderStableLayerNorm(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs): super().__init__(**kwargs)","\"more than the number of channels (\" + str(dim) + \").\" ) if","call(self, input_values): hidden_states = tf.expand_dims(input_values, -1) for conv_layer in self.conv_layers: hidden_states = conv_layer(hidden_states)","-1, epsilon: float = 1e-3, center: bool = True, scale: bool = True,","__init__(self, config: HubertConfig, **kwargs): super().__init__(**kwargs) self.layer_norm = tf.keras.layers.LayerNormalization(epsilon=config.layer_norm_eps, name=\"layer_norm\") self.projection = tf.keras.layers.Dense( units=config.hidden_size,","for the feature encoder so that its parameters will not be updated during","for all its model (such as downloading or saving, resizing the input embeddings,","function of the TensorFlow model. config ([`PretrainedConfig`]): The config of the running model.","the gradient computation for the feature encoder so that its parameter will not","**kwargs): super().__init__(config, *inputs, **kwargs) self.hubert = TFHubertMainLayer(config, name=\"hubert\") self.dropout = tf.keras.layers.Dropout(config.final_dropout) self.lm_head =","layer if output_hidden_states: all_hidden_states = all_hidden_states + (hidden_states,) if not return_dict: return tuple(v","name=\"pos_conv_embed\") self.layer_norm = tf.keras.layers.LayerNormalization(epsilon=config.layer_norm_eps, name=\"layer_norm\") self.dropout = tf.keras.layers.Dropout(config.hidden_dropout) self.layer = [ TFHubertEncoderLayerStableLayerNorm(config, name=f\"layers.{i}\")","class TFHubertEncoderLayerStableLayerNorm(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs): super().__init__(**kwargs) self.attention = TFHubertAttention( embed_dim=config.hidden_size, num_heads=config.num_attention_heads,","have to add this exception if \"args\" in output: if output[\"args\"] is not","masked indices <= sequence_length if num_masked_spans * mask_length > sequence_length: num_masked_spans = sequence_length","seq_len]` to `[bsz, 1, tgt_seq_len, src_seq_len]`. \"\"\" src_len = shape_list(mask)[1] tgt_len = tgt_len","name=\"gamma\", initializer=self.gamma_initializer, regularizer=self.gamma_regularizer, constraint=self.gamma_constraint, ) else: self.gamma = None def _add_beta_weight(self, input_shape): dim","self.num_heads, -1, self.head_dim) query_states = tf.reshape(self._shape(query_states, tgt_len, bsz), proj_shape) key_states = tf.reshape(key_states, proj_shape)","to fill spec_aug_mask = tf.zeros((batch_size, sequence_length), dtype=tf.int32) # uniform distribution to sample from,","None): \"\"\" Masks extracted features along time axis and/or along feature axis according","batch[\"speech\"] = speech ... return batch >>> ds = load_dataset(\"hf-internal-testing/librispeech_asr_dummy\", \"clean\", split=\"validation\") >>>","proper output we have to add this exception if \"args\" in output: if","sequence_length, hidden_size = shape_list(hidden_states) # `config.apply_spec_augment` can set masking to False if not","1]`. [What are position IDs?](../glossary#position-ids) head_mask (`np.ndarray` or `tf.Tensor` of shape `(num_heads,)` or","TO THE UNIVERSE SIR I EXIST\" >>> # wrap processor as target processor","outputs = (hidden_states,) if output_attentions: outputs += (attn_weights,) return outputs # Copied from","def build(self, input_shape: tf.TensorShape): self.masked_spec_embed = self.add_weight( shape=(self.config.hidden_size,), initializer=\"uniform\", trainable=True, name=\"masked_spec_embed\" ) super().build(input_shape)","None: output[parameter_names[0]] = input_values else: raise ValueError( f\"Data of type {type(input_values)} is not","# So to respect the proper output we have to add this exception","(got `embed_dim`: {self.embed_dim}\" f\" and `num_heads`: {num_heads}).\" ) self.scaling = self.head_dim**-0.5 self.is_decoder =","position_ids (`np.ndarray` or `tf.Tensor` of shape `({0})`, *optional*): Indices of positions of each","class TFHubertPreTrainedModel(TFPreTrainedModel): \"\"\" An abstract class to handle weights initialization and a simple","and type(output[\"args\"]) == tf.Tensor: tensor_name = output[\"args\"].name.split(\":\")[0] output[tensor_name] = output[\"args\"] else: # `args`","* mask_length)) offsets = tf.range(mask_length)[tf.newaxis, tf.newaxis, :] offsets = tf.tile(offsets, (batch_size, num_masked_spans, 1))","mask to fill spec_aug_mask = tf.zeros((batch_size, sequence_length), dtype=tf.int32) # uniform distribution to sample","If you wish \" \"to train/fine-tine this model, you need a GPU or","self.intermediate_dense = tf.keras.layers.Dense( units=config.intermediate_size, kernel_initializer=get_initializer(config.initializer_range), bias_initializer=\"zeros\", name=\"intermediate_dense\", ) self.intermediate_act_fn = get_tf_activation(config.hidden_act) self.output_dense =","with `input_values` only and nothing else: `model(inputs_ids)` - a list of varying length","= tf.stack(group_shape) reshaped_inputs = tf.reshape(inputs, group_shape) return reshaped_inputs, group_shape else: return inputs, group_shape","input_values: tf.Tensor, attention_mask: Optional[tf.Tensor] = None, token_type_ids: Optional[tf.Tensor] = None, position_ids: Optional[tf.Tensor] =","sequence_length uniform_dist = tf.ones((batch_size, sequence_length - (mask_length - 1))) # get random indices","the docstring: `model([input_values, attention_mask])` or `model([input_values, attention_mask, token_type_ids])` - a dictionary with one","TensorFlow Hubert model.\"\"\" import inspect import warnings from typing import Any, Dict, Optional,","function as in PyTorch with indices in format (batch_dim, indixes) \"\"\" indices_shape =","size 1 >>> logits = model(input_values).logits >>> predicted_ids = tf.argmax(logits, axis=-1) >>> transcription","None, training: Optional[bool] = False, ) -> Union[TFCausalLMOutput, Tuple[tf.Tensor]]: r\"\"\" labels (`tf.Tensor` or","model is also a [tf.keras.Model](https://www.tensorflow.org/api_docs/python/tf/keras/Model) subclass. Use it as a regular TF 2.0","as tf >>> from transformers import Wav2Vec2Processor, TFHubertForCTC >>> from datasets import load_dataset","None, layer_head_mask: Optional[tf.Tensor] = None, training: Optional[bool] = False, ) -> Tuple[tf.Tensor, Optional[tf.Tensor]]:","= config.conv_dim[layer_id] if layer_id > 0 else 1 self.out_conv_dim = config.conv_dim[layer_id] self.conv =","base_config = super().get_config() return {**base_config, **config} def compute_output_shape(self, input_shape): return input_shape def _reshape_into_groups(self,","- a list of varying length with one or several input Tensors IN","key_value_states are provided this layer is used as a cross-attention layer # for","= input elif isinstance(input, allowed_types) or input is None: output[parameter_names[i]] = input else:","this case is always the first parameter, then `input_values` output[\"input_values\"] = output[\"args\"] del","input_shape): broadcast_shape = [1] * len(input_shape) is_instance_norm = (input_shape[self.axis] // self.groups) == 1","Optional[tf.Tensor] = None, inputs_embeds: Optional[tf.Tensor] = None, output_attentions: Optional[tf.Tensor] = None, output_hidden_states: Optional[tf.Tensor]","encoder so that its parameters will not be updated during training. \"\"\" warnings.warn(","random mask spans for a given shape Args: shape: the the shape for","strides=config.conv_stride[layer_id], use_bias=config.conv_bias, name=\"conv\", ) self.activation = get_tf_activation(config.feat_extract_activation) def call(self, hidden_states: tf.Tensor) -> tf.Tensor:","beta_constraint: tf.keras.constraints.Constraint = None, gamma_constraint: tf.keras.constraints.Constraint = None, **kwargs, ): super().__init__(**kwargs) self.supports_masking =","The callable function of the TensorFlow model. config ([`PretrainedConfig`]): The config of the","number of masked spans in batch num_masked_spans = int(mask_prob * sequence_length / mask_length","call( self, hidden_states: tf.Tensor, attention_mask: Optional[tf.Tensor] = None, output_attentions: Optional[bool] = False, output_hidden_states:","def __init__(self, config: HubertConfig, **kwargs): super().__init__(**kwargs) self.config = config self.pos_conv_embed = TFHubertPositionalConvEmbedding(config, name=\"pos_conv_embed\")","self.groups: raise ValueError( \"Number of groups (\" + str(self.groups) + \") cannot be","units=config.hidden_size, kernel_initializer=get_initializer(config.initializer_range), bias_initializer=\"zeros\", name=\"output_dense\", ) self.output_dropout = tf.keras.layers.Dropout(config.hidden_dropout) def call(self, hidden_states: tf.Tensor, training:","not use this file except in compliance with the License. # You may","return a [`~file_utils.ModelOutput`] instead of a plain tuple. This argument can be used","TFBart->TFHubert class TFHubertAttention(tf.keras.layers.Layer): \"\"\"Multi-headed attention from \"Attention Is All You Need\"\"\" def __init__(","Optional[tf.Tensor] = None, output_attentions: Optional[tf.Tensor] = None, output_hidden_states: Optional[tf.Tensor] = None, return_dict: Optional[bool]","= self.add_weight( shape=(self.config.hidden_size,), initializer=\"uniform\", trainable=True, name=\"masked_spec_embed\" ) super().build(input_shape) def _get_feat_extract_output_lengths(self, input_lengths: tf.Tensor): \"\"\"","encoder_outputs[0] if not inputs[\"return_dict\"]: return (hidden_states,) + encoder_outputs[1:] return TFBaseModelOutput( last_hidden_state=hidden_states, hidden_states=encoder_outputs.hidden_states, attentions=encoder_outputs.attentions,","call(self, inputs): input_shape = tf.keras.backend.int_shape(inputs) tensor_input_shape = tf.shape(inputs) reshaped_inputs, group_shape = self._reshape_into_groups(inputs, input_shape,","attn_weights, past_key_value # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2FeedForward with Wav2Vec2->Hubert class TFHubertFeedForward(tf.keras.layers.Layer): def __init__(self, config:","transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2SamePadLayer with Wav2Vec2->Hubert class TFHubertSamePadLayer(tf.keras.layers.Layer): def __init__(self, num_conv_pos_embeddings, **kwargs): super().__init__(**kwargs) self.num_pad_remove = 1","reshaped_inputs, group_shape else: return inputs, group_shape def _apply_normalization(self, reshaped_inputs, input_shape): group_shape = tf.keras.backend.int_shape(reshaped_inputs)","__init__(self, config: HubertConfig, **kwargs): super().__init__(**kwargs) self.intermediate_dropout = tf.keras.layers.Dropout(config.activation_dropout) self.intermediate_dense = tf.keras.layers.Dense( units=config.intermediate_size, kernel_initializer=get_initializer(config.initializer_range),","prevent masking padded elements mask_prob: probability for each token to be chosen as","agreed to in writing, software # distributed under the License is distributed on","token, - 1 corresponds to a *sentence B* token. [What are token type","tf.Tensor]` or `Dict[str, np.ndarray]` and each example must have the shape `({0})`): Indices","not None else tf.ones_like(inputs[\"input_values\"], dtype=tf.float32) ) input_lengths = self.hubert._get_feat_extract_output_lengths(tf.reduce_sum(attention_mask, axis=-1)) # assuming that","None, token_type_ids: Optional[tf.Tensor] = None, position_ids: Optional[tf.Tensor] = None, head_mask: Optional[tf.Tensor] = None,","self._create_broadcast_shape(input_shape) gamma = None beta = None if self.scale: gamma = tf.reshape(self.gamma, broadcast_shape)","def _shape(self, tensor: tf.Tensor, seq_len: int, bsz: int): return tf.transpose(tf.reshape(tensor, (bsz, seq_len, self.num_heads,","def _compute_mask_indices( shape: Tuple[int, int], mask_prob: float, mask_length: int, min_masks: int = 0,","batch_indices, output_shape): \"\"\" Scatter function as in PyTorch with indices in format (batch_dim,","dim def _check_size_of_dimensions(self, input_shape): dim = input_shape[self.axis] if dim < self.groups: raise ValueError(","reuse k,v, cross_attentions key_states = past_key_value[0] value_states = past_key_value[1] elif is_cross_attention: # cross_attentions","Keras Model and refer to the TF 2.0 documentation for all matter related","False if not getattr(self.config, \"apply_spec_augment\", True): return hidden_states if mask_time_indices is not None:","= tf.keras.backend.int_shape(reshaped_inputs) group_reduction_axes = list(range(1, len(group_shape))) is_instance_norm = (input_shape[self.axis] // self.groups) == 1","- having all inputs as a list, tuple or dict in the first","= tf.reshape(attn_weights, (bsz, self.num_heads, tgt_len, src_len)) + attention_mask attn_weights = tf.reshape(attn_weights, (bsz *","{**base_config, **config} def compute_output_shape(self, input_shape): return input_shape def _reshape_into_groups(self, inputs, input_shape, tensor_input_shape): group_shape","\"sum\": loss = tf.reduce_sum(loss) if self.config.ctc_loss_reduction == \"mean\": loss = tf.reduce_mean(loss) else: loss","to return a [`~file_utils.ModelOutput`] instead of a plain tuple. This argument can be","for the unexpected layers. \"\"\" signature = dict(inspect.signature(func).parameters) signature.pop(\"kwargs\", None) signature.pop(\"self\", None) parameter_names","value_states = past_key_value[1] elif is_cross_attention: # cross_attentions key_states = self._shape(self.k_proj(key_value_states), -1, bsz) value_states","shape_list(layer_head_mask), [self.num_heads], message=f\"Head mask for a single layer should be of size {(self.num_heads)},","ValueError( \"Axis \" + str(self.axis) + \" of \" \"input tensor should have","refer to the TF 2.0 documentation for all matter related to general usage","Indices should be in `[-100, 0, ..., config.vocab_size]` (see `input_values` docstring) Tokens with","None, past_key_values_length: int = 0): \"\"\" Expands attention_mask from `[bsz, seq_len]` to `[bsz,","in other modes than eager. if tf.executing_eagerly(): tf.debugging.assert_equal( shape_list(layer_head_mask), [self.num_heads], message=f\"Head mask for","else self.axis - 1 else: axis = -1 if self.axis == -1 else","hidden_states): if self.num_pad_remove > 0: hidden_states = hidden_states[:, : -self.num_pad_remove, :] return hidden_states",") # compute number of masked spans in batch num_masked_spans = int(mask_prob *","mode the value in the config will be used instead. return_dict (`bool`, *optional*):","or a TPU\" ) @tf.function def serving(self, inputs): output = self.call(input_values=inputs, training=False) return","output_lengths, maxlen=shape_list(hidden_states)[1], dtype=hidden_states.dtype ) hidden_states = self.feature_projection(hidden_states, training=inputs[\"training\"]) mask_time_indices = kwargs.get(\"mask_time_indices\", None) if","if labels is not None: if tf.reduce_max(labels) >= self.config.vocab_size: raise ValueError(f\"Label values must","1 self.out_conv_dim = config.conv_dim[layer_id] self.conv = tf.keras.layers.Conv1D( filters=self.out_conv_dim, kernel_size=config.conv_kernel[layer_id], strides=config.conv_stride[layer_id], use_bias=config.conv_bias, name=\"conv\", )","tf.keras.layers.Dense(embed_dim, use_bias=bias, name=\"v_proj\") self.out_proj = tf.keras.layers.Dense(embed_dim, use_bias=bias, name=\"out_proj\") def _shape(self, tensor: tf.Tensor, seq_len:","logging, replace_return_docstrings, ) from .configuration_hubert import HubertConfig logger = logging.get_logger(__name__) _CONFIG_FOR_DOC = \"HubertConfig\"","{} allowed_types = (tf.Tensor, bool, int, ModelOutput, tuple, list, dict, np.ndarray) for k,","(input_shape[self.axis] // self.groups) == 1 if not is_instance_norm: group_shape[self.axis] = input_shape[self.axis] // self.groups","*optional*): Labels for computing the masked language modeling loss. Indices should be in","kwargs.items(): if isinstance(v, allowed_types) or v is None: output[k] = v else: raise","I EXIST\" >>> # wrap processor as target processor to encode labels >>>","self.gamma_initializer = tf.keras.initializers.get(gamma_initializer) self.beta_regularizer = tf.keras.regularizers.get(beta_regularizer) self.gamma_regularizer = tf.keras.regularizers.get(gamma_regularizer) self.beta_constraint = tf.keras.constraints.get(beta_constraint) self.gamma_constraint","corresponds to a *sentence B* token. [What are token type IDs?](../glossary#token-type-ids) position_ids (`np.ndarray`","hidden_states = self.layer_norm(hidden_states) hidden_states = self.activation(hidden_states) return hidden_states # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2GroupNormConvLayer with","= Wav2Vec2Processor.from_pretrained(\"facebook/hubert-base-960h\") >>> model = TFHubertForCTC.from_pretrained(\"facebook/hubert-base-960h\") >>> def map_to_array(batch): ... speech, _ =","the Apache License, Version 2.0 (the \"License\"); # you may not use this","from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2PositionalConvEmbedding with Wav2Vec2->Hubert class TFHubertPositionalConvEmbedding(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs: Any) ->","in self.conv_layers: hidden_states = conv_layer(hidden_states) return hidden_states class TFHubertFeatureExtractor(TFHubertFeatureEncoder): def __init__(self, config, **kwargs):","signature[name].default) # When creating a SavedModel TF calls the method with LayerCall.__call__(args, **kwargs)","parameter {k} does not belongs to the parameter list {parameter_names} and will be","2.7, so we need to account for padding input_shape[-2] += self.explicit_padding * 2","= input_shape[self.axis] shape = (dim,) if self.scale: self.gamma = self.add_weight( shape=shape, name=\"gamma\", initializer=self.gamma_initializer,","behavior. <Tip> TF 2.0 models accepts two formats as inputs: - having all","`({0})`, *optional*): Segment token indices to indicate first and second portions of the","= model(input_values).last_hidden_state ```\"\"\" inputs = input_values_processing( func=self.call, config=self.config, input_values=input_values, attention_mask=attention_mask, token_type_ids=token_type_ids, position_ids=position_ids, head_mask=head_mask,","to the TF 2.0 documentation for all matter related to general usage and","Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2SamePadLayer with Wav2Vec2->Hubert class TFHubertSamePadLayer(tf.keras.layers.Layer): def __init__(self, num_conv_pos_embeddings, **kwargs): super().__init__(**kwargs) self.num_pad_remove","downloading or saving, resizing the input embeddings, pruning heads etc.) This model is","will be used instead. return_dict (`bool`, *optional*): Whether or not to return a",") return outputs def serving_output(self, output): hs = tf.convert_to_tensor(output.hidden_states) if self.config.output_hidden_states else None","method with LayerCall.__call__(args, **kwargs) # So to respect the proper output we have","sequence_length: raise ValueError( f\"`mask_length` has to be smaller than `sequence_length`, but got `mask_length`:","_compute_mask_indices( shape: Tuple[int, int], mask_prob: float, mask_length: int, min_masks: int = 0, )","HubertConfig, **kwargs): super().__init__(**kwargs) self.intermediate_dropout = tf.keras.layers.Dropout(config.activation_dropout) self.intermediate_dense = tf.keras.layers.Dense( units=config.intermediate_size, kernel_initializer=get_initializer(config.initializer_range), bias_initializer=\"zeros\", name=\"intermediate_dense\",",") continue else: raise ValueError(f\"Data of type {type(v)} is not allowed only {allowed_types}","(batch_size, num_masked_spans * mask_length)) offsets = tf.range(mask_length)[tf.newaxis, tf.newaxis, :] offsets = tf.tile(offsets, (batch_size,","as keyword arguments (like PyTorch models), or - having all inputs as a","not in list(output.keys()) and name != \"args\": output[name] = kwargs.pop(name, signature[name].default) # When","if encoder bi-directional self-attention `past_key_value` is always `None` past_key_value = (key_states, value_states) proj_shape","and will be removed in a future version, use `input_values` instead.\", FutureWarning, )","self.freeze_feature_encoder() def freeze_feature_encoder(self): \"\"\" Calling this function will disable the gradient computation for","of all layers. See `hidden_states` under returned tensors for more detail. This argument","+ (layer_outputs[1],) hidden_states = self.layer_norm(hidden_states) if output_hidden_states: all_hidden_states = all_hidden_states + (hidden_states,) if","output[tensor_name] = input else: output[parameter_names[i]] = input elif isinstance(input, allowed_types) or input is","self.dropout = tf.keras.layers.Dropout(config.hidden_dropout) self.layer = [ TFHubertEncoderLayerStableLayerNorm(config, name=f\"layers.{i}\") for i in range(config.num_hidden_layers) ]","modes than eager. if tf.executing_eagerly(): tf.debugging.assert_equal( shape_list(attention_mask), [bsz, 1, tgt_len, src_len], message=f\"Attention mask","input embeddings, pruning heads etc.) This model is also a [tf.keras.Model](https://www.tensorflow.org/api_docs/python/tf/keras/Model) subclass. Use","probability for each token to be chosen as start of the span to",") if inputs[\"attention_mask\"] is not None: # compute real output lengths according to","k not in parameter_names and \"args\" not in parameter_names: logger.warning( f\"The parameter {k}","than 0.\") if mask_length > sequence_length: raise ValueError( f\"`mask_length` has to be smaller","if k in [\"return_dict\", \"output_attentions\", \"output_hidden_states\", \"use_cache\"] } output.update(booleans_processing(config=config, **boolean_dict)) return output #","dropout=config.attention_dropout, is_decoder=False, name=\"attention\", ) self.dropout = tf.keras.layers.Dropout(config.hidden_dropout) self.layer_norm = tf.keras.layers.LayerNormalization(epsilon=config.layer_norm_eps, name=\"layer_norm\") self.feed_forward =","a SavedModel TF calls the method with LayerCall.__call__(args, **kwargs) # So to respect","Optional[tf.Tensor] = None, head_mask: Optional[tf.Tensor] = None, inputs_embeds: Optional[tf.Tensor] = None, output_attentions: Optional[bool]","layer is used as a cross-attention layer # for the decoder is_cross_attention =","\"Please use the equivalent `freeze_feature_encoder` method instead.\", FutureWarning, ) self.freeze_feature_encoder() def freeze_feature_encoder(self): \"\"\"","with Wav2Vec2->Hubert class TFHubertEncoderLayerStableLayerNorm(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs): super().__init__(**kwargs) self.attention = TFHubertAttention(","(see `input_values` docstring) Tokens with indices set to `-100` are ignored (masked), the","= self.activation(hidden_states) return hidden_states # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2PositionalConvEmbedding with Wav2Vec2->Hubert class TFHubertPositionalConvEmbedding(tf.keras.layers.Layer): def","hidden_states, 0) return hidden_states def call( self, input_values: tf.Tensor, attention_mask: Optional[tf.Tensor] = None,","attn_residual = hidden_states hidden_states, attn_weights, _ = self.attention( hidden_states, attention_mask=attention_mask, training=training ) hidden_states","target_lengths = tf.reduce_sum(labels_mask, axis=-1) loss = tf.nn.ctc_loss( logits=logits, labels=labels, logit_length=input_lengths, label_length=target_lengths, blank_index=self.config.pad_token_id, logits_time_major=False,","transpose_b=True) # The tf.debugging asserts are not compliant with XLA then they #","kernel_size=config.num_conv_pos_embeddings, groups=config.num_conv_pos_embedding_groups, explicit_padding=config.num_conv_pos_embeddings // 2, name=\"conv\", ) self.padding = TFHubertSamePadLayer(config.num_conv_pos_embeddings) self.activation = get_tf_activation(config.feat_extract_activation)","all the input Tensors in the first positional argument : - a single","2, name=\"conv\", ) self.padding = TFHubertSamePadLayer(config.num_conv_pos_embeddings) self.activation = get_tf_activation(config.feat_extract_activation) def call(self, hidden_states: tf.Tensor)","last_hidden_state=hidden_states, hidden_states=all_hidden_states, attentions=all_self_attentions, ) @keras_serializable class TFHubertMainLayer(tf.keras.layers.Layer): config_class = HubertConfig def __init__(self, config:","= HubertConfig def __init__(self, config: HubertConfig, **kwargs): super().__init__(**kwargs) self.config = config self.feature_extractor =","with Wav2Vec2->Hubert class TFHubertGroupNorm(tf.keras.layers.Layer): \"\"\" From tensorflow-addons https://www.tensorflow.org/addons/api_docs/python/tfa/layers/GroupNormalization \"\"\" def __init__( self, groups:","= ( inputs[\"attention_mask\"] if inputs[\"attention_mask\"] is not None else tf.ones_like(inputs[\"input_values\"], dtype=tf.float32) ) input_lengths","for details. [What are input IDs?](../glossary#input-ids) attention_mask (`np.ndarray` or `tf.Tensor` of shape `({0})`,","with processor.as_target_processor(): ... labels = processor(transcription, return_tensors=\"tf\").input_values >>> loss = model(input_values, labels=labels).loss ```\"\"\"","`(num_layers, num_heads)`, *optional*): Mask to nullify selected heads of the self-attention modules. Mask","the missing layers, and another one for the unexpected layers. \"\"\" signature =","or `tf.Tensor` of shape `({0})`, *optional*): Segment token indices to indicate first and","= input_shape[self.axis] // self.groups broadcast_shape.insert(self.axis, self.groups) else: broadcast_shape[self.axis] = self.groups return broadcast_shape #","output we have to add this exception if \"args\" in output: if output[\"args\"]","is not None) return TFBaseModelOutput( last_hidden_state=hidden_states, hidden_states=all_hidden_states, attentions=all_self_attentions, ) @keras_serializable class TFHubertMainLayer(tf.keras.layers.Layer): config_class","== 1 if not is_instance_norm: broadcast_shape[self.axis] = input_shape[self.axis] // self.groups broadcast_shape.insert(self.axis, self.groups) else:","is not None: # reuse k,v, cross_attentions key_states = past_key_value[0] value_states = past_key_value[1]","self-attention # can concat previous decoder key/value_states to current projected key/value_states (third \"elif\"","head_mask=head_mask, inputs_embeds=inputs_embeds, output_attentions=output_attentions, output_hidden_states=output_hidden_states, return_dict=return_dict, training=training, ) inputs[\"output_hidden_states\"] = ( inputs[\"output_hidden_states\"] if inputs[\"output_hidden_states\"]","depreciated \" \"and will be removed in Transformers v5. \" f\"Use `{self.__class__.__bases__[0].__name__}` instead.\",","None def _add_beta_weight(self, input_shape): dim = input_shape[self.axis] shape = (dim,) if self.center: self.beta","embed_dim)) attn_output = self.out_proj(attn_output) attn_weights: tf.Tensor = tf.reshape(attn_weights, (bsz, self.num_heads, tgt_len, src_len)) return","v elif k not in parameter_names and \"args\" not in parameter_names: logger.warning( f\"The","self.projection = tf.keras.layers.Dense( units=config.hidden_size, kernel_initializer=get_initializer(config.initializer_range), bias_initializer=\"zeros\", name=\"projection\", ) self.dropout = tf.keras.layers.Dropout(rate=config.feat_proj_dropout) def call(self,","def call(self, hidden_states): if self.num_pad_remove > 0: hidden_states = hidden_states[:, : -self.num_pad_remove, :]","group_shape = self._reshape_into_groups(inputs, input_shape, tensor_input_shape) normalized_inputs = self._apply_normalization(reshaped_inputs, input_shape) is_instance_norm = (input_shape[self.axis] //","not None: # reuse k, v, self_attention key_states = self._shape(self.k_proj(hidden_states), -1, bsz) value_states","Model configuration class with all the parameters of the model. Initializing with a","-1, bsz) value_states = self._shape(self.v_proj(hidden_states), -1, bsz) if self.is_decoder: # if cross_attention save","key_states = past_key_value[0] value_states = past_key_value[1] elif is_cross_attention: # cross_attentions key_states = self._shape(self.k_proj(key_value_states),","head_mask=head_mask, inputs_embeds=inputs_embeds, output_attentions=output_attentions, output_hidden_states=output_hidden_states, return_dict=return_dict, training=training, ) outputs = self.hubert( input_values=inputs[\"input_values\"], attention_mask=inputs[\"attention_mask\"], token_type_ids=inputs[\"token_type_ids\"],","input_values=input_values, attention_mask=attention_mask, token_type_ids=token_type_ids, position_ids=position_ids, head_mask=head_mask, inputs_embeds=inputs_embeds, output_attentions=output_attentions, output_hidden_states=output_hidden_states, return_dict=return_dict, training=training, kwargs_call=kwargs, ) hidden_states","= tf.reduce_sum(loss) if self.config.ctc_loss_reduction == \"mean\": loss = tf.reduce_mean(loss) else: loss = None","{(bsz, 1, tgt_len, src_len)}, but is {shape_list(attention_mask)}\", ) attention_mask = tf.cast(attention_mask, dtype=attn_weights.dtype) attn_weights","on an \"AS IS\" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,","training=inputs[\"training\"], ) hidden_states = encoder_outputs[0] if not inputs[\"return_dict\"]: return (hidden_states,) + encoder_outputs[1:] return","to mask spec_aug_mask_idxs = _sample_without_replacement(uniform_dist, num_masked_spans) # expand masked indices to masked spans","it as a regular TF 2.0 Keras Model and refer to the TF","booleans. In case of a list of symbolic inputs, each input has to","= None position_embeddings = self.pos_conv_embed(hidden_states) hidden_states = hidden_states + position_embeddings hidden_states = self.dropout(hidden_states,","modules have different behaviors between training and evaluation). \"\"\" @add_start_docstrings( \"The bare TFHubert","range(len(input_shape))] is_instance_norm = (input_shape[self.axis] // self.groups) == 1 if not is_instance_norm: group_shape[self.axis] =","`inputs` argument is deprecated and will be removed in a future version, use","\"\"\"Multi-headed attention from \"Attention Is All You Need\"\"\" def __init__( self, embed_dim: int,","output): hs = tf.convert_to_tensor(output.hidden_states) if self.config.output_hidden_states else None attns = tf.convert_to_tensor(output.attentions) if self.config.output_attentions","value_states) proj_shape = (bsz * self.num_heads, -1, self.head_dim) query_states = tf.reshape(self._shape(query_states, tgt_len, bsz),","padded_inputs = tf.pad(inputs, ((0, 0), (self.explicit_padding, self.explicit_padding), (0, 0))) output = super().call(padded_inputs) return","return TFBaseModelOutput(last_hidden_state=output.last_hidden_state, hidden_states=hs, attentions=attns) @add_start_docstrings( \"\"\"TFHubert Model with a `language modeling` head on","== tf.Tensor: # Tensor names have always the pattern `name:id` then we check","f\"`config.feat_extract_norm` is {config.feat_extract_norm}, but has to be one of ['group', 'layer']\" ) self.conv_layers","1)) offsets = tf.reshape(offsets, (batch_size, num_masked_spans * mask_length)) spec_aug_mask_idxs = spec_aug_mask_idxs + offsets","disabled in other modes than eager. if tf.executing_eagerly(): tf.debugging.assert_equal( shape_list(attn_weights), [bsz * self.num_heads,","need a GPU or a TPU\" ) @tf.function def serving(self, inputs): output =","def __init__(self, config: HubertConfig, **kwargs): super().__init__(**kwargs) self.layer_norm = tf.keras.layers.LayerNormalization(epsilon=config.layer_norm_eps, name=\"layer_norm\") self.projection = tf.keras.layers.Dense(","that are **masked**. [What are attention masks?](../glossary#attention-mask) token_type_ids (`np.ndarray` or `tf.Tensor` of shape","# http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in","Batch size 1 >>> hidden_states = model(input_values).last_hidden_state ```\"\"\" inputs = input_values_processing( func=self.call, config=self.config,","from ...modeling_tf_utils import TFPreTrainedModel, booleans_processing, get_initializer, keras_serializable from ...tf_utils import shape_list from ...tokenization_utils_base","load_dataset(\"hf-internal-testing/librispeech_asr_dummy\", \"clean\", split=\"validation\") >>> ds = ds.map(map_to_array) >>> input_values = processor(ds[\"speech\"][0], return_tensors=\"tf\").input_values #","replace_return_docstrings, ) from .configuration_hubert import HubertConfig logger = logging.get_logger(__name__) _CONFIG_FOR_DOC = \"HubertConfig\" TF_HUBERT_PRETRAINED_MODEL_ARCHIVE_LIST","TFPreTrainedModel, booleans_processing, get_initializer, keras_serializable from ...tf_utils import shape_list from ...tokenization_utils_base import BatchEncoding from","lengths according to convolution formula output_lengths = self._get_feat_extract_output_lengths(tf.reduce_sum(inputs[\"attention_mask\"], -1)) attention_mask = tf.sequence_mask( output_lengths,","the parameters name, i.e. `input_values = tf.keras.Input(shape=(128,), dtype='float32', name=\"input_values\")` otherwise the order of","[1, -1] ) # transform batch_indices to pair_indices pair_indices = tf.transpose(tf.concat([broad_casted_batch_dims, tf.reshape(batch_indices, [1,","to current projected key/value_states (third \"elif\" case) # if encoder bi-directional self-attention `past_key_value`","arguments. This second option is useful when using [`tf.keras.Model.fit`] method which currently requires","= self._shape(self.v_proj(key_value_states), -1, bsz) elif past_key_value is not None: # reuse k, v,","return_dict: return tuple(v for v in [hidden_states, all_hidden_states, all_self_attentions] if v is not","embed_dim self.num_heads = num_heads self.dropout = tf.keras.layers.Dropout(dropout) self.head_dim = embed_dim // num_heads if","use_bias=config.conv_bias, name=\"conv\", ) self.activation = get_tf_activation(config.feat_extract_activation) self.layer_norm = TFHubertGroupNorm(groups=self.out_conv_dim, epsilon=config.layer_norm_eps, name=\"layer_norm\") def call(self,","kernel_size, groups, explicit_padding, **kwargs): super().__init__( filters=filters, kernel_size=kernel_size, groups=groups, padding=\"valid\", use_bias=True, bias_initializer=\"he_normal\", **kwargs, )","hidden_size)`, *optional*): Optionally, instead of passing `input_values` you can choose to directly pass","tf.constant([0, 1]) def _init_norm(self): \"\"\"Set the norm of the weight vector.\"\"\" kernel_norm =","= tf.keras.layers.Dropout(config.hidden_dropout) self.layer_norm = tf.keras.layers.LayerNormalization(epsilon=config.layer_norm_eps, name=\"layer_norm\") self.feed_forward = TFHubertFeedForward(config, name=\"feed_forward\") self.final_layer_norm = tf.keras.layers.LayerNormalization(","masks?](../glossary#attention-mask) token_type_ids (`np.ndarray` or `tf.Tensor` of shape `({0})`, *optional*): Segment token indices to","= tf.keras.layers.Dropout(config.activation_dropout) self.intermediate_dense = tf.keras.layers.Dense( units=config.intermediate_size, kernel_initializer=get_initializer(config.initializer_range), bias_initializer=\"zeros\", name=\"intermediate_dense\", ) self.intermediate_act_fn = get_tf_activation(config.hidden_act)","heads of the self-attention modules. Mask values selected in `[0, 1]`: - 1","the output length of the convolutional layers \"\"\" def _conv_out_length(input_length, kernel_size, stride): #","**kwargs): super().__init__(config, *inputs, **kwargs) logger.warning( f\"\\n{self.__class__.__name__} has backpropagation operations that are NOT supported","indices into associated vectors than the model's internal embedding lookup matrix. output_attentions (`bool`,","{ \"groups\": self.groups, \"axis\": self.axis, \"epsilon\": self.epsilon, \"center\": self.center, \"scale\": self.scale, \"beta_initializer\": tf.keras.initializers.serialize(self.beta_initializer),","self.scale, \"beta_initializer\": tf.keras.initializers.serialize(self.beta_initializer), \"gamma_initializer\": tf.keras.initializers.serialize(self.gamma_initializer), \"beta_regularizer\": tf.keras.regularizers.serialize(self.beta_regularizer), \"gamma_regularizer\": tf.keras.regularizers.serialize(self.gamma_regularizer), \"beta_constraint\": tf.keras.constraints.serialize(self.beta_constraint), \"gamma_constraint\": tf.keras.constraints.serialize(self.gamma_constraint),","an input with shape \" + str(input_shape) + \".\" ) def _set_number_of_groups_for_instance_norm(self, input_shape):","None beta = None if self.scale: gamma = tf.reshape(self.gamma, broadcast_shape) if self.center: beta",") def _create_input_spec(self, input_shape): dim = input_shape[self.axis] self.input_spec = tf.keras.layers.InputSpec(ndim=len(input_shape), axes={self.axis: dim}) def","mask for a single layer should be of size {(self.num_heads)}, but is {shape_list(layer_head_mask)}\",","training: bool = False, ) -> Union[TFBaseModelOutput, Tuple[tf.Tensor]]: \"\"\" Returns: Example: ```python >>>","for {k}.\") if isinstance(input_values, (tuple, list)): for i, input in enumerate(input_values): # EagerTensors","-> tf.Tensor: \"\"\" Computes random mask spans for a given shape Args: shape:","one for the unexpected layers. \"\"\" signature = dict(inspect.signature(func).parameters) signature.pop(\"kwargs\", None) signature.pop(\"self\", None)","... speech, _ = sf.read(batch[\"file\"]) ... batch[\"speech\"] = speech ... return batch >>>","attention_mask=attention_mask, token_type_ids=token_type_ids, position_ids=position_ids, head_mask=head_mask, inputs_embeds=inputs_embeds, output_attentions=output_attentions, output_hidden_states=output_hidden_states, return_dict=return_dict, training=training, kwargs_call=kwargs, ) hidden_states =","self.groups) == 1 if not is_instance_norm: broadcast_shape[self.axis] = input_shape[self.axis] // self.groups broadcast_shape.insert(self.axis, self.groups)",">>> import soundfile as sf >>> processor = Wav2Vec2Processor.from_pretrained(\"facebook/hubert-base-960h\") >>> model = TFHubertForCTC.from_pretrained(\"facebook/hubert-base-960h\")","x Channel\"\"\" # if key_value_states are provided this layer is used as a","if self.num_pad_remove > 0: hidden_states = hidden_states[:, : -self.num_pad_remove, :] return hidden_states class","= None): \"\"\" Masks extracted features along time axis and/or along feature axis","output[\"input_values\"] = input_values.pop(\"inputs\") if \"decoder_cached_states\" in input_values: warnings.warn( \"The `decoder_cached_states` argument is deprecated","all_self_attentions] if v is not None) return TFBaseModelOutput( last_hidden_state=hidden_states, hidden_states=all_hidden_states, attentions=all_self_attentions, ) @keras_serializable","<= vocab_size: {self.config.vocab_size}\") attention_mask = ( inputs[\"attention_mask\"] if inputs[\"attention_mask\"] is not None else","to convert `input_values` indices into associated vectors than the model's internal embedding lookup","= tf.keras.layers.Dense( units=config.hidden_size, kernel_initializer=get_initializer(config.initializer_range), bias_initializer=\"zeros\", name=\"output_dense\", ) self.output_dropout = tf.keras.layers.Dropout(config.hidden_dropout) def call(self, hidden_states:","sequence_length if num_masked_spans * mask_length > sequence_length: num_masked_spans = sequence_length // mask_length #","self.beta = self.add_weight( shape=shape, name=\"beta\", initializer=self.beta_initializer, regularizer=self.beta_regularizer, constraint=self.beta_constraint, ) else: self.beta = None","isinstance(input, allowed_types) or input is None: output[parameter_names[i]] = input else: raise ValueError( f\"Data","= [ \"facebook/hubert-base-ls960\", # See all Hubert models at https://huggingface.co/models?filter=hubert ] LARGE_NEGATIVE =","IN THE ORDER given in the docstring: `model([input_values, attention_mask])` or `model([input_values, attention_mask, token_type_ids])`","Optional[tf.Tensor] = None, training: Optional[bool] = False, ) -> Tuple[tf.Tensor, Optional[tf.Tensor]]: \"\"\"Input shape:","hidden_states, attention_mask=attention_mask, output_attentions=inputs[\"output_attentions\"], output_hidden_states=inputs[\"output_hidden_states\"], return_dict=inputs[\"return_dict\"], training=inputs[\"training\"], ) hidden_states = encoder_outputs[0] if not inputs[\"return_dict\"]:","f\"`mask_length` has to be smaller than `sequence_length`, but got `mask_length`: {mask_length} and `sequence_length`:","weights. \"\"\" HUBERT_INPUTS_DOCSTRING = r\"\"\" Args: input_values (`np.ndarray`, `tf.Tensor`, `List[tf.Tensor]` ``Dict[str, tf.Tensor]` or","mode the value in the config will be used instead. output_hidden_states (`bool`, *optional*):","+ self.feed_forward(hidden_states) hidden_states = self.final_layer_norm(hidden_states) outputs = (hidden_states,) if output_attentions: outputs += (attn_weights,)","HubertConfig logger = logging.get_logger(__name__) _CONFIG_FOR_DOC = \"HubertConfig\" TF_HUBERT_PRETRAINED_MODEL_ARCHIVE_LIST = [ \"facebook/hubert-base-ls960\", # See","config_class = HubertConfig base_model_prefix = \"hubert\" main_input_name = \"input_values\" @property def dummy_inputs(self) ->","the the shape for which to compute masks. should be of size 2","tf.keras.constraints.serialize(self.gamma_constraint), } base_config = super().get_config() return {**base_config, **config} def compute_output_shape(self, input_shape): return input_shape","= tf.reduce_sum(labels_mask, axis=-1) loss = tf.nn.ctc_loss( logits=logits, labels=labels, logit_length=input_lengths, label_length=target_lengths, blank_index=self.config.pad_token_id, logits_time_major=False, )","WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See","tf.newaxis, tf.newaxis]) def _normalize_kernel(self): \"\"\"Generate normalized weights.\"\"\" kernel = tf.nn.l2_normalize(self.weight_v, axis=self.kernel_norm_axes) * tf.transpose(self.weight_g)","= False, ) -> Union[TFCausalLMOutput, Tuple[tf.Tensor]]: r\"\"\" labels (`tf.Tensor` or `np.ndarray` of shape","*inputs, **kwargs): super().__init__(config, *inputs, **kwargs) self.hubert = TFHubertMainLayer(config, name=\"hubert\") self.dropout = tf.keras.layers.Dropout(config.final_dropout) self.lm_head","has to be one of ['group', 'layer']\" ) self.conv_layers = conv_layers def call(self,","inputs: - having all inputs as keyword arguments (like PyTorch models), or -","position_embeddings = self.pos_conv_embed(hidden_states) hidden_states = hidden_states + position_embeddings hidden_states = self.layer_norm(hidden_states) hidden_states =","else: broadcast_shape[self.axis] = self.groups return broadcast_shape # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2WeightNormConv1D with Wav2Vec2->Hubert class","\"mean\": loss = tf.reduce_mean(loss) else: loss = None if not inputs[\"return_dict\"]: output =","TFHubertWeightNormConv1D( filters=config.hidden_size, kernel_size=config.num_conv_pos_embeddings, groups=config.num_conv_pos_embedding_groups, explicit_padding=config.num_conv_pos_embeddings // 2, name=\"conv\", ) self.padding = TFHubertSamePadLayer(config.num_conv_pos_embeddings) self.activation","if v is not None) return TFBaseModelOutput( last_hidden_state=hidden_states, hidden_states=all_hidden_states, attentions=all_self_attentions, ) # Copied","= tf.keras.layers.Conv1D( filters=self.out_conv_dim, kernel_size=config.conv_kernel[layer_id], strides=config.conv_stride[layer_id], use_bias=config.conv_bias, name=\"conv\", ) self.activation = get_tf_activation(config.feat_extract_activation) def call(self,","output_hidden_states=output_hidden_states, return_dict=return_dict, training=training, ) outputs = self.hubert( input_values=inputs[\"input_values\"], attention_mask=inputs[\"attention_mask\"], token_type_ids=inputs[\"token_type_ids\"], position_ids=inputs[\"position_ids\"], head_mask=inputs[\"head_mask\"], inputs_embeds=inputs[\"inputs_embeds\"],","unexpected layers. \"\"\" signature = dict(inspect.signature(func).parameters) signature.pop(\"kwargs\", None) signature.pop(\"self\", None) parameter_names = list(signature.keys())","input_shape): return input_shape def _reshape_into_groups(self, inputs, input_shape, tensor_input_shape): group_shape = [tensor_input_shape[i] for i","LARGE_NEGATIVE = -1e8 # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.input_values_processing def input_values_processing(func, config, input_values, **kwargs): \"\"\"","# reuse k, v, self_attention key_states = self._shape(self.k_proj(hidden_states), -1, bsz) value_states = self._shape(self.v_proj(hidden_states),","Batch size 1 >>> logits = model(input_values).logits >>> predicted_ids = tf.argmax(logits, axis=-1) >>>","initializer=self.gamma_initializer, regularizer=self.gamma_regularizer, constraint=self.gamma_constraint, ) else: self.gamma = None def _add_beta_weight(self, input_shape): dim =","to a *sentence A* token, - 1 corresponds to a *sentence B* token.","( inputs[\"output_hidden_states\"] if inputs[\"output_hidden_states\"] else self.config.output_hidden_states ) inputs[\"output_attentions\"] = ( inputs[\"output_attentions\"] if inputs[\"output_attentions\"]","def _check_if_input_shape_is_none(self, input_shape): dim = input_shape[self.axis] if dim is None: raise ValueError( \"Axis","**kwargs): super().__init__(config, **kwargs) warnings.warn( f\"The class `{self.__class__.__name__}` has been depreciated \" \"and will","to `-100` are ignored (masked), the loss is only computed for the tokens","`num_heads`: {num_heads}).\" ) self.scaling = self.head_dim**-0.5 self.is_decoder = is_decoder self.k_proj = tf.keras.layers.Dense(embed_dim, use_bias=bias,",") super().build(input_shape) def _get_feat_extract_output_lengths(self, input_lengths: tf.Tensor): \"\"\" Computes the output length of the","`model([input_values, attention_mask, token_type_ids])` - a dictionary with one or several input Tensors associated","i in range(config.num_hidden_layers)] def call( self, hidden_states: tf.Tensor, attention_mask: Optional[tf.Tensor] = None, output_attentions:","logger = logging.get_logger(__name__) _CONFIG_FOR_DOC = \"HubertConfig\" TF_HUBERT_PRETRAINED_MODEL_ARCHIVE_LIST = [ \"facebook/hubert-base-ls960\", # See all","from [fairseq's data_utils.py](https://github.com/pytorch/fairseq/blob/e0788f7007a8473a76db573985031f3c94201e79/fairseq/data/data_utils.py#L376). \"\"\" batch_size, sequence_length = shape if mask_length < 1: raise","= self.layer_norm(hidden_states) hidden_states = self.activation(hidden_states) return hidden_states # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2PositionalConvEmbedding with Wav2Vec2->Hubert","1)) _, indices = tf.nn.top_k(distribution + z, num_samples) return indices # Copied from","self.serving_output(output) HUBERT_START_DOCSTRING = r\"\"\" This model inherits from [`TFPreTrainedModel`]. Check the superclass documentation","attention_mask = ( inputs[\"attention_mask\"] if inputs[\"attention_mask\"] is not None else tf.ones_like(inputs[\"input_values\"], dtype=tf.float32) )","in other modes than eager. if tf.executing_eagerly(): tf.debugging.assert_equal( shape_list(attention_mask), [bsz, 1, tgt_len, src_len],","kernel_size) // stride + 1 for kernel_size, stride in zip(self.config.conv_kernel, self.config.conv_stride): input_lengths =","+ offsets # scatter indices to mask spec_aug_mask = _scatter_values_on_batch_indices( tf.ones_like(spec_aug_mask_idxs), spec_aug_mask_idxs, spec_aug_mask.shape","str(dim) + \").\" ) if dim % self.groups != 0: raise ValueError( \"Number","] else: raise ValueError( f\"`config.feat_extract_norm` is {config.feat_extract_norm}, but has to be one of","# uniform distribution to sample from, make sure that offset samples are <","= embed_dim // num_heads if (self.head_dim * num_heads) != self.embed_dim: raise ValueError( f\"embed_dim","output = {} allowed_types = (tf.Tensor, bool, int, ModelOutput, tuple, list, dict, np.ndarray)","= kwargs.pop(name, signature[name].default) # When creating a SavedModel TF calls the method with","axis mask_time_indices = _compute_mask_indices( (batch_size, sequence_length), mask_prob=self.config.mask_time_prob, mask_length=self.config.mask_time_length, min_masks=2, ) hidden_states = tf.where(","embedding lookup matrix. output_attentions (`bool`, *optional*): Whether or not to return the attentions","number will be smaller (unless no_overlap is True) mask_length: size of the mask","name=\"output_dense\", ) self.output_dropout = tf.keras.layers.Dropout(config.hidden_dropout) def call(self, hidden_states: tf.Tensor, training: bool = False)","under the License is distributed on an \"AS IS\" BASIS, # WITHOUT WARRANTIES","key_states, transpose_b=True) # The tf.debugging asserts are not compliant with XLA then they","\"AS IS\" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express","return outputs # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2EncoderLayerStableLayerNorm with Wav2Vec2->Hubert class TFHubertEncoderLayerStableLayerNorm(tf.keras.layers.Layer): def __init__(self, config:","if self.center: beta = tf.reshape(self.beta, broadcast_shape) return gamma, beta def _check_if_input_shape_is_none(self, input_shape): dim","-1e8 # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.input_values_processing def input_values_processing(func, config, input_values, **kwargs): \"\"\" Process the",") hidden_states = layer_outputs[0] if output_attentions: all_self_attentions = all_self_attentions + (layer_outputs[1],) # Add","inputs_embeds=inputs[\"inputs_embeds\"], output_attentions=inputs[\"output_attentions\"], output_hidden_states=inputs[\"output_hidden_states\"], return_dict=inputs[\"return_dict\"], training=inputs[\"training\"], ) hidden_states = outputs[0] hidden_states = self.dropout(hidden_states, training=inputs[\"training\"])","get_tf_activation(config.hidden_act) self.output_dense = tf.keras.layers.Dense( units=config.hidden_size, kernel_initializer=get_initializer(config.initializer_range), bias_initializer=\"zeros\", name=\"output_dense\", ) self.output_dropout = tf.keras.layers.Dropout(config.hidden_dropout) def","# compute number of masked spans in batch num_masked_spans = int(mask_prob * sequence_length","for i in range(config.num_hidden_layers)] def call( self, hidden_states: tf.Tensor, attention_mask: Optional[tf.Tensor] = None,","of type {type(v)} is not allowed only {allowed_types} is accepted for {k}.\") if","tf.expand_dims(attention_mask, -1) attention_mask = _expand_mask(attention_mask) else: attention_mask = None position_embeddings = self.pos_conv_embed(hidden_states) hidden_states","Optional[Tuple[Tuple[tf.Tensor]]] = None, attention_mask: Optional[tf.Tensor] = None, layer_head_mask: Optional[tf.Tensor] = None, training: Optional[bool]","None: # The tf.debugging asserts are not compliant with XLA then they #","tf.keras.initializers.serialize(self.beta_initializer), \"gamma_initializer\": tf.keras.initializers.serialize(self.gamma_initializer), \"beta_regularizer\": tf.keras.regularizers.serialize(self.beta_regularizer), \"gamma_regularizer\": tf.keras.regularizers.serialize(self.gamma_regularizer), \"beta_constraint\": tf.keras.constraints.serialize(self.beta_constraint), \"gamma_constraint\": tf.keras.constraints.serialize(self.gamma_constraint), } base_config","= tf.nn.ctc_loss( logits=logits, labels=labels, logit_length=input_lengths, label_length=target_lengths, blank_index=self.config.pad_token_id, logits_time_major=False, ) if self.config.ctc_loss_reduction == \"sum\":","CONDITIONS OF ANY KIND, either express or implied. # See the License for","can choose to directly pass an embedded representation. This is useful if you","import tensorflow as tf >>> from transformers import Wav2Vec2Processor, TFHubertForCTC >>> from datasets","1 if not is_instance_norm: group_shape[self.axis] = input_shape[self.axis] // self.groups group_shape.insert(self.axis, self.groups) group_shape =","with Wav2Vec2->Hubert class TFHubertLayerNormConvLayer(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, layer_id: int = 0, **kwargs:","None, :], (1, 1, tgt_len, 1)) return (one_cst - expanded_mask) * LARGE_NEGATIVE #","models accepts two formats as inputs: - having all inputs as keyword arguments","input Tensors in the first positional argument : - a single Tensor with",") inputs[\"output_attentions\"] = ( inputs[\"output_attentions\"] if inputs[\"output_attentions\"] else self.config.output_attentions ) inputs[\"return_dict\"] = inputs[\"return_dict\"]","output_attentions: all_self_attentions = all_self_attentions + (layer_outputs[1],) hidden_states = self.layer_norm(hidden_states) if output_hidden_states: all_hidden_states =","and evaluation). \"\"\" @add_start_docstrings( \"The bare TFHubert Model transformer outputing raw hidden-states without","shape `({0})`, *optional*): Mask to avoid performing attention on padding token indices. Mask","time axis mask_time_indices = _compute_mask_indices( (batch_size, sequence_length), mask_prob=self.config.mask_time_prob, mask_length=self.config.mask_time_length, min_masks=2, ) hidden_states =","-self.num_pad_remove, :] return hidden_states class TFHubertFeatureEncoder(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs: Any) ->","to masked spans spec_aug_mask_idxs = tf.expand_dims(spec_aug_mask_idxs, -1) spec_aug_mask_idxs = tf.tile(spec_aug_mask_idxs, (1, 1, mask_length))","past_key_value = (key_states, value_states) proj_shape = (bsz * self.num_heads, -1, self.head_dim) query_states =","tf.keras.initializers.Initializer = \"zeros\", gamma_initializer: tf.keras.initializers.Initializer = \"ones\", beta_regularizer: tf.keras.regularizers.Regularizer = None, gamma_regularizer: tf.keras.regularizers.Regularizer","compliance with the License. # You may obtain a copy of the License","= TFHubertMainLayer(config, name=\"hubert\") self.dropout = tf.keras.layers.Dropout(config.final_dropout) self.lm_head = tf.keras.layers.Dense(config.vocab_size, name=\"lm_head\") def freeze_feature_extractor(self): \"\"\"","weights should be of size {(bsz * self.num_heads, tgt_len, src_len)}, but is {shape_list(attn_weights)}\",","self.activation = get_tf_activation(config.feat_extract_activation) self.layer_norm = TFHubertGroupNorm(groups=self.out_conv_dim, epsilon=config.layer_norm_eps, name=\"layer_norm\") def call(self, hidden_states: tf.Tensor) ->","return hidden_states class TFHubertFeatureEncoder(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs: Any) -> None: super().__init__(**kwargs)","eager. if tf.executing_eagerly(): tf.debugging.assert_equal( shape_list(attention_mask), [bsz, 1, tgt_len, src_len], message=f\"Attention mask should be","you need a GPU or a TPU\" ) @tf.function def serving(self, inputs): output","1 >>> logits = model(input_values).logits >>> predicted_ids = tf.argmax(logits, axis=-1) >>> transcription =","{k}.\") if isinstance(input_values, (tuple, list)): for i, input in enumerate(input_values): # EagerTensors don't","is not None else tf.ones_like(inputs[\"input_values\"], dtype=tf.float32) ) input_lengths = self.hubert._get_feat_extract_output_lengths(tf.reduce_sum(attention_mask, axis=-1)) # assuming","= list(signature.keys()) output = {} allowed_types = (tf.Tensor, bool, int, ModelOutput, tuple, list,","// mask_length # SpecAugment mask to fill spec_aug_mask = tf.zeros((batch_size, sequence_length), dtype=tf.int32) #","+ str(dim) + \").\" ) if dim % self.groups != 0: raise ValueError(","(\" + str(self.groups) + \") must be a \" \"multiple of the number","the running model. **kwargs: The inputs of the model. Returns: Two lists, one","different behaviors between training and evaluation). \"\"\" @add_start_docstrings( \"The bare TFHubert Model transformer","> sequence_length: num_masked_spans = sequence_length // mask_length # SpecAugment mask to fill spec_aug_mask","= self.output_dropout(hidden_states, training=training) return hidden_states # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2EncoderLayer with Wav2Vec2->Hubert class TFHubertEncoderLayer(tf.keras.layers.Layer):","indixes) \"\"\" indices_shape = shape_list(batch_indices) # broadcast batch dim to indices_shape broad_casted_batch_dims =","= self.final_layer_norm(hidden_states) outputs = (hidden_states,) if output_attentions: outputs += (attn_weights,) return outputs #","input_shape: tf.TensorShape): self.masked_spec_embed = self.add_weight( shape=(self.config.hidden_size,), initializer=\"uniform\", trainable=True, name=\"masked_spec_embed\" ) super().build(input_shape) def _get_feat_extract_output_lengths(self,","1 >>> hidden_states = model(input_values).last_hidden_state ```\"\"\" inputs = input_values_processing( func=self.call, config=self.config, input_values=input_values, attention_mask=attention_mask,","int, min_masks: int = 0, ) -> tf.Tensor: \"\"\" Computes random mask spans","def _reshape_into_groups(self, inputs, input_shape, tensor_input_shape): group_shape = [tensor_input_shape[i] for i in range(len(input_shape))] is_instance_norm","than `sequence_length`, but got `mask_length`: {mask_length} and `sequence_length`: {sequence_length}`\" ) # compute number","including the booleans. In case of a list of symbolic inputs, each input","be chosen as start of the span to be masked. this will be","hidden_states = layer_outputs[0] if output_attentions: all_self_attentions = all_self_attentions + (layer_outputs[1],) hidden_states = self.layer_norm(hidden_states)","- kernel_size) // stride + 1 for kernel_size, stride in zip(self.config.conv_kernel, self.config.conv_stride): input_lengths","input_shape, tensor_input_shape) normalized_inputs = self._apply_normalization(reshaped_inputs, input_shape) is_instance_norm = (input_shape[self.axis] // self.groups) == 1","output = self.call(input_values=inputs, training=False) return self.serving_output(output) HUBERT_START_DOCSTRING = r\"\"\" This model inherits from","Labels for computing the masked language modeling loss. Indices should be in `[-100,","for the decoder is_cross_attention = key_value_states is not None bsz, tgt_len, embed_dim =","vectors than the model's internal embedding lookup matrix. output_attentions (`bool`, *optional*): Whether or","): super().__init__(**kwargs) self.supports_masking = True self.groups = groups self.axis = axis self.epsilon =","apply SpecAugment along time axis mask_time_indices = _compute_mask_indices( (batch_size, sequence_length), mask_prob=self.config.mask_time_prob, mask_length=self.config.mask_time_length, min_masks=2,","def compute_output_shape(self, input_shape): return input_shape def _reshape_into_groups(self, inputs, input_shape, tensor_input_shape): group_shape = [tensor_input_shape[i]","want more control over how to convert `input_values` indices into associated vectors than","`[0, 1]`: - 1 indicates the head is **not masked**, - 0 indicates","] elif config.feat_extract_norm == \"layer\": conv_layers = [ TFHubertLayerNormConvLayer(config, layer_id=i, name=f\"conv_layers.{i}\") for i","\"elif\" case) # if encoder bi-directional self-attention `past_key_value` is always `None` past_key_value =","is_cross_attention: # cross_attentions key_states = self._shape(self.k_proj(key_value_states), -1, bsz) value_states = self._shape(self.v_proj(key_value_states), -1, bsz)","# Unless required by applicable law or agreed to in writing, software #","hidden_states # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2SamePadLayer with Wav2Vec2->Hubert class TFHubertSamePadLayer(tf.keras.layers.Layer): def __init__(self, num_conv_pos_embeddings, **kwargs):","attns = tf.convert_to_tensor(output.attentions) if self.config.output_attentions else None return TFBaseModelOutput(last_hidden_state=output.last_hidden_state, hidden_states=hs, attentions=attns) @add_start_docstrings( \"\"\"TFHubert","training=False) return self.serving_output(output) HUBERT_START_DOCSTRING = r\"\"\" This model inherits from [`TFPreTrainedModel`]. Check the","features along time axis and/or along feature axis according to [SpecAugment](https://arxiv.org/abs/1904.08779). \"\"\" batch_size,","def __init__(self, filters, kernel_size, groups, explicit_padding, **kwargs): super().__init__( filters=filters, kernel_size=kernel_size, groups=groups, padding=\"valid\", use_bias=True,","Optional[tf.Tensor]]: \"\"\"Input shape: Batch x Time x Channel\"\"\" # if key_value_states are provided","self.padding = TFHubertSamePadLayer(config.num_conv_pos_embeddings) self.activation = get_tf_activation(config.feat_extract_activation) def call(self, hidden_states: tf.Tensor) -> tf.Tensor: hidden_states","= shape_list(mask)[1] tgt_len = tgt_len if tgt_len is not None else src_len one_cst","v in [hidden_states, all_hidden_states, all_self_attentions] if v is not None) return TFBaseModelOutput( last_hidden_state=hidden_states,","((0, 0), (self.explicit_padding, self.explicit_padding), (0, 0))) output = super().call(padded_inputs) return output # Copied","in enumerate(self.layer): if output_hidden_states: all_hidden_states = all_hidden_states + (hidden_states,) # add LayerDrop (see","if output_hidden_states: all_hidden_states = all_hidden_states + (hidden_states,) if not return_dict: return tuple(v for","self.intermediate_dropout = tf.keras.layers.Dropout(config.activation_dropout) self.intermediate_dense = tf.keras.layers.Dense( units=config.intermediate_size, kernel_initializer=get_initializer(config.initializer_range), bias_initializer=\"zeros\", name=\"intermediate_dense\", ) self.intermediate_act_fn =","loss >>> target_transcription = \"A MAN SAID TO THE UNIVERSE SIR I EXIST\"","in parameter_names and \"args\" not in parameter_names: logger.warning( f\"The parameter {k} does not","token indices. Mask values selected in `[0, 1]`: - 1 for tokens that","{k}.\") else: if isinstance(input_values, tf.Tensor) or input_values is None: output[parameter_names[0]] = input_values else:","shape: Batch x Time x Channel\"\"\" # if key_value_states are provided this layer","hidden_states # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2LayerNormConvLayer with Wav2Vec2->Hubert class TFHubertLayerNormConvLayer(tf.keras.layers.Layer): def __init__(self, config: HubertConfig,",":], hidden_states, 0) return hidden_states def call( self, input_values: tf.Tensor, attention_mask: Optional[tf.Tensor] =","attentions=all_self_attentions, ) # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2EncoderStableLayerNorm with Wav2Vec2->Hubert class TFHubertEncoderStableLayerNorm(tf.keras.layers.Layer): def __init__(self, config:","False, ) -> Tuple[tf.Tensor]: attn_residual = hidden_states hidden_states = self.layer_norm(hidden_states) hidden_states, attn_weights, _","HubertConfig, **kwargs: Any) -> None: super().__init__(**kwargs) if config.feat_extract_norm == \"group\": conv_layers = [TFHubertGroupNormConvLayer(config,","str(dim) + \").\" ) def _check_axis(self): if self.axis == 0: raise ValueError( \"You","attn_weights, (bsz, self.num_heads, tgt_len, src_len) ) attn_weights = tf.reshape(attn_weights, (bsz * self.num_heads, tgt_len,","tensor should have a defined dimension \" \"but the layer received an input","a GPU or a TPU\" ) @tf.function def serving(self, inputs): output = self.call(input_values=inputs,","Mask to avoid performing attention on padding token indices. Mask values selected in","training=training) hidden_states = attn_residual + hidden_states hidden_states = self.layer_norm(hidden_states) hidden_states = hidden_states +","is_instance_norm = (input_shape[self.axis] // self.groups) == 1 if not is_instance_norm: axis = -2","def _init_norm(self): \"\"\"Set the norm of the weight vector.\"\"\" kernel_norm = tf.sqrt(tf.reduce_sum(tf.square(self.weight_v), axis=self.kernel_norm_axes))","argument of the model call function: `model(inputs)`. If you choose this second option,","tf.cast(tf.not_equal(input_values, pad_token), tf.float32), } return dummy_inputs def __init__(self, config, *inputs, **kwargs): super().__init__(config, *inputs,","spec_aug_mask.shape ) return spec_aug_mask # Copied from transformers.models.bart.modeling_tf_bart._expand_mask def _expand_mask(mask: tf.Tensor, tgt_len: Optional[int]","having all inputs as a list, tuple or dict in the first positional","= output[\"args\"] del output[\"args\"] if \"kwargs\" in output: del output[\"kwargs\"] boolean_dict = {","self.layer_norm(hidden_states) hidden_states = self.activation(hidden_states) return hidden_states # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2PositionalConvEmbedding with Wav2Vec2->Hubert class","\"groups\": self.groups, \"axis\": self.axis, \"epsilon\": self.epsilon, \"center\": self.center, \"scale\": self.scale, \"beta_initializer\": tf.keras.initializers.serialize(self.beta_initializer), \"gamma_initializer\":","OR CONDITIONS OF ANY KIND, either express or implied. # See the License","under the License. \"\"\" TensorFlow Hubert model.\"\"\" import inspect import warnings from typing","load_dataset >>> import soundfile as sf >>> processor = Wav2Vec2Processor.from_pretrained(\"facebook/hubert-base-960h\") >>> model =","hidden_size), mask_prob=self.config.mask_feature_prob, mask_length=self.config.mask_feature_length, ) hidden_states = tf.where(mask_feature_indices[:, tf.newaxis, :], hidden_states, 0) return hidden_states","`past_key_value` is always `None` past_key_value = (key_states, value_states) proj_shape = (bsz * self.num_heads,","input of each TensorFlow model including the booleans. In case of a list","-> tf.Tensor: hidden_states = self.conv(hidden_states) hidden_states = self.padding(hidden_states) hidden_states = self.activation(hidden_states) return hidden_states","name=\"layer_norm\") self.dropout = tf.keras.layers.Dropout(config.hidden_dropout) self.layer = [TFHubertEncoderLayer(config, name=f\"layers.{i}\") for i in range(config.num_hidden_layers)] def","tf.keras.regularizers.Regularizer = None, beta_constraint: tf.keras.constraints.Constraint = None, gamma_constraint: tf.keras.constraints.Constraint = None, **kwargs, ):","Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2EncoderLayer with Wav2Vec2->Hubert class TFHubertEncoderLayer(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs): super().__init__(**kwargs)","= self._apply_normalization(reshaped_inputs, input_shape) is_instance_norm = (input_shape[self.axis] // self.groups) == 1 if not is_instance_norm:","for each token to be chosen as start of the span to be","self.groups) == 1 if not is_instance_norm: group_shape[self.axis] = input_shape[self.axis] // self.groups group_shape.insert(self.axis, self.groups)","parameters name, i.e. `input_values = tf.keras.Input(shape=(128,), dtype='float32', name=\"input_values\")` otherwise the order of the","Wav2Vec2->Hubert class TFHubertEncoder(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs): super().__init__(**kwargs) self.config = config self.pos_conv_embed","\"\"\" def _conv_out_length(input_length, kernel_size, stride): # 1D convolutional layer output length formula taken","return hidden_states # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2PositionalConvEmbedding with Wav2Vec2->Hubert class TFHubertPositionalConvEmbedding(tf.keras.layers.Layer): def __init__(self, config:","def serving_output(self, output): hs = tf.convert_to_tensor(output.hidden_states) if self.config.output_hidden_states else None attns = tf.convert_to_tensor(output.attentions)","head_mask=head_mask, inputs_embeds=inputs_embeds, output_attentions=output_attentions, output_hidden_states=output_hidden_states, return_dict=return_dict, training=training, kwargs_call=kwargs, ) hidden_states = self.feature_extractor( tf.cast(inputs[\"input_values\"], tf.float32),","to sample from, make sure that offset samples are < sequence_length uniform_dist =","function will disable the gradient computation for the feature encoder so that its","tf.keras.layers.LayerNormalization(epsilon=config.layer_norm_eps, name=\"layer_norm\") self.projection = tf.keras.layers.Dense( units=config.hidden_size, kernel_initializer=get_initializer(config.initializer_range), bias_initializer=\"zeros\", name=\"projection\", ) self.dropout = tf.keras.layers.Dropout(rate=config.feat_proj_dropout)","attn_residual = hidden_states hidden_states = self.layer_norm(hidden_states) hidden_states, attn_weights, _ = self.attention( hidden_states, attention_mask=attention_mask,",") @keras_serializable class TFHubertMainLayer(tf.keras.layers.Layer): config_class = HubertConfig def __init__(self, config: HubertConfig, **kwargs): super().__init__(**kwargs)","= self._get_feat_extract_output_lengths(tf.reduce_sum(inputs[\"attention_mask\"], -1)) attention_mask = tf.sequence_mask( output_lengths, maxlen=shape_list(hidden_states)[1], dtype=hidden_states.dtype ) hidden_states = self.feature_projection(hidden_states,","tf.keras.constraints.serialize(self.beta_constraint), \"gamma_constraint\": tf.keras.constraints.serialize(self.gamma_constraint), } base_config = super().get_config() return {**base_config, **config} def compute_output_shape(self, input_shape):","= shape_list(hidden_states) # get query proj query_states = self.q_proj(hidden_states) * self.scaling # get","def __init__(self, config: HubertConfig, **kwargs): super().__init__(**kwargs) self.intermediate_dropout = tf.keras.layers.Dropout(config.activation_dropout) self.intermediate_dense = tf.keras.layers.Dense( units=config.intermediate_size,","tf.Tensor, seq_len: int, bsz: int): return tf.transpose(tf.reshape(tensor, (bsz, seq_len, self.num_heads, self.head_dim)), (0, 2,","self._create_input_spec(input_shape) self._add_gamma_weight(input_shape) self._add_beta_weight(input_shape) self.built = True super().build(input_shape) def call(self, inputs): input_shape = tf.keras.backend.int_shape(inputs)","self.dropout(hidden_states, training=training) hidden_states = attn_residual + hidden_states hidden_states = hidden_states + self.feed_forward(self.final_layer_norm(hidden_states)) outputs","\"apply_spec_augment\", True): return hidden_states if mask_time_indices is not None: # apply SpecAugment along","= tf.keras.layers.Conv1D( filters=self.out_conv_dim, kernel_size=config.conv_kernel[layer_id], strides=config.conv_stride[layer_id], use_bias=config.conv_bias, name=\"conv\", ) self.activation = get_tf_activation(config.feat_extract_activation) self.layer_norm =","input Tensors associated to the input names given in the docstring: `model({\"input_values\": input_values,","seq_len, self.num_heads, self.head_dim)), (0, 2, 1, 3)) def call( self, hidden_states: tf.Tensor, key_value_states:","\"axis\": self.axis, \"epsilon\": self.epsilon, \"center\": self.center, \"scale\": self.scale, \"beta_initializer\": tf.keras.initializers.serialize(self.beta_initializer), \"gamma_initializer\": tf.keras.initializers.serialize(self.gamma_initializer), \"beta_regularizer\":","but has to be one of ['group', 'layer']\" ) self.conv_layers = conv_layers def","hidden_states # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2EncoderLayer with Wav2Vec2->Hubert class TFHubertEncoderLayer(tf.keras.layers.Layer): def __init__(self, config: HubertConfig,","bias: bool = True, **kwargs, ): super().__init__(**kwargs) self.embed_dim = embed_dim self.num_heads = num_heads","apply SpecAugment along time axis with given mask_time_indices hidden_states = tf.where( tf.cast(mask_time_indices[:, :,","<Tip> TF 2.0 models accepts two formats as inputs: - having all inputs","hidden_states hidden_states = self.layer_norm(hidden_states) hidden_states, attn_weights, _ = self.attention( hidden_states, attention_mask=attention_mask, training=training )","`Dict[str, np.ndarray]` and each example must have the shape `({0})`): Indices of input","from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2NoLayerNormConvLayer with Wav2Vec2->Hubert class TFHubertNoLayerNormConvLayer(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, layer_id: int =","with Wav2Vec2->Hubert class TFHubertWeightNormConv1D(tf.keras.layers.Conv1D): \"\"\"Adapted from https://www.tensorflow.org/probability/api_docs/python/tfp/layers/weight_norm/WeightNorm\"\"\" def __init__(self, filters, kernel_size, groups, explicit_padding,","1 if num_conv_pos_embeddings % 2 == 0 else 0 def call(self, hidden_states): if","shape: Tuple[int, int], mask_prob: float, mask_length: int, min_masks: int = 0, ) ->","tf.newaxis, :], hidden_states, ) elif self.config.mask_time_prob > 0: # generate indices & apply","argument : - a single Tensor with `input_values` only and nothing else: `model(inputs_ids)`","load the weights associated with the model, only the configuration. Check out the","allowed only {allowed_types} is accepted for {parameter_names[0]}.\" ) for name in parameter_names: if","not None: # The tf.debugging asserts are not compliant with XLA then they","= scale self.beta_initializer = tf.keras.initializers.get(beta_initializer) self.gamma_initializer = tf.keras.initializers.get(gamma_initializer) self.beta_regularizer = tf.keras.regularizers.get(beta_regularizer) self.gamma_regularizer =","attn_weights = tf.matmul(query_states, key_states, transpose_b=True) # The tf.debugging asserts are not compliant with","if self.config.ctc_loss_reduction == \"sum\": loss = tf.reduce_sum(loss) if self.config.ctc_loss_reduction == \"mean\": loss =","value_states], axis=2) else: # self_attention key_states = self._shape(self.k_proj(hidden_states), -1, bsz) value_states = self._shape(self.v_proj(hidden_states),","= output[\"args\"].name.split(\":\")[0] output[tensor_name] = output[\"args\"] else: # `args` in this case is always","of size {(bsz, 1, tgt_len, src_len)}, but is {shape_list(attention_mask)}\", ) attention_mask = tf.cast(attention_mask,","= tf.reshape(self.gamma, broadcast_shape) if self.center: beta = tf.reshape(self.beta, broadcast_shape) return gamma, beta def","bsz), proj_shape) key_states = tf.reshape(key_states, proj_shape) value_states = tf.reshape(value_states, proj_shape) src_len = shape_list(key_states)[1]","logits = model(input_values).logits >>> predicted_ids = tf.argmax(logits, axis=-1) >>> transcription = processor.decode(predicted_ids[0]) >>>","TFHubertAttention(tf.keras.layers.Layer): \"\"\"Multi-headed attention from \"Attention Is All You Need\"\"\" def __init__( self, embed_dim:","src_len)}, but is {shape_list(attn_weights)}\", ) if attention_mask is not None: # The tf.debugging","is batch size and 2nd is timesteps attention_mask: optional padding mask of the","name=\"conv\", ) self.layer_norm = tf.keras.layers.LayerNormalization(name=\"layer_norm\", epsilon=config.layer_norm_eps) self.activation = get_tf_activation(config.feat_extract_activation) def call(self, hidden_states: tf.Tensor)","is_instance_norm: group_shape[self.axis] = input_shape[self.axis] // self.groups group_shape.insert(self.axis, self.groups) group_shape = tf.stack(group_shape) reshaped_inputs =","strides=config.conv_stride[layer_id], use_bias=config.conv_bias, name=\"conv\", ) self.layer_norm = tf.keras.layers.LayerNormalization(name=\"layer_norm\", epsilon=config.layer_norm_eps) self.activation = get_tf_activation(config.feat_extract_activation) def call(self,","TFHubertFeedForward(config, name=\"feed_forward\") self.final_layer_norm = tf.keras.layers.LayerNormalization( epsilon=config.layer_norm_eps, name=\"final_layer_norm\" ) def call( self, hidden_states: tf.Tensor,","{parameter_names[0]}.\" ) for name in parameter_names: if name not in list(output.keys()) and name","- 0 indicates the head is **masked**. inputs_embeds (`np.ndarray` or `tf.Tensor` of shape",") attention_mask = tf.cast(attention_mask, dtype=attn_weights.dtype) attn_weights = tf.reshape(attn_weights, (bsz, self.num_heads, tgt_len, src_len)) +","= (dim,) if self.scale: self.gamma = self.add_weight( shape=shape, name=\"gamma\", initializer=self.gamma_initializer, regularizer=self.gamma_regularizer, constraint=self.gamma_constraint, )","\" \"multiple of the number of channels (\" + str(dim) + \").\" )","Licensed under the Apache License, Version 2.0 (the \"License\"); # you may not",") class TFHubertFeatureProjection(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs): super().__init__(**kwargs) self.layer_norm = tf.keras.layers.LayerNormalization(epsilon=config.layer_norm_eps, name=\"layer_norm\")","models at https://huggingface.co/models?filter=hubert ] LARGE_NEGATIVE = -1e8 # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.input_values_processing def input_values_processing(func,","self.intermediate_dense(hidden_states) hidden_states = self.intermediate_act_fn(hidden_states) hidden_states = self.intermediate_dropout(hidden_states, training=training) hidden_states = self.output_dense(hidden_states) hidden_states =",") self.freeze_feature_encoder() def freeze_feature_encoder(self): \"\"\" Calling this function will disable the gradient computation","= is_decoder self.k_proj = tf.keras.layers.Dense(embed_dim, use_bias=bias, name=\"k_proj\") self.q_proj = tf.keras.layers.Dense(embed_dim, use_bias=bias, name=\"q_proj\") self.v_proj","self.conv = tf.keras.layers.Conv1D( filters=self.out_conv_dim, kernel_size=config.conv_kernel[layer_id], strides=config.conv_stride[layer_id], use_bias=config.conv_bias, name=\"conv\", ) self.activation = get_tf_activation(config.feat_extract_activation) self.layer_norm","cross_attentions key_states = self._shape(self.k_proj(key_value_states), -1, bsz) value_states = self._shape(self.v_proj(key_value_states), -1, bsz) elif past_key_value","1)) return (one_cst - expanded_mask) * LARGE_NEGATIVE # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2GroupNorm with Wav2Vec2->Hubert","is distributed on an \"AS IS\" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF","with indices set to `-100` are ignored (masked), the loss is only computed","skip the layer continue layer_outputs = layer_module( hidden_states=hidden_states, attention_mask=attention_mask, output_attentions=output_attentions, training=training, ) hidden_states","input_shape): dim = input_shape[self.axis] shape = (dim,) if self.scale: self.gamma = self.add_weight( shape=shape,","del output[\"args\"] if \"kwargs\" in output: del output[\"kwargs\"] boolean_dict = { k: v",":] offsets = tf.tile(offsets, (batch_size, num_masked_spans, 1)) offsets = tf.reshape(offsets, (batch_size, num_masked_spans *","= self.layer_norm(hidden_states) hidden_states = hidden_states + self.feed_forward(hidden_states) hidden_states = self.final_layer_norm(hidden_states) outputs = (hidden_states,)","is not allowed only {allowed_types} is accepted for {parameter_names[i]}.\" ) elif isinstance(input_values, (dict,","Example: ```python >>> from transformers import Wav2Vec2Processor, TFHubertModel >>> from datasets import load_dataset","(bsz, tgt_len, embed_dim)) attn_output = self.out_proj(attn_output) attn_weights: tf.Tensor = tf.reshape(attn_weights, (bsz, self.num_heads, tgt_len,",") class TFHubertModel(TFHubertPreTrainedModel): def __init__(self, config: HubertConfig, *inputs, **kwargs): super().__init__(config, *inputs, **kwargs) self.config","will do for now - see https://github.com/tensorflow/tensorflow/issues/9260 for more info \"\"\" z =","[`TFPreTrainedModel`]. Check the superclass documentation for the generic methods the library implements for","np.ndarray) for k, v in kwargs.items(): if isinstance(v, allowed_types) or v is None:","in dict(input_values).items(): if isinstance(v, allowed_types) or v is None: output[k] = v elif","HubertConfig, layer_id: int = 0, **kwargs: Any) -> None: super().__init__(**kwargs) self.in_conv_dim = config.conv_dim[layer_id]","Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2WeightNormConv1D with Wav2Vec2->Hubert class TFHubertWeightNormConv1D(tf.keras.layers.Conv1D): \"\"\"Adapted from https://www.tensorflow.org/probability/api_docs/python/tfp/layers/weight_norm/WeightNorm\"\"\" def __init__(self, filters,","if layer_head_mask is not None: # The tf.debugging asserts are not compliant with","= tf.tile(offsets, (batch_size, num_masked_spans, 1)) offsets = tf.reshape(offsets, (batch_size, num_masked_spans * mask_length)) spec_aug_mask_idxs","dtype=self.weight_v.dtype, trainable=True, ) self.bias = self.add_weight(name=\"bias\", shape=(self.filters,), initializer=\"zeros\", trainable=True) def call(self, inputs): if","can be used only in eager mode, in graph mode the value in","hidden_states = tf.where( tf.cast(mask_time_indices[:, :, tf.newaxis], tf.bool), self.masked_spec_embed[tf.newaxis, tf.newaxis, :], hidden_states, ) elif","in `[0, ..., config.vocab_size]` Returns: Example: ```python >>> import tensorflow as tf >>>","return the attentions tensors of all attention layers. See `attentions` under returned tensors","shape for which to compute masks. should be of size 2 where first","instead. output_hidden_states (`bool`, *optional*): Whether or not to return the hidden states of","0): \"\"\" Expands attention_mask from `[bsz, seq_len]` to `[bsz, 1, tgt_seq_len, src_seq_len]`. \"\"\"","([`HubertConfig`]): Model configuration class with all the parameters of the model. Initializing with","the config will be used instead. output_hidden_states (`bool`, *optional*): Whether or not to","tf.Tensor) -> tf.Tensor: hidden_states = self.conv(hidden_states) hidden_states = self.layer_norm(hidden_states) hidden_states = self.activation(hidden_states) return","hidden_states # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2GroupNormConvLayer with Wav2Vec2->Hubert class TFHubertGroupNormConvLayer(tf.keras.layers.Layer): def __init__(self, config: HubertConfig,","expanded_mask) * LARGE_NEGATIVE # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2GroupNorm with Wav2Vec2->Hubert class TFHubertGroupNorm(tf.keras.layers.Layer): \"\"\" From","\"\"\"Set the norm of the weight vector.\"\"\" kernel_norm = tf.sqrt(tf.reduce_sum(tf.square(self.weight_v), axis=self.kernel_norm_axes)) self.weight_g.assign(kernel_norm[:, tf.newaxis,","shape `(batch_size, sequence_length)`, *optional*): Labels for computing the masked language modeling loss. Indices","of # all previous decoder key/value_states. Further calls to uni-directional self-attention # can","= (hidden_states,) if output_attentions: outputs += (attn_weights,) return outputs # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2Encoder","HubertConfig base_model_prefix = \"hubert\" main_input_name = \"input_values\" @property def dummy_inputs(self) -> Dict[str, tf.Tensor]:","to be masked. this will be multiplied by number of timesteps divided by","from transformers import Wav2Vec2Processor, TFHubertModel >>> from datasets import load_dataset >>> import soundfile","THE ORDER given in the docstring: `model([input_values, attention_mask])` or `model([input_values, attention_mask, token_type_ids])` -","tf.ones_like(inputs[\"input_values\"], dtype=tf.float32) ) input_lengths = self.hubert._get_feat_extract_output_lengths(tf.reduce_sum(attention_mask, axis=-1)) # assuming that padded tokens are","shape_list(hidden_states) # `config.apply_spec_augment` can set masking to False if not getattr(self.config, \"apply_spec_augment\", True):","src_len)) attn_weights = tf.nn.softmax(attn_weights, axis=-1) if layer_head_mask is not None: # The tf.debugging","values must be <= vocab_size: {self.config.vocab_size}\") attention_mask = ( inputs[\"attention_mask\"] if inputs[\"attention_mask\"] is","% self.groups != 0: raise ValueError( \"Number of groups (\" + str(self.groups) +","returned tensors for more detail. This argument can be used only in eager","# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. #","list)): for i, input in enumerate(input_values): # EagerTensors don't allow to use the","self.num_heads, tgt_len, self.head_dim], message=f\"`attn_output` should be of size {(bsz, self.num_heads, tgt_len, self.head_dim)}, but","self.center = center self.scale = scale self.beta_initializer = tf.keras.initializers.get(beta_initializer) self.gamma_initializer = tf.keras.initializers.get(gamma_initializer) self.beta_regularizer","This model is also a [tf.keras.Model](https://www.tensorflow.org/api_docs/python/tf/keras/Model) subclass. Use it as a regular TF","TFHubertFeedForward(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs): super().__init__(**kwargs) self.intermediate_dropout = tf.keras.layers.Dropout(config.activation_dropout) self.intermediate_dense = tf.keras.layers.Dense(","or not to return a [`~file_utils.ModelOutput`] instead of a plain tuple. This argument","None, output_attentions: Optional[tf.Tensor] = None, output_hidden_states: Optional[tf.Tensor] = None, return_dict: Optional[bool] = None,","indices return tf.scatter_nd(pair_indices, tf.reshape(values, [-1]), output_shape) # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2._compute_mask_indices def _compute_mask_indices( shape:","tf.reshape(batch_indices, [1, -1])], 0)) # scatter values to pair indices return tf.scatter_nd(pair_indices, tf.reshape(values,","Batch x Time x Channel\"\"\" # if key_value_states are provided this layer is","`None` past_key_value = (key_states, value_states) proj_shape = (bsz * self.num_heads, -1, self.head_dim) query_states","config, *inputs, **kwargs): super().__init__(config, *inputs, **kwargs) logger.warning( f\"\\n{self.__class__.__name__} has backpropagation operations that are","(1, 1, tgt_len, 1)) return (one_cst - expanded_mask) * LARGE_NEGATIVE # Copied from","sure num masked indices <= sequence_length if num_masked_spans * mask_length > sequence_length: num_masked_spans","class TFHubertMainLayer(tf.keras.layers.Layer): config_class = HubertConfig def __init__(self, config: HubertConfig, **kwargs): super().__init__(**kwargs) self.config =","used only in eager mode, in graph mode the value in the config","logit_length=input_lengths, label_length=target_lengths, blank_index=self.config.pad_token_id, logits_time_major=False, ) if self.config.ctc_loss_reduction == \"sum\": loss = tf.reduce_sum(loss) if","get_tf_activation(config.feat_extract_activation) self.layer_norm = TFHubertGroupNorm(groups=self.out_conv_dim, epsilon=config.layer_norm_eps, name=\"layer_norm\") def call(self, hidden_states: tf.Tensor) -> tf.Tensor: hidden_states","**kwargs, ): super().__init__(**kwargs) self.embed_dim = embed_dim self.num_heads = num_heads self.dropout = tf.keras.layers.Dropout(dropout) self.head_dim","__init__(self, filters, kernel_size, groups, explicit_padding, **kwargs): super().__init__( filters=filters, kernel_size=kernel_size, groups=groups, padding=\"valid\", use_bias=True, bias_initializer=\"he_normal\",","self.supports_masking = True self.groups = groups self.axis = axis self.epsilon = epsilon self.center","def serving_output(self, output: TFCausalLMOutput) -> TFCausalLMOutput: hs = tf.convert_to_tensor(output.hidden_states) if self.config.output_hidden_states else None","in the config will be used instead. output_hidden_states (`bool`, *optional*): Whether or not","not in parameter_names: logger.warning( f\"The parameter {k} does not belongs to the parameter","you can choose to directly pass an embedded representation. This is useful if","and 2nd is timesteps attention_mask: optional padding mask of the same size as","with -100 # when not being attended to labels_mask = tf.cast(labels >= 0,","# coding=utf-8 # Copyright 2021 The Fairseq Authors and the HuggingFace Inc. team.","# Copied from transformers.models.bart.modeling_tf_bart.TFBartAttention with TFBart->TFHubert class TFHubertAttention(tf.keras.layers.Layer): \"\"\"Multi-headed attention from \"Attention Is","self.output_dropout(hidden_states, training=training) return hidden_states # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2EncoderLayer with Wav2Vec2->Hubert class TFHubertEncoderLayer(tf.keras.layers.Layer): def","if self.config.output_attentions else None return TFBaseModelOutput(last_hidden_state=output.last_hidden_state, hidden_states=hs, attentions=attns) @add_start_docstrings( \"\"\"TFHubert Model with a","_create_broadcast_shape(self, input_shape): broadcast_shape = [1] * len(input_shape) is_instance_norm = (input_shape[self.axis] // self.groups) ==","fill spec_aug_mask = tf.zeros((batch_size, sequence_length), dtype=tf.int32) # uniform distribution to sample from, make","proj_shape = (bsz * self.num_heads, -1, self.head_dim) query_states = tf.reshape(self._shape(query_states, tgt_len, bsz), proj_shape)","= config.conv_dim[layer_id] self.conv = tf.keras.layers.Conv1D( filters=self.out_conv_dim, kernel_size=config.conv_kernel[layer_id], strides=config.conv_stride[layer_id], use_bias=config.conv_bias, name=\"conv\", ) self.activation =","case) # if uni-directional self-attention (decoder) save Tuple(tf.Tensor, tf.Tensor) of # all previous","head_mask: Optional[tf.Tensor] = None, inputs_embeds: Optional[tf.Tensor] = None, output_attentions: Optional[bool] = None, labels:","layers \"\"\" def _conv_out_length(input_length, kernel_size, stride): # 1D convolutional layer output length formula","self.dropout(hidden_states, training=training) for i, layer_module in enumerate(self.layer): if output_hidden_states: all_hidden_states = all_hidden_states +","def _mask_hidden_states(self, hidden_states: tf.Tensor, mask_time_indices: Optional[tf.Tensor] = None): \"\"\" Masks extracted features along","None all_self_attentions = () if output_attentions else None if attention_mask is not None:","Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2._compute_mask_indices def _compute_mask_indices( shape: Tuple[int, int], mask_prob: float, mask_length: int, min_masks:","\"beta_constraint\": tf.keras.constraints.serialize(self.beta_constraint), \"gamma_constraint\": tf.keras.constraints.serialize(self.gamma_constraint), } base_config = super().get_config() return {**base_config, **config} def compute_output_shape(self,","TFHubertForCTC.from_pretrained(\"facebook/hubert-base-960h\") >>> def map_to_array(batch): ... speech, _ = sf.read(batch[\"file\"]) ... batch[\"speech\"] = speech","config: HubertConfig, *inputs, **kwargs): super().__init__(config, *inputs, **kwargs) self.hubert = TFHubertMainLayer(config, name=\"hubert\") self.dropout =","hidden_states = self.padding(hidden_states) hidden_states = self.activation(hidden_states) return hidden_states # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2SamePadLayer with","None, gamma_constraint: tf.keras.constraints.Constraint = None, **kwargs, ): super().__init__(**kwargs) self.supports_masking = True self.groups =","Wav2Vec2Processor.from_pretrained(\"facebook/hubert-base-960h\") >>> model = TFHubertModel.from_pretrained(\"facebook/hubert-base-960h\") >>> def map_to_array(batch): ... speech, _ = sf.read(batch[\"file\"])","return tf.transpose(tf.reshape(tensor, (bsz, seq_len, self.num_heads, self.head_dim)), (0, 2, 1, 3)) def call( self,","past_key_value[0] value_states = past_key_value[1] elif is_cross_attention: # cross_attentions key_states = self._shape(self.k_proj(key_value_states), -1, bsz)","all inputs as keyword arguments (like PyTorch models), or - having all inputs","hidden_states = self.feature_projection(hidden_states, training=inputs[\"training\"]) mask_time_indices = kwargs.get(\"mask_time_indices\", None) if inputs[\"training\"]: hidden_states = self._mask_hidden_states(hidden_states,","is_cross_attention and past_key_value is not None: # reuse k,v, cross_attentions key_states = past_key_value[0]","attentions=outputs.attentions, ) def serving_output(self, output: TFCausalLMOutput) -> TFCausalLMOutput: hs = tf.convert_to_tensor(output.hidden_states) if self.config.output_hidden_states","import soundfile as sf >>> processor = Wav2Vec2Processor.from_pretrained(\"facebook/hubert-base-960h\") >>> model = TFHubertForCTC.from_pretrained(\"facebook/hubert-base-960h\") >>>","Tensors IN THE ORDER given in the docstring: `model([input_values, attention_mask])` or `model([input_values, attention_mask,","compute_output_shape(self, input_shape): return input_shape def _reshape_into_groups(self, inputs, input_shape, tensor_input_shape): group_shape = [tensor_input_shape[i] for","- 1 group_reduction_axes.pop(axis) mean, variance = tf.nn.moments(reshaped_inputs, group_reduction_axes, keepdims=True) gamma, beta = self._get_reshaped_weights(input_shape)","epsilon self.center = center self.scale = scale self.beta_initializer = tf.keras.initializers.get(beta_initializer) self.gamma_initializer = tf.keras.initializers.get(gamma_initializer)","units=config.intermediate_size, kernel_initializer=get_initializer(config.initializer_range), bias_initializer=\"zeros\", name=\"intermediate_dense\", ) self.intermediate_act_fn = get_tf_activation(config.hidden_act) self.output_dense = tf.keras.layers.Dense( units=config.hidden_size, kernel_initializer=get_initializer(config.initializer_range),","TPU\" ) @tf.function def serving(self, inputs): output = self.call(input_values=inputs, training=False) return self.serving_output(output) HUBERT_START_DOCSTRING","training. Args: func (`callable`): The callable function of the TensorFlow model. config ([`PretrainedConfig`]):","will not be updated during training. \"\"\" self.hubert.feature_extractor.trainable = False @add_start_docstrings_to_model_forward(HUBERT_INPUTS_DOCSTRING) @replace_return_docstrings(output_type=TFCausalLMOutput, config_class=_CONFIG_FOR_DOC)","for a real Tensor if type(input) == tf.Tensor: # Tensor names have always","will be removed in Transformers v5.\" \"Please use the equivalent `freeze_feature_encoder` method instead.\",","name=\"attention\", ) self.dropout = tf.keras.layers.Dropout(config.hidden_dropout) self.layer_norm = tf.keras.layers.LayerNormalization(epsilon=config.layer_norm_eps, name=\"layer_norm\") self.feed_forward = TFHubertFeedForward(config, name=\"feed_forward\")","def map_to_array(batch): ... speech, _ = sf.read(batch[\"file\"]) ... batch[\"speech\"] = speech ... return","info \"\"\" z = -tf.math.log(tf.random.uniform(shape_list(distribution), 0, 1)) _, indices = tf.nn.top_k(distribution + z,","bsz) value_states = self._shape(self.v_proj(hidden_states), -1, bsz) key_states = tf.concat([past_key_value[0], key_states], axis=2) value_states =","loss = tf.reduce_mean(loss) else: loss = None if not inputs[\"return_dict\"]: output = (logits,)","be disabled in other modes than eager. if tf.executing_eagerly(): tf.debugging.assert_equal( shape_list(attn_output), [bsz *","cross_attention save Tuple(tf.Tensor, tf.Tensor) of all cross attention key/value_states. # Further calls to","be of size {(bsz * self.num_heads, tgt_len, src_len)}, but is {shape_list(attn_weights)}\", ) if","name=\"final_layer_norm\" ) def call( self, hidden_states: tf.Tensor, attention_mask: Optional[tf.Tensor] = None, output_attentions: Optional[bool]","compliant with XLA then they # have to be disabled in other modes","`mask_length`: {mask_length} and `sequence_length`: {sequence_length}`\" ) # compute number of masked spans in","embedded representation. This is useful if you want more control over how to","scale: bool = True, beta_initializer: tf.keras.initializers.Initializer = \"zeros\", gamma_initializer: tf.keras.initializers.Initializer = \"ones\", beta_regularizer:",") hidden_states = encoder_outputs[0] if not inputs[\"return_dict\"]: return (hidden_states,) + encoder_outputs[1:] return TFBaseModelOutput(","with TFBart->TFHubert class TFHubertAttention(tf.keras.layers.Layer): \"\"\"Multi-headed attention from \"Attention Is All You Need\"\"\" def","spec_aug_mask = _scatter_values_on_batch_indices( tf.ones_like(spec_aug_mask_idxs), spec_aug_mask_idxs, spec_aug_mask.shape ) return spec_aug_mask # Copied from transformers.models.bart.modeling_tf_bart._expand_mask","running model. **kwargs: The inputs of the model. Returns: Two lists, one for","of the model call function: `model(inputs)`. If you choose this second option, there","if name not in list(output.keys()) and name != \"args\": output[name] = kwargs.pop(name, signature[name].default)","0)) # scatter values to pair indices return tf.scatter_nd(pair_indices, tf.reshape(values, [-1]), output_shape) #","if self.scale: self.gamma = self.add_weight( shape=shape, name=\"gamma\", initializer=self.gamma_initializer, regularizer=self.gamma_regularizer, constraint=self.gamma_constraint, ) else: self.gamma","import Any, Dict, Optional, Tuple, Union import numpy as np import tensorflow as","= tf.constant([0, 1]) def _init_norm(self): \"\"\"Set the norm of the weight vector.\"\"\" kernel_norm","in range(config.num_feat_extract_layers) ] else: raise ValueError( f\"`config.feat_extract_norm` is {config.feat_extract_norm}, but has to be","reserved. # # Licensed under the Apache License, Version 2.0 (the \"License\"); #","tf.keras.initializers.Initializer = \"ones\", beta_regularizer: tf.keras.regularizers.Regularizer = None, gamma_regularizer: tf.keras.regularizers.Regularizer = None, beta_constraint: tf.keras.constraints.Constraint","attention_mask = tf.sequence_mask( output_lengths, maxlen=shape_list(hidden_states)[1], dtype=hidden_states.dtype ) hidden_states = self.feature_projection(hidden_states, training=inputs[\"training\"]) mask_time_indices =","call(self, hidden_states): if self.num_pad_remove > 0: hidden_states = hidden_states[:, : -self.num_pad_remove, :] return","input sequence tokens in the vocabulary. Indices can be obtained using [`BertTokenizer`]. See","[bsz * self.num_heads, tgt_len, self.head_dim], message=f\"`attn_output` should be of size {(bsz, self.num_heads, tgt_len,","a cross-attention layer # for the decoder is_cross_attention = key_value_states is not None","if self.config.output_hidden_states else None attns = tf.convert_to_tensor(output.attentions) if self.config.output_attentions else None return TFCausalLMOutput(logits=output.logits,","operations that are NOT supported on CPU. If you wish \" \"to train/fine-tine","name=\"weight_g\", shape=(int(self.weight_v.shape[self.filter_axis]), 1, 1), initializer=\"ones\", dtype=self.weight_v.dtype, trainable=True, ) self.bias = self.add_weight(name=\"bias\", shape=(self.filters,), initializer=\"zeros\",","['group', 'layer']\" ) self.conv_layers = conv_layers def call(self, input_values): hidden_states = tf.expand_dims(input_values, -1)","cross-attention layer # for the decoder is_cross_attention = key_value_states is not None bsz,","the decoder is_cross_attention = key_value_states is not None bsz, tgt_len, embed_dim = shape_list(hidden_states)","are ignored (masked), the loss is only computed for the tokens with labels","than the model's internal embedding lookup matrix. output_attentions (`bool`, *optional*): Whether or not","self._shape(self.k_proj(hidden_states), -1, bsz) value_states = self._shape(self.v_proj(hidden_states), -1, bsz) key_states = tf.concat([past_key_value[0], key_states], axis=2)","output_hidden_states=inputs[\"output_hidden_states\"], return_dict=inputs[\"return_dict\"], training=inputs[\"training\"], ) hidden_states = encoder_outputs[0] if not inputs[\"return_dict\"]: return (hidden_states,) +","axis=-1)) # assuming that padded tokens are filled with -100 # when not","to directly pass an embedded representation. This is useful if you want more","tensor_name in parameter_names: output[tensor_name] = input else: output[parameter_names[i]] = input elif isinstance(input, allowed_types)","if \"inputs\" in input_values: warnings.warn( \"The `inputs` argument is deprecated and will be","don't allow to use the .name property so we check for a real","None, output_hidden_states: Optional[tf.Tensor] = None, return_dict: Optional[bool] = None, training: bool = False,","range(config.num_feat_extract_layers - 1) ] elif config.feat_extract_norm == \"layer\": conv_layers = [ TFHubertLayerNormConvLayer(config, layer_id=i,","else: # self_attention key_states = self._shape(self.k_proj(hidden_states), -1, bsz) value_states = self._shape(self.v_proj(hidden_states), -1, bsz)","in `[0, 1]`: - 1 indicates the head is **not masked**, - 0","tf.cast(mask, dtype=one_cst.dtype) expanded_mask = tf.tile(mask[:, None, None, :], (1, 1, tgt_len, 1)) return","get_tf_activation(config.feat_extract_activation) def call(self, hidden_states: tf.Tensor) -> tf.Tensor: hidden_states = self.conv(hidden_states) hidden_states = self.padding(hidden_states)","dimension \" \"but the layer received an input with shape \" + str(input_shape)","= True, **kwargs, ): super().__init__(**kwargs) self.embed_dim = embed_dim self.num_heads = num_heads self.dropout =","else self.axis - 1 group_reduction_axes.pop(axis) mean, variance = tf.nn.moments(reshaped_inputs, group_reduction_axes, keepdims=True) gamma, beta","self._shape(self.k_proj(hidden_states), -1, bsz) value_states = self._shape(self.v_proj(hidden_states), -1, bsz) if self.is_decoder: # if cross_attention","are provided this layer is used as a cross-attention layer # for the","all layers. See `hidden_states` under returned tensors for more detail. This argument can","= spec_aug_mask_idxs + offsets # scatter indices to mask spec_aug_mask = _scatter_values_on_batch_indices( tf.ones_like(spec_aug_mask_idxs),","to gather all the input Tensors in the first positional argument : -","the proper output we have to add this exception if \"args\" in output:","tf.Tensor) -> tf.Tensor: hidden_states = self.conv(hidden_states) hidden_states = self.activation(hidden_states) return hidden_states # Copied","Optional[bool] = None, return_dict: Optional[bool] = None, training: bool = False, ) ->","_init_norm(self): \"\"\"Set the norm of the weight vector.\"\"\" kernel_norm = tf.sqrt(tf.reduce_sum(tf.square(self.weight_v), axis=self.kernel_norm_axes)) self.weight_g.assign(kernel_norm[:,","if dim % self.groups != 0: raise ValueError( \"Number of groups (\" +","\"Axis \" + str(self.axis) + \" of \" \"input tensor should have a","= self.dropout(hidden_states, training=training) hidden_states = attn_residual + hidden_states hidden_states = self.layer_norm(hidden_states) hidden_states =","output.items() if k in [\"return_dict\", \"output_attentions\", \"output_hidden_states\", \"use_cache\"] } output.update(booleans_processing(config=config, **boolean_dict)) return output","tf.shape(inputs) reshaped_inputs, group_shape = self._reshape_into_groups(inputs, input_shape, tensor_input_shape) normalized_inputs = self._apply_normalization(reshaped_inputs, input_shape) is_instance_norm =","all_hidden_states + (hidden_states,) if not return_dict: return tuple(v for v in [hidden_states, all_hidden_states,","} return dummy_inputs def __init__(self, config, *inputs, **kwargs): super().__init__(config, *inputs, **kwargs) logger.warning( f\"\\n{self.__class__.__name__}","Whether or not to use the model in training mode (some modules like","tf.keras.layers.Conv1D( filters=self.out_conv_dim, kernel_size=config.conv_kernel[layer_id], strides=config.conv_stride[layer_id], use_bias=config.conv_bias, name=\"conv\", ) self.activation = get_tf_activation(config.feat_extract_activation) def call(self, hidden_states:","dict(input_values).items(): if isinstance(v, allowed_types) or v is None: output[k] = v elif k","hidden_states = self.layer_norm(hidden_states) hidden_states = self.dropout(hidden_states, training=training) for i, layer_module in enumerate(self.layer): if","self.kernel = tf.Variable(tf.transpose(self.kernel), name=\"weight_v\", trainable=True) self.weight_v = self.kernel self.weight_g = self.add_weight( name=\"weight_g\", shape=(int(self.weight_v.shape[self.filter_axis]),","spec_aug_mask_idxs = tf.reshape(spec_aug_mask_idxs, (batch_size, num_masked_spans * mask_length)) offsets = tf.range(mask_length)[tf.newaxis, tf.newaxis, :] offsets","mask approximately this percentage of all elements. however due to overlaps, the actual","_apply_normalization(self, reshaped_inputs, input_shape): group_shape = tf.keras.backend.int_shape(reshaped_inputs) group_reduction_axes = list(range(1, len(group_shape))) is_instance_norm = (input_shape[self.axis]","tf.cast(mask_time_indices[:, :, tf.newaxis], tf.bool), self.masked_spec_embed[tf.newaxis, tf.newaxis, :], hidden_states, ) elif self.config.mask_time_prob > 0:","possibilities you can use to gather all the input Tensors in the first","https://arxiv.org/abs/1909.11556 for description) dropout_probability = np.random.uniform(0, 1) if training and (dropout_probability < self.config.layerdrop):","choose this second option, there are three possibilities you can use to gather","self.built = True super().build(input_shape) def call(self, inputs): input_shape = tf.keras.backend.int_shape(inputs) tensor_input_shape = tf.shape(inputs)","Optional[tf.Tensor] = None, inputs_embeds: Optional[tf.Tensor] = None, output_attentions: Optional[bool] = None, output_hidden_states: Optional[bool]","hidden_states + position_embeddings hidden_states = self.layer_norm(hidden_states) hidden_states = self.dropout(hidden_states, training=training) for i, layer_module","past_key_value # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2FeedForward with Wav2Vec2->Hubert class TFHubertFeedForward(tf.keras.layers.Layer): def __init__(self, config: HubertConfig,","to cross_attention layer can then reuse all cross-attention # key/value_states (first \"if\" case)","\"args\": output[name] = kwargs.pop(name, signature[name].default) # When creating a SavedModel TF calls the","indices_shape broad_casted_batch_dims = tf.reshape( tf.broadcast_to(tf.expand_dims(tf.range(indices_shape[0]), axis=-1), indices_shape), [1, -1] ) # transform batch_indices","value_states = tf.concat([past_key_value[1], value_states], axis=2) else: # self_attention key_states = self._shape(self.k_proj(hidden_states), -1, bsz)","config: HubertConfig, layer_id: int = 0, **kwargs: Any) -> None: super().__init__(**kwargs) self.in_conv_dim =","tf.reduce_sum(labels_mask, axis=-1) loss = tf.nn.ctc_loss( logits=logits, labels=labels, logit_length=input_lengths, label_length=target_lengths, blank_index=self.config.pad_token_id, logits_time_major=False, ) if","time since TF 2.7, so we need to account for padding input_shape[-2] +=","def call(self, hidden_states: tf.Tensor) -> tf.Tensor: hidden_states = self.conv(hidden_states) hidden_states = self.layer_norm(hidden_states) hidden_states","of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable","v in output.items() if k in [\"return_dict\", \"output_attentions\", \"output_hidden_states\", \"use_cache\"] } output.update(booleans_processing(config=config, **boolean_dict))","approximately this percentage of all elements. however due to overlaps, the actual number","self.q_proj(hidden_states) * self.scaling # get key, value proj if is_cross_attention and past_key_value is","You Need\"\"\" def __init__( self, embed_dim: int, num_heads: int, dropout: float = 0.0,","2.0 models accepts two formats as inputs: - having all inputs as keyword","= self.conv(hidden_states) hidden_states = self.layer_norm(hidden_states) hidden_states = self.activation(hidden_states) return hidden_states # Copied from","`({0})`, *optional*): Mask to avoid performing attention on padding token indices. Mask values","int = 0, ) -> tf.Tensor: \"\"\" Computes random mask spans for a","case is always the first parameter, then `input_values` output[\"input_values\"] = output[\"args\"] del output[\"args\"]","output_attentions: outputs += (attn_weights,) return outputs # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2Encoder with Wav2Vec2->Hubert class","(input_shape[self.axis] // self.groups) == 1 if not is_instance_norm: axis = -2 if self.axis","tf.keras.layers.Conv1D( filters=self.out_conv_dim, kernel_size=config.conv_kernel[layer_id], strides=config.conv_stride[layer_id], use_bias=config.conv_bias, name=\"conv\", ) self.layer_norm = tf.keras.layers.LayerNormalization(name=\"layer_norm\", epsilon=config.layer_norm_eps) self.activation =","+ tf.random.uniform((1,))) num_masked_spans = max(num_masked_spans, min_masks) # make sure num masked indices <=","should be of size {(bsz, self.num_heads, tgt_len, self.head_dim)}, but is {shape_list(attn_output)}\", ) attn_output","input.name.split(\":\")[0] if tensor_name in parameter_names: output[tensor_name] = input else: output[parameter_names[i]] = input elif","arguments (like PyTorch models), or - having all inputs as a list, tuple","+ position_embeddings hidden_states = self.layer_norm(hidden_states) hidden_states = self.dropout(hidden_states, training=training) for i, layer_module in","= None, output_attentions: Optional[bool] = False, training: bool = False, ) -> Tuple[tf.Tensor]:","raise ValueError( \"Number of groups (\" + str(self.groups) + \") cannot be \"","configuration. Check out the [`~PreTrainedModel.from_pretrained`] method to load the model weights. \"\"\" HUBERT_INPUTS_DOCSTRING","should be of size {(self.num_heads)}, but is {shape_list(layer_head_mask)}\", ) attn_weights = tf.reshape(layer_head_mask, (1,","booleans_processing, get_initializer, keras_serializable from ...tf_utils import shape_list from ...tokenization_utils_base import BatchEncoding from ...utils","pad_token = 0.0 input_values = tf.convert_to_tensor(np.random.rand(1, 16000), tf.float32) dummy_inputs = { \"input_values\": input_values,","(some modules like dropout modules have different behaviors between training and evaluation). \"\"\"","in graph mode the value will always be set to True. training (`bool`,","hidden_states = self.layer_norm(hidden_states) hidden_states = self.activation(hidden_states) return hidden_states # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2PositionalConvEmbedding with","1), initializer=\"ones\", dtype=self.weight_v.dtype, trainable=True, ) self.bias = self.add_weight(name=\"bias\", shape=(self.filters,), initializer=\"zeros\", trainable=True) def call(self,","-> Union[TFBaseModelOutput, Tuple[tf.Tensor]]: all_hidden_states = () if output_hidden_states else None all_self_attentions = ()","self.explicit_padding = explicit_padding self.filter_axis = 2 self.initialized = False self.kernel_norm_axes = tf.constant([0, 1])","tf.bool), self.masked_spec_embed[tf.newaxis, tf.newaxis, :], hidden_states, ) # apply SpecAugment along feature axis if","regularizer=self.beta_regularizer, constraint=self.beta_constraint, ) else: self.beta = None def _create_broadcast_shape(self, input_shape): broadcast_shape = [1]","beta = tf.reshape(self.beta, broadcast_shape) return gamma, beta def _check_if_input_shape_is_none(self, input_shape): dim = input_shape[self.axis]","if type(input) == tf.Tensor: # Tensor names have always the pattern `name:id` then","dropout_probability = np.random.uniform(0, 1) if training and (dropout_probability < self.config.layerdrop): # skip the","description) dropout_probability = np.random.uniform(0, 1) if training and (dropout_probability < self.config.layerdrop): # skip","else None return TFBaseModelOutput(last_hidden_state=output.last_hidden_state, hidden_states=hs, attentions=attns) @add_start_docstrings( \"\"\"TFHubert Model with a `language modeling`","TFHubertFeatureExtractor(TFHubertFeatureEncoder): def __init__(self, config, **kwargs): super().__init__(config, **kwargs) warnings.warn( f\"The class `{self.__class__.__name__}` has been","None, output_attentions: Optional[bool] = None, labels: Optional[tf.Tensor] = None, output_hidden_states: Optional[bool] = None,","= [tensor_input_shape[i] for i in range(len(input_shape))] is_instance_norm = (input_shape[self.axis] // self.groups) == 1","tf.cast(labels >= 0, tf.int32) target_lengths = tf.reduce_sum(labels_mask, axis=-1) loss = tf.nn.ctc_loss( logits=logits, labels=labels,","f\"Data of type {type(input_values)} is not allowed only {allowed_types} is accepted for {parameter_names[0]}.\"","Copyright 2021 The Fairseq Authors and the HuggingFace Inc. team. All rights reserved.","config = { \"groups\": self.groups, \"axis\": self.axis, \"epsilon\": self.epsilon, \"center\": self.center, \"scale\": self.scale,","tf >>> from transformers import Wav2Vec2Processor, TFHubertForCTC >>> from datasets import load_dataset >>>","\"output_hidden_states\", \"use_cache\"] } output.update(booleans_processing(config=config, **boolean_dict)) return output # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2._sample_without_replacement def _sample_without_replacement(distribution,","training: bool = False, ) -> Tuple[tf.Tensor]: attn_residual = hidden_states hidden_states, attn_weights, _","0, tf.int32) target_lengths = tf.reduce_sum(labels_mask, axis=-1) loss = tf.nn.ctc_loss( logits=logits, labels=labels, logit_length=input_lengths, label_length=target_lengths,","indices in format (batch_dim, indixes) \"\"\" indices_shape = shape_list(batch_indices) # broadcast batch dim","-> tf.Tensor: hidden_states = self.conv(hidden_states) hidden_states = self.activation(hidden_states) return hidden_states # Copied from","loss=loss, logits=logits, hidden_states=outputs.hidden_states, attentions=outputs.attentions, ) def serving_output(self, output: TFCausalLMOutput) -> TFCausalLMOutput: hs =","outputs = tf.reshape(normalized_inputs, tensor_input_shape) else: outputs = normalized_inputs return outputs def get_config(self): config","https://www.tensorflow.org/addons/api_docs/python/tfa/layers/GroupNormalization \"\"\" def __init__( self, groups: int = 32, axis: int = -1,",") -> Tuple[tf.Tensor]: attn_residual = hidden_states hidden_states = self.layer_norm(hidden_states) hidden_states, attn_weights, _ =","tf.Tensor: # Tensor names have always the pattern `name:id` then we check only","will be smaller (unless no_overlap is True) mask_length: size of the mask min_masks:","= self._shape(self.v_proj(hidden_states), -1, bsz) key_states = tf.concat([past_key_value[0], key_states], axis=2) value_states = tf.concat([past_key_value[1], value_states],","self.activation(hidden_states) return hidden_states # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2LayerNormConvLayer with Wav2Vec2->Hubert class TFHubertLayerNormConvLayer(tf.keras.layers.Layer): def __init__(self,",">= self.config.vocab_size: raise ValueError(f\"Label values must be <= vocab_size: {self.config.vocab_size}\") attention_mask = (","in the position embeddings. Selected in the range `[0, config.max_position_embeddings - 1]`. [What","== -1 else self.axis - 1 group_reduction_axes.pop(axis) mean, variance = tf.nn.moments(reshaped_inputs, group_reduction_axes, keepdims=True)","eager mode, in graph mode the value in the config will be used","= self.call(input_values=inputs, training=False) return self.serving_output(output) HUBERT_START_DOCSTRING = r\"\"\" This model inherits from [`TFPreTrainedModel`].","attention_mask: Optional[tf.Tensor] = None, output_attentions: Optional[bool] = False, training: bool = False, )","name, i.e. `input_values = tf.keras.Input(shape=(128,), dtype='float32', name=\"input_values\")` otherwise the order of the tensors","message=f\"Head mask for a single layer should be of size {(self.num_heads)}, but is","i in range(len(input_shape))] is_instance_norm = (input_shape[self.axis] // self.groups) == 1 if not is_instance_norm:","of shape `(batch_size, sequence_length)`, *optional*): Labels for computing the masked language modeling loss.","SpecAugment along feature axis if self.config.mask_feature_prob > 0: mask_feature_indices = _compute_mask_indices( (batch_size, hidden_size),","head_mask (`np.ndarray` or `tf.Tensor` of shape `(num_heads,)` or `(num_layers, num_heads)`, *optional*): Mask to","hidden_states = tf.where(mask_feature_indices[:, tf.newaxis, :], hidden_states, 0) return hidden_states def call( self, input_values:","Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2GroupNormConvLayer with Wav2Vec2->Hubert class TFHubertGroupNormConvLayer(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, layer_id: int","0 corresponds to a *sentence A* token, - 1 corresponds to a *sentence","\") cannot be \" \"more than the number of channels (\" + str(dim)","super().build(input_shape) def _get_feat_extract_output_lengths(self, input_lengths: tf.Tensor): \"\"\" Computes the output length of the convolutional","hidden_states = attn_residual + hidden_states hidden_states = self.layer_norm(hidden_states) hidden_states = hidden_states + self.feed_forward(hidden_states)","Wav2Vec2->Hubert class TFHubertPositionalConvEmbedding(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs: Any) -> None: super().__init__(**kwargs) self.conv","indices # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2._scatter_values_on_batch_indices def _scatter_values_on_batch_indices(values, batch_indices, output_shape): \"\"\" Scatter function as","import Wav2Vec2Processor, TFHubertForCTC >>> from datasets import load_dataset >>> import soundfile as sf","config.conv_dim[layer_id] self.conv = tf.keras.layers.Conv1D( filters=self.out_conv_dim, kernel_size=config.conv_kernel[layer_id], strides=config.conv_stride[layer_id], use_bias=config.conv_bias, name=\"conv\", ) self.layer_norm = tf.keras.layers.LayerNormalization(name=\"layer_norm\",","only the configuration. Check out the [`~PreTrainedModel.from_pretrained`] method to load the model weights.","`tf.Tensor` of shape `({0}, hidden_size)`, *optional*): Optionally, instead of passing `input_values` you can","del output[\"kwargs\"] boolean_dict = { k: v for k, v in output.items() if","attention from \"Attention Is All You Need\"\"\" def __init__( self, embed_dim: int, num_heads:","always the first parameter, then `input_values` output[\"input_values\"] = output[\"args\"] del output[\"args\"] if \"kwargs\"","= processor(ds[\"speech\"][0], return_tensors=\"tf\").input_values # Batch size 1 >>> logits = model(input_values).logits >>> predicted_ids","key_states = tf.concat([past_key_value[0], key_states], axis=2) value_states = tf.concat([past_key_value[1], value_states], axis=2) else: # self_attention","model in training mode (some modules like dropout modules have different behaviors between","if inputs[\"output_attentions\"] else self.config.output_attentions ) inputs[\"return_dict\"] = inputs[\"return_dict\"] if inputs[\"return_dict\"] else self.config.return_dict outputs","tf.ones_like(spec_aug_mask_idxs), spec_aug_mask_idxs, spec_aug_mask.shape ) return spec_aug_mask # Copied from transformers.models.bart.modeling_tf_bart._expand_mask def _expand_mask(mask: tf.Tensor,","self.layer_norm = tf.keras.layers.LayerNormalization(name=\"layer_norm\", epsilon=config.layer_norm_eps) self.activation = get_tf_activation(config.feat_extract_activation) def call(self, hidden_states: tf.Tensor) -> tf.Tensor:","internal embedding lookup matrix. output_attentions (`bool`, *optional*): Whether or not to return the","@add_start_docstrings_to_model_forward(HUBERT_INPUTS_DOCSTRING) @replace_return_docstrings(output_type=TFCausalLMOutput, config_class=_CONFIG_FOR_DOC) def call( self, input_values: tf.Tensor, attention_mask: Optional[tf.Tensor] = None, token_type_ids:","self.config.vocab_size: raise ValueError(f\"Label values must be <= vocab_size: {self.config.vocab_size}\") attention_mask = ( inputs[\"attention_mask\"]","span to be masked. this will be multiplied by number of timesteps divided","convolutional layers \"\"\" def _conv_out_length(input_length, kernel_size, stride): # 1D convolutional layer output length","``Dict[str, tf.Tensor]` or `Dict[str, np.ndarray]` and each example must have the shape `({0})`):","raise ValueError( \"Number of groups (\" + str(self.groups) + \") must be a","z = -tf.math.log(tf.random.uniform(shape_list(distribution), 0, 1)) _, indices = tf.nn.top_k(distribution + z, num_samples) return","self.add_weight( name=\"weight_g\", shape=(int(self.weight_v.shape[self.filter_axis]), 1, 1), initializer=\"ones\", dtype=self.weight_v.dtype, trainable=True, ) self.bias = self.add_weight(name=\"bias\", shape=(self.filters,),","for Connectionist Temporal Classification (CTC).\"\"\", HUBERT_START_DOCSTRING, ) class TFHubertForCTC(TFHubertPreTrainedModel): def __init__(self, config: HubertConfig,","= tf.nn.l2_normalize(self.weight_v, axis=self.kernel_norm_axes) * tf.transpose(self.weight_g) self.kernel = tf.transpose(kernel) def build(self, input_shape): if not","token_type_ids (`np.ndarray` or `tf.Tensor` of shape `({0})`, *optional*): Segment token indices to indicate","self.groups = dim def _check_size_of_dimensions(self, input_shape): dim = input_shape[self.axis] if dim < self.groups:","tf.reduce_mean(loss) else: loss = None if not inputs[\"return_dict\"]: output = (logits,) + outputs[1:]","outputs += (attn_weights,) return outputs # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2Encoder with Wav2Vec2->Hubert class TFHubertEncoder(tf.keras.layers.Layer):","# `args` in this case is always the first parameter, then `input_values` output[\"input_values\"]","raise ValueError( f\"Data of type {type(input)} is not allowed only {allowed_types} is accepted","gamma, beta def _check_if_input_shape_is_none(self, input_shape): dim = input_shape[self.axis] if dim is None: raise","supported on CPU. If you wish \" \"to train/fine-tine this model, you need","return normalized_inputs def _get_reshaped_weights(self, input_shape): broadcast_shape = self._create_broadcast_shape(input_shape) gamma = None beta =","token indices to indicate first and second portions of the inputs. Indices are","{ \"input_values\": input_values, \"attention_mask\": tf.cast(tf.not_equal(input_values, pad_token), tf.float32), } return dummy_inputs def __init__(self, config,","stride) return input_lengths def _mask_hidden_states(self, hidden_states: tf.Tensor, mask_time_indices: Optional[tf.Tensor] = None): \"\"\" Masks","= None if self.scale: gamma = tf.reshape(self.gamma, broadcast_shape) if self.center: beta = tf.reshape(self.beta,","dtype=hidden_states.dtype ) hidden_states = self.feature_projection(hidden_states, training=inputs[\"training\"]) mask_time_indices = kwargs.get(\"mask_time_indices\", None) if inputs[\"training\"]: hidden_states","None, beta_constraint: tf.keras.constraints.Constraint = None, gamma_constraint: tf.keras.constraints.Constraint = None, **kwargs, ): super().__init__(**kwargs) self.supports_masking","return (input_length - kernel_size) // stride + 1 for kernel_size, stride in zip(self.config.conv_kernel,","TFCausalLMOutput) -> TFCausalLMOutput: hs = tf.convert_to_tensor(output.hidden_states) if self.config.output_hidden_states else None attns = tf.convert_to_tensor(output.attentions)","inputs_embeds=inputs[\"inputs_embeds\"], output_attentions=inputs[\"output_attentions\"], output_hidden_states=inputs[\"output_hidden_states\"], return_dict=inputs[\"return_dict\"], training=inputs[\"training\"], ) return outputs def serving_output(self, output): hs =","key/value_states (third \"elif\" case) # if encoder bi-directional self-attention `past_key_value` is always `None`","hidden_states = hidden_states + position_embeddings hidden_states = self.layer_norm(hidden_states) hidden_states = self.dropout(hidden_states, training=training) for","during training. \"\"\" warnings.warn( \"The method `freeze_feature_extractor` is deprecated and will be removed","name=\"intermediate_dense\", ) self.intermediate_act_fn = get_tf_activation(config.hidden_act) self.output_dense = tf.keras.layers.Dense( units=config.hidden_size, kernel_initializer=get_initializer(config.initializer_range), bias_initializer=\"zeros\", name=\"output_dense\", )","**masked**. inputs_embeds (`np.ndarray` or `tf.Tensor` of shape `({0}, hidden_size)`, *optional*): Optionally, instead of","outputs = self.hubert( input_values=inputs[\"input_values\"], attention_mask=inputs[\"attention_mask\"], token_type_ids=inputs[\"token_type_ids\"], position_ids=inputs[\"position_ids\"], head_mask=inputs[\"head_mask\"], inputs_embeds=inputs[\"inputs_embeds\"], output_attentions=inputs[\"output_attentions\"], output_hidden_states=inputs[\"output_hidden_states\"], return_dict=inputs[\"return_dict\"], training=inputs[\"training\"],","attention_mask is not None: # The tf.debugging asserts are not compliant with XLA","_expand_mask(attention_mask) else: attention_mask = None position_embeddings = self.pos_conv_embed(hidden_states) hidden_states = hidden_states + position_embeddings","return outputs def serving_output(self, output): hs = tf.convert_to_tensor(output.hidden_states) if self.config.output_hidden_states else None attns","from ...modeling_tf_outputs import TFBaseModelOutput, TFCausalLMOutput from ...modeling_tf_utils import TFPreTrainedModel, booleans_processing, get_initializer, keras_serializable from","tokens in the vocabulary. Indices can be obtained using [`BertTokenizer`]. See [`PreTrainedTokenizer.__call__`] and","value_states = self._shape(self.v_proj(hidden_states), -1, bsz) key_states = tf.concat([past_key_value[0], key_states], axis=2) value_states = tf.concat([past_key_value[1],","type IDs?](../glossary#token-type-ids) position_ids (`np.ndarray` or `tf.Tensor` of shape `({0})`, *optional*): Indices of positions","for {parameter_names[0]}.\" ) for name in parameter_names: if name not in list(output.keys()) and","None, inputs_embeds: Optional[tf.Tensor] = None, output_attentions: Optional[tf.Tensor] = None, output_hidden_states: Optional[tf.Tensor] = None,","tensor_input_shape): group_shape = [tensor_input_shape[i] for i in range(len(input_shape))] is_instance_norm = (input_shape[self.axis] // self.groups)","(bsz * self.num_heads, tgt_len, src_len)) attn_probs = self.dropout(attn_weights, training=training) attn_output = tf.matmul(attn_probs, value_states)","= None, head_mask: Optional[tf.Tensor] = None, inputs_embeds: Optional[tf.Tensor] = None, output_attentions: Optional[tf.Tensor] =","self.beta_initializer = tf.keras.initializers.get(beta_initializer) self.gamma_initializer = tf.keras.initializers.get(gamma_initializer) self.beta_regularizer = tf.keras.regularizers.get(beta_regularizer) self.gamma_regularizer = tf.keras.regularizers.get(gamma_regularizer) self.beta_constraint","= self.groups return broadcast_shape # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2WeightNormConv1D with Wav2Vec2->Hubert class TFHubertWeightNormConv1D(tf.keras.layers.Conv1D): \"\"\"Adapted","https://github.com/tensorflow/tensorflow/issues/9260 for more info \"\"\" z = -tf.math.log(tf.random.uniform(shape_list(distribution), 0, 1)) _, indices =","if \"kwargs\" in output: del output[\"kwargs\"] boolean_dict = { k: v for k,","# See all Hubert models at https://huggingface.co/models?filter=hubert ] LARGE_NEGATIVE = -1e8 # Copied","the value in the config will be used instead. output_hidden_states (`bool`, *optional*): Whether","= encoder_outputs[0] if not inputs[\"return_dict\"]: return (hidden_states,) + encoder_outputs[1:] return TFBaseModelOutput( last_hidden_state=hidden_states, hidden_states=encoder_outputs.hidden_states,","for name in parameter_names: if name not in list(output.keys()) and name != \"args\":","return_tensors=\"tf\").input_values >>> loss = model(input_values, labels=labels).loss ```\"\"\" inputs = input_values_processing( func=self.call, config=self.config, input_values=input_values,","self-attention (decoder) save Tuple(tf.Tensor, tf.Tensor) of # all previous decoder key/value_states. Further calls","expanded_mask = tf.tile(mask[:, None, None, :], (1, 1, tgt_len, 1)) return (one_cst -","past_key_values_length: int = 0): \"\"\" Expands attention_mask from `[bsz, seq_len]` to `[bsz, 1,","if isinstance(v, allowed_types) or v is None: output[k] = v else: raise ValueError(f\"Data","[fairseq's data_utils.py](https://github.com/pytorch/fairseq/blob/e0788f7007a8473a76db573985031f3c94201e79/fairseq/data/data_utils.py#L376). \"\"\" batch_size, sequence_length = shape if mask_length < 1: raise ValueError(\"`mask_length`","governing permissions and # limitations under the License. \"\"\" TensorFlow Hubert model.\"\"\" import","= shape_list(batch_indices) # broadcast batch dim to indices_shape broad_casted_batch_dims = tf.reshape( tf.broadcast_to(tf.expand_dims(tf.range(indices_shape[0]), axis=-1),","hidden_states class TFHubertFeatureExtractor(TFHubertFeatureEncoder): def __init__(self, config, **kwargs): super().__init__(config, **kwargs) warnings.warn( f\"The class `{self.__class__.__name__}`","(batch_size, num_masked_spans, 1)) offsets = tf.reshape(offsets, (batch_size, num_masked_spans * mask_length)) spec_aug_mask_idxs = spec_aug_mask_idxs","message=f\"Attention weights should be of size {(bsz * self.num_heads, tgt_len, src_len)}, but is","# When creating a SavedModel TF calls the method with LayerCall.__call__(args, **kwargs) #","TFHubertGroupNorm(groups=self.out_conv_dim, epsilon=config.layer_norm_eps, name=\"layer_norm\") def call(self, hidden_states: tf.Tensor) -> tf.Tensor: hidden_states = self.conv(hidden_states) hidden_states","inputs_embeds (`np.ndarray` or `tf.Tensor` of shape `({0}, hidden_size)`, *optional*): Optionally, instead of passing","tf.where( tf.cast(mask_time_indices[:, :, tf.newaxis], tf.bool), self.masked_spec_embed[tf.newaxis, tf.newaxis, :], hidden_states, ) # apply SpecAugment","= TFHubertModel.from_pretrained(\"facebook/hubert-base-960h\") >>> def map_to_array(batch): ... speech, _ = sf.read(batch[\"file\"]) ... batch[\"speech\"] =","weights.\"\"\" kernel = tf.nn.l2_normalize(self.weight_v, axis=self.kernel_norm_axes) * tf.transpose(self.weight_g) self.kernel = tf.transpose(kernel) def build(self, input_shape):","# Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2WeightNormConv1D with Wav2Vec2->Hubert class TFHubertWeightNormConv1D(tf.keras.layers.Conv1D): \"\"\"Adapted from https://www.tensorflow.org/probability/api_docs/python/tfp/layers/weight_norm/WeightNorm\"\"\" def __init__(self,","values selected in `[0, 1]`: - 1 for tokens that are **not masked**,","compute loss >>> target_transcription = \"A MAN SAID TO THE UNIVERSE SIR I","training=inputs[\"training\"], ) hidden_states = outputs[0] hidden_states = self.dropout(hidden_states, training=inputs[\"training\"]) logits = self.lm_head(hidden_states) if","tf.concat([past_key_value[0], key_states], axis=2) value_states = tf.concat([past_key_value[1], value_states], axis=2) else: # self_attention key_states =","weight vector.\"\"\" kernel_norm = tf.sqrt(tf.reduce_sum(tf.square(self.weight_v), axis=self.kernel_norm_axes)) self.weight_g.assign(kernel_norm[:, tf.newaxis, tf.newaxis]) def _normalize_kernel(self): \"\"\"Generate normalized","of ['group', 'layer']\" ) self.conv_layers = conv_layers def call(self, input_values): hidden_states = tf.expand_dims(input_values,","pair indices return tf.scatter_nd(pair_indices, tf.reshape(values, [-1]), output_shape) # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2._compute_mask_indices def _compute_mask_indices(","option, there are three possibilities you can use to gather all the input","Model with a `language modeling` head on top for Connectionist Temporal Classification (CTC).\"\"\",","if v is not None) return TFBaseModelOutput( last_hidden_state=hidden_states, hidden_states=all_hidden_states, attentions=all_self_attentions, ) @keras_serializable class","= None def _add_beta_weight(self, input_shape): dim = input_shape[self.axis] shape = (dim,) if self.center:","return_dict=inputs[\"return_dict\"], training=inputs[\"training\"], ) return outputs def serving_output(self, output): hs = tf.convert_to_tensor(output.hidden_states) if self.config.output_hidden_states","use `input_values` instead.\", FutureWarning, ) output[\"input_values\"] = input_values.pop(\"inputs\") if \"decoder_cached_states\" in input_values: warnings.warn(","reshaped_inputs = tf.reshape(inputs, group_shape) return reshaped_inputs, group_shape else: return inputs, group_shape def _apply_normalization(self,","hidden_states, attn_weights, _ = self.attention( hidden_states, attention_mask=attention_mask, training=training ) hidden_states = self.dropout(hidden_states, training=training)","instead.\", FutureWarning, ) output[\"past_key_values\"] = input_values.pop(\"decoder_cached_states\") for k, v in dict(input_values).items(): if isinstance(v,","we need to account for padding input_shape[-2] += self.explicit_padding * 2 super().build(input_shape) self.kernel","have to be disabled in other modes than eager. if tf.executing_eagerly(): tf.debugging.assert_equal( shape_list(attn_output),","= self.attention( hidden_states, attention_mask=attention_mask, training=training ) hidden_states = self.dropout(hidden_states, training=training) hidden_states = attn_residual","class with all the parameters of the model. Initializing with a config file","= max(num_masked_spans, min_masks) # make sure num masked indices <= sequence_length if num_masked_spans","to be chosen as start of the span to be masked. this will","in input_values: warnings.warn( \"The `decoder_cached_states` argument is deprecated and will be removed in","to avoid performing attention on padding token indices. Mask values selected in `[0,","= tf.reduce_mean(loss) else: loss = None if not inputs[\"return_dict\"]: output = (logits,) +","allowed only {allowed_types} is accepted for {parameter_names[i]}.\" ) elif isinstance(input_values, (dict, BatchEncoding)): if","token_type_ids])` - a dictionary with one or several input Tensors associated to the","lookup matrix. output_attentions (`bool`, *optional*): Whether or not to return the attentions tensors","is True) mask_length: size of the mask min_masks: minimum number of masked spans","Indices can be obtained using [`BertTokenizer`]. See [`PreTrainedTokenizer.__call__`] and [`PreTrainedTokenizer.encode`] for details. [What","@add_start_docstrings( \"The bare TFHubert Model transformer outputing raw hidden-states without any specific head","loss = tf.reduce_sum(loss) if self.config.ctc_loss_reduction == \"mean\": loss = tf.reduce_mean(loss) else: loss =","use_bias=True, bias_initializer=\"he_normal\", **kwargs, ) self.explicit_padding = explicit_padding self.filter_axis = 2 self.initialized = False","the superclass documentation for the generic methods the library implements for all its","**not masked**, - 0 indicates the head is **masked**. inputs_embeds (`np.ndarray` or `tf.Tensor`","model including the booleans. In case of a list of symbolic inputs, each","= tgt_len if tgt_len is not None else src_len one_cst = tf.constant(1.0) mask","return outputs # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2Encoder with Wav2Vec2->Hubert class TFHubertEncoder(tf.keras.layers.Layer): def __init__(self, config:","tf.scatter_nd(pair_indices, tf.reshape(values, [-1]), output_shape) # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2._compute_mask_indices def _compute_mask_indices( shape: Tuple[int, int],","tf.keras.layers.Dropout(dropout) self.head_dim = embed_dim // num_heads if (self.head_dim * num_heads) != self.embed_dim: raise","mask = tf.cast(mask, dtype=one_cst.dtype) expanded_mask = tf.tile(mask[:, None, None, :], (1, 1, tgt_len,","inputs_embeds: Optional[tf.Tensor] = None, output_attentions: Optional[bool] = None, output_hidden_states: Optional[bool] = None, return_dict:","Temporal Classification (CTC).\"\"\", HUBERT_START_DOCSTRING, ) class TFHubertForCTC(TFHubertPreTrainedModel): def __init__(self, config: HubertConfig, *inputs, **kwargs):","be divisible by num_heads (got `embed_dim`: {self.embed_dim}\" f\" and `num_heads`: {num_heads}).\" ) self.scaling","= self.dropout(hidden_states, training=training) hidden_states = attn_residual + hidden_states hidden_states = hidden_states + self.feed_forward(self.final_layer_norm(hidden_states))","Tuple[int, int], mask_prob: float, mask_length: int, min_masks: int = 0, ) -> tf.Tensor:","call(self, hidden_states: tf.Tensor) -> tf.Tensor: hidden_states = self.conv(hidden_states) hidden_states = self.activation(hidden_states) return hidden_states","eager. if tf.executing_eagerly(): tf.debugging.assert_equal( shape_list(attn_output), [bsz * self.num_heads, tgt_len, self.head_dim], message=f\"`attn_output` should be","else: outputs = normalized_inputs return outputs def get_config(self): config = { \"groups\": self.groups,","return output # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2._sample_without_replacement def _sample_without_replacement(distribution, num_samples): \"\"\" Categorical sampling without","position_ids=position_ids, head_mask=head_mask, inputs_embeds=inputs_embeds, output_attentions=output_attentions, output_hidden_states=output_hidden_states, return_dict=return_dict, training=training, ) inputs[\"output_hidden_states\"] = ( inputs[\"output_hidden_states\"] if","should be of size {(bsz, 1, tgt_len, src_len)}, but is {shape_list(attention_mask)}\", ) attention_mask","**kwargs) self.config = config self.hubert = TFHubertMainLayer(config, name=\"hubert\") @add_start_docstrings_to_model_forward(HUBERT_INPUTS_DOCSTRING) @replace_return_docstrings(output_type=TFBaseModelOutput, config_class=_CONFIG_FOR_DOC) def call(","= hidden_states + self.feed_forward(self.final_layer_norm(hidden_states)) outputs = (hidden_states,) if output_attentions: outputs += (attn_weights,) return","isinstance(v, allowed_types) or v is None: output[k] = v else: raise ValueError(f\"Data of","self._mask_hidden_states(hidden_states, mask_time_indices=mask_time_indices) encoder_outputs = self.encoder( hidden_states, attention_mask=attention_mask, output_attentions=inputs[\"output_attentions\"], output_hidden_states=inputs[\"output_hidden_states\"], return_dict=inputs[\"return_dict\"], training=inputs[\"training\"], ) hidden_states","TFHubertAttention( embed_dim=config.hidden_size, num_heads=config.num_attention_heads, dropout=config.attention_dropout, is_decoder=False, name=\"attention\", ) self.dropout = tf.keras.layers.Dropout(config.hidden_dropout) self.layer_norm = tf.keras.layers.LayerNormalization(epsilon=config.layer_norm_eps,","= HubertConfig base_model_prefix = \"hubert\" main_input_name = \"input_values\" @property def dummy_inputs(self) -> Dict[str,","TFHubertModel.from_pretrained(\"facebook/hubert-base-960h\") >>> def map_to_array(batch): ... speech, _ = sf.read(batch[\"file\"]) ... batch[\"speech\"] = speech","Further calls to uni-directional self-attention # can concat previous decoder key/value_states to current","[`tf.keras.Model.fit`] method which currently requires having all the tensors in the first argument","else None all_self_attentions = () if output_attentions else None if attention_mask is not","if output_attentions: outputs += (attn_weights,) return outputs # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2EncoderLayerStableLayerNorm with Wav2Vec2->Hubert","dummy_inputs = { \"input_values\": input_values, \"attention_mask\": tf.cast(tf.not_equal(input_values, pad_token), tf.float32), } return dummy_inputs def","num_heads)`, *optional*): Mask to nullify selected heads of the self-attention modules. Mask values","2, 1, 3) ) attn_output = tf.reshape(attn_output, (bsz, tgt_len, embed_dim)) attn_output = self.out_proj(attn_output)","output[\"input_values\"] = output[\"args\"] del output[\"args\"] if \"kwargs\" in output: del output[\"kwargs\"] boolean_dict =","get random indices to mask spec_aug_mask_idxs = _sample_without_replacement(uniform_dist, num_masked_spans) # expand masked indices","hidden_states = hidden_states + self.feed_forward(self.final_layer_norm(hidden_states)) outputs = (hidden_states,) if output_attentions: outputs += (attn_weights,)","distributed under the License is distributed on an \"AS IS\" BASIS, # WITHOUT","tf.keras.regularizers.serialize(self.gamma_regularizer), \"beta_constraint\": tf.keras.constraints.serialize(self.beta_constraint), \"gamma_constraint\": tf.keras.constraints.serialize(self.gamma_constraint), } base_config = super().get_config() return {**base_config, **config} def","if mask_length > sequence_length: raise ValueError( f\"`mask_length` has to be smaller than `sequence_length`,","class TFHubertEncoderLayer(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs): super().__init__(**kwargs) self.attention = TFHubertAttention( embed_dim=config.hidden_size, num_heads=config.num_attention_heads,",") -> Union[TFCausalLMOutput, Tuple[tf.Tensor]]: r\"\"\" labels (`tf.Tensor` or `np.ndarray` of shape `(batch_size, sequence_length)`,","= self.output_dense(hidden_states) hidden_states = self.output_dropout(hidden_states, training=training) return hidden_states # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2EncoderLayer with","is accepted for {k}.\") else: if isinstance(input_values, tf.Tensor) or input_values is None: output[parameter_names[0]]","initializer=\"uniform\", trainable=True, name=\"masked_spec_embed\" ) super().build(input_shape) def _get_feat_extract_output_lengths(self, input_lengths: tf.Tensor): \"\"\" Computes the output",") self.dropout = tf.keras.layers.Dropout(config.hidden_dropout) self.layer_norm = tf.keras.layers.LayerNormalization(epsilon=config.layer_norm_eps, name=\"layer_norm\") self.feed_forward = TFHubertFeedForward(config, name=\"feed_forward\") self.final_layer_norm","they # have to be disabled in other modes than eager. if tf.executing_eagerly():","and \"args\" not in parameter_names: logger.warning( f\"The parameter {k} does not belongs to","(hidden_states,) if output_attentions: outputs += (attn_weights,) return outputs # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2Encoder with","position_ids=position_ids, head_mask=head_mask, inputs_embeds=inputs_embeds, output_attentions=output_attentions, output_hidden_states=output_hidden_states, return_dict=return_dict, training=training, kwargs_call=kwargs, ) hidden_states = self.feature_extractor( tf.cast(inputs[\"input_values\"],","int = 32, axis: int = -1, epsilon: float = 1e-3, center: bool","kernel_size=config.conv_kernel[layer_id], strides=config.conv_stride[layer_id], use_bias=config.conv_bias, name=\"conv\", ) self.activation = get_tf_activation(config.feat_extract_activation) def call(self, hidden_states: tf.Tensor) ->","layer_id=i + 1, name=f\"conv_layers.{i+1}\") for i in range(config.num_feat_extract_layers - 1) ] elif config.feat_extract_norm","is None: raise ValueError( \"Axis \" + str(self.axis) + \" of \" \"input","(first \"if\" case) # if uni-directional self-attention (decoder) save Tuple(tf.Tensor, tf.Tensor) of #","hidden_states: tf.Tensor) -> tf.Tensor: hidden_states = self.conv(hidden_states) hidden_states = self.activation(hidden_states) return hidden_states #","tf.Tensor, attention_mask: Optional[tf.Tensor] = None, output_attentions: Optional[bool] = False, training: bool = False,","return TFCausalLMOutput( loss=loss, logits=logits, hidden_states=outputs.hidden_states, attentions=outputs.attentions, ) def serving_output(self, output: TFCausalLMOutput) -> TFCausalLMOutput:","to handle weights initialization and a simple interface for downloading and loading pretrained","output = super().call(padded_inputs) return output # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2NoLayerNormConvLayer with Wav2Vec2->Hubert class TFHubertNoLayerNormConvLayer(tf.keras.layers.Layer):","> 0: hidden_states = hidden_states[:, : -self.num_pad_remove, :] return hidden_states class TFHubertFeatureEncoder(tf.keras.layers.Layer): def","group_shape[self.axis] = input_shape[self.axis] // self.groups group_shape.insert(self.axis, self.groups) group_shape = tf.stack(group_shape) reshaped_inputs = tf.reshape(inputs,","layer continue layer_outputs = layer_module( hidden_states=hidden_states, attention_mask=attention_mask, output_attentions=output_attentions, training=training, ) hidden_states = layer_outputs[0]","specific head on top.\", HUBERT_START_DOCSTRING, ) class TFHubertModel(TFHubertPreTrainedModel): def __init__(self, config: HubertConfig, *inputs,","broadcast batch dim to indices_shape broad_casted_batch_dims = tf.reshape( tf.broadcast_to(tf.expand_dims(tf.range(indices_shape[0]), axis=-1), indices_shape), [1, -1]","if not inputs[\"return_dict\"]: return (hidden_states,) + encoder_outputs[1:] return TFBaseModelOutput( last_hidden_state=hidden_states, hidden_states=encoder_outputs.hidden_states, attentions=encoder_outputs.attentions, )","else self.config.return_dict outputs = self.hubert( input_values=inputs[\"input_values\"], attention_mask=inputs[\"attention_mask\"], token_type_ids=inputs[\"token_type_ids\"], position_ids=inputs[\"position_ids\"], head_mask=inputs[\"head_mask\"], inputs_embeds=inputs[\"inputs_embeds\"], output_attentions=inputs[\"output_attentions\"], output_hidden_states=inputs[\"output_hidden_states\"],","loss is not None else output return TFCausalLMOutput( loss=loss, logits=logits, hidden_states=outputs.hidden_states, attentions=outputs.attentions, )","def dummy_inputs(self) -> Dict[str, tf.Tensor]: pad_token = 0.0 input_values = tf.convert_to_tensor(np.random.rand(1, 16000), tf.float32)","output length formula taken # from https://pytorch.org/docs/stable/generated/torch.nn.Conv1d.html return (input_length - kernel_size) // stride","modules. Mask values selected in `[0, 1]`: - 1 indicates the head is","for i, layer_module in enumerate(self.layer): if output_hidden_states: all_hidden_states = all_hidden_states + (hidden_states,) #","attention_mask (`np.ndarray` or `tf.Tensor` of shape `({0})`, *optional*): Mask to avoid performing attention","elements mask_prob: probability for each token to be chosen as start of the","-1 else self.axis - 1 group_reduction_axes.pop(axis) mean, variance = tf.nn.moments(reshaped_inputs, group_reduction_axes, keepdims=True) gamma,","padded tokens are filled with -100 # when not being attended to labels_mask","output_attentions: Optional[bool] = None, output_hidden_states: Optional[bool] = None, return_dict: Optional[bool] = None, training:","= () if output_attentions else None if attention_mask is not None: hidden_states =","example must have the shape `({0})`): Indices of input sequence tokens in the","= v elif k not in parameter_names and \"args\" not in parameter_names: logger.warning(","time axis and/or along feature axis according to [SpecAugment](https://arxiv.org/abs/1904.08779). \"\"\" batch_size, sequence_length, hidden_size","choose to directly pass an embedded representation. This is useful if you want","The inputs of the model. Returns: Two lists, one for the missing layers,","*inputs, **kwargs) logger.warning( f\"\\n{self.__class__.__name__} has backpropagation operations that are NOT supported on CPU.","output_hidden_states=output_hidden_states, return_dict=return_dict, training=training, kwargs_call=kwargs, ) hidden_states = self.feature_extractor( tf.cast(inputs[\"input_values\"], tf.float32), training=inputs[\"training\"] ) if","type {type(input_values)} is not allowed only {allowed_types} is accepted for {parameter_names[0]}.\" ) for","of all attention layers. See `attentions` under returned tensors for more detail. This","the generic methods the library implements for all its model (such as downloading","attention_mask])` or `model([input_values, attention_mask, token_type_ids])` - a dictionary with one or several input","symbolic inputs, each input has to be named accordingly to the parameters name,","_check_if_input_shape_is_none(self, input_shape): dim = input_shape[self.axis] if dim is None: raise ValueError( \"Axis \"","tf.bool), self.masked_spec_embed[tf.newaxis, tf.newaxis, :], hidden_states, ) elif self.config.mask_time_prob > 0: # generate indices","self.beta_constraint = tf.keras.constraints.get(beta_constraint) self.gamma_constraint = tf.keras.constraints.get(gamma_constraint) self._check_axis() def build(self, input_shape): self._check_if_input_shape_is_none(input_shape) self._set_number_of_groups_for_instance_norm(input_shape) self._check_size_of_dimensions(input_shape)","layer_outputs = layer_module( hidden_states=hidden_states, attention_mask=attention_mask, output_attentions=output_attentions, training=training, ) hidden_states = layer_outputs[0] if output_attentions:","= None, inputs_embeds: Optional[tf.Tensor] = None, output_attentions: Optional[bool] = None, labels: Optional[tf.Tensor] =","transformers.models.wav2vec2.modeling_tf_wav2vec2._sample_without_replacement def _sample_without_replacement(distribution, num_samples): \"\"\" Categorical sampling without replacement is currently not implemented.","padding mask of the same size as shape, which will prevent masking padded","keras_serializable from ...tf_utils import shape_list from ...tokenization_utils_base import BatchEncoding from ...utils import (","= tf.reshape(value_states, proj_shape) src_len = shape_list(key_states)[1] attn_weights = tf.matmul(query_states, key_states, transpose_b=True) # The","the unexpected layers. \"\"\" signature = dict(inspect.signature(func).parameters) signature.pop(\"kwargs\", None) signature.pop(\"self\", None) parameter_names =","1]`: - 1 indicates the head is **not masked**, - 0 indicates the","the tokens with labels in `[0, ..., config.vocab_size]` Returns: Example: ```python >>> import","= 0): \"\"\" Expands attention_mask from `[bsz, seq_len]` to `[bsz, 1, tgt_seq_len, src_seq_len]`.","inputs_embeds: Optional[tf.Tensor] = None, output_attentions: Optional[tf.Tensor] = None, output_hidden_states: Optional[tf.Tensor] = None, return_dict:","training mode (some modules like dropout modules have different behaviors between training and","calls to uni-directional self-attention # can concat previous decoder key/value_states to current projected","loss = None if not inputs[\"return_dict\"]: output = (logits,) + outputs[1:] return ((loss,)","1 group_reduction_axes.pop(axis) mean, variance = tf.nn.moments(reshaped_inputs, group_reduction_axes, keepdims=True) gamma, beta = self._get_reshaped_weights(input_shape) normalized_inputs","gradient computation for the feature encoder so that its parameter will not be","checked at build time since TF 2.7, so we need to account for",") if self.config.ctc_loss_reduction == \"sum\": loss = tf.reduce_sum(loss) if self.config.ctc_loss_reduction == \"mean\": loss","are **masked**. [What are attention masks?](../glossary#attention-mask) token_type_ids (`np.ndarray` or `tf.Tensor` of shape `({0})`,","( inputs[\"output_attentions\"] if inputs[\"output_attentions\"] else self.config.output_attentions ) inputs[\"return_dict\"] = inputs[\"return_dict\"] if inputs[\"return_dict\"] else","training: Optional[bool] = False, ) -> Union[TFBaseModelOutput, Tuple[tf.Tensor]]: all_hidden_states = () if output_hidden_states","attn_output, attn_weights, past_key_value # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2FeedForward with Wav2Vec2->Hubert class TFHubertFeedForward(tf.keras.layers.Layer): def __init__(self,","not is_instance_norm: outputs = tf.reshape(normalized_inputs, tensor_input_shape) else: outputs = normalized_inputs return outputs def","hidden_states = self.dropout(hidden_states, training=training) for i, layer_module in enumerate(self.layer): if output_hidden_states: all_hidden_states =","layer received an input with shape \" + str(input_shape) + \".\" ) def","= int(mask_prob * sequence_length / mask_length + tf.random.uniform((1,))) num_masked_spans = max(num_masked_spans, min_masks) #","import shape_list from ...tokenization_utils_base import BatchEncoding from ...utils import ( ModelOutput, add_start_docstrings, add_start_docstrings_to_model_forward,","can use to gather all the input Tensors in the first positional argument",":], (1, 1, tgt_len, 1)) return (one_cst - expanded_mask) * LARGE_NEGATIVE # Copied","a [tf.keras.Model](https://www.tensorflow.org/api_docs/python/tf/keras/Model) subclass. Use it as a regular TF 2.0 Keras Model and","is deprecated and will be removed in a future version, use `input_values` instead.\",","self.lm_head = tf.keras.layers.Dense(config.vocab_size, name=\"lm_head\") def freeze_feature_extractor(self): \"\"\" Calling this function will disable the","> 0: mask_feature_indices = _compute_mask_indices( (batch_size, hidden_size), mask_prob=self.config.mask_feature_prob, mask_length=self.config.mask_feature_length, ) hidden_states = tf.where(mask_feature_indices[:,","not to return the hidden states of all layers. See `hidden_states` under returned","Optional[bool] = False, return_dict: Optional[bool] = True, training: Optional[bool] = False, ) ->","= False, ) -> Tuple[tf.Tensor, Optional[tf.Tensor]]: \"\"\"Input shape: Batch x Time x Channel\"\"\"","from \"Attention Is All You Need\"\"\" def __init__( self, embed_dim: int, num_heads: int,","boolean_dict = { k: v for k, v in output.items() if k in","list(range(1, len(group_shape))) is_instance_norm = (input_shape[self.axis] // self.groups) == 1 if not is_instance_norm: axis","tensors for more detail. This argument can be used only in eager mode,","= None, past_key_value: Optional[Tuple[Tuple[tf.Tensor]]] = None, attention_mask: Optional[tf.Tensor] = None, layer_head_mask: Optional[tf.Tensor] =","self.out_proj = tf.keras.layers.Dense(embed_dim, use_bias=bias, name=\"out_proj\") def _shape(self, tensor: tf.Tensor, seq_len: int, bsz: int):","tf.keras.layers.Dense(embed_dim, use_bias=bias, name=\"k_proj\") self.q_proj = tf.keras.layers.Dense(embed_dim, use_bias=bias, name=\"q_proj\") self.v_proj = tf.keras.layers.Dense(embed_dim, use_bias=bias, name=\"v_proj\")","call( self, input_values: tf.Tensor, attention_mask: Optional[tf.Tensor] = None, token_type_ids: Optional[tf.Tensor] = None, position_ids:","that are NOT supported on CPU. If you wish \" \"to train/fine-tine this","sequence_length), dtype=tf.int32) # uniform distribution to sample from, make sure that offset samples","epsilon=config.layer_norm_eps, name=\"layer_norm\") def call(self, hidden_states: tf.Tensor) -> tf.Tensor: hidden_states = self.conv(hidden_states) hidden_states =","= tf.matmul(attn_probs, value_states) # The tf.debugging asserts are not compliant with XLA then","def __init__(self, config: HubertConfig, **kwargs: Any) -> None: super().__init__(**kwargs) if config.feat_extract_norm == \"group\":","tokens in the position embeddings. Selected in the range `[0, config.max_position_embeddings - 1]`.","the value in the config will be used instead. return_dict (`bool`, *optional*): Whether","weights initialization and a simple interface for downloading and loading pretrained models. \"\"\"","self._check_size_of_dimensions(input_shape) self._create_input_spec(input_shape) self._add_gamma_weight(input_shape) self._add_beta_weight(input_shape) self.built = True super().build(input_shape) def call(self, inputs): input_shape =","hidden_states if mask_time_indices is not None: # apply SpecAugment along time axis with","for a single layer should be of size {(self.num_heads)}, but is {shape_list(layer_head_mask)}\", )","is **not masked**, - 0 indicates the head is **masked**. inputs_embeds (`np.ndarray` or","TF_HUBERT_PRETRAINED_MODEL_ARCHIVE_LIST = [ \"facebook/hubert-base-ls960\", # See all Hubert models at https://huggingface.co/models?filter=hubert ] LARGE_NEGATIVE","= tf.nn.softmax(attn_weights, axis=-1) if layer_head_mask is not None: # The tf.debugging asserts are","# `name` part tensor_name = input.name.split(\":\")[0] if tensor_name in parameter_names: output[tensor_name] = input","= self.out_proj(attn_output) attn_weights: tf.Tensor = tf.reshape(attn_weights, (bsz, self.num_heads, tgt_len, src_len)) return attn_output, attn_weights,","mask_prob=self.config.mask_feature_prob, mask_length=self.config.mask_feature_length, ) hidden_states = tf.where(mask_feature_indices[:, tf.newaxis, :], hidden_states, 0) return hidden_states def","inputs[\"output_attentions\"] = ( inputs[\"output_attentions\"] if inputs[\"output_attentions\"] else self.config.output_attentions ) inputs[\"return_dict\"] = inputs[\"return_dict\"] if","# when not being attended to labels_mask = tf.cast(labels >= 0, tf.int32) target_lengths","= _expand_mask(attention_mask) else: attention_mask = None position_embeddings = self.pos_conv_embed(hidden_states) hidden_states = hidden_states +","shapes are checked at build time since TF 2.7, so we need to",") if attention_mask is not None: # The tf.debugging asserts are not compliant","the # `name` part tensor_name = input.name.split(\":\")[0] if tensor_name in parameter_names: output[tensor_name] =","will prevent masking padded elements mask_prob: probability for each token to be chosen","Args: func (`callable`): The callable function of the TensorFlow model. config ([`PretrainedConfig`]): The","Copied from transformers.models.bart.modeling_tf_bart._expand_mask def _expand_mask(mask: tf.Tensor, tgt_len: Optional[int] = None, past_key_values_length: int =","self.input_spec = tf.keras.layers.InputSpec(ndim=len(input_shape), axes={self.axis: dim}) def _add_gamma_weight(self, input_shape): dim = input_shape[self.axis] shape =","input_shape[self.axis] shape = (dim,) if self.scale: self.gamma = self.add_weight( shape=shape, name=\"gamma\", initializer=self.gamma_initializer, regularizer=self.gamma_regularizer,","to convolution formula output_lengths = self._get_feat_extract_output_lengths(tf.reduce_sum(inputs[\"attention_mask\"], -1)) attention_mask = tf.sequence_mask( output_lengths, maxlen=shape_list(hidden_states)[1], dtype=hidden_states.dtype","= groups self.axis = axis self.epsilon = epsilon self.center = center self.scale =","Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2Encoder with Wav2Vec2->Hubert class TFHubertEncoder(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs): super().__init__(**kwargs)","from https://pytorch.org/docs/stable/generated/torch.nn.Conv1d.html return (input_length - kernel_size) // stride + 1 for kernel_size, stride","...tokenization_utils_base import BatchEncoding from ...utils import ( ModelOutput, add_start_docstrings, add_start_docstrings_to_model_forward, logging, replace_return_docstrings, )","Use it as a regular TF 2.0 Keras Model and refer to the","training=training) for i, layer_module in enumerate(self.layer): if output_hidden_states: all_hidden_states = all_hidden_states + (hidden_states,)","`input_values` only and nothing else: `model(inputs_ids)` - a list of varying length with","hidden_states = self.conv(hidden_states) hidden_states = self.padding(hidden_states) hidden_states = self.activation(hidden_states) return hidden_states # Copied","all inputs as a list, tuple or dict in the first positional arguments.","trainable=True) def call(self, inputs): if not self.initialized: self._init_norm() self.initialized = True self._normalize_kernel() padded_inputs","tf.transpose(tf.concat([broad_casted_batch_dims, tf.reshape(batch_indices, [1, -1])], 0)) # scatter values to pair indices return tf.scatter_nd(pair_indices,","model. Returns: Two lists, one for the missing layers, and another one for","computation for the feature encoder so that its parameter will not be updated","{self.config.vocab_size}\") attention_mask = ( inputs[\"attention_mask\"] if inputs[\"attention_mask\"] is not None else tf.ones_like(inputs[\"input_values\"], dtype=tf.float32)","of all cross attention key/value_states. # Further calls to cross_attention layer can then","self.initialized: self._init_norm() self.initialized = True self._normalize_kernel() padded_inputs = tf.pad(inputs, ((0, 0), (self.explicit_padding, self.explicit_padding),","parameter_names and \"args\" not in parameter_names: logger.warning( f\"The parameter {k} does not belongs","we have to add this exception if \"args\" in output: if output[\"args\"] is","all_self_attentions + (layer_outputs[1],) # Add last layer if output_hidden_states: all_hidden_states = all_hidden_states +",") def _check_axis(self): if self.axis == 0: raise ValueError( \"You are trying to","token_type_ids=inputs[\"token_type_ids\"], position_ids=inputs[\"position_ids\"], head_mask=inputs[\"head_mask\"], inputs_embeds=inputs[\"inputs_embeds\"], output_attentions=inputs[\"output_attentions\"], output_hidden_states=inputs[\"output_hidden_states\"], return_dict=inputs[\"return_dict\"], training=inputs[\"training\"], ) hidden_states = outputs[0] hidden_states","self.activation(hidden_states) return hidden_states # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2SamePadLayer with Wav2Vec2->Hubert class TFHubertSamePadLayer(tf.keras.layers.Layer): def __init__(self,","= False, return_dict: Optional[bool] = True, training: Optional[bool] = False, ) -> Union[TFBaseModelOutput,","__init__(self, config: HubertConfig, **kwargs): super().__init__(**kwargs) self.config = config self.feature_extractor = TFHubertFeatureEncoder(config, name=\"feature_extractor\") self.feature_projection","\"License\"); # you may not use this file except in compliance with the","obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless","top.\", HUBERT_START_DOCSTRING, ) class TFHubertModel(TFHubertPreTrainedModel): def __init__(self, config: HubertConfig, *inputs, **kwargs): super().__init__(config, *inputs,","center self.scale = scale self.beta_initializer = tf.keras.initializers.get(beta_initializer) self.gamma_initializer = tf.keras.initializers.get(gamma_initializer) self.beta_regularizer = tf.keras.regularizers.get(beta_regularizer)","epsilon=config.layer_norm_eps) self.activation = get_tf_activation(config.feat_extract_activation) def call(self, hidden_states: tf.Tensor) -> tf.Tensor: hidden_states = self.conv(hidden_states)","accepted for {k}.\") else: if isinstance(input_values, tf.Tensor) or input_values is None: output[parameter_names[0]] =","\"gamma_constraint\": tf.keras.constraints.serialize(self.gamma_constraint), } base_config = super().get_config() return {**base_config, **config} def compute_output_shape(self, input_shape): return","= tf.sequence_mask( output_lengths, maxlen=shape_list(hidden_states)[1], dtype=hidden_states.dtype ) hidden_states = self.feature_projection(hidden_states, training=inputs[\"training\"]) mask_time_indices = kwargs.get(\"mask_time_indices\",","batch dim to indices_shape broad_casted_batch_dims = tf.reshape( tf.broadcast_to(tf.expand_dims(tf.range(indices_shape[0]), axis=-1), indices_shape), [1, -1] )","to nullify selected heads of the self-attention modules. Mask values selected in `[0,","tf.reshape(attn_weights, (bsz, self.num_heads, tgt_len, src_len)) + attention_mask attn_weights = tf.reshape(attn_weights, (bsz * self.num_heads,","is not None bsz, tgt_len, embed_dim = shape_list(hidden_states) # get query proj query_states","- expanded_mask) * LARGE_NEGATIVE # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2GroupNorm with Wav2Vec2->Hubert class TFHubertGroupNorm(tf.keras.layers.Layer): \"\"\"","only in eager mode, in graph mode the value in the config will","will be used instead. output_hidden_states (`bool`, *optional*): Whether or not to return the","\"\"\" Scatter function as in PyTorch with indices in format (batch_dim, indixes) \"\"\"","then they # have to be disabled in other modes than eager. if","UNIVERSE SIR I EXIST\" >>> # wrap processor as target processor to encode","key_states = tf.reshape(key_states, proj_shape) value_states = tf.reshape(value_states, proj_shape) src_len = shape_list(key_states)[1] attn_weights =","eager. if tf.executing_eagerly(): tf.debugging.assert_equal( shape_list(attn_weights), [bsz * self.num_heads, tgt_len, src_len], message=f\"Attention weights should","__init__(self, config: HubertConfig, **kwargs: Any) -> None: super().__init__(**kwargs) self.conv = TFHubertWeightNormConv1D( filters=config.hidden_size, kernel_size=config.num_conv_pos_embeddings,","tf.reshape(attn_weights, (bsz, self.num_heads, tgt_len, src_len)) return attn_output, attn_weights, past_key_value # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2FeedForward","if num_conv_pos_embeddings % 2 == 0 else 0 def call(self, hidden_states): if self.num_pad_remove","= None, return_dict: Optional[bool] = None, training: bool = False, ) -> Union[TFBaseModelOutput,","import HubertConfig logger = logging.get_logger(__name__) _CONFIG_FOR_DOC = \"HubertConfig\" TF_HUBERT_PRETRAINED_MODEL_ARCHIVE_LIST = [ \"facebook/hubert-base-ls960\", #","{(self.num_heads)}, but is {shape_list(layer_head_mask)}\", ) attn_weights = tf.reshape(layer_head_mask, (1, -1, 1, 1)) *","`input_values` output[\"input_values\"] = output[\"args\"] del output[\"args\"] if \"kwargs\" in output: del output[\"kwargs\"] boolean_dict","*optional*): Mask to nullify selected heads of the self-attention modules. Mask values selected","= None, output_attentions: Optional[bool] = False, output_hidden_states: Optional[bool] = False, return_dict: Optional[bool] =","kernel_size=config.conv_kernel[layer_id], strides=config.conv_stride[layer_id], use_bias=config.conv_bias, name=\"conv\", ) self.layer_norm = tf.keras.layers.LayerNormalization(name=\"layer_norm\", epsilon=config.layer_norm_eps) self.activation = get_tf_activation(config.feat_extract_activation) def","Masks extracted features along time axis and/or along feature axis according to [SpecAugment](https://arxiv.org/abs/1904.08779).","gamma, beta = self._get_reshaped_weights(input_shape) normalized_inputs = tf.nn.batch_normalization( reshaped_inputs, mean=mean, variance=variance, scale=gamma, offset=beta, variance_epsilon=self.epsilon,","must be a \" \"multiple of the number of channels (\" + str(dim)","shape = (dim,) if self.center: self.beta = self.add_weight( shape=shape, name=\"beta\", initializer=self.beta_initializer, regularizer=self.beta_regularizer, constraint=self.beta_constraint,","FutureWarning, ) output[\"past_key_values\"] = input_values.pop(\"decoder_cached_states\") for k, v in dict(input_values).items(): if isinstance(v, allowed_types)","import TFPreTrainedModel, booleans_processing, get_initializer, keras_serializable from ...tf_utils import shape_list from ...tokenization_utils_base import BatchEncoding","@replace_return_docstrings(output_type=TFCausalLMOutput, config_class=_CONFIG_FOR_DOC) def call( self, input_values: tf.Tensor, attention_mask: Optional[tf.Tensor] = None, token_type_ids: Optional[tf.Tensor]","tgt_len: Optional[int] = None, past_key_values_length: int = 0): \"\"\" Expands attention_mask from `[bsz,","training=inputs[\"training\"] ) if inputs[\"attention_mask\"] is not None: # compute real output lengths according","shape=shape, name=\"beta\", initializer=self.beta_initializer, regularizer=self.beta_regularizer, constraint=self.beta_constraint, ) else: self.beta = None def _create_broadcast_shape(self, input_shape):","of size 2 where first element is batch size and 2nd is timesteps","None: if tf.reduce_max(labels) >= self.config.vocab_size: raise ValueError(f\"Label values must be <= vocab_size: {self.config.vocab_size}\")","attention_mask attn_weights = tf.reshape(attn_weights, (bsz * self.num_heads, tgt_len, src_len)) attn_weights = tf.nn.softmax(attn_weights, axis=-1)","num_heads: int, dropout: float = 0.0, is_decoder: bool = False, bias: bool =","`List[tf.Tensor]` ``Dict[str, tf.Tensor]` or `Dict[str, np.ndarray]` and each example must have the shape","= speech ... return batch >>> ds = load_dataset(\"hf-internal-testing/librispeech_asr_dummy\", \"clean\", split=\"validation\") >>> ds","logits=logits, hidden_states=outputs.hidden_states, attentions=outputs.attentions, ) def serving_output(self, output: TFCausalLMOutput) -> TFCausalLMOutput: hs = tf.convert_to_tensor(output.hidden_states)","Need\"\"\" def __init__( self, embed_dim: int, num_heads: int, dropout: float = 0.0, is_decoder:","isinstance(input_values, tf.Tensor) or input_values is None: output[parameter_names[0]] = input_values else: raise ValueError( f\"Data","1]) def _init_norm(self): \"\"\"Set the norm of the weight vector.\"\"\" kernel_norm = tf.sqrt(tf.reduce_sum(tf.square(self.weight_v),","WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the","self.projection(hidden_states) hidden_states = self.dropout(hidden_states, training=training) return hidden_states # Copied from transformers.models.bart.modeling_tf_bart.TFBartAttention with TFBart->TFHubert","disabled in other modes than eager. if tf.executing_eagerly(): tf.debugging.assert_equal( shape_list(attention_mask), [bsz, 1, tgt_len,","not compliant with XLA then they # have to be disabled in other","according to convolution formula output_lengths = self._get_feat_extract_output_lengths(tf.reduce_sum(inputs[\"attention_mask\"], -1)) attention_mask = tf.sequence_mask( output_lengths, maxlen=shape_list(hidden_states)[1],","masked spans Adapted from [fairseq's data_utils.py](https://github.com/pytorch/fairseq/blob/e0788f7007a8473a76db573985031f3c94201e79/fairseq/data/data_utils.py#L376). \"\"\" batch_size, sequence_length = shape if mask_length","in graph mode the value in the config will be used instead. return_dict","the model call function: `model(inputs)`. If you choose this second option, there are","bool = False) -> tf.Tensor: hidden_states = self.intermediate_dense(hidden_states) hidden_states = self.intermediate_act_fn(hidden_states) hidden_states =","pattern `name:id` then we check only the # `name` part tensor_name = input.name.split(\":\")[0]","(0, 0))) output = super().call(padded_inputs) return output # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2NoLayerNormConvLayer with Wav2Vec2->Hubert","explicit_padding=config.num_conv_pos_embeddings // 2, name=\"conv\", ) self.padding = TFHubertSamePadLayer(config.num_conv_pos_embeddings) self.activation = get_tf_activation(config.feat_extract_activation) def call(self,","return outputs def get_config(self): config = { \"groups\": self.groups, \"axis\": self.axis, \"epsilon\": self.epsilon,","tf.keras.layers.Dropout(config.hidden_dropout) self.layer = [TFHubertEncoderLayer(config, name=f\"layers.{i}\") for i in range(config.num_hidden_layers)] def call( self, hidden_states:","**kwargs): super().__init__(**kwargs) self.config = config self.pos_conv_embed = TFHubertPositionalConvEmbedding(config, name=\"pos_conv_embed\") self.layer_norm = tf.keras.layers.LayerNormalization(epsilon=config.layer_norm_eps, name=\"layer_norm\")","associated to the input names given in the docstring: `model({\"input_values\": input_values, \"token_type_ids\": token_type_ids})`","if output_attentions: all_self_attentions = all_self_attentions + (layer_outputs[1],) # Add last layer if output_hidden_states:","library implements for all its model (such as downloading or saving, resizing the","embeddings. Selected in the range `[0, config.max_position_embeddings - 1]`. [What are position IDs?](../glossary#position-ids)","-1, self.head_dim) query_states = tf.reshape(self._shape(query_states, tgt_len, bsz), proj_shape) key_states = tf.reshape(key_states, proj_shape) value_states","= tf.reshape(attn_weights, (bsz, self.num_heads, tgt_len, src_len)) return attn_output, attn_weights, past_key_value # Copied from","warnings.warn( \"The `decoder_cached_states` argument is deprecated and will be removed in a future","= None, training: Optional[bool] = False, ) -> Tuple[tf.Tensor, Optional[tf.Tensor]]: \"\"\"Input shape: Batch","tf.keras.layers.LayerNormalization(epsilon=config.layer_norm_eps, name=\"layer_norm\") self.dropout = tf.keras.layers.Dropout(config.hidden_dropout) self.layer = [TFHubertEncoderLayer(config, name=f\"layers.{i}\") for i in range(config.num_hidden_layers)]","other modes than eager. if tf.executing_eagerly(): tf.debugging.assert_equal( shape_list(layer_head_mask), [self.num_heads], message=f\"Head mask for a","list, dict, np.ndarray) for k, v in kwargs.items(): if isinstance(v, allowed_types) or v","(tuple, list)): for i, input in enumerate(input_values): # EagerTensors don't allow to use","of shape `({0})`, *optional*): Segment token indices to indicate first and second portions","num_heads (got `embed_dim`: {self.embed_dim}\" f\" and `num_heads`: {num_heads}).\" ) self.scaling = self.head_dim**-0.5 self.is_decoder","with the model, only the configuration. Check out the [`~PreTrainedModel.from_pretrained`] method to load","speech ... return batch >>> ds = load_dataset(\"hf-internal-testing/librispeech_asr_dummy\", \"clean\", split=\"validation\") >>> ds =","= layer_module( hidden_states=hidden_states, attention_mask=attention_mask, output_attentions=output_attentions, training=training, ) hidden_states = layer_outputs[0] if output_attentions: all_self_attentions","tf.zeros((batch_size, sequence_length), dtype=tf.int32) # uniform distribution to sample from, make sure that offset","ValueError( f\"Data of type {type(input_values)} is not allowed only {allowed_types} is accepted for","removed in Transformers v5. \" f\"Use `{self.__class__.__bases__[0].__name__}` instead.\", FutureWarning, ) class TFHubertFeatureProjection(tf.keras.layers.Layer): def","hidden_states hidden_states = self.layer_norm(hidden_states) hidden_states = hidden_states + self.feed_forward(hidden_states) hidden_states = self.final_layer_norm(hidden_states) outputs","hidden_states = self.activation(hidden_states) return hidden_states # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2PositionalConvEmbedding with Wav2Vec2->Hubert class TFHubertPositionalConvEmbedding(tf.keras.layers.Layer):","self.lm_head(hidden_states) if labels is not None: if tf.reduce_max(labels) >= self.config.vocab_size: raise ValueError(f\"Label values","1, mask_length)) spec_aug_mask_idxs = tf.reshape(spec_aug_mask_idxs, (batch_size, num_masked_spans * mask_length)) offsets = tf.range(mask_length)[tf.newaxis, tf.newaxis,","\"use_cache\"] } output.update(booleans_processing(config=config, **boolean_dict)) return output # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2._sample_without_replacement def _sample_without_replacement(distribution, num_samples):",") from .configuration_hubert import HubertConfig logger = logging.get_logger(__name__) _CONFIG_FOR_DOC = \"HubertConfig\" TF_HUBERT_PRETRAINED_MODEL_ARCHIVE_LIST =","gamma_regularizer: tf.keras.regularizers.Regularizer = None, beta_constraint: tf.keras.constraints.Constraint = None, gamma_constraint: tf.keras.constraints.Constraint = None, **kwargs,","x Time x Channel\"\"\" # if key_value_states are provided this layer is used","feature encoder so that its parameters will not be updated during training. \"\"\"","tf.matmul(query_states, key_states, transpose_b=True) # The tf.debugging asserts are not compliant with XLA then","config=self.config, input_values=input_values, attention_mask=attention_mask, token_type_ids=token_type_ids, position_ids=position_ids, head_mask=head_mask, inputs_embeds=inputs_embeds, output_attentions=output_attentions, output_hidden_states=output_hidden_states, return_dict=return_dict, training=training, ) inputs[\"output_hidden_states\"]","Returns: Two lists, one for the missing layers, and another one for the","name=\"conv\", ) self.activation = get_tf_activation(config.feat_extract_activation) def call(self, hidden_states: tf.Tensor) -> tf.Tensor: hidden_states =","elif k not in parameter_names and \"args\" not in parameter_names: logger.warning( f\"The parameter","return_dict: Optional[bool] = None, training: bool = False, **kwargs: Any, ): inputs =","1, 1)) * tf.reshape( attn_weights, (bsz, self.num_heads, tgt_len, src_len) ) attn_weights = tf.reshape(attn_weights,","**boolean_dict)) return output # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2._sample_without_replacement def _sample_without_replacement(distribution, num_samples): \"\"\" Categorical sampling","one or several input Tensors associated to the input names given in the","list, tuple or dict in the first positional arguments. This second option is","class TFHubertFeedForward(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs): super().__init__(**kwargs) self.intermediate_dropout = tf.keras.layers.Dropout(config.activation_dropout) self.intermediate_dense =","SpecAugment along time axis mask_time_indices = _compute_mask_indices( (batch_size, sequence_length), mask_prob=self.config.mask_time_prob, mask_length=self.config.mask_time_length, min_masks=2, )","time axis with given mask_time_indices hidden_states = tf.where( tf.cast(mask_time_indices[:, :, tf.newaxis], tf.bool), self.masked_spec_embed[tf.newaxis,","not allowed only {allowed_types} is accepted for {parameter_names[i]}.\" ) elif isinstance(input_values, (dict, BatchEncoding)):","conv_layer(hidden_states) return hidden_states class TFHubertFeatureExtractor(TFHubertFeatureEncoder): def __init__(self, config, **kwargs): super().__init__(config, **kwargs) warnings.warn( f\"The","= tf.transpose(tf.concat([broad_casted_batch_dims, tf.reshape(batch_indices, [1, -1])], 0)) # scatter values to pair indices return","tf.keras.layers.Dropout(config.hidden_dropout) def call(self, hidden_states: tf.Tensor, training: bool = False) -> tf.Tensor: hidden_states =","The Fairseq Authors and the HuggingFace Inc. team. All rights reserved. # #","the position embeddings. Selected in the range `[0, config.max_position_embeddings - 1]`. [What are","-1: self.groups = dim def _check_size_of_dimensions(self, input_shape): dim = input_shape[self.axis] if dim <","def _get_reshaped_weights(self, input_shape): broadcast_shape = self._create_broadcast_shape(input_shape) gamma = None beta = None if","shape=(self.config.hidden_size,), initializer=\"uniform\", trainable=True, name=\"masked_spec_embed\" ) super().build(input_shape) def _get_feat_extract_output_lengths(self, input_lengths: tf.Tensor): \"\"\" Computes the","class `{self.__class__.__name__}` has been depreciated \" \"and will be removed in Transformers v5.","*inputs, **kwargs) self.config = config self.hubert = TFHubertMainLayer(config, name=\"hubert\") @add_start_docstrings_to_model_forward(HUBERT_INPUTS_DOCSTRING) @replace_return_docstrings(output_type=TFBaseModelOutput, config_class=_CONFIG_FOR_DOC) def","mask_length=self.config.mask_time_length, min_masks=2, ) hidden_states = tf.where( tf.cast(mask_time_indices[:, :, tf.newaxis], tf.bool), self.masked_spec_embed[tf.newaxis, tf.newaxis, :],","config will be used instead. return_dict (`bool`, *optional*): Whether or not to return","zip(self.config.conv_kernel, self.config.conv_stride): input_lengths = _conv_out_length(input_lengths, kernel_size, stride) return input_lengths def _mask_hidden_states(self, hidden_states: tf.Tensor,","return attn_output, attn_weights, past_key_value # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2FeedForward with Wav2Vec2->Hubert class TFHubertFeedForward(tf.keras.layers.Layer): def","TFBaseModelOutput( last_hidden_state=hidden_states, hidden_states=all_hidden_states, attentions=all_self_attentions, ) # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2EncoderStableLayerNorm with Wav2Vec2->Hubert class TFHubertEncoderStableLayerNorm(tf.keras.layers.Layer):","TF 2.0 Keras Model and refer to the TF 2.0 documentation for all","instead\" ) def _create_input_spec(self, input_shape): dim = input_shape[self.axis] self.input_spec = tf.keras.layers.InputSpec(ndim=len(input_shape), axes={self.axis: dim})","hidden_states=outputs.hidden_states, attentions=outputs.attentions, ) def serving_output(self, output: TFCausalLMOutput) -> TFCausalLMOutput: hs = tf.convert_to_tensor(output.hidden_states) if","attn_weights: tf.Tensor = tf.reshape(attn_weights, (bsz, self.num_heads, tgt_len, src_len)) return attn_output, attn_weights, past_key_value #",") # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2EncoderStableLayerNorm with Wav2Vec2->Hubert class TFHubertEncoderStableLayerNorm(tf.keras.layers.Layer): def __init__(self, config: HubertConfig,","requires having all the tensors in the first argument of the model call","a list of varying length with one or several input Tensors IN THE","heads etc.) This model is also a [tf.keras.Model](https://www.tensorflow.org/api_docs/python/tf/keras/Model) subclass. Use it as a","in parameter_names: logger.warning( f\"The parameter {k} does not belongs to the parameter list","output_hidden_states (`bool`, *optional*): Whether or not to return the hidden states of all","if \"args\" in output: if output[\"args\"] is not None and type(output[\"args\"]) == tf.Tensor:","in range(config.num_hidden_layers)] def call( self, hidden_states: tf.Tensor, attention_mask: Optional[tf.Tensor] = None, output_attentions: Optional[bool]","self.is_decoder = is_decoder self.k_proj = tf.keras.layers.Dense(embed_dim, use_bias=bias, name=\"k_proj\") self.q_proj = tf.keras.layers.Dense(embed_dim, use_bias=bias, name=\"q_proj\")","masking to False if not getattr(self.config, \"apply_spec_augment\", True): return hidden_states if mask_time_indices is","name=f\"conv_layers.{0}\")] + [ TFHubertNoLayerNormConvLayer(config, layer_id=i + 1, name=f\"conv_layers.{i+1}\") for i in range(config.num_feat_extract_layers -","super().__init__(config, **kwargs) warnings.warn( f\"The class `{self.__class__.__name__}` has been depreciated \" \"and will be","+= (attn_weights,) return outputs # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2Encoder with Wav2Vec2->Hubert class TFHubertEncoder(tf.keras.layers.Layer): def","if inputs[\"attention_mask\"] is not None: # compute real output lengths according to convolution","**not masked**, - 0 for tokens that are **masked**. [What are attention masks?](../glossary#attention-mask)",") outputs = self.hubert( input_values=inputs[\"input_values\"], attention_mask=inputs[\"attention_mask\"], token_type_ids=inputs[\"token_type_ids\"], position_ids=inputs[\"position_ids\"], head_mask=inputs[\"head_mask\"], inputs_embeds=inputs[\"inputs_embeds\"], output_attentions=inputs[\"output_attentions\"], output_hidden_states=inputs[\"output_hidden_states\"], return_dict=inputs[\"return_dict\"],","size 1 >>> hidden_states = model(input_values).last_hidden_state ```\"\"\" inputs = input_values_processing( func=self.call, config=self.config, input_values=input_values,","list of varying length with one or several input Tensors IN THE ORDER","= kwargs.get(\"mask_time_indices\", None) if inputs[\"training\"]: hidden_states = self._mask_hidden_states(hidden_states, mask_time_indices=mask_time_indices) encoder_outputs = self.encoder( hidden_states,","hidden states of all layers. See `hidden_states` under returned tensors for more detail.","in the first argument of the model call function: `model(inputs)`. If you choose","`[0, config.max_position_embeddings - 1]`. [What are position IDs?](../glossary#position-ids) head_mask (`np.ndarray` or `tf.Tensor` of","License is distributed on an \"AS IS\" BASIS, # WITHOUT WARRANTIES OR CONDITIONS","@add_start_docstrings_to_model_forward(HUBERT_INPUTS_DOCSTRING) @replace_return_docstrings(output_type=TFBaseModelOutput, config_class=_CONFIG_FOR_DOC) def call( self, input_values: tf.Tensor, attention_mask: Optional[tf.Tensor] = None, token_type_ids:","inputs_embeds=inputs_embeds, output_attentions=output_attentions, output_hidden_states=output_hidden_states, return_dict=return_dict, training=training, kwargs_call=kwargs, ) hidden_states = self.feature_extractor( tf.cast(inputs[\"input_values\"], tf.float32), training=inputs[\"training\"]","else 1 self.out_conv_dim = config.conv_dim[layer_id] self.conv = tf.keras.layers.Conv1D( filters=self.out_conv_dim, kernel_size=config.conv_kernel[layer_id], strides=config.conv_stride[layer_id], use_bias=config.conv_bias, name=\"conv\",","or `tf.Tensor` of shape `({0}, hidden_size)`, *optional*): Optionally, instead of passing `input_values` you","there are three possibilities you can use to gather all the input Tensors","self.masked_spec_embed[tf.newaxis, tf.newaxis, :], hidden_states, ) elif self.config.mask_time_prob > 0: # generate indices &","input_values = processor(ds[\"speech\"][0], return_tensors=\"tf\").input_values # Batch size 1 >>> hidden_states = model(input_values).last_hidden_state ```\"\"\"","hidden_states = self.dropout(hidden_states, training=training) return hidden_states # Copied from transformers.models.bart.modeling_tf_bart.TFBartAttention with TFBart->TFHubert class","normalized_inputs def _get_reshaped_weights(self, input_shape): broadcast_shape = self._create_broadcast_shape(input_shape) gamma = None beta = None","which currently requires having all the tensors in the first argument of the","= tf.keras.layers.LayerNormalization(epsilon=config.layer_norm_eps, name=\"layer_norm\") self.feed_forward = TFHubertFeedForward(config, name=\"feed_forward\") self.final_layer_norm = tf.keras.layers.LayerNormalization( epsilon=config.layer_norm_eps, name=\"final_layer_norm\" )","token_type_ids=inputs[\"token_type_ids\"], position_ids=inputs[\"position_ids\"], head_mask=inputs[\"head_mask\"], inputs_embeds=inputs[\"inputs_embeds\"], output_attentions=inputs[\"output_attentions\"], output_hidden_states=inputs[\"output_hidden_states\"], return_dict=inputs[\"return_dict\"], training=inputs[\"training\"], ) return outputs def serving_output(self,","0 def call(self, hidden_states): if self.num_pad_remove > 0: hidden_states = hidden_states[:, : -self.num_pad_remove,","-> tf.Tensor: hidden_states = self.intermediate_dense(hidden_states) hidden_states = self.intermediate_act_fn(hidden_states) hidden_states = self.intermediate_dropout(hidden_states, training=training) hidden_states","or several input Tensors associated to the input names given in the docstring:","inputs, group_shape def _apply_normalization(self, reshaped_inputs, input_shape): group_shape = tf.keras.backend.int_shape(reshaped_inputs) group_reduction_axes = list(range(1, len(group_shape)))","# if key_value_states are provided this layer is used as a cross-attention layer","= tf.reshape(self._shape(query_states, tgt_len, bsz), proj_shape) key_states = tf.reshape(key_states, proj_shape) value_states = tf.reshape(value_states, proj_shape)","gamma = None beta = None if self.scale: gamma = tf.reshape(self.gamma, broadcast_shape) if","{k} does not belongs to the parameter list {parameter_names} and will be ignored.\"","[`~file_utils.ModelOutput`] instead of a plain tuple. This argument can be used in eager","+ 1, name=f\"conv_layers.{i+1}\") for i in range(config.num_feat_extract_layers - 1) ] elif config.feat_extract_norm ==","tf.reduce_max(labels) >= self.config.vocab_size: raise ValueError(f\"Label values must be <= vocab_size: {self.config.vocab_size}\") attention_mask =","0 else 0 def call(self, hidden_states): if self.num_pad_remove > 0: hidden_states = hidden_states[:,","or - having all inputs as a list, tuple or dict in the","self.hubert( input_values=inputs[\"input_values\"], attention_mask=inputs[\"attention_mask\"], token_type_ids=inputs[\"token_type_ids\"], position_ids=inputs[\"position_ids\"], head_mask=inputs[\"head_mask\"], inputs_embeds=inputs[\"inputs_embeds\"], output_attentions=inputs[\"output_attentions\"], output_hidden_states=inputs[\"output_hidden_states\"], return_dict=inputs[\"return_dict\"], training=inputs[\"training\"], ) hidden_states","feature axis according to [SpecAugment](https://arxiv.org/abs/1904.08779). \"\"\" batch_size, sequence_length, hidden_size = shape_list(hidden_states) # `config.apply_spec_augment`","1D convolutional layer output length formula taken # from https://pytorch.org/docs/stable/generated/torch.nn.Conv1d.html return (input_length -","self.num_heads, tgt_len, self.head_dim)), (0, 2, 1, 3) ) attn_output = tf.reshape(attn_output, (bsz, tgt_len,","(like PyTorch models), or - having all inputs as a list, tuple or","TFHubert Model transformer outputing raw hidden-states without any specific head on top.\", HUBERT_START_DOCSTRING,","else: raise ValueError( f\"Data of type {type(input_values)} is not allowed only {allowed_types} is","train/fine-tine this model, you need a GPU or a TPU\" ) @tf.function def","= tf.reshape(self.beta, broadcast_shape) return gamma, beta def _check_if_input_shape_is_none(self, input_shape): dim = input_shape[self.axis] if","modes than eager. if tf.executing_eagerly(): tf.debugging.assert_equal( shape_list(layer_head_mask), [self.num_heads], message=f\"Head mask for a single","attention_mask = tf.cast(attention_mask, dtype=attn_weights.dtype) attn_weights = tf.reshape(attn_weights, (bsz, self.num_heads, tgt_len, src_len)) + attention_mask","the first parameter, then `input_values` output[\"input_values\"] = output[\"args\"] del output[\"args\"] if \"kwargs\" in","Optional[int] = None, past_key_values_length: int = 0): \"\"\" Expands attention_mask from `[bsz, seq_len]`","Unless required by applicable law or agreed to in writing, software # distributed","-1 if self.axis == -1 else self.axis - 1 group_reduction_axes.pop(axis) mean, variance =","None attns = tf.convert_to_tensor(output.attentions) if self.config.output_attentions else None return TFBaseModelOutput(last_hidden_state=output.last_hidden_state, hidden_states=hs, attentions=attns) @add_start_docstrings(","= TFHubertEncoderStableLayerNorm(config, name=\"encoder\") else: self.encoder = TFHubertEncoder(config, name=\"encoder\") def build(self, input_shape: tf.TensorShape): self.masked_spec_embed","its model (such as downloading or saving, resizing the input embeddings, pruning heads","self._check_axis() def build(self, input_shape): self._check_if_input_shape_is_none(input_shape) self._set_number_of_groups_for_instance_norm(input_shape) self._check_size_of_dimensions(input_shape) self._create_input_spec(input_shape) self._add_gamma_weight(input_shape) self._add_beta_weight(input_shape) self.built = True","to compute masks. should be of size 2 where first element is batch","embed_dim // num_heads if (self.head_dim * num_heads) != self.embed_dim: raise ValueError( f\"embed_dim must","self.final_layer_norm = tf.keras.layers.LayerNormalization( epsilon=config.layer_norm_eps, name=\"final_layer_norm\" ) def call( self, hidden_states: tf.Tensor, attention_mask: Optional[tf.Tensor]","self.explicit_padding), (0, 0))) output = super().call(padded_inputs) return output # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2NoLayerNormConvLayer with","pretrained models. \"\"\" config_class = HubertConfig base_model_prefix = \"hubert\" main_input_name = \"input_values\" @property","= self.dropout(hidden_states, training=training) return hidden_states # Copied from transformers.models.bart.modeling_tf_bart.TFBartAttention with TFBart->TFHubert class TFHubertAttention(tf.keras.layers.Layer):","Tuple[tf.Tensor]: attn_residual = hidden_states hidden_states = self.layer_norm(hidden_states) hidden_states, attn_weights, _ = self.attention( hidden_states,","see https://github.com/tensorflow/tensorflow/issues/9260 for more info \"\"\" z = -tf.math.log(tf.random.uniform(shape_list(distribution), 0, 1)) _, indices","tf.newaxis, :], hidden_states, 0) return hidden_states def call( self, input_values: tf.Tensor, attention_mask: Optional[tf.Tensor]","but is {shape_list(layer_head_mask)}\", ) attn_weights = tf.reshape(layer_head_mask, (1, -1, 1, 1)) * tf.reshape(","*optional*): Whether or not to return the hidden states of all layers. See","shape_list(key_states)[1] attn_weights = tf.matmul(query_states, key_states, transpose_b=True) # The tf.debugging asserts are not compliant","bool = False) -> tf.Tensor: hidden_states = self.layer_norm(hidden_states) hidden_states = self.projection(hidden_states) hidden_states =","if self.config.ctc_loss_reduction == \"mean\": loss = tf.reduce_mean(loss) else: loss = None if not","tgt_len is not None else src_len one_cst = tf.constant(1.0) mask = tf.cast(mask, dtype=one_cst.dtype)","will be multiplied by number of timesteps divided by length of mask span","training and (dropout_probability < self.config.layerdrop): # skip the layer continue layer_outputs = layer_module(","= [ TFHubertLayerNormConvLayer(config, layer_id=i, name=f\"conv_layers.{i}\") for i in range(config.num_feat_extract_layers) ] else: raise ValueError(","class TFHubertGroupNorm(tf.keras.layers.Layer): \"\"\" From tensorflow-addons https://www.tensorflow.org/addons/api_docs/python/tfa/layers/GroupNormalization \"\"\" def __init__( self, groups: int =","Channel\"\"\" # if key_value_states are provided this layer is used as a cross-attention","0: mask_feature_indices = _compute_mask_indices( (batch_size, hidden_size), mask_prob=self.config.mask_feature_prob, mask_length=self.config.mask_feature_length, ) hidden_states = tf.where(mask_feature_indices[:, tf.newaxis,","model's internal embedding lookup matrix. output_attentions (`bool`, *optional*): Whether or not to return","compute real output lengths according to convolution formula output_lengths = self._get_feat_extract_output_lengths(tf.reduce_sum(inputs[\"attention_mask\"], -1)) attention_mask","more control over how to convert `input_values` indices into associated vectors than the","otherwise the order of the tensors will not be guaranteed during the training.","raise ValueError( f\"`mask_length` has to be smaller than `sequence_length`, but got `mask_length`: {mask_length}","tf.keras.initializers.get(gamma_initializer) self.beta_regularizer = tf.keras.regularizers.get(beta_regularizer) self.gamma_regularizer = tf.keras.regularizers.get(gamma_regularizer) self.beta_constraint = tf.keras.constraints.get(beta_constraint) self.gamma_constraint = tf.keras.constraints.get(gamma_constraint)","if not is_instance_norm: group_shape[self.axis] = input_shape[self.axis] // self.groups group_shape.insert(self.axis, self.groups) group_shape = tf.stack(group_shape)","TFHubertSamePadLayer(config.num_conv_pos_embeddings) self.activation = get_tf_activation(config.feat_extract_activation) def call(self, hidden_states: tf.Tensor) -> tf.Tensor: hidden_states = self.conv(hidden_states)","equivalent `freeze_feature_encoder` method instead.\", FutureWarning, ) self.freeze_feature_encoder() def freeze_feature_encoder(self): \"\"\" Calling this function","of shape `(num_heads,)` or `(num_layers, num_heads)`, *optional*): Mask to nullify selected heads of","spans Adapted from [fairseq's data_utils.py](https://github.com/pytorch/fairseq/blob/e0788f7007a8473a76db573985031f3c94201e79/fairseq/data/data_utils.py#L376). \"\"\" batch_size, sequence_length = shape if mask_length <","None, **kwargs, ): super().__init__(**kwargs) self.supports_masking = True self.groups = groups self.axis = axis","usage and behavior. <Tip> TF 2.0 models accepts two formats as inputs: -","graph mode the value will always be set to True. training (`bool`, *optional*,","True super().build(input_shape) def call(self, inputs): input_shape = tf.keras.backend.int_shape(inputs) tensor_input_shape = tf.shape(inputs) reshaped_inputs, group_shape",">>> import soundfile as sf >>> processor = Wav2Vec2Processor.from_pretrained(\"facebook/hubert-base-960h\") >>> model = TFHubertModel.from_pretrained(\"facebook/hubert-base-960h\")","self.layer = [ TFHubertEncoderLayerStableLayerNorm(config, name=f\"layers.{i}\") for i in range(config.num_hidden_layers) ] def call( self,","each token to be chosen as start of the span to be masked.","name=\"hubert\") self.dropout = tf.keras.layers.Dropout(config.final_dropout) self.lm_head = tf.keras.layers.Dense(config.vocab_size, name=\"lm_head\") def freeze_feature_extractor(self): \"\"\" Calling this","min_masks: int = 0, ) -> tf.Tensor: \"\"\" Computes random mask spans for","from, make sure that offset samples are < sequence_length uniform_dist = tf.ones((batch_size, sequence_length","output[parameter_names[i]] = input else: raise ValueError( f\"Data of type {type(input)} is not allowed","attn_output = tf.matmul(attn_probs, value_states) # The tf.debugging asserts are not compliant with XLA","config: HubertConfig, **kwargs): super().__init__(**kwargs) self.config = config self.feature_extractor = TFHubertFeatureEncoder(config, name=\"feature_extractor\") self.feature_projection =","= self.intermediate_dropout(hidden_states, training=training) hidden_states = self.output_dense(hidden_states) hidden_states = self.output_dropout(hidden_states, training=training) return hidden_states #","a [`~file_utils.ModelOutput`] instead of a plain tuple. This argument can be used in","\"\"\" batch_size, sequence_length = shape if mask_length < 1: raise ValueError(\"`mask_length` has to","hidden_states hidden_states = hidden_states + self.feed_forward(self.final_layer_norm(hidden_states)) outputs = (hidden_states,) if output_attentions: outputs +=","attention_mask=inputs[\"attention_mask\"], token_type_ids=inputs[\"token_type_ids\"], position_ids=inputs[\"position_ids\"], head_mask=inputs[\"head_mask\"], inputs_embeds=inputs[\"inputs_embeds\"], output_attentions=inputs[\"output_attentions\"], output_hidden_states=inputs[\"output_hidden_states\"], return_dict=inputs[\"return_dict\"], training=inputs[\"training\"], ) return outputs def","be ignored.\" ) continue else: raise ValueError(f\"Data of type {type(v)} is not allowed","self-attention modules. Mask values selected in `[0, 1]`: - 1 indicates the head","# Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2._scatter_values_on_batch_indices def _scatter_values_on_batch_indices(values, batch_indices, output_shape): \"\"\" Scatter function as in","the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law","-1])], 0)) # scatter values to pair indices return tf.scatter_nd(pair_indices, tf.reshape(values, [-1]), output_shape)","1)) * tf.reshape( attn_weights, (bsz, self.num_heads, tgt_len, src_len) ) attn_weights = tf.reshape(attn_weights, (bsz","self, groups: int = 32, axis: int = -1, epsilon: float = 1e-3,","value proj if is_cross_attention and past_key_value is not None: # reuse k,v, cross_attentions","one for the missing layers, and another one for the unexpected layers. \"\"\"","**kwargs: Any, ): inputs = input_values_processing( func=self.call, config=self.config, input_values=input_values, attention_mask=attention_mask, token_type_ids=token_type_ids, position_ids=position_ids, head_mask=head_mask,","beta = None if self.scale: gamma = tf.reshape(self.gamma, broadcast_shape) if self.center: beta =",":] return hidden_states class TFHubertFeatureEncoder(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs: Any) -> None:","= None, output_hidden_states: Optional[tf.Tensor] = None, return_dict: Optional[bool] = None, training: bool =","range(config.num_hidden_layers) ] def call( self, hidden_states: tf.Tensor, attention_mask: Optional[tf.Tensor] = None, output_attentions: Optional[bool]","is {shape_list(layer_head_mask)}\", ) attn_weights = tf.reshape(layer_head_mask, (1, -1, 1, 1)) * tf.reshape( attn_weights,","\").\" ) def _check_axis(self): if self.axis == 0: raise ValueError( \"You are trying","from datasets import load_dataset >>> import soundfile as sf >>> processor = Wav2Vec2Processor.from_pretrained(\"facebook/hubert-base-960h\")","= None, layer_head_mask: Optional[tf.Tensor] = None, training: Optional[bool] = False, ) -> Tuple[tf.Tensor,","hidden_states = self.intermediate_dropout(hidden_states, training=training) hidden_states = self.output_dense(hidden_states) hidden_states = self.output_dropout(hidden_states, training=training) return hidden_states","-tf.math.log(tf.random.uniform(shape_list(distribution), 0, 1)) _, indices = tf.nn.top_k(distribution + z, num_samples) return indices #","Is All You Need\"\"\" def __init__( self, embed_dim: int, num_heads: int, dropout: float","be set to True. training (`bool`, *optional*, defaults to `False``): Whether or not","padding input_shape[-2] += self.explicit_padding * 2 super().build(input_shape) self.kernel = tf.Variable(tf.transpose(self.kernel), name=\"weight_v\", trainable=True) self.weight_v","sampling without replacement is currently not implemented. The gumbel-max trick will do for","return input_shape def _reshape_into_groups(self, inputs, input_shape, tensor_input_shape): group_shape = [tensor_input_shape[i] for i in","from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2Encoder with Wav2Vec2->Hubert class TFHubertEncoder(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs): super().__init__(**kwargs) self.config","scatter indices to mask spec_aug_mask = _scatter_values_on_batch_indices( tf.ones_like(spec_aug_mask_idxs), spec_aug_mask_idxs, spec_aug_mask.shape ) return spec_aug_mask","= load_dataset(\"hf-internal-testing/librispeech_asr_dummy\", \"clean\", split=\"validation\") >>> ds = ds.map(map_to_array) >>> input_values = processor(ds[\"speech\"][0], return_tensors=\"tf\").input_values","the model, only the configuration. Check out the [`~PreTrainedModel.from_pretrained`] method to load the","and will be removed in Transformers v5.\" \"Please use the equivalent `freeze_feature_encoder` method","layer should be of size {(self.num_heads)}, but is {shape_list(layer_head_mask)}\", ) attn_weights = tf.reshape(layer_head_mask,","\"\"\" warnings.warn( \"The method `freeze_feature_extractor` is deprecated and will be removed in Transformers","specific language governing permissions and # limitations under the License. \"\"\" TensorFlow Hubert","will be ignored.\" ) continue else: raise ValueError(f\"Data of type {type(v)} is not","will always be set to True. training (`bool`, *optional*, defaults to `False``): Whether","self.center, \"scale\": self.scale, \"beta_initializer\": tf.keras.initializers.serialize(self.beta_initializer), \"gamma_initializer\": tf.keras.initializers.serialize(self.gamma_initializer), \"beta_regularizer\": tf.keras.regularizers.serialize(self.beta_regularizer), \"gamma_regularizer\": tf.keras.regularizers.serialize(self.gamma_regularizer), \"beta_constraint\": tf.keras.constraints.serialize(self.beta_constraint),","False, ) -> Tuple[tf.Tensor, Optional[tf.Tensor]]: \"\"\"Input shape: Batch x Time x Channel\"\"\" #","model(input_values, labels=labels).loss ```\"\"\" inputs = input_values_processing( func=self.call, config=self.config, input_values=input_values, attention_mask=attention_mask, token_type_ids=token_type_ids, position_ids=position_ids, head_mask=head_mask,","hidden_states: tf.Tensor, training: bool = False) -> tf.Tensor: hidden_states = self.intermediate_dense(hidden_states) hidden_states =","self.feed_forward = TFHubertFeedForward(config, name=\"feed_forward\") self.final_layer_norm = tf.keras.layers.LayerNormalization( epsilon=config.layer_norm_eps, name=\"final_layer_norm\" ) def call( self,","tf.reshape(spec_aug_mask_idxs, (batch_size, num_masked_spans * mask_length)) offsets = tf.range(mask_length)[tf.newaxis, tf.newaxis, :] offsets = tf.tile(offsets,","keepdims=True) gamma, beta = self._get_reshaped_weights(input_shape) normalized_inputs = tf.nn.batch_normalization( reshaped_inputs, mean=mean, variance=variance, scale=gamma, offset=beta,","masks. should be of size 2 where first element is batch size and","*sentence B* token. [What are token type IDs?](../glossary#token-type-ids) position_ids (`np.ndarray` or `tf.Tensor` of","= \"zeros\", gamma_initializer: tf.keras.initializers.Initializer = \"ones\", beta_regularizer: tf.keras.regularizers.Regularizer = None, gamma_regularizer: tf.keras.regularizers.Regularizer =","broadcast_shape[self.axis] = input_shape[self.axis] // self.groups broadcast_shape.insert(self.axis, self.groups) else: broadcast_shape[self.axis] = self.groups return broadcast_shape","call(self, hidden_states: tf.Tensor) -> tf.Tensor: hidden_states = self.conv(hidden_states) hidden_states = self.layer_norm(hidden_states) hidden_states =","1: raise ValueError(\"`mask_length` has to be bigger than 0.\") if mask_length > sequence_length:","dictionary with one or several input Tensors associated to the input names given","input_shape.as_list() # Conv1D output shapes are checked at build time since TF 2.7,","_sample_without_replacement(distribution, num_samples): \"\"\" Categorical sampling without replacement is currently not implemented. The gumbel-max","_ = sf.read(batch[\"file\"]) ... batch[\"speech\"] = speech ... return batch >>> ds =","TFHubertEncoder(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs): super().__init__(**kwargs) self.config = config self.pos_conv_embed = TFHubertPositionalConvEmbedding(config,","the TensorFlow model. config ([`PretrainedConfig`]): The config of the running model. **kwargs: The",") elif self.config.mask_time_prob > 0: # generate indices & apply SpecAugment along time","f\"\\n{self.__class__.__name__} has backpropagation operations that are NOT supported on CPU. If you wish","\"use tf.layer.batch_normalization instead\" ) def _create_input_spec(self, input_shape): dim = input_shape[self.axis] self.input_spec = tf.keras.layers.InputSpec(ndim=len(input_shape),","formats as inputs: - having all inputs as keyword arguments (like PyTorch models),","distributed on an \"AS IS\" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY","or several input Tensors IN THE ORDER given in the docstring: `model([input_values, attention_mask])`","sample from, make sure that offset samples are < sequence_length uniform_dist = tf.ones((batch_size,","or `model([input_values, attention_mask, token_type_ids])` - a dictionary with one or several input Tensors","be of size {(bsz, 1, tgt_len, src_len)}, but is {shape_list(attention_mask)}\", ) attention_mask =","of shape `({0})`, *optional*): Mask to avoid performing attention on padding token indices.","= tf.keras.layers.Dense(config.vocab_size, name=\"lm_head\") def freeze_feature_extractor(self): \"\"\" Calling this function will disable the gradient","= input_values.pop(\"decoder_cached_states\") for k, v in dict(input_values).items(): if isinstance(v, allowed_types) or v is","name=\"layer_norm\") self.dropout = tf.keras.layers.Dropout(config.hidden_dropout) self.layer = [ TFHubertEncoderLayerStableLayerNorm(config, name=f\"layers.{i}\") for i in range(config.num_hidden_layers)","\"layer\": conv_layers = [ TFHubertLayerNormConvLayer(config, layer_id=i, name=f\"conv_layers.{i}\") for i in range(config.num_feat_extract_layers) ] else:","disabled in other modes than eager. if tf.executing_eagerly(): tf.debugging.assert_equal( shape_list(layer_head_mask), [self.num_heads], message=f\"Head mask","self.encoder( hidden_states, attention_mask=attention_mask, output_attentions=inputs[\"output_attentions\"], output_hidden_states=inputs[\"output_hidden_states\"], return_dict=inputs[\"return_dict\"], training=inputs[\"training\"], ) hidden_states = encoder_outputs[0] if not","of groups (\" + str(self.groups) + \") must be a \" \"multiple of","= self.intermediate_dense(hidden_states) hidden_states = self.intermediate_act_fn(hidden_states) hidden_states = self.intermediate_dropout(hidden_states, training=training) hidden_states = self.output_dense(hidden_states) hidden_states","target_transcription = \"A MAN SAID TO THE UNIVERSE SIR I EXIST\" >>> #","be a \" \"multiple of the number of channels (\" + str(dim) +","labels: Optional[tf.Tensor] = None, output_hidden_states: Optional[bool] = None, return_dict: Optional[bool] = None, training:","padded elements mask_prob: probability for each token to be chosen as start of","be used instead. return_dict (`bool`, *optional*): Whether or not to return a [`~file_utils.ModelOutput`]","attention_mask=attention_mask, token_type_ids=token_type_ids, position_ids=position_ids, head_mask=head_mask, inputs_embeds=inputs_embeds, output_attentions=output_attentions, output_hidden_states=output_hidden_states, return_dict=return_dict, training=training, ) inputs[\"output_hidden_states\"] = (","timesteps divided by length of mask span to mask approximately this percentage of","mask_length)) spec_aug_mask_idxs = spec_aug_mask_idxs + offsets # scatter indices to mask spec_aug_mask =",") input_lengths = self.hubert._get_feat_extract_output_lengths(tf.reduce_sum(attention_mask, axis=-1)) # assuming that padded tokens are filled with","input_shape[self.axis] // self.groups broadcast_shape.insert(self.axis, self.groups) else: broadcast_shape[self.axis] = self.groups return broadcast_shape # Copied","= (input_shape[self.axis] // self.groups) == 1 if not is_instance_norm: group_shape[self.axis] = input_shape[self.axis] //","self.add_weight(name=\"bias\", shape=(self.filters,), initializer=\"zeros\", trainable=True) def call(self, inputs): if not self.initialized: self._init_norm() self.initialized =","= { k: v for k, v in output.items() if k in [\"return_dict\",","tf.keras.layers.LayerNormalization(name=\"layer_norm\", epsilon=config.layer_norm_eps) self.activation = get_tf_activation(config.feat_extract_activation) def call(self, hidden_states: tf.Tensor) -> tf.Tensor: hidden_states =","self.padding(hidden_states) hidden_states = self.activation(hidden_states) return hidden_states # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2SamePadLayer with Wav2Vec2->Hubert class","to in writing, software # distributed under the License is distributed on an","the mask min_masks: minimum number of masked spans Adapted from [fairseq's data_utils.py](https://github.com/pytorch/fairseq/blob/e0788f7007a8473a76db573985031f3c94201e79/fairseq/data/data_utils.py#L376). \"\"\"","is_instance_norm: axis = -2 if self.axis == -1 else self.axis - 1 else:","warnings from typing import Any, Dict, Optional, Tuple, Union import numpy as np","tf.reshape(normalized_inputs, tensor_input_shape) else: outputs = normalized_inputs return outputs def get_config(self): config = {","size {(bsz, self.num_heads, tgt_len, self.head_dim)}, but is {shape_list(attn_output)}\", ) attn_output = tf.transpose( tf.reshape(attn_output,","in this case is always the first parameter, then `input_values` output[\"input_values\"] = output[\"args\"]","..., config.vocab_size]` (see `input_values` docstring) Tokens with indices set to `-100` are ignored","if tgt_len is not None else src_len one_cst = tf.constant(1.0) mask = tf.cast(mask,","TFHubertMainLayer(config, name=\"hubert\") @add_start_docstrings_to_model_forward(HUBERT_INPUTS_DOCSTRING) @replace_return_docstrings(output_type=TFBaseModelOutput, config_class=_CONFIG_FOR_DOC) def call( self, input_values: tf.Tensor, attention_mask: Optional[tf.Tensor] =","transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2GroupNorm with Wav2Vec2->Hubert class TFHubertGroupNorm(tf.keras.layers.Layer): \"\"\" From tensorflow-addons https://www.tensorflow.org/addons/api_docs/python/tfa/layers/GroupNormalization \"\"\" def __init__( self,","\"args\" in output: if output[\"args\"] is not None and type(output[\"args\"]) == tf.Tensor: tensor_name","-1) for conv_layer in self.conv_layers: hidden_states = conv_layer(hidden_states) return hidden_states class TFHubertFeatureExtractor(TFHubertFeatureEncoder): def","as sf >>> processor = Wav2Vec2Processor.from_pretrained(\"facebook/hubert-base-960h\") >>> model = TFHubertForCTC.from_pretrained(\"facebook/hubert-base-960h\") >>> def map_to_array(batch):","to use the .name property so we check for a real Tensor if","a single layer should be of size {(self.num_heads)}, but is {shape_list(layer_head_mask)}\", ) attn_weights","= self.pos_conv_embed(hidden_states) hidden_states = hidden_states + position_embeddings hidden_states = self.layer_norm(hidden_states) hidden_states = self.dropout(hidden_states,","tf.keras.constraints.get(beta_constraint) self.gamma_constraint = tf.keras.constraints.get(gamma_constraint) self._check_axis() def build(self, input_shape): self._check_if_input_shape_is_none(input_shape) self._set_number_of_groups_for_instance_norm(input_shape) self._check_size_of_dimensions(input_shape) self._create_input_spec(input_shape) self._add_gamma_weight(input_shape)","Apache License, Version 2.0 (the \"License\"); # you may not use this file","Initializing with a config file does not load the weights associated with the","shape_list(hidden_states) # get query proj query_states = self.q_proj(hidden_states) * self.scaling # get key,","logger.warning( f\"\\n{self.__class__.__name__} has backpropagation operations that are NOT supported on CPU. If you","the License is distributed on an \"AS IS\" BASIS, # WITHOUT WARRANTIES OR","is_cross_attention = key_value_states is not None bsz, tgt_len, embed_dim = shape_list(hidden_states) # get","= all_hidden_states + (hidden_states,) # add LayerDrop (see https://arxiv.org/abs/1909.11556 for description) dropout_probability =","is not None: # reuse k, v, self_attention key_states = self._shape(self.k_proj(hidden_states), -1, bsz)","= -2 if self.axis == -1 else self.axis - 1 else: axis =","get_tf_activation from ...modeling_tf_outputs import TFBaseModelOutput, TFCausalLMOutput from ...modeling_tf_utils import TFPreTrainedModel, booleans_processing, get_initializer, keras_serializable","to be named accordingly to the parameters name, i.e. `input_values = tf.keras.Input(shape=(128,), dtype='float32',","you may not use this file except in compliance with the License. #","transformers.models.wav2vec2.modeling_tf_wav2vec2.input_values_processing def input_values_processing(func, config, input_values, **kwargs): \"\"\" Process the input of each TensorFlow","the weights associated with the model, only the configuration. Check out the [`~PreTrainedModel.from_pretrained`]","tf.keras.initializers.get(beta_initializer) self.gamma_initializer = tf.keras.initializers.get(gamma_initializer) self.beta_regularizer = tf.keras.regularizers.get(beta_regularizer) self.gamma_regularizer = tf.keras.regularizers.get(gamma_regularizer) self.beta_constraint = tf.keras.constraints.get(beta_constraint)","== \"group\": conv_layers = [TFHubertGroupNormConvLayer(config, layer_id=0, name=f\"conv_layers.{0}\")] + [ TFHubertNoLayerNormConvLayer(config, layer_id=i + 1,","training: Optional[bool] = False, ) -> Union[TFCausalLMOutput, Tuple[tf.Tensor]]: r\"\"\" labels (`tf.Tensor` or `np.ndarray`","TFHubertPreTrainedModel(TFPreTrainedModel): \"\"\" An abstract class to handle weights initialization and a simple interface","tf.keras.constraints.get(gamma_constraint) self._check_axis() def build(self, input_shape): self._check_if_input_shape_is_none(input_shape) self._set_number_of_groups_for_instance_norm(input_shape) self._check_size_of_dimensions(input_shape) self._create_input_spec(input_shape) self._add_gamma_weight(input_shape) self._add_beta_weight(input_shape) self.built =","= (tf.Tensor, bool, int, ModelOutput, tuple, list, dict, np.ndarray) for k, v in","= None, training: bool = False, **kwargs: Any, ): inputs = input_values_processing( func=self.call,","config.max_position_embeddings - 1]`. [What are position IDs?](../glossary#position-ids) head_mask (`np.ndarray` or `tf.Tensor` of shape","32, axis: int = -1, epsilon: float = 1e-3, center: bool = True,","`model(inputs_ids)` - a list of varying length with one or several input Tensors","is_instance_norm = (input_shape[self.axis] // self.groups) == 1 if not is_instance_norm: group_shape[self.axis] = input_shape[self.axis]","__init__( self, embed_dim: int, num_heads: int, dropout: float = 0.0, is_decoder: bool =","IDs?](../glossary#input-ids) attention_mask (`np.ndarray` or `tf.Tensor` of shape `({0})`, *optional*): Mask to avoid performing","will disable the gradient computation for the feature encoder so that its parameter","# Licensed under the Apache License, Version 2.0 (the \"License\"); # you may","None return TFBaseModelOutput(last_hidden_state=output.last_hidden_state, hidden_states=hs, attentions=attns) @add_start_docstrings( \"\"\"TFHubert Model with a `language modeling` head","self.encoder = TFHubertEncoder(config, name=\"encoder\") def build(self, input_shape: tf.TensorShape): self.masked_spec_embed = self.add_weight( shape=(self.config.hidden_size,), initializer=\"uniform\",","all the tensors in the first argument of the model call function: `model(inputs)`.","not to return the attentions tensors of all attention layers. See `attentions` under","= tf.convert_to_tensor(np.random.rand(1, 16000), tf.float32) dummy_inputs = { \"input_values\": input_values, \"attention_mask\": tf.cast(tf.not_equal(input_values, pad_token), tf.float32),","src_len)}, but is {shape_list(attention_mask)}\", ) attention_mask = tf.cast(attention_mask, dtype=attn_weights.dtype) attn_weights = tf.reshape(attn_weights, (bsz,","*optional*): Indices of positions of each input sequence tokens in the position embeddings.","normalized_inputs return outputs def get_config(self): config = { \"groups\": self.groups, \"axis\": self.axis, \"epsilon\":","with Wav2Vec2->Hubert class TFHubertNoLayerNormConvLayer(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, layer_id: int = 0, **kwargs:","as shape, which will prevent masking padded elements mask_prob: probability for each token","logging.get_logger(__name__) _CONFIG_FOR_DOC = \"HubertConfig\" TF_HUBERT_PRETRAINED_MODEL_ARCHIVE_LIST = [ \"facebook/hubert-base-ls960\", # See all Hubert models","_compute_mask_indices( (batch_size, hidden_size), mask_prob=self.config.mask_feature_prob, mask_length=self.config.mask_feature_length, ) hidden_states = tf.where(mask_feature_indices[:, tf.newaxis, :], hidden_states, 0)","-> Union[TFCausalLMOutput, Tuple[tf.Tensor]]: r\"\"\" labels (`tf.Tensor` or `np.ndarray` of shape `(batch_size, sequence_length)`, *optional*):","Computes the output length of the convolutional layers \"\"\" def _conv_out_length(input_length, kernel_size, stride):","= False, output_hidden_states: Optional[bool] = False, return_dict: Optional[bool] = True, training: Optional[bool] =","mean, variance = tf.nn.moments(reshaped_inputs, group_reduction_axes, keepdims=True) gamma, beta = self._get_reshaped_weights(input_shape) normalized_inputs = tf.nn.batch_normalization(","sequence tokens in the position embeddings. Selected in the range `[0, config.max_position_embeddings -","isinstance(v, allowed_types) or v is None: output[k] = v elif k not in","that padded tokens are filled with -100 # when not being attended to","= self.activation(hidden_states) return hidden_states # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2GroupNormConvLayer with Wav2Vec2->Hubert class TFHubertGroupNormConvLayer(tf.keras.layers.Layer): def","list of symbolic inputs, each input has to be named accordingly to the","selected in `[0, 1]`: - 1 indicates the head is **not masked**, -","def _add_beta_weight(self, input_shape): dim = input_shape[self.axis] shape = (dim,) if self.center: self.beta =","attention_mask = _expand_mask(attention_mask) else: attention_mask = None position_embeddings = self.pos_conv_embed(hidden_states) hidden_states = hidden_states","however due to overlaps, the actual number will be smaller (unless no_overlap is","= tf.keras.layers.InputSpec(ndim=len(input_shape), axes={self.axis: dim}) def _add_gamma_weight(self, input_shape): dim = input_shape[self.axis] shape = (dim,)","Connectionist Temporal Classification (CTC).\"\"\", HUBERT_START_DOCSTRING, ) class TFHubertForCTC(TFHubertPreTrainedModel): def __init__(self, config: HubertConfig, *inputs,","ValueError( \"Number of groups (\" + str(self.groups) + \") cannot be \" \"more","we check for a real Tensor if type(input) == tf.Tensor: # Tensor names","ValueError( \"You are trying to normalize your batch axis. Do you want to","= input else: output[parameter_names[i]] = input elif isinstance(input, allowed_types) or input is None:","* mask_length)) spec_aug_mask_idxs = spec_aug_mask_idxs + offsets # scatter indices to mask spec_aug_mask","values selected in `[0, 1]`: - 1 indicates the head is **not masked**,","if not return_dict: return tuple(v for v in [hidden_states, all_hidden_states, all_self_attentions] if v","with indices in format (batch_dim, indixes) \"\"\" indices_shape = shape_list(batch_indices) # broadcast batch","hs = tf.convert_to_tensor(output.hidden_states) if self.config.output_hidden_states else None attns = tf.convert_to_tensor(output.attentions) if self.config.output_attentions else","def _expand_mask(mask: tf.Tensor, tgt_len: Optional[int] = None, past_key_values_length: int = 0): \"\"\" Expands","= self.layer_norm(hidden_states) if output_hidden_states: all_hidden_states = all_hidden_states + (hidden_states,) if not return_dict: return","numpy as np import tensorflow as tf from ...activations_tf import get_tf_activation from ...modeling_tf_outputs","cross_attention layer can then reuse all cross-attention # key/value_states (first \"if\" case) #","be removed in Transformers v5. \" f\"Use `{self.__class__.__bases__[0].__name__}` instead.\", FutureWarning, ) class TFHubertFeatureProjection(tf.keras.layers.Layer):","general usage and behavior. <Tip> TF 2.0 models accepts two formats as inputs:","ModelOutput, add_start_docstrings, add_start_docstrings_to_model_forward, logging, replace_return_docstrings, ) from .configuration_hubert import HubertConfig logger = logging.get_logger(__name__)","kernel_norm = tf.sqrt(tf.reduce_sum(tf.square(self.weight_v), axis=self.kernel_norm_axes)) self.weight_g.assign(kernel_norm[:, tf.newaxis, tf.newaxis]) def _normalize_kernel(self): \"\"\"Generate normalized weights.\"\"\" kernel","and `num_heads`: {num_heads}).\" ) self.scaling = self.head_dim**-0.5 self.is_decoder = is_decoder self.k_proj = tf.keras.layers.Dense(embed_dim,","raise ValueError( f\"embed_dim must be divisible by num_heads (got `embed_dim`: {self.embed_dim}\" f\" and","Indices are selected in `[0, 1]`: - 0 corresponds to a *sentence A*","def _create_broadcast_shape(self, input_shape): broadcast_shape = [1] * len(input_shape) is_instance_norm = (input_shape[self.axis] // self.groups)","Whether or not to return a [`~file_utils.ModelOutput`] instead of a plain tuple. This","output = (logits,) + outputs[1:] return ((loss,) + output) if loss is not","(batch_size, sequence_length), mask_prob=self.config.mask_time_prob, mask_length=self.config.mask_time_length, min_masks=2, ) hidden_states = tf.where( tf.cast(mask_time_indices[:, :, tf.newaxis], tf.bool),","to account for padding input_shape[-2] += self.explicit_padding * 2 super().build(input_shape) self.kernel = tf.Variable(tf.transpose(self.kernel),","@tf.function def serving(self, inputs): output = self.call(input_values=inputs, training=False) return self.serving_output(output) HUBERT_START_DOCSTRING = r\"\"\"","dim % self.groups != 0: raise ValueError( \"Number of groups (\" + str(self.groups)","= -1 if self.axis == -1 else self.axis - 1 group_reduction_axes.pop(axis) mean, variance","transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2EncoderLayerStableLayerNorm with Wav2Vec2->Hubert class TFHubertEncoderLayerStableLayerNorm(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs): super().__init__(**kwargs) self.attention =","TFBaseModelOutput( last_hidden_state=hidden_states, hidden_states=all_hidden_states, attentions=all_self_attentions, ) @keras_serializable class TFHubertMainLayer(tf.keras.layers.Layer): config_class = HubertConfig def __init__(self,","input is None: output[parameter_names[i]] = input else: raise ValueError( f\"Data of type {type(input)}","else: loss = None if not inputs[\"return_dict\"]: output = (logits,) + outputs[1:] return","attn_weights = tf.reshape(layer_head_mask, (1, -1, 1, 1)) * tf.reshape( attn_weights, (bsz, self.num_heads, tgt_len,","% 2 == 0 else 0 def call(self, hidden_states): if self.num_pad_remove > 0:","HubertConfig, **kwargs): super().__init__(**kwargs) self.config = config self.pos_conv_embed = TFHubertPositionalConvEmbedding(config, name=\"pos_conv_embed\") self.layer_norm = tf.keras.layers.LayerNormalization(epsilon=config.layer_norm_eps,","- 1]`. [What are position IDs?](../glossary#position-ids) head_mask (`np.ndarray` or `tf.Tensor` of shape `(num_heads,)`",">>> predicted_ids = tf.argmax(logits, axis=-1) >>> transcription = processor.decode(predicted_ids[0]) >>> # compute loss","num_heads=config.num_attention_heads, dropout=config.attention_dropout, is_decoder=False, name=\"attention\", ) self.dropout = tf.keras.layers.Dropout(config.hidden_dropout) self.layer_norm = tf.keras.layers.LayerNormalization(epsilon=config.layer_norm_eps, name=\"layer_norm\") self.feed_forward","missing layers, and another one for the unexpected layers. \"\"\" signature = dict(inspect.signature(func).parameters)","This argument can be used in eager mode, in graph mode the value","super().__init__(config, *inputs, **kwargs) self.config = config self.hubert = TFHubertMainLayer(config, name=\"hubert\") @add_start_docstrings_to_model_forward(HUBERT_INPUTS_DOCSTRING) @replace_return_docstrings(output_type=TFBaseModelOutput, config_class=_CONFIG_FOR_DOC)","return_dict=return_dict, training=training, ) outputs = self.hubert( input_values=inputs[\"input_values\"], attention_mask=inputs[\"attention_mask\"], token_type_ids=inputs[\"token_type_ids\"], position_ids=inputs[\"position_ids\"], head_mask=inputs[\"head_mask\"], inputs_embeds=inputs[\"inputs_embeds\"], output_attentions=inputs[\"output_attentions\"],","model.\"\"\" import inspect import warnings from typing import Any, Dict, Optional, Tuple, Union","if attention_mask is not None: hidden_states = hidden_states * tf.expand_dims(attention_mask, -1) attention_mask =","0 indicates the head is **masked**. inputs_embeds (`np.ndarray` or `tf.Tensor` of shape `({0},","Optional[bool] = None, training: bool = False, **kwargs: Any, ): inputs = input_values_processing(","training=training) attn_output = tf.matmul(attn_probs, value_states) # The tf.debugging asserts are not compliant with","in `[0, 1]`: - 0 corresponds to a *sentence A* token, - 1","input_values.pop(\"decoder_cached_states\") for k, v in dict(input_values).items(): if isinstance(v, allowed_types) or v is None:","layer can then reuse all cross-attention # key/value_states (first \"if\" case) # if","Wav2Vec2->Hubert class TFHubertWeightNormConv1D(tf.keras.layers.Conv1D): \"\"\"Adapted from https://www.tensorflow.org/probability/api_docs/python/tfp/layers/weight_norm/WeightNorm\"\"\" def __init__(self, filters, kernel_size, groups, explicit_padding, **kwargs):","attention_mask: optional padding mask of the same size as shape, which will prevent","super().__init__(**kwargs) self.conv = TFHubertWeightNormConv1D( filters=config.hidden_size, kernel_size=config.num_conv_pos_embeddings, groups=config.num_conv_pos_embedding_groups, explicit_padding=config.num_conv_pos_embeddings // 2, name=\"conv\", ) self.padding","position_embeddings hidden_states = self.layer_norm(hidden_states) hidden_states = self.dropout(hidden_states, training=training) for i, layer_module in enumerate(self.layer):","disabled in other modes than eager. if tf.executing_eagerly(): tf.debugging.assert_equal( shape_list(attn_output), [bsz * self.num_heads,","for more detail. This argument can be used only in eager mode, in","= tf.keras.constraints.get(gamma_constraint) self._check_axis() def build(self, input_shape): self._check_if_input_shape_is_none(input_shape) self._set_number_of_groups_for_instance_norm(input_shape) self._check_size_of_dimensions(input_shape) self._create_input_spec(input_shape) self._add_gamma_weight(input_shape) self._add_beta_weight(input_shape) self.built","See the License for the specific language governing permissions and # limitations under",">>> from transformers import Wav2Vec2Processor, TFHubertModel >>> from datasets import load_dataset >>> import","future version, use `input_values` instead.\", FutureWarning, ) output[\"input_values\"] = input_values.pop(\"inputs\") if \"decoder_cached_states\" in","values to pair indices return tf.scatter_nd(pair_indices, tf.reshape(values, [-1]), output_shape) # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2._compute_mask_indices","ValueError(f\"Label values must be <= vocab_size: {self.config.vocab_size}\") attention_mask = ( inputs[\"attention_mask\"] if inputs[\"attention_mask\"]","(decoder) save Tuple(tf.Tensor, tf.Tensor) of # all previous decoder key/value_states. Further calls to","HubertConfig, **kwargs): super().__init__(**kwargs) self.attention = TFHubertAttention( embed_dim=config.hidden_size, num_heads=config.num_attention_heads, dropout=config.attention_dropout, is_decoder=False, name=\"attention\", ) self.dropout","= 0.0, is_decoder: bool = False, bias: bool = True, **kwargs, ): super().__init__(**kwargs)","# `config.apply_spec_augment` can set masking to False if not getattr(self.config, \"apply_spec_augment\", True): return","r\"\"\" Args: input_values (`np.ndarray`, `tf.Tensor`, `List[tf.Tensor]` ``Dict[str, tf.Tensor]` or `Dict[str, np.ndarray]` and each","raise ValueError( f\"`config.feat_extract_norm` is {config.feat_extract_norm}, but has to be one of ['group', 'layer']\"","return TFBaseModelOutput( last_hidden_state=hidden_states, hidden_states=all_hidden_states, attentions=all_self_attentions, ) @keras_serializable class TFHubertMainLayer(tf.keras.layers.Layer): config_class = HubertConfig def","not None and type(output[\"args\"]) == tf.Tensor: tensor_name = output[\"args\"].name.split(\":\")[0] output[tensor_name] = output[\"args\"] else:","has to be named accordingly to the parameters name, i.e. `input_values = tf.keras.Input(shape=(128,),","from transformers import Wav2Vec2Processor, TFHubertForCTC >>> from datasets import load_dataset >>> import soundfile","according to [SpecAugment](https://arxiv.org/abs/1904.08779). \"\"\" batch_size, sequence_length, hidden_size = shape_list(hidden_states) # `config.apply_spec_augment` can set","`past_key_values` instead.\", FutureWarning, ) output[\"past_key_values\"] = input_values.pop(\"decoder_cached_states\") for k, v in dict(input_values).items(): if","-100 # when not being attended to labels_mask = tf.cast(labels >= 0, tf.int32)","is {shape_list(attn_weights)}\", ) if attention_mask is not None: # The tf.debugging asserts are","tensors will not be guaranteed during the training. Args: func (`callable`): The callable","# apply SpecAugment along feature axis if self.config.mask_feature_prob > 0: mask_feature_indices = _compute_mask_indices(","# 1D convolutional layer output length formula taken # from https://pytorch.org/docs/stable/generated/torch.nn.Conv1d.html return (input_length","of positions of each input sequence tokens in the position embeddings. Selected in","TFHubertEncoderLayerStableLayerNorm(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs): super().__init__(**kwargs) self.attention = TFHubertAttention( embed_dim=config.hidden_size, num_heads=config.num_attention_heads, dropout=config.attention_dropout,","instead of passing `input_values` you can choose to directly pass an embedded representation.",") class TFHubertForCTC(TFHubertPreTrainedModel): def __init__(self, config: HubertConfig, *inputs, **kwargs): super().__init__(config, *inputs, **kwargs) self.hubert","= None position_embeddings = self.pos_conv_embed(hidden_states) hidden_states = hidden_states + position_embeddings hidden_states = self.layer_norm(hidden_states)","\"args\" not in parameter_names: logger.warning( f\"The parameter {k} does not belongs to the","* sequence_length / mask_length + tf.random.uniform((1,))) num_masked_spans = max(num_masked_spans, min_masks) # make sure","None) return TFBaseModelOutput( last_hidden_state=hidden_states, hidden_states=all_hidden_states, attentions=all_self_attentions, ) # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2EncoderStableLayerNorm with Wav2Vec2->Hubert","ds = load_dataset(\"hf-internal-testing/librispeech_asr_dummy\", \"clean\", split=\"validation\") >>> ds = ds.map(map_to_array) >>> input_values = processor(ds[\"speech\"][0],","axis=2) else: # self_attention key_states = self._shape(self.k_proj(hidden_states), -1, bsz) value_states = self._shape(self.v_proj(hidden_states), -1,","if self.center: self.beta = self.add_weight( shape=shape, name=\"beta\", initializer=self.beta_initializer, regularizer=self.beta_regularizer, constraint=self.beta_constraint, ) else: self.beta","* self.num_heads, tgt_len, src_len], message=f\"Attention weights should be of size {(bsz * self.num_heads,","the method with LayerCall.__call__(args, **kwargs) # So to respect the proper output we","strides=config.conv_stride[layer_id], use_bias=config.conv_bias, name=\"conv\", ) self.activation = get_tf_activation(config.feat_extract_activation) self.layer_norm = TFHubertGroupNorm(groups=self.out_conv_dim, epsilon=config.layer_norm_eps, name=\"layer_norm\") def","compute number of masked spans in batch num_masked_spans = int(mask_prob * sequence_length /","dict, np.ndarray) for k, v in kwargs.items(): if isinstance(v, allowed_types) or v is","TFHubertGroupNorm(tf.keras.layers.Layer): \"\"\" From tensorflow-addons https://www.tensorflow.org/addons/api_docs/python/tfa/layers/GroupNormalization \"\"\" def __init__( self, groups: int = 32,","shape `(num_heads,)` or `(num_layers, num_heads)`, *optional*): Mask to nullify selected heads of the","dropout modules have different behaviors between training and evaluation). \"\"\" @add_start_docstrings( \"The bare","attention_mask: Optional[tf.Tensor] = None, output_attentions: Optional[bool] = False, output_hidden_states: Optional[bool] = False, return_dict:","self._reshape_into_groups(inputs, input_shape, tensor_input_shape) normalized_inputs = self._apply_normalization(reshaped_inputs, input_shape) is_instance_norm = (input_shape[self.axis] // self.groups) ==","bias_initializer=\"zeros\", name=\"intermediate_dense\", ) self.intermediate_act_fn = get_tf_activation(config.hidden_act) self.output_dense = tf.keras.layers.Dense( units=config.hidden_size, kernel_initializer=get_initializer(config.initializer_range), bias_initializer=\"zeros\", name=\"output_dense\",","raise ValueError( \"You are trying to normalize your batch axis. Do you want","... return batch >>> ds = load_dataset(\"hf-internal-testing/librispeech_asr_dummy\", \"clean\", split=\"validation\") >>> ds = ds.map(map_to_array)","# scatter values to pair indices return tf.scatter_nd(pair_indices, tf.reshape(values, [-1]), output_shape) # Copied","not be updated during training. \"\"\" self.hubert.feature_extractor.trainable = False @add_start_docstrings_to_model_forward(HUBERT_INPUTS_DOCSTRING) @replace_return_docstrings(output_type=TFCausalLMOutput, config_class=_CONFIG_FOR_DOC) def","use `past_key_values` instead.\", FutureWarning, ) output[\"past_key_values\"] = input_values.pop(\"decoder_cached_states\") for k, v in dict(input_values).items():","tf.float32), training=inputs[\"training\"] ) if inputs[\"attention_mask\"] is not None: # compute real output lengths","of a list of symbolic inputs, each input has to be named accordingly","input_shape[self.axis] if dim is None: raise ValueError( \"Axis \" + str(self.axis) + \"","tf.Tensor, mask_time_indices: Optional[tf.Tensor] = None): \"\"\" Masks extracted features along time axis and/or","*optional*): Optionally, instead of passing `input_values` you can choose to directly pass an","mask spans for a given shape Args: shape: the the shape for which","\").\" ) if dim % self.groups != 0: raise ValueError( \"Number of groups","tf.keras.layers.Dense( units=config.intermediate_size, kernel_initializer=get_initializer(config.initializer_range), bias_initializer=\"zeros\", name=\"intermediate_dense\", ) self.intermediate_act_fn = get_tf_activation(config.hidden_act) self.output_dense = tf.keras.layers.Dense( units=config.hidden_size,","_check_size_of_dimensions(self, input_shape): dim = input_shape[self.axis] if dim < self.groups: raise ValueError( \"Number of","[`PreTrainedTokenizer.encode`] for details. [What are input IDs?](../glossary#input-ids) attention_mask (`np.ndarray` or `tf.Tensor` of shape","([`PretrainedConfig`]): The config of the running model. **kwargs: The inputs of the model.","= tf.shape(inputs) reshaped_inputs, group_shape = self._reshape_into_groups(inputs, input_shape, tensor_input_shape) normalized_inputs = self._apply_normalization(reshaped_inputs, input_shape) is_instance_norm","coding=utf-8 # Copyright 2021 The Fairseq Authors and the HuggingFace Inc. team. All","self.hubert.feature_extractor.trainable = False @add_start_docstrings_to_model_forward(HUBERT_INPUTS_DOCSTRING) @replace_return_docstrings(output_type=TFCausalLMOutput, config_class=_CONFIG_FOR_DOC) def call( self, input_values: tf.Tensor, attention_mask: Optional[tf.Tensor]","= hidden_states + self.feed_forward(hidden_states) hidden_states = self.final_layer_norm(hidden_states) outputs = (hidden_states,) if output_attentions: outputs","to add this exception if \"args\" in output: if output[\"args\"] is not None","-> tf.Tensor: hidden_states = self.layer_norm(hidden_states) hidden_states = self.projection(hidden_states) hidden_states = self.dropout(hidden_states, training=training) return","you choose this second option, there are three possibilities you can use to","\"The method `freeze_feature_extractor` is deprecated and will be removed in Transformers v5.\" \"Please","class TFHubertSamePadLayer(tf.keras.layers.Layer): def __init__(self, num_conv_pos_embeddings, **kwargs): super().__init__(**kwargs) self.num_pad_remove = 1 if num_conv_pos_embeddings %","a simple interface for downloading and loading pretrained models. \"\"\" config_class = HubertConfig","if cross_attention save Tuple(tf.Tensor, tf.Tensor) of all cross attention key/value_states. # Further calls","_normalize_kernel(self): \"\"\"Generate normalized weights.\"\"\" kernel = tf.nn.l2_normalize(self.weight_v, axis=self.kernel_norm_axes) * tf.transpose(self.weight_g) self.kernel = tf.transpose(kernel)","self.groups) group_shape = tf.stack(group_shape) reshaped_inputs = tf.reshape(inputs, group_shape) return reshaped_inputs, group_shape else: return","input_values = processor(ds[\"speech\"][0], return_tensors=\"tf\").input_values # Batch size 1 >>> logits = model(input_values).logits >>>","return hidden_states # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2LayerNormConvLayer with Wav2Vec2->Hubert class TFHubertLayerNormConvLayer(tf.keras.layers.Layer): def __init__(self, config:","ANY KIND, either express or implied. # See the License for the specific","as a list, tuple or dict in the first positional arguments. This second","< sequence_length uniform_dist = tf.ones((batch_size, sequence_length - (mask_length - 1))) # get random","for downloading and loading pretrained models. \"\"\" config_class = HubertConfig base_model_prefix = \"hubert\"","this function will disable the gradient computation for the feature encoder so that","= 0.0 input_values = tf.convert_to_tensor(np.random.rand(1, 16000), tf.float32) dummy_inputs = { \"input_values\": input_values, \"attention_mask\":","self.num_heads, tgt_len, src_len) ) attn_weights = tf.reshape(attn_weights, (bsz * self.num_heads, tgt_len, src_len)) attn_probs","each input has to be named accordingly to the parameters name, i.e. `input_values","= tf.keras.layers.Dropout(config.hidden_dropout) self.layer = [ TFHubertEncoderLayerStableLayerNorm(config, name=f\"layers.{i}\") for i in range(config.num_hidden_layers) ] def","broadcast_shape = self._create_broadcast_shape(input_shape) gamma = None beta = None if self.scale: gamma =","{shape_list(attn_weights)}\", ) if attention_mask is not None: # The tf.debugging asserts are not","axis=-1), indices_shape), [1, -1] ) # transform batch_indices to pair_indices pair_indices = tf.transpose(tf.concat([broad_casted_batch_dims,","is always `None` past_key_value = (key_states, value_states) proj_shape = (bsz * self.num_heads, -1,","bias_initializer=\"zeros\", name=\"output_dense\", ) self.output_dropout = tf.keras.layers.Dropout(config.hidden_dropout) def call(self, hidden_states: tf.Tensor, training: bool =","which to compute masks. should be of size 2 where first element is","\"scale\": self.scale, \"beta_initializer\": tf.keras.initializers.serialize(self.beta_initializer), \"gamma_initializer\": tf.keras.initializers.serialize(self.gamma_initializer), \"beta_regularizer\": tf.keras.regularizers.serialize(self.beta_regularizer), \"gamma_regularizer\": tf.keras.regularizers.serialize(self.gamma_regularizer), \"beta_constraint\": tf.keras.constraints.serialize(self.beta_constraint), \"gamma_constraint\":","being attended to labels_mask = tf.cast(labels >= 0, tf.int32) target_lengths = tf.reduce_sum(labels_mask, axis=-1)","FutureWarning, ) self.freeze_feature_encoder() def freeze_feature_encoder(self): \"\"\" Calling this function will disable the gradient","of the inputs. Indices are selected in `[0, 1]`: - 0 corresponds to","name=f\"layers.{i}\") for i in range(config.num_hidden_layers) ] def call( self, hidden_states: tf.Tensor, attention_mask: Optional[tf.Tensor]","one of ['group', 'layer']\" ) self.conv_layers = conv_layers def call(self, input_values): hidden_states =","super().__init__(**kwargs) self.in_conv_dim = config.conv_dim[layer_id] if layer_id > 0 else 1 self.out_conv_dim = config.conv_dim[layer_id]","\"You are trying to normalize your batch axis. Do you want to \"","obtained using [`BertTokenizer`]. See [`PreTrainedTokenizer.__call__`] and [`PreTrainedTokenizer.encode`] for details. [What are input IDs?](../glossary#input-ids)","= input_shape[self.axis] // self.groups group_shape.insert(self.axis, self.groups) group_shape = tf.stack(group_shape) reshaped_inputs = tf.reshape(inputs, group_shape)","output_attentions=output_attentions, output_hidden_states=output_hidden_states, return_dict=return_dict, training=training, kwargs_call=kwargs, ) hidden_states = self.feature_extractor( tf.cast(inputs[\"input_values\"], tf.float32), training=inputs[\"training\"] )","minimum number of masked spans Adapted from [fairseq's data_utils.py](https://github.com/pytorch/fairseq/blob/e0788f7007a8473a76db573985031f3c94201e79/fairseq/data/data_utils.py#L376). \"\"\" batch_size, sequence_length =","= self.add_weight( shape=shape, name=\"gamma\", initializer=self.gamma_initializer, regularizer=self.gamma_regularizer, constraint=self.gamma_constraint, ) else: self.gamma = None def","map_to_array(batch): ... speech, _ = sf.read(batch[\"file\"]) ... batch[\"speech\"] = speech ... return batch","= False, training: bool = False, ) -> Tuple[tf.Tensor]: attn_residual = hidden_states hidden_states","= shape if mask_length < 1: raise ValueError(\"`mask_length` has to be bigger than","# can concat previous decoder key/value_states to current projected key/value_states (third \"elif\" case)","only {allowed_types} is accepted for {parameter_names[i]}.\" ) elif isinstance(input_values, (dict, BatchEncoding)): if \"inputs\"","on CPU. If you wish \" \"to train/fine-tine this model, you need a","def _normalize_kernel(self): \"\"\"Generate normalized weights.\"\"\" kernel = tf.nn.l2_normalize(self.weight_v, axis=self.kernel_norm_axes) * tf.transpose(self.weight_g) self.kernel =","the model. Initializing with a config file does not load the weights associated","self, hidden_states: tf.Tensor, attention_mask: Optional[tf.Tensor] = None, output_attentions: Optional[bool] = False, output_hidden_states: Optional[bool]","super().__init__(**kwargs) self.layer_norm = tf.keras.layers.LayerNormalization(epsilon=config.layer_norm_eps, name=\"layer_norm\") self.projection = tf.keras.layers.Dense( units=config.hidden_size, kernel_initializer=get_initializer(config.initializer_range), bias_initializer=\"zeros\", name=\"projection\", )","= tf.keras.regularizers.get(beta_regularizer) self.gamma_regularizer = tf.keras.regularizers.get(gamma_regularizer) self.beta_constraint = tf.keras.constraints.get(beta_constraint) self.gamma_constraint = tf.keras.constraints.get(gamma_constraint) self._check_axis() def","to general usage and behavior. <Tip> TF 2.0 models accepts two formats as","inputs[\"output_attentions\"] else self.config.output_attentions ) inputs[\"return_dict\"] = inputs[\"return_dict\"] if inputs[\"return_dict\"] else self.config.return_dict outputs =","= tf.reshape(layer_head_mask, (1, -1, 1, 1)) * tf.reshape( attn_weights, (bsz, self.num_heads, tgt_len, src_len)","trick will do for now - see https://github.com/tensorflow/tensorflow/issues/9260 for more info \"\"\" z","writing, software # distributed under the License is distributed on an \"AS IS\"","config_class=_CONFIG_FOR_DOC) def call( self, input_values: tf.Tensor, attention_mask: Optional[tf.Tensor] = None, token_type_ids: Optional[tf.Tensor] =","attentions=encoder_outputs.attentions, ) class TFHubertPreTrainedModel(TFPreTrainedModel): \"\"\" An abstract class to handle weights initialization and","def __init__(self, config: HubertConfig, *inputs, **kwargs): super().__init__(config, *inputs, **kwargs) self.hubert = TFHubertMainLayer(config, name=\"hubert\")","tf.constant(1.0) mask = tf.cast(mask, dtype=one_cst.dtype) expanded_mask = tf.tile(mask[:, None, None, :], (1, 1,","output[k] = v else: raise ValueError(f\"Data of type {type(v)} is not allowed only","= config.conv_dim[layer_id] self.conv = tf.keras.layers.Conv1D( filters=self.out_conv_dim, kernel_size=config.conv_kernel[layer_id], strides=config.conv_stride[layer_id], use_bias=config.conv_bias, name=\"conv\", ) self.layer_norm =","related to general usage and behavior. <Tip> TF 2.0 models accepts two formats","not in parameter_names and \"args\" not in parameter_names: logger.warning( f\"The parameter {k} does","else: self.encoder = TFHubertEncoder(config, name=\"encoder\") def build(self, input_shape: tf.TensorShape): self.masked_spec_embed = self.add_weight( shape=(self.config.hidden_size,),","groups (\" + str(self.groups) + \") must be a \" \"multiple of the","position_ids=inputs[\"position_ids\"], head_mask=inputs[\"head_mask\"], inputs_embeds=inputs[\"inputs_embeds\"], output_attentions=inputs[\"output_attentions\"], output_hidden_states=inputs[\"output_hidden_states\"], return_dict=inputs[\"return_dict\"], training=inputs[\"training\"], ) return outputs def serving_output(self, output):","formula output_lengths = self._get_feat_extract_output_lengths(tf.reduce_sum(inputs[\"attention_mask\"], -1)) attention_mask = tf.sequence_mask( output_lengths, maxlen=shape_list(hidden_states)[1], dtype=hidden_states.dtype ) hidden_states","language modeling loss. Indices should be in `[-100, 0, ..., config.vocab_size]` (see `input_values`","`model({\"input_values\": input_values, \"token_type_ids\": token_type_ids})` </Tip> Args: config ([`HubertConfig`]): Model configuration class with all","name=\"v_proj\") self.out_proj = tf.keras.layers.Dense(embed_dim, use_bias=bias, name=\"out_proj\") def _shape(self, tensor: tf.Tensor, seq_len: int, bsz:","last layer if output_hidden_states: all_hidden_states = all_hidden_states + (hidden_states,) if not return_dict: return","shape = (dim,) if self.scale: self.gamma = self.add_weight( shape=shape, name=\"gamma\", initializer=self.gamma_initializer, regularizer=self.gamma_regularizer, constraint=self.gamma_constraint,",") self.scaling = self.head_dim**-0.5 self.is_decoder = is_decoder self.k_proj = tf.keras.layers.Dense(embed_dim, use_bias=bias, name=\"k_proj\") self.q_proj","input Tensors IN THE ORDER given in the docstring: `model([input_values, attention_mask])` or `model([input_values,","= self.q_proj(hidden_states) * self.scaling # get key, value proj if is_cross_attention and past_key_value","self.activation(hidden_states) return hidden_states # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2GroupNormConvLayer with Wav2Vec2->Hubert class TFHubertGroupNormConvLayer(tf.keras.layers.Layer): def __init__(self,","allowed_types = (tf.Tensor, bool, int, ModelOutput, tuple, list, dict, np.ndarray) for k, v","return ((loss,) + output) if loss is not None else output return TFCausalLMOutput(","src_len)) return attn_output, attn_weights, past_key_value # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2FeedForward with Wav2Vec2->Hubert class TFHubertFeedForward(tf.keras.layers.Layer):","# generate indices & apply SpecAugment along time axis mask_time_indices = _compute_mask_indices( (batch_size,","tuple(v for v in [hidden_states, all_hidden_states, all_self_attentions] if v is not None) return","[`PreTrainedTokenizer.__call__`] and [`PreTrainedTokenizer.encode`] for details. [What are input IDs?](../glossary#input-ids) attention_mask (`np.ndarray` or `tf.Tensor`","config_class = HubertConfig def __init__(self, config: HubertConfig, **kwargs): super().__init__(**kwargs) self.config = config self.feature_extractor","self.feature_extractor = TFHubertFeatureEncoder(config, name=\"feature_extractor\") self.feature_projection = TFHubertFeatureProjection(config, name=\"feature_projection\") if config.do_stable_layer_norm: self.encoder = TFHubertEncoderStableLayerNorm(config,","in the docstring: `model([input_values, attention_mask])` or `model([input_values, attention_mask, token_type_ids])` - a dictionary with","in Transformers v5. \" f\"Use `{self.__class__.__bases__[0].__name__}` instead.\", FutureWarning, ) class TFHubertFeatureProjection(tf.keras.layers.Layer): def __init__(self,","= tf.reshape( tf.broadcast_to(tf.expand_dims(tf.range(indices_shape[0]), axis=-1), indices_shape), [1, -1] ) # transform batch_indices to pair_indices","Tuple[tf.Tensor]: attn_residual = hidden_states hidden_states, attn_weights, _ = self.attention( hidden_states, attention_mask=attention_mask, training=training )","of groups (\" + str(self.groups) + \") cannot be \" \"more than the","all_self_attentions] if v is not None) return TFBaseModelOutput( last_hidden_state=hidden_states, hidden_states=all_hidden_states, attentions=all_self_attentions, ) #","self.config.output_attentions else None return TFBaseModelOutput(last_hidden_state=output.last_hidden_state, hidden_states=hs, attentions=attns) @add_start_docstrings( \"\"\"TFHubert Model with a `language","**kwargs) warnings.warn( f\"The class `{self.__class__.__name__}` has been depreciated \" \"and will be removed","0 else 1 self.out_conv_dim = config.conv_dim[layer_id] self.conv = tf.keras.layers.Conv1D( filters=self.out_conv_dim, kernel_size=config.conv_kernel[layer_id], strides=config.conv_stride[layer_id], use_bias=config.conv_bias,","at https://huggingface.co/models?filter=hubert ] LARGE_NEGATIVE = -1e8 # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.input_values_processing def input_values_processing(func, config,","tensor_input_shape) normalized_inputs = self._apply_normalization(reshaped_inputs, input_shape) is_instance_norm = (input_shape[self.axis] // self.groups) == 1 if","file except in compliance with the License. # You may obtain a copy","self.scale: self.gamma = self.add_weight( shape=shape, name=\"gamma\", initializer=self.gamma_initializer, regularizer=self.gamma_regularizer, constraint=self.gamma_constraint, ) else: self.gamma =","(hidden_states,) if output_attentions: outputs += (attn_weights,) return outputs # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2EncoderLayerStableLayerNorm with","config.feat_extract_norm == \"layer\": conv_layers = [ TFHubertLayerNormConvLayer(config, layer_id=i, name=f\"conv_layers.{i}\") for i in range(config.num_feat_extract_layers)","value_states) # The tf.debugging asserts are not compliant with XLA then they #","0, **kwargs: Any) -> None: super().__init__(**kwargs) self.in_conv_dim = config.conv_dim[layer_id] if layer_id > 0","int, bsz: int): return tf.transpose(tf.reshape(tensor, (bsz, seq_len, self.num_heads, self.head_dim)), (0, 2, 1, 3))","*inputs, **kwargs): super().__init__(config, *inputs, **kwargs) self.config = config self.hubert = TFHubertMainLayer(config, name=\"hubert\") @add_start_docstrings_to_model_forward(HUBERT_INPUTS_DOCSTRING)","position IDs?](../glossary#position-ids) head_mask (`np.ndarray` or `tf.Tensor` of shape `(num_heads,)` or `(num_layers, num_heads)`, *optional*):","tf.reshape(values, [-1]), output_shape) # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2._compute_mask_indices def _compute_mask_indices( shape: Tuple[int, int], mask_prob:","to [SpecAugment](https://arxiv.org/abs/1904.08779). \"\"\" batch_size, sequence_length, hidden_size = shape_list(hidden_states) # `config.apply_spec_augment` can set masking","\" \"to train/fine-tine this model, you need a GPU or a TPU\" )","enumerate(input_values): # EagerTensors don't allow to use the .name property so we check","overlaps, the actual number will be smaller (unless no_overlap is True) mask_length: size","+ \").\" ) if dim % self.groups != 0: raise ValueError( \"Number of","processor(ds[\"speech\"][0], return_tensors=\"tf\").input_values # Batch size 1 >>> logits = model(input_values).logits >>> predicted_ids =","hidden_states: tf.Tensor) -> tf.Tensor: hidden_states = self.conv(hidden_states) hidden_states = self.layer_norm(hidden_states) hidden_states = self.activation(hidden_states)","{self.embed_dim}\" f\" and `num_heads`: {num_heads}).\" ) self.scaling = self.head_dim**-0.5 self.is_decoder = is_decoder self.k_proj","proj_shape) value_states = tf.reshape(value_states, proj_shape) src_len = shape_list(key_states)[1] attn_weights = tf.matmul(query_states, key_states, transpose_b=True)","filters=self.out_conv_dim, kernel_size=config.conv_kernel[layer_id], strides=config.conv_stride[layer_id], use_bias=config.conv_bias, name=\"conv\", ) self.activation = get_tf_activation(config.feat_extract_activation) def call(self, hidden_states: tf.Tensor)","1 else: axis = -1 if self.axis == -1 else self.axis - 1","convert `input_values` indices into associated vectors than the model's internal embedding lookup matrix.","logger.warning( f\"The parameter {k} does not belongs to the parameter list {parameter_names} and","(layer_outputs[1],) # Add last layer if output_hidden_states: all_hidden_states = all_hidden_states + (hidden_states,) if","output_attentions: Optional[bool] = False, training: bool = False, ) -> Tuple[tf.Tensor]: attn_residual =","the tensors will not be guaranteed during the training. Args: func (`callable`): The","hidden_states: tf.Tensor, mask_time_indices: Optional[tf.Tensor] = None): \"\"\" Masks extracted features along time axis",") self.activation = get_tf_activation(config.feat_extract_activation) def call(self, hidden_states: tf.Tensor) -> tf.Tensor: hidden_states = self.conv(hidden_states)","tensor_input_shape = tf.shape(inputs) reshaped_inputs, group_shape = self._reshape_into_groups(inputs, input_shape, tensor_input_shape) normalized_inputs = self._apply_normalization(reshaped_inputs, input_shape)","can be used in eager mode, in graph mode the value will always","input_shape) is_instance_norm = (input_shape[self.axis] // self.groups) == 1 if not is_instance_norm: outputs =","**kwargs: Any) -> None: super().__init__(**kwargs) if config.feat_extract_norm == \"group\": conv_layers = [TFHubertGroupNormConvLayer(config, layer_id=0,","sequence_length = shape if mask_length < 1: raise ValueError(\"`mask_length` has to be bigger","elif is_cross_attention: # cross_attentions key_states = self._shape(self.k_proj(key_value_states), -1, bsz) value_states = self._shape(self.v_proj(key_value_states), -1,","16000), tf.float32) dummy_inputs = { \"input_values\": input_values, \"attention_mask\": tf.cast(tf.not_equal(input_values, pad_token), tf.float32), } return","normalized_inputs = self._apply_normalization(reshaped_inputs, input_shape) is_instance_norm = (input_shape[self.axis] // self.groups) == 1 if not",") hidden_states = tf.where(mask_feature_indices[:, tf.newaxis, :], hidden_states, 0) return hidden_states def call( self,","__init__(self, num_conv_pos_embeddings, **kwargs): super().__init__(**kwargs) self.num_pad_remove = 1 if num_conv_pos_embeddings % 2 == 0","== 0: raise ValueError( \"You are trying to normalize your batch axis. Do","is currently not implemented. The gumbel-max trick will do for now - see","tf.keras.layers.LayerNormalization(epsilon=config.layer_norm_eps, name=\"layer_norm\") self.dropout = tf.keras.layers.Dropout(config.hidden_dropout) self.layer = [ TFHubertEncoderLayerStableLayerNorm(config, name=f\"layers.{i}\") for i in","not inputs[\"return_dict\"]: return (hidden_states,) + encoder_outputs[1:] return TFBaseModelOutput( last_hidden_state=hidden_states, hidden_states=encoder_outputs.hidden_states, attentions=encoder_outputs.attentions, ) class","input_values): hidden_states = tf.expand_dims(input_values, -1) for conv_layer in self.conv_layers: hidden_states = conv_layer(hidden_states) return","\"\"\" @add_start_docstrings( \"The bare TFHubert Model transformer outputing raw hidden-states without any specific","tf.nn.moments(reshaped_inputs, group_reduction_axes, keepdims=True) gamma, beta = self._get_reshaped_weights(input_shape) normalized_inputs = tf.nn.batch_normalization( reshaped_inputs, mean=mean, variance=variance,","input sequence tokens in the position embeddings. Selected in the range `[0, config.max_position_embeddings","type {type(v)} is not allowed only {allowed_types} is accepted for {k}.\") else: if","the specific language governing permissions and # limitations under the License. \"\"\" TensorFlow","self.in_conv_dim = config.conv_dim[layer_id] if layer_id > 0 else 1 self.out_conv_dim = config.conv_dim[layer_id] self.conv","= \"ones\", beta_regularizer: tf.keras.regularizers.Regularizer = None, gamma_regularizer: tf.keras.regularizers.Regularizer = None, beta_constraint: tf.keras.constraints.Constraint =","Optional[tf.Tensor] = None, output_hidden_states: Optional[tf.Tensor] = None, return_dict: Optional[bool] = None, training: bool","elif isinstance(input, allowed_types) or input is None: output[parameter_names[i]] = input else: raise ValueError(","from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2EncoderStableLayerNorm with Wav2Vec2->Hubert class TFHubertEncoderStableLayerNorm(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs): super().__init__(**kwargs) self.config","if key_value_states are provided this layer is used as a cross-attention layer #","[bsz * self.num_heads, tgt_len, src_len], message=f\"Attention weights should be of size {(bsz *","2021 The Fairseq Authors and the HuggingFace Inc. team. All rights reserved. #","group_reduction_axes, keepdims=True) gamma, beta = self._get_reshaped_weights(input_shape) normalized_inputs = tf.nn.batch_normalization( reshaped_inputs, mean=mean, variance=variance, scale=gamma,","self.layer_norm(hidden_states) hidden_states = self.activation(hidden_states) return hidden_states # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2GroupNormConvLayer with Wav2Vec2->Hubert class","labels (`tf.Tensor` or `np.ndarray` of shape `(batch_size, sequence_length)`, *optional*): Labels for computing the","hidden_states # Copied from transformers.models.bart.modeling_tf_bart.TFBartAttention with TFBart->TFHubert class TFHubertAttention(tf.keras.layers.Layer): \"\"\"Multi-headed attention from \"Attention","states of all layers. See `hidden_states` under returned tensors for more detail. This","`{self.__class__.__name__}` has been depreciated \" \"and will be removed in Transformers v5. \"","method which currently requires having all the tensors in the first argument of",">>> target_transcription = \"A MAN SAID TO THE UNIVERSE SIR I EXIST\" >>>","tf.Tensor, attention_mask: Optional[tf.Tensor] = None, output_attentions: Optional[bool] = False, output_hidden_states: Optional[bool] = False,","the vocabulary. Indices can be obtained using [`BertTokenizer`]. See [`PreTrainedTokenizer.__call__`] and [`PreTrainedTokenizer.encode`] for","= TFHubertFeatureProjection(config, name=\"feature_projection\") if config.do_stable_layer_norm: self.encoder = TFHubertEncoderStableLayerNorm(config, name=\"encoder\") else: self.encoder = TFHubertEncoder(config,","= None, labels: Optional[tf.Tensor] = None, output_hidden_states: Optional[bool] = None, return_dict: Optional[bool] =","to False if not getattr(self.config, \"apply_spec_augment\", True): return hidden_states if mask_time_indices is not","== -1 else self.axis - 1 else: axis = -1 if self.axis ==","set to `-100` are ignored (masked), the loss is only computed for the","mask_length > sequence_length: num_masked_spans = sequence_length // mask_length # SpecAugment mask to fill","self.config.return_dict outputs = self.hubert( input_values=inputs[\"input_values\"], attention_mask=inputs[\"attention_mask\"], token_type_ids=inputs[\"token_type_ids\"], position_ids=inputs[\"position_ids\"], head_mask=inputs[\"head_mask\"], inputs_embeds=inputs[\"inputs_embeds\"], output_attentions=inputs[\"output_attentions\"], output_hidden_states=inputs[\"output_hidden_states\"], return_dict=inputs[\"return_dict\"],","message=f\"`attn_output` should be of size {(bsz, self.num_heads, tgt_len, self.head_dim)}, but is {shape_list(attn_output)}\", )","training=training, ) outputs = self.hubert( input_values=inputs[\"input_values\"], attention_mask=inputs[\"attention_mask\"], token_type_ids=inputs[\"token_type_ids\"], position_ids=inputs[\"position_ids\"], head_mask=inputs[\"head_mask\"], inputs_embeds=inputs[\"inputs_embeds\"], output_attentions=inputs[\"output_attentions\"], output_hidden_states=inputs[\"output_hidden_states\"],","broadcast_shape # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2WeightNormConv1D with Wav2Vec2->Hubert class TFHubertWeightNormConv1D(tf.keras.layers.Conv1D): \"\"\"Adapted from https://www.tensorflow.org/probability/api_docs/python/tfp/layers/weight_norm/WeightNorm\"\"\" def","training: bool = False, ) -> Tuple[tf.Tensor]: attn_residual = hidden_states hidden_states = self.layer_norm(hidden_states)","self.layer_norm(hidden_states) if output_hidden_states: all_hidden_states = all_hidden_states + (hidden_states,) if not return_dict: return tuple(v","* self.num_heads, tgt_len, src_len)) attn_probs = self.dropout(attn_weights, training=training) attn_output = tf.matmul(attn_probs, value_states) #","[What are input IDs?](../glossary#input-ids) attention_mask (`np.ndarray` or `tf.Tensor` of shape `({0})`, *optional*): Mask","+ [ TFHubertNoLayerNormConvLayer(config, layer_id=i + 1, name=f\"conv_layers.{i+1}\") for i in range(config.num_feat_extract_layers - 1)","tf.keras.constraints.Constraint = None, gamma_constraint: tf.keras.constraints.Constraint = None, **kwargs, ): super().__init__(**kwargs) self.supports_masking = True","tf.reshape(self.beta, broadcast_shape) return gamma, beta def _check_if_input_shape_is_none(self, input_shape): dim = input_shape[self.axis] if dim","None, past_key_value: Optional[Tuple[Tuple[tf.Tensor]]] = None, attention_mask: Optional[tf.Tensor] = None, layer_head_mask: Optional[tf.Tensor] = None,","model weights. \"\"\" HUBERT_INPUTS_DOCSTRING = r\"\"\" Args: input_values (`np.ndarray`, `tf.Tensor`, `List[tf.Tensor]` ``Dict[str, tf.Tensor]`","self.attention = TFHubertAttention( embed_dim=config.hidden_size, num_heads=config.num_attention_heads, dropout=config.attention_dropout, is_decoder=False, name=\"attention\", ) self.dropout = tf.keras.layers.Dropout(config.hidden_dropout) self.layer_norm","call(self, inputs): if not self.initialized: self._init_norm() self.initialized = True self._normalize_kernel() padded_inputs = tf.pad(inputs,","self.conv = tf.keras.layers.Conv1D( filters=self.out_conv_dim, kernel_size=config.conv_kernel[layer_id], strides=config.conv_stride[layer_id], use_bias=config.conv_bias, name=\"conv\", ) self.layer_norm = tf.keras.layers.LayerNormalization(name=\"layer_norm\", epsilon=config.layer_norm_eps)","keyword arguments (like PyTorch models), or - having all inputs as a list,","= True, beta_initializer: tf.keras.initializers.Initializer = \"zeros\", gamma_initializer: tf.keras.initializers.Initializer = \"ones\", beta_regularizer: tf.keras.regularizers.Regularizer =","False, ) -> Union[TFBaseModelOutput, Tuple[tf.Tensor]]: all_hidden_states = () if output_hidden_states else None all_self_attentions","1, tgt_seq_len, src_seq_len]`. \"\"\" src_len = shape_list(mask)[1] tgt_len = tgt_len if tgt_len is","\"zeros\", gamma_initializer: tf.keras.initializers.Initializer = \"ones\", beta_regularizer: tf.keras.regularizers.Regularizer = None, gamma_regularizer: tf.keras.regularizers.Regularizer = None,","Optional[tf.Tensor] = None, position_ids: Optional[tf.Tensor] = None, head_mask: Optional[tf.Tensor] = None, inputs_embeds: Optional[tf.Tensor]","\"\"\" Categorical sampling without replacement is currently not implemented. The gumbel-max trick will","last_hidden_state=hidden_states, hidden_states=all_hidden_states, attentions=all_self_attentions, ) # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2EncoderStableLayerNorm with Wav2Vec2->Hubert class TFHubertEncoderStableLayerNorm(tf.keras.layers.Layer): def","used instead. return_dict (`bool`, *optional*): Whether or not to return a [`~file_utils.ModelOutput`] instead","with Wav2Vec2->Hubert class TFHubertEncoderLayer(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs): super().__init__(**kwargs) self.attention = TFHubertAttention(","feature axis if self.config.mask_feature_prob > 0: mask_feature_indices = _compute_mask_indices( (batch_size, hidden_size), mask_prob=self.config.mask_feature_prob, mask_length=self.config.mask_feature_length,","super().__init__(**kwargs) self.attention = TFHubertAttention( embed_dim=config.hidden_size, num_heads=config.num_attention_heads, dropout=config.attention_dropout, is_decoder=False, name=\"attention\", ) self.dropout = tf.keras.layers.Dropout(config.hidden_dropout)","1e-3, center: bool = True, scale: bool = True, beta_initializer: tf.keras.initializers.Initializer = \"zeros\",","= None, beta_constraint: tf.keras.constraints.Constraint = None, gamma_constraint: tf.keras.constraints.Constraint = None, **kwargs, ): super().__init__(**kwargs)","reshaped_inputs, group_shape = self._reshape_into_groups(inputs, input_shape, tensor_input_shape) normalized_inputs = self._apply_normalization(reshaped_inputs, input_shape) is_instance_norm = (input_shape[self.axis]","is_instance_norm: outputs = tf.reshape(normalized_inputs, tensor_input_shape) else: outputs = normalized_inputs return outputs def get_config(self):","self.layer_norm(hidden_states) hidden_states = hidden_states + self.feed_forward(hidden_states) hidden_states = self.final_layer_norm(hidden_states) outputs = (hidden_states,) if","# Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2LayerNormConvLayer with Wav2Vec2->Hubert class TFHubertLayerNormConvLayer(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, layer_id:","tgt_len, src_len)}, but is {shape_list(attention_mask)}\", ) attention_mask = tf.cast(attention_mask, dtype=attn_weights.dtype) attn_weights = tf.reshape(attn_weights,","i.e. `input_values = tf.keras.Input(shape=(128,), dtype='float32', name=\"input_values\")` otherwise the order of the tensors will","Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2._scatter_values_on_batch_indices def _scatter_values_on_batch_indices(values, batch_indices, output_shape): \"\"\" Scatter function as in PyTorch","= tf.pad(inputs, ((0, 0), (self.explicit_padding, self.explicit_padding), (0, 0))) output = super().call(padded_inputs) return output","Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2FeedForward with Wav2Vec2->Hubert class TFHubertFeedForward(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs): super().__init__(**kwargs)","( inputs[\"attention_mask\"] if inputs[\"attention_mask\"] is not None else tf.ones_like(inputs[\"input_values\"], dtype=tf.float32) ) input_lengths =","not belongs to the parameter list {parameter_names} and will be ignored.\" ) continue","the model weights. \"\"\" HUBERT_INPUTS_DOCSTRING = r\"\"\" Args: input_values (`np.ndarray`, `tf.Tensor`, `List[tf.Tensor]` ``Dict[str,","k in [\"return_dict\", \"output_attentions\", \"output_hidden_states\", \"use_cache\"] } output.update(booleans_processing(config=config, **boolean_dict)) return output # Copied","super().__init__(**kwargs) self.intermediate_dropout = tf.keras.layers.Dropout(config.activation_dropout) self.intermediate_dense = tf.keras.layers.Dense( units=config.intermediate_size, kernel_initializer=get_initializer(config.initializer_range), bias_initializer=\"zeros\", name=\"intermediate_dense\", ) self.intermediate_act_fn","filters=self.out_conv_dim, kernel_size=config.conv_kernel[layer_id], strides=config.conv_stride[layer_id], use_bias=config.conv_bias, name=\"conv\", ) self.activation = get_tf_activation(config.feat_extract_activation) self.layer_norm = TFHubertGroupNorm(groups=self.out_conv_dim, epsilon=config.layer_norm_eps,","!= self.embed_dim: raise ValueError( f\"embed_dim must be divisible by num_heads (got `embed_dim`: {self.embed_dim}\"","inputs = input_values_processing( func=self.call, config=self.config, input_values=input_values, attention_mask=attention_mask, token_type_ids=token_type_ids, position_ids=position_ids, head_mask=head_mask, inputs_embeds=inputs_embeds, output_attentions=output_attentions, output_hidden_states=output_hidden_states,","only computed for the tokens with labels in `[0, ..., config.vocab_size]` Returns: Example:","name=\"layer_norm\") def call(self, hidden_states: tf.Tensor) -> tf.Tensor: hidden_states = self.conv(hidden_states) hidden_states = self.layer_norm(hidden_states)","rights reserved. # # Licensed under the Apache License, Version 2.0 (the \"License\");","None, position_ids: Optional[tf.Tensor] = None, head_mask: Optional[tf.Tensor] = None, inputs_embeds: Optional[tf.Tensor] = None,","hidden_states class TFHubertFeatureEncoder(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs: Any) -> None: super().__init__(**kwargs) if","length of mask span to mask approximately this percentage of all elements. however",") self.bias = self.add_weight(name=\"bias\", shape=(self.filters,), initializer=\"zeros\", trainable=True) def call(self, inputs): if not self.initialized:","layers, and another one for the unexpected layers. \"\"\" signature = dict(inspect.signature(func).parameters) signature.pop(\"kwargs\",","inputs[\"attention_mask\"] is not None: # compute real output lengths according to convolution formula","hidden_states = self.final_layer_norm(hidden_states) outputs = (hidden_states,) if output_attentions: outputs += (attn_weights,) return outputs","attention_mask, token_type_ids])` - a dictionary with one or several input Tensors associated to","None: super().__init__(**kwargs) self.conv = TFHubertWeightNormConv1D( filters=config.hidden_size, kernel_size=config.num_conv_pos_embeddings, groups=config.num_conv_pos_embedding_groups, explicit_padding=config.num_conv_pos_embeddings // 2, name=\"conv\", )","`input_values` indices into associated vectors than the model's internal embedding lookup matrix. output_attentions","attention_mask=attention_mask, training=training ) hidden_states = self.dropout(hidden_states, training=training) hidden_states = attn_residual + hidden_states hidden_states","else src_len one_cst = tf.constant(1.0) mask = tf.cast(mask, dtype=one_cst.dtype) expanded_mask = tf.tile(mask[:, None,","Optional[bool] = True, training: Optional[bool] = False, ) -> Union[TFBaseModelOutput, Tuple[tf.Tensor]]: all_hidden_states =","tf.keras.layers.Dropout(config.final_dropout) self.lm_head = tf.keras.layers.Dense(config.vocab_size, name=\"lm_head\") def freeze_feature_extractor(self): \"\"\" Calling this function will disable","f\" and `num_heads`: {num_heads}).\" ) self.scaling = self.head_dim**-0.5 self.is_decoder = is_decoder self.k_proj =","Optional[bool] = False, output_hidden_states: Optional[bool] = False, return_dict: Optional[bool] = True, training: Optional[bool]","[TFHubertGroupNormConvLayer(config, layer_id=0, name=f\"conv_layers.{0}\")] + [ TFHubertNoLayerNormConvLayer(config, layer_id=i + 1, name=f\"conv_layers.{i+1}\") for i in","been depreciated \" \"and will be removed in Transformers v5. \" f\"Use `{self.__class__.__bases__[0].__name__}`","self.activation = get_tf_activation(config.feat_extract_activation) def call(self, hidden_states: tf.Tensor) -> tf.Tensor: hidden_states = self.conv(hidden_states) hidden_states","you want to \" \"use tf.layer.batch_normalization instead\" ) def _create_input_spec(self, input_shape): dim =","embed_dim = shape_list(hidden_states) # get query proj query_states = self.q_proj(hidden_states) * self.scaling #","kernel_size=kernel_size, groups=groups, padding=\"valid\", use_bias=True, bias_initializer=\"he_normal\", **kwargs, ) self.explicit_padding = explicit_padding self.filter_axis = 2","for description) dropout_probability = np.random.uniform(0, 1) if training and (dropout_probability < self.config.layerdrop): #","and the HuggingFace Inc. team. All rights reserved. # # Licensed under the","be disabled in other modes than eager. if tf.executing_eagerly(): tf.debugging.assert_equal( shape_list(layer_head_mask), [self.num_heads], message=f\"Head","units=config.hidden_size, kernel_initializer=get_initializer(config.initializer_range), bias_initializer=\"zeros\", name=\"projection\", ) self.dropout = tf.keras.layers.Dropout(rate=config.feat_proj_dropout) def call(self, hidden_states: tf.Tensor, training:","TFHubertLayerNormConvLayer(config, layer_id=i, name=f\"conv_layers.{i}\") for i in range(config.num_feat_extract_layers) ] else: raise ValueError( f\"`config.feat_extract_norm` is",": - a single Tensor with `input_values` only and nothing else: `model(inputs_ids)` -","trying to normalize your batch axis. Do you want to \" \"use tf.layer.batch_normalization","add this exception if \"args\" in output: if output[\"args\"] is not None and","None) return TFBaseModelOutput( last_hidden_state=hidden_states, hidden_states=all_hidden_states, attentions=all_self_attentions, ) @keras_serializable class TFHubertMainLayer(tf.keras.layers.Layer): config_class = HubertConfig","self.layer_norm(hidden_states) hidden_states, attn_weights, _ = self.attention( hidden_states, attention_mask=attention_mask, training=training ) hidden_states = self.dropout(hidden_states,","is_instance_norm: broadcast_shape[self.axis] = input_shape[self.axis] // self.groups broadcast_shape.insert(self.axis, self.groups) else: broadcast_shape[self.axis] = self.groups return","the first positional arguments. This second option is useful when using [`tf.keras.Model.fit`] method","SavedModel TF calls the method with LayerCall.__call__(args, **kwargs) # So to respect the","and another one for the unexpected layers. \"\"\" signature = dict(inspect.signature(func).parameters) signature.pop(\"kwargs\", None)","self.initialized = False self.kernel_norm_axes = tf.constant([0, 1]) def _init_norm(self): \"\"\"Set the norm of","None: output[k] = v else: raise ValueError(f\"Data of type {type(v)} is not allowed","int, num_heads: int, dropout: float = 0.0, is_decoder: bool = False, bias: bool","from transformers.models.wav2vec2.modeling_tf_wav2vec2.input_values_processing def input_values_processing(func, config, input_values, **kwargs): \"\"\" Process the input of each","Version 2.0 (the \"License\"); # you may not use this file except in","attn_weights = tf.reshape(attn_weights, (bsz, self.num_heads, tgt_len, src_len)) + attention_mask attn_weights = tf.reshape(attn_weights, (bsz","\"HubertConfig\" TF_HUBERT_PRETRAINED_MODEL_ARCHIVE_LIST = [ \"facebook/hubert-base-ls960\", # See all Hubert models at https://huggingface.co/models?filter=hubert ]","will be removed in a future version, use `input_values` instead.\", FutureWarning, ) output[\"input_values\"]","max(num_masked_spans, min_masks) # make sure num masked indices <= sequence_length if num_masked_spans *","conv_layers def call(self, input_values): hidden_states = tf.expand_dims(input_values, -1) for conv_layer in self.conv_layers: hidden_states","hidden_states = tf.expand_dims(input_values, -1) for conv_layer in self.conv_layers: hidden_states = conv_layer(hidden_states) return hidden_states","( ModelOutput, add_start_docstrings, add_start_docstrings_to_model_forward, logging, replace_return_docstrings, ) from .configuration_hubert import HubertConfig logger =","for computing the masked language modeling loss. Indices should be in `[-100, 0,","type(input) == tf.Tensor: # Tensor names have always the pattern `name:id` then we","class TFHubertGroupNormConvLayer(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, layer_id: int = 0, **kwargs: Any) ->","return hidden_states # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2SamePadLayer with Wav2Vec2->Hubert class TFHubertSamePadLayer(tf.keras.layers.Layer): def __init__(self, num_conv_pos_embeddings,","(bsz, self.num_heads, tgt_len, src_len)) return attn_output, attn_weights, past_key_value # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2FeedForward with","to the parameters name, i.e. `input_values = tf.keras.Input(shape=(128,), dtype='float32', name=\"input_values\")` otherwise the order","= 2 self.initialized = False self.kernel_norm_axes = tf.constant([0, 1]) def _init_norm(self): \"\"\"Set the","be used in eager mode, in graph mode the value will always be","= outputs[0] hidden_states = self.dropout(hidden_states, training=inputs[\"training\"]) logits = self.lm_head(hidden_states) if labels is not","training=training, ) inputs[\"output_hidden_states\"] = ( inputs[\"output_hidden_states\"] if inputs[\"output_hidden_states\"] else self.config.output_hidden_states ) inputs[\"output_attentions\"] =","is_decoder: bool = False, bias: bool = True, **kwargs, ): super().__init__(**kwargs) self.embed_dim =","# skip the layer continue layer_outputs = layer_module( hidden_states=hidden_states, attention_mask=attention_mask, output_attentions=output_attentions, training=training, )","tf.where( tf.cast(mask_time_indices[:, :, tf.newaxis], tf.bool), self.masked_spec_embed[tf.newaxis, tf.newaxis, :], hidden_states, ) elif self.config.mask_time_prob >","token_type_ids=token_type_ids, position_ids=position_ids, head_mask=head_mask, inputs_embeds=inputs_embeds, output_attentions=output_attentions, output_hidden_states=output_hidden_states, return_dict=return_dict, training=training, ) inputs[\"output_hidden_states\"] = ( inputs[\"output_hidden_states\"]","= past_key_value[1] elif is_cross_attention: # cross_attentions key_states = self._shape(self.k_proj(key_value_states), -1, bsz) value_states =","i in range(config.num_feat_extract_layers - 1) ] elif config.feat_extract_norm == \"layer\": conv_layers = [","if layer_id > 0 else 1 self.out_conv_dim = config.conv_dim[layer_id] self.conv = tf.keras.layers.Conv1D( filters=self.out_conv_dim,","config, **kwargs): super().__init__(config, **kwargs) warnings.warn( f\"The class `{self.__class__.__name__}` has been depreciated \" \"and","along time axis with given mask_time_indices hidden_states = tf.where( tf.cast(mask_time_indices[:, :, tf.newaxis], tf.bool),","Wav2Vec2->Hubert class TFHubertGroupNorm(tf.keras.layers.Layer): \"\"\" From tensorflow-addons https://www.tensorflow.org/addons/api_docs/python/tfa/layers/GroupNormalization \"\"\" def __init__( self, groups: int","/ mask_length + tf.random.uniform((1,))) num_masked_spans = max(num_masked_spans, min_masks) # make sure num masked","= TFHubertForCTC.from_pretrained(\"facebook/hubert-base-960h\") >>> def map_to_array(batch): ... speech, _ = sf.read(batch[\"file\"]) ... batch[\"speech\"] =","< self.groups: raise ValueError( \"Number of groups (\" + str(self.groups) + \") cannot","= axis self.epsilon = epsilon self.center = center self.scale = scale self.beta_initializer =","\"\"\" src_len = shape_list(mask)[1] tgt_len = tgt_len if tgt_len is not None else","= config self.hubert = TFHubertMainLayer(config, name=\"hubert\") @add_start_docstrings_to_model_forward(HUBERT_INPUTS_DOCSTRING) @replace_return_docstrings(output_type=TFBaseModelOutput, config_class=_CONFIG_FOR_DOC) def call( self, input_values:","Hubert model.\"\"\" import inspect import warnings from typing import Any, Dict, Optional, Tuple,","you want more control over how to convert `input_values` indices into associated vectors","axis=-1) if layer_head_mask is not None: # The tf.debugging asserts are not compliant","*sentence A* token, - 1 corresponds to a *sentence B* token. [What are","self.num_heads, tgt_len, src_len)) return attn_output, attn_weights, past_key_value # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2FeedForward with Wav2Vec2->Hubert","the input Tensors in the first positional argument : - a single Tensor","element is batch size and 2nd is timesteps attention_mask: optional padding mask of","to be one of ['group', 'layer']\" ) self.conv_layers = conv_layers def call(self, input_values):","sure that offset samples are < sequence_length uniform_dist = tf.ones((batch_size, sequence_length - (mask_length","and/or along feature axis according to [SpecAugment](https://arxiv.org/abs/1904.08779). \"\"\" batch_size, sequence_length, hidden_size = shape_list(hidden_states)","(`bool`, *optional*): Whether or not to return a [`~file_utils.ModelOutput`] instead of a plain","= key_value_states is not None bsz, tgt_len, embed_dim = shape_list(hidden_states) # get query","pair_indices pair_indices = tf.transpose(tf.concat([broad_casted_batch_dims, tf.reshape(batch_indices, [1, -1])], 0)) # scatter values to pair","value will always be set to True. training (`bool`, *optional*, defaults to `False``):","is not None: if tf.reduce_max(labels) >= self.config.vocab_size: raise ValueError(f\"Label values must be <=","tgt_len, src_len)) + attention_mask attn_weights = tf.reshape(attn_weights, (bsz * self.num_heads, tgt_len, src_len)) attn_weights","self.add_weight( shape=shape, name=\"gamma\", initializer=self.gamma_initializer, regularizer=self.gamma_regularizer, constraint=self.gamma_constraint, ) else: self.gamma = None def _add_beta_weight(self,","the head is **masked**. inputs_embeds (`np.ndarray` or `tf.Tensor` of shape `({0}, hidden_size)`, *optional*):","\"beta_regularizer\": tf.keras.regularizers.serialize(self.beta_regularizer), \"gamma_regularizer\": tf.keras.regularizers.serialize(self.gamma_regularizer), \"beta_constraint\": tf.keras.constraints.serialize(self.beta_constraint), \"gamma_constraint\": tf.keras.constraints.serialize(self.gamma_constraint), } base_config = super().get_config() return","def _apply_normalization(self, reshaped_inputs, input_shape): group_shape = tf.keras.backend.int_shape(reshaped_inputs) group_reduction_axes = list(range(1, len(group_shape))) is_instance_norm =","generate indices & apply SpecAugment along time axis mask_time_indices = _compute_mask_indices( (batch_size, sequence_length),","kwargs_call=kwargs, ) hidden_states = self.feature_extractor( tf.cast(inputs[\"input_values\"], tf.float32), training=inputs[\"training\"] ) if inputs[\"attention_mask\"] is not","input_values, \"token_type_ids\": token_type_ids})` </Tip> Args: config ([`HubertConfig`]): Model configuration class with all the","as tf from ...activations_tf import get_tf_activation from ...modeling_tf_outputs import TFBaseModelOutput, TFCausalLMOutput from ...modeling_tf_utils","License. \"\"\" TensorFlow Hubert model.\"\"\" import inspect import warnings from typing import Any,","and [`PreTrainedTokenizer.encode`] for details. [What are input IDs?](../glossary#input-ids) attention_mask (`np.ndarray` or `tf.Tensor` of","= False) -> tf.Tensor: hidden_states = self.intermediate_dense(hidden_states) hidden_states = self.intermediate_act_fn(hidden_states) hidden_states = self.intermediate_dropout(hidden_states,","self.config.mask_time_prob > 0: # generate indices & apply SpecAugment along time axis mask_time_indices","docstring: `model([input_values, attention_mask])` or `model([input_values, attention_mask, token_type_ids])` - a dictionary with one or","shape `({0})`): Indices of input sequence tokens in the vocabulary. Indices can be","of masked spans Adapted from [fairseq's data_utils.py](https://github.com/pytorch/fairseq/blob/e0788f7007a8473a76db573985031f3c94201e79/fairseq/data/data_utils.py#L376). \"\"\" batch_size, sequence_length = shape if","the self-attention modules. Mask values selected in `[0, 1]`: - 1 indicates the","if config.do_stable_layer_norm: self.encoder = TFHubertEncoderStableLayerNorm(config, name=\"encoder\") else: self.encoder = TFHubertEncoder(config, name=\"encoder\") def build(self,","return indices # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2._scatter_values_on_batch_indices def _scatter_values_on_batch_indices(values, batch_indices, output_shape): \"\"\" Scatter function","Adapted from [fairseq's data_utils.py](https://github.com/pytorch/fairseq/blob/e0788f7007a8473a76db573985031f3c94201e79/fairseq/data/data_utils.py#L376). \"\"\" batch_size, sequence_length = shape if mask_length < 1:","src_len = shape_list(mask)[1] tgt_len = tgt_len if tgt_len is not None else src_len","when not being attended to labels_mask = tf.cast(labels >= 0, tf.int32) target_lengths =","head on top for Connectionist Temporal Classification (CTC).\"\"\", HUBERT_START_DOCSTRING, ) class TFHubertForCTC(TFHubertPreTrainedModel): def","self.groups return broadcast_shape # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2WeightNormConv1D with Wav2Vec2->Hubert class TFHubertWeightNormConv1D(tf.keras.layers.Conv1D): \"\"\"Adapted from","else: output[parameter_names[i]] = input elif isinstance(input, allowed_types) or input is None: output[parameter_names[i]] =","always the pattern `name:id` then we check only the # `name` part tensor_name","dropout: float = 0.0, is_decoder: bool = False, bias: bool = True, **kwargs,","tf.keras.layers.Dropout(config.activation_dropout) self.intermediate_dense = tf.keras.layers.Dense( units=config.intermediate_size, kernel_initializer=get_initializer(config.initializer_range), bias_initializer=\"zeros\", name=\"intermediate_dense\", ) self.intermediate_act_fn = get_tf_activation(config.hidden_act) self.output_dense","1) ] elif config.feat_extract_norm == \"layer\": conv_layers = [ TFHubertLayerNormConvLayer(config, layer_id=i, name=f\"conv_layers.{i}\") for","True self.groups = groups self.axis = axis self.epsilon = epsilon self.center = center","self.groups) else: broadcast_shape[self.axis] = self.groups return broadcast_shape # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2WeightNormConv1D with Wav2Vec2->Hubert","a given shape Args: shape: the the shape for which to compute masks.","layer_id > 0 else 1 self.out_conv_dim = config.conv_dim[layer_id] self.conv = tf.keras.layers.Conv1D( filters=self.out_conv_dim, kernel_size=config.conv_kernel[layer_id],","TFBaseModelOutput, TFCausalLMOutput from ...modeling_tf_utils import TFPreTrainedModel, booleans_processing, get_initializer, keras_serializable from ...tf_utils import shape_list","super().build(input_shape) def call(self, inputs): input_shape = tf.keras.backend.int_shape(inputs) tensor_input_shape = tf.shape(inputs) reshaped_inputs, group_shape =","continue else: raise ValueError(f\"Data of type {type(v)} is not allowed only {allowed_types} is","return hidden_states # Copied from transformers.models.bart.modeling_tf_bart.TFBartAttention with TFBart->TFHubert class TFHubertAttention(tf.keras.layers.Layer): \"\"\"Multi-headed attention from","are checked at build time since TF 2.7, so we need to account","epsilon=config.layer_norm_eps, name=\"final_layer_norm\" ) def call( self, hidden_states: tf.Tensor, attention_mask: Optional[tf.Tensor] = None, output_attentions:","= self.dropout(hidden_states, training=training) for i, layer_module in enumerate(self.layer): if output_hidden_states: all_hidden_states = all_hidden_states","size as shape, which will prevent masking padded elements mask_prob: probability for each","= None if not inputs[\"return_dict\"]: output = (logits,) + outputs[1:] return ((loss,) +","save Tuple(tf.Tensor, tf.Tensor) of # all previous decoder key/value_states. Further calls to uni-directional","= get_tf_activation(config.hidden_act) self.output_dense = tf.keras.layers.Dense( units=config.hidden_size, kernel_initializer=get_initializer(config.initializer_range), bias_initializer=\"zeros\", name=\"output_dense\", ) self.output_dropout = tf.keras.layers.Dropout(config.hidden_dropout)","self.scaling = self.head_dim**-0.5 self.is_decoder = is_decoder self.k_proj = tf.keras.layers.Dense(embed_dim, use_bias=bias, name=\"k_proj\") self.q_proj =","= (dim,) if self.center: self.beta = self.add_weight( shape=shape, name=\"beta\", initializer=self.beta_initializer, regularizer=self.beta_regularizer, constraint=self.beta_constraint, )","input elif isinstance(input, allowed_types) or input is None: output[parameter_names[i]] = input else: raise","shape=(int(self.weight_v.shape[self.filter_axis]), 1, 1), initializer=\"ones\", dtype=self.weight_v.dtype, trainable=True, ) self.bias = self.add_weight(name=\"bias\", shape=(self.filters,), initializer=\"zeros\", trainable=True)","use the model in training mode (some modules like dropout modules have different","import tensorflow as tf from ...activations_tf import get_tf_activation from ...modeling_tf_outputs import TFBaseModelOutput, TFCausalLMOutput","output_hidden_states=inputs[\"output_hidden_states\"], return_dict=inputs[\"return_dict\"], training=inputs[\"training\"], ) hidden_states = outputs[0] hidden_states = self.dropout(hidden_states, training=inputs[\"training\"]) logits =","under the Apache License, Version 2.0 (the \"License\"); # you may not use","message=f\"Attention mask should be of size {(bsz, 1, tgt_len, src_len)}, but is {shape_list(attention_mask)}\",","config self.feature_extractor = TFHubertFeatureEncoder(config, name=\"feature_extractor\") self.feature_projection = TFHubertFeatureProjection(config, name=\"feature_projection\") if config.do_stable_layer_norm: self.encoder =","names given in the docstring: `model({\"input_values\": input_values, \"token_type_ids\": token_type_ids})` </Tip> Args: config ([`HubertConfig`]):","self.center: self.beta = self.add_weight( shape=shape, name=\"beta\", initializer=self.beta_initializer, regularizer=self.beta_regularizer, constraint=self.beta_constraint, ) else: self.beta =","key, value proj if is_cross_attention and past_key_value is not None: # reuse k,v,","proj_shape) key_states = tf.reshape(key_states, proj_shape) value_states = tf.reshape(value_states, proj_shape) src_len = shape_list(key_states)[1] attn_weights","axis. Do you want to \" \"use tf.layer.batch_normalization instead\" ) def _create_input_spec(self, input_shape):","head_mask=inputs[\"head_mask\"], inputs_embeds=inputs[\"inputs_embeds\"], output_attentions=inputs[\"output_attentions\"], output_hidden_states=inputs[\"output_hidden_states\"], return_dict=inputs[\"return_dict\"], training=inputs[\"training\"], ) return outputs def serving_output(self, output): hs","Tuple, Union import numpy as np import tensorflow as tf from ...activations_tf import","encoder so that its parameter will not be updated during training. \"\"\" self.hubert.feature_extractor.trainable","if self.config.mask_feature_prob > 0: mask_feature_indices = _compute_mask_indices( (batch_size, hidden_size), mask_prob=self.config.mask_feature_prob, mask_length=self.config.mask_feature_length, ) hidden_states","# compute loss >>> target_transcription = \"A MAN SAID TO THE UNIVERSE SIR","the attentions tensors of all attention layers. See `attentions` under returned tensors for","_get_reshaped_weights(self, input_shape): broadcast_shape = self._create_broadcast_shape(input_shape) gamma = None beta = None if self.scale:","config: HubertConfig, **kwargs: Any) -> None: super().__init__(**kwargs) if config.feat_extract_norm == \"group\": conv_layers =","= False, bias: bool = True, **kwargs, ): super().__init__(**kwargs) self.embed_dim = embed_dim self.num_heads","`model([input_values, attention_mask])` or `model([input_values, attention_mask, token_type_ids])` - a dictionary with one or several","this second option, there are three possibilities you can use to gather all","from transformers.models.wav2vec2.modeling_tf_wav2vec2._compute_mask_indices def _compute_mask_indices( shape: Tuple[int, int], mask_prob: float, mask_length: int, min_masks: int","self.dropout = tf.keras.layers.Dropout(config.hidden_dropout) self.layer = [TFHubertEncoderLayer(config, name=f\"layers.{i}\") for i in range(config.num_hidden_layers)] def call(","* self.num_heads, tgt_len, src_len)}, but is {shape_list(attn_weights)}\", ) if attention_mask is not None:","int = 0, **kwargs: Any) -> None: super().__init__(**kwargs) self.in_conv_dim = config.conv_dim[layer_id] if layer_id","range(config.num_feat_extract_layers) ] else: raise ValueError( f\"`config.feat_extract_norm` is {config.feat_extract_norm}, but has to be one","The tf.debugging asserts are not compliant with XLA then they # have to","for the tokens with labels in `[0, ..., config.vocab_size]` Returns: Example: ```python >>>","during the training. Args: func (`callable`): The callable function of the TensorFlow model.","of the span to be masked. this will be multiplied by number of","loading pretrained models. \"\"\" config_class = HubertConfig base_model_prefix = \"hubert\" main_input_name = \"input_values\"","spans for a given shape Args: shape: the the shape for which to","License, Version 2.0 (the \"License\"); # you may not use this file except","inputs_embeds=inputs_embeds, output_attentions=output_attentions, output_hidden_states=output_hidden_states, return_dict=return_dict, training=training, ) inputs[\"output_hidden_states\"] = ( inputs[\"output_hidden_states\"] if inputs[\"output_hidden_states\"] else","class TFHubertFeatureExtractor(TFHubertFeatureEncoder): def __init__(self, config, **kwargs): super().__init__(config, **kwargs) warnings.warn( f\"The class `{self.__class__.__name__}` has","= hidden_states hidden_states = self.layer_norm(hidden_states) hidden_states, attn_weights, _ = self.attention( hidden_states, attention_mask=attention_mask, training=training","inputs as keyword arguments (like PyTorch models), or - having all inputs as","...modeling_tf_outputs import TFBaseModelOutput, TFCausalLMOutput from ...modeling_tf_utils import TFPreTrainedModel, booleans_processing, get_initializer, keras_serializable from ...tf_utils","is also a [tf.keras.Model](https://www.tensorflow.org/api_docs/python/tf/keras/Model) subclass. Use it as a regular TF 2.0 Keras","in output: if output[\"args\"] is not None and type(output[\"args\"]) == tf.Tensor: tensor_name =","TF 2.7, so we need to account for padding input_shape[-2] += self.explicit_padding *","output.update(booleans_processing(config=config, **boolean_dict)) return output # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2._sample_without_replacement def _sample_without_replacement(distribution, num_samples): \"\"\" Categorical","for tokens that are **masked**. [What are attention masks?](../glossary#attention-mask) token_type_ids (`np.ndarray` or `tf.Tensor`","masking padded elements mask_prob: probability for each token to be chosen as start","\" \"use tf.layer.batch_normalization instead\" ) def _create_input_spec(self, input_shape): dim = input_shape[self.axis] self.input_spec =","self.beta_regularizer = tf.keras.regularizers.get(beta_regularizer) self.gamma_regularizer = tf.keras.regularizers.get(gamma_regularizer) self.beta_constraint = tf.keras.constraints.get(beta_constraint) self.gamma_constraint = tf.keras.constraints.get(gamma_constraint) self._check_axis()","- 0 for tokens that are **masked**. [What are attention masks?](../glossary#attention-mask) token_type_ids (`np.ndarray`","tf.reshape( tf.broadcast_to(tf.expand_dims(tf.range(indices_shape[0]), axis=-1), indices_shape), [1, -1] ) # transform batch_indices to pair_indices pair_indices","self.scale = scale self.beta_initializer = tf.keras.initializers.get(beta_initializer) self.gamma_initializer = tf.keras.initializers.get(gamma_initializer) self.beta_regularizer = tf.keras.regularizers.get(beta_regularizer) self.gamma_regularizer","model = TFHubertModel.from_pretrained(\"facebook/hubert-base-960h\") >>> def map_to_array(batch): ... speech, _ = sf.read(batch[\"file\"]) ... batch[\"speech\"]","predicted_ids = tf.argmax(logits, axis=-1) >>> transcription = processor.decode(predicted_ids[0]) >>> # compute loss >>>","if tf.executing_eagerly(): tf.debugging.assert_equal( shape_list(layer_head_mask), [self.num_heads], message=f\"Head mask for a single layer should be","self.config.output_hidden_states else None attns = tf.convert_to_tensor(output.attentions) if self.config.output_attentions else None return TFCausalLMOutput(logits=output.logits, hidden_states=hs,","class to handle weights initialization and a simple interface for downloading and loading","`(batch_size, sequence_length)`, *optional*): Labels for computing the masked language modeling loss. Indices should","copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by","tf.layer.batch_normalization instead\" ) def _create_input_spec(self, input_shape): dim = input_shape[self.axis] self.input_spec = tf.keras.layers.InputSpec(ndim=len(input_shape), axes={self.axis:","Wav2Vec2Processor.from_pretrained(\"facebook/hubert-base-960h\") >>> model = TFHubertForCTC.from_pretrained(\"facebook/hubert-base-960h\") >>> def map_to_array(batch): ... speech, _ = sf.read(batch[\"file\"])","= TFHubertSamePadLayer(config.num_conv_pos_embeddings) self.activation = get_tf_activation(config.feat_extract_activation) def call(self, hidden_states: tf.Tensor) -> tf.Tensor: hidden_states =","TFHubertForCTC >>> from datasets import load_dataset >>> import soundfile as sf >>> processor","Scatter function as in PyTorch with indices in format (batch_dim, indixes) \"\"\" indices_shape","Optional[tf.Tensor] = None, token_type_ids: Optional[tf.Tensor] = None, position_ids: Optional[tf.Tensor] = None, head_mask: Optional[tf.Tensor]","key/value_states to current projected key/value_states (third \"elif\" case) # if encoder bi-directional self-attention","= TFHubertWeightNormConv1D( filters=config.hidden_size, kernel_size=config.num_conv_pos_embeddings, groups=config.num_conv_pos_embedding_groups, explicit_padding=config.num_conv_pos_embeddings // 2, name=\"conv\", ) self.padding = TFHubertSamePadLayer(config.num_conv_pos_embeddings)","`[bsz, 1, tgt_seq_len, src_seq_len]`. \"\"\" src_len = shape_list(mask)[1] tgt_len = tgt_len if tgt_len","so that its parameter will not be updated during training. \"\"\" self.hubert.feature_extractor.trainable =","but got `mask_length`: {mask_length} and `sequence_length`: {sequence_length}`\" ) # compute number of masked","not be updated during training. \"\"\" warnings.warn( \"The method `freeze_feature_extractor` is deprecated and","now - see https://github.com/tensorflow/tensorflow/issues/9260 for more info \"\"\" z = -tf.math.log(tf.random.uniform(shape_list(distribution), 0, 1))","are attention masks?](../glossary#attention-mask) token_type_ids (`np.ndarray` or `tf.Tensor` of shape `({0})`, *optional*): Segment token","= TFHubertPositionalConvEmbedding(config, name=\"pos_conv_embed\") self.layer_norm = tf.keras.layers.LayerNormalization(epsilon=config.layer_norm_eps, name=\"layer_norm\") self.dropout = tf.keras.layers.Dropout(config.hidden_dropout) self.layer = [TFHubertEncoderLayer(config,","= sf.read(batch[\"file\"]) ... batch[\"speech\"] = speech ... return batch >>> ds = load_dataset(\"hf-internal-testing/librispeech_asr_dummy\",","= tf.reshape(attn_weights, (bsz * self.num_heads, tgt_len, src_len)) attn_weights = tf.nn.softmax(attn_weights, axis=-1) if layer_head_mask","labels_mask = tf.cast(labels >= 0, tf.int32) target_lengths = tf.reduce_sum(labels_mask, axis=-1) loss = tf.nn.ctc_loss(","apply SpecAugment along feature axis if self.config.mask_feature_prob > 0: mask_feature_indices = _compute_mask_indices( (batch_size,","or v is None: output[k] = v else: raise ValueError(f\"Data of type {type(v)}","else output return TFCausalLMOutput( loss=loss, logits=logits, hidden_states=outputs.hidden_states, attentions=outputs.attentions, ) def serving_output(self, output: TFCausalLMOutput)","axis and/or along feature axis according to [SpecAugment](https://arxiv.org/abs/1904.08779). \"\"\" batch_size, sequence_length, hidden_size =","config, input_values, **kwargs): \"\"\" Process the input of each TensorFlow model including the","due to overlaps, the actual number will be smaller (unless no_overlap is True)","mode, in graph mode the value in the config will be used instead.","# if uni-directional self-attention (decoder) save Tuple(tf.Tensor, tf.Tensor) of # all previous decoder","(`np.ndarray` or `tf.Tensor` of shape `({0})`, *optional*): Mask to avoid performing attention on","(batch_size, hidden_size), mask_prob=self.config.mask_feature_prob, mask_length=self.config.mask_feature_length, ) hidden_states = tf.where(mask_feature_indices[:, tf.newaxis, :], hidden_states, 0) return","samples are < sequence_length uniform_dist = tf.ones((batch_size, sequence_length - (mask_length - 1))) #","a dictionary with one or several input Tensors associated to the input names","Optional[bool] = None, return_dict: Optional[bool] = None, training: Optional[bool] = False, ) ->","having all the tensors in the first argument of the model call function:","= None, return_dict: Optional[bool] = None, training: Optional[bool] = False, ) -> Union[TFCausalLMOutput,","be updated during training. \"\"\" warnings.warn( \"The method `freeze_feature_extractor` is deprecated and will","= center self.scale = scale self.beta_initializer = tf.keras.initializers.get(beta_initializer) self.gamma_initializer = tf.keras.initializers.get(gamma_initializer) self.beta_regularizer =","self.kernel self.weight_g = self.add_weight( name=\"weight_g\", shape=(int(self.weight_v.shape[self.filter_axis]), 1, 1), initializer=\"ones\", dtype=self.weight_v.dtype, trainable=True, ) self.bias","Tuple[tf.Tensor]]: \"\"\" Returns: Example: ```python >>> from transformers import Wav2Vec2Processor, TFHubertModel >>> from","same size as shape, which will prevent masking padded elements mask_prob: probability for","tf.pad(inputs, ((0, 0), (self.explicit_padding, self.explicit_padding), (0, 0))) output = super().call(padded_inputs) return output #","= hidden_states[:, : -self.num_pad_remove, :] return hidden_states class TFHubertFeatureEncoder(tf.keras.layers.Layer): def __init__(self, config: HubertConfig,","self.dropout = tf.keras.layers.Dropout(config.hidden_dropout) self.layer_norm = tf.keras.layers.LayerNormalization(epsilon=config.layer_norm_eps, name=\"layer_norm\") self.feed_forward = TFHubertFeedForward(config, name=\"feed_forward\") self.final_layer_norm =","currently requires having all the tensors in the first argument of the model","self.groups, \"axis\": self.axis, \"epsilon\": self.epsilon, \"center\": self.center, \"scale\": self.scale, \"beta_initializer\": tf.keras.initializers.serialize(self.beta_initializer), \"gamma_initializer\": tf.keras.initializers.serialize(self.gamma_initializer),","is {shape_list(attention_mask)}\", ) attention_mask = tf.cast(attention_mask, dtype=attn_weights.dtype) attn_weights = tf.reshape(attn_weights, (bsz, self.num_heads, tgt_len,","offsets = tf.range(mask_length)[tf.newaxis, tf.newaxis, :] offsets = tf.tile(offsets, (batch_size, num_masked_spans, 1)) offsets =","_create_input_spec(self, input_shape): dim = input_shape[self.axis] self.input_spec = tf.keras.layers.InputSpec(ndim=len(input_shape), axes={self.axis: dim}) def _add_gamma_weight(self, input_shape):","build(self, input_shape): self._check_if_input_shape_is_none(input_shape) self._set_number_of_groups_for_instance_norm(input_shape) self._check_size_of_dimensions(input_shape) self._create_input_spec(input_shape) self._add_gamma_weight(input_shape) self._add_beta_weight(input_shape) self.built = True super().build(input_shape) def","= [TFHubertGroupNormConvLayer(config, layer_id=0, name=f\"conv_layers.{0}\")] + [ TFHubertNoLayerNormConvLayer(config, layer_id=i + 1, name=f\"conv_layers.{i+1}\") for i","one or several input Tensors IN THE ORDER given in the docstring: `model([input_values,","key_value_states is not None bsz, tgt_len, embed_dim = shape_list(hidden_states) # get query proj","current projected key/value_states (third \"elif\" case) # if encoder bi-directional self-attention `past_key_value` is","def __init__(self, num_conv_pos_embeddings, **kwargs): super().__init__(**kwargs) self.num_pad_remove = 1 if num_conv_pos_embeddings % 2 ==","0: raise ValueError( \"Number of groups (\" + str(self.groups) + \") must be","= tf.tile(spec_aug_mask_idxs, (1, 1, mask_length)) spec_aug_mask_idxs = tf.reshape(spec_aug_mask_idxs, (batch_size, num_masked_spans * mask_length)) offsets","of the self-attention modules. Mask values selected in `[0, 1]`: - 1 indicates","tgt_len, src_len)}, but is {shape_list(attn_weights)}\", ) if attention_mask is not None: # The","1 for tokens that are **not masked**, - 0 for tokens that are","the range `[0, config.max_position_embeddings - 1]`. [What are position IDs?](../glossary#position-ids) head_mask (`np.ndarray` or","stride in zip(self.config.conv_kernel, self.config.conv_stride): input_lengths = _conv_out_length(input_lengths, kernel_size, stride) return input_lengths def _mask_hidden_states(self,","from typing import Any, Dict, Optional, Tuple, Union import numpy as np import","shape if mask_length < 1: raise ValueError(\"`mask_length` has to be bigger than 0.\")","decoder is_cross_attention = key_value_states is not None bsz, tgt_len, embed_dim = shape_list(hidden_states) #","the feature encoder so that its parameters will not be updated during training.","...tf_utils import shape_list from ...tokenization_utils_base import BatchEncoding from ...utils import ( ModelOutput, add_start_docstrings,","-1, bsz) elif past_key_value is not None: # reuse k, v, self_attention key_states","(input_shape[self.axis] // self.groups) == 1 if not is_instance_norm: outputs = tf.reshape(normalized_inputs, tensor_input_shape) else:","kernel_size, stride) return input_lengths def _mask_hidden_states(self, hidden_states: tf.Tensor, mask_time_indices: Optional[tf.Tensor] = None): \"\"\"","parameter_names: if name not in list(output.keys()) and name != \"args\": output[name] = kwargs.pop(name,","or input is None: output[parameter_names[i]] = input else: raise ValueError( f\"Data of type","mean=mean, variance=variance, scale=gamma, offset=beta, variance_epsilon=self.epsilon, ) return normalized_inputs def _get_reshaped_weights(self, input_shape): broadcast_shape =","get_initializer, keras_serializable from ...tf_utils import shape_list from ...tokenization_utils_base import BatchEncoding from ...utils import","config: HubertConfig, **kwargs): super().__init__(**kwargs) self.attention = TFHubertAttention( embed_dim=config.hidden_size, num_heads=config.num_attention_heads, dropout=config.attention_dropout, is_decoder=False, name=\"attention\", )","\"\"\"Adapted from https://www.tensorflow.org/probability/api_docs/python/tfp/layers/weight_norm/WeightNorm\"\"\" def __init__(self, filters, kernel_size, groups, explicit_padding, **kwargs): super().__init__( filters=filters, kernel_size=kernel_size,","tf.Tensor, key_value_states: Optional[tf.Tensor] = None, past_key_value: Optional[Tuple[Tuple[tf.Tensor]]] = None, attention_mask: Optional[tf.Tensor] = None,","mask_feature_indices = _compute_mask_indices( (batch_size, hidden_size), mask_prob=self.config.mask_feature_prob, mask_length=self.config.mask_feature_length, ) hidden_states = tf.where(mask_feature_indices[:, tf.newaxis, :],","can concat previous decoder key/value_states to current projected key/value_states (third \"elif\" case) #","= TFHubertEncoder(config, name=\"encoder\") def build(self, input_shape: tf.TensorShape): self.masked_spec_embed = self.add_weight( shape=(self.config.hidden_size,), initializer=\"uniform\", trainable=True,","Whether or not to return the hidden states of all layers. See `hidden_states`","with a config file does not load the weights associated with the model,","Tuple[tf.Tensor, Optional[tf.Tensor]]: \"\"\"Input shape: Batch x Time x Channel\"\"\" # if key_value_states are",">>> model = TFHubertModel.from_pretrained(\"facebook/hubert-base-960h\") >>> def map_to_array(batch): ... speech, _ = sf.read(batch[\"file\"]) ...","stride + 1 for kernel_size, stride in zip(self.config.conv_kernel, self.config.conv_stride): input_lengths = _conv_out_length(input_lengths, kernel_size,","output_shape) # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2._compute_mask_indices def _compute_mask_indices( shape: Tuple[int, int], mask_prob: float, mask_length:","None, inputs_embeds: Optional[tf.Tensor] = None, output_attentions: Optional[bool] = None, output_hidden_states: Optional[bool] = None,","= self.add_weight(name=\"bias\", shape=(self.filters,), initializer=\"zeros\", trainable=True) def call(self, inputs): if not self.initialized: self._init_norm() self.initialized","mask_prob: probability for each token to be chosen as start of the span","mask spec_aug_mask = _scatter_values_on_batch_indices( tf.ones_like(spec_aug_mask_idxs), spec_aug_mask_idxs, spec_aug_mask.shape ) return spec_aug_mask # Copied from","# Tensor names have always the pattern `name:id` then we check only the","# SpecAugment mask to fill spec_aug_mask = tf.zeros((batch_size, sequence_length), dtype=tf.int32) # uniform distribution","= tf.cast(labels >= 0, tf.int32) target_lengths = tf.reduce_sum(labels_mask, axis=-1) loss = tf.nn.ctc_loss( logits=logits,","= input_values else: raise ValueError( f\"Data of type {type(input_values)} is not allowed only","= tf.keras.layers.Dropout(config.final_dropout) self.lm_head = tf.keras.layers.Dense(config.vocab_size, name=\"lm_head\") def freeze_feature_extractor(self): \"\"\" Calling this function will","# Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2NoLayerNormConvLayer with Wav2Vec2->Hubert class TFHubertNoLayerNormConvLayer(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, layer_id:","= shape_list(hidden_states) # `config.apply_spec_augment` can set masking to False if not getattr(self.config, \"apply_spec_augment\",","if inputs[\"training\"]: hidden_states = self._mask_hidden_states(hidden_states, mask_time_indices=mask_time_indices) encoder_outputs = self.encoder( hidden_states, attention_mask=attention_mask, output_attentions=inputs[\"output_attentions\"], output_hidden_states=inputs[\"output_hidden_states\"],","instead. return_dict (`bool`, *optional*): Whether or not to return a [`~file_utils.ModelOutput`] instead of","= ( inputs[\"output_hidden_states\"] if inputs[\"output_hidden_states\"] else self.config.output_hidden_states ) inputs[\"output_attentions\"] = ( inputs[\"output_attentions\"] if","else: raise ValueError( f\"`config.feat_extract_norm` is {config.feat_extract_norm}, but has to be one of ['group',",") hidden_states = outputs[0] hidden_states = self.dropout(hidden_states, training=inputs[\"training\"]) logits = self.lm_head(hidden_states) if labels","for kernel_size, stride in zip(self.config.conv_kernel, self.config.conv_stride): input_lengths = _conv_out_length(input_lengths, kernel_size, stride) return input_lengths","having all inputs as keyword arguments (like PyTorch models), or - having all","input_shape, tensor_input_shape): group_shape = [tensor_input_shape[i] for i in range(len(input_shape))] is_instance_norm = (input_shape[self.axis] //","axis: int = -1, epsilon: float = 1e-3, center: bool = True, scale:","instead.\", FutureWarning, ) class TFHubertFeatureProjection(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs): super().__init__(**kwargs) self.layer_norm =","if self.groups == -1: self.groups = dim def _check_size_of_dimensions(self, input_shape): dim = input_shape[self.axis]",">>> from transformers import Wav2Vec2Processor, TFHubertForCTC >>> from datasets import load_dataset >>> import","dim}) def _add_gamma_weight(self, input_shape): dim = input_shape[self.axis] shape = (dim,) if self.scale: self.gamma","LayerCall.__call__(args, **kwargs) # So to respect the proper output we have to add",") hidden_states = tf.where( tf.cast(mask_time_indices[:, :, tf.newaxis], tf.bool), self.masked_spec_embed[tf.newaxis, tf.newaxis, :], hidden_states, )","Args: input_values (`np.ndarray`, `tf.Tensor`, `List[tf.Tensor]` ``Dict[str, tf.Tensor]` or `Dict[str, np.ndarray]` and each example","with the License. # You may obtain a copy of the License at","so we check for a real Tensor if type(input) == tf.Tensor: # Tensor","self.config.layerdrop): # skip the layer continue layer_outputs = layer_module( hidden_states=hidden_states, attention_mask=attention_mask, output_attentions=output_attentions, training=training,","model inherits from [`TFPreTrainedModel`]. Check the superclass documentation for the generic methods the","build time since TF 2.7, so we need to account for padding input_shape[-2]","in `[0, 1]`: - 1 for tokens that are **not masked**, - 0","output[\"args\"].name.split(\":\")[0] output[tensor_name] = output[\"args\"] else: # `args` in this case is always the","load the model weights. \"\"\" HUBERT_INPUTS_DOCSTRING = r\"\"\" Args: input_values (`np.ndarray`, `tf.Tensor`, `List[tf.Tensor]`","= tf.keras.Input(shape=(128,), dtype='float32', name=\"input_values\")` otherwise the order of the tensors will not be","return_dict=inputs[\"return_dict\"], training=inputs[\"training\"], ) hidden_states = outputs[0] hidden_states = self.dropout(hidden_states, training=inputs[\"training\"]) logits = self.lm_head(hidden_states)","law or agreed to in writing, software # distributed under the License is","output_attentions=inputs[\"output_attentions\"], output_hidden_states=inputs[\"output_hidden_states\"], return_dict=inputs[\"return_dict\"], training=inputs[\"training\"], ) hidden_states = outputs[0] hidden_states = self.dropout(hidden_states, training=inputs[\"training\"]) logits","= input_shape[self.axis] if dim is None: raise ValueError( \"Axis \" + str(self.axis) +","channels (\" + str(dim) + \").\" ) def _check_axis(self): if self.axis == 0:","the input names given in the docstring: `model({\"input_values\": input_values, \"token_type_ids\": token_type_ids})` </Tip> Args:","tensorflow-addons https://www.tensorflow.org/addons/api_docs/python/tfa/layers/GroupNormalization \"\"\" def __init__( self, groups: int = 32, axis: int =","Tensors in the first positional argument : - a single Tensor with `input_values`","input_shape): dim = input_shape[self.axis] if self.groups == -1: self.groups = dim def _check_size_of_dimensions(self,","inputs[\"training\"]: hidden_states = self._mask_hidden_states(hidden_states, mask_time_indices=mask_time_indices) encoder_outputs = self.encoder( hidden_states, attention_mask=attention_mask, output_attentions=inputs[\"output_attentions\"], output_hidden_states=inputs[\"output_hidden_states\"], return_dict=inputs[\"return_dict\"],","for i in range(config.num_feat_extract_layers - 1) ] elif config.feat_extract_norm == \"layer\": conv_layers =","(`callable`): The callable function of the TensorFlow model. config ([`PretrainedConfig`]): The config of","isinstance(input_values, (tuple, list)): for i, input in enumerate(input_values): # EagerTensors don't allow to","range(config.num_hidden_layers)] def call( self, hidden_states: tf.Tensor, attention_mask: Optional[tf.Tensor] = None, output_attentions: Optional[bool] =","the shape `({0})`): Indices of input sequence tokens in the vocabulary. Indices can","{mask_length} and `sequence_length`: {sequence_length}`\" ) # compute number of masked spans in batch",">>> transcription = processor.decode(predicted_ids[0]) >>> # compute loss >>> target_transcription = \"A MAN","[`BertTokenizer`]. See [`PreTrainedTokenizer.__call__`] and [`PreTrainedTokenizer.encode`] for details. [What are input IDs?](../glossary#input-ids) attention_mask (`np.ndarray`","lists, one for the missing layers, and another one for the unexpected layers.","(`np.ndarray` or `tf.Tensor` of shape `(num_heads,)` or `(num_layers, num_heads)`, *optional*): Mask to nullify","to the parameter list {parameter_names} and will be ignored.\" ) continue else: raise","not being attended to labels_mask = tf.cast(labels >= 0, tf.int32) target_lengths = tf.reduce_sum(labels_mask,","self.is_decoder: # if cross_attention save Tuple(tf.Tensor, tf.Tensor) of all cross attention key/value_states. #","Wav2Vec2->Hubert class TFHubertGroupNormConvLayer(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, layer_id: int = 0, **kwargs: Any)","TensorFlow model including the booleans. In case of a list of symbolic inputs,","len(input_shape) is_instance_norm = (input_shape[self.axis] // self.groups) == 1 if not is_instance_norm: broadcast_shape[self.axis] =","disable the gradient computation for the feature encoder so that its parameter will","= None, attention_mask: Optional[tf.Tensor] = None, layer_head_mask: Optional[tf.Tensor] = None, training: Optional[bool] =","tf.int32) target_lengths = tf.reduce_sum(labels_mask, axis=-1) loss = tf.nn.ctc_loss( logits=logits, labels=labels, logit_length=input_lengths, label_length=target_lengths, blank_index=self.config.pad_token_id,","\"but the layer received an input with shape \" + str(input_shape) + \".\"","self.conv(hidden_states) hidden_states = self.padding(hidden_states) hidden_states = self.activation(hidden_states) return hidden_states # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2SamePadLayer","size {(bsz, 1, tgt_len, src_len)}, but is {shape_list(attention_mask)}\", ) attention_mask = tf.cast(attention_mask, dtype=attn_weights.dtype)","- 1 for tokens that are **not masked**, - 0 for tokens that","key/value_states. Further calls to uni-directional self-attention # can concat previous decoder key/value_states to","batch_size, sequence_length, hidden_size = shape_list(hidden_states) # `config.apply_spec_augment` can set masking to False if","[hidden_states, all_hidden_states, all_self_attentions] if v is not None) return TFBaseModelOutput( last_hidden_state=hidden_states, hidden_states=all_hidden_states, attentions=all_self_attentions,",") self.explicit_padding = explicit_padding self.filter_axis = 2 self.initialized = False self.kernel_norm_axes = tf.constant([0,","= tf.keras.initializers.get(beta_initializer) self.gamma_initializer = tf.keras.initializers.get(gamma_initializer) self.beta_regularizer = tf.keras.regularizers.get(beta_regularizer) self.gamma_regularizer = tf.keras.regularizers.get(gamma_regularizer) self.beta_constraint =","also a [tf.keras.Model](https://www.tensorflow.org/api_docs/python/tf/keras/Model) subclass. Use it as a regular TF 2.0 Keras Model","+ (hidden_states,) # add LayerDrop (see https://arxiv.org/abs/1909.11556 for description) dropout_probability = np.random.uniform(0, 1)","transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2EncoderStableLayerNorm with Wav2Vec2->Hubert class TFHubertEncoderStableLayerNorm(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs): super().__init__(**kwargs) self.config =","output_shape): \"\"\" Scatter function as in PyTorch with indices in format (batch_dim, indixes)","= all_self_attentions + (layer_outputs[1],) # Add last layer if output_hidden_states: all_hidden_states = all_hidden_states",">>> loss = model(input_values, labels=labels).loss ```\"\"\" inputs = input_values_processing( func=self.call, config=self.config, input_values=input_values, attention_mask=attention_mask,","other modes than eager. if tf.executing_eagerly(): tf.debugging.assert_equal( shape_list(attn_output), [bsz * self.num_heads, tgt_len, self.head_dim],","return_dict: Optional[bool] = None, training: bool = False, ) -> Union[TFBaseModelOutput, Tuple[tf.Tensor]]: \"\"\"","'layer']\" ) self.conv_layers = conv_layers def call(self, input_values): hidden_states = tf.expand_dims(input_values, -1) for","attn_residual + hidden_states hidden_states = self.layer_norm(hidden_states) hidden_states = hidden_states + self.feed_forward(hidden_states) hidden_states =","k, v, self_attention key_states = self._shape(self.k_proj(hidden_states), -1, bsz) value_states = self._shape(self.v_proj(hidden_states), -1, bsz)","self.beta = None def _create_broadcast_shape(self, input_shape): broadcast_shape = [1] * len(input_shape) is_instance_norm =","passing `input_values` you can choose to directly pass an embedded representation. This is","more info \"\"\" z = -tf.math.log(tf.random.uniform(shape_list(distribution), 0, 1)) _, indices = tf.nn.top_k(distribution +","mask_length > sequence_length: raise ValueError( f\"`mask_length` has to be smaller than `sequence_length`, but","of the tensors will not be guaranteed during the training. Args: func (`callable`):","\"\"\" TensorFlow Hubert model.\"\"\" import inspect import warnings from typing import Any, Dict,","is_instance_norm = (input_shape[self.axis] // self.groups) == 1 if not is_instance_norm: broadcast_shape[self.axis] = input_shape[self.axis]","tgt_len, self.head_dim], message=f\"`attn_output` should be of size {(bsz, self.num_heads, tgt_len, self.head_dim)}, but is","all previous decoder key/value_states. Further calls to uni-directional self-attention # can concat previous","name=f\"conv_layers.{i}\") for i in range(config.num_feat_extract_layers) ] else: raise ValueError( f\"`config.feat_extract_norm` is {config.feat_extract_norm}, but","the model. Returns: Two lists, one for the missing layers, and another one","= None, position_ids: Optional[tf.Tensor] = None, head_mask: Optional[tf.Tensor] = None, inputs_embeds: Optional[tf.Tensor] =","hidden_states def call( self, input_values: tf.Tensor, attention_mask: Optional[tf.Tensor] = None, token_type_ids: Optional[tf.Tensor] =","_set_number_of_groups_for_instance_norm(self, input_shape): dim = input_shape[self.axis] if self.groups == -1: self.groups = dim def","self.kernel = tf.transpose(kernel) def build(self, input_shape): if not self.built: input_shape = input_shape.as_list() #","chosen as start of the span to be masked. this will be multiplied","+ \") must be a \" \"multiple of the number of channels (\"","): inputs = input_values_processing( func=self.call, config=self.config, input_values=input_values, attention_mask=attention_mask, token_type_ids=token_type_ids, position_ids=position_ids, head_mask=head_mask, inputs_embeds=inputs_embeds, output_attentions=output_attentions,","Optional[bool] = None, training: Optional[bool] = False, ) -> Union[TFCausalLMOutput, Tuple[tf.Tensor]]: r\"\"\" labels","f\"Use `{self.__class__.__bases__[0].__name__}` instead.\", FutureWarning, ) class TFHubertFeatureProjection(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs): super().__init__(**kwargs)","the model in training mode (some modules like dropout modules have different behaviors","batch axis. Do you want to \" \"use tf.layer.batch_normalization instead\" ) def _create_input_spec(self,","groups, explicit_padding, **kwargs): super().__init__( filters=filters, kernel_size=kernel_size, groups=groups, padding=\"valid\", use_bias=True, bias_initializer=\"he_normal\", **kwargs, ) self.explicit_padding","warnings.warn( f\"The class `{self.__class__.__name__}` has been depreciated \" \"and will be removed in","feature encoder so that its parameter will not be updated during training. \"\"\"","output_attentions: Optional[bool] = False, output_hidden_states: Optional[bool] = False, return_dict: Optional[bool] = True, training:","is not None: hidden_states = hidden_states * tf.expand_dims(attention_mask, -1) attention_mask = _expand_mask(attention_mask) else:","this file except in compliance with the License. # You may obtain a","without any specific head on top.\", HUBERT_START_DOCSTRING, ) class TFHubertModel(TFHubertPreTrainedModel): def __init__(self, config:","model call function: `model(inputs)`. If you choose this second option, there are three","`tf.Tensor` of shape `(num_heads,)` or `(num_layers, num_heads)`, *optional*): Mask to nullify selected heads","if not is_instance_norm: broadcast_shape[self.axis] = input_shape[self.axis] // self.groups broadcast_shape.insert(self.axis, self.groups) else: broadcast_shape[self.axis] =","= None, training: bool = False, ) -> Union[TFBaseModelOutput, Tuple[tf.Tensor]]: \"\"\" Returns: Example:","number of channels (\" + str(dim) + \").\" ) if dim % self.groups","to a *sentence B* token. [What are token type IDs?](../glossary#token-type-ids) position_ids (`np.ndarray` or","= None, output_attentions: Optional[bool] = None, labels: Optional[tf.Tensor] = None, output_hidden_states: Optional[bool] =","= hidden_states + position_embeddings hidden_states = self.dropout(hidden_states, training=training) for i, layer_module in enumerate(self.layer):","\"\"\" Calling this function will disable the gradient computation for the feature encoder","name=\"q_proj\") self.v_proj = tf.keras.layers.Dense(embed_dim, use_bias=bias, name=\"v_proj\") self.out_proj = tf.keras.layers.Dense(embed_dim, use_bias=bias, name=\"out_proj\") def _shape(self,","self.built: input_shape = input_shape.as_list() # Conv1D output shapes are checked at build time","behaviors between training and evaluation). \"\"\" @add_start_docstrings( \"The bare TFHubert Model transformer outputing","tf.keras.constraints.Constraint = None, **kwargs, ): super().__init__(**kwargs) self.supports_masking = True self.groups = groups self.axis","always be set to True. training (`bool`, *optional*, defaults to `False``): Whether or","self.conv(hidden_states) hidden_states = self.activation(hidden_states) return hidden_states # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2LayerNormConvLayer with Wav2Vec2->Hubert class","# from https://pytorch.org/docs/stable/generated/torch.nn.Conv1d.html return (input_length - kernel_size) // stride + 1 for kernel_size,","taken # from https://pytorch.org/docs/stable/generated/torch.nn.Conv1d.html return (input_length - kernel_size) // stride + 1 for","spec_aug_mask = tf.zeros((batch_size, sequence_length), dtype=tf.int32) # uniform distribution to sample from, make sure","Tensor if type(input) == tf.Tensor: # Tensor names have always the pattern `name:id`","self.feature_projection(hidden_states, training=inputs[\"training\"]) mask_time_indices = kwargs.get(\"mask_time_indices\", None) if inputs[\"training\"]: hidden_states = self._mask_hidden_states(hidden_states, mask_time_indices=mask_time_indices) encoder_outputs","attention_mask from `[bsz, seq_len]` to `[bsz, 1, tgt_seq_len, src_seq_len]`. \"\"\" src_len = shape_list(mask)[1]","tf.debugging asserts are not compliant with XLA then they # have to be","(logits,) + outputs[1:] return ((loss,) + output) if loss is not None else","= self.conv(hidden_states) hidden_states = self.padding(hidden_states) hidden_states = self.activation(hidden_states) return hidden_states # Copied from","past_key_value is not None: # reuse k,v, cross_attentions key_states = past_key_value[0] value_states =","\"Attention Is All You Need\"\"\" def __init__( self, embed_dim: int, num_heads: int, dropout:","super().call(padded_inputs) return output # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2NoLayerNormConvLayer with Wav2Vec2->Hubert class TFHubertNoLayerNormConvLayer(tf.keras.layers.Layer): def __init__(self,","self.dropout(hidden_states, training=training) hidden_states = attn_residual + hidden_states hidden_states = self.layer_norm(hidden_states) hidden_states = hidden_states","trainable=True, name=\"masked_spec_embed\" ) super().build(input_shape) def _get_feat_extract_output_lengths(self, input_lengths: tf.Tensor): \"\"\" Computes the output length","-> None: super().__init__(**kwargs) self.in_conv_dim = config.conv_dim[layer_id] if layer_id > 0 else 1 self.out_conv_dim","matter related to general usage and behavior. <Tip> TF 2.0 models accepts two","= self.layer_norm(hidden_states) hidden_states = self.activation(hidden_states) return hidden_states # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2GroupNormConvLayer with Wav2Vec2->Hubert","self.head_dim = embed_dim // num_heads if (self.head_dim * num_heads) != self.embed_dim: raise ValueError(","hidden_states + self.feed_forward(hidden_states) hidden_states = self.final_layer_norm(hidden_states) outputs = (hidden_states,) if output_attentions: outputs +=","a \" \"multiple of the number of channels (\" + str(dim) + \").\"","= conv_layer(hidden_states) return hidden_states class TFHubertFeatureExtractor(TFHubertFeatureEncoder): def __init__(self, config, **kwargs): super().__init__(config, **kwargs) warnings.warn(","- a single Tensor with `input_values` only and nothing else: `model(inputs_ids)` - a","0, 1)) _, indices = tf.nn.top_k(distribution + z, num_samples) return indices # Copied","training: Optional[bool] = False, ) -> Tuple[tf.Tensor, Optional[tf.Tensor]]: \"\"\"Input shape: Batch x Time","signature.pop(\"self\", None) parameter_names = list(signature.keys()) output = {} allowed_types = (tf.Tensor, bool, int,",">>> logits = model(input_values).logits >>> predicted_ids = tf.argmax(logits, axis=-1) >>> transcription = processor.decode(predicted_ids[0])","argument can be used only in eager mode, in graph mode the value","tf.broadcast_to(tf.expand_dims(tf.range(indices_shape[0]), axis=-1), indices_shape), [1, -1] ) # transform batch_indices to pair_indices pair_indices =","to labels_mask = tf.cast(labels >= 0, tf.int32) target_lengths = tf.reduce_sum(labels_mask, axis=-1) loss =","required by applicable law or agreed to in writing, software # distributed under","// 2, name=\"conv\", ) self.padding = TFHubertSamePadLayer(config.num_conv_pos_embeddings) self.activation = get_tf_activation(config.feat_extract_activation) def call(self, hidden_states:","hidden_states, ) elif self.config.mask_time_prob > 0: # generate indices & apply SpecAugment along","beta_regularizer: tf.keras.regularizers.Regularizer = None, gamma_regularizer: tf.keras.regularizers.Regularizer = None, beta_constraint: tf.keras.constraints.Constraint = None, gamma_constraint:","\" \"and will be removed in Transformers v5. \" f\"Use `{self.__class__.__bases__[0].__name__}` instead.\", FutureWarning,","output_hidden_states: all_hidden_states = all_hidden_states + (hidden_states,) if not return_dict: return tuple(v for v","(\" + str(self.groups) + \") cannot be \" \"more than the number of","not is_instance_norm: broadcast_shape[self.axis] = input_shape[self.axis] // self.groups broadcast_shape.insert(self.axis, self.groups) else: broadcast_shape[self.axis] = self.groups","self._init_norm() self.initialized = True self._normalize_kernel() padded_inputs = tf.pad(inputs, ((0, 0), (self.explicit_padding, self.explicit_padding), (0,","\"\"\"TFHubert Model with a `language modeling` head on top for Connectionist Temporal Classification","= tf.reshape(normalized_inputs, tensor_input_shape) else: outputs = normalized_inputs return outputs def get_config(self): config =","are not compliant with XLA then they # have to be disabled in","so that its parameters will not be updated during training. \"\"\" warnings.warn( \"The","for which to compute masks. should be of size 2 where first element","groups: int = 32, axis: int = -1, epsilon: float = 1e-3, center:","axis = -2 if self.axis == -1 else self.axis - 1 else: axis","mask of the same size as shape, which will prevent masking padded elements",">= 0, tf.int32) target_lengths = tf.reduce_sum(labels_mask, axis=-1) loss = tf.nn.ctc_loss( logits=logits, labels=labels, logit_length=input_lengths,","value in the config will be used instead. return_dict (`bool`, *optional*): Whether or","number of timesteps divided by length of mask span to mask approximately this","self.num_pad_remove = 1 if num_conv_pos_embeddings % 2 == 0 else 0 def call(self,","\"The bare TFHubert Model transformer outputing raw hidden-states without any specific head on","argument is deprecated and will be removed in a future version, use `input_values`","tf.Tensor: hidden_states = self.layer_norm(hidden_states) hidden_states = self.projection(hidden_states) hidden_states = self.dropout(hidden_states, training=training) return hidden_states","v is None: output[k] = v elif k not in parameter_names and \"args\"","TFHubertPositionalConvEmbedding(config, name=\"pos_conv_embed\") self.layer_norm = tf.keras.layers.LayerNormalization(epsilon=config.layer_norm_eps, name=\"layer_norm\") self.dropout = tf.keras.layers.Dropout(config.hidden_dropout) self.layer = [TFHubertEncoderLayer(config, name=f\"layers.{i}\")","HUBERT_START_DOCSTRING, ) class TFHubertModel(TFHubertPreTrainedModel): def __init__(self, config: HubertConfig, *inputs, **kwargs): super().__init__(config, *inputs, **kwargs)","tf.keras.regularizers.get(gamma_regularizer) self.beta_constraint = tf.keras.constraints.get(beta_constraint) self.gamma_constraint = tf.keras.constraints.get(gamma_constraint) self._check_axis() def build(self, input_shape): self._check_if_input_shape_is_none(input_shape) self._set_number_of_groups_for_instance_norm(input_shape)","query_states = self.q_proj(hidden_states) * self.scaling # get key, value proj if is_cross_attention and","as target processor to encode labels >>> with processor.as_target_processor(): ... labels = processor(transcription,","layer # for the decoder is_cross_attention = key_value_states is not None bsz, tgt_len,","= tf.nn.top_k(distribution + z, num_samples) return indices # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2._scatter_values_on_batch_indices def _scatter_values_on_batch_indices(values,","is not allowed only {allowed_types} is accepted for {k}.\") if isinstance(input_values, (tuple, list)):","from ...utils import ( ModelOutput, add_start_docstrings, add_start_docstrings_to_model_forward, logging, replace_return_docstrings, ) from .configuration_hubert import","{parameter_names[i]}.\" ) elif isinstance(input_values, (dict, BatchEncoding)): if \"inputs\" in input_values: warnings.warn( \"The `inputs`","layer_id=i, name=f\"conv_layers.{i}\") for i in range(config.num_feat_extract_layers) ] else: raise ValueError( f\"`config.feat_extract_norm` is {config.feat_extract_norm},","be guaranteed during the training. Args: func (`callable`): The callable function of the","mode (some modules like dropout modules have different behaviors between training and evaluation).","attention key/value_states. # Further calls to cross_attention layer can then reuse all cross-attention","self-attention `past_key_value` is always `None` past_key_value = (key_states, value_states) proj_shape = (bsz *","in the first positional arguments. This second option is useful when using [`tf.keras.Model.fit`]","replacement is currently not implemented. The gumbel-max trick will do for now -",">>> model = TFHubertForCTC.from_pretrained(\"facebook/hubert-base-960h\") >>> def map_to_array(batch): ... speech, _ = sf.read(batch[\"file\"]) ...","if output[\"args\"] is not None and type(output[\"args\"]) == tf.Tensor: tensor_name = output[\"args\"].name.split(\":\")[0] output[tensor_name]","self.hubert = TFHubertMainLayer(config, name=\"hubert\") self.dropout = tf.keras.layers.Dropout(config.final_dropout) self.lm_head = tf.keras.layers.Dense(config.vocab_size, name=\"lm_head\") def freeze_feature_extractor(self):","input_lengths def _mask_hidden_states(self, hidden_states: tf.Tensor, mask_time_indices: Optional[tf.Tensor] = None): \"\"\" Masks extracted features","from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2WeightNormConv1D with Wav2Vec2->Hubert class TFHubertWeightNormConv1D(tf.keras.layers.Conv1D): \"\"\"Adapted from https://www.tensorflow.org/probability/api_docs/python/tfp/layers/weight_norm/WeightNorm\"\"\" def __init__(self, filters, kernel_size,","as sf >>> processor = Wav2Vec2Processor.from_pretrained(\"facebook/hubert-base-960h\") >>> model = TFHubertModel.from_pretrained(\"facebook/hubert-base-960h\") >>> def map_to_array(batch):","use_bias=config.conv_bias, name=\"conv\", ) self.activation = get_tf_activation(config.feat_extract_activation) def call(self, hidden_states: tf.Tensor) -> tf.Tensor: hidden_states","tf.reshape(attn_output, (bsz, self.num_heads, tgt_len, self.head_dim)), (0, 2, 1, 3) ) attn_output = tf.reshape(attn_output,","= r\"\"\" Args: input_values (`np.ndarray`, `tf.Tensor`, `List[tf.Tensor]` ``Dict[str, tf.Tensor]` or `Dict[str, np.ndarray]` and","a TPU\" ) @tf.function def serving(self, inputs): output = self.call(input_values=inputs, training=False) return self.serving_output(output)","Optionally, instead of passing `input_values` you can choose to directly pass an embedded","None else output return TFCausalLMOutput( loss=loss, logits=logits, hidden_states=outputs.hidden_states, attentions=outputs.attentions, ) def serving_output(self, output:","- 1) ] elif config.feat_extract_norm == \"layer\": conv_layers = [ TFHubertLayerNormConvLayer(config, layer_id=i, name=f\"conv_layers.{i}\")","tgt_len if tgt_len is not None else src_len one_cst = tf.constant(1.0) mask =","tensor_name = output[\"args\"].name.split(\":\")[0] output[tensor_name] = output[\"args\"] else: # `args` in this case is","self, embed_dim: int, num_heads: int, dropout: float = 0.0, is_decoder: bool = False,","parameter will not be updated during training. \"\"\" self.hubert.feature_extractor.trainable = False @add_start_docstrings_to_model_forward(HUBERT_INPUTS_DOCSTRING) @replace_return_docstrings(output_type=TFCausalLMOutput,","input_shape = input_shape.as_list() # Conv1D output shapes are checked at build time since","explicit_padding self.filter_axis = 2 self.initialized = False self.kernel_norm_axes = tf.constant([0, 1]) def _init_norm(self):","HUBERT_START_DOCSTRING, ) class TFHubertForCTC(TFHubertPreTrainedModel): def __init__(self, config: HubertConfig, *inputs, **kwargs): super().__init__(config, *inputs, **kwargs)","speech, _ = sf.read(batch[\"file\"]) ... batch[\"speech\"] = speech ... return batch >>> ds","{allowed_types} is accepted for {k}.\") if isinstance(input_values, (tuple, list)): for i, input in","= False) -> tf.Tensor: hidden_states = self.layer_norm(hidden_states) hidden_states = self.projection(hidden_states) hidden_states = self.dropout(hidden_states,","**config} def compute_output_shape(self, input_shape): return input_shape def _reshape_into_groups(self, inputs, input_shape, tensor_input_shape): group_shape =","of the number of channels (\" + str(dim) + \").\" ) def _check_axis(self):","tf.argmax(logits, axis=-1) >>> transcription = processor.decode(predicted_ids[0]) >>> # compute loss >>> target_transcription =","`tf.Tensor` of shape `({0})`, *optional*): Segment token indices to indicate first and second","indicates the head is **masked**. inputs_embeds (`np.ndarray` or `tf.Tensor` of shape `({0}, hidden_size)`,","if inputs[\"output_hidden_states\"] else self.config.output_hidden_states ) inputs[\"output_attentions\"] = ( inputs[\"output_attentions\"] if inputs[\"output_attentions\"] else self.config.output_attentions","self.add_weight( shape=shape, name=\"beta\", initializer=self.beta_initializer, regularizer=self.beta_regularizer, constraint=self.beta_constraint, ) else: self.beta = None def _create_broadcast_shape(self,","only and nothing else: `model(inputs_ids)` - a list of varying length with one","config=self.config, input_values=input_values, attention_mask=attention_mask, token_type_ids=token_type_ids, position_ids=position_ids, head_mask=head_mask, inputs_embeds=inputs_embeds, output_attentions=output_attentions, output_hidden_states=output_hidden_states, return_dict=return_dict, training=training, ) outputs","for {parameter_names[i]}.\" ) elif isinstance(input_values, (dict, BatchEncoding)): if \"inputs\" in input_values: warnings.warn( \"The","then we check only the # `name` part tensor_name = input.name.split(\":\")[0] if tensor_name","= [ TFHubertEncoderLayerStableLayerNorm(config, name=f\"layers.{i}\") for i in range(config.num_hidden_layers) ] def call( self, hidden_states:","filters=config.hidden_size, kernel_size=config.num_conv_pos_embeddings, groups=config.num_conv_pos_embedding_groups, explicit_padding=config.num_conv_pos_embeddings // 2, name=\"conv\", ) self.padding = TFHubertSamePadLayer(config.num_conv_pos_embeddings) self.activation =","for all matter related to general usage and behavior. <Tip> TF 2.0 models","inputs[\"output_attentions\"] if inputs[\"output_attentions\"] else self.config.output_attentions ) inputs[\"return_dict\"] = inputs[\"return_dict\"] if inputs[\"return_dict\"] else self.config.return_dict","TFHubertEncoderStableLayerNorm(config, name=\"encoder\") else: self.encoder = TFHubertEncoder(config, name=\"encoder\") def build(self, input_shape: tf.TensorShape): self.masked_spec_embed =","Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2GroupNorm with Wav2Vec2->Hubert class TFHubertGroupNorm(tf.keras.layers.Layer): \"\"\" From tensorflow-addons https://www.tensorflow.org/addons/api_docs/python/tfa/layers/GroupNormalization \"\"\" def","= TFHubertFeedForward(config, name=\"feed_forward\") self.final_layer_norm = tf.keras.layers.LayerNormalization( epsilon=config.layer_norm_eps, name=\"final_layer_norm\" ) def call( self, hidden_states:","self.out_conv_dim = config.conv_dim[layer_id] self.conv = tf.keras.layers.Conv1D( filters=self.out_conv_dim, kernel_size=config.conv_kernel[layer_id], strides=config.conv_stride[layer_id], use_bias=config.conv_bias, name=\"conv\", ) self.activation","hidden_states = self.feature_extractor( tf.cast(inputs[\"input_values\"], tf.float32), training=inputs[\"training\"] ) if inputs[\"attention_mask\"] is not None: #","output_attentions: Optional[bool] = None, labels: Optional[tf.Tensor] = None, output_hidden_states: Optional[bool] = None, return_dict:","self.num_heads, tgt_len, self.head_dim)}, but is {shape_list(attn_output)}\", ) attn_output = tf.transpose( tf.reshape(attn_output, (bsz, self.num_heads,","to indices_shape broad_casted_batch_dims = tf.reshape( tf.broadcast_to(tf.expand_dims(tf.range(indices_shape[0]), axis=-1), indices_shape), [1, -1] ) # transform","2.0 Keras Model and refer to the TF 2.0 documentation for all matter","be one of ['group', 'layer']\" ) self.conv_layers = conv_layers def call(self, input_values): hidden_states","transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2NoLayerNormConvLayer with Wav2Vec2->Hubert class TFHubertNoLayerNormConvLayer(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, layer_id: int = 0,","# Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2GroupNormConvLayer with Wav2Vec2->Hubert class TFHubertGroupNormConvLayer(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, layer_id:","output shapes are checked at build time since TF 2.7, so we need","= input_shape[self.axis] self.input_spec = tf.keras.layers.InputSpec(ndim=len(input_shape), axes={self.axis: dim}) def _add_gamma_weight(self, input_shape): dim = input_shape[self.axis]","...utils import ( ModelOutput, add_start_docstrings, add_start_docstrings_to_model_forward, logging, replace_return_docstrings, ) from .configuration_hubert import HubertConfig","raise ValueError(f\"Data of type {type(v)} is not allowed only {allowed_types} is accepted for","training: bool = False) -> tf.Tensor: hidden_states = self.intermediate_dense(hidden_states) hidden_states = self.intermediate_act_fn(hidden_states) hidden_states","self, hidden_states: tf.Tensor, key_value_states: Optional[tf.Tensor] = None, past_key_value: Optional[Tuple[Tuple[tf.Tensor]]] = None, attention_mask: Optional[tf.Tensor]","self._normalize_kernel() padded_inputs = tf.pad(inputs, ((0, 0), (self.explicit_padding, self.explicit_padding), (0, 0))) output = super().call(padded_inputs)","be removed in a future version, use `past_key_values` instead.\", FutureWarning, ) output[\"past_key_values\"] =","http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing,","self.masked_spec_embed[tf.newaxis, tf.newaxis, :], hidden_states, ) # apply SpecAugment along feature axis if self.config.mask_feature_prob","func=self.call, config=self.config, input_values=input_values, attention_mask=attention_mask, token_type_ids=token_type_ids, position_ids=position_ids, head_mask=head_mask, inputs_embeds=inputs_embeds, output_attentions=output_attentions, output_hidden_states=output_hidden_states, return_dict=return_dict, training=training, kwargs_call=kwargs,","in writing, software # distributed under the License is distributed on an \"AS","past_key_value[1] elif is_cross_attention: # cross_attentions key_states = self._shape(self.k_proj(key_value_states), -1, bsz) value_states = self._shape(self.v_proj(key_value_states),","= self.feature_extractor( tf.cast(inputs[\"input_values\"], tf.float32), training=inputs[\"training\"] ) if inputs[\"attention_mask\"] is not None: # compute","use_bias=config.conv_bias, name=\"conv\", ) self.layer_norm = tf.keras.layers.LayerNormalization(name=\"layer_norm\", epsilon=config.layer_norm_eps) self.activation = get_tf_activation(config.feat_extract_activation) def call(self, hidden_states:","mask_time_indices=mask_time_indices) encoder_outputs = self.encoder( hidden_states, attention_mask=attention_mask, output_attentions=inputs[\"output_attentions\"], output_hidden_states=inputs[\"output_hidden_states\"], return_dict=inputs[\"return_dict\"], training=inputs[\"training\"], ) hidden_states =","k, v in dict(input_values).items(): if isinstance(v, allowed_types) or v is None: output[k] =",") self.intermediate_act_fn = get_tf_activation(config.hidden_act) self.output_dense = tf.keras.layers.Dense( units=config.hidden_size, kernel_initializer=get_initializer(config.initializer_range), bias_initializer=\"zeros\", name=\"output_dense\", ) self.output_dropout","using [`tf.keras.Model.fit`] method which currently requires having all the tensors in the first","query proj query_states = self.q_proj(hidden_states) * self.scaling # get key, value proj if","= False, ) -> Union[TFBaseModelOutput, Tuple[tf.Tensor]]: all_hidden_states = () if output_hidden_states else None","how to convert `input_values` indices into associated vectors than the model's internal embedding","self.gamma = self.add_weight( shape=shape, name=\"gamma\", initializer=self.gamma_initializer, regularizer=self.gamma_regularizer, constraint=self.gamma_constraint, ) else: self.gamma = None","} output.update(booleans_processing(config=config, **boolean_dict)) return output # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2._sample_without_replacement def _sample_without_replacement(distribution, num_samples): \"\"\"","and refer to the TF 2.0 documentation for all matter related to general","argument is deprecated and will be removed in a future version, use `past_key_values`","(layer_outputs[1],) hidden_states = self.layer_norm(hidden_states) if output_hidden_states: all_hidden_states = all_hidden_states + (hidden_states,) if not","self.embed_dim = embed_dim self.num_heads = num_heads self.dropout = tf.keras.layers.Dropout(dropout) self.head_dim = embed_dim //","super().__init__(config, *inputs, **kwargs) logger.warning( f\"\\n{self.__class__.__name__} has backpropagation operations that are NOT supported on","serving_output(self, output: TFCausalLMOutput) -> TFCausalLMOutput: hs = tf.convert_to_tensor(output.hidden_states) if self.config.output_hidden_states else None attns","tuple or dict in the first positional arguments. This second option is useful","as in PyTorch with indices in format (batch_dim, indixes) \"\"\" indices_shape = shape_list(batch_indices)","name=\"conv\", ) self.activation = get_tf_activation(config.feat_extract_activation) self.layer_norm = TFHubertGroupNorm(groups=self.out_conv_dim, epsilon=config.layer_norm_eps, name=\"layer_norm\") def call(self, hidden_states:","gradient computation for the feature encoder so that its parameters will not be","ValueError( f\"embed_dim must be divisible by num_heads (got `embed_dim`: {self.embed_dim}\" f\" and `num_heads`:","along feature axis if self.config.mask_feature_prob > 0: mask_feature_indices = _compute_mask_indices( (batch_size, hidden_size), mask_prob=self.config.mask_feature_prob,","calls to cross_attention layer can then reuse all cross-attention # key/value_states (first \"if\"","TFHubertFeatureProjection(config, name=\"feature_projection\") if config.do_stable_layer_norm: self.encoder = TFHubertEncoderStableLayerNorm(config, name=\"encoder\") else: self.encoder = TFHubertEncoder(config, name=\"encoder\")","for i in range(config.num_hidden_layers) ] def call( self, hidden_states: tf.Tensor, attention_mask: Optional[tf.Tensor] =","hidden_states = self.dropout(hidden_states, training=inputs[\"training\"]) logits = self.lm_head(hidden_states) if labels is not None: if","True, scale: bool = True, beta_initializer: tf.keras.initializers.Initializer = \"zeros\", gamma_initializer: tf.keras.initializers.Initializer = \"ones\",","will be removed in a future version, use `past_key_values` instead.\", FutureWarning, ) output[\"past_key_values\"]","self.pos_conv_embed = TFHubertPositionalConvEmbedding(config, name=\"pos_conv_embed\") self.layer_norm = tf.keras.layers.LayerNormalization(epsilon=config.layer_norm_eps, name=\"layer_norm\") self.dropout = tf.keras.layers.Dropout(config.hidden_dropout) self.layer =","import load_dataset >>> import soundfile as sf >>> processor = Wav2Vec2Processor.from_pretrained(\"facebook/hubert-base-960h\") >>> model","None bsz, tgt_len, embed_dim = shape_list(hidden_states) # get query proj query_states = self.q_proj(hidden_states)","2.0 (the \"License\"); # you may not use this file except in compliance","must be divisible by num_heads (got `embed_dim`: {self.embed_dim}\" f\" and `num_heads`: {num_heads}).\" )","(`np.ndarray` or `tf.Tensor` of shape `({0})`, *optional*): Indices of positions of each input","cross_attentions key_states = past_key_value[0] value_states = past_key_value[1] elif is_cross_attention: # cross_attentions key_states =","if attention_mask is not None: # The tf.debugging asserts are not compliant with","tf.keras.regularizers.serialize(self.beta_regularizer), \"gamma_regularizer\": tf.keras.regularizers.serialize(self.gamma_regularizer), \"beta_constraint\": tf.keras.constraints.serialize(self.beta_constraint), \"gamma_constraint\": tf.keras.constraints.serialize(self.gamma_constraint), } base_config = super().get_config() return {**base_config,","uniform_dist = tf.ones((batch_size, sequence_length - (mask_length - 1))) # get random indices to","= False, ) -> Tuple[tf.Tensor]: attn_residual = hidden_states hidden_states, attn_weights, _ = self.attention(","self.groups broadcast_shape.insert(self.axis, self.groups) else: broadcast_shape[self.axis] = self.groups return broadcast_shape # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2WeightNormConv1D","**kwargs) self.hubert = TFHubertMainLayer(config, name=\"hubert\") self.dropout = tf.keras.layers.Dropout(config.final_dropout) self.lm_head = tf.keras.layers.Dense(config.vocab_size, name=\"lm_head\") def","of timesteps divided by length of mask span to mask approximately this percentage","...modeling_tf_utils import TFPreTrainedModel, booleans_processing, get_initializer, keras_serializable from ...tf_utils import shape_list from ...tokenization_utils_base import","> 0 else 1 self.out_conv_dim = config.conv_dim[layer_id] self.conv = tf.keras.layers.Conv1D( filters=self.out_conv_dim, kernel_size=config.conv_kernel[layer_id], strides=config.conv_stride[layer_id],","express or implied. # See the License for the specific language governing permissions","of passing `input_values` you can choose to directly pass an embedded representation. This","Tensors associated to the input names given in the docstring: `model({\"input_values\": input_values, \"token_type_ids\":","number of masked spans Adapted from [fairseq's data_utils.py](https://github.com/pytorch/fairseq/blob/e0788f7007a8473a76db573985031f3c94201e79/fairseq/data/data_utils.py#L376). \"\"\" batch_size, sequence_length = shape","import soundfile as sf >>> processor = Wav2Vec2Processor.from_pretrained(\"facebook/hubert-base-960h\") >>> model = TFHubertModel.from_pretrained(\"facebook/hubert-base-960h\") >>>","TFCausalLMOutput from ...modeling_tf_utils import TFPreTrainedModel, booleans_processing, get_initializer, keras_serializable from ...tf_utils import shape_list from","uni-directional self-attention # can concat previous decoder key/value_states to current projected key/value_states (third","and nothing else: `model(inputs_ids)` - a list of varying length with one or","super().__init__(config, *inputs, **kwargs) self.hubert = TFHubertMainLayer(config, name=\"hubert\") self.dropout = tf.keras.layers.Dropout(config.final_dropout) self.lm_head = tf.keras.layers.Dense(config.vocab_size,","False, **kwargs: Any, ): inputs = input_values_processing( func=self.call, config=self.config, input_values=input_values, attention_mask=attention_mask, token_type_ids=token_type_ids, position_ids=position_ids,","tokens are filled with -100 # when not being attended to labels_mask =","beta_initializer: tf.keras.initializers.Initializer = \"zeros\", gamma_initializer: tf.keras.initializers.Initializer = \"ones\", beta_regularizer: tf.keras.regularizers.Regularizer = None, gamma_regularizer:","# if encoder bi-directional self-attention `past_key_value` is always `None` past_key_value = (key_states, value_states)","self.hubert._get_feat_extract_output_lengths(tf.reduce_sum(attention_mask, axis=-1)) # assuming that padded tokens are filled with -100 # when","broadcast_shape) if self.center: beta = tf.reshape(self.beta, broadcast_shape) return gamma, beta def _check_if_input_shape_is_none(self, input_shape):","1, 1), initializer=\"ones\", dtype=self.weight_v.dtype, trainable=True, ) self.bias = self.add_weight(name=\"bias\", shape=(self.filters,), initializer=\"zeros\", trainable=True) def","= tf.nn.moments(reshaped_inputs, group_reduction_axes, keepdims=True) gamma, beta = self._get_reshaped_weights(input_shape) normalized_inputs = tf.nn.batch_normalization( reshaped_inputs, mean=mean,","attn_weights = tf.nn.softmax(attn_weights, axis=-1) if layer_head_mask is not None: # The tf.debugging asserts","PyTorch models), or - having all inputs as a list, tuple or dict","elif config.feat_extract_norm == \"layer\": conv_layers = [ TFHubertLayerNormConvLayer(config, layer_id=i, name=f\"conv_layers.{i}\") for i in","each example must have the shape `({0})`): Indices of input sequence tokens in","\" \"more than the number of channels (\" + str(dim) + \").\" )","= self._create_broadcast_shape(input_shape) gamma = None beta = None if self.scale: gamma = tf.reshape(self.gamma,","__init__(self, config, *inputs, **kwargs): super().__init__(config, *inputs, **kwargs) logger.warning( f\"\\n{self.__class__.__name__} has backpropagation operations that","output[\"args\"] else: # `args` in this case is always the first parameter, then","Returns: Example: ```python >>> import tensorflow as tf >>> from transformers import Wav2Vec2Processor,","use the equivalent `freeze_feature_encoder` method instead.\", FutureWarning, ) self.freeze_feature_encoder() def freeze_feature_encoder(self): \"\"\" Calling","tf.Tensor]: pad_token = 0.0 input_values = tf.convert_to_tensor(np.random.rand(1, 16000), tf.float32) dummy_inputs = { \"input_values\":","has to be bigger than 0.\") if mask_length > sequence_length: raise ValueError( f\"`mask_length`","configuration class with all the parameters of the model. Initializing with a config","bool = False, **kwargs: Any, ): inputs = input_values_processing( func=self.call, config=self.config, input_values=input_values, attention_mask=attention_mask,","should be of size 2 where first element is batch size and 2nd","{shape_list(attention_mask)}\", ) attention_mask = tf.cast(attention_mask, dtype=attn_weights.dtype) attn_weights = tf.reshape(attn_weights, (bsz, self.num_heads, tgt_len, src_len))","1 for kernel_size, stride in zip(self.config.conv_kernel, self.config.conv_stride): input_lengths = _conv_out_length(input_lengths, kernel_size, stride) return","# # Licensed under the Apache License, Version 2.0 (the \"License\"); # you","(\" + str(dim) + \").\" ) if dim % self.groups != 0: raise","processor.as_target_processor(): ... labels = processor(transcription, return_tensors=\"tf\").input_values >>> loss = model(input_values, labels=labels).loss ```\"\"\" inputs","return_dict: Optional[bool] = True, training: Optional[bool] = False, ) -> Union[TFBaseModelOutput, Tuple[tf.Tensor]]: all_hidden_states","that offset samples are < sequence_length uniform_dist = tf.ones((batch_size, sequence_length - (mask_length -","* tf.reshape( attn_weights, (bsz, self.num_heads, tgt_len, src_len) ) attn_weights = tf.reshape(attn_weights, (bsz *","self.intermediate_dropout(hidden_states, training=training) hidden_states = self.output_dense(hidden_states) hidden_states = self.output_dropout(hidden_states, training=training) return hidden_states # Copied","self.config.ctc_loss_reduction == \"mean\": loss = tf.reduce_mean(loss) else: loss = None if not inputs[\"return_dict\"]:","\"token_type_ids\": token_type_ids})` </Tip> Args: config ([`HubertConfig`]): Model configuration class with all the parameters","= None, token_type_ids: Optional[tf.Tensor] = None, position_ids: Optional[tf.Tensor] = None, head_mask: Optional[tf.Tensor] =","# Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2EncoderLayerStableLayerNorm with Wav2Vec2->Hubert class TFHubertEncoderLayerStableLayerNorm(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs):","accepts two formats as inputs: - having all inputs as keyword arguments (like","ORDER given in the docstring: `model([input_values, attention_mask])` or `model([input_values, attention_mask, token_type_ids])` - a","\"kwargs\" in output: del output[\"kwargs\"] boolean_dict = { k: v for k, v","hidden-states without any specific head on top.\", HUBERT_START_DOCSTRING, ) class TFHubertModel(TFHubertPreTrainedModel): def __init__(self,","position_ids: Optional[tf.Tensor] = None, head_mask: Optional[tf.Tensor] = None, inputs_embeds: Optional[tf.Tensor] = None, output_attentions:","= False @add_start_docstrings_to_model_forward(HUBERT_INPUTS_DOCSTRING) @replace_return_docstrings(output_type=TFCausalLMOutput, config_class=_CONFIG_FOR_DOC) def call( self, input_values: tf.Tensor, attention_mask: Optional[tf.Tensor] =","only {allowed_types} is accepted for {k}.\") if isinstance(input_values, (tuple, list)): for i, input","output_attentions=output_attentions, output_hidden_states=output_hidden_states, return_dict=return_dict, training=training, ) inputs[\"output_hidden_states\"] = ( inputs[\"output_hidden_states\"] if inputs[\"output_hidden_states\"] else self.config.output_hidden_states","attention_mask: Optional[tf.Tensor] = None, token_type_ids: Optional[tf.Tensor] = None, position_ids: Optional[tf.Tensor] = None, head_mask:","tf.sequence_mask( output_lengths, maxlen=shape_list(hidden_states)[1], dtype=hidden_states.dtype ) hidden_states = self.feature_projection(hidden_states, training=inputs[\"training\"]) mask_time_indices = kwargs.get(\"mask_time_indices\", None)","= self.padding(hidden_states) hidden_states = self.activation(hidden_states) return hidden_states # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2SamePadLayer with Wav2Vec2->Hubert","hidden_states * tf.expand_dims(attention_mask, -1) attention_mask = _expand_mask(attention_mask) else: attention_mask = None position_embeddings =","training=training) return hidden_states # Copied from transformers.models.bart.modeling_tf_bart.TFBartAttention with TFBart->TFHubert class TFHubertAttention(tf.keras.layers.Layer): \"\"\"Multi-headed attention","that its parameters will not be updated during training. \"\"\" warnings.warn( \"The method","str(self.groups) + \") cannot be \" \"more than the number of channels (\"","int = 0): \"\"\" Expands attention_mask from `[bsz, seq_len]` to `[bsz, 1, tgt_seq_len,","v in kwargs.items(): if isinstance(v, allowed_types) or v is None: output[k] = v","in the docstring: `model({\"input_values\": input_values, \"token_type_ids\": token_type_ids})` </Tip> Args: config ([`HubertConfig`]): Model configuration","_expand_mask(mask: tf.Tensor, tgt_len: Optional[int] = None, past_key_values_length: int = 0): \"\"\" Expands attention_mask","func=self.call, config=self.config, input_values=input_values, attention_mask=attention_mask, token_type_ids=token_type_ids, position_ids=position_ids, head_mask=head_mask, inputs_embeds=inputs_embeds, output_attentions=output_attentions, output_hidden_states=output_hidden_states, return_dict=return_dict, training=training, )","**kwargs: The inputs of the model. Returns: Two lists, one for the missing","downloading and loading pretrained models. \"\"\" config_class = HubertConfig base_model_prefix = \"hubert\" main_input_name","mask_time_indices: Optional[tf.Tensor] = None): \"\"\" Masks extracted features along time axis and/or along","first parameter, then `input_values` output[\"input_values\"] = output[\"args\"] del output[\"args\"] if \"kwargs\" in output:","== 1 if not is_instance_norm: outputs = tf.reshape(normalized_inputs, tensor_input_shape) else: outputs = normalized_inputs","type {type(v)} is not allowed only {allowed_types} is accepted for {k}.\") if isinstance(input_values,","SpecAugment along time axis with given mask_time_indices hidden_states = tf.where( tf.cast(mask_time_indices[:, :, tf.newaxis],","return tf.scatter_nd(pair_indices, tf.reshape(values, [-1]), output_shape) # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2._compute_mask_indices def _compute_mask_indices( shape: Tuple[int,","f\"The class `{self.__class__.__name__}` has been depreciated \" \"and will be removed in Transformers","a `language modeling` head on top for Connectionist Temporal Classification (CTC).\"\"\", HUBERT_START_DOCSTRING, )","input_values, \"attention_mask\": tf.cast(tf.not_equal(input_values, pad_token), tf.float32), } return dummy_inputs def __init__(self, config, *inputs, **kwargs):","(input_shape[self.axis] // self.groups) == 1 if not is_instance_norm: broadcast_shape[self.axis] = input_shape[self.axis] // self.groups","* self.scaling # get key, value proj if is_cross_attention and past_key_value is not","\"\"\" HUBERT_INPUTS_DOCSTRING = r\"\"\" Args: input_values (`np.ndarray`, `tf.Tensor`, `List[tf.Tensor]` ``Dict[str, tf.Tensor]` or `Dict[str,","is **masked**. inputs_embeds (`np.ndarray` or `tf.Tensor` of shape `({0}, hidden_size)`, *optional*): Optionally, instead","tf.newaxis, :], hidden_states, ) # apply SpecAugment along feature axis if self.config.mask_feature_prob >","src_len], message=f\"Attention weights should be of size {(bsz * self.num_heads, tgt_len, src_len)}, but","\"Number of groups (\" + str(self.groups) + \") must be a \" \"multiple","inputs[\"output_hidden_states\"] if inputs[\"output_hidden_states\"] else self.config.output_hidden_states ) inputs[\"output_attentions\"] = ( inputs[\"output_attentions\"] if inputs[\"output_attentions\"] else","labels=labels).loss ```\"\"\" inputs = input_values_processing( func=self.call, config=self.config, input_values=input_values, attention_mask=attention_mask, token_type_ids=token_type_ids, position_ids=position_ids, head_mask=head_mask, inputs_embeds=inputs_embeds,","input_values_processing( func=self.call, config=self.config, input_values=input_values, attention_mask=attention_mask, token_type_ids=token_type_ids, position_ids=position_ids, head_mask=head_mask, inputs_embeds=inputs_embeds, output_attentions=output_attentions, output_hidden_states=output_hidden_states, return_dict=return_dict, training=training,","= tf.where(mask_feature_indices[:, tf.newaxis, :], hidden_states, 0) return hidden_states def call( self, input_values: tf.Tensor,","but is {shape_list(attn_weights)}\", ) if attention_mask is not None: # The tf.debugging asserts","training=training) hidden_states = self.output_dense(hidden_states) hidden_states = self.output_dropout(hidden_states, training=training) return hidden_states # Copied from",">>> with processor.as_target_processor(): ... labels = processor(transcription, return_tensors=\"tf\").input_values >>> loss = model(input_values, labels=labels).loss","except in compliance with the License. # You may obtain a copy of","for more info \"\"\" z = -tf.math.log(tf.random.uniform(shape_list(distribution), 0, 1)) _, indices = tf.nn.top_k(distribution","tf.keras.layers.LayerNormalization( epsilon=config.layer_norm_eps, name=\"final_layer_norm\" ) def call( self, hidden_states: tf.Tensor, attention_mask: Optional[tf.Tensor] = None,","split=\"validation\") >>> ds = ds.map(map_to_array) >>> input_values = processor(ds[\"speech\"][0], return_tensors=\"tf\").input_values # Batch size",") -> tf.Tensor: \"\"\" Computes random mask spans for a given shape Args:",") hidden_states = self.dropout(hidden_states, training=training) hidden_states = attn_residual + hidden_states hidden_states = hidden_states","See `attentions` under returned tensors for more detail. This argument can be used","Union[TFBaseModelOutput, Tuple[tf.Tensor]]: \"\"\" Returns: Example: ```python >>> from transformers import Wav2Vec2Processor, TFHubertModel >>>","tf from ...activations_tf import get_tf_activation from ...modeling_tf_outputs import TFBaseModelOutput, TFCausalLMOutput from ...modeling_tf_utils import","self.weight_v = self.kernel self.weight_g = self.add_weight( name=\"weight_g\", shape=(int(self.weight_v.shape[self.filter_axis]), 1, 1), initializer=\"ones\", dtype=self.weight_v.dtype, trainable=True,","# get random indices to mask spec_aug_mask_idxs = _sample_without_replacement(uniform_dist, num_masked_spans) # expand masked","super().__init__(**kwargs) self.num_pad_remove = 1 if num_conv_pos_embeddings % 2 == 0 else 0 def","compute masks. should be of size 2 where first element is batch size","num_masked_spans * mask_length)) offsets = tf.range(mask_length)[tf.newaxis, tf.newaxis, :] offsets = tf.tile(offsets, (batch_size, num_masked_spans,","= tf.convert_to_tensor(output.attentions) if self.config.output_attentions else None return TFBaseModelOutput(last_hidden_state=output.last_hidden_state, hidden_states=hs, attentions=attns) @add_start_docstrings( \"\"\"TFHubert Model","-> None: super().__init__(**kwargs) self.conv = TFHubertWeightNormConv1D( filters=config.hidden_size, kernel_size=config.num_conv_pos_embeddings, groups=config.num_conv_pos_embedding_groups, explicit_padding=config.num_conv_pos_embeddings // 2, name=\"conv\",","def call( self, hidden_states: tf.Tensor, attention_mask: Optional[tf.Tensor] = None, output_attentions: Optional[bool] = False,","Time x Channel\"\"\" # if key_value_states are provided this layer is used as","from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2SamePadLayer with Wav2Vec2->Hubert class TFHubertSamePadLayer(tf.keras.layers.Layer): def __init__(self, num_conv_pos_embeddings, **kwargs): super().__init__(**kwargs) self.num_pad_remove =","= tf.keras.layers.Conv1D( filters=self.out_conv_dim, kernel_size=config.conv_kernel[layer_id], strides=config.conv_stride[layer_id], use_bias=config.conv_bias, name=\"conv\", ) self.layer_norm = tf.keras.layers.LayerNormalization(name=\"layer_norm\", epsilon=config.layer_norm_eps) self.activation","token. [What are token type IDs?](../glossary#token-type-ids) position_ids (`np.ndarray` or `tf.Tensor` of shape `({0})`,","bsz) key_states = tf.concat([past_key_value[0], key_states], axis=2) value_states = tf.concat([past_key_value[1], value_states], axis=2) else: #","return_tensors=\"tf\").input_values # Batch size 1 >>> hidden_states = model(input_values).last_hidden_state ```\"\"\" inputs = input_values_processing(","super().__init__(**kwargs) self.config = config self.pos_conv_embed = TFHubertPositionalConvEmbedding(config, name=\"pos_conv_embed\") self.layer_norm = tf.keras.layers.LayerNormalization(epsilon=config.layer_norm_eps, name=\"layer_norm\") self.dropout","in range(config.num_hidden_layers) ] def call( self, hidden_states: tf.Tensor, attention_mask: Optional[tf.Tensor] = None, output_attentions:","input_shape): dim = input_shape[self.axis] shape = (dim,) if self.center: self.beta = self.add_weight( shape=shape,","output[parameter_names[0]] = input_values else: raise ValueError( f\"Data of type {type(input_values)} is not allowed","= 1e-3, center: bool = True, scale: bool = True, beta_initializer: tf.keras.initializers.Initializer =",".configuration_hubert import HubertConfig logger = logging.get_logger(__name__) _CONFIG_FOR_DOC = \"HubertConfig\" TF_HUBERT_PRETRAINED_MODEL_ARCHIVE_LIST = [ \"facebook/hubert-base-ls960\",","which will prevent masking padded elements mask_prob: probability for each token to be","disable the gradient computation for the feature encoder so that its parameters will","-> TFCausalLMOutput: hs = tf.convert_to_tensor(output.hidden_states) if self.config.output_hidden_states else None attns = tf.convert_to_tensor(output.attentions) if","documentation for the generic methods the library implements for all its model (such","model. config ([`PretrainedConfig`]): The config of the running model. **kwargs: The inputs of","size 2 where first element is batch size and 2nd is timesteps attention_mask:","name != \"args\": output[name] = kwargs.pop(name, signature[name].default) # When creating a SavedModel TF","of the model. Returns: Two lists, one for the missing layers, and another","TFHubertMainLayer(tf.keras.layers.Layer): config_class = HubertConfig def __init__(self, config: HubertConfig, **kwargs): super().__init__(**kwargs) self.config = config","of symbolic inputs, each input has to be named accordingly to the parameters","elif self.config.mask_time_prob > 0: # generate indices & apply SpecAugment along time axis","hidden_states = encoder_outputs[0] if not inputs[\"return_dict\"]: return (hidden_states,) + encoder_outputs[1:] return TFBaseModelOutput( last_hidden_state=hidden_states,","- 0 corresponds to a *sentence A* token, - 1 corresponds to a","if not getattr(self.config, \"apply_spec_augment\", True): return hidden_states if mask_time_indices is not None: #","hidden_states = self.output_dropout(hidden_states, training=training) return hidden_states # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2EncoderLayer with Wav2Vec2->Hubert class","datasets import load_dataset >>> import soundfile as sf >>> processor = Wav2Vec2Processor.from_pretrained(\"facebook/hubert-base-960h\") >>>","updated during training. \"\"\" warnings.warn( \"The method `freeze_feature_extractor` is deprecated and will be","= super().get_config() return {**base_config, **config} def compute_output_shape(self, input_shape): return input_shape def _reshape_into_groups(self, inputs,","Segment token indices to indicate first and second portions of the inputs. Indices","transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2EncoderLayer with Wav2Vec2->Hubert class TFHubertEncoderLayer(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs): super().__init__(**kwargs) self.attention =","return dummy_inputs def __init__(self, config, *inputs, **kwargs): super().__init__(config, *inputs, **kwargs) logger.warning( f\"\\n{self.__class__.__name__} has","are **not masked**, - 0 for tokens that are **masked**. [What are attention","be \" \"more than the number of channels (\" + str(dim) + \").\"","axis according to [SpecAugment](https://arxiv.org/abs/1904.08779). \"\"\" batch_size, sequence_length, hidden_size = shape_list(hidden_states) # `config.apply_spec_augment` can","modes than eager. if tf.executing_eagerly(): tf.debugging.assert_equal( shape_list(attn_output), [bsz * self.num_heads, tgt_len, self.head_dim], message=f\"`attn_output`","case of a list of symbolic inputs, each input has to be named","Dict[str, tf.Tensor]: pad_token = 0.0 input_values = tf.convert_to_tensor(np.random.rand(1, 16000), tf.float32) dummy_inputs = {","start of the span to be masked. this will be multiplied by number","_add_gamma_weight(self, input_shape): dim = input_shape[self.axis] shape = (dim,) if self.scale: self.gamma = self.add_weight(","for the missing layers, and another one for the unexpected layers. \"\"\" signature","input_shape[self.axis] shape = (dim,) if self.center: self.beta = self.add_weight( shape=shape, name=\"beta\", initializer=self.beta_initializer, regularizer=self.beta_regularizer,","[ \"facebook/hubert-base-ls960\", # See all Hubert models at https://huggingface.co/models?filter=hubert ] LARGE_NEGATIVE = -1e8","to \" \"use tf.layer.batch_normalization instead\" ) def _create_input_spec(self, input_shape): dim = input_shape[self.axis] self.input_spec","nullify selected heads of the self-attention modules. Mask values selected in `[0, 1]`:","axis = -1 if self.axis == -1 else self.axis - 1 group_reduction_axes.pop(axis) mean,","= input_shape[self.axis] if dim < self.groups: raise ValueError( \"Number of groups (\" +","Optional[bool] = False, ) -> Union[TFCausalLMOutput, Tuple[tf.Tensor]]: r\"\"\" labels (`tf.Tensor` or `np.ndarray` of","inputs[\"return_dict\"]: output = (logits,) + outputs[1:] return ((loss,) + output) if loss is","**kwargs, ): super().__init__(**kwargs) self.supports_masking = True self.groups = groups self.axis = axis self.epsilon","a *sentence B* token. [What are token type IDs?](../glossary#token-type-ids) position_ids (`np.ndarray` or `tf.Tensor`","# EagerTensors don't allow to use the .name property so we check for","self.axis - 1 group_reduction_axes.pop(axis) mean, variance = tf.nn.moments(reshaped_inputs, group_reduction_axes, keepdims=True) gamma, beta =","[tf.keras.Model](https://www.tensorflow.org/api_docs/python/tf/keras/Model) subclass. Use it as a regular TF 2.0 Keras Model and refer","self._add_gamma_weight(input_shape) self._add_beta_weight(input_shape) self.built = True super().build(input_shape) def call(self, inputs): input_shape = tf.keras.backend.int_shape(inputs) tensor_input_shape","value_states = self._shape(self.v_proj(hidden_states), -1, bsz) if self.is_decoder: # if cross_attention save Tuple(tf.Tensor, tf.Tensor)","cannot be \" \"more than the number of channels (\" + str(dim) +","\"gamma_regularizer\": tf.keras.regularizers.serialize(self.gamma_regularizer), \"beta_constraint\": tf.keras.constraints.serialize(self.beta_constraint), \"gamma_constraint\": tf.keras.constraints.serialize(self.gamma_constraint), } base_config = super().get_config() return {**base_config, **config}","\"A MAN SAID TO THE UNIVERSE SIR I EXIST\" >>> # wrap processor","return reshaped_inputs, group_shape else: return inputs, group_shape def _apply_normalization(self, reshaped_inputs, input_shape): group_shape =","tf.debugging.assert_equal( shape_list(layer_head_mask), [self.num_heads], message=f\"Head mask for a single layer should be of size","# self_attention key_states = self._shape(self.k_proj(hidden_states), -1, bsz) value_states = self._shape(self.v_proj(hidden_states), -1, bsz) if","updated during training. \"\"\" self.hubert.feature_extractor.trainable = False @add_start_docstrings_to_model_forward(HUBERT_INPUTS_DOCSTRING) @replace_return_docstrings(output_type=TFCausalLMOutput, config_class=_CONFIG_FOR_DOC) def call( self,","self.dropout(attn_weights, training=training) attn_output = tf.matmul(attn_probs, value_states) # The tf.debugging asserts are not compliant","Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2LayerNormConvLayer with Wav2Vec2->Hubert class TFHubertLayerNormConvLayer(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, layer_id: int","have to be disabled in other modes than eager. if tf.executing_eagerly(): tf.debugging.assert_equal( shape_list(attn_weights),","parameters will not be updated during training. \"\"\" warnings.warn( \"The method `freeze_feature_extractor` is","use_bias=bias, name=\"q_proj\") self.v_proj = tf.keras.layers.Dense(embed_dim, use_bias=bias, name=\"v_proj\") self.out_proj = tf.keras.layers.Dense(embed_dim, use_bias=bias, name=\"out_proj\") def","masked**, - 0 for tokens that are **masked**. [What are attention masks?](../glossary#attention-mask) token_type_ids","See [`PreTrainedTokenizer.__call__`] and [`PreTrainedTokenizer.encode`] for details. [What are input IDs?](../glossary#input-ids) attention_mask (`np.ndarray` or","get key, value proj if is_cross_attention and past_key_value is not None: # reuse","(batch_dim, indixes) \"\"\" indices_shape = shape_list(batch_indices) # broadcast batch dim to indices_shape broad_casted_batch_dims","= { \"input_values\": input_values, \"attention_mask\": tf.cast(tf.not_equal(input_values, pad_token), tf.float32), } return dummy_inputs def __init__(self,","0.\") if mask_length > sequence_length: raise ValueError( f\"`mask_length` has to be smaller than","* mask_length > sequence_length: num_masked_spans = sequence_length // mask_length # SpecAugment mask to","the config will be used instead. return_dict (`bool`, *optional*): Whether or not to","software # distributed under the License is distributed on an \"AS IS\" BASIS,",") # transform batch_indices to pair_indices pair_indices = tf.transpose(tf.concat([broad_casted_batch_dims, tf.reshape(batch_indices, [1, -1])], 0))","implemented. The gumbel-max trick will do for now - see https://github.com/tensorflow/tensorflow/issues/9260 for more","Check out the [`~PreTrainedModel.from_pretrained`] method to load the model weights. \"\"\" HUBERT_INPUTS_DOCSTRING =","Any, Dict, Optional, Tuple, Union import numpy as np import tensorflow as tf","encode labels >>> with processor.as_target_processor(): ... labels = processor(transcription, return_tensors=\"tf\").input_values >>> loss =","output return TFCausalLMOutput( loss=loss, logits=logits, hidden_states=outputs.hidden_states, attentions=outputs.attentions, ) def serving_output(self, output: TFCausalLMOutput) ->","-> Tuple[tf.Tensor]: attn_residual = hidden_states hidden_states, attn_weights, _ = self.attention( hidden_states, attention_mask=attention_mask, training=training","bsz: int): return tf.transpose(tf.reshape(tensor, (bsz, seq_len, self.num_heads, self.head_dim)), (0, 2, 1, 3)) def","hidden_states = conv_layer(hidden_states) return hidden_states class TFHubertFeatureExtractor(TFHubertFeatureEncoder): def __init__(self, config, **kwargs): super().__init__(config, **kwargs)","None: # compute real output lengths according to convolution formula output_lengths = self._get_feat_extract_output_lengths(tf.reduce_sum(inputs[\"attention_mask\"],","will not be updated during training. \"\"\" warnings.warn( \"The method `freeze_feature_extractor` is deprecated","in [\"return_dict\", \"output_attentions\", \"output_hidden_states\", \"use_cache\"] } output.update(booleans_processing(config=config, **boolean_dict)) return output # Copied from","attn_output = self.out_proj(attn_output) attn_weights: tf.Tensor = tf.reshape(attn_weights, (bsz, self.num_heads, tgt_len, src_len)) return attn_output,","Optional, Tuple, Union import numpy as np import tensorflow as tf from ...activations_tf","language governing permissions and # limitations under the License. \"\"\" TensorFlow Hubert model.\"\"\"","(see https://arxiv.org/abs/1909.11556 for description) dropout_probability = np.random.uniform(0, 1) if training and (dropout_probability <","input_shape): self._check_if_input_shape_is_none(input_shape) self._set_number_of_groups_for_instance_norm(input_shape) self._check_size_of_dimensions(input_shape) self._create_input_spec(input_shape) self._add_gamma_weight(input_shape) self._add_beta_weight(input_shape) self.built = True super().build(input_shape) def call(self,","argument can be used in eager mode, in graph mode the value will","in `[-100, 0, ..., config.vocab_size]` (see `input_values` docstring) Tokens with indices set to","= shape_list(key_states)[1] attn_weights = tf.matmul(query_states, key_states, transpose_b=True) # The tf.debugging asserts are not","transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2FeedForward with Wav2Vec2->Hubert class TFHubertFeedForward(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs): super().__init__(**kwargs) self.intermediate_dropout =","None: # reuse k,v, cross_attentions key_states = past_key_value[0] value_states = past_key_value[1] elif is_cross_attention:","None position_embeddings = self.pos_conv_embed(hidden_states) hidden_states = hidden_states + position_embeddings hidden_states = self.layer_norm(hidden_states) hidden_states","first and second portions of the inputs. Indices are selected in `[0, 1]`:","groups (\" + str(self.groups) + \") cannot be \" \"more than the number","config: HubertConfig, **kwargs): super().__init__(**kwargs) self.intermediate_dropout = tf.keras.layers.Dropout(config.activation_dropout) self.intermediate_dense = tf.keras.layers.Dense( units=config.intermediate_size, kernel_initializer=get_initializer(config.initializer_range), bias_initializer=\"zeros\",","not to return a [`~file_utils.ModelOutput`] instead of a plain tuple. This argument can","attentions tensors of all attention layers. See `attentions` under returned tensors for more","B* token. [What are token type IDs?](../glossary#token-type-ids) position_ids (`np.ndarray` or `tf.Tensor` of shape","raise ValueError( f\"Data of type {type(input_values)} is not allowed only {allowed_types} is accepted","be multiplied by number of timesteps divided by length of mask span to","ValueError(\"`mask_length` has to be bigger than 0.\") if mask_length > sequence_length: raise ValueError(","- (mask_length - 1))) # get random indices to mask spec_aug_mask_idxs = _sample_without_replacement(uniform_dist,","pair_indices = tf.transpose(tf.concat([broad_casted_batch_dims, tf.reshape(batch_indices, [1, -1])], 0)) # scatter values to pair indices","axis=-1) >>> transcription = processor.decode(predicted_ids[0]) >>> # compute loss >>> target_transcription = \"A","import inspect import warnings from typing import Any, Dict, Optional, Tuple, Union import",") self.padding = TFHubertSamePadLayer(config.num_conv_pos_embeddings) self.activation = get_tf_activation(config.feat_extract_activation) def call(self, hidden_states: tf.Tensor) -> tf.Tensor:","None: output[k] = v elif k not in parameter_names and \"args\" not in","= ds.map(map_to_array) >>> input_values = processor(ds[\"speech\"][0], return_tensors=\"tf\").input_values # Batch size 1 >>> hidden_states","constraint=self.gamma_constraint, ) else: self.gamma = None def _add_beta_weight(self, input_shape): dim = input_shape[self.axis] shape","2 self.initialized = False self.kernel_norm_axes = tf.constant([0, 1]) def _init_norm(self): \"\"\"Set the norm","self.gamma = None def _add_beta_weight(self, input_shape): dim = input_shape[self.axis] shape = (dim,) if","import warnings from typing import Any, Dict, Optional, Tuple, Union import numpy as","allowed_types) or input is None: output[parameter_names[i]] = input else: raise ValueError( f\"Data of","list {parameter_names} and will be ignored.\" ) continue else: raise ValueError(f\"Data of type","you wish \" \"to train/fine-tine this model, you need a GPU or a","actual number will be smaller (unless no_overlap is True) mask_length: size of the","len(group_shape))) is_instance_norm = (input_shape[self.axis] // self.groups) == 1 if not is_instance_norm: axis =","tf.keras.Input(shape=(128,), dtype='float32', name=\"input_values\")` otherwise the order of the tensors will not be guaranteed","name=\"layer_norm\") self.feed_forward = TFHubertFeedForward(config, name=\"feed_forward\") self.final_layer_norm = tf.keras.layers.LayerNormalization( epsilon=config.layer_norm_eps, name=\"final_layer_norm\" ) def call(","if not self.built: input_shape = input_shape.as_list() # Conv1D output shapes are checked at","\"epsilon\": self.epsilon, \"center\": self.center, \"scale\": self.scale, \"beta_initializer\": tf.keras.initializers.serialize(self.beta_initializer), \"gamma_initializer\": tf.keras.initializers.serialize(self.gamma_initializer), \"beta_regularizer\": tf.keras.regularizers.serialize(self.beta_regularizer), \"gamma_regularizer\":","kernel_initializer=get_initializer(config.initializer_range), bias_initializer=\"zeros\", name=\"intermediate_dense\", ) self.intermediate_act_fn = get_tf_activation(config.hidden_act) self.output_dense = tf.keras.layers.Dense( units=config.hidden_size, kernel_initializer=get_initializer(config.initializer_range), bias_initializer=\"zeros\",","`[0, ..., config.vocab_size]` Returns: Example: ```python >>> import tensorflow as tf >>> from","num_masked_spans) # expand masked indices to masked spans spec_aug_mask_idxs = tf.expand_dims(spec_aug_mask_idxs, -1) spec_aug_mask_idxs",":], hidden_states, ) elif self.config.mask_time_prob > 0: # generate indices & apply SpecAugment","is not allowed only {allowed_types} is accepted for {k}.\") else: if isinstance(input_values, tf.Tensor)","be removed in Transformers v5.\" \"Please use the equivalent `freeze_feature_encoder` method instead.\", FutureWarning,","ds.map(map_to_array) >>> input_values = processor(ds[\"speech\"][0], return_tensors=\"tf\").input_values # Batch size 1 >>> logits =","at build time since TF 2.7, so we need to account for padding","None position_embeddings = self.pos_conv_embed(hidden_states) hidden_states = hidden_states + position_embeddings hidden_states = self.dropout(hidden_states, training=training)","\"and will be removed in Transformers v5. \" f\"Use `{self.__class__.__bases__[0].__name__}` instead.\", FutureWarning, )","name=\"lm_head\") def freeze_feature_extractor(self): \"\"\" Calling this function will disable the gradient computation for","if tf.executing_eagerly(): tf.debugging.assert_equal( shape_list(attention_mask), [bsz, 1, tgt_len, src_len], message=f\"Attention mask should be of","than the number of channels (\" + str(dim) + \").\" ) if dim","have to be disabled in other modes than eager. if tf.executing_eagerly(): tf.debugging.assert_equal( shape_list(layer_head_mask),","the License. \"\"\" TensorFlow Hubert model.\"\"\" import inspect import warnings from typing import","parameter list {parameter_names} and will be ignored.\" ) continue else: raise ValueError(f\"Data of","!= \"args\": output[name] = kwargs.pop(name, signature[name].default) # When creating a SavedModel TF calls","nothing else: `model(inputs_ids)` - a list of varying length with one or several","(masked), the loss is only computed for the tokens with labels in `[0,","multiplied by number of timesteps divided by length of mask span to mask","or saving, resizing the input embeddings, pruning heads etc.) This model is also","`({0})`, *optional*): Indices of positions of each input sequence tokens in the position","mask_length)) spec_aug_mask_idxs = tf.reshape(spec_aug_mask_idxs, (batch_size, num_masked_spans * mask_length)) offsets = tf.range(mask_length)[tf.newaxis, tf.newaxis, :]","\") must be a \" \"multiple of the number of channels (\" +","second option is useful when using [`tf.keras.Model.fit`] method which currently requires having all","None if not inputs[\"return_dict\"]: output = (logits,) + outputs[1:] return ((loss,) + output)","\"group\": conv_layers = [TFHubertGroupNormConvLayer(config, layer_id=0, name=f\"conv_layers.{0}\")] + [ TFHubertNoLayerNormConvLayer(config, layer_id=i + 1, name=f\"conv_layers.{i+1}\")","processor as target processor to encode labels >>> with processor.as_target_processor(): ... labels =","backpropagation operations that are NOT supported on CPU. If you wish \" \"to","num_heads if (self.head_dim * num_heads) != self.embed_dim: raise ValueError( f\"embed_dim must be divisible","float, mask_length: int, min_masks: int = 0, ) -> tf.Tensor: \"\"\" Computes random","TFHubertEncoderStableLayerNorm(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs): super().__init__(**kwargs) self.config = config self.pos_conv_embed = TFHubertPositionalConvEmbedding(config,","that are **not masked**, - 0 for tokens that are **masked**. [What are","): super().__init__(**kwargs) self.embed_dim = embed_dim self.num_heads = num_heads self.dropout = tf.keras.layers.Dropout(dropout) self.head_dim =","not None bsz, tgt_len, embed_dim = shape_list(hidden_states) # get query proj query_states =","True) mask_length: size of the mask min_masks: minimum number of masked spans Adapted","a real Tensor if type(input) == tf.Tensor: # Tensor names have always the","tf.reshape(self._shape(query_states, tgt_len, bsz), proj_shape) key_states = tf.reshape(key_states, proj_shape) value_states = tf.reshape(value_states, proj_shape) src_len","self.output_dense = tf.keras.layers.Dense( units=config.hidden_size, kernel_initializer=get_initializer(config.initializer_range), bias_initializer=\"zeros\", name=\"output_dense\", ) self.output_dropout = tf.keras.layers.Dropout(config.hidden_dropout) def call(self,","tf.convert_to_tensor(np.random.rand(1, 16000), tf.float32) dummy_inputs = { \"input_values\": input_values, \"attention_mask\": tf.cast(tf.not_equal(input_values, pad_token), tf.float32), }","as start of the span to be masked. this will be multiplied by","mask_length + tf.random.uniform((1,))) num_masked_spans = max(num_masked_spans, min_masks) # make sure num masked indices","= model(input_values, labels=labels).loss ```\"\"\" inputs = input_values_processing( func=self.call, config=self.config, input_values=input_values, attention_mask=attention_mask, token_type_ids=token_type_ids, position_ids=position_ids,","for tokens that are **not masked**, - 0 for tokens that are **masked**.","implied. # See the License for the specific language governing permissions and #","= tf.argmax(logits, axis=-1) >>> transcription = processor.decode(predicted_ids[0]) >>> # compute loss >>> target_transcription","all_self_attentions + (layer_outputs[1],) hidden_states = self.layer_norm(hidden_states) if output_hidden_states: all_hidden_states = all_hidden_states + (hidden_states,)","logits=logits, labels=labels, logit_length=input_lengths, label_length=target_lengths, blank_index=self.config.pad_token_id, logits_time_major=False, ) if self.config.ctc_loss_reduction == \"sum\": loss =","input_values=inputs[\"input_values\"], attention_mask=inputs[\"attention_mask\"], token_type_ids=inputs[\"token_type_ids\"], position_ids=inputs[\"position_ids\"], head_mask=inputs[\"head_mask\"], inputs_embeds=inputs[\"inputs_embeds\"], output_attentions=inputs[\"output_attentions\"], output_hidden_states=inputs[\"output_hidden_states\"], return_dict=inputs[\"return_dict\"], training=inputs[\"training\"], ) return outputs","= True super().build(input_shape) def call(self, inputs): input_shape = tf.keras.backend.int_shape(inputs) tensor_input_shape = tf.shape(inputs) reshaped_inputs,","tgt_len, bsz), proj_shape) key_states = tf.reshape(key_states, proj_shape) value_states = tf.reshape(value_states, proj_shape) src_len =","filters=self.out_conv_dim, kernel_size=config.conv_kernel[layer_id], strides=config.conv_stride[layer_id], use_bias=config.conv_bias, name=\"conv\", ) self.layer_norm = tf.keras.layers.LayerNormalization(name=\"layer_norm\", epsilon=config.layer_norm_eps) self.activation = get_tf_activation(config.feat_extract_activation)","name=f\"conv_layers.{i+1}\") for i in range(config.num_feat_extract_layers - 1) ] elif config.feat_extract_norm == \"layer\": conv_layers","TFBaseModelOutput(last_hidden_state=output.last_hidden_state, hidden_states=hs, attentions=attns) @add_start_docstrings( \"\"\"TFHubert Model with a `language modeling` head on top","training=training ) hidden_states = self.dropout(hidden_states, training=training) hidden_states = attn_residual + hidden_states hidden_states =","def _get_feat_extract_output_lengths(self, input_lengths: tf.Tensor): \"\"\" Computes the output length of the convolutional layers","is useful when using [`tf.keras.Model.fit`] method which currently requires having all the tensors","HUBERT_START_DOCSTRING = r\"\"\" This model inherits from [`TFPreTrainedModel`]. Check the superclass documentation for","return inputs, group_shape def _apply_normalization(self, reshaped_inputs, input_shape): group_shape = tf.keras.backend.int_shape(reshaped_inputs) group_reduction_axes = list(range(1,","is None: output[k] = v elif k not in parameter_names and \"args\" not","two formats as inputs: - having all inputs as keyword arguments (like PyTorch","output_hidden_states else None all_self_attentions = () if output_attentions else None if attention_mask is","if isinstance(v, allowed_types) or v is None: output[k] = v elif k not","be of size 2 where first element is batch size and 2nd is","transformers.models.wav2vec2.modeling_tf_wav2vec2._compute_mask_indices def _compute_mask_indices( shape: Tuple[int, int], mask_prob: float, mask_length: int, min_masks: int =","= self.intermediate_act_fn(hidden_states) hidden_states = self.intermediate_dropout(hidden_states, training=training) hidden_states = self.output_dense(hidden_states) hidden_states = self.output_dropout(hidden_states, training=training)","another one for the unexpected layers. \"\"\" signature = dict(inspect.signature(func).parameters) signature.pop(\"kwargs\", None) signature.pop(\"self\",","not is_instance_norm: group_shape[self.axis] = input_shape[self.axis] // self.groups group_shape.insert(self.axis, self.groups) group_shape = tf.stack(group_shape) reshaped_inputs","(self.explicit_padding, self.explicit_padding), (0, 0))) output = super().call(padded_inputs) return output # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2NoLayerNormConvLayer","labels=labels, logit_length=input_lengths, label_length=target_lengths, blank_index=self.config.pad_token_id, logits_time_major=False, ) if self.config.ctc_loss_reduction == \"sum\": loss = tf.reduce_sum(loss)","spec_aug_mask_idxs = tf.tile(spec_aug_mask_idxs, (1, 1, mask_length)) spec_aug_mask_idxs = tf.reshape(spec_aug_mask_idxs, (batch_size, num_masked_spans * mask_length))","only {allowed_types} is accepted for {k}.\") else: if isinstance(input_values, tf.Tensor) or input_values is","1))) # get random indices to mask spec_aug_mask_idxs = _sample_without_replacement(uniform_dist, num_masked_spans) # expand","attn_residual + hidden_states hidden_states = hidden_states + self.feed_forward(self.final_layer_norm(hidden_states)) outputs = (hidden_states,) if output_attentions:","# See the License for the specific language governing permissions and # limitations","inputs, input_shape, tensor_input_shape): group_shape = [tensor_input_shape[i] for i in range(len(input_shape))] is_instance_norm = (input_shape[self.axis]","[ TFHubertNoLayerNormConvLayer(config, layer_id=i + 1, name=f\"conv_layers.{i+1}\") for i in range(config.num_feat_extract_layers - 1) ]","self.config.output_attentions ) inputs[\"return_dict\"] = inputs[\"return_dict\"] if inputs[\"return_dict\"] else self.config.return_dict outputs = self.hubert( input_values=inputs[\"input_values\"],","name=\"layer_norm\") self.projection = tf.keras.layers.Dense( units=config.hidden_size, kernel_initializer=get_initializer(config.initializer_range), bias_initializer=\"zeros\", name=\"projection\", ) self.dropout = tf.keras.layers.Dropout(rate=config.feat_proj_dropout) def","or input_values is None: output[parameter_names[0]] = input_values else: raise ValueError( f\"Data of type","methods the library implements for all its model (such as downloading or saving,","tf.Tensor) -> tf.Tensor: hidden_states = self.conv(hidden_states) hidden_states = self.padding(hidden_states) hidden_states = self.activation(hidden_states) return","self.add_weight( shape=(self.config.hidden_size,), initializer=\"uniform\", trainable=True, name=\"masked_spec_embed\" ) super().build(input_shape) def _get_feat_extract_output_lengths(self, input_lengths: tf.Tensor): \"\"\" Computes","the HuggingFace Inc. team. All rights reserved. # # Licensed under the Apache","inputs[\"attention_mask\"] if inputs[\"attention_mask\"] is not None else tf.ones_like(inputs[\"input_values\"], dtype=tf.float32) ) input_lengths = self.hubert._get_feat_extract_output_lengths(tf.reduce_sum(attention_mask,","None) signature.pop(\"self\", None) parameter_names = list(signature.keys()) output = {} allowed_types = (tf.Tensor, bool,","-1, 1, 1)) * tf.reshape( attn_weights, (bsz, self.num_heads, tgt_len, src_len) ) attn_weights =","((loss,) + output) if loss is not None else output return TFCausalLMOutput( loss=loss,","self.feed_forward(self.final_layer_norm(hidden_states)) outputs = (hidden_states,) if output_attentions: outputs += (attn_weights,) return outputs # Copied","def __init__(self, config: HubertConfig, layer_id: int = 0, **kwargs: Any) -> None: super().__init__(**kwargs)","inputs, each input has to be named accordingly to the parameters name, i.e.","all the parameters of the model. Initializing with a config file does not","in [hidden_states, all_hidden_states, all_self_attentions] if v is not None) return TFBaseModelOutput( last_hidden_state=hidden_states, hidden_states=all_hidden_states,","= _conv_out_length(input_lengths, kernel_size, stride) return input_lengths def _mask_hidden_states(self, hidden_states: tf.Tensor, mask_time_indices: Optional[tf.Tensor] =","self.gamma_regularizer = tf.keras.regularizers.get(gamma_regularizer) self.beta_constraint = tf.keras.constraints.get(beta_constraint) self.gamma_constraint = tf.keras.constraints.get(gamma_constraint) self._check_axis() def build(self, input_shape):","to be disabled in other modes than eager. if tf.executing_eagerly(): tf.debugging.assert_equal( shape_list(attn_output), [bsz","hidden_states: tf.Tensor, attention_mask: Optional[tf.Tensor] = None, output_attentions: Optional[bool] = False, training: bool =","the tensors in the first argument of the model call function: `model(inputs)`. If","0, ..., config.vocab_size]` (see `input_values` docstring) Tokens with indices set to `-100` are","directly pass an embedded representation. This is useful if you want more control","the head is **not masked**, - 0 indicates the head is **masked**. inputs_embeds","**masked**. [What are attention masks?](../glossary#attention-mask) token_type_ids (`np.ndarray` or `tf.Tensor` of shape `({0})`, *optional*):","# Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.input_values_processing def input_values_processing(func, config, input_values, **kwargs): \"\"\" Process the input","self.intermediate_act_fn = get_tf_activation(config.hidden_act) self.output_dense = tf.keras.layers.Dense( units=config.hidden_size, kernel_initializer=get_initializer(config.initializer_range), bias_initializer=\"zeros\", name=\"output_dense\", ) self.output_dropout =","None, training: bool = False, ) -> Union[TFBaseModelOutput, Tuple[tf.Tensor]]: \"\"\" Returns: Example: ```python","warnings.warn( \"The `inputs` argument is deprecated and will be removed in a future","= [TFHubertEncoderLayer(config, name=f\"layers.{i}\") for i in range(config.num_hidden_layers)] def call( self, hidden_states: tf.Tensor, attention_mask:","= tf.concat([past_key_value[0], key_states], axis=2) value_states = tf.concat([past_key_value[1], value_states], axis=2) else: # self_attention key_states","1 if not is_instance_norm: broadcast_shape[self.axis] = input_shape[self.axis] // self.groups broadcast_shape.insert(self.axis, self.groups) else: broadcast_shape[self.axis]","attention on padding token indices. Mask values selected in `[0, 1]`: - 1","# Copied from transformers.models.bart.modeling_tf_bart._expand_mask def _expand_mask(mask: tf.Tensor, tgt_len: Optional[int] = None, past_key_values_length: int","= (input_shape[self.axis] // self.groups) == 1 if not is_instance_norm: broadcast_shape[self.axis] = input_shape[self.axis] //","sequence tokens in the vocabulary. Indices can be obtained using [`BertTokenizer`]. See [`PreTrainedTokenizer.__call__`]","hidden_states = model(input_values).last_hidden_state ```\"\"\" inputs = input_values_processing( func=self.call, config=self.config, input_values=input_values, attention_mask=attention_mask, token_type_ids=token_type_ids, position_ids=position_ids,","self.layer_norm = tf.keras.layers.LayerNormalization(epsilon=config.layer_norm_eps, name=\"layer_norm\") self.feed_forward = TFHubertFeedForward(config, name=\"feed_forward\") self.final_layer_norm = tf.keras.layers.LayerNormalization( epsilon=config.layer_norm_eps, name=\"final_layer_norm\"","def call(self, hidden_states: tf.Tensor) -> tf.Tensor: hidden_states = self.conv(hidden_states) hidden_states = self.activation(hidden_states) return","hidden_states = hidden_states + position_embeddings hidden_states = self.dropout(hidden_states, training=training) for i, layer_module in","token_type_ids=token_type_ids, position_ids=position_ids, head_mask=head_mask, inputs_embeds=inputs_embeds, output_attentions=output_attentions, output_hidden_states=output_hidden_states, return_dict=return_dict, training=training, kwargs_call=kwargs, ) hidden_states = self.feature_extractor(","tf.where(mask_feature_indices[:, tf.newaxis, :], hidden_states, 0) return hidden_states def call( self, input_values: tf.Tensor, attention_mask:","= inputs[\"return_dict\"] if inputs[\"return_dict\"] else self.config.return_dict outputs = self.hubert( input_values=inputs[\"input_values\"], attention_mask=inputs[\"attention_mask\"], token_type_ids=inputs[\"token_type_ids\"], position_ids=inputs[\"position_ids\"],","`input_values = tf.keras.Input(shape=(128,), dtype='float32', name=\"input_values\")` otherwise the order of the tensors will not","Optional[tf.Tensor] = None, past_key_value: Optional[Tuple[Tuple[tf.Tensor]]] = None, attention_mask: Optional[tf.Tensor] = None, layer_head_mask: Optional[tf.Tensor]","input_shape): dim = input_shape[self.axis] if dim is None: raise ValueError( \"Axis \" +","account for padding input_shape[-2] += self.explicit_padding * 2 super().build(input_shape) self.kernel = tf.Variable(tf.transpose(self.kernel), name=\"weight_v\",","np import tensorflow as tf from ...activations_tf import get_tf_activation from ...modeling_tf_outputs import TFBaseModelOutput,","Any) -> None: super().__init__(**kwargs) if config.feat_extract_norm == \"group\": conv_layers = [TFHubertGroupNormConvLayer(config, layer_id=0, name=f\"conv_layers.{0}\")]","- 1 corresponds to a *sentence B* token. [What are token type IDs?](../glossary#token-type-ids)","offset samples are < sequence_length uniform_dist = tf.ones((batch_size, sequence_length - (mask_length - 1)))","True, training: Optional[bool] = False, ) -> Union[TFBaseModelOutput, Tuple[tf.Tensor]]: all_hidden_states = () if","parameter_names: output[tensor_name] = input else: output[parameter_names[i]] = input elif isinstance(input, allowed_types) or input","as a regular TF 2.0 Keras Model and refer to the TF 2.0","self.conv = TFHubertWeightNormConv1D( filters=config.hidden_size, kernel_size=config.num_conv_pos_embeddings, groups=config.num_conv_pos_embedding_groups, explicit_padding=config.num_conv_pos_embeddings // 2, name=\"conv\", ) self.padding =","hidden_states = self.output_dense(hidden_states) hidden_states = self.output_dropout(hidden_states, training=training) return hidden_states # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2EncoderLayer","eager mode, in graph mode the value will always be set to True.","of mask span to mask approximately this percentage of all elements. however due","= 0, **kwargs: Any) -> None: super().__init__(**kwargs) self.in_conv_dim = config.conv_dim[layer_id] if layer_id >","the span to be masked. this will be multiplied by number of timesteps","self.layer_norm(hidden_states) hidden_states = self.dropout(hidden_states, training=training) for i, layer_module in enumerate(self.layer): if output_hidden_states: all_hidden_states",") -> Union[TFBaseModelOutput, Tuple[tf.Tensor]]: \"\"\" Returns: Example: ```python >>> from transformers import Wav2Vec2Processor,",":, tf.newaxis], tf.bool), self.masked_spec_embed[tf.newaxis, tf.newaxis, :], hidden_states, ) elif self.config.mask_time_prob > 0: #","https://www.tensorflow.org/probability/api_docs/python/tfp/layers/weight_norm/WeightNorm\"\"\" def __init__(self, filters, kernel_size, groups, explicit_padding, **kwargs): super().__init__( filters=filters, kernel_size=kernel_size, groups=groups, padding=\"valid\",","the training. Args: func (`callable`): The callable function of the TensorFlow model. config","training=inputs[\"training\"], ) return outputs def serving_output(self, output): hs = tf.convert_to_tensor(output.hidden_states) if self.config.output_hidden_states else","logits = self.lm_head(hidden_states) if labels is not None: if tf.reduce_max(labels) >= self.config.vocab_size: raise","= processor.decode(predicted_ids[0]) >>> # compute loss >>> target_transcription = \"A MAN SAID TO","k,v, cross_attentions key_states = past_key_value[0] value_states = past_key_value[1] elif is_cross_attention: # cross_attentions key_states","if tensor_name in parameter_names: output[tensor_name] = input else: output[parameter_names[i]] = input elif isinstance(input,","output_attentions=inputs[\"output_attentions\"], output_hidden_states=inputs[\"output_hidden_states\"], return_dict=inputs[\"return_dict\"], training=inputs[\"training\"], ) hidden_states = encoder_outputs[0] if not inputs[\"return_dict\"]: return (hidden_states,)","previous decoder key/value_states. Further calls to uni-directional self-attention # can concat previous decoder","None, return_dict: Optional[bool] = None, training: bool = False, ) -> Union[TFBaseModelOutput, Tuple[tf.Tensor]]:","self.output_dropout = tf.keras.layers.Dropout(config.hidden_dropout) def call(self, hidden_states: tf.Tensor, training: bool = False) -> tf.Tensor:","*optional*, defaults to `False``): Whether or not to use the model in training","hidden_states=hs, attentions=attns) @add_start_docstrings( \"\"\"TFHubert Model with a `language modeling` head on top for","else: raise ValueError(f\"Data of type {type(v)} is not allowed only {allowed_types} is accepted","if not is_instance_norm: outputs = tf.reshape(normalized_inputs, tensor_input_shape) else: outputs = normalized_inputs return outputs","of the running model. **kwargs: The inputs of the model. Returns: Two lists,","with Wav2Vec2->Hubert class TFHubertEncoder(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs): super().__init__(**kwargs) self.config = config","by length of mask span to mask approximately this percentage of all elements.","= True self.groups = groups self.axis = axis self.epsilon = epsilon self.center =","self.intermediate_act_fn(hidden_states) hidden_states = self.intermediate_dropout(hidden_states, training=training) hidden_states = self.output_dense(hidden_states) hidden_states = self.output_dropout(hidden_states, training=training) return","Optional[tf.Tensor] = None, layer_head_mask: Optional[tf.Tensor] = None, training: Optional[bool] = False, ) ->","= \"input_values\" @property def dummy_inputs(self) -> Dict[str, tf.Tensor]: pad_token = 0.0 input_values =","to the input names given in the docstring: `model({\"input_values\": input_values, \"token_type_ids\": token_type_ids})` </Tip>","key_states], axis=2) value_states = tf.concat([past_key_value[1], value_states], axis=2) else: # self_attention key_states = self._shape(self.k_proj(hidden_states),","config ([`HubertConfig`]): Model configuration class with all the parameters of the model. Initializing","Tokens with indices set to `-100` are ignored (masked), the loss is only","mask_time_indices is not None: # apply SpecAugment along time axis with given mask_time_indices","False, return_dict: Optional[bool] = True, training: Optional[bool] = False, ) -> Union[TFBaseModelOutput, Tuple[tf.Tensor]]:","want to \" \"use tf.layer.batch_normalization instead\" ) def _create_input_spec(self, input_shape): dim = input_shape[self.axis]","with Wav2Vec2->Hubert class TFHubertSamePadLayer(tf.keras.layers.Layer): def __init__(self, num_conv_pos_embeddings, **kwargs): super().__init__(**kwargs) self.num_pad_remove = 1 if","Optional[tf.Tensor] = None, output_attentions: Optional[bool] = None, labels: Optional[tf.Tensor] = None, output_hidden_states: Optional[bool]","= self._shape(self.k_proj(hidden_states), -1, bsz) value_states = self._shape(self.v_proj(hidden_states), -1, bsz) if self.is_decoder: # if","attn_weights = tf.reshape(attn_weights, (bsz * self.num_heads, tgt_len, src_len)) attn_weights = tf.nn.softmax(attn_weights, axis=-1) if","if isinstance(input_values, tf.Tensor) or input_values is None: output[parameter_names[0]] = input_values else: raise ValueError(","= (hidden_states,) if output_attentions: outputs += (attn_weights,) return outputs # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2EncoderLayerStableLayerNorm","initialization and a simple interface for downloading and loading pretrained models. \"\"\" config_class","in list(output.keys()) and name != \"args\": output[name] = kwargs.pop(name, signature[name].default) # When creating","HubertConfig, **kwargs: Any) -> None: super().__init__(**kwargs) self.conv = TFHubertWeightNormConv1D( filters=config.hidden_size, kernel_size=config.num_conv_pos_embeddings, groups=config.num_conv_pos_embedding_groups, explicit_padding=config.num_conv_pos_embeddings","channels (\" + str(dim) + \").\" ) if dim % self.groups != 0:","are filled with -100 # when not being attended to labels_mask = tf.cast(labels","0 for tokens that are **masked**. [What are attention masks?](../glossary#attention-mask) token_type_ids (`np.ndarray` or","if not self.initialized: self._init_norm() self.initialized = True self._normalize_kernel() padded_inputs = tf.pad(inputs, ((0, 0),","outputs # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2EncoderLayerStableLayerNorm with Wav2Vec2->Hubert class TFHubertEncoderLayerStableLayerNorm(tf.keras.layers.Layer): def __init__(self, config: HubertConfig,","self.bias = self.add_weight(name=\"bias\", shape=(self.filters,), initializer=\"zeros\", trainable=True) def call(self, inputs): if not self.initialized: self._init_norm()","for v in [hidden_states, all_hidden_states, all_self_attentions] if v is not None) return TFBaseModelOutput(","kernel_size, stride in zip(self.config.conv_kernel, self.config.conv_stride): input_lengths = _conv_out_length(input_lengths, kernel_size, stride) return input_lengths def","`config.apply_spec_augment` can set masking to False if not getattr(self.config, \"apply_spec_augment\", True): return hidden_states","`(num_heads,)` or `(num_layers, num_heads)`, *optional*): Mask to nullify selected heads of the self-attention","uniform distribution to sample from, make sure that offset samples are < sequence_length","() if output_hidden_states else None all_self_attentions = () if output_attentions else None if","in training mode (some modules like dropout modules have different behaviors between training","head on top.\", HUBERT_START_DOCSTRING, ) class TFHubertModel(TFHubertPreTrainedModel): def __init__(self, config: HubertConfig, *inputs, **kwargs):","for k, v in output.items() if k in [\"return_dict\", \"output_attentions\", \"output_hidden_states\", \"use_cache\"] }","[self.num_heads], message=f\"Head mask for a single layer should be of size {(self.num_heads)}, but","reuse all cross-attention # key/value_states (first \"if\" case) # if uni-directional self-attention (decoder)","Wav2Vec2->Hubert class TFHubertFeedForward(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs): super().__init__(**kwargs) self.intermediate_dropout = tf.keras.layers.Dropout(config.activation_dropout) self.intermediate_dense","> 0: # generate indices & apply SpecAugment along time axis mask_time_indices =","groups self.axis = axis self.epsilon = epsilon self.center = center self.scale = scale","Tuple[tf.Tensor]]: r\"\"\" labels (`tf.Tensor` or `np.ndarray` of shape `(batch_size, sequence_length)`, *optional*): Labels for","hidden_states: tf.Tensor, training: bool = False) -> tf.Tensor: hidden_states = self.layer_norm(hidden_states) hidden_states =","= _scatter_values_on_batch_indices( tf.ones_like(spec_aug_mask_idxs), spec_aug_mask_idxs, spec_aug_mask.shape ) return spec_aug_mask # Copied from transformers.models.bart.modeling_tf_bart._expand_mask def","shape=shape, name=\"gamma\", initializer=self.gamma_initializer, regularizer=self.gamma_regularizer, constraint=self.gamma_constraint, ) else: self.gamma = None def _add_beta_weight(self, input_shape):","check for a real Tensor if type(input) == tf.Tensor: # Tensor names have","(`tf.Tensor` or `np.ndarray` of shape `(batch_size, sequence_length)`, *optional*): Labels for computing the masked","```python >>> import tensorflow as tf >>> from transformers import Wav2Vec2Processor, TFHubertForCTC >>>","is deprecated and will be removed in a future version, use `past_key_values` instead.\",","shape `({0})`, *optional*): Indices of positions of each input sequence tokens in the","= tf.keras.layers.Dense( units=config.intermediate_size, kernel_initializer=get_initializer(config.initializer_range), bias_initializer=\"zeros\", name=\"intermediate_dense\", ) self.intermediate_act_fn = get_tf_activation(config.hidden_act) self.output_dense = tf.keras.layers.Dense(","tuple. This argument can be used in eager mode, in graph mode the","input_shape): dim = input_shape[self.axis] self.input_spec = tf.keras.layers.InputSpec(ndim=len(input_shape), axes={self.axis: dim}) def _add_gamma_weight(self, input_shape): dim","not is_instance_norm: axis = -2 if self.axis == -1 else self.axis - 1","cross-attention # key/value_states (first \"if\" case) # if uni-directional self-attention (decoder) save Tuple(tf.Tensor,","sequence_length // mask_length # SpecAugment mask to fill spec_aug_mask = tf.zeros((batch_size, sequence_length), dtype=tf.int32)","Whether or not to return the attentions tensors of all attention layers. See","= tf.keras.layers.Dense(embed_dim, use_bias=bias, name=\"v_proj\") self.out_proj = tf.keras.layers.Dense(embed_dim, use_bias=bias, name=\"out_proj\") def _shape(self, tensor: tf.Tensor,","bias_initializer=\"he_normal\", **kwargs, ) self.explicit_padding = explicit_padding self.filter_axis = 2 self.initialized = False self.kernel_norm_axes",") inputs[\"return_dict\"] = inputs[\"return_dict\"] if inputs[\"return_dict\"] else self.config.return_dict outputs = self.hubert( input_values=inputs[\"input_values\"], attention_mask=inputs[\"attention_mask\"],","= tf.keras.initializers.get(gamma_initializer) self.beta_regularizer = tf.keras.regularizers.get(beta_regularizer) self.gamma_regularizer = tf.keras.regularizers.get(gamma_regularizer) self.beta_constraint = tf.keras.constraints.get(beta_constraint) self.gamma_constraint =","hidden_states + self.feed_forward(self.final_layer_norm(hidden_states)) outputs = (hidden_states,) if output_attentions: outputs += (attn_weights,) return outputs","= (input_shape[self.axis] // self.groups) == 1 if not is_instance_norm: axis = -2 if","handle weights initialization and a simple interface for downloading and loading pretrained models.","freeze_feature_extractor(self): \"\"\" Calling this function will disable the gradient computation for the feature","input_values = tf.convert_to_tensor(np.random.rand(1, 16000), tf.float32) dummy_inputs = { \"input_values\": input_values, \"attention_mask\": tf.cast(tf.not_equal(input_values, pad_token),","self.head_dim**-0.5 self.is_decoder = is_decoder self.k_proj = tf.keras.layers.Dense(embed_dim, use_bias=bias, name=\"k_proj\") self.q_proj = tf.keras.layers.Dense(embed_dim, use_bias=bias,","\"\"\" From tensorflow-addons https://www.tensorflow.org/addons/api_docs/python/tfa/layers/GroupNormalization \"\"\" def __init__( self, groups: int = 32, axis:","attention_mask = None position_embeddings = self.pos_conv_embed(hidden_states) hidden_states = hidden_states + position_embeddings hidden_states =","self.kernel_norm_axes = tf.constant([0, 1]) def _init_norm(self): \"\"\"Set the norm of the weight vector.\"\"\"","build(self, input_shape): if not self.built: input_shape = input_shape.as_list() # Conv1D output shapes are","True self._normalize_kernel() padded_inputs = tf.pad(inputs, ((0, 0), (self.explicit_padding, self.explicit_padding), (0, 0))) output =","no_overlap is True) mask_length: size of the mask min_masks: minimum number of masked","sf >>> processor = Wav2Vec2Processor.from_pretrained(\"facebook/hubert-base-960h\") >>> model = TFHubertForCTC.from_pretrained(\"facebook/hubert-base-960h\") >>> def map_to_array(batch): ...","self.head_dim)}, but is {shape_list(attn_output)}\", ) attn_output = tf.transpose( tf.reshape(attn_output, (bsz, self.num_heads, tgt_len, self.head_dim)),","output[\"past_key_values\"] = input_values.pop(\"decoder_cached_states\") for k, v in dict(input_values).items(): if isinstance(v, allowed_types) or v","# assuming that padded tokens are filled with -100 # when not being","2 super().build(input_shape) self.kernel = tf.Variable(tf.transpose(self.kernel), name=\"weight_v\", trainable=True) self.weight_v = self.kernel self.weight_g = self.add_weight(","_compute_mask_indices( (batch_size, sequence_length), mask_prob=self.config.mask_time_prob, mask_length=self.config.mask_time_length, min_masks=2, ) hidden_states = tf.where( tf.cast(mask_time_indices[:, :, tf.newaxis],","= input_shape.as_list() # Conv1D output shapes are checked at build time since TF","SAID TO THE UNIVERSE SIR I EXIST\" >>> # wrap processor as target","1, 3) ) attn_output = tf.reshape(attn_output, (bsz, tgt_len, embed_dim)) attn_output = self.out_proj(attn_output) attn_weights:","are trying to normalize your batch axis. Do you want to \" \"use","have the shape `({0})`): Indices of input sequence tokens in the vocabulary. Indices",") hidden_states = self.feature_extractor( tf.cast(inputs[\"input_values\"], tf.float32), training=inputs[\"training\"] ) if inputs[\"attention_mask\"] is not None:","== 1 if not is_instance_norm: group_shape[self.axis] = input_shape[self.axis] // self.groups group_shape.insert(self.axis, self.groups) group_shape","https://pytorch.org/docs/stable/generated/torch.nn.Conv1d.html return (input_length - kernel_size) // stride + 1 for kernel_size, stride in","All You Need\"\"\" def __init__( self, embed_dim: int, num_heads: int, dropout: float =","mask_time_indices hidden_states = tf.where( tf.cast(mask_time_indices[:, :, tf.newaxis], tf.bool), self.masked_spec_embed[tf.newaxis, tf.newaxis, :], hidden_states, )","allowed only {allowed_types} is accepted for {k}.\") else: if isinstance(input_values, tf.Tensor) or input_values","modules like dropout modules have different behaviors between training and evaluation). \"\"\" @add_start_docstrings(","else self.config.output_attentions ) inputs[\"return_dict\"] = inputs[\"return_dict\"] if inputs[\"return_dict\"] else self.config.return_dict outputs = self.hubert(","input_values is None: output[parameter_names[0]] = input_values else: raise ValueError( f\"Data of type {type(input_values)}","__init__(self, config: HubertConfig, layer_id: int = 0, **kwargs: Any) -> None: super().__init__(**kwargs) self.in_conv_dim","src_len) ) attn_weights = tf.reshape(attn_weights, (bsz * self.num_heads, tgt_len, src_len)) attn_probs = self.dropout(attn_weights,","past_key_value is not None: # reuse k, v, self_attention key_states = self._shape(self.k_proj(hidden_states), -1,","in range(len(input_shape))] is_instance_norm = (input_shape[self.axis] // self.groups) == 1 if not is_instance_norm: group_shape[self.axis]","**kwargs: Any) -> None: super().__init__(**kwargs) self.in_conv_dim = config.conv_dim[layer_id] if layer_id > 0 else","output_attentions: Optional[tf.Tensor] = None, output_hidden_states: Optional[tf.Tensor] = None, return_dict: Optional[bool] = None, training:","= tf.cast(mask, dtype=one_cst.dtype) expanded_mask = tf.tile(mask[:, None, None, :], (1, 1, tgt_len, 1))","False, ) -> Union[TFBaseModelOutput, Tuple[tf.Tensor]]: \"\"\" Returns: Example: ```python >>> from transformers import","formula taken # from https://pytorch.org/docs/stable/generated/torch.nn.Conv1d.html return (input_length - kernel_size) // stride + 1","dim = input_shape[self.axis] if dim is None: raise ValueError( \"Axis \" + str(self.axis)","+ (layer_outputs[1],) # Add last layer if output_hidden_states: all_hidden_states = all_hidden_states + (hidden_states,)","input_lengths: tf.Tensor): \"\"\" Computes the output length of the convolutional layers \"\"\" def","`[0, 1]`: - 0 corresponds to a *sentence A* token, - 1 corresponds","return_dict=inputs[\"return_dict\"], training=inputs[\"training\"], ) hidden_states = encoder_outputs[0] if not inputs[\"return_dict\"]: return (hidden_states,) + encoder_outputs[1:]","output[\"kwargs\"] boolean_dict = { k: v for k, v in output.items() if k","**kwargs): super().__init__(**kwargs) self.attention = TFHubertAttention( embed_dim=config.hidden_size, num_heads=config.num_attention_heads, dropout=config.attention_dropout, is_decoder=False, name=\"attention\", ) self.dropout =","need to account for padding input_shape[-2] += self.explicit_padding * 2 super().build(input_shape) self.kernel =","(such as downloading or saving, resizing the input embeddings, pruning heads etc.) This","int], mask_prob: float, mask_length: int, min_masks: int = 0, ) -> tf.Tensor: \"\"\"","= logging.get_logger(__name__) _CONFIG_FOR_DOC = \"HubertConfig\" TF_HUBERT_PRETRAINED_MODEL_ARCHIVE_LIST = [ \"facebook/hubert-base-ls960\", # See all Hubert","\"\"\" An abstract class to handle weights initialization and a simple interface for","False, ) -> Union[TFCausalLMOutput, Tuple[tf.Tensor]]: r\"\"\" labels (`tf.Tensor` or `np.ndarray` of shape `(batch_size,","offset=beta, variance_epsilon=self.epsilon, ) return normalized_inputs def _get_reshaped_weights(self, input_shape): broadcast_shape = self._create_broadcast_shape(input_shape) gamma =","input_shape[self.axis] if self.groups == -1: self.groups = dim def _check_size_of_dimensions(self, input_shape): dim =","signature.pop(\"kwargs\", None) signature.pop(\"self\", None) parameter_names = list(signature.keys()) output = {} allowed_types = (tf.Tensor,","to encode labels >>> with processor.as_target_processor(): ... labels = processor(transcription, return_tensors=\"tf\").input_values >>> loss","= ( inputs[\"output_attentions\"] if inputs[\"output_attentions\"] else self.config.output_attentions ) inputs[\"return_dict\"] = inputs[\"return_dict\"] if inputs[\"return_dict\"]","return TFBaseModelOutput( last_hidden_state=hidden_states, hidden_states=encoder_outputs.hidden_states, attentions=encoder_outputs.attentions, ) class TFHubertPreTrainedModel(TFPreTrainedModel): \"\"\" An abstract class to","applicable law or agreed to in writing, software # distributed under the License","and past_key_value is not None: # reuse k,v, cross_attentions key_states = past_key_value[0] value_states","This second option is useful when using [`tf.keras.Model.fit`] method which currently requires having","tuple, list, dict, np.ndarray) for k, v in kwargs.items(): if isinstance(v, allowed_types) or","the TF 2.0 documentation for all matter related to general usage and behavior.","is not None else src_len one_cst = tf.constant(1.0) mask = tf.cast(mask, dtype=one_cst.dtype) expanded_mask","All rights reserved. # # Licensed under the Apache License, Version 2.0 (the","return_dict=return_dict, training=training, ) inputs[\"output_hidden_states\"] = ( inputs[\"output_hidden_states\"] if inputs[\"output_hidden_states\"] else self.config.output_hidden_states ) inputs[\"output_attentions\"]","dim < self.groups: raise ValueError( \"Number of groups (\" + str(self.groups) + \")","can be obtained using [`BertTokenizer`]. See [`PreTrainedTokenizer.__call__`] and [`PreTrainedTokenizer.encode`] for details. [What are","= self.head_dim**-0.5 self.is_decoder = is_decoder self.k_proj = tf.keras.layers.Dense(embed_dim, use_bias=bias, name=\"k_proj\") self.q_proj = tf.keras.layers.Dense(embed_dim,",") self.conv_layers = conv_layers def call(self, input_values): hidden_states = tf.expand_dims(input_values, -1) for conv_layer","= tf.keras.layers.Dense(embed_dim, use_bias=bias, name=\"k_proj\") self.q_proj = tf.keras.layers.Dense(embed_dim, use_bias=bias, name=\"q_proj\") self.v_proj = tf.keras.layers.Dense(embed_dim, use_bias=bias,","we check only the # `name` part tensor_name = input.name.split(\":\")[0] if tensor_name in","# add LayerDrop (see https://arxiv.org/abs/1909.11556 for description) dropout_probability = np.random.uniform(0, 1) if training","or not to return the attentions tensors of all attention layers. See `attentions`","[bsz, 1, tgt_len, src_len], message=f\"Attention mask should be of size {(bsz, 1, tgt_len,","self._check_if_input_shape_is_none(input_shape) self._set_number_of_groups_for_instance_norm(input_shape) self._check_size_of_dimensions(input_shape) self._create_input_spec(input_shape) self._add_gamma_weight(input_shape) self._add_beta_weight(input_shape) self.built = True super().build(input_shape) def call(self, inputs):","< 1: raise ValueError(\"`mask_length` has to be bigger than 0.\") if mask_length >","CPU. If you wish \" \"to train/fine-tine this model, you need a GPU","[ TFHubertLayerNormConvLayer(config, layer_id=i, name=f\"conv_layers.{i}\") for i in range(config.num_feat_extract_layers) ] else: raise ValueError( f\"`config.feat_extract_norm`","if self.config.output_hidden_states else None attns = tf.convert_to_tensor(output.attentions) if self.config.output_attentions else None return TFBaseModelOutput(last_hidden_state=output.last_hidden_state,","class TFHubertFeatureProjection(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs): super().__init__(**kwargs) self.layer_norm = tf.keras.layers.LayerNormalization(epsilon=config.layer_norm_eps, name=\"layer_norm\") self.projection","v is not None) return TFBaseModelOutput( last_hidden_state=hidden_states, hidden_states=all_hidden_states, attentions=all_self_attentions, ) @keras_serializable class TFHubertMainLayer(tf.keras.layers.Layer):","TFHubertModel >>> from datasets import load_dataset >>> import soundfile as sf >>> processor","= tf.keras.backend.int_shape(inputs) tensor_input_shape = tf.shape(inputs) reshaped_inputs, group_shape = self._reshape_into_groups(inputs, input_shape, tensor_input_shape) normalized_inputs =","Inc. team. All rights reserved. # # Licensed under the Apache License, Version","limitations under the License. \"\"\" TensorFlow Hubert model.\"\"\" import inspect import warnings from","= None, gamma_constraint: tf.keras.constraints.Constraint = None, **kwargs, ): super().__init__(**kwargs) self.supports_masking = True self.groups","TFHubertModel(TFHubertPreTrainedModel): def __init__(self, config: HubertConfig, *inputs, **kwargs): super().__init__(config, *inputs, **kwargs) self.config = config","position_ids=position_ids, head_mask=head_mask, inputs_embeds=inputs_embeds, output_attentions=output_attentions, output_hidden_states=output_hidden_states, return_dict=return_dict, training=training, ) outputs = self.hubert( input_values=inputs[\"input_values\"], attention_mask=inputs[\"attention_mask\"],","None, output_hidden_states: Optional[bool] = None, return_dict: Optional[bool] = None, training: bool = False,","3) ) attn_output = tf.reshape(attn_output, (bsz, tgt_len, embed_dim)) attn_output = self.out_proj(attn_output) attn_weights: tf.Tensor","= self.activation(hidden_states) return hidden_states # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2LayerNormConvLayer with Wav2Vec2->Hubert class TFHubertLayerNormConvLayer(tf.keras.layers.Layer): def","**kwargs): super().__init__(config, *inputs, **kwargs) self.config = config self.hubert = TFHubertMainLayer(config, name=\"hubert\") @add_start_docstrings_to_model_forward(HUBERT_INPUTS_DOCSTRING) @replace_return_docstrings(output_type=TFBaseModelOutput,","= tf.reshape(offsets, (batch_size, num_masked_spans * mask_length)) spec_aug_mask_idxs = spec_aug_mask_idxs + offsets # scatter","is accepted for {parameter_names[i]}.\" ) elif isinstance(input_values, (dict, BatchEncoding)): if \"inputs\" in input_values:","0) return hidden_states def call( self, input_values: tf.Tensor, attention_mask: Optional[tf.Tensor] = None, token_type_ids:","self.config = config self.hubert = TFHubertMainLayer(config, name=\"hubert\") @add_start_docstrings_to_model_forward(HUBERT_INPUTS_DOCSTRING) @replace_return_docstrings(output_type=TFBaseModelOutput, config_class=_CONFIG_FOR_DOC) def call( self,","None, head_mask: Optional[tf.Tensor] = None, inputs_embeds: Optional[tf.Tensor] = None, output_attentions: Optional[bool] = None,","* self.num_heads, tgt_len, src_len)) attn_weights = tf.nn.softmax(attn_weights, axis=-1) if layer_head_mask is not None:","tf.reshape(key_states, proj_shape) value_states = tf.reshape(value_states, proj_shape) src_len = shape_list(key_states)[1] attn_weights = tf.matmul(query_states, key_states,","(bsz, self.num_heads, tgt_len, src_len) ) attn_weights = tf.reshape(attn_weights, (bsz * self.num_heads, tgt_len, src_len))","{num_heads}).\" ) self.scaling = self.head_dim**-0.5 self.is_decoder = is_decoder self.k_proj = tf.keras.layers.Dense(embed_dim, use_bias=bias, name=\"k_proj\")","given in the docstring: `model({\"input_values\": input_values, \"token_type_ids\": token_type_ids})` </Tip> Args: config ([`HubertConfig`]): Model","= True, training: Optional[bool] = False, ) -> Union[TFBaseModelOutput, Tuple[tf.Tensor]]: all_hidden_states = ()","if is_cross_attention and past_key_value is not None: # reuse k,v, cross_attentions key_states =","= tf.zeros((batch_size, sequence_length), dtype=tf.int32) # uniform distribution to sample from, make sure that","vocabulary. Indices can be obtained using [`BertTokenizer`]. See [`PreTrainedTokenizer.__call__`] and [`PreTrainedTokenizer.encode`] for details.","version, use `input_values` instead.\", FutureWarning, ) output[\"input_values\"] = input_values.pop(\"inputs\") if \"decoder_cached_states\" in input_values:","is always the first parameter, then `input_values` output[\"input_values\"] = output[\"args\"] del output[\"args\"] if","version, use `past_key_values` instead.\", FutureWarning, ) output[\"past_key_values\"] = input_values.pop(\"decoder_cached_states\") for k, v in","(the \"License\"); # you may not use this file except in compliance with","self.config.mask_feature_prob > 0: mask_feature_indices = _compute_mask_indices( (batch_size, hidden_size), mask_prob=self.config.mask_feature_prob, mask_length=self.config.mask_feature_length, ) hidden_states =","class TFHubertForCTC(TFHubertPreTrainedModel): def __init__(self, config: HubertConfig, *inputs, **kwargs): super().__init__(config, *inputs, **kwargs) self.hubert =","kernel = tf.nn.l2_normalize(self.weight_v, axis=self.kernel_norm_axes) * tf.transpose(self.weight_g) self.kernel = tf.transpose(kernel) def build(self, input_shape): if","to pair indices return tf.scatter_nd(pair_indices, tf.reshape(values, [-1]), output_shape) # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2._compute_mask_indices def","= TFHubertGroupNorm(groups=self.out_conv_dim, epsilon=config.layer_norm_eps, name=\"layer_norm\") def call(self, hidden_states: tf.Tensor) -> tf.Tensor: hidden_states = self.conv(hidden_states)","value in the config will be used instead. output_hidden_states (`bool`, *optional*): Whether or","(dim,) if self.scale: self.gamma = self.add_weight( shape=shape, name=\"gamma\", initializer=self.gamma_initializer, regularizer=self.gamma_regularizer, constraint=self.gamma_constraint, ) else:","and (dropout_probability < self.config.layerdrop): # skip the layer continue layer_outputs = layer_module( hidden_states=hidden_states,","tf.tile(offsets, (batch_size, num_masked_spans, 1)) offsets = tf.reshape(offsets, (batch_size, num_masked_spans * mask_length)) spec_aug_mask_idxs =","last_hidden_state=hidden_states, hidden_states=encoder_outputs.hidden_states, attentions=encoder_outputs.attentions, ) class TFHubertPreTrainedModel(TFPreTrainedModel): \"\"\" An abstract class to handle weights","is {config.feat_extract_norm}, but has to be one of ['group', 'layer']\" ) self.conv_layers =","hidden_states = attn_residual + hidden_states hidden_states = hidden_states + self.feed_forward(self.final_layer_norm(hidden_states)) outputs = (hidden_states,)","+ output) if loss is not None else output return TFCausalLMOutput( loss=loss, logits=logits,","TFHubertEncoder(config, name=\"encoder\") def build(self, input_shape: tf.TensorShape): self.masked_spec_embed = self.add_weight( shape=(self.config.hidden_size,), initializer=\"uniform\", trainable=True, name=\"masked_spec_embed\"","used as a cross-attention layer # for the decoder is_cross_attention = key_value_states is","attention_mask=inputs[\"attention_mask\"], token_type_ids=inputs[\"token_type_ids\"], position_ids=inputs[\"position_ids\"], head_mask=inputs[\"head_mask\"], inputs_embeds=inputs[\"inputs_embeds\"], output_attentions=inputs[\"output_attentions\"], output_hidden_states=inputs[\"output_hidden_states\"], return_dict=inputs[\"return_dict\"], training=inputs[\"training\"], ) hidden_states = outputs[0]","None if self.scale: gamma = tf.reshape(self.gamma, broadcast_shape) if self.center: beta = tf.reshape(self.beta, broadcast_shape)","- see https://github.com/tensorflow/tensorflow/issues/9260 for more info \"\"\" z = -tf.math.log(tf.random.uniform(shape_list(distribution), 0, 1)) _,","conv_layers = [ TFHubertLayerNormConvLayer(config, layer_id=i, name=f\"conv_layers.{i}\") for i in range(config.num_feat_extract_layers) ] else: raise","not None: hidden_states = hidden_states * tf.expand_dims(attention_mask, -1) attention_mask = _expand_mask(attention_mask) else: attention_mask","kernel_size, stride): # 1D convolutional layer output length formula taken # from https://pytorch.org/docs/stable/generated/torch.nn.Conv1d.html","for i in range(config.num_feat_extract_layers) ] else: raise ValueError( f\"`config.feat_extract_norm` is {config.feat_extract_norm}, but has","= dim def _check_size_of_dimensions(self, input_shape): dim = input_shape[self.axis] if dim < self.groups: raise","Mask values selected in `[0, 1]`: - 1 indicates the head is **not","and name != \"args\": output[name] = kwargs.pop(name, signature[name].default) # When creating a SavedModel","cross attention key/value_states. # Further calls to cross_attention layer can then reuse all","== 1 if not is_instance_norm: axis = -2 if self.axis == -1 else","tgt_len, src_len) ) attn_weights = tf.reshape(attn_weights, (bsz * self.num_heads, tgt_len, src_len)) attn_probs =","hidden_states = self.activation(hidden_states) return hidden_states # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2GroupNormConvLayer with Wav2Vec2->Hubert class TFHubertGroupNormConvLayer(tf.keras.layers.Layer):","instead of a plain tuple. This argument can be used in eager mode,","input_shape): group_shape = tf.keras.backend.int_shape(reshaped_inputs) group_reduction_axes = list(range(1, len(group_shape))) is_instance_norm = (input_shape[self.axis] // self.groups)","logits_time_major=False, ) if self.config.ctc_loss_reduction == \"sum\": loss = tf.reduce_sum(loss) if self.config.ctc_loss_reduction == \"mean\":","center: bool = True, scale: bool = True, beta_initializer: tf.keras.initializers.Initializer = \"zeros\", gamma_initializer:","of the weight vector.\"\"\" kernel_norm = tf.sqrt(tf.reduce_sum(tf.square(self.weight_v), axis=self.kernel_norm_axes)) self.weight_g.assign(kernel_norm[:, tf.newaxis, tf.newaxis]) def _normalize_kernel(self):","raise ValueError(\"`mask_length` has to be bigger than 0.\") if mask_length > sequence_length: raise","int): return tf.transpose(tf.reshape(tensor, (bsz, seq_len, self.num_heads, self.head_dim)), (0, 2, 1, 3)) def call(","# all previous decoder key/value_states. Further calls to uni-directional self-attention # can concat","if output_attentions: outputs += (attn_weights,) return outputs # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2Encoder with Wav2Vec2->Hubert","self.dropout(hidden_states, training=inputs[\"training\"]) logits = self.lm_head(hidden_states) if labels is not None: if tf.reduce_max(labels) >=","sequence_length), mask_prob=self.config.mask_time_prob, mask_length=self.config.mask_time_length, min_masks=2, ) hidden_states = tf.where( tf.cast(mask_time_indices[:, :, tf.newaxis], tf.bool), self.masked_spec_embed[tf.newaxis,","& apply SpecAugment along time axis mask_time_indices = _compute_mask_indices( (batch_size, sequence_length), mask_prob=self.config.mask_time_prob, mask_length=self.config.mask_time_length,","is not None: # The tf.debugging asserts are not compliant with XLA then","outputs[1:] return ((loss,) + output) if loss is not None else output return","has to be smaller than `sequence_length`, but got `mask_length`: {mask_length} and `sequence_length`: {sequence_length}`\"","0), (self.explicit_padding, self.explicit_padding), (0, 0))) output = super().call(padded_inputs) return output # Copied from","build(self, input_shape: tf.TensorShape): self.masked_spec_embed = self.add_weight( shape=(self.config.hidden_size,), initializer=\"uniform\", trainable=True, name=\"masked_spec_embed\" ) super().build(input_shape) def","attention layers. See `attentions` under returned tensors for more detail. This argument can","(bsz, self.num_heads, tgt_len, src_len)) + attention_mask attn_weights = tf.reshape(attn_weights, (bsz * self.num_heads, tgt_len,","part tensor_name = input.name.split(\":\")[0] if tensor_name in parameter_names: output[tensor_name] = input else: output[parameter_names[i]]","is not None: # compute real output lengths according to convolution formula output_lengths","1, tgt_len, 1)) return (one_cst - expanded_mask) * LARGE_NEGATIVE # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2GroupNorm","training=training) hidden_states = attn_residual + hidden_states hidden_states = hidden_states + self.feed_forward(self.final_layer_norm(hidden_states)) outputs =","given shape Args: shape: the the shape for which to compute masks. should","= False, ) -> Tuple[tf.Tensor]: attn_residual = hidden_states hidden_states = self.layer_norm(hidden_states) hidden_states, attn_weights,","variance_epsilon=self.epsilon, ) return normalized_inputs def _get_reshaped_weights(self, input_shape): broadcast_shape = self._create_broadcast_shape(input_shape) gamma = None","trainable=True) self.weight_v = self.kernel self.weight_g = self.add_weight( name=\"weight_g\", shape=(int(self.weight_v.shape[self.filter_axis]), 1, 1), initializer=\"ones\", dtype=self.weight_v.dtype,","tf.Tensor) or input_values is None: output[parameter_names[0]] = input_values else: raise ValueError( f\"Data of","for the specific language governing permissions and # limitations under the License. \"\"\"","each input sequence tokens in the position embeddings. Selected in the range `[0,","..., config.vocab_size]` Returns: Example: ```python >>> import tensorflow as tf >>> from transformers","self.groups != 0: raise ValueError( \"Number of groups (\" + str(self.groups) + \")",".name property so we check for a real Tensor if type(input) == tf.Tensor:","three possibilities you can use to gather all the input Tensors in the","[SpecAugment](https://arxiv.org/abs/1904.08779). \"\"\" batch_size, sequence_length, hidden_size = shape_list(hidden_states) # `config.apply_spec_augment` can set masking to",">>> def map_to_array(batch): ... speech, _ = sf.read(batch[\"file\"]) ... batch[\"speech\"] = speech ...","sequence_length / mask_length + tf.random.uniform((1,))) num_masked_spans = max(num_masked_spans, min_masks) # make sure num","input_lengths = _conv_out_length(input_lengths, kernel_size, stride) return input_lengths def _mask_hidden_states(self, hidden_states: tf.Tensor, mask_time_indices: Optional[tf.Tensor]","= None, gamma_regularizer: tf.keras.regularizers.Regularizer = None, beta_constraint: tf.keras.constraints.Constraint = None, gamma_constraint: tf.keras.constraints.Constraint =","use_bias=bias, name=\"v_proj\") self.out_proj = tf.keras.layers.Dense(embed_dim, use_bias=bias, name=\"out_proj\") def _shape(self, tensor: tf.Tensor, seq_len: int,","the same size as shape, which will prevent masking padded elements mask_prob: probability","computation for the feature encoder so that its parameters will not be updated","tf.TensorShape): self.masked_spec_embed = self.add_weight( shape=(self.config.hidden_size,), initializer=\"uniform\", trainable=True, name=\"masked_spec_embed\" ) super().build(input_shape) def _get_feat_extract_output_lengths(self, input_lengths:","= tf.range(mask_length)[tf.newaxis, tf.newaxis, :] offsets = tf.tile(offsets, (batch_size, num_masked_spans, 1)) offsets = tf.reshape(offsets,","self.final_layer_norm(hidden_states) outputs = (hidden_states,) if output_attentions: outputs += (attn_weights,) return outputs # Copied","indices to indicate first and second portions of the inputs. Indices are selected","() if output_attentions else None if attention_mask is not None: hidden_states = hidden_states","masked language modeling loss. Indices should be in `[-100, 0, ..., config.vocab_size]` (see","transformers.models.bart.modeling_tf_bart._expand_mask def _expand_mask(mask: tf.Tensor, tgt_len: Optional[int] = None, past_key_values_length: int = 0): \"\"\"","raise ValueError(f\"Label values must be <= vocab_size: {self.config.vocab_size}\") attention_mask = ( inputs[\"attention_mask\"] if","(`bool`, *optional*, defaults to `False``): Whether or not to use the model in","return_tensors=\"tf\").input_values # Batch size 1 >>> logits = model(input_values).logits >>> predicted_ids = tf.argmax(logits,","the shape for which to compute masks. should be of size 2 where","along feature axis according to [SpecAugment](https://arxiv.org/abs/1904.08779). \"\"\" batch_size, sequence_length, hidden_size = shape_list(hidden_states) #","= input.name.split(\":\")[0] if tensor_name in parameter_names: output[tensor_name] = input else: output[parameter_names[i]] = input","self.head_dim) query_states = tf.reshape(self._shape(query_states, tgt_len, bsz), proj_shape) key_states = tf.reshape(key_states, proj_shape) value_states =","future version, use `past_key_values` instead.\", FutureWarning, ) output[\"past_key_values\"] = input_values.pop(\"decoder_cached_states\") for k, v","\"center\": self.center, \"scale\": self.scale, \"beta_initializer\": tf.keras.initializers.serialize(self.beta_initializer), \"gamma_initializer\": tf.keras.initializers.serialize(self.gamma_initializer), \"beta_regularizer\": tf.keras.regularizers.serialize(self.beta_regularizer), \"gamma_regularizer\": tf.keras.regularizers.serialize(self.gamma_regularizer), \"beta_constraint\":","= None, output_attentions: Optional[tf.Tensor] = None, output_hidden_states: Optional[tf.Tensor] = None, return_dict: Optional[bool] =","HubertConfig, **kwargs): super().__init__(**kwargs) self.config = config self.feature_extractor = TFHubertFeatureEncoder(config, name=\"feature_extractor\") self.feature_projection = TFHubertFeatureProjection(config,","Add last layer if output_hidden_states: all_hidden_states = all_hidden_states + (hidden_states,) if not return_dict:","hidden_states, attention_mask=attention_mask, training=training ) hidden_states = self.dropout(hidden_states, training=training) hidden_states = attn_residual + hidden_states","for i in range(len(input_shape))] is_instance_norm = (input_shape[self.axis] // self.groups) == 1 if not","from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2EncoderLayer with Wav2Vec2->Hubert class TFHubertEncoderLayer(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs): super().__init__(**kwargs) self.attention","\"input_values\" @property def dummy_inputs(self) -> Dict[str, tf.Tensor]: pad_token = 0.0 input_values = tf.convert_to_tensor(np.random.rand(1,","input_values: warnings.warn( \"The `decoder_cached_states` argument is deprecated and will be removed in a","{allowed_types} is accepted for {parameter_names[i]}.\" ) elif isinstance(input_values, (dict, BatchEncoding)): if \"inputs\" in","dtype=one_cst.dtype) expanded_mask = tf.tile(mask[:, None, None, :], (1, 1, tgt_len, 1)) return (one_cst","plain tuple. This argument can be used in eager mode, in graph mode","mask_length: size of the mask min_masks: minimum number of masked spans Adapted from","return hidden_states if mask_time_indices is not None: # apply SpecAugment along time axis","return_dict=return_dict, training=training, kwargs_call=kwargs, ) hidden_states = self.feature_extractor( tf.cast(inputs[\"input_values\"], tf.float32), training=inputs[\"training\"] ) if inputs[\"attention_mask\"]","self._get_feat_extract_output_lengths(tf.reduce_sum(inputs[\"attention_mask\"], -1)) attention_mask = tf.sequence_mask( output_lengths, maxlen=shape_list(hidden_states)[1], dtype=hidden_states.dtype ) hidden_states = self.feature_projection(hidden_states, training=inputs[\"training\"])","\"\"\" Masks extracted features along time axis and/or along feature axis according to","\"\"\" indices_shape = shape_list(batch_indices) # broadcast batch dim to indices_shape broad_casted_batch_dims = tf.reshape(","initializer=self.beta_initializer, regularizer=self.beta_regularizer, constraint=self.beta_constraint, ) else: self.beta = None def _create_broadcast_shape(self, input_shape): broadcast_shape =","do for now - see https://github.com/tensorflow/tensorflow/issues/9260 for more info \"\"\" z = -tf.math.log(tf.random.uniform(shape_list(distribution),","_CONFIG_FOR_DOC = \"HubertConfig\" TF_HUBERT_PRETRAINED_MODEL_ARCHIVE_LIST = [ \"facebook/hubert-base-ls960\", # See all Hubert models at","check only the # `name` part tensor_name = input.name.split(\":\")[0] if tensor_name in parameter_names:","num_conv_pos_embeddings, **kwargs): super().__init__(**kwargs) self.num_pad_remove = 1 if num_conv_pos_embeddings % 2 == 0 else","tf.Tensor, attention_mask: Optional[tf.Tensor] = None, token_type_ids: Optional[tf.Tensor] = None, position_ids: Optional[tf.Tensor] = None,","self.conv(hidden_states) hidden_states = self.layer_norm(hidden_states) hidden_states = self.activation(hidden_states) return hidden_states # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2PositionalConvEmbedding","layer_outputs[0] if output_attentions: all_self_attentions = all_self_attentions + (layer_outputs[1],) # Add last layer if","of a plain tuple. This argument can be used in eager mode, in","for k, v in dict(input_values).items(): if isinstance(v, allowed_types) or v is None: output[k]","float = 1e-3, center: bool = True, scale: bool = True, beta_initializer: tf.keras.initializers.Initializer","attention_mask is not None: hidden_states = hidden_states * tf.expand_dims(attention_mask, -1) attention_mask = _expand_mask(attention_mask)","than eager. if tf.executing_eagerly(): tf.debugging.assert_equal( shape_list(layer_head_mask), [self.num_heads], message=f\"Head mask for a single layer","Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2._sample_without_replacement def _sample_without_replacement(distribution, num_samples): \"\"\" Categorical sampling without replacement is currently","= tf.keras.layers.Dropout(config.hidden_dropout) def call(self, hidden_states: tf.Tensor, training: bool = False) -> tf.Tensor: hidden_states","query_states = tf.reshape(self._shape(query_states, tgt_len, bsz), proj_shape) key_states = tf.reshape(key_states, proj_shape) value_states = tf.reshape(value_states,","from https://www.tensorflow.org/probability/api_docs/python/tfp/layers/weight_norm/WeightNorm\"\"\" def __init__(self, filters, kernel_size, groups, explicit_padding, **kwargs): super().__init__( filters=filters, kernel_size=kernel_size, groups=groups,","\"input tensor should have a defined dimension \" \"but the layer received an","- 1 else: axis = -1 if self.axis == -1 else self.axis -","input else: output[parameter_names[i]] = input elif isinstance(input, allowed_types) or input is None: output[parameter_names[i]]","__init__(self, config, **kwargs): super().__init__(config, **kwargs) warnings.warn( f\"The class `{self.__class__.__name__}` has been depreciated \"","Tuple(tf.Tensor, tf.Tensor) of # all previous decoder key/value_states. Further calls to uni-directional self-attention","in input_values: warnings.warn( \"The `inputs` argument is deprecated and will be removed in","from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2GroupNorm with Wav2Vec2->Hubert class TFHubertGroupNorm(tf.keras.layers.Layer): \"\"\" From tensorflow-addons https://www.tensorflow.org/addons/api_docs/python/tfa/layers/GroupNormalization \"\"\" def __init__(","config.do_stable_layer_norm: self.encoder = TFHubertEncoderStableLayerNorm(config, name=\"encoder\") else: self.encoder = TFHubertEncoder(config, name=\"encoder\") def build(self, input_shape:",">>> processor = Wav2Vec2Processor.from_pretrained(\"facebook/hubert-base-960h\") >>> model = TFHubertModel.from_pretrained(\"facebook/hubert-base-960h\") >>> def map_to_array(batch): ... speech,","if tf.reduce_max(labels) >= self.config.vocab_size: raise ValueError(f\"Label values must be <= vocab_size: {self.config.vocab_size}\") attention_mask","**kwargs) # So to respect the proper output we have to add this","maxlen=shape_list(hidden_states)[1], dtype=hidden_states.dtype ) hidden_states = self.feature_projection(hidden_states, training=inputs[\"training\"]) mask_time_indices = kwargs.get(\"mask_time_indices\", None) if inputs[\"training\"]:","this exception if \"args\" in output: if output[\"args\"] is not None and type(output[\"args\"])","config: HubertConfig, *inputs, **kwargs): super().__init__(config, *inputs, **kwargs) self.config = config self.hubert = TFHubertMainLayer(config,","# key/value_states (first \"if\" case) # if uni-directional self-attention (decoder) save Tuple(tf.Tensor, tf.Tensor)","i in range(config.num_hidden_layers) ] def call( self, hidden_states: tf.Tensor, attention_mask: Optional[tf.Tensor] = None,","self.scale: gamma = tf.reshape(self.gamma, broadcast_shape) if self.center: beta = tf.reshape(self.beta, broadcast_shape) return gamma,","sequence_length: num_masked_spans = sequence_length // mask_length # SpecAugment mask to fill spec_aug_mask =","name=\"encoder\") def build(self, input_shape: tf.TensorShape): self.masked_spec_embed = self.add_weight( shape=(self.config.hidden_size,), initializer=\"uniform\", trainable=True, name=\"masked_spec_embed\" )","be smaller (unless no_overlap is True) mask_length: size of the mask min_masks: minimum","= self._shape(self.k_proj(key_value_states), -1, bsz) value_states = self._shape(self.v_proj(key_value_states), -1, bsz) elif past_key_value is not","labels = processor(transcription, return_tensors=\"tf\").input_values >>> loss = model(input_values, labels=labels).loss ```\"\"\" inputs = input_values_processing(","as np import tensorflow as tf from ...activations_tf import get_tf_activation from ...modeling_tf_outputs import","[1, -1])], 0)) # scatter values to pair indices return tf.scatter_nd(pair_indices, tf.reshape(values, [-1]),","self.dropout(hidden_states, training=training) return hidden_states # Copied from transformers.models.bart.modeling_tf_bart.TFBartAttention with TFBart->TFHubert class TFHubertAttention(tf.keras.layers.Layer): \"\"\"Multi-headed","config.conv_dim[layer_id] if layer_id > 0 else 1 self.out_conv_dim = config.conv_dim[layer_id] self.conv = tf.keras.layers.Conv1D(","instead.\", FutureWarning, ) output[\"input_values\"] = input_values.pop(\"inputs\") if \"decoder_cached_states\" in input_values: warnings.warn( \"The `decoder_cached_states`","def call(self, inputs): input_shape = tf.keras.backend.int_shape(inputs) tensor_input_shape = tf.shape(inputs) reshaped_inputs, group_shape = self._reshape_into_groups(inputs,","graph mode the value in the config will be used instead. return_dict (`bool`,",") self.dropout = tf.keras.layers.Dropout(rate=config.feat_proj_dropout) def call(self, hidden_states: tf.Tensor, training: bool = False) ->","*optional*): Whether or not to return a [`~file_utils.ModelOutput`] instead of a plain tuple.","output_attentions else None if attention_mask is not None: hidden_states = hidden_states * tf.expand_dims(attention_mask,","and second portions of the inputs. Indices are selected in `[0, 1]`: -","TFBaseModelOutput( last_hidden_state=hidden_states, hidden_states=encoder_outputs.hidden_states, attentions=encoder_outputs.attentions, ) class TFHubertPreTrainedModel(TFPreTrainedModel): \"\"\" An abstract class to handle","shape \" + str(input_shape) + \".\" ) def _set_number_of_groups_for_instance_norm(self, input_shape): dim = input_shape[self.axis]","from transformers.models.bart.modeling_tf_bart.TFBartAttention with TFBart->TFHubert class TFHubertAttention(tf.keras.layers.Layer): \"\"\"Multi-headed attention from \"Attention Is All You","= -tf.math.log(tf.random.uniform(shape_list(distribution), 0, 1)) _, indices = tf.nn.top_k(distribution + z, num_samples) return indices","def call(self, hidden_states: tf.Tensor) -> tf.Tensor: hidden_states = self.conv(hidden_states) hidden_states = self.padding(hidden_states) hidden_states","Categorical sampling without replacement is currently not implemented. The gumbel-max trick will do",") if dim % self.groups != 0: raise ValueError( \"Number of groups (\"","self.layer_norm = tf.keras.layers.LayerNormalization(epsilon=config.layer_norm_eps, name=\"layer_norm\") self.dropout = tf.keras.layers.Dropout(config.hidden_dropout) self.layer = [ TFHubertEncoderLayerStableLayerNorm(config, name=f\"layers.{i}\") for","kernel_size=config.conv_kernel[layer_id], strides=config.conv_stride[layer_id], use_bias=config.conv_bias, name=\"conv\", ) self.activation = get_tf_activation(config.feat_extract_activation) self.layer_norm = TFHubertGroupNorm(groups=self.out_conv_dim, epsilon=config.layer_norm_eps, name=\"layer_norm\")",") return spec_aug_mask # Copied from transformers.models.bart.modeling_tf_bart._expand_mask def _expand_mask(mask: tf.Tensor, tgt_len: Optional[int] =","num_masked_spans * mask_length)) spec_aug_mask_idxs = spec_aug_mask_idxs + offsets # scatter indices to mask","(1, 1, mask_length)) spec_aug_mask_idxs = tf.reshape(spec_aug_mask_idxs, (batch_size, num_masked_spans * mask_length)) offsets = tf.range(mask_length)[tf.newaxis,","norm of the weight vector.\"\"\" kernel_norm = tf.sqrt(tf.reduce_sum(tf.square(self.weight_v), axis=self.kernel_norm_axes)) self.weight_g.assign(kernel_norm[:, tf.newaxis, tf.newaxis]) def","return spec_aug_mask # Copied from transformers.models.bart.modeling_tf_bart._expand_mask def _expand_mask(mask: tf.Tensor, tgt_len: Optional[int] = None,","in Transformers v5.\" \"Please use the equivalent `freeze_feature_encoder` method instead.\", FutureWarning, ) self.freeze_feature_encoder()","_, indices = tf.nn.top_k(distribution + z, num_samples) return indices # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2._scatter_values_on_batch_indices","conv_layer in self.conv_layers: hidden_states = conv_layer(hidden_states) return hidden_states class TFHubertFeatureExtractor(TFHubertFeatureEncoder): def __init__(self, config,","outputs def serving_output(self, output): hs = tf.convert_to_tensor(output.hidden_states) if self.config.output_hidden_states else None attns =","kwargs.pop(name, signature[name].default) # When creating a SavedModel TF calls the method with LayerCall.__call__(args,","else None if attention_mask is not None: hidden_states = hidden_states * tf.expand_dims(attention_mask, -1)","useful if you want more control over how to convert `input_values` indices into","= all_hidden_states + (hidden_states,) if not return_dict: return tuple(v for v in [hidden_states,","= tf.tile(mask[:, None, None, :], (1, 1, tgt_len, 1)) return (one_cst - expanded_mask)","varying length with one or several input Tensors IN THE ORDER given in","inputs[\"return_dict\"] else self.config.return_dict outputs = self.hubert( input_values=inputs[\"input_values\"], attention_mask=inputs[\"attention_mask\"], token_type_ids=inputs[\"token_type_ids\"], position_ids=inputs[\"position_ids\"], head_mask=inputs[\"head_mask\"], inputs_embeds=inputs[\"inputs_embeds\"], output_attentions=inputs[\"output_attentions\"],","None) if inputs[\"training\"]: hidden_states = self._mask_hidden_states(hidden_states, mask_time_indices=mask_time_indices) encoder_outputs = self.encoder( hidden_states, attention_mask=attention_mask, output_attentions=inputs[\"output_attentions\"],","tf.keras.backend.int_shape(inputs) tensor_input_shape = tf.shape(inputs) reshaped_inputs, group_shape = self._reshape_into_groups(inputs, input_shape, tensor_input_shape) normalized_inputs = self._apply_normalization(reshaped_inputs,","permissions and # limitations under the License. \"\"\" TensorFlow Hubert model.\"\"\" import inspect",": -self.num_pad_remove, :] return hidden_states class TFHubertFeatureEncoder(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs: Any)","tf.Tensor): \"\"\" Computes the output length of the convolutional layers \"\"\" def _conv_out_length(input_length,","tf.reshape(attn_output, (bsz, tgt_len, embed_dim)) attn_output = self.out_proj(attn_output) attn_weights: tf.Tensor = tf.reshape(attn_weights, (bsz, self.num_heads,","`False``): Whether or not to use the model in training mode (some modules","type {type(input)} is not allowed only {allowed_types} is accepted for {parameter_names[i]}.\" ) elif",">>> ds = load_dataset(\"hf-internal-testing/librispeech_asr_dummy\", \"clean\", split=\"validation\") >>> ds = ds.map(map_to_array) >>> input_values =","1, tgt_len, src_len], message=f\"Attention mask should be of size {(bsz, 1, tgt_len, src_len)},","Dict, Optional, Tuple, Union import numpy as np import tensorflow as tf from","group_shape = tf.stack(group_shape) reshaped_inputs = tf.reshape(inputs, group_shape) return reshaped_inputs, group_shape else: return inputs,","output[\"args\"] if \"kwargs\" in output: del output[\"kwargs\"] boolean_dict = { k: v for","from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2LayerNormConvLayer with Wav2Vec2->Hubert class TFHubertLayerNormConvLayer(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, layer_id: int =","# Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2FeedForward with Wav2Vec2->Hubert class TFHubertFeedForward(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs):","= normalized_inputs return outputs def get_config(self): config = { \"groups\": self.groups, \"axis\": self.axis,","or `tf.Tensor` of shape `({0})`, *optional*): Mask to avoid performing attention on padding","offsets # scatter indices to mask spec_aug_mask = _scatter_values_on_batch_indices( tf.ones_like(spec_aug_mask_idxs), spec_aug_mask_idxs, spec_aug_mask.shape )","soundfile as sf >>> processor = Wav2Vec2Processor.from_pretrained(\"facebook/hubert-base-960h\") >>> model = TFHubertForCTC.from_pretrained(\"facebook/hubert-base-960h\") >>> def","hidden_states = self._mask_hidden_states(hidden_states, mask_time_indices=mask_time_indices) encoder_outputs = self.encoder( hidden_states, attention_mask=attention_mask, output_attentions=inputs[\"output_attentions\"], output_hidden_states=inputs[\"output_hidden_states\"], return_dict=inputs[\"return_dict\"], training=inputs[\"training\"],","None def _create_broadcast_shape(self, input_shape): broadcast_shape = [1] * len(input_shape) is_instance_norm = (input_shape[self.axis] //",") def _set_number_of_groups_for_instance_norm(self, input_shape): dim = input_shape[self.axis] if self.groups == -1: self.groups =","with shape \" + str(input_shape) + \".\" ) def _set_number_of_groups_for_instance_norm(self, input_shape): dim =","should be of size {(bsz * self.num_heads, tgt_len, src_len)}, but is {shape_list(attn_weights)}\", )","= tf.reshape(attn_output, (bsz, tgt_len, embed_dim)) attn_output = self.out_proj(attn_output) attn_weights: tf.Tensor = tf.reshape(attn_weights, (bsz,","broadcast_shape) return gamma, beta def _check_if_input_shape_is_none(self, input_shape): dim = input_shape[self.axis] if dim is","self.encoder = TFHubertEncoderStableLayerNorm(config, name=\"encoder\") else: self.encoder = TFHubertEncoder(config, name=\"encoder\") def build(self, input_shape: tf.TensorShape):","= () if output_hidden_states else None all_self_attentions = () if output_attentions else None","def _set_number_of_groups_for_instance_norm(self, input_shape): dim = input_shape[self.axis] if self.groups == -1: self.groups = dim","num_masked_spans = max(num_masked_spans, min_masks) # make sure num masked indices <= sequence_length if","= None, inputs_embeds: Optional[tf.Tensor] = None, output_attentions: Optional[tf.Tensor] = None, output_hidden_states: Optional[tf.Tensor] =","calls the method with LayerCall.__call__(args, **kwargs) # So to respect the proper output","key/value_states. # Further calls to cross_attention layer can then reuse all cross-attention #","= self.hubert._get_feat_extract_output_lengths(tf.reduce_sum(attention_mask, axis=-1)) # assuming that padded tokens are filled with -100 #","shape `({0}, hidden_size)`, *optional*): Optionally, instead of passing `input_values` you can choose to","input_values, **kwargs): \"\"\" Process the input of each TensorFlow model including the booleans.","self.num_heads, tgt_len, src_len], message=f\"Attention weights should be of size {(bsz * self.num_heads, tgt_len,","inputs[\"attention_mask\"] is not None else tf.ones_like(inputs[\"input_values\"], dtype=tf.float32) ) input_lengths = self.hubert._get_feat_extract_output_lengths(tf.reduce_sum(attention_mask, axis=-1)) #","`decoder_cached_states` argument is deprecated and will be removed in a future version, use","gather all the input Tensors in the first positional argument : - a","config file does not load the weights associated with the model, only the","name=\"pos_conv_embed\") self.layer_norm = tf.keras.layers.LayerNormalization(epsilon=config.layer_norm_eps, name=\"layer_norm\") self.dropout = tf.keras.layers.Dropout(config.hidden_dropout) self.layer = [TFHubertEncoderLayer(config, name=f\"layers.{i}\") for","if self.axis == -1 else self.axis - 1 else: axis = -1 if","mask_prob=self.config.mask_time_prob, mask_length=self.config.mask_time_length, min_masks=2, ) hidden_states = tf.where( tf.cast(mask_time_indices[:, :, tf.newaxis], tf.bool), self.masked_spec_embed[tf.newaxis, tf.newaxis,","# Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2EncoderLayer with Wav2Vec2->Hubert class TFHubertEncoderLayer(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs):","for padding input_shape[-2] += self.explicit_padding * 2 super().build(input_shape) self.kernel = tf.Variable(tf.transpose(self.kernel), name=\"weight_v\", trainable=True)","range `[0, config.max_position_embeddings - 1]`. [What are position IDs?](../glossary#position-ids) head_mask (`np.ndarray` or `tf.Tensor`","0, ) -> tf.Tensor: \"\"\" Computes random mask spans for a given shape","control over how to convert `input_values` indices into associated vectors than the model's","\" of \" \"input tensor should have a defined dimension \" \"but the","output: TFCausalLMOutput) -> TFCausalLMOutput: hs = tf.convert_to_tensor(output.hidden_states) if self.config.output_hidden_states else None attns =","class TFHubertModel(TFHubertPreTrainedModel): def __init__(self, config: HubertConfig, *inputs, **kwargs): super().__init__(config, *inputs, **kwargs) self.config =","loss. Indices should be in `[-100, 0, ..., config.vocab_size]` (see `input_values` docstring) Tokens","== \"layer\": conv_layers = [ TFHubertLayerNormConvLayer(config, layer_id=i, name=f\"conv_layers.{i}\") for i in range(config.num_feat_extract_layers) ]","input_shape): if not self.built: input_shape = input_shape.as_list() # Conv1D output shapes are checked","of the convolutional layers \"\"\" def _conv_out_length(input_length, kernel_size, stride): # 1D convolutional layer",") attn_output = tf.transpose( tf.reshape(attn_output, (bsz, self.num_heads, tgt_len, self.head_dim)), (0, 2, 1, 3)","sequence_length)`, *optional*): Labels for computing the masked language modeling loss. Indices should be","make sure that offset samples are < sequence_length uniform_dist = tf.ones((batch_size, sequence_length -","tf.concat([past_key_value[1], value_states], axis=2) else: # self_attention key_states = self._shape(self.k_proj(hidden_states), -1, bsz) value_states =","is_decoder=False, name=\"attention\", ) self.dropout = tf.keras.layers.Dropout(config.hidden_dropout) self.layer_norm = tf.keras.layers.LayerNormalization(epsilon=config.layer_norm_eps, name=\"layer_norm\") self.feed_forward = TFHubertFeedForward(config,","(third \"elif\" case) # if encoder bi-directional self-attention `past_key_value` is always `None` past_key_value","class TFHubertPositionalConvEmbedding(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs: Any) -> None: super().__init__(**kwargs) self.conv =","bool = False, bias: bool = True, **kwargs, ): super().__init__(**kwargs) self.embed_dim = embed_dim","abstract class to handle weights initialization and a simple interface for downloading and","# get query proj query_states = self.q_proj(hidden_states) * self.scaling # get key, value","`({0}, hidden_size)`, *optional*): Optionally, instead of passing `input_values` you can choose to directly","target processor to encode labels >>> with processor.as_target_processor(): ... labels = processor(transcription, return_tensors=\"tf\").input_values","Optional[tf.Tensor] = None, output_attentions: Optional[bool] = None, output_hidden_states: Optional[bool] = None, return_dict: Optional[bool]","str(input_shape) + \".\" ) def _set_number_of_groups_for_instance_norm(self, input_shape): dim = input_shape[self.axis] if self.groups ==","axis if self.config.mask_feature_prob > 0: mask_feature_indices = _compute_mask_indices( (batch_size, hidden_size), mask_prob=self.config.mask_feature_prob, mask_length=self.config.mask_feature_length, )","model = TFHubertForCTC.from_pretrained(\"facebook/hubert-base-960h\") >>> def map_to_array(batch): ... speech, _ = sf.read(batch[\"file\"]) ... batch[\"speech\"]","None: super().__init__(**kwargs) if config.feat_extract_norm == \"group\": conv_layers = [TFHubertGroupNormConvLayer(config, layer_id=0, name=f\"conv_layers.{0}\")] + [","optional padding mask of the same size as shape, which will prevent masking","{allowed_types} is accepted for {k}.\") else: if isinstance(input_values, tf.Tensor) or input_values is None:","constraint=self.beta_constraint, ) else: self.beta = None def _create_broadcast_shape(self, input_shape): broadcast_shape = [1] *","License. # You may obtain a copy of the License at # #","group_shape else: return inputs, group_shape def _apply_normalization(self, reshaped_inputs, input_shape): group_shape = tf.keras.backend.int_shape(reshaped_inputs) group_reduction_axes","TF calls the method with LayerCall.__call__(args, **kwargs) # So to respect the proper","if tf.executing_eagerly(): tf.debugging.assert_equal( shape_list(attn_weights), [bsz * self.num_heads, tgt_len, src_len], message=f\"Attention weights should be","be obtained using [`BertTokenizer`]. See [`PreTrainedTokenizer.__call__`] and [`PreTrainedTokenizer.encode`] for details. [What are input","TFHubertEncoderLayer(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs): super().__init__(**kwargs) self.attention = TFHubertAttention( embed_dim=config.hidden_size, num_heads=config.num_attention_heads, dropout=config.attention_dropout,","# transform batch_indices to pair_indices pair_indices = tf.transpose(tf.concat([broad_casted_batch_dims, tf.reshape(batch_indices, [1, -1])], 0)) #","spec_aug_mask_idxs = spec_aug_mask_idxs + offsets # scatter indices to mask spec_aug_mask = _scatter_values_on_batch_indices(","`input_values` docstring) Tokens with indices set to `-100` are ignored (masked), the loss","\"\"\" self.hubert.feature_extractor.trainable = False @add_start_docstrings_to_model_forward(HUBERT_INPUTS_DOCSTRING) @replace_return_docstrings(output_type=TFCausalLMOutput, config_class=_CONFIG_FOR_DOC) def call( self, input_values: tf.Tensor, attention_mask:","serving(self, inputs): output = self.call(input_values=inputs, training=False) return self.serving_output(output) HUBERT_START_DOCSTRING = r\"\"\" This model","# compute real output lengths according to convolution formula output_lengths = self._get_feat_extract_output_lengths(tf.reduce_sum(inputs[\"attention_mask\"], -1))","ds.map(map_to_array) >>> input_values = processor(ds[\"speech\"][0], return_tensors=\"tf\").input_values # Batch size 1 >>> hidden_states =","= (key_states, value_states) proj_shape = (bsz * self.num_heads, -1, self.head_dim) query_states = tf.reshape(self._shape(query_states,","else: raise ValueError( f\"Data of type {type(input)} is not allowed only {allowed_types} is","add_start_docstrings_to_model_forward, logging, replace_return_docstrings, ) from .configuration_hubert import HubertConfig logger = logging.get_logger(__name__) _CONFIG_FOR_DOC =","= None, output_attentions: Optional[bool] = None, output_hidden_states: Optional[bool] = None, return_dict: Optional[bool] =","= self.dropout(hidden_states, training=inputs[\"training\"]) logits = self.lm_head(hidden_states) if labels is not None: if tf.reduce_max(labels)","and each example must have the shape `({0})`): Indices of input sequence tokens","= True self._normalize_kernel() padded_inputs = tf.pad(inputs, ((0, 0), (self.explicit_padding, self.explicit_padding), (0, 0))) output","# Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2PositionalConvEmbedding with Wav2Vec2->Hubert class TFHubertPositionalConvEmbedding(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs:","self.conv(hidden_states) hidden_states = self.layer_norm(hidden_states) hidden_states = self.activation(hidden_states) return hidden_states # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2GroupNormConvLayer","output_attentions=inputs[\"output_attentions\"], output_hidden_states=inputs[\"output_hidden_states\"], return_dict=inputs[\"return_dict\"], training=inputs[\"training\"], ) return outputs def serving_output(self, output): hs = tf.convert_to_tensor(output.hidden_states)","be named accordingly to the parameters name, i.e. `input_values = tf.keras.Input(shape=(128,), dtype='float32', name=\"input_values\")`","class TFHubertWeightNormConv1D(tf.keras.layers.Conv1D): \"\"\"Adapted from https://www.tensorflow.org/probability/api_docs/python/tfp/layers/weight_norm/WeightNorm\"\"\" def __init__(self, filters, kernel_size, groups, explicit_padding, **kwargs): super().__init__(","ignored (masked), the loss is only computed for the tokens with labels in","broadcast_shape.insert(self.axis, self.groups) else: broadcast_shape[self.axis] = self.groups return broadcast_shape # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2WeightNormConv1D with","tensors of all attention layers. See `attentions` under returned tensors for more detail.","**kwargs): super().__init__( filters=filters, kernel_size=kernel_size, groups=groups, padding=\"valid\", use_bias=True, bias_initializer=\"he_normal\", **kwargs, ) self.explicit_padding = explicit_padding","order of the tensors will not be guaranteed during the training. Args: func","use the .name property so we check for a real Tensor if type(input)","1]`: - 1 for tokens that are **not masked**, - 0 for tokens","ValueError( f\"`mask_length` has to be smaller than `sequence_length`, but got `mask_length`: {mask_length} and","accepted for {parameter_names[i]}.\" ) elif isinstance(input_values, (dict, BatchEncoding)): if \"inputs\" in input_values: warnings.warn(","to indicate first and second portions of the inputs. Indices are selected in","= tf.keras.layers.Dense(embed_dim, use_bias=bias, name=\"out_proj\") def _shape(self, tensor: tf.Tensor, seq_len: int, bsz: int): return","indicates the head is **not masked**, - 0 indicates the head is **masked**.","0: # generate indices & apply SpecAugment along time axis mask_time_indices = _compute_mask_indices(","to respect the proper output we have to add this exception if \"args\"","hidden_states hidden_states, attn_weights, _ = self.attention( hidden_states, attention_mask=attention_mask, training=training ) hidden_states = self.dropout(hidden_states,","+ position_embeddings hidden_states = self.dropout(hidden_states, training=training) for i, layer_module in enumerate(self.layer): if output_hidden_states:","num_heads) != self.embed_dim: raise ValueError( f\"embed_dim must be divisible by num_heads (got `embed_dim`:","Fairseq Authors and the HuggingFace Inc. team. All rights reserved. # # Licensed","add LayerDrop (see https://arxiv.org/abs/1909.11556 for description) dropout_probability = np.random.uniform(0, 1) if training and","\" \"input tensor should have a defined dimension \" \"but the layer received","of type {type(input)} is not allowed only {allowed_types} is accepted for {parameter_names[i]}.\" )","= hidden_states * tf.expand_dims(attention_mask, -1) attention_mask = _expand_mask(attention_mask) else: attention_mask = None position_embeddings","and loading pretrained models. \"\"\" config_class = HubertConfig base_model_prefix = \"hubert\" main_input_name =","from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2FeedForward with Wav2Vec2->Hubert class TFHubertFeedForward(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs): super().__init__(**kwargs) self.intermediate_dropout","in a future version, use `past_key_values` instead.\", FutureWarning, ) output[\"past_key_values\"] = input_values.pop(\"decoder_cached_states\") for","= [1] * len(input_shape) is_instance_norm = (input_shape[self.axis] // self.groups) == 1 if not","hidden_states = self.dropout(hidden_states, training=training) hidden_states = attn_residual + hidden_states hidden_states = self.layer_norm(hidden_states) hidden_states",") hidden_states = self.dropout(hidden_states, training=training) hidden_states = attn_residual + hidden_states hidden_states = self.layer_norm(hidden_states)","+ (hidden_states,) if not return_dict: return tuple(v for v in [hidden_states, all_hidden_states, all_self_attentions]","= None, head_mask: Optional[tf.Tensor] = None, inputs_embeds: Optional[tf.Tensor] = None, output_attentions: Optional[bool] =","several input Tensors IN THE ORDER given in the docstring: `model([input_values, attention_mask])` or","using [`BertTokenizer`]. See [`PreTrainedTokenizer.__call__`] and [`PreTrainedTokenizer.encode`] for details. [What are input IDs?](../glossary#input-ids) attention_mask","`freeze_feature_encoder` method instead.\", FutureWarning, ) self.freeze_feature_encoder() def freeze_feature_encoder(self): \"\"\" Calling this function will","</Tip> Args: config ([`HubertConfig`]): Model configuration class with all the parameters of the","def freeze_feature_encoder(self): \"\"\" Calling this function will disable the gradient computation for the","BatchEncoding)): if \"inputs\" in input_values: warnings.warn( \"The `inputs` argument is deprecated and will","TFHubertFeatureProjection(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs): super().__init__(**kwargs) self.layer_norm = tf.keras.layers.LayerNormalization(epsilon=config.layer_norm_eps, name=\"layer_norm\") self.projection =","(0, 2, 1, 3) ) attn_output = tf.reshape(attn_output, (bsz, tgt_len, embed_dim)) attn_output =","transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2Encoder with Wav2Vec2->Hubert class TFHubertEncoder(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs): super().__init__(**kwargs) self.config =","in graph mode the value in the config will be used instead. output_hidden_states","if self.axis == -1 else self.axis - 1 group_reduction_axes.pop(axis) mean, variance = tf.nn.moments(reshaped_inputs,","from ...tokenization_utils_base import BatchEncoding from ...utils import ( ModelOutput, add_start_docstrings, add_start_docstrings_to_model_forward, logging, replace_return_docstrings,","\"The `inputs` argument is deprecated and will be removed in a future version,","self.conv = tf.keras.layers.Conv1D( filters=self.out_conv_dim, kernel_size=config.conv_kernel[layer_id], strides=config.conv_stride[layer_id], use_bias=config.conv_bias, name=\"conv\", ) self.activation = get_tf_activation(config.feat_extract_activation) def","__init__(self, config: HubertConfig, **kwargs): super().__init__(**kwargs) self.attention = TFHubertAttention( embed_dim=config.hidden_size, num_heads=config.num_attention_heads, dropout=config.attention_dropout, is_decoder=False, name=\"attention\",","axis=2) value_states = tf.concat([past_key_value[1], value_states], axis=2) else: # self_attention key_states = self._shape(self.k_proj(hidden_states), -1,","super().__init__(**kwargs) self.embed_dim = embed_dim self.num_heads = num_heads self.dropout = tf.keras.layers.Dropout(dropout) self.head_dim = embed_dim","selected heads of the self-attention modules. Mask values selected in `[0, 1]`: -","all its model (such as downloading or saving, resizing the input embeddings, pruning","2 where first element is batch size and 2nd is timesteps attention_mask: optional","pass an embedded representation. This is useful if you want more control over","head_mask=inputs[\"head_mask\"], inputs_embeds=inputs[\"inputs_embeds\"], output_attentions=inputs[\"output_attentions\"], output_hidden_states=inputs[\"output_hidden_states\"], return_dict=inputs[\"return_dict\"], training=inputs[\"training\"], ) hidden_states = outputs[0] hidden_states = self.dropout(hidden_states,","... batch[\"speech\"] = speech ... return batch >>> ds = load_dataset(\"hf-internal-testing/librispeech_asr_dummy\", \"clean\", split=\"validation\")","the feature encoder so that its parameter will not be updated during training.","gumbel-max trick will do for now - see https://github.com/tensorflow/tensorflow/issues/9260 for more info \"\"\"","= (logits,) + outputs[1:] return ((loss,) + output) if loss is not None","corresponds to a *sentence A* token, - 1 corresponds to a *sentence B*","-1) attention_mask = _expand_mask(attention_mask) else: attention_mask = None position_embeddings = self.pos_conv_embed(hidden_states) hidden_states =","# Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2EncoderStableLayerNorm with Wav2Vec2->Hubert class TFHubertEncoderStableLayerNorm(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs):","to return the attentions tensors of all attention layers. See `attentions` under returned","always `None` past_key_value = (key_states, value_states) proj_shape = (bsz * self.num_heads, -1, self.head_dim)","group_shape = [tensor_input_shape[i] for i in range(len(input_shape))] is_instance_norm = (input_shape[self.axis] // self.groups) ==","= tf.constant(1.0) mask = tf.cast(mask, dtype=one_cst.dtype) expanded_mask = tf.tile(mask[:, None, None, :], (1,","have a defined dimension \" \"but the layer received an input with shape","epsilon: float = 1e-3, center: bool = True, scale: bool = True, beta_initializer:","from ...tf_utils import shape_list from ...tokenization_utils_base import BatchEncoding from ...utils import ( ModelOutput,","HubertConfig, *inputs, **kwargs): super().__init__(config, *inputs, **kwargs) self.hubert = TFHubertMainLayer(config, name=\"hubert\") self.dropout = tf.keras.layers.Dropout(config.final_dropout)","smaller than `sequence_length`, but got `mask_length`: {mask_length} and `sequence_length`: {sequence_length}`\" ) # compute","= sequence_length // mask_length # SpecAugment mask to fill spec_aug_mask = tf.zeros((batch_size, sequence_length),","name=\"weight_v\", trainable=True) self.weight_v = self.kernel self.weight_g = self.add_weight( name=\"weight_g\", shape=(int(self.weight_v.shape[self.filter_axis]), 1, 1), initializer=\"ones\",","use this file except in compliance with the License. # You may obtain","accordingly to the parameters name, i.e. `input_values = tf.keras.Input(shape=(128,), dtype='float32', name=\"input_values\")` otherwise the","] def call( self, hidden_states: tf.Tensor, attention_mask: Optional[tf.Tensor] = None, output_attentions: Optional[bool] =","dtype='float32', name=\"input_values\")` otherwise the order of the tensors will not be guaranteed during","**kwargs): super().__init__(**kwargs) self.layer_norm = tf.keras.layers.LayerNormalization(epsilon=config.layer_norm_eps, name=\"layer_norm\") self.projection = tf.keras.layers.Dense( units=config.hidden_size, kernel_initializer=get_initializer(config.initializer_range), bias_initializer=\"zeros\", name=\"projection\",","= self.add_weight( name=\"weight_g\", shape=(int(self.weight_v.shape[self.filter_axis]), 1, 1), initializer=\"ones\", dtype=self.weight_v.dtype, trainable=True, ) self.bias = self.add_weight(name=\"bias\",","i, layer_module in enumerate(self.layer): if output_hidden_states: all_hidden_states = all_hidden_states + (hidden_states,) # add","not be guaranteed during the training. Args: func (`callable`): The callable function of","group_reduction_axes = list(range(1, len(group_shape))) is_instance_norm = (input_shape[self.axis] // self.groups) == 1 if not","def _sample_without_replacement(distribution, num_samples): \"\"\" Categorical sampling without replacement is currently not implemented. The","dtype=tf.float32) ) input_lengths = self.hubert._get_feat_extract_output_lengths(tf.reduce_sum(attention_mask, axis=-1)) # assuming that padded tokens are filled","the actual number will be smaller (unless no_overlap is True) mask_length: size of","output[\"args\"] is not None and type(output[\"args\"]) == tf.Tensor: tensor_name = output[\"args\"].name.split(\":\")[0] output[tensor_name] =","r\"\"\" labels (`tf.Tensor` or `np.ndarray` of shape `(batch_size, sequence_length)`, *optional*): Labels for computing","\"inputs\" in input_values: warnings.warn( \"The `inputs` argument is deprecated and will be removed","= self.kernel self.weight_g = self.add_weight( name=\"weight_g\", shape=(int(self.weight_v.shape[self.filter_axis]), 1, 1), initializer=\"ones\", dtype=self.weight_v.dtype, trainable=True, )","have always the pattern `name:id` then we check only the # `name` part","in batch num_masked_spans = int(mask_prob * sequence_length / mask_length + tf.random.uniform((1,))) num_masked_spans =","-> Dict[str, tf.Tensor]: pad_token = 0.0 input_values = tf.convert_to_tensor(np.random.rand(1, 16000), tf.float32) dummy_inputs =","PyTorch with indices in format (batch_dim, indixes) \"\"\" indices_shape = shape_list(batch_indices) # broadcast","then reuse all cross-attention # key/value_states (first \"if\" case) # if uni-directional self-attention","# Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2Encoder with Wav2Vec2->Hubert class TFHubertEncoder(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs):","a plain tuple. This argument can be used in eager mode, in graph","1, tgt_len, src_len)}, but is {shape_list(attention_mask)}\", ) attention_mask = tf.cast(attention_mask, dtype=attn_weights.dtype) attn_weights =","tf.Tensor: tensor_name = output[\"args\"].name.split(\":\")[0] output[tensor_name] = output[\"args\"] else: # `args` in this case","allowed_types) or v is None: output[k] = v else: raise ValueError(f\"Data of type","(input_length - kernel_size) // stride + 1 for kernel_size, stride in zip(self.config.conv_kernel, self.config.conv_stride):","self.groups) == 1 if not is_instance_norm: outputs = tf.reshape(normalized_inputs, tensor_input_shape) else: outputs =","str(self.groups) + \") must be a \" \"multiple of the number of channels","= TFHubertFeatureEncoder(config, name=\"feature_extractor\") self.feature_projection = TFHubertFeatureProjection(config, name=\"feature_projection\") if config.do_stable_layer_norm: self.encoder = TFHubertEncoderStableLayerNorm(config, name=\"encoder\")","spec_aug_mask # Copied from transformers.models.bart.modeling_tf_bart._expand_mask def _expand_mask(mask: tf.Tensor, tgt_len: Optional[int] = None, past_key_values_length:","\"multiple of the number of channels (\" + str(dim) + \").\" ) def","in PyTorch with indices in format (batch_dim, indixes) \"\"\" indices_shape = shape_list(batch_indices) #","class TFHubertNoLayerNormConvLayer(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, layer_id: int = 0, **kwargs: Any) ->","`freeze_feature_extractor` is deprecated and will be removed in Transformers v5.\" \"Please use the","# Add last layer if output_hidden_states: all_hidden_states = all_hidden_states + (hidden_states,) if not","+ hidden_states hidden_states = hidden_states + self.feed_forward(self.final_layer_norm(hidden_states)) outputs = (hidden_states,) if output_attentions: outputs","is not None: # apply SpecAugment along time axis with given mask_time_indices hidden_states","removed in a future version, use `past_key_values` instead.\", FutureWarning, ) output[\"past_key_values\"] = input_values.pop(\"decoder_cached_states\")","so we need to account for padding input_shape[-2] += self.explicit_padding * 2 super().build(input_shape)","Indices of positions of each input sequence tokens in the position embeddings. Selected","# distributed under the License is distributed on an \"AS IS\" BASIS, #","= tf.transpose( tf.reshape(attn_output, (bsz, self.num_heads, tgt_len, self.head_dim)), (0, 2, 1, 3) ) attn_output","None, training: bool = False, **kwargs: Any, ): inputs = input_values_processing( func=self.call, config=self.config,","filters=filters, kernel_size=kernel_size, groups=groups, padding=\"valid\", use_bias=True, bias_initializer=\"he_normal\", **kwargs, ) self.explicit_padding = explicit_padding self.filter_axis =","the convolutional layers \"\"\" def _conv_out_length(input_length, kernel_size, stride): # 1D convolutional layer output","broadcast_shape = [1] * len(input_shape) is_instance_norm = (input_shape[self.axis] // self.groups) == 1 if","span to mask approximately this percentage of all elements. however due to overlaps,","inputs): if not self.initialized: self._init_norm() self.initialized = True self._normalize_kernel() padded_inputs = tf.pad(inputs, ((0,","tf.transpose(tf.reshape(tensor, (bsz, seq_len, self.num_heads, self.head_dim)), (0, 2, 1, 3)) def call( self, hidden_states:","in the vocabulary. Indices can be obtained using [`BertTokenizer`]. See [`PreTrainedTokenizer.__call__`] and [`PreTrainedTokenizer.encode`]","= input else: raise ValueError( f\"Data of type {type(input)} is not allowed only","`model(inputs)`. If you choose this second option, there are three possibilities you can","if tf.executing_eagerly(): tf.debugging.assert_equal( shape_list(attn_output), [bsz * self.num_heads, tgt_len, self.head_dim], message=f\"`attn_output` should be of","self.k_proj = tf.keras.layers.Dense(embed_dim, use_bias=bias, name=\"k_proj\") self.q_proj = tf.keras.layers.Dense(embed_dim, use_bias=bias, name=\"q_proj\") self.v_proj = tf.keras.layers.Dense(embed_dim,","bool = True, beta_initializer: tf.keras.initializers.Initializer = \"zeros\", gamma_initializer: tf.keras.initializers.Initializer = \"ones\", beta_regularizer: tf.keras.regularizers.Regularizer","= layer_outputs[0] if output_attentions: all_self_attentions = all_self_attentions + (layer_outputs[1],) hidden_states = self.layer_norm(hidden_states) if","tgt_len, src_len)) attn_probs = self.dropout(attn_weights, training=training) attn_output = tf.matmul(attn_probs, value_states) # The tf.debugging","input_values=input_values, attention_mask=attention_mask, token_type_ids=token_type_ids, position_ids=position_ids, head_mask=head_mask, inputs_embeds=inputs_embeds, output_attentions=output_attentions, output_hidden_states=output_hidden_states, return_dict=return_dict, training=training, ) inputs[\"output_hidden_states\"] =","return hidden_states # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2EncoderLayer with Wav2Vec2->Hubert class TFHubertEncoderLayer(tf.keras.layers.Layer): def __init__(self, config:","head_mask: Optional[tf.Tensor] = None, inputs_embeds: Optional[tf.Tensor] = None, output_attentions: Optional[tf.Tensor] = None, output_hidden_states:","= self._shape(self.k_proj(hidden_states), -1, bsz) value_states = self._shape(self.v_proj(hidden_states), -1, bsz) key_states = tf.concat([past_key_value[0], key_states],","False, bias: bool = True, **kwargs, ): super().__init__(**kwargs) self.embed_dim = embed_dim self.num_heads =","tgt_len, src_len)) return attn_output, attn_weights, past_key_value # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2FeedForward with Wav2Vec2->Hubert class",") return normalized_inputs def _get_reshaped_weights(self, input_shape): broadcast_shape = self._create_broadcast_shape(input_shape) gamma = None beta","wish \" \"to train/fine-tine this model, you need a GPU or a TPU\"","func (`callable`): The callable function of the TensorFlow model. config ([`PretrainedConfig`]): The config","tf.expand_dims(spec_aug_mask_idxs, -1) spec_aug_mask_idxs = tf.tile(spec_aug_mask_idxs, (1, 1, mask_length)) spec_aug_mask_idxs = tf.reshape(spec_aug_mask_idxs, (batch_size, num_masked_spans","the equivalent `freeze_feature_encoder` method instead.\", FutureWarning, ) self.freeze_feature_encoder() def freeze_feature_encoder(self): \"\"\" Calling this","all Hubert models at https://huggingface.co/models?filter=hubert ] LARGE_NEGATIVE = -1e8 # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.input_values_processing","3)) def call( self, hidden_states: tf.Tensor, key_value_states: Optional[tf.Tensor] = None, past_key_value: Optional[Tuple[Tuple[tf.Tensor]]] =","EagerTensors don't allow to use the .name property so we check for a","to pair_indices pair_indices = tf.transpose(tf.concat([broad_casted_batch_dims, tf.reshape(batch_indices, [1, -1])], 0)) # scatter values to","2nd is timesteps attention_mask: optional padding mask of the same size as shape,","- having all inputs as keyword arguments (like PyTorch models), or - having","num_samples): \"\"\" Categorical sampling without replacement is currently not implemented. The gumbel-max trick","are < sequence_length uniform_dist = tf.ones((batch_size, sequence_length - (mask_length - 1))) # get","scatter values to pair indices return tf.scatter_nd(pair_indices, tf.reshape(values, [-1]), output_shape) # Copied from","`-100` are ignored (masked), the loss is only computed for the tokens with","BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.","`sequence_length`: {sequence_length}`\" ) # compute number of masked spans in batch num_masked_spans =","graph mode the value in the config will be used instead. output_hidden_states (`bool`,","= self.add_weight( shape=shape, name=\"beta\", initializer=self.beta_initializer, regularizer=self.beta_regularizer, constraint=self.beta_constraint, ) else: self.beta = None def","Do you want to \" \"use tf.layer.batch_normalization instead\" ) def _create_input_spec(self, input_shape): dim","a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required","False self.kernel_norm_axes = tf.constant([0, 1]) def _init_norm(self): \"\"\"Set the norm of the weight","def _check_size_of_dimensions(self, input_shape): dim = input_shape[self.axis] if dim < self.groups: raise ValueError( \"Number","tf.nn.batch_normalization( reshaped_inputs, mean=mean, variance=variance, scale=gamma, offset=beta, variance_epsilon=self.epsilon, ) return normalized_inputs def _get_reshaped_weights(self, input_shape):","Union[TFCausalLMOutput, Tuple[tf.Tensor]]: r\"\"\" labels (`tf.Tensor` or `np.ndarray` of shape `(batch_size, sequence_length)`, *optional*): Labels","provided this layer is used as a cross-attention layer # for the decoder","hidden_states = tf.where( tf.cast(mask_time_indices[:, :, tf.newaxis], tf.bool), self.masked_spec_embed[tf.newaxis, tf.newaxis, :], hidden_states, ) #","Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2PositionalConvEmbedding with Wav2Vec2->Hubert class TFHubertPositionalConvEmbedding(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs: Any)","= tf.keras.layers.LayerNormalization( epsilon=config.layer_norm_eps, name=\"final_layer_norm\" ) def call( self, hidden_states: tf.Tensor, attention_mask: Optional[tf.Tensor] =","Expands attention_mask from `[bsz, seq_len]` to `[bsz, 1, tgt_seq_len, src_seq_len]`. \"\"\" src_len =","super().__init__(**kwargs) if config.feat_extract_norm == \"group\": conv_layers = [TFHubertGroupNormConvLayer(config, layer_id=0, name=f\"conv_layers.{0}\")] + [ TFHubertNoLayerNormConvLayer(config,","is not None) return TFBaseModelOutput( last_hidden_state=hidden_states, hidden_states=all_hidden_states, attentions=all_self_attentions, ) # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2EncoderStableLayerNorm","shape, which will prevent masking padded elements mask_prob: probability for each token to","in parameter_names: output[tensor_name] = input else: output[parameter_names[i]] = input elif isinstance(input, allowed_types) or","detail. This argument can be used only in eager mode, in graph mode","input_values=inputs[\"input_values\"], attention_mask=inputs[\"attention_mask\"], token_type_ids=inputs[\"token_type_ids\"], position_ids=inputs[\"position_ids\"], head_mask=inputs[\"head_mask\"], inputs_embeds=inputs[\"inputs_embeds\"], output_attentions=inputs[\"output_attentions\"], output_hidden_states=inputs[\"output_hidden_states\"], return_dict=inputs[\"return_dict\"], training=inputs[\"training\"], ) hidden_states =","None, gamma_regularizer: tf.keras.regularizers.Regularizer = None, beta_constraint: tf.keras.constraints.Constraint = None, gamma_constraint: tf.keras.constraints.Constraint = None,","accepted for {k}.\") if isinstance(input_values, (tuple, list)): for i, input in enumerate(input_values): #","token_type_ids: Optional[tf.Tensor] = None, position_ids: Optional[tf.Tensor] = None, head_mask: Optional[tf.Tensor] = None, inputs_embeds:","hidden_states = self.intermediate_act_fn(hidden_states) hidden_states = self.intermediate_dropout(hidden_states, training=training) hidden_states = self.output_dense(hidden_states) hidden_states = self.output_dropout(hidden_states,","Optional[bool] = None, output_hidden_states: Optional[bool] = None, return_dict: Optional[bool] = None, training: bool","must be <= vocab_size: {self.config.vocab_size}\") attention_mask = ( inputs[\"attention_mask\"] if inputs[\"attention_mask\"] is not","= tf.keras.layers.Dense(embed_dim, use_bias=bias, name=\"q_proj\") self.v_proj = tf.keras.layers.Dense(embed_dim, use_bias=bias, name=\"v_proj\") self.out_proj = tf.keras.layers.Dense(embed_dim, use_bias=bias,","TFHubertWeightNormConv1D(tf.keras.layers.Conv1D): \"\"\"Adapted from https://www.tensorflow.org/probability/api_docs/python/tfp/layers/weight_norm/WeightNorm\"\"\" def __init__(self, filters, kernel_size, groups, explicit_padding, **kwargs): super().__init__( filters=filters,","= dict(inspect.signature(func).parameters) signature.pop(\"kwargs\", None) signature.pop(\"self\", None) parameter_names = list(signature.keys()) output = {} allowed_types","config will be used instead. output_hidden_states (`bool`, *optional*): Whether or not to return","config: HubertConfig, **kwargs): super().__init__(**kwargs) self.layer_norm = tf.keras.layers.LayerNormalization(epsilon=config.layer_norm_eps, name=\"layer_norm\") self.projection = tf.keras.layers.Dense( units=config.hidden_size, kernel_initializer=get_initializer(config.initializer_range),","wrap processor as target processor to encode labels >>> with processor.as_target_processor(): ... labels","processor.decode(predicted_ids[0]) >>> # compute loss >>> target_transcription = \"A MAN SAID TO THE","* num_heads) != self.embed_dim: raise ValueError( f\"embed_dim must be divisible by num_heads (got","deprecated and will be removed in Transformers v5.\" \"Please use the equivalent `freeze_feature_encoder`","only the # `name` part tensor_name = input.name.split(\":\")[0] if tensor_name in parameter_names: output[tensor_name]","TFHubertGroupNormConvLayer(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, layer_id: int = 0, **kwargs: Any) -> None:","# get key, value proj if is_cross_attention and past_key_value is not None: #","False) -> tf.Tensor: hidden_states = self.layer_norm(hidden_states) hidden_states = self.projection(hidden_states) hidden_states = self.dropout(hidden_states, training=training)","tf.Tensor, tgt_len: Optional[int] = None, past_key_values_length: int = 0): \"\"\" Expands attention_mask from","have different behaviors between training and evaluation). \"\"\" @add_start_docstrings( \"The bare TFHubert Model","the first positional argument : - a single Tensor with `input_values` only and","hidden_states: tf.Tensor) -> tf.Tensor: hidden_states = self.conv(hidden_states) hidden_states = self.padding(hidden_states) hidden_states = self.activation(hidden_states)","tf.keras.regularizers.get(beta_regularizer) self.gamma_regularizer = tf.keras.regularizers.get(gamma_regularizer) self.beta_constraint = tf.keras.constraints.get(beta_constraint) self.gamma_constraint = tf.keras.constraints.get(gamma_constraint) self._check_axis() def build(self,","tf.transpose(kernel) def build(self, input_shape): if not self.built: input_shape = input_shape.as_list() # Conv1D output","tensorflow as tf >>> from transformers import Wav2Vec2Processor, TFHubertForCTC >>> from datasets import","if output_hidden_states else None all_self_attentions = () if output_attentions else None if attention_mask","token_type_ids=token_type_ids, position_ids=position_ids, head_mask=head_mask, inputs_embeds=inputs_embeds, output_attentions=output_attentions, output_hidden_states=output_hidden_states, return_dict=return_dict, training=training, ) outputs = self.hubert( input_values=inputs[\"input_values\"],","-1 else self.axis - 1 else: axis = -1 if self.axis == -1","with one or several input Tensors associated to the input names given in","num_masked_spans = int(mask_prob * sequence_length / mask_length + tf.random.uniform((1,))) num_masked_spans = max(num_masked_spans, min_masks)","attn_probs = self.dropout(attn_weights, training=training) attn_output = tf.matmul(attn_probs, value_states) # The tf.debugging asserts are","self.weight_g.assign(kernel_norm[:, tf.newaxis, tf.newaxis]) def _normalize_kernel(self): \"\"\"Generate normalized weights.\"\"\" kernel = tf.nn.l2_normalize(self.weight_v, axis=self.kernel_norm_axes) *","= tf.keras.constraints.get(beta_constraint) self.gamma_constraint = tf.keras.constraints.get(gamma_constraint) self._check_axis() def build(self, input_shape): self._check_if_input_shape_is_none(input_shape) self._set_number_of_groups_for_instance_norm(input_shape) self._check_size_of_dimensions(input_shape) self._create_input_spec(input_shape)","attended to labels_mask = tf.cast(labels >= 0, tf.int32) target_lengths = tf.reduce_sum(labels_mask, axis=-1) loss","with given mask_time_indices hidden_states = tf.where( tf.cast(mask_time_indices[:, :, tf.newaxis], tf.bool), self.masked_spec_embed[tf.newaxis, tf.newaxis, :],","`tf.Tensor` of shape `({0})`, *optional*): Indices of positions of each input sequence tokens","all_self_attentions = all_self_attentions + (layer_outputs[1],) hidden_states = self.layer_norm(hidden_states) if output_hidden_states: all_hidden_states = all_hidden_states","self.groups group_shape.insert(self.axis, self.groups) group_shape = tf.stack(group_shape) reshaped_inputs = tf.reshape(inputs, group_shape) return reshaped_inputs, group_shape","of size {(self.num_heads)}, but is {shape_list(layer_head_mask)}\", ) attn_weights = tf.reshape(layer_head_mask, (1, -1, 1,","def _create_input_spec(self, input_shape): dim = input_shape[self.axis] self.input_spec = tf.keras.layers.InputSpec(ndim=len(input_shape), axes={self.axis: dim}) def _add_gamma_weight(self,","= tf.keras.layers.LayerNormalization(epsilon=config.layer_norm_eps, name=\"layer_norm\") self.dropout = tf.keras.layers.Dropout(config.hidden_dropout) self.layer = [TFHubertEncoderLayer(config, name=f\"layers.{i}\") for i in","= tf.reshape(key_states, proj_shape) value_states = tf.reshape(value_states, proj_shape) src_len = shape_list(key_states)[1] attn_weights = tf.matmul(query_states,","An abstract class to handle weights initialization and a simple interface for downloading","name=f\"layers.{i}\") for i in range(config.num_hidden_layers)] def call( self, hidden_states: tf.Tensor, attention_mask: Optional[tf.Tensor] =","shape: the the shape for which to compute masks. should be of size","name=\"feature_extractor\") self.feature_projection = TFHubertFeatureProjection(config, name=\"feature_projection\") if config.do_stable_layer_norm: self.encoder = TFHubertEncoderStableLayerNorm(config, name=\"encoder\") else: self.encoder","mask_time_indices = _compute_mask_indices( (batch_size, sequence_length), mask_prob=self.config.mask_time_prob, mask_length=self.config.mask_time_length, min_masks=2, ) hidden_states = tf.where( tf.cast(mask_time_indices[:,","# Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2._compute_mask_indices def _compute_mask_indices( shape: Tuple[int, int], mask_prob: float, mask_length: int,","if loss is not None else output return TFCausalLMOutput( loss=loss, logits=logits, hidden_states=outputs.hidden_states, attentions=outputs.attentions,","and will be removed in a future version, use `past_key_values` instead.\", FutureWarning, )","the weight vector.\"\"\" kernel_norm = tf.sqrt(tf.reduce_sum(tf.square(self.weight_v), axis=self.kernel_norm_axes)) self.weight_g.assign(kernel_norm[:, tf.newaxis, tf.newaxis]) def _normalize_kernel(self): \"\"\"Generate","when using [`tf.keras.Model.fit`] method which currently requires having all the tensors in the","{type(v)} is not allowed only {allowed_types} is accepted for {k}.\") else: if isinstance(input_values,","tensor: tf.Tensor, seq_len: int, bsz: int): return tf.transpose(tf.reshape(tensor, (bsz, seq_len, self.num_heads, self.head_dim)), (0,","else: axis = -1 if self.axis == -1 else self.axis - 1 group_reduction_axes.pop(axis)","details. [What are input IDs?](../glossary#input-ids) attention_mask (`np.ndarray` or `tf.Tensor` of shape `({0})`, *optional*):","def input_values_processing(func, config, input_values, **kwargs): \"\"\" Process the input of each TensorFlow model","inherits from [`TFPreTrainedModel`]. Check the superclass documentation for the generic methods the library","# wrap processor as target processor to encode labels >>> with processor.as_target_processor(): ...","Optional[bool] = False, ) -> Union[TFBaseModelOutput, Tuple[tf.Tensor]]: all_hidden_states = () if output_hidden_states else","offsets = tf.tile(offsets, (batch_size, num_masked_spans, 1)) offsets = tf.reshape(offsets, (batch_size, num_masked_spans * mask_length))","serving_output(self, output): hs = tf.convert_to_tensor(output.hidden_states) if self.config.output_hidden_states else None attns = tf.convert_to_tensor(output.attentions) if","1 corresponds to a *sentence B* token. [What are token type IDs?](../glossary#token-type-ids) position_ids","not implemented. The gumbel-max trick will do for now - see https://github.com/tensorflow/tensorflow/issues/9260 for","return batch >>> ds = load_dataset(\"hf-internal-testing/librispeech_asr_dummy\", \"clean\", split=\"validation\") >>> ds = ds.map(map_to_array) >>>","variance = tf.nn.moments(reshaped_inputs, group_reduction_axes, keepdims=True) gamma, beta = self._get_reshaped_weights(input_shape) normalized_inputs = tf.nn.batch_normalization( reshaped_inputs,",") self.activation = get_tf_activation(config.feat_extract_activation) self.layer_norm = TFHubertGroupNorm(groups=self.out_conv_dim, epsilon=config.layer_norm_eps, name=\"layer_norm\") def call(self, hidden_states: tf.Tensor)","like dropout modules have different behaviors between training and evaluation). \"\"\" @add_start_docstrings( \"The","all_hidden_states + (hidden_states,) # add LayerDrop (see https://arxiv.org/abs/1909.11556 for description) dropout_probability = np.random.uniform(0,","_conv_out_length(input_length, kernel_size, stride): # 1D convolutional layer output length formula taken # from","training: bool = False, **kwargs: Any, ): inputs = input_values_processing( func=self.call, config=self.config, input_values=input_values,","self.layer_norm = tf.keras.layers.LayerNormalization(epsilon=config.layer_norm_eps, name=\"layer_norm\") self.dropout = tf.keras.layers.Dropout(config.hidden_dropout) self.layer = [TFHubertEncoderLayer(config, name=f\"layers.{i}\") for i","typing import Any, Dict, Optional, Tuple, Union import numpy as np import tensorflow","got `mask_length`: {mask_length} and `sequence_length`: {sequence_length}`\" ) # compute number of masked spans","config: HubertConfig, **kwargs: Any) -> None: super().__init__(**kwargs) self.conv = TFHubertWeightNormConv1D( filters=config.hidden_size, kernel_size=config.num_conv_pos_embeddings, groups=config.num_conv_pos_embedding_groups,","axis=self.kernel_norm_axes)) self.weight_g.assign(kernel_norm[:, tf.newaxis, tf.newaxis]) def _normalize_kernel(self): \"\"\"Generate normalized weights.\"\"\" kernel = tf.nn.l2_normalize(self.weight_v, axis=self.kernel_norm_axes)","performing attention on padding token indices. Mask values selected in `[0, 1]`: -","config ([`PretrainedConfig`]): The config of the running model. **kwargs: The inputs of the","# reuse k,v, cross_attentions key_states = past_key_value[0] value_states = past_key_value[1] elif is_cross_attention: #","input names given in the docstring: `model({\"input_values\": input_values, \"token_type_ids\": token_type_ids})` </Tip> Args: config","mask_length: int, min_masks: int = 0, ) -> tf.Tensor: \"\"\" Computes random mask","# scatter indices to mask spec_aug_mask = _scatter_values_on_batch_indices( tf.ones_like(spec_aug_mask_idxs), spec_aug_mask_idxs, spec_aug_mask.shape ) return","tf.keras.layers.LayerNormalization(epsilon=config.layer_norm_eps, name=\"layer_norm\") self.feed_forward = TFHubertFeedForward(config, name=\"feed_forward\") self.final_layer_norm = tf.keras.layers.LayerNormalization( epsilon=config.layer_norm_eps, name=\"final_layer_norm\" ) def","for {k}.\") else: if isinstance(input_values, tf.Tensor) or input_values is None: output[parameter_names[0]] = input_values","min_masks=2, ) hidden_states = tf.where( tf.cast(mask_time_indices[:, :, tf.newaxis], tf.bool), self.masked_spec_embed[tf.newaxis, tf.newaxis, :], hidden_states,","tf.cast(attention_mask, dtype=attn_weights.dtype) attn_weights = tf.reshape(attn_weights, (bsz, self.num_heads, tgt_len, src_len)) + attention_mask attn_weights =","# # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to","key_states = self._shape(self.k_proj(key_value_states), -1, bsz) value_states = self._shape(self.v_proj(key_value_states), -1, bsz) elif past_key_value is","\" f\"Use `{self.__class__.__bases__[0].__name__}` instead.\", FutureWarning, ) class TFHubertFeatureProjection(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs):","the parameter list {parameter_names} and will be ignored.\" ) continue else: raise ValueError(f\"Data","mask_length < 1: raise ValueError(\"`mask_length` has to be bigger than 0.\") if mask_length","`sequence_length`, but got `mask_length`: {mask_length} and `sequence_length`: {sequence_length}`\" ) # compute number of","None) parameter_names = list(signature.keys()) output = {} allowed_types = (tf.Tensor, bool, int, ModelOutput,","attn_output = tf.reshape(attn_output, (bsz, tgt_len, embed_dim)) attn_output = self.out_proj(attn_output) attn_weights: tf.Tensor = tf.reshape(attn_weights,","assuming that padded tokens are filled with -100 # when not being attended","= tf.keras.regularizers.get(gamma_regularizer) self.beta_constraint = tf.keras.constraints.get(beta_constraint) self.gamma_constraint = tf.keras.constraints.get(gamma_constraint) self._check_axis() def build(self, input_shape): self._check_if_input_shape_is_none(input_shape)","self.attention( hidden_states, attention_mask=attention_mask, training=training ) hidden_states = self.dropout(hidden_states, training=training) hidden_states = attn_residual +",">>> from datasets import load_dataset >>> import soundfile as sf >>> processor =","# apply SpecAugment along time axis with given mask_time_indices hidden_states = tf.where( tf.cast(mask_time_indices[:,","EXIST\" >>> # wrap processor as target processor to encode labels >>> with","token_type_ids})` </Tip> Args: config ([`HubertConfig`]): Model configuration class with all the parameters of",">>> # wrap processor as target processor to encode labels >>> with processor.as_target_processor():","the hidden states of all layers. See `hidden_states` under returned tensors for more",") elif isinstance(input_values, (dict, BatchEncoding)): if \"inputs\" in input_values: warnings.warn( \"The `inputs` argument","mask_time_indices = kwargs.get(\"mask_time_indices\", None) if inputs[\"training\"]: hidden_states = self._mask_hidden_states(hidden_states, mask_time_indices=mask_time_indices) encoder_outputs = self.encoder(","Optional[bool] = False, training: bool = False, ) -> Tuple[tf.Tensor]: attn_residual = hidden_states","for i, input in enumerate(input_values): # EagerTensors don't allow to use the .name","`args` in this case is always the first parameter, then `input_values` output[\"input_values\"] =","`input_values` instead.\", FutureWarning, ) output[\"input_values\"] = input_values.pop(\"inputs\") if \"decoder_cached_states\" in input_values: warnings.warn( \"The","masked**, - 0 indicates the head is **masked**. inputs_embeds (`np.ndarray` or `tf.Tensor` of","batch size and 2nd is timesteps attention_mask: optional padding mask of the same","= tf.reshape(spec_aug_mask_idxs, (batch_size, num_masked_spans * mask_length)) offsets = tf.range(mask_length)[tf.newaxis, tf.newaxis, :] offsets =","= tf.transpose(kernel) def build(self, input_shape): if not self.built: input_shape = input_shape.as_list() # Conv1D","the docstring: `model({\"input_values\": input_values, \"token_type_ids\": token_type_ids})` </Tip> Args: config ([`HubertConfig`]): Model configuration class","+ self.feed_forward(self.final_layer_norm(hidden_states)) outputs = (hidden_states,) if output_attentions: outputs += (attn_weights,) return outputs #","decoder key/value_states. Further calls to uni-directional self-attention # can concat previous decoder key/value_states","MAN SAID TO THE UNIVERSE SIR I EXIST\" >>> # wrap processor as","this model, you need a GPU or a TPU\" ) @tf.function def serving(self,","def __init__( self, embed_dim: int, num_heads: int, dropout: float = 0.0, is_decoder: bool","== -1: self.groups = dim def _check_size_of_dimensions(self, input_shape): dim = input_shape[self.axis] if dim","You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 #","{type(v)} is not allowed only {allowed_types} is accepted for {k}.\") if isinstance(input_values, (tuple,","Wav2Vec2->Hubert class TFHubertLayerNormConvLayer(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, layer_id: int = 0, **kwargs: Any)","spec_aug_mask_idxs + offsets # scatter indices to mask spec_aug_mask = _scatter_values_on_batch_indices( tf.ones_like(spec_aug_mask_idxs), spec_aug_mask_idxs,","self.axis == 0: raise ValueError( \"You are trying to normalize your batch axis.","used instead. output_hidden_states (`bool`, *optional*): Whether or not to return the hidden states","= None, output_hidden_states: Optional[bool] = None, return_dict: Optional[bool] = None, training: bool =","group_shape) return reshaped_inputs, group_shape else: return inputs, group_shape def _apply_normalization(self, reshaped_inputs, input_shape): group_shape","\"\"\" signature = dict(inspect.signature(func).parameters) signature.pop(\"kwargs\", None) signature.pop(\"self\", None) parameter_names = list(signature.keys()) output =","not None else output return TFCausalLMOutput( loss=loss, logits=logits, hidden_states=outputs.hidden_states, attentions=outputs.attentions, ) def serving_output(self,","masked spans spec_aug_mask_idxs = tf.expand_dims(spec_aug_mask_idxs, -1) spec_aug_mask_idxs = tf.tile(spec_aug_mask_idxs, (1, 1, mask_length)) spec_aug_mask_idxs","can then reuse all cross-attention # key/value_states (first \"if\" case) # if uni-directional","tf.reshape(self.gamma, broadcast_shape) if self.center: beta = tf.reshape(self.beta, broadcast_shape) return gamma, beta def _check_if_input_shape_is_none(self,","self.num_pad_remove > 0: hidden_states = hidden_states[:, : -self.num_pad_remove, :] return hidden_states class TFHubertFeatureEncoder(tf.keras.layers.Layer):","_mask_hidden_states(self, hidden_states: tf.Tensor, mask_time_indices: Optional[tf.Tensor] = None): \"\"\" Masks extracted features along time",") def call( self, hidden_states: tf.Tensor, attention_mask: Optional[tf.Tensor] = None, output_attentions: Optional[bool] =","more detail. This argument can be used only in eager mode, in graph","None: # apply SpecAugment along time axis with given mask_time_indices hidden_states = tf.where(","tf.reshape(value_states, proj_shape) src_len = shape_list(key_states)[1] attn_weights = tf.matmul(query_states, key_states, transpose_b=True) # The tf.debugging","tf.keras.layers.Dropout(rate=config.feat_proj_dropout) def call(self, hidden_states: tf.Tensor, training: bool = False) -> tf.Tensor: hidden_states =","to uni-directional self-attention # can concat previous decoder key/value_states to current projected key/value_states","training. \"\"\" self.hubert.feature_extractor.trainable = False @add_start_docstrings_to_model_forward(HUBERT_INPUTS_DOCSTRING) @replace_return_docstrings(output_type=TFCausalLMOutput, config_class=_CONFIG_FOR_DOC) def call( self, input_values: tf.Tensor,","mask should be of size {(bsz, 1, tgt_len, src_len)}, but is {shape_list(attention_mask)}\", )","output_attentions: outputs += (attn_weights,) return outputs # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2EncoderLayerStableLayerNorm with Wav2Vec2->Hubert class","\"to train/fine-tine this model, you need a GPU or a TPU\" ) @tf.function","output_lengths = self._get_feat_extract_output_lengths(tf.reduce_sum(inputs[\"attention_mask\"], -1)) attention_mask = tf.sequence_mask( output_lengths, maxlen=shape_list(hidden_states)[1], dtype=hidden_states.dtype ) hidden_states =","self.pos_conv_embed(hidden_states) hidden_states = hidden_states + position_embeddings hidden_states = self.dropout(hidden_states, training=training) for i, layer_module","output) if loss is not None else output return TFCausalLMOutput( loss=loss, logits=logits, hidden_states=outputs.hidden_states,","\"beta_initializer\": tf.keras.initializers.serialize(self.beta_initializer), \"gamma_initializer\": tf.keras.initializers.serialize(self.gamma_initializer), \"beta_regularizer\": tf.keras.regularizers.serialize(self.beta_regularizer), \"gamma_regularizer\": tf.keras.regularizers.serialize(self.gamma_regularizer), \"beta_constraint\": tf.keras.constraints.serialize(self.beta_constraint), \"gamma_constraint\": tf.keras.constraints.serialize(self.gamma_constraint), }","blank_index=self.config.pad_token_id, logits_time_major=False, ) if self.config.ctc_loss_reduction == \"sum\": loss = tf.reduce_sum(loss) if self.config.ctc_loss_reduction ==","the layer received an input with shape \" + str(input_shape) + \".\" )","TFHubertSamePadLayer(tf.keras.layers.Layer): def __init__(self, num_conv_pos_embeddings, **kwargs): super().__init__(**kwargs) self.num_pad_remove = 1 if num_conv_pos_embeddings % 2","tf.nn.top_k(distribution + z, num_samples) return indices # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2._scatter_values_on_batch_indices def _scatter_values_on_batch_indices(values, batch_indices,","# you may not use this file except in compliance with the License.","first element is batch size and 2nd is timesteps attention_mask: optional padding mask","None else src_len one_cst = tf.constant(1.0) mask = tf.cast(mask, dtype=one_cst.dtype) expanded_mask = tf.tile(mask[:,","call( self, hidden_states: tf.Tensor, key_value_states: Optional[tf.Tensor] = None, past_key_value: Optional[Tuple[Tuple[tf.Tensor]]] = None, attention_mask:","= config self.feature_extractor = TFHubertFeatureEncoder(config, name=\"feature_extractor\") self.feature_projection = TFHubertFeatureProjection(config, name=\"feature_projection\") if config.do_stable_layer_norm: self.encoder","positional argument : - a single Tensor with `input_values` only and nothing else:","= _sample_without_replacement(uniform_dist, num_masked_spans) # expand masked indices to masked spans spec_aug_mask_idxs = tf.expand_dims(spec_aug_mask_idxs,","min_masks) # make sure num masked indices <= sequence_length if num_masked_spans * mask_length","be masked. this will be multiplied by number of timesteps divided by length","else: return inputs, group_shape def _apply_normalization(self, reshaped_inputs, input_shape): group_shape = tf.keras.backend.int_shape(reshaped_inputs) group_reduction_axes =","trainable=True, ) self.bias = self.add_weight(name=\"bias\", shape=(self.filters,), initializer=\"zeros\", trainable=True) def call(self, inputs): if not","= self.conv(hidden_states) hidden_states = self.activation(hidden_states) return hidden_states # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2LayerNormConvLayer with Wav2Vec2->Hubert","TFHubertFeatureEncoder(config, name=\"feature_extractor\") self.feature_projection = TFHubertFeatureProjection(config, name=\"feature_projection\") if config.do_stable_layer_norm: self.encoder = TFHubertEncoderStableLayerNorm(config, name=\"encoder\") else:","first positional arguments. This second option is useful when using [`tf.keras.Model.fit`] method which","deprecated and will be removed in a future version, use `input_values` instead.\", FutureWarning,","Conv1D output shapes are checked at build time since TF 2.7, so we","= None, past_key_values_length: int = 0): \"\"\" Expands attention_mask from `[bsz, seq_len]` to","output_hidden_states: Optional[bool] = False, return_dict: Optional[bool] = True, training: Optional[bool] = False, )","= num_heads self.dropout = tf.keras.layers.Dropout(dropout) self.head_dim = embed_dim // num_heads if (self.head_dim *","License for the specific language governing permissions and # limitations under the License.","processor = Wav2Vec2Processor.from_pretrained(\"facebook/hubert-base-960h\") >>> model = TFHubertForCTC.from_pretrained(\"facebook/hubert-base-960h\") >>> def map_to_array(batch): ... speech, _","+ str(input_shape) + \".\" ) def _set_number_of_groups_for_instance_norm(self, input_shape): dim = input_shape[self.axis] if self.groups","self.explicit_padding * 2 super().build(input_shape) self.kernel = tf.Variable(tf.transpose(self.kernel), name=\"weight_v\", trainable=True) self.weight_v = self.kernel self.weight_g","evaluation). \"\"\" @add_start_docstrings( \"The bare TFHubert Model transformer outputing raw hidden-states without any","= (bsz * self.num_heads, -1, self.head_dim) query_states = tf.reshape(self._shape(query_states, tgt_len, bsz), proj_shape) key_states","embeddings, pruning heads etc.) This model is also a [tf.keras.Model](https://www.tensorflow.org/api_docs/python/tf/keras/Model) subclass. Use it","Transformers v5. \" f\"Use `{self.__class__.__bases__[0].__name__}` instead.\", FutureWarning, ) class TFHubertFeatureProjection(tf.keras.layers.Layer): def __init__(self, config:","**kwargs): \"\"\" Process the input of each TensorFlow model including the booleans. In","self.config = config self.feature_extractor = TFHubertFeatureEncoder(config, name=\"feature_extractor\") self.feature_projection = TFHubertFeatureProjection(config, name=\"feature_projection\") if config.do_stable_layer_norm:","output[name] = kwargs.pop(name, signature[name].default) # When creating a SavedModel TF calls the method","respect the proper output we have to add this exception if \"args\" in","```python >>> from transformers import Wav2Vec2Processor, TFHubertModel >>> from datasets import load_dataset >>>","] LARGE_NEGATIVE = -1e8 # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.input_values_processing def input_values_processing(func, config, input_values, **kwargs):","{parameter_names} and will be ignored.\" ) continue else: raise ValueError(f\"Data of type {type(v)}","-1, bsz) key_states = tf.concat([past_key_value[0], key_states], axis=2) value_states = tf.concat([past_key_value[1], value_states], axis=2) else:","dim = input_shape[self.axis] if dim < self.groups: raise ValueError( \"Number of groups (\"","0.0 input_values = tf.convert_to_tensor(np.random.rand(1, 16000), tf.float32) dummy_inputs = { \"input_values\": input_values, \"attention_mask\": tf.cast(tf.not_equal(input_values,","case) # if encoder bi-directional self-attention `past_key_value` is always `None` past_key_value = (key_states,","as inputs: - having all inputs as keyword arguments (like PyTorch models), or","= input_shape[self.axis] shape = (dim,) if self.center: self.beta = self.add_weight( shape=shape, name=\"beta\", initializer=self.beta_initializer,","attentions=all_self_attentions, ) @keras_serializable class TFHubertMainLayer(tf.keras.layers.Layer): config_class = HubertConfig def __init__(self, config: HubertConfig, **kwargs):","= super().call(padded_inputs) return output # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2NoLayerNormConvLayer with Wav2Vec2->Hubert class TFHubertNoLayerNormConvLayer(tf.keras.layers.Layer): def","for k, v in kwargs.items(): if isinstance(v, allowed_types) or v is None: output[k]","is None: output[parameter_names[i]] = input else: raise ValueError( f\"Data of type {type(input)} is","does not belongs to the parameter list {parameter_names} and will be ignored.\" )","deprecated and will be removed in a future version, use `past_key_values` instead.\", FutureWarning,","super().__init__(**kwargs) self.config = config self.feature_extractor = TFHubertFeatureEncoder(config, name=\"feature_extractor\") self.feature_projection = TFHubertFeatureProjection(config, name=\"feature_projection\") if","transcription = processor.decode(predicted_ids[0]) >>> # compute loss >>> target_transcription = \"A MAN SAID","embed_dim: int, num_heads: int, dropout: float = 0.0, is_decoder: bool = False, bias:","(1, -1, 1, 1)) * tf.reshape( attn_weights, (bsz, self.num_heads, tgt_len, src_len) ) attn_weights","of varying length with one or several input Tensors IN THE ORDER given","processor(ds[\"speech\"][0], return_tensors=\"tf\").input_values # Batch size 1 >>> hidden_states = model(input_values).last_hidden_state ```\"\"\" inputs =","tf.keras.initializers.serialize(self.gamma_initializer), \"beta_regularizer\": tf.keras.regularizers.serialize(self.beta_regularizer), \"gamma_regularizer\": tf.keras.regularizers.serialize(self.gamma_regularizer), \"beta_constraint\": tf.keras.constraints.serialize(self.beta_constraint), \"gamma_constraint\": tf.keras.constraints.serialize(self.gamma_constraint), } base_config = super().get_config()","parameter, then `input_values` output[\"input_values\"] = output[\"args\"] del output[\"args\"] if \"kwargs\" in output: del","TF 2.0 documentation for all matter related to general usage and behavior. <Tip>","if output_attentions else None if attention_mask is not None: hidden_states = hidden_states *","k, v in kwargs.items(): if isinstance(v, allowed_types) or v is None: output[k] =","tf.nn.softmax(attn_weights, axis=-1) if layer_head_mask is not None: # The tf.debugging asserts are not","self.activation(hidden_states) return hidden_states # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2PositionalConvEmbedding with Wav2Vec2->Hubert class TFHubertPositionalConvEmbedding(tf.keras.layers.Layer): def __init__(self,","Model transformer outputing raw hidden-states without any specific head on top.\", HUBERT_START_DOCSTRING, )","return gamma, beta def _check_if_input_shape_is_none(self, input_shape): dim = input_shape[self.axis] if dim is None:","docstring) Tokens with indices set to `-100` are ignored (masked), the loss is","tf.keras.layers.Dense(embed_dim, use_bias=bias, name=\"q_proj\") self.v_proj = tf.keras.layers.Dense(embed_dim, use_bias=bias, name=\"v_proj\") self.out_proj = tf.keras.layers.Dense(embed_dim, use_bias=bias, name=\"out_proj\")","mask_length=self.config.mask_feature_length, ) hidden_states = tf.where(mask_feature_indices[:, tf.newaxis, :], hidden_states, 0) return hidden_states def call(","def __init__( self, groups: int = 32, axis: int = -1, epsilon: float","is not None else output return TFCausalLMOutput( loss=loss, logits=logits, hidden_states=outputs.hidden_states, attentions=outputs.attentions, ) def","\"decoder_cached_states\" in input_values: warnings.warn( \"The `decoder_cached_states` argument is deprecated and will be removed","= Wav2Vec2Processor.from_pretrained(\"facebook/hubert-base-960h\") >>> model = TFHubertModel.from_pretrained(\"facebook/hubert-base-960h\") >>> def map_to_array(batch): ... speech, _ =","= np.random.uniform(0, 1) if training and (dropout_probability < self.config.layerdrop): # skip the layer","import ( ModelOutput, add_start_docstrings, add_start_docstrings_to_model_forward, logging, replace_return_docstrings, ) from .configuration_hubert import HubertConfig logger","is accepted for {k}.\") if isinstance(input_values, (tuple, list)): for i, input in enumerate(input_values):","positional arguments. This second option is useful when using [`tf.keras.Model.fit`] method which currently","conv_layers = [TFHubertGroupNormConvLayer(config, layer_id=0, name=f\"conv_layers.{0}\")] + [ TFHubertNoLayerNormConvLayer(config, layer_id=i + 1, name=f\"conv_layers.{i+1}\") for","# Copyright 2021 The Fairseq Authors and the HuggingFace Inc. team. All rights","spec_aug_mask_idxs = _sample_without_replacement(uniform_dist, num_masked_spans) # expand masked indices to masked spans spec_aug_mask_idxs =","= model(input_values).logits >>> predicted_ids = tf.argmax(logits, axis=-1) >>> transcription = processor.decode(predicted_ids[0]) >>> #","See all Hubert models at https://huggingface.co/models?filter=hubert ] LARGE_NEGATIVE = -1e8 # Copied from","be <= vocab_size: {self.config.vocab_size}\") attention_mask = ( inputs[\"attention_mask\"] if inputs[\"attention_mask\"] is not None","size {(bsz * self.num_heads, tgt_len, src_len)}, but is {shape_list(attn_weights)}\", ) if attention_mask is","// self.groups) == 1 if not is_instance_norm: axis = -2 if self.axis ==","Copied from transformers.models.bart.modeling_tf_bart.TFBartAttention with TFBart->TFHubert class TFHubertAttention(tf.keras.layers.Layer): \"\"\"Multi-headed attention from \"Attention Is All","super().__init__( filters=filters, kernel_size=kernel_size, groups=groups, padding=\"valid\", use_bias=True, bias_initializer=\"he_normal\", **kwargs, ) self.explicit_padding = explicit_padding self.filter_axis","vector.\"\"\" kernel_norm = tf.sqrt(tf.reduce_sum(tf.square(self.weight_v), axis=self.kernel_norm_axes)) self.weight_g.assign(kernel_norm[:, tf.newaxis, tf.newaxis]) def _normalize_kernel(self): \"\"\"Generate normalized weights.\"\"\"","False @add_start_docstrings_to_model_forward(HUBERT_INPUTS_DOCSTRING) @replace_return_docstrings(output_type=TFCausalLMOutput, config_class=_CONFIG_FOR_DOC) def call( self, input_values: tf.Tensor, attention_mask: Optional[tf.Tensor] = None,","saving, resizing the input embeddings, pruning heads etc.) This model is also a","labels is not None: if tf.reduce_max(labels) >= self.config.vocab_size: raise ValueError(f\"Label values must be","= { \"groups\": self.groups, \"axis\": self.axis, \"epsilon\": self.epsilon, \"center\": self.center, \"scale\": self.scale, \"beta_initializer\":","of the same size as shape, which will prevent masking padded elements mask_prob:","group_reduction_axes.pop(axis) mean, variance = tf.nn.moments(reshaped_inputs, group_reduction_axes, keepdims=True) gamma, beta = self._get_reshaped_weights(input_shape) normalized_inputs =","are token type IDs?](../glossary#token-type-ids) position_ids (`np.ndarray` or `tf.Tensor` of shape `({0})`, *optional*): Indices","* LARGE_NEGATIVE # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2GroupNorm with Wav2Vec2->Hubert class TFHubertGroupNorm(tf.keras.layers.Layer): \"\"\" From tensorflow-addons","(\" + str(dim) + \").\" ) def _check_axis(self): if self.axis == 0: raise","(one_cst - expanded_mask) * LARGE_NEGATIVE # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2GroupNorm with Wav2Vec2->Hubert class TFHubertGroupNorm(tf.keras.layers.Layer):","sf >>> processor = Wav2Vec2Processor.from_pretrained(\"facebook/hubert-base-960h\") >>> model = TFHubertModel.from_pretrained(\"facebook/hubert-base-960h\") >>> def map_to_array(batch): ...","associated vectors than the model's internal embedding lookup matrix. output_attentions (`bool`, *optional*): Whether","Optional[bool] = None, labels: Optional[tf.Tensor] = None, output_hidden_states: Optional[bool] = None, return_dict: Optional[bool]","{sequence_length}`\" ) # compute number of masked spans in batch num_masked_spans = int(mask_prob","self.head_dim], message=f\"`attn_output` should be of size {(bsz, self.num_heads, tgt_len, self.head_dim)}, but is {shape_list(attn_output)}\",","+ 1 for kernel_size, stride in zip(self.config.conv_kernel, self.config.conv_stride): input_lengths = _conv_out_length(input_lengths, kernel_size, stride)","self.dropout = tf.keras.layers.Dropout(config.final_dropout) self.lm_head = tf.keras.layers.Dense(config.vocab_size, name=\"lm_head\") def freeze_feature_extractor(self): \"\"\" Calling this function","= (input_shape[self.axis] // self.groups) == 1 if not is_instance_norm: outputs = tf.reshape(normalized_inputs, tensor_input_shape)","of the model. Initializing with a config file does not load the weights","inputs): input_shape = tf.keras.backend.int_shape(inputs) tensor_input_shape = tf.shape(inputs) reshaped_inputs, group_shape = self._reshape_into_groups(inputs, input_shape, tensor_input_shape)","distribution to sample from, make sure that offset samples are < sequence_length uniform_dist","bool = False, ) -> Tuple[tf.Tensor]: attn_residual = hidden_states hidden_states, attn_weights, _ =","v5.\" \"Please use the equivalent `freeze_feature_encoder` method instead.\", FutureWarning, ) self.freeze_feature_encoder() def freeze_feature_encoder(self):","else self.config.output_hidden_states ) inputs[\"output_attentions\"] = ( inputs[\"output_attentions\"] if inputs[\"output_attentions\"] else self.config.output_attentions ) inputs[\"return_dict\"]","group_shape.insert(self.axis, self.groups) group_shape = tf.stack(group_shape) reshaped_inputs = tf.reshape(inputs, group_shape) return reshaped_inputs, group_shape else:","hidden_states = self.layer_norm(hidden_states) hidden_states = hidden_states + self.feed_forward(hidden_states) hidden_states = self.final_layer_norm(hidden_states) outputs =",") @tf.function def serving(self, inputs): output = self.call(input_values=inputs, training=False) return self.serving_output(output) HUBERT_START_DOCSTRING =","Args: config ([`HubertConfig`]): Model configuration class with all the parameters of the model.","with Wav2Vec2->Hubert class TFHubertGroupNormConvLayer(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, layer_id: int = 0, **kwargs:","is only computed for the tokens with labels in `[0, ..., config.vocab_size]` Returns:","all cross-attention # key/value_states (first \"if\" case) # if uni-directional self-attention (decoder) save","the gradient computation for the feature encoder so that its parameters will not","shape_list from ...tokenization_utils_base import BatchEncoding from ...utils import ( ModelOutput, add_start_docstrings, add_start_docstrings_to_model_forward, logging,","z, num_samples) return indices # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2._scatter_values_on_batch_indices def _scatter_values_on_batch_indices(values, batch_indices, output_shape): \"\"\"","head is **masked**. inputs_embeds (`np.ndarray` or `tf.Tensor` of shape `({0}, hidden_size)`, *optional*): Optionally,","inspect import warnings from typing import Any, Dict, Optional, Tuple, Union import numpy","allowed_types) or v is None: output[k] = v elif k not in parameter_names","= tf.reshape(inputs, group_shape) return reshaped_inputs, group_shape else: return inputs, group_shape def _apply_normalization(self, reshaped_inputs,","k: v for k, v in output.items() if k in [\"return_dict\", \"output_attentions\", \"output_hidden_states\",","def __init__(self, config: HubertConfig, **kwargs): super().__init__(**kwargs) self.attention = TFHubertAttention( embed_dim=config.hidden_size, num_heads=config.num_attention_heads, dropout=config.attention_dropout, is_decoder=False,","model, only the configuration. Check out the [`~PreTrainedModel.from_pretrained`] method to load the model","\"\"\" Process the input of each TensorFlow model including the booleans. In case","length with one or several input Tensors IN THE ORDER given in the","Optional[tf.Tensor] = None, output_attentions: Optional[bool] = False, output_hidden_states: Optional[bool] = False, return_dict: Optional[bool]","self.conv_layers: hidden_states = conv_layer(hidden_states) return hidden_states class TFHubertFeatureExtractor(TFHubertFeatureEncoder): def __init__(self, config, **kwargs): super().__init__(config,","proj query_states = self.q_proj(hidden_states) * self.scaling # get key, value proj if is_cross_attention","to `[bsz, 1, tgt_seq_len, src_seq_len]`. \"\"\" src_len = shape_list(mask)[1] tgt_len = tgt_len if","self_attention key_states = self._shape(self.k_proj(hidden_states), -1, bsz) value_states = self._shape(self.v_proj(hidden_states), -1, bsz) if self.is_decoder:","parameter_names = list(signature.keys()) output = {} allowed_types = (tf.Tensor, bool, int, ModelOutput, tuple,","be in `[-100, 0, ..., config.vocab_size]` (see `input_values` docstring) Tokens with indices set","_get_feat_extract_output_lengths(self, input_lengths: tf.Tensor): \"\"\" Computes the output length of the convolutional layers \"\"\"","input_lengths = self.hubert._get_feat_extract_output_lengths(tf.reduce_sum(attention_mask, axis=-1)) # assuming that padded tokens are filled with -100","__init__( self, groups: int = 32, axis: int = -1, epsilon: float =","indices to masked spans spec_aug_mask_idxs = tf.expand_dims(spec_aug_mask_idxs, -1) spec_aug_mask_idxs = tf.tile(spec_aug_mask_idxs, (1, 1,","tgt_len, src_len)) attn_weights = tf.nn.softmax(attn_weights, axis=-1) if layer_head_mask is not None: # The","= hidden_states hidden_states, attn_weights, _ = self.attention( hidden_states, attention_mask=attention_mask, training=training ) hidden_states =","= self.feature_projection(hidden_states, training=inputs[\"training\"]) mask_time_indices = kwargs.get(\"mask_time_indices\", None) if inputs[\"training\"]: hidden_states = self._mask_hidden_states(hidden_states, mask_time_indices=mask_time_indices)","random indices to mask spec_aug_mask_idxs = _sample_without_replacement(uniform_dist, num_masked_spans) # expand masked indices to","group_shape = tf.keras.backend.int_shape(reshaped_inputs) group_reduction_axes = list(range(1, len(group_shape))) is_instance_norm = (input_shape[self.axis] // self.groups) ==","= self.activation(hidden_states) return hidden_states # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2SamePadLayer with Wav2Vec2->Hubert class TFHubertSamePadLayer(tf.keras.layers.Layer): def","ValueError( f\"`config.feat_extract_norm` is {config.feat_extract_norm}, but has to be one of ['group', 'layer']\" )","the input embeddings, pruning heads etc.) This model is also a [tf.keras.Model](https://www.tensorflow.org/api_docs/python/tf/keras/Model) subclass.","regularizer=self.gamma_regularizer, constraint=self.gamma_constraint, ) else: self.gamma = None def _add_beta_weight(self, input_shape): dim = input_shape[self.axis]","// self.groups group_shape.insert(self.axis, self.groups) group_shape = tf.stack(group_shape) reshaped_inputs = tf.reshape(inputs, group_shape) return reshaped_inputs,","model(input_values).last_hidden_state ```\"\"\" inputs = input_values_processing( func=self.call, config=self.config, input_values=input_values, attention_mask=attention_mask, token_type_ids=token_type_ids, position_ids=position_ids, head_mask=head_mask, inputs_embeds=inputs_embeds,","shape Args: shape: the the shape for which to compute masks. should be","be of size {(bsz, self.num_heads, tgt_len, self.head_dim)}, but is {shape_list(attn_output)}\", ) attn_output =","float = 0.0, is_decoder: bool = False, bias: bool = True, **kwargs, ):","(`np.ndarray` or `tf.Tensor` of shape `({0})`, *optional*): Segment token indices to indicate first","loss = model(input_values, labels=labels).loss ```\"\"\" inputs = input_values_processing( func=self.call, config=self.config, input_values=input_values, attention_mask=attention_mask, token_type_ids=token_type_ids,","is None: output[k] = v else: raise ValueError(f\"Data of type {type(v)} is not","in eager mode, in graph mode the value will always be set to","NOT supported on CPU. If you wish \" \"to train/fine-tine this model, you","indices set to `-100` are ignored (masked), the loss is only computed for","-1, bsz) if self.is_decoder: # if cross_attention save Tuple(tf.Tensor, tf.Tensor) of all cross","parameters of the model. Initializing with a config file does not load the","output: del output[\"kwargs\"] boolean_dict = { k: v for k, v in output.items()","**kwargs): super().__init__(**kwargs) self.config = config self.feature_extractor = TFHubertFeatureEncoder(config, name=\"feature_extractor\") self.feature_projection = TFHubertFeatureProjection(config, name=\"feature_projection\")","[What are position IDs?](../glossary#position-ids) head_mask (`np.ndarray` or `tf.Tensor` of shape `(num_heads,)` or `(num_layers,","with LayerCall.__call__(args, **kwargs) # So to respect the proper output we have to","on padding token indices. Mask values selected in `[0, 1]`: - 1 for","with Wav2Vec2->Hubert class TFHubertPositionalConvEmbedding(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs: Any) -> None: super().__init__(**kwargs)","call(self, hidden_states: tf.Tensor, training: bool = False) -> tf.Tensor: hidden_states = self.layer_norm(hidden_states) hidden_states","implements for all its model (such as downloading or saving, resizing the input","self.initialized = True self._normalize_kernel() padded_inputs = tf.pad(inputs, ((0, 0), (self.explicit_padding, self.explicit_padding), (0, 0)))","has backpropagation operations that are NOT supported on CPU. If you wish \"","* self.num_heads, tgt_len, self.head_dim], message=f\"`attn_output` should be of size {(bsz, self.num_heads, tgt_len, self.head_dim)},","None: hidden_states = hidden_states * tf.expand_dims(attention_mask, -1) attention_mask = _expand_mask(attention_mask) else: attention_mask =","tf.transpose( tf.reshape(attn_output, (bsz, self.num_heads, tgt_len, self.head_dim)), (0, 2, 1, 3) ) attn_output =","tf.float32) dummy_inputs = { \"input_values\": input_values, \"attention_mask\": tf.cast(tf.not_equal(input_values, pad_token), tf.float32), } return dummy_inputs","(dict, BatchEncoding)): if \"inputs\" in input_values: warnings.warn( \"The `inputs` argument is deprecated and","in the config will be used instead. return_dict (`bool`, *optional*): Whether or not","== \"sum\": loss = tf.reduce_sum(loss) if self.config.ctc_loss_reduction == \"mean\": loss = tf.reduce_mean(loss) else:","self.scaling # get key, value proj if is_cross_attention and past_key_value is not None:","output[k] = v elif k not in parameter_names and \"args\" not in parameter_names:","this layer is used as a cross-attention layer # for the decoder is_cross_attention","or `(num_layers, num_heads)`, *optional*): Mask to nullify selected heads of the self-attention modules.","method instead.\", FutureWarning, ) self.freeze_feature_encoder() def freeze_feature_encoder(self): \"\"\" Calling this function will disable","or `Dict[str, np.ndarray]` and each example must have the shape `({0})`): Indices of","self._apply_normalization(reshaped_inputs, input_shape) is_instance_norm = (input_shape[self.axis] // self.groups) == 1 if not is_instance_norm: outputs"],"string":"[\n \"= _compute_mask_indices( (batch_size, sequence_length), mask_prob=self.config.mask_time_prob, mask_length=self.config.mask_time_length, min_masks=2, ) hidden_states = tf.where( tf.cast(mask_time_indices[:, :,\",\n \"length of the convolutional layers \\\"\\\"\\\" def _conv_out_length(input_length, kernel_size, stride): # 1D convolutional\",\n \"else tf.ones_like(inputs[\\\"input_values\\\"], dtype=tf.float32) ) input_lengths = self.hubert._get_feat_extract_output_lengths(tf.reduce_sum(attention_mask, axis=-1)) # assuming that padded tokens\",\n \"= epsilon self.center = center self.scale = scale self.beta_initializer = tf.keras.initializers.get(beta_initializer) self.gamma_initializer =\",\n \"transformers.models.wav2vec2.modeling_tf_wav2vec2._scatter_values_on_batch_indices def _scatter_values_on_batch_indices(values, batch_indices, output_shape): \\\"\\\"\\\" Scatter function as in PyTorch with indices\",\n \"if dim < self.groups: raise ValueError( \\\"Number of groups (\\\" + str(self.groups) +\",\n \"beta def _check_if_input_shape_is_none(self, input_shape): dim = input_shape[self.axis] if dim is None: raise ValueError(\",\n \"this will be multiplied by number of timesteps divided by length of mask\",\n \"self_attention key_states = self._shape(self.k_proj(hidden_states), -1, bsz) value_states = self._shape(self.v_proj(hidden_states), -1, bsz) key_states =\",\n \"Indices of input sequence tokens in the vocabulary. Indices can be obtained using\",\n \"exception if \\\"args\\\" in output: if output[\\\"args\\\"] is not None and type(output[\\\"args\\\"]) ==\",\n \"self.layer = [TFHubertEncoderLayer(config, name=f\\\"layers.{i}\\\") for i in range(config.num_hidden_layers)] def call( self, hidden_states: tf.Tensor,\",\n \"= \\\"A MAN SAID TO THE UNIVERSE SIR I EXIST\\\" >>> # wrap\",\n \"<= sequence_length if num_masked_spans * mask_length > sequence_length: num_masked_spans = sequence_length // mask_length\",\n \"tf.tile(mask[:, None, None, :], (1, 1, tgt_len, 1)) return (one_cst - expanded_mask) *\",\n \"Further calls to cross_attention layer can then reuse all cross-attention # key/value_states (first\",\n \"This model inherits from [`TFPreTrainedModel`]. Check the superclass documentation for the generic methods\",\n \"self.num_heads, tgt_len, src_len)) attn_probs = self.dropout(attn_weights, training=training) attn_output = tf.matmul(attn_probs, value_states) # The\",\n \"return tuple(v for v in [hidden_states, all_hidden_states, all_self_attentions] if v is not None)\",\n \"input IDs?](../glossary#input-ids) attention_mask (`np.ndarray` or `tf.Tensor` of shape `({0})`, *optional*): Mask to avoid\",\n \"@keras_serializable class TFHubertMainLayer(tf.keras.layers.Layer): config_class = HubertConfig def __init__(self, config: HubertConfig, **kwargs): super().__init__(**kwargs) self.config\",\n \"is deprecated and will be removed in Transformers v5.\\\" \\\"Please use the equivalent\",\n \"if self.scale: gamma = tf.reshape(self.gamma, broadcast_shape) if self.center: beta = tf.reshape(self.beta, broadcast_shape) return\",\n \"stride): # 1D convolutional layer output length formula taken # from https://pytorch.org/docs/stable/generated/torch.nn.Conv1d.html return\",\n \"name not in list(output.keys()) and name != \\\"args\\\": output[name] = kwargs.pop(name, signature[name].default) #\",\n \"(`np.ndarray` or `tf.Tensor` of shape `({0}, hidden_size)`, *optional*): Optionally, instead of passing `input_values`\",\n \"IS\\\" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or\",\n \"not inputs[\\\"return_dict\\\"]: output = (logits,) + outputs[1:] return ((loss,) + output) if loss\",\n \"tgt_len, src_len], message=f\\\"Attention weights should be of size {(bsz * self.num_heads, tgt_len, src_len)},\",\n \"axes={self.axis: dim}) def _add_gamma_weight(self, input_shape): dim = input_shape[self.axis] shape = (dim,) if self.scale:\",\n \"groups=groups, padding=\\\"valid\\\", use_bias=True, bias_initializer=\\\"he_normal\\\", **kwargs, ) self.explicit_padding = explicit_padding self.filter_axis = 2 self.initialized\",\n \"= True, scale: bool = True, beta_initializer: tf.keras.initializers.Initializer = \\\"zeros\\\", gamma_initializer: tf.keras.initializers.Initializer =\",\n \"all_self_attentions = () if output_attentions else None if attention_mask is not None: hidden_states\",\n \"concat previous decoder key/value_states to current projected key/value_states (third \\\"elif\\\" case) # if\",\n \"belongs to the parameter list {parameter_names} and will be ignored.\\\" ) continue else:\",\n \"tgt_len, embed_dim)) attn_output = self.out_proj(attn_output) attn_weights: tf.Tensor = tf.reshape(attn_weights, (bsz, self.num_heads, tgt_len, src_len))\",\n \"along time axis and/or along feature axis according to [SpecAugment](https://arxiv.org/abs/1904.08779). \\\"\\\"\\\" batch_size, sequence_length,\",\n \"= get_tf_activation(config.feat_extract_activation) def call(self, hidden_states: tf.Tensor) -> tf.Tensor: hidden_states = self.conv(hidden_states) hidden_states =\",\n \"tf.debugging.assert_equal( shape_list(attention_mask), [bsz, 1, tgt_len, src_len], message=f\\\"Attention mask should be of size {(bsz,\",\n \"else: attention_mask = None position_embeddings = self.pos_conv_embed(hidden_states) hidden_states = hidden_states + position_embeddings hidden_states\",\n \"indicate first and second portions of the inputs. Indices are selected in `[0,\",\n \"outputs[0] hidden_states = self.dropout(hidden_states, training=inputs[\\\"training\\\"]) logits = self.lm_head(hidden_states) if labels is not None:\",\n \"of type {type(v)} is not allowed only {allowed_types} is accepted for {k}.\\\") else:\",\n \"def _check_axis(self): if self.axis == 0: raise ValueError( \\\"You are trying to normalize\",\n \"any specific head on top.\\\", HUBERT_START_DOCSTRING, ) class TFHubertModel(TFHubertPreTrainedModel): def __init__(self, config: HubertConfig,\",\n \"None else tf.ones_like(inputs[\\\"input_values\\\"], dtype=tf.float32) ) input_lengths = self.hubert._get_feat_extract_output_lengths(tf.reduce_sum(attention_mask, axis=-1)) # assuming that padded\",\n \"= None, return_dict: Optional[bool] = None, training: bool = False, **kwargs: Any, ):\",\n \"src_len], message=f\\\"Attention mask should be of size {(bsz, 1, tgt_len, src_len)}, but is\",\n \"@replace_return_docstrings(output_type=TFBaseModelOutput, config_class=_CONFIG_FOR_DOC) def call( self, input_values: tf.Tensor, attention_mask: Optional[tf.Tensor] = None, token_type_ids: Optional[tf.Tensor]\",\n \"{ k: v for k, v in output.items() if k in [\\\"return_dict\\\", \\\"output_attentions\\\",\",\n \"tf.reshape( attn_weights, (bsz, self.num_heads, tgt_len, src_len) ) attn_weights = tf.reshape(attn_weights, (bsz * self.num_heads,\",\n \"bool = True, scale: bool = True, beta_initializer: tf.keras.initializers.Initializer = \\\"zeros\\\", gamma_initializer: tf.keras.initializers.Initializer\",\n \"a future version, use `input_values` instead.\\\", FutureWarning, ) output[\\\"input_values\\\"] = input_values.pop(\\\"inputs\\\") if \\\"decoder_cached_states\\\"\",\n \"config: HubertConfig, **kwargs): super().__init__(**kwargs) self.config = config self.pos_conv_embed = TFHubertPositionalConvEmbedding(config, name=\\\"pos_conv_embed\\\") self.layer_norm =\",\n \"selected in `[0, 1]`: - 0 corresponds to a *sentence A* token, -\",\n \"call( self, hidden_states: tf.Tensor, attention_mask: Optional[tf.Tensor] = None, output_attentions: Optional[bool] = False, training:\",\n \"= processor(transcription, return_tensors=\\\"tf\\\").input_values >>> loss = model(input_values, labels=labels).loss ```\\\"\\\"\\\" inputs = input_values_processing( func=self.call,\",\n \"return self.serving_output(output) HUBERT_START_DOCSTRING = r\\\"\\\"\\\" This model inherits from [`TFPreTrainedModel`]. Check the superclass\",\n \"layer_module in enumerate(self.layer): if output_hidden_states: all_hidden_states = all_hidden_states + (hidden_states,) # add LayerDrop\",\n \"self.v_proj = tf.keras.layers.Dense(embed_dim, use_bias=bias, name=\\\"v_proj\\\") self.out_proj = tf.keras.layers.Dense(embed_dim, use_bias=bias, name=\\\"out_proj\\\") def _shape(self, tensor:\",\n \"in zip(self.config.conv_kernel, self.config.conv_stride): input_lengths = _conv_out_length(input_lengths, kernel_size, stride) return input_lengths def _mask_hidden_states(self, hidden_states:\",\n \"shape_list(attn_weights), [bsz * self.num_heads, tgt_len, src_len], message=f\\\"Attention weights should be of size {(bsz\",\n \"def __init__(self, config: HubertConfig, **kwargs: Any) -> None: super().__init__(**kwargs) self.conv = TFHubertWeightNormConv1D( filters=config.hidden_size,\",\n \"dummy_inputs(self) -> Dict[str, tf.Tensor]: pad_token = 0.0 input_values = tf.convert_to_tensor(np.random.rand(1, 16000), tf.float32) dummy_inputs\",\n \"v in dict(input_values).items(): if isinstance(v, allowed_types) or v is None: output[k] = v\",\n \"output[\\\"args\\\"] del output[\\\"args\\\"] if \\\"kwargs\\\" in output: del output[\\\"kwargs\\\"] boolean_dict = { k:\",\n \"are input IDs?](../glossary#input-ids) attention_mask (`np.ndarray` or `tf.Tensor` of shape `({0})`, *optional*): Mask to\",\n \"if inputs[\\\"return_dict\\\"] else self.config.return_dict outputs = self.hubert( input_values=inputs[\\\"input_values\\\"], attention_mask=inputs[\\\"attention_mask\\\"], token_type_ids=inputs[\\\"token_type_ids\\\"], position_ids=inputs[\\\"position_ids\\\"], head_mask=inputs[\\\"head_mask\\\"], inputs_embeds=inputs[\\\"inputs_embeds\\\"],\",\n \"percentage of all elements. however due to overlaps, the actual number will be\",\n \"int = -1, epsilon: float = 1e-3, center: bool = True, scale: bool\",\n \"models), or - having all inputs as a list, tuple or dict in\",\n \"tf.tile(spec_aug_mask_idxs, (1, 1, mask_length)) spec_aug_mask_idxs = tf.reshape(spec_aug_mask_idxs, (batch_size, num_masked_spans * mask_length)) offsets =\",\n \"label_length=target_lengths, blank_index=self.config.pad_token_id, logits_time_major=False, ) if self.config.ctc_loss_reduction == \\\"sum\\\": loss = tf.reduce_sum(loss) if self.config.ctc_loss_reduction\",\n \"hidden_states=hidden_states, attention_mask=attention_mask, output_attentions=output_attentions, training=training, ) hidden_states = layer_outputs[0] if output_attentions: all_self_attentions = all_self_attentions\",\n \"dict(inspect.signature(func).parameters) signature.pop(\\\"kwargs\\\", None) signature.pop(\\\"self\\\", None) parameter_names = list(signature.keys()) output = {} allowed_types =\",\n \"length formula taken # from https://pytorch.org/docs/stable/generated/torch.nn.Conv1d.html return (input_length - kernel_size) // stride +\",\n \") hidden_states = self.feature_projection(hidden_states, training=inputs[\\\"training\\\"]) mask_time_indices = kwargs.get(\\\"mask_time_indices\\\", None) if inputs[\\\"training\\\"]: hidden_states =\",\n \"TFHubertEncoderLayerStableLayerNorm(config, name=f\\\"layers.{i}\\\") for i in range(config.num_hidden_layers) ] def call( self, hidden_states: tf.Tensor, attention_mask:\",\n \"= 32, axis: int = -1, epsilon: float = 1e-3, center: bool =\",\n \"None, output_hidden_states: Optional[bool] = None, return_dict: Optional[bool] = None, training: Optional[bool] = False,\",\n \"*optional*): Whether or not to return the attentions tensors of all attention layers.\",\n \"in the range `[0, config.max_position_embeddings - 1]`. [What are position IDs?](../glossary#position-ids) head_mask (`np.ndarray`\",\n \"f\\\"The parameter {k} does not belongs to the parameter list {parameter_names} and will\",\n \"axis=self.kernel_norm_axes) * tf.transpose(self.weight_g) self.kernel = tf.transpose(kernel) def build(self, input_shape): if not self.built: input_shape\",\n \"return hidden_states class TFHubertFeatureExtractor(TFHubertFeatureEncoder): def __init__(self, config, **kwargs): super().__init__(config, **kwargs) warnings.warn( f\\\"The class\",\n \"its parameters will not be updated during training. \\\"\\\"\\\" warnings.warn( \\\"The method `freeze_feature_extractor`\",\n \"config self.pos_conv_embed = TFHubertPositionalConvEmbedding(config, name=\\\"pos_conv_embed\\\") self.layer_norm = tf.keras.layers.LayerNormalization(epsilon=config.layer_norm_eps, name=\\\"layer_norm\\\") self.dropout = tf.keras.layers.Dropout(config.hidden_dropout) self.layer\",\n \"FutureWarning, ) output[\\\"input_values\\\"] = input_values.pop(\\\"inputs\\\") if \\\"decoder_cached_states\\\" in input_values: warnings.warn( \\\"The `decoder_cached_states` argument\",\n \"training=inputs[\\\"training\\\"]) logits = self.lm_head(hidden_states) if labels is not None: if tf.reduce_max(labels) >= self.config.vocab_size:\",\n \"input_shape): dim = input_shape[self.axis] if dim < self.groups: raise ValueError( \\\"Number of groups\",\n \"indices = tf.nn.top_k(distribution + z, num_samples) return indices # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2._scatter_values_on_batch_indices def\",\n \"\\\"hubert\\\" main_input_name = \\\"input_values\\\" @property def dummy_inputs(self) -> Dict[str, tf.Tensor]: pad_token = 0.0\",\n \"*optional*): Mask to avoid performing attention on padding token indices. Mask values selected\",\n \"tf.executing_eagerly(): tf.debugging.assert_equal( shape_list(layer_head_mask), [self.num_heads], message=f\\\"Head mask for a single layer should be of\",\n \"the pattern `name:id` then we check only the # `name` part tensor_name =\",\n \"-1)) attention_mask = tf.sequence_mask( output_lengths, maxlen=shape_list(hidden_states)[1], dtype=hidden_states.dtype ) hidden_states = self.feature_projection(hidden_states, training=inputs[\\\"training\\\"]) mask_time_indices\",\n \"tf.float32), } return dummy_inputs def __init__(self, config, *inputs, **kwargs): super().__init__(config, *inputs, **kwargs) logger.warning(\",\n \"None, None, :], (1, 1, tgt_len, 1)) return (one_cst - expanded_mask) * LARGE_NEGATIVE\",\n \"spans spec_aug_mask_idxs = tf.expand_dims(spec_aug_mask_idxs, -1) spec_aug_mask_idxs = tf.tile(spec_aug_mask_idxs, (1, 1, mask_length)) spec_aug_mask_idxs =\",\n \"None: super().__init__(**kwargs) self.in_conv_dim = config.conv_dim[layer_id] if layer_id > 0 else 1 self.out_conv_dim =\",\n \"None, inputs_embeds: Optional[tf.Tensor] = None, output_attentions: Optional[bool] = None, labels: Optional[tf.Tensor] = None,\",\n \"defined dimension \\\" \\\"but the layer received an input with shape \\\" +\",\n \"Wav2Vec2Processor, TFHubertModel >>> from datasets import load_dataset >>> import soundfile as sf >>>\",\n \"tokens with labels in `[0, ..., config.vocab_size]` Returns: Example: ```python >>> import tensorflow\",\n \"= None, training: Optional[bool] = False, ) -> Union[TFCausalLMOutput, Tuple[tf.Tensor]]: r\\\"\\\"\\\" labels (`tf.Tensor`\",\n \"output: if output[\\\"args\\\"] is not None and type(output[\\\"args\\\"]) == tf.Tensor: tensor_name = output[\\\"args\\\"].name.split(\\\":\\\")[0]\",\n \":, tf.newaxis], tf.bool), self.masked_spec_embed[tf.newaxis, tf.newaxis, :], hidden_states, ) # apply SpecAugment along feature\",\n \"\\\"clean\\\", split=\\\"validation\\\") >>> ds = ds.map(map_to_array) >>> input_values = processor(ds[\\\"speech\\\"][0], return_tensors=\\\"tf\\\").input_values # Batch\",\n \"= -1, epsilon: float = 1e-3, center: bool = True, scale: bool =\",\n \"position embeddings. Selected in the range `[0, config.max_position_embeddings - 1]`. [What are position\",\n \"HuggingFace Inc. team. All rights reserved. # # Licensed under the Apache License,\",\n \"Wav2Vec2->Hubert class TFHubertEncoderLayerStableLayerNorm(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs): super().__init__(**kwargs) self.attention = TFHubertAttention( embed_dim=config.hidden_size,\",\n \"or `tf.Tensor` of shape `({0})`, *optional*): Indices of positions of each input sequence\",\n \"self.axis == -1 else self.axis - 1 else: axis = -1 if self.axis\",\n \"given mask_time_indices hidden_states = tf.where( tf.cast(mask_time_indices[:, :, tf.newaxis], tf.bool), self.masked_spec_embed[tf.newaxis, tf.newaxis, :], hidden_states,\",\n \"= tf.expand_dims(spec_aug_mask_idxs, -1) spec_aug_mask_idxs = tf.tile(spec_aug_mask_idxs, (1, 1, mask_length)) spec_aug_mask_idxs = tf.reshape(spec_aug_mask_idxs, (batch_size,\",\n \"batch_indices to pair_indices pair_indices = tf.transpose(tf.concat([broad_casted_batch_dims, tf.reshape(batch_indices, [1, -1])], 0)) # scatter values\",\n \"all cross attention key/value_states. # Further calls to cross_attention layer can then reuse\",\n \"= all_self_attentions + (layer_outputs[1],) hidden_states = self.layer_norm(hidden_states) if output_hidden_states: all_hidden_states = all_hidden_states +\",\n \"one_cst = tf.constant(1.0) mask = tf.cast(mask, dtype=one_cst.dtype) expanded_mask = tf.tile(mask[:, None, None, :],\",\n \"input_values else: raise ValueError( f\\\"Data of type {type(input_values)} is not allowed only {allowed_types}\",\n \"None: # reuse k, v, self_attention key_states = self._shape(self.k_proj(hidden_states), -1, bsz) value_states =\",\n \"\\\"facebook/hubert-base-ls960\\\", # See all Hubert models at https://huggingface.co/models?filter=hubert ] LARGE_NEGATIVE = -1e8 #\",\n \"(mask_length - 1))) # get random indices to mask spec_aug_mask_idxs = _sample_without_replacement(uniform_dist, num_masked_spans)\",\n \"key/value_states (first \\\"if\\\" case) # if uni-directional self-attention (decoder) save Tuple(tf.Tensor, tf.Tensor) of\",\n \"set to True. training (`bool`, *optional*, defaults to `False``): Whether or not to\",\n \"add_start_docstrings, add_start_docstrings_to_model_forward, logging, replace_return_docstrings, ) from .configuration_hubert import HubertConfig logger = logging.get_logger(__name__) _CONFIG_FOR_DOC\",\n \"src_seq_len]`. \\\"\\\"\\\" src_len = shape_list(mask)[1] tgt_len = tgt_len if tgt_len is not None\",\n \"class TFHubertAttention(tf.keras.layers.Layer): \\\"\\\"\\\"Multi-headed attention from \\\"Attention Is All You Need\\\"\\\"\\\" def __init__( self,\",\n \"{config.feat_extract_norm}, but has to be one of ['group', 'layer']\\\" ) self.conv_layers = conv_layers\",\n \"**kwargs, ) self.explicit_padding = explicit_padding self.filter_axis = 2 self.initialized = False self.kernel_norm_axes =\",\n \"if self.axis == 0: raise ValueError( \\\"You are trying to normalize your batch\",\n \"import Wav2Vec2Processor, TFHubertModel >>> from datasets import load_dataset >>> import soundfile as sf\",\n \"tgt_len, self.head_dim)), (0, 2, 1, 3) ) attn_output = tf.reshape(attn_output, (bsz, tgt_len, embed_dim))\",\n \"or dict in the first positional arguments. This second option is useful when\",\n \"+ str(self.groups) + \\\") cannot be \\\" \\\"more than the number of channels\",\n \"a config file does not load the weights associated with the model, only\",\n \"= tf.reshape(attn_weights, (bsz * self.num_heads, tgt_len, src_len)) attn_probs = self.dropout(attn_weights, training=training) attn_output =\",\n \"during training. \\\"\\\"\\\" self.hubert.feature_extractor.trainable = False @add_start_docstrings_to_model_forward(HUBERT_INPUTS_DOCSTRING) @replace_return_docstrings(output_type=TFCausalLMOutput, config_class=_CONFIG_FOR_DOC) def call( self, input_values:\",\n \"= TFHubertMainLayer(config, name=\\\"hubert\\\") @add_start_docstrings_to_model_forward(HUBERT_INPUTS_DOCSTRING) @replace_return_docstrings(output_type=TFBaseModelOutput, config_class=_CONFIG_FOR_DOC) def call( self, input_values: tf.Tensor, attention_mask: Optional[tf.Tensor]\",\n \"tf.debugging.assert_equal( shape_list(attn_output), [bsz * self.num_heads, tgt_len, self.head_dim], message=f\\\"`attn_output` should be of size {(bsz,\",\n \"False, training: bool = False, ) -> Tuple[tf.Tensor]: attn_residual = hidden_states hidden_states, attn_weights,\",\n \"getattr(self.config, \\\"apply_spec_augment\\\", True): return hidden_states if mask_time_indices is not None: # apply SpecAugment\",\n \"num_samples) return indices # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2._scatter_values_on_batch_indices def _scatter_values_on_batch_indices(values, batch_indices, output_shape): \\\"\\\"\\\" Scatter\",\n \"`tf.Tensor`, `List[tf.Tensor]` ``Dict[str, tf.Tensor]` or `Dict[str, np.ndarray]` and each example must have the\",\n \"processor = Wav2Vec2Processor.from_pretrained(\\\"facebook/hubert-base-960h\\\") >>> model = TFHubertModel.from_pretrained(\\\"facebook/hubert-base-960h\\\") >>> def map_to_array(batch): ... speech, _\",\n \"gamma_constraint: tf.keras.constraints.Constraint = None, **kwargs, ): super().__init__(**kwargs) self.supports_masking = True self.groups = groups\",\n \"dtype=attn_weights.dtype) attn_weights = tf.reshape(attn_weights, (bsz, self.num_heads, tgt_len, src_len)) + attention_mask attn_weights = tf.reshape(attn_weights,\",\n \"all_hidden_states, all_self_attentions] if v is not None) return TFBaseModelOutput( last_hidden_state=hidden_states, hidden_states=all_hidden_states, attentions=all_self_attentions, )\",\n \"encoder_outputs = self.encoder( hidden_states, attention_mask=attention_mask, output_attentions=inputs[\\\"output_attentions\\\"], output_hidden_states=inputs[\\\"output_hidden_states\\\"], return_dict=inputs[\\\"return_dict\\\"], training=inputs[\\\"training\\\"], ) hidden_states = encoder_outputs[0]\",\n \"def build(self, input_shape): self._check_if_input_shape_is_none(input_shape) self._set_number_of_groups_for_instance_norm(input_shape) self._check_size_of_dimensions(input_shape) self._create_input_spec(input_shape) self._add_gamma_weight(input_shape) self._add_beta_weight(input_shape) self.built = True super().build(input_shape)\",\n \"bool = True, **kwargs, ): super().__init__(**kwargs) self.embed_dim = embed_dim self.num_heads = num_heads self.dropout\",\n \"} base_config = super().get_config() return {**base_config, **config} def compute_output_shape(self, input_shape): return input_shape def\",\n \"mode the value will always be set to True. training (`bool`, *optional*, defaults\",\n \"v is None: output[k] = v else: raise ValueError(f\\\"Data of type {type(v)} is\",\n \"def freeze_feature_extractor(self): \\\"\\\"\\\" Calling this function will disable the gradient computation for the\",\n \"input_values (`np.ndarray`, `tf.Tensor`, `List[tf.Tensor]` ``Dict[str, tf.Tensor]` or `Dict[str, np.ndarray]` and each example must\",\n \"1 if not is_instance_norm: outputs = tf.reshape(normalized_inputs, tensor_input_shape) else: outputs = normalized_inputs return\",\n \"= conv_layers def call(self, input_values): hidden_states = tf.expand_dims(input_values, -1) for conv_layer in self.conv_layers:\",\n \"is timesteps attention_mask: optional padding mask of the same size as shape, which\",\n \"several input Tensors associated to the input names given in the docstring: `model({\\\"input_values\\\":\",\n \"__init__(self, config: HubertConfig, **kwargs): super().__init__(**kwargs) self.config = config self.pos_conv_embed = TFHubertPositionalConvEmbedding(config, name=\\\"pos_conv_embed\\\") self.layer_norm\",\n \"= attn_residual + hidden_states hidden_states = hidden_states + self.feed_forward(self.final_layer_norm(hidden_states)) outputs = (hidden_states,) if\",\n \"position_embeddings = self.pos_conv_embed(hidden_states) hidden_states = hidden_states + position_embeddings hidden_states = self.dropout(hidden_states, training=training) for\",\n \"i in range(config.num_feat_extract_layers) ] else: raise ValueError( f\\\"`config.feat_extract_norm` is {config.feat_extract_norm}, but has to\",\n \"tf.keras.layers.Dense(config.vocab_size, name=\\\"lm_head\\\") def freeze_feature_extractor(self): \\\"\\\"\\\" Calling this function will disable the gradient computation\",\n \"_sample_without_replacement(uniform_dist, num_masked_spans) # expand masked indices to masked spans spec_aug_mask_idxs = tf.expand_dims(spec_aug_mask_idxs, -1)\",\n \"tf.range(mask_length)[tf.newaxis, tf.newaxis, :] offsets = tf.tile(offsets, (batch_size, num_masked_spans, 1)) offsets = tf.reshape(offsets, (batch_size,\",\n \"value_states = tf.reshape(value_states, proj_shape) src_len = shape_list(key_states)[1] attn_weights = tf.matmul(query_states, key_states, transpose_b=True) #\",\n \"the library implements for all its model (such as downloading or saving, resizing\",\n \"_scatter_values_on_batch_indices( tf.ones_like(spec_aug_mask_idxs), spec_aug_mask_idxs, spec_aug_mask.shape ) return spec_aug_mask # Copied from transformers.models.bart.modeling_tf_bart._expand_mask def _expand_mask(mask:\",\n \"of each TensorFlow model including the booleans. In case of a list of\",\n \"= tf.convert_to_tensor(output.hidden_states) if self.config.output_hidden_states else None attns = tf.convert_to_tensor(output.attentions) if self.config.output_attentions else None\",\n \"else None attns = tf.convert_to_tensor(output.attentions) if self.config.output_attentions else None return TFCausalLMOutput(logits=output.logits, hidden_states=hs, attentions=attns)\",\n \"inputs[\\\"return_dict\\\"] = inputs[\\\"return_dict\\\"] if inputs[\\\"return_dict\\\"] else self.config.return_dict outputs = self.hubert( input_values=inputs[\\\"input_values\\\"], attention_mask=inputs[\\\"attention_mask\\\"], token_type_ids=inputs[\\\"token_type_ids\\\"],\",\n \"interface for downloading and loading pretrained models. \\\"\\\"\\\" config_class = HubertConfig base_model_prefix =\",\n \"accepted for {parameter_names[0]}.\\\" ) for name in parameter_names: if name not in list(output.keys())\",\n \"{(bsz * self.num_heads, tgt_len, src_len)}, but is {shape_list(attn_weights)}\\\", ) if attention_mask is not\",\n \"SIR I EXIST\\\" >>> # wrap processor as target processor to encode labels\",\n \"proj if is_cross_attention and past_key_value is not None: # reuse k,v, cross_attentions key_states\",\n \"def call(self, hidden_states: tf.Tensor, training: bool = False) -> tf.Tensor: hidden_states = self.layer_norm(hidden_states)\",\n \"will be removed in Transformers v5. \\\" f\\\"Use `{self.__class__.__bases__[0].__name__}` instead.\\\", FutureWarning, ) class\",\n \"with a `language modeling` head on top for Connectionist Temporal Classification (CTC).\\\"\\\"\\\", HUBERT_START_DOCSTRING,\",\n \"tokens that are **not masked**, - 0 for tokens that are **masked**. [What\",\n \"hidden_states=all_hidden_states, attentions=all_self_attentions, ) @keras_serializable class TFHubertMainLayer(tf.keras.layers.Layer): config_class = HubertConfig def __init__(self, config: HubertConfig,\",\n \"return {**base_config, **config} def compute_output_shape(self, input_shape): return input_shape def _reshape_into_groups(self, inputs, input_shape, tensor_input_shape):\",\n \"useful when using [`tf.keras.Model.fit`] method which currently requires having all the tensors in\",\n \"Mask values selected in `[0, 1]`: - 1 for tokens that are **not\",\n \"training and evaluation). \\\"\\\"\\\" @add_start_docstrings( \\\"The bare TFHubert Model transformer outputing raw hidden-states\",\n \"// num_heads if (self.head_dim * num_heads) != self.embed_dim: raise ValueError( f\\\"embed_dim must be\",\n \"docstring: `model({\\\"input_values\\\": input_values, \\\"token_type_ids\\\": token_type_ids})` </Tip> Args: config ([`HubertConfig`]): Model configuration class with\",\n \"= self._shape(self.v_proj(hidden_states), -1, bsz) if self.is_decoder: # if cross_attention save Tuple(tf.Tensor, tf.Tensor) of\",\n \"transformer outputing raw hidden-states without any specific head on top.\\\", HUBERT_START_DOCSTRING, ) class\",\n \"expand masked indices to masked spans spec_aug_mask_idxs = tf.expand_dims(spec_aug_mask_idxs, -1) spec_aug_mask_idxs = tf.tile(spec_aug_mask_idxs,\",\n \"on top.\\\", HUBERT_START_DOCSTRING, ) class TFHubertModel(TFHubertPreTrainedModel): def __init__(self, config: HubertConfig, *inputs, **kwargs): super().__init__(config,\",\n \"all_hidden_states = all_hidden_states + (hidden_states,) if not return_dict: return tuple(v for v in\",\n \"for the generic methods the library implements for all its model (such as\",\n \"Selected in the range `[0, config.max_position_embeddings - 1]`. [What are position IDs?](../glossary#position-ids) head_mask\",\n \"= self.lm_head(hidden_states) if labels is not None: if tf.reduce_max(labels) >= self.config.vocab_size: raise ValueError(f\\\"Label\",\n \"tf.Tensor: \\\"\\\"\\\" Computes random mask spans for a given shape Args: shape: the\",\n \">>> input_values = processor(ds[\\\"speech\\\"][0], return_tensors=\\\"tf\\\").input_values # Batch size 1 >>> logits = model(input_values).logits\",\n \"asserts are not compliant with XLA then they # have to be disabled\",\n \"kernel_initializer=get_initializer(config.initializer_range), bias_initializer=\\\"zeros\\\", name=\\\"output_dense\\\", ) self.output_dropout = tf.keras.layers.Dropout(config.hidden_dropout) def call(self, hidden_states: tf.Tensor, training: bool\",\n \"of \\\" \\\"input tensor should have a defined dimension \\\" \\\"but the layer\",\n \"indices_shape), [1, -1] ) # transform batch_indices to pair_indices pair_indices = tf.transpose(tf.concat([broad_casted_batch_dims, tf.reshape(batch_indices,\",\n \"v for k, v in output.items() if k in [\\\"return_dict\\\", \\\"output_attentions\\\", \\\"output_hidden_states\\\", \\\"use_cache\\\"]\",\n \"into associated vectors than the model's internal embedding lookup matrix. output_attentions (`bool`, *optional*):\",\n \"= tf.sqrt(tf.reduce_sum(tf.square(self.weight_v), axis=self.kernel_norm_axes)) self.weight_g.assign(kernel_norm[:, tf.newaxis, tf.newaxis]) def _normalize_kernel(self): \\\"\\\"\\\"Generate normalized weights.\\\"\\\"\\\" kernel =\",\n \"is accepted for {parameter_names[0]}.\\\" ) for name in parameter_names: if name not in\",\n \"spans in batch num_masked_spans = int(mask_prob * sequence_length / mask_length + tf.random.uniform((1,))) num_masked_spans\",\n \"not None: # compute real output lengths according to convolution formula output_lengths =\",\n \"+ \\\".\\\" ) def _set_number_of_groups_for_instance_norm(self, input_shape): dim = input_shape[self.axis] if self.groups == -1:\",\n \"the masked language modeling loss. Indices should be in `[-100, 0, ..., config.vocab_size]`\",\n \"None, head_mask: Optional[tf.Tensor] = None, inputs_embeds: Optional[tf.Tensor] = None, output_attentions: Optional[tf.Tensor] = None,\",\n \"HubertConfig, *inputs, **kwargs): super().__init__(config, *inputs, **kwargs) self.config = config self.hubert = TFHubertMainLayer(config, name=\\\"hubert\\\")\",\n \"self.gamma_constraint = tf.keras.constraints.get(gamma_constraint) self._check_axis() def build(self, input_shape): self._check_if_input_shape_is_none(input_shape) self._set_number_of_groups_for_instance_norm(input_shape) self._check_size_of_dimensions(input_shape) self._create_input_spec(input_shape) self._add_gamma_weight(input_shape) self._add_beta_weight(input_shape)\",\n \"[1] * len(input_shape) is_instance_norm = (input_shape[self.axis] // self.groups) == 1 if not is_instance_norm:\",\n \"name=\\\"beta\\\", initializer=self.beta_initializer, regularizer=self.beta_regularizer, constraint=self.beta_constraint, ) else: self.beta = None def _create_broadcast_shape(self, input_shape): broadcast_shape\",\n \") self.output_dropout = tf.keras.layers.Dropout(config.hidden_dropout) def call(self, hidden_states: tf.Tensor, training: bool = False) ->\",\n \"class TFHubertEncoderStableLayerNorm(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs): super().__init__(**kwargs) self.config = config self.pos_conv_embed =\",\n \"(`bool`, *optional*): Whether or not to return the attentions tensors of all attention\",\n \"dim = input_shape[self.axis] if self.groups == -1: self.groups = dim def _check_size_of_dimensions(self, input_shape):\",\n \"head_mask: Optional[tf.Tensor] = None, inputs_embeds: Optional[tf.Tensor] = None, output_attentions: Optional[bool] = None, output_hidden_states:\",\n \"+ str(self.axis) + \\\" of \\\" \\\"input tensor should have a defined dimension\",\n \"not load the weights associated with the model, only the configuration. Check out\",\n \") attn_output = tf.reshape(attn_output, (bsz, tgt_len, embed_dim)) attn_output = self.out_proj(attn_output) attn_weights: tf.Tensor =\",\n \"= list(range(1, len(group_shape))) is_instance_norm = (input_shape[self.axis] // self.groups) == 1 if not is_instance_norm:\",\n \"def __init__(self, config, **kwargs): super().__init__(config, **kwargs) warnings.warn( f\\\"The class `{self.__class__.__name__}` has been depreciated\",\n \"+ outputs[1:] return ((loss,) + output) if loss is not None else output\",\n \"Optional[tf.Tensor] = None, head_mask: Optional[tf.Tensor] = None, inputs_embeds: Optional[tf.Tensor] = None, output_attentions: Optional[tf.Tensor]\",\n \"tf.newaxis]) def _normalize_kernel(self): \\\"\\\"\\\"Generate normalized weights.\\\"\\\"\\\" kernel = tf.nn.l2_normalize(self.weight_v, axis=self.kernel_norm_axes) * tf.transpose(self.weight_g) self.kernel\",\n \"output_attentions=output_attentions, training=training, ) hidden_states = layer_outputs[0] if output_attentions: all_self_attentions = all_self_attentions + (layer_outputs[1],)\",\n \"1, name=f\\\"conv_layers.{i+1}\\\") for i in range(config.num_feat_extract_layers - 1) ] elif config.feat_extract_norm == \\\"layer\\\":\",\n \"tf.keras.layers.InputSpec(ndim=len(input_shape), axes={self.axis: dim}) def _add_gamma_weight(self, input_shape): dim = input_shape[self.axis] shape = (dim,) if\",\n \"isinstance(input_values, (dict, BatchEncoding)): if \\\"inputs\\\" in input_values: warnings.warn( \\\"The `inputs` argument is deprecated\",\n \"sf.read(batch[\\\"file\\\"]) ... batch[\\\"speech\\\"] = speech ... return batch >>> ds = load_dataset(\\\"hf-internal-testing/librispeech_asr_dummy\\\", \\\"clean\\\",\",\n \"used in eager mode, in graph mode the value will always be set\",\n \"computing the masked language modeling loss. Indices should be in `[-100, 0, ...,\",\n \"else: # `args` in this case is always the first parameter, then `input_values`\",\n \"def _conv_out_length(input_length, kernel_size, stride): # 1D convolutional layer output length formula taken #\",\n \"the configuration. Check out the [`~PreTrainedModel.from_pretrained`] method to load the model weights. \\\"\\\"\\\"\",\n \") def serving_output(self, output: TFCausalLMOutput) -> TFCausalLMOutput: hs = tf.convert_to_tensor(output.hidden_states) if self.config.output_hidden_states else\",\n \"+ \\\" of \\\" \\\"input tensor should have a defined dimension \\\" \\\"but\",\n \"_check_axis(self): if self.axis == 0: raise ValueError( \\\"You are trying to normalize your\",\n \"indices to mask spec_aug_mask = _scatter_values_on_batch_indices( tf.ones_like(spec_aug_mask_idxs), spec_aug_mask_idxs, spec_aug_mask.shape ) return spec_aug_mask #\",\n \"https://huggingface.co/models?filter=hubert ] LARGE_NEGATIVE = -1e8 # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.input_values_processing def input_values_processing(func, config, input_values,\",\n \"ValueError( f\\\"Data of type {type(input)} is not allowed only {allowed_types} is accepted for\",\n \"2.0 documentation for all matter related to general usage and behavior. <Tip> TF\",\n \"tf.executing_eagerly(): tf.debugging.assert_equal( shape_list(attn_weights), [bsz * self.num_heads, tgt_len, src_len], message=f\\\"Attention weights should be of\",\n \"all_hidden_states = all_hidden_states + (hidden_states,) # add LayerDrop (see https://arxiv.org/abs/1909.11556 for description) dropout_probability\",\n \"hidden_states = self.activation(hidden_states) return hidden_states # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2LayerNormConvLayer with Wav2Vec2->Hubert class TFHubertLayerNormConvLayer(tf.keras.layers.Layer):\",\n \"`[-100, 0, ..., config.vocab_size]` (see `input_values` docstring) Tokens with indices set to `-100`\",\n \"Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2EncoderLayerStableLayerNorm with Wav2Vec2->Hubert class TFHubertEncoderLayerStableLayerNorm(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs): super().__init__(**kwargs)\",\n \"encoder_outputs[1:] return TFBaseModelOutput( last_hidden_state=hidden_states, hidden_states=encoder_outputs.hidden_states, attentions=encoder_outputs.attentions, ) class TFHubertPreTrainedModel(TFPreTrainedModel): \\\"\\\"\\\" An abstract class\",\n \"IDs?](../glossary#token-type-ids) position_ids (`np.ndarray` or `tf.Tensor` of shape `({0})`, *optional*): Indices of positions of\",\n \"mask spec_aug_mask_idxs = _sample_without_replacement(uniform_dist, num_masked_spans) # expand masked indices to masked spans spec_aug_mask_idxs\",\n \"training=training, ) hidden_states = layer_outputs[0] if output_attentions: all_self_attentions = all_self_attentions + (layer_outputs[1],) #\",\n \"between training and evaluation). \\\"\\\"\\\" @add_start_docstrings( \\\"The bare TFHubert Model transformer outputing raw\",\n \"not None: if tf.reduce_max(labels) >= self.config.vocab_size: raise ValueError(f\\\"Label values must be <= vocab_size:\",\n \"{type(input)} is not allowed only {allowed_types} is accepted for {parameter_names[i]}.\\\" ) elif isinstance(input_values,\",\n \"number of channels (\\\" + str(dim) + \\\").\\\" ) def _check_axis(self): if self.axis\",\n \"k, v in output.items() if k in [\\\"return_dict\\\", \\\"output_attentions\\\", \\\"output_hidden_states\\\", \\\"use_cache\\\"] } output.update(booleans_processing(config=config,\",\n \"name=\\\"projection\\\", ) self.dropout = tf.keras.layers.Dropout(rate=config.feat_proj_dropout) def call(self, hidden_states: tf.Tensor, training: bool = False)\",\n \"hidden_states = layer_outputs[0] if output_attentions: all_self_attentions = all_self_attentions + (layer_outputs[1],) # Add last\",\n \"encoder bi-directional self-attention `past_key_value` is always `None` past_key_value = (key_states, value_states) proj_shape =\",\n \"tf.keras.layers.Dense( units=config.hidden_size, kernel_initializer=get_initializer(config.initializer_range), bias_initializer=\\\"zeros\\\", name=\\\"output_dense\\\", ) self.output_dropout = tf.keras.layers.Dropout(config.hidden_dropout) def call(self, hidden_states: tf.Tensor,\",\n \"... labels = processor(transcription, return_tensors=\\\"tf\\\").input_values >>> loss = model(input_values, labels=labels).loss ```\\\"\\\"\\\" inputs =\",\n \"of the mask min_masks: minimum number of masked spans Adapted from [fairseq's data_utils.py](https://github.com/pytorch/fairseq/blob/e0788f7007a8473a76db573985031f3c94201e79/fairseq/data/data_utils.py#L376).\",\n \"_scatter_values_on_batch_indices(values, batch_indices, output_shape): \\\"\\\"\\\" Scatter function as in PyTorch with indices in format\",\n \"save Tuple(tf.Tensor, tf.Tensor) of all cross attention key/value_states. # Further calls to cross_attention\",\n \"freeze_feature_encoder(self): \\\"\\\"\\\" Calling this function will disable the gradient computation for the feature\",\n \"hidden_states = self.layer_norm(hidden_states) if output_hidden_states: all_hidden_states = all_hidden_states + (hidden_states,) if not return_dict:\",\n \"= r\\\"\\\"\\\" This model inherits from [`TFPreTrainedModel`]. Check the superclass documentation for the\",\n \"__init__(self, config: HubertConfig, *inputs, **kwargs): super().__init__(config, *inputs, **kwargs) self.hubert = TFHubertMainLayer(config, name=\\\"hubert\\\") self.dropout\",\n \"# You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0\",\n \"input with shape \\\" + str(input_shape) + \\\".\\\" ) def _set_number_of_groups_for_instance_norm(self, input_shape): dim\",\n \"tensorflow as tf from ...activations_tf import get_tf_activation from ...modeling_tf_outputs import TFBaseModelOutput, TFCausalLMOutput from\",\n \"elements. however due to overlaps, the actual number will be smaller (unless no_overlap\",\n \"from .configuration_hubert import HubertConfig logger = logging.get_logger(__name__) _CONFIG_FOR_DOC = \\\"HubertConfig\\\" TF_HUBERT_PRETRAINED_MODEL_ARCHIVE_LIST = [\",\n \"Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.input_values_processing def input_values_processing(func, config, input_values, **kwargs): \\\"\\\"\\\" Process the input of\",\n \") class TFHubertPreTrainedModel(TFPreTrainedModel): \\\"\\\"\\\" An abstract class to handle weights initialization and a\",\n \"(bsz * self.num_heads, tgt_len, src_len)) attn_weights = tf.nn.softmax(attn_weights, axis=-1) if layer_head_mask is not\",\n \"name=\\\"feature_projection\\\") if config.do_stable_layer_norm: self.encoder = TFHubertEncoderStableLayerNorm(config, name=\\\"encoder\\\") else: self.encoder = TFHubertEncoder(config, name=\\\"encoder\\\") def\",\n \"hidden_states: tf.Tensor, key_value_states: Optional[tf.Tensor] = None, past_key_value: Optional[Tuple[Tuple[tf.Tensor]]] = None, attention_mask: Optional[tf.Tensor] =\",\n \"hidden_states = self.intermediate_dense(hidden_states) hidden_states = self.intermediate_act_fn(hidden_states) hidden_states = self.intermediate_dropout(hidden_states, training=training) hidden_states = self.output_dense(hidden_states)\",\n \"by num_heads (got `embed_dim`: {self.embed_dim}\\\" f\\\" and `num_heads`: {num_heads}).\\\" ) self.scaling = self.head_dim**-0.5\",\n \"False, ) -> Tuple[tf.Tensor]: attn_residual = hidden_states hidden_states, attn_weights, _ = self.attention( hidden_states,\",\n \"TFHubertPositionalConvEmbedding(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs: Any) -> None: super().__init__(**kwargs) self.conv = TFHubertWeightNormConv1D(\",\n \"HubertConfig def __init__(self, config: HubertConfig, **kwargs): super().__init__(**kwargs) self.config = config self.feature_extractor = TFHubertFeatureEncoder(config,\",\n \"the .name property so we check for a real Tensor if type(input) ==\",\n \"return output # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2NoLayerNormConvLayer with Wav2Vec2->Hubert class TFHubertNoLayerNormConvLayer(tf.keras.layers.Layer): def __init__(self, config:\",\n \"shape_list(mask)[1] tgt_len = tgt_len if tgt_len is not None else src_len one_cst =\",\n \"gamma_initializer: tf.keras.initializers.Initializer = \\\"ones\\\", beta_regularizer: tf.keras.regularizers.Regularizer = None, gamma_regularizer: tf.keras.regularizers.Regularizer = None, beta_constraint:\",\n \"- 1))) # get random indices to mask spec_aug_mask_idxs = _sample_without_replacement(uniform_dist, num_masked_spans) #\",\n \"= hidden_states + position_embeddings hidden_states = self.layer_norm(hidden_states) hidden_states = self.dropout(hidden_states, training=training) for i,\",\n \"tf.newaxis], tf.bool), self.masked_spec_embed[tf.newaxis, tf.newaxis, :], hidden_states, ) # apply SpecAugment along feature axis\",\n \"+= self.explicit_padding * 2 super().build(input_shape) self.kernel = tf.Variable(tf.transpose(self.kernel), name=\\\"weight_v\\\", trainable=True) self.weight_v = self.kernel\",\n \"function: `model(inputs)`. If you choose this second option, there are three possibilities you\",\n \"tf.reshape(inputs, group_shape) return reshaped_inputs, group_shape else: return inputs, group_shape def _apply_normalization(self, reshaped_inputs, input_shape):\",\n \"tf.debugging.assert_equal( shape_list(attn_weights), [bsz * self.num_heads, tgt_len, src_len], message=f\\\"Attention weights should be of size\",\n \"hidden_states = self.layer_norm(hidden_states) hidden_states, attn_weights, _ = self.attention( hidden_states, attention_mask=attention_mask, training=training ) hidden_states\",\n \"tgt_len = tgt_len if tgt_len is not None else src_len one_cst = tf.constant(1.0)\",\n \"\\\".\\\" ) def _set_number_of_groups_for_instance_norm(self, input_shape): dim = input_shape[self.axis] if self.groups == -1: self.groups\",\n \"shape_list(batch_indices) # broadcast batch dim to indices_shape broad_casted_batch_dims = tf.reshape( tf.broadcast_to(tf.expand_dims(tf.range(indices_shape[0]), axis=-1), indices_shape),\",\n \"_add_beta_weight(self, input_shape): dim = input_shape[self.axis] shape = (dim,) if self.center: self.beta = self.add_weight(\",\n \"str(self.axis) + \\\" of \\\" \\\"input tensor should have a defined dimension \\\"\",\n \"= False, training: bool = False, ) -> Tuple[tf.Tensor]: attn_residual = hidden_states hidden_states,\",\n \"is useful if you want more control over how to convert `input_values` indices\",\n \"= TFHubertPositionalConvEmbedding(config, name=\\\"pos_conv_embed\\\") self.layer_norm = tf.keras.layers.LayerNormalization(epsilon=config.layer_norm_eps, name=\\\"layer_norm\\\") self.dropout = tf.keras.layers.Dropout(config.hidden_dropout) self.layer = [\",\n \"be updated during training. \\\"\\\"\\\" self.hubert.feature_extractor.trainable = False @add_start_docstrings_to_model_forward(HUBERT_INPUTS_DOCSTRING) @replace_return_docstrings(output_type=TFCausalLMOutput, config_class=_CONFIG_FOR_DOC) def call(\",\n \"`language modeling` head on top for Connectionist Temporal Classification (CTC).\\\"\\\"\\\", HUBERT_START_DOCSTRING, ) class\",\n \"KIND, either express or implied. # See the License for the specific language\",\n \"first argument of the model call function: `model(inputs)`. If you choose this second\",\n \"TensorFlow model. config ([`PretrainedConfig`]): The config of the running model. **kwargs: The inputs\",\n \"-1) spec_aug_mask_idxs = tf.tile(spec_aug_mask_idxs, (1, 1, mask_length)) spec_aug_mask_idxs = tf.reshape(spec_aug_mask_idxs, (batch_size, num_masked_spans *\",\n \"self.epsilon, \\\"center\\\": self.center, \\\"scale\\\": self.scale, \\\"beta_initializer\\\": tf.keras.initializers.serialize(self.beta_initializer), \\\"gamma_initializer\\\": tf.keras.initializers.serialize(self.gamma_initializer), \\\"beta_regularizer\\\": tf.keras.regularizers.serialize(self.beta_regularizer), \\\"gamma_regularizer\\\": tf.keras.regularizers.serialize(self.gamma_regularizer),\",\n \"self.out_proj(attn_output) attn_weights: tf.Tensor = tf.reshape(attn_weights, (bsz, self.num_heads, tgt_len, src_len)) return attn_output, attn_weights, past_key_value\",\n \"tf.Tensor: hidden_states = self.conv(hidden_states) hidden_states = self.layer_norm(hidden_states) hidden_states = self.activation(hidden_states) return hidden_states #\",\n \"- 1 indicates the head is **not masked**, - 0 indicates the head\",\n \"From tensorflow-addons https://www.tensorflow.org/addons/api_docs/python/tfa/layers/GroupNormalization \\\"\\\"\\\" def __init__( self, groups: int = 32, axis: int\",\n \"mask_length)) offsets = tf.range(mask_length)[tf.newaxis, tf.newaxis, :] offsets = tf.tile(offsets, (batch_size, num_masked_spans, 1)) offsets\",\n \"output_hidden_states: Optional[bool] = None, return_dict: Optional[bool] = None, training: bool = False, )\",\n \"tf.stack(group_shape) reshaped_inputs = tf.reshape(inputs, group_shape) return reshaped_inputs, group_shape else: return inputs, group_shape def\",\n \"-> Tuple[tf.Tensor]: attn_residual = hidden_states hidden_states = self.layer_norm(hidden_states) hidden_states, attn_weights, _ = self.attention(\",\n \"normalize your batch axis. Do you want to \\\" \\\"use tf.layer.batch_normalization instead\\\" )\",\n \"# Conv1D output shapes are checked at build time since TF 2.7, so\",\n \"in other modes than eager. if tf.executing_eagerly(): tf.debugging.assert_equal( shape_list(attn_weights), [bsz * self.num_heads, tgt_len,\",\n \"will not be guaranteed during the training. Args: func (`callable`): The callable function\",\n \"if inputs[\\\"attention_mask\\\"] is not None else tf.ones_like(inputs[\\\"input_values\\\"], dtype=tf.float32) ) input_lengths = self.hubert._get_feat_extract_output_lengths(tf.reduce_sum(attention_mask, axis=-1))\",\n \"layers. \\\"\\\"\\\" signature = dict(inspect.signature(func).parameters) signature.pop(\\\"kwargs\\\", None) signature.pop(\\\"self\\\", None) parameter_names = list(signature.keys()) output\",\n \"decoder key/value_states to current projected key/value_states (third \\\"elif\\\" case) # if encoder bi-directional\",\n \") inputs[\\\"output_hidden_states\\\"] = ( inputs[\\\"output_hidden_states\\\"] if inputs[\\\"output_hidden_states\\\"] else self.config.output_hidden_states ) inputs[\\\"output_attentions\\\"] = (\",\n \"past_key_value: Optional[Tuple[Tuple[tf.Tensor]]] = None, attention_mask: Optional[tf.Tensor] = None, layer_head_mask: Optional[tf.Tensor] = None, training:\",\n \"not None: # reuse k,v, cross_attentions key_states = past_key_value[0] value_states = past_key_value[1] elif\",\n \"self.axis, \\\"epsilon\\\": self.epsilon, \\\"center\\\": self.center, \\\"scale\\\": self.scale, \\\"beta_initializer\\\": tf.keras.initializers.serialize(self.beta_initializer), \\\"gamma_initializer\\\": tf.keras.initializers.serialize(self.gamma_initializer), \\\"beta_regularizer\\\": tf.keras.regularizers.serialize(self.beta_regularizer),\",\n \"self.groups) == 1 if not is_instance_norm: axis = -2 if self.axis == -1\",\n \"tf.reshape(layer_head_mask, (1, -1, 1, 1)) * tf.reshape( attn_weights, (bsz, self.num_heads, tgt_len, src_len) )\",\n \"name=\\\"encoder\\\") else: self.encoder = TFHubertEncoder(config, name=\\\"encoder\\\") def build(self, input_shape: tf.TensorShape): self.masked_spec_embed = self.add_weight(\",\n \"inputs[\\\"return_dict\\\"] if inputs[\\\"return_dict\\\"] else self.config.return_dict outputs = self.hubert( input_values=inputs[\\\"input_values\\\"], attention_mask=inputs[\\\"attention_mask\\\"], token_type_ids=inputs[\\\"token_type_ids\\\"], position_ids=inputs[\\\"position_ids\\\"], head_mask=inputs[\\\"head_mask\\\"],\",\n \"layer_head_mask is not None: # The tf.debugging asserts are not compliant with XLA\",\n \"in output: del output[\\\"kwargs\\\"] boolean_dict = { k: v for k, v in\",\n \"num_masked_spans, 1)) offsets = tf.reshape(offsets, (batch_size, num_masked_spans * mask_length)) spec_aug_mask_idxs = spec_aug_mask_idxs +\",\n \"bi-directional self-attention `past_key_value` is always `None` past_key_value = (key_states, value_states) proj_shape = (bsz\",\n \"src_len = shape_list(key_states)[1] attn_weights = tf.matmul(query_states, key_states, transpose_b=True) # The tf.debugging asserts are\",\n \"embed_dim=config.hidden_size, num_heads=config.num_attention_heads, dropout=config.attention_dropout, is_decoder=False, name=\\\"attention\\\", ) self.dropout = tf.keras.layers.Dropout(config.hidden_dropout) self.layer_norm = tf.keras.layers.LayerNormalization(epsilon=config.layer_norm_eps, name=\\\"layer_norm\\\")\",\n \"-1, bsz) value_states = self._shape(self.v_proj(key_value_states), -1, bsz) elif past_key_value is not None: #\",\n \"to mask approximately this percentage of all elements. however due to overlaps, the\",\n \"= tf.keras.layers.LayerNormalization(name=\\\"layer_norm\\\", epsilon=config.layer_norm_eps) self.activation = get_tf_activation(config.feat_extract_activation) def call(self, hidden_states: tf.Tensor) -> tf.Tensor: hidden_states\",\n \"\\\"\\\"\\\" Returns: Example: ```python >>> from transformers import Wav2Vec2Processor, TFHubertModel >>> from datasets\",\n \"axis=-1) loss = tf.nn.ctc_loss( logits=logits, labels=labels, logit_length=input_lengths, label_length=target_lengths, blank_index=self.config.pad_token_id, logits_time_major=False, ) if self.config.ctc_loss_reduction\",\n \"tf.nn.ctc_loss( logits=logits, labels=labels, logit_length=input_lengths, label_length=target_lengths, blank_index=self.config.pad_token_id, logits_time_major=False, ) if self.config.ctc_loss_reduction == \\\"sum\\\": loss\",\n \"+ attention_mask attn_weights = tf.reshape(attn_weights, (bsz * self.num_heads, tgt_len, src_len)) attn_weights = tf.nn.softmax(attn_weights,\",\n \"= self._get_reshaped_weights(input_shape) normalized_inputs = tf.nn.batch_normalization( reshaped_inputs, mean=mean, variance=variance, scale=gamma, offset=beta, variance_epsilon=self.epsilon, ) return\",\n \"size {(self.num_heads)}, but is {shape_list(layer_head_mask)}\\\", ) attn_weights = tf.reshape(layer_head_mask, (1, -1, 1, 1))\",\n \"with XLA then they # have to be disabled in other modes than\",\n \"else None attns = tf.convert_to_tensor(output.attentions) if self.config.output_attentions else None return TFBaseModelOutput(last_hidden_state=output.last_hidden_state, hidden_states=hs, attentions=attns)\",\n \"== \\\"mean\\\": loss = tf.reduce_mean(loss) else: loss = None if not inputs[\\\"return_dict\\\"]: output\",\n \"key_states = self._shape(self.k_proj(hidden_states), -1, bsz) value_states = self._shape(self.v_proj(hidden_states), -1, bsz) key_states = tf.concat([past_key_value[0],\",\n \"== tf.Tensor: tensor_name = output[\\\"args\\\"].name.split(\\\":\\\")[0] output[tensor_name] = output[\\\"args\\\"] else: # `args` in this\",\n \"# limitations under the License. \\\"\\\"\\\" TensorFlow Hubert model.\\\"\\\"\\\" import inspect import warnings\",\n \"masked spans in batch num_masked_spans = int(mask_prob * sequence_length / mask_length + tf.random.uniform((1,)))\",\n \"TFHubertLayerNormConvLayer(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, layer_id: int = 0, **kwargs: Any) -> None:\",\n \"indices <= sequence_length if num_masked_spans * mask_length > sequence_length: num_masked_spans = sequence_length //\",\n \"<gh_stars>1-10 # coding=utf-8 # Copyright 2021 The Fairseq Authors and the HuggingFace Inc.\",\n \"config=self.config, input_values=input_values, attention_mask=attention_mask, token_type_ids=token_type_ids, position_ids=position_ids, head_mask=head_mask, inputs_embeds=inputs_embeds, output_attentions=output_attentions, output_hidden_states=output_hidden_states, return_dict=return_dict, training=training, kwargs_call=kwargs, )\",\n \"self._shape(self.v_proj(hidden_states), -1, bsz) if self.is_decoder: # if cross_attention save Tuple(tf.Tensor, tf.Tensor) of all\",\n \":], hidden_states, ) # apply SpecAugment along feature axis if self.config.mask_feature_prob > 0:\",\n \"if output_hidden_states: all_hidden_states = all_hidden_states + (hidden_states,) # add LayerDrop (see https://arxiv.org/abs/1909.11556 for\",\n \"= v else: raise ValueError(f\\\"Data of type {type(v)} is not allowed only {allowed_types}\",\n \"_ = self.attention( hidden_states, attention_mask=attention_mask, training=training ) hidden_states = self.dropout(hidden_states, training=training) hidden_states =\",\n \"list(output.keys()) and name != \\\"args\\\": output[name] = kwargs.pop(name, signature[name].default) # When creating a\",\n \"else: `model(inputs_ids)` - a list of varying length with one or several input\",\n \"size of the mask min_masks: minimum number of masked spans Adapted from [fairseq's\",\n \"you can use to gather all the input Tensors in the first positional\",\n \"tf.Tensor: hidden_states = self.conv(hidden_states) hidden_states = self.activation(hidden_states) return hidden_states # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2LayerNormConvLayer\",\n \"a single Tensor with `input_values` only and nothing else: `model(inputs_ids)` - a list\",\n \"...activations_tf import get_tf_activation from ...modeling_tf_outputs import TFBaseModelOutput, TFCausalLMOutput from ...modeling_tf_utils import TFPreTrainedModel, booleans_processing,\",\n \"import BatchEncoding from ...utils import ( ModelOutput, add_start_docstrings, add_start_docstrings_to_model_forward, logging, replace_return_docstrings, ) from\",\n \"removed in Transformers v5.\\\" \\\"Please use the equivalent `freeze_feature_encoder` method instead.\\\", FutureWarning, )\",\n \"self.axis - 1 else: axis = -1 if self.axis == -1 else self.axis\",\n \"outputing raw hidden-states without any specific head on top.\\\", HUBERT_START_DOCSTRING, ) class TFHubertModel(TFHubertPreTrainedModel):\",\n \"FutureWarning, ) class TFHubertFeatureProjection(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs): super().__init__(**kwargs) self.layer_norm = tf.keras.layers.LayerNormalization(epsilon=config.layer_norm_eps,\",\n \"that its parameter will not be updated during training. \\\"\\\"\\\" self.hubert.feature_extractor.trainable = False\",\n \"sequence_length - (mask_length - 1))) # get random indices to mask spec_aug_mask_idxs =\",\n \"self.config.conv_stride): input_lengths = _conv_out_length(input_lengths, kernel_size, stride) return input_lengths def _mask_hidden_states(self, hidden_states: tf.Tensor, mask_time_indices:\",\n \"where first element is batch size and 2nd is timesteps attention_mask: optional padding\",\n \"self.num_heads, tgt_len, src_len)) + attention_mask attn_weights = tf.reshape(attn_weights, (bsz * self.num_heads, tgt_len, src_len))\",\n \"return (hidden_states,) + encoder_outputs[1:] return TFBaseModelOutput( last_hidden_state=hidden_states, hidden_states=encoder_outputs.hidden_states, attentions=encoder_outputs.attentions, ) class TFHubertPreTrainedModel(TFPreTrainedModel): \\\"\\\"\\\"\",\n \"of shape `({0}, hidden_size)`, *optional*): Optionally, instead of passing `input_values` you can choose\",\n \"a list of symbolic inputs, each input has to be named accordingly to\",\n \"(bsz * self.num_heads, -1, self.head_dim) query_states = tf.reshape(self._shape(query_states, tgt_len, bsz), proj_shape) key_states =\",\n \"scale=gamma, offset=beta, variance_epsilon=self.epsilon, ) return normalized_inputs def _get_reshaped_weights(self, input_shape): broadcast_shape = self._create_broadcast_shape(input_shape) gamma\",\n \"\\\" + str(self.axis) + \\\" of \\\" \\\"input tensor should have a defined\",\n \"input_shape[self.axis] self.input_spec = tf.keras.layers.InputSpec(ndim=len(input_shape), axes={self.axis: dim}) def _add_gamma_weight(self, input_shape): dim = input_shape[self.axis] shape\",\n \"= past_key_value[0] value_states = past_key_value[1] elif is_cross_attention: # cross_attentions key_states = self._shape(self.k_proj(key_value_states), -1,\",\n \"not None) return TFBaseModelOutput( last_hidden_state=hidden_states, hidden_states=all_hidden_states, attentions=all_self_attentions, ) # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2EncoderStableLayerNorm with\",\n \"`name:id` then we check only the # `name` part tensor_name = input.name.split(\\\":\\\")[0] if\",\n \"self.layer_norm = tf.keras.layers.LayerNormalization(epsilon=config.layer_norm_eps, name=\\\"layer_norm\\\") self.projection = tf.keras.layers.Dense( units=config.hidden_size, kernel_initializer=get_initializer(config.initializer_range), bias_initializer=\\\"zeros\\\", name=\\\"projection\\\", ) self.dropout\",\n \"normalized weights.\\\"\\\"\\\" kernel = tf.nn.l2_normalize(self.weight_v, axis=self.kernel_norm_axes) * tf.transpose(self.weight_g) self.kernel = tf.transpose(kernel) def build(self,\",\n \"-1, bsz) value_states = self._shape(self.v_proj(hidden_states), -1, bsz) key_states = tf.concat([past_key_value[0], key_states], axis=2) value_states\",\n \"v5. \\\" f\\\"Use `{self.__class__.__bases__[0].__name__}` instead.\\\", FutureWarning, ) class TFHubertFeatureProjection(tf.keras.layers.Layer): def __init__(self, config: HubertConfig,\",\n \"def __init__(self, config: HubertConfig, **kwargs): super().__init__(**kwargs) self.config = config self.feature_extractor = TFHubertFeatureEncoder(config, name=\\\"feature_extractor\\\")\",\n \"set masking to False if not getattr(self.config, \\\"apply_spec_augment\\\", True): return hidden_states if mask_time_indices\",\n \"method `freeze_feature_extractor` is deprecated and will be removed in Transformers v5.\\\" \\\"Please use\",\n \"1]`: - 0 corresponds to a *sentence A* token, - 1 corresponds to\",\n \"tensor_name = input.name.split(\\\":\\\")[0] if tensor_name in parameter_names: output[tensor_name] = input else: output[parameter_names[i]] =\",\n \"tf.cast(inputs[\\\"input_values\\\"], tf.float32), training=inputs[\\\"training\\\"] ) if inputs[\\\"attention_mask\\\"] is not None: # compute real output\",\n \"dim to indices_shape broad_casted_batch_dims = tf.reshape( tf.broadcast_to(tf.expand_dims(tf.range(indices_shape[0]), axis=-1), indices_shape), [1, -1] ) #\",\n \"self.feature_projection = TFHubertFeatureProjection(config, name=\\\"feature_projection\\\") if config.do_stable_layer_norm: self.encoder = TFHubertEncoderStableLayerNorm(config, name=\\\"encoder\\\") else: self.encoder =\",\n \"with one or several input Tensors IN THE ORDER given in the docstring:\",\n \"True): return hidden_states if mask_time_indices is not None: # apply SpecAugment along time\",\n \"token type IDs?](../glossary#token-type-ids) position_ids (`np.ndarray` or `tf.Tensor` of shape `({0})`, *optional*): Indices of\",\n \"None: output[parameter_names[i]] = input else: raise ValueError( f\\\"Data of type {type(input)} is not\",\n \"are selected in `[0, 1]`: - 0 corresponds to a *sentence A* token,\",\n \"self.num_heads = num_heads self.dropout = tf.keras.layers.Dropout(dropout) self.head_dim = embed_dim // num_heads if (self.head_dim\",\n \"labels in `[0, ..., config.vocab_size]` Returns: Example: ```python >>> import tensorflow as tf\",\n \"team. All rights reserved. # # Licensed under the Apache License, Version 2.0\",\n \"by applicable law or agreed to in writing, software # distributed under the\",\n \"of shape `({0})`, *optional*): Indices of positions of each input sequence tokens in\",\n \"output_attentions=output_attentions, output_hidden_states=output_hidden_states, return_dict=return_dict, training=training, ) outputs = self.hubert( input_values=inputs[\\\"input_values\\\"], attention_mask=inputs[\\\"attention_mask\\\"], token_type_ids=inputs[\\\"token_type_ids\\\"], position_ids=inputs[\\\"position_ids\\\"], head_mask=inputs[\\\"head_mask\\\"],\",\n \"mask_length # SpecAugment mask to fill spec_aug_mask = tf.zeros((batch_size, sequence_length), dtype=tf.int32) # uniform\",\n \"is not None and type(output[\\\"args\\\"]) == tf.Tensor: tensor_name = output[\\\"args\\\"].name.split(\\\":\\\")[0] output[tensor_name] = output[\\\"args\\\"]\",\n \"pad_token), tf.float32), } return dummy_inputs def __init__(self, config, *inputs, **kwargs): super().__init__(config, *inputs, **kwargs)\",\n \"[-1]), output_shape) # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2._compute_mask_indices def _compute_mask_indices( shape: Tuple[int, int], mask_prob: float,\",\n \") else: self.beta = None def _create_broadcast_shape(self, input_shape): broadcast_shape = [1] * len(input_shape)\",\n \"input_values=input_values, attention_mask=attention_mask, token_type_ids=token_type_ids, position_ids=position_ids, head_mask=head_mask, inputs_embeds=inputs_embeds, output_attentions=output_attentions, output_hidden_states=output_hidden_states, return_dict=return_dict, training=training, ) outputs =\",\n \"\\\"\\\"\\\" Computes random mask spans for a given shape Args: shape: the the\",\n \"**kwargs): super().__init__(**kwargs) self.num_pad_remove = 1 if num_conv_pos_embeddings % 2 == 0 else 0\",\n \"to True. training (`bool`, *optional*, defaults to `False``): Whether or not to use\",\n \"if \\\"decoder_cached_states\\\" in input_values: warnings.warn( \\\"The `decoder_cached_states` argument is deprecated and will be\",\n \"self.epsilon = epsilon self.center = center self.scale = scale self.beta_initializer = tf.keras.initializers.get(beta_initializer) self.gamma_initializer\",\n \"not None else src_len one_cst = tf.constant(1.0) mask = tf.cast(mask, dtype=one_cst.dtype) expanded_mask =\",\n \"position_embeddings hidden_states = self.dropout(hidden_states, training=training) for i, layer_module in enumerate(self.layer): if output_hidden_states: all_hidden_states\",\n \"tgt_len, 1)) return (one_cst - expanded_mask) * LARGE_NEGATIVE # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2GroupNorm with\",\n \"be used instead. output_hidden_states (`bool`, *optional*): Whether or not to return the hidden\",\n \"along time axis mask_time_indices = _compute_mask_indices( (batch_size, sequence_length), mask_prob=self.config.mask_time_prob, mask_length=self.config.mask_time_length, min_masks=2, ) hidden_states\",\n \"Union import numpy as np import tensorflow as tf from ...activations_tf import get_tf_activation\",\n \"given in the docstring: `model([input_values, attention_mask])` or `model([input_values, attention_mask, token_type_ids])` - a dictionary\",\n \"LayerDrop (see https://arxiv.org/abs/1909.11556 for description) dropout_probability = np.random.uniform(0, 1) if training and (dropout_probability\",\n \"matrix. output_attentions (`bool`, *optional*): Whether or not to return the attentions tensors of\",\n \"SpecAugment mask to fill spec_aug_mask = tf.zeros((batch_size, sequence_length), dtype=tf.int32) # uniform distribution to\",\n \"not None) return TFBaseModelOutput( last_hidden_state=hidden_states, hidden_states=all_hidden_states, attentions=all_self_attentions, ) @keras_serializable class TFHubertMainLayer(tf.keras.layers.Layer): config_class =\",\n \"(key_states, value_states) proj_shape = (bsz * self.num_heads, -1, self.head_dim) query_states = tf.reshape(self._shape(query_states, tgt_len,\",\n \"may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # #\",\n \"tf.executing_eagerly(): tf.debugging.assert_equal( shape_list(attention_mask), [bsz, 1, tgt_len, src_len], message=f\\\"Attention mask should be of size\",\n \"names have always the pattern `name:id` then we check only the # `name`\",\n \"over how to convert `input_values` indices into associated vectors than the model's internal\",\n \"previous decoder key/value_states to current projected key/value_states (third \\\"elif\\\" case) # if encoder\",\n \"hidden_states: tf.Tensor, attention_mask: Optional[tf.Tensor] = None, output_attentions: Optional[bool] = False, output_hidden_states: Optional[bool] =\",\n \"a list, tuple or dict in the first positional arguments. This second option\",\n \"= tf.concat([past_key_value[1], value_states], axis=2) else: # self_attention key_states = self._shape(self.k_proj(hidden_states), -1, bsz) value_states\",\n \"transformers import Wav2Vec2Processor, TFHubertForCTC >>> from datasets import load_dataset >>> import soundfile as\",\n \"if mask_length < 1: raise ValueError(\\\"`mask_length` has to be bigger than 0.\\\") if\",\n \"= input_values.pop(\\\"inputs\\\") if \\\"decoder_cached_states\\\" in input_values: warnings.warn( \\\"The `decoder_cached_states` argument is deprecated and\",\n \"None, output_attentions: Optional[bool] = False, training: bool = False, ) -> Tuple[tf.Tensor]: attn_residual\",\n \"Wav2Vec2->Hubert class TFHubertEncoderStableLayerNorm(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs): super().__init__(**kwargs) self.config = config self.pos_conv_embed\",\n \"be disabled in other modes than eager. if tf.executing_eagerly(): tf.debugging.assert_equal( shape_list(attn_weights), [bsz *\",\n \"// self.groups) == 1 if not is_instance_norm: group_shape[self.axis] = input_shape[self.axis] // self.groups group_shape.insert(self.axis,\",\n \"to be disabled in other modes than eager. if tf.executing_eagerly(): tf.debugging.assert_equal( shape_list(layer_head_mask), [self.num_heads],\",\n \"// self.groups) == 1 if not is_instance_norm: broadcast_shape[self.axis] = input_shape[self.axis] // self.groups broadcast_shape.insert(self.axis,\",\n \"if (self.head_dim * num_heads) != self.embed_dim: raise ValueError( f\\\"embed_dim must be divisible by\",\n \"-> Union[TFBaseModelOutput, Tuple[tf.Tensor]]: \\\"\\\"\\\" Returns: Example: ```python >>> from transformers import Wav2Vec2Processor, TFHubertModel\",\n \"parameter_names: logger.warning( f\\\"The parameter {k} does not belongs to the parameter list {parameter_names}\",\n \"token to be chosen as start of the span to be masked. this\",\n \"the layer continue layer_outputs = layer_module( hidden_states=hidden_states, attention_mask=attention_mask, output_attentions=output_attentions, training=training, ) hidden_states =\",\n \"reshaped_inputs, input_shape): group_shape = tf.keras.backend.int_shape(reshaped_inputs) group_reduction_axes = list(range(1, len(group_shape))) is_instance_norm = (input_shape[self.axis] //\",\n \"continue layer_outputs = layer_module( hidden_states=hidden_states, attention_mask=attention_mask, output_attentions=output_attentions, training=training, ) hidden_states = layer_outputs[0] if\",\n \"# cross_attentions key_states = self._shape(self.k_proj(key_value_states), -1, bsz) value_states = self._shape(self.v_proj(key_value_states), -1, bsz) elif\",\n \"!= 0: raise ValueError( \\\"Number of groups (\\\" + str(self.groups) + \\\") must\",\n \"-> Tuple[tf.Tensor, Optional[tf.Tensor]]: \\\"\\\"\\\"Input shape: Batch x Time x Channel\\\"\\\"\\\" # if key_value_states\",\n \"f\\\"Data of type {type(input)} is not allowed only {allowed_types} is accepted for {parameter_names[i]}.\\\"\",\n \"(dim,) if self.center: self.beta = self.add_weight( shape=shape, name=\\\"beta\\\", initializer=self.beta_initializer, regularizer=self.beta_regularizer, constraint=self.beta_constraint, ) else:\",\n \"elif past_key_value is not None: # reuse k, v, self_attention key_states = self._shape(self.k_proj(hidden_states),\",\n \"> sequence_length: raise ValueError( f\\\"`mask_length` has to be smaller than `sequence_length`, but got\",\n \"value_states = self._shape(self.v_proj(key_value_states), -1, bsz) elif past_key_value is not None: # reuse k,\",\n \"# Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2GroupNorm with Wav2Vec2->Hubert class TFHubertGroupNorm(tf.keras.layers.Layer): \\\"\\\"\\\" From tensorflow-addons https://www.tensorflow.org/addons/api_docs/python/tfa/layers/GroupNormalization \\\"\\\"\\\"\",\n \"if not is_instance_norm: axis = -2 if self.axis == -1 else self.axis -\",\n \"def _scatter_values_on_batch_indices(values, batch_indices, output_shape): \\\"\\\"\\\" Scatter function as in PyTorch with indices in\",\n \"inputs_embeds: Optional[tf.Tensor] = None, output_attentions: Optional[bool] = None, labels: Optional[tf.Tensor] = None, output_hidden_states:\",\n \"for the feature encoder so that its parameter will not be updated during\",\n \"if num_masked_spans * mask_length > sequence_length: num_masked_spans = sequence_length // mask_length # SpecAugment\",\n \"top for Connectionist Temporal Classification (CTC).\\\"\\\"\\\", HUBERT_START_DOCSTRING, ) class TFHubertForCTC(TFHubertPreTrainedModel): def __init__(self, config:\",\n \"tf.keras.layers.Dropout(config.hidden_dropout) self.layer = [ TFHubertEncoderLayerStableLayerNorm(config, name=f\\\"layers.{i}\\\") for i in range(config.num_hidden_layers) ] def call(\",\n \"# The tf.debugging asserts are not compliant with XLA then they # have\",\n \"to overlaps, the actual number will be smaller (unless no_overlap is True) mask_length:\",\n \"signature = dict(inspect.signature(func).parameters) signature.pop(\\\"kwargs\\\", None) signature.pop(\\\"self\\\", None) parameter_names = list(signature.keys()) output = {}\",\n \"a *sentence A* token, - 1 corresponds to a *sentence B* token. [What\",\n \"input in enumerate(input_values): # EagerTensors don't allow to use the .name property so\",\n \"normalized_inputs = tf.nn.batch_normalization( reshaped_inputs, mean=mean, variance=variance, scale=gamma, offset=beta, variance_epsilon=self.epsilon, ) return normalized_inputs def\",\n \"the [`~PreTrainedModel.from_pretrained`] method to load the model weights. \\\"\\\"\\\" HUBERT_INPUTS_DOCSTRING = r\\\"\\\"\\\" Args:\",\n \"Two lists, one for the missing layers, and another one for the unexpected\",\n \"= tf.cast(attention_mask, dtype=attn_weights.dtype) attn_weights = tf.reshape(attn_weights, (bsz, self.num_heads, tgt_len, src_len)) + attention_mask attn_weights\",\n \"positions of each input sequence tokens in the position embeddings. Selected in the\",\n \"file does not load the weights associated with the model, only the configuration.\",\n \"named accordingly to the parameters name, i.e. `input_values = tf.keras.Input(shape=(128,), dtype='float32', name=\\\"input_values\\\")` otherwise\",\n \"broadcast_shape[self.axis] = self.groups return broadcast_shape # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2WeightNormConv1D with Wav2Vec2->Hubert class TFHubertWeightNormConv1D(tf.keras.layers.Conv1D):\",\n \"from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2EncoderLayerStableLayerNorm with Wav2Vec2->Hubert class TFHubertEncoderLayerStableLayerNorm(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs): super().__init__(**kwargs) self.attention\",\n \"= False self.kernel_norm_axes = tf.constant([0, 1]) def _init_norm(self): \\\"\\\"\\\"Set the norm of the\",\n \"name in parameter_names: if name not in list(output.keys()) and name != \\\"args\\\": output[name]\",\n \"layer_id: int = 0, **kwargs: Any) -> None: super().__init__(**kwargs) self.in_conv_dim = config.conv_dim[layer_id] if\",\n \"without replacement is currently not implemented. The gumbel-max trick will do for now\",\n \"make sure num masked indices <= sequence_length if num_masked_spans * mask_length > sequence_length:\",\n \"= tf.keras.layers.Dense( units=config.hidden_size, kernel_initializer=get_initializer(config.initializer_range), bias_initializer=\\\"zeros\\\", name=\\\"projection\\\", ) self.dropout = tf.keras.layers.Dropout(rate=config.feat_proj_dropout) def call(self, hidden_states:\",\n \"super().get_config() return {**base_config, **config} def compute_output_shape(self, input_shape): return input_shape def _reshape_into_groups(self, inputs, input_shape,\",\n \"training (`bool`, *optional*, defaults to `False``): Whether or not to use the model\",\n \"Authors and the HuggingFace Inc. team. All rights reserved. # # Licensed under\",\n \"@property def dummy_inputs(self) -> Dict[str, tf.Tensor]: pad_token = 0.0 input_values = tf.convert_to_tensor(np.random.rand(1, 16000),\",\n \"= self.encoder( hidden_states, attention_mask=attention_mask, output_attentions=inputs[\\\"output_attentions\\\"], output_hidden_states=inputs[\\\"output_hidden_states\\\"], return_dict=inputs[\\\"return_dict\\\"], training=inputs[\\\"training\\\"], ) hidden_states = encoder_outputs[0] if\",\n \"The gumbel-max trick will do for now - see https://github.com/tensorflow/tensorflow/issues/9260 for more info\",\n \"all elements. however due to overlaps, the actual number will be smaller (unless\",\n \"Wav2Vec2->Hubert class TFHubertSamePadLayer(tf.keras.layers.Layer): def __init__(self, num_conv_pos_embeddings, **kwargs): super().__init__(**kwargs) self.num_pad_remove = 1 if num_conv_pos_embeddings\",\n \"from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2GroupNormConvLayer with Wav2Vec2->Hubert class TFHubertGroupNormConvLayer(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, layer_id: int =\",\n \"self.dropout = tf.keras.layers.Dropout(dropout) self.head_dim = embed_dim // num_heads if (self.head_dim * num_heads) !=\",\n \"\\\"if\\\" case) # if uni-directional self-attention (decoder) save Tuple(tf.Tensor, tf.Tensor) of # all\",\n \"self._shape(self.k_proj(key_value_states), -1, bsz) value_states = self._shape(self.v_proj(key_value_states), -1, bsz) elif past_key_value is not None:\",\n \"self.feed_forward(hidden_states) hidden_states = self.final_layer_norm(hidden_states) outputs = (hidden_states,) if output_attentions: outputs += (attn_weights,) return\",\n \"return TFBaseModelOutput( last_hidden_state=hidden_states, hidden_states=all_hidden_states, attentions=all_self_attentions, ) # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2EncoderStableLayerNorm with Wav2Vec2->Hubert class\",\n \"single Tensor with `input_values` only and nothing else: `model(inputs_ids)` - a list of\",\n \"be bigger than 0.\\\") if mask_length > sequence_length: raise ValueError( f\\\"`mask_length` has to\",\n \"but is {shape_list(attention_mask)}\\\", ) attention_mask = tf.cast(attention_mask, dtype=attn_weights.dtype) attn_weights = tf.reshape(attn_weights, (bsz, self.num_heads,\",\n \"= \\\"hubert\\\" main_input_name = \\\"input_values\\\" @property def dummy_inputs(self) -> Dict[str, tf.Tensor]: pad_token =\",\n \"tf.convert_to_tensor(output.hidden_states) if self.config.output_hidden_states else None attns = tf.convert_to_tensor(output.attentions) if self.config.output_attentions else None return\",\n \"\\\" \\\"but the layer received an input with shape \\\" + str(input_shape) +\",\n \"inputs as a list, tuple or dict in the first positional arguments. This\",\n \"simple interface for downloading and loading pretrained models. \\\"\\\"\\\" config_class = HubertConfig base_model_prefix\",\n \"# Batch size 1 >>> logits = model(input_values).logits >>> predicted_ids = tf.argmax(logits, axis=-1)\",\n \"Computes random mask spans for a given shape Args: shape: the the shape\",\n \"So to respect the proper output we have to add this exception if\",\n \"model (such as downloading or saving, resizing the input embeddings, pruning heads etc.)\",\n \"self.feature_extractor( tf.cast(inputs[\\\"input_values\\\"], tf.float32), training=inputs[\\\"training\\\"] ) if inputs[\\\"attention_mask\\\"] is not None: # compute real\",\n \"True, **kwargs, ): super().__init__(**kwargs) self.embed_dim = embed_dim self.num_heads = num_heads self.dropout = tf.keras.layers.Dropout(dropout)\",\n \"are NOT supported on CPU. If you wish \\\" \\\"to train/fine-tine this model,\",\n \"Wav2Vec2->Hubert class TFHubertNoLayerNormConvLayer(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, layer_id: int = 0, **kwargs: Any)\",\n \"and `sequence_length`: {sequence_length}`\\\" ) # compute number of masked spans in batch num_masked_spans\",\n \"warnings.warn( \\\"The method `freeze_feature_extractor` is deprecated and will be removed in Transformers v5.\\\"\",\n \"\\\"Number of groups (\\\" + str(self.groups) + \\\") cannot be \\\" \\\"more than\",\n \"= -1e8 # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.input_values_processing def input_values_processing(func, config, input_values, **kwargs): \\\"\\\"\\\" Process\",\n \"+= (attn_weights,) return outputs # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2EncoderLayerStableLayerNorm with Wav2Vec2->Hubert class TFHubertEncoderLayerStableLayerNorm(tf.keras.layers.Layer): def\",\n \"not allowed only {allowed_types} is accepted for {k}.\\\") if isinstance(input_values, (tuple, list)): for\",\n \"output length of the convolutional layers \\\"\\\"\\\" def _conv_out_length(input_length, kernel_size, stride): # 1D\",\n \"of channels (\\\" + str(dim) + \\\").\\\" ) if dim % self.groups !=\",\n \"import numpy as np import tensorflow as tf from ...activations_tf import get_tf_activation from\",\n \"callable function of the TensorFlow model. config ([`PretrainedConfig`]): The config of the running\",\n \"= tf.where( tf.cast(mask_time_indices[:, :, tf.newaxis], tf.bool), self.masked_spec_embed[tf.newaxis, tf.newaxis, :], hidden_states, ) # apply\",\n \"of type {type(input_values)} is not allowed only {allowed_types} is accepted for {parameter_names[0]}.\\\" )\",\n \"call(self, hidden_states: tf.Tensor) -> tf.Tensor: hidden_states = self.conv(hidden_states) hidden_states = self.padding(hidden_states) hidden_states =\",\n \"the License for the specific language governing permissions and # limitations under the\",\n \"inputs): output = self.call(input_values=inputs, training=False) return self.serving_output(output) HUBERT_START_DOCSTRING = r\\\"\\\"\\\" This model inherits\",\n \"hidden_states = self.dropout(hidden_states, training=training) hidden_states = attn_residual + hidden_states hidden_states = hidden_states +\",\n \"Process the input of each TensorFlow model including the booleans. In case of\",\n \"from ...activations_tf import get_tf_activation from ...modeling_tf_outputs import TFBaseModelOutput, TFCausalLMOutput from ...modeling_tf_utils import TFPreTrainedModel,\",\n \"elif isinstance(input_values, (dict, BatchEncoding)): if \\\"inputs\\\" in input_values: warnings.warn( \\\"The `inputs` argument is\",\n \"reshaped_inputs, mean=mean, variance=variance, scale=gamma, offset=beta, variance_epsilon=self.epsilon, ) return normalized_inputs def _get_reshaped_weights(self, input_shape): broadcast_shape\",\n \"= ds.map(map_to_array) >>> input_values = processor(ds[\\\"speech\\\"][0], return_tensors=\\\"tf\\\").input_values # Batch size 1 >>> logits\",\n \"shape_list(attn_output), [bsz * self.num_heads, tgt_len, self.head_dim], message=f\\\"`attn_output` should be of size {(bsz, self.num_heads,\",\n \"input_shape = tf.keras.backend.int_shape(inputs) tensor_input_shape = tf.shape(inputs) reshaped_inputs, group_shape = self._reshape_into_groups(inputs, input_shape, tensor_input_shape) normalized_inputs\",\n \"output # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2NoLayerNormConvLayer with Wav2Vec2->Hubert class TFHubertNoLayerNormConvLayer(tf.keras.layers.Layer): def __init__(self, config: HubertConfig,\",\n \"with all the parameters of the model. Initializing with a config file does\",\n \"transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2GroupNormConvLayer with Wav2Vec2->Hubert class TFHubertGroupNormConvLayer(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, layer_id: int = 0,\",\n \"`attentions` under returned tensors for more detail. This argument can be used only\",\n \"name=\\\"input_values\\\")` otherwise the order of the tensors will not be guaranteed during the\",\n \"+ hidden_states hidden_states = self.layer_norm(hidden_states) hidden_states = hidden_states + self.feed_forward(hidden_states) hidden_states = self.final_layer_norm(hidden_states)\",\n \"processor(transcription, return_tensors=\\\"tf\\\").input_values >>> loss = model(input_values, labels=labels).loss ```\\\"\\\"\\\" inputs = input_values_processing( func=self.call, config=self.config,\",\n \"**kwargs) logger.warning( f\\\"\\\\n{self.__class__.__name__} has backpropagation operations that are NOT supported on CPU. If\",\n \"\\\"output_attentions\\\", \\\"output_hidden_states\\\", \\\"use_cache\\\"] } output.update(booleans_processing(config=config, **boolean_dict)) return output # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2._sample_without_replacement def\",\n \"= embed_dim self.num_heads = num_heads self.dropout = tf.keras.layers.Dropout(dropout) self.head_dim = embed_dim // num_heads\",\n \"\\\"\\\"\\\" Expands attention_mask from `[bsz, seq_len]` to `[bsz, 1, tgt_seq_len, src_seq_len]`. \\\"\\\"\\\" src_len\",\n \"Model and refer to the TF 2.0 documentation for all matter related to\",\n \"tf.sqrt(tf.reduce_sum(tf.square(self.weight_v), axis=self.kernel_norm_axes)) self.weight_g.assign(kernel_norm[:, tf.newaxis, tf.newaxis]) def _normalize_kernel(self): \\\"\\\"\\\"Generate normalized weights.\\\"\\\"\\\" kernel = tf.nn.l2_normalize(self.weight_v,\",\n \"in a future version, use `input_values` instead.\\\", FutureWarning, ) output[\\\"input_values\\\"] = input_values.pop(\\\"inputs\\\") if\",\n \"TF 2.0 models accepts two formats as inputs: - having all inputs as\",\n \"- a dictionary with one or several input Tensors associated to the input\",\n \"model(input_values).logits >>> predicted_ids = tf.argmax(logits, axis=-1) >>> transcription = processor.decode(predicted_ids[0]) >>> # compute\",\n \"dict in the first positional arguments. This second option is useful when using\",\n \") output[\\\"input_values\\\"] = input_values.pop(\\\"inputs\\\") if \\\"decoder_cached_states\\\" in input_values: warnings.warn( \\\"The `decoder_cached_states` argument is\",\n \"if isinstance(input_values, (tuple, list)): for i, input in enumerate(input_values): # EagerTensors don't allow\",\n \"tf.keras.layers.Dense(embed_dim, use_bias=bias, name=\\\"out_proj\\\") def _shape(self, tensor: tf.Tensor, seq_len: int, bsz: int): return tf.transpose(tf.reshape(tensor,\",\n \"the loss is only computed for the tokens with labels in `[0, ...,\",\n \"dummy_inputs def __init__(self, config, *inputs, **kwargs): super().__init__(config, *inputs, **kwargs) logger.warning( f\\\"\\\\n{self.__class__.__name__} has backpropagation\",\n \"outputs = normalized_inputs return outputs def get_config(self): config = { \\\"groups\\\": self.groups, \\\"axis\\\":\",\n \"real Tensor if type(input) == tf.Tensor: # Tensor names have always the pattern\",\n \"A* token, - 1 corresponds to a *sentence B* token. [What are token\",\n \"mask min_masks: minimum number of masked spans Adapted from [fairseq's data_utils.py](https://github.com/pytorch/fairseq/blob/e0788f7007a8473a76db573985031f3c94201e79/fairseq/data/data_utils.py#L376). \\\"\\\"\\\" batch_size,\",\n \"not allowed only {allowed_types} is accepted for {k}.\\\") else: if isinstance(input_values, tf.Tensor) or\",\n \"_conv_out_length(input_lengths, kernel_size, stride) return input_lengths def _mask_hidden_states(self, hidden_states: tf.Tensor, mask_time_indices: Optional[tf.Tensor] = None):\",\n \"* 2 super().build(input_shape) self.kernel = tf.Variable(tf.transpose(self.kernel), name=\\\"weight_v\\\", trainable=True) self.weight_v = self.kernel self.weight_g =\",\n \"tf.reshape(offsets, (batch_size, num_masked_spans * mask_length)) spec_aug_mask_idxs = spec_aug_mask_idxs + offsets # scatter indices\",\n \"reuse k, v, self_attention key_states = self._shape(self.k_proj(hidden_states), -1, bsz) value_states = self._shape(self.v_proj(hidden_states), -1,\",\n \"**kwargs): super().__init__(**kwargs) self.intermediate_dropout = tf.keras.layers.Dropout(config.activation_dropout) self.intermediate_dense = tf.keras.layers.Dense( units=config.intermediate_size, kernel_initializer=get_initializer(config.initializer_range), bias_initializer=\\\"zeros\\\", name=\\\"intermediate_dense\\\", )\",\n \"modeling loss. Indices should be in `[-100, 0, ..., config.vocab_size]` (see `input_values` docstring)\",\n \"dim = input_shape[self.axis] shape = (dim,) if self.scale: self.gamma = self.add_weight( shape=shape, name=\\\"gamma\\\",\",\n \"= self._reshape_into_groups(inputs, input_shape, tensor_input_shape) normalized_inputs = self._apply_normalization(reshaped_inputs, input_shape) is_instance_norm = (input_shape[self.axis] // self.groups)\",\n \"self._set_number_of_groups_for_instance_norm(input_shape) self._check_size_of_dimensions(input_shape) self._create_input_spec(input_shape) self._add_gamma_weight(input_shape) self._add_beta_weight(input_shape) self.built = True super().build(input_shape) def call(self, inputs): input_shape\",\n \"selected in `[0, 1]`: - 1 for tokens that are **not masked**, -\",\n \"option is useful when using [`tf.keras.Model.fit`] method which currently requires having all the\",\n \"tgt_len, src_len], message=f\\\"Attention mask should be of size {(bsz, 1, tgt_len, src_len)}, but\",\n \"computed for the tokens with labels in `[0, ..., config.vocab_size]` Returns: Example: ```python\",\n \"seq_len: int, bsz: int): return tf.transpose(tf.reshape(tensor, (bsz, seq_len, self.num_heads, self.head_dim)), (0, 2, 1,\",\n \"of all elements. however due to overlaps, the actual number will be smaller\",\n \"{shape_list(layer_head_mask)}\\\", ) attn_weights = tf.reshape(layer_head_mask, (1, -1, 1, 1)) * tf.reshape( attn_weights, (bsz,\",\n \"THE UNIVERSE SIR I EXIST\\\" >>> # wrap processor as target processor to\",\n \"tf.random.uniform((1,))) num_masked_spans = max(num_masked_spans, min_masks) # make sure num masked indices <= sequence_length\",\n \"def build(self, input_shape): if not self.built: input_shape = input_shape.as_list() # Conv1D output shapes\",\n \"tf.Tensor = tf.reshape(attn_weights, (bsz, self.num_heads, tgt_len, src_len)) return attn_output, attn_weights, past_key_value # Copied\",\n \"Hubert models at https://huggingface.co/models?filter=hubert ] LARGE_NEGATIVE = -1e8 # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.input_values_processing def\",\n \"# Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2._sample_without_replacement def _sample_without_replacement(distribution, num_samples): \\\"\\\"\\\" Categorical sampling without replacement is\",\n \"Wav2Vec2->Hubert class TFHubertEncoderLayer(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs): super().__init__(**kwargs) self.attention = TFHubertAttention( embed_dim=config.hidden_size,\",\n \"batch_size, sequence_length = shape if mask_length < 1: raise ValueError(\\\"`mask_length` has to be\",\n \"must have the shape `({0})`): Indices of input sequence tokens in the vocabulary.\",\n \"the number of channels (\\\" + str(dim) + \\\").\\\" ) if dim %\",\n \"masked. this will be multiplied by number of timesteps divided by length of\",\n \"tf.keras.regularizers.Regularizer = None, gamma_regularizer: tf.keras.regularizers.Regularizer = None, beta_constraint: tf.keras.constraints.Constraint = None, gamma_constraint: tf.keras.constraints.Constraint\",\n \"associated with the model, only the configuration. Check out the [`~PreTrainedModel.from_pretrained`] method to\",\n \"training: bool = False) -> tf.Tensor: hidden_states = self.layer_norm(hidden_states) hidden_states = self.projection(hidden_states) hidden_states\",\n \"tf.Tensor: hidden_states = self.conv(hidden_states) hidden_states = self.padding(hidden_states) hidden_states = self.activation(hidden_states) return hidden_states #\",\n \"self.config = config self.pos_conv_embed = TFHubertPositionalConvEmbedding(config, name=\\\"pos_conv_embed\\\") self.layer_norm = tf.keras.layers.LayerNormalization(epsilon=config.layer_norm_eps, name=\\\"layer_norm\\\") self.dropout =\",\n \"= get_tf_activation(config.feat_extract_activation) self.layer_norm = TFHubertGroupNorm(groups=self.out_conv_dim, epsilon=config.layer_norm_eps, name=\\\"layer_norm\\\") def call(self, hidden_states: tf.Tensor) -> tf.Tensor:\",\n \"on top for Connectionist Temporal Classification (CTC).\\\"\\\"\\\", HUBERT_START_DOCSTRING, ) class TFHubertForCTC(TFHubertPreTrainedModel): def __init__(self,\",\n \"= tf.keras.layers.Dropout(dropout) self.head_dim = embed_dim // num_heads if (self.head_dim * num_heads) != self.embed_dim:\",\n \"all attention layers. See `attentions` under returned tensors for more detail. This argument\",\n \"as a cross-attention layer # for the decoder is_cross_attention = key_value_states is not\",\n \") # apply SpecAugment along feature axis if self.config.mask_feature_prob > 0: mask_feature_indices =\",\n \"or `tf.Tensor` of shape `(num_heads,)` or `(num_layers, num_heads)`, *optional*): Mask to nullify selected\",\n \"spec_aug_mask_idxs, spec_aug_mask.shape ) return spec_aug_mask # Copied from transformers.models.bart.modeling_tf_bart._expand_mask def _expand_mask(mask: tf.Tensor, tgt_len:\",\n \"When creating a SavedModel TF calls the method with LayerCall.__call__(args, **kwargs) # So\",\n \"# expand masked indices to masked spans spec_aug_mask_idxs = tf.expand_dims(spec_aug_mask_idxs, -1) spec_aug_mask_idxs =\",\n \"layer_head_mask: Optional[tf.Tensor] = None, training: Optional[bool] = False, ) -> Tuple[tf.Tensor, Optional[tf.Tensor]]: \\\"\\\"\\\"Input\",\n \"None, return_dict: Optional[bool] = None, training: bool = False, **kwargs: Any, ): inputs\",\n \"dtype=tf.int32) # uniform distribution to sample from, make sure that offset samples are\",\n \"```\\\"\\\"\\\" inputs = input_values_processing( func=self.call, config=self.config, input_values=input_values, attention_mask=attention_mask, token_type_ids=token_type_ids, position_ids=position_ids, head_mask=head_mask, inputs_embeds=inputs_embeds, output_attentions=output_attentions,\",\n \"hidden_states + position_embeddings hidden_states = self.dropout(hidden_states, training=training) for i, layer_module in enumerate(self.layer): if\",\n \"or `np.ndarray` of shape `(batch_size, sequence_length)`, *optional*): Labels for computing the masked language\",\n \"(bsz, self.num_heads, tgt_len, self.head_dim)), (0, 2, 1, 3) ) attn_output = tf.reshape(attn_output, (bsz,\",\n \"and a simple interface for downloading and loading pretrained models. \\\"\\\"\\\" config_class =\",\n \"0.0, is_decoder: bool = False, bias: bool = True, **kwargs, ): super().__init__(**kwargs) self.embed_dim\",\n \"(hidden_states,) # add LayerDrop (see https://arxiv.org/abs/1909.11556 for description) dropout_probability = np.random.uniform(0, 1) if\",\n \"*inputs, **kwargs) self.hubert = TFHubertMainLayer(config, name=\\\"hubert\\\") self.dropout = tf.keras.layers.Dropout(config.final_dropout) self.lm_head = tf.keras.layers.Dense(config.vocab_size, name=\\\"lm_head\\\")\",\n \"be of size {(self.num_heads)}, but is {shape_list(layer_head_mask)}\\\", ) attn_weights = tf.reshape(layer_head_mask, (1, -1,\",\n \"convolutional layer output length formula taken # from https://pytorch.org/docs/stable/generated/torch.nn.Conv1d.html return (input_length - kernel_size)\",\n \"+ str(self.groups) + \\\") must be a \\\" \\\"multiple of the number of\",\n \"`{self.__class__.__bases__[0].__name__}` instead.\\\", FutureWarning, ) class TFHubertFeatureProjection(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs): super().__init__(**kwargs) self.layer_norm\",\n \"bool, int, ModelOutput, tuple, list, dict, np.ndarray) for k, v in kwargs.items(): if\",\n \"removed in a future version, use `input_values` instead.\\\", FutureWarning, ) output[\\\"input_values\\\"] = input_values.pop(\\\"inputs\\\")\",\n \"inputs_embeds=inputs_embeds, output_attentions=output_attentions, output_hidden_states=output_hidden_states, return_dict=return_dict, training=training, ) outputs = self.hubert( input_values=inputs[\\\"input_values\\\"], attention_mask=inputs[\\\"attention_mask\\\"], token_type_ids=inputs[\\\"token_type_ids\\\"], position_ids=inputs[\\\"position_ids\\\"],\",\n \"beta = self._get_reshaped_weights(input_shape) normalized_inputs = tf.nn.batch_normalization( reshaped_inputs, mean=mean, variance=variance, scale=gamma, offset=beta, variance_epsilon=self.epsilon, )\",\n \"= False, ) -> Union[TFBaseModelOutput, Tuple[tf.Tensor]]: \\\"\\\"\\\" Returns: Example: ```python >>> from transformers\",\n \"1) if training and (dropout_probability < self.config.layerdrop): # skip the layer continue layer_outputs\",\n \"other modes than eager. if tf.executing_eagerly(): tf.debugging.assert_equal( shape_list(attn_weights), [bsz * self.num_heads, tgt_len, src_len],\",\n \"True. training (`bool`, *optional*, defaults to `False``): Whether or not to use the\",\n \"TFHubertNoLayerNormConvLayer(config, layer_id=i + 1, name=f\\\"conv_layers.{i+1}\\\") for i in range(config.num_feat_extract_layers - 1) ] elif\",\n \"not self.built: input_shape = input_shape.as_list() # Conv1D output shapes are checked at build\",\n \"= TFHubertAttention( embed_dim=config.hidden_size, num_heads=config.num_attention_heads, dropout=config.attention_dropout, is_decoder=False, name=\\\"attention\\\", ) self.dropout = tf.keras.layers.Dropout(config.hidden_dropout) self.layer_norm =\",\n \"in enumerate(input_values): # EagerTensors don't allow to use the .name property so we\",\n \"head is **not masked**, - 0 indicates the head is **masked**. inputs_embeds (`np.ndarray`\",\n \"= attn_residual + hidden_states hidden_states = self.layer_norm(hidden_states) hidden_states = hidden_states + self.feed_forward(hidden_states) hidden_states\",\n \"= {} allowed_types = (tf.Tensor, bool, int, ModelOutput, tuple, list, dict, np.ndarray) for\",\n \"OF ANY KIND, either express or implied. # See the License for the\",\n \"output # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2._sample_without_replacement def _sample_without_replacement(distribution, num_samples): \\\"\\\"\\\" Categorical sampling without replacement\",\n \"See `hidden_states` under returned tensors for more detail. This argument can be used\",\n \"property so we check for a real Tensor if type(input) == tf.Tensor: #\",\n \"self.masked_spec_embed = self.add_weight( shape=(self.config.hidden_size,), initializer=\\\"uniform\\\", trainable=True, name=\\\"masked_spec_embed\\\" ) super().build(input_shape) def _get_feat_extract_output_lengths(self, input_lengths: tf.Tensor):\",\n \"tf.reshape(attn_weights, (bsz * self.num_heads, tgt_len, src_len)) attn_weights = tf.nn.softmax(attn_weights, axis=-1) if layer_head_mask is\",\n \"self.output_dense(hidden_states) hidden_states = self.output_dropout(hidden_states, training=training) return hidden_states # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2EncoderLayer with Wav2Vec2->Hubert\",\n \"its parameter will not be updated during training. \\\"\\\"\\\" self.hubert.feature_extractor.trainable = False @add_start_docstrings_to_model_forward(HUBERT_INPUTS_DOCSTRING)\",\n \"bsz, tgt_len, embed_dim = shape_list(hidden_states) # get query proj query_states = self.q_proj(hidden_states) *\",\n \"self.call(input_values=inputs, training=False) return self.serving_output(output) HUBERT_START_DOCSTRING = r\\\"\\\"\\\" This model inherits from [`TFPreTrainedModel`]. Check\",\n \"if you want more control over how to convert `input_values` indices into associated\",\n \"Tuple[tf.Tensor]]: all_hidden_states = () if output_hidden_states else None all_self_attentions = () if output_attentions\",\n \"portions of the inputs. Indices are selected in `[0, 1]`: - 0 corresponds\",\n \"self.config.ctc_loss_reduction == \\\"sum\\\": loss = tf.reduce_sum(loss) if self.config.ctc_loss_reduction == \\\"mean\\\": loss = tf.reduce_mean(loss)\",\n \"attn_weights, _ = self.attention( hidden_states, attention_mask=attention_mask, training=training ) hidden_states = self.dropout(hidden_states, training=training) hidden_states\",\n \"hidden_size = shape_list(hidden_states) # `config.apply_spec_augment` can set masking to False if not getattr(self.config,\",\n \"or v is None: output[k] = v elif k not in parameter_names and\",\n \"than eager. if tf.executing_eagerly(): tf.debugging.assert_equal( shape_list(attn_output), [bsz * self.num_heads, tgt_len, self.head_dim], message=f\\\"`attn_output` should\",\n \"int, ModelOutput, tuple, list, dict, np.ndarray) for k, v in kwargs.items(): if isinstance(v,\",\n \"have to be disabled in other modes than eager. if tf.executing_eagerly(): tf.debugging.assert_equal( shape_list(attention_mask),\",\n \"for now - see https://github.com/tensorflow/tensorflow/issues/9260 for more info \\\"\\\"\\\" z = -tf.math.log(tf.random.uniform(shape_list(distribution), 0,\",\n \"loss = tf.nn.ctc_loss( logits=logits, labels=labels, logit_length=input_lengths, label_length=target_lengths, blank_index=self.config.pad_token_id, logits_time_major=False, ) if self.config.ctc_loss_reduction ==\",\n \"not None: # apply SpecAugment along time axis with given mask_time_indices hidden_states =\",\n \"self.axis == -1 else self.axis - 1 group_reduction_axes.pop(axis) mean, variance = tf.nn.moments(reshaped_inputs, group_reduction_axes,\",\n \"[ TFHubertEncoderLayerStableLayerNorm(config, name=f\\\"layers.{i}\\\") for i in range(config.num_hidden_layers) ] def call( self, hidden_states: tf.Tensor,\",\n \"is None: output[parameter_names[0]] = input_values else: raise ValueError( f\\\"Data of type {type(input_values)} is\",\n \"input_shape def _reshape_into_groups(self, inputs, input_shape, tensor_input_shape): group_shape = [tensor_input_shape[i] for i in range(len(input_shape))]\",\n \"def serving(self, inputs): output = self.call(input_values=inputs, training=False) return self.serving_output(output) HUBERT_START_DOCSTRING = r\\\"\\\"\\\" This\",\n \"offsets = tf.reshape(offsets, (batch_size, num_masked_spans * mask_length)) spec_aug_mask_idxs = spec_aug_mask_idxs + offsets #\",\n \"// stride + 1 for kernel_size, stride in zip(self.config.conv_kernel, self.config.conv_stride): input_lengths = _conv_out_length(input_lengths,\",\n \"src_len one_cst = tf.constant(1.0) mask = tf.cast(mask, dtype=one_cst.dtype) expanded_mask = tf.tile(mask[:, None, None,\",\n \"use_bias=bias, name=\\\"k_proj\\\") self.q_proj = tf.keras.layers.Dense(embed_dim, use_bias=bias, name=\\\"q_proj\\\") self.v_proj = tf.keras.layers.Dense(embed_dim, use_bias=bias, name=\\\"v_proj\\\") self.out_proj\",\n \"2, 1, 3)) def call( self, hidden_states: tf.Tensor, key_value_states: Optional[tf.Tensor] = None, past_key_value:\",\n \"< self.config.layerdrop): # skip the layer continue layer_outputs = layer_module( hidden_states=hidden_states, attention_mask=attention_mask, output_attentions=output_attentions,\",\n \"(bsz, seq_len, self.num_heads, self.head_dim)), (0, 2, 1, 3)) def call( self, hidden_states: tf.Tensor,\",\n \"of the TensorFlow model. config ([`PretrainedConfig`]): The config of the running model. **kwargs:\",\n \"or agreed to in writing, software # distributed under the License is distributed\",\n \"\\\"\\\"\\\" z = -tf.math.log(tf.random.uniform(shape_list(distribution), 0, 1)) _, indices = tf.nn.top_k(distribution + z, num_samples)\",\n \"soundfile as sf >>> processor = Wav2Vec2Processor.from_pretrained(\\\"facebook/hubert-base-960h\\\") >>> model = TFHubertModel.from_pretrained(\\\"facebook/hubert-base-960h\\\") >>> def\",\n \"type(output[\\\"args\\\"]) == tf.Tensor: tensor_name = output[\\\"args\\\"].name.split(\\\":\\\")[0] output[tensor_name] = output[\\\"args\\\"] else: # `args` in\",\n \"# make sure num masked indices <= sequence_length if num_masked_spans * mask_length >\",\n \"self._add_beta_weight(input_shape) self.built = True super().build(input_shape) def call(self, inputs): input_shape = tf.keras.backend.int_shape(inputs) tensor_input_shape =\",\n \"int(mask_prob * sequence_length / mask_length + tf.random.uniform((1,))) num_masked_spans = max(num_masked_spans, min_masks) # make\",\n \"True, beta_initializer: tf.keras.initializers.Initializer = \\\"zeros\\\", gamma_initializer: tf.keras.initializers.Initializer = \\\"ones\\\", beta_regularizer: tf.keras.regularizers.Regularizer = None,\",\n \"kwargs.get(\\\"mask_time_indices\\\", None) if inputs[\\\"training\\\"]: hidden_states = self._mask_hidden_states(hidden_states, mask_time_indices=mask_time_indices) encoder_outputs = self.encoder( hidden_states, attention_mask=attention_mask,\",\n \"your batch axis. Do you want to \\\" \\\"use tf.layer.batch_normalization instead\\\" ) def\",\n \"= self.layer_norm(hidden_states) hidden_states, attn_weights, _ = self.attention( hidden_states, attention_mask=attention_mask, training=training ) hidden_states =\",\n \"None, labels: Optional[tf.Tensor] = None, output_hidden_states: Optional[bool] = None, return_dict: Optional[bool] = None,\",\n \"format (batch_dim, indixes) \\\"\\\"\\\" indices_shape = shape_list(batch_indices) # broadcast batch dim to indices_shape\",\n \"the norm of the weight vector.\\\"\\\"\\\" kernel_norm = tf.sqrt(tf.reduce_sum(tf.square(self.weight_v), axis=self.kernel_norm_axes)) self.weight_g.assign(kernel_norm[:, tf.newaxis, tf.newaxis])\",\n \"axis self.epsilon = epsilon self.center = center self.scale = scale self.beta_initializer = tf.keras.initializers.get(beta_initializer)\",\n \"enumerate(self.layer): if output_hidden_states: all_hidden_states = all_hidden_states + (hidden_states,) # add LayerDrop (see https://arxiv.org/abs/1909.11556\",\n \"dim = input_shape[self.axis] self.input_spec = tf.keras.layers.InputSpec(ndim=len(input_shape), axes={self.axis: dim}) def _add_gamma_weight(self, input_shape): dim =\",\n \"of masked spans in batch num_masked_spans = int(mask_prob * sequence_length / mask_length +\",\n \"is {shape_list(attn_output)}\\\", ) attn_output = tf.transpose( tf.reshape(attn_output, (bsz, self.num_heads, tgt_len, self.head_dim)), (0, 2,\",\n \"of each input sequence tokens in the position embeddings. Selected in the range\",\n \"* len(input_shape) is_instance_norm = (input_shape[self.axis] // self.groups) == 1 if not is_instance_norm: broadcast_shape[self.axis]\",\n \"inputs[\\\"output_hidden_states\\\"] = ( inputs[\\\"output_hidden_states\\\"] if inputs[\\\"output_hidden_states\\\"] else self.config.output_hidden_states ) inputs[\\\"output_attentions\\\"] = ( inputs[\\\"output_attentions\\\"]\",\n \"= processor(ds[\\\"speech\\\"][0], return_tensors=\\\"tf\\\").input_values # Batch size 1 >>> hidden_states = model(input_values).last_hidden_state ```\\\"\\\"\\\" inputs\",\n \"= tf.nn.batch_normalization( reshaped_inputs, mean=mean, variance=variance, scale=gamma, offset=beta, variance_epsilon=self.epsilon, ) return normalized_inputs def _get_reshaped_weights(self,\",\n \"Optional[tf.Tensor] = None, output_hidden_states: Optional[bool] = None, return_dict: Optional[bool] = None, training: Optional[bool]\",\n \"base_model_prefix = \\\"hubert\\\" main_input_name = \\\"input_values\\\" @property def dummy_inputs(self) -> Dict[str, tf.Tensor]: pad_token\",\n \"= explicit_padding self.filter_axis = 2 self.initialized = False self.kernel_norm_axes = tf.constant([0, 1]) def\",\n \"def call(self, hidden_states: tf.Tensor, training: bool = False) -> tf.Tensor: hidden_states = self.intermediate_dense(hidden_states)\",\n \"\\\"\\\"\\\" config_class = HubertConfig base_model_prefix = \\\"hubert\\\" main_input_name = \\\"input_values\\\" @property def dummy_inputs(self)\",\n \"ModelOutput, tuple, list, dict, np.ndarray) for k, v in kwargs.items(): if isinstance(v, allowed_types)\",\n \"def __init__(self, config, *inputs, **kwargs): super().__init__(config, *inputs, **kwargs) logger.warning( f\\\"\\\\n{self.__class__.__name__} has backpropagation operations\",\n \"be removed in a future version, use `input_values` instead.\\\", FutureWarning, ) output[\\\"input_values\\\"] =\",\n \"to mask spec_aug_mask = _scatter_values_on_batch_indices( tf.ones_like(spec_aug_mask_idxs), spec_aug_mask_idxs, spec_aug_mask.shape ) return spec_aug_mask # Copied\",\n \"Tensor with `input_values` only and nothing else: `model(inputs_ids)` - a list of varying\",\n \"= 1 if num_conv_pos_embeddings % 2 == 0 else 0 def call(self, hidden_states):\",\n \"TFCausalLMOutput( loss=loss, logits=logits, hidden_states=outputs.hidden_states, attentions=outputs.attentions, ) def serving_output(self, output: TFCausalLMOutput) -> TFCausalLMOutput: hs\",\n \"-> tf.Tensor: hidden_states = self.conv(hidden_states) hidden_states = self.layer_norm(hidden_states) hidden_states = self.activation(hidden_states) return hidden_states\",\n \"hidden_states, ) # apply SpecAugment along feature axis if self.config.mask_feature_prob > 0: mask_feature_indices\",\n \"def call(self, input_values): hidden_states = tf.expand_dims(input_values, -1) for conv_layer in self.conv_layers: hidden_states =\",\n \"processor to encode labels >>> with processor.as_target_processor(): ... labels = processor(transcription, return_tensors=\\\"tf\\\").input_values >>>\",\n \"size and 2nd is timesteps attention_mask: optional padding mask of the same size\",\n \"instead.\\\", FutureWarning, ) self.freeze_feature_encoder() def freeze_feature_encoder(self): \\\"\\\"\\\" Calling this function will disable the\",\n \"else: self.beta = None def _create_broadcast_shape(self, input_shape): broadcast_shape = [1] * len(input_shape) is_instance_norm\",\n \"if output_attentions: all_self_attentions = all_self_attentions + (layer_outputs[1],) hidden_states = self.layer_norm(hidden_states) if output_hidden_states: all_hidden_states\",\n \"False, output_hidden_states: Optional[bool] = False, return_dict: Optional[bool] = True, training: Optional[bool] = False,\",\n \"can set masking to False if not getattr(self.config, \\\"apply_spec_augment\\\", True): return hidden_states if\",\n \"all_self_attentions = all_self_attentions + (layer_outputs[1],) # Add last layer if output_hidden_states: all_hidden_states =\",\n \"tf.transpose(self.weight_g) self.kernel = tf.transpose(kernel) def build(self, input_shape): if not self.built: input_shape = input_shape.as_list()\",\n \"src_len)) attn_probs = self.dropout(attn_weights, training=training) attn_output = tf.matmul(attn_probs, value_states) # The tf.debugging asserts\",\n \"tf.executing_eagerly(): tf.debugging.assert_equal( shape_list(attn_output), [bsz * self.num_heads, tgt_len, self.head_dim], message=f\\\"`attn_output` should be of size\",\n \"output[parameter_names[i]] = input elif isinstance(input, allowed_types) or input is None: output[parameter_names[i]] = input\",\n \"[\\\"return_dict\\\", \\\"output_attentions\\\", \\\"output_hidden_states\\\", \\\"use_cache\\\"] } output.update(booleans_processing(config=config, **boolean_dict)) return output # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2._sample_without_replacement\",\n \"hidden_states = self.activation(hidden_states) return hidden_states # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2SamePadLayer with Wav2Vec2->Hubert class TFHubertSamePadLayer(tf.keras.layers.Layer):\",\n \"= layer_outputs[0] if output_attentions: all_self_attentions = all_self_attentions + (layer_outputs[1],) # Add last layer\",\n \"`name` part tensor_name = input.name.split(\\\":\\\")[0] if tensor_name in parameter_names: output[tensor_name] = input else:\",\n \"attention_mask=attention_mask, token_type_ids=token_type_ids, position_ids=position_ids, head_mask=head_mask, inputs_embeds=inputs_embeds, output_attentions=output_attentions, output_hidden_states=output_hidden_states, return_dict=return_dict, training=training, ) outputs = self.hubert(\",\n \"masked indices to masked spans spec_aug_mask_idxs = tf.expand_dims(spec_aug_mask_idxs, -1) spec_aug_mask_idxs = tf.tile(spec_aug_mask_idxs, (1,\",\n \"tf.Tensor, training: bool = False) -> tf.Tensor: hidden_states = self.intermediate_dense(hidden_states) hidden_states = self.intermediate_act_fn(hidden_states)\",\n \"to load the model weights. \\\"\\\"\\\" HUBERT_INPUTS_DOCSTRING = r\\\"\\\"\\\" Args: input_values (`np.ndarray`, `tf.Tensor`,\",\n \"output lengths according to convolution formula output_lengths = self._get_feat_extract_output_lengths(tf.reduce_sum(inputs[\\\"attention_mask\\\"], -1)) attention_mask = tf.sequence_mask(\",\n \"+ \\\").\\\" ) def _check_axis(self): if self.axis == 0: raise ValueError( \\\"You are\",\n \"class TFHubertLayerNormConvLayer(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, layer_id: int = 0, **kwargs: Any) ->\",\n \"with labels in `[0, ..., config.vocab_size]` Returns: Example: ```python >>> import tensorflow as\",\n \"hidden_states = hidden_states * tf.expand_dims(attention_mask, -1) attention_mask = _expand_mask(attention_mask) else: attention_mask = None\",\n \"`input_values` you can choose to directly pass an embedded representation. This is useful\",\n \"bigger than 0.\\\") if mask_length > sequence_length: raise ValueError( f\\\"`mask_length` has to be\",\n \"attention masks?](../glossary#attention-mask) token_type_ids (`np.ndarray` or `tf.Tensor` of shape `({0})`, *optional*): Segment token indices\",\n \"tokens that are **masked**. [What are attention masks?](../glossary#attention-mask) token_type_ids (`np.ndarray` or `tf.Tensor` of\",\n \"= None, inputs_embeds: Optional[tf.Tensor] = None, output_attentions: Optional[bool] = None, output_hidden_states: Optional[bool] =\",\n \"attn_weights = tf.reshape(attn_weights, (bsz * self.num_heads, tgt_len, src_len)) attn_probs = self.dropout(attn_weights, training=training) attn_output\",\n \"= None, output_hidden_states: Optional[bool] = None, return_dict: Optional[bool] = None, training: Optional[bool] =\",\n \"`[bsz, seq_len]` to `[bsz, 1, tgt_seq_len, src_seq_len]`. \\\"\\\"\\\" src_len = shape_list(mask)[1] tgt_len =\",\n \") -> Tuple[tf.Tensor]: attn_residual = hidden_states hidden_states, attn_weights, _ = self.attention( hidden_states, attention_mask=attention_mask,\",\n \"Args: shape: the the shape for which to compute masks. should be of\",\n \"[What are token type IDs?](../glossary#token-type-ids) position_ids (`np.ndarray` or `tf.Tensor` of shape `({0})`, *optional*):\",\n \"num_masked_spans = sequence_length // mask_length # SpecAugment mask to fill spec_aug_mask = tf.zeros((batch_size,\",\n \"or implied. # See the License for the specific language governing permissions and\",\n \"{shape_list(attn_output)}\\\", ) attn_output = tf.transpose( tf.reshape(attn_output, (bsz, self.num_heads, tgt_len, self.head_dim)), (0, 2, 1,\",\n \"[`~PreTrainedModel.from_pretrained`] method to load the model weights. \\\"\\\"\\\" HUBERT_INPUTS_DOCSTRING = r\\\"\\\"\\\" Args: input_values\",\n \"Optional[tf.Tensor] = None, inputs_embeds: Optional[tf.Tensor] = None, output_attentions: Optional[bool] = None, labels: Optional[tf.Tensor]\",\n \"[TFHubertEncoderLayer(config, name=f\\\"layers.{i}\\\") for i in range(config.num_hidden_layers)] def call( self, hidden_states: tf.Tensor, attention_mask: Optional[tf.Tensor]\",\n \"0: raise ValueError( \\\"You are trying to normalize your batch axis. Do you\",\n \"filled with -100 # when not being attended to labels_mask = tf.cast(labels >=\",\n \"self.embed_dim: raise ValueError( f\\\"embed_dim must be divisible by num_heads (got `embed_dim`: {self.embed_dim}\\\" f\\\"\",\n \"def call(self, inputs): if not self.initialized: self._init_norm() self.initialized = True self._normalize_kernel() padded_inputs =\",\n \"the order of the tensors will not be guaranteed during the training. Args:\",\n \"timesteps attention_mask: optional padding mask of the same size as shape, which will\",\n \"from transformers.models.bart.modeling_tf_bart._expand_mask def _expand_mask(mask: tf.Tensor, tgt_len: Optional[int] = None, past_key_values_length: int = 0):\",\n \"input_values: warnings.warn( \\\"The `inputs` argument is deprecated and will be removed in a\",\n \"of channels (\\\" + str(dim) + \\\").\\\" ) def _check_axis(self): if self.axis ==\",\n \"self.config.output_hidden_states ) inputs[\\\"output_attentions\\\"] = ( inputs[\\\"output_attentions\\\"] if inputs[\\\"output_attentions\\\"] else self.config.output_attentions ) inputs[\\\"return_dict\\\"] =\",\n \"config of the running model. **kwargs: The inputs of the model. Returns: Two\",\n \"= None, **kwargs, ): super().__init__(**kwargs) self.supports_masking = True self.groups = groups self.axis =\",\n \"for a given shape Args: shape: the the shape for which to compute\",\n \"super().__init__(**kwargs) self.supports_masking = True self.groups = groups self.axis = axis self.epsilon = epsilon\",\n \"layers. See `attentions` under returned tensors for more detail. This argument can be\",\n \"uni-directional self-attention (decoder) save Tuple(tf.Tensor, tf.Tensor) of # all previous decoder key/value_states. Further\",\n \"(self.head_dim * num_heads) != self.embed_dim: raise ValueError( f\\\"embed_dim must be divisible by num_heads\",\n \"should be in `[-100, 0, ..., config.vocab_size]` (see `input_values` docstring) Tokens with indices\",\n \"Any, ): inputs = input_values_processing( func=self.call, config=self.config, input_values=input_values, attention_mask=attention_mask, token_type_ids=token_type_ids, position_ids=position_ids, head_mask=head_mask, inputs_embeds=inputs_embeds,\",\n \"output_hidden_states: Optional[tf.Tensor] = None, return_dict: Optional[bool] = None, training: bool = False, **kwargs:\",\n \"from [`TFPreTrainedModel`]. Check the superclass documentation for the generic methods the library implements\",\n \"from `[bsz, seq_len]` to `[bsz, 1, tgt_seq_len, src_seq_len]`. \\\"\\\"\\\" src_len = shape_list(mask)[1] tgt_len\",\n \"inputs[\\\"output_hidden_states\\\"] else self.config.output_hidden_states ) inputs[\\\"output_attentions\\\"] = ( inputs[\\\"output_attentions\\\"] if inputs[\\\"output_attentions\\\"] else self.config.output_attentions )\",\n \"None: raise ValueError( \\\"Axis \\\" + str(self.axis) + \\\" of \\\" \\\"input tensor\",\n \"model. Initializing with a config file does not load the weights associated with\",\n \"to normalize your batch axis. Do you want to \\\" \\\"use tf.layer.batch_normalization instead\\\"\",\n \"= \\\"HubertConfig\\\" TF_HUBERT_PRETRAINED_MODEL_ARCHIVE_LIST = [ \\\"facebook/hubert-base-ls960\\\", # See all Hubert models at https://huggingface.co/models?filter=hubert\",\n \"hidden_states[:, : -self.num_pad_remove, :] return hidden_states class TFHubertFeatureEncoder(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs:\",\n \"dim is None: raise ValueError( \\\"Axis \\\" + str(self.axis) + \\\" of \\\"\",\n \"= False, **kwargs: Any, ): inputs = input_values_processing( func=self.call, config=self.config, input_values=input_values, attention_mask=attention_mask, token_type_ids=token_type_ids,\",\n \"data_utils.py](https://github.com/pytorch/fairseq/blob/e0788f7007a8473a76db573985031f3c94201e79/fairseq/data/data_utils.py#L376). \\\"\\\"\\\" batch_size, sequence_length = shape if mask_length < 1: raise ValueError(\\\"`mask_length` has\",\n \"self.center: beta = tf.reshape(self.beta, broadcast_shape) return gamma, beta def _check_if_input_shape_is_none(self, input_shape): dim =\",\n \"if config.feat_extract_norm == \\\"group\\\": conv_layers = [TFHubertGroupNormConvLayer(config, layer_id=0, name=f\\\"conv_layers.{0}\\\")] + [ TFHubertNoLayerNormConvLayer(config, layer_id=i\",\n \"call(self, hidden_states: tf.Tensor, training: bool = False) -> tf.Tensor: hidden_states = self.intermediate_dense(hidden_states) hidden_states\",\n \"self, input_values: tf.Tensor, attention_mask: Optional[tf.Tensor] = None, token_type_ids: Optional[tf.Tensor] = None, position_ids: Optional[tf.Tensor]\",\n \"`tf.Tensor` of shape `({0})`, *optional*): Mask to avoid performing attention on padding token\",\n \"resizing the input embeddings, pruning heads etc.) This model is also a [tf.keras.Model](https://www.tensorflow.org/api_docs/python/tf/keras/Model)\",\n \"in kwargs.items(): if isinstance(v, allowed_types) or v is None: output[k] = v else:\",\n \"The config of the running model. **kwargs: The inputs of the model. Returns:\",\n \"convolution formula output_lengths = self._get_feat_extract_output_lengths(tf.reduce_sum(inputs[\\\"attention_mask\\\"], -1)) attention_mask = tf.sequence_mask( output_lengths, maxlen=shape_list(hidden_states)[1], dtype=hidden_states.dtype )\",\n \"hidden_states=all_hidden_states, attentions=all_self_attentions, ) # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2EncoderStableLayerNorm with Wav2Vec2->Hubert class TFHubertEncoderStableLayerNorm(tf.keras.layers.Layer): def __init__(self,\",\n \"XLA then they # have to be disabled in other modes than eager.\",\n \"if training and (dropout_probability < self.config.layerdrop): # skip the layer continue layer_outputs =\",\n \"tf.reduce_sum(loss) if self.config.ctc_loss_reduction == \\\"mean\\\": loss = tf.reduce_mean(loss) else: loss = None if\",\n \"# broadcast batch dim to indices_shape broad_casted_batch_dims = tf.reshape( tf.broadcast_to(tf.expand_dims(tf.range(indices_shape[0]), axis=-1), indices_shape), [1,\",\n \"a future version, use `past_key_values` instead.\\\", FutureWarning, ) output[\\\"past_key_values\\\"] = input_values.pop(\\\"decoder_cached_states\\\") for k,\",\n \"* self.num_heads, -1, self.head_dim) query_states = tf.reshape(self._shape(query_states, tgt_len, bsz), proj_shape) key_states = tf.reshape(key_states,\",\n \"tf.newaxis, :] offsets = tf.tile(offsets, (batch_size, num_masked_spans, 1)) offsets = tf.reshape(offsets, (batch_size, num_masked_spans\",\n \"None, return_dict: Optional[bool] = None, training: Optional[bool] = False, ) -> Union[TFCausalLMOutput, Tuple[tf.Tensor]]:\",\n \"min_masks: minimum number of masked spans Adapted from [fairseq's data_utils.py](https://github.com/pytorch/fairseq/blob/e0788f7007a8473a76db573985031f3c94201e79/fairseq/data/data_utils.py#L376). \\\"\\\"\\\" batch_size, sequence_length\",\n \"an \\\"AS IS\\\" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either\",\n \"will disable the gradient computation for the feature encoder so that its parameters\",\n \"This is useful if you want more control over how to convert `input_values`\",\n \"\\\"\\\"\\\" batch_size, sequence_length, hidden_size = shape_list(hidden_states) # `config.apply_spec_augment` can set masking to False\",\n \"(hidden_states,) + encoder_outputs[1:] return TFBaseModelOutput( last_hidden_state=hidden_states, hidden_states=encoder_outputs.hidden_states, attentions=encoder_outputs.attentions, ) class TFHubertPreTrainedModel(TFPreTrainedModel): \\\"\\\"\\\" An\",\n \"models. \\\"\\\"\\\" config_class = HubertConfig base_model_prefix = \\\"hubert\\\" main_input_name = \\\"input_values\\\" @property def\",\n \"attention_mask=attention_mask, output_attentions=output_attentions, training=training, ) hidden_states = layer_outputs[0] if output_attentions: all_self_attentions = all_self_attentions +\",\n \"\\\"gamma_initializer\\\": tf.keras.initializers.serialize(self.gamma_initializer), \\\"beta_regularizer\\\": tf.keras.regularizers.serialize(self.beta_regularizer), \\\"gamma_regularizer\\\": tf.keras.regularizers.serialize(self.gamma_regularizer), \\\"beta_constraint\\\": tf.keras.constraints.serialize(self.beta_constraint), \\\"gamma_constraint\\\": tf.keras.constraints.serialize(self.gamma_constraint), } base_config =\",\n \"_shape(self, tensor: tf.Tensor, seq_len: int, bsz: int): return tf.transpose(tf.reshape(tensor, (bsz, seq_len, self.num_heads, self.head_dim)),\",\n \"TFCausalLMOutput: hs = tf.convert_to_tensor(output.hidden_states) if self.config.output_hidden_states else None attns = tf.convert_to_tensor(output.attentions) if self.config.output_attentions\",\n \"ValueError(f\\\"Data of type {type(v)} is not allowed only {allowed_types} is accepted for {k}.\\\")\",\n \"spec_aug_mask_idxs = tf.expand_dims(spec_aug_mask_idxs, -1) spec_aug_mask_idxs = tf.tile(spec_aug_mask_idxs, (1, 1, mask_length)) spec_aug_mask_idxs = tf.reshape(spec_aug_mask_idxs,\",\n \"(batch_size, num_masked_spans * mask_length)) spec_aug_mask_idxs = spec_aug_mask_idxs + offsets # scatter indices to\",\n \"self.hubert = TFHubertMainLayer(config, name=\\\"hubert\\\") @add_start_docstrings_to_model_forward(HUBERT_INPUTS_DOCSTRING) @replace_return_docstrings(output_type=TFBaseModelOutput, config_class=_CONFIG_FOR_DOC) def call( self, input_values: tf.Tensor, attention_mask:\",\n \"than eager. if tf.executing_eagerly(): tf.debugging.assert_equal( shape_list(attn_weights), [bsz * self.num_heads, tgt_len, src_len], message=f\\\"Attention weights\",\n \"or not to return the hidden states of all layers. See `hidden_states` under\",\n \"Optional[bool] = None, training: bool = False, ) -> Union[TFBaseModelOutput, Tuple[tf.Tensor]]: \\\"\\\"\\\" Returns:\",\n \"tf.nn.l2_normalize(self.weight_v, axis=self.kernel_norm_axes) * tf.transpose(self.weight_g) self.kernel = tf.transpose(kernel) def build(self, input_shape): if not self.built:\",\n \"self.groups == -1: self.groups = dim def _check_size_of_dimensions(self, input_shape): dim = input_shape[self.axis] if\",\n \"output[tensor_name] = output[\\\"args\\\"] else: # `args` in this case is always the first\",\n \">>> # compute loss >>> target_transcription = \\\"A MAN SAID TO THE UNIVERSE\",\n \"batch num_masked_spans = int(mask_prob * sequence_length / mask_length + tf.random.uniform((1,))) num_masked_spans = max(num_masked_spans,\",\n \"= tf.keras.layers.LayerNormalization(epsilon=config.layer_norm_eps, name=\\\"layer_norm\\\") self.dropout = tf.keras.layers.Dropout(config.hidden_dropout) self.layer = [ TFHubertEncoderLayerStableLayerNorm(config, name=f\\\"layers.{i}\\\") for i\",\n \"LARGE_NEGATIVE # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2GroupNorm with Wav2Vec2->Hubert class TFHubertGroupNorm(tf.keras.layers.Layer): \\\"\\\"\\\" From tensorflow-addons https://www.tensorflow.org/addons/api_docs/python/tfa/layers/GroupNormalization\",\n \"key_value_states: Optional[tf.Tensor] = None, past_key_value: Optional[Tuple[Tuple[tf.Tensor]]] = None, attention_mask: Optional[tf.Tensor] = None, layer_head_mask:\",\n \"inputs[\\\"return_dict\\\"]: return (hidden_states,) + encoder_outputs[1:] return TFBaseModelOutput( last_hidden_state=hidden_states, hidden_states=encoder_outputs.hidden_states, attentions=encoder_outputs.attentions, ) class TFHubertPreTrainedModel(TFPreTrainedModel):\",\n \"False) -> tf.Tensor: hidden_states = self.intermediate_dense(hidden_states) hidden_states = self.intermediate_act_fn(hidden_states) hidden_states = self.intermediate_dropout(hidden_states, training=training)\",\n \"or not to use the model in training mode (some modules like dropout\",\n \"= _compute_mask_indices( (batch_size, hidden_size), mask_prob=self.config.mask_feature_prob, mask_length=self.config.mask_feature_length, ) hidden_states = tf.where(mask_feature_indices[:, tf.newaxis, :], hidden_states,\",\n \"output_attentions (`bool`, *optional*): Whether or not to return the attentions tensors of all\",\n \"(hidden_states,) if not return_dict: return tuple(v for v in [hidden_states, all_hidden_states, all_self_attentions] if\",\n \"group_shape def _apply_normalization(self, reshaped_inputs, input_shape): group_shape = tf.keras.backend.int_shape(reshaped_inputs) group_reduction_axes = list(range(1, len(group_shape))) is_instance_norm\",\n \"(CTC).\\\"\\\"\\\", HUBERT_START_DOCSTRING, ) class TFHubertForCTC(TFHubertPreTrainedModel): def __init__(self, config: HubertConfig, *inputs, **kwargs): super().__init__(config, *inputs,\",\n \"# have to be disabled in other modes than eager. if tf.executing_eagerly(): tf.debugging.assert_equal(\",\n \"transform batch_indices to pair_indices pair_indices = tf.transpose(tf.concat([broad_casted_batch_dims, tf.reshape(batch_indices, [1, -1])], 0)) # scatter\",\n \"method to load the model weights. \\\"\\\"\\\" HUBERT_INPUTS_DOCSTRING = r\\\"\\\"\\\" Args: input_values (`np.ndarray`,\",\n \"is_decoder self.k_proj = tf.keras.layers.Dense(embed_dim, use_bias=bias, name=\\\"k_proj\\\") self.q_proj = tf.keras.layers.Dense(embed_dim, use_bias=bias, name=\\\"q_proj\\\") self.v_proj =\",\n \"`embed_dim`: {self.embed_dim}\\\" f\\\" and `num_heads`: {num_heads}).\\\" ) self.scaling = self.head_dim**-0.5 self.is_decoder = is_decoder\",\n \"inputs. Indices are selected in `[0, 1]`: - 0 corresponds to a *sentence\",\n \"tf.keras.layers.Conv1D( filters=self.out_conv_dim, kernel_size=config.conv_kernel[layer_id], strides=config.conv_stride[layer_id], use_bias=config.conv_bias, name=\\\"conv\\\", ) self.activation = get_tf_activation(config.feat_extract_activation) self.layer_norm = TFHubertGroupNorm(groups=self.out_conv_dim,\",\n \"attention_mask=attention_mask, output_attentions=inputs[\\\"output_attentions\\\"], output_hidden_states=inputs[\\\"output_hidden_states\\\"], return_dict=inputs[\\\"return_dict\\\"], training=inputs[\\\"training\\\"], ) hidden_states = encoder_outputs[0] if not inputs[\\\"return_dict\\\"]: return\",\n \"\\\"\\\"\\\"Generate normalized weights.\\\"\\\"\\\" kernel = tf.nn.l2_normalize(self.weight_v, axis=self.kernel_norm_axes) * tf.transpose(self.weight_g) self.kernel = tf.transpose(kernel) def\",\n \"layers. See `hidden_states` under returned tensors for more detail. This argument can be\",\n \"tf.newaxis], tf.bool), self.masked_spec_embed[tf.newaxis, tf.newaxis, :], hidden_states, ) elif self.config.mask_time_prob > 0: # generate\",\n \"the booleans. In case of a list of symbolic inputs, each input has\",\n \"def __init__(self, config: HubertConfig, *inputs, **kwargs): super().__init__(config, *inputs, **kwargs) self.config = config self.hubert\",\n \"hidden_states = self.layer_norm(hidden_states) hidden_states = self.projection(hidden_states) hidden_states = self.dropout(hidden_states, training=training) return hidden_states #\",\n \"= tf.matmul(query_states, key_states, transpose_b=True) # The tf.debugging asserts are not compliant with XLA\",\n \"in compliance with the License. # You may obtain a copy of the\",\n \"License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or\",\n \"// self.groups) == 1 if not is_instance_norm: outputs = tf.reshape(normalized_inputs, tensor_input_shape) else: outputs\",\n \"regular TF 2.0 Keras Model and refer to the TF 2.0 documentation for\",\n \"shape=(self.filters,), initializer=\\\"zeros\\\", trainable=True) def call(self, inputs): if not self.initialized: self._init_norm() self.initialized = True\",\n \"config.vocab_size]` Returns: Example: ```python >>> import tensorflow as tf >>> from transformers import\",\n \"hidden_states=encoder_outputs.hidden_states, attentions=encoder_outputs.attentions, ) class TFHubertPreTrainedModel(TFPreTrainedModel): \\\"\\\"\\\" An abstract class to handle weights initialization\",\n \"self.num_heads, tgt_len, src_len)}, but is {shape_list(attn_weights)}\\\", ) if attention_mask is not None: #\",\n \"padding token indices. Mask values selected in `[0, 1]`: - 1 for tokens\",\n \"filters, kernel_size, groups, explicit_padding, **kwargs): super().__init__( filters=filters, kernel_size=kernel_size, groups=groups, padding=\\\"valid\\\", use_bias=True, bias_initializer=\\\"he_normal\\\", **kwargs,\",\n \"= input_values_processing( func=self.call, config=self.config, input_values=input_values, attention_mask=attention_mask, token_type_ids=token_type_ids, position_ids=position_ids, head_mask=head_mask, inputs_embeds=inputs_embeds, output_attentions=output_attentions, output_hidden_states=output_hidden_states, return_dict=return_dict,\",\n \"get_tf_activation(config.feat_extract_activation) def call(self, hidden_states: tf.Tensor) -> tf.Tensor: hidden_states = self.conv(hidden_states) hidden_states = self.activation(hidden_states)\",\n \"GPU or a TPU\\\" ) @tf.function def serving(self, inputs): output = self.call(input_values=inputs, training=False)\",\n \"not allowed only {allowed_types} is accepted for {parameter_names[0]}.\\\" ) for name in parameter_names:\",\n \"= tf.keras.layers.LayerNormalization(epsilon=config.layer_norm_eps, name=\\\"layer_norm\\\") self.projection = tf.keras.layers.Dense( units=config.hidden_size, kernel_initializer=get_initializer(config.initializer_range), bias_initializer=\\\"zeros\\\", name=\\\"projection\\\", ) self.dropout =\",\n \"self.out_conv_dim = config.conv_dim[layer_id] self.conv = tf.keras.layers.Conv1D( filters=self.out_conv_dim, kernel_size=config.conv_kernel[layer_id], strides=config.conv_stride[layer_id], use_bias=config.conv_bias, name=\\\"conv\\\", ) self.layer_norm\",\n \"# Batch size 1 >>> hidden_states = model(input_values).last_hidden_state ```\\\"\\\"\\\" inputs = input_values_processing( func=self.call,\",\n \"return_dict: Optional[bool] = None, training: Optional[bool] = False, ) -> Union[TFCausalLMOutput, Tuple[tf.Tensor]]: r\\\"\\\"\\\"\",\n \") -> Tuple[tf.Tensor, Optional[tf.Tensor]]: \\\"\\\"\\\"Input shape: Batch x Time x Channel\\\"\\\"\\\" # if\",\n \"import get_tf_activation from ...modeling_tf_outputs import TFBaseModelOutput, TFCausalLMOutput from ...modeling_tf_utils import TFPreTrainedModel, booleans_processing, get_initializer,\",\n \"the input of each TensorFlow model including the booleans. In case of a\",\n \">>> ds = ds.map(map_to_array) >>> input_values = processor(ds[\\\"speech\\\"][0], return_tensors=\\\"tf\\\").input_values # Batch size 1\",\n \"with Wav2Vec2->Hubert class TFHubertFeedForward(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs): super().__init__(**kwargs) self.intermediate_dropout = tf.keras.layers.Dropout(config.activation_dropout)\",\n \"model. **kwargs: The inputs of the model. Returns: Two lists, one for the\",\n \"input has to be named accordingly to the parameters name, i.e. `input_values =\",\n \"return (one_cst - expanded_mask) * LARGE_NEGATIVE # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2GroupNorm with Wav2Vec2->Hubert class\",\n \"0: hidden_states = hidden_states[:, : -self.num_pad_remove, :] return hidden_states class TFHubertFeatureEncoder(tf.keras.layers.Layer): def __init__(self,\",\n \"model, you need a GPU or a TPU\\\" ) @tf.function def serving(self, inputs):\",\n \"input_shape[self.axis] if dim < self.groups: raise ValueError( \\\"Number of groups (\\\" + str(self.groups)\",\n \"Optional[tf.Tensor] = None): \\\"\\\"\\\" Masks extracted features along time axis and/or along feature\",\n \"get_config(self): config = { \\\"groups\\\": self.groups, \\\"axis\\\": self.axis, \\\"epsilon\\\": self.epsilon, \\\"center\\\": self.center, \\\"scale\\\":\",\n \"+ encoder_outputs[1:] return TFBaseModelOutput( last_hidden_state=hidden_states, hidden_states=encoder_outputs.hidden_states, attentions=encoder_outputs.attentions, ) class TFHubertPreTrainedModel(TFPreTrainedModel): \\\"\\\"\\\" An abstract\",\n \"input else: raise ValueError( f\\\"Data of type {type(input)} is not allowed only {allowed_types}\",\n \"training. \\\"\\\"\\\" warnings.warn( \\\"The method `freeze_feature_extractor` is deprecated and will be removed in\",\n \"(0, 2, 1, 3)) def call( self, hidden_states: tf.Tensor, key_value_states: Optional[tf.Tensor] = None,\",\n \"1, 3)) def call( self, hidden_states: tf.Tensor, key_value_states: Optional[tf.Tensor] = None, past_key_value: Optional[Tuple[Tuple[tf.Tensor]]]\",\n \"tf.Tensor: hidden_states = self.intermediate_dense(hidden_states) hidden_states = self.intermediate_act_fn(hidden_states) hidden_states = self.intermediate_dropout(hidden_states, training=training) hidden_states =\",\n \"Calling this function will disable the gradient computation for the feature encoder so\",\n \"If you choose this second option, there are three possibilities you can use\",\n \"is not allowed only {allowed_types} is accepted for {parameter_names[0]}.\\\" ) for name in\",\n \"(`bool`, *optional*): Whether or not to return the hidden states of all layers.\",\n \"self._shape(self.v_proj(key_value_states), -1, bsz) elif past_key_value is not None: # reuse k, v, self_attention\",\n \"tf.convert_to_tensor(output.attentions) if self.config.output_attentions else None return TFBaseModelOutput(last_hidden_state=output.last_hidden_state, hidden_states=hs, attentions=attns) @add_start_docstrings( \\\"\\\"\\\"TFHubert Model with\",\n \"tgt_len, embed_dim = shape_list(hidden_states) # get query proj query_states = self.q_proj(hidden_states) * self.scaling\",\n \"**kwargs: Any) -> None: super().__init__(**kwargs) self.conv = TFHubertWeightNormConv1D( filters=config.hidden_size, kernel_size=config.num_conv_pos_embeddings, groups=config.num_conv_pos_embedding_groups, explicit_padding=config.num_conv_pos_embeddings //\",\n \"self.groups = groups self.axis = axis self.epsilon = epsilon self.center = center self.scale\",\n \"hidden_states = outputs[0] hidden_states = self.dropout(hidden_states, training=inputs[\\\"training\\\"]) logits = self.lm_head(hidden_states) if labels is\",\n \"None and type(output[\\\"args\\\"]) == tf.Tensor: tensor_name = output[\\\"args\\\"].name.split(\\\":\\\")[0] output[tensor_name] = output[\\\"args\\\"] else: #\",\n \"key_states = self._shape(self.k_proj(hidden_states), -1, bsz) value_states = self._shape(self.v_proj(hidden_states), -1, bsz) if self.is_decoder: #\",\n \"layer_id=0, name=f\\\"conv_layers.{0}\\\")] + [ TFHubertNoLayerNormConvLayer(config, layer_id=i + 1, name=f\\\"conv_layers.{i+1}\\\") for i in range(config.num_feat_extract_layers\",\n \"\\\"\\\"\\\" def __init__( self, groups: int = 32, axis: int = -1, epsilon:\",\n \"outputs # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2Encoder with Wav2Vec2->Hubert class TFHubertEncoder(tf.keras.layers.Layer): def __init__(self, config: HubertConfig,\",\n \"avoid performing attention on padding token indices. Mask values selected in `[0, 1]`:\",\n \"tf.ones((batch_size, sequence_length - (mask_length - 1))) # get random indices to mask spec_aug_mask_idxs\",\n \"to be disabled in other modes than eager. if tf.executing_eagerly(): tf.debugging.assert_equal( shape_list(attention_mask), [bsz,\",\n \"main_input_name = \\\"input_values\\\" @property def dummy_inputs(self) -> Dict[str, tf.Tensor]: pad_token = 0.0 input_values\",\n \"the parameters of the model. Initializing with a config file does not load\",\n \"TFHubertMainLayer(config, name=\\\"hubert\\\") self.dropout = tf.keras.layers.Dropout(config.final_dropout) self.lm_head = tf.keras.layers.Dense(config.vocab_size, name=\\\"lm_head\\\") def freeze_feature_extractor(self): \\\"\\\"\\\" Calling\",\n \"as downloading or saving, resizing the input embeddings, pruning heads etc.) This model\",\n \"ValueError( \\\"Number of groups (\\\" + str(self.groups) + \\\") must be a \\\"\",\n \"(`np.ndarray`, `tf.Tensor`, `List[tf.Tensor]` ``Dict[str, tf.Tensor]` or `Dict[str, np.ndarray]` and each example must have\",\n \"bias_initializer=\\\"zeros\\\", name=\\\"projection\\\", ) self.dropout = tf.keras.layers.Dropout(rate=config.feat_proj_dropout) def call(self, hidden_states: tf.Tensor, training: bool =\",\n \"return hidden_states # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2GroupNormConvLayer with Wav2Vec2->Hubert class TFHubertGroupNormConvLayer(tf.keras.layers.Layer): def __init__(self, config:\",\n \"self.layer_norm(hidden_states) hidden_states = self.projection(hidden_states) hidden_states = self.dropout(hidden_states, training=training) return hidden_states # Copied from\",\n \"and behavior. <Tip> TF 2.0 models accepts two formats as inputs: - having\",\n \"bare TFHubert Model transformer outputing raw hidden-states without any specific head on top.\\\",\",\n \"modes than eager. if tf.executing_eagerly(): tf.debugging.assert_equal( shape_list(attn_weights), [bsz * self.num_heads, tgt_len, src_len], message=f\\\"Attention\",\n \"from transformers.models.wav2vec2.modeling_tf_wav2vec2._sample_without_replacement def _sample_without_replacement(distribution, num_samples): \\\"\\\"\\\" Categorical sampling without replacement is currently not\",\n \"padding=\\\"valid\\\", use_bias=True, bias_initializer=\\\"he_normal\\\", **kwargs, ) self.explicit_padding = explicit_padding self.filter_axis = 2 self.initialized =\",\n \"this percentage of all elements. however due to overlaps, the actual number will\",\n \"\\\" + str(input_shape) + \\\".\\\" ) def _set_number_of_groups_for_instance_norm(self, input_shape): dim = input_shape[self.axis] if\",\n \"training=inputs[\\\"training\\\"]) mask_time_indices = kwargs.get(\\\"mask_time_indices\\\", None) if inputs[\\\"training\\\"]: hidden_states = self._mask_hidden_states(hidden_states, mask_time_indices=mask_time_indices) encoder_outputs =\",\n \"self.dropout = tf.keras.layers.Dropout(rate=config.feat_proj_dropout) def call(self, hidden_states: tf.Tensor, training: bool = False) -> tf.Tensor:\",\n \"+ \\\") cannot be \\\" \\\"more than the number of channels (\\\" +\",\n \"mask span to mask approximately this percentage of all elements. however due to\",\n \"indices to mask spec_aug_mask_idxs = _sample_without_replacement(uniform_dist, num_masked_spans) # expand masked indices to masked\",\n \"v, self_attention key_states = self._shape(self.k_proj(hidden_states), -1, bsz) value_states = self._shape(self.v_proj(hidden_states), -1, bsz) key_states\",\n \"def get_config(self): config = { \\\"groups\\\": self.groups, \\\"axis\\\": self.axis, \\\"epsilon\\\": self.epsilon, \\\"center\\\": self.center,\",\n \"since TF 2.7, so we need to account for padding input_shape[-2] += self.explicit_padding\",\n \"tf.Variable(tf.transpose(self.kernel), name=\\\"weight_v\\\", trainable=True) self.weight_v = self.kernel self.weight_g = self.add_weight( name=\\\"weight_g\\\", shape=(int(self.weight_v.shape[self.filter_axis]), 1, 1),\",\n \"[tensor_input_shape[i] for i in range(len(input_shape))] is_instance_norm = (input_shape[self.axis] // self.groups) == 1 if\",\n \"currently not implemented. The gumbel-max trick will do for now - see https://github.com/tensorflow/tensorflow/issues/9260\",\n \"generic methods the library implements for all its model (such as downloading or\",\n \"return the hidden states of all layers. See `hidden_states` under returned tensors for\",\n \"num_conv_pos_embeddings % 2 == 0 else 0 def call(self, hidden_states): if self.num_pad_remove >\",\n \"to be smaller than `sequence_length`, but got `mask_length`: {mask_length} and `sequence_length`: {sequence_length}`\\\" )\",\n \"Optional[tf.Tensor] = None, return_dict: Optional[bool] = None, training: bool = False, **kwargs: Any,\",\n \"tf.reshape(attn_weights, (bsz * self.num_heads, tgt_len, src_len)) attn_probs = self.dropout(attn_weights, training=training) attn_output = tf.matmul(attn_probs,\",\n \"Returns: Example: ```python >>> from transformers import Wav2Vec2Processor, TFHubertModel >>> from datasets import\",\n \") else: self.gamma = None def _add_beta_weight(self, input_shape): dim = input_shape[self.axis] shape =\",\n \"under returned tensors for more detail. This argument can be used only in\",\n \"else: if isinstance(input_values, tf.Tensor) or input_values is None: output[parameter_names[0]] = input_values else: raise\",\n \"training=training, ) hidden_states = layer_outputs[0] if output_attentions: all_self_attentions = all_self_attentions + (layer_outputs[1],) hidden_states\",\n \"HubertConfig, **kwargs): super().__init__(**kwargs) self.layer_norm = tf.keras.layers.LayerNormalization(epsilon=config.layer_norm_eps, name=\\\"layer_norm\\\") self.projection = tf.keras.layers.Dense( units=config.hidden_size, kernel_initializer=get_initializer(config.initializer_range), bias_initializer=\\\"zeros\\\",\",\n \"= output[\\\"args\\\"] else: # `args` in this case is always the first parameter,\",\n \"self.filter_axis = 2 self.initialized = False self.kernel_norm_axes = tf.constant([0, 1]) def _init_norm(self): \\\"\\\"\\\"Set\",\n \"name=\\\"feed_forward\\\") self.final_layer_norm = tf.keras.layers.LayerNormalization( epsilon=config.layer_norm_eps, name=\\\"final_layer_norm\\\" ) def call( self, hidden_states: tf.Tensor, attention_mask:\",\n \"self.q_proj = tf.keras.layers.Dense(embed_dim, use_bias=bias, name=\\\"q_proj\\\") self.v_proj = tf.keras.layers.Dense(embed_dim, use_bias=bias, name=\\\"v_proj\\\") self.out_proj = tf.keras.layers.Dense(embed_dim,\",\n \"in the first positional argument : - a single Tensor with `input_values` only\",\n \"tgt_len, self.head_dim)}, but is {shape_list(attn_output)}\\\", ) attn_output = tf.transpose( tf.reshape(attn_output, (bsz, self.num_heads, tgt_len,\",\n \"the number of channels (\\\" + str(dim) + \\\").\\\" ) def _check_axis(self): if\",\n \"__init__(self, config: HubertConfig, **kwargs: Any) -> None: super().__init__(**kwargs) if config.feat_extract_norm == \\\"group\\\": conv_layers\",\n \"etc.) This model is also a [tf.keras.Model](https://www.tensorflow.org/api_docs/python/tf/keras/Model) subclass. Use it as a regular\",\n \"config.feat_extract_norm == \\\"group\\\": conv_layers = [TFHubertGroupNormConvLayer(config, layer_id=0, name=f\\\"conv_layers.{0}\\\")] + [ TFHubertNoLayerNormConvLayer(config, layer_id=i +\",\n \"if not inputs[\\\"return_dict\\\"]: output = (logits,) + outputs[1:] return ((loss,) + output) if\",\n \"use to gather all the input Tensors in the first positional argument :\",\n \"self.num_heads, self.head_dim)), (0, 2, 1, 3)) def call( self, hidden_states: tf.Tensor, key_value_states: Optional[tf.Tensor]\",\n \"+ str(dim) + \\\").\\\" ) def _check_axis(self): if self.axis == 0: raise ValueError(\",\n \"divisible by num_heads (got `embed_dim`: {self.embed_dim}\\\" f\\\" and `num_heads`: {num_heads}).\\\" ) self.scaling =\",\n \"*optional*): Segment token indices to indicate first and second portions of the inputs.\",\n \"= self.layer_norm(hidden_states) hidden_states = self.dropout(hidden_states, training=training) for i, layer_module in enumerate(self.layer): if output_hidden_states:\",\n \"tf.keras.backend.int_shape(reshaped_inputs) group_reduction_axes = list(range(1, len(group_shape))) is_instance_norm = (input_shape[self.axis] // self.groups) == 1 if\",\n \"not getattr(self.config, \\\"apply_spec_augment\\\", True): return hidden_states if mask_time_indices is not None: # apply\",\n \"In case of a list of symbolic inputs, each input has to be\",\n \"raise ValueError( \\\"Axis \\\" + str(self.axis) + \\\" of \\\" \\\"input tensor should\",\n \") attn_weights = tf.reshape(attn_weights, (bsz * self.num_heads, tgt_len, src_len)) attn_probs = self.dropout(attn_weights, training=training)\",\n \"`hidden_states` under returned tensors for more detail. This argument can be used only\",\n \"import TFBaseModelOutput, TFCausalLMOutput from ...modeling_tf_utils import TFPreTrainedModel, booleans_processing, get_initializer, keras_serializable from ...tf_utils import\",\n \"2 == 0 else 0 def call(self, hidden_states): if self.num_pad_remove > 0: hidden_states\",\n \"then `input_values` output[\\\"input_values\\\"] = output[\\\"args\\\"] del output[\\\"args\\\"] if \\\"kwargs\\\" in output: del output[\\\"kwargs\\\"]\",\n \"This argument can be used only in eager mode, in graph mode the\",\n \"variance=variance, scale=gamma, offset=beta, variance_epsilon=self.epsilon, ) return normalized_inputs def _get_reshaped_weights(self, input_shape): broadcast_shape = self._create_broadcast_shape(input_shape)\",\n \"v else: raise ValueError(f\\\"Data of type {type(v)} is not allowed only {allowed_types} is\",\n \"tf.keras.layers.Dropout(config.hidden_dropout) self.layer_norm = tf.keras.layers.LayerNormalization(epsilon=config.layer_norm_eps, name=\\\"layer_norm\\\") self.feed_forward = TFHubertFeedForward(config, name=\\\"feed_forward\\\") self.final_layer_norm = tf.keras.layers.LayerNormalization( epsilon=config.layer_norm_eps,\",\n \"output_hidden_states: Optional[bool] = None, return_dict: Optional[bool] = None, training: Optional[bool] = False, )\",\n \"i, input in enumerate(input_values): # EagerTensors don't allow to use the .name property\",\n \"smaller (unless no_overlap is True) mask_length: size of the mask min_masks: minimum number\",\n \") attn_weights = tf.reshape(layer_head_mask, (1, -1, 1, 1)) * tf.reshape( attn_weights, (bsz, self.num_heads,\",\n \"proj_shape) src_len = shape_list(key_states)[1] attn_weights = tf.matmul(query_states, key_states, transpose_b=True) # The tf.debugging asserts\",\n \"Tensor names have always the pattern `name:id` then we check only the #\",\n \"layer output length formula taken # from https://pytorch.org/docs/stable/generated/torch.nn.Conv1d.html return (input_length - kernel_size) //\",\n \"Classification (CTC).\\\"\\\"\\\", HUBERT_START_DOCSTRING, ) class TFHubertForCTC(TFHubertPreTrainedModel): def __init__(self, config: HubertConfig, *inputs, **kwargs): super().__init__(config,\",\n \"self._shape(self.v_proj(hidden_states), -1, bsz) key_states = tf.concat([past_key_value[0], key_states], axis=2) value_states = tf.concat([past_key_value[1], value_states], axis=2)\",\n \"raw hidden-states without any specific head on top.\\\", HUBERT_START_DOCSTRING, ) class TFHubertModel(TFHubertPreTrainedModel): def\",\n \"= tf.ones((batch_size, sequence_length - (mask_length - 1))) # get random indices to mask\",\n \"projected key/value_states (third \\\"elif\\\" case) # if encoder bi-directional self-attention `past_key_value` is always\",\n \"than eager. if tf.executing_eagerly(): tf.debugging.assert_equal( shape_list(attention_mask), [bsz, 1, tgt_len, src_len], message=f\\\"Attention mask should\",\n \"= 0, ) -> tf.Tensor: \\\"\\\"\\\" Computes random mask spans for a given\",\n \"kernel_initializer=get_initializer(config.initializer_range), bias_initializer=\\\"zeros\\\", name=\\\"projection\\\", ) self.dropout = tf.keras.layers.Dropout(rate=config.feat_proj_dropout) def call(self, hidden_states: tf.Tensor, training: bool\",\n \"name=\\\"out_proj\\\") def _shape(self, tensor: tf.Tensor, seq_len: int, bsz: int): return tf.transpose(tf.reshape(tensor, (bsz, seq_len,\",\n \"None, attention_mask: Optional[tf.Tensor] = None, layer_head_mask: Optional[tf.Tensor] = None, training: Optional[bool] = False,\",\n \"second portions of the inputs. Indices are selected in `[0, 1]`: - 0\",\n \"Any) -> None: super().__init__(**kwargs) self.in_conv_dim = config.conv_dim[layer_id] if layer_id > 0 else 1\",\n \"= None def _create_broadcast_shape(self, input_shape): broadcast_shape = [1] * len(input_shape) is_instance_norm = (input_shape[self.axis]\",\n \"= self.dropout(attn_weights, training=training) attn_output = tf.matmul(attn_probs, value_states) # The tf.debugging asserts are not\",\n \"output_hidden_states=inputs[\\\"output_hidden_states\\\"], return_dict=inputs[\\\"return_dict\\\"], training=inputs[\\\"training\\\"], ) return outputs def serving_output(self, output): hs = tf.convert_to_tensor(output.hidden_states) if\",\n \"return broadcast_shape # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2WeightNormConv1D with Wav2Vec2->Hubert class TFHubertWeightNormConv1D(tf.keras.layers.Conv1D): \\\"\\\"\\\"Adapted from https://www.tensorflow.org/probability/api_docs/python/tfp/layers/weight_norm/WeightNorm\\\"\\\"\\\"\",\n \"# for the decoder is_cross_attention = key_value_states is not None bsz, tgt_len, embed_dim\",\n \"* tf.expand_dims(attention_mask, -1) attention_mask = _expand_mask(attention_mask) else: attention_mask = None position_embeddings = self.pos_conv_embed(hidden_states)\",\n \"initializer=\\\"ones\\\", dtype=self.weight_v.dtype, trainable=True, ) self.bias = self.add_weight(name=\\\"bias\\\", shape=(self.filters,), initializer=\\\"zeros\\\", trainable=True) def call(self, inputs):\",\n \"the model's internal embedding lookup matrix. output_attentions (`bool`, *optional*): Whether or not to\",\n \"# Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2SamePadLayer with Wav2Vec2->Hubert class TFHubertSamePadLayer(tf.keras.layers.Layer): def __init__(self, num_conv_pos_embeddings, **kwargs): super().__init__(**kwargs)\",\n \"received an input with shape \\\" + str(input_shape) + \\\".\\\" ) def _set_number_of_groups_for_instance_norm(self,\",\n \"allowed only {allowed_types} is accepted for {k}.\\\") if isinstance(input_values, (tuple, list)): for i,\",\n \"in range(config.num_feat_extract_layers - 1) ] elif config.feat_extract_norm == \\\"layer\\\": conv_layers = [ TFHubertLayerNormConvLayer(config,\",\n \"tensors in the first argument of the model call function: `model(inputs)`. If you\",\n \"f\\\"embed_dim must be divisible by num_heads (got `embed_dim`: {self.embed_dim}\\\" f\\\" and `num_heads`: {num_heads}).\\\"\",\n \"to be disabled in other modes than eager. if tf.executing_eagerly(): tf.debugging.assert_equal( shape_list(attn_weights), [bsz\",\n \"tf.expand_dims(input_values, -1) for conv_layer in self.conv_layers: hidden_states = conv_layer(hidden_states) return hidden_states class TFHubertFeatureExtractor(TFHubertFeatureEncoder):\",\n \"self.layer_norm = TFHubertGroupNorm(groups=self.out_conv_dim, epsilon=config.layer_norm_eps, name=\\\"layer_norm\\\") def call(self, hidden_states: tf.Tensor) -> tf.Tensor: hidden_states =\",\n \"output_hidden_states: all_hidden_states = all_hidden_states + (hidden_states,) # add LayerDrop (see https://arxiv.org/abs/1909.11556 for description)\",\n \"indices & apply SpecAugment along time axis mask_time_indices = _compute_mask_indices( (batch_size, sequence_length), mask_prob=self.config.mask_time_prob,\",\n \"bsz) value_states = self._shape(self.v_proj(hidden_states), -1, bsz) if self.is_decoder: # if cross_attention save Tuple(tf.Tensor,\",\n \"of size {(bsz, self.num_heads, tgt_len, self.head_dim)}, but is {shape_list(attn_output)}\\\", ) attn_output = tf.transpose(\",\n \"inputs of the model. Returns: Two lists, one for the missing layers, and\",\n \"else 0 def call(self, hidden_states): if self.num_pad_remove > 0: hidden_states = hidden_states[:, :\",\n \") output[\\\"past_key_values\\\"] = input_values.pop(\\\"decoder_cached_states\\\") for k, v in dict(input_values).items(): if isinstance(v, allowed_types) or\",\n \"in other modes than eager. if tf.executing_eagerly(): tf.debugging.assert_equal( shape_list(attn_output), [bsz * self.num_heads, tgt_len,\",\n \"tf.matmul(attn_probs, value_states) # The tf.debugging asserts are not compliant with XLA then they\",\n \"1 if not is_instance_norm: axis = -2 if self.axis == -1 else self.axis\",\n \"`({0})`): Indices of input sequence tokens in the vocabulary. Indices can be obtained\",\n \"\\\"\\\"\\\"Input shape: Batch x Time x Channel\\\"\\\"\\\" # if key_value_states are provided this\",\n \"the inputs. Indices are selected in `[0, 1]`: - 0 corresponds to a\",\n \"self.conv_layers = conv_layers def call(self, input_values): hidden_states = tf.expand_dims(input_values, -1) for conv_layer in\",\n \"not return_dict: return tuple(v for v in [hidden_states, all_hidden_states, all_self_attentions] if v is\",\n \"src_len)) + attention_mask attn_weights = tf.reshape(attn_weights, (bsz * self.num_heads, tgt_len, src_len)) attn_weights =\",\n \"pruning heads etc.) This model is also a [tf.keras.Model](https://www.tensorflow.org/api_docs/python/tf/keras/Model) subclass. Use it as\",\n \"for conv_layer in self.conv_layers: hidden_states = conv_layer(hidden_states) return hidden_states class TFHubertFeatureExtractor(TFHubertFeatureEncoder): def __init__(self,\",\n \"of size {(bsz * self.num_heads, tgt_len, src_len)}, but is {shape_list(attn_weights)}\\\", ) if attention_mask\",\n \"self.head_dim)), (0, 2, 1, 3) ) attn_output = tf.reshape(attn_output, (bsz, tgt_len, embed_dim)) attn_output\",\n \"self.config.output_hidden_states else None attns = tf.convert_to_tensor(output.attentions) if self.config.output_attentions else None return TFBaseModelOutput(last_hidden_state=output.last_hidden_state, hidden_states=hs,\",\n \"single layer should be of size {(self.num_heads)}, but is {shape_list(layer_head_mask)}\\\", ) attn_weights =\",\n \"attention_mask: Optional[tf.Tensor] = None, layer_head_mask: Optional[tf.Tensor] = None, training: Optional[bool] = False, )\",\n \"config.vocab_size]` (see `input_values` docstring) Tokens with indices set to `-100` are ignored (masked),\",\n \"if self.is_decoder: # if cross_attention save Tuple(tf.Tensor, tf.Tensor) of all cross attention key/value_states.\",\n \"to `False``): Whether or not to use the model in training mode (some\",\n \"training=training, kwargs_call=kwargs, ) hidden_states = self.feature_extractor( tf.cast(inputs[\\\"input_values\\\"], tf.float32), training=inputs[\\\"training\\\"] ) if inputs[\\\"attention_mask\\\"] is\",\n \"Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2NoLayerNormConvLayer with Wav2Vec2->Hubert class TFHubertNoLayerNormConvLayer(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, layer_id: int\",\n \"each TensorFlow model including the booleans. In case of a list of symbolic\",\n \"-> None: super().__init__(**kwargs) if config.feat_extract_norm == \\\"group\\\": conv_layers = [TFHubertGroupNormConvLayer(config, layer_id=0, name=f\\\"conv_layers.{0}\\\")] +\",\n \"return_dict (`bool`, *optional*): Whether or not to return a [`~file_utils.ModelOutput`] instead of a\",\n \"if dim is None: raise ValueError( \\\"Axis \\\" + str(self.axis) + \\\" of\",\n \"bsz) elif past_key_value is not None: # reuse k, v, self_attention key_states =\",\n \"Optional[tf.Tensor] = None, output_attentions: Optional[bool] = False, training: bool = False, ) ->\",\n \") for name in parameter_names: if name not in list(output.keys()) and name !=\",\n \"transformers.models.bart.modeling_tf_bart.TFBartAttention with TFBart->TFHubert class TFHubertAttention(tf.keras.layers.Layer): \\\"\\\"\\\"Multi-headed attention from \\\"Attention Is All You Need\\\"\\\"\\\"\",\n \"labels >>> with processor.as_target_processor(): ... labels = processor(transcription, return_tensors=\\\"tf\\\").input_values >>> loss = model(input_values,\",\n \"\\\"input_values\\\": input_values, \\\"attention_mask\\\": tf.cast(tf.not_equal(input_values, pad_token), tf.float32), } return dummy_inputs def __init__(self, config, *inputs,\",\n \"transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2PositionalConvEmbedding with Wav2Vec2->Hubert class TFHubertPositionalConvEmbedding(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs: Any) -> None:\",\n \"tensor_input_shape) else: outputs = normalized_inputs return outputs def get_config(self): config = { \\\"groups\\\":\",\n \"shape_list(attention_mask), [bsz, 1, tgt_len, src_len], message=f\\\"Attention mask should be of size {(bsz, 1,\",\n \"be used only in eager mode, in graph mode the value in the\",\n \"output_attentions: all_self_attentions = all_self_attentions + (layer_outputs[1],) # Add last layer if output_hidden_states: all_hidden_states\",\n \"transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2LayerNormConvLayer with Wav2Vec2->Hubert class TFHubertLayerNormConvLayer(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, layer_id: int = 0,\",\n \"in parameter_names: if name not in list(output.keys()) and name != \\\"args\\\": output[name] =\",\n \"attentions=attns) @add_start_docstrings( \\\"\\\"\\\"TFHubert Model with a `language modeling` head on top for Connectionist\",\n \"outputs def get_config(self): config = { \\\"groups\\\": self.groups, \\\"axis\\\": self.axis, \\\"epsilon\\\": self.epsilon, \\\"center\\\":\",\n \"TFHubertForCTC(TFHubertPreTrainedModel): def __init__(self, config: HubertConfig, *inputs, **kwargs): super().__init__(config, *inputs, **kwargs) self.hubert = TFHubertMainLayer(config,\",\n \"-2 if self.axis == -1 else self.axis - 1 else: axis = -1\",\n \"\\\"attention_mask\\\": tf.cast(tf.not_equal(input_values, pad_token), tf.float32), } return dummy_inputs def __init__(self, config, *inputs, **kwargs): super().__init__(config,\",\n \"return input_lengths def _mask_hidden_states(self, hidden_states: tf.Tensor, mask_time_indices: Optional[tf.Tensor] = None): \\\"\\\"\\\" Masks extracted\",\n \"{allowed_types} is accepted for {parameter_names[0]}.\\\" ) for name in parameter_names: if name not\",\n \"name=\\\"hubert\\\") @add_start_docstrings_to_model_forward(HUBERT_INPUTS_DOCSTRING) @replace_return_docstrings(output_type=TFBaseModelOutput, config_class=_CONFIG_FOR_DOC) def call( self, input_values: tf.Tensor, attention_mask: Optional[tf.Tensor] = None,\",\n \"= tf.where( tf.cast(mask_time_indices[:, :, tf.newaxis], tf.bool), self.masked_spec_embed[tf.newaxis, tf.newaxis, :], hidden_states, ) elif self.config.mask_time_prob\",\n \"in output.items() if k in [\\\"return_dict\\\", \\\"output_attentions\\\", \\\"output_hidden_states\\\", \\\"use_cache\\\"] } output.update(booleans_processing(config=config, **boolean_dict)) return\",\n \"transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2WeightNormConv1D with Wav2Vec2->Hubert class TFHubertWeightNormConv1D(tf.keras.layers.Conv1D): \\\"\\\"\\\"Adapted from https://www.tensorflow.org/probability/api_docs/python/tfp/layers/weight_norm/WeightNorm\\\"\\\"\\\" def __init__(self, filters, kernel_size, groups,\",\n \"= tf.expand_dims(input_values, -1) for conv_layer in self.conv_layers: hidden_states = conv_layer(hidden_states) return hidden_states class\",\n \"guaranteed during the training. Args: func (`callable`): The callable function of the TensorFlow\",\n \"Mask to nullify selected heads of the self-attention modules. Mask values selected in\",\n \"from transformers.models.wav2vec2.modeling_tf_wav2vec2._scatter_values_on_batch_indices def _scatter_values_on_batch_indices(values, batch_indices, output_shape): \\\"\\\"\\\" Scatter function as in PyTorch with\",\n \"are position IDs?](../glossary#position-ids) head_mask (`np.ndarray` or `tf.Tensor` of shape `(num_heads,)` or `(num_layers, num_heads)`,\",\n \"representation. This is useful if you want more control over how to convert\",\n \"hidden_states = hidden_states + self.feed_forward(hidden_states) hidden_states = self.final_layer_norm(hidden_states) outputs = (hidden_states,) if output_attentions:\",\n \"def call( self, input_values: tf.Tensor, attention_mask: Optional[tf.Tensor] = None, token_type_ids: Optional[tf.Tensor] = None,\",\n \"None, output_attentions: Optional[bool] = False, output_hidden_states: Optional[bool] = False, return_dict: Optional[bool] = True,\",\n \"bool = False, ) -> Union[TFBaseModelOutput, Tuple[tf.Tensor]]: \\\"\\\"\\\" Returns: Example: ```python >>> from\",\n \"bool = False, ) -> Tuple[tf.Tensor]: attn_residual = hidden_states hidden_states = self.layer_norm(hidden_states) hidden_states,\",\n \"use_bias=bias, name=\\\"out_proj\\\") def _shape(self, tensor: tf.Tensor, seq_len: int, bsz: int): return tf.transpose(tf.reshape(tensor, (bsz,\",\n \"num_masked_spans * mask_length > sequence_length: num_masked_spans = sequence_length // mask_length # SpecAugment mask\",\n \"be smaller than `sequence_length`, but got `mask_length`: {mask_length} and `sequence_length`: {sequence_length}`\\\" ) #\",\n \"is_instance_norm = (input_shape[self.axis] // self.groups) == 1 if not is_instance_norm: outputs = tf.reshape(normalized_inputs,\",\n \"TFHubertFeatureEncoder(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs: Any) -> None: super().__init__(**kwargs) if config.feat_extract_norm ==\",\n \"= self.projection(hidden_states) hidden_states = self.dropout(hidden_states, training=training) return hidden_states # Copied from transformers.models.bart.modeling_tf_bart.TFBartAttention with\",\n \"second option, there are three possibilities you can use to gather all the\",\n \"(attn_weights,) return outputs # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2EncoderLayerStableLayerNorm with Wav2Vec2->Hubert class TFHubertEncoderLayerStableLayerNorm(tf.keras.layers.Layer): def __init__(self,\",\n \"modeling` head on top for Connectionist Temporal Classification (CTC).\\\"\\\"\\\", HUBERT_START_DOCSTRING, ) class TFHubertForCTC(TFHubertPreTrainedModel):\",\n \"first positional argument : - a single Tensor with `input_values` only and nothing\",\n \"loss is only computed for the tokens with labels in `[0, ..., config.vocab_size]`\",\n \"but is {shape_list(attn_output)}\\\", ) attn_output = tf.transpose( tf.reshape(attn_output, (bsz, self.num_heads, tgt_len, self.head_dim)), (0,\",\n \"training=training) return hidden_states # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2EncoderLayer with Wav2Vec2->Hubert class TFHubertEncoderLayer(tf.keras.layers.Layer): def __init__(self,\",\n \"scale self.beta_initializer = tf.keras.initializers.get(beta_initializer) self.gamma_initializer = tf.keras.initializers.get(gamma_initializer) self.beta_regularizer = tf.keras.regularizers.get(beta_regularizer) self.gamma_regularizer = tf.keras.regularizers.get(gamma_regularizer)\",\n \"Optional[bool] = False, ) -> Tuple[tf.Tensor, Optional[tf.Tensor]]: \\\"\\\"\\\"Input shape: Batch x Time x\",\n \"shape `({0})`, *optional*): Segment token indices to indicate first and second portions of\",\n \"= self.hubert( input_values=inputs[\\\"input_values\\\"], attention_mask=inputs[\\\"attention_mask\\\"], token_type_ids=inputs[\\\"token_type_ids\\\"], position_ids=inputs[\\\"position_ids\\\"], head_mask=inputs[\\\"head_mask\\\"], inputs_embeds=inputs[\\\"inputs_embeds\\\"], output_attentions=inputs[\\\"output_attentions\\\"], output_hidden_states=inputs[\\\"output_hidden_states\\\"], return_dict=inputs[\\\"return_dict\\\"], training=inputs[\\\"training\\\"], )\",\n \"class TFHubertEncoder(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs): super().__init__(**kwargs) self.config = config self.pos_conv_embed =\",\n \"self.axis = axis self.epsilon = epsilon self.center = center self.scale = scale self.beta_initializer\",\n \") hidden_states = layer_outputs[0] if output_attentions: all_self_attentions = all_self_attentions + (layer_outputs[1],) hidden_states =\",\n \">>> input_values = processor(ds[\\\"speech\\\"][0], return_tensors=\\\"tf\\\").input_values # Batch size 1 >>> hidden_states = model(input_values).last_hidden_state\",\n \"are three possibilities you can use to gather all the input Tensors in\",\n \"int, dropout: float = 0.0, is_decoder: bool = False, bias: bool = True,\",\n \"is used as a cross-attention layer # for the decoder is_cross_attention = key_value_states\",\n \"with Wav2Vec2->Hubert class TFHubertEncoderStableLayerNorm(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs): super().__init__(**kwargs) self.config = config\",\n \"num_heads self.dropout = tf.keras.layers.Dropout(dropout) self.head_dim = embed_dim // num_heads if (self.head_dim * num_heads)\",\n \"np.random.uniform(0, 1) if training and (dropout_probability < self.config.layerdrop): # skip the layer continue\",\n \"and # limitations under the License. \\\"\\\"\\\" TensorFlow Hubert model.\\\"\\\"\\\" import inspect import\",\n \"= input_shape[self.axis] if self.groups == -1: self.groups = dim def _check_size_of_dimensions(self, input_shape): dim\",\n \"weights associated with the model, only the configuration. Check out the [`~PreTrainedModel.from_pretrained`] method\",\n \"Union[TFBaseModelOutput, Tuple[tf.Tensor]]: all_hidden_states = () if output_hidden_states else None all_self_attentions = () if\",\n \"mode, in graph mode the value will always be set to True. training\",\n \"ds = ds.map(map_to_array) >>> input_values = processor(ds[\\\"speech\\\"][0], return_tensors=\\\"tf\\\").input_values # Batch size 1 >>>\",\n \"output_hidden_states=output_hidden_states, return_dict=return_dict, training=training, ) inputs[\\\"output_hidden_states\\\"] = ( inputs[\\\"output_hidden_states\\\"] if inputs[\\\"output_hidden_states\\\"] else self.config.output_hidden_states )\",\n \"r\\\"\\\"\\\" This model inherits from [`TFPreTrainedModel`]. Check the superclass documentation for the generic\",\n \"outputs += (attn_weights,) return outputs # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2EncoderLayerStableLayerNorm with Wav2Vec2->Hubert class TFHubertEncoderLayerStableLayerNorm(tf.keras.layers.Layer):\",\n \">>> processor = Wav2Vec2Processor.from_pretrained(\\\"facebook/hubert-base-960h\\\") >>> model = TFHubertForCTC.from_pretrained(\\\"facebook/hubert-base-960h\\\") >>> def map_to_array(batch): ... speech,\",\n \"(unless no_overlap is True) mask_length: size of the mask min_masks: minimum number of\",\n \"= None beta = None if self.scale: gamma = tf.reshape(self.gamma, broadcast_shape) if self.center:\",\n \"`np.ndarray` of shape `(batch_size, sequence_length)`, *optional*): Labels for computing the masked language modeling\",\n \"None, output_attentions: Optional[bool] = None, output_hidden_states: Optional[bool] = None, return_dict: Optional[bool] = None,\",\n \"name=\\\"k_proj\\\") self.q_proj = tf.keras.layers.Dense(embed_dim, use_bias=bias, name=\\\"q_proj\\\") self.v_proj = tf.keras.layers.Dense(embed_dim, use_bias=bias, name=\\\"v_proj\\\") self.out_proj =\",\n \"other modes than eager. if tf.executing_eagerly(): tf.debugging.assert_equal( shape_list(attention_mask), [bsz, 1, tgt_len, src_len], message=f\\\"Attention\",\n \"(attn_weights,) return outputs # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2Encoder with Wav2Vec2->Hubert class TFHubertEncoder(tf.keras.layers.Layer): def __init__(self,\",\n \"if mask_time_indices is not None: # apply SpecAugment along time axis with given\",\n \"\\\"The `decoder_cached_states` argument is deprecated and will be removed in a future version,\",\n \"Transformers v5.\\\" \\\"Please use the equivalent `freeze_feature_encoder` method instead.\\\", FutureWarning, ) self.freeze_feature_encoder() def\",\n \"# # Unless required by applicable law or agreed to in writing, software\",\n \"indices_shape = shape_list(batch_indices) # broadcast batch dim to indices_shape broad_casted_batch_dims = tf.reshape( tf.broadcast_to(tf.expand_dims(tf.range(indices_shape[0]),\",\n \"initializer=\\\"zeros\\\", trainable=True) def call(self, inputs): if not self.initialized: self._init_norm() self.initialized = True self._normalize_kernel()\",\n \"of input sequence tokens in the vocabulary. Indices can be obtained using [`BertTokenizer`].\",\n \"hidden_states = self.conv(hidden_states) hidden_states = self.layer_norm(hidden_states) hidden_states = self.activation(hidden_states) return hidden_states # Copied\",\n \"input_shape[self.axis] // self.groups group_shape.insert(self.axis, self.groups) group_shape = tf.stack(group_shape) reshaped_inputs = tf.reshape(inputs, group_shape) return\",\n \"`[0, 1]`: - 1 for tokens that are **not masked**, - 0 for\",\n \"to be bigger than 0.\\\") if mask_length > sequence_length: raise ValueError( f\\\"`mask_length` has\",\n \"either express or implied. # See the License for the specific language governing\",\n \"= self.pos_conv_embed(hidden_states) hidden_states = hidden_states + position_embeddings hidden_states = self.dropout(hidden_states, training=training) for i,\",\n \"HUBERT_INPUTS_DOCSTRING = r\\\"\\\"\\\" Args: input_values (`np.ndarray`, `tf.Tensor`, `List[tf.Tensor]` ``Dict[str, tf.Tensor]` or `Dict[str, np.ndarray]`\",\n \") self.layer_norm = tf.keras.layers.LayerNormalization(name=\\\"layer_norm\\\", epsilon=config.layer_norm_eps) self.activation = get_tf_activation(config.feat_extract_activation) def call(self, hidden_states: tf.Tensor) ->\",\n \"tf.Tensor) of all cross attention key/value_states. # Further calls to cross_attention layer can\",\n \"a regular TF 2.0 Keras Model and refer to the TF 2.0 documentation\",\n \"BatchEncoding from ...utils import ( ModelOutput, add_start_docstrings, add_start_docstrings_to_model_forward, logging, replace_return_docstrings, ) from .configuration_hubert\",\n \"tf.keras.layers.Dense( units=config.hidden_size, kernel_initializer=get_initializer(config.initializer_range), bias_initializer=\\\"zeros\\\", name=\\\"projection\\\", ) self.dropout = tf.keras.layers.Dropout(rate=config.feat_proj_dropout) def call(self, hidden_states: tf.Tensor,\",\n \"the License. # You may obtain a copy of the License at #\",\n \"None, training: Optional[bool] = False, ) -> Tuple[tf.Tensor, Optional[tf.Tensor]]: \\\"\\\"\\\"Input shape: Batch x\",\n \"config.conv_dim[layer_id] self.conv = tf.keras.layers.Conv1D( filters=self.out_conv_dim, kernel_size=config.conv_kernel[layer_id], strides=config.conv_stride[layer_id], use_bias=config.conv_bias, name=\\\"conv\\\", ) self.activation = get_tf_activation(config.feat_extract_activation)\",\n \"= tf.Variable(tf.transpose(self.kernel), name=\\\"weight_v\\\", trainable=True) self.weight_v = self.kernel self.weight_g = self.add_weight( name=\\\"weight_g\\\", shape=(int(self.weight_v.shape[self.filter_axis]), 1,\",\n \"creating a SavedModel TF calls the method with LayerCall.__call__(args, **kwargs) # So to\",\n \"to return the hidden states of all layers. See `hidden_states` under returned tensors\",\n \"TFHubertPositionalConvEmbedding(config, name=\\\"pos_conv_embed\\\") self.layer_norm = tf.keras.layers.LayerNormalization(epsilon=config.layer_norm_eps, name=\\\"layer_norm\\\") self.dropout = tf.keras.layers.Dropout(config.hidden_dropout) self.layer = [ TFHubertEncoderLayerStableLayerNorm(config,\",\n \"real output lengths according to convolution formula output_lengths = self._get_feat_extract_output_lengths(tf.reduce_sum(inputs[\\\"attention_mask\\\"], -1)) attention_mask =\",\n \"self, hidden_states: tf.Tensor, attention_mask: Optional[tf.Tensor] = None, output_attentions: Optional[bool] = False, training: bool\",\n \"and will be ignored.\\\" ) continue else: raise ValueError(f\\\"Data of type {type(v)} is\",\n \"Wav2Vec2Processor, TFHubertForCTC >>> from datasets import load_dataset >>> import soundfile as sf >>>\",\n \"in eager mode, in graph mode the value in the config will be\",\n \"explicit_padding, **kwargs): super().__init__( filters=filters, kernel_size=kernel_size, groups=groups, padding=\\\"valid\\\", use_bias=True, bias_initializer=\\\"he_normal\\\", **kwargs, ) self.explicit_padding =\",\n \"bsz) value_states = self._shape(self.v_proj(key_value_states), -1, bsz) elif past_key_value is not None: # reuse\",\n \"gamma = tf.reshape(self.gamma, broadcast_shape) if self.center: beta = tf.reshape(self.beta, broadcast_shape) return gamma, beta\",\n \"should have a defined dimension \\\" \\\"but the layer received an input with\",\n \"_reshape_into_groups(self, inputs, input_shape, tensor_input_shape): group_shape = [tensor_input_shape[i] for i in range(len(input_shape))] is_instance_norm =\",\n \"* tf.transpose(self.weight_g) self.kernel = tf.transpose(kernel) def build(self, input_shape): if not self.built: input_shape =\",\n \">>> import tensorflow as tf >>> from transformers import Wav2Vec2Processor, TFHubertForCTC >>> from\",\n \"None if attention_mask is not None: hidden_states = hidden_states * tf.expand_dims(attention_mask, -1) attention_mask\",\n \"# if cross_attention save Tuple(tf.Tensor, tf.Tensor) of all cross attention key/value_states. # Further\",\n \"name=\\\"conv\\\", ) self.padding = TFHubertSamePadLayer(config.num_conv_pos_embeddings) self.activation = get_tf_activation(config.feat_extract_activation) def call(self, hidden_states: tf.Tensor) ->\",\n \"input_values_processing(func, config, input_values, **kwargs): \\\"\\\"\\\" Process the input of each TensorFlow model including\",\n \"hidden_states = self.projection(hidden_states) hidden_states = self.dropout(hidden_states, training=training) return hidden_states # Copied from transformers.models.bart.modeling_tf_bart.TFBartAttention\",\n \"__init__(self, config: HubertConfig, *inputs, **kwargs): super().__init__(config, *inputs, **kwargs) self.config = config self.hubert =\",\n \"return hidden_states def call( self, input_values: tf.Tensor, attention_mask: Optional[tf.Tensor] = None, token_type_ids: Optional[tf.Tensor]\",\n \"1 indicates the head is **not masked**, - 0 indicates the head is\",\n \"(tf.Tensor, bool, int, ModelOutput, tuple, list, dict, np.ndarray) for k, v in kwargs.items():\",\n \"be disabled in other modes than eager. if tf.executing_eagerly(): tf.debugging.assert_equal( shape_list(attention_mask), [bsz, 1,\",\n \"self.head_dim)), (0, 2, 1, 3)) def call( self, hidden_states: tf.Tensor, key_value_states: Optional[tf.Tensor] =\",\n \"layer_module( hidden_states=hidden_states, attention_mask=attention_mask, output_attentions=output_attentions, training=training, ) hidden_states = layer_outputs[0] if output_attentions: all_self_attentions =\",\n \"\\\"ones\\\", beta_regularizer: tf.keras.regularizers.Regularizer = None, gamma_regularizer: tf.keras.regularizers.Regularizer = None, beta_constraint: tf.keras.constraints.Constraint = None,\",\n \"TFHubertNoLayerNormConvLayer(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, layer_id: int = 0, **kwargs: Any) -> None:\",\n \"{(bsz, self.num_heads, tgt_len, self.head_dim)}, but is {shape_list(attn_output)}\\\", ) attn_output = tf.transpose( tf.reshape(attn_output, (bsz,\",\n \"def _add_gamma_weight(self, input_shape): dim = input_shape[self.axis] shape = (dim,) if self.scale: self.gamma =\",\n \"at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed\",\n \"axis with given mask_time_indices hidden_states = tf.where( tf.cast(mask_time_indices[:, :, tf.newaxis], tf.bool), self.masked_spec_embed[tf.newaxis, tf.newaxis,\",\n \"batch >>> ds = load_dataset(\\\"hf-internal-testing/librispeech_asr_dummy\\\", \\\"clean\\\", split=\\\"validation\\\") >>> ds = ds.map(map_to_array) >>> input_values\",\n \"-1] ) # transform batch_indices to pair_indices pair_indices = tf.transpose(tf.concat([broad_casted_batch_dims, tf.reshape(batch_indices, [1, -1])],\",\n \"self._get_reshaped_weights(input_shape) normalized_inputs = tf.nn.batch_normalization( reshaped_inputs, mean=mean, variance=variance, scale=gamma, offset=beta, variance_epsilon=self.epsilon, ) return normalized_inputs\",\n \"= self.layer_norm(hidden_states) hidden_states = self.projection(hidden_states) hidden_states = self.dropout(hidden_states, training=training) return hidden_states # Copied\",\n \"self.pos_conv_embed(hidden_states) hidden_states = hidden_states + position_embeddings hidden_states = self.layer_norm(hidden_states) hidden_states = self.dropout(hidden_states, training=training)\",\n \"== 0 else 0 def call(self, hidden_states): if self.num_pad_remove > 0: hidden_states =\",\n \"[What are attention masks?](../glossary#attention-mask) token_type_ids (`np.ndarray` or `tf.Tensor` of shape `({0})`, *optional*): Segment\",\n \"dim = input_shape[self.axis] shape = (dim,) if self.center: self.beta = self.add_weight( shape=shape, name=\\\"beta\\\",\",\n \"np.ndarray]` and each example must have the shape `({0})`): Indices of input sequence\",\n \"indices. Mask values selected in `[0, 1]`: - 1 for tokens that are\",\n \"self.weight_g = self.add_weight( name=\\\"weight_g\\\", shape=(int(self.weight_v.shape[self.filter_axis]), 1, 1), initializer=\\\"ones\\\", dtype=self.weight_v.dtype, trainable=True, ) self.bias =\",\n \"out the [`~PreTrainedModel.from_pretrained`] method to load the model weights. \\\"\\\"\\\" HUBERT_INPUTS_DOCSTRING = r\\\"\\\"\\\"\",\n \"list(signature.keys()) output = {} allowed_types = (tf.Tensor, bool, int, ModelOutput, tuple, list, dict,\",\n \"tf.cast(mask_time_indices[:, :, tf.newaxis], tf.bool), self.masked_spec_embed[tf.newaxis, tf.newaxis, :], hidden_states, ) # apply SpecAugment along\",\n \"hidden_states = self.conv(hidden_states) hidden_states = self.activation(hidden_states) return hidden_states # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2LayerNormConvLayer with\",\n \"self.hubert( input_values=inputs[\\\"input_values\\\"], attention_mask=inputs[\\\"attention_mask\\\"], token_type_ids=inputs[\\\"token_type_ids\\\"], position_ids=inputs[\\\"position_ids\\\"], head_mask=inputs[\\\"head_mask\\\"], inputs_embeds=inputs[\\\"inputs_embeds\\\"], output_attentions=inputs[\\\"output_attentions\\\"], output_hidden_states=inputs[\\\"output_hidden_states\\\"], return_dict=inputs[\\\"return_dict\\\"], training=inputs[\\\"training\\\"], ) return\",\n \"class TFHubertFeatureEncoder(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs: Any) -> None: super().__init__(**kwargs) if config.feat_extract_norm\",\n \"in format (batch_dim, indixes) \\\"\\\"\\\" indices_shape = shape_list(batch_indices) # broadcast batch dim to\",\n \"an embedded representation. This is useful if you want more control over how\",\n \"= tf.keras.layers.Dropout(rate=config.feat_proj_dropout) def call(self, hidden_states: tf.Tensor, training: bool = False) -> tf.Tensor: hidden_states\",\n \">>> hidden_states = model(input_values).last_hidden_state ```\\\"\\\"\\\" inputs = input_values_processing( func=self.call, config=self.config, input_values=input_values, attention_mask=attention_mask, token_type_ids=token_type_ids,\",\n \"self.num_heads, tgt_len, src_len)) attn_weights = tf.nn.softmax(attn_weights, axis=-1) if layer_head_mask is not None: #\",\n \"+ z, num_samples) return indices # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2._scatter_values_on_batch_indices def _scatter_values_on_batch_indices(values, batch_indices, output_shape):\",\n \"the first argument of the model call function: `model(inputs)`. If you choose this\",\n \"eager. if tf.executing_eagerly(): tf.debugging.assert_equal( shape_list(layer_head_mask), [self.num_heads], message=f\\\"Head mask for a single layer should\",\n \"superclass documentation for the generic methods the library implements for all its model\",\n \"tgt_seq_len, src_seq_len]`. \\\"\\\"\\\" src_len = shape_list(mask)[1] tgt_len = tgt_len if tgt_len is not\",\n \"may not use this file except in compliance with the License. # You\",\n \"the value will always be set to True. training (`bool`, *optional*, defaults to\",\n \"not self.initialized: self._init_norm() self.initialized = True self._normalize_kernel() padded_inputs = tf.pad(inputs, ((0, 0), (self.explicit_padding,\",\n \"divided by length of mask span to mask approximately this percentage of all\",\n \"attn_output = tf.transpose( tf.reshape(attn_output, (bsz, self.num_heads, tgt_len, self.head_dim)), (0, 2, 1, 3) )\",\n \"groups=config.num_conv_pos_embedding_groups, explicit_padding=config.num_conv_pos_embeddings // 2, name=\\\"conv\\\", ) self.padding = TFHubertSamePadLayer(config.num_conv_pos_embeddings) self.activation = get_tf_activation(config.feat_extract_activation) def\",\n \"get query proj query_states = self.q_proj(hidden_states) * self.scaling # get key, value proj\",\n \"config self.hubert = TFHubertMainLayer(config, name=\\\"hubert\\\") @add_start_docstrings_to_model_forward(HUBERT_INPUTS_DOCSTRING) @replace_return_docstrings(output_type=TFBaseModelOutput, config_class=_CONFIG_FOR_DOC) def call( self, input_values: tf.Tensor,\",\n \"if uni-directional self-attention (decoder) save Tuple(tf.Tensor, tf.Tensor) of # all previous decoder key/value_states.\",\n \"num masked indices <= sequence_length if num_masked_spans * mask_length > sequence_length: num_masked_spans =\",\n \"hidden_states = hidden_states[:, : -self.num_pad_remove, :] return hidden_states class TFHubertFeatureEncoder(tf.keras.layers.Layer): def __init__(self, config:\",\n \"tf.Tensor, training: bool = False) -> tf.Tensor: hidden_states = self.layer_norm(hidden_states) hidden_states = self.projection(hidden_states)\",\n \"else: self.gamma = None def _add_beta_weight(self, input_shape): dim = input_shape[self.axis] shape = (dim,)\",\n \"IDs?](../glossary#position-ids) head_mask (`np.ndarray` or `tf.Tensor` of shape `(num_heads,)` or `(num_layers, num_heads)`, *optional*): Mask\",\n \"all matter related to general usage and behavior. <Tip> TF 2.0 models accepts\",\n \"// self.groups broadcast_shape.insert(self.axis, self.groups) else: broadcast_shape[self.axis] = self.groups return broadcast_shape # Copied from\",\n \"= tf.keras.layers.Dropout(config.hidden_dropout) self.layer = [TFHubertEncoderLayer(config, name=f\\\"layers.{i}\\\") for i in range(config.num_hidden_layers)] def call( self,\",\n \"broad_casted_batch_dims = tf.reshape( tf.broadcast_to(tf.expand_dims(tf.range(indices_shape[0]), axis=-1), indices_shape), [1, -1] ) # transform batch_indices to\",\n \"position_ids=inputs[\\\"position_ids\\\"], head_mask=inputs[\\\"head_mask\\\"], inputs_embeds=inputs[\\\"inputs_embeds\\\"], output_attentions=inputs[\\\"output_attentions\\\"], output_hidden_states=inputs[\\\"output_hidden_states\\\"], return_dict=inputs[\\\"return_dict\\\"], training=inputs[\\\"training\\\"], ) hidden_states = outputs[0] hidden_states =\",\n \"Example: ```python >>> import tensorflow as tf >>> from transformers import Wav2Vec2Processor, TFHubertForCTC\",\n \"*inputs, **kwargs): super().__init__(config, *inputs, **kwargs) logger.warning( f\\\"\\\\n{self.__class__.__name__} has backpropagation operations that are NOT\",\n \"allow to use the .name property so we check for a real Tensor\",\n \"not to use the model in training mode (some modules like dropout modules\",\n \"@add_start_docstrings( \\\"\\\"\\\"TFHubert Model with a `language modeling` head on top for Connectionist Temporal\",\n \"subclass. Use it as a regular TF 2.0 Keras Model and refer to\",\n \"def call( self, hidden_states: tf.Tensor, key_value_states: Optional[tf.Tensor] = None, past_key_value: Optional[Tuple[Tuple[tf.Tensor]]] = None,\",\n \"Check the superclass documentation for the generic methods the library implements for all\",\n \"has been depreciated \\\" \\\"and will be removed in Transformers v5. \\\" f\\\"Use\",\n \"{type(input_values)} is not allowed only {allowed_types} is accepted for {parameter_names[0]}.\\\" ) for name\",\n \") -> Union[TFBaseModelOutput, Tuple[tf.Tensor]]: all_hidden_states = () if output_hidden_states else None all_self_attentions =\",\n \"super().build(input_shape) self.kernel = tf.Variable(tf.transpose(self.kernel), name=\\\"weight_v\\\", trainable=True) self.weight_v = self.kernel self.weight_g = self.add_weight( name=\\\"weight_g\\\",\",\n \"all_hidden_states = () if output_hidden_states else None all_self_attentions = () if output_attentions else\",\n \"(dropout_probability < self.config.layerdrop): # skip the layer continue layer_outputs = layer_module( hidden_states=hidden_states, attention_mask=attention_mask,\",\n \"by number of timesteps divided by length of mask span to mask approximately\",\n \"vocab_size: {self.config.vocab_size}\\\") attention_mask = ( inputs[\\\"attention_mask\\\"] if inputs[\\\"attention_mask\\\"] is not None else tf.ones_like(inputs[\\\"input_values\\\"],\",\n \"hidden_states # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2PositionalConvEmbedding with Wav2Vec2->Hubert class TFHubertPositionalConvEmbedding(tf.keras.layers.Layer): def __init__(self, config: HubertConfig,\",\n \"does not load the weights associated with the model, only the configuration. Check\",\n \"input_values.pop(\\\"inputs\\\") if \\\"decoder_cached_states\\\" in input_values: warnings.warn( \\\"The `decoder_cached_states` argument is deprecated and will\",\n \"to use the model in training mode (some modules like dropout modules have\",\n \"transformers import Wav2Vec2Processor, TFHubertModel >>> from datasets import load_dataset >>> import soundfile as\",\n \"bsz) if self.is_decoder: # if cross_attention save Tuple(tf.Tensor, tf.Tensor) of all cross attention\",\n \"tf.Tensor) of # all previous decoder key/value_states. Further calls to uni-directional self-attention #\",\n \"name=\\\"masked_spec_embed\\\" ) super().build(input_shape) def _get_feat_extract_output_lengths(self, input_lengths: tf.Tensor): \\\"\\\"\\\" Computes the output length of\",\n \"False, training: bool = False, ) -> Tuple[tf.Tensor]: attn_residual = hidden_states hidden_states =\",\n \"v is not None) return TFBaseModelOutput( last_hidden_state=hidden_states, hidden_states=all_hidden_states, attentions=all_self_attentions, ) # Copied from\",\n \"documentation for all matter related to general usage and behavior. <Tip> TF 2.0\",\n \"call function: `model(inputs)`. If you choose this second option, there are three possibilities\",\n \"= self._mask_hidden_states(hidden_states, mask_time_indices=mask_time_indices) encoder_outputs = self.encoder( hidden_states, attention_mask=attention_mask, output_attentions=inputs[\\\"output_attentions\\\"], output_hidden_states=inputs[\\\"output_hidden_states\\\"], return_dict=inputs[\\\"return_dict\\\"], training=inputs[\\\"training\\\"], )\",\n \"get_tf_activation(config.feat_extract_activation) def call(self, hidden_states: tf.Tensor) -> tf.Tensor: hidden_states = self.conv(hidden_states) hidden_states = self.layer_norm(hidden_states)\",\n \"only {allowed_types} is accepted for {parameter_names[0]}.\\\" ) for name in parameter_names: if name\",\n \"input_shape[-2] += self.explicit_padding * 2 super().build(input_shape) self.kernel = tf.Variable(tf.transpose(self.kernel), name=\\\"weight_v\\\", trainable=True) self.weight_v =\",\n \"= config self.pos_conv_embed = TFHubertPositionalConvEmbedding(config, name=\\\"pos_conv_embed\\\") self.layer_norm = tf.keras.layers.LayerNormalization(epsilon=config.layer_norm_eps, name=\\\"layer_norm\\\") self.dropout = tf.keras.layers.Dropout(config.hidden_dropout)\",\n \"extracted features along time axis and/or along feature axis according to [SpecAugment](https://arxiv.org/abs/1904.08779). \\\"\\\"\\\"\",\n \"layer_outputs[0] if output_attentions: all_self_attentions = all_self_attentions + (layer_outputs[1],) hidden_states = self.layer_norm(hidden_states) if output_hidden_states:\",\n \"# Further calls to cross_attention layer can then reuse all cross-attention # key/value_states\",\n \"\\\"\\\"\\\" Computes the output length of the convolutional layers \\\"\\\"\\\" def _conv_out_length(input_length, kernel_size,\",\n \"a defined dimension \\\" \\\"but the layer received an input with shape \\\"\",\n \"mask_prob: float, mask_length: int, min_masks: int = 0, ) -> tf.Tensor: \\\"\\\"\\\" Computes\",\n \"defaults to `False``): Whether or not to use the model in training mode\",\n \"0))) output = super().call(padded_inputs) return output # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2NoLayerNormConvLayer with Wav2Vec2->Hubert class\",\n \"Any) -> None: super().__init__(**kwargs) self.conv = TFHubertWeightNormConv1D( filters=config.hidden_size, kernel_size=config.num_conv_pos_embeddings, groups=config.num_conv_pos_embedding_groups, explicit_padding=config.num_conv_pos_embeddings // 2,\",\n \"Tuple(tf.Tensor, tf.Tensor) of all cross attention key/value_states. # Further calls to cross_attention layer\",\n \"input_shape): broadcast_shape = self._create_broadcast_shape(input_shape) gamma = None beta = None if self.scale: gamma\",\n \"ignored.\\\" ) continue else: raise ValueError(f\\\"Data of type {type(v)} is not allowed only\",\n \"Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2EncoderStableLayerNorm with Wav2Vec2->Hubert class TFHubertEncoderStableLayerNorm(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs): super().__init__(**kwargs)\",\n \"\\\"more than the number of channels (\\\" + str(dim) + \\\").\\\" ) if\",\n \"call(self, input_values): hidden_states = tf.expand_dims(input_values, -1) for conv_layer in self.conv_layers: hidden_states = conv_layer(hidden_states)\",\n \"-1, epsilon: float = 1e-3, center: bool = True, scale: bool = True,\",\n \"__init__(self, config: HubertConfig, **kwargs): super().__init__(**kwargs) self.layer_norm = tf.keras.layers.LayerNormalization(epsilon=config.layer_norm_eps, name=\\\"layer_norm\\\") self.projection = tf.keras.layers.Dense( units=config.hidden_size,\",\n \"for the feature encoder so that its parameters will not be updated during\",\n \"for all its model (such as downloading or saving, resizing the input embeddings,\",\n \"function of the TensorFlow model. config ([`PretrainedConfig`]): The config of the running model.\",\n \"the gradient computation for the feature encoder so that its parameter will not\",\n \"**kwargs): super().__init__(config, *inputs, **kwargs) self.hubert = TFHubertMainLayer(config, name=\\\"hubert\\\") self.dropout = tf.keras.layers.Dropout(config.final_dropout) self.lm_head =\",\n \"layer if output_hidden_states: all_hidden_states = all_hidden_states + (hidden_states,) if not return_dict: return tuple(v\",\n \"name=\\\"pos_conv_embed\\\") self.layer_norm = tf.keras.layers.LayerNormalization(epsilon=config.layer_norm_eps, name=\\\"layer_norm\\\") self.dropout = tf.keras.layers.Dropout(config.hidden_dropout) self.layer = [ TFHubertEncoderLayerStableLayerNorm(config, name=f\\\"layers.{i}\\\")\",\n \"class TFHubertEncoderLayerStableLayerNorm(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs): super().__init__(**kwargs) self.attention = TFHubertAttention( embed_dim=config.hidden_size, num_heads=config.num_attention_heads,\",\n \"have to add this exception if \\\"args\\\" in output: if output[\\\"args\\\"] is not\",\n \"masked indices <= sequence_length if num_masked_spans * mask_length > sequence_length: num_masked_spans = sequence_length\",\n \"seq_len]` to `[bsz, 1, tgt_seq_len, src_seq_len]`. \\\"\\\"\\\" src_len = shape_list(mask)[1] tgt_len = tgt_len\",\n \"name=\\\"gamma\\\", initializer=self.gamma_initializer, regularizer=self.gamma_regularizer, constraint=self.gamma_constraint, ) else: self.gamma = None def _add_beta_weight(self, input_shape): dim\",\n \"self.num_heads, -1, self.head_dim) query_states = tf.reshape(self._shape(query_states, tgt_len, bsz), proj_shape) key_states = tf.reshape(key_states, proj_shape)\",\n \"to fill spec_aug_mask = tf.zeros((batch_size, sequence_length), dtype=tf.int32) # uniform distribution to sample from,\",\n \"None): \\\"\\\"\\\" Masks extracted features along time axis and/or along feature axis according\",\n \"batch[\\\"speech\\\"] = speech ... return batch >>> ds = load_dataset(\\\"hf-internal-testing/librispeech_asr_dummy\\\", \\\"clean\\\", split=\\\"validation\\\") >>>\",\n \"proper output we have to add this exception if \\\"args\\\" in output: if\",\n \"sequence_length, hidden_size = shape_list(hidden_states) # `config.apply_spec_augment` can set masking to False if not\",\n \"1]`. [What are position IDs?](../glossary#position-ids) head_mask (`np.ndarray` or `tf.Tensor` of shape `(num_heads,)` or\",\n \"TO THE UNIVERSE SIR I EXIST\\\" >>> # wrap processor as target processor\",\n \"outputs = (hidden_states,) if output_attentions: outputs += (attn_weights,) return outputs # Copied from\",\n \"def build(self, input_shape: tf.TensorShape): self.masked_spec_embed = self.add_weight( shape=(self.config.hidden_size,), initializer=\\\"uniform\\\", trainable=True, name=\\\"masked_spec_embed\\\" ) super().build(input_shape)\",\n \"None: output[parameter_names[0]] = input_values else: raise ValueError( f\\\"Data of type {type(input_values)} is not\",\n \"# So to respect the proper output we have to add this exception\",\n \"(got `embed_dim`: {self.embed_dim}\\\" f\\\" and `num_heads`: {num_heads}).\\\" ) self.scaling = self.head_dim**-0.5 self.is_decoder =\",\n \"position_ids (`np.ndarray` or `tf.Tensor` of shape `({0})`, *optional*): Indices of positions of each\",\n \"class TFHubertPreTrainedModel(TFPreTrainedModel): \\\"\\\"\\\" An abstract class to handle weights initialization and a simple\",\n \"and type(output[\\\"args\\\"]) == tf.Tensor: tensor_name = output[\\\"args\\\"].name.split(\\\":\\\")[0] output[tensor_name] = output[\\\"args\\\"] else: # `args`\",\n \"* mask_length)) offsets = tf.range(mask_length)[tf.newaxis, tf.newaxis, :] offsets = tf.tile(offsets, (batch_size, num_masked_spans, 1))\",\n \"mask to fill spec_aug_mask = tf.zeros((batch_size, sequence_length), dtype=tf.int32) # uniform distribution to sample\",\n \"If you wish \\\" \\\"to train/fine-tine this model, you need a GPU or\",\n \"self.intermediate_dense = tf.keras.layers.Dense( units=config.intermediate_size, kernel_initializer=get_initializer(config.initializer_range), bias_initializer=\\\"zeros\\\", name=\\\"intermediate_dense\\\", ) self.intermediate_act_fn = get_tf_activation(config.hidden_act) self.output_dense =\",\n \"with `input_values` only and nothing else: `model(inputs_ids)` - a list of varying length\",\n \"= tf.stack(group_shape) reshaped_inputs = tf.reshape(inputs, group_shape) return reshaped_inputs, group_shape else: return inputs, group_shape\",\n \"input_values: tf.Tensor, attention_mask: Optional[tf.Tensor] = None, token_type_ids: Optional[tf.Tensor] = None, position_ids: Optional[tf.Tensor] =\",\n \"sequence_length uniform_dist = tf.ones((batch_size, sequence_length - (mask_length - 1))) # get random indices\",\n \"the docstring: `model([input_values, attention_mask])` or `model([input_values, attention_mask, token_type_ids])` - a dictionary with one\",\n \"TensorFlow Hubert model.\\\"\\\"\\\" import inspect import warnings from typing import Any, Dict, Optional,\",\n \"function as in PyTorch with indices in format (batch_dim, indixes) \\\"\\\"\\\" indices_shape =\",\n \"size 1 >>> logits = model(input_values).logits >>> predicted_ids = tf.argmax(logits, axis=-1) >>> transcription\",\n \"None, training: Optional[bool] = False, ) -> Union[TFCausalLMOutput, Tuple[tf.Tensor]]: r\\\"\\\"\\\" labels (`tf.Tensor` or\",\n \"model is also a [tf.keras.Model](https://www.tensorflow.org/api_docs/python/tf/keras/Model) subclass. Use it as a regular TF 2.0\",\n \"as tf >>> from transformers import Wav2Vec2Processor, TFHubertForCTC >>> from datasets import load_dataset\",\n \"None, layer_head_mask: Optional[tf.Tensor] = None, training: Optional[bool] = False, ) -> Tuple[tf.Tensor, Optional[tf.Tensor]]:\",\n \"= config.conv_dim[layer_id] if layer_id > 0 else 1 self.out_conv_dim = config.conv_dim[layer_id] self.conv =\",\n \"base_config = super().get_config() return {**base_config, **config} def compute_output_shape(self, input_shape): return input_shape def _reshape_into_groups(self,\",\n \"- a list of varying length with one or several input Tensors IN\",\n \"key_value_states are provided this layer is used as a cross-attention layer # for\",\n \"= input elif isinstance(input, allowed_types) or input is None: output[parameter_names[i]] = input else:\",\n \"this case is always the first parameter, then `input_values` output[\\\"input_values\\\"] = output[\\\"args\\\"] del\",\n \"input_shape): broadcast_shape = [1] * len(input_shape) is_instance_norm = (input_shape[self.axis] // self.groups) == 1\",\n \"Optional[tf.Tensor] = None, inputs_embeds: Optional[tf.Tensor] = None, output_attentions: Optional[tf.Tensor] = None, output_hidden_states: Optional[tf.Tensor]\",\n \"encoder so that its parameters will not be updated during training. \\\"\\\"\\\" warnings.warn(\",\n \"random mask spans for a given shape Args: shape: the the shape for\",\n \"strides=config.conv_stride[layer_id], use_bias=config.conv_bias, name=\\\"conv\\\", ) self.activation = get_tf_activation(config.feat_extract_activation) def call(self, hidden_states: tf.Tensor) -> tf.Tensor:\",\n \"beta_constraint: tf.keras.constraints.Constraint = None, gamma_constraint: tf.keras.constraints.Constraint = None, **kwargs, ): super().__init__(**kwargs) self.supports_masking =\",\n \"The callable function of the TensorFlow model. config ([`PretrainedConfig`]): The config of the\",\n \"number of masked spans in batch num_masked_spans = int(mask_prob * sequence_length / mask_length\",\n \"call( self, hidden_states: tf.Tensor, attention_mask: Optional[tf.Tensor] = None, output_attentions: Optional[bool] = False, output_hidden_states:\",\n \"def __init__(self, config: HubertConfig, **kwargs): super().__init__(**kwargs) self.config = config self.pos_conv_embed = TFHubertPositionalConvEmbedding(config, name=\\\"pos_conv_embed\\\")\",\n \"self.groups: raise ValueError( \\\"Number of groups (\\\" + str(self.groups) + \\\") cannot be\",\n \"units=config.hidden_size, kernel_initializer=get_initializer(config.initializer_range), bias_initializer=\\\"zeros\\\", name=\\\"output_dense\\\", ) self.output_dropout = tf.keras.layers.Dropout(config.hidden_dropout) def call(self, hidden_states: tf.Tensor, training:\",\n \"not use this file except in compliance with the License. # You may\",\n \"return a [`~file_utils.ModelOutput`] instead of a plain tuple. This argument can be used\",\n \"TFBart->TFHubert class TFHubertAttention(tf.keras.layers.Layer): \\\"\\\"\\\"Multi-headed attention from \\\"Attention Is All You Need\\\"\\\"\\\" def __init__(\",\n \"Optional[tf.Tensor] = None, output_attentions: Optional[tf.Tensor] = None, output_hidden_states: Optional[tf.Tensor] = None, return_dict: Optional[bool]\",\n \"= self.add_weight( shape=(self.config.hidden_size,), initializer=\\\"uniform\\\", trainable=True, name=\\\"masked_spec_embed\\\" ) super().build(input_shape) def _get_feat_extract_output_lengths(self, input_lengths: tf.Tensor): \\\"\\\"\\\"\",\n \"encoder_outputs[0] if not inputs[\\\"return_dict\\\"]: return (hidden_states,) + encoder_outputs[1:] return TFBaseModelOutput( last_hidden_state=hidden_states, hidden_states=encoder_outputs.hidden_states, attentions=encoder_outputs.attentions,\",\n \"call(self, inputs): input_shape = tf.keras.backend.int_shape(inputs) tensor_input_shape = tf.shape(inputs) reshaped_inputs, group_shape = self._reshape_into_groups(inputs, input_shape,\",\n \"attn_weights, past_key_value # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2FeedForward with Wav2Vec2->Hubert class TFHubertFeedForward(tf.keras.layers.Layer): def __init__(self, config:\",\n \"transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2SamePadLayer with Wav2Vec2->Hubert class TFHubertSamePadLayer(tf.keras.layers.Layer): def __init__(self, num_conv_pos_embeddings, **kwargs): super().__init__(**kwargs) self.num_pad_remove = 1\",\n \"reshaped_inputs, group_shape else: return inputs, group_shape def _apply_normalization(self, reshaped_inputs, input_shape): group_shape = tf.keras.backend.int_shape(reshaped_inputs)\",\n \"__init__(self, config: HubertConfig, **kwargs): super().__init__(**kwargs) self.intermediate_dropout = tf.keras.layers.Dropout(config.activation_dropout) self.intermediate_dense = tf.keras.layers.Dense( units=config.intermediate_size, kernel_initializer=get_initializer(config.initializer_range),\",\n \"prevent masking padded elements mask_prob: probability for each token to be chosen as\",\n \"agreed to in writing, software # distributed under the License is distributed on\",\n \"token, - 1 corresponds to a *sentence B* token. [What are token type\",\n \"tf.Tensor]` or `Dict[str, np.ndarray]` and each example must have the shape `({0})`): Indices\",\n \"not None else tf.ones_like(inputs[\\\"input_values\\\"], dtype=tf.float32) ) input_lengths = self.hubert._get_feat_extract_output_lengths(tf.reduce_sum(attention_mask, axis=-1)) # assuming that\",\n \"None, token_type_ids: Optional[tf.Tensor] = None, position_ids: Optional[tf.Tensor] = None, head_mask: Optional[tf.Tensor] = None,\",\n \"self._create_broadcast_shape(input_shape) gamma = None beta = None if self.scale: gamma = tf.reshape(self.gamma, broadcast_shape)\",\n \"def _shape(self, tensor: tf.Tensor, seq_len: int, bsz: int): return tf.transpose(tf.reshape(tensor, (bsz, seq_len, self.num_heads,\",\n \"def _compute_mask_indices( shape: Tuple[int, int], mask_prob: float, mask_length: int, min_masks: int = 0,\",\n \"batch_indices, output_shape): \\\"\\\"\\\" Scatter function as in PyTorch with indices in format (batch_dim,\",\n \"dim def _check_size_of_dimensions(self, input_shape): dim = input_shape[self.axis] if dim < self.groups: raise ValueError(\",\n \"reuse k,v, cross_attentions key_states = past_key_value[0] value_states = past_key_value[1] elif is_cross_attention: # cross_attentions\",\n \"Keras Model and refer to the TF 2.0 documentation for all matter related\",\n \"False if not getattr(self.config, \\\"apply_spec_augment\\\", True): return hidden_states if mask_time_indices is not None:\",\n \"= tf.keras.backend.int_shape(reshaped_inputs) group_reduction_axes = list(range(1, len(group_shape))) is_instance_norm = (input_shape[self.axis] // self.groups) == 1\",\n \"- having all inputs as a list, tuple or dict in the first\",\n \"= tf.reshape(attn_weights, (bsz, self.num_heads, tgt_len, src_len)) + attention_mask attn_weights = tf.reshape(attn_weights, (bsz *\",\n \"{**base_config, **config} def compute_output_shape(self, input_shape): return input_shape def _reshape_into_groups(self, inputs, input_shape, tensor_input_shape): group_shape\",\n \"\\\"sum\\\": loss = tf.reduce_sum(loss) if self.config.ctc_loss_reduction == \\\"mean\\\": loss = tf.reduce_mean(loss) else: loss\",\n \"to return a [`~file_utils.ModelOutput`] instead of a plain tuple. This argument can be\",\n \"for the unexpected layers. \\\"\\\"\\\" signature = dict(inspect.signature(func).parameters) signature.pop(\\\"kwargs\\\", None) signature.pop(\\\"self\\\", None) parameter_names\",\n \"value_states = past_key_value[1] elif is_cross_attention: # cross_attentions key_states = self._shape(self.k_proj(key_value_states), -1, bsz) value_states\",\n \"shape_list(layer_head_mask), [self.num_heads], message=f\\\"Head mask for a single layer should be of size {(self.num_heads)},\",\n \"ValueError( \\\"Axis \\\" + str(self.axis) + \\\" of \\\" \\\"input tensor should have\",\n \"refer to the TF 2.0 documentation for all matter related to general usage\",\n \"Indices should be in `[-100, 0, ..., config.vocab_size]` (see `input_values` docstring) Tokens with\",\n \"None, past_key_values_length: int = 0): \\\"\\\"\\\" Expands attention_mask from `[bsz, seq_len]` to `[bsz,\",\n \"in other modes than eager. if tf.executing_eagerly(): tf.debugging.assert_equal( shape_list(layer_head_mask), [self.num_heads], message=f\\\"Head mask for\",\n \"else self.axis - 1 else: axis = -1 if self.axis == -1 else\",\n \"hidden_states): if self.num_pad_remove > 0: hidden_states = hidden_states[:, : -self.num_pad_remove, :] return hidden_states\",\n \") # compute number of masked spans in batch num_masked_spans = int(mask_prob *\",\n \"mode the value in the config will be used instead. return_dict (`bool`, *optional*):\",\n \"or a TPU\\\" ) @tf.function def serving(self, inputs): output = self.call(input_values=inputs, training=False) return\",\n \"output_lengths, maxlen=shape_list(hidden_states)[1], dtype=hidden_states.dtype ) hidden_states = self.feature_projection(hidden_states, training=inputs[\\\"training\\\"]) mask_time_indices = kwargs.get(\\\"mask_time_indices\\\", None) if\",\n \"if labels is not None: if tf.reduce_max(labels) >= self.config.vocab_size: raise ValueError(f\\\"Label values must\",\n \"1 self.out_conv_dim = config.conv_dim[layer_id] self.conv = tf.keras.layers.Conv1D( filters=self.out_conv_dim, kernel_size=config.conv_kernel[layer_id], strides=config.conv_stride[layer_id], use_bias=config.conv_bias, name=\\\"conv\\\", )\",\n \"tf.keras.layers.Dense(embed_dim, use_bias=bias, name=\\\"v_proj\\\") self.out_proj = tf.keras.layers.Dense(embed_dim, use_bias=bias, name=\\\"out_proj\\\") def _shape(self, tensor: tf.Tensor, seq_len:\",\n \"logging, replace_return_docstrings, ) from .configuration_hubert import HubertConfig logger = logging.get_logger(__name__) _CONFIG_FOR_DOC = \\\"HubertConfig\\\"\",\n \"{} allowed_types = (tf.Tensor, bool, int, ModelOutput, tuple, list, dict, np.ndarray) for k,\",\n \"(input_shape[self.axis] // self.groups) == 1 if not is_instance_norm: group_shape[self.axis] = input_shape[self.axis] // self.groups\",\n \"*optional*): Labels for computing the masked language modeling loss. Indices should be in\",\n \"kwargs.items(): if isinstance(v, allowed_types) or v is None: output[k] = v else: raise\",\n \"I EXIST\\\" >>> # wrap processor as target processor to encode labels >>>\",\n \"self.gamma_initializer = tf.keras.initializers.get(gamma_initializer) self.beta_regularizer = tf.keras.regularizers.get(beta_regularizer) self.gamma_regularizer = tf.keras.regularizers.get(gamma_regularizer) self.beta_constraint = tf.keras.constraints.get(beta_constraint) self.gamma_constraint\",\n \"corresponds to a *sentence B* token. [What are token type IDs?](../glossary#token-type-ids) position_ids (`np.ndarray`\",\n \"hidden_states = self.layer_norm(hidden_states) hidden_states = self.activation(hidden_states) return hidden_states # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2GroupNormConvLayer with\",\n \"= Wav2Vec2Processor.from_pretrained(\\\"facebook/hubert-base-960h\\\") >>> model = TFHubertForCTC.from_pretrained(\\\"facebook/hubert-base-960h\\\") >>> def map_to_array(batch): ... speech, _ =\",\n \"the Apache License, Version 2.0 (the \\\"License\\\"); # you may not use this\",\n \"from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2PositionalConvEmbedding with Wav2Vec2->Hubert class TFHubertPositionalConvEmbedding(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs: Any) ->\",\n \"in self.conv_layers: hidden_states = conv_layer(hidden_states) return hidden_states class TFHubertFeatureExtractor(TFHubertFeatureEncoder): def __init__(self, config, **kwargs):\",\n \"signature[name].default) # When creating a SavedModel TF calls the method with LayerCall.__call__(args, **kwargs)\",\n \"parameter {k} does not belongs to the parameter list {parameter_names} and will be\",\n \"2.7, so we need to account for padding input_shape[-2] += self.explicit_padding * 2\",\n \"= input_shape[self.axis] shape = (dim,) if self.scale: self.gamma = self.add_weight( shape=shape, name=\\\"gamma\\\", initializer=self.gamma_initializer,\",\n \"behavior. <Tip> TF 2.0 models accepts two formats as inputs: - having all\",\n \"`({0})`, *optional*): Segment token indices to indicate first and second portions of the\",\n \"= model(input_values).last_hidden_state ```\\\"\\\"\\\" inputs = input_values_processing( func=self.call, config=self.config, input_values=input_values, attention_mask=attention_mask, token_type_ids=token_type_ids, position_ids=position_ids, head_mask=head_mask,\",\n \"to the TF 2.0 documentation for all matter related to general usage and\",\n \"Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2SamePadLayer with Wav2Vec2->Hubert class TFHubertSamePadLayer(tf.keras.layers.Layer): def __init__(self, num_conv_pos_embeddings, **kwargs): super().__init__(**kwargs) self.num_pad_remove\",\n \"downloading or saving, resizing the input embeddings, pruning heads etc.) This model is\",\n \"will be used instead. return_dict (`bool`, *optional*): Whether or not to return a\",\n \") return outputs def serving_output(self, output): hs = tf.convert_to_tensor(output.hidden_states) if self.config.output_hidden_states else None\",\n \"method with LayerCall.__call__(args, **kwargs) # So to respect the proper output we have\",\n \"sequence_length: raise ValueError( f\\\"`mask_length` has to be smaller than `sequence_length`, but got `mask_length`:\",\n \"_compute_mask_indices( shape: Tuple[int, int], mask_prob: float, mask_length: int, min_masks: int = 0, )\",\n \"HubertConfig, **kwargs): super().__init__(**kwargs) self.intermediate_dropout = tf.keras.layers.Dropout(config.activation_dropout) self.intermediate_dense = tf.keras.layers.Dense( units=config.intermediate_size, kernel_initializer=get_initializer(config.initializer_range), bias_initializer=\\\"zeros\\\", name=\\\"intermediate_dense\\\",\",\n \") continue else: raise ValueError(f\\\"Data of type {type(v)} is not allowed only {allowed_types}\",\n \"(batch_size, num_masked_spans * mask_length)) offsets = tf.range(mask_length)[tf.newaxis, tf.newaxis, :] offsets = tf.tile(offsets, (batch_size,\",\n \"as keyword arguments (like PyTorch models), or - having all inputs as a\",\n \"not in list(output.keys()) and name != \\\"args\\\": output[name] = kwargs.pop(name, signature[name].default) # When\",\n \"if encoder bi-directional self-attention `past_key_value` is always `None` past_key_value = (key_states, value_states) proj_shape\",\n \"and will be removed in a future version, use `input_values` instead.\\\", FutureWarning, )\",\n \"self.freeze_feature_encoder() def freeze_feature_encoder(self): \\\"\\\"\\\" Calling this function will disable the gradient computation for\",\n \"of all layers. See `hidden_states` under returned tensors for more detail. This argument\",\n \"+ (layer_outputs[1],) hidden_states = self.layer_norm(hidden_states) if output_hidden_states: all_hidden_states = all_hidden_states + (hidden_states,) if\",\n \"output[tensor_name] = input else: output[parameter_names[i]] = input elif isinstance(input, allowed_types) or input is\",\n \"self.dropout = tf.keras.layers.Dropout(config.hidden_dropout) self.layer = [ TFHubertEncoderLayerStableLayerNorm(config, name=f\\\"layers.{i}\\\") for i in range(config.num_hidden_layers) ]\",\n \"modes than eager. if tf.executing_eagerly(): tf.debugging.assert_equal( shape_list(attention_mask), [bsz, 1, tgt_len, src_len], message=f\\\"Attention mask\",\n \"input embeddings, pruning heads etc.) This model is also a [tf.keras.Model](https://www.tensorflow.org/api_docs/python/tf/keras/Model) subclass. Use\",\n \"probability for each token to be chosen as start of the span to\",\n \") if inputs[\\\"attention_mask\\\"] is not None: # compute real output lengths according to\",\n \"k not in parameter_names and \\\"args\\\" not in parameter_names: logger.warning( f\\\"The parameter {k}\",\n \"than 0.\\\") if mask_length > sequence_length: raise ValueError( f\\\"`mask_length` has to be smaller\",\n \"if k in [\\\"return_dict\\\", \\\"output_attentions\\\", \\\"output_hidden_states\\\", \\\"use_cache\\\"] } output.update(booleans_processing(config=config, **boolean_dict)) return output #\",\n \"dropout=config.attention_dropout, is_decoder=False, name=\\\"attention\\\", ) self.dropout = tf.keras.layers.Dropout(config.hidden_dropout) self.layer_norm = tf.keras.layers.LayerNormalization(epsilon=config.layer_norm_eps, name=\\\"layer_norm\\\") self.feed_forward =\",\n \"a SavedModel TF calls the method with LayerCall.__call__(args, **kwargs) # So to respect\",\n \"Optional[tf.Tensor] = None, head_mask: Optional[tf.Tensor] = None, inputs_embeds: Optional[tf.Tensor] = None, output_attentions: Optional[bool]\",\n \"layer is used as a cross-attention layer # for the decoder is_cross_attention =\",\n \"\\\"Please use the equivalent `freeze_feature_encoder` method instead.\\\", FutureWarning, ) self.freeze_feature_encoder() def freeze_feature_encoder(self): \\\"\\\"\\\"\",\n \"with Wav2Vec2->Hubert class TFHubertEncoderLayerStableLayerNorm(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs): super().__init__(**kwargs) self.attention = TFHubertAttention(\",\n \"(see `input_values` docstring) Tokens with indices set to `-100` are ignored (masked), the\",\n \"= self.activation(hidden_states) return hidden_states # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2PositionalConvEmbedding with Wav2Vec2->Hubert class TFHubertPositionalConvEmbedding(tf.keras.layers.Layer): def\",\n \"hidden_states, 0) return hidden_states def call( self, input_values: tf.Tensor, attention_mask: Optional[tf.Tensor] = None,\",\n \"attn_residual = hidden_states hidden_states, attn_weights, _ = self.attention( hidden_states, attention_mask=attention_mask, training=training ) hidden_states\",\n \"target_lengths = tf.reduce_sum(labels_mask, axis=-1) loss = tf.nn.ctc_loss( logits=logits, labels=labels, logit_length=input_lengths, label_length=target_lengths, blank_index=self.config.pad_token_id, logits_time_major=False,\",\n \"transpose_b=True) # The tf.debugging asserts are not compliant with XLA then they #\",\n \"kernel_size=config.num_conv_pos_embeddings, groups=config.num_conv_pos_embedding_groups, explicit_padding=config.num_conv_pos_embeddings // 2, name=\\\"conv\\\", ) self.padding = TFHubertSamePadLayer(config.num_conv_pos_embeddings) self.activation = get_tf_activation(config.feat_extract_activation)\",\n \"all the input Tensors in the first positional argument : - a single\",\n \"2, name=\\\"conv\\\", ) self.padding = TFHubertSamePadLayer(config.num_conv_pos_embeddings) self.activation = get_tf_activation(config.feat_extract_activation) def call(self, hidden_states: tf.Tensor)\",\n \"last_hidden_state=hidden_states, hidden_states=all_hidden_states, attentions=all_self_attentions, ) @keras_serializable class TFHubertMainLayer(tf.keras.layers.Layer): config_class = HubertConfig def __init__(self, config:\",\n \"= HubertConfig def __init__(self, config: HubertConfig, **kwargs): super().__init__(**kwargs) self.config = config self.feature_extractor =\",\n \"with Wav2Vec2->Hubert class TFHubertGroupNorm(tf.keras.layers.Layer): \\\"\\\"\\\" From tensorflow-addons https://www.tensorflow.org/addons/api_docs/python/tfa/layers/GroupNormalization \\\"\\\"\\\" def __init__( self, groups:\",\n \"= ( inputs[\\\"attention_mask\\\"] if inputs[\\\"attention_mask\\\"] is not None else tf.ones_like(inputs[\\\"input_values\\\"], dtype=tf.float32) ) input_lengths\",\n \"for details. [What are input IDs?](../glossary#input-ids) attention_mask (`np.ndarray` or `tf.Tensor` of shape `({0})`,\",\n \"with processor.as_target_processor(): ... labels = processor(transcription, return_tensors=\\\"tf\\\").input_values >>> loss = model(input_values, labels=labels).loss ```\\\"\\\"\\\"\",\n \"`(num_layers, num_heads)`, *optional*): Mask to nullify selected heads of the self-attention modules. Mask\",\n \"the missing layers, and another one for the unexpected layers. \\\"\\\"\\\" signature =\",\n \"or `tf.Tensor` of shape `({0})`, *optional*): Segment token indices to indicate first and\",\n \"= input_shape[self.axis] // self.groups broadcast_shape.insert(self.axis, self.groups) else: broadcast_shape[self.axis] = self.groups return broadcast_shape #\",\n \"output we have to add this exception if \\\"args\\\" in output: if output[\\\"args\\\"]\",\n \"is not None) return TFBaseModelOutput( last_hidden_state=hidden_states, hidden_states=all_hidden_states, attentions=all_self_attentions, ) @keras_serializable class TFHubertMainLayer(tf.keras.layers.Layer): config_class\",\n \"== 1 if not is_instance_norm: broadcast_shape[self.axis] = input_shape[self.axis] // self.groups broadcast_shape.insert(self.axis, self.groups) else:\",\n \"is not None: # reuse k,v, cross_attentions key_states = past_key_value[0] value_states = past_key_value[1]\",\n \"self-attention # can concat previous decoder key/value_states to current projected key/value_states (third \\\"elif\\\"\",\n \"head_mask=head_mask, inputs_embeds=inputs_embeds, output_attentions=output_attentions, output_hidden_states=output_hidden_states, return_dict=return_dict, training=training, ) inputs[\\\"output_hidden_states\\\"] = ( inputs[\\\"output_hidden_states\\\"] if inputs[\\\"output_hidden_states\\\"]\",\n \"depreciated \\\" \\\"and will be removed in Transformers v5. \\\" f\\\"Use `{self.__class__.__bases__[0].__name__}` instead.\\\",\",\n \"None def _add_beta_weight(self, input_shape): dim = input_shape[self.axis] shape = (dim,) if self.center: self.beta\",\n \"embed_dim)) attn_output = self.out_proj(attn_output) attn_weights: tf.Tensor = tf.reshape(attn_weights, (bsz, self.num_heads, tgt_len, src_len)) return\",\n \"v elif k not in parameter_names and \\\"args\\\" not in parameter_names: logger.warning( f\\\"The\",\n \"self.projection = tf.keras.layers.Dense( units=config.hidden_size, kernel_initializer=get_initializer(config.initializer_range), bias_initializer=\\\"zeros\\\", name=\\\"projection\\\", ) self.dropout = tf.keras.layers.Dropout(rate=config.feat_proj_dropout) def call(self,\",\n \"def call(self, hidden_states): if self.num_pad_remove > 0: hidden_states = hidden_states[:, : -self.num_pad_remove, :]\",\n \"group_shape = self._reshape_into_groups(inputs, input_shape, tensor_input_shape) normalized_inputs = self._apply_normalization(reshaped_inputs, input_shape) is_instance_norm = (input_shape[self.axis] //\",\n \"not None: # reuse k, v, self_attention key_states = self._shape(self.k_proj(hidden_states), -1, bsz) value_states\",\n \"Model configuration class with all the parameters of the model. Initializing with a\",\n \"-1, bsz) value_states = self._shape(self.v_proj(hidden_states), -1, bsz) if self.is_decoder: # if cross_attention save\",\n \"key_states = past_key_value[0] value_states = past_key_value[1] elif is_cross_attention: # cross_attentions key_states = self._shape(self.k_proj(key_value_states),\",\n \"head_mask=head_mask, inputs_embeds=inputs_embeds, output_attentions=output_attentions, output_hidden_states=output_hidden_states, return_dict=return_dict, training=training, ) outputs = self.hubert( input_values=inputs[\\\"input_values\\\"], attention_mask=inputs[\\\"attention_mask\\\"], token_type_ids=inputs[\\\"token_type_ids\\\"],\",\n \"input_values=input_values, attention_mask=attention_mask, token_type_ids=token_type_ids, position_ids=position_ids, head_mask=head_mask, inputs_embeds=inputs_embeds, output_attentions=output_attentions, output_hidden_states=output_hidden_states, return_dict=return_dict, training=training, kwargs_call=kwargs, ) hidden_states\",\n \"= tf.reduce_sum(loss) if self.config.ctc_loss_reduction == \\\"mean\\\": loss = tf.reduce_mean(loss) else: loss = None\",\n \"{(bsz, 1, tgt_len, src_len)}, but is {shape_list(attention_mask)}\\\", ) attention_mask = tf.cast(attention_mask, dtype=attn_weights.dtype) attn_weights\",\n \"on an \\\"AS IS\\\" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\",\n \"training=inputs[\\\"training\\\"], ) hidden_states = encoder_outputs[0] if not inputs[\\\"return_dict\\\"]: return (hidden_states,) + encoder_outputs[1:] return\",\n \"to mask spec_aug_mask_idxs = _sample_without_replacement(uniform_dist, num_masked_spans) # expand masked indices to masked spans\",\n \"it as a regular TF 2.0 Keras Model and refer to the TF\",\n \"booleans. In case of a list of symbolic inputs, each input has to\",\n \"= None position_embeddings = self.pos_conv_embed(hidden_states) hidden_states = hidden_states + position_embeddings hidden_states = self.dropout(hidden_states,\",\n \"modules have different behaviors between training and evaluation). \\\"\\\"\\\" @add_start_docstrings( \\\"The bare TFHubert\",\n \"range(len(input_shape))] is_instance_norm = (input_shape[self.axis] // self.groups) == 1 if not is_instance_norm: group_shape[self.axis] =\",\n \"`inputs` argument is deprecated and will be removed in a future version, use\",\n \"\\\"\\\"\\\"Multi-headed attention from \\\"Attention Is All You Need\\\"\\\"\\\" def __init__( self, embed_dim: int,\",\n \"output): hs = tf.convert_to_tensor(output.hidden_states) if self.config.output_hidden_states else None attns = tf.convert_to_tensor(output.attentions) if self.config.output_attentions\",\n \"value_states) proj_shape = (bsz * self.num_heads, -1, self.head_dim) query_states = tf.reshape(self._shape(query_states, tgt_len, bsz),\",\n \"padded_inputs = tf.pad(inputs, ((0, 0), (self.explicit_padding, self.explicit_padding), (0, 0))) output = super().call(padded_inputs) return\",\n \"return TFBaseModelOutput(last_hidden_state=output.last_hidden_state, hidden_states=hs, attentions=attns) @add_start_docstrings( \\\"\\\"\\\"TFHubert Model with a `language modeling` head on\",\n \"== tf.Tensor: # Tensor names have always the pattern `name:id` then we check\",\n \"f\\\"`config.feat_extract_norm` is {config.feat_extract_norm}, but has to be one of ['group', 'layer']\\\" ) self.conv_layers\",\n \"1)) offsets = tf.reshape(offsets, (batch_size, num_masked_spans * mask_length)) spec_aug_mask_idxs = spec_aug_mask_idxs + offsets\",\n \"disabled in other modes than eager. if tf.executing_eagerly(): tf.debugging.assert_equal( shape_list(attn_weights), [bsz * self.num_heads,\",\n \"need a GPU or a TPU\\\" ) @tf.function def serving(self, inputs): output =\",\n \"def __init__(self, config: HubertConfig, **kwargs): super().__init__(**kwargs) self.layer_norm = tf.keras.layers.LayerNormalization(epsilon=config.layer_norm_eps, name=\\\"layer_norm\\\") self.projection = tf.keras.layers.Dense(\",\n \"that are **masked**. [What are attention masks?](../glossary#attention-mask) token_type_ids (`np.ndarray` or `tf.Tensor` of shape\",\n \"# http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in\",\n \"Batch size 1 >>> hidden_states = model(input_values).last_hidden_state ```\\\"\\\"\\\" inputs = input_values_processing( func=self.call, config=self.config,\",\n \"from ...modeling_tf_utils import TFPreTrainedModel, booleans_processing, get_initializer, keras_serializable from ...tf_utils import shape_list from ...tokenization_utils_base\",\n \"load_dataset(\\\"hf-internal-testing/librispeech_asr_dummy\\\", \\\"clean\\\", split=\\\"validation\\\") >>> ds = ds.map(map_to_array) >>> input_values = processor(ds[\\\"speech\\\"][0], return_tensors=\\\"tf\\\").input_values #\",\n \"replace_return_docstrings, ) from .configuration_hubert import HubertConfig logger = logging.get_logger(__name__) _CONFIG_FOR_DOC = \\\"HubertConfig\\\" TF_HUBERT_PRETRAINED_MODEL_ARCHIVE_LIST\",\n \"TFPreTrainedModel, booleans_processing, get_initializer, keras_serializable from ...tf_utils import shape_list from ...tokenization_utils_base import BatchEncoding from\",\n \"lengths according to convolution formula output_lengths = self._get_feat_extract_output_lengths(tf.reduce_sum(inputs[\\\"attention_mask\\\"], -1)) attention_mask = tf.sequence_mask( output_lengths,\",\n \"the parameters name, i.e. `input_values = tf.keras.Input(shape=(128,), dtype='float32', name=\\\"input_values\\\")` otherwise the order of\",\n \"[1, -1] ) # transform batch_indices to pair_indices pair_indices = tf.transpose(tf.concat([broad_casted_batch_dims, tf.reshape(batch_indices, [1,\",\n \"to current projected key/value_states (third \\\"elif\\\" case) # if encoder bi-directional self-attention `past_key_value`\",\n \"arguments. This second option is useful when using [`tf.keras.Model.fit`] method which currently requires\",\n \"= self._shape(self.v_proj(key_value_states), -1, bsz) elif past_key_value is not None: # reuse k, v,\",\n \"return_dict: return tuple(v for v in [hidden_states, all_hidden_states, all_self_attentions] if v is not\",\n \"embed_dim self.num_heads = num_heads self.dropout = tf.keras.layers.Dropout(dropout) self.head_dim = embed_dim // num_heads if\",\n \"use_bias=config.conv_bias, name=\\\"conv\\\", ) self.activation = get_tf_activation(config.feat_extract_activation) self.layer_norm = TFHubertGroupNorm(groups=self.out_conv_dim, epsilon=config.layer_norm_eps, name=\\\"layer_norm\\\") def call(self,\",\n \"kernel_size, groups, explicit_padding, **kwargs): super().__init__( filters=filters, kernel_size=kernel_size, groups=groups, padding=\\\"valid\\\", use_bias=True, bias_initializer=\\\"he_normal\\\", **kwargs, )\",\n \"hidden_size)`, *optional*): Optionally, instead of passing `input_values` you can choose to directly pass\",\n \"tf.constant([0, 1]) def _init_norm(self): \\\"\\\"\\\"Set the norm of the weight vector.\\\"\\\"\\\" kernel_norm =\",\n \"= tf.keras.layers.Dropout(config.hidden_dropout) self.layer_norm = tf.keras.layers.LayerNormalization(epsilon=config.layer_norm_eps, name=\\\"layer_norm\\\") self.feed_forward = TFHubertFeedForward(config, name=\\\"feed_forward\\\") self.final_layer_norm = tf.keras.layers.LayerNormalization(\",\n \"masks?](../glossary#attention-mask) token_type_ids (`np.ndarray` or `tf.Tensor` of shape `({0})`, *optional*): Segment token indices to\",\n \"= tf.keras.layers.Dropout(config.activation_dropout) self.intermediate_dense = tf.keras.layers.Dense( units=config.intermediate_size, kernel_initializer=get_initializer(config.initializer_range), bias_initializer=\\\"zeros\\\", name=\\\"intermediate_dense\\\", ) self.intermediate_act_fn = get_tf_activation(config.hidden_act)\",\n \"heads of the self-attention modules. Mask values selected in `[0, 1]`: - 1\",\n \"the output length of the convolutional layers \\\"\\\"\\\" def _conv_out_length(input_length, kernel_size, stride): #\",\n \"**kwargs): super().__init__(config, *inputs, **kwargs) logger.warning( f\\\"\\\\n{self.__class__.__name__} has backpropagation operations that are NOT supported\",\n \"indices into associated vectors than the model's internal embedding lookup matrix. output_attentions (`bool`,\",\n \"{ \\\"groups\\\": self.groups, \\\"axis\\\": self.axis, \\\"epsilon\\\": self.epsilon, \\\"center\\\": self.center, \\\"scale\\\": self.scale, \\\"beta_initializer\\\": tf.keras.initializers.serialize(self.beta_initializer),\",\n \"self.scale, \\\"beta_initializer\\\": tf.keras.initializers.serialize(self.beta_initializer), \\\"gamma_initializer\\\": tf.keras.initializers.serialize(self.gamma_initializer), \\\"beta_regularizer\\\": tf.keras.regularizers.serialize(self.beta_regularizer), \\\"gamma_regularizer\\\": tf.keras.regularizers.serialize(self.gamma_regularizer), \\\"beta_constraint\\\": tf.keras.constraints.serialize(self.beta_constraint), \\\"gamma_constraint\\\": tf.keras.constraints.serialize(self.gamma_constraint),\",\n \"an input with shape \\\" + str(input_shape) + \\\".\\\" ) def _set_number_of_groups_for_instance_norm(self, input_shape):\",\n \"None beta = None if self.scale: gamma = tf.reshape(self.gamma, broadcast_shape) if self.center: beta\",\n \") def _create_input_spec(self, input_shape): dim = input_shape[self.axis] self.input_spec = tf.keras.layers.InputSpec(ndim=len(input_shape), axes={self.axis: dim}) def\",\n \"mask for a single layer should be of size {(self.num_heads)}, but is {shape_list(layer_head_mask)}\\\",\",\n \"training: bool = False, ) -> Union[TFBaseModelOutput, Tuple[tf.Tensor]]: \\\"\\\"\\\" Returns: Example: ```python >>>\",\n \"for {k}.\\\") if isinstance(input_values, (tuple, list)): for i, input in enumerate(input_values): # EagerTensors\",\n \"-> tf.Tensor: \\\"\\\"\\\" Computes random mask spans for a given shape Args: shape:\",\n \"one for the unexpected layers. \\\"\\\"\\\" signature = dict(inspect.signature(func).parameters) signature.pop(\\\"kwargs\\\", None) signature.pop(\\\"self\\\", None)\",\n \"... speech, _ = sf.read(batch[\\\"file\\\"]) ... batch[\\\"speech\\\"] = speech ... return batch >>>\",\n \"attention_mask=attention_mask, token_type_ids=token_type_ids, position_ids=position_ids, head_mask=head_mask, inputs_embeds=inputs_embeds, output_attentions=output_attentions, output_hidden_states=output_hidden_states, return_dict=return_dict, training=training, kwargs_call=kwargs, ) hidden_states =\",\n \"self.groups) == 1 if not is_instance_norm: broadcast_shape[self.axis] = input_shape[self.axis] // self.groups broadcast_shape.insert(self.axis, self.groups)\",\n \">>> import soundfile as sf >>> processor = Wav2Vec2Processor.from_pretrained(\\\"facebook/hubert-base-960h\\\") >>> model = TFHubertForCTC.from_pretrained(\\\"facebook/hubert-base-960h\\\")\",\n \"x Channel\\\"\\\"\\\" # if key_value_states are provided this layer is used as a\",\n \"if self.num_pad_remove > 0: hidden_states = hidden_states[:, : -self.num_pad_remove, :] return hidden_states class\",\n \"= None): \\\"\\\"\\\" Masks extracted features along time axis and/or along feature axis\",\n \"output[\\\"input_values\\\"] = input_values.pop(\\\"inputs\\\") if \\\"decoder_cached_states\\\" in input_values: warnings.warn( \\\"The `decoder_cached_states` argument is deprecated\",\n \"all_self_attentions] if v is not None) return TFBaseModelOutput( last_hidden_state=hidden_states, hidden_states=all_hidden_states, attentions=all_self_attentions, ) @keras_serializable\",\n \"<= vocab_size: {self.config.vocab_size}\\\") attention_mask = ( inputs[\\\"attention_mask\\\"] if inputs[\\\"attention_mask\\\"] is not None else\",\n \"to convert `input_values` indices into associated vectors than the model's internal embedding lookup\",\n \"= tf.keras.layers.Dense( units=config.hidden_size, kernel_initializer=get_initializer(config.initializer_range), bias_initializer=\\\"zeros\\\", name=\\\"output_dense\\\", ) self.output_dropout = tf.keras.layers.Dropout(config.hidden_dropout) def call(self, hidden_states:\",\n \"sequence_length if num_masked_spans * mask_length > sequence_length: num_masked_spans = sequence_length // mask_length #\",\n \"self.beta = self.add_weight( shape=shape, name=\\\"beta\\\", initializer=self.beta_initializer, regularizer=self.beta_regularizer, constraint=self.beta_constraint, ) else: self.beta = None\",\n \"isinstance(input, allowed_types) or input is None: output[parameter_names[i]] = input else: raise ValueError( f\\\"Data\",\n \"= [ \\\"facebook/hubert-base-ls960\\\", # See all Hubert models at https://huggingface.co/models?filter=hubert ] LARGE_NEGATIVE =\",\n \"IN THE ORDER given in the docstring: `model([input_values, attention_mask])` or `model([input_values, attention_mask, token_type_ids])`\",\n \"Optional[tf.Tensor] = None, training: Optional[bool] = False, ) -> Tuple[tf.Tensor, Optional[tf.Tensor]]: \\\"\\\"\\\"Input shape:\",\n \"hidden_states, attention_mask=attention_mask, output_attentions=inputs[\\\"output_attentions\\\"], output_hidden_states=inputs[\\\"output_hidden_states\\\"], return_dict=inputs[\\\"return_dict\\\"], training=inputs[\\\"training\\\"], ) hidden_states = encoder_outputs[0] if not inputs[\\\"return_dict\\\"]:\",\n \"f\\\"`mask_length` has to be smaller than `sequence_length`, but got `mask_length`: {mask_length} and `sequence_length`:\",\n \"weights. \\\"\\\"\\\" HUBERT_INPUTS_DOCSTRING = r\\\"\\\"\\\" Args: input_values (`np.ndarray`, `tf.Tensor`, `List[tf.Tensor]` ``Dict[str, tf.Tensor]` or\",\n \"mode the value in the config will be used instead. output_hidden_states (`bool`, *optional*):\",\n \"+ self.feed_forward(hidden_states) hidden_states = self.final_layer_norm(hidden_states) outputs = (hidden_states,) if output_attentions: outputs += (attn_weights,)\",\n \"HubertConfig logger = logging.get_logger(__name__) _CONFIG_FOR_DOC = \\\"HubertConfig\\\" TF_HUBERT_PRETRAINED_MODEL_ARCHIVE_LIST = [ \\\"facebook/hubert-base-ls960\\\", # See\",\n \"config_class = HubertConfig base_model_prefix = \\\"hubert\\\" main_input_name = \\\"input_values\\\" @property def dummy_inputs(self) ->\",\n \"the the shape for which to compute masks. should be of size 2\",\n \"tf.keras.constraints.serialize(self.gamma_constraint), } base_config = super().get_config() return {**base_config, **config} def compute_output_shape(self, input_shape): return input_shape\",\n \"= tf.reduce_sum(labels_mask, axis=-1) loss = tf.nn.ctc_loss( logits=logits, labels=labels, logit_length=input_lengths, label_length=target_lengths, blank_index=self.config.pad_token_id, logits_time_major=False, )\",\n \"WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See\",\n \"tf.newaxis, tf.newaxis]) def _normalize_kernel(self): \\\"\\\"\\\"Generate normalized weights.\\\"\\\"\\\" kernel = tf.nn.l2_normalize(self.weight_v, axis=self.kernel_norm_axes) * tf.transpose(self.weight_g)\",\n \"= False, ) -> Union[TFCausalLMOutput, Tuple[tf.Tensor]]: r\\\"\\\"\\\" labels (`tf.Tensor` or `np.ndarray` of shape\",\n \"*inputs, **kwargs): super().__init__(config, *inputs, **kwargs) self.hubert = TFHubertMainLayer(config, name=\\\"hubert\\\") self.dropout = tf.keras.layers.Dropout(config.final_dropout) self.lm_head\",\n \"has to be one of ['group', 'layer']\\\" ) self.conv_layers = conv_layers def call(self,\",\n \"inputs: - having all inputs as keyword arguments (like PyTorch models), or -\",\n \"position_embeddings = self.pos_conv_embed(hidden_states) hidden_states = hidden_states + position_embeddings hidden_states = self.layer_norm(hidden_states) hidden_states =\",\n \"else: broadcast_shape[self.axis] = self.groups return broadcast_shape # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2WeightNormConv1D with Wav2Vec2->Hubert class\",\n \"\\\"mean\\\": loss = tf.reduce_mean(loss) else: loss = None if not inputs[\\\"return_dict\\\"]: output =\",\n \"TFHubertWeightNormConv1D( filters=config.hidden_size, kernel_size=config.num_conv_pos_embeddings, groups=config.num_conv_pos_embedding_groups, explicit_padding=config.num_conv_pos_embeddings // 2, name=\\\"conv\\\", ) self.padding = TFHubertSamePadLayer(config.num_conv_pos_embeddings) self.activation\",\n \"if v is not None) return TFBaseModelOutput( last_hidden_state=hidden_states, hidden_states=all_hidden_states, attentions=all_self_attentions, ) # Copied\",\n \"= tf.keras.layers.Conv1D( filters=self.out_conv_dim, kernel_size=config.conv_kernel[layer_id], strides=config.conv_stride[layer_id], use_bias=config.conv_bias, name=\\\"conv\\\", ) self.activation = get_tf_activation(config.feat_extract_activation) def call(self,\",\n \"output_hidden_states=output_hidden_states, return_dict=return_dict, training=training, ) outputs = self.hubert( input_values=inputs[\\\"input_values\\\"], attention_mask=inputs[\\\"attention_mask\\\"], token_type_ids=inputs[\\\"token_type_ids\\\"], position_ids=inputs[\\\"position_ids\\\"], head_mask=inputs[\\\"head_mask\\\"], inputs_embeds=inputs[\\\"inputs_embeds\\\"],\",\n \"unexpected layers. \\\"\\\"\\\" signature = dict(inspect.signature(func).parameters) signature.pop(\\\"kwargs\\\", None) signature.pop(\\\"self\\\", None) parameter_names = list(signature.keys())\",\n \"input_shape): return input_shape def _reshape_into_groups(self, inputs, input_shape, tensor_input_shape): group_shape = [tensor_input_shape[i] for i\",\n \"LARGE_NEGATIVE = -1e8 # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.input_values_processing def input_values_processing(func, config, input_values, **kwargs): \\\"\\\"\\\"\",\n \"# reuse k, v, self_attention key_states = self._shape(self.k_proj(hidden_states), -1, bsz) value_states = self._shape(self.v_proj(hidden_states),\",\n \"Batch size 1 >>> logits = model(input_values).logits >>> predicted_ids = tf.argmax(logits, axis=-1) >>>\",\n \"initializer=self.gamma_initializer, regularizer=self.gamma_regularizer, constraint=self.gamma_constraint, ) else: self.gamma = None def _add_beta_weight(self, input_shape): dim =\",\n \"to a *sentence A* token, - 1 corresponds to a *sentence B* token.\",\n \"( inputs[\\\"output_hidden_states\\\"] if inputs[\\\"output_hidden_states\\\"] else self.config.output_hidden_states ) inputs[\\\"output_attentions\\\"] = ( inputs[\\\"output_attentions\\\"] if inputs[\\\"output_attentions\\\"]\",\n \"def _check_if_input_shape_is_none(self, input_shape): dim = input_shape[self.axis] if dim is None: raise ValueError( \\\"Axis\",\n \"**kwargs): super().__init__(config, **kwargs) warnings.warn( f\\\"The class `{self.__class__.__name__}` has been depreciated \\\" \\\"and will\",\n \"to `-100` are ignored (masked), the loss is only computed for the tokens\",\n \"`num_heads`: {num_heads}).\\\" ) self.scaling = self.head_dim**-0.5 self.is_decoder = is_decoder self.k_proj = tf.keras.layers.Dense(embed_dim, use_bias=bias,\",\n \") super().build(input_shape) def _get_feat_extract_output_lengths(self, input_lengths: tf.Tensor): \\\"\\\"\\\" Computes the output length of the\",\n \"`model([input_values, attention_mask, token_type_ids])` - a dictionary with one or several input Tensors associated\",\n \"i in range(config.num_hidden_layers)] def call( self, hidden_states: tf.Tensor, attention_mask: Optional[tf.Tensor] = None, output_attentions:\",\n \"logger = logging.get_logger(__name__) _CONFIG_FOR_DOC = \\\"HubertConfig\\\" TF_HUBERT_PRETRAINED_MODEL_ARCHIVE_LIST = [ \\\"facebook/hubert-base-ls960\\\", # See all\",\n \"from [fairseq's data_utils.py](https://github.com/pytorch/fairseq/blob/e0788f7007a8473a76db573985031f3c94201e79/fairseq/data/data_utils.py#L376). \\\"\\\"\\\" batch_size, sequence_length = shape if mask_length < 1: raise\",\n \"= self.layer_norm(hidden_states) hidden_states = self.activation(hidden_states) return hidden_states # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2PositionalConvEmbedding with Wav2Vec2->Hubert\",\n \"1)) _, indices = tf.nn.top_k(distribution + z, num_samples) return indices # Copied from\",\n \"self.serving_output(output) HUBERT_START_DOCSTRING = r\\\"\\\"\\\" This model inherits from [`TFPreTrainedModel`]. Check the superclass documentation\",\n \"attention_mask = ( inputs[\\\"attention_mask\\\"] if inputs[\\\"attention_mask\\\"] is not None else tf.ones_like(inputs[\\\"input_values\\\"], dtype=tf.float32) )\",\n \"in other modes than eager. if tf.executing_eagerly(): tf.debugging.assert_equal( shape_list(attention_mask), [bsz, 1, tgt_len, src_len],\",\n \"kernel_size) // stride + 1 for kernel_size, stride in zip(self.config.conv_kernel, self.config.conv_stride): input_lengths =\",\n \"+ offsets # scatter indices to mask spec_aug_mask = _scatter_values_on_batch_indices( tf.ones_like(spec_aug_mask_idxs), spec_aug_mask_idxs, spec_aug_mask.shape\",\n \"str(dim) + \\\").\\\" ) if dim % self.groups != 0: raise ValueError( \\\"Number\",\n \"] else: raise ValueError( f\\\"`config.feat_extract_norm` is {config.feat_extract_norm}, but has to be one of\",\n \"# uniform distribution to sample from, make sure that offset samples are <\",\n \"= embed_dim // num_heads if (self.head_dim * num_heads) != self.embed_dim: raise ValueError( f\\\"embed_dim\",\n \"output = {} allowed_types = (tf.Tensor, bool, int, ModelOutput, tuple, list, dict, np.ndarray)\",\n \"= kwargs.pop(name, signature[name].default) # When creating a SavedModel TF calls the method with\",\n \"axis mask_time_indices = _compute_mask_indices( (batch_size, sequence_length), mask_prob=self.config.mask_time_prob, mask_length=self.config.mask_time_length, min_masks=2, ) hidden_states = tf.where(\",\n \"embedding lookup matrix. output_attentions (`bool`, *optional*): Whether or not to return the attentions\",\n \"number will be smaller (unless no_overlap is True) mask_length: size of the mask\",\n \"name=\\\"output_dense\\\", ) self.output_dropout = tf.keras.layers.Dropout(config.hidden_dropout) def call(self, hidden_states: tf.Tensor, training: bool = False)\",\n \"under the License is distributed on an \\\"AS IS\\\" BASIS, # WITHOUT WARRANTIES\",\n \"key_states, transpose_b=True) # The tf.debugging asserts are not compliant with XLA then they\",\n \"\\\"AS IS\\\" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express\",\n \"return outputs # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2EncoderLayerStableLayerNorm with Wav2Vec2->Hubert class TFHubertEncoderLayerStableLayerNorm(tf.keras.layers.Layer): def __init__(self, config:\",\n \"if self.center: beta = tf.reshape(self.beta, broadcast_shape) return gamma, beta def _check_if_input_shape_is_none(self, input_shape): dim\",\n \"-1e8 # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.input_values_processing def input_values_processing(func, config, input_values, **kwargs): \\\"\\\"\\\" Process the\",\n \") hidden_states = layer_outputs[0] if output_attentions: all_self_attentions = all_self_attentions + (layer_outputs[1],) # Add\",\n \"inputs_embeds=inputs[\\\"inputs_embeds\\\"], output_attentions=inputs[\\\"output_attentions\\\"], output_hidden_states=inputs[\\\"output_hidden_states\\\"], return_dict=inputs[\\\"return_dict\\\"], training=inputs[\\\"training\\\"], ) hidden_states = outputs[0] hidden_states = self.dropout(hidden_states, training=inputs[\\\"training\\\"])\",\n \"get_tf_activation(config.hidden_act) self.output_dense = tf.keras.layers.Dense( units=config.hidden_size, kernel_initializer=get_initializer(config.initializer_range), bias_initializer=\\\"zeros\\\", name=\\\"output_dense\\\", ) self.output_dropout = tf.keras.layers.Dropout(config.hidden_dropout) def\",\n \"# compute number of masked spans in batch num_masked_spans = int(mask_prob * sequence_length\",\n \"for i in range(config.num_hidden_layers)] def call( self, hidden_states: tf.Tensor, attention_mask: Optional[tf.Tensor] = None,\",\n \"of type {type(v)} is not allowed only {allowed_types} is accepted for {k}.\\\") if\",\n \"tf.expand_dims(attention_mask, -1) attention_mask = _expand_mask(attention_mask) else: attention_mask = None position_embeddings = self.pos_conv_embed(hidden_states) hidden_states\",\n \"Optional[Tuple[Tuple[tf.Tensor]]] = None, attention_mask: Optional[tf.Tensor] = None, layer_head_mask: Optional[tf.Tensor] = None, training: Optional[bool]\",\n \"None: # The tf.debugging asserts are not compliant with XLA then they #\",\n \"tf.keras.initializers.serialize(self.beta_initializer), \\\"gamma_initializer\\\": tf.keras.initializers.serialize(self.gamma_initializer), \\\"beta_regularizer\\\": tf.keras.regularizers.serialize(self.beta_regularizer), \\\"gamma_regularizer\\\": tf.keras.regularizers.serialize(self.gamma_regularizer), \\\"beta_constraint\\\": tf.keras.constraints.serialize(self.beta_constraint), \\\"gamma_constraint\\\": tf.keras.constraints.serialize(self.gamma_constraint), } base_config\",\n \"= tf.nn.ctc_loss( logits=logits, labels=labels, logit_length=input_lengths, label_length=target_lengths, blank_index=self.config.pad_token_id, logits_time_major=False, ) if self.config.ctc_loss_reduction == \\\"sum\\\":\",\n \"CONDITIONS OF ANY KIND, either express or implied. # See the License for\",\n \"can choose to directly pass an embedded representation. This is useful if you\",\n \"import tensorflow as tf >>> from transformers import Wav2Vec2Processor, TFHubertForCTC >>> from datasets\",\n \"1 if not is_instance_norm: group_shape[self.axis] = input_shape[self.axis] // self.groups group_shape.insert(self.axis, self.groups) group_shape =\",\n \"with Wav2Vec2->Hubert class TFHubertLayerNormConvLayer(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, layer_id: int = 0, **kwargs:\",\n \"None, :], (1, 1, tgt_len, 1)) return (one_cst - expanded_mask) * LARGE_NEGATIVE #\",\n \"models accepts two formats as inputs: - having all inputs as keyword arguments\",\n \"input Tensors in the first positional argument : - a single Tensor with\",\n \") inputs[\\\"output_attentions\\\"] = ( inputs[\\\"output_attentions\\\"] if inputs[\\\"output_attentions\\\"] else self.config.output_attentions ) inputs[\\\"return_dict\\\"] = inputs[\\\"return_dict\\\"]\",\n \"output_attentions: all_self_attentions = all_self_attentions + (layer_outputs[1],) hidden_states = self.layer_norm(hidden_states) if output_hidden_states: all_hidden_states =\",\n \"and evaluation). \\\"\\\"\\\" @add_start_docstrings( \\\"The bare TFHubert Model transformer outputing raw hidden-states without\",\n \"shape `({0})`, *optional*): Mask to avoid performing attention on padding token indices. Mask\",\n \"time axis mask_time_indices = _compute_mask_indices( (batch_size, sequence_length), mask_prob=self.config.mask_time_prob, mask_length=self.config.mask_time_length, min_masks=2, ) hidden_states =\",\n \"-self.num_pad_remove, :] return hidden_states class TFHubertFeatureEncoder(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs: Any) ->\",\n \"to masked spans spec_aug_mask_idxs = tf.expand_dims(spec_aug_mask_idxs, -1) spec_aug_mask_idxs = tf.tile(spec_aug_mask_idxs, (1, 1, mask_length))\",\n \"past_key_value = (key_states, value_states) proj_shape = (bsz * self.num_heads, -1, self.head_dim) query_states =\",\n \"tf.keras.initializers.Initializer = \\\"zeros\\\", gamma_initializer: tf.keras.initializers.Initializer = \\\"ones\\\", beta_regularizer: tf.keras.regularizers.Regularizer = None, gamma_regularizer: tf.keras.regularizers.Regularizer\",\n \"compliance with the License. # You may obtain a copy of the License\",\n \"= TFHubertMainLayer(config, name=\\\"hubert\\\") self.dropout = tf.keras.layers.Dropout(config.final_dropout) self.lm_head = tf.keras.layers.Dense(config.vocab_size, name=\\\"lm_head\\\") def freeze_feature_extractor(self): \\\"\\\"\\\"\",\n \"weights should be of size {(bsz * self.num_heads, tgt_len, src_len)}, but is {shape_list(attn_weights)}\\\",\",\n \"self.activation = get_tf_activation(config.feat_extract_activation) self.layer_norm = TFHubertGroupNorm(groups=self.out_conv_dim, epsilon=config.layer_norm_eps, name=\\\"layer_norm\\\") def call(self, hidden_states: tf.Tensor) ->\",\n \"return hidden_states class TFHubertFeatureEncoder(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs: Any) -> None: super().__init__(**kwargs)\",\n \"eager. if tf.executing_eagerly(): tf.debugging.assert_equal( shape_list(attention_mask), [bsz, 1, tgt_len, src_len], message=f\\\"Attention mask should be\",\n \"you need a GPU or a TPU\\\" ) @tf.function def serving(self, inputs): output\",\n \"1 >>> logits = model(input_values).logits >>> predicted_ids = tf.argmax(logits, axis=-1) >>> transcription =\",\n \"{k}.\\\") if isinstance(input_values, (tuple, list)): for i, input in enumerate(input_values): # EagerTensors don't\",\n \"is not None else tf.ones_like(inputs[\\\"input_values\\\"], dtype=tf.float32) ) input_lengths = self.hubert._get_feat_extract_output_lengths(tf.reduce_sum(attention_mask, axis=-1)) # assuming\",\n \"= list(signature.keys()) output = {} allowed_types = (tf.Tensor, bool, int, ModelOutput, tuple, list,\",\n \"// mask_length # SpecAugment mask to fill spec_aug_mask = tf.zeros((batch_size, sequence_length), dtype=tf.int32) #\",\n \"+ str(dim) + \\\").\\\" ) if dim % self.groups != 0: raise ValueError(\",\n \"(\\\" + str(self.groups) + \\\") must be a \\\" \\\"multiple of the number\",\n \"the running model. **kwargs: The inputs of the model. Returns: Two lists, one\",\n \"different behaviors between training and evaluation). \\\"\\\"\\\" @add_start_docstrings( \\\"The bare TFHubert Model transformer\",\n \"> sequence_length: num_masked_spans = sequence_length // mask_length # SpecAugment mask to fill spec_aug_mask\",\n \"= self.output_dropout(hidden_states, training=training) return hidden_states # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2EncoderLayer with Wav2Vec2->Hubert class TFHubertEncoderLayer(tf.keras.layers.Layer):\",\n \"indixes) \\\"\\\"\\\" indices_shape = shape_list(batch_indices) # broadcast batch dim to indices_shape broad_casted_batch_dims =\",\n \"= self.final_layer_norm(hidden_states) outputs = (hidden_states,) if output_attentions: outputs += (attn_weights,) return outputs #\",\n \"input_shape: tf.TensorShape): self.masked_spec_embed = self.add_weight( shape=(self.config.hidden_size,), initializer=\\\"uniform\\\", trainable=True, name=\\\"masked_spec_embed\\\" ) super().build(input_shape) def _get_feat_extract_output_lengths(self,\",\n \"1 >>> hidden_states = model(input_values).last_hidden_state ```\\\"\\\"\\\" inputs = input_values_processing( func=self.call, config=self.config, input_values=input_values, attention_mask=attention_mask,\",\n \"int, min_masks: int = 0, ) -> tf.Tensor: \\\"\\\"\\\" Computes random mask spans\",\n \"def _reshape_into_groups(self, inputs, input_shape, tensor_input_shape): group_shape = [tensor_input_shape[i] for i in range(len(input_shape))] is_instance_norm\",\n \"than `sequence_length`, but got `mask_length`: {mask_length} and `sequence_length`: {sequence_length}`\\\" ) # compute number\",\n \"including the booleans. In case of a list of symbolic inputs, each input\",\n \"be chosen as start of the span to be masked. this will be\",\n \"hidden_states = layer_outputs[0] if output_attentions: all_self_attentions = all_self_attentions + (layer_outputs[1],) hidden_states = self.layer_norm(hidden_states)\",\n \"- kernel_size) // stride + 1 for kernel_size, stride in zip(self.config.conv_kernel, self.config.conv_stride): input_lengths\",\n \"input_shape, tensor_input_shape) normalized_inputs = self._apply_normalization(reshaped_inputs, input_shape) is_instance_norm = (input_shape[self.axis] // self.groups) == 1\",\n \"output = self.call(input_values=inputs, training=False) return self.serving_output(output) HUBERT_START_DOCSTRING = r\\\"\\\"\\\" This model inherits from\",\n \"Labels for computing the masked language modeling loss. Indices should be in `[-100,\",\n \"for the decoder is_cross_attention = key_value_states is not None bsz, tgt_len, embed_dim =\",\n \"vectors than the model's internal embedding lookup matrix. output_attentions (`bool`, *optional*): Whether or\",\n \"): super().__init__(**kwargs) self.supports_masking = True self.groups = groups self.axis = axis self.epsilon =\",\n \"apply SpecAugment along time axis mask_time_indices = _compute_mask_indices( (batch_size, sequence_length), mask_prob=self.config.mask_time_prob, mask_length=self.config.mask_time_length, min_masks=2,\",\n \"def compute_output_shape(self, input_shape): return input_shape def _reshape_into_groups(self, inputs, input_shape, tensor_input_shape): group_shape = [tensor_input_shape[i]\",\n \"want more control over how to convert `input_values` indices into associated vectors than\",\n \"`[0, 1]`: - 1 indicates the head is **not masked**, - 0 indicates\",\n \"] elif config.feat_extract_norm == \\\"layer\\\": conv_layers = [ TFHubertLayerNormConvLayer(config, layer_id=i, name=f\\\"conv_layers.{i}\\\") for i\",\n \"\\\"elif\\\" case) # if encoder bi-directional self-attention `past_key_value` is always `None` past_key_value =\",\n \"is_cross_attention: # cross_attentions key_states = self._shape(self.k_proj(key_value_states), -1, bsz) value_states = self._shape(self.v_proj(key_value_states), -1, bsz)\",\n \"# Unless required by applicable law or agreed to in writing, software #\",\n \"hidden_states # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2SamePadLayer with Wav2Vec2->Hubert class TFHubertSamePadLayer(tf.keras.layers.Layer): def __init__(self, num_conv_pos_embeddings, **kwargs):\",\n \"attns = tf.convert_to_tensor(output.attentions) if self.config.output_attentions else None return TFBaseModelOutput(last_hidden_state=output.last_hidden_state, hidden_states=hs, attentions=attns) @add_start_docstrings( \\\"\\\"\\\"TFHubert\",\n \"training=False) return self.serving_output(output) HUBERT_START_DOCSTRING = r\\\"\\\"\\\" This model inherits from [`TFPreTrainedModel`]. Check the\",\n \"features along time axis and/or along feature axis according to [SpecAugment](https://arxiv.org/abs/1904.08779). \\\"\\\"\\\" batch_size,\",\n \"def __init__(self, filters, kernel_size, groups, explicit_padding, **kwargs): super().__init__( filters=filters, kernel_size=kernel_size, groups=groups, padding=\\\"valid\\\", use_bias=True,\",\n \"Optional[tf.Tensor]]: \\\"\\\"\\\"Input shape: Batch x Time x Channel\\\"\\\"\\\" # if key_value_states are provided\",\n \"self.padding = TFHubertSamePadLayer(config.num_conv_pos_embeddings) self.activation = get_tf_activation(config.feat_extract_activation) def call(self, hidden_states: tf.Tensor) -> tf.Tensor: hidden_states\",\n \"= shape_list(mask)[1] tgt_len = tgt_len if tgt_len is not None else src_len one_cst\",\n \"v in [hidden_states, all_hidden_states, all_self_attentions] if v is not None) return TFBaseModelOutput( last_hidden_state=hidden_states,\",\n \"((0, 0), (self.explicit_padding, self.explicit_padding), (0, 0))) output = super().call(padded_inputs) return output # Copied\",\n \"in enumerate(self.layer): if output_hidden_states: all_hidden_states = all_hidden_states + (hidden_states,) # add LayerDrop (see\",\n \"if output_hidden_states: all_hidden_states = all_hidden_states + (hidden_states,) if not return_dict: return tuple(v for\",\n \"self.intermediate_dropout = tf.keras.layers.Dropout(config.activation_dropout) self.intermediate_dense = tf.keras.layers.Dense( units=config.intermediate_size, kernel_initializer=get_initializer(config.initializer_range), bias_initializer=\\\"zeros\\\", name=\\\"intermediate_dense\\\", ) self.intermediate_act_fn =\",\n \"loss >>> target_transcription = \\\"A MAN SAID TO THE UNIVERSE SIR I EXIST\\\"\",\n \"in parameter_names and \\\"args\\\" not in parameter_names: logger.warning( f\\\"The parameter {k} does not\",\n \"token indices. Mask values selected in `[0, 1]`: - 1 for tokens that\",\n \"{k}.\\\") else: if isinstance(input_values, tf.Tensor) or input_values is None: output[parameter_names[0]] = input_values else:\",\n \"shape: Batch x Time x Channel\\\"\\\"\\\" # if key_value_states are provided this layer\",\n \"hidden_states # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2LayerNormConvLayer with Wav2Vec2->Hubert class TFHubertLayerNormConvLayer(tf.keras.layers.Layer): def __init__(self, config: HubertConfig,\",\n \":], hidden_states, 0) return hidden_states def call( self, input_values: tf.Tensor, attention_mask: Optional[tf.Tensor] =\",\n \"attentions=all_self_attentions, ) # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2EncoderStableLayerNorm with Wav2Vec2->Hubert class TFHubertEncoderStableLayerNorm(tf.keras.layers.Layer): def __init__(self, config:\",\n \"False, ) -> Tuple[tf.Tensor]: attn_residual = hidden_states hidden_states = self.layer_norm(hidden_states) hidden_states, attn_weights, _\",\n \"HubertConfig, **kwargs: Any) -> None: super().__init__(**kwargs) if config.feat_extract_norm == \\\"group\\\": conv_layers = [TFHubertGroupNormConvLayer(config,\",\n \"str(dim) + \\\").\\\" ) def _check_axis(self): if self.axis == 0: raise ValueError( \\\"You\",\n \"attn_weights, (bsz, self.num_heads, tgt_len, src_len) ) attn_weights = tf.reshape(attn_weights, (bsz * self.num_heads, tgt_len,\",\n \"tensor should have a defined dimension \\\" \\\"but the layer received an input\",\n \"a GPU or a TPU\\\" ) @tf.function def serving(self, inputs): output = self.call(input_values=inputs,\",\n \"Mask to avoid performing attention on padding token indices. Mask values selected in\",\n \"training=training) hidden_states = attn_residual + hidden_states hidden_states = self.layer_norm(hidden_states) hidden_states = hidden_states +\",\n \"is_instance_norm = (input_shape[self.axis] // self.groups) == 1 if not is_instance_norm: axis = -2\",\n \"def _init_norm(self): \\\"\\\"\\\"Set the norm of the weight vector.\\\"\\\"\\\" kernel_norm = tf.sqrt(tf.reduce_sum(tf.square(self.weight_v), axis=self.kernel_norm_axes))\",\n \"argument of the model call function: `model(inputs)`. If you choose this second option,\",\n \"tf.cast(tf.not_equal(input_values, pad_token), tf.float32), } return dummy_inputs def __init__(self, config, *inputs, **kwargs): super().__init__(config, *inputs,\",\n \"spec_aug_mask.shape ) return spec_aug_mask # Copied from transformers.models.bart.modeling_tf_bart._expand_mask def _expand_mask(mask: tf.Tensor, tgt_len: Optional[int]\",\n \"having all inputs as a list, tuple or dict in the first positional\",\n \"= output[\\\"args\\\"] del output[\\\"args\\\"] if \\\"kwargs\\\" in output: del output[\\\"kwargs\\\"] boolean_dict = {\",\n \"self.layer_norm(hidden_states) hidden_states = self.activation(hidden_states) return hidden_states # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2PositionalConvEmbedding with Wav2Vec2->Hubert class\",\n \"\\\"groups\\\": self.groups, \\\"axis\\\": self.axis, \\\"epsilon\\\": self.epsilon, \\\"center\\\": self.center, \\\"scale\\\": self.scale, \\\"beta_initializer\\\": tf.keras.initializers.serialize(self.beta_initializer), \\\"gamma_initializer\\\":\",\n \"OR CONDITIONS OF ANY KIND, either express or implied. # See the License\",\n \"under the License. \\\"\\\"\\\" TensorFlow Hubert model.\\\"\\\"\\\" import inspect import warnings from typing\",\n \"load_dataset >>> import soundfile as sf >>> processor = Wav2Vec2Processor.from_pretrained(\\\"facebook/hubert-base-960h\\\") >>> model =\",\n \"hidden_size), mask_prob=self.config.mask_feature_prob, mask_length=self.config.mask_feature_length, ) hidden_states = tf.where(mask_feature_indices[:, tf.newaxis, :], hidden_states, 0) return hidden_states\",\n \"`past_key_value` is always `None` past_key_value = (key_states, value_states) proj_shape = (bsz * self.num_heads,\",\n \"input of each TensorFlow model including the booleans. In case of a list\",\n \"-> tf.Tensor: hidden_states = self.conv(hidden_states) hidden_states = self.padding(hidden_states) hidden_states = self.activation(hidden_states) return hidden_states\",\n \"name=\\\"layer_norm\\\") self.dropout = tf.keras.layers.Dropout(config.hidden_dropout) self.layer = [TFHubertEncoderLayer(config, name=f\\\"layers.{i}\\\") for i in range(config.num_hidden_layers)] def\",\n \"tf.keras.regularizers.Regularizer = None, beta_constraint: tf.keras.constraints.Constraint = None, gamma_constraint: tf.keras.constraints.Constraint = None, **kwargs, ):\",\n \"Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2EncoderLayer with Wav2Vec2->Hubert class TFHubertEncoderLayer(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs): super().__init__(**kwargs)\",\n \"= self._apply_normalization(reshaped_inputs, input_shape) is_instance_norm = (input_shape[self.axis] // self.groups) == 1 if not is_instance_norm:\",\n \"for each token to be chosen as start of the span to be\",\n \"self.groups) == 1 if not is_instance_norm: group_shape[self.axis] = input_shape[self.axis] // self.groups group_shape.insert(self.axis, self.groups)\",\n \"parameters name, i.e. `input_values = tf.keras.Input(shape=(128,), dtype='float32', name=\\\"input_values\\\")` otherwise the order of the\",\n \"Wav2Vec2->Hubert class TFHubertEncoder(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs): super().__init__(**kwargs) self.config = config self.pos_conv_embed\",\n \"\\\"\\\"\\\" def _conv_out_length(input_length, kernel_size, stride): # 1D convolutional layer output length formula taken\",\n \"return hidden_states # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2PositionalConvEmbedding with Wav2Vec2->Hubert class TFHubertPositionalConvEmbedding(tf.keras.layers.Layer): def __init__(self, config:\",\n \"def serving_output(self, output): hs = tf.convert_to_tensor(output.hidden_states) if self.config.output_hidden_states else None attns = tf.convert_to_tensor(output.attentions)\",\n \"head_mask=head_mask, inputs_embeds=inputs_embeds, output_attentions=output_attentions, output_hidden_states=output_hidden_states, return_dict=return_dict, training=training, kwargs_call=kwargs, ) hidden_states = self.feature_extractor( tf.cast(inputs[\\\"input_values\\\"], tf.float32),\",\n \"to sample from, make sure that offset samples are < sequence_length uniform_dist =\",\n \"function will disable the gradient computation for the feature encoder so that its\",\n \"tf.keras.layers.LayerNormalization(epsilon=config.layer_norm_eps, name=\\\"layer_norm\\\") self.projection = tf.keras.layers.Dense( units=config.hidden_size, kernel_initializer=get_initializer(config.initializer_range), bias_initializer=\\\"zeros\\\", name=\\\"projection\\\", ) self.dropout = tf.keras.layers.Dropout(rate=config.feat_proj_dropout)\",\n \"attn_residual = hidden_states hidden_states = self.layer_norm(hidden_states) hidden_states, attn_weights, _ = self.attention( hidden_states, attention_mask=attention_mask,\",\n \") @keras_serializable class TFHubertMainLayer(tf.keras.layers.Layer): config_class = HubertConfig def __init__(self, config: HubertConfig, **kwargs): super().__init__(**kwargs)\",\n \"= self._get_feat_extract_output_lengths(tf.reduce_sum(inputs[\\\"attention_mask\\\"], -1)) attention_mask = tf.sequence_mask( output_lengths, maxlen=shape_list(hidden_states)[1], dtype=hidden_states.dtype ) hidden_states = self.feature_projection(hidden_states,\",\n \"tf.keras.constraints.serialize(self.beta_constraint), \\\"gamma_constraint\\\": tf.keras.constraints.serialize(self.gamma_constraint), } base_config = super().get_config() return {**base_config, **config} def compute_output_shape(self, input_shape):\",\n \"= shape_list(hidden_states) # get query proj query_states = self.q_proj(hidden_states) * self.scaling # get\",\n \"def __init__(self, config: HubertConfig, **kwargs): super().__init__(**kwargs) self.intermediate_dropout = tf.keras.layers.Dropout(config.activation_dropout) self.intermediate_dense = tf.keras.layers.Dense( units=config.intermediate_size,\",\n \"tf.Tensor, seq_len: int, bsz: int): return tf.transpose(tf.reshape(tensor, (bsz, seq_len, self.num_heads, self.head_dim)), (0, 2,\",\n \"self._create_input_spec(input_shape) self._add_gamma_weight(input_shape) self._add_beta_weight(input_shape) self.built = True super().build(input_shape) def call(self, inputs): input_shape = tf.keras.backend.int_shape(inputs)\",\n \"self.dropout(hidden_states, training=training) hidden_states = attn_residual + hidden_states hidden_states = hidden_states + self.feed_forward(self.final_layer_norm(hidden_states)) outputs\",\n \"\\\"apply_spec_augment\\\", True): return hidden_states if mask_time_indices is not None: # apply SpecAugment along\",\n \"= tf.keras.layers.Conv1D( filters=self.out_conv_dim, kernel_size=config.conv_kernel[layer_id], strides=config.conv_stride[layer_id], use_bias=config.conv_bias, name=\\\"conv\\\", ) self.activation = get_tf_activation(config.feat_extract_activation) self.layer_norm =\",\n \"input Tensors associated to the input names given in the docstring: `model({\\\"input_values\\\": input_values,\",\n \"seq_len, self.num_heads, self.head_dim)), (0, 2, 1, 3)) def call( self, hidden_states: tf.Tensor, key_value_states:\",\n \"\\\"axis\\\": self.axis, \\\"epsilon\\\": self.epsilon, \\\"center\\\": self.center, \\\"scale\\\": self.scale, \\\"beta_initializer\\\": tf.keras.initializers.serialize(self.beta_initializer), \\\"gamma_initializer\\\": tf.keras.initializers.serialize(self.gamma_initializer), \\\"beta_regularizer\\\":\",\n \"but has to be one of ['group', 'layer']\\\" ) self.conv_layers = conv_layers def\",\n \"hidden_states # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2EncoderLayer with Wav2Vec2->Hubert class TFHubertEncoderLayer(tf.keras.layers.Layer): def __init__(self, config: HubertConfig,\",\n \"bias: bool = True, **kwargs, ): super().__init__(**kwargs) self.embed_dim = embed_dim self.num_heads = num_heads\",\n \"apply SpecAugment along time axis with given mask_time_indices hidden_states = tf.where( tf.cast(mask_time_indices[:, :,\",\n \"<Tip> TF 2.0 models accepts two formats as inputs: - having all inputs\",\n \"hidden_states hidden_states = self.layer_norm(hidden_states) hidden_states, attn_weights, _ = self.attention( hidden_states, attention_mask=attention_mask, training=training )\",\n \"`Dict[str, np.ndarray]` and each example must have the shape `({0})`): Indices of input\",\n \"from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2NoLayerNormConvLayer with Wav2Vec2->Hubert class TFHubertNoLayerNormConvLayer(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, layer_id: int =\",\n \"with Wav2Vec2->Hubert class TFHubertWeightNormConv1D(tf.keras.layers.Conv1D): \\\"\\\"\\\"Adapted from https://www.tensorflow.org/probability/api_docs/python/tfp/layers/weight_norm/WeightNorm\\\"\\\"\\\" def __init__(self, filters, kernel_size, groups, explicit_padding,\",\n \"1 if num_conv_pos_embeddings % 2 == 0 else 0 def call(self, hidden_states): if\",\n \"shape: Tuple[int, int], mask_prob: float, mask_length: int, min_masks: int = 0, ) ->\",\n \"tf.newaxis, :], hidden_states, ) elif self.config.mask_time_prob > 0: # generate indices & apply\",\n \"argument : - a single Tensor with `input_values` only and nothing else: `model(inputs_ids)`\",\n \"load the weights associated with the model, only the configuration. Check out the\",\n \"allowed only {allowed_types} is accepted for {parameter_names[0]}.\\\" ) for name in parameter_names: if\",\n \"not None: # The tf.debugging asserts are not compliant with XLA then they\",\n \"= scale self.beta_initializer = tf.keras.initializers.get(beta_initializer) self.gamma_initializer = tf.keras.initializers.get(gamma_initializer) self.beta_regularizer = tf.keras.regularizers.get(beta_regularizer) self.gamma_regularizer =\",\n \"attn_weights = tf.matmul(query_states, key_states, transpose_b=True) # The tf.debugging asserts are not compliant with\",\n \"if self.config.ctc_loss_reduction == \\\"sum\\\": loss = tf.reduce_sum(loss) if self.config.ctc_loss_reduction == \\\"mean\\\": loss =\",\n \"value_states], axis=2) else: # self_attention key_states = self._shape(self.k_proj(hidden_states), -1, bsz) value_states = self._shape(self.v_proj(hidden_states),\",\n \"= output[\\\"args\\\"].name.split(\\\":\\\")[0] output[tensor_name] = output[\\\"args\\\"] else: # `args` in this case is always\",\n \"of size {(bsz, 1, tgt_len, src_len)}, but is {shape_list(attention_mask)}\\\", ) attention_mask = tf.cast(attention_mask,\",\n \"= tf.reshape(self.gamma, broadcast_shape) if self.center: beta = tf.reshape(self.beta, broadcast_shape) return gamma, beta def\",\n \"bsz), proj_shape) key_states = tf.reshape(key_states, proj_shape) value_states = tf.reshape(value_states, proj_shape) src_len = shape_list(key_states)[1]\",\n \"logits = model(input_values).logits >>> predicted_ids = tf.argmax(logits, axis=-1) >>> transcription = processor.decode(predicted_ids[0]) >>>\",\n \"TFHubertAttention(tf.keras.layers.Layer): \\\"\\\"\\\"Multi-headed attention from \\\"Attention Is All You Need\\\"\\\"\\\" def __init__( self, embed_dim:\",\n \"src_len)}, but is {shape_list(attn_weights)}\\\", ) if attention_mask is not None: # The tf.debugging\",\n \"is batch size and 2nd is timesteps attention_mask: optional padding mask of the\",\n \"name=\\\"conv\\\", ) self.layer_norm = tf.keras.layers.LayerNormalization(name=\\\"layer_norm\\\", epsilon=config.layer_norm_eps) self.activation = get_tf_activation(config.feat_extract_activation) def call(self, hidden_states: tf.Tensor)\",\n \"is_instance_norm: group_shape[self.axis] = input_shape[self.axis] // self.groups group_shape.insert(self.axis, self.groups) group_shape = tf.stack(group_shape) reshaped_inputs =\",\n \"strides=config.conv_stride[layer_id], use_bias=config.conv_bias, name=\\\"conv\\\", ) self.layer_norm = tf.keras.layers.LayerNormalization(name=\\\"layer_norm\\\", epsilon=config.layer_norm_eps) self.activation = get_tf_activation(config.feat_extract_activation) def call(self,\",\n \"TFHubertFeedForward(config, name=\\\"feed_forward\\\") self.final_layer_norm = tf.keras.layers.LayerNormalization( epsilon=config.layer_norm_eps, name=\\\"final_layer_norm\\\" ) def call( self, hidden_states: tf.Tensor,\",\n \"{parameter_names[0]}.\\\" ) for name in parameter_names: if name not in list(output.keys()) and name\",\n \"- 0 indicates the head is **masked**. inputs_embeds (`np.ndarray` or `tf.Tensor` of shape\",\n \") attention_mask = tf.cast(attention_mask, dtype=attn_weights.dtype) attn_weights = tf.reshape(attn_weights, (bsz, self.num_heads, tgt_len, src_len)) +\",\n \"= (dim,) if self.scale: self.gamma = self.add_weight( shape=shape, name=\\\"gamma\\\", initializer=self.gamma_initializer, regularizer=self.gamma_regularizer, constraint=self.gamma_constraint, )\",\n \"\\\" \\\"multiple of the number of channels (\\\" + str(dim) + \\\").\\\" )\",\n \"Licensed under the Apache License, Version 2.0 (the \\\"License\\\"); # you may not\",\n \") class TFHubertFeatureProjection(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs): super().__init__(**kwargs) self.layer_norm = tf.keras.layers.LayerNormalization(epsilon=config.layer_norm_eps, name=\\\"layer_norm\\\")\",\n \"models at https://huggingface.co/models?filter=hubert ] LARGE_NEGATIVE = -1e8 # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.input_values_processing def input_values_processing(func,\",\n \"self.intermediate_dense(hidden_states) hidden_states = self.intermediate_act_fn(hidden_states) hidden_states = self.intermediate_dropout(hidden_states, training=training) hidden_states = self.output_dense(hidden_states) hidden_states =\",\n \") self.freeze_feature_encoder() def freeze_feature_encoder(self): \\\"\\\"\\\" Calling this function will disable the gradient computation\",\n \"= is_decoder self.k_proj = tf.keras.layers.Dense(embed_dim, use_bias=bias, name=\\\"k_proj\\\") self.q_proj = tf.keras.layers.Dense(embed_dim, use_bias=bias, name=\\\"q_proj\\\") self.v_proj\",\n \"self.conv = tf.keras.layers.Conv1D( filters=self.out_conv_dim, kernel_size=config.conv_kernel[layer_id], strides=config.conv_stride[layer_id], use_bias=config.conv_bias, name=\\\"conv\\\", ) self.activation = get_tf_activation(config.feat_extract_activation) self.layer_norm\",\n \"cross_attentions key_states = self._shape(self.k_proj(key_value_states), -1, bsz) value_states = self._shape(self.v_proj(key_value_states), -1, bsz) elif past_key_value\",\n \"1)) return (one_cst - expanded_mask) * LARGE_NEGATIVE # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2GroupNorm with Wav2Vec2->Hubert\",\n \"is distributed on an \\\"AS IS\\\" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF\",\n \"with indices set to `-100` are ignored (masked), the loss is only computed\",\n \"skip the layer continue layer_outputs = layer_module( hidden_states=hidden_states, attention_mask=attention_mask, output_attentions=output_attentions, training=training, ) hidden_states\",\n \"input_shape): dim = input_shape[self.axis] shape = (dim,) if self.scale: self.gamma = self.add_weight( shape=shape,\",\n \"del output[\\\"args\\\"] if \\\"kwargs\\\" in output: del output[\\\"kwargs\\\"] boolean_dict = { k: v\",\n \":] offsets = tf.tile(offsets, (batch_size, num_masked_spans, 1)) offsets = tf.reshape(offsets, (batch_size, num_masked_spans *\",\n \"= self.layer_norm(hidden_states) hidden_states = hidden_states + self.feed_forward(hidden_states) hidden_states = self.final_layer_norm(hidden_states) outputs = (hidden_states,)\",\n \"is not allowed only {allowed_types} is accepted for {parameter_names[i]}.\\\" ) elif isinstance(input_values, (dict,\",\n \"Example: ```python >>> from transformers import Wav2Vec2Processor, TFHubertModel >>> from datasets import load_dataset\",\n \"(bsz, tgt_len, embed_dim)) attn_output = self.out_proj(attn_output) attn_weights: tf.Tensor = tf.reshape(attn_weights, (bsz, self.num_heads, tgt_len,\",\n \") class TFHubertModel(TFHubertPreTrainedModel): def __init__(self, config: HubertConfig, *inputs, **kwargs): super().__init__(config, *inputs, **kwargs) self.config\",\n \"will do for now - see https://github.com/tensorflow/tensorflow/issues/9260 for more info \\\"\\\"\\\" z =\",\n \"[`TFPreTrainedModel`]. Check the superclass documentation for the generic methods the library implements for\",\n \"np.ndarray) for k, v in kwargs.items(): if isinstance(v, allowed_types) or v is None:\",\n \"in dict(input_values).items(): if isinstance(v, allowed_types) or v is None: output[k] = v elif\",\n \"HubertConfig, layer_id: int = 0, **kwargs: Any) -> None: super().__init__(**kwargs) self.in_conv_dim = config.conv_dim[layer_id]\",\n \"Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2WeightNormConv1D with Wav2Vec2->Hubert class TFHubertWeightNormConv1D(tf.keras.layers.Conv1D): \\\"\\\"\\\"Adapted from https://www.tensorflow.org/probability/api_docs/python/tfp/layers/weight_norm/WeightNorm\\\"\\\"\\\" def __init__(self, filters,\",\n \"if layer_head_mask is not None: # The tf.debugging asserts are not compliant with\",\n \"= tf.tile(offsets, (batch_size, num_masked_spans, 1)) offsets = tf.reshape(offsets, (batch_size, num_masked_spans * mask_length)) spec_aug_mask_idxs\",\n \"dtype=self.weight_v.dtype, trainable=True, ) self.bias = self.add_weight(name=\\\"bias\\\", shape=(self.filters,), initializer=\\\"zeros\\\", trainable=True) def call(self, inputs): if\",\n \"can be used only in eager mode, in graph mode the value in\",\n \"hidden_states = tf.where( tf.cast(mask_time_indices[:, :, tf.newaxis], tf.bool), self.masked_spec_embed[tf.newaxis, tf.newaxis, :], hidden_states, ) elif\",\n \"in `[0, ..., config.vocab_size]` Returns: Example: ```python >>> import tensorflow as tf >>>\",\n \"return the attentions tensors of all attention layers. See `attentions` under returned tensors\",\n \"shape for which to compute masks. should be of size 2 where first\",\n \"instead. output_hidden_states (`bool`, *optional*): Whether or not to return the hidden states of\",\n \"0): \\\"\\\"\\\" Expands attention_mask from `[bsz, seq_len]` to `[bsz, 1, tgt_seq_len, src_seq_len]`. \\\"\\\"\\\"\",\n \"([`HubertConfig`]): Model configuration class with all the parameters of the model. Initializing with\",\n \"the config will be used instead. output_hidden_states (`bool`, *optional*): Whether or not to\",\n \"tf.Tensor) -> tf.Tensor: hidden_states = self.conv(hidden_states) hidden_states = self.layer_norm(hidden_states) hidden_states = self.activation(hidden_states) return\",\n \"hidden_states # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2GroupNormConvLayer with Wav2Vec2->Hubert class TFHubertGroupNormConvLayer(tf.keras.layers.Layer): def __init__(self, config: HubertConfig,\",\n \"expanded_mask) * LARGE_NEGATIVE # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2GroupNorm with Wav2Vec2->Hubert class TFHubertGroupNorm(tf.keras.layers.Layer): \\\"\\\"\\\" From\",\n \"\\\"\\\"\\\"Set the norm of the weight vector.\\\"\\\"\\\" kernel_norm = tf.sqrt(tf.reduce_sum(tf.square(self.weight_v), axis=self.kernel_norm_axes)) self.weight_g.assign(kernel_norm[:, tf.newaxis,\",\n \"shape `(batch_size, sequence_length)`, *optional*): Labels for computing the masked language modeling loss. Indices\",\n \"of # all previous decoder key/value_states. Further calls to uni-directional self-attention # can\",\n \"= (hidden_states,) if output_attentions: outputs += (attn_weights,) return outputs # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2Encoder\",\n \"HubertConfig base_model_prefix = \\\"hubert\\\" main_input_name = \\\"input_values\\\" @property def dummy_inputs(self) -> Dict[str, tf.Tensor]:\",\n \"to be masked. this will be multiplied by number of timesteps divided by\",\n \"from transformers import Wav2Vec2Processor, TFHubertModel >>> from datasets import load_dataset >>> import soundfile\",\n \"THE ORDER given in the docstring: `model([input_values, attention_mask])` or `model([input_values, attention_mask, token_type_ids])` -\",\n \"tf.ones_like(inputs[\\\"input_values\\\"], dtype=tf.float32) ) input_lengths = self.hubert._get_feat_extract_output_lengths(tf.reduce_sum(attention_mask, axis=-1)) # assuming that padded tokens are\",\n \"shape_list(hidden_states) # `config.apply_spec_augment` can set masking to False if not getattr(self.config, \\\"apply_spec_augment\\\", True):\",\n \"src_len)) attn_weights = tf.nn.softmax(attn_weights, axis=-1) if layer_head_mask is not None: # The tf.debugging\",\n \"values must be <= vocab_size: {self.config.vocab_size}\\\") attention_mask = ( inputs[\\\"attention_mask\\\"] if inputs[\\\"attention_mask\\\"] is\",\n \"% self.groups != 0: raise ValueError( \\\"Number of groups (\\\" + str(self.groups) +\",\n \"returned tensors for more detail. This argument can be used only in eager\",\n \"# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. #\",\n \"list)): for i, input in enumerate(input_values): # EagerTensors don't allow to use the\",\n \"self.num_heads, tgt_len, self.head_dim], message=f\\\"`attn_output` should be of size {(bsz, self.num_heads, tgt_len, self.head_dim)}, but\",\n \"self.center = center self.scale = scale self.beta_initializer = tf.keras.initializers.get(beta_initializer) self.gamma_initializer = tf.keras.initializers.get(gamma_initializer) self.beta_regularizer\",\n \"This model is also a [tf.keras.Model](https://www.tensorflow.org/api_docs/python/tf/keras/Model) subclass. Use it as a regular TF\",\n \"TFHubertFeedForward(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs): super().__init__(**kwargs) self.intermediate_dropout = tf.keras.layers.Dropout(config.activation_dropout) self.intermediate_dense = tf.keras.layers.Dense(\",\n \"or not to return a [`~file_utils.ModelOutput`] instead of a plain tuple. This argument\",\n \"None, output_attentions: Optional[tf.Tensor] = None, output_hidden_states: Optional[tf.Tensor] = None, return_dict: Optional[bool] = None,\",\n \"indices return tf.scatter_nd(pair_indices, tf.reshape(values, [-1]), output_shape) # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2._compute_mask_indices def _compute_mask_indices( shape:\",\n \"tf.reshape(batch_indices, [1, -1])], 0)) # scatter values to pair indices return tf.scatter_nd(pair_indices, tf.reshape(values,\",\n \"Batch x Time x Channel\\\"\\\"\\\" # if key_value_states are provided this layer is\",\n \"`None` past_key_value = (key_states, value_states) proj_shape = (bsz * self.num_heads, -1, self.head_dim) query_states\",\n \"config, *inputs, **kwargs): super().__init__(config, *inputs, **kwargs) logger.warning( f\\\"\\\\n{self.__class__.__name__} has backpropagation operations that are\",\n \"(1, 1, tgt_len, 1)) return (one_cst - expanded_mask) * LARGE_NEGATIVE # Copied from\",\n \"sure num masked indices <= sequence_length if num_masked_spans * mask_length > sequence_length: num_masked_spans\",\n \"class TFHubertMainLayer(tf.keras.layers.Layer): config_class = HubertConfig def __init__(self, config: HubertConfig, **kwargs): super().__init__(**kwargs) self.config =\",\n \"used only in eager mode, in graph mode the value in the config\",\n \"logit_length=input_lengths, label_length=target_lengths, blank_index=self.config.pad_token_id, logits_time_major=False, ) if self.config.ctc_loss_reduction == \\\"sum\\\": loss = tf.reduce_sum(loss) if\",\n \"get_tf_activation(config.feat_extract_activation) self.layer_norm = TFHubertGroupNorm(groups=self.out_conv_dim, epsilon=config.layer_norm_eps, name=\\\"layer_norm\\\") def call(self, hidden_states: tf.Tensor) -> tf.Tensor: hidden_states\",\n \"**kwargs, ): super().__init__(**kwargs) self.embed_dim = embed_dim self.num_heads = num_heads self.dropout = tf.keras.layers.Dropout(dropout) self.head_dim\",\n \"__init__(self, filters, kernel_size, groups, explicit_padding, **kwargs): super().__init__( filters=filters, kernel_size=kernel_size, groups=groups, padding=\\\"valid\\\", use_bias=True, bias_initializer=\\\"he_normal\\\",\",\n \"self.supports_masking = True self.groups = groups self.axis = axis self.epsilon = epsilon self.center\",\n \"def serving_output(self, output: TFCausalLMOutput) -> TFCausalLMOutput: hs = tf.convert_to_tensor(output.hidden_states) if self.config.output_hidden_states else None\",\n \"in the config will be used instead. output_hidden_states (`bool`, *optional*): Whether or not\",\n \"not in parameter_names: logger.warning( f\\\"The parameter {k} does not belongs to the parameter\",\n \"you can choose to directly pass an embedded representation. This is useful if\",\n \"and 2nd is timesteps attention_mask: optional padding mask of the same size as\",\n \"with -100 # when not being attended to labels_mask = tf.cast(labels >= 0,\",\n \"# coding=utf-8 # Copyright 2021 The Fairseq Authors and the HuggingFace Inc. team.\",\n \"# Copied from transformers.models.bart.modeling_tf_bart.TFBartAttention with TFBart->TFHubert class TFHubertAttention(tf.keras.layers.Layer): \\\"\\\"\\\"Multi-headed attention from \\\"Attention Is\",\n \"self.output_dropout(hidden_states, training=training) return hidden_states # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2EncoderLayer with Wav2Vec2->Hubert class TFHubertEncoderLayer(tf.keras.layers.Layer): def\",\n \"if self.config.output_attentions else None return TFBaseModelOutput(last_hidden_state=output.last_hidden_state, hidden_states=hs, attentions=attns) @add_start_docstrings( \\\"\\\"\\\"TFHubert Model with a\",\n \"_create_broadcast_shape(self, input_shape): broadcast_shape = [1] * len(input_shape) is_instance_norm = (input_shape[self.axis] // self.groups) ==\",\n \"fill spec_aug_mask = tf.zeros((batch_size, sequence_length), dtype=tf.int32) # uniform distribution to sample from, make\",\n \"proj_shape = (bsz * self.num_heads, -1, self.head_dim) query_states = tf.reshape(self._shape(query_states, tgt_len, bsz), proj_shape)\",\n \"= config.conv_dim[layer_id] self.conv = tf.keras.layers.Conv1D( filters=self.out_conv_dim, kernel_size=config.conv_kernel[layer_id], strides=config.conv_stride[layer_id], use_bias=config.conv_bias, name=\\\"conv\\\", ) self.activation =\",\n \"case) # if uni-directional self-attention (decoder) save Tuple(tf.Tensor, tf.Tensor) of # all previous\",\n \"head_mask: Optional[tf.Tensor] = None, inputs_embeds: Optional[tf.Tensor] = None, output_attentions: Optional[bool] = None, labels:\",\n \"layers \\\"\\\"\\\" def _conv_out_length(input_length, kernel_size, stride): # 1D convolutional layer output length formula\",\n \"self.dropout(hidden_states, training=training) for i, layer_module in enumerate(self.layer): if output_hidden_states: all_hidden_states = all_hidden_states +\",\n \"def _mask_hidden_states(self, hidden_states: tf.Tensor, mask_time_indices: Optional[tf.Tensor] = None): \\\"\\\"\\\" Masks extracted features along\",\n \"None all_self_attentions = () if output_attentions else None if attention_mask is not None:\",\n \"Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2._compute_mask_indices def _compute_mask_indices( shape: Tuple[int, int], mask_prob: float, mask_length: int, min_masks:\",\n \"\\\"beta_constraint\\\": tf.keras.constraints.serialize(self.beta_constraint), \\\"gamma_constraint\\\": tf.keras.constraints.serialize(self.gamma_constraint), } base_config = super().get_config() return {**base_config, **config} def compute_output_shape(self,\",\n \"TFHubertForCTC.from_pretrained(\\\"facebook/hubert-base-960h\\\") >>> def map_to_array(batch): ... speech, _ = sf.read(batch[\\\"file\\\"]) ... batch[\\\"speech\\\"] = speech\",\n \"config: HubertConfig, *inputs, **kwargs): super().__init__(config, *inputs, **kwargs) self.hubert = TFHubertMainLayer(config, name=\\\"hubert\\\") self.dropout =\",\n \"hidden_states = self.padding(hidden_states) hidden_states = self.activation(hidden_states) return hidden_states # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2SamePadLayer with\",\n \"None, gamma_constraint: tf.keras.constraints.Constraint = None, **kwargs, ): super().__init__(**kwargs) self.supports_masking = True self.groups =\",\n \"Wav2Vec2Processor.from_pretrained(\\\"facebook/hubert-base-960h\\\") >>> model = TFHubertModel.from_pretrained(\\\"facebook/hubert-base-960h\\\") >>> def map_to_array(batch): ... speech, _ = sf.read(batch[\\\"file\\\"])\",\n \"return tf.transpose(tf.reshape(tensor, (bsz, seq_len, self.num_heads, self.head_dim)), (0, 2, 1, 3)) def call( self,\",\n \"past_key_value[0] value_states = past_key_value[1] elif is_cross_attention: # cross_attentions key_states = self._shape(self.k_proj(key_value_states), -1, bsz)\",\n \"all inputs as keyword arguments (like PyTorch models), or - having all inputs\",\n \"hidden_states = self.feature_projection(hidden_states, training=inputs[\\\"training\\\"]) mask_time_indices = kwargs.get(\\\"mask_time_indices\\\", None) if inputs[\\\"training\\\"]: hidden_states = self._mask_hidden_states(hidden_states,\",\n \"is_cross_attention and past_key_value is not None: # reuse k,v, cross_attentions key_states = past_key_value[0]\",\n \"attentions=outputs.attentions, ) def serving_output(self, output: TFCausalLMOutput) -> TFCausalLMOutput: hs = tf.convert_to_tensor(output.hidden_states) if self.config.output_hidden_states\",\n \"import soundfile as sf >>> processor = Wav2Vec2Processor.from_pretrained(\\\"facebook/hubert-base-960h\\\") >>> model = TFHubertForCTC.from_pretrained(\\\"facebook/hubert-base-960h\\\") >>>\",\n \"Tensors IN THE ORDER given in the docstring: `model([input_values, attention_mask])` or `model([input_values, attention_mask,\",\n \"compute_output_shape(self, input_shape): return input_shape def _reshape_into_groups(self, inputs, input_shape, tensor_input_shape): group_shape = [tensor_input_shape[i] for\",\n \"- 1 group_reduction_axes.pop(axis) mean, variance = tf.nn.moments(reshaped_inputs, group_reduction_axes, keepdims=True) gamma, beta = self._get_reshaped_weights(input_shape)\",\n \"epsilon self.center = center self.scale = scale self.beta_initializer = tf.keras.initializers.get(beta_initializer) self.gamma_initializer = tf.keras.initializers.get(gamma_initializer)\",\n \"units=config.intermediate_size, kernel_initializer=get_initializer(config.initializer_range), bias_initializer=\\\"zeros\\\", name=\\\"intermediate_dense\\\", ) self.intermediate_act_fn = get_tf_activation(config.hidden_act) self.output_dense = tf.keras.layers.Dense( units=config.hidden_size, kernel_initializer=get_initializer(config.initializer_range),\",\n \"TPU\\\" ) @tf.function def serving(self, inputs): output = self.call(input_values=inputs, training=False) return self.serving_output(output) HUBERT_START_DOCSTRING\",\n \"training. Args: func (`callable`): The callable function of the TensorFlow model. config ([`PretrainedConfig`]):\",\n \"will not be updated during training. \\\"\\\"\\\" self.hubert.feature_extractor.trainable = False @add_start_docstrings_to_model_forward(HUBERT_INPUTS_DOCSTRING) @replace_return_docstrings(output_type=TFCausalLMOutput, config_class=_CONFIG_FOR_DOC)\",\n \"for a real Tensor if type(input) == tf.Tensor: # Tensor names have always\",\n \"will be removed in Transformers v5.\\\" \\\"Please use the equivalent `freeze_feature_encoder` method instead.\\\",\",\n \"name=\\\"attention\\\", ) self.dropout = tf.keras.layers.Dropout(config.hidden_dropout) self.layer_norm = tf.keras.layers.LayerNormalization(epsilon=config.layer_norm_eps, name=\\\"layer_norm\\\") self.feed_forward = TFHubertFeedForward(config, name=\\\"feed_forward\\\")\",\n \"def map_to_array(batch): ... speech, _ = sf.read(batch[\\\"file\\\"]) ... batch[\\\"speech\\\"] = speech ... return\",\n \"info \\\"\\\"\\\" z = -tf.math.log(tf.random.uniform(shape_list(distribution), 0, 1)) _, indices = tf.nn.top_k(distribution + z,\",\n \"bsz) value_states = self._shape(self.v_proj(hidden_states), -1, bsz) key_states = tf.concat([past_key_value[0], key_states], axis=2) value_states =\",\n \"loss = tf.reduce_mean(loss) else: loss = None if not inputs[\\\"return_dict\\\"]: output = (logits,)\",\n \"be disabled in other modes than eager. if tf.executing_eagerly(): tf.debugging.assert_equal( shape_list(attn_output), [bsz *\",\n \"cross_attention save Tuple(tf.Tensor, tf.Tensor) of all cross attention key/value_states. # Further calls to\",\n \"be of size {(bsz * self.num_heads, tgt_len, src_len)}, but is {shape_list(attn_weights)}\\\", ) if\",\n \"name=\\\"final_layer_norm\\\" ) def call( self, hidden_states: tf.Tensor, attention_mask: Optional[tf.Tensor] = None, output_attentions: Optional[bool]\",\n \"compliant with XLA then they # have to be disabled in other modes\",\n \"`mask_length`: {mask_length} and `sequence_length`: {sequence_length}`\\\" ) # compute number of masked spans in\",\n \"embedded representation. This is useful if you want more control over how to\",\n \"scale: bool = True, beta_initializer: tf.keras.initializers.Initializer = \\\"zeros\\\", gamma_initializer: tf.keras.initializers.Initializer = \\\"ones\\\", beta_regularizer:\",\n \") hidden_states = encoder_outputs[0] if not inputs[\\\"return_dict\\\"]: return (hidden_states,) + encoder_outputs[1:] return TFBaseModelOutput(\",\n \"with TFBart->TFHubert class TFHubertAttention(tf.keras.layers.Layer): \\\"\\\"\\\"Multi-headed attention from \\\"Attention Is All You Need\\\"\\\"\\\" def\",\n \"spec_aug_mask = _scatter_values_on_batch_indices( tf.ones_like(spec_aug_mask_idxs), spec_aug_mask_idxs, spec_aug_mask.shape ) return spec_aug_mask # Copied from transformers.models.bart.modeling_tf_bart._expand_mask\",\n \"running model. **kwargs: The inputs of the model. Returns: Two lists, one for\",\n \"of the model call function: `model(inputs)`. If you choose this second option, there\",\n \"if name not in list(output.keys()) and name != \\\"args\\\": output[name] = kwargs.pop(name, signature[name].default)\",\n \"0)) # scatter values to pair indices return tf.scatter_nd(pair_indices, tf.reshape(values, [-1]), output_shape) #\",\n \"if self.scale: self.gamma = self.add_weight( shape=shape, name=\\\"gamma\\\", initializer=self.gamma_initializer, regularizer=self.gamma_regularizer, constraint=self.gamma_constraint, ) else: self.gamma\",\n \"import Any, Dict, Optional, Tuple, Union import numpy as np import tensorflow as\",\n \"= tf.constant([0, 1]) def _init_norm(self): \\\"\\\"\\\"Set the norm of the weight vector.\\\"\\\"\\\" kernel_norm\",\n \"in range(config.num_feat_extract_layers) ] else: raise ValueError( f\\\"`config.feat_extract_norm` is {config.feat_extract_norm}, but has to be\",\n \"reserved. # # Licensed under the Apache License, Version 2.0 (the \\\"License\\\"); #\",\n \"tf.keras.initializers.Initializer = \\\"ones\\\", beta_regularizer: tf.keras.regularizers.Regularizer = None, gamma_regularizer: tf.keras.regularizers.Regularizer = None, beta_constraint: tf.keras.constraints.Constraint\",\n \"attention_mask = tf.sequence_mask( output_lengths, maxlen=shape_list(hidden_states)[1], dtype=hidden_states.dtype ) hidden_states = self.feature_projection(hidden_states, training=inputs[\\\"training\\\"]) mask_time_indices =\",\n \"call(self, hidden_states): if self.num_pad_remove > 0: hidden_states = hidden_states[:, : -self.num_pad_remove, :] return\",\n \"input sequence tokens in the vocabulary. Indices can be obtained using [`BertTokenizer`]. See\",\n \"[bsz * self.num_heads, tgt_len, self.head_dim], message=f\\\"`attn_output` should be of size {(bsz, self.num_heads, tgt_len,\",\n \"a cross-attention layer # for the decoder is_cross_attention = key_value_states is not None\",\n \"if self.config.output_hidden_states else None attns = tf.convert_to_tensor(output.attentions) if self.config.output_attentions else None return TFCausalLMOutput(logits=output.logits,\",\n \"operations that are NOT supported on CPU. If you wish \\\" \\\"to train/fine-tine\",\n \"name=\\\"weight_g\\\", shape=(int(self.weight_v.shape[self.filter_axis]), 1, 1), initializer=\\\"ones\\\", dtype=self.weight_v.dtype, trainable=True, ) self.bias = self.add_weight(name=\\\"bias\\\", shape=(self.filters,), initializer=\\\"zeros\\\",\",\n \"['group', 'layer']\\\" ) self.conv_layers = conv_layers def call(self, input_values): hidden_states = tf.expand_dims(input_values, -1)\",\n \"cross-attention layer # for the decoder is_cross_attention = key_value_states is not None bsz,\",\n \"the decoder is_cross_attention = key_value_states is not None bsz, tgt_len, embed_dim = shape_list(hidden_states)\",\n \"are ignored (masked), the loss is only computed for the tokens with labels\",\n \"than the model's internal embedding lookup matrix. output_attentions (`bool`, *optional*): Whether or not\",\n \"self._shape(self.k_proj(hidden_states), -1, bsz) value_states = self._shape(self.v_proj(hidden_states), -1, bsz) key_states = tf.concat([past_key_value[0], key_states], axis=2)\",\n \"output_hidden_states=inputs[\\\"output_hidden_states\\\"], return_dict=inputs[\\\"return_dict\\\"], training=inputs[\\\"training\\\"], ) hidden_states = encoder_outputs[0] if not inputs[\\\"return_dict\\\"]: return (hidden_states,) +\",\n \"axis=-1)) # assuming that padded tokens are filled with -100 # when not\",\n \"to directly pass an embedded representation. This is useful if you want more\",\n \"tensor_name in parameter_names: output[tensor_name] = input else: output[parameter_names[i]] = input elif isinstance(input, allowed_types)\",\n \"if \\\"inputs\\\" in input_values: warnings.warn( \\\"The `inputs` argument is deprecated and will be\",\n \"don't allow to use the .name property so we check for a real\",\n \"None, output_hidden_states: Optional[tf.Tensor] = None, return_dict: Optional[bool] = None, training: bool = False,\",\n \"range(config.num_feat_extract_layers - 1) ] elif config.feat_extract_norm == \\\"layer\\\": conv_layers = [ TFHubertLayerNormConvLayer(config, layer_id=i,\",\n \"else: # self_attention key_states = self._shape(self.k_proj(hidden_states), -1, bsz) value_states = self._shape(self.v_proj(hidden_states), -1, bsz)\",\n \"in `[0, 1]`: - 1 indicates the head is **not masked**, - 0\",\n \"tf.cast(mask, dtype=one_cst.dtype) expanded_mask = tf.tile(mask[:, None, None, :], (1, 1, tgt_len, 1)) return\",\n \"get_tf_activation(config.feat_extract_activation) def call(self, hidden_states: tf.Tensor) -> tf.Tensor: hidden_states = self.conv(hidden_states) hidden_states = self.padding(hidden_states)\",\n \"dimension \\\" \\\"but the layer received an input with shape \\\" + str(input_shape)\",\n \"= True, **kwargs, ): super().__init__(**kwargs) self.embed_dim = embed_dim self.num_heads = num_heads self.dropout =\",\n \"else self.axis - 1 group_reduction_axes.pop(axis) mean, variance = tf.nn.moments(reshaped_inputs, group_reduction_axes, keepdims=True) gamma, beta\",\n \"self._shape(self.k_proj(hidden_states), -1, bsz) value_states = self._shape(self.v_proj(hidden_states), -1, bsz) if self.is_decoder: # if cross_attention\",\n \"are provided this layer is used as a cross-attention layer # for the\",\n \"all layers. See `hidden_states` under returned tensors for more detail. This argument can\",\n \"= spec_aug_mask_idxs + offsets # scatter indices to mask spec_aug_mask = _scatter_values_on_batch_indices( tf.ones_like(spec_aug_mask_idxs),\",\n \"to gather all the input Tensors in the first positional argument : -\",\n \"the proper output we have to add this exception if \\\"args\\\" in output:\",\n \"tf.Tensor) -> tf.Tensor: hidden_states = self.conv(hidden_states) hidden_states = self.activation(hidden_states) return hidden_states # Copied\",\n \"Optional[bool] = None, return_dict: Optional[bool] = None, training: bool = False, ) ->\",\n \"_init_norm(self): \\\"\\\"\\\"Set the norm of the weight vector.\\\"\\\"\\\" kernel_norm = tf.sqrt(tf.reduce_sum(tf.square(self.weight_v), axis=self.kernel_norm_axes)) self.weight_g.assign(kernel_norm[:,\",\n \"if dim % self.groups != 0: raise ValueError( \\\"Number of groups (\\\" +\",\n \"\\\"Axis \\\" + str(self.axis) + \\\" of \\\" \\\"input tensor should have a\",\n \"= self.dropout(hidden_states, training=training) hidden_states = attn_residual + hidden_states hidden_states = self.layer_norm(hidden_states) hidden_states =\",\n \"output.items() if k in [\\\"return_dict\\\", \\\"output_attentions\\\", \\\"output_hidden_states\\\", \\\"use_cache\\\"] } output.update(booleans_processing(config=config, **boolean_dict)) return output\",\n \"tf.shape(inputs) reshaped_inputs, group_shape = self._reshape_into_groups(inputs, input_shape, tensor_input_shape) normalized_inputs = self._apply_normalization(reshaped_inputs, input_shape) is_instance_norm =\",\n \"all_hidden_states + (hidden_states,) if not return_dict: return tuple(v for v in [hidden_states, all_hidden_states,\",\n \"} return dummy_inputs def __init__(self, config, *inputs, **kwargs): super().__init__(config, *inputs, **kwargs) logger.warning( f\\\"\\\\n{self.__class__.__name__}\",\n \"Whether or not to use the model in training mode (some modules like\",\n \"tf.keras.layers.Conv1D( filters=self.out_conv_dim, kernel_size=config.conv_kernel[layer_id], strides=config.conv_stride[layer_id], use_bias=config.conv_bias, name=\\\"conv\\\", ) self.activation = get_tf_activation(config.feat_extract_activation) def call(self, hidden_states:\",\n \"dict(input_values).items(): if isinstance(v, allowed_types) or v is None: output[k] = v elif k\",\n \"hidden_states = self.layer_norm(hidden_states) hidden_states = self.dropout(hidden_states, training=training) for i, layer_module in enumerate(self.layer): if\",\n \"self.kernel = tf.Variable(tf.transpose(self.kernel), name=\\\"weight_v\\\", trainable=True) self.weight_v = self.kernel self.weight_g = self.add_weight( name=\\\"weight_g\\\", shape=(int(self.weight_v.shape[self.filter_axis]),\",\n \"spec_aug_mask_idxs = tf.reshape(spec_aug_mask_idxs, (batch_size, num_masked_spans * mask_length)) offsets = tf.range(mask_length)[tf.newaxis, tf.newaxis, :] offsets\",\n \"mask approximately this percentage of all elements. however due to overlaps, the actual\",\n \"_apply_normalization(self, reshaped_inputs, input_shape): group_shape = tf.keras.backend.int_shape(reshaped_inputs) group_reduction_axes = list(range(1, len(group_shape))) is_instance_norm = (input_shape[self.axis]\",\n \"tf.cast(mask_time_indices[:, :, tf.newaxis], tf.bool), self.masked_spec_embed[tf.newaxis, tf.newaxis, :], hidden_states, ) elif self.config.mask_time_prob > 0:\",\n \"possibilities you can use to gather all the input Tensors in the first\",\n \"https://arxiv.org/abs/1909.11556 for description) dropout_probability = np.random.uniform(0, 1) if training and (dropout_probability < self.config.layerdrop):\",\n \"choose this second option, there are three possibilities you can use to gather\",\n \"self.built = True super().build(input_shape) def call(self, inputs): input_shape = tf.keras.backend.int_shape(inputs) tensor_input_shape = tf.shape(inputs)\",\n \"Optional[tf.Tensor] = None, inputs_embeds: Optional[tf.Tensor] = None, output_attentions: Optional[bool] = None, output_hidden_states: Optional[bool]\",\n \"hidden_states + position_embeddings hidden_states = self.layer_norm(hidden_states) hidden_states = self.dropout(hidden_states, training=training) for i, layer_module\",\n \"past_key_value # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2FeedForward with Wav2Vec2->Hubert class TFHubertFeedForward(tf.keras.layers.Layer): def __init__(self, config: HubertConfig,\",\n \"to cross_attention layer can then reuse all cross-attention # key/value_states (first \\\"if\\\" case)\",\n \"\\\"args\\\": output[name] = kwargs.pop(name, signature[name].default) # When creating a SavedModel TF calls the\",\n \"indices_shape broad_casted_batch_dims = tf.reshape( tf.broadcast_to(tf.expand_dims(tf.range(indices_shape[0]), axis=-1), indices_shape), [1, -1] ) # transform batch_indices\",\n \"value_states = tf.concat([past_key_value[1], value_states], axis=2) else: # self_attention key_states = self._shape(self.k_proj(hidden_states), -1, bsz)\",\n \"config: HubertConfig, layer_id: int = 0, **kwargs: Any) -> None: super().__init__(**kwargs) self.in_conv_dim =\",\n \"tf.reduce_sum(labels_mask, axis=-1) loss = tf.nn.ctc_loss( logits=logits, labels=labels, logit_length=input_lengths, label_length=target_lengths, blank_index=self.config.pad_token_id, logits_time_major=False, ) if\",\n \"time since TF 2.7, so we need to account for padding input_shape[-2] +=\",\n \"def call(self, hidden_states: tf.Tensor) -> tf.Tensor: hidden_states = self.conv(hidden_states) hidden_states = self.layer_norm(hidden_states) hidden_states\",\n \"of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable\",\n \"v in output.items() if k in [\\\"return_dict\\\", \\\"output_attentions\\\", \\\"output_hidden_states\\\", \\\"use_cache\\\"] } output.update(booleans_processing(config=config, **boolean_dict))\",\n \"approximately this percentage of all elements. however due to overlaps, the actual number\",\n \"self.q_proj(hidden_states) * self.scaling # get key, value proj if is_cross_attention and past_key_value is\",\n \"You Need\\\"\\\"\\\" def __init__( self, embed_dim: int, num_heads: int, dropout: float = 0.0,\",\n \"2.0 models accepts two formats as inputs: - having all inputs as keyword\",\n \"= self.conv(hidden_states) hidden_states = self.layer_norm(hidden_states) hidden_states = self.activation(hidden_states) return hidden_states # Copied from\",\n \"`({0})`, *optional*): Mask to avoid performing attention on padding token indices. Mask values\",\n \"int = 0, ) -> tf.Tensor: \\\"\\\"\\\" Computes random mask spans for a\",\n \"case is always the first parameter, then `input_values` output[\\\"input_values\\\"] = output[\\\"args\\\"] del output[\\\"args\\\"]\",\n \"output_attentions: outputs += (attn_weights,) return outputs # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2Encoder with Wav2Vec2->Hubert class\",\n \"(input_shape[self.axis] // self.groups) == 1 if not is_instance_norm: axis = -2 if self.axis\",\n \"tf.keras.layers.Conv1D( filters=self.out_conv_dim, kernel_size=config.conv_kernel[layer_id], strides=config.conv_stride[layer_id], use_bias=config.conv_bias, name=\\\"conv\\\", ) self.layer_norm = tf.keras.layers.LayerNormalization(name=\\\"layer_norm\\\", epsilon=config.layer_norm_eps) self.activation =\",\n \"+ tf.random.uniform((1,))) num_masked_spans = max(num_masked_spans, min_masks) # make sure num masked indices <=\",\n \"should be of size {(bsz, self.num_heads, tgt_len, self.head_dim)}, but is {shape_list(attn_output)}\\\", ) attn_output\",\n \"input.name.split(\\\":\\\")[0] if tensor_name in parameter_names: output[tensor_name] = input else: output[parameter_names[i]] = input elif\",\n \"arguments (like PyTorch models), or - having all inputs as a list, tuple\",\n \"+ position_embeddings hidden_states = self.layer_norm(hidden_states) hidden_states = self.dropout(hidden_states, training=training) for i, layer_module in\",\n \"= None, output_attentions: Optional[bool] = False, training: bool = False, ) -> Tuple[tf.Tensor]:\",\n \"raise ValueError( \\\"Number of groups (\\\" + str(self.groups) + \\\") cannot be \\\"\",\n \"configuration. Check out the [`~PreTrainedModel.from_pretrained`] method to load the model weights. \\\"\\\"\\\" HUBERT_INPUTS_DOCSTRING\",\n \"should be of size {(self.num_heads)}, but is {shape_list(layer_head_mask)}\\\", ) attn_weights = tf.reshape(layer_head_mask, (1,\",\n \"booleans_processing, get_initializer, keras_serializable from ...tf_utils import shape_list from ...tokenization_utils_base import BatchEncoding from ...utils\",\n \"pad_token = 0.0 input_values = tf.convert_to_tensor(np.random.rand(1, 16000), tf.float32) dummy_inputs = { \\\"input_values\\\": input_values,\",\n \"(some modules like dropout modules have different behaviors between training and evaluation). \\\"\\\"\\\"\",\n \"in graph mode the value will always be set to True. training (`bool`,\",\n \"hidden_states = self.layer_norm(hidden_states) hidden_states = self.activation(hidden_states) return hidden_states # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2PositionalConvEmbedding with\",\n \"1), initializer=\\\"ones\\\", dtype=self.weight_v.dtype, trainable=True, ) self.bias = self.add_weight(name=\\\"bias\\\", shape=(self.filters,), initializer=\\\"zeros\\\", trainable=True) def call(self,\",\n \"-> Union[TFBaseModelOutput, Tuple[tf.Tensor]]: all_hidden_states = () if output_hidden_states else None all_self_attentions = ()\",\n \"self.explicit_padding = explicit_padding self.filter_axis = 2 self.initialized = False self.kernel_norm_axes = tf.constant([0, 1])\",\n \"tf.bool), self.masked_spec_embed[tf.newaxis, tf.newaxis, :], hidden_states, ) # apply SpecAugment along feature axis if\",\n \"regularizer=self.beta_regularizer, constraint=self.beta_constraint, ) else: self.beta = None def _create_broadcast_shape(self, input_shape): broadcast_shape = [1]\",\n \"beta = tf.reshape(self.beta, broadcast_shape) return gamma, beta def _check_if_input_shape_is_none(self, input_shape): dim = input_shape[self.axis]\",\n \"if type(input) == tf.Tensor: # Tensor names have always the pattern `name:id` then\",\n \"dropout_probability = np.random.uniform(0, 1) if training and (dropout_probability < self.config.layerdrop): # skip the\",\n \"description) dropout_probability = np.random.uniform(0, 1) if training and (dropout_probability < self.config.layerdrop): # skip\",\n \"else None return TFBaseModelOutput(last_hidden_state=output.last_hidden_state, hidden_states=hs, attentions=attns) @add_start_docstrings( \\\"\\\"\\\"TFHubert Model with a `language modeling`\",\n \"TFHubertFeatureExtractor(TFHubertFeatureEncoder): def __init__(self, config, **kwargs): super().__init__(config, **kwargs) warnings.warn( f\\\"The class `{self.__class__.__name__}` has been\",\n \"None, output_attentions: Optional[bool] = None, labels: Optional[tf.Tensor] = None, output_hidden_states: Optional[bool] = None,\",\n \"= [tensor_input_shape[i] for i in range(len(input_shape))] is_instance_norm = (input_shape[self.axis] // self.groups) == 1\",\n \"tf.cast(labels >= 0, tf.int32) target_lengths = tf.reduce_sum(labels_mask, axis=-1) loss = tf.nn.ctc_loss( logits=logits, labels=labels,\",\n \"f\\\"Data of type {type(input_values)} is not allowed only {allowed_types} is accepted for {parameter_names[0]}.\\\"\",\n \"Copyright 2021 The Fairseq Authors and the HuggingFace Inc. team. All rights reserved.\",\n \"config = { \\\"groups\\\": self.groups, \\\"axis\\\": self.axis, \\\"epsilon\\\": self.epsilon, \\\"center\\\": self.center, \\\"scale\\\": self.scale,\",\n \"tf >>> from transformers import Wav2Vec2Processor, TFHubertForCTC >>> from datasets import load_dataset >>>\",\n \"\\\"output_hidden_states\\\", \\\"use_cache\\\"] } output.update(booleans_processing(config=config, **boolean_dict)) return output # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2._sample_without_replacement def _sample_without_replacement(distribution,\",\n \"training: bool = False, ) -> Tuple[tf.Tensor]: attn_residual = hidden_states hidden_states, attn_weights, _\",\n \"0, tf.int32) target_lengths = tf.reduce_sum(labels_mask, axis=-1) loss = tf.nn.ctc_loss( logits=logits, labels=labels, logit_length=input_lengths, label_length=target_lengths,\",\n \"indices in format (batch_dim, indixes) \\\"\\\"\\\" indices_shape = shape_list(batch_indices) # broadcast batch dim\",\n \"-> tf.Tensor: hidden_states = self.conv(hidden_states) hidden_states = self.activation(hidden_states) return hidden_states # Copied from\",\n \"loss=loss, logits=logits, hidden_states=outputs.hidden_states, attentions=outputs.attentions, ) def serving_output(self, output: TFCausalLMOutput) -> TFCausalLMOutput: hs =\",\n \"outputs = tf.reshape(normalized_inputs, tensor_input_shape) else: outputs = normalized_inputs return outputs def get_config(self): config\",\n \"https://www.tensorflow.org/addons/api_docs/python/tfa/layers/GroupNormalization \\\"\\\"\\\" def __init__( self, groups: int = 32, axis: int = -1,\",\n \") -> Tuple[tf.Tensor]: attn_residual = hidden_states hidden_states = self.layer_norm(hidden_states) hidden_states, attn_weights, _ =\",\n \"tf.Tensor: # Tensor names have always the pattern `name:id` then we check only\",\n \"will be smaller (unless no_overlap is True) mask_length: size of the mask min_masks:\",\n \"= self._shape(self.v_proj(hidden_states), -1, bsz) key_states = tf.concat([past_key_value[0], key_states], axis=2) value_states = tf.concat([past_key_value[1], value_states],\",\n \"self.activation(hidden_states) return hidden_states # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2LayerNormConvLayer with Wav2Vec2->Hubert class TFHubertLayerNormConvLayer(tf.keras.layers.Layer): def __init__(self,\",\n \">= self.config.vocab_size: raise ValueError(f\\\"Label values must be <= vocab_size: {self.config.vocab_size}\\\") attention_mask = (\",\n \"in the position embeddings. Selected in the range `[0, config.max_position_embeddings - 1]`. [What\",\n \"== -1 else self.axis - 1 group_reduction_axes.pop(axis) mean, variance = tf.nn.moments(reshaped_inputs, group_reduction_axes, keepdims=True)\",\n \"eager mode, in graph mode the value in the config will be used\",\n \"= self.call(input_values=inputs, training=False) return self.serving_output(output) HUBERT_START_DOCSTRING = r\\\"\\\"\\\" This model inherits from [`TFPreTrainedModel`].\",\n \"attention_mask: Optional[tf.Tensor] = None, output_attentions: Optional[bool] = False, training: bool = False, )\",\n \"name, i.e. `input_values = tf.keras.Input(shape=(128,), dtype='float32', name=\\\"input_values\\\")` otherwise the order of the tensors\",\n \"message=f\\\"Head mask for a single layer should be of size {(self.num_heads)}, but is\",\n \"i in range(len(input_shape))] is_instance_norm = (input_shape[self.axis] // self.groups) == 1 if not is_instance_norm:\",\n \"of shape `(batch_size, sequence_length)`, *optional*): Labels for computing the masked language modeling loss.\",\n \"SpecAugment along feature axis if self.config.mask_feature_prob > 0: mask_feature_indices = _compute_mask_indices( (batch_size, hidden_size),\",\n \"head_mask (`np.ndarray` or `tf.Tensor` of shape `(num_heads,)` or `(num_layers, num_heads)`, *optional*): Mask to\",\n \"hidden_states = tf.where(mask_feature_indices[:, tf.newaxis, :], hidden_states, 0) return hidden_states def call( self, input_values:\",\n \"Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2GroupNormConvLayer with Wav2Vec2->Hubert class TFHubertGroupNormConvLayer(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, layer_id: int\",\n \"0 corresponds to a *sentence A* token, - 1 corresponds to a *sentence\",\n \"\\\") cannot be \\\" \\\"more than the number of channels (\\\" + str(dim)\",\n \"super().build(input_shape) def _get_feat_extract_output_lengths(self, input_lengths: tf.Tensor): \\\"\\\"\\\" Computes the output length of the convolutional\",\n \"hidden_states = attn_residual + hidden_states hidden_states = self.layer_norm(hidden_states) hidden_states = hidden_states + self.feed_forward(hidden_states)\",\n \"Wav2Vec2->Hubert class TFHubertPositionalConvEmbedding(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs: Any) -> None: super().__init__(**kwargs) self.conv\",\n \"indices # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2._scatter_values_on_batch_indices def _scatter_values_on_batch_indices(values, batch_indices, output_shape): \\\"\\\"\\\" Scatter function as\",\n \"import Wav2Vec2Processor, TFHubertForCTC >>> from datasets import load_dataset >>> import soundfile as sf\",\n \"config.conv_dim[layer_id] self.conv = tf.keras.layers.Conv1D( filters=self.out_conv_dim, kernel_size=config.conv_kernel[layer_id], strides=config.conv_stride[layer_id], use_bias=config.conv_bias, name=\\\"conv\\\", ) self.layer_norm = tf.keras.layers.LayerNormalization(name=\\\"layer_norm\\\",\",\n \"only the configuration. Check out the [`~PreTrainedModel.from_pretrained`] method to load the model weights.\",\n \"`tf.Tensor` of shape `({0}, hidden_size)`, *optional*): Optionally, instead of passing `input_values` you can\",\n \"del output[\\\"kwargs\\\"] boolean_dict = { k: v for k, v in output.items() if\",\n \"attention from \\\"Attention Is All You Need\\\"\\\"\\\" def __init__( self, embed_dim: int, num_heads:\",\n \"always the first parameter, then `input_values` output[\\\"input_values\\\"] = output[\\\"args\\\"] del output[\\\"args\\\"] if \\\"kwargs\\\"\",\n \"= processor(ds[\\\"speech\\\"][0], return_tensors=\\\"tf\\\").input_values # Batch size 1 >>> logits = model(input_values).logits >>> predicted_ids\",\n \"key_states = tf.concat([past_key_value[0], key_states], axis=2) value_states = tf.concat([past_key_value[1], value_states], axis=2) else: # self_attention\",\n \"model in training mode (some modules like dropout modules have different behaviors between\",\n \"if inputs[\\\"output_attentions\\\"] else self.config.output_attentions ) inputs[\\\"return_dict\\\"] = inputs[\\\"return_dict\\\"] if inputs[\\\"return_dict\\\"] else self.config.return_dict outputs\",\n \"tf.ones_like(spec_aug_mask_idxs), spec_aug_mask_idxs, spec_aug_mask.shape ) return spec_aug_mask # Copied from transformers.models.bart.modeling_tf_bart._expand_mask def _expand_mask(mask: tf.Tensor,\",\n \"self.layer_norm = tf.keras.layers.LayerNormalization(name=\\\"layer_norm\\\", epsilon=config.layer_norm_eps) self.activation = get_tf_activation(config.feat_extract_activation) def call(self, hidden_states: tf.Tensor) -> tf.Tensor:\",\n \"internal embedding lookup matrix. output_attentions (`bool`, *optional*): Whether or not to return the\",\n \"@add_start_docstrings_to_model_forward(HUBERT_INPUTS_DOCSTRING) @replace_return_docstrings(output_type=TFCausalLMOutput, config_class=_CONFIG_FOR_DOC) def call( self, input_values: tf.Tensor, attention_mask: Optional[tf.Tensor] = None, token_type_ids:\",\n \"self.config.vocab_size: raise ValueError(f\\\"Label values must be <= vocab_size: {self.config.vocab_size}\\\") attention_mask = ( inputs[\\\"attention_mask\\\"]\",\n \"span to be masked. this will be multiplied by number of timesteps divided\",\n \"convolutional layers \\\"\\\"\\\" def _conv_out_length(input_length, kernel_size, stride): # 1D convolutional layer output length\",\n \"``Dict[str, tf.Tensor]` or `Dict[str, np.ndarray]` and each example must have the shape `({0})`):\",\n \"raise ValueError( \\\"Number of groups (\\\" + str(self.groups) + \\\") must be a\",\n \"z = -tf.math.log(tf.random.uniform(shape_list(distribution), 0, 1)) _, indices = tf.nn.top_k(distribution + z, num_samples) return\",\n \"self.add_weight( name=\\\"weight_g\\\", shape=(int(self.weight_v.shape[self.filter_axis]), 1, 1), initializer=\\\"ones\\\", dtype=self.weight_v.dtype, trainable=True, ) self.bias = self.add_weight(name=\\\"bias\\\", shape=(self.filters,),\",\n \"for Connectionist Temporal Classification (CTC).\\\"\\\"\\\", HUBERT_START_DOCSTRING, ) class TFHubertForCTC(TFHubertPreTrainedModel): def __init__(self, config: HubertConfig,\",\n \"= tf.nn.l2_normalize(self.weight_v, axis=self.kernel_norm_axes) * tf.transpose(self.weight_g) self.kernel = tf.transpose(kernel) def build(self, input_shape): if not\",\n \"token_type_ids (`np.ndarray` or `tf.Tensor` of shape `({0})`, *optional*): Segment token indices to indicate\",\n \"self.groups = dim def _check_size_of_dimensions(self, input_shape): dim = input_shape[self.axis] if dim < self.groups:\",\n \"tf.reduce_mean(loss) else: loss = None if not inputs[\\\"return_dict\\\"]: output = (logits,) + outputs[1:]\",\n \"outputs += (attn_weights,) return outputs # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2Encoder with Wav2Vec2->Hubert class TFHubertEncoder(tf.keras.layers.Layer):\",\n \"# `args` in this case is always the first parameter, then `input_values` output[\\\"input_values\\\"]\",\n \"raise ValueError( f\\\"Data of type {type(input)} is not allowed only {allowed_types} is accepted\",\n \"gamma, beta def _check_if_input_shape_is_none(self, input_shape): dim = input_shape[self.axis] if dim is None: raise\",\n \"supported on CPU. If you wish \\\" \\\"to train/fine-tine this model, you need\",\n \"return normalized_inputs def _get_reshaped_weights(self, input_shape): broadcast_shape = self._create_broadcast_shape(input_shape) gamma = None beta =\",\n \"token indices to indicate first and second portions of the inputs. Indices are\",\n \"{ \\\"input_values\\\": input_values, \\\"attention_mask\\\": tf.cast(tf.not_equal(input_values, pad_token), tf.float32), } return dummy_inputs def __init__(self, config,\",\n \"stride) return input_lengths def _mask_hidden_states(self, hidden_states: tf.Tensor, mask_time_indices: Optional[tf.Tensor] = None): \\\"\\\"\\\" Masks\",\n \"= None if self.scale: gamma = tf.reshape(self.gamma, broadcast_shape) if self.center: beta = tf.reshape(self.beta,\",\n \"dtype=hidden_states.dtype ) hidden_states = self.feature_projection(hidden_states, training=inputs[\\\"training\\\"]) mask_time_indices = kwargs.get(\\\"mask_time_indices\\\", None) if inputs[\\\"training\\\"]: hidden_states\",\n \"None, beta_constraint: tf.keras.constraints.Constraint = None, gamma_constraint: tf.keras.constraints.Constraint = None, **kwargs, ): super().__init__(**kwargs) self.supports_masking\",\n \"return (input_length - kernel_size) // stride + 1 for kernel_size, stride in zip(self.config.conv_kernel,\",\n \"TFCausalLMOutput) -> TFCausalLMOutput: hs = tf.convert_to_tensor(output.hidden_states) if self.config.output_hidden_states else None attns = tf.convert_to_tensor(output.attentions)\",\n \"inputs_embeds=inputs[\\\"inputs_embeds\\\"], output_attentions=inputs[\\\"output_attentions\\\"], output_hidden_states=inputs[\\\"output_hidden_states\\\"], return_dict=inputs[\\\"return_dict\\\"], training=inputs[\\\"training\\\"], ) return outputs def serving_output(self, output): hs =\",\n \"key/value_states (third \\\"elif\\\" case) # if encoder bi-directional self-attention `past_key_value` is always `None`\",\n \"hidden_states = hidden_states + position_embeddings hidden_states = self.layer_norm(hidden_states) hidden_states = self.dropout(hidden_states, training=training) for\",\n \"during training. \\\"\\\"\\\" warnings.warn( \\\"The method `freeze_feature_extractor` is deprecated and will be removed\",\n \"name=\\\"intermediate_dense\\\", ) self.intermediate_act_fn = get_tf_activation(config.hidden_act) self.output_dense = tf.keras.layers.Dense( units=config.hidden_size, kernel_initializer=get_initializer(config.initializer_range), bias_initializer=\\\"zeros\\\", name=\\\"output_dense\\\", )\",\n \"**masked**. inputs_embeds (`np.ndarray` or `tf.Tensor` of shape `({0}, hidden_size)`, *optional*): Optionally, instead of\",\n \"outputs = self.hubert( input_values=inputs[\\\"input_values\\\"], attention_mask=inputs[\\\"attention_mask\\\"], token_type_ids=inputs[\\\"token_type_ids\\\"], position_ids=inputs[\\\"position_ids\\\"], head_mask=inputs[\\\"head_mask\\\"], inputs_embeds=inputs[\\\"inputs_embeds\\\"], output_attentions=inputs[\\\"output_attentions\\\"], output_hidden_states=inputs[\\\"output_hidden_states\\\"], return_dict=inputs[\\\"return_dict\\\"], training=inputs[\\\"training\\\"],\",\n \"attention_mask is not None: # The tf.debugging asserts are not compliant with XLA\",\n \"_expand_mask(attention_mask) else: attention_mask = None position_embeddings = self.pos_conv_embed(hidden_states) hidden_states = hidden_states + position_embeddings\",\n \"return outputs def serving_output(self, output): hs = tf.convert_to_tensor(output.hidden_states) if self.config.output_hidden_states else None attns\",\n \"from ...modeling_tf_outputs import TFBaseModelOutput, TFCausalLMOutput from ...modeling_tf_utils import TFPreTrainedModel, booleans_processing, get_initializer, keras_serializable from\",\n \"tokens in the vocabulary. Indices can be obtained using [`BertTokenizer`]. See [`PreTrainedTokenizer.__call__`] and\",\n \"value_states = self._shape(self.v_proj(hidden_states), -1, bsz) key_states = tf.concat([past_key_value[0], key_states], axis=2) value_states = tf.concat([past_key_value[1],\",\n \"type IDs?](../glossary#token-type-ids) position_ids (`np.ndarray` or `tf.Tensor` of shape `({0})`, *optional*): Indices of positions\",\n \"for {parameter_names[0]}.\\\" ) for name in parameter_names: if name not in list(output.keys()) and\",\n \"None, inputs_embeds: Optional[tf.Tensor] = None, output_attentions: Optional[tf.Tensor] = None, output_hidden_states: Optional[tf.Tensor] = None,\",\n \"tensor_input_shape): group_shape = [tensor_input_shape[i] for i in range(len(input_shape))] is_instance_norm = (input_shape[self.axis] // self.groups)\",\n \"(bsz * self.num_heads, tgt_len, src_len)) attn_probs = self.dropout(attn_weights, training=training) attn_output = tf.matmul(attn_probs, value_states)\",\n \"= None, head_mask: Optional[tf.Tensor] = None, inputs_embeds: Optional[tf.Tensor] = None, output_attentions: Optional[tf.Tensor] =\",\n \"self.beta_initializer = tf.keras.initializers.get(beta_initializer) self.gamma_initializer = tf.keras.initializers.get(gamma_initializer) self.beta_regularizer = tf.keras.regularizers.get(beta_regularizer) self.gamma_regularizer = tf.keras.regularizers.get(gamma_regularizer) self.beta_constraint\",\n \"= self.groups return broadcast_shape # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2WeightNormConv1D with Wav2Vec2->Hubert class TFHubertWeightNormConv1D(tf.keras.layers.Conv1D): \\\"\\\"\\\"Adapted\",\n \"https://github.com/tensorflow/tensorflow/issues/9260 for more info \\\"\\\"\\\" z = -tf.math.log(tf.random.uniform(shape_list(distribution), 0, 1)) _, indices =\",\n \"if \\\"kwargs\\\" in output: del output[\\\"kwargs\\\"] boolean_dict = { k: v for k,\",\n \"# See all Hubert models at https://huggingface.co/models?filter=hubert ] LARGE_NEGATIVE = -1e8 # Copied\",\n \"the value in the config will be used instead. output_hidden_states (`bool`, *optional*): Whether\",\n \"= encoder_outputs[0] if not inputs[\\\"return_dict\\\"]: return (hidden_states,) + encoder_outputs[1:] return TFBaseModelOutput( last_hidden_state=hidden_states, hidden_states=encoder_outputs.hidden_states,\",\n \"for name in parameter_names: if name not in list(output.keys()) and name != \\\"args\\\":\",\n \"return_tensors=\\\"tf\\\").input_values >>> loss = model(input_values, labels=labels).loss ```\\\"\\\"\\\" inputs = input_values_processing( func=self.call, config=self.config, input_values=input_values,\",\n \"self-attention (decoder) save Tuple(tf.Tensor, tf.Tensor) of # all previous decoder key/value_states. Further calls\",\n \"expanded_mask = tf.tile(mask[:, None, None, :], (1, 1, tgt_len, 1)) return (one_cst -\",\n \"past_key_values_length: int = 0): \\\"\\\"\\\" Expands attention_mask from `[bsz, seq_len]` to `[bsz, 1,\",\n \"if isinstance(v, allowed_types) or v is None: output[k] = v else: raise ValueError(f\\\"Data\",\n \"[fairseq's data_utils.py](https://github.com/pytorch/fairseq/blob/e0788f7007a8473a76db573985031f3c94201e79/fairseq/data/data_utils.py#L376). \\\"\\\"\\\" batch_size, sequence_length = shape if mask_length < 1: raise ValueError(\\\"`mask_length`\",\n \"governing permissions and # limitations under the License. \\\"\\\"\\\" TensorFlow Hubert model.\\\"\\\"\\\" import\",\n \"= shape_list(batch_indices) # broadcast batch dim to indices_shape broad_casted_batch_dims = tf.reshape( tf.broadcast_to(tf.expand_dims(tf.range(indices_shape[0]), axis=-1),\",\n \"hidden_states class TFHubertFeatureExtractor(TFHubertFeatureEncoder): def __init__(self, config, **kwargs): super().__init__(config, **kwargs) warnings.warn( f\\\"The class `{self.__class__.__name__}`\",\n \"(batch_size, num_masked_spans, 1)) offsets = tf.reshape(offsets, (batch_size, num_masked_spans * mask_length)) spec_aug_mask_idxs = spec_aug_mask_idxs\",\n \"message=f\\\"Attention weights should be of size {(bsz * self.num_heads, tgt_len, src_len)}, but is\",\n \"# When creating a SavedModel TF calls the method with LayerCall.__call__(args, **kwargs) #\",\n \"TFHubertGroupNorm(groups=self.out_conv_dim, epsilon=config.layer_norm_eps, name=\\\"layer_norm\\\") def call(self, hidden_states: tf.Tensor) -> tf.Tensor: hidden_states = self.conv(hidden_states) hidden_states\",\n \"inputs_embeds (`np.ndarray` or `tf.Tensor` of shape `({0}, hidden_size)`, *optional*): Optionally, instead of passing\",\n \"tf.where( tf.cast(mask_time_indices[:, :, tf.newaxis], tf.bool), self.masked_spec_embed[tf.newaxis, tf.newaxis, :], hidden_states, ) # apply SpecAugment\",\n \"= TFHubertModel.from_pretrained(\\\"facebook/hubert-base-960h\\\") >>> def map_to_array(batch): ... speech, _ = sf.read(batch[\\\"file\\\"]) ... batch[\\\"speech\\\"] =\",\n \"weights.\\\"\\\"\\\" kernel = tf.nn.l2_normalize(self.weight_v, axis=self.kernel_norm_axes) * tf.transpose(self.weight_g) self.kernel = tf.transpose(kernel) def build(self, input_shape):\",\n \"# Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2WeightNormConv1D with Wav2Vec2->Hubert class TFHubertWeightNormConv1D(tf.keras.layers.Conv1D): \\\"\\\"\\\"Adapted from https://www.tensorflow.org/probability/api_docs/python/tfp/layers/weight_norm/WeightNorm\\\"\\\"\\\" def __init__(self,\",\n \"values selected in `[0, 1]`: - 1 for tokens that are **not masked**,\",\n \"compute loss >>> target_transcription = \\\"A MAN SAID TO THE UNIVERSE SIR I\",\n \"training=inputs[\\\"training\\\"], ) hidden_states = outputs[0] hidden_states = self.dropout(hidden_states, training=inputs[\\\"training\\\"]) logits = self.lm_head(hidden_states) if\",\n \"tf.concat([past_key_value[0], key_states], axis=2) value_states = tf.concat([past_key_value[1], value_states], axis=2) else: # self_attention key_states =\",\n \"weight vector.\\\"\\\"\\\" kernel_norm = tf.sqrt(tf.reduce_sum(tf.square(self.weight_v), axis=self.kernel_norm_axes)) self.weight_g.assign(kernel_norm[:, tf.newaxis, tf.newaxis]) def _normalize_kernel(self): \\\"\\\"\\\"Generate normalized\",\n \"of ['group', 'layer']\\\" ) self.conv_layers = conv_layers def call(self, input_values): hidden_states = tf.expand_dims(input_values,\",\n \"pair indices return tf.scatter_nd(pair_indices, tf.reshape(values, [-1]), output_shape) # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2._compute_mask_indices def _compute_mask_indices(\",\n \"option, there are three possibilities you can use to gather all the input\",\n \"Model with a `language modeling` head on top for Connectionist Temporal Classification (CTC).\\\"\\\"\\\",\",\n \"if v is not None) return TFBaseModelOutput( last_hidden_state=hidden_states, hidden_states=all_hidden_states, attentions=all_self_attentions, ) @keras_serializable class\",\n \"= None def _add_beta_weight(self, input_shape): dim = input_shape[self.axis] shape = (dim,) if self.center:\",\n \"return_dict=inputs[\\\"return_dict\\\"], training=inputs[\\\"training\\\"], ) return outputs def serving_output(self, output): hs = tf.convert_to_tensor(output.hidden_states) if self.config.output_hidden_states\",\n \"use `input_values` instead.\\\", FutureWarning, ) output[\\\"input_values\\\"] = input_values.pop(\\\"inputs\\\") if \\\"decoder_cached_states\\\" in input_values: warnings.warn(\",\n \"reshaped_inputs = tf.reshape(inputs, group_shape) return reshaped_inputs, group_shape else: return inputs, group_shape def _apply_normalization(self,\",\n \"hidden_states, attn_weights, _ = self.attention( hidden_states, attention_mask=attention_mask, training=training ) hidden_states = self.dropout(hidden_states, training=training)\",\n \"instead.\\\", FutureWarning, ) output[\\\"past_key_values\\\"] = input_values.pop(\\\"decoder_cached_states\\\") for k, v in dict(input_values).items(): if isinstance(v,\",\n \"we need to account for padding input_shape[-2] += self.explicit_padding * 2 super().build(input_shape) self.kernel\",\n \"have to be disabled in other modes than eager. if tf.executing_eagerly(): tf.debugging.assert_equal( shape_list(attn_output),\",\n \"= self.attention( hidden_states, attention_mask=attention_mask, training=training ) hidden_states = self.dropout(hidden_states, training=training) hidden_states = attn_residual\",\n \"class with all the parameters of the model. Initializing with a config file\",\n \"= max(num_masked_spans, min_masks) # make sure num masked indices <= sequence_length if num_masked_spans\",\n \"to be chosen as start of the span to be masked. this will\",\n \"in input_values: warnings.warn( \\\"The `decoder_cached_states` argument is deprecated and will be removed in\",\n \"to avoid performing attention on padding token indices. Mask values selected in `[0,\",\n \"= tf.reduce_mean(loss) else: loss = None if not inputs[\\\"return_dict\\\"]: output = (logits,) +\",\n \"allowed only {allowed_types} is accepted for {parameter_names[i]}.\\\" ) elif isinstance(input_values, (dict, BatchEncoding)): if\",\n \"token_type_ids])` - a dictionary with one or several input Tensors associated to the\",\n \"lookup matrix. output_attentions (`bool`, *optional*): Whether or not to return the attentions tensors\",\n \"is True) mask_length: size of the mask min_masks: minimum number of masked spans\",\n \"Indices can be obtained using [`BertTokenizer`]. See [`PreTrainedTokenizer.__call__`] and [`PreTrainedTokenizer.encode`] for details. [What\",\n \"@add_start_docstrings( \\\"The bare TFHubert Model transformer outputing raw hidden-states without any specific head\",\n \"loss = tf.reduce_sum(loss) if self.config.ctc_loss_reduction == \\\"mean\\\": loss = tf.reduce_mean(loss) else: loss =\",\n \"use_bias=True, bias_initializer=\\\"he_normal\\\", **kwargs, ) self.explicit_padding = explicit_padding self.filter_axis = 2 self.initialized = False\",\n \"the superclass documentation for the generic methods the library implements for all its\",\n \"**not masked**, - 0 indicates the head is **masked**. inputs_embeds (`np.ndarray` or `tf.Tensor`\",\n \"model including the booleans. In case of a list of symbolic inputs, each\",\n \"= tgt_len if tgt_len is not None else src_len one_cst = tf.constant(1.0) mask\",\n \"return outputs # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2Encoder with Wav2Vec2->Hubert class TFHubertEncoder(tf.keras.layers.Layer): def __init__(self, config:\",\n \"tf.scatter_nd(pair_indices, tf.reshape(values, [-1]), output_shape) # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2._compute_mask_indices def _compute_mask_indices( shape: Tuple[int, int],\",\n \"tf.keras.layers.Dropout(dropout) self.head_dim = embed_dim // num_heads if (self.head_dim * num_heads) != self.embed_dim: raise\",\n \"mask = tf.cast(mask, dtype=one_cst.dtype) expanded_mask = tf.tile(mask[:, None, None, :], (1, 1, tgt_len,\",\n \"inputs_embeds: Optional[tf.Tensor] = None, output_attentions: Optional[bool] = None, output_hidden_states: Optional[bool] = None, return_dict:\",\n \"Temporal Classification (CTC).\\\"\\\"\\\", HUBERT_START_DOCSTRING, ) class TFHubertForCTC(TFHubertPreTrainedModel): def __init__(self, config: HubertConfig, *inputs, **kwargs):\",\n \"be divisible by num_heads (got `embed_dim`: {self.embed_dim}\\\" f\\\" and `num_heads`: {num_heads}).\\\" ) self.scaling\",\n \"= self.dropout(hidden_states, training=training) hidden_states = attn_residual + hidden_states hidden_states = hidden_states + self.feed_forward(self.final_layer_norm(hidden_states))\",\n \"Tuple[int, int], mask_prob: float, mask_length: int, min_masks: int = 0, ) -> tf.Tensor:\",\n \"call(self, hidden_states: tf.Tensor) -> tf.Tensor: hidden_states = self.conv(hidden_states) hidden_states = self.activation(hidden_states) return hidden_states\",\n \"eager. if tf.executing_eagerly(): tf.debugging.assert_equal( shape_list(attn_output), [bsz * self.num_heads, tgt_len, self.head_dim], message=f\\\"`attn_output` should be\",\n \"else: outputs = normalized_inputs return outputs def get_config(self): config = { \\\"groups\\\": self.groups,\",\n \"return output # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2._sample_without_replacement def _sample_without_replacement(distribution, num_samples): \\\"\\\"\\\" Categorical sampling without\",\n \"position_ids=position_ids, head_mask=head_mask, inputs_embeds=inputs_embeds, output_attentions=output_attentions, output_hidden_states=output_hidden_states, return_dict=return_dict, training=training, ) inputs[\\\"output_hidden_states\\\"] = ( inputs[\\\"output_hidden_states\\\"] if\",\n \"should be of size {(bsz, 1, tgt_len, src_len)}, but is {shape_list(attention_mask)}\\\", ) attention_mask\",\n \"**kwargs) self.config = config self.hubert = TFHubertMainLayer(config, name=\\\"hubert\\\") @add_start_docstrings_to_model_forward(HUBERT_INPUTS_DOCSTRING) @replace_return_docstrings(output_type=TFBaseModelOutput, config_class=_CONFIG_FOR_DOC) def call(\",\n \"= hidden_states + self.feed_forward(self.final_layer_norm(hidden_states)) outputs = (hidden_states,) if output_attentions: outputs += (attn_weights,) return\",\n \"isinstance(v, allowed_types) or v is None: output[k] = v else: raise ValueError(f\\\"Data of\",\n \"self._mask_hidden_states(hidden_states, mask_time_indices=mask_time_indices) encoder_outputs = self.encoder( hidden_states, attention_mask=attention_mask, output_attentions=inputs[\\\"output_attentions\\\"], output_hidden_states=inputs[\\\"output_hidden_states\\\"], return_dict=inputs[\\\"return_dict\\\"], training=inputs[\\\"training\\\"], ) hidden_states\",\n \"TFHubertAttention( embed_dim=config.hidden_size, num_heads=config.num_attention_heads, dropout=config.attention_dropout, is_decoder=False, name=\\\"attention\\\", ) self.dropout = tf.keras.layers.Dropout(config.hidden_dropout) self.layer_norm = tf.keras.layers.LayerNormalization(epsilon=config.layer_norm_eps,\",\n \"= HubertConfig base_model_prefix = \\\"hubert\\\" main_input_name = \\\"input_values\\\" @property def dummy_inputs(self) -> Dict[str,\",\n \"TFHubertModel.from_pretrained(\\\"facebook/hubert-base-960h\\\") >>> def map_to_array(batch): ... speech, _ = sf.read(batch[\\\"file\\\"]) ... batch[\\\"speech\\\"] = speech\",\n \"Further calls to uni-directional self-attention # can concat previous decoder key/value_states to current\",\n \"[`tf.keras.Model.fit`] method which currently requires having all the tensors in the first argument\",\n \"else None all_self_attentions = () if output_attentions else None if attention_mask is not\",\n \"if output_attentions: outputs += (attn_weights,) return outputs # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2EncoderLayerStableLayerNorm with Wav2Vec2->Hubert\",\n \"dummy_inputs = { \\\"input_values\\\": input_values, \\\"attention_mask\\\": tf.cast(tf.not_equal(input_values, pad_token), tf.float32), } return dummy_inputs def\",\n \"num_heads)`, *optional*): Mask to nullify selected heads of the self-attention modules. Mask values\",\n \"2, 1, 3) ) attn_output = tf.reshape(attn_output, (bsz, tgt_len, embed_dim)) attn_output = self.out_proj(attn_output)\",\n \"output[\\\"input_values\\\"] = output[\\\"args\\\"] del output[\\\"args\\\"] if \\\"kwargs\\\" in output: del output[\\\"kwargs\\\"] boolean_dict =\",\n \"get random indices to mask spec_aug_mask_idxs = _sample_without_replacement(uniform_dist, num_masked_spans) # expand masked indices\",\n \"hidden_states = hidden_states + self.feed_forward(self.final_layer_norm(hidden_states)) outputs = (hidden_states,) if output_attentions: outputs += (attn_weights,)\",\n \"distributed under the License is distributed on an \\\"AS IS\\\" BASIS, # WITHOUT\",\n \"tf.keras.regularizers.serialize(self.gamma_regularizer), \\\"beta_constraint\\\": tf.keras.constraints.serialize(self.beta_constraint), \\\"gamma_constraint\\\": tf.keras.constraints.serialize(self.gamma_constraint), } base_config = super().get_config() return {**base_config, **config} def\",\n \"if mask_length > sequence_length: raise ValueError( f\\\"`mask_length` has to be smaller than `sequence_length`,\",\n \"class TFHubertEncoderLayer(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs): super().__init__(**kwargs) self.attention = TFHubertAttention( embed_dim=config.hidden_size, num_heads=config.num_attention_heads,\",\n \") -> Union[TFCausalLMOutput, Tuple[tf.Tensor]]: r\\\"\\\"\\\" labels (`tf.Tensor` or `np.ndarray` of shape `(batch_size, sequence_length)`,\",\n \"= self.output_dense(hidden_states) hidden_states = self.output_dropout(hidden_states, training=training) return hidden_states # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2EncoderLayer with\",\n \"is accepted for {k}.\\\") else: if isinstance(input_values, tf.Tensor) or input_values is None: output[parameter_names[0]]\",\n \"initializer=\\\"uniform\\\", trainable=True, name=\\\"masked_spec_embed\\\" ) super().build(input_shape) def _get_feat_extract_output_lengths(self, input_lengths: tf.Tensor): \\\"\\\"\\\" Computes the output\",\n \") self.dropout = tf.keras.layers.Dropout(config.hidden_dropout) self.layer_norm = tf.keras.layers.LayerNormalization(epsilon=config.layer_norm_eps, name=\\\"layer_norm\\\") self.feed_forward = TFHubertFeedForward(config, name=\\\"feed_forward\\\") self.final_layer_norm\",\n \"they # have to be disabled in other modes than eager. if tf.executing_eagerly():\",\n \"and \\\"args\\\" not in parameter_names: logger.warning( f\\\"The parameter {k} does not belongs to\",\n \"(hidden_states,) if output_attentions: outputs += (attn_weights,) return outputs # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2Encoder with\",\n \"position_ids=position_ids, head_mask=head_mask, inputs_embeds=inputs_embeds, output_attentions=output_attentions, output_hidden_states=output_hidden_states, return_dict=return_dict, training=training, kwargs_call=kwargs, ) hidden_states = self.feature_extractor( tf.cast(inputs[\\\"input_values\\\"],\",\n \"int = 32, axis: int = -1, epsilon: float = 1e-3, center: bool\",\n \"kernel_size=config.conv_kernel[layer_id], strides=config.conv_stride[layer_id], use_bias=config.conv_bias, name=\\\"conv\\\", ) self.activation = get_tf_activation(config.feat_extract_activation) def call(self, hidden_states: tf.Tensor) ->\",\n \"layer_id=i + 1, name=f\\\"conv_layers.{i+1}\\\") for i in range(config.num_feat_extract_layers - 1) ] elif config.feat_extract_norm\",\n \"is None: raise ValueError( \\\"Axis \\\" + str(self.axis) + \\\" of \\\" \\\"input\",\n \"(first \\\"if\\\" case) # if uni-directional self-attention (decoder) save Tuple(tf.Tensor, tf.Tensor) of #\",\n \"hidden_states: tf.Tensor) -> tf.Tensor: hidden_states = self.conv(hidden_states) hidden_states = self.activation(hidden_states) return hidden_states #\",\n \"tf.Tensor, attention_mask: Optional[tf.Tensor] = None, output_attentions: Optional[bool] = False, training: bool = False,\",\n \"return TFCausalLMOutput( loss=loss, logits=logits, hidden_states=outputs.hidden_states, attentions=outputs.attentions, ) def serving_output(self, output: TFCausalLMOutput) -> TFCausalLMOutput:\",\n \"to handle weights initialization and a simple interface for downloading and loading pretrained\",\n \"output = super().call(padded_inputs) return output # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2NoLayerNormConvLayer with Wav2Vec2->Hubert class TFHubertNoLayerNormConvLayer(tf.keras.layers.Layer):\",\n \"> 0: hidden_states = hidden_states[:, : -self.num_pad_remove, :] return hidden_states class TFHubertFeatureEncoder(tf.keras.layers.Layer): def\",\n \"group_shape[self.axis] = input_shape[self.axis] // self.groups group_shape.insert(self.axis, self.groups) group_shape = tf.stack(group_shape) reshaped_inputs = tf.reshape(inputs,\",\n \"layer continue layer_outputs = layer_module( hidden_states=hidden_states, attention_mask=attention_mask, output_attentions=output_attentions, training=training, ) hidden_states = layer_outputs[0]\",\n \"specific head on top.\\\", HUBERT_START_DOCSTRING, ) class TFHubertModel(TFHubertPreTrainedModel): def __init__(self, config: HubertConfig, *inputs,\",\n \"broadcast batch dim to indices_shape broad_casted_batch_dims = tf.reshape( tf.broadcast_to(tf.expand_dims(tf.range(indices_shape[0]), axis=-1), indices_shape), [1, -1]\",\n \"if not inputs[\\\"return_dict\\\"]: return (hidden_states,) + encoder_outputs[1:] return TFBaseModelOutput( last_hidden_state=hidden_states, hidden_states=encoder_outputs.hidden_states, attentions=encoder_outputs.attentions, )\",\n \"else self.config.return_dict outputs = self.hubert( input_values=inputs[\\\"input_values\\\"], attention_mask=inputs[\\\"attention_mask\\\"], token_type_ids=inputs[\\\"token_type_ids\\\"], position_ids=inputs[\\\"position_ids\\\"], head_mask=inputs[\\\"head_mask\\\"], inputs_embeds=inputs[\\\"inputs_embeds\\\"], output_attentions=inputs[\\\"output_attentions\\\"], output_hidden_states=inputs[\\\"output_hidden_states\\\"],\",\n \"loss is not None else output return TFCausalLMOutput( loss=loss, logits=logits, hidden_states=outputs.hidden_states, attentions=outputs.attentions, )\",\n \"def dummy_inputs(self) -> Dict[str, tf.Tensor]: pad_token = 0.0 input_values = tf.convert_to_tensor(np.random.rand(1, 16000), tf.float32)\",\n \"output length formula taken # from https://pytorch.org/docs/stable/generated/torch.nn.Conv1d.html return (input_length - kernel_size) // stride\",\n \"modules. Mask values selected in `[0, 1]`: - 1 indicates the head is\",\n \"for i, layer_module in enumerate(self.layer): if output_hidden_states: all_hidden_states = all_hidden_states + (hidden_states,) #\",\n \"attention_mask (`np.ndarray` or `tf.Tensor` of shape `({0})`, *optional*): Mask to avoid performing attention\",\n \"elements mask_prob: probability for each token to be chosen as start of the\",\n \"-1 else self.axis - 1 group_reduction_axes.pop(axis) mean, variance = tf.nn.moments(reshaped_inputs, group_reduction_axes, keepdims=True) gamma,\",\n \"padded tokens are filled with -100 # when not being attended to labels_mask\",\n \"output_attentions: Optional[bool] = None, output_hidden_states: Optional[bool] = None, return_dict: Optional[bool] = None, training:\",\n \"= () if output_attentions else None if attention_mask is not None: hidden_states =\",\n \"example must have the shape `({0})`): Indices of input sequence tokens in the\",\n \"= v elif k not in parameter_names and \\\"args\\\" not in parameter_names: logger.warning(\",\n \"time axis and/or along feature axis according to [SpecAugment](https://arxiv.org/abs/1904.08779). \\\"\\\"\\\" batch_size, sequence_length, hidden_size\",\n \"choose to directly pass an embedded representation. This is useful if you want\",\n \"The inputs of the model. Returns: Two lists, one for the missing layers,\",\n \"*inputs, **kwargs) logger.warning( f\\\"\\\\n{self.__class__.__name__} has backpropagation operations that are NOT supported on CPU.\",\n \"output_hidden_states=output_hidden_states, return_dict=return_dict, training=training, kwargs_call=kwargs, ) hidden_states = self.feature_extractor( tf.cast(inputs[\\\"input_values\\\"], tf.float32), training=inputs[\\\"training\\\"] ) if\",\n \"type {type(input_values)} is not allowed only {allowed_types} is accepted for {parameter_names[0]}.\\\" ) for\",\n \"of all attention layers. See `attentions` under returned tensors for more detail. This\",\n \"the generic methods the library implements for all its model (such as downloading\",\n \"attention_mask])` or `model([input_values, attention_mask, token_type_ids])` - a dictionary with one or several input\",\n \"symbolic inputs, each input has to be named accordingly to the parameters name,\",\n \"_check_if_input_shape_is_none(self, input_shape): dim = input_shape[self.axis] if dim is None: raise ValueError( \\\"Axis \\\"\",\n \"tf.bool), self.masked_spec_embed[tf.newaxis, tf.newaxis, :], hidden_states, ) elif self.config.mask_time_prob > 0: # generate indices\",\n \"self.beta_constraint = tf.keras.constraints.get(beta_constraint) self.gamma_constraint = tf.keras.constraints.get(gamma_constraint) self._check_axis() def build(self, input_shape): self._check_if_input_shape_is_none(input_shape) self._set_number_of_groups_for_instance_norm(input_shape) self._check_size_of_dimensions(input_shape)\",\n \"layer_outputs = layer_module( hidden_states=hidden_states, attention_mask=attention_mask, output_attentions=output_attentions, training=training, ) hidden_states = layer_outputs[0] if output_attentions:\",\n \"= None, inputs_embeds: Optional[tf.Tensor] = None, output_attentions: Optional[bool] = None, labels: Optional[tf.Tensor] =\",\n \"transformers.models.wav2vec2.modeling_tf_wav2vec2._sample_without_replacement def _sample_without_replacement(distribution, num_samples): \\\"\\\"\\\" Categorical sampling without replacement is currently not implemented.\",\n \"padding mask of the same size as shape, which will prevent masking padded\",\n \"keras_serializable from ...tf_utils import shape_list from ...tokenization_utils_base import BatchEncoding from ...utils import (\",\n \"= tf.reshape(value_states, proj_shape) src_len = shape_list(key_states)[1] attn_weights = tf.matmul(query_states, key_states, transpose_b=True) # The\",\n \"the unexpected layers. \\\"\\\"\\\" signature = dict(inspect.signature(func).parameters) signature.pop(\\\"kwargs\\\", None) signature.pop(\\\"self\\\", None) parameter_names =\",\n \"1]`: - 1 indicates the head is **not masked**, - 0 indicates the\",\n \"the tokens with labels in `[0, ..., config.vocab_size]` Returns: Example: ```python >>> import\",\n \"= 0): \\\"\\\"\\\" Expands attention_mask from `[bsz, seq_len]` to `[bsz, 1, tgt_seq_len, src_seq_len]`.\",\n \"inputs_embeds: Optional[tf.Tensor] = None, output_attentions: Optional[tf.Tensor] = None, output_hidden_states: Optional[tf.Tensor] = None, return_dict:\",\n \"training mode (some modules like dropout modules have different behaviors between training and\",\n \"calls to uni-directional self-attention # can concat previous decoder key/value_states to current projected\",\n \"loss = None if not inputs[\\\"return_dict\\\"]: output = (logits,) + outputs[1:] return ((loss,)\",\n \"1 group_reduction_axes.pop(axis) mean, variance = tf.nn.moments(reshaped_inputs, group_reduction_axes, keepdims=True) gamma, beta = self._get_reshaped_weights(input_shape) normalized_inputs\",\n \"gradient computation for the feature encoder so that its parameter will not be\",\n \"checked at build time since TF 2.7, so we need to account for\",\n \") if self.config.ctc_loss_reduction == \\\"sum\\\": loss = tf.reduce_sum(loss) if self.config.ctc_loss_reduction == \\\"mean\\\": loss\",\n \"are **masked**. [What are attention masks?](../glossary#attention-mask) token_type_ids (`np.ndarray` or `tf.Tensor` of shape `({0})`,\",\n \"( inputs[\\\"output_attentions\\\"] if inputs[\\\"output_attentions\\\"] else self.config.output_attentions ) inputs[\\\"return_dict\\\"] = inputs[\\\"return_dict\\\"] if inputs[\\\"return_dict\\\"] else\",\n \"training: Optional[bool] = False, ) -> Union[TFBaseModelOutput, Tuple[tf.Tensor]]: all_hidden_states = () if output_hidden_states\",\n \"attn_output, attn_weights, past_key_value # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2FeedForward with Wav2Vec2->Hubert class TFHubertFeedForward(tf.keras.layers.Layer): def __init__(self,\",\n \"not is_instance_norm: outputs = tf.reshape(normalized_inputs, tensor_input_shape) else: outputs = normalized_inputs return outputs def\",\n \"hidden_states = self.dropout(hidden_states, training=training) for i, layer_module in enumerate(self.layer): if output_hidden_states: all_hidden_states =\",\n \"layer received an input with shape \\\" + str(input_shape) + \\\".\\\" ) def\",\n \"= int(mask_prob * sequence_length / mask_length + tf.random.uniform((1,))) num_masked_spans = max(num_masked_spans, min_masks) #\",\n \"import shape_list from ...tokenization_utils_base import BatchEncoding from ...utils import ( ModelOutput, add_start_docstrings, add_start_docstrings_to_model_forward,\",\n \"can use to gather all the input Tensors in the first positional argument\",\n \":], (1, 1, tgt_len, 1)) return (one_cst - expanded_mask) * LARGE_NEGATIVE # Copied\",\n \"a [tf.keras.Model](https://www.tensorflow.org/api_docs/python/tf/keras/Model) subclass. Use it as a regular TF 2.0 Keras Model and\",\n \"is deprecated and will be removed in a future version, use `input_values` instead.\\\",\",\n \"self.lm_head = tf.keras.layers.Dense(config.vocab_size, name=\\\"lm_head\\\") def freeze_feature_extractor(self): \\\"\\\"\\\" Calling this function will disable the\",\n \"> 0: mask_feature_indices = _compute_mask_indices( (batch_size, hidden_size), mask_prob=self.config.mask_feature_prob, mask_length=self.config.mask_feature_length, ) hidden_states = tf.where(mask_feature_indices[:,\",\n \"not to return the hidden states of all layers. See `hidden_states` under returned\",\n \"Optional[bool] = False, return_dict: Optional[bool] = True, training: Optional[bool] = False, ) ->\",\n \"= False, ) -> Tuple[tf.Tensor, Optional[tf.Tensor]]: \\\"\\\"\\\"Input shape: Batch x Time x Channel\\\"\\\"\\\"\",\n \"from \\\"Attention Is All You Need\\\"\\\"\\\" def __init__( self, embed_dim: int, num_heads: int,\",\n \"boolean_dict = { k: v for k, v in output.items() if k in\",\n \"list(range(1, len(group_shape))) is_instance_norm = (input_shape[self.axis] // self.groups) == 1 if not is_instance_norm: axis\",\n \"tensors for more detail. This argument can be used only in eager mode,\",\n \"= None, past_key_value: Optional[Tuple[Tuple[tf.Tensor]]] = None, attention_mask: Optional[tf.Tensor] = None, layer_head_mask: Optional[tf.Tensor] =\",\n \"self.out_proj = tf.keras.layers.Dense(embed_dim, use_bias=bias, name=\\\"out_proj\\\") def _shape(self, tensor: tf.Tensor, seq_len: int, bsz: int):\",\n \"tf.keras.layers.Dense(embed_dim, use_bias=bias, name=\\\"k_proj\\\") self.q_proj = tf.keras.layers.Dense(embed_dim, use_bias=bias, name=\\\"q_proj\\\") self.v_proj = tf.keras.layers.Dense(embed_dim, use_bias=bias, name=\\\"v_proj\\\")\",\n \"call( self, input_values: tf.Tensor, attention_mask: Optional[tf.Tensor] = None, token_type_ids: Optional[tf.Tensor] = None, position_ids:\",\n \"that are NOT supported on CPU. If you wish \\\" \\\"to train/fine-tine this\",\n \"sequence_length), dtype=tf.int32) # uniform distribution to sample from, make sure that offset samples\",\n \"epsilon=config.layer_norm_eps, name=\\\"layer_norm\\\") def call(self, hidden_states: tf.Tensor) -> tf.Tensor: hidden_states = self.conv(hidden_states) hidden_states =\",\n \"= tf.matmul(attn_probs, value_states) # The tf.debugging asserts are not compliant with XLA then\",\n \"def __init__(self, config: HubertConfig, **kwargs: Any) -> None: super().__init__(**kwargs) if config.feat_extract_norm == \\\"group\\\":\",\n \"tokens in the position embeddings. Selected in the range `[0, config.max_position_embeddings - 1]`.\",\n \"the value in the config will be used instead. return_dict (`bool`, *optional*): Whether\",\n \"weights initialization and a simple interface for downloading and loading pretrained models. \\\"\\\"\\\"\",\n \"self._check_size_of_dimensions(input_shape) self._create_input_spec(input_shape) self._add_gamma_weight(input_shape) self._add_beta_weight(input_shape) self.built = True super().build(input_shape) def call(self, inputs): input_shape =\",\n \"hidden_states if mask_time_indices is not None: # apply SpecAugment along time axis with\",\n \"for a single layer should be of size {(self.num_heads)}, but is {shape_list(layer_head_mask)}\\\", )\",\n \"is **not masked**, - 0 indicates the head is **masked**. inputs_embeds (`np.ndarray` or\",\n \"TF_HUBERT_PRETRAINED_MODEL_ARCHIVE_LIST = [ \\\"facebook/hubert-base-ls960\\\", # See all Hubert models at https://huggingface.co/models?filter=hubert ] LARGE_NEGATIVE\",\n \"= tf.nn.softmax(attn_weights, axis=-1) if layer_head_mask is not None: # The tf.debugging asserts are\",\n \"# `name` part tensor_name = input.name.split(\\\":\\\")[0] if tensor_name in parameter_names: output[tensor_name] = input\",\n \"= self.out_proj(attn_output) attn_weights: tf.Tensor = tf.reshape(attn_weights, (bsz, self.num_heads, tgt_len, src_len)) return attn_output, attn_weights,\",\n \"mask_prob=self.config.mask_feature_prob, mask_length=self.config.mask_feature_length, ) hidden_states = tf.where(mask_feature_indices[:, tf.newaxis, :], hidden_states, 0) return hidden_states def\",\n \"inputs[\\\"output_attentions\\\"] = ( inputs[\\\"output_attentions\\\"] if inputs[\\\"output_attentions\\\"] else self.config.output_attentions ) inputs[\\\"return_dict\\\"] = inputs[\\\"return_dict\\\"] if\",\n \"# when not being attended to labels_mask = tf.cast(labels >= 0, tf.int32) target_lengths\",\n \"= _expand_mask(attention_mask) else: attention_mask = None position_embeddings = self.pos_conv_embed(hidden_states) hidden_states = hidden_states +\",\n \"shapes are checked at build time since TF 2.7, so we need to\",\n \") if attention_mask is not None: # The tf.debugging asserts are not compliant\",\n \"the # `name` part tensor_name = input.name.split(\\\":\\\")[0] if tensor_name in parameter_names: output[tensor_name] =\",\n \"will prevent masking padded elements mask_prob: probability for each token to be chosen\",\n \"Args: func (`callable`): The callable function of the TensorFlow model. config ([`PretrainedConfig`]): The\",\n \"Copied from transformers.models.bart.modeling_tf_bart._expand_mask def _expand_mask(mask: tf.Tensor, tgt_len: Optional[int] = None, past_key_values_length: int =\",\n \"self.input_spec = tf.keras.layers.InputSpec(ndim=len(input_shape), axes={self.axis: dim}) def _add_gamma_weight(self, input_shape): dim = input_shape[self.axis] shape =\",\n \"input_shape[self.axis] shape = (dim,) if self.scale: self.gamma = self.add_weight( shape=shape, name=\\\"gamma\\\", initializer=self.gamma_initializer, regularizer=self.gamma_regularizer,\",\n \"to convolution formula output_lengths = self._get_feat_extract_output_lengths(tf.reduce_sum(inputs[\\\"attention_mask\\\"], -1)) attention_mask = tf.sequence_mask( output_lengths, maxlen=shape_list(hidden_states)[1], dtype=hidden_states.dtype\",\n \"= groups self.axis = axis self.epsilon = epsilon self.center = center self.scale =\",\n \"Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2Encoder with Wav2Vec2->Hubert class TFHubertEncoder(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs): super().__init__(**kwargs)\",\n \"from https://pytorch.org/docs/stable/generated/torch.nn.Conv1d.html return (input_length - kernel_size) // stride + 1 for kernel_size, stride\",\n \"...tokenization_utils_base import BatchEncoding from ...utils import ( ModelOutput, add_start_docstrings, add_start_docstrings_to_model_forward, logging, replace_return_docstrings, )\",\n \"Use it as a regular TF 2.0 Keras Model and refer to the\",\n \"training=training) for i, layer_module in enumerate(self.layer): if output_hidden_states: all_hidden_states = all_hidden_states + (hidden_states,)\",\n \"`input_values` only and nothing else: `model(inputs_ids)` - a list of varying length with\",\n \"hidden_states = self.conv(hidden_states) hidden_states = self.padding(hidden_states) hidden_states = self.activation(hidden_states) return hidden_states # Copied\",\n \"all inputs as a list, tuple or dict in the first positional arguments.\",\n \"trainable=True) def call(self, inputs): if not self.initialized: self._init_norm() self.initialized = True self._normalize_kernel() padded_inputs\",\n \"tf.transpose(tf.concat([broad_casted_batch_dims, tf.reshape(batch_indices, [1, -1])], 0)) # scatter values to pair indices return tf.scatter_nd(pair_indices,\",\n \"model. Returns: Two lists, one for the missing layers, and another one for\",\n \"computation for the feature encoder so that its parameter will not be updated\",\n \"{self.config.vocab_size}\\\") attention_mask = ( inputs[\\\"attention_mask\\\"] if inputs[\\\"attention_mask\\\"] is not None else tf.ones_like(inputs[\\\"input_values\\\"], dtype=tf.float32)\",\n \"of all cross attention key/value_states. # Further calls to cross_attention layer can then\",\n \"self.initialized: self._init_norm() self.initialized = True self._normalize_kernel() padded_inputs = tf.pad(inputs, ((0, 0), (self.explicit_padding, self.explicit_padding),\",\n \"parameter_names and \\\"args\\\" not in parameter_names: logger.warning( f\\\"The parameter {k} does not belongs\",\n \"we have to add this exception if \\\"args\\\" in output: if output[\\\"args\\\"] is\",\n \"all_self_attentions + (layer_outputs[1],) # Add last layer if output_hidden_states: all_hidden_states = all_hidden_states +\",\n \") def _check_axis(self): if self.axis == 0: raise ValueError( \\\"You are trying to\",\n \"token_type_ids=inputs[\\\"token_type_ids\\\"], position_ids=inputs[\\\"position_ids\\\"], head_mask=inputs[\\\"head_mask\\\"], inputs_embeds=inputs[\\\"inputs_embeds\\\"], output_attentions=inputs[\\\"output_attentions\\\"], output_hidden_states=inputs[\\\"output_hidden_states\\\"], return_dict=inputs[\\\"return_dict\\\"], training=inputs[\\\"training\\\"], ) hidden_states = outputs[0] hidden_states\",\n \"self.activation(hidden_states) return hidden_states # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2SamePadLayer with Wav2Vec2->Hubert class TFHubertSamePadLayer(tf.keras.layers.Layer): def __init__(self,\",\n \"= False, return_dict: Optional[bool] = True, training: Optional[bool] = False, ) -> Union[TFBaseModelOutput,\",\n \"__init__(self, config: HubertConfig, **kwargs): super().__init__(**kwargs) self.config = config self.feature_extractor = TFHubertFeatureEncoder(config, name=\\\"feature_extractor\\\") self.feature_projection\",\n \"\\\"License\\\"); # you may not use this file except in compliance with the\",\n \"obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless\",\n \"top.\\\", HUBERT_START_DOCSTRING, ) class TFHubertModel(TFHubertPreTrainedModel): def __init__(self, config: HubertConfig, *inputs, **kwargs): super().__init__(config, *inputs,\",\n \"center self.scale = scale self.beta_initializer = tf.keras.initializers.get(beta_initializer) self.gamma_initializer = tf.keras.initializers.get(gamma_initializer) self.beta_regularizer = tf.keras.regularizers.get(beta_regularizer)\",\n \"epsilon=config.layer_norm_eps) self.activation = get_tf_activation(config.feat_extract_activation) def call(self, hidden_states: tf.Tensor) -> tf.Tensor: hidden_states = self.conv(hidden_states)\",\n \"accepted for {k}.\\\") else: if isinstance(input_values, tf.Tensor) or input_values is None: output[parameter_names[0]] =\",\n \"\\\"gamma_constraint\\\": tf.keras.constraints.serialize(self.gamma_constraint), } base_config = super().get_config() return {**base_config, **config} def compute_output_shape(self, input_shape): return\",\n \"= tf.sequence_mask( output_lengths, maxlen=shape_list(hidden_states)[1], dtype=hidden_states.dtype ) hidden_states = self.feature_projection(hidden_states, training=inputs[\\\"training\\\"]) mask_time_indices = kwargs.get(\\\"mask_time_indices\\\",\",\n \"batch dim to indices_shape broad_casted_batch_dims = tf.reshape( tf.broadcast_to(tf.expand_dims(tf.range(indices_shape[0]), axis=-1), indices_shape), [1, -1] )\",\n \"to nullify selected heads of the self-attention modules. Mask values selected in `[0,\",\n \"tf.reshape(attn_weights, (bsz, self.num_heads, tgt_len, src_len)) + attention_mask attn_weights = tf.reshape(attn_weights, (bsz * self.num_heads,\",\n \"is not None bsz, tgt_len, embed_dim = shape_list(hidden_states) # get query proj query_states\",\n \"- expanded_mask) * LARGE_NEGATIVE # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2GroupNorm with Wav2Vec2->Hubert class TFHubertGroupNorm(tf.keras.layers.Layer): \\\"\\\"\\\"\",\n \"only in eager mode, in graph mode the value in the config will\",\n \"will be used instead. output_hidden_states (`bool`, *optional*): Whether or not to return the\",\n \"\\\"\\\"\\\" Scatter function as in PyTorch with indices in format (batch_dim, indixes) \\\"\\\"\\\"\",\n \"then they # have to be disabled in other modes than eager. if\",\n \"UNIVERSE SIR I EXIST\\\" >>> # wrap processor as target processor to encode\",\n \"key_states = tf.reshape(key_states, proj_shape) value_states = tf.reshape(value_states, proj_shape) src_len = shape_list(key_states)[1] attn_weights =\",\n \"eager. if tf.executing_eagerly(): tf.debugging.assert_equal( shape_list(attn_weights), [bsz * self.num_heads, tgt_len, src_len], message=f\\\"Attention weights should\",\n \"__init__(self, config: HubertConfig, **kwargs: Any) -> None: super().__init__(**kwargs) self.conv = TFHubertWeightNormConv1D( filters=config.hidden_size, kernel_size=config.num_conv_pos_embeddings,\",\n \"tf.reshape(attn_weights, (bsz, self.num_heads, tgt_len, src_len)) return attn_output, attn_weights, past_key_value # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2FeedForward\",\n \"if num_conv_pos_embeddings % 2 == 0 else 0 def call(self, hidden_states): if self.num_pad_remove\",\n \"= None, return_dict: Optional[bool] = None, training: bool = False, ) -> Union[TFBaseModelOutput,\",\n \"import HubertConfig logger = logging.get_logger(__name__) _CONFIG_FOR_DOC = \\\"HubertConfig\\\" TF_HUBERT_PRETRAINED_MODEL_ARCHIVE_LIST = [ \\\"facebook/hubert-base-ls960\\\", #\",\n \"{(self.num_heads)}, but is {shape_list(layer_head_mask)}\\\", ) attn_weights = tf.reshape(layer_head_mask, (1, -1, 1, 1)) *\",\n \"`input_values` output[\\\"input_values\\\"] = output[\\\"args\\\"] del output[\\\"args\\\"] if \\\"kwargs\\\" in output: del output[\\\"kwargs\\\"] boolean_dict\",\n \"*optional*): Mask to nullify selected heads of the self-attention modules. Mask values selected\",\n \"= None, output_attentions: Optional[bool] = False, output_hidden_states: Optional[bool] = False, return_dict: Optional[bool] =\",\n \"kernel_size=config.conv_kernel[layer_id], strides=config.conv_stride[layer_id], use_bias=config.conv_bias, name=\\\"conv\\\", ) self.layer_norm = tf.keras.layers.LayerNormalization(name=\\\"layer_norm\\\", epsilon=config.layer_norm_eps) self.activation = get_tf_activation(config.feat_extract_activation) def\",\n \"Masks extracted features along time axis and/or along feature axis according to [SpecAugment](https://arxiv.org/abs/1904.08779).\",\n \"gamma, beta = self._get_reshaped_weights(input_shape) normalized_inputs = tf.nn.batch_normalization( reshaped_inputs, mean=mean, variance=variance, scale=gamma, offset=beta, variance_epsilon=self.epsilon,\",\n \"must be a \\\" \\\"multiple of the number of channels (\\\" + str(dim)\",\n \"shape = (dim,) if self.center: self.beta = self.add_weight( shape=shape, name=\\\"beta\\\", initializer=self.beta_initializer, regularizer=self.beta_regularizer, constraint=self.beta_constraint,\",\n \"FutureWarning, ) output[\\\"past_key_values\\\"] = input_values.pop(\\\"decoder_cached_states\\\") for k, v in dict(input_values).items(): if isinstance(v, allowed_types)\",\n \"import TFPreTrainedModel, booleans_processing, get_initializer, keras_serializable from ...tf_utils import shape_list from ...tokenization_utils_base import BatchEncoding\",\n \"@replace_return_docstrings(output_type=TFCausalLMOutput, config_class=_CONFIG_FOR_DOC) def call( self, input_values: tf.Tensor, attention_mask: Optional[tf.Tensor] = None, token_type_ids: Optional[tf.Tensor]\",\n \"tgt_len: Optional[int] = None, past_key_values_length: int = 0): \\\"\\\"\\\" Expands attention_mask from `[bsz,\",\n \"training=inputs[\\\"training\\\"] ) if inputs[\\\"attention_mask\\\"] is not None: # compute real output lengths according\",\n \"shape=shape, name=\\\"beta\\\", initializer=self.beta_initializer, regularizer=self.beta_regularizer, constraint=self.beta_constraint, ) else: self.beta = None def _create_broadcast_shape(self, input_shape):\",\n \"of size 2 where first element is batch size and 2nd is timesteps\",\n \"None: if tf.reduce_max(labels) >= self.config.vocab_size: raise ValueError(f\\\"Label values must be <= vocab_size: {self.config.vocab_size}\\\")\",\n \"attention_mask attn_weights = tf.reshape(attn_weights, (bsz * self.num_heads, tgt_len, src_len)) attn_weights = tf.nn.softmax(attn_weights, axis=-1)\",\n \"num_heads: int, dropout: float = 0.0, is_decoder: bool = False, bias: bool =\",\n \"`List[tf.Tensor]` ``Dict[str, tf.Tensor]` or `Dict[str, np.ndarray]` and each example must have the shape\",\n \"= speech ... return batch >>> ds = load_dataset(\\\"hf-internal-testing/librispeech_asr_dummy\\\", \\\"clean\\\", split=\\\"validation\\\") >>> ds\",\n \"logits=logits, hidden_states=outputs.hidden_states, attentions=outputs.attentions, ) def serving_output(self, output: TFCausalLMOutput) -> TFCausalLMOutput: hs = tf.convert_to_tensor(output.hidden_states)\",\n \"Need\\\"\\\"\\\" def __init__( self, embed_dim: int, num_heads: int, dropout: float = 0.0, is_decoder:\",\n \"isinstance(input_values, tf.Tensor) or input_values is None: output[parameter_names[0]] = input_values else: raise ValueError( f\\\"Data\",\n \"1]) def _init_norm(self): \\\"\\\"\\\"Set the norm of the weight vector.\\\"\\\"\\\" kernel_norm = tf.sqrt(tf.reduce_sum(tf.square(self.weight_v),\",\n \"WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the\",\n \"self.projection(hidden_states) hidden_states = self.dropout(hidden_states, training=training) return hidden_states # Copied from transformers.models.bart.modeling_tf_bart.TFBartAttention with TFBart->TFHubert\",\n \"disabled in other modes than eager. if tf.executing_eagerly(): tf.debugging.assert_equal( shape_list(attention_mask), [bsz, 1, tgt_len,\",\n \"not compliant with XLA then they # have to be disabled in other\",\n \"according to convolution formula output_lengths = self._get_feat_extract_output_lengths(tf.reduce_sum(inputs[\\\"attention_mask\\\"], -1)) attention_mask = tf.sequence_mask( output_lengths, maxlen=shape_list(hidden_states)[1],\",\n \"masked spans Adapted from [fairseq's data_utils.py](https://github.com/pytorch/fairseq/blob/e0788f7007a8473a76db573985031f3c94201e79/fairseq/data/data_utils.py#L376). \\\"\\\"\\\" batch_size, sequence_length = shape if mask_length\",\n \"in graph mode the value in the config will be used instead. return_dict\",\n \"the model call function: `model(inputs)`. If you choose this second option, there are\",\n \"bool = False) -> tf.Tensor: hidden_states = self.intermediate_dense(hidden_states) hidden_states = self.intermediate_act_fn(hidden_states) hidden_states =\",\n \"pattern `name:id` then we check only the # `name` part tensor_name = input.name.split(\\\":\\\")[0]\",\n \"(0, 0))) output = super().call(padded_inputs) return output # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2NoLayerNormConvLayer with Wav2Vec2->Hubert\",\n \"explicit_padding=config.num_conv_pos_embeddings // 2, name=\\\"conv\\\", ) self.padding = TFHubertSamePadLayer(config.num_conv_pos_embeddings) self.activation = get_tf_activation(config.feat_extract_activation) def call(self,\",\n \"return outputs def get_config(self): config = { \\\"groups\\\": self.groups, \\\"axis\\\": self.axis, \\\"epsilon\\\": self.epsilon,\",\n \"tf.keras.layers.Dropout(config.hidden_dropout) self.layer = [TFHubertEncoderLayer(config, name=f\\\"layers.{i}\\\") for i in range(config.num_hidden_layers)] def call( self, hidden_states:\",\n \"**kwargs): super().__init__(**kwargs) self.config = config self.pos_conv_embed = TFHubertPositionalConvEmbedding(config, name=\\\"pos_conv_embed\\\") self.layer_norm = tf.keras.layers.LayerNormalization(epsilon=config.layer_norm_eps, name=\\\"layer_norm\\\")\",\n \"associated to the input names given in the docstring: `model({\\\"input_values\\\": input_values, \\\"token_type_ids\\\": token_type_ids})`\",\n \"if output_attentions: all_self_attentions = all_self_attentions + (layer_outputs[1],) # Add last layer if output_hidden_states:\",\n \"library implements for all its model (such as downloading or saving, resizing the\",\n \"embeddings. Selected in the range `[0, config.max_position_embeddings - 1]`. [What are position IDs?](../glossary#position-ids)\",\n \"-1, self.head_dim) query_states = tf.reshape(self._shape(query_states, tgt_len, bsz), proj_shape) key_states = tf.reshape(key_states, proj_shape) value_states\",\n \"= tf.reshape(attn_weights, (bsz, self.num_heads, tgt_len, src_len)) return attn_output, attn_weights, past_key_value # Copied from\",\n \"warnings.warn( \\\"The `decoder_cached_states` argument is deprecated and will be removed in a future\",\n \"= None, training: Optional[bool] = False, ) -> Tuple[tf.Tensor, Optional[tf.Tensor]]: \\\"\\\"\\\"Input shape: Batch\",\n \"tf.keras.layers.LayerNormalization(epsilon=config.layer_norm_eps, name=\\\"layer_norm\\\") self.dropout = tf.keras.layers.Dropout(config.hidden_dropout) self.layer = [TFHubertEncoderLayer(config, name=f\\\"layers.{i}\\\") for i in range(config.num_hidden_layers)]\",\n \"other modes than eager. if tf.executing_eagerly(): tf.debugging.assert_equal( shape_list(layer_head_mask), [self.num_heads], message=f\\\"Head mask for a\",\n \"list, dict, np.ndarray) for k, v in kwargs.items(): if isinstance(v, allowed_types) or v\",\n \"(tuple, list)): for i, input in enumerate(input_values): # EagerTensors don't allow to use\",\n \"of shape `({0})`, *optional*): Segment token indices to indicate first and second portions\",\n \"num_heads (got `embed_dim`: {self.embed_dim}\\\" f\\\" and `num_heads`: {num_heads}).\\\" ) self.scaling = self.head_dim**-0.5 self.is_decoder\",\n \"with the model, only the configuration. Check out the [`~PreTrainedModel.from_pretrained`] method to load\",\n \"speech ... return batch >>> ds = load_dataset(\\\"hf-internal-testing/librispeech_asr_dummy\\\", \\\"clean\\\", split=\\\"validation\\\") >>> ds =\",\n \"= layer_module( hidden_states=hidden_states, attention_mask=attention_mask, output_attentions=output_attentions, training=training, ) hidden_states = layer_outputs[0] if output_attentions: all_self_attentions\",\n \"tf.zeros((batch_size, sequence_length), dtype=tf.int32) # uniform distribution to sample from, make sure that offset\",\n \"ValueError( f\\\"Data of type {type(input_values)} is not allowed only {allowed_types} is accepted for\",\n \"removed in Transformers v5. \\\" f\\\"Use `{self.__class__.__bases__[0].__name__}` instead.\\\", FutureWarning, ) class TFHubertFeatureProjection(tf.keras.layers.Layer): def\",\n \"hidden_states hidden_states = self.layer_norm(hidden_states) hidden_states = hidden_states + self.feed_forward(hidden_states) hidden_states = self.final_layer_norm(hidden_states) outputs\",\n \"hidden_states = self.activation(hidden_states) return hidden_states # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2PositionalConvEmbedding with Wav2Vec2->Hubert class TFHubertPositionalConvEmbedding(tf.keras.layers.Layer):\",\n \"self.lm_head(hidden_states) if labels is not None: if tf.reduce_max(labels) >= self.config.vocab_size: raise ValueError(f\\\"Label values\",\n \"1, mask_length)) spec_aug_mask_idxs = tf.reshape(spec_aug_mask_idxs, (batch_size, num_masked_spans * mask_length)) offsets = tf.range(mask_length)[tf.newaxis, tf.newaxis,\",\n \"\\\"use_cache\\\"] } output.update(booleans_processing(config=config, **boolean_dict)) return output # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2._sample_without_replacement def _sample_without_replacement(distribution, num_samples):\",\n \") from .configuration_hubert import HubertConfig logger = logging.get_logger(__name__) _CONFIG_FOR_DOC = \\\"HubertConfig\\\" TF_HUBERT_PRETRAINED_MODEL_ARCHIVE_LIST =\",\n \"gamma_regularizer: tf.keras.regularizers.Regularizer = None, beta_constraint: tf.keras.constraints.Constraint = None, gamma_constraint: tf.keras.constraints.Constraint = None, **kwargs,\",\n \"x Time x Channel\\\"\\\"\\\" # if key_value_states are provided this layer is used\",\n \"feature encoder so that its parameters will not be updated during training. \\\"\\\"\\\"\",\n \"tf.matmul(query_states, key_states, transpose_b=True) # The tf.debugging asserts are not compliant with XLA then\",\n \"config=self.config, input_values=input_values, attention_mask=attention_mask, token_type_ids=token_type_ids, position_ids=position_ids, head_mask=head_mask, inputs_embeds=inputs_embeds, output_attentions=output_attentions, output_hidden_states=output_hidden_states, return_dict=return_dict, training=training, ) inputs[\\\"output_hidden_states\\\"]\",\n \"Returns: Two lists, one for the missing layers, and another one for the\",\n \"name=\\\"conv\\\", ) self.activation = get_tf_activation(config.feat_extract_activation) def call(self, hidden_states: tf.Tensor) -> tf.Tensor: hidden_states =\",\n \"elif k not in parameter_names and \\\"args\\\" not in parameter_names: logger.warning( f\\\"The parameter\",\n \"return_dict: Optional[bool] = None, training: bool = False, **kwargs: Any, ): inputs =\",\n \"1, 1)) * tf.reshape( attn_weights, (bsz, self.num_heads, tgt_len, src_len) ) attn_weights = tf.reshape(attn_weights,\",\n \"**boolean_dict)) return output # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2._sample_without_replacement def _sample_without_replacement(distribution, num_samples): \\\"\\\"\\\" Categorical sampling\",\n \"one or several input Tensors associated to the input names given in the\",\n \"list, tuple or dict in the first positional arguments. This second option is\",\n \"class TFHubertFeedForward(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs): super().__init__(**kwargs) self.intermediate_dropout = tf.keras.layers.Dropout(config.activation_dropout) self.intermediate_dense =\",\n \"SpecAugment along time axis mask_time_indices = _compute_mask_indices( (batch_size, sequence_length), mask_prob=self.config.mask_time_prob, mask_length=self.config.mask_time_length, min_masks=2, )\",\n \"time axis with given mask_time_indices hidden_states = tf.where( tf.cast(mask_time_indices[:, :, tf.newaxis], tf.bool), self.masked_spec_embed[tf.newaxis,\",\n \"not allowed only {allowed_types} is accepted for {parameter_names[i]}.\\\" ) elif isinstance(input_values, (dict, BatchEncoding)):\",\n \"conv_layer(hidden_states) return hidden_states class TFHubertFeatureExtractor(TFHubertFeatureEncoder): def __init__(self, config, **kwargs): super().__init__(config, **kwargs) warnings.warn( f\\\"The\",\n \"= tf.transpose(tf.concat([broad_casted_batch_dims, tf.reshape(batch_indices, [1, -1])], 0)) # scatter values to pair indices return\",\n \"tf.keras.layers.Dropout(config.hidden_dropout) def call(self, hidden_states: tf.Tensor, training: bool = False) -> tf.Tensor: hidden_states =\",\n \"The Fairseq Authors and the HuggingFace Inc. team. All rights reserved. # #\",\n \"the position embeddings. Selected in the range `[0, config.max_position_embeddings - 1]`. [What are\",\n \"-1: self.groups = dim def _check_size_of_dimensions(self, input_shape): dim = input_shape[self.axis] if dim <\",\n \"def _get_reshaped_weights(self, input_shape): broadcast_shape = self._create_broadcast_shape(input_shape) gamma = None beta = None if\",\n \"shape=(self.config.hidden_size,), initializer=\\\"uniform\\\", trainable=True, name=\\\"masked_spec_embed\\\" ) super().build(input_shape) def _get_feat_extract_output_lengths(self, input_lengths: tf.Tensor): \\\"\\\"\\\" Computes the\",\n \"class `{self.__class__.__name__}` has been depreciated \\\" \\\"and will be removed in Transformers v5.\",\n \"*inputs, **kwargs) self.config = config self.hubert = TFHubertMainLayer(config, name=\\\"hubert\\\") @add_start_docstrings_to_model_forward(HUBERT_INPUTS_DOCSTRING) @replace_return_docstrings(output_type=TFBaseModelOutput, config_class=_CONFIG_FOR_DOC) def\",\n \"mask_length=self.config.mask_time_length, min_masks=2, ) hidden_states = tf.where( tf.cast(mask_time_indices[:, :, tf.newaxis], tf.bool), self.masked_spec_embed[tf.newaxis, tf.newaxis, :],\",\n \"config will be used instead. return_dict (`bool`, *optional*): Whether or not to return\",\n \"zip(self.config.conv_kernel, self.config.conv_stride): input_lengths = _conv_out_length(input_lengths, kernel_size, stride) return input_lengths def _mask_hidden_states(self, hidden_states: tf.Tensor,\",\n \"return attn_output, attn_weights, past_key_value # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2FeedForward with Wav2Vec2->Hubert class TFHubertFeedForward(tf.keras.layers.Layer): def\",\n \"TFBaseModelOutput( last_hidden_state=hidden_states, hidden_states=all_hidden_states, attentions=all_self_attentions, ) # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2EncoderStableLayerNorm with Wav2Vec2->Hubert class TFHubertEncoderStableLayerNorm(tf.keras.layers.Layer):\",\n \"TF 2.0 Keras Model and refer to the TF 2.0 documentation for all\",\n \"instead\\\" ) def _create_input_spec(self, input_shape): dim = input_shape[self.axis] self.input_spec = tf.keras.layers.InputSpec(ndim=len(input_shape), axes={self.axis: dim})\",\n \"hidden_states=outputs.hidden_states, attentions=outputs.attentions, ) def serving_output(self, output: TFCausalLMOutput) -> TFCausalLMOutput: hs = tf.convert_to_tensor(output.hidden_states) if\",\n \"attn_weights: tf.Tensor = tf.reshape(attn_weights, (bsz, self.num_heads, tgt_len, src_len)) return attn_output, attn_weights, past_key_value #\",\n \") # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2EncoderStableLayerNorm with Wav2Vec2->Hubert class TFHubertEncoderStableLayerNorm(tf.keras.layers.Layer): def __init__(self, config: HubertConfig,\",\n \"requires having all the tensors in the first argument of the model call\",\n \"a list of varying length with one or several input Tensors IN THE\",\n \"heads etc.) This model is also a [tf.keras.Model](https://www.tensorflow.org/api_docs/python/tf/keras/Model) subclass. Use it as a\",\n \"in parameter_names: logger.warning( f\\\"The parameter {k} does not belongs to the parameter list\",\n \"output_hidden_states (`bool`, *optional*): Whether or not to return the hidden states of all\",\n \"if \\\"args\\\" in output: if output[\\\"args\\\"] is not None and type(output[\\\"args\\\"]) == tf.Tensor:\",\n \"in range(config.num_hidden_layers)] def call( self, hidden_states: tf.Tensor, attention_mask: Optional[tf.Tensor] = None, output_attentions: Optional[bool]\",\n \"self.is_decoder = is_decoder self.k_proj = tf.keras.layers.Dense(embed_dim, use_bias=bias, name=\\\"k_proj\\\") self.q_proj = tf.keras.layers.Dense(embed_dim, use_bias=bias, name=\\\"q_proj\\\")\",\n \"masking to False if not getattr(self.config, \\\"apply_spec_augment\\\", True): return hidden_states if mask_time_indices is\",\n \"name=f\\\"conv_layers.{0}\\\")] + [ TFHubertNoLayerNormConvLayer(config, layer_id=i + 1, name=f\\\"conv_layers.{i+1}\\\") for i in range(config.num_feat_extract_layers -\",\n \"super().__init__(config, **kwargs) warnings.warn( f\\\"The class `{self.__class__.__name__}` has been depreciated \\\" \\\"and will be\",\n \"+= (attn_weights,) return outputs # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2Encoder with Wav2Vec2->Hubert class TFHubertEncoder(tf.keras.layers.Layer): def\",\n \"if inputs[\\\"attention_mask\\\"] is not None: # compute real output lengths according to convolution\",\n \"**not masked**, - 0 for tokens that are **masked**. [What are attention masks?](../glossary#attention-mask)\",\n \") outputs = self.hubert( input_values=inputs[\\\"input_values\\\"], attention_mask=inputs[\\\"attention_mask\\\"], token_type_ids=inputs[\\\"token_type_ids\\\"], position_ids=inputs[\\\"position_ids\\\"], head_mask=inputs[\\\"head_mask\\\"], inputs_embeds=inputs[\\\"inputs_embeds\\\"], output_attentions=inputs[\\\"output_attentions\\\"], output_hidden_states=inputs[\\\"output_hidden_states\\\"], return_dict=inputs[\\\"return_dict\\\"],\",\n \"size 1 >>> hidden_states = model(input_values).last_hidden_state ```\\\"\\\"\\\" inputs = input_values_processing( func=self.call, config=self.config, input_values=input_values,\",\n \"list of varying length with one or several input Tensors IN THE ORDER\",\n \"= kwargs.get(\\\"mask_time_indices\\\", None) if inputs[\\\"training\\\"]: hidden_states = self._mask_hidden_states(hidden_states, mask_time_indices=mask_time_indices) encoder_outputs = self.encoder( hidden_states,\",\n \"hidden states of all layers. See `hidden_states` under returned tensors for more detail.\",\n \"in the first argument of the model call function: `model(inputs)`. If you choose\",\n \"`[0, config.max_position_embeddings - 1]`. [What are position IDs?](../glossary#position-ids) head_mask (`np.ndarray` or `tf.Tensor` of\",\n \"License is distributed on an \\\"AS IS\\\" BASIS, # WITHOUT WARRANTIES OR CONDITIONS\",\n \"@add_start_docstrings_to_model_forward(HUBERT_INPUTS_DOCSTRING) @replace_return_docstrings(output_type=TFBaseModelOutput, config_class=_CONFIG_FOR_DOC) def call( self, input_values: tf.Tensor, attention_mask: Optional[tf.Tensor] = None, token_type_ids:\",\n \"inputs_embeds=inputs_embeds, output_attentions=output_attentions, output_hidden_states=output_hidden_states, return_dict=return_dict, training=training, kwargs_call=kwargs, ) hidden_states = self.feature_extractor( tf.cast(inputs[\\\"input_values\\\"], tf.float32), training=inputs[\\\"training\\\"]\",\n \"else 1 self.out_conv_dim = config.conv_dim[layer_id] self.conv = tf.keras.layers.Conv1D( filters=self.out_conv_dim, kernel_size=config.conv_kernel[layer_id], strides=config.conv_stride[layer_id], use_bias=config.conv_bias, name=\\\"conv\\\",\",\n \"or `tf.Tensor` of shape `({0}, hidden_size)`, *optional*): Optionally, instead of passing `input_values` you\",\n \"there are three possibilities you can use to gather all the input Tensors\",\n \"self.masked_spec_embed[tf.newaxis, tf.newaxis, :], hidden_states, ) elif self.config.mask_time_prob > 0: # generate indices &\",\n \"input_values = processor(ds[\\\"speech\\\"][0], return_tensors=\\\"tf\\\").input_values # Batch size 1 >>> hidden_states = model(input_values).last_hidden_state ```\\\"\\\"\\\"\",\n \"hidden_states = self.dropout(hidden_states, training=training) return hidden_states # Copied from transformers.models.bart.modeling_tf_bart.TFBartAttention with TFBart->TFHubert class\",\n \"normalized_inputs def _get_reshaped_weights(self, input_shape): broadcast_shape = self._create_broadcast_shape(input_shape) gamma = None beta = None\",\n \"which currently requires having all the tensors in the first argument of the\",\n \"= tf.keras.layers.LayerNormalization(epsilon=config.layer_norm_eps, name=\\\"layer_norm\\\") self.feed_forward = TFHubertFeedForward(config, name=\\\"feed_forward\\\") self.final_layer_norm = tf.keras.layers.LayerNormalization( epsilon=config.layer_norm_eps, name=\\\"final_layer_norm\\\" )\",\n \"token_type_ids=inputs[\\\"token_type_ids\\\"], position_ids=inputs[\\\"position_ids\\\"], head_mask=inputs[\\\"head_mask\\\"], inputs_embeds=inputs[\\\"inputs_embeds\\\"], output_attentions=inputs[\\\"output_attentions\\\"], output_hidden_states=inputs[\\\"output_hidden_states\\\"], return_dict=inputs[\\\"return_dict\\\"], training=inputs[\\\"training\\\"], ) return outputs def serving_output(self,\",\n \"0 def call(self, hidden_states): if self.num_pad_remove > 0: hidden_states = hidden_states[:, : -self.num_pad_remove,\",\n \"-> tf.Tensor: hidden_states = self.intermediate_dense(hidden_states) hidden_states = self.intermediate_act_fn(hidden_states) hidden_states = self.intermediate_dropout(hidden_states, training=training) hidden_states\",\n \"or several input Tensors associated to the input names given in the docstring:\",\n \"inputs, group_shape def _apply_normalization(self, reshaped_inputs, input_shape): group_shape = tf.keras.backend.int_shape(reshaped_inputs) group_reduction_axes = list(range(1, len(group_shape)))\",\n \"# if key_value_states are provided this layer is used as a cross-attention layer\",\n \"= tf.reshape(self._shape(query_states, tgt_len, bsz), proj_shape) key_states = tf.reshape(key_states, proj_shape) value_states = tf.reshape(value_states, proj_shape)\",\n \"gamma = None beta = None if self.scale: gamma = tf.reshape(self.gamma, broadcast_shape) if\",\n \"{k} does not belongs to the parameter list {parameter_names} and will be ignored.\\\"\",\n \"[`~file_utils.ModelOutput`] instead of a plain tuple. This argument can be used in eager\",\n \"+ 1, name=f\\\"conv_layers.{i+1}\\\") for i in range(config.num_feat_extract_layers - 1) ] elif config.feat_extract_norm ==\",\n \"tf.reduce_max(labels) >= self.config.vocab_size: raise ValueError(f\\\"Label values must be <= vocab_size: {self.config.vocab_size}\\\") attention_mask =\",\n \"0 else 0 def call(self, hidden_states): if self.num_pad_remove > 0: hidden_states = hidden_states[:,\",\n \"or - having all inputs as a list, tuple or dict in the\",\n \"self.hubert( input_values=inputs[\\\"input_values\\\"], attention_mask=inputs[\\\"attention_mask\\\"], token_type_ids=inputs[\\\"token_type_ids\\\"], position_ids=inputs[\\\"position_ids\\\"], head_mask=inputs[\\\"head_mask\\\"], inputs_embeds=inputs[\\\"inputs_embeds\\\"], output_attentions=inputs[\\\"output_attentions\\\"], output_hidden_states=inputs[\\\"output_hidden_states\\\"], return_dict=inputs[\\\"return_dict\\\"], training=inputs[\\\"training\\\"], ) hidden_states\",\n \"feature axis according to [SpecAugment](https://arxiv.org/abs/1904.08779). \\\"\\\"\\\" batch_size, sequence_length, hidden_size = shape_list(hidden_states) # `config.apply_spec_augment`\",\n \"1D convolutional layer output length formula taken # from https://pytorch.org/docs/stable/generated/torch.nn.Conv1d.html return (input_length -\",\n \"self.num_heads, tgt_len, self.head_dim)), (0, 2, 1, 3) ) attn_output = tf.reshape(attn_output, (bsz, tgt_len,\",\n \"(like PyTorch models), or - having all inputs as a list, tuple or\",\n \"TFHubert Model transformer outputing raw hidden-states without any specific head on top.\\\", HUBERT_START_DOCSTRING,\",\n \"else: raise ValueError( f\\\"Data of type {type(input_values)} is not allowed only {allowed_types} is\",\n \"train/fine-tine this model, you need a GPU or a TPU\\\" ) @tf.function def\",\n \"= tf.reshape(self.beta, broadcast_shape) return gamma, beta def _check_if_input_shape_is_none(self, input_shape): dim = input_shape[self.axis] if\",\n \"modes than eager. if tf.executing_eagerly(): tf.debugging.assert_equal( shape_list(layer_head_mask), [self.num_heads], message=f\\\"Head mask for a single\",\n \"attention_mask = tf.cast(attention_mask, dtype=attn_weights.dtype) attn_weights = tf.reshape(attn_weights, (bsz, self.num_heads, tgt_len, src_len)) + attention_mask\",\n \"the first parameter, then `input_values` output[\\\"input_values\\\"] = output[\\\"args\\\"] del output[\\\"args\\\"] if \\\"kwargs\\\" in\",\n \"Optional[int] = None, past_key_values_length: int = 0): \\\"\\\"\\\" Expands attention_mask from `[bsz, seq_len]`\",\n \"Unless required by applicable law or agreed to in writing, software # distributed\",\n \"-1 if self.axis == -1 else self.axis - 1 group_reduction_axes.pop(axis) mean, variance =\",\n \"None attns = tf.convert_to_tensor(output.attentions) if self.config.output_attentions else None return TFBaseModelOutput(last_hidden_state=output.last_hidden_state, hidden_states=hs, attentions=attns) @add_start_docstrings(\",\n \"= TFHubertEncoderStableLayerNorm(config, name=\\\"encoder\\\") else: self.encoder = TFHubertEncoder(config, name=\\\"encoder\\\") def build(self, input_shape: tf.TensorShape): self.masked_spec_embed\",\n \"its model (such as downloading or saving, resizing the input embeddings, pruning heads\",\n \"self._check_axis() def build(self, input_shape): self._check_if_input_shape_is_none(input_shape) self._set_number_of_groups_for_instance_norm(input_shape) self._check_size_of_dimensions(input_shape) self._create_input_spec(input_shape) self._add_gamma_weight(input_shape) self._add_beta_weight(input_shape) self.built = True\",\n \"to compute masks. should be of size 2 where first element is batch\",\n \"embed_dim // num_heads if (self.head_dim * num_heads) != self.embed_dim: raise ValueError( f\\\"embed_dim must\",\n \"self.final_layer_norm = tf.keras.layers.LayerNormalization( epsilon=config.layer_norm_eps, name=\\\"final_layer_norm\\\" ) def call( self, hidden_states: tf.Tensor, attention_mask: Optional[tf.Tensor]\",\n \"self.explicit_padding), (0, 0))) output = super().call(padded_inputs) return output # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2NoLayerNormConvLayer with\",\n \"pretrained models. \\\"\\\"\\\" config_class = HubertConfig base_model_prefix = \\\"hubert\\\" main_input_name = \\\"input_values\\\" @property\",\n \"= self.dropout(hidden_states, training=training) return hidden_states # Copied from transformers.models.bart.modeling_tf_bart.TFBartAttention with TFBart->TFHubert class TFHubertAttention(tf.keras.layers.Layer):\",\n \"Tuple[tf.Tensor]: attn_residual = hidden_states hidden_states = self.layer_norm(hidden_states) hidden_states, attn_weights, _ = self.attention( hidden_states,\",\n \"see https://github.com/tensorflow/tensorflow/issues/9260 for more info \\\"\\\"\\\" z = -tf.math.log(tf.random.uniform(shape_list(distribution), 0, 1)) _, indices\",\n \"tf.newaxis, :], hidden_states, 0) return hidden_states def call( self, input_values: tf.Tensor, attention_mask: Optional[tf.Tensor]\",\n \"but is {shape_list(layer_head_mask)}\\\", ) attn_weights = tf.reshape(layer_head_mask, (1, -1, 1, 1)) * tf.reshape(\",\n \"*optional*): Whether or not to return the hidden states of all layers. See\",\n \"shape_list(key_states)[1] attn_weights = tf.matmul(query_states, key_states, transpose_b=True) # The tf.debugging asserts are not compliant\",\n \"bool = False) -> tf.Tensor: hidden_states = self.layer_norm(hidden_states) hidden_states = self.projection(hidden_states) hidden_states =\",\n \"if self.config.ctc_loss_reduction == \\\"mean\\\": loss = tf.reduce_mean(loss) else: loss = None if not\",\n \"tgt_len is not None else src_len one_cst = tf.constant(1.0) mask = tf.cast(mask, dtype=one_cst.dtype)\",\n \"will be multiplied by number of timesteps divided by length of mask span\",\n \"training and (dropout_probability < self.config.layerdrop): # skip the layer continue layer_outputs = layer_module(\",\n \"= [ TFHubertLayerNormConvLayer(config, layer_id=i, name=f\\\"conv_layers.{i}\\\") for i in range(config.num_feat_extract_layers) ] else: raise ValueError(\",\n \"class TFHubertGroupNorm(tf.keras.layers.Layer): \\\"\\\"\\\" From tensorflow-addons https://www.tensorflow.org/addons/api_docs/python/tfa/layers/GroupNormalization \\\"\\\"\\\" def __init__( self, groups: int =\",\n \"Channel\\\"\\\"\\\" # if key_value_states are provided this layer is used as a cross-attention\",\n \"0: mask_feature_indices = _compute_mask_indices( (batch_size, hidden_size), mask_prob=self.config.mask_feature_prob, mask_length=self.config.mask_feature_length, ) hidden_states = tf.where(mask_feature_indices[:, tf.newaxis,\",\n \"model's internal embedding lookup matrix. output_attentions (`bool`, *optional*): Whether or not to return\",\n \"compute real output lengths according to convolution formula output_lengths = self._get_feat_extract_output_lengths(tf.reduce_sum(inputs[\\\"attention_mask\\\"], -1)) attention_mask\",\n \"more control over how to convert `input_values` indices into associated vectors than the\",\n \"otherwise the order of the tensors will not be guaranteed during the training.\",\n \"raise ValueError( f\\\"`mask_length` has to be smaller than `sequence_length`, but got `mask_length`: {mask_length}\",\n \"tf.keras.initializers.get(gamma_initializer) self.beta_regularizer = tf.keras.regularizers.get(beta_regularizer) self.gamma_regularizer = tf.keras.regularizers.get(gamma_regularizer) self.beta_constraint = tf.keras.constraints.get(beta_constraint) self.gamma_constraint = tf.keras.constraints.get(gamma_constraint)\",\n \"if not is_instance_norm: group_shape[self.axis] = input_shape[self.axis] // self.groups group_shape.insert(self.axis, self.groups) group_shape = tf.stack(group_shape)\",\n \"TFHubertSamePadLayer(config.num_conv_pos_embeddings) self.activation = get_tf_activation(config.feat_extract_activation) def call(self, hidden_states: tf.Tensor) -> tf.Tensor: hidden_states = self.conv(hidden_states)\",\n \"equivalent `freeze_feature_encoder` method instead.\\\", FutureWarning, ) self.freeze_feature_encoder() def freeze_feature_encoder(self): \\\"\\\"\\\" Calling this function\",\n \"of shape `(num_heads,)` or `(num_layers, num_heads)`, *optional*): Mask to nullify selected heads of\",\n \"spans Adapted from [fairseq's data_utils.py](https://github.com/pytorch/fairseq/blob/e0788f7007a8473a76db573985031f3c94201e79/fairseq/data/data_utils.py#L376). \\\"\\\"\\\" batch_size, sequence_length = shape if mask_length <\",\n \"None, **kwargs, ): super().__init__(**kwargs) self.supports_masking = True self.groups = groups self.axis = axis\",\n \"usage and behavior. <Tip> TF 2.0 models accepts two formats as inputs: -\",\n \"graph mode the value will always be set to True. training (`bool`, *optional*,\",\n \"True super().build(input_shape) def call(self, inputs): input_shape = tf.keras.backend.int_shape(inputs) tensor_input_shape = tf.shape(inputs) reshaped_inputs, group_shape\",\n \">>> import soundfile as sf >>> processor = Wav2Vec2Processor.from_pretrained(\\\"facebook/hubert-base-960h\\\") >>> model = TFHubertModel.from_pretrained(\\\"facebook/hubert-base-960h\\\")\",\n \"self.layer = [ TFHubertEncoderLayerStableLayerNorm(config, name=f\\\"layers.{i}\\\") for i in range(config.num_hidden_layers) ] def call( self,\",\n \"each token to be chosen as start of the span to be masked.\",\n \"name=\\\"hubert\\\") self.dropout = tf.keras.layers.Dropout(config.final_dropout) self.lm_head = tf.keras.layers.Dense(config.vocab_size, name=\\\"lm_head\\\") def freeze_feature_extractor(self): \\\"\\\"\\\" Calling this\",\n \"min_masks: int = 0, ) -> tf.Tensor: \\\"\\\"\\\" Computes random mask spans for\",\n \"from, make sure that offset samples are < sequence_length uniform_dist = tf.ones((batch_size, sequence_length\",\n \"output[parameter_names[i]] = input else: raise ValueError( f\\\"Data of type {type(input)} is not allowed\",\n \"attn_output = tf.matmul(attn_probs, value_states) # The tf.debugging asserts are not compliant with XLA\",\n \"config: HubertConfig, **kwargs): super().__init__(**kwargs) self.config = config self.feature_extractor = TFHubertFeatureEncoder(config, name=\\\"feature_extractor\\\") self.feature_projection =\",\n \"= self.intermediate_dropout(hidden_states, training=training) hidden_states = self.output_dense(hidden_states) hidden_states = self.output_dropout(hidden_states, training=training) return hidden_states #\",\n \"a [`~file_utils.ModelOutput`] instead of a plain tuple. This argument can be used in\",\n \"\\\"\\\"\\\" batch_size, sequence_length = shape if mask_length < 1: raise ValueError(\\\"`mask_length` has to\",\n \"hidden_states hidden_states = hidden_states + self.feed_forward(self.final_layer_norm(hidden_states)) outputs = (hidden_states,) if output_attentions: outputs +=\",\n \"attention_mask=inputs[\\\"attention_mask\\\"], token_type_ids=inputs[\\\"token_type_ids\\\"], position_ids=inputs[\\\"position_ids\\\"], head_mask=inputs[\\\"head_mask\\\"], inputs_embeds=inputs[\\\"inputs_embeds\\\"], output_attentions=inputs[\\\"output_attentions\\\"], output_hidden_states=inputs[\\\"output_hidden_states\\\"], return_dict=inputs[\\\"return_dict\\\"], training=inputs[\\\"training\\\"], ) return outputs def\",\n \"be ignored.\\\" ) continue else: raise ValueError(f\\\"Data of type {type(v)} is not allowed\",\n \"self-attention modules. Mask values selected in `[0, 1]`: - 1 indicates the head\",\n \"# Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2._scatter_values_on_batch_indices def _scatter_values_on_batch_indices(values, batch_indices, output_shape): \\\"\\\"\\\" Scatter function as in\",\n \"the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law\",\n \"-1])], 0)) # scatter values to pair indices return tf.scatter_nd(pair_indices, tf.reshape(values, [-1]), output_shape)\",\n \"1)) * tf.reshape( attn_weights, (bsz, self.num_heads, tgt_len, src_len) ) attn_weights = tf.reshape(attn_weights, (bsz\",\n \"self, groups: int = 32, axis: int = -1, epsilon: float = 1e-3,\",\n \"value proj if is_cross_attention and past_key_value is not None: # reuse k,v, cross_attentions\",\n \"one for the missing layers, and another one for the unexpected layers. \\\"\\\"\\\"\",\n \"**kwargs: Any, ): inputs = input_values_processing( func=self.call, config=self.config, input_values=input_values, attention_mask=attention_mask, token_type_ids=token_type_ids, position_ids=position_ids, head_mask=head_mask,\",\n \"beta = None if self.scale: gamma = tf.reshape(self.gamma, broadcast_shape) if self.center: beta =\",\n \":] return hidden_states class TFHubertFeatureEncoder(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs: Any) -> None:\",\n \"= None, output_hidden_states: Optional[tf.Tensor] = None, return_dict: Optional[bool] = None, training: bool =\",\n \"range(config.num_hidden_layers) ] def call( self, hidden_states: tf.Tensor, attention_mask: Optional[tf.Tensor] = None, output_attentions: Optional[bool]\",\n \"is {shape_list(layer_head_mask)}\\\", ) attn_weights = tf.reshape(layer_head_mask, (1, -1, 1, 1)) * tf.reshape( attn_weights,\",\n \"\\\").\\\" ) def _check_axis(self): if self.axis == 0: raise ValueError( \\\"You are trying\",\n \"from datasets import load_dataset >>> import soundfile as sf >>> processor = Wav2Vec2Processor.from_pretrained(\\\"facebook/hubert-base-960h\\\")\",\n \"= None, layer_head_mask: Optional[tf.Tensor] = None, training: Optional[bool] = False, ) -> Tuple[tf.Tensor,\",\n \"hidden_states = self.intermediate_dropout(hidden_states, training=training) hidden_states = self.output_dense(hidden_states) hidden_states = self.output_dropout(hidden_states, training=training) return hidden_states\",\n \"-tf.math.log(tf.random.uniform(shape_list(distribution), 0, 1)) _, indices = tf.nn.top_k(distribution + z, num_samples) return indices #\",\n \"Is All You Need\\\"\\\"\\\" def __init__( self, embed_dim: int, num_heads: int, dropout: float\",\n \"be set to True. training (`bool`, *optional*, defaults to `False``): Whether or not\",\n \"padding input_shape[-2] += self.explicit_padding * 2 super().build(input_shape) self.kernel = tf.Variable(tf.transpose(self.kernel), name=\\\"weight_v\\\", trainable=True) self.weight_v\",\n \"sampling without replacement is currently not implemented. The gumbel-max trick will do for\",\n \"return input_shape def _reshape_into_groups(self, inputs, input_shape, tensor_input_shape): group_shape = [tensor_input_shape[i] for i in\",\n \"from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2Encoder with Wav2Vec2->Hubert class TFHubertEncoder(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs): super().__init__(**kwargs) self.config\",\n \"scatter indices to mask spec_aug_mask = _scatter_values_on_batch_indices( tf.ones_like(spec_aug_mask_idxs), spec_aug_mask_idxs, spec_aug_mask.shape ) return spec_aug_mask\",\n \"= load_dataset(\\\"hf-internal-testing/librispeech_asr_dummy\\\", \\\"clean\\\", split=\\\"validation\\\") >>> ds = ds.map(map_to_array) >>> input_values = processor(ds[\\\"speech\\\"][0], return_tensors=\\\"tf\\\").input_values\",\n \"the model, only the configuration. Check out the [`~PreTrainedModel.from_pretrained`] method to load the\",\n \"and will be removed in Transformers v5.\\\" \\\"Please use the equivalent `freeze_feature_encoder` method\",\n \"layer should be of size {(self.num_heads)}, but is {shape_list(layer_head_mask)}\\\", ) attn_weights = tf.reshape(layer_head_mask,\",\n \"\\\"\\\"\\\" warnings.warn( \\\"The method `freeze_feature_extractor` is deprecated and will be removed in Transformers\",\n \"specific language governing permissions and # limitations under the License. \\\"\\\"\\\" TensorFlow Hubert\",\n \"will be ignored.\\\" ) continue else: raise ValueError(f\\\"Data of type {type(v)} is not\",\n \"will always be set to True. training (`bool`, *optional*, defaults to `False``): Whether\",\n \"self.center, \\\"scale\\\": self.scale, \\\"beta_initializer\\\": tf.keras.initializers.serialize(self.beta_initializer), \\\"gamma_initializer\\\": tf.keras.initializers.serialize(self.gamma_initializer), \\\"beta_regularizer\\\": tf.keras.regularizers.serialize(self.beta_regularizer), \\\"gamma_regularizer\\\": tf.keras.regularizers.serialize(self.gamma_regularizer), \\\"beta_constraint\\\": tf.keras.constraints.serialize(self.beta_constraint),\",\n \"False, ) -> Tuple[tf.Tensor, Optional[tf.Tensor]]: \\\"\\\"\\\"Input shape: Batch x Time x Channel\\\"\\\"\\\" #\",\n \"model(input_values, labels=labels).loss ```\\\"\\\"\\\" inputs = input_values_processing( func=self.call, config=self.config, input_values=input_values, attention_mask=attention_mask, token_type_ids=token_type_ids, position_ids=position_ids, head_mask=head_mask,\",\n \"hidden_states: tf.Tensor, training: bool = False) -> tf.Tensor: hidden_states = self.intermediate_dense(hidden_states) hidden_states =\",\n \"self.feed_forward = TFHubertFeedForward(config, name=\\\"feed_forward\\\") self.final_layer_norm = tf.keras.layers.LayerNormalization( epsilon=config.layer_norm_eps, name=\\\"final_layer_norm\\\" ) def call( self,\",\n \"tf.reshape(spec_aug_mask_idxs, (batch_size, num_masked_spans * mask_length)) offsets = tf.range(mask_length)[tf.newaxis, tf.newaxis, :] offsets = tf.tile(offsets,\",\n \"keepdims=True) gamma, beta = self._get_reshaped_weights(input_shape) normalized_inputs = tf.nn.batch_normalization( reshaped_inputs, mean=mean, variance=variance, scale=gamma, offset=beta,\",\n \"masks. should be of size 2 where first element is batch size and\",\n \"*sentence B* token. [What are token type IDs?](../glossary#token-type-ids) position_ids (`np.ndarray` or `tf.Tensor` of\",\n \"= \\\"zeros\\\", gamma_initializer: tf.keras.initializers.Initializer = \\\"ones\\\", beta_regularizer: tf.keras.regularizers.Regularizer = None, gamma_regularizer: tf.keras.regularizers.Regularizer =\",\n \"broadcast_shape[self.axis] = input_shape[self.axis] // self.groups broadcast_shape.insert(self.axis, self.groups) else: broadcast_shape[self.axis] = self.groups return broadcast_shape\",\n \"call(self, hidden_states: tf.Tensor) -> tf.Tensor: hidden_states = self.conv(hidden_states) hidden_states = self.layer_norm(hidden_states) hidden_states =\",\n \"1: raise ValueError(\\\"`mask_length` has to be bigger than 0.\\\") if mask_length > sequence_length:\",\n \"dictionary with one or several input Tensors associated to the input names given\",\n \"input_shape.as_list() # Conv1D output shapes are checked at build time since TF 2.7,\",\n \"_sample_without_replacement(distribution, num_samples): \\\"\\\"\\\" Categorical sampling without replacement is currently not implemented. The gumbel-max\",\n \"_ = sf.read(batch[\\\"file\\\"]) ... batch[\\\"speech\\\"] = speech ... return batch >>> ds =\",\n \"TFHubertEncoder(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs): super().__init__(**kwargs) self.config = config self.pos_conv_embed = TFHubertPositionalConvEmbedding(config,\",\n \"the TensorFlow model. config ([`PretrainedConfig`]): The config of the running model. **kwargs: The\",\n \") elif self.config.mask_time_prob > 0: # generate indices & apply SpecAugment along time\",\n \"f\\\"\\\\n{self.__class__.__name__} has backpropagation operations that are NOT supported on CPU. If you wish\",\n \"\\\"use tf.layer.batch_normalization instead\\\" ) def _create_input_spec(self, input_shape): dim = input_shape[self.axis] self.input_spec = tf.keras.layers.InputSpec(ndim=len(input_shape),\",\n \"formats as inputs: - having all inputs as keyword arguments (like PyTorch models),\",\n \"distributed on an \\\"AS IS\\\" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY\",\n \"or several input Tensors IN THE ORDER given in the docstring: `model([input_values, attention_mask])`\",\n \"sample from, make sure that offset samples are < sequence_length uniform_dist = tf.ones((batch_size,\",\n \"or `model([input_values, attention_mask, token_type_ids])` - a dictionary with one or several input Tensors\",\n \"be of size {(bsz, 1, tgt_len, src_len)}, but is {shape_list(attention_mask)}\\\", ) attention_mask =\",\n \"of shape `({0})`, *optional*): Mask to avoid performing attention on padding token indices.\",\n \"= tf.keras.layers.Dense(config.vocab_size, name=\\\"lm_head\\\") def freeze_feature_extractor(self): \\\"\\\"\\\" Calling this function will disable the gradient\",\n \"= input_values.pop(\\\"decoder_cached_states\\\") for k, v in dict(input_values).items(): if isinstance(v, allowed_types) or v is\",\n \"name=\\\"layer_norm\\\") self.dropout = tf.keras.layers.Dropout(config.hidden_dropout) self.layer = [ TFHubertEncoderLayerStableLayerNorm(config, name=f\\\"layers.{i}\\\") for i in range(config.num_hidden_layers)\",\n \"\\\"layer\\\": conv_layers = [ TFHubertLayerNormConvLayer(config, layer_id=i, name=f\\\"conv_layers.{i}\\\") for i in range(config.num_feat_extract_layers) ] else:\",\n \"disabled in other modes than eager. if tf.executing_eagerly(): tf.debugging.assert_equal( shape_list(layer_head_mask), [self.num_heads], message=f\\\"Head mask\",\n \"self.encoder( hidden_states, attention_mask=attention_mask, output_attentions=inputs[\\\"output_attentions\\\"], output_hidden_states=inputs[\\\"output_hidden_states\\\"], return_dict=inputs[\\\"return_dict\\\"], training=inputs[\\\"training\\\"], ) hidden_states = encoder_outputs[0] if not\",\n \"of groups (\\\" + str(self.groups) + \\\") must be a \\\" \\\"multiple of\",\n \"= self.intermediate_dense(hidden_states) hidden_states = self.intermediate_act_fn(hidden_states) hidden_states = self.intermediate_dropout(hidden_states, training=training) hidden_states = self.output_dense(hidden_states) hidden_states\",\n \"target_transcription = \\\"A MAN SAID TO THE UNIVERSE SIR I EXIST\\\" >>> #\",\n \"be a \\\" \\\"multiple of the number of channels (\\\" + str(dim) +\",\n \"labels: Optional[tf.Tensor] = None, output_hidden_states: Optional[bool] = None, return_dict: Optional[bool] = None, training:\",\n \"padded elements mask_prob: probability for each token to be chosen as start of\",\n \"be used instead. return_dict (`bool`, *optional*): Whether or not to return a [`~file_utils.ModelOutput`]\",\n \"attention_mask=attention_mask, token_type_ids=token_type_ids, position_ids=position_ids, head_mask=head_mask, inputs_embeds=inputs_embeds, output_attentions=output_attentions, output_hidden_states=output_hidden_states, return_dict=return_dict, training=training, ) inputs[\\\"output_hidden_states\\\"] = (\",\n \"timesteps divided by length of mask span to mask approximately this percentage of\",\n \"mask_length)) spec_aug_mask_idxs = spec_aug_mask_idxs + offsets # scatter indices to mask spec_aug_mask =\",\n \") input_lengths = self.hubert._get_feat_extract_output_lengths(tf.reduce_sum(attention_mask, axis=-1)) # assuming that padded tokens are filled with\",\n \"input_shape[self.axis] // self.groups broadcast_shape.insert(self.axis, self.groups) else: broadcast_shape[self.axis] = self.groups return broadcast_shape # Copied\",\n \"= (input_shape[self.axis] // self.groups) == 1 if not is_instance_norm: group_shape[self.axis] = input_shape[self.axis] //\",\n \"self.add_weight(name=\\\"bias\\\", shape=(self.filters,), initializer=\\\"zeros\\\", trainable=True) def call(self, inputs): if not self.initialized: self._init_norm() self.initialized =\",\n \"= { k: v for k, v in output.items() if k in [\\\"return_dict\\\",\",\n \"tf.keras.layers.LayerNormalization(name=\\\"layer_norm\\\", epsilon=config.layer_norm_eps) self.activation = get_tf_activation(config.feat_extract_activation) def call(self, hidden_states: tf.Tensor) -> tf.Tensor: hidden_states =\",\n \"self.padding(hidden_states) hidden_states = self.activation(hidden_states) return hidden_states # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2SamePadLayer with Wav2Vec2->Hubert class\",\n \"to in writing, software # distributed under the License is distributed on an\",\n \"the mask min_masks: minimum number of masked spans Adapted from [fairseq's data_utils.py](https://github.com/pytorch/fairseq/blob/e0788f7007a8473a76db573985031f3c94201e79/fairseq/data/data_utils.py#L376). \\\"\\\"\\\"\",\n \"is_instance_norm: axis = -2 if self.axis == -1 else self.axis - 1 else:\",\n \"warnings from typing import Any, Dict, Optional, Tuple, Union import numpy as np\",\n \"tf.reshape(normalized_inputs, tensor_input_shape) else: outputs = normalized_inputs return outputs def get_config(self): config = {\",\n \"size {(bsz, self.num_heads, tgt_len, self.head_dim)}, but is {shape_list(attn_output)}\\\", ) attn_output = tf.transpose( tf.reshape(attn_output,\",\n \"in this case is always the first parameter, then `input_values` output[\\\"input_values\\\"] = output[\\\"args\\\"]\",\n \"..., config.vocab_size]` (see `input_values` docstring) Tokens with indices set to `-100` are ignored\",\n \"if tgt_len is not None else src_len one_cst = tf.constant(1.0) mask = tf.cast(mask,\",\n \"TFHubertMainLayer(config, name=\\\"hubert\\\") @add_start_docstrings_to_model_forward(HUBERT_INPUTS_DOCSTRING) @replace_return_docstrings(output_type=TFBaseModelOutput, config_class=_CONFIG_FOR_DOC) def call( self, input_values: tf.Tensor, attention_mask: Optional[tf.Tensor] =\",\n \"transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2GroupNorm with Wav2Vec2->Hubert class TFHubertGroupNorm(tf.keras.layers.Layer): \\\"\\\"\\\" From tensorflow-addons https://www.tensorflow.org/addons/api_docs/python/tfa/layers/GroupNormalization \\\"\\\"\\\" def __init__( self,\",\n \"\\\"args\\\" in output: if output[\\\"args\\\"] is not None and type(output[\\\"args\\\"]) == tf.Tensor: tensor_name\",\n \"-1) for conv_layer in self.conv_layers: hidden_states = conv_layer(hidden_states) return hidden_states class TFHubertFeatureExtractor(TFHubertFeatureEncoder): def\",\n \"as sf >>> processor = Wav2Vec2Processor.from_pretrained(\\\"facebook/hubert-base-960h\\\") >>> model = TFHubertForCTC.from_pretrained(\\\"facebook/hubert-base-960h\\\") >>> def map_to_array(batch):\",\n \"to use the .name property so we check for a real Tensor if\",\n \"a single layer should be of size {(self.num_heads)}, but is {shape_list(layer_head_mask)}\\\", ) attn_weights\",\n \"= self.pos_conv_embed(hidden_states) hidden_states = hidden_states + position_embeddings hidden_states = self.layer_norm(hidden_states) hidden_states = self.dropout(hidden_states,\",\n \"tf.keras.constraints.get(beta_constraint) self.gamma_constraint = tf.keras.constraints.get(gamma_constraint) self._check_axis() def build(self, input_shape): self._check_if_input_shape_is_none(input_shape) self._set_number_of_groups_for_instance_norm(input_shape) self._check_size_of_dimensions(input_shape) self._create_input_spec(input_shape) self._add_gamma_weight(input_shape)\",\n \"Apache License, Version 2.0 (the \\\"License\\\"); # you may not use this file\",\n \"Initializing with a config file does not load the weights associated with the\",\n \"shape_list(hidden_states) # get query proj query_states = self.q_proj(hidden_states) * self.scaling # get key,\",\n \"logger.warning( f\\\"\\\\n{self.__class__.__name__} has backpropagation operations that are NOT supported on CPU. If you\",\n \"the License is distributed on an \\\"AS IS\\\" BASIS, # WITHOUT WARRANTIES OR\",\n \"is_cross_attention = key_value_states is not None bsz, tgt_len, embed_dim = shape_list(hidden_states) # get\",\n \"= all_hidden_states + (hidden_states,) # add LayerDrop (see https://arxiv.org/abs/1909.11556 for description) dropout_probability =\",\n \"is not None: # reuse k, v, self_attention key_states = self._shape(self.k_proj(hidden_states), -1, bsz)\",\n \"= -2 if self.axis == -1 else self.axis - 1 else: axis =\",\n \"get_tf_activation from ...modeling_tf_outputs import TFBaseModelOutput, TFCausalLMOutput from ...modeling_tf_utils import TFPreTrainedModel, booleans_processing, get_initializer, keras_serializable\",\n \"to be named accordingly to the parameters name, i.e. `input_values = tf.keras.Input(shape=(128,), dtype='float32',\",\n \"you may not use this file except in compliance with the License. #\",\n \"transformers.models.wav2vec2.modeling_tf_wav2vec2.input_values_processing def input_values_processing(func, config, input_values, **kwargs): \\\"\\\"\\\" Process the input of each TensorFlow\",\n \"the weights associated with the model, only the configuration. Check out the [`~PreTrainedModel.from_pretrained`]\",\n \"tf.keras.initializers.get(beta_initializer) self.gamma_initializer = tf.keras.initializers.get(gamma_initializer) self.beta_regularizer = tf.keras.regularizers.get(beta_regularizer) self.gamma_regularizer = tf.keras.regularizers.get(gamma_regularizer) self.beta_constraint = tf.keras.constraints.get(beta_constraint)\",\n \"== \\\"group\\\": conv_layers = [TFHubertGroupNormConvLayer(config, layer_id=0, name=f\\\"conv_layers.{0}\\\")] + [ TFHubertNoLayerNormConvLayer(config, layer_id=i + 1,\",\n \"training: Optional[bool] = False, ) -> Union[TFCausalLMOutput, Tuple[tf.Tensor]]: r\\\"\\\"\\\" labels (`tf.Tensor` or `np.ndarray`\",\n \"TFHubertPreTrainedModel(TFPreTrainedModel): \\\"\\\"\\\" An abstract class to handle weights initialization and a simple interface\",\n \"tf.keras.constraints.get(gamma_constraint) self._check_axis() def build(self, input_shape): self._check_if_input_shape_is_none(input_shape) self._set_number_of_groups_for_instance_norm(input_shape) self._check_size_of_dimensions(input_shape) self._create_input_spec(input_shape) self._add_gamma_weight(input_shape) self._add_beta_weight(input_shape) self.built =\",\n \"= (tf.Tensor, bool, int, ModelOutput, tuple, list, dict, np.ndarray) for k, v in\",\n \"= None, training: bool = False, **kwargs: Any, ): inputs = input_values_processing( func=self.call,\",\n \"config.max_position_embeddings - 1]`. [What are position IDs?](../glossary#position-ids) head_mask (`np.ndarray` or `tf.Tensor` of shape\",\n \"32, axis: int = -1, epsilon: float = 1e-3, center: bool = True,\",\n \"`model(inputs_ids)` - a list of varying length with one or several input Tensors\",\n \"is_instance_norm = (input_shape[self.axis] // self.groups) == 1 if not is_instance_norm: group_shape[self.axis] = input_shape[self.axis]\",\n \"__init__( self, embed_dim: int, num_heads: int, dropout: float = 0.0, is_decoder: bool =\",\n \"IDs?](../glossary#input-ids) attention_mask (`np.ndarray` or `tf.Tensor` of shape `({0})`, *optional*): Mask to avoid performing\",\n \"will disable the gradient computation for the feature encoder so that its parameter\",\n \"# Licensed under the Apache License, Version 2.0 (the \\\"License\\\"); # you may\",\n \"None return TFBaseModelOutput(last_hidden_state=output.last_hidden_state, hidden_states=hs, attentions=attns) @add_start_docstrings( \\\"\\\"\\\"TFHubert Model with a `language modeling` head\",\n \"self.encoder = TFHubertEncoder(config, name=\\\"encoder\\\") def build(self, input_shape: tf.TensorShape): self.masked_spec_embed = self.add_weight( shape=(self.config.hidden_size,), initializer=\\\"uniform\\\",\",\n \"all the tensors in the first argument of the model call function: `model(inputs)`.\",\n \"not to return the attentions tensors of all attention layers. See `attentions` under\",\n \"= tf.convert_to_tensor(np.random.rand(1, 16000), tf.float32) dummy_inputs = { \\\"input_values\\\": input_values, \\\"attention_mask\\\": tf.cast(tf.not_equal(input_values, pad_token), tf.float32),\",\n \"src_len)}, but is {shape_list(attention_mask)}\\\", ) attention_mask = tf.cast(attention_mask, dtype=attn_weights.dtype) attn_weights = tf.reshape(attn_weights, (bsz,\",\n \"*optional*): Indices of positions of each input sequence tokens in the position embeddings.\",\n \"normalized_inputs return outputs def get_config(self): config = { \\\"groups\\\": self.groups, \\\"axis\\\": self.axis, \\\"epsilon\\\":\",\n \"with Wav2Vec2->Hubert class TFHubertNoLayerNormConvLayer(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, layer_id: int = 0, **kwargs:\",\n \"as shape, which will prevent masking padded elements mask_prob: probability for each token\",\n \"logging.get_logger(__name__) _CONFIG_FOR_DOC = \\\"HubertConfig\\\" TF_HUBERT_PRETRAINED_MODEL_ARCHIVE_LIST = [ \\\"facebook/hubert-base-ls960\\\", # See all Hubert models\",\n \"_compute_mask_indices( (batch_size, hidden_size), mask_prob=self.config.mask_feature_prob, mask_length=self.config.mask_feature_length, ) hidden_states = tf.where(mask_feature_indices[:, tf.newaxis, :], hidden_states, 0)\",\n \"-> Union[TFCausalLMOutput, Tuple[tf.Tensor]]: r\\\"\\\"\\\" labels (`tf.Tensor` or `np.ndarray` of shape `(batch_size, sequence_length)`, *optional*):\",\n \"Computes the output length of the convolutional layers \\\"\\\"\\\" def _conv_out_length(input_length, kernel_size, stride):\",\n \"= False, output_hidden_states: Optional[bool] = False, return_dict: Optional[bool] = True, training: Optional[bool] =\",\n \"mean, variance = tf.nn.moments(reshaped_inputs, group_reduction_axes, keepdims=True) gamma, beta = self._get_reshaped_weights(input_shape) normalized_inputs = tf.nn.batch_normalization(\",\n \"sequence tokens in the position embeddings. Selected in the range `[0, config.max_position_embeddings -\",\n \"isinstance(v, allowed_types) or v is None: output[k] = v elif k not in\",\n \"that padded tokens are filled with -100 # when not being attended to\",\n \"= self.activation(hidden_states) return hidden_states # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2GroupNormConvLayer with Wav2Vec2->Hubert class TFHubertGroupNormConvLayer(tf.keras.layers.Layer): def\",\n \"list of symbolic inputs, each input has to be named accordingly to the\",\n \"selected in `[0, 1]`: - 1 indicates the head is **not masked**, -\",\n \"def _add_beta_weight(self, input_shape): dim = input_shape[self.axis] shape = (dim,) if self.center: self.beta =\",\n \"attention_mask = _expand_mask(attention_mask) else: attention_mask = None position_embeddings = self.pos_conv_embed(hidden_states) hidden_states = hidden_states\",\n \"however due to overlaps, the actual number will be smaller (unless no_overlap is\",\n \"= tf.keras.layers.InputSpec(ndim=len(input_shape), axes={self.axis: dim}) def _add_gamma_weight(self, input_shape): dim = input_shape[self.axis] shape = (dim,)\",\n \"Connectionist Temporal Classification (CTC).\\\"\\\"\\\", HUBERT_START_DOCSTRING, ) class TFHubertForCTC(TFHubertPreTrainedModel): def __init__(self, config: HubertConfig, *inputs,\",\n \"ValueError( \\\"Number of groups (\\\" + str(self.groups) + \\\") cannot be \\\" \\\"more\",\n \"we check for a real Tensor if type(input) == tf.Tensor: # Tensor names\",\n \"ValueError( \\\"You are trying to normalize your batch axis. Do you want to\",\n \"= input else: output[parameter_names[i]] = input elif isinstance(input, allowed_types) or input is None:\",\n \"* mask_length)) spec_aug_mask_idxs = spec_aug_mask_idxs + offsets # scatter indices to mask spec_aug_mask\",\n \"values selected in `[0, 1]`: - 1 indicates the head is **not masked**,\",\n \"if not return_dict: return tuple(v for v in [hidden_states, all_hidden_states, all_self_attentions] if v\",\n \"with indices in format (batch_dim, indixes) \\\"\\\"\\\" indices_shape = shape_list(batch_indices) # broadcast batch\",\n \"hs = tf.convert_to_tensor(output.hidden_states) if self.config.output_hidden_states else None attns = tf.convert_to_tensor(output.attentions) if self.config.output_attentions else\",\n \"def _expand_mask(mask: tf.Tensor, tgt_len: Optional[int] = None, past_key_values_length: int = 0): \\\"\\\"\\\" Expands\",\n \"= self.layer_norm(hidden_states) if output_hidden_states: all_hidden_states = all_hidden_states + (hidden_states,) if not return_dict: return\",\n \"numpy as np import tensorflow as tf from ...activations_tf import get_tf_activation from ...modeling_tf_outputs\",\n \"cross_attention layer can then reuse all cross-attention # key/value_states (first \\\"if\\\" case) #\",\n \"be removed in Transformers v5. \\\" f\\\"Use `{self.__class__.__bases__[0].__name__}` instead.\\\", FutureWarning, ) class TFHubertFeatureProjection(tf.keras.layers.Layer):\",\n \"general usage and behavior. <Tip> TF 2.0 models accepts two formats as inputs:\",\n \"ModelOutput, add_start_docstrings, add_start_docstrings_to_model_forward, logging, replace_return_docstrings, ) from .configuration_hubert import HubertConfig logger = logging.get_logger(__name__)\",\n \"kernel_norm = tf.sqrt(tf.reduce_sum(tf.square(self.weight_v), axis=self.kernel_norm_axes)) self.weight_g.assign(kernel_norm[:, tf.newaxis, tf.newaxis]) def _normalize_kernel(self): \\\"\\\"\\\"Generate normalized weights.\\\"\\\"\\\" kernel\",\n \"and `num_heads`: {num_heads}).\\\" ) self.scaling = self.head_dim**-0.5 self.is_decoder = is_decoder self.k_proj = tf.keras.layers.Dense(embed_dim,\",\n \"raise ValueError( f\\\"embed_dim must be divisible by num_heads (got `embed_dim`: {self.embed_dim}\\\" f\\\" and\",\n \"Indices are selected in `[0, 1]`: - 0 corresponds to a *sentence A*\",\n \"def _create_broadcast_shape(self, input_shape): broadcast_shape = [1] * len(input_shape) is_instance_norm = (input_shape[self.axis] // self.groups)\",\n \"Whether or not to return a [`~file_utils.ModelOutput`] instead of a plain tuple. This\",\n \"output = (logits,) + outputs[1:] return ((loss,) + output) if loss is not\",\n \"(batch_size, sequence_length), mask_prob=self.config.mask_time_prob, mask_length=self.config.mask_time_length, min_masks=2, ) hidden_states = tf.where( tf.cast(mask_time_indices[:, :, tf.newaxis], tf.bool),\",\n \"to account for padding input_shape[-2] += self.explicit_padding * 2 super().build(input_shape) self.kernel = tf.Variable(tf.transpose(self.kernel),\",\n \"@tf.function def serving(self, inputs): output = self.call(input_values=inputs, training=False) return self.serving_output(output) HUBERT_START_DOCSTRING = r\\\"\\\"\\\"\",\n \"dim % self.groups != 0: raise ValueError( \\\"Number of groups (\\\" + str(self.groups)\",\n \"= -1 if self.axis == -1 else self.axis - 1 group_reduction_axes.pop(axis) mean, variance\",\n \"transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2EncoderLayerStableLayerNorm with Wav2Vec2->Hubert class TFHubertEncoderLayerStableLayerNorm(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs): super().__init__(**kwargs) self.attention =\",\n \"TFBaseModelOutput( last_hidden_state=hidden_states, hidden_states=all_hidden_states, attentions=all_self_attentions, ) @keras_serializable class TFHubertMainLayer(tf.keras.layers.Layer): config_class = HubertConfig def __init__(self,\",\n \"input is None: output[parameter_names[i]] = input else: raise ValueError( f\\\"Data of type {type(input)}\",\n \"else: loss = None if not inputs[\\\"return_dict\\\"]: output = (logits,) + outputs[1:] return\",\n \"attn_weights = tf.reshape(layer_head_mask, (1, -1, 1, 1)) * tf.reshape( attn_weights, (bsz, self.num_heads, tgt_len,\",\n \"% 2 == 0 else 0 def call(self, hidden_states): if self.num_pad_remove > 0:\",\n \"HubertConfig, **kwargs): super().__init__(**kwargs) self.config = config self.pos_conv_embed = TFHubertPositionalConvEmbedding(config, name=\\\"pos_conv_embed\\\") self.layer_norm = tf.keras.layers.LayerNormalization(epsilon=config.layer_norm_eps,\",\n \"- 1]`. [What are position IDs?](../glossary#position-ids) head_mask (`np.ndarray` or `tf.Tensor` of shape `(num_heads,)`\",\n \">>> predicted_ids = tf.argmax(logits, axis=-1) >>> transcription = processor.decode(predicted_ids[0]) >>> # compute loss\",\n \"num_heads=config.num_attention_heads, dropout=config.attention_dropout, is_decoder=False, name=\\\"attention\\\", ) self.dropout = tf.keras.layers.Dropout(config.hidden_dropout) self.layer_norm = tf.keras.layers.LayerNormalization(epsilon=config.layer_norm_eps, name=\\\"layer_norm\\\") self.feed_forward\",\n \"missing layers, and another one for the unexpected layers. \\\"\\\"\\\" signature = dict(inspect.signature(func).parameters)\",\n \"This argument can be used in eager mode, in graph mode the value\",\n \"super().__init__(config, *inputs, **kwargs) self.config = config self.hubert = TFHubertMainLayer(config, name=\\\"hubert\\\") @add_start_docstrings_to_model_forward(HUBERT_INPUTS_DOCSTRING) @replace_return_docstrings(output_type=TFBaseModelOutput, config_class=_CONFIG_FOR_DOC)\",\n \"return_dict=return_dict, training=training, ) outputs = self.hubert( input_values=inputs[\\\"input_values\\\"], attention_mask=inputs[\\\"attention_mask\\\"], token_type_ids=inputs[\\\"token_type_ids\\\"], position_ids=inputs[\\\"position_ids\\\"], head_mask=inputs[\\\"head_mask\\\"], inputs_embeds=inputs[\\\"inputs_embeds\\\"], output_attentions=inputs[\\\"output_attentions\\\"],\",\n \"model.\\\"\\\"\\\" import inspect import warnings from typing import Any, Dict, Optional, Tuple, Union\",\n \"if attention_mask is not None: hidden_states = hidden_states * tf.expand_dims(attention_mask, -1) attention_mask =\",\n \"0 indicates the head is **masked**. inputs_embeds (`np.ndarray` or `tf.Tensor` of shape `({0},\",\n \"Optional[bool] = None, training: bool = False, **kwargs: Any, ): inputs = input_values_processing(\",\n \"training=training) attn_output = tf.matmul(attn_probs, value_states) # The tf.debugging asserts are not compliant with\",\n \"in `[0, 1]`: - 0 corresponds to a *sentence A* token, - 1\",\n \"input_values.pop(\\\"decoder_cached_states\\\") for k, v in dict(input_values).items(): if isinstance(v, allowed_types) or v is None:\",\n \"layer can then reuse all cross-attention # key/value_states (first \\\"if\\\" case) # if\",\n \"Wav2Vec2->Hubert class TFHubertWeightNormConv1D(tf.keras.layers.Conv1D): \\\"\\\"\\\"Adapted from https://www.tensorflow.org/probability/api_docs/python/tfp/layers/weight_norm/WeightNorm\\\"\\\"\\\" def __init__(self, filters, kernel_size, groups, explicit_padding, **kwargs):\",\n \"attention_mask: optional padding mask of the same size as shape, which will prevent\",\n \"super().__init__(**kwargs) self.conv = TFHubertWeightNormConv1D( filters=config.hidden_size, kernel_size=config.num_conv_pos_embeddings, groups=config.num_conv_pos_embedding_groups, explicit_padding=config.num_conv_pos_embeddings // 2, name=\\\"conv\\\", ) self.padding\",\n \"position_embeddings hidden_states = self.layer_norm(hidden_states) hidden_states = self.dropout(hidden_states, training=training) for i, layer_module in enumerate(self.layer):\",\n \"disabled in other modes than eager. if tf.executing_eagerly(): tf.debugging.assert_equal( shape_list(attn_output), [bsz * self.num_heads,\",\n \"for more detail. This argument can be used only in eager mode, in\",\n \"= tf.keras.constraints.get(gamma_constraint) self._check_axis() def build(self, input_shape): self._check_if_input_shape_is_none(input_shape) self._set_number_of_groups_for_instance_norm(input_shape) self._check_size_of_dimensions(input_shape) self._create_input_spec(input_shape) self._add_gamma_weight(input_shape) self._add_beta_weight(input_shape) self.built\",\n \"See the License for the specific language governing permissions and # limitations under\",\n \">>> from transformers import Wav2Vec2Processor, TFHubertModel >>> from datasets import load_dataset >>> import\",\n \"future version, use `input_values` instead.\\\", FutureWarning, ) output[\\\"input_values\\\"] = input_values.pop(\\\"inputs\\\") if \\\"decoder_cached_states\\\" in\",\n \"values to pair indices return tf.scatter_nd(pair_indices, tf.reshape(values, [-1]), output_shape) # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2._compute_mask_indices\",\n \"ValueError(f\\\"Label values must be <= vocab_size: {self.config.vocab_size}\\\") attention_mask = ( inputs[\\\"attention_mask\\\"] if inputs[\\\"attention_mask\\\"]\",\n \"(decoder) save Tuple(tf.Tensor, tf.Tensor) of # all previous decoder key/value_states. Further calls to\",\n \"HubertConfig, **kwargs): super().__init__(**kwargs) self.attention = TFHubertAttention( embed_dim=config.hidden_size, num_heads=config.num_attention_heads, dropout=config.attention_dropout, is_decoder=False, name=\\\"attention\\\", ) self.dropout\",\n \"= 0.0, is_decoder: bool = False, bias: bool = True, **kwargs, ): super().__init__(**kwargs)\",\n \"# `config.apply_spec_augment` can set masking to False if not getattr(self.config, \\\"apply_spec_augment\\\", True): return\",\n \"r\\\"\\\"\\\" Args: input_values (`np.ndarray`, `tf.Tensor`, `List[tf.Tensor]` ``Dict[str, tf.Tensor]` or `Dict[str, np.ndarray]` and each\",\n \"raise ValueError( f\\\"`config.feat_extract_norm` is {config.feat_extract_norm}, but has to be one of ['group', 'layer']\\\"\",\n \"return TFBaseModelOutput( last_hidden_state=hidden_states, hidden_states=all_hidden_states, attentions=all_self_attentions, ) @keras_serializable class TFHubertMainLayer(tf.keras.layers.Layer): config_class = HubertConfig def\",\n \"not None and type(output[\\\"args\\\"]) == tf.Tensor: tensor_name = output[\\\"args\\\"].name.split(\\\":\\\")[0] output[tensor_name] = output[\\\"args\\\"] else:\",\n \"has to be named accordingly to the parameters name, i.e. `input_values = tf.keras.Input(shape=(128,),\",\n \"from transformers import Wav2Vec2Processor, TFHubertForCTC >>> from datasets import load_dataset >>> import soundfile\",\n \"according to [SpecAugment](https://arxiv.org/abs/1904.08779). \\\"\\\"\\\" batch_size, sequence_length, hidden_size = shape_list(hidden_states) # `config.apply_spec_augment` can set\",\n \"`past_key_values` instead.\\\", FutureWarning, ) output[\\\"past_key_values\\\"] = input_values.pop(\\\"decoder_cached_states\\\") for k, v in dict(input_values).items(): if\",\n \"-100 # when not being attended to labels_mask = tf.cast(labels >= 0, tf.int32)\",\n \"is {shape_list(attn_weights)}\\\", ) if attention_mask is not None: # The tf.debugging asserts are\",\n \"tensors will not be guaranteed during the training. Args: func (`callable`): The callable\",\n \"# apply SpecAugment along feature axis if self.config.mask_feature_prob > 0: mask_feature_indices = _compute_mask_indices(\",\n \"# 1D convolutional layer output length formula taken # from https://pytorch.org/docs/stable/generated/torch.nn.Conv1d.html return (input_length\",\n \"of positions of each input sequence tokens in the position embeddings. Selected in\",\n \"TFHubertEncoderLayerStableLayerNorm(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs): super().__init__(**kwargs) self.attention = TFHubertAttention( embed_dim=config.hidden_size, num_heads=config.num_attention_heads, dropout=config.attention_dropout,\",\n \"instead of passing `input_values` you can choose to directly pass an embedded representation.\",\n \") class TFHubertForCTC(TFHubertPreTrainedModel): def __init__(self, config: HubertConfig, *inputs, **kwargs): super().__init__(config, *inputs, **kwargs) self.hubert\",\n \"= None position_embeddings = self.pos_conv_embed(hidden_states) hidden_states = hidden_states + position_embeddings hidden_states = self.layer_norm(hidden_states)\",\n \"\\\"args\\\" not in parameter_names: logger.warning( f\\\"The parameter {k} does not belongs to the\",\n \"* sequence_length / mask_length + tf.random.uniform((1,))) num_masked_spans = max(num_masked_spans, min_masks) # make sure\",\n \"None) return TFBaseModelOutput( last_hidden_state=hidden_states, hidden_states=all_hidden_states, attentions=all_self_attentions, ) # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2EncoderStableLayerNorm with Wav2Vec2->Hubert\",\n \"ds = load_dataset(\\\"hf-internal-testing/librispeech_asr_dummy\\\", \\\"clean\\\", split=\\\"validation\\\") >>> ds = ds.map(map_to_array) >>> input_values = processor(ds[\\\"speech\\\"][0],\",\n \"axis=2) else: # self_attention key_states = self._shape(self.k_proj(hidden_states), -1, bsz) value_states = self._shape(self.v_proj(hidden_states), -1,\",\n \"if self.center: self.beta = self.add_weight( shape=shape, name=\\\"beta\\\", initializer=self.beta_initializer, regularizer=self.beta_regularizer, constraint=self.beta_constraint, ) else: self.beta\",\n \"* self.num_heads, tgt_len, src_len], message=f\\\"Attention weights should be of size {(bsz * self.num_heads,\",\n \"the method with LayerCall.__call__(args, **kwargs) # So to respect the proper output we\",\n \"strides=config.conv_stride[layer_id], use_bias=config.conv_bias, name=\\\"conv\\\", ) self.activation = get_tf_activation(config.feat_extract_activation) self.layer_norm = TFHubertGroupNorm(groups=self.out_conv_dim, epsilon=config.layer_norm_eps, name=\\\"layer_norm\\\") def\",\n \"compute number of masked spans in batch num_masked_spans = int(mask_prob * sequence_length /\",\n \"dict, np.ndarray) for k, v in kwargs.items(): if isinstance(v, allowed_types) or v is\",\n \"TFHubertGroupNorm(tf.keras.layers.Layer): \\\"\\\"\\\" From tensorflow-addons https://www.tensorflow.org/addons/api_docs/python/tfa/layers/GroupNormalization \\\"\\\"\\\" def __init__( self, groups: int = 32,\",\n \"shape `(num_heads,)` or `(num_layers, num_heads)`, *optional*): Mask to nullify selected heads of the\",\n \"dropout modules have different behaviors between training and evaluation). \\\"\\\"\\\" @add_start_docstrings( \\\"The bare\",\n \"attention_mask: Optional[tf.Tensor] = None, output_attentions: Optional[bool] = False, output_hidden_states: Optional[bool] = False, return_dict:\",\n \"self._reshape_into_groups(inputs, input_shape, tensor_input_shape) normalized_inputs = self._apply_normalization(reshaped_inputs, input_shape) is_instance_norm = (input_shape[self.axis] // self.groups) ==\",\n \"bias_initializer=\\\"zeros\\\", name=\\\"intermediate_dense\\\", ) self.intermediate_act_fn = get_tf_activation(config.hidden_act) self.output_dense = tf.keras.layers.Dense( units=config.hidden_size, kernel_initializer=get_initializer(config.initializer_range), bias_initializer=\\\"zeros\\\", name=\\\"output_dense\\\",\",\n \"raise ValueError( \\\"You are trying to normalize your batch axis. Do you want\",\n \"... return batch >>> ds = load_dataset(\\\"hf-internal-testing/librispeech_asr_dummy\\\", \\\"clean\\\", split=\\\"validation\\\") >>> ds = ds.map(map_to_array)\",\n \"# scatter values to pair indices return tf.scatter_nd(pair_indices, tf.reshape(values, [-1]), output_shape) # Copied\",\n \"not be updated during training. \\\"\\\"\\\" self.hubert.feature_extractor.trainable = False @add_start_docstrings_to_model_forward(HUBERT_INPUTS_DOCSTRING) @replace_return_docstrings(output_type=TFCausalLMOutput, config_class=_CONFIG_FOR_DOC) def\",\n \"use `past_key_values` instead.\\\", FutureWarning, ) output[\\\"past_key_values\\\"] = input_values.pop(\\\"decoder_cached_states\\\") for k, v in dict(input_values).items():\",\n \"tf.float32), training=inputs[\\\"training\\\"] ) if inputs[\\\"attention_mask\\\"] is not None: # compute real output lengths\",\n \"of a list of symbolic inputs, each input has to be named accordingly\",\n \"input_shape[self.axis] if dim is None: raise ValueError( \\\"Axis \\\" + str(self.axis) + \\\"\",\n \"tf.Tensor, mask_time_indices: Optional[tf.Tensor] = None): \\\"\\\"\\\" Masks extracted features along time axis and/or\",\n \"*optional*): Optionally, instead of passing `input_values` you can choose to directly pass an\",\n \"mask spans for a given shape Args: shape: the the shape for which\",\n \"\\\").\\\" ) if dim % self.groups != 0: raise ValueError( \\\"Number of groups\",\n \"tf.keras.layers.Dense( units=config.intermediate_size, kernel_initializer=get_initializer(config.initializer_range), bias_initializer=\\\"zeros\\\", name=\\\"intermediate_dense\\\", ) self.intermediate_act_fn = get_tf_activation(config.hidden_act) self.output_dense = tf.keras.layers.Dense( units=config.hidden_size,\",\n \"_check_size_of_dimensions(self, input_shape): dim = input_shape[self.axis] if dim < self.groups: raise ValueError( \\\"Number of\",\n \"[`PreTrainedTokenizer.encode`] for details. [What are input IDs?](../glossary#input-ids) attention_mask (`np.ndarray` or `tf.Tensor` of shape\",\n \"([`PretrainedConfig`]): The config of the running model. **kwargs: The inputs of the model.\",\n \"= tf.shape(inputs) reshaped_inputs, group_shape = self._reshape_into_groups(inputs, input_shape, tensor_input_shape) normalized_inputs = self._apply_normalization(reshaped_inputs, input_shape) is_instance_norm\",\n \"coding=utf-8 # Copyright 2021 The Fairseq Authors and the HuggingFace Inc. team. All\",\n \"self.hubert.feature_extractor.trainable = False @add_start_docstrings_to_model_forward(HUBERT_INPUTS_DOCSTRING) @replace_return_docstrings(output_type=TFCausalLMOutput, config_class=_CONFIG_FOR_DOC) def call( self, input_values: tf.Tensor, attention_mask: Optional[tf.Tensor]\",\n \"= hidden_states + self.feed_forward(hidden_states) hidden_states = self.final_layer_norm(hidden_states) outputs = (hidden_states,) if output_attentions: outputs\",\n \"to add this exception if \\\"args\\\" in output: if output[\\\"args\\\"] is not None\",\n \"-> tf.Tensor: hidden_states = self.layer_norm(hidden_states) hidden_states = self.projection(hidden_states) hidden_states = self.dropout(hidden_states, training=training) return\",\n \"you choose this second option, there are three possibilities you can use to\",\n \"\\\"The method `freeze_feature_extractor` is deprecated and will be removed in Transformers v5.\\\" \\\"Please\",\n \"class TFHubertSamePadLayer(tf.keras.layers.Layer): def __init__(self, num_conv_pos_embeddings, **kwargs): super().__init__(**kwargs) self.num_pad_remove = 1 if num_conv_pos_embeddings %\",\n \"a simple interface for downloading and loading pretrained models. \\\"\\\"\\\" config_class = HubertConfig\",\n \"if cross_attention save Tuple(tf.Tensor, tf.Tensor) of all cross attention key/value_states. # Further calls\",\n \"_normalize_kernel(self): \\\"\\\"\\\"Generate normalized weights.\\\"\\\"\\\" kernel = tf.nn.l2_normalize(self.weight_v, axis=self.kernel_norm_axes) * tf.transpose(self.weight_g) self.kernel = tf.transpose(kernel)\",\n \"self.groups) group_shape = tf.stack(group_shape) reshaped_inputs = tf.reshape(inputs, group_shape) return reshaped_inputs, group_shape else: return\",\n \"input_values = processor(ds[\\\"speech\\\"][0], return_tensors=\\\"tf\\\").input_values # Batch size 1 >>> logits = model(input_values).logits >>>\",\n \"return hidden_states # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2LayerNormConvLayer with Wav2Vec2->Hubert class TFHubertLayerNormConvLayer(tf.keras.layers.Layer): def __init__(self, config:\",\n \"ANY KIND, either express or implied. # See the License for the specific\",\n \"as a list, tuple or dict in the first positional arguments. This second\",\n \"< sequence_length uniform_dist = tf.ones((batch_size, sequence_length - (mask_length - 1))) # get random\",\n \"for downloading and loading pretrained models. \\\"\\\"\\\" config_class = HubertConfig base_model_prefix = \\\"hubert\\\"\",\n \"this function will disable the gradient computation for the feature encoder so that\",\n \"= 0.0 input_values = tf.convert_to_tensor(np.random.rand(1, 16000), tf.float32) dummy_inputs = { \\\"input_values\\\": input_values, \\\"attention_mask\\\":\",\n \"self.num_heads, tgt_len, src_len) ) attn_weights = tf.reshape(attn_weights, (bsz * self.num_heads, tgt_len, src_len)) attn_probs\",\n \"each input has to be named accordingly to the parameters name, i.e. `input_values\",\n \"= tf.keras.layers.Dropout(config.hidden_dropout) self.layer = [ TFHubertEncoderLayerStableLayerNorm(config, name=f\\\"layers.{i}\\\") for i in range(config.num_hidden_layers) ] def\",\n \"broadcast_shape = self._create_broadcast_shape(input_shape) gamma = None beta = None if self.scale: gamma =\",\n \"{shape_list(attn_weights)}\\\", ) if attention_mask is not None: # The tf.debugging asserts are not\",\n \"axis=-1), indices_shape), [1, -1] ) # transform batch_indices to pair_indices pair_indices = tf.transpose(tf.concat([broad_casted_batch_dims,\",\n \"is always `None` past_key_value = (key_states, value_states) proj_shape = (bsz * self.num_heads, -1,\",\n \"bias_initializer=\\\"zeros\\\", name=\\\"output_dense\\\", ) self.output_dropout = tf.keras.layers.Dropout(config.hidden_dropout) def call(self, hidden_states: tf.Tensor, training: bool =\",\n \"which to compute masks. should be of size 2 where first element is\",\n \"\\\"scale\\\": self.scale, \\\"beta_initializer\\\": tf.keras.initializers.serialize(self.beta_initializer), \\\"gamma_initializer\\\": tf.keras.initializers.serialize(self.gamma_initializer), \\\"beta_regularizer\\\": tf.keras.regularizers.serialize(self.beta_regularizer), \\\"gamma_regularizer\\\": tf.keras.regularizers.serialize(self.gamma_regularizer), \\\"beta_constraint\\\": tf.keras.constraints.serialize(self.beta_constraint), \\\"gamma_constraint\\\":\",\n \"being attended to labels_mask = tf.cast(labels >= 0, tf.int32) target_lengths = tf.reduce_sum(labels_mask, axis=-1)\",\n \"FutureWarning, ) self.freeze_feature_encoder() def freeze_feature_encoder(self): \\\"\\\"\\\" Calling this function will disable the gradient\",\n \"of the inputs. Indices are selected in `[0, 1]`: - 0 corresponds to\",\n \"name=f\\\"layers.{i}\\\") for i in range(config.num_hidden_layers) ] def call( self, hidden_states: tf.Tensor, attention_mask: Optional[tf.Tensor]\",\n \"one of ['group', 'layer']\\\" ) self.conv_layers = conv_layers def call(self, input_values): hidden_states =\",\n \"super().__init__(**kwargs) self.in_conv_dim = config.conv_dim[layer_id] if layer_id > 0 else 1 self.out_conv_dim = config.conv_dim[layer_id]\",\n \"\\\"You are trying to normalize your batch axis. Do you want to \\\"\",\n \"obtained using [`BertTokenizer`]. See [`PreTrainedTokenizer.__call__`] and [`PreTrainedTokenizer.encode`] for details. [What are input IDs?](../glossary#input-ids)\",\n \"= input_shape[self.axis] // self.groups group_shape.insert(self.axis, self.groups) group_shape = tf.stack(group_shape) reshaped_inputs = tf.reshape(inputs, group_shape)\",\n \"output_attentions=output_attentions, output_hidden_states=output_hidden_states, return_dict=return_dict, training=training, kwargs_call=kwargs, ) hidden_states = self.feature_extractor( tf.cast(inputs[\\\"input_values\\\"], tf.float32), training=inputs[\\\"training\\\"] )\",\n \"minimum number of masked spans Adapted from [fairseq's data_utils.py](https://github.com/pytorch/fairseq/blob/e0788f7007a8473a76db573985031f3c94201e79/fairseq/data/data_utils.py#L376). \\\"\\\"\\\" batch_size, sequence_length =\",\n \"= self.add_weight( shape=shape, name=\\\"gamma\\\", initializer=self.gamma_initializer, regularizer=self.gamma_regularizer, constraint=self.gamma_constraint, ) else: self.gamma = None def\",\n \"map_to_array(batch): ... speech, _ = sf.read(batch[\\\"file\\\"]) ... batch[\\\"speech\\\"] = speech ... return batch\",\n \"= False, training: bool = False, ) -> Tuple[tf.Tensor]: attn_residual = hidden_states hidden_states\",\n \"= shape if mask_length < 1: raise ValueError(\\\"`mask_length` has to be bigger than\",\n \"# can concat previous decoder key/value_states to current projected key/value_states (third \\\"elif\\\" case)\",\n \"only {allowed_types} is accepted for {parameter_names[i]}.\\\" ) elif isinstance(input_values, (dict, BatchEncoding)): if \\\"inputs\\\"\",\n \"on CPU. If you wish \\\" \\\"to train/fine-tine this model, you need a\",\n \"def _normalize_kernel(self): \\\"\\\"\\\"Generate normalized weights.\\\"\\\"\\\" kernel = tf.nn.l2_normalize(self.weight_v, axis=self.kernel_norm_axes) * tf.transpose(self.weight_g) self.kernel =\",\n \"the model. Initializing with a config file does not load the weights associated\",\n \"self, hidden_states: tf.Tensor, attention_mask: Optional[tf.Tensor] = None, output_attentions: Optional[bool] = False, output_hidden_states: Optional[bool]\",\n \"super().__init__(**kwargs) self.layer_norm = tf.keras.layers.LayerNormalization(epsilon=config.layer_norm_eps, name=\\\"layer_norm\\\") self.projection = tf.keras.layers.Dense( units=config.hidden_size, kernel_initializer=get_initializer(config.initializer_range), bias_initializer=\\\"zeros\\\", name=\\\"projection\\\", )\",\n \"= tf.keras.regularizers.get(beta_regularizer) self.gamma_regularizer = tf.keras.regularizers.get(gamma_regularizer) self.beta_constraint = tf.keras.constraints.get(beta_constraint) self.gamma_constraint = tf.keras.constraints.get(gamma_constraint) self._check_axis() def\",\n \"to general usage and behavior. <Tip> TF 2.0 models accepts two formats as\",\n \"inputs[\\\"output_attentions\\\"] else self.config.output_attentions ) inputs[\\\"return_dict\\\"] = inputs[\\\"return_dict\\\"] if inputs[\\\"return_dict\\\"] else self.config.return_dict outputs =\",\n \"= tf.reshape(layer_head_mask, (1, -1, 1, 1)) * tf.reshape( attn_weights, (bsz, self.num_heads, tgt_len, src_len)\",\n \"trick will do for now - see https://github.com/tensorflow/tensorflow/issues/9260 for more info \\\"\\\"\\\" z\",\n \"writing, software # distributed under the License is distributed on an \\\"AS IS\\\"\",\n \"config_class=_CONFIG_FOR_DOC) def call( self, input_values: tf.Tensor, attention_mask: Optional[tf.Tensor] = None, token_type_ids: Optional[tf.Tensor] =\",\n \"attentions=encoder_outputs.attentions, ) class TFHubertPreTrainedModel(TFPreTrainedModel): \\\"\\\"\\\" An abstract class to handle weights initialization and\",\n \"def __init__(self, config: HubertConfig, *inputs, **kwargs): super().__init__(config, *inputs, **kwargs) self.hubert = TFHubertMainLayer(config, name=\\\"hubert\\\")\",\n \"tf.constant(1.0) mask = tf.cast(mask, dtype=one_cst.dtype) expanded_mask = tf.tile(mask[:, None, None, :], (1, 1,\",\n \"output[k] = v else: raise ValueError(f\\\"Data of type {type(v)} is not allowed only\",\n \"= config.conv_dim[layer_id] self.conv = tf.keras.layers.Conv1D( filters=self.out_conv_dim, kernel_size=config.conv_kernel[layer_id], strides=config.conv_stride[layer_id], use_bias=config.conv_bias, name=\\\"conv\\\", ) self.layer_norm =\",\n \"related to general usage and behavior. <Tip> TF 2.0 models accepts two formats\",\n \"not in parameter_names and \\\"args\\\" not in parameter_names: logger.warning( f\\\"The parameter {k} does\",\n \"else: self.encoder = TFHubertEncoder(config, name=\\\"encoder\\\") def build(self, input_shape: tf.TensorShape): self.masked_spec_embed = self.add_weight( shape=(self.config.hidden_size,),\",\n \"groups (\\\" + str(self.groups) + \\\") must be a \\\" \\\"multiple of the\",\n \"position_ids=inputs[\\\"position_ids\\\"], head_mask=inputs[\\\"head_mask\\\"], inputs_embeds=inputs[\\\"inputs_embeds\\\"], output_attentions=inputs[\\\"output_attentions\\\"], output_hidden_states=inputs[\\\"output_hidden_states\\\"], return_dict=inputs[\\\"return_dict\\\"], training=inputs[\\\"training\\\"], ) return outputs def serving_output(self, output):\",\n \"formula output_lengths = self._get_feat_extract_output_lengths(tf.reduce_sum(inputs[\\\"attention_mask\\\"], -1)) attention_mask = tf.sequence_mask( output_lengths, maxlen=shape_list(hidden_states)[1], dtype=hidden_states.dtype ) hidden_states\",\n \"language modeling loss. Indices should be in `[-100, 0, ..., config.vocab_size]` (see `input_values`\",\n \"`model({\\\"input_values\\\": input_values, \\\"token_type_ids\\\": token_type_ids})` </Tip> Args: config ([`HubertConfig`]): Model configuration class with all\",\n \"name=\\\"v_proj\\\") self.out_proj = tf.keras.layers.Dense(embed_dim, use_bias=bias, name=\\\"out_proj\\\") def _shape(self, tensor: tf.Tensor, seq_len: int, bsz:\",\n \"last layer if output_hidden_states: all_hidden_states = all_hidden_states + (hidden_states,) if not return_dict: return\",\n \"shape = (dim,) if self.scale: self.gamma = self.add_weight( shape=shape, name=\\\"gamma\\\", initializer=self.gamma_initializer, regularizer=self.gamma_regularizer, constraint=self.gamma_constraint,\",\n \") self.scaling = self.head_dim**-0.5 self.is_decoder = is_decoder self.k_proj = tf.keras.layers.Dense(embed_dim, use_bias=bias, name=\\\"k_proj\\\") self.q_proj\",\n \"input Tensors IN THE ORDER given in the docstring: `model([input_values, attention_mask])` or `model([input_values,\",\n \"= self.q_proj(hidden_states) * self.scaling # get key, value proj if is_cross_attention and past_key_value\",\n \"self.activation(hidden_states) return hidden_states # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2GroupNormConvLayer with Wav2Vec2->Hubert class TFHubertGroupNormConvLayer(tf.keras.layers.Layer): def __init__(self,\",\n \"allowed_types = (tf.Tensor, bool, int, ModelOutput, tuple, list, dict, np.ndarray) for k, v\",\n \"return ((loss,) + output) if loss is not None else output return TFCausalLMOutput(\",\n \"src_len)) return attn_output, attn_weights, past_key_value # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2FeedForward with Wav2Vec2->Hubert class TFHubertFeedForward(tf.keras.layers.Layer):\",\n \"# generate indices & apply SpecAugment along time axis mask_time_indices = _compute_mask_indices( (batch_size,\",\n \"tuple(v for v in [hidden_states, all_hidden_states, all_self_attentions] if v is not None) return\",\n \"[`PreTrainedTokenizer.__call__`] and [`PreTrainedTokenizer.encode`] for details. [What are input IDs?](../glossary#input-ids) attention_mask (`np.ndarray` or `tf.Tensor`\",\n \"config_class = HubertConfig def __init__(self, config: HubertConfig, **kwargs): super().__init__(**kwargs) self.config = config self.feature_extractor\",\n \"self.feature_extractor = TFHubertFeatureEncoder(config, name=\\\"feature_extractor\\\") self.feature_projection = TFHubertFeatureProjection(config, name=\\\"feature_projection\\\") if config.do_stable_layer_norm: self.encoder = TFHubertEncoderStableLayerNorm(config,\",\n \"in the docstring: `model([input_values, attention_mask])` or `model([input_values, attention_mask, token_type_ids])` - a dictionary with\",\n \"in Transformers v5. \\\" f\\\"Use `{self.__class__.__bases__[0].__name__}` instead.\\\", FutureWarning, ) class TFHubertFeatureProjection(tf.keras.layers.Layer): def __init__(self,\",\n \"= tf.reshape( tf.broadcast_to(tf.expand_dims(tf.range(indices_shape[0]), axis=-1), indices_shape), [1, -1] ) # transform batch_indices to pair_indices\",\n \"Tuple[tf.Tensor]: attn_residual = hidden_states hidden_states, attn_weights, _ = self.attention( hidden_states, attention_mask=attention_mask, training=training )\",\n \"of groups (\\\" + str(self.groups) + \\\") cannot be \\\" \\\"more than the\",\n \"all_self_attentions] if v is not None) return TFBaseModelOutput( last_hidden_state=hidden_states, hidden_states=all_hidden_states, attentions=all_self_attentions, ) #\",\n \"self.config.output_attentions else None return TFBaseModelOutput(last_hidden_state=output.last_hidden_state, hidden_states=hs, attentions=attns) @add_start_docstrings( \\\"\\\"\\\"TFHubert Model with a `language\",\n \"**kwargs) warnings.warn( f\\\"The class `{self.__class__.__name__}` has been depreciated \\\" \\\"and will be removed\",\n \"0 else 1 self.out_conv_dim = config.conv_dim[layer_id] self.conv = tf.keras.layers.Conv1D( filters=self.out_conv_dim, kernel_size=config.conv_kernel[layer_id], strides=config.conv_stride[layer_id], use_bias=config.conv_bias,\",\n \"at https://huggingface.co/models?filter=hubert ] LARGE_NEGATIVE = -1e8 # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.input_values_processing def input_values_processing(func, config,\",\n \"tensor_input_shape) normalized_inputs = self._apply_normalization(reshaped_inputs, input_shape) is_instance_norm = (input_shape[self.axis] // self.groups) == 1 if\",\n \"file except in compliance with the License. # You may obtain a copy\",\n \"self.scale: self.gamma = self.add_weight( shape=shape, name=\\\"gamma\\\", initializer=self.gamma_initializer, regularizer=self.gamma_regularizer, constraint=self.gamma_constraint, ) else: self.gamma =\",\n \"(hidden_states,) if output_attentions: outputs += (attn_weights,) return outputs # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2EncoderLayerStableLayerNorm with\",\n \"config.feat_extract_norm == \\\"layer\\\": conv_layers = [ TFHubertLayerNormConvLayer(config, layer_id=i, name=f\\\"conv_layers.{i}\\\") for i in range(config.num_feat_extract_layers)\",\n \"value_states) # The tf.debugging asserts are not compliant with XLA then they #\",\n \"0, **kwargs: Any) -> None: super().__init__(**kwargs) self.in_conv_dim = config.conv_dim[layer_id] if layer_id > 0\",\n \"int, bsz: int): return tf.transpose(tf.reshape(tensor, (bsz, seq_len, self.num_heads, self.head_dim)), (0, 2, 1, 3))\",\n \"*inputs, **kwargs): super().__init__(config, *inputs, **kwargs) self.config = config self.hubert = TFHubertMainLayer(config, name=\\\"hubert\\\") @add_start_docstrings_to_model_forward(HUBERT_INPUTS_DOCSTRING)\",\n \"position IDs?](../glossary#position-ids) head_mask (`np.ndarray` or `tf.Tensor` of shape `(num_heads,)` or `(num_layers, num_heads)`, *optional*):\",\n \"tf.reshape(values, [-1]), output_shape) # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2._compute_mask_indices def _compute_mask_indices( shape: Tuple[int, int], mask_prob:\",\n \"to [SpecAugment](https://arxiv.org/abs/1904.08779). \\\"\\\"\\\" batch_size, sequence_length, hidden_size = shape_list(hidden_states) # `config.apply_spec_augment` can set masking\",\n \"\\\" \\\"to train/fine-tine this model, you need a GPU or a TPU\\\" )\",\n \"enumerate(input_values): # EagerTensors don't allow to use the .name property so we check\",\n \"overlaps, the actual number will be smaller (unless no_overlap is True) mask_length: size\",\n \"+ \\\").\\\" ) if dim % self.groups != 0: raise ValueError( \\\"Number of\",\n \"processor(ds[\\\"speech\\\"][0], return_tensors=\\\"tf\\\").input_values # Batch size 1 >>> logits = model(input_values).logits >>> predicted_ids =\",\n \"hidden_states: tf.Tensor) -> tf.Tensor: hidden_states = self.conv(hidden_states) hidden_states = self.layer_norm(hidden_states) hidden_states = self.activation(hidden_states)\",\n \"{self.embed_dim}\\\" f\\\" and `num_heads`: {num_heads}).\\\" ) self.scaling = self.head_dim**-0.5 self.is_decoder = is_decoder self.k_proj\",\n \"proj_shape) value_states = tf.reshape(value_states, proj_shape) src_len = shape_list(key_states)[1] attn_weights = tf.matmul(query_states, key_states, transpose_b=True)\",\n \"filters=self.out_conv_dim, kernel_size=config.conv_kernel[layer_id], strides=config.conv_stride[layer_id], use_bias=config.conv_bias, name=\\\"conv\\\", ) self.activation = get_tf_activation(config.feat_extract_activation) def call(self, hidden_states: tf.Tensor)\",\n \"1 else: axis = -1 if self.axis == -1 else self.axis - 1\",\n \"convert `input_values` indices into associated vectors than the model's internal embedding lookup matrix.\",\n \"logger.warning( f\\\"The parameter {k} does not belongs to the parameter list {parameter_names} and\",\n \"(layer_outputs[1],) # Add last layer if output_hidden_states: all_hidden_states = all_hidden_states + (hidden_states,) if\",\n \"output_attentions: Optional[bool] = False, training: bool = False, ) -> Tuple[tf.Tensor]: attn_residual =\",\n \"the tensors will not be guaranteed during the training. Args: func (`callable`): The\",\n \"hidden_states: tf.Tensor, mask_time_indices: Optional[tf.Tensor] = None): \\\"\\\"\\\" Masks extracted features along time axis\",\n \") self.activation = get_tf_activation(config.feat_extract_activation) def call(self, hidden_states: tf.Tensor) -> tf.Tensor: hidden_states = self.conv(hidden_states)\",\n \"tensor_input_shape = tf.shape(inputs) reshaped_inputs, group_shape = self._reshape_into_groups(inputs, input_shape, tensor_input_shape) normalized_inputs = self._apply_normalization(reshaped_inputs, input_shape)\",\n \"can be used in eager mode, in graph mode the value will always\",\n \"input_shape) is_instance_norm = (input_shape[self.axis] // self.groups) == 1 if not is_instance_norm: outputs =\",\n \"**kwargs: Any) -> None: super().__init__(**kwargs) if config.feat_extract_norm == \\\"group\\\": conv_layers = [TFHubertGroupNormConvLayer(config, layer_id=0,\",\n \"sequence_length = shape if mask_length < 1: raise ValueError(\\\"`mask_length` has to be bigger\",\n \"elif is_cross_attention: # cross_attentions key_states = self._shape(self.k_proj(key_value_states), -1, bsz) value_states = self._shape(self.v_proj(key_value_states), -1,\",\n \"16000), tf.float32) dummy_inputs = { \\\"input_values\\\": input_values, \\\"attention_mask\\\": tf.cast(tf.not_equal(input_values, pad_token), tf.float32), } return\",\n \"normalized_inputs = self._apply_normalization(reshaped_inputs, input_shape) is_instance_norm = (input_shape[self.axis] // self.groups) == 1 if not\",\n \") hidden_states = tf.where(mask_feature_indices[:, tf.newaxis, :], hidden_states, 0) return hidden_states def call( self,\",\n \"__init__(self, num_conv_pos_embeddings, **kwargs): super().__init__(**kwargs) self.num_pad_remove = 1 if num_conv_pos_embeddings % 2 == 0\",\n \"== 0: raise ValueError( \\\"You are trying to normalize your batch axis. Do\",\n \"is currently not implemented. The gumbel-max trick will do for now - see\",\n \"tf.keras.layers.LayerNormalization(epsilon=config.layer_norm_eps, name=\\\"layer_norm\\\") self.dropout = tf.keras.layers.Dropout(config.hidden_dropout) self.layer = [ TFHubertEncoderLayerStableLayerNorm(config, name=f\\\"layers.{i}\\\") for i in\",\n \"not inputs[\\\"return_dict\\\"]: return (hidden_states,) + encoder_outputs[1:] return TFBaseModelOutput( last_hidden_state=hidden_states, hidden_states=encoder_outputs.hidden_states, attentions=encoder_outputs.attentions, ) class\",\n \"input_values): hidden_states = tf.expand_dims(input_values, -1) for conv_layer in self.conv_layers: hidden_states = conv_layer(hidden_states) return\",\n \"\\\"\\\"\\\" @add_start_docstrings( \\\"The bare TFHubert Model transformer outputing raw hidden-states without any specific\",\n \"tf.nn.moments(reshaped_inputs, group_reduction_axes, keepdims=True) gamma, beta = self._get_reshaped_weights(input_shape) normalized_inputs = tf.nn.batch_normalization( reshaped_inputs, mean=mean, variance=variance,\",\n \"input sequence tokens in the position embeddings. Selected in the range `[0, config.max_position_embeddings\",\n \"type {type(v)} is not allowed only {allowed_types} is accepted for {k}.\\\") else: if\",\n \"the specific language governing permissions and # limitations under the License. \\\"\\\"\\\" TensorFlow\",\n \"self.in_conv_dim = config.conv_dim[layer_id] if layer_id > 0 else 1 self.out_conv_dim = config.conv_dim[layer_id] self.conv\",\n \"= \\\"ones\\\", beta_regularizer: tf.keras.regularizers.Regularizer = None, gamma_regularizer: tf.keras.regularizers.Regularizer = None, beta_constraint: tf.keras.constraints.Constraint =\",\n \"Optional[tf.Tensor] = None, output_hidden_states: Optional[tf.Tensor] = None, return_dict: Optional[bool] = None, training: bool\",\n \"elif isinstance(input, allowed_types) or input is None: output[parameter_names[i]] = input else: raise ValueError(\",\n \"from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2EncoderStableLayerNorm with Wav2Vec2->Hubert class TFHubertEncoderStableLayerNorm(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs): super().__init__(**kwargs) self.config\",\n \"if key_value_states are provided this layer is used as a cross-attention layer #\",\n \"[bsz * self.num_heads, tgt_len, src_len], message=f\\\"Attention weights should be of size {(bsz *\",\n \"2021 The Fairseq Authors and the HuggingFace Inc. team. All rights reserved. #\",\n \"group_reduction_axes, keepdims=True) gamma, beta = self._get_reshaped_weights(input_shape) normalized_inputs = tf.nn.batch_normalization( reshaped_inputs, mean=mean, variance=variance, scale=gamma,\",\n \"self.layer_norm(hidden_states) hidden_states = self.activation(hidden_states) return hidden_states # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2GroupNormConvLayer with Wav2Vec2->Hubert class\",\n \"labels (`tf.Tensor` or `np.ndarray` of shape `(batch_size, sequence_length)`, *optional*): Labels for computing the\",\n \"hidden_states # Copied from transformers.models.bart.modeling_tf_bart.TFBartAttention with TFBart->TFHubert class TFHubertAttention(tf.keras.layers.Layer): \\\"\\\"\\\"Multi-headed attention from \\\"Attention\",\n \"states of all layers. See `hidden_states` under returned tensors for more detail. This\",\n \"`{self.__class__.__name__}` has been depreciated \\\" \\\"and will be removed in Transformers v5. \\\"\",\n \"method which currently requires having all the tensors in the first argument of\",\n \">>> target_transcription = \\\"A MAN SAID TO THE UNIVERSE SIR I EXIST\\\" >>>\",\n \"tf.Tensor, attention_mask: Optional[tf.Tensor] = None, output_attentions: Optional[bool] = False, output_hidden_states: Optional[bool] = False,\",\n \"the vocabulary. Indices can be obtained using [`BertTokenizer`]. See [`PreTrainedTokenizer.__call__`] and [`PreTrainedTokenizer.encode`] for\",\n \"= TFHubertFeatureProjection(config, name=\\\"feature_projection\\\") if config.do_stable_layer_norm: self.encoder = TFHubertEncoderStableLayerNorm(config, name=\\\"encoder\\\") else: self.encoder = TFHubertEncoder(config,\",\n \"= None, labels: Optional[tf.Tensor] = None, output_hidden_states: Optional[bool] = None, return_dict: Optional[bool] =\",\n \"to False if not getattr(self.config, \\\"apply_spec_augment\\\", True): return hidden_states if mask_time_indices is not\",\n \"== -1 else self.axis - 1 else: axis = -1 if self.axis ==\",\n \"set to `-100` are ignored (masked), the loss is only computed for the\",\n \"mask_length > sequence_length: num_masked_spans = sequence_length // mask_length # SpecAugment mask to fill\",\n \"self.config.return_dict outputs = self.hubert( input_values=inputs[\\\"input_values\\\"], attention_mask=inputs[\\\"attention_mask\\\"], token_type_ids=inputs[\\\"token_type_ids\\\"], position_ids=inputs[\\\"position_ids\\\"], head_mask=inputs[\\\"head_mask\\\"], inputs_embeds=inputs[\\\"inputs_embeds\\\"], output_attentions=inputs[\\\"output_attentions\\\"], output_hidden_states=inputs[\\\"output_hidden_states\\\"], return_dict=inputs[\\\"return_dict\\\"],\",\n \"message=f\\\"`attn_output` should be of size {(bsz, self.num_heads, tgt_len, self.head_dim)}, but is {shape_list(attn_output)}\\\", )\",\n \"training=training, ) outputs = self.hubert( input_values=inputs[\\\"input_values\\\"], attention_mask=inputs[\\\"attention_mask\\\"], token_type_ids=inputs[\\\"token_type_ids\\\"], position_ids=inputs[\\\"position_ids\\\"], head_mask=inputs[\\\"head_mask\\\"], inputs_embeds=inputs[\\\"inputs_embeds\\\"], output_attentions=inputs[\\\"output_attentions\\\"], output_hidden_states=inputs[\\\"output_hidden_states\\\"],\",\n \"broadcast_shape # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2WeightNormConv1D with Wav2Vec2->Hubert class TFHubertWeightNormConv1D(tf.keras.layers.Conv1D): \\\"\\\"\\\"Adapted from https://www.tensorflow.org/probability/api_docs/python/tfp/layers/weight_norm/WeightNorm\\\"\\\"\\\" def\",\n \"training: bool = False, ) -> Tuple[tf.Tensor]: attn_residual = hidden_states hidden_states = self.layer_norm(hidden_states)\",\n \"self.layer_norm(hidden_states) if output_hidden_states: all_hidden_states = all_hidden_states + (hidden_states,) if not return_dict: return tuple(v\",\n \"* self.num_heads, tgt_len, src_len)) attn_probs = self.dropout(attn_weights, training=training) attn_output = tf.matmul(attn_probs, value_states) #\",\n \"[What are input IDs?](../glossary#input-ids) attention_mask (`np.ndarray` or `tf.Tensor` of shape `({0})`, *optional*): Mask\",\n \"+ [ TFHubertNoLayerNormConvLayer(config, layer_id=i + 1, name=f\\\"conv_layers.{i+1}\\\") for i in range(config.num_feat_extract_layers - 1)\",\n \"tf.keras.constraints.Constraint = None, gamma_constraint: tf.keras.constraints.Constraint = None, **kwargs, ): super().__init__(**kwargs) self.supports_masking = True\",\n \"tf.reshape(self.beta, broadcast_shape) return gamma, beta def _check_if_input_shape_is_none(self, input_shape): dim = input_shape[self.axis] if dim\",\n \"None, past_key_value: Optional[Tuple[Tuple[tf.Tensor]]] = None, attention_mask: Optional[tf.Tensor] = None, layer_head_mask: Optional[tf.Tensor] = None,\",\n \"model weights. \\\"\\\"\\\" HUBERT_INPUTS_DOCSTRING = r\\\"\\\"\\\" Args: input_values (`np.ndarray`, `tf.Tensor`, `List[tf.Tensor]` ``Dict[str, tf.Tensor]`\",\n \"self.attention = TFHubertAttention( embed_dim=config.hidden_size, num_heads=config.num_attention_heads, dropout=config.attention_dropout, is_decoder=False, name=\\\"attention\\\", ) self.dropout = tf.keras.layers.Dropout(config.hidden_dropout) self.layer_norm\",\n \"call(self, inputs): if not self.initialized: self._init_norm() self.initialized = True self._normalize_kernel() padded_inputs = tf.pad(inputs,\",\n \"self.conv = tf.keras.layers.Conv1D( filters=self.out_conv_dim, kernel_size=config.conv_kernel[layer_id], strides=config.conv_stride[layer_id], use_bias=config.conv_bias, name=\\\"conv\\\", ) self.layer_norm = tf.keras.layers.LayerNormalization(name=\\\"layer_norm\\\", epsilon=config.layer_norm_eps)\",\n \"keyword arguments (like PyTorch models), or - having all inputs as a list,\",\n \"= True, beta_initializer: tf.keras.initializers.Initializer = \\\"zeros\\\", gamma_initializer: tf.keras.initializers.Initializer = \\\"ones\\\", beta_regularizer: tf.keras.regularizers.Regularizer =\",\n \"False, ) -> Union[TFBaseModelOutput, Tuple[tf.Tensor]]: all_hidden_states = () if output_hidden_states else None all_self_attentions\",\n \"1, tgt_seq_len, src_seq_len]`. \\\"\\\"\\\" src_len = shape_list(mask)[1] tgt_len = tgt_len if tgt_len is\",\n \"\\\"zeros\\\", gamma_initializer: tf.keras.initializers.Initializer = \\\"ones\\\", beta_regularizer: tf.keras.regularizers.Regularizer = None, gamma_regularizer: tf.keras.regularizers.Regularizer = None,\",\n \"Optional[tf.Tensor] = None, position_ids: Optional[tf.Tensor] = None, head_mask: Optional[tf.Tensor] = None, inputs_embeds: Optional[tf.Tensor]\",\n \"\\\"\\\"\\\" Categorical sampling without replacement is currently not implemented. The gumbel-max trick will\",\n \"last_hidden_state=hidden_states, hidden_states=all_hidden_states, attentions=all_self_attentions, ) # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2EncoderStableLayerNorm with Wav2Vec2->Hubert class TFHubertEncoderStableLayerNorm(tf.keras.layers.Layer): def\",\n \"used instead. return_dict (`bool`, *optional*): Whether or not to return a [`~file_utils.ModelOutput`] instead\",\n \"with Wav2Vec2->Hubert class TFHubertEncoderLayer(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs): super().__init__(**kwargs) self.attention = TFHubertAttention(\",\n \"feature axis if self.config.mask_feature_prob > 0: mask_feature_indices = _compute_mask_indices( (batch_size, hidden_size), mask_prob=self.config.mask_feature_prob, mask_length=self.config.mask_feature_length,\",\n \"super().__init__(**kwargs) self.attention = TFHubertAttention( embed_dim=config.hidden_size, num_heads=config.num_attention_heads, dropout=config.attention_dropout, is_decoder=False, name=\\\"attention\\\", ) self.dropout = tf.keras.layers.Dropout(config.hidden_dropout)\",\n \"1e-3, center: bool = True, scale: bool = True, beta_initializer: tf.keras.initializers.Initializer = \\\"zeros\\\",\",\n \"= None, beta_constraint: tf.keras.constraints.Constraint = None, gamma_constraint: tf.keras.constraints.Constraint = None, **kwargs, ): super().__init__(**kwargs)\",\n \"reshaped_inputs, group_shape = self._reshape_into_groups(inputs, input_shape, tensor_input_shape) normalized_inputs = self._apply_normalization(reshaped_inputs, input_shape) is_instance_norm = (input_shape[self.axis]\",\n \"is_instance_norm: outputs = tf.reshape(normalized_inputs, tensor_input_shape) else: outputs = normalized_inputs return outputs def get_config(self):\",\n \"self.layer_norm(hidden_states) hidden_states = hidden_states + self.feed_forward(hidden_states) hidden_states = self.final_layer_norm(hidden_states) outputs = (hidden_states,) if\",\n \"# Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2LayerNormConvLayer with Wav2Vec2->Hubert class TFHubertLayerNormConvLayer(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, layer_id:\",\n \"tgt_len, src_len)}, but is {shape_list(attention_mask)}\\\", ) attention_mask = tf.cast(attention_mask, dtype=attn_weights.dtype) attn_weights = tf.reshape(attn_weights,\",\n \"i.e. `input_values = tf.keras.Input(shape=(128,), dtype='float32', name=\\\"input_values\\\")` otherwise the order of the tensors will\",\n \"Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2._scatter_values_on_batch_indices def _scatter_values_on_batch_indices(values, batch_indices, output_shape): \\\"\\\"\\\" Scatter function as in PyTorch\",\n \"= tf.pad(inputs, ((0, 0), (self.explicit_padding, self.explicit_padding), (0, 0))) output = super().call(padded_inputs) return output\",\n \"Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2FeedForward with Wav2Vec2->Hubert class TFHubertFeedForward(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs): super().__init__(**kwargs)\",\n \"( inputs[\\\"attention_mask\\\"] if inputs[\\\"attention_mask\\\"] is not None else tf.ones_like(inputs[\\\"input_values\\\"], dtype=tf.float32) ) input_lengths =\",\n \"not belongs to the parameter list {parameter_names} and will be ignored.\\\" ) continue\",\n \"the model weights. \\\"\\\"\\\" HUBERT_INPUTS_DOCSTRING = r\\\"\\\"\\\" Args: input_values (`np.ndarray`, `tf.Tensor`, `List[tf.Tensor]` ``Dict[str,\",\n \"k in [\\\"return_dict\\\", \\\"output_attentions\\\", \\\"output_hidden_states\\\", \\\"use_cache\\\"] } output.update(booleans_processing(config=config, **boolean_dict)) return output # Copied\",\n \"super().__init__(**kwargs) self.intermediate_dropout = tf.keras.layers.Dropout(config.activation_dropout) self.intermediate_dense = tf.keras.layers.Dense( units=config.intermediate_size, kernel_initializer=get_initializer(config.initializer_range), bias_initializer=\\\"zeros\\\", name=\\\"intermediate_dense\\\", ) self.intermediate_act_fn\",\n \"filters=self.out_conv_dim, kernel_size=config.conv_kernel[layer_id], strides=config.conv_stride[layer_id], use_bias=config.conv_bias, name=\\\"conv\\\", ) self.activation = get_tf_activation(config.feat_extract_activation) self.layer_norm = TFHubertGroupNorm(groups=self.out_conv_dim, epsilon=config.layer_norm_eps,\",\n \"!= self.embed_dim: raise ValueError( f\\\"embed_dim must be divisible by num_heads (got `embed_dim`: {self.embed_dim}\\\"\",\n \"inputs = input_values_processing( func=self.call, config=self.config, input_values=input_values, attention_mask=attention_mask, token_type_ids=token_type_ids, position_ids=position_ids, head_mask=head_mask, inputs_embeds=inputs_embeds, output_attentions=output_attentions, output_hidden_states=output_hidden_states,\",\n \"only computed for the tokens with labels in `[0, ..., config.vocab_size]` Returns: Example:\",\n \"name=\\\"layer_norm\\\") def call(self, hidden_states: tf.Tensor) -> tf.Tensor: hidden_states = self.conv(hidden_states) hidden_states = self.layer_norm(hidden_states)\",\n \"rights reserved. # # Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\",\n \"None, position_ids: Optional[tf.Tensor] = None, head_mask: Optional[tf.Tensor] = None, inputs_embeds: Optional[tf.Tensor] = None,\",\n \"hidden_states class TFHubertFeatureEncoder(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs: Any) -> None: super().__init__(**kwargs) if\",\n \"length of mask span to mask approximately this percentage of all elements. however\",\n \") self.bias = self.add_weight(name=\\\"bias\\\", shape=(self.filters,), initializer=\\\"zeros\\\", trainable=True) def call(self, inputs): if not self.initialized:\",\n \"layers, and another one for the unexpected layers. \\\"\\\"\\\" signature = dict(inspect.signature(func).parameters) signature.pop(\\\"kwargs\\\",\",\n \"inputs[\\\"attention_mask\\\"] is not None: # compute real output lengths according to convolution formula\",\n \"hidden_states = self.final_layer_norm(hidden_states) outputs = (hidden_states,) if output_attentions: outputs += (attn_weights,) return outputs\",\n \"attention_mask, token_type_ids])` - a dictionary with one or several input Tensors associated to\",\n \"None: super().__init__(**kwargs) self.conv = TFHubertWeightNormConv1D( filters=config.hidden_size, kernel_size=config.num_conv_pos_embeddings, groups=config.num_conv_pos_embedding_groups, explicit_padding=config.num_conv_pos_embeddings // 2, name=\\\"conv\\\", )\",\n \"`input_values` indices into associated vectors than the model's internal embedding lookup matrix. output_attentions\",\n \"attention_mask=attention_mask, training=training ) hidden_states = self.dropout(hidden_states, training=training) hidden_states = attn_residual + hidden_states hidden_states\",\n \"else src_len one_cst = tf.constant(1.0) mask = tf.cast(mask, dtype=one_cst.dtype) expanded_mask = tf.tile(mask[:, None,\",\n \"Optional[bool] = True, training: Optional[bool] = False, ) -> Union[TFBaseModelOutput, Tuple[tf.Tensor]]: all_hidden_states =\",\n \"tf.keras.layers.Dropout(config.final_dropout) self.lm_head = tf.keras.layers.Dense(config.vocab_size, name=\\\"lm_head\\\") def freeze_feature_extractor(self): \\\"\\\"\\\" Calling this function will disable\",\n \"f\\\" and `num_heads`: {num_heads}).\\\" ) self.scaling = self.head_dim**-0.5 self.is_decoder = is_decoder self.k_proj =\",\n \"Optional[bool] = False, output_hidden_states: Optional[bool] = False, return_dict: Optional[bool] = True, training: Optional[bool]\",\n \"[TFHubertGroupNormConvLayer(config, layer_id=0, name=f\\\"conv_layers.{0}\\\")] + [ TFHubertNoLayerNormConvLayer(config, layer_id=i + 1, name=f\\\"conv_layers.{i+1}\\\") for i in\",\n \"been depreciated \\\" \\\"and will be removed in Transformers v5. \\\" f\\\"Use `{self.__class__.__bases__[0].__name__}`\",\n \"self.activation = get_tf_activation(config.feat_extract_activation) def call(self, hidden_states: tf.Tensor) -> tf.Tensor: hidden_states = self.conv(hidden_states) hidden_states\",\n \"you want to \\\" \\\"use tf.layer.batch_normalization instead\\\" ) def _create_input_spec(self, input_shape): dim =\",\n \"embed_dim = shape_list(hidden_states) # get query proj query_states = self.q_proj(hidden_states) * self.scaling #\",\n \"kernel_size=kernel_size, groups=groups, padding=\\\"valid\\\", use_bias=True, bias_initializer=\\\"he_normal\\\", **kwargs, ) self.explicit_padding = explicit_padding self.filter_axis = 2\",\n \"for description) dropout_probability = np.random.uniform(0, 1) if training and (dropout_probability < self.config.layerdrop): #\",\n \"and the HuggingFace Inc. team. All rights reserved. # # Licensed under the\",\n \"be disabled in other modes than eager. if tf.executing_eagerly(): tf.debugging.assert_equal( shape_list(layer_head_mask), [self.num_heads], message=f\\\"Head\",\n \"units=config.hidden_size, kernel_initializer=get_initializer(config.initializer_range), bias_initializer=\\\"zeros\\\", name=\\\"projection\\\", ) self.dropout = tf.keras.layers.Dropout(rate=config.feat_proj_dropout) def call(self, hidden_states: tf.Tensor, training:\",\n \"TFHubertLayerNormConvLayer(config, layer_id=i, name=f\\\"conv_layers.{i}\\\") for i in range(config.num_feat_extract_layers) ] else: raise ValueError( f\\\"`config.feat_extract_norm` is\",\n \": - a single Tensor with `input_values` only and nothing else: `model(inputs_ids)` -\",\n \"trying to normalize your batch axis. Do you want to \\\" \\\"use tf.layer.batch_normalization\",\n \"add this exception if \\\"args\\\" in output: if output[\\\"args\\\"] is not None and\",\n \"None) return TFBaseModelOutput( last_hidden_state=hidden_states, hidden_states=all_hidden_states, attentions=all_self_attentions, ) @keras_serializable class TFHubertMainLayer(tf.keras.layers.Layer): config_class = HubertConfig\",\n \"self.layer_norm(hidden_states) hidden_states, attn_weights, _ = self.attention( hidden_states, attention_mask=attention_mask, training=training ) hidden_states = self.dropout(hidden_states,\",\n \"is_instance_norm: broadcast_shape[self.axis] = input_shape[self.axis] // self.groups broadcast_shape.insert(self.axis, self.groups) else: broadcast_shape[self.axis] = self.groups return\",\n \"the first positional arguments. This second option is useful when using [`tf.keras.Model.fit`] method\",\n \"SavedModel TF calls the method with LayerCall.__call__(args, **kwargs) # So to respect the\",\n \"and another one for the unexpected layers. \\\"\\\"\\\" signature = dict(inspect.signature(func).parameters) signature.pop(\\\"kwargs\\\", None)\",\n \"self.initialized = False self.kernel_norm_axes = tf.constant([0, 1]) def _init_norm(self): \\\"\\\"\\\"Set the norm of\",\n \"None: output[k] = v else: raise ValueError(f\\\"Data of type {type(v)} is not allowed\",\n \"int, num_heads: int, dropout: float = 0.0, is_decoder: bool = False, bias: bool\",\n \"from transformers.models.wav2vec2.modeling_tf_wav2vec2.input_values_processing def input_values_processing(func, config, input_values, **kwargs): \\\"\\\"\\\" Process the input of each\",\n \"Version 2.0 (the \\\"License\\\"); # you may not use this file except in\",\n \"attn_weights = tf.reshape(attn_weights, (bsz, self.num_heads, tgt_len, src_len)) + attention_mask attn_weights = tf.reshape(attn_weights, (bsz\",\n \"\\\"HubertConfig\\\" TF_HUBERT_PRETRAINED_MODEL_ARCHIVE_LIST = [ \\\"facebook/hubert-base-ls960\\\", # See all Hubert models at https://huggingface.co/models?filter=hubert ]\",\n \"will be removed in a future version, use `input_values` instead.\\\", FutureWarning, ) output[\\\"input_values\\\"]\",\n \"max(num_masked_spans, min_masks) # make sure num masked indices <= sequence_length if num_masked_spans *\",\n \"conv_layers def call(self, input_values): hidden_states = tf.expand_dims(input_values, -1) for conv_layer in self.conv_layers: hidden_states\",\n \"hidden_states = tf.expand_dims(input_values, -1) for conv_layer in self.conv_layers: hidden_states = conv_layer(hidden_states) return hidden_states\",\n \"( ModelOutput, add_start_docstrings, add_start_docstrings_to_model_forward, logging, replace_return_docstrings, ) from .configuration_hubert import HubertConfig logger =\",\n \"for computing the masked language modeling loss. Indices should be in `[-100, 0,\",\n \"type(input) == tf.Tensor: # Tensor names have always the pattern `name:id` then we\",\n \"class TFHubertGroupNormConvLayer(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, layer_id: int = 0, **kwargs: Any) ->\",\n \"return hidden_states # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2SamePadLayer with Wav2Vec2->Hubert class TFHubertSamePadLayer(tf.keras.layers.Layer): def __init__(self, num_conv_pos_embeddings,\",\n \"(bsz, self.num_heads, tgt_len, src_len)) return attn_output, attn_weights, past_key_value # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2FeedForward with\",\n \"to the parameters name, i.e. `input_values = tf.keras.Input(shape=(128,), dtype='float32', name=\\\"input_values\\\")` otherwise the order\",\n \"= 2 self.initialized = False self.kernel_norm_axes = tf.constant([0, 1]) def _init_norm(self): \\\"\\\"\\\"Set the\",\n \"be used in eager mode, in graph mode the value will always be\",\n \"= outputs[0] hidden_states = self.dropout(hidden_states, training=inputs[\\\"training\\\"]) logits = self.lm_head(hidden_states) if labels is not\",\n \"training=training, ) inputs[\\\"output_hidden_states\\\"] = ( inputs[\\\"output_hidden_states\\\"] if inputs[\\\"output_hidden_states\\\"] else self.config.output_hidden_states ) inputs[\\\"output_attentions\\\"] =\",\n \"is_decoder: bool = False, bias: bool = True, **kwargs, ): super().__init__(**kwargs) self.embed_dim =\",\n \"# skip the layer continue layer_outputs = layer_module( hidden_states=hidden_states, attention_mask=attention_mask, output_attentions=output_attentions, training=training, )\",\n \"tf.where( tf.cast(mask_time_indices[:, :, tf.newaxis], tf.bool), self.masked_spec_embed[tf.newaxis, tf.newaxis, :], hidden_states, ) elif self.config.mask_time_prob >\",\n \"token_type_ids=token_type_ids, position_ids=position_ids, head_mask=head_mask, inputs_embeds=inputs_embeds, output_attentions=output_attentions, output_hidden_states=output_hidden_states, return_dict=return_dict, training=training, ) inputs[\\\"output_hidden_states\\\"] = ( inputs[\\\"output_hidden_states\\\"]\",\n \"= past_key_value[1] elif is_cross_attention: # cross_attentions key_states = self._shape(self.k_proj(key_value_states), -1, bsz) value_states =\",\n \"i in range(config.num_feat_extract_layers - 1) ] elif config.feat_extract_norm == \\\"layer\\\": conv_layers = [\",\n \"if layer_id > 0 else 1 self.out_conv_dim = config.conv_dim[layer_id] self.conv = tf.keras.layers.Conv1D( filters=self.out_conv_dim,\",\n \"config, **kwargs): super().__init__(config, **kwargs) warnings.warn( f\\\"The class `{self.__class__.__name__}` has been depreciated \\\" \\\"and\",\n \"along time axis with given mask_time_indices hidden_states = tf.where( tf.cast(mask_time_indices[:, :, tf.newaxis], tf.bool),\",\n \"Wav2Vec2->Hubert class TFHubertGroupNorm(tf.keras.layers.Layer): \\\"\\\"\\\" From tensorflow-addons https://www.tensorflow.org/addons/api_docs/python/tfa/layers/GroupNormalization \\\"\\\"\\\" def __init__( self, groups: int\",\n \"/ mask_length + tf.random.uniform((1,))) num_masked_spans = max(num_masked_spans, min_masks) # make sure num masked\",\n \"= TFHubertForCTC.from_pretrained(\\\"facebook/hubert-base-960h\\\") >>> def map_to_array(batch): ... speech, _ = sf.read(batch[\\\"file\\\"]) ... batch[\\\"speech\\\"] =\",\n \"< self.groups: raise ValueError( \\\"Number of groups (\\\" + str(self.groups) + \\\") cannot\",\n \"= axis self.epsilon = epsilon self.center = center self.scale = scale self.beta_initializer =\",\n \"\\\"\\\"\\\" src_len = shape_list(mask)[1] tgt_len = tgt_len if tgt_len is not None else\",\n \"= config self.hubert = TFHubertMainLayer(config, name=\\\"hubert\\\") @add_start_docstrings_to_model_forward(HUBERT_INPUTS_DOCSTRING) @replace_return_docstrings(output_type=TFBaseModelOutput, config_class=_CONFIG_FOR_DOC) def call( self, input_values:\",\n \"Hubert model.\\\"\\\"\\\" import inspect import warnings from typing import Any, Dict, Optional, Tuple,\",\n \"you want more control over how to convert `input_values` indices into associated vectors\",\n \"axis=-1) if layer_head_mask is not None: # The tf.debugging asserts are not compliant\",\n \"*sentence A* token, - 1 corresponds to a *sentence B* token. [What are\",\n \"self.num_heads, tgt_len, src_len)) return attn_output, attn_weights, past_key_value # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2FeedForward with Wav2Vec2->Hubert\",\n \"the input Tensors in the first positional argument : - a single Tensor\",\n \"element is batch size and 2nd is timesteps attention_mask: optional padding mask of\",\n \"to be one of ['group', 'layer']\\\" ) self.conv_layers = conv_layers def call(self, input_values):\",\n \"sure that offset samples are < sequence_length uniform_dist = tf.ones((batch_size, sequence_length - (mask_length\",\n \"and/or along feature axis according to [SpecAugment](https://arxiv.org/abs/1904.08779). \\\"\\\"\\\" batch_size, sequence_length, hidden_size = shape_list(hidden_states)\",\n \"(`bool`, *optional*): Whether or not to return a [`~file_utils.ModelOutput`] instead of a plain\",\n \"= key_value_states is not None bsz, tgt_len, embed_dim = shape_list(hidden_states) # get query\",\n \"pair_indices pair_indices = tf.transpose(tf.concat([broad_casted_batch_dims, tf.reshape(batch_indices, [1, -1])], 0)) # scatter values to pair\",\n \"value will always be set to True. training (`bool`, *optional*, defaults to `False``):\",\n \"is not None: if tf.reduce_max(labels) >= self.config.vocab_size: raise ValueError(f\\\"Label values must be <=\",\n \"tgt_len, src_len)) + attention_mask attn_weights = tf.reshape(attn_weights, (bsz * self.num_heads, tgt_len, src_len)) attn_weights\",\n \"self.add_weight( shape=shape, name=\\\"gamma\\\", initializer=self.gamma_initializer, regularizer=self.gamma_regularizer, constraint=self.gamma_constraint, ) else: self.gamma = None def _add_beta_weight(self,\",\n \"the head is **masked**. inputs_embeds (`np.ndarray` or `tf.Tensor` of shape `({0}, hidden_size)`, *optional*):\",\n \"\\\"beta_regularizer\\\": tf.keras.regularizers.serialize(self.beta_regularizer), \\\"gamma_regularizer\\\": tf.keras.regularizers.serialize(self.gamma_regularizer), \\\"beta_constraint\\\": tf.keras.constraints.serialize(self.beta_constraint), \\\"gamma_constraint\\\": tf.keras.constraints.serialize(self.gamma_constraint), } base_config = super().get_config() return\",\n \"def _apply_normalization(self, reshaped_inputs, input_shape): group_shape = tf.keras.backend.int_shape(reshaped_inputs) group_reduction_axes = list(range(1, len(group_shape))) is_instance_norm =\",\n \"generate indices & apply SpecAugment along time axis mask_time_indices = _compute_mask_indices( (batch_size, sequence_length),\",\n \"kwargs_call=kwargs, ) hidden_states = self.feature_extractor( tf.cast(inputs[\\\"input_values\\\"], tf.float32), training=inputs[\\\"training\\\"] ) if inputs[\\\"attention_mask\\\"] is not\",\n \"input_values, \\\"token_type_ids\\\": token_type_ids})` </Tip> Args: config ([`HubertConfig`]): Model configuration class with all the\",\n \"as tf from ...activations_tf import get_tf_activation from ...modeling_tf_outputs import TFBaseModelOutput, TFCausalLMOutput from ...modeling_tf_utils\",\n \"License. \\\"\\\"\\\" TensorFlow Hubert model.\\\"\\\"\\\" import inspect import warnings from typing import Any,\",\n \"and [`PreTrainedTokenizer.encode`] for details. [What are input IDs?](../glossary#input-ids) attention_mask (`np.ndarray` or `tf.Tensor` of\",\n \"= False) -> tf.Tensor: hidden_states = self.intermediate_dense(hidden_states) hidden_states = self.intermediate_act_fn(hidden_states) hidden_states = self.intermediate_dropout(hidden_states,\",\n \"self.config.mask_time_prob > 0: # generate indices & apply SpecAugment along time axis mask_time_indices\",\n \"docstring: `model([input_values, attention_mask])` or `model([input_values, attention_mask, token_type_ids])` - a dictionary with one or\",\n \"shape `({0})`): Indices of input sequence tokens in the vocabulary. Indices can be\",\n \"of masked spans Adapted from [fairseq's data_utils.py](https://github.com/pytorch/fairseq/blob/e0788f7007a8473a76db573985031f3c94201e79/fairseq/data/data_utils.py#L376). \\\"\\\"\\\" batch_size, sequence_length = shape if\",\n \"the self-attention modules. Mask values selected in `[0, 1]`: - 1 indicates the\",\n \"if config.do_stable_layer_norm: self.encoder = TFHubertEncoderStableLayerNorm(config, name=\\\"encoder\\\") else: self.encoder = TFHubertEncoder(config, name=\\\"encoder\\\") def build(self,\",\n \"return indices # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2._scatter_values_on_batch_indices def _scatter_values_on_batch_indices(values, batch_indices, output_shape): \\\"\\\"\\\" Scatter function\",\n \"Adapted from [fairseq's data_utils.py](https://github.com/pytorch/fairseq/blob/e0788f7007a8473a76db573985031f3c94201e79/fairseq/data/data_utils.py#L376). \\\"\\\"\\\" batch_size, sequence_length = shape if mask_length < 1:\",\n \"src_len = shape_list(mask)[1] tgt_len = tgt_len if tgt_len is not None else src_len\",\n \"when not being attended to labels_mask = tf.cast(labels >= 0, tf.int32) target_lengths =\",\n \"head on top for Connectionist Temporal Classification (CTC).\\\"\\\"\\\", HUBERT_START_DOCSTRING, ) class TFHubertForCTC(TFHubertPreTrainedModel): def\",\n \"self.groups return broadcast_shape # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2WeightNormConv1D with Wav2Vec2->Hubert class TFHubertWeightNormConv1D(tf.keras.layers.Conv1D): \\\"\\\"\\\"Adapted from\",\n \"else: output[parameter_names[i]] = input elif isinstance(input, allowed_types) or input is None: output[parameter_names[i]] =\",\n \"always the pattern `name:id` then we check only the # `name` part tensor_name\",\n \"dropout: float = 0.0, is_decoder: bool = False, bias: bool = True, **kwargs,\",\n \"tf.keras.layers.Dropout(config.activation_dropout) self.intermediate_dense = tf.keras.layers.Dense( units=config.intermediate_size, kernel_initializer=get_initializer(config.initializer_range), bias_initializer=\\\"zeros\\\", name=\\\"intermediate_dense\\\", ) self.intermediate_act_fn = get_tf_activation(config.hidden_act) self.output_dense\",\n \"1) ] elif config.feat_extract_norm == \\\"layer\\\": conv_layers = [ TFHubertLayerNormConvLayer(config, layer_id=i, name=f\\\"conv_layers.{i}\\\") for\",\n \"True self.groups = groups self.axis = axis self.epsilon = epsilon self.center = center\",\n \"self.groups) else: broadcast_shape[self.axis] = self.groups return broadcast_shape # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2WeightNormConv1D with Wav2Vec2->Hubert\",\n \"a given shape Args: shape: the the shape for which to compute masks.\",\n \"layer_id > 0 else 1 self.out_conv_dim = config.conv_dim[layer_id] self.conv = tf.keras.layers.Conv1D( filters=self.out_conv_dim, kernel_size=config.conv_kernel[layer_id],\",\n \"TFBaseModelOutput, TFCausalLMOutput from ...modeling_tf_utils import TFPreTrainedModel, booleans_processing, get_initializer, keras_serializable from ...tf_utils import shape_list\",\n \"super().build(input_shape) def call(self, inputs): input_shape = tf.keras.backend.int_shape(inputs) tensor_input_shape = tf.shape(inputs) reshaped_inputs, group_shape =\",\n \"continue else: raise ValueError(f\\\"Data of type {type(v)} is not allowed only {allowed_types} is\",\n \"return hidden_states # Copied from transformers.models.bart.modeling_tf_bart.TFBartAttention with TFBart->TFHubert class TFHubertAttention(tf.keras.layers.Layer): \\\"\\\"\\\"Multi-headed attention from\",\n \"are checked at build time since TF 2.7, so we need to account\",\n \"epsilon=config.layer_norm_eps, name=\\\"final_layer_norm\\\" ) def call( self, hidden_states: tf.Tensor, attention_mask: Optional[tf.Tensor] = None, output_attentions:\",\n \"= self.dropout(hidden_states, training=training) for i, layer_module in enumerate(self.layer): if output_hidden_states: all_hidden_states = all_hidden_states\",\n \"size as shape, which will prevent masking padded elements mask_prob: probability for each\",\n \"= None if not inputs[\\\"return_dict\\\"]: output = (logits,) + outputs[1:] return ((loss,) +\",\n \"save Tuple(tf.Tensor, tf.Tensor) of # all previous decoder key/value_states. Further calls to uni-directional\",\n \"= get_tf_activation(config.hidden_act) self.output_dense = tf.keras.layers.Dense( units=config.hidden_size, kernel_initializer=get_initializer(config.initializer_range), bias_initializer=\\\"zeros\\\", name=\\\"output_dense\\\", ) self.output_dropout = tf.keras.layers.Dropout(config.hidden_dropout)\",\n \"self.scaling = self.head_dim**-0.5 self.is_decoder = is_decoder self.k_proj = tf.keras.layers.Dense(embed_dim, use_bias=bias, name=\\\"k_proj\\\") self.q_proj =\",\n \"= (dim,) if self.center: self.beta = self.add_weight( shape=shape, name=\\\"beta\\\", initializer=self.beta_initializer, regularizer=self.beta_regularizer, constraint=self.beta_constraint, )\",\n \"input elif isinstance(input, allowed_types) or input is None: output[parameter_names[i]] = input else: raise\",\n \"shape=(int(self.weight_v.shape[self.filter_axis]), 1, 1), initializer=\\\"ones\\\", dtype=self.weight_v.dtype, trainable=True, ) self.bias = self.add_weight(name=\\\"bias\\\", shape=(self.filters,), initializer=\\\"zeros\\\", trainable=True)\",\n \"use the model in training mode (some modules like dropout modules have different\",\n \"import tensorflow as tf from ...activations_tf import get_tf_activation from ...modeling_tf_outputs import TFBaseModelOutput, TFCausalLMOutput\",\n \"output_hidden_states=inputs[\\\"output_hidden_states\\\"], return_dict=inputs[\\\"return_dict\\\"], training=inputs[\\\"training\\\"], ) hidden_states = outputs[0] hidden_states = self.dropout(hidden_states, training=inputs[\\\"training\\\"]) logits =\",\n \"under the Apache License, Version 2.0 (the \\\"License\\\"); # you may not use\",\n \"message=f\\\"Attention mask should be of size {(bsz, 1, tgt_len, src_len)}, but is {shape_list(attention_mask)}\\\",\",\n \"config self.feature_extractor = TFHubertFeatureEncoder(config, name=\\\"feature_extractor\\\") self.feature_projection = TFHubertFeatureProjection(config, name=\\\"feature_projection\\\") if config.do_stable_layer_norm: self.encoder =\",\n \"names given in the docstring: `model({\\\"input_values\\\": input_values, \\\"token_type_ids\\\": token_type_ids})` </Tip> Args: config ([`HubertConfig`]):\",\n \"self.center: self.beta = self.add_weight( shape=shape, name=\\\"beta\\\", initializer=self.beta_initializer, regularizer=self.beta_regularizer, constraint=self.beta_constraint, ) else: self.beta =\",\n \"key, value proj if is_cross_attention and past_key_value is not None: # reuse k,v,\",\n \"proj_shape) key_states = tf.reshape(key_states, proj_shape) value_states = tf.reshape(value_states, proj_shape) src_len = shape_list(key_states)[1] attn_weights\",\n \"axis. Do you want to \\\" \\\"use tf.layer.batch_normalization instead\\\" ) def _create_input_spec(self, input_shape):\",\n \"head_mask=inputs[\\\"head_mask\\\"], inputs_embeds=inputs[\\\"inputs_embeds\\\"], output_attentions=inputs[\\\"output_attentions\\\"], output_hidden_states=inputs[\\\"output_hidden_states\\\"], return_dict=inputs[\\\"return_dict\\\"], training=inputs[\\\"training\\\"], ) return outputs def serving_output(self, output): hs\",\n \"Tuple, Union import numpy as np import tensorflow as tf from ...activations_tf import\",\n \"encoder so that its parameter will not be updated during training. \\\"\\\"\\\" self.hubert.feature_extractor.trainable\",\n \"if self.config.mask_feature_prob > 0: mask_feature_indices = _compute_mask_indices( (batch_size, hidden_size), mask_prob=self.config.mask_feature_prob, mask_length=self.config.mask_feature_length, ) hidden_states\",\n \"# compute loss >>> target_transcription = \\\"A MAN SAID TO THE UNIVERSE SIR\",\n \"the attentions tensors of all attention layers. See `attentions` under returned tensors for\",\n \"_get_reshaped_weights(self, input_shape): broadcast_shape = self._create_broadcast_shape(input_shape) gamma = None beta = None if self.scale:\",\n \"config: HubertConfig, **kwargs: Any) -> None: super().__init__(**kwargs) if config.feat_extract_norm == \\\"group\\\": conv_layers =\",\n \"= False, bias: bool = True, **kwargs, ): super().__init__(**kwargs) self.embed_dim = embed_dim self.num_heads\",\n \"`model([input_values, attention_mask])` or `model([input_values, attention_mask, token_type_ids])` - a dictionary with one or several\",\n \"this second option, there are three possibilities you can use to gather all\",\n \"from transformers.models.wav2vec2.modeling_tf_wav2vec2._compute_mask_indices def _compute_mask_indices( shape: Tuple[int, int], mask_prob: float, mask_length: int, min_masks: int\",\n \"self.dropout = tf.keras.layers.Dropout(config.hidden_dropout) self.layer = [TFHubertEncoderLayer(config, name=f\\\"layers.{i}\\\") for i in range(config.num_hidden_layers)] def call(\",\n \"* self.num_heads, tgt_len, src_len)}, but is {shape_list(attn_weights)}\\\", ) if attention_mask is not None:\",\n \"int = 0, **kwargs: Any) -> None: super().__init__(**kwargs) self.in_conv_dim = config.conv_dim[layer_id] if layer_id\",\n \"range(config.num_feat_extract_layers) ] else: raise ValueError( f\\\"`config.feat_extract_norm` is {config.feat_extract_norm}, but has to be one\",\n \"The tf.debugging asserts are not compliant with XLA then they # have to\",\n \"for the tokens with labels in `[0, ..., config.vocab_size]` Returns: Example: ```python >>>\",\n \"during the training. Args: func (`callable`): The callable function of the TensorFlow model.\",\n \"of the span to be masked. this will be multiplied by number of\",\n \"loading pretrained models. \\\"\\\"\\\" config_class = HubertConfig base_model_prefix = \\\"hubert\\\" main_input_name = \\\"input_values\\\"\",\n \"spans for a given shape Args: shape: the the shape for which to\",\n \"License, Version 2.0 (the \\\"License\\\"); # you may not use this file except\",\n \"inputs_embeds=inputs_embeds, output_attentions=output_attentions, output_hidden_states=output_hidden_states, return_dict=return_dict, training=training, ) inputs[\\\"output_hidden_states\\\"] = ( inputs[\\\"output_hidden_states\\\"] if inputs[\\\"output_hidden_states\\\"] else\",\n \"class TFHubertFeatureExtractor(TFHubertFeatureEncoder): def __init__(self, config, **kwargs): super().__init__(config, **kwargs) warnings.warn( f\\\"The class `{self.__class__.__name__}` has\",\n \"= hidden_states hidden_states = self.layer_norm(hidden_states) hidden_states, attn_weights, _ = self.attention( hidden_states, attention_mask=attention_mask, training=training\",\n \"inputs as keyword arguments (like PyTorch models), or - having all inputs as\",\n \"...modeling_tf_outputs import TFBaseModelOutput, TFCausalLMOutput from ...modeling_tf_utils import TFPreTrainedModel, booleans_processing, get_initializer, keras_serializable from ...tf_utils\",\n \"is also a [tf.keras.Model](https://www.tensorflow.org/api_docs/python/tf/keras/Model) subclass. Use it as a regular TF 2.0 Keras\",\n \"in output: if output[\\\"args\\\"] is not None and type(output[\\\"args\\\"]) == tf.Tensor: tensor_name =\",\n \"TF 2.7, so we need to account for padding input_shape[-2] += self.explicit_padding *\",\n \"output.update(booleans_processing(config=config, **boolean_dict)) return output # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2._sample_without_replacement def _sample_without_replacement(distribution, num_samples): \\\"\\\"\\\" Categorical\",\n \"for tokens that are **masked**. [What are attention masks?](../glossary#attention-mask) token_type_ids (`np.ndarray` or `tf.Tensor`\",\n \"masking padded elements mask_prob: probability for each token to be chosen as start\",\n \"\\\" \\\"use tf.layer.batch_normalization instead\\\" ) def _create_input_spec(self, input_shape): dim = input_shape[self.axis] self.input_spec =\",\n \"self.beta_regularizer = tf.keras.regularizers.get(beta_regularizer) self.gamma_regularizer = tf.keras.regularizers.get(gamma_regularizer) self.beta_constraint = tf.keras.constraints.get(beta_constraint) self.gamma_constraint = tf.keras.constraints.get(gamma_constraint) self._check_axis()\",\n \"- 0 for tokens that are **masked**. [What are attention masks?](../glossary#attention-mask) token_type_ids (`np.ndarray`\",\n \"tf.reshape( tf.broadcast_to(tf.expand_dims(tf.range(indices_shape[0]), axis=-1), indices_shape), [1, -1] ) # transform batch_indices to pair_indices pair_indices\",\n \"self.scale = scale self.beta_initializer = tf.keras.initializers.get(beta_initializer) self.gamma_initializer = tf.keras.initializers.get(gamma_initializer) self.beta_regularizer = tf.keras.regularizers.get(beta_regularizer) self.gamma_regularizer\",\n \"model = TFHubertModel.from_pretrained(\\\"facebook/hubert-base-960h\\\") >>> def map_to_array(batch): ... speech, _ = sf.read(batch[\\\"file\\\"]) ... batch[\\\"speech\\\"]\",\n \"predicted_ids = tf.argmax(logits, axis=-1) >>> transcription = processor.decode(predicted_ids[0]) >>> # compute loss >>>\",\n \"if tf.executing_eagerly(): tf.debugging.assert_equal( shape_list(layer_head_mask), [self.num_heads], message=f\\\"Head mask for a single layer should be\",\n \"self.config.output_hidden_states else None attns = tf.convert_to_tensor(output.attentions) if self.config.output_attentions else None return TFCausalLMOutput(logits=output.logits, hidden_states=hs,\",\n \"class to handle weights initialization and a simple interface for downloading and loading\",\n \"`(batch_size, sequence_length)`, *optional*): Labels for computing the masked language modeling loss. Indices should\",\n \"copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by\",\n \"tf.layer.batch_normalization instead\\\" ) def _create_input_spec(self, input_shape): dim = input_shape[self.axis] self.input_spec = tf.keras.layers.InputSpec(ndim=len(input_shape), axes={self.axis:\",\n \"Wav2Vec2Processor.from_pretrained(\\\"facebook/hubert-base-960h\\\") >>> model = TFHubertForCTC.from_pretrained(\\\"facebook/hubert-base-960h\\\") >>> def map_to_array(batch): ... speech, _ = sf.read(batch[\\\"file\\\"])\",\n \"= TFHubertSamePadLayer(config.num_conv_pos_embeddings) self.activation = get_tf_activation(config.feat_extract_activation) def call(self, hidden_states: tf.Tensor) -> tf.Tensor: hidden_states =\",\n \"TFHubertForCTC >>> from datasets import load_dataset >>> import soundfile as sf >>> processor\",\n \"Scatter function as in PyTorch with indices in format (batch_dim, indixes) \\\"\\\"\\\" indices_shape\",\n \"Optional[tf.Tensor] = None, token_type_ids: Optional[tf.Tensor] = None, position_ids: Optional[tf.Tensor] = None, head_mask: Optional[tf.Tensor]\",\n \"key/value_states to current projected key/value_states (third \\\"elif\\\" case) # if encoder bi-directional self-attention\",\n \"= TFHubertWeightNormConv1D( filters=config.hidden_size, kernel_size=config.num_conv_pos_embeddings, groups=config.num_conv_pos_embedding_groups, explicit_padding=config.num_conv_pos_embeddings // 2, name=\\\"conv\\\", ) self.padding = TFHubertSamePadLayer(config.num_conv_pos_embeddings)\",\n \"`[bsz, 1, tgt_seq_len, src_seq_len]`. \\\"\\\"\\\" src_len = shape_list(mask)[1] tgt_len = tgt_len if tgt_len\",\n \"so that its parameter will not be updated during training. \\\"\\\"\\\" self.hubert.feature_extractor.trainable =\",\n \"but got `mask_length`: {mask_length} and `sequence_length`: {sequence_length}`\\\" ) # compute number of masked\",\n \"not be updated during training. \\\"\\\"\\\" warnings.warn( \\\"The method `freeze_feature_extractor` is deprecated and\",\n \"now - see https://github.com/tensorflow/tensorflow/issues/9260 for more info \\\"\\\"\\\" z = -tf.math.log(tf.random.uniform(shape_list(distribution), 0, 1))\",\n \"are attention masks?](../glossary#attention-mask) token_type_ids (`np.ndarray` or `tf.Tensor` of shape `({0})`, *optional*): Segment token\",\n \"= TFHubertPositionalConvEmbedding(config, name=\\\"pos_conv_embed\\\") self.layer_norm = tf.keras.layers.LayerNormalization(epsilon=config.layer_norm_eps, name=\\\"layer_norm\\\") self.dropout = tf.keras.layers.Dropout(config.hidden_dropout) self.layer = [TFHubertEncoderLayer(config,\",\n \"= sf.read(batch[\\\"file\\\"]) ... batch[\\\"speech\\\"] = speech ... return batch >>> ds = load_dataset(\\\"hf-internal-testing/librispeech_asr_dummy\\\",\",\n \"= tf.reshape(attn_weights, (bsz * self.num_heads, tgt_len, src_len)) attn_weights = tf.nn.softmax(attn_weights, axis=-1) if layer_head_mask\",\n \"labels_mask = tf.cast(labels >= 0, tf.int32) target_lengths = tf.reduce_sum(labels_mask, axis=-1) loss = tf.nn.ctc_loss(\",\n \"apply SpecAugment along feature axis if self.config.mask_feature_prob > 0: mask_feature_indices = _compute_mask_indices( (batch_size,\",\n \"or v is None: output[k] = v else: raise ValueError(f\\\"Data of type {type(v)}\",\n \"else output return TFCausalLMOutput( loss=loss, logits=logits, hidden_states=outputs.hidden_states, attentions=outputs.attentions, ) def serving_output(self, output: TFCausalLMOutput)\",\n \"axis and/or along feature axis according to [SpecAugment](https://arxiv.org/abs/1904.08779). \\\"\\\"\\\" batch_size, sequence_length, hidden_size =\",\n \"config, input_values, **kwargs): \\\"\\\"\\\" Process the input of each TensorFlow model including the\",\n \"due to overlaps, the actual number will be smaller (unless no_overlap is True)\",\n \"mode, in graph mode the value in the config will be used instead.\",\n \"# if uni-directional self-attention (decoder) save Tuple(tf.Tensor, tf.Tensor) of # all previous decoder\",\n \"(`np.ndarray` or `tf.Tensor` of shape `({0})`, *optional*): Mask to avoid performing attention on\",\n \"(batch_size, hidden_size), mask_prob=self.config.mask_feature_prob, mask_length=self.config.mask_feature_length, ) hidden_states = tf.where(mask_feature_indices[:, tf.newaxis, :], hidden_states, 0) return\",\n \"samples are < sequence_length uniform_dist = tf.ones((batch_size, sequence_length - (mask_length - 1))) #\",\n \"a dictionary with one or several input Tensors associated to the input names\",\n \"Optional[bool] = None, return_dict: Optional[bool] = None, training: Optional[bool] = False, ) ->\",\n \"having all the tensors in the first argument of the model call function:\",\n \"= None, return_dict: Optional[bool] = None, training: Optional[bool] = False, ) -> Union[TFCausalLMOutput,\",\n \"be updated during training. \\\"\\\"\\\" warnings.warn( \\\"The method `freeze_feature_extractor` is deprecated and will\",\n \"= center self.scale = scale self.beta_initializer = tf.keras.initializers.get(beta_initializer) self.gamma_initializer = tf.keras.initializers.get(gamma_initializer) self.beta_regularizer =\",\n \"self.kernel self.weight_g = self.add_weight( name=\\\"weight_g\\\", shape=(int(self.weight_v.shape[self.filter_axis]), 1, 1), initializer=\\\"ones\\\", dtype=self.weight_v.dtype, trainable=True, ) self.bias\",\n \"Tuple[tf.Tensor]]: \\\"\\\"\\\" Returns: Example: ```python >>> from transformers import Wav2Vec2Processor, TFHubertModel >>> from\",\n \"same size as shape, which will prevent masking padded elements mask_prob: probability for\",\n \"tf.pad(inputs, ((0, 0), (self.explicit_padding, self.explicit_padding), (0, 0))) output = super().call(padded_inputs) return output #\",\n \"= hidden_states[:, : -self.num_pad_remove, :] return hidden_states class TFHubertFeatureEncoder(tf.keras.layers.Layer): def __init__(self, config: HubertConfig,\",\n \"self.dropout = tf.keras.layers.Dropout(config.hidden_dropout) self.layer_norm = tf.keras.layers.LayerNormalization(epsilon=config.layer_norm_eps, name=\\\"layer_norm\\\") self.feed_forward = TFHubertFeedForward(config, name=\\\"feed_forward\\\") self.final_layer_norm =\",\n \"currently requires having all the tensors in the first argument of the model\",\n \"self.groups, \\\"axis\\\": self.axis, \\\"epsilon\\\": self.epsilon, \\\"center\\\": self.center, \\\"scale\\\": self.scale, \\\"beta_initializer\\\": tf.keras.initializers.serialize(self.beta_initializer), \\\"gamma_initializer\\\": tf.keras.initializers.serialize(self.gamma_initializer),\",\n \"is {shape_list(attention_mask)}\\\", ) attention_mask = tf.cast(attention_mask, dtype=attn_weights.dtype) attn_weights = tf.reshape(attn_weights, (bsz, self.num_heads, tgt_len,\",\n \"offsets = tf.range(mask_length)[tf.newaxis, tf.newaxis, :] offsets = tf.tile(offsets, (batch_size, num_masked_spans, 1)) offsets =\",\n \"_create_input_spec(self, input_shape): dim = input_shape[self.axis] self.input_spec = tf.keras.layers.InputSpec(ndim=len(input_shape), axes={self.axis: dim}) def _add_gamma_weight(self, input_shape):\",\n \"build(self, input_shape): self._check_if_input_shape_is_none(input_shape) self._set_number_of_groups_for_instance_norm(input_shape) self._check_size_of_dimensions(input_shape) self._create_input_spec(input_shape) self._add_gamma_weight(input_shape) self._add_beta_weight(input_shape) self.built = True super().build(input_shape) def\",\n \"= [TFHubertGroupNormConvLayer(config, layer_id=0, name=f\\\"conv_layers.{0}\\\")] + [ TFHubertNoLayerNormConvLayer(config, layer_id=i + 1, name=f\\\"conv_layers.{i+1}\\\") for i\",\n \"one or several input Tensors IN THE ORDER given in the docstring: `model([input_values,\",\n \"key_value_states is not None bsz, tgt_len, embed_dim = shape_list(hidden_states) # get query proj\",\n \"current projected key/value_states (third \\\"elif\\\" case) # if encoder bi-directional self-attention `past_key_value` is\",\n \"def __init__(self, num_conv_pos_embeddings, **kwargs): super().__init__(**kwargs) self.num_pad_remove = 1 if num_conv_pos_embeddings % 2 ==\",\n \"0: raise ValueError( \\\"Number of groups (\\\" + str(self.groups) + \\\") must be\",\n \"= tf.tile(spec_aug_mask_idxs, (1, 1, mask_length)) spec_aug_mask_idxs = tf.reshape(spec_aug_mask_idxs, (batch_size, num_masked_spans * mask_length)) offsets\",\n \"of the self-attention modules. Mask values selected in `[0, 1]`: - 1 indicates\",\n \"tgt_len, src_len)}, but is {shape_list(attn_weights)}\\\", ) if attention_mask is not None: # The\",\n \"1 for tokens that are **not masked**, - 0 for tokens that are\",\n \"the range `[0, config.max_position_embeddings - 1]`. [What are position IDs?](../glossary#position-ids) head_mask (`np.ndarray` or\",\n \"stride in zip(self.config.conv_kernel, self.config.conv_stride): input_lengths = _conv_out_length(input_lengths, kernel_size, stride) return input_lengths def _mask_hidden_states(self,\",\n \"from typing import Any, Dict, Optional, Tuple, Union import numpy as np import\",\n \"shape if mask_length < 1: raise ValueError(\\\"`mask_length` has to be bigger than 0.\\\")\",\n \"decoder is_cross_attention = key_value_states is not None bsz, tgt_len, embed_dim = shape_list(hidden_states) #\",\n \"the feature encoder so that its parameters will not be updated during training.\",\n \"...tf_utils import shape_list from ...tokenization_utils_base import BatchEncoding from ...utils import ( ModelOutput, add_start_docstrings,\",\n \"-1, bsz) elif past_key_value is not None: # reuse k, v, self_attention key_states\",\n \"(input_shape[self.axis] // self.groups) == 1 if not is_instance_norm: outputs = tf.reshape(normalized_inputs, tensor_input_shape) else:\",\n \"kernel_size, stride) return input_lengths def _mask_hidden_states(self, hidden_states: tf.Tensor, mask_time_indices: Optional[tf.Tensor] = None): \\\"\\\"\\\"\",\n \"parameter_names: if name not in list(output.keys()) and name != \\\"args\\\": output[name] = kwargs.pop(name,\",\n \"or input is None: output[parameter_names[i]] = input else: raise ValueError( f\\\"Data of type\",\n \"mean=mean, variance=variance, scale=gamma, offset=beta, variance_epsilon=self.epsilon, ) return normalized_inputs def _get_reshaped_weights(self, input_shape): broadcast_shape =\",\n \"get_initializer, keras_serializable from ...tf_utils import shape_list from ...tokenization_utils_base import BatchEncoding from ...utils import\",\n \"config: HubertConfig, **kwargs): super().__init__(**kwargs) self.attention = TFHubertAttention( embed_dim=config.hidden_size, num_heads=config.num_attention_heads, dropout=config.attention_dropout, is_decoder=False, name=\\\"attention\\\", )\",\n \"\\\"\\\"\\\"Adapted from https://www.tensorflow.org/probability/api_docs/python/tfp/layers/weight_norm/WeightNorm\\\"\\\"\\\" def __init__(self, filters, kernel_size, groups, explicit_padding, **kwargs): super().__init__( filters=filters, kernel_size=kernel_size,\",\n \"tf.Tensor, key_value_states: Optional[tf.Tensor] = None, past_key_value: Optional[Tuple[Tuple[tf.Tensor]]] = None, attention_mask: Optional[tf.Tensor] = None,\",\n \"mask_feature_indices = _compute_mask_indices( (batch_size, hidden_size), mask_prob=self.config.mask_feature_prob, mask_length=self.config.mask_feature_length, ) hidden_states = tf.where(mask_feature_indices[:, tf.newaxis, :],\",\n \"can concat previous decoder key/value_states to current projected key/value_states (third \\\"elif\\\" case) #\",\n \"= TFHubertEncoder(config, name=\\\"encoder\\\") def build(self, input_shape: tf.TensorShape): self.masked_spec_embed = self.add_weight( shape=(self.config.hidden_size,), initializer=\\\"uniform\\\", trainable=True,\",\n \"Whether or not to return the hidden states of all layers. See `hidden_states`\",\n \"with a config file does not load the weights associated with the model,\",\n \"Tuple[tf.Tensor, Optional[tf.Tensor]]: \\\"\\\"\\\"Input shape: Batch x Time x Channel\\\"\\\"\\\" # if key_value_states are\",\n \">>> model = TFHubertModel.from_pretrained(\\\"facebook/hubert-base-960h\\\") >>> def map_to_array(batch): ... speech, _ = sf.read(batch[\\\"file\\\"]) ...\",\n \"stride + 1 for kernel_size, stride in zip(self.config.conv_kernel, self.config.conv_stride): input_lengths = _conv_out_length(input_lengths, kernel_size,\",\n \"output_shape) # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2._compute_mask_indices def _compute_mask_indices( shape: Tuple[int, int], mask_prob: float, mask_length:\",\n \"None, inputs_embeds: Optional[tf.Tensor] = None, output_attentions: Optional[bool] = None, output_hidden_states: Optional[bool] = None,\",\n \"= self.add_weight(name=\\\"bias\\\", shape=(self.filters,), initializer=\\\"zeros\\\", trainable=True) def call(self, inputs): if not self.initialized: self._init_norm() self.initialized\",\n \"mask_prob: probability for each token to be chosen as start of the span\",\n \"mask spec_aug_mask = _scatter_values_on_batch_indices( tf.ones_like(spec_aug_mask_idxs), spec_aug_mask_idxs, spec_aug_mask.shape ) return spec_aug_mask # Copied from\",\n \"# Tensor names have always the pattern `name:id` then we check only the\",\n \"# SpecAugment mask to fill spec_aug_mask = tf.zeros((batch_size, sequence_length), dtype=tf.int32) # uniform distribution\",\n \"= tf.cast(labels >= 0, tf.int32) target_lengths = tf.reduce_sum(labels_mask, axis=-1) loss = tf.nn.ctc_loss( logits=logits,\",\n \"= input_values else: raise ValueError( f\\\"Data of type {type(input_values)} is not allowed only\",\n \"= tf.keras.layers.Dropout(config.final_dropout) self.lm_head = tf.keras.layers.Dense(config.vocab_size, name=\\\"lm_head\\\") def freeze_feature_extractor(self): \\\"\\\"\\\" Calling this function will\",\n \"# Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2NoLayerNormConvLayer with Wav2Vec2->Hubert class TFHubertNoLayerNormConvLayer(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, layer_id:\",\n \"= shape_list(hidden_states) # `config.apply_spec_augment` can set masking to False if not getattr(self.config, \\\"apply_spec_augment\\\",\",\n \"if inputs[\\\"training\\\"]: hidden_states = self._mask_hidden_states(hidden_states, mask_time_indices=mask_time_indices) encoder_outputs = self.encoder( hidden_states, attention_mask=attention_mask, output_attentions=inputs[\\\"output_attentions\\\"], output_hidden_states=inputs[\\\"output_hidden_states\\\"],\",\n \"instead. return_dict (`bool`, *optional*): Whether or not to return a [`~file_utils.ModelOutput`] instead of\",\n \"= ( inputs[\\\"output_hidden_states\\\"] if inputs[\\\"output_hidden_states\\\"] else self.config.output_hidden_states ) inputs[\\\"output_attentions\\\"] = ( inputs[\\\"output_attentions\\\"] if\",\n \"else: raise ValueError( f\\\"`config.feat_extract_norm` is {config.feat_extract_norm}, but has to be one of ['group',\",\n \") hidden_states = outputs[0] hidden_states = self.dropout(hidden_states, training=inputs[\\\"training\\\"]) logits = self.lm_head(hidden_states) if labels\",\n \"for kernel_size, stride in zip(self.config.conv_kernel, self.config.conv_stride): input_lengths = _conv_out_length(input_lengths, kernel_size, stride) return input_lengths\",\n \"having all inputs as keyword arguments (like PyTorch models), or - having all\",\n \"input_shape, tensor_input_shape): group_shape = [tensor_input_shape[i] for i in range(len(input_shape))] is_instance_norm = (input_shape[self.axis] //\",\n \"axis: int = -1, epsilon: float = 1e-3, center: bool = True, scale:\",\n \"instead.\\\", FutureWarning, ) class TFHubertFeatureProjection(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs): super().__init__(**kwargs) self.layer_norm =\",\n \"if self.groups == -1: self.groups = dim def _check_size_of_dimensions(self, input_shape): dim = input_shape[self.axis]\",\n \">>> from transformers import Wav2Vec2Processor, TFHubertForCTC >>> from datasets import load_dataset >>> import\",\n \"dim}) def _add_gamma_weight(self, input_shape): dim = input_shape[self.axis] shape = (dim,) if self.scale: self.gamma\",\n \"LayerCall.__call__(args, **kwargs) # So to respect the proper output we have to add\",\n \") hidden_states = tf.where( tf.cast(mask_time_indices[:, :, tf.newaxis], tf.bool), self.masked_spec_embed[tf.newaxis, tf.newaxis, :], hidden_states, )\",\n \"Args: input_values (`np.ndarray`, `tf.Tensor`, `List[tf.Tensor]` ``Dict[str, tf.Tensor]` or `Dict[str, np.ndarray]` and each example\",\n \"with the License. # You may obtain a copy of the License at\",\n \"so we check for a real Tensor if type(input) == tf.Tensor: # Tensor\",\n \"self.config.layerdrop): # skip the layer continue layer_outputs = layer_module( hidden_states=hidden_states, attention_mask=attention_mask, output_attentions=output_attentions, training=training,\",\n \"model inherits from [`TFPreTrainedModel`]. Check the superclass documentation for the generic methods the\",\n \"build time since TF 2.7, so we need to account for padding input_shape[-2]\",\n \"in `[0, 1]`: - 1 for tokens that are **not masked**, - 0\",\n \"output[\\\"args\\\"].name.split(\\\":\\\")[0] output[tensor_name] = output[\\\"args\\\"] else: # `args` in this case is always the\",\n \"load the model weights. \\\"\\\"\\\" HUBERT_INPUTS_DOCSTRING = r\\\"\\\"\\\" Args: input_values (`np.ndarray`, `tf.Tensor`, `List[tf.Tensor]`\",\n \"= tf.keras.Input(shape=(128,), dtype='float32', name=\\\"input_values\\\")` otherwise the order of the tensors will not be\",\n \"return_dict=inputs[\\\"return_dict\\\"], training=inputs[\\\"training\\\"], ) hidden_states = outputs[0] hidden_states = self.dropout(hidden_states, training=inputs[\\\"training\\\"]) logits = self.lm_head(hidden_states)\",\n \"law or agreed to in writing, software # distributed under the License is\",\n \"output_attentions=inputs[\\\"output_attentions\\\"], output_hidden_states=inputs[\\\"output_hidden_states\\\"], return_dict=inputs[\\\"return_dict\\\"], training=inputs[\\\"training\\\"], ) hidden_states = outputs[0] hidden_states = self.dropout(hidden_states, training=inputs[\\\"training\\\"]) logits\",\n \"= input_shape[self.axis] if dim is None: raise ValueError( \\\"Axis \\\" + str(self.axis) +\",\n \"channels (\\\" + str(dim) + \\\").\\\" ) def _check_axis(self): if self.axis == 0:\",\n \"the input names given in the docstring: `model({\\\"input_values\\\": input_values, \\\"token_type_ids\\\": token_type_ids})` </Tip> Args:\",\n \"tensorflow-addons https://www.tensorflow.org/addons/api_docs/python/tfa/layers/GroupNormalization \\\"\\\"\\\" def __init__( self, groups: int = 32, axis: int =\",\n \"Tensors in the first positional argument : - a single Tensor with `input_values`\",\n \"input_shape): dim = input_shape[self.axis] if self.groups == -1: self.groups = dim def _check_size_of_dimensions(self,\",\n \"inputs[\\\"training\\\"]: hidden_states = self._mask_hidden_states(hidden_states, mask_time_indices=mask_time_indices) encoder_outputs = self.encoder( hidden_states, attention_mask=attention_mask, output_attentions=inputs[\\\"output_attentions\\\"], output_hidden_states=inputs[\\\"output_hidden_states\\\"], return_dict=inputs[\\\"return_dict\\\"],\",\n \"for i in range(config.num_feat_extract_layers - 1) ] elif config.feat_extract_norm == \\\"layer\\\": conv_layers =\",\n \"(`callable`): The callable function of the TensorFlow model. config ([`PretrainedConfig`]): The config of\",\n \"isinstance(input_values, (tuple, list)): for i, input in enumerate(input_values): # EagerTensors don't allow to\",\n \"range(config.num_hidden_layers)] def call( self, hidden_states: tf.Tensor, attention_mask: Optional[tf.Tensor] = None, output_attentions: Optional[bool] =\",\n \"the shape `({0})`): Indices of input sequence tokens in the vocabulary. Indices can\",\n \"{mask_length} and `sequence_length`: {sequence_length}`\\\" ) # compute number of masked spans in batch\",\n \">>> transcription = processor.decode(predicted_ids[0]) >>> # compute loss >>> target_transcription = \\\"A MAN\",\n \"[`BertTokenizer`]. See [`PreTrainedTokenizer.__call__`] and [`PreTrainedTokenizer.encode`] for details. [What are input IDs?](../glossary#input-ids) attention_mask (`np.ndarray`\",\n \"lists, one for the missing layers, and another one for the unexpected layers.\",\n \"(`np.ndarray` or `tf.Tensor` of shape `(num_heads,)` or `(num_layers, num_heads)`, *optional*): Mask to nullify\",\n \"to the parameter list {parameter_names} and will be ignored.\\\" ) continue else: raise\",\n \"not being attended to labels_mask = tf.cast(labels >= 0, tf.int32) target_lengths = tf.reduce_sum(labels_mask,\",\n \"self.is_decoder: # if cross_attention save Tuple(tf.Tensor, tf.Tensor) of all cross attention key/value_states. #\",\n \"Wav2Vec2->Hubert class TFHubertGroupNormConvLayer(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, layer_id: int = 0, **kwargs: Any)\",\n \"TensorFlow model including the booleans. In case of a list of symbolic inputs,\",\n \"len(input_shape) is_instance_norm = (input_shape[self.axis] // self.groups) == 1 if not is_instance_norm: broadcast_shape[self.axis] =\",\n \"disable the gradient computation for the feature encoder so that its parameter will\",\n \"= None, attention_mask: Optional[tf.Tensor] = None, layer_head_mask: Optional[tf.Tensor] = None, training: Optional[bool] =\",\n \"tf.int32) target_lengths = tf.reduce_sum(labels_mask, axis=-1) loss = tf.nn.ctc_loss( logits=logits, labels=labels, logit_length=input_lengths, label_length=target_lengths, blank_index=self.config.pad_token_id,\",\n \"\\\"but the layer received an input with shape \\\" + str(input_shape) + \\\".\\\"\",\n \"self.conv(hidden_states) hidden_states = self.padding(hidden_states) hidden_states = self.activation(hidden_states) return hidden_states # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2SamePadLayer\",\n \"size {(bsz, 1, tgt_len, src_len)}, but is {shape_list(attention_mask)}\\\", ) attention_mask = tf.cast(attention_mask, dtype=attn_weights.dtype)\",\n \"- 1 for tokens that are **not masked**, - 0 for tokens that\",\n \"key/value_states. Further calls to uni-directional self-attention # can concat previous decoder key/value_states to\",\n \"batch_size, sequence_length, hidden_size = shape_list(hidden_states) # `config.apply_spec_augment` can set masking to False if\",\n \"[hidden_states, all_hidden_states, all_self_attentions] if v is not None) return TFBaseModelOutput( last_hidden_state=hidden_states, hidden_states=all_hidden_states, attentions=all_self_attentions,\",\n \") self.explicit_padding = explicit_padding self.filter_axis = 2 self.initialized = False self.kernel_norm_axes = tf.constant([0,\",\n \"= tf.keras.initializers.get(beta_initializer) self.gamma_initializer = tf.keras.initializers.get(gamma_initializer) self.beta_regularizer = tf.keras.regularizers.get(beta_regularizer) self.gamma_regularizer = tf.keras.regularizers.get(gamma_regularizer) self.beta_constraint =\",\n \"also a [tf.keras.Model](https://www.tensorflow.org/api_docs/python/tf/keras/Model) subclass. Use it as a regular TF 2.0 Keras Model\",\n \"+ (hidden_states,) # add LayerDrop (see https://arxiv.org/abs/1909.11556 for description) dropout_probability = np.random.uniform(0, 1)\",\n \"transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2EncoderStableLayerNorm with Wav2Vec2->Hubert class TFHubertEncoderStableLayerNorm(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs): super().__init__(**kwargs) self.config =\",\n \"output_shape): \\\"\\\"\\\" Scatter function as in PyTorch with indices in format (batch_dim, indixes)\",\n \"= all_self_attentions + (layer_outputs[1],) # Add last layer if output_hidden_states: all_hidden_states = all_hidden_states\",\n \">>> loss = model(input_values, labels=labels).loss ```\\\"\\\"\\\" inputs = input_values_processing( func=self.call, config=self.config, input_values=input_values, attention_mask=attention_mask,\",\n \"other modes than eager. if tf.executing_eagerly(): tf.debugging.assert_equal( shape_list(attn_output), [bsz * self.num_heads, tgt_len, self.head_dim],\",\n \"return_dict: Optional[bool] = None, training: bool = False, ) -> Union[TFBaseModelOutput, Tuple[tf.Tensor]]: \\\"\\\"\\\"\",\n \"'layer']\\\" ) self.conv_layers = conv_layers def call(self, input_values): hidden_states = tf.expand_dims(input_values, -1) for\",\n \"attn_residual + hidden_states hidden_states = self.layer_norm(hidden_states) hidden_states = hidden_states + self.feed_forward(hidden_states) hidden_states =\",\n \"k, v, self_attention key_states = self._shape(self.k_proj(hidden_states), -1, bsz) value_states = self._shape(self.v_proj(hidden_states), -1, bsz)\",\n \"self.beta = None def _create_broadcast_shape(self, input_shape): broadcast_shape = [1] * len(input_shape) is_instance_norm =\",\n \"passing `input_values` you can choose to directly pass an embedded representation. This is\",\n \"more info \\\"\\\"\\\" z = -tf.math.log(tf.random.uniform(shape_list(distribution), 0, 1)) _, indices = tf.nn.top_k(distribution +\",\n \"mask_length > sequence_length: raise ValueError( f\\\"`mask_length` has to be smaller than `sequence_length`, but\",\n \"of the tensors will not be guaranteed during the training. Args: func (`callable`):\",\n \"\\\"\\\"\\\" TensorFlow Hubert model.\\\"\\\"\\\" import inspect import warnings from typing import Any, Dict,\",\n \"is_instance_norm = (input_shape[self.axis] // self.groups) == 1 if not is_instance_norm: broadcast_shape[self.axis] = input_shape[self.axis]\",\n \"tgt_len, self.head_dim], message=f\\\"`attn_output` should be of size {(bsz, self.num_heads, tgt_len, self.head_dim)}, but is\",\n \"all previous decoder key/value_states. Further calls to uni-directional self-attention # can concat previous\",\n \"name=f\\\"conv_layers.{i}\\\") for i in range(config.num_feat_extract_layers) ] else: raise ValueError( f\\\"`config.feat_extract_norm` is {config.feat_extract_norm}, but\",\n \"the model. Returns: Two lists, one for the missing layers, and another one\",\n \"= None, position_ids: Optional[tf.Tensor] = None, head_mask: Optional[tf.Tensor] = None, inputs_embeds: Optional[tf.Tensor] =\",\n \"hidden_states def call( self, input_values: tf.Tensor, attention_mask: Optional[tf.Tensor] = None, token_type_ids: Optional[tf.Tensor] =\",\n \"_set_number_of_groups_for_instance_norm(self, input_shape): dim = input_shape[self.axis] if self.groups == -1: self.groups = dim def\",\n \"self.kernel = tf.transpose(kernel) def build(self, input_shape): if not self.built: input_shape = input_shape.as_list() #\",\n \"chosen as start of the span to be masked. this will be multiplied\",\n \"+ \\\") must be a \\\" \\\"multiple of the number of channels (\\\"\",\n \"): inputs = input_values_processing( func=self.call, config=self.config, input_values=input_values, attention_mask=attention_mask, token_type_ids=token_type_ids, position_ids=position_ids, head_mask=head_mask, inputs_embeds=inputs_embeds, output_attentions=output_attentions,\",\n \"Optional[bool] = None, training: Optional[bool] = False, ) -> Union[TFCausalLMOutput, Tuple[tf.Tensor]]: r\\\"\\\"\\\" labels\",\n \"f\\\"Use `{self.__class__.__bases__[0].__name__}` instead.\\\", FutureWarning, ) class TFHubertFeatureProjection(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs): super().__init__(**kwargs)\",\n \"the model in training mode (some modules like dropout modules have different behaviors\",\n \"batch axis. Do you want to \\\" \\\"use tf.layer.batch_normalization instead\\\" ) def _create_input_spec(self,\",\n \"groups, explicit_padding, **kwargs): super().__init__( filters=filters, kernel_size=kernel_size, groups=groups, padding=\\\"valid\\\", use_bias=True, bias_initializer=\\\"he_normal\\\", **kwargs, ) self.explicit_padding\",\n \"warnings.warn( f\\\"The class `{self.__class__.__name__}` has been depreciated \\\" \\\"and will be removed in\",\n \"feature encoder so that its parameter will not be updated during training. \\\"\\\"\\\"\",\n \"output_attentions: Optional[bool] = False, output_hidden_states: Optional[bool] = False, return_dict: Optional[bool] = True, training:\",\n \"is not None: hidden_states = hidden_states * tf.expand_dims(attention_mask, -1) attention_mask = _expand_mask(attention_mask) else:\",\n \"this file except in compliance with the License. # You may obtain a\",\n \"without any specific head on top.\\\", HUBERT_START_DOCSTRING, ) class TFHubertModel(TFHubertPreTrainedModel): def __init__(self, config:\",\n \"model call function: `model(inputs)`. If you choose this second option, there are three\",\n \"`tf.Tensor` of shape `(num_heads,)` or `(num_layers, num_heads)`, *optional*): Mask to nullify selected heads\",\n \"if not is_instance_norm: broadcast_shape[self.axis] = input_shape[self.axis] // self.groups broadcast_shape.insert(self.axis, self.groups) else: broadcast_shape[self.axis] =\",\n \"= None, training: bool = False, ) -> Union[TFBaseModelOutput, Tuple[tf.Tensor]]: \\\"\\\"\\\" Returns: Example:\",\n \"number of channels (\\\" + str(dim) + \\\").\\\" ) if dim % self.groups\",\n \"to a *sentence B* token. [What are token type IDs?](../glossary#token-type-ids) position_ids (`np.ndarray` or\",\n \"= None, output_attentions: Optional[bool] = None, labels: Optional[tf.Tensor] = None, output_hidden_states: Optional[bool] =\",\n \"= hidden_states + position_embeddings hidden_states = self.dropout(hidden_states, training=training) for i, layer_module in enumerate(self.layer):\",\n \"\\\"\\\"\\\" Calling this function will disable the gradient computation for the feature encoder\",\n \"name=\\\"q_proj\\\") self.v_proj = tf.keras.layers.Dense(embed_dim, use_bias=bias, name=\\\"v_proj\\\") self.out_proj = tf.keras.layers.Dense(embed_dim, use_bias=bias, name=\\\"out_proj\\\") def _shape(self,\",\n \"self.built: input_shape = input_shape.as_list() # Conv1D output shapes are checked at build time\",\n \"behaviors between training and evaluation). \\\"\\\"\\\" @add_start_docstrings( \\\"The bare TFHubert Model transformer outputing\",\n \"tf.keras.constraints.Constraint = None, **kwargs, ): super().__init__(**kwargs) self.supports_masking = True self.groups = groups self.axis\",\n \"always be set to True. training (`bool`, *optional*, defaults to `False``): Whether or\",\n \"self.conv(hidden_states) hidden_states = self.activation(hidden_states) return hidden_states # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2LayerNormConvLayer with Wav2Vec2->Hubert class\",\n \"# from https://pytorch.org/docs/stable/generated/torch.nn.Conv1d.html return (input_length - kernel_size) // stride + 1 for kernel_size,\",\n \"taken # from https://pytorch.org/docs/stable/generated/torch.nn.Conv1d.html return (input_length - kernel_size) // stride + 1 for\",\n \"spec_aug_mask = tf.zeros((batch_size, sequence_length), dtype=tf.int32) # uniform distribution to sample from, make sure\",\n \"Tensor if type(input) == tf.Tensor: # Tensor names have always the pattern `name:id`\",\n \"self.feature_projection(hidden_states, training=inputs[\\\"training\\\"]) mask_time_indices = kwargs.get(\\\"mask_time_indices\\\", None) if inputs[\\\"training\\\"]: hidden_states = self._mask_hidden_states(hidden_states, mask_time_indices=mask_time_indices) encoder_outputs\",\n \"attention_mask from `[bsz, seq_len]` to `[bsz, 1, tgt_seq_len, src_seq_len]`. \\\"\\\"\\\" src_len = shape_list(mask)[1]\",\n \"tf.debugging asserts are not compliant with XLA then they # have to be\",\n \"(logits,) + outputs[1:] return ((loss,) + output) if loss is not None else\",\n \"= self.conv(hidden_states) hidden_states = self.padding(hidden_states) hidden_states = self.activation(hidden_states) return hidden_states # Copied from\",\n \"past_key_value is not None: # reuse k,v, cross_attentions key_states = past_key_value[0] value_states =\",\n \"\\\"Attention Is All You Need\\\"\\\"\\\" def __init__( self, embed_dim: int, num_heads: int, dropout:\",\n \"super().call(padded_inputs) return output # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2NoLayerNormConvLayer with Wav2Vec2->Hubert class TFHubertNoLayerNormConvLayer(tf.keras.layers.Layer): def __init__(self,\",\n \"self.dropout(hidden_states, training=training) hidden_states = attn_residual + hidden_states hidden_states = self.layer_norm(hidden_states) hidden_states = hidden_states\",\n \"trainable=True, name=\\\"masked_spec_embed\\\" ) super().build(input_shape) def _get_feat_extract_output_lengths(self, input_lengths: tf.Tensor): \\\"\\\"\\\" Computes the output length\",\n \"-> None: super().__init__(**kwargs) self.in_conv_dim = config.conv_dim[layer_id] if layer_id > 0 else 1 self.out_conv_dim\",\n \"matter related to general usage and behavior. <Tip> TF 2.0 models accepts two\",\n \"= self.layer_norm(hidden_states) hidden_states = self.activation(hidden_states) return hidden_states # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2GroupNormConvLayer with Wav2Vec2->Hubert\",\n \"self.head_dim = embed_dim // num_heads if (self.head_dim * num_heads) != self.embed_dim: raise ValueError(\",\n \"hidden_states + self.feed_forward(hidden_states) hidden_states = self.final_layer_norm(hidden_states) outputs = (hidden_states,) if output_attentions: outputs +=\",\n \"a \\\" \\\"multiple of the number of channels (\\\" + str(dim) + \\\").\\\"\",\n \"= conv_layer(hidden_states) return hidden_states class TFHubertFeatureExtractor(TFHubertFeatureEncoder): def __init__(self, config, **kwargs): super().__init__(config, **kwargs) warnings.warn(\",\n \"- a single Tensor with `input_values` only and nothing else: `model(inputs_ids)` - a\",\n \"0, 1)) _, indices = tf.nn.top_k(distribution + z, num_samples) return indices # Copied\",\n \"training: Optional[bool] = False, ) -> Tuple[tf.Tensor, Optional[tf.Tensor]]: \\\"\\\"\\\"Input shape: Batch x Time\",\n \"signature.pop(\\\"self\\\", None) parameter_names = list(signature.keys()) output = {} allowed_types = (tf.Tensor, bool, int,\",\n \">>> logits = model(input_values).logits >>> predicted_ids = tf.argmax(logits, axis=-1) >>> transcription = processor.decode(predicted_ids[0])\",\n \"argument can be used only in eager mode, in graph mode the value\",\n \"tf.broadcast_to(tf.expand_dims(tf.range(indices_shape[0]), axis=-1), indices_shape), [1, -1] ) # transform batch_indices to pair_indices pair_indices =\",\n \"to labels_mask = tf.cast(labels >= 0, tf.int32) target_lengths = tf.reduce_sum(labels_mask, axis=-1) loss =\",\n \"required by applicable law or agreed to in writing, software # distributed under\",\n \"// 2, name=\\\"conv\\\", ) self.padding = TFHubertSamePadLayer(config.num_conv_pos_embeddings) self.activation = get_tf_activation(config.feat_extract_activation) def call(self, hidden_states:\",\n \"hidden_states, ) elif self.config.mask_time_prob > 0: # generate indices & apply SpecAugment along\",\n \"beta_regularizer: tf.keras.regularizers.Regularizer = None, gamma_regularizer: tf.keras.regularizers.Regularizer = None, beta_constraint: tf.keras.constraints.Constraint = None, gamma_constraint:\",\n \"\\\" \\\"and will be removed in Transformers v5. \\\" f\\\"Use `{self.__class__.__bases__[0].__name__}` instead.\\\", FutureWarning,\",\n \"output_hidden_states: all_hidden_states = all_hidden_states + (hidden_states,) if not return_dict: return tuple(v for v\",\n \"(\\\" + str(self.groups) + \\\") cannot be \\\" \\\"more than the number of\",\n \"not is_instance_norm: broadcast_shape[self.axis] = input_shape[self.axis] // self.groups broadcast_shape.insert(self.axis, self.groups) else: broadcast_shape[self.axis] = self.groups\",\n \"self._init_norm() self.initialized = True self._normalize_kernel() padded_inputs = tf.pad(inputs, ((0, 0), (self.explicit_padding, self.explicit_padding), (0,\",\n \"\\\"\\\"\\\"TFHubert Model with a `language modeling` head on top for Connectionist Temporal Classification\",\n \"= tf.reshape(normalized_inputs, tensor_input_shape) else: outputs = normalized_inputs return outputs def get_config(self): config =\",\n \"are not compliant with XLA then they # have to be disabled in\",\n \"so that its parameters will not be updated during training. \\\"\\\"\\\" warnings.warn( \\\"The\",\n \"for which to compute masks. should be of size 2 where first element\",\n \"groups: int = 32, axis: int = -1, epsilon: float = 1e-3, center:\",\n \"axis = -2 if self.axis == -1 else self.axis - 1 else: axis\",\n \"mask of the same size as shape, which will prevent masking padded elements\",\n \">= 0, tf.int32) target_lengths = tf.reduce_sum(labels_mask, axis=-1) loss = tf.nn.ctc_loss( logits=logits, labels=labels, logit_length=input_lengths,\",\n \"value in the config will be used instead. return_dict (`bool`, *optional*): Whether or\",\n \"number of timesteps divided by length of mask span to mask approximately this\",\n \"self.num_pad_remove = 1 if num_conv_pos_embeddings % 2 == 0 else 0 def call(self,\",\n \"\\\"The bare TFHubert Model transformer outputing raw hidden-states without any specific head on\",\n \"argument is deprecated and will be removed in a future version, use `input_values`\",\n \"tf.Tensor: hidden_states = self.layer_norm(hidden_states) hidden_states = self.projection(hidden_states) hidden_states = self.dropout(hidden_states, training=training) return hidden_states\",\n \"v is None: output[k] = v elif k not in parameter_names and \\\"args\\\"\",\n \"TFHubertPositionalConvEmbedding(config, name=\\\"pos_conv_embed\\\") self.layer_norm = tf.keras.layers.LayerNormalization(epsilon=config.layer_norm_eps, name=\\\"layer_norm\\\") self.dropout = tf.keras.layers.Dropout(config.hidden_dropout) self.layer = [TFHubertEncoderLayer(config, name=f\\\"layers.{i}\\\")\",\n \"HUBERT_START_DOCSTRING, ) class TFHubertModel(TFHubertPreTrainedModel): def __init__(self, config: HubertConfig, *inputs, **kwargs): super().__init__(config, *inputs, **kwargs)\",\n \"tf.keras.regularizers.get(gamma_regularizer) self.beta_constraint = tf.keras.constraints.get(beta_constraint) self.gamma_constraint = tf.keras.constraints.get(gamma_constraint) self._check_axis() def build(self, input_shape): self._check_if_input_shape_is_none(input_shape) self._set_number_of_groups_for_instance_norm(input_shape)\",\n \"query_states = self.q_proj(hidden_states) * self.scaling # get key, value proj if is_cross_attention and\",\n \"as target processor to encode labels >>> with processor.as_target_processor(): ... labels = processor(transcription,\",\n \"layer # for the decoder is_cross_attention = key_value_states is not None bsz, tgt_len,\",\n \"= tf.nn.top_k(distribution + z, num_samples) return indices # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2._scatter_values_on_batch_indices def _scatter_values_on_batch_indices(values,\",\n \"is not allowed only {allowed_types} is accepted for {k}.\\\") if isinstance(input_values, (tuple, list)):\",\n \"from ...utils import ( ModelOutput, add_start_docstrings, add_start_docstrings_to_model_forward, logging, replace_return_docstrings, ) from .configuration_hubert import\",\n \"{parameter_names[i]}.\\\" ) elif isinstance(input_values, (dict, BatchEncoding)): if \\\"inputs\\\" in input_values: warnings.warn( \\\"The `inputs`\",\n \"layer_id=i, name=f\\\"conv_layers.{i}\\\") for i in range(config.num_feat_extract_layers) ] else: raise ValueError( f\\\"`config.feat_extract_norm` is {config.feat_extract_norm},\",\n \"be guaranteed during the training. Args: func (`callable`): The callable function of the\",\n \"mode (some modules like dropout modules have different behaviors between training and evaluation).\",\n \"attention key/value_states. # Further calls to cross_attention layer can then reuse all cross-attention\",\n \"self-attention `past_key_value` is always `None` past_key_value = (key_states, value_states) proj_shape = (bsz *\",\n \"in the first positional arguments. This second option is useful when using [`tf.keras.Model.fit`]\",\n \"replacement is currently not implemented. The gumbel-max trick will do for now -\",\n \">>> model = TFHubertForCTC.from_pretrained(\\\"facebook/hubert-base-960h\\\") >>> def map_to_array(batch): ... speech, _ = sf.read(batch[\\\"file\\\"]) ...\",\n \"if output[\\\"args\\\"] is not None and type(output[\\\"args\\\"]) == tf.Tensor: tensor_name = output[\\\"args\\\"].name.split(\\\":\\\")[0] output[tensor_name]\",\n \"self.hubert = TFHubertMainLayer(config, name=\\\"hubert\\\") self.dropout = tf.keras.layers.Dropout(config.final_dropout) self.lm_head = tf.keras.layers.Dense(config.vocab_size, name=\\\"lm_head\\\") def freeze_feature_extractor(self):\",\n \"input_lengths def _mask_hidden_states(self, hidden_states: tf.Tensor, mask_time_indices: Optional[tf.Tensor] = None): \\\"\\\"\\\" Masks extracted features\",\n \"from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2WeightNormConv1D with Wav2Vec2->Hubert class TFHubertWeightNormConv1D(tf.keras.layers.Conv1D): \\\"\\\"\\\"Adapted from https://www.tensorflow.org/probability/api_docs/python/tfp/layers/weight_norm/WeightNorm\\\"\\\"\\\" def __init__(self, filters, kernel_size,\",\n \"as sf >>> processor = Wav2Vec2Processor.from_pretrained(\\\"facebook/hubert-base-960h\\\") >>> model = TFHubertModel.from_pretrained(\\\"facebook/hubert-base-960h\\\") >>> def map_to_array(batch):\",\n \"use_bias=config.conv_bias, name=\\\"conv\\\", ) self.activation = get_tf_activation(config.feat_extract_activation) def call(self, hidden_states: tf.Tensor) -> tf.Tensor: hidden_states\",\n \"tf.reshape(attn_output, (bsz, self.num_heads, tgt_len, self.head_dim)), (0, 2, 1, 3) ) attn_output = tf.reshape(attn_output,\",\n \"= r\\\"\\\"\\\" Args: input_values (`np.ndarray`, `tf.Tensor`, `List[tf.Tensor]` ``Dict[str, tf.Tensor]` or `Dict[str, np.ndarray]` and\",\n \"a TPU\\\" ) @tf.function def serving(self, inputs): output = self.call(input_values=inputs, training=False) return self.serving_output(output)\",\n \"Optionally, instead of passing `input_values` you can choose to directly pass an embedded\",\n \"None else output return TFCausalLMOutput( loss=loss, logits=logits, hidden_states=outputs.hidden_states, attentions=outputs.attentions, ) def serving_output(self, output:\",\n \"- 1) ] elif config.feat_extract_norm == \\\"layer\\\": conv_layers = [ TFHubertLayerNormConvLayer(config, layer_id=i, name=f\\\"conv_layers.{i}\\\")\",\n \"tgt_len if tgt_len is not None else src_len one_cst = tf.constant(1.0) mask =\",\n \"tensor_name = output[\\\"args\\\"].name.split(\\\":\\\")[0] output[tensor_name] = output[\\\"args\\\"] else: # `args` in this case is\",\n \"self, embed_dim: int, num_heads: int, dropout: float = 0.0, is_decoder: bool = False,\",\n \"parameter will not be updated during training. \\\"\\\"\\\" self.hubert.feature_extractor.trainable = False @add_start_docstrings_to_model_forward(HUBERT_INPUTS_DOCSTRING) @replace_return_docstrings(output_type=TFCausalLMOutput,\",\n \"input_shape = input_shape.as_list() # Conv1D output shapes are checked at build time since\",\n \"explicit_padding self.filter_axis = 2 self.initialized = False self.kernel_norm_axes = tf.constant([0, 1]) def _init_norm(self):\",\n \"HUBERT_START_DOCSTRING, ) class TFHubertForCTC(TFHubertPreTrainedModel): def __init__(self, config: HubertConfig, *inputs, **kwargs): super().__init__(config, *inputs, **kwargs)\",\n \"speech, _ = sf.read(batch[\\\"file\\\"]) ... batch[\\\"speech\\\"] = speech ... return batch >>> ds\",\n \"{allowed_types} is accepted for {k}.\\\") if isinstance(input_values, (tuple, list)): for i, input in\",\n \"= False) -> tf.Tensor: hidden_states = self.layer_norm(hidden_states) hidden_states = self.projection(hidden_states) hidden_states = self.dropout(hidden_states,\",\n \"**config} def compute_output_shape(self, input_shape): return input_shape def _reshape_into_groups(self, inputs, input_shape, tensor_input_shape): group_shape =\",\n \"of the number of channels (\\\" + str(dim) + \\\").\\\" ) def _check_axis(self):\",\n \"tf.argmax(logits, axis=-1) >>> transcription = processor.decode(predicted_ids[0]) >>> # compute loss >>> target_transcription =\",\n \"`tf.Tensor` of shape `({0})`, *optional*): Segment token indices to indicate first and second\",\n \"indicates the head is **masked**. inputs_embeds (`np.ndarray` or `tf.Tensor` of shape `({0}, hidden_size)`,\",\n \"if inputs[\\\"output_hidden_states\\\"] else self.config.output_hidden_states ) inputs[\\\"output_attentions\\\"] = ( inputs[\\\"output_attentions\\\"] if inputs[\\\"output_attentions\\\"] else self.config.output_attentions\",\n \"self.add_weight( shape=shape, name=\\\"beta\\\", initializer=self.beta_initializer, regularizer=self.beta_regularizer, constraint=self.beta_constraint, ) else: self.beta = None def _create_broadcast_shape(self,\",\n \"only and nothing else: `model(inputs_ids)` - a list of varying length with one\",\n \"config=self.config, input_values=input_values, attention_mask=attention_mask, token_type_ids=token_type_ids, position_ids=position_ids, head_mask=head_mask, inputs_embeds=inputs_embeds, output_attentions=output_attentions, output_hidden_states=output_hidden_states, return_dict=return_dict, training=training, ) outputs\",\n \"for {parameter_names[i]}.\\\" ) elif isinstance(input_values, (dict, BatchEncoding)): if \\\"inputs\\\" in input_values: warnings.warn( \\\"The\",\n \"then we check only the # `name` part tensor_name = input.name.split(\\\":\\\")[0] if tensor_name\",\n \"= [ TFHubertEncoderLayerStableLayerNorm(config, name=f\\\"layers.{i}\\\") for i in range(config.num_hidden_layers) ] def call( self, hidden_states:\",\n \"filters=config.hidden_size, kernel_size=config.num_conv_pos_embeddings, groups=config.num_conv_pos_embedding_groups, explicit_padding=config.num_conv_pos_embeddings // 2, name=\\\"conv\\\", ) self.padding = TFHubertSamePadLayer(config.num_conv_pos_embeddings) self.activation =\",\n \"for all matter related to general usage and behavior. <Tip> TF 2.0 models\",\n \"inputs[\\\"output_attentions\\\"] if inputs[\\\"output_attentions\\\"] else self.config.output_attentions ) inputs[\\\"return_dict\\\"] = inputs[\\\"return_dict\\\"] if inputs[\\\"return_dict\\\"] else self.config.return_dict\",\n \"TFHubertEncoderStableLayerNorm(config, name=\\\"encoder\\\") else: self.encoder = TFHubertEncoder(config, name=\\\"encoder\\\") def build(self, input_shape: tf.TensorShape): self.masked_spec_embed =\",\n \"Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2GroupNorm with Wav2Vec2->Hubert class TFHubertGroupNorm(tf.keras.layers.Layer): \\\"\\\"\\\" From tensorflow-addons https://www.tensorflow.org/addons/api_docs/python/tfa/layers/GroupNormalization \\\"\\\"\\\" def\",\n \"= TFHubertFeedForward(config, name=\\\"feed_forward\\\") self.final_layer_norm = tf.keras.layers.LayerNormalization( epsilon=config.layer_norm_eps, name=\\\"final_layer_norm\\\" ) def call( self, hidden_states:\",\n \"self.out_conv_dim = config.conv_dim[layer_id] self.conv = tf.keras.layers.Conv1D( filters=self.out_conv_dim, kernel_size=config.conv_kernel[layer_id], strides=config.conv_stride[layer_id], use_bias=config.conv_bias, name=\\\"conv\\\", ) self.activation\",\n \"hidden_states = self.feature_extractor( tf.cast(inputs[\\\"input_values\\\"], tf.float32), training=inputs[\\\"training\\\"] ) if inputs[\\\"attention_mask\\\"] is not None: #\",\n \"output_attentions: Optional[bool] = None, labels: Optional[tf.Tensor] = None, output_hidden_states: Optional[bool] = None, return_dict:\",\n \"self.num_heads, tgt_len, self.head_dim)}, but is {shape_list(attn_output)}\\\", ) attn_output = tf.transpose( tf.reshape(attn_output, (bsz, self.num_heads,\",\n \"to indices_shape broad_casted_batch_dims = tf.reshape( tf.broadcast_to(tf.expand_dims(tf.range(indices_shape[0]), axis=-1), indices_shape), [1, -1] ) # transform\",\n \"2.0 Keras Model and refer to the TF 2.0 documentation for all matter\",\n \"be one of ['group', 'layer']\\\" ) self.conv_layers = conv_layers def call(self, input_values): hidden_states\",\n \"transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2NoLayerNormConvLayer with Wav2Vec2->Hubert class TFHubertNoLayerNormConvLayer(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, layer_id: int = 0,\",\n \"# Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2GroupNormConvLayer with Wav2Vec2->Hubert class TFHubertGroupNormConvLayer(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, layer_id:\",\n \"output shapes are checked at build time since TF 2.7, so we need\",\n \"= input_shape[self.axis] self.input_spec = tf.keras.layers.InputSpec(ndim=len(input_shape), axes={self.axis: dim}) def _add_gamma_weight(self, input_shape): dim = input_shape[self.axis]\",\n \"...utils import ( ModelOutput, add_start_docstrings, add_start_docstrings_to_model_forward, logging, replace_return_docstrings, ) from .configuration_hubert import HubertConfig\",\n \"raise ValueError(f\\\"Data of type {type(v)} is not allowed only {allowed_types} is accepted for\",\n \"training: bool = False) -> tf.Tensor: hidden_states = self.intermediate_dense(hidden_states) hidden_states = self.intermediate_act_fn(hidden_states) hidden_states\",\n \"self, hidden_states: tf.Tensor, key_value_states: Optional[tf.Tensor] = None, past_key_value: Optional[Tuple[Tuple[tf.Tensor]]] = None, attention_mask: Optional[tf.Tensor]\",\n \"self._normalize_kernel() padded_inputs = tf.pad(inputs, ((0, 0), (self.explicit_padding, self.explicit_padding), (0, 0))) output = super().call(padded_inputs)\",\n \"be removed in a future version, use `past_key_values` instead.\\\", FutureWarning, ) output[\\\"past_key_values\\\"] =\",\n \"http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing,\",\n \"self.masked_spec_embed[tf.newaxis, tf.newaxis, :], hidden_states, ) # apply SpecAugment along feature axis if self.config.mask_feature_prob\",\n \"func=self.call, config=self.config, input_values=input_values, attention_mask=attention_mask, token_type_ids=token_type_ids, position_ids=position_ids, head_mask=head_mask, inputs_embeds=inputs_embeds, output_attentions=output_attentions, output_hidden_states=output_hidden_states, return_dict=return_dict, training=training, kwargs_call=kwargs,\",\n \"in writing, software # distributed under the License is distributed on an \\\"AS\",\n \"past_key_value[1] elif is_cross_attention: # cross_attentions key_states = self._shape(self.k_proj(key_value_states), -1, bsz) value_states = self._shape(self.v_proj(key_value_states),\",\n \"= self.feature_extractor( tf.cast(inputs[\\\"input_values\\\"], tf.float32), training=inputs[\\\"training\\\"] ) if inputs[\\\"attention_mask\\\"] is not None: # compute\",\n \"use_bias=config.conv_bias, name=\\\"conv\\\", ) self.layer_norm = tf.keras.layers.LayerNormalization(name=\\\"layer_norm\\\", epsilon=config.layer_norm_eps) self.activation = get_tf_activation(config.feat_extract_activation) def call(self, hidden_states:\",\n \"mask_time_indices=mask_time_indices) encoder_outputs = self.encoder( hidden_states, attention_mask=attention_mask, output_attentions=inputs[\\\"output_attentions\\\"], output_hidden_states=inputs[\\\"output_hidden_states\\\"], return_dict=inputs[\\\"return_dict\\\"], training=inputs[\\\"training\\\"], ) hidden_states =\",\n \"k, v in dict(input_values).items(): if isinstance(v, allowed_types) or v is None: output[k] =\",\n \") self.intermediate_act_fn = get_tf_activation(config.hidden_act) self.output_dense = tf.keras.layers.Dense( units=config.hidden_size, kernel_initializer=get_initializer(config.initializer_range), bias_initializer=\\\"zeros\\\", name=\\\"output_dense\\\", ) self.output_dropout\",\n \"using [`tf.keras.Model.fit`] method which currently requires having all the tensors in the first\",\n \"query proj query_states = self.q_proj(hidden_states) * self.scaling # get key, value proj if\",\n \"= False, ) -> Union[TFBaseModelOutput, Tuple[tf.Tensor]]: all_hidden_states = () if output_hidden_states else None\",\n \"how to convert `input_values` indices into associated vectors than the model's internal embedding\",\n \"self.gamma = self.add_weight( shape=shape, name=\\\"gamma\\\", initializer=self.gamma_initializer, regularizer=self.gamma_regularizer, constraint=self.gamma_constraint, ) else: self.gamma = None\",\n \"} output.update(booleans_processing(config=config, **boolean_dict)) return output # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2._sample_without_replacement def _sample_without_replacement(distribution, num_samples): \\\"\\\"\\\"\",\n \"and refer to the TF 2.0 documentation for all matter related to general\",\n \"argument is deprecated and will be removed in a future version, use `past_key_values`\",\n \"(layer_outputs[1],) hidden_states = self.layer_norm(hidden_states) if output_hidden_states: all_hidden_states = all_hidden_states + (hidden_states,) if not\",\n \"self.embed_dim = embed_dim self.num_heads = num_heads self.dropout = tf.keras.layers.Dropout(dropout) self.head_dim = embed_dim //\",\n \"super().__init__(config, *inputs, **kwargs) logger.warning( f\\\"\\\\n{self.__class__.__name__} has backpropagation operations that are NOT supported on\",\n \"serving_output(self, output: TFCausalLMOutput) -> TFCausalLMOutput: hs = tf.convert_to_tensor(output.hidden_states) if self.config.output_hidden_states else None attns\",\n \"tuple or dict in the first positional arguments. This second option is useful\",\n \"as in PyTorch with indices in format (batch_dim, indixes) \\\"\\\"\\\" indices_shape = shape_list(batch_indices)\",\n \"name=\\\"conv\\\", ) self.activation = get_tf_activation(config.feat_extract_activation) self.layer_norm = TFHubertGroupNorm(groups=self.out_conv_dim, epsilon=config.layer_norm_eps, name=\\\"layer_norm\\\") def call(self, hidden_states:\",\n \"gradient computation for the feature encoder so that its parameters will not be\",\n \"ValueError( f\\\"embed_dim must be divisible by num_heads (got `embed_dim`: {self.embed_dim}\\\" f\\\" and `num_heads`:\",\n \"along feature axis if self.config.mask_feature_prob > 0: mask_feature_indices = _compute_mask_indices( (batch_size, hidden_size), mask_prob=self.config.mask_feature_prob,\",\n \"calls to cross_attention layer can then reuse all cross-attention # key/value_states (first \\\"if\\\"\",\n \"TFHubertFeatureProjection(config, name=\\\"feature_projection\\\") if config.do_stable_layer_norm: self.encoder = TFHubertEncoderStableLayerNorm(config, name=\\\"encoder\\\") else: self.encoder = TFHubertEncoder(config, name=\\\"encoder\\\")\",\n \"for i in range(config.num_hidden_layers) ] def call( self, hidden_states: tf.Tensor, attention_mask: Optional[tf.Tensor] =\",\n \"hidden_states = self.dropout(hidden_states, training=inputs[\\\"training\\\"]) logits = self.lm_head(hidden_states) if labels is not None: if\",\n \"True, scale: bool = True, beta_initializer: tf.keras.initializers.Initializer = \\\"zeros\\\", gamma_initializer: tf.keras.initializers.Initializer = \\\"ones\\\",\",\n \"will be removed in a future version, use `past_key_values` instead.\\\", FutureWarning, ) output[\\\"past_key_values\\\"]\",\n \"self.pos_conv_embed = TFHubertPositionalConvEmbedding(config, name=\\\"pos_conv_embed\\\") self.layer_norm = tf.keras.layers.LayerNormalization(epsilon=config.layer_norm_eps, name=\\\"layer_norm\\\") self.dropout = tf.keras.layers.Dropout(config.hidden_dropout) self.layer =\",\n \"import load_dataset >>> import soundfile as sf >>> processor = Wav2Vec2Processor.from_pretrained(\\\"facebook/hubert-base-960h\\\") >>> model\",\n \"None bsz, tgt_len, embed_dim = shape_list(hidden_states) # get query proj query_states = self.q_proj(hidden_states)\",\n \"2.0 (the \\\"License\\\"); # you may not use this file except in compliance\",\n \"must be divisible by num_heads (got `embed_dim`: {self.embed_dim}\\\" f\\\" and `num_heads`: {num_heads}).\\\" )\",\n \"(`np.ndarray` or `tf.Tensor` of shape `({0})`, *optional*): Indices of positions of each input\",\n \"cross_attentions key_states = past_key_value[0] value_states = past_key_value[1] elif is_cross_attention: # cross_attentions key_states =\",\n \"if attention_mask is not None: # The tf.debugging asserts are not compliant with\",\n \"tf.keras.regularizers.serialize(self.beta_regularizer), \\\"gamma_regularizer\\\": tf.keras.regularizers.serialize(self.gamma_regularizer), \\\"beta_constraint\\\": tf.keras.constraints.serialize(self.beta_constraint), \\\"gamma_constraint\\\": tf.keras.constraints.serialize(self.gamma_constraint), } base_config = super().get_config() return {**base_config,\",\n \"uniform_dist = tf.ones((batch_size, sequence_length - (mask_length - 1))) # get random indices to\",\n \"= False, ) -> Tuple[tf.Tensor]: attn_residual = hidden_states hidden_states, attn_weights, _ = self.attention(\",\n \"self.groups broadcast_shape.insert(self.axis, self.groups) else: broadcast_shape[self.axis] = self.groups return broadcast_shape # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2WeightNormConv1D\",\n \"**kwargs) self.hubert = TFHubertMainLayer(config, name=\\\"hubert\\\") self.dropout = tf.keras.layers.Dropout(config.final_dropout) self.lm_head = tf.keras.layers.Dense(config.vocab_size, name=\\\"lm_head\\\") def\",\n \"of timesteps divided by length of mask span to mask approximately this percentage\",\n \"...modeling_tf_utils import TFPreTrainedModel, booleans_processing, get_initializer, keras_serializable from ...tf_utils import shape_list from ...tokenization_utils_base import\",\n \"> 0 else 1 self.out_conv_dim = config.conv_dim[layer_id] self.conv = tf.keras.layers.Conv1D( filters=self.out_conv_dim, kernel_size=config.conv_kernel[layer_id], strides=config.conv_stride[layer_id],\",\n \"express or implied. # See the License for the specific language governing permissions\",\n \"of passing `input_values` you can choose to directly pass an embedded representation. This\",\n \"Tensors associated to the input names given in the docstring: `model({\\\"input_values\\\": input_values, \\\"token_type_ids\\\":\",\n \"number of masked spans Adapted from [fairseq's data_utils.py](https://github.com/pytorch/fairseq/blob/e0788f7007a8473a76db573985031f3c94201e79/fairseq/data/data_utils.py#L376). \\\"\\\"\\\" batch_size, sequence_length = shape\",\n \"import soundfile as sf >>> processor = Wav2Vec2Processor.from_pretrained(\\\"facebook/hubert-base-960h\\\") >>> model = TFHubertModel.from_pretrained(\\\"facebook/hubert-base-960h\\\") >>>\",\n \"TFCausalLMOutput from ...modeling_tf_utils import TFPreTrainedModel, booleans_processing, get_initializer, keras_serializable from ...tf_utils import shape_list from\",\n \"uni-directional self-attention # can concat previous decoder key/value_states to current projected key/value_states (third\",\n \"and nothing else: `model(inputs_ids)` - a list of varying length with one or\",\n \"super().__init__(config, *inputs, **kwargs) self.hubert = TFHubertMainLayer(config, name=\\\"hubert\\\") self.dropout = tf.keras.layers.Dropout(config.final_dropout) self.lm_head = tf.keras.layers.Dense(config.vocab_size,\",\n \"False, **kwargs: Any, ): inputs = input_values_processing( func=self.call, config=self.config, input_values=input_values, attention_mask=attention_mask, token_type_ids=token_type_ids, position_ids=position_ids,\",\n \"tokens are filled with -100 # when not being attended to labels_mask =\",\n \"beta_initializer: tf.keras.initializers.Initializer = \\\"zeros\\\", gamma_initializer: tf.keras.initializers.Initializer = \\\"ones\\\", beta_regularizer: tf.keras.regularizers.Regularizer = None, gamma_regularizer:\",\n \"# if encoder bi-directional self-attention `past_key_value` is always `None` past_key_value = (key_states, value_states)\",\n \"self.hubert._get_feat_extract_output_lengths(tf.reduce_sum(attention_mask, axis=-1)) # assuming that padded tokens are filled with -100 # when\",\n \"broadcast_shape) if self.center: beta = tf.reshape(self.beta, broadcast_shape) return gamma, beta def _check_if_input_shape_is_none(self, input_shape):\",\n \"1, 1), initializer=\\\"ones\\\", dtype=self.weight_v.dtype, trainable=True, ) self.bias = self.add_weight(name=\\\"bias\\\", shape=(self.filters,), initializer=\\\"zeros\\\", trainable=True) def\",\n \"= tf.nn.moments(reshaped_inputs, group_reduction_axes, keepdims=True) gamma, beta = self._get_reshaped_weights(input_shape) normalized_inputs = tf.nn.batch_normalization( reshaped_inputs, mean=mean,\",\n \"attn_weights = tf.nn.softmax(attn_weights, axis=-1) if layer_head_mask is not None: # The tf.debugging asserts\",\n \"PyTorch models), or - having all inputs as a list, tuple or dict\",\n \"elif config.feat_extract_norm == \\\"layer\\\": conv_layers = [ TFHubertLayerNormConvLayer(config, layer_id=i, name=f\\\"conv_layers.{i}\\\") for i in\",\n \"each example must have the shape `({0})`): Indices of input sequence tokens in\",\n \"\\\" \\\"more than the number of channels (\\\" + str(dim) + \\\").\\\" )\",\n \"= self._create_broadcast_shape(input_shape) gamma = None beta = None if self.scale: gamma = tf.reshape(self.gamma,\",\n \"__init__(self, config, *inputs, **kwargs): super().__init__(config, *inputs, **kwargs) logger.warning( f\\\"\\\\n{self.__class__.__name__} has backpropagation operations that\",\n \"output[\\\"args\\\"] else: # `args` in this case is always the first parameter, then\",\n \"Returns: Example: ```python >>> import tensorflow as tf >>> from transformers import Wav2Vec2Processor,\",\n \"use the equivalent `freeze_feature_encoder` method instead.\\\", FutureWarning, ) self.freeze_feature_encoder() def freeze_feature_encoder(self): \\\"\\\"\\\" Calling\",\n \"tf.Tensor]: pad_token = 0.0 input_values = tf.convert_to_tensor(np.random.rand(1, 16000), tf.float32) dummy_inputs = { \\\"input_values\\\":\",\n \"has to be bigger than 0.\\\") if mask_length > sequence_length: raise ValueError( f\\\"`mask_length`\",\n \"configuration class with all the parameters of the model. Initializing with a config\",\n \"bool = False, **kwargs: Any, ): inputs = input_values_processing( func=self.call, config=self.config, input_values=input_values, attention_mask=attention_mask,\",\n \"should be of size 2 where first element is batch size and 2nd\",\n \"{shape_list(attention_mask)}\\\", ) attention_mask = tf.cast(attention_mask, dtype=attn_weights.dtype) attn_weights = tf.reshape(attn_weights, (bsz, self.num_heads, tgt_len, src_len))\",\n \"1 for kernel_size, stride in zip(self.config.conv_kernel, self.config.conv_stride): input_lengths = _conv_out_length(input_lengths, kernel_size, stride) return\",\n \"# # Licensed under the Apache License, Version 2.0 (the \\\"License\\\"); # you\",\n \"(\\\" + str(dim) + \\\").\\\" ) if dim % self.groups != 0: raise\",\n \"processor.as_target_processor(): ... labels = processor(transcription, return_tensors=\\\"tf\\\").input_values >>> loss = model(input_values, labels=labels).loss ```\\\"\\\"\\\" inputs\",\n \"return_dict: Optional[bool] = True, training: Optional[bool] = False, ) -> Union[TFBaseModelOutput, Tuple[tf.Tensor]]: all_hidden_states\",\n \"that offset samples are < sequence_length uniform_dist = tf.ones((batch_size, sequence_length - (mask_length -\",\n \"* tf.reshape( attn_weights, (bsz, self.num_heads, tgt_len, src_len) ) attn_weights = tf.reshape(attn_weights, (bsz *\",\n \"self.intermediate_dropout(hidden_states, training=training) hidden_states = self.output_dense(hidden_states) hidden_states = self.output_dropout(hidden_states, training=training) return hidden_states # Copied\",\n \"self.config.ctc_loss_reduction == \\\"mean\\\": loss = tf.reduce_mean(loss) else: loss = None if not inputs[\\\"return_dict\\\"]:\",\n \"\\\"token_type_ids\\\": token_type_ids})` </Tip> Args: config ([`HubertConfig`]): Model configuration class with all the parameters\",\n \"= None, token_type_ids: Optional[tf.Tensor] = None, position_ids: Optional[tf.Tensor] = None, head_mask: Optional[tf.Tensor] =\",\n \"# Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2EncoderLayerStableLayerNorm with Wav2Vec2->Hubert class TFHubertEncoderLayerStableLayerNorm(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs):\",\n \"accepts two formats as inputs: - having all inputs as keyword arguments (like\",\n \"ORDER given in the docstring: `model([input_values, attention_mask])` or `model([input_values, attention_mask, token_type_ids])` - a\",\n \"\\\"kwargs\\\" in output: del output[\\\"kwargs\\\"] boolean_dict = { k: v for k, v\",\n \"hidden-states without any specific head on top.\\\", HUBERT_START_DOCSTRING, ) class TFHubertModel(TFHubertPreTrainedModel): def __init__(self,\",\n \"position_ids: Optional[tf.Tensor] = None, head_mask: Optional[tf.Tensor] = None, inputs_embeds: Optional[tf.Tensor] = None, output_attentions:\",\n \"= False @add_start_docstrings_to_model_forward(HUBERT_INPUTS_DOCSTRING) @replace_return_docstrings(output_type=TFCausalLMOutput, config_class=_CONFIG_FOR_DOC) def call( self, input_values: tf.Tensor, attention_mask: Optional[tf.Tensor] =\",\n \"only {allowed_types} is accepted for {k}.\\\") if isinstance(input_values, (tuple, list)): for i, input\",\n \"output_attentions=output_attentions, output_hidden_states=output_hidden_states, return_dict=return_dict, training=training, ) inputs[\\\"output_hidden_states\\\"] = ( inputs[\\\"output_hidden_states\\\"] if inputs[\\\"output_hidden_states\\\"] else self.config.output_hidden_states\",\n \"attention_mask: Optional[tf.Tensor] = None, token_type_ids: Optional[tf.Tensor] = None, position_ids: Optional[tf.Tensor] = None, head_mask:\",\n \"tf.sequence_mask( output_lengths, maxlen=shape_list(hidden_states)[1], dtype=hidden_states.dtype ) hidden_states = self.feature_projection(hidden_states, training=inputs[\\\"training\\\"]) mask_time_indices = kwargs.get(\\\"mask_time_indices\\\", None)\",\n \"= self.padding(hidden_states) hidden_states = self.activation(hidden_states) return hidden_states # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2SamePadLayer with Wav2Vec2->Hubert\",\n \"hidden_states * tf.expand_dims(attention_mask, -1) attention_mask = _expand_mask(attention_mask) else: attention_mask = None position_embeddings =\",\n \"training=training) return hidden_states # Copied from transformers.models.bart.modeling_tf_bart.TFBartAttention with TFBart->TFHubert class TFHubertAttention(tf.keras.layers.Layer): \\\"\\\"\\\"Multi-headed attention\",\n \"that its parameters will not be updated during training. \\\"\\\"\\\" warnings.warn( \\\"The method\",\n \"str(self.groups) + \\\") cannot be \\\" \\\"more than the number of channels (\\\"\",\n \"int = 0): \\\"\\\"\\\" Expands attention_mask from `[bsz, seq_len]` to `[bsz, 1, tgt_seq_len,\",\n \"v in kwargs.items(): if isinstance(v, allowed_types) or v is None: output[k] = v\",\n \"in the docstring: `model({\\\"input_values\\\": input_values, \\\"token_type_ids\\\": token_type_ids})` </Tip> Args: config ([`HubertConfig`]): Model configuration\",\n \"_expand_mask(mask: tf.Tensor, tgt_len: Optional[int] = None, past_key_values_length: int = 0): \\\"\\\"\\\" Expands attention_mask\",\n \"func=self.call, config=self.config, input_values=input_values, attention_mask=attention_mask, token_type_ids=token_type_ids, position_ids=position_ids, head_mask=head_mask, inputs_embeds=inputs_embeds, output_attentions=output_attentions, output_hidden_states=output_hidden_states, return_dict=return_dict, training=training, )\",\n \"**kwargs: The inputs of the model. Returns: Two lists, one for the missing\",\n \"downloading and loading pretrained models. \\\"\\\"\\\" config_class = HubertConfig base_model_prefix = \\\"hubert\\\" main_input_name\",\n \"mask_time_indices: Optional[tf.Tensor] = None): \\\"\\\"\\\" Masks extracted features along time axis and/or along\",\n \"first parameter, then `input_values` output[\\\"input_values\\\"] = output[\\\"args\\\"] del output[\\\"args\\\"] if \\\"kwargs\\\" in output:\",\n \"== 1 if not is_instance_norm: outputs = tf.reshape(normalized_inputs, tensor_input_shape) else: outputs = normalized_inputs\",\n \"type {type(v)} is not allowed only {allowed_types} is accepted for {k}.\\\") if isinstance(input_values,\",\n \"SpecAugment along time axis with given mask_time_indices hidden_states = tf.where( tf.cast(mask_time_indices[:, :, tf.newaxis],\",\n \"return tf.scatter_nd(pair_indices, tf.reshape(values, [-1]), output_shape) # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2._compute_mask_indices def _compute_mask_indices( shape: Tuple[int,\",\n \"f\\\"The class `{self.__class__.__name__}` has been depreciated \\\" \\\"and will be removed in Transformers\",\n \"a `language modeling` head on top for Connectionist Temporal Classification (CTC).\\\"\\\"\\\", HUBERT_START_DOCSTRING, )\",\n \"input_values, \\\"attention_mask\\\": tf.cast(tf.not_equal(input_values, pad_token), tf.float32), } return dummy_inputs def __init__(self, config, *inputs, **kwargs):\",\n \"(input_shape[self.axis] // self.groups) == 1 if not is_instance_norm: broadcast_shape[self.axis] = input_shape[self.axis] // self.groups\",\n \"* self.scaling # get key, value proj if is_cross_attention and past_key_value is not\",\n \"\\\"\\\"\\\" HUBERT_INPUTS_DOCSTRING = r\\\"\\\"\\\" Args: input_values (`np.ndarray`, `tf.Tensor`, `List[tf.Tensor]` ``Dict[str, tf.Tensor]` or `Dict[str,\",\n \"is **masked**. inputs_embeds (`np.ndarray` or `tf.Tensor` of shape `({0}, hidden_size)`, *optional*): Optionally, instead\",\n \"tf.newaxis, :], hidden_states, ) # apply SpecAugment along feature axis if self.config.mask_feature_prob >\",\n \"src_len], message=f\\\"Attention weights should be of size {(bsz * self.num_heads, tgt_len, src_len)}, but\",\n \"\\\"Number of groups (\\\" + str(self.groups) + \\\") must be a \\\" \\\"multiple\",\n \"inputs[\\\"output_hidden_states\\\"] if inputs[\\\"output_hidden_states\\\"] else self.config.output_hidden_states ) inputs[\\\"output_attentions\\\"] = ( inputs[\\\"output_attentions\\\"] if inputs[\\\"output_attentions\\\"] else\",\n \"labels=labels).loss ```\\\"\\\"\\\" inputs = input_values_processing( func=self.call, config=self.config, input_values=input_values, attention_mask=attention_mask, token_type_ids=token_type_ids, position_ids=position_ids, head_mask=head_mask, inputs_embeds=inputs_embeds,\",\n \"input_values_processing( func=self.call, config=self.config, input_values=input_values, attention_mask=attention_mask, token_type_ids=token_type_ids, position_ids=position_ids, head_mask=head_mask, inputs_embeds=inputs_embeds, output_attentions=output_attentions, output_hidden_states=output_hidden_states, return_dict=return_dict, training=training,\",\n \"= tf.where(mask_feature_indices[:, tf.newaxis, :], hidden_states, 0) return hidden_states def call( self, input_values: tf.Tensor,\",\n \"but is {shape_list(attn_weights)}\\\", ) if attention_mask is not None: # The tf.debugging asserts\",\n \"training=training) hidden_states = self.output_dense(hidden_states) hidden_states = self.output_dropout(hidden_states, training=training) return hidden_states # Copied from\",\n \">>> with processor.as_target_processor(): ... labels = processor(transcription, return_tensors=\\\"tf\\\").input_values >>> loss = model(input_values, labels=labels).loss\",\n \"except in compliance with the License. # You may obtain a copy of\",\n \"for more info \\\"\\\"\\\" z = -tf.math.log(tf.random.uniform(shape_list(distribution), 0, 1)) _, indices = tf.nn.top_k(distribution\",\n \"tf.keras.layers.LayerNormalization( epsilon=config.layer_norm_eps, name=\\\"final_layer_norm\\\" ) def call( self, hidden_states: tf.Tensor, attention_mask: Optional[tf.Tensor] = None,\",\n \"split=\\\"validation\\\") >>> ds = ds.map(map_to_array) >>> input_values = processor(ds[\\\"speech\\\"][0], return_tensors=\\\"tf\\\").input_values # Batch size\",\n \") -> tf.Tensor: \\\"\\\"\\\" Computes random mask spans for a given shape Args:\",\n \") hidden_states = self.dropout(hidden_states, training=training) hidden_states = attn_residual + hidden_states hidden_states = hidden_states\",\n \"See `attentions` under returned tensors for more detail. This argument can be used\",\n \"Union[TFBaseModelOutput, Tuple[tf.Tensor]]: \\\"\\\"\\\" Returns: Example: ```python >>> from transformers import Wav2Vec2Processor, TFHubertModel >>>\",\n \"tf from ...activations_tf import get_tf_activation from ...modeling_tf_outputs import TFBaseModelOutput, TFCausalLMOutput from ...modeling_tf_utils import\",\n \"self.weight_v = self.kernel self.weight_g = self.add_weight( name=\\\"weight_g\\\", shape=(int(self.weight_v.shape[self.filter_axis]), 1, 1), initializer=\\\"ones\\\", dtype=self.weight_v.dtype, trainable=True,\",\n \"# get random indices to mask spec_aug_mask_idxs = _sample_without_replacement(uniform_dist, num_masked_spans) # expand masked\",\n \"super().__init__(**kwargs) self.num_pad_remove = 1 if num_conv_pos_embeddings % 2 == 0 else 0 def\",\n \"compute masks. should be of size 2 where first element is batch size\",\n \"num_masked_spans * mask_length)) offsets = tf.range(mask_length)[tf.newaxis, tf.newaxis, :] offsets = tf.tile(offsets, (batch_size, num_masked_spans,\",\n \"= tf.convert_to_tensor(output.attentions) if self.config.output_attentions else None return TFBaseModelOutput(last_hidden_state=output.last_hidden_state, hidden_states=hs, attentions=attns) @add_start_docstrings( \\\"\\\"\\\"TFHubert Model\",\n \"-> None: super().__init__(**kwargs) self.conv = TFHubertWeightNormConv1D( filters=config.hidden_size, kernel_size=config.num_conv_pos_embeddings, groups=config.num_conv_pos_embedding_groups, explicit_padding=config.num_conv_pos_embeddings // 2, name=\\\"conv\\\",\",\n \"def call( self, hidden_states: tf.Tensor, attention_mask: Optional[tf.Tensor] = None, output_attentions: Optional[bool] = False,\",\n \"Time x Channel\\\"\\\"\\\" # if key_value_states are provided this layer is used as\",\n \"from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2SamePadLayer with Wav2Vec2->Hubert class TFHubertSamePadLayer(tf.keras.layers.Layer): def __init__(self, num_conv_pos_embeddings, **kwargs): super().__init__(**kwargs) self.num_pad_remove =\",\n \"= tf.keras.layers.Conv1D( filters=self.out_conv_dim, kernel_size=config.conv_kernel[layer_id], strides=config.conv_stride[layer_id], use_bias=config.conv_bias, name=\\\"conv\\\", ) self.layer_norm = tf.keras.layers.LayerNormalization(name=\\\"layer_norm\\\", epsilon=config.layer_norm_eps) self.activation\",\n \"token. [What are token type IDs?](../glossary#token-type-ids) position_ids (`np.ndarray` or `tf.Tensor` of shape `({0})`,\",\n \"bsz) key_states = tf.concat([past_key_value[0], key_states], axis=2) value_states = tf.concat([past_key_value[1], value_states], axis=2) else: #\",\n \"return_tensors=\\\"tf\\\").input_values # Batch size 1 >>> hidden_states = model(input_values).last_hidden_state ```\\\"\\\"\\\" inputs = input_values_processing(\",\n \"super().__init__(**kwargs) self.config = config self.pos_conv_embed = TFHubertPositionalConvEmbedding(config, name=\\\"pos_conv_embed\\\") self.layer_norm = tf.keras.layers.LayerNormalization(epsilon=config.layer_norm_eps, name=\\\"layer_norm\\\") self.dropout\",\n \"in range(config.num_hidden_layers) ] def call( self, hidden_states: tf.Tensor, attention_mask: Optional[tf.Tensor] = None, output_attentions:\",\n \"input_shape): dim = input_shape[self.axis] shape = (dim,) if self.center: self.beta = self.add_weight( shape=shape,\",\n \"output[parameter_names[0]] = input_values else: raise ValueError( f\\\"Data of type {type(input_values)} is not allowed\",\n \"= 1e-3, center: bool = True, scale: bool = True, beta_initializer: tf.keras.initializers.Initializer =\",\n \".configuration_hubert import HubertConfig logger = logging.get_logger(__name__) _CONFIG_FOR_DOC = \\\"HubertConfig\\\" TF_HUBERT_PRETRAINED_MODEL_ARCHIVE_LIST = [ \\\"facebook/hubert-base-ls960\\\",\",\n \"which will prevent masking padded elements mask_prob: probability for each token to be\",\n \"disable the gradient computation for the feature encoder so that its parameters will\",\n \"-> TFCausalLMOutput: hs = tf.convert_to_tensor(output.hidden_states) if self.config.output_hidden_states else None attns = tf.convert_to_tensor(output.attentions) if\",\n \"documentation for the generic methods the library implements for all its model (such\",\n \"model. config ([`PretrainedConfig`]): The config of the running model. **kwargs: The inputs of\",\n \"size 2 where first element is batch size and 2nd is timesteps attention_mask:\",\n \"name != \\\"args\\\": output[name] = kwargs.pop(name, signature[name].default) # When creating a SavedModel TF\",\n \"of the model. Returns: Two lists, one for the missing layers, and another\",\n \"TFHubertMainLayer(tf.keras.layers.Layer): config_class = HubertConfig def __init__(self, config: HubertConfig, **kwargs): super().__init__(**kwargs) self.config = config\",\n \"of symbolic inputs, each input has to be named accordingly to the parameters\",\n \"elif self.config.mask_time_prob > 0: # generate indices & apply SpecAugment along time axis\",\n \"hidden_states = encoder_outputs[0] if not inputs[\\\"return_dict\\\"]: return (hidden_states,) + encoder_outputs[1:] return TFBaseModelOutput( last_hidden_state=hidden_states,\",\n \"- 0 corresponds to a *sentence A* token, - 1 corresponds to a\",\n \"if not getattr(self.config, \\\"apply_spec_augment\\\", True): return hidden_states if mask_time_indices is not None: #\",\n \"hidden_states = self.output_dropout(hidden_states, training=training) return hidden_states # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2EncoderLayer with Wav2Vec2->Hubert class\",\n \"datasets import load_dataset >>> import soundfile as sf >>> processor = Wav2Vec2Processor.from_pretrained(\\\"facebook/hubert-base-960h\\\") >>>\",\n \"updated during training. \\\"\\\"\\\" warnings.warn( \\\"The method `freeze_feature_extractor` is deprecated and will be\",\n \"= super().get_config() return {**base_config, **config} def compute_output_shape(self, input_shape): return input_shape def _reshape_into_groups(self, inputs,\",\n \"Segment token indices to indicate first and second portions of the inputs. Indices\",\n \"transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2EncoderLayer with Wav2Vec2->Hubert class TFHubertEncoderLayer(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs): super().__init__(**kwargs) self.attention =\",\n \"return dummy_inputs def __init__(self, config, *inputs, **kwargs): super().__init__(config, *inputs, **kwargs) logger.warning( f\\\"\\\\n{self.__class__.__name__} has\",\n \"are **not masked**, - 0 for tokens that are **masked**. [What are attention\",\n \"be \\\" \\\"more than the number of channels (\\\" + str(dim) + \\\").\\\"\",\n \"axis according to [SpecAugment](https://arxiv.org/abs/1904.08779). \\\"\\\"\\\" batch_size, sequence_length, hidden_size = shape_list(hidden_states) # `config.apply_spec_augment` can\",\n \"modes than eager. if tf.executing_eagerly(): tf.debugging.assert_equal( shape_list(attn_output), [bsz * self.num_heads, tgt_len, self.head_dim], message=f\\\"`attn_output`\",\n \"case of a list of symbolic inputs, each input has to be named\",\n \"Dict[str, tf.Tensor]: pad_token = 0.0 input_values = tf.convert_to_tensor(np.random.rand(1, 16000), tf.float32) dummy_inputs = {\",\n \"start of the span to be masked. this will be multiplied by number\",\n \"_add_gamma_weight(self, input_shape): dim = input_shape[self.axis] shape = (dim,) if self.scale: self.gamma = self.add_weight(\",\n \"for the missing layers, and another one for the unexpected layers. \\\"\\\"\\\" signature\",\n \"input_shape[self.axis] shape = (dim,) if self.center: self.beta = self.add_weight( shape=shape, name=\\\"beta\\\", initializer=self.beta_initializer, regularizer=self.beta_regularizer,\",\n \"[ \\\"facebook/hubert-base-ls960\\\", # See all Hubert models at https://huggingface.co/models?filter=hubert ] LARGE_NEGATIVE = -1e8\",\n \"to \\\" \\\"use tf.layer.batch_normalization instead\\\" ) def _create_input_spec(self, input_shape): dim = input_shape[self.axis] self.input_spec\",\n \"nullify selected heads of the self-attention modules. Mask values selected in `[0, 1]`:\",\n \"axis = -1 if self.axis == -1 else self.axis - 1 group_reduction_axes.pop(axis) mean,\",\n \"= input_shape[self.axis] if dim < self.groups: raise ValueError( \\\"Number of groups (\\\" +\",\n \"Optional[bool] = False, ) -> Union[TFCausalLMOutput, Tuple[tf.Tensor]]: r\\\"\\\"\\\" labels (`tf.Tensor` or `np.ndarray` of\",\n \"inputs[\\\"return_dict\\\"]: output = (logits,) + outputs[1:] return ((loss,) + output) if loss is\",\n \"**kwargs, ): super().__init__(**kwargs) self.supports_masking = True self.groups = groups self.axis = axis self.epsilon\",\n \"a *sentence B* token. [What are token type IDs?](../glossary#token-type-ids) position_ids (`np.ndarray` or `tf.Tensor`\",\n \"# EagerTensors don't allow to use the .name property so we check for\",\n \"self.axis - 1 group_reduction_axes.pop(axis) mean, variance = tf.nn.moments(reshaped_inputs, group_reduction_axes, keepdims=True) gamma, beta =\",\n \"[tf.keras.Model](https://www.tensorflow.org/api_docs/python/tf/keras/Model) subclass. Use it as a regular TF 2.0 Keras Model and refer\",\n \"self._add_gamma_weight(input_shape) self._add_beta_weight(input_shape) self.built = True super().build(input_shape) def call(self, inputs): input_shape = tf.keras.backend.int_shape(inputs) tensor_input_shape\",\n \"value_states = self._shape(self.v_proj(hidden_states), -1, bsz) if self.is_decoder: # if cross_attention save Tuple(tf.Tensor, tf.Tensor)\",\n \"cannot be \\\" \\\"more than the number of channels (\\\" + str(dim) +\",\n \"\\\"gamma_regularizer\\\": tf.keras.regularizers.serialize(self.gamma_regularizer), \\\"beta_constraint\\\": tf.keras.constraints.serialize(self.beta_constraint), \\\"gamma_constraint\\\": tf.keras.constraints.serialize(self.gamma_constraint), } base_config = super().get_config() return {**base_config, **config}\",\n \"\\\"A MAN SAID TO THE UNIVERSE SIR I EXIST\\\" >>> # wrap processor\",\n \"return reshaped_inputs, group_shape else: return inputs, group_shape def _apply_normalization(self, reshaped_inputs, input_shape): group_shape =\",\n \"tf.debugging.assert_equal( shape_list(layer_head_mask), [self.num_heads], message=f\\\"Head mask for a single layer should be of size\",\n \"# self_attention key_states = self._shape(self.k_proj(hidden_states), -1, bsz) value_states = self._shape(self.v_proj(hidden_states), -1, bsz) if\",\n \"updated during training. \\\"\\\"\\\" self.hubert.feature_extractor.trainable = False @add_start_docstrings_to_model_forward(HUBERT_INPUTS_DOCSTRING) @replace_return_docstrings(output_type=TFCausalLMOutput, config_class=_CONFIG_FOR_DOC) def call( self,\",\n \"self.dropout(attn_weights, training=training) attn_output = tf.matmul(attn_probs, value_states) # The tf.debugging asserts are not compliant\",\n \"Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2LayerNormConvLayer with Wav2Vec2->Hubert class TFHubertLayerNormConvLayer(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, layer_id: int\",\n \"have to be disabled in other modes than eager. if tf.executing_eagerly(): tf.debugging.assert_equal( shape_list(attn_weights),\",\n \"parameters will not be updated during training. \\\"\\\"\\\" warnings.warn( \\\"The method `freeze_feature_extractor` is\",\n \"use_bias=bias, name=\\\"q_proj\\\") self.v_proj = tf.keras.layers.Dense(embed_dim, use_bias=bias, name=\\\"v_proj\\\") self.out_proj = tf.keras.layers.Dense(embed_dim, use_bias=bias, name=\\\"out_proj\\\") def\",\n \"masked**, - 0 for tokens that are **masked**. [What are attention masks?](../glossary#attention-mask) token_type_ids\",\n \"See [`PreTrainedTokenizer.__call__`] and [`PreTrainedTokenizer.encode`] for details. [What are input IDs?](../glossary#input-ids) attention_mask (`np.ndarray` or\",\n \"get key, value proj if is_cross_attention and past_key_value is not None: # reuse\",\n \"(batch_dim, indixes) \\\"\\\"\\\" indices_shape = shape_list(batch_indices) # broadcast batch dim to indices_shape broad_casted_batch_dims\",\n \"= { \\\"input_values\\\": input_values, \\\"attention_mask\\\": tf.cast(tf.not_equal(input_values, pad_token), tf.float32), } return dummy_inputs def __init__(self,\",\n \"0.\\\") if mask_length > sequence_length: raise ValueError( f\\\"`mask_length` has to be smaller than\",\n \"* mask_length > sequence_length: num_masked_spans = sequence_length // mask_length # SpecAugment mask to\",\n \"the config will be used instead. return_dict (`bool`, *optional*): Whether or not to\",\n \"software # distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\",\n \") # transform batch_indices to pair_indices pair_indices = tf.transpose(tf.concat([broad_casted_batch_dims, tf.reshape(batch_indices, [1, -1])], 0))\",\n \"implemented. The gumbel-max trick will do for now - see https://github.com/tensorflow/tensorflow/issues/9260 for more\",\n \"Check out the [`~PreTrainedModel.from_pretrained`] method to load the model weights. \\\"\\\"\\\" HUBERT_INPUTS_DOCSTRING =\",\n \"Any, Dict, Optional, Tuple, Union import numpy as np import tensorflow as tf\",\n \"encode labels >>> with processor.as_target_processor(): ... labels = processor(transcription, return_tensors=\\\"tf\\\").input_values >>> loss =\",\n \"output return TFCausalLMOutput( loss=loss, logits=logits, hidden_states=outputs.hidden_states, attentions=outputs.attentions, ) def serving_output(self, output: TFCausalLMOutput) ->\",\n \"-> Tuple[tf.Tensor]: attn_residual = hidden_states hidden_states, attn_weights, _ = self.attention( hidden_states, attention_mask=attention_mask, training=training\",\n \"bsz: int): return tf.transpose(tf.reshape(tensor, (bsz, seq_len, self.num_heads, self.head_dim)), (0, 2, 1, 3)) def\",\n \"hidden_states = conv_layer(hidden_states) return hidden_states class TFHubertFeatureExtractor(TFHubertFeatureEncoder): def __init__(self, config, **kwargs): super().__init__(config, **kwargs)\",\n \"None: # compute real output lengths according to convolution formula output_lengths = self._get_feat_extract_output_lengths(tf.reduce_sum(inputs[\\\"attention_mask\\\"],\",\n \"will not be updated during training. \\\"\\\"\\\" warnings.warn( \\\"The method `freeze_feature_extractor` is deprecated\",\n \"in [\\\"return_dict\\\", \\\"output_attentions\\\", \\\"output_hidden_states\\\", \\\"use_cache\\\"] } output.update(booleans_processing(config=config, **boolean_dict)) return output # Copied from\",\n \"attn_output = self.out_proj(attn_output) attn_weights: tf.Tensor = tf.reshape(attn_weights, (bsz, self.num_heads, tgt_len, src_len)) return attn_output,\",\n \"Optional, Tuple, Union import numpy as np import tensorflow as tf from ...activations_tf\",\n \"language governing permissions and # limitations under the License. \\\"\\\"\\\" TensorFlow Hubert model.\\\"\\\"\\\"\",\n \"(see https://arxiv.org/abs/1909.11556 for description) dropout_probability = np.random.uniform(0, 1) if training and (dropout_probability <\",\n \"input_shape): self._check_if_input_shape_is_none(input_shape) self._set_number_of_groups_for_instance_norm(input_shape) self._check_size_of_dimensions(input_shape) self._create_input_spec(input_shape) self._add_gamma_weight(input_shape) self._add_beta_weight(input_shape) self.built = True super().build(input_shape) def call(self,\",\n \"argument can be used in eager mode, in graph mode the value will\",\n \"in `[-100, 0, ..., config.vocab_size]` (see `input_values` docstring) Tokens with indices set to\",\n \"= shape_list(key_states)[1] attn_weights = tf.matmul(query_states, key_states, transpose_b=True) # The tf.debugging asserts are not\",\n \"transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2FeedForward with Wav2Vec2->Hubert class TFHubertFeedForward(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs): super().__init__(**kwargs) self.intermediate_dropout =\",\n \"None: # reuse k,v, cross_attentions key_states = past_key_value[0] value_states = past_key_value[1] elif is_cross_attention:\",\n \"None position_embeddings = self.pos_conv_embed(hidden_states) hidden_states = hidden_states + position_embeddings hidden_states = self.layer_norm(hidden_states) hidden_states\",\n \"first and second portions of the inputs. Indices are selected in `[0, 1]`:\",\n \"groups (\\\" + str(self.groups) + \\\") cannot be \\\" \\\"more than the number\",\n \"config: HubertConfig, **kwargs): super().__init__(**kwargs) self.intermediate_dropout = tf.keras.layers.Dropout(config.activation_dropout) self.intermediate_dense = tf.keras.layers.Dense( units=config.intermediate_size, kernel_initializer=get_initializer(config.initializer_range), bias_initializer=\\\"zeros\\\",\",\n \"not to return a [`~file_utils.ModelOutput`] instead of a plain tuple. This argument can\",\n \"attentions tensors of all attention layers. See `attentions` under returned tensors for more\",\n \"B* token. [What are token type IDs?](../glossary#token-type-ids) position_ids (`np.ndarray` or `tf.Tensor` of shape\",\n \"raise ValueError( f\\\"Data of type {type(input_values)} is not allowed only {allowed_types} is accepted\",\n \"be multiplied by number of timesteps divided by length of mask span to\",\n \"ValueError(\\\"`mask_length` has to be bigger than 0.\\\") if mask_length > sequence_length: raise ValueError(\",\n \"- (mask_length - 1))) # get random indices to mask spec_aug_mask_idxs = _sample_without_replacement(uniform_dist,\",\n \"pair_indices = tf.transpose(tf.concat([broad_casted_batch_dims, tf.reshape(batch_indices, [1, -1])], 0)) # scatter values to pair indices\",\n \"axis=-1) >>> transcription = processor.decode(predicted_ids[0]) >>> # compute loss >>> target_transcription = \\\"A\",\n \"import inspect import warnings from typing import Any, Dict, Optional, Tuple, Union import\",\n \") self.padding = TFHubertSamePadLayer(config.num_conv_pos_embeddings) self.activation = get_tf_activation(config.feat_extract_activation) def call(self, hidden_states: tf.Tensor) -> tf.Tensor:\",\n \"None: output[k] = v elif k not in parameter_names and \\\"args\\\" not in\",\n \"= ds.map(map_to_array) >>> input_values = processor(ds[\\\"speech\\\"][0], return_tensors=\\\"tf\\\").input_values # Batch size 1 >>> hidden_states\",\n \"constraint=self.gamma_constraint, ) else: self.gamma = None def _add_beta_weight(self, input_shape): dim = input_shape[self.axis] shape\",\n \"2 self.initialized = False self.kernel_norm_axes = tf.constant([0, 1]) def _init_norm(self): \\\"\\\"\\\"Set the norm\",\n \"self.gamma = None def _add_beta_weight(self, input_shape): dim = input_shape[self.axis] shape = (dim,) if\",\n \"import warnings from typing import Any, Dict, Optional, Tuple, Union import numpy as\",\n \"allowed_types) or input is None: output[parameter_names[i]] = input else: raise ValueError( f\\\"Data of\",\n \"list {parameter_names} and will be ignored.\\\" ) continue else: raise ValueError(f\\\"Data of type\",\n \"you wish \\\" \\\"to train/fine-tine this model, you need a GPU or a\",\n \"actual number will be smaller (unless no_overlap is True) mask_length: size of the\",\n \"len(group_shape))) is_instance_norm = (input_shape[self.axis] // self.groups) == 1 if not is_instance_norm: axis =\",\n \"tf.keras.Input(shape=(128,), dtype='float32', name=\\\"input_values\\\")` otherwise the order of the tensors will not be guaranteed\",\n \"name=\\\"layer_norm\\\") self.feed_forward = TFHubertFeedForward(config, name=\\\"feed_forward\\\") self.final_layer_norm = tf.keras.layers.LayerNormalization( epsilon=config.layer_norm_eps, name=\\\"final_layer_norm\\\" ) def call(\",\n \"if not self.built: input_shape = input_shape.as_list() # Conv1D output shapes are checked at\",\n \"\\\"epsilon\\\": self.epsilon, \\\"center\\\": self.center, \\\"scale\\\": self.scale, \\\"beta_initializer\\\": tf.keras.initializers.serialize(self.beta_initializer), \\\"gamma_initializer\\\": tf.keras.initializers.serialize(self.gamma_initializer), \\\"beta_regularizer\\\": tf.keras.regularizers.serialize(self.beta_regularizer), \\\"gamma_regularizer\\\":\",\n \"kernel_initializer=get_initializer(config.initializer_range), bias_initializer=\\\"zeros\\\", name=\\\"intermediate_dense\\\", ) self.intermediate_act_fn = get_tf_activation(config.hidden_act) self.output_dense = tf.keras.layers.Dense( units=config.hidden_size, kernel_initializer=get_initializer(config.initializer_range), bias_initializer=\\\"zeros\\\",\",\n \"`[0, ..., config.vocab_size]` Returns: Example: ```python >>> import tensorflow as tf >>> from\",\n \"num_masked_spans) # expand masked indices to masked spans spec_aug_mask_idxs = tf.expand_dims(spec_aug_mask_idxs, -1) spec_aug_mask_idxs\",\n \":], hidden_states, ) elif self.config.mask_time_prob > 0: # generate indices & apply SpecAugment\",\n \"is not allowed only {allowed_types} is accepted for {k}.\\\") else: if isinstance(input_values, tf.Tensor)\",\n \"be removed in Transformers v5.\\\" \\\"Please use the equivalent `freeze_feature_encoder` method instead.\\\", FutureWarning,\",\n \"ds.map(map_to_array) >>> input_values = processor(ds[\\\"speech\\\"][0], return_tensors=\\\"tf\\\").input_values # Batch size 1 >>> logits =\",\n \"at build time since TF 2.7, so we need to account for padding\",\n \"None position_embeddings = self.pos_conv_embed(hidden_states) hidden_states = hidden_states + position_embeddings hidden_states = self.dropout(hidden_states, training=training)\",\n \"\\\"and will be removed in Transformers v5. \\\" f\\\"Use `{self.__class__.__bases__[0].__name__}` instead.\\\", FutureWarning, )\",\n \"name=\\\"lm_head\\\") def freeze_feature_extractor(self): \\\"\\\"\\\" Calling this function will disable the gradient computation for\",\n \"if tf.executing_eagerly(): tf.debugging.assert_equal( shape_list(attention_mask), [bsz, 1, tgt_len, src_len], message=f\\\"Attention mask should be of\",\n \"than the number of channels (\\\" + str(dim) + \\\").\\\" ) if dim\",\n \"have to be disabled in other modes than eager. if tf.executing_eagerly(): tf.debugging.assert_equal( shape_list(layer_head_mask),\",\n \"the License. \\\"\\\"\\\" TensorFlow Hubert model.\\\"\\\"\\\" import inspect import warnings from typing import\",\n \"parameter list {parameter_names} and will be ignored.\\\" ) continue else: raise ValueError(f\\\"Data of\",\n \"!= \\\"args\\\": output[name] = kwargs.pop(name, signature[name].default) # When creating a SavedModel TF calls\",\n \"nothing else: `model(inputs_ids)` - a list of varying length with one or several\",\n \"(masked), the loss is only computed for the tokens with labels in `[0,\",\n \"multiplied by number of timesteps divided by length of mask span to mask\",\n \"or saving, resizing the input embeddings, pruning heads etc.) This model is also\",\n \"`({0})`, *optional*): Indices of positions of each input sequence tokens in the position\",\n \"mask_length)) spec_aug_mask_idxs = tf.reshape(spec_aug_mask_idxs, (batch_size, num_masked_spans * mask_length)) offsets = tf.range(mask_length)[tf.newaxis, tf.newaxis, :]\",\n \"\\\") must be a \\\" \\\"multiple of the number of channels (\\\" +\",\n \"second option is useful when using [`tf.keras.Model.fit`] method which currently requires having all\",\n \"None if not inputs[\\\"return_dict\\\"]: output = (logits,) + outputs[1:] return ((loss,) + output)\",\n \"\\\"group\\\": conv_layers = [TFHubertGroupNormConvLayer(config, layer_id=0, name=f\\\"conv_layers.{0}\\\")] + [ TFHubertNoLayerNormConvLayer(config, layer_id=i + 1, name=f\\\"conv_layers.{i+1}\\\")\",\n \"processor as target processor to encode labels >>> with processor.as_target_processor(): ... labels =\",\n \"backpropagation operations that are NOT supported on CPU. If you wish \\\" \\\"to\",\n \"num_heads if (self.head_dim * num_heads) != self.embed_dim: raise ValueError( f\\\"embed_dim must be divisible\",\n \"float, mask_length: int, min_masks: int = 0, ) -> tf.Tensor: \\\"\\\"\\\" Computes random\",\n \"TFHubertEncoderStableLayerNorm(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs): super().__init__(**kwargs) self.config = config self.pos_conv_embed = TFHubertPositionalConvEmbedding(config,\",\n \"that are **not masked**, - 0 for tokens that are **masked**. [What are\",\n \"): super().__init__(**kwargs) self.embed_dim = embed_dim self.num_heads = num_heads self.dropout = tf.keras.layers.Dropout(dropout) self.head_dim =\",\n \"not None bsz, tgt_len, embed_dim = shape_list(hidden_states) # get query proj query_states =\",\n \"True) mask_length: size of the mask min_masks: minimum number of masked spans Adapted\",\n \"a real Tensor if type(input) == tf.Tensor: # Tensor names have always the\",\n \"tf.reshape(self._shape(query_states, tgt_len, bsz), proj_shape) key_states = tf.reshape(key_states, proj_shape) value_states = tf.reshape(value_states, proj_shape) src_len\",\n \"self.output_dense = tf.keras.layers.Dense( units=config.hidden_size, kernel_initializer=get_initializer(config.initializer_range), bias_initializer=\\\"zeros\\\", name=\\\"output_dense\\\", ) self.output_dropout = tf.keras.layers.Dropout(config.hidden_dropout) def call(self,\",\n \"tf.convert_to_tensor(np.random.rand(1, 16000), tf.float32) dummy_inputs = { \\\"input_values\\\": input_values, \\\"attention_mask\\\": tf.cast(tf.not_equal(input_values, pad_token), tf.float32), }\",\n \"as start of the span to be masked. this will be multiplied by\",\n \"mask_length + tf.random.uniform((1,))) num_masked_spans = max(num_masked_spans, min_masks) # make sure num masked indices\",\n \"= model(input_values, labels=labels).loss ```\\\"\\\"\\\" inputs = input_values_processing( func=self.call, config=self.config, input_values=input_values, attention_mask=attention_mask, token_type_ids=token_type_ids, position_ids=position_ids,\",\n \"for tokens that are **not masked**, - 0 for tokens that are **masked**.\",\n \"implied. # See the License for the specific language governing permissions and #\",\n \"= tf.argmax(logits, axis=-1) >>> transcription = processor.decode(predicted_ids[0]) >>> # compute loss >>> target_transcription\",\n \"all_self_attentions + (layer_outputs[1],) hidden_states = self.layer_norm(hidden_states) if output_hidden_states: all_hidden_states = all_hidden_states + (hidden_states,)\",\n \"logits=logits, labels=labels, logit_length=input_lengths, label_length=target_lengths, blank_index=self.config.pad_token_id, logits_time_major=False, ) if self.config.ctc_loss_reduction == \\\"sum\\\": loss =\",\n \"input_values=inputs[\\\"input_values\\\"], attention_mask=inputs[\\\"attention_mask\\\"], token_type_ids=inputs[\\\"token_type_ids\\\"], position_ids=inputs[\\\"position_ids\\\"], head_mask=inputs[\\\"head_mask\\\"], inputs_embeds=inputs[\\\"inputs_embeds\\\"], output_attentions=inputs[\\\"output_attentions\\\"], output_hidden_states=inputs[\\\"output_hidden_states\\\"], return_dict=inputs[\\\"return_dict\\\"], training=inputs[\\\"training\\\"], ) return outputs\",\n \"= True super().build(input_shape) def call(self, inputs): input_shape = tf.keras.backend.int_shape(inputs) tensor_input_shape = tf.shape(inputs) reshaped_inputs,\",\n \"tgt_len, bsz), proj_shape) key_states = tf.reshape(key_states, proj_shape) value_states = tf.reshape(value_states, proj_shape) src_len =\",\n \"filters=self.out_conv_dim, kernel_size=config.conv_kernel[layer_id], strides=config.conv_stride[layer_id], use_bias=config.conv_bias, name=\\\"conv\\\", ) self.layer_norm = tf.keras.layers.LayerNormalization(name=\\\"layer_norm\\\", epsilon=config.layer_norm_eps) self.activation = get_tf_activation(config.feat_extract_activation)\",\n \"name=f\\\"conv_layers.{i+1}\\\") for i in range(config.num_feat_extract_layers - 1) ] elif config.feat_extract_norm == \\\"layer\\\": conv_layers\",\n \"TFBaseModelOutput(last_hidden_state=output.last_hidden_state, hidden_states=hs, attentions=attns) @add_start_docstrings( \\\"\\\"\\\"TFHubert Model with a `language modeling` head on top\",\n \"training=training ) hidden_states = self.dropout(hidden_states, training=training) hidden_states = attn_residual + hidden_states hidden_states =\",\n \"def _get_feat_extract_output_lengths(self, input_lengths: tf.Tensor): \\\"\\\"\\\" Computes the output length of the convolutional layers\",\n \"is useful when using [`tf.keras.Model.fit`] method which currently requires having all the tensors\",\n \"HUBERT_START_DOCSTRING = r\\\"\\\"\\\" This model inherits from [`TFPreTrainedModel`]. Check the superclass documentation for\",\n \"return inputs, group_shape def _apply_normalization(self, reshaped_inputs, input_shape): group_shape = tf.keras.backend.int_shape(reshaped_inputs) group_reduction_axes = list(range(1,\",\n \"is None: output[k] = v elif k not in parameter_names and \\\"args\\\" not\",\n \"two formats as inputs: - having all inputs as keyword arguments (like PyTorch\",\n \"output_hidden_states else None all_self_attentions = () if output_attentions else None if attention_mask is\",\n \"if isinstance(v, allowed_types) or v is None: output[k] = v elif k not\",\n \"be of size 2 where first element is batch size and 2nd is\",\n \"transformers.models.wav2vec2.modeling_tf_wav2vec2._compute_mask_indices def _compute_mask_indices( shape: Tuple[int, int], mask_prob: float, mask_length: int, min_masks: int =\",\n \"= self.intermediate_act_fn(hidden_states) hidden_states = self.intermediate_dropout(hidden_states, training=training) hidden_states = self.output_dense(hidden_states) hidden_states = self.output_dropout(hidden_states, training=training)\",\n \"another one for the unexpected layers. \\\"\\\"\\\" signature = dict(inspect.signature(func).parameters) signature.pop(\\\"kwargs\\\", None) signature.pop(\\\"self\\\",\",\n \"not is_instance_norm: group_shape[self.axis] = input_shape[self.axis] // self.groups group_shape.insert(self.axis, self.groups) group_shape = tf.stack(group_shape) reshaped_inputs\",\n \"(self.explicit_padding, self.explicit_padding), (0, 0))) output = super().call(padded_inputs) return output # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2NoLayerNormConvLayer\",\n \"labels=labels, logit_length=input_lengths, label_length=target_lengths, blank_index=self.config.pad_token_id, logits_time_major=False, ) if self.config.ctc_loss_reduction == \\\"sum\\\": loss = tf.reduce_sum(loss)\",\n \"spec_aug_mask_idxs = tf.tile(spec_aug_mask_idxs, (1, 1, mask_length)) spec_aug_mask_idxs = tf.reshape(spec_aug_mask_idxs, (batch_size, num_masked_spans * mask_length))\",\n \"only {allowed_types} is accepted for {k}.\\\") else: if isinstance(input_values, tf.Tensor) or input_values is\",\n \"1))) # get random indices to mask spec_aug_mask_idxs = _sample_without_replacement(uniform_dist, num_masked_spans) # expand\",\n \"attn_residual + hidden_states hidden_states = hidden_states + self.feed_forward(self.final_layer_norm(hidden_states)) outputs = (hidden_states,) if output_attentions:\",\n \"# See the License for the specific language governing permissions and # limitations\",\n \"inputs, input_shape, tensor_input_shape): group_shape = [tensor_input_shape[i] for i in range(len(input_shape))] is_instance_norm = (input_shape[self.axis]\",\n \"[ TFHubertNoLayerNormConvLayer(config, layer_id=i + 1, name=f\\\"conv_layers.{i+1}\\\") for i in range(config.num_feat_extract_layers - 1) ]\",\n \"self.config.output_attentions ) inputs[\\\"return_dict\\\"] = inputs[\\\"return_dict\\\"] if inputs[\\\"return_dict\\\"] else self.config.return_dict outputs = self.hubert( input_values=inputs[\\\"input_values\\\"],\",\n \"name=\\\"layer_norm\\\") self.projection = tf.keras.layers.Dense( units=config.hidden_size, kernel_initializer=get_initializer(config.initializer_range), bias_initializer=\\\"zeros\\\", name=\\\"projection\\\", ) self.dropout = tf.keras.layers.Dropout(rate=config.feat_proj_dropout) def\",\n \"or input_values is None: output[parameter_names[0]] = input_values else: raise ValueError( f\\\"Data of type\",\n \"methods the library implements for all its model (such as downloading or saving,\",\n \"tf.Tensor) -> tf.Tensor: hidden_states = self.conv(hidden_states) hidden_states = self.padding(hidden_states) hidden_states = self.activation(hidden_states) return\",\n \"self.add_weight( shape=(self.config.hidden_size,), initializer=\\\"uniform\\\", trainable=True, name=\\\"masked_spec_embed\\\" ) super().build(input_shape) def _get_feat_extract_output_lengths(self, input_lengths: tf.Tensor): \\\"\\\"\\\" Computes\",\n \"the HuggingFace Inc. team. All rights reserved. # # Licensed under the Apache\",\n \"inputs[\\\"attention_mask\\\"] if inputs[\\\"attention_mask\\\"] is not None else tf.ones_like(inputs[\\\"input_values\\\"], dtype=tf.float32) ) input_lengths = self.hubert._get_feat_extract_output_lengths(tf.reduce_sum(attention_mask,\",\n \"None) signature.pop(\\\"self\\\", None) parameter_names = list(signature.keys()) output = {} allowed_types = (tf.Tensor, bool,\",\n \"-1, 1, 1)) * tf.reshape( attn_weights, (bsz, self.num_heads, tgt_len, src_len) ) attn_weights =\",\n \"((loss,) + output) if loss is not None else output return TFCausalLMOutput( loss=loss,\",\n \"self.feed_forward(self.final_layer_norm(hidden_states)) outputs = (hidden_states,) if output_attentions: outputs += (attn_weights,) return outputs # Copied\",\n \"def __init__(self, config: HubertConfig, layer_id: int = 0, **kwargs: Any) -> None: super().__init__(**kwargs)\",\n \"inputs, each input has to be named accordingly to the parameters name, i.e.\",\n \"all the parameters of the model. Initializing with a config file does not\",\n \"in [hidden_states, all_hidden_states, all_self_attentions] if v is not None) return TFBaseModelOutput( last_hidden_state=hidden_states, hidden_states=all_hidden_states,\",\n \"= _conv_out_length(input_lengths, kernel_size, stride) return input_lengths def _mask_hidden_states(self, hidden_states: tf.Tensor, mask_time_indices: Optional[tf.Tensor] =\",\n \"self.gamma_regularizer = tf.keras.regularizers.get(gamma_regularizer) self.beta_constraint = tf.keras.constraints.get(beta_constraint) self.gamma_constraint = tf.keras.constraints.get(gamma_constraint) self._check_axis() def build(self, input_shape):\",\n \"to be disabled in other modes than eager. if tf.executing_eagerly(): tf.debugging.assert_equal( shape_list(attn_output), [bsz\",\n \"hidden_states: tf.Tensor, attention_mask: Optional[tf.Tensor] = None, output_attentions: Optional[bool] = False, training: bool =\",\n \"the tensors in the first argument of the model call function: `model(inputs)`. If\",\n \"0, ..., config.vocab_size]` (see `input_values` docstring) Tokens with indices set to `-100` are\",\n \"directly pass an embedded representation. This is useful if you want more control\",\n \"the head is **not masked**, - 0 indicates the head is **masked**. inputs_embeds\",\n \"**masked**. [What are attention masks?](../glossary#attention-mask) token_type_ids (`np.ndarray` or `tf.Tensor` of shape `({0})`, *optional*):\",\n \"# Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.input_values_processing def input_values_processing(func, config, input_values, **kwargs): \\\"\\\"\\\" Process the input\",\n \"self.intermediate_act_fn = get_tf_activation(config.hidden_act) self.output_dense = tf.keras.layers.Dense( units=config.hidden_size, kernel_initializer=get_initializer(config.initializer_range), bias_initializer=\\\"zeros\\\", name=\\\"output_dense\\\", ) self.output_dropout =\",\n \"None, training: bool = False, ) -> Union[TFBaseModelOutput, Tuple[tf.Tensor]]: \\\"\\\"\\\" Returns: Example: ```python\",\n \"warnings.warn( \\\"The `inputs` argument is deprecated and will be removed in a future\",\n \"= [TFHubertEncoderLayer(config, name=f\\\"layers.{i}\\\") for i in range(config.num_hidden_layers)] def call( self, hidden_states: tf.Tensor, attention_mask:\",\n \"= tf.concat([past_key_value[0], key_states], axis=2) value_states = tf.concat([past_key_value[1], value_states], axis=2) else: # self_attention key_states\",\n \"1 if not is_instance_norm: broadcast_shape[self.axis] = input_shape[self.axis] // self.groups broadcast_shape.insert(self.axis, self.groups) else: broadcast_shape[self.axis]\",\n \"attention on padding token indices. Mask values selected in `[0, 1]`: - 1\",\n \"# Copied from transformers.models.bart.modeling_tf_bart._expand_mask def _expand_mask(mask: tf.Tensor, tgt_len: Optional[int] = None, past_key_values_length: int\",\n \"= (input_shape[self.axis] // self.groups) == 1 if not is_instance_norm: broadcast_shape[self.axis] = input_shape[self.axis] //\",\n \"sequence tokens in the vocabulary. Indices can be obtained using [`BertTokenizer`]. See [`PreTrainedTokenizer.__call__`]\",\n \"hidden_states = model(input_values).last_hidden_state ```\\\"\\\"\\\" inputs = input_values_processing( func=self.call, config=self.config, input_values=input_values, attention_mask=attention_mask, token_type_ids=token_type_ids, position_ids=position_ids,\",\n \"self.layer_norm = tf.keras.layers.LayerNormalization(epsilon=config.layer_norm_eps, name=\\\"layer_norm\\\") self.feed_forward = TFHubertFeedForward(config, name=\\\"feed_forward\\\") self.final_layer_norm = tf.keras.layers.LayerNormalization( epsilon=config.layer_norm_eps, name=\\\"final_layer_norm\\\"\",\n \"def call(self, hidden_states: tf.Tensor) -> tf.Tensor: hidden_states = self.conv(hidden_states) hidden_states = self.activation(hidden_states) return\",\n \"hidden_states = hidden_states + position_embeddings hidden_states = self.dropout(hidden_states, training=training) for i, layer_module in\",\n \"token_type_ids=token_type_ids, position_ids=position_ids, head_mask=head_mask, inputs_embeds=inputs_embeds, output_attentions=output_attentions, output_hidden_states=output_hidden_states, return_dict=return_dict, training=training, kwargs_call=kwargs, ) hidden_states = self.feature_extractor(\",\n \"tf.where(mask_feature_indices[:, tf.newaxis, :], hidden_states, 0) return hidden_states def call( self, input_values: tf.Tensor, attention_mask:\",\n \"= inputs[\\\"return_dict\\\"] if inputs[\\\"return_dict\\\"] else self.config.return_dict outputs = self.hubert( input_values=inputs[\\\"input_values\\\"], attention_mask=inputs[\\\"attention_mask\\\"], token_type_ids=inputs[\\\"token_type_ids\\\"], position_ids=inputs[\\\"position_ids\\\"],\",\n \"`input_values = tf.keras.Input(shape=(128,), dtype='float32', name=\\\"input_values\\\")` otherwise the order of the tensors will not\",\n \"Optional[tf.Tensor] = None, past_key_value: Optional[Tuple[Tuple[tf.Tensor]]] = None, attention_mask: Optional[tf.Tensor] = None, layer_head_mask: Optional[tf.Tensor]\",\n \"input_shape): dim = input_shape[self.axis] if dim is None: raise ValueError( \\\"Axis \\\" +\",\n \"account for padding input_shape[-2] += self.explicit_padding * 2 super().build(input_shape) self.kernel = tf.Variable(tf.transpose(self.kernel), name=\\\"weight_v\\\",\",\n \"np import tensorflow as tf from ...activations_tf import get_tf_activation from ...modeling_tf_outputs import TFBaseModelOutput,\",\n \"Any) -> None: super().__init__(**kwargs) if config.feat_extract_norm == \\\"group\\\": conv_layers = [TFHubertGroupNormConvLayer(config, layer_id=0, name=f\\\"conv_layers.{0}\\\")]\",\n \"- 1 corresponds to a *sentence B* token. [What are token type IDs?](../glossary#token-type-ids)\",\n \"offset samples are < sequence_length uniform_dist = tf.ones((batch_size, sequence_length - (mask_length - 1)))\",\n \"True, training: Optional[bool] = False, ) -> Union[TFBaseModelOutput, Tuple[tf.Tensor]]: all_hidden_states = () if\",\n \"parameter_names: output[tensor_name] = input else: output[parameter_names[i]] = input elif isinstance(input, allowed_types) or input\",\n \"as a regular TF 2.0 Keras Model and refer to the TF 2.0\",\n \"self.conv = TFHubertWeightNormConv1D( filters=config.hidden_size, kernel_size=config.num_conv_pos_embeddings, groups=config.num_conv_pos_embedding_groups, explicit_padding=config.num_conv_pos_embeddings // 2, name=\\\"conv\\\", ) self.padding =\",\n \"hidden_states = self.output_dense(hidden_states) hidden_states = self.output_dropout(hidden_states, training=training) return hidden_states # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2EncoderLayer\",\n \"eager mode, in graph mode the value will always be set to True.\",\n \"of mask span to mask approximately this percentage of all elements. however due\",\n \"= 0, **kwargs: Any) -> None: super().__init__(**kwargs) self.in_conv_dim = config.conv_dim[layer_id] if layer_id >\",\n \"the span to be masked. this will be multiplied by number of timesteps\",\n \"self.layer_norm(hidden_states) hidden_states = self.dropout(hidden_states, training=training) for i, layer_module in enumerate(self.layer): if output_hidden_states: all_hidden_states\",\n \") -> Union[TFBaseModelOutput, Tuple[tf.Tensor]]: \\\"\\\"\\\" Returns: Example: ```python >>> from transformers import Wav2Vec2Processor,\",\n \":, tf.newaxis], tf.bool), self.masked_spec_embed[tf.newaxis, tf.newaxis, :], hidden_states, ) elif self.config.mask_time_prob > 0: #\",\n \"https://www.tensorflow.org/probability/api_docs/python/tfp/layers/weight_norm/WeightNorm\\\"\\\"\\\" def __init__(self, filters, kernel_size, groups, explicit_padding, **kwargs): super().__init__( filters=filters, kernel_size=kernel_size, groups=groups, padding=\\\"valid\\\",\",\n \"the training. Args: func (`callable`): The callable function of the TensorFlow model. config\",\n \"training=inputs[\\\"training\\\"], ) return outputs def serving_output(self, output): hs = tf.convert_to_tensor(output.hidden_states) if self.config.output_hidden_states else\",\n \"logits = self.lm_head(hidden_states) if labels is not None: if tf.reduce_max(labels) >= self.config.vocab_size: raise\",\n \"= processor.decode(predicted_ids[0]) >>> # compute loss >>> target_transcription = \\\"A MAN SAID TO\",\n \"k,v, cross_attentions key_states = past_key_value[0] value_states = past_key_value[1] elif is_cross_attention: # cross_attentions key_states\",\n \"if tensor_name in parameter_names: output[tensor_name] = input else: output[parameter_names[i]] = input elif isinstance(input,\",\n \"output_attentions=inputs[\\\"output_attentions\\\"], output_hidden_states=inputs[\\\"output_hidden_states\\\"], return_dict=inputs[\\\"return_dict\\\"], training=inputs[\\\"training\\\"], ) hidden_states = encoder_outputs[0] if not inputs[\\\"return_dict\\\"]: return (hidden_states,)\",\n \"previous decoder key/value_states. Further calls to uni-directional self-attention # can concat previous decoder\",\n \"None, return_dict: Optional[bool] = None, training: bool = False, ) -> Union[TFBaseModelOutput, Tuple[tf.Tensor]]:\",\n \"self.output_dropout = tf.keras.layers.Dropout(config.hidden_dropout) def call(self, hidden_states: tf.Tensor, training: bool = False) -> tf.Tensor:\",\n \"*optional*, defaults to `False``): Whether or not to use the model in training\",\n \"hidden_states=hs, attentions=attns) @add_start_docstrings( \\\"\\\"\\\"TFHubert Model with a `language modeling` head on top for\",\n \"else: raise ValueError(f\\\"Data of type {type(v)} is not allowed only {allowed_types} is accepted\",\n \"if not is_instance_norm: outputs = tf.reshape(normalized_inputs, tensor_input_shape) else: outputs = normalized_inputs return outputs\",\n \"of the running model. **kwargs: The inputs of the model. Returns: Two lists,\",\n \"with Wav2Vec2->Hubert class TFHubertEncoder(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs): super().__init__(**kwargs) self.config = config\",\n \"by length of mask span to mask approximately this percentage of all elements.\",\n \"= True self.groups = groups self.axis = axis self.epsilon = epsilon self.center =\",\n \"self.intermediate_act_fn(hidden_states) hidden_states = self.intermediate_dropout(hidden_states, training=training) hidden_states = self.output_dense(hidden_states) hidden_states = self.output_dropout(hidden_states, training=training) return\",\n \"Optional[tf.Tensor] = None, layer_head_mask: Optional[tf.Tensor] = None, training: Optional[bool] = False, ) ->\",\n \"= \\\"input_values\\\" @property def dummy_inputs(self) -> Dict[str, tf.Tensor]: pad_token = 0.0 input_values =\",\n \"to the input names given in the docstring: `model({\\\"input_values\\\": input_values, \\\"token_type_ids\\\": token_type_ids})` </Tip>\",\n \"key_states], axis=2) value_states = tf.concat([past_key_value[1], value_states], axis=2) else: # self_attention key_states = self._shape(self.k_proj(hidden_states),\",\n \"config ([`HubertConfig`]): Model configuration class with all the parameters of the model. Initializing\",\n \"Tokens with indices set to `-100` are ignored (masked), the loss is only\",\n \"mask_time_indices is not None: # apply SpecAugment along time axis with given mask_time_indices\",\n \"False, return_dict: Optional[bool] = True, training: Optional[bool] = False, ) -> Union[TFBaseModelOutput, Tuple[tf.Tensor]]:\",\n \"want to \\\" \\\"use tf.layer.batch_normalization instead\\\" ) def _create_input_spec(self, input_shape): dim = input_shape[self.axis]\",\n \"with Wav2Vec2->Hubert class TFHubertSamePadLayer(tf.keras.layers.Layer): def __init__(self, num_conv_pos_embeddings, **kwargs): super().__init__(**kwargs) self.num_pad_remove = 1 if\",\n \"Optional[tf.Tensor] = None, output_attentions: Optional[bool] = None, labels: Optional[tf.Tensor] = None, output_hidden_states: Optional[bool]\",\n \"= self._shape(self.k_proj(hidden_states), -1, bsz) value_states = self._shape(self.v_proj(hidden_states), -1, bsz) if self.is_decoder: # if\",\n \"attn_weights = tf.reshape(attn_weights, (bsz * self.num_heads, tgt_len, src_len)) attn_weights = tf.nn.softmax(attn_weights, axis=-1) if\",\n \"if isinstance(input_values, tf.Tensor) or input_values is None: output[parameter_names[0]] = input_values else: raise ValueError(\",\n \"= (hidden_states,) if output_attentions: outputs += (attn_weights,) return outputs # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2EncoderLayerStableLayerNorm\",\n \"initialization and a simple interface for downloading and loading pretrained models. \\\"\\\"\\\" config_class\",\n \"in list(output.keys()) and name != \\\"args\\\": output[name] = kwargs.pop(name, signature[name].default) # When creating\",\n \"HubertConfig, **kwargs: Any) -> None: super().__init__(**kwargs) self.conv = TFHubertWeightNormConv1D( filters=config.hidden_size, kernel_size=config.num_conv_pos_embeddings, groups=config.num_conv_pos_embedding_groups, explicit_padding=config.num_conv_pos_embeddings\",\n \"channels (\\\" + str(dim) + \\\").\\\" ) if dim % self.groups != 0:\",\n \"are filled with -100 # when not being attended to labels_mask = tf.cast(labels\",\n \"0 for tokens that are **masked**. [What are attention masks?](../glossary#attention-mask) token_type_ids (`np.ndarray` or\",\n \"if not self.initialized: self._init_norm() self.initialized = True self._normalize_kernel() padded_inputs = tf.pad(inputs, ((0, 0),\",\n \"outputs # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2EncoderLayerStableLayerNorm with Wav2Vec2->Hubert class TFHubertEncoderLayerStableLayerNorm(tf.keras.layers.Layer): def __init__(self, config: HubertConfig,\",\n \"self.bias = self.add_weight(name=\\\"bias\\\", shape=(self.filters,), initializer=\\\"zeros\\\", trainable=True) def call(self, inputs): if not self.initialized: self._init_norm()\",\n \"for v in [hidden_states, all_hidden_states, all_self_attentions] if v is not None) return TFBaseModelOutput(\",\n \"kernel_size, stride in zip(self.config.conv_kernel, self.config.conv_stride): input_lengths = _conv_out_length(input_lengths, kernel_size, stride) return input_lengths def\",\n \"`config.apply_spec_augment` can set masking to False if not getattr(self.config, \\\"apply_spec_augment\\\", True): return hidden_states\",\n \"`(num_heads,)` or `(num_layers, num_heads)`, *optional*): Mask to nullify selected heads of the self-attention\",\n \"uniform distribution to sample from, make sure that offset samples are < sequence_length\",\n \"() if output_hidden_states else None all_self_attentions = () if output_attentions else None if\",\n \"in training mode (some modules like dropout modules have different behaviors between training\",\n \"head on top.\\\", HUBERT_START_DOCSTRING, ) class TFHubertModel(TFHubertPreTrainedModel): def __init__(self, config: HubertConfig, *inputs, **kwargs):\",\n \"for k, v in output.items() if k in [\\\"return_dict\\\", \\\"output_attentions\\\", \\\"output_hidden_states\\\", \\\"use_cache\\\"] }\",\n \"[self.num_heads], message=f\\\"Head mask for a single layer should be of size {(self.num_heads)}, but\",\n \"reuse all cross-attention # key/value_states (first \\\"if\\\" case) # if uni-directional self-attention (decoder)\",\n \"Wav2Vec2->Hubert class TFHubertFeedForward(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs): super().__init__(**kwargs) self.intermediate_dropout = tf.keras.layers.Dropout(config.activation_dropout) self.intermediate_dense\",\n \"> 0: # generate indices & apply SpecAugment along time axis mask_time_indices =\",\n \"groups self.axis = axis self.epsilon = epsilon self.center = center self.scale = scale\",\n \"Tuple[tf.Tensor]]: r\\\"\\\"\\\" labels (`tf.Tensor` or `np.ndarray` of shape `(batch_size, sequence_length)`, *optional*): Labels for\",\n \"hidden_states: tf.Tensor, training: bool = False) -> tf.Tensor: hidden_states = self.layer_norm(hidden_states) hidden_states =\",\n \"= _scatter_values_on_batch_indices( tf.ones_like(spec_aug_mask_idxs), spec_aug_mask_idxs, spec_aug_mask.shape ) return spec_aug_mask # Copied from transformers.models.bart.modeling_tf_bart._expand_mask def\",\n \"shape=shape, name=\\\"gamma\\\", initializer=self.gamma_initializer, regularizer=self.gamma_regularizer, constraint=self.gamma_constraint, ) else: self.gamma = None def _add_beta_weight(self, input_shape):\",\n \"check for a real Tensor if type(input) == tf.Tensor: # Tensor names have\",\n \"(`tf.Tensor` or `np.ndarray` of shape `(batch_size, sequence_length)`, *optional*): Labels for computing the masked\",\n \"```python >>> import tensorflow as tf >>> from transformers import Wav2Vec2Processor, TFHubertForCTC >>>\",\n \"is deprecated and will be removed in a future version, use `past_key_values` instead.\\\",\",\n \"shape `({0})`, *optional*): Indices of positions of each input sequence tokens in the\",\n \"= tf.keras.layers.Dense( units=config.intermediate_size, kernel_initializer=get_initializer(config.initializer_range), bias_initializer=\\\"zeros\\\", name=\\\"intermediate_dense\\\", ) self.intermediate_act_fn = get_tf_activation(config.hidden_act) self.output_dense = tf.keras.layers.Dense(\",\n \"tuple. This argument can be used in eager mode, in graph mode the\",\n \"input_shape): dim = input_shape[self.axis] self.input_spec = tf.keras.layers.InputSpec(ndim=len(input_shape), axes={self.axis: dim}) def _add_gamma_weight(self, input_shape): dim\",\n \"not is_instance_norm: axis = -2 if self.axis == -1 else self.axis - 1\",\n \"cross-attention # key/value_states (first \\\"if\\\" case) # if uni-directional self-attention (decoder) save Tuple(tf.Tensor,\",\n \"sequence_length // mask_length # SpecAugment mask to fill spec_aug_mask = tf.zeros((batch_size, sequence_length), dtype=tf.int32)\",\n \"Whether or not to return the attentions tensors of all attention layers. See\",\n \"= tf.keras.layers.Dense(embed_dim, use_bias=bias, name=\\\"v_proj\\\") self.out_proj = tf.keras.layers.Dense(embed_dim, use_bias=bias, name=\\\"out_proj\\\") def _shape(self, tensor: tf.Tensor,\",\n \"bias_initializer=\\\"he_normal\\\", **kwargs, ) self.explicit_padding = explicit_padding self.filter_axis = 2 self.initialized = False self.kernel_norm_axes\",\n \") inputs[\\\"return_dict\\\"] = inputs[\\\"return_dict\\\"] if inputs[\\\"return_dict\\\"] else self.config.return_dict outputs = self.hubert( input_values=inputs[\\\"input_values\\\"], attention_mask=inputs[\\\"attention_mask\\\"],\",\n \"= tf.keras.initializers.get(gamma_initializer) self.beta_regularizer = tf.keras.regularizers.get(beta_regularizer) self.gamma_regularizer = tf.keras.regularizers.get(gamma_regularizer) self.beta_constraint = tf.keras.constraints.get(beta_constraint) self.gamma_constraint =\",\n \"hidden_states + self.feed_forward(self.final_layer_norm(hidden_states)) outputs = (hidden_states,) if output_attentions: outputs += (attn_weights,) return outputs\",\n \"= (input_shape[self.axis] // self.groups) == 1 if not is_instance_norm: axis = -2 if\",\n \"handle weights initialization and a simple interface for downloading and loading pretrained models.\",\n \"freeze_feature_extractor(self): \\\"\\\"\\\" Calling this function will disable the gradient computation for the feature\",\n \"input_values = tf.convert_to_tensor(np.random.rand(1, 16000), tf.float32) dummy_inputs = { \\\"input_values\\\": input_values, \\\"attention_mask\\\": tf.cast(tf.not_equal(input_values, pad_token),\",\n \"self.head_dim**-0.5 self.is_decoder = is_decoder self.k_proj = tf.keras.layers.Dense(embed_dim, use_bias=bias, name=\\\"k_proj\\\") self.q_proj = tf.keras.layers.Dense(embed_dim, use_bias=bias,\",\n \"\\\"\\\"\\\" From tensorflow-addons https://www.tensorflow.org/addons/api_docs/python/tfa/layers/GroupNormalization \\\"\\\"\\\" def __init__( self, groups: int = 32, axis:\",\n \"attention_mask = None position_embeddings = self.pos_conv_embed(hidden_states) hidden_states = hidden_states + position_embeddings hidden_states =\",\n \"self.kernel_norm_axes = tf.constant([0, 1]) def _init_norm(self): \\\"\\\"\\\"Set the norm of the weight vector.\\\"\\\"\\\"\",\n \"build(self, input_shape): if not self.built: input_shape = input_shape.as_list() # Conv1D output shapes are\",\n \"True self._normalize_kernel() padded_inputs = tf.pad(inputs, ((0, 0), (self.explicit_padding, self.explicit_padding), (0, 0))) output =\",\n \"no_overlap is True) mask_length: size of the mask min_masks: minimum number of masked\",\n \"sf >>> processor = Wav2Vec2Processor.from_pretrained(\\\"facebook/hubert-base-960h\\\") >>> model = TFHubertForCTC.from_pretrained(\\\"facebook/hubert-base-960h\\\") >>> def map_to_array(batch): ...\",\n \"self.head_dim)}, but is {shape_list(attn_output)}\\\", ) attn_output = tf.transpose( tf.reshape(attn_output, (bsz, self.num_heads, tgt_len, self.head_dim)),\",\n \"output[\\\"past_key_values\\\"] = input_values.pop(\\\"decoder_cached_states\\\") for k, v in dict(input_values).items(): if isinstance(v, allowed_types) or v\",\n \"# assuming that padded tokens are filled with -100 # when not being\",\n \"2 super().build(input_shape) self.kernel = tf.Variable(tf.transpose(self.kernel), name=\\\"weight_v\\\", trainable=True) self.weight_v = self.kernel self.weight_g = self.add_weight(\",\n \"_compute_mask_indices( (batch_size, sequence_length), mask_prob=self.config.mask_time_prob, mask_length=self.config.mask_time_length, min_masks=2, ) hidden_states = tf.where( tf.cast(mask_time_indices[:, :, tf.newaxis],\",\n \"= input_shape.as_list() # Conv1D output shapes are checked at build time since TF\",\n \"SAID TO THE UNIVERSE SIR I EXIST\\\" >>> # wrap processor as target\",\n \"1, 3) ) attn_output = tf.reshape(attn_output, (bsz, tgt_len, embed_dim)) attn_output = self.out_proj(attn_output) attn_weights:\",\n \"are trying to normalize your batch axis. Do you want to \\\" \\\"use\",\n \"have the shape `({0})`): Indices of input sequence tokens in the vocabulary. Indices\",\n \") hidden_states = self.feature_extractor( tf.cast(inputs[\\\"input_values\\\"], tf.float32), training=inputs[\\\"training\\\"] ) if inputs[\\\"attention_mask\\\"] is not None:\",\n \"== 1 if not is_instance_norm: group_shape[self.axis] = input_shape[self.axis] // self.groups group_shape.insert(self.axis, self.groups) group_shape\",\n \"https://pytorch.org/docs/stable/generated/torch.nn.Conv1d.html return (input_length - kernel_size) // stride + 1 for kernel_size, stride in\",\n \"All You Need\\\"\\\"\\\" def __init__( self, embed_dim: int, num_heads: int, dropout: float =\",\n \"mask_time_indices hidden_states = tf.where( tf.cast(mask_time_indices[:, :, tf.newaxis], tf.bool), self.masked_spec_embed[tf.newaxis, tf.newaxis, :], hidden_states, )\",\n \"allowed only {allowed_types} is accepted for {k}.\\\") else: if isinstance(input_values, tf.Tensor) or input_values\",\n \"modules like dropout modules have different behaviors between training and evaluation). \\\"\\\"\\\" @add_start_docstrings(\",\n \"else self.config.output_attentions ) inputs[\\\"return_dict\\\"] = inputs[\\\"return_dict\\\"] if inputs[\\\"return_dict\\\"] else self.config.return_dict outputs = self.hubert(\",\n \"input_values is None: output[parameter_names[0]] = input_values else: raise ValueError( f\\\"Data of type {type(input_values)}\",\n \"__init__(self, config: HubertConfig, layer_id: int = 0, **kwargs: Any) -> None: super().__init__(**kwargs) self.in_conv_dim\",\n \"src_len) ) attn_weights = tf.reshape(attn_weights, (bsz * self.num_heads, tgt_len, src_len)) attn_probs = self.dropout(attn_weights,\",\n \"past_key_value is not None: # reuse k, v, self_attention key_states = self._shape(self.k_proj(hidden_states), -1,\",\n \"in range(len(input_shape))] is_instance_norm = (input_shape[self.axis] // self.groups) == 1 if not is_instance_norm: group_shape[self.axis]\",\n \"**kwargs: Any) -> None: super().__init__(**kwargs) self.in_conv_dim = config.conv_dim[layer_id] if layer_id > 0 else\",\n \"output_attentions: Optional[tf.Tensor] = None, output_hidden_states: Optional[tf.Tensor] = None, return_dict: Optional[bool] = None, training:\",\n \"= tf.cast(mask, dtype=one_cst.dtype) expanded_mask = tf.tile(mask[:, None, None, :], (1, 1, tgt_len, 1))\",\n \"False, ) -> Union[TFBaseModelOutput, Tuple[tf.Tensor]]: \\\"\\\"\\\" Returns: Example: ```python >>> from transformers import\",\n \"formula taken # from https://pytorch.org/docs/stable/generated/torch.nn.Conv1d.html return (input_length - kernel_size) // stride + 1\",\n \"dim = input_shape[self.axis] if dim is None: raise ValueError( \\\"Axis \\\" + str(self.axis)\",\n \"+ (layer_outputs[1],) # Add last layer if output_hidden_states: all_hidden_states = all_hidden_states + (hidden_states,)\",\n \"input_lengths: tf.Tensor): \\\"\\\"\\\" Computes the output length of the convolutional layers \\\"\\\"\\\" def\",\n \"`[0, 1]`: - 0 corresponds to a *sentence A* token, - 1 corresponds\",\n \"return_dict=inputs[\\\"return_dict\\\"], training=inputs[\\\"training\\\"], ) hidden_states = encoder_outputs[0] if not inputs[\\\"return_dict\\\"]: return (hidden_states,) + encoder_outputs[1:]\",\n \"output[\\\"kwargs\\\"] boolean_dict = { k: v for k, v in output.items() if k\",\n \"**kwargs): super().__init__(**kwargs) self.attention = TFHubertAttention( embed_dim=config.hidden_size, num_heads=config.num_attention_heads, dropout=config.attention_dropout, is_decoder=False, name=\\\"attention\\\", ) self.dropout =\",\n \"need to account for padding input_shape[-2] += self.explicit_padding * 2 super().build(input_shape) self.kernel =\",\n \"(such as downloading or saving, resizing the input embeddings, pruning heads etc.) This\",\n \"int], mask_prob: float, mask_length: int, min_masks: int = 0, ) -> tf.Tensor: \\\"\\\"\\\"\",\n \"= logging.get_logger(__name__) _CONFIG_FOR_DOC = \\\"HubertConfig\\\" TF_HUBERT_PRETRAINED_MODEL_ARCHIVE_LIST = [ \\\"facebook/hubert-base-ls960\\\", # See all Hubert\",\n \"\\\"\\\"\\\" An abstract class to handle weights initialization and a simple interface for\",\n \"False, ) -> Union[TFCausalLMOutput, Tuple[tf.Tensor]]: r\\\"\\\"\\\" labels (`tf.Tensor` or `np.ndarray` of shape `(batch_size,\",\n \"offset=beta, variance_epsilon=self.epsilon, ) return normalized_inputs def _get_reshaped_weights(self, input_shape): broadcast_shape = self._create_broadcast_shape(input_shape) gamma =\",\n \"input_shape[self.axis] if self.groups == -1: self.groups = dim def _check_size_of_dimensions(self, input_shape): dim =\",\n \"signature.pop(\\\"kwargs\\\", None) signature.pop(\\\"self\\\", None) parameter_names = list(signature.keys()) output = {} allowed_types = (tf.Tensor,\",\n \"to encode labels >>> with processor.as_target_processor(): ... labels = processor(transcription, return_tensors=\\\"tf\\\").input_values >>> loss\",\n \"= ( inputs[\\\"output_attentions\\\"] if inputs[\\\"output_attentions\\\"] else self.config.output_attentions ) inputs[\\\"return_dict\\\"] = inputs[\\\"return_dict\\\"] if inputs[\\\"return_dict\\\"]\",\n \"return TFBaseModelOutput( last_hidden_state=hidden_states, hidden_states=encoder_outputs.hidden_states, attentions=encoder_outputs.attentions, ) class TFHubertPreTrainedModel(TFPreTrainedModel): \\\"\\\"\\\" An abstract class to\",\n \"applicable law or agreed to in writing, software # distributed under the License\",\n \"and past_key_value is not None: # reuse k,v, cross_attentions key_states = past_key_value[0] value_states\",\n \"This second option is useful when using [`tf.keras.Model.fit`] method which currently requires having\",\n \"tuple, list, dict, np.ndarray) for k, v in kwargs.items(): if isinstance(v, allowed_types) or\",\n \"the TF 2.0 documentation for all matter related to general usage and behavior.\",\n \"is not None else src_len one_cst = tf.constant(1.0) mask = tf.cast(mask, dtype=one_cst.dtype) expanded_mask\",\n \"All rights reserved. # # Licensed under the Apache License, Version 2.0 (the\",\n \"return_dict=return_dict, training=training, ) inputs[\\\"output_hidden_states\\\"] = ( inputs[\\\"output_hidden_states\\\"] if inputs[\\\"output_hidden_states\\\"] else self.config.output_hidden_states ) inputs[\\\"output_attentions\\\"]\",\n \"dim < self.groups: raise ValueError( \\\"Number of groups (\\\" + str(self.groups) + \\\")\",\n \"can be obtained using [`BertTokenizer`]. See [`PreTrainedTokenizer.__call__`] and [`PreTrainedTokenizer.encode`] for details. [What are\",\n \"= self.head_dim**-0.5 self.is_decoder = is_decoder self.k_proj = tf.keras.layers.Dense(embed_dim, use_bias=bias, name=\\\"k_proj\\\") self.q_proj = tf.keras.layers.Dense(embed_dim,\",\n \") self.conv_layers = conv_layers def call(self, input_values): hidden_states = tf.expand_dims(input_values, -1) for conv_layer\",\n \"= tf.keras.layers.Dense(embed_dim, use_bias=bias, name=\\\"k_proj\\\") self.q_proj = tf.keras.layers.Dense(embed_dim, use_bias=bias, name=\\\"q_proj\\\") self.v_proj = tf.keras.layers.Dense(embed_dim, use_bias=bias,\",\n \"we check only the # `name` part tensor_name = input.name.split(\\\":\\\")[0] if tensor_name in\",\n \"# add LayerDrop (see https://arxiv.org/abs/1909.11556 for description) dropout_probability = np.random.uniform(0, 1) if training\",\n \"or not to return the attentions tensors of all attention layers. See `attentions`\",\n \"[bsz, 1, tgt_len, src_len], message=f\\\"Attention mask should be of size {(bsz, 1, tgt_len,\",\n \"self._check_if_input_shape_is_none(input_shape) self._set_number_of_groups_for_instance_norm(input_shape) self._check_size_of_dimensions(input_shape) self._create_input_spec(input_shape) self._add_gamma_weight(input_shape) self._add_beta_weight(input_shape) self.built = True super().build(input_shape) def call(self, inputs):\",\n \"< 1: raise ValueError(\\\"`mask_length` has to be bigger than 0.\\\") if mask_length >\",\n \"CPU. If you wish \\\" \\\"to train/fine-tine this model, you need a GPU\",\n \"[ TFHubertLayerNormConvLayer(config, layer_id=i, name=f\\\"conv_layers.{i}\\\") for i in range(config.num_feat_extract_layers) ] else: raise ValueError( f\\\"`config.feat_extract_norm`\",\n \"if self.config.output_hidden_states else None attns = tf.convert_to_tensor(output.attentions) if self.config.output_attentions else None return TFBaseModelOutput(last_hidden_state=output.last_hidden_state,\",\n \"class TFHubertFeatureProjection(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs): super().__init__(**kwargs) self.layer_norm = tf.keras.layers.LayerNormalization(epsilon=config.layer_norm_eps, name=\\\"layer_norm\\\") self.projection\",\n \"v is not None) return TFBaseModelOutput( last_hidden_state=hidden_states, hidden_states=all_hidden_states, attentions=all_self_attentions, ) @keras_serializable class TFHubertMainLayer(tf.keras.layers.Layer):\",\n \"TFHubertModel >>> from datasets import load_dataset >>> import soundfile as sf >>> processor\",\n \"= tf.keras.backend.int_shape(inputs) tensor_input_shape = tf.shape(inputs) reshaped_inputs, group_shape = self._reshape_into_groups(inputs, input_shape, tensor_input_shape) normalized_inputs =\",\n \"Inc. team. All rights reserved. # # Licensed under the Apache License, Version\",\n \"limitations under the License. \\\"\\\"\\\" TensorFlow Hubert model.\\\"\\\"\\\" import inspect import warnings from\",\n \"= None, gamma_constraint: tf.keras.constraints.Constraint = None, **kwargs, ): super().__init__(**kwargs) self.supports_masking = True self.groups\",\n \"TFHubertModel(TFHubertPreTrainedModel): def __init__(self, config: HubertConfig, *inputs, **kwargs): super().__init__(config, *inputs, **kwargs) self.config = config\",\n \"position_ids=position_ids, head_mask=head_mask, inputs_embeds=inputs_embeds, output_attentions=output_attentions, output_hidden_states=output_hidden_states, return_dict=return_dict, training=training, ) outputs = self.hubert( input_values=inputs[\\\"input_values\\\"], attention_mask=inputs[\\\"attention_mask\\\"],\",\n \"None, output_hidden_states: Optional[bool] = None, return_dict: Optional[bool] = None, training: bool = False,\",\n \"3) ) attn_output = tf.reshape(attn_output, (bsz, tgt_len, embed_dim)) attn_output = self.out_proj(attn_output) attn_weights: tf.Tensor\",\n \"= self.activation(hidden_states) return hidden_states # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2LayerNormConvLayer with Wav2Vec2->Hubert class TFHubertLayerNormConvLayer(tf.keras.layers.Layer): def\",\n \"**kwargs): super().__init__(config, *inputs, **kwargs) self.config = config self.hubert = TFHubertMainLayer(config, name=\\\"hubert\\\") @add_start_docstrings_to_model_forward(HUBERT_INPUTS_DOCSTRING) @replace_return_docstrings(output_type=TFBaseModelOutput,\",\n \"= tf.reshape(offsets, (batch_size, num_masked_spans * mask_length)) spec_aug_mask_idxs = spec_aug_mask_idxs + offsets # scatter\",\n \"is accepted for {parameter_names[i]}.\\\" ) elif isinstance(input_values, (dict, BatchEncoding)): if \\\"inputs\\\" in input_values:\",\n \"0) return hidden_states def call( self, input_values: tf.Tensor, attention_mask: Optional[tf.Tensor] = None, token_type_ids:\",\n \"self.config = config self.hubert = TFHubertMainLayer(config, name=\\\"hubert\\\") @add_start_docstrings_to_model_forward(HUBERT_INPUTS_DOCSTRING) @replace_return_docstrings(output_type=TFBaseModelOutput, config_class=_CONFIG_FOR_DOC) def call( self,\",\n \"None, head_mask: Optional[tf.Tensor] = None, inputs_embeds: Optional[tf.Tensor] = None, output_attentions: Optional[bool] = None,\",\n \"* self.num_heads, tgt_len, src_len)) attn_weights = tf.nn.softmax(attn_weights, axis=-1) if layer_head_mask is not None:\",\n \"tf.reshape(key_states, proj_shape) value_states = tf.reshape(value_states, proj_shape) src_len = shape_list(key_states)[1] attn_weights = tf.matmul(query_states, key_states,\",\n \"(bsz, self.num_heads, tgt_len, src_len) ) attn_weights = tf.reshape(attn_weights, (bsz * self.num_heads, tgt_len, src_len))\",\n \"{num_heads}).\\\" ) self.scaling = self.head_dim**-0.5 self.is_decoder = is_decoder self.k_proj = tf.keras.layers.Dense(embed_dim, use_bias=bias, name=\\\"k_proj\\\")\",\n \"given in the docstring: `model({\\\"input_values\\\": input_values, \\\"token_type_ids\\\": token_type_ids})` </Tip> Args: config ([`HubertConfig`]): Model\",\n \"= True, training: Optional[bool] = False, ) -> Union[TFBaseModelOutput, Tuple[tf.Tensor]]: all_hidden_states = ()\",\n \"if is_cross_attention and past_key_value is not None: # reuse k,v, cross_attentions key_states =\",\n \"= tf.zeros((batch_size, sequence_length), dtype=tf.int32) # uniform distribution to sample from, make sure that\",\n \"vocabulary. Indices can be obtained using [`BertTokenizer`]. See [`PreTrainedTokenizer.__call__`] and [`PreTrainedTokenizer.encode`] for details.\",\n \"version, use `input_values` instead.\\\", FutureWarning, ) output[\\\"input_values\\\"] = input_values.pop(\\\"inputs\\\") if \\\"decoder_cached_states\\\" in input_values:\",\n \"is always the first parameter, then `input_values` output[\\\"input_values\\\"] = output[\\\"args\\\"] del output[\\\"args\\\"] if\",\n \"version, use `past_key_values` instead.\\\", FutureWarning, ) output[\\\"past_key_values\\\"] = input_values.pop(\\\"decoder_cached_states\\\") for k, v in\",\n \"(the \\\"License\\\"); # you may not use this file except in compliance with\",\n \"self.config.mask_feature_prob > 0: mask_feature_indices = _compute_mask_indices( (batch_size, hidden_size), mask_prob=self.config.mask_feature_prob, mask_length=self.config.mask_feature_length, ) hidden_states =\",\n \"class TFHubertForCTC(TFHubertPreTrainedModel): def __init__(self, config: HubertConfig, *inputs, **kwargs): super().__init__(config, *inputs, **kwargs) self.hubert =\",\n \"kernel = tf.nn.l2_normalize(self.weight_v, axis=self.kernel_norm_axes) * tf.transpose(self.weight_g) self.kernel = tf.transpose(kernel) def build(self, input_shape): if\",\n \"to pair indices return tf.scatter_nd(pair_indices, tf.reshape(values, [-1]), output_shape) # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2._compute_mask_indices def\",\n \"= TFHubertGroupNorm(groups=self.out_conv_dim, epsilon=config.layer_norm_eps, name=\\\"layer_norm\\\") def call(self, hidden_states: tf.Tensor) -> tf.Tensor: hidden_states = self.conv(hidden_states)\",\n \"value in the config will be used instead. output_hidden_states (`bool`, *optional*): Whether or\",\n \"(dim,) if self.scale: self.gamma = self.add_weight( shape=shape, name=\\\"gamma\\\", initializer=self.gamma_initializer, regularizer=self.gamma_regularizer, constraint=self.gamma_constraint, ) else:\",\n \"and (dropout_probability < self.config.layerdrop): # skip the layer continue layer_outputs = layer_module( hidden_states=hidden_states,\",\n \"tf.tile(offsets, (batch_size, num_masked_spans, 1)) offsets = tf.reshape(offsets, (batch_size, num_masked_spans * mask_length)) spec_aug_mask_idxs =\",\n \"last_hidden_state=hidden_states, hidden_states=encoder_outputs.hidden_states, attentions=encoder_outputs.attentions, ) class TFHubertPreTrainedModel(TFPreTrainedModel): \\\"\\\"\\\" An abstract class to handle weights\",\n \"is {config.feat_extract_norm}, but has to be one of ['group', 'layer']\\\" ) self.conv_layers =\",\n \"hidden_states = attn_residual + hidden_states hidden_states = hidden_states + self.feed_forward(self.final_layer_norm(hidden_states)) outputs = (hidden_states,)\",\n \"+ output) if loss is not None else output return TFCausalLMOutput( loss=loss, logits=logits,\",\n \"TFHubertEncoder(config, name=\\\"encoder\\\") def build(self, input_shape: tf.TensorShape): self.masked_spec_embed = self.add_weight( shape=(self.config.hidden_size,), initializer=\\\"uniform\\\", trainable=True, name=\\\"masked_spec_embed\\\"\",\n \"used as a cross-attention layer # for the decoder is_cross_attention = key_value_states is\",\n \"attention_mask=inputs[\\\"attention_mask\\\"], token_type_ids=inputs[\\\"token_type_ids\\\"], position_ids=inputs[\\\"position_ids\\\"], head_mask=inputs[\\\"head_mask\\\"], inputs_embeds=inputs[\\\"inputs_embeds\\\"], output_attentions=inputs[\\\"output_attentions\\\"], output_hidden_states=inputs[\\\"output_hidden_states\\\"], return_dict=inputs[\\\"return_dict\\\"], training=inputs[\\\"training\\\"], ) hidden_states = outputs[0]\",\n \"None if self.scale: gamma = tf.reshape(self.gamma, broadcast_shape) if self.center: beta = tf.reshape(self.beta, broadcast_shape)\",\n \"- see https://github.com/tensorflow/tensorflow/issues/9260 for more info \\\"\\\"\\\" z = -tf.math.log(tf.random.uniform(shape_list(distribution), 0, 1)) _,\",\n \"conv_layers = [ TFHubertLayerNormConvLayer(config, layer_id=i, name=f\\\"conv_layers.{i}\\\") for i in range(config.num_feat_extract_layers) ] else: raise\",\n \"not None: hidden_states = hidden_states * tf.expand_dims(attention_mask, -1) attention_mask = _expand_mask(attention_mask) else: attention_mask\",\n \"kernel_size, stride): # 1D convolutional layer output length formula taken # from https://pytorch.org/docs/stable/generated/torch.nn.Conv1d.html\",\n \"for i in range(config.num_feat_extract_layers) ] else: raise ValueError( f\\\"`config.feat_extract_norm` is {config.feat_extract_norm}, but has\",\n \"= dim def _check_size_of_dimensions(self, input_shape): dim = input_shape[self.axis] if dim < self.groups: raise\",\n \"Mask values selected in `[0, 1]`: - 1 indicates the head is **not\",\n \"and name != \\\"args\\\": output[name] = kwargs.pop(name, signature[name].default) # When creating a SavedModel\",\n \"cross attention key/value_states. # Further calls to cross_attention layer can then reuse all\",\n \"== 1 if not is_instance_norm: axis = -2 if self.axis == -1 else\",\n \"tgt_len, src_len) ) attn_weights = tf.reshape(attn_weights, (bsz * self.num_heads, tgt_len, src_len)) attn_probs =\",\n \"hidden_states = self.activation(hidden_states) return hidden_states # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2GroupNormConvLayer with Wav2Vec2->Hubert class TFHubertGroupNormConvLayer(tf.keras.layers.Layer):\",\n \"instead of a plain tuple. This argument can be used in eager mode,\",\n \"input_shape): group_shape = tf.keras.backend.int_shape(reshaped_inputs) group_reduction_axes = list(range(1, len(group_shape))) is_instance_norm = (input_shape[self.axis] // self.groups)\",\n \"logits_time_major=False, ) if self.config.ctc_loss_reduction == \\\"sum\\\": loss = tf.reduce_sum(loss) if self.config.ctc_loss_reduction == \\\"mean\\\":\",\n \"center: bool = True, scale: bool = True, beta_initializer: tf.keras.initializers.Initializer = \\\"zeros\\\", gamma_initializer:\",\n \"of the weight vector.\\\"\\\"\\\" kernel_norm = tf.sqrt(tf.reduce_sum(tf.square(self.weight_v), axis=self.kernel_norm_axes)) self.weight_g.assign(kernel_norm[:, tf.newaxis, tf.newaxis]) def _normalize_kernel(self):\",\n \"raise ValueError(\\\"`mask_length` has to be bigger than 0.\\\") if mask_length > sequence_length: raise\",\n \"int): return tf.transpose(tf.reshape(tensor, (bsz, seq_len, self.num_heads, self.head_dim)), (0, 2, 1, 3)) def call(\",\n \"# all previous decoder key/value_states. Further calls to uni-directional self-attention # can concat\",\n \"if output_attentions: outputs += (attn_weights,) return outputs # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2Encoder with Wav2Vec2->Hubert\",\n \"self.dropout(hidden_states, training=inputs[\\\"training\\\"]) logits = self.lm_head(hidden_states) if labels is not None: if tf.reduce_max(labels) >=\",\n \"sequence_length), mask_prob=self.config.mask_time_prob, mask_length=self.config.mask_time_length, min_masks=2, ) hidden_states = tf.where( tf.cast(mask_time_indices[:, :, tf.newaxis], tf.bool), self.masked_spec_embed[tf.newaxis,\",\n \"& apply SpecAugment along time axis mask_time_indices = _compute_mask_indices( (batch_size, sequence_length), mask_prob=self.config.mask_time_prob, mask_length=self.config.mask_time_length,\",\n \"is not None: # The tf.debugging asserts are not compliant with XLA then\",\n \"outputs[1:] return ((loss,) + output) if loss is not None else output return\",\n \"has to be smaller than `sequence_length`, but got `mask_length`: {mask_length} and `sequence_length`: {sequence_length}`\\\"\",\n \"0), (self.explicit_padding, self.explicit_padding), (0, 0))) output = super().call(padded_inputs) return output # Copied from\",\n \"build(self, input_shape: tf.TensorShape): self.masked_spec_embed = self.add_weight( shape=(self.config.hidden_size,), initializer=\\\"uniform\\\", trainable=True, name=\\\"masked_spec_embed\\\" ) super().build(input_shape) def\",\n \"attention layers. See `attentions` under returned tensors for more detail. This argument can\",\n \"(bsz, self.num_heads, tgt_len, src_len)) + attention_mask attn_weights = tf.reshape(attn_weights, (bsz * self.num_heads, tgt_len,\",\n \"part tensor_name = input.name.split(\\\":\\\")[0] if tensor_name in parameter_names: output[tensor_name] = input else: output[parameter_names[i]]\",\n \"is not None: # compute real output lengths according to convolution formula output_lengths\",\n \"1, tgt_len, 1)) return (one_cst - expanded_mask) * LARGE_NEGATIVE # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2GroupNorm\",\n \"training=training) hidden_states = attn_residual + hidden_states hidden_states = hidden_states + self.feed_forward(self.final_layer_norm(hidden_states)) outputs =\",\n \"given shape Args: shape: the the shape for which to compute masks. should\",\n \"= False, ) -> Tuple[tf.Tensor]: attn_residual = hidden_states hidden_states = self.layer_norm(hidden_states) hidden_states, attn_weights,\",\n \"variance_epsilon=self.epsilon, ) return normalized_inputs def _get_reshaped_weights(self, input_shape): broadcast_shape = self._create_broadcast_shape(input_shape) gamma = None\",\n \"trainable=True) self.weight_v = self.kernel self.weight_g = self.add_weight( name=\\\"weight_g\\\", shape=(int(self.weight_v.shape[self.filter_axis]), 1, 1), initializer=\\\"ones\\\", dtype=self.weight_v.dtype,\",\n \"tf.Tensor) or input_values is None: output[parameter_names[0]] = input_values else: raise ValueError( f\\\"Data of\",\n \"for the specific language governing permissions and # limitations under the License. \\\"\\\"\\\"\",\n \"each input sequence tokens in the position embeddings. Selected in the range `[0,\",\n \"..., config.vocab_size]` Returns: Example: ```python >>> import tensorflow as tf >>> from transformers\",\n \"self.groups != 0: raise ValueError( \\\"Number of groups (\\\" + str(self.groups) + \\\")\",\n \".name property so we check for a real Tensor if type(input) == tf.Tensor:\",\n \"three possibilities you can use to gather all the input Tensors in the\",\n \"[SpecAugment](https://arxiv.org/abs/1904.08779). \\\"\\\"\\\" batch_size, sequence_length, hidden_size = shape_list(hidden_states) # `config.apply_spec_augment` can set masking to\",\n \">>> def map_to_array(batch): ... speech, _ = sf.read(batch[\\\"file\\\"]) ... batch[\\\"speech\\\"] = speech ...\",\n \"sequence_length / mask_length + tf.random.uniform((1,))) num_masked_spans = max(num_masked_spans, min_masks) # make sure num\",\n \"input_lengths = _conv_out_length(input_lengths, kernel_size, stride) return input_lengths def _mask_hidden_states(self, hidden_states: tf.Tensor, mask_time_indices: Optional[tf.Tensor]\",\n \"= None, gamma_regularizer: tf.keras.regularizers.Regularizer = None, beta_constraint: tf.keras.constraints.Constraint = None, gamma_constraint: tf.keras.constraints.Constraint =\",\n \"use_bias=bias, name=\\\"v_proj\\\") self.out_proj = tf.keras.layers.Dense(embed_dim, use_bias=bias, name=\\\"out_proj\\\") def _shape(self, tensor: tf.Tensor, seq_len: int,\",\n \"the same size as shape, which will prevent masking padded elements mask_prob: probability\",\n \"computation for the feature encoder so that its parameters will not be updated\",\n \"tf.TensorShape): self.masked_spec_embed = self.add_weight( shape=(self.config.hidden_size,), initializer=\\\"uniform\\\", trainable=True, name=\\\"masked_spec_embed\\\" ) super().build(input_shape) def _get_feat_extract_output_lengths(self, input_lengths:\",\n \"= tf.range(mask_length)[tf.newaxis, tf.newaxis, :] offsets = tf.tile(offsets, (batch_size, num_masked_spans, 1)) offsets = tf.reshape(offsets,\",\n \"self.final_layer_norm(hidden_states) outputs = (hidden_states,) if output_attentions: outputs += (attn_weights,) return outputs # Copied\",\n \"indices to indicate first and second portions of the inputs. Indices are selected\",\n \"() if output_attentions else None if attention_mask is not None: hidden_states = hidden_states\",\n \"masked language modeling loss. Indices should be in `[-100, 0, ..., config.vocab_size]` (see\",\n \"transformers.models.bart.modeling_tf_bart._expand_mask def _expand_mask(mask: tf.Tensor, tgt_len: Optional[int] = None, past_key_values_length: int = 0): \\\"\\\"\\\"\",\n \"raise ValueError(f\\\"Label values must be <= vocab_size: {self.config.vocab_size}\\\") attention_mask = ( inputs[\\\"attention_mask\\\"] if\",\n \"(`bool`, *optional*, defaults to `False``): Whether or not to use the model in\",\n \"return_tensors=\\\"tf\\\").input_values # Batch size 1 >>> logits = model(input_values).logits >>> predicted_ids = tf.argmax(logits,\",\n \"the shape for which to compute masks. should be of size 2 where\",\n \"along feature axis according to [SpecAugment](https://arxiv.org/abs/1904.08779). \\\"\\\"\\\" batch_size, sequence_length, hidden_size = shape_list(hidden_states) #\",\n \"= input.name.split(\\\":\\\")[0] if tensor_name in parameter_names: output[tensor_name] = input else: output[parameter_names[i]] = input\",\n \"self.head_dim) query_states = tf.reshape(self._shape(query_states, tgt_len, bsz), proj_shape) key_states = tf.reshape(key_states, proj_shape) value_states =\",\n \"future version, use `past_key_values` instead.\\\", FutureWarning, ) output[\\\"past_key_values\\\"] = input_values.pop(\\\"decoder_cached_states\\\") for k, v\",\n \"\\\"center\\\": self.center, \\\"scale\\\": self.scale, \\\"beta_initializer\\\": tf.keras.initializers.serialize(self.beta_initializer), \\\"gamma_initializer\\\": tf.keras.initializers.serialize(self.gamma_initializer), \\\"beta_regularizer\\\": tf.keras.regularizers.serialize(self.beta_regularizer), \\\"gamma_regularizer\\\": tf.keras.regularizers.serialize(self.gamma_regularizer), \\\"beta_constraint\\\":\",\n \"= None, output_attentions: Optional[tf.Tensor] = None, output_hidden_states: Optional[tf.Tensor] = None, return_dict: Optional[bool] =\",\n \"HubertConfig, **kwargs): super().__init__(**kwargs) self.config = config self.feature_extractor = TFHubertFeatureEncoder(config, name=\\\"feature_extractor\\\") self.feature_projection = TFHubertFeatureProjection(config,\",\n \"Add last layer if output_hidden_states: all_hidden_states = all_hidden_states + (hidden_states,) if not return_dict:\",\n \"hidden_states, attention_mask=attention_mask, training=training ) hidden_states = self.dropout(hidden_states, training=training) hidden_states = attn_residual + hidden_states\",\n \"for i in range(len(input_shape))] is_instance_norm = (input_shape[self.axis] // self.groups) == 1 if not\",\n \"from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2EncoderLayer with Wav2Vec2->Hubert class TFHubertEncoderLayer(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs): super().__init__(**kwargs) self.attention\",\n \"\\\"input_values\\\" @property def dummy_inputs(self) -> Dict[str, tf.Tensor]: pad_token = 0.0 input_values = tf.convert_to_tensor(np.random.rand(1,\",\n \"input_values: warnings.warn( \\\"The `decoder_cached_states` argument is deprecated and will be removed in a\",\n \"{allowed_types} is accepted for {parameter_names[i]}.\\\" ) elif isinstance(input_values, (dict, BatchEncoding)): if \\\"inputs\\\" in\",\n \"dtype=one_cst.dtype) expanded_mask = tf.tile(mask[:, None, None, :], (1, 1, tgt_len, 1)) return (one_cst\",\n \"plain tuple. This argument can be used in eager mode, in graph mode\",\n \"mask_length: size of the mask min_masks: minimum number of masked spans Adapted from\",\n \"return hidden_states if mask_time_indices is not None: # apply SpecAugment along time axis\",\n \"return_dict=return_dict, training=training, kwargs_call=kwargs, ) hidden_states = self.feature_extractor( tf.cast(inputs[\\\"input_values\\\"], tf.float32), training=inputs[\\\"training\\\"] ) if inputs[\\\"attention_mask\\\"]\",\n \"self._get_feat_extract_output_lengths(tf.reduce_sum(inputs[\\\"attention_mask\\\"], -1)) attention_mask = tf.sequence_mask( output_lengths, maxlen=shape_list(hidden_states)[1], dtype=hidden_states.dtype ) hidden_states = self.feature_projection(hidden_states, training=inputs[\\\"training\\\"])\",\n \"\\\"\\\"\\\" Masks extracted features along time axis and/or along feature axis according to\",\n \"\\\"\\\"\\\" indices_shape = shape_list(batch_indices) # broadcast batch dim to indices_shape broad_casted_batch_dims = tf.reshape(\",\n \"initializer=self.beta_initializer, regularizer=self.beta_regularizer, constraint=self.beta_constraint, ) else: self.beta = None def _create_broadcast_shape(self, input_shape): broadcast_shape =\",\n \"do for now - see https://github.com/tensorflow/tensorflow/issues/9260 for more info \\\"\\\"\\\" z = -tf.math.log(tf.random.uniform(shape_list(distribution),\",\n \"_CONFIG_FOR_DOC = \\\"HubertConfig\\\" TF_HUBERT_PRETRAINED_MODEL_ARCHIVE_LIST = [ \\\"facebook/hubert-base-ls960\\\", # See all Hubert models at\",\n \"check only the # `name` part tensor_name = input.name.split(\\\":\\\")[0] if tensor_name in parameter_names:\",\n \"num_conv_pos_embeddings, **kwargs): super().__init__(**kwargs) self.num_pad_remove = 1 if num_conv_pos_embeddings % 2 == 0 else\",\n \"tf.Tensor, attention_mask: Optional[tf.Tensor] = None, token_type_ids: Optional[tf.Tensor] = None, position_ids: Optional[tf.Tensor] = None,\",\n \"self.conv(hidden_states) hidden_states = self.layer_norm(hidden_states) hidden_states = self.activation(hidden_states) return hidden_states # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2PositionalConvEmbedding\",\n \"layer_outputs[0] if output_attentions: all_self_attentions = all_self_attentions + (layer_outputs[1],) # Add last layer if\",\n \"of a plain tuple. This argument can be used in eager mode, in\",\n \"for k, v in dict(input_values).items(): if isinstance(v, allowed_types) or v is None: output[k]\",\n \"float = 1e-3, center: bool = True, scale: bool = True, beta_initializer: tf.keras.initializers.Initializer\",\n \"attention_mask is not None: hidden_states = hidden_states * tf.expand_dims(attention_mask, -1) attention_mask = _expand_mask(attention_mask)\",\n \"than eager. if tf.executing_eagerly(): tf.debugging.assert_equal( shape_list(layer_head_mask), [self.num_heads], message=f\\\"Head mask for a single layer\",\n \"Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2._sample_without_replacement def _sample_without_replacement(distribution, num_samples): \\\"\\\"\\\" Categorical sampling without replacement is currently\",\n \"= tf.keras.layers.Dropout(config.hidden_dropout) def call(self, hidden_states: tf.Tensor, training: bool = False) -> tf.Tensor: hidden_states\",\n \"query_states = tf.reshape(self._shape(query_states, tgt_len, bsz), proj_shape) key_states = tf.reshape(key_states, proj_shape) value_states = tf.reshape(value_states,\",\n \"from https://www.tensorflow.org/probability/api_docs/python/tfp/layers/weight_norm/WeightNorm\\\"\\\"\\\" def __init__(self, filters, kernel_size, groups, explicit_padding, **kwargs): super().__init__( filters=filters, kernel_size=kernel_size, groups=groups,\",\n \"\\\"input tensor should have a defined dimension \\\" \\\"but the layer received an\",\n \"- 1 else: axis = -1 if self.axis == -1 else self.axis -\",\n \"input else: output[parameter_names[i]] = input elif isinstance(input, allowed_types) or input is None: output[parameter_names[i]]\",\n \"__init__(self, config, **kwargs): super().__init__(config, **kwargs) warnings.warn( f\\\"The class `{self.__class__.__name__}` has been depreciated \\\"\",\n \"Tuple(tf.Tensor, tf.Tensor) of # all previous decoder key/value_states. Further calls to uni-directional self-attention\",\n \"in input_values: warnings.warn( \\\"The `inputs` argument is deprecated and will be removed in\",\n \"from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2GroupNorm with Wav2Vec2->Hubert class TFHubertGroupNorm(tf.keras.layers.Layer): \\\"\\\"\\\" From tensorflow-addons https://www.tensorflow.org/addons/api_docs/python/tfa/layers/GroupNormalization \\\"\\\"\\\" def __init__(\",\n \"config.do_stable_layer_norm: self.encoder = TFHubertEncoderStableLayerNorm(config, name=\\\"encoder\\\") else: self.encoder = TFHubertEncoder(config, name=\\\"encoder\\\") def build(self, input_shape:\",\n \">>> processor = Wav2Vec2Processor.from_pretrained(\\\"facebook/hubert-base-960h\\\") >>> model = TFHubertModel.from_pretrained(\\\"facebook/hubert-base-960h\\\") >>> def map_to_array(batch): ... speech,\",\n \"if tf.reduce_max(labels) >= self.config.vocab_size: raise ValueError(f\\\"Label values must be <= vocab_size: {self.config.vocab_size}\\\") attention_mask\",\n \"**kwargs) # So to respect the proper output we have to add this\",\n \"maxlen=shape_list(hidden_states)[1], dtype=hidden_states.dtype ) hidden_states = self.feature_projection(hidden_states, training=inputs[\\\"training\\\"]) mask_time_indices = kwargs.get(\\\"mask_time_indices\\\", None) if inputs[\\\"training\\\"]:\",\n \"this exception if \\\"args\\\" in output: if output[\\\"args\\\"] is not None and type(output[\\\"args\\\"])\",\n \"config: HubertConfig, *inputs, **kwargs): super().__init__(config, *inputs, **kwargs) self.config = config self.hubert = TFHubertMainLayer(config,\",\n \"# key/value_states (first \\\"if\\\" case) # if uni-directional self-attention (decoder) save Tuple(tf.Tensor, tf.Tensor)\",\n \"i in range(config.num_hidden_layers) ] def call( self, hidden_states: tf.Tensor, attention_mask: Optional[tf.Tensor] = None,\",\n \"self.scale: gamma = tf.reshape(self.gamma, broadcast_shape) if self.center: beta = tf.reshape(self.beta, broadcast_shape) return gamma,\",\n \"sequence_length: num_masked_spans = sequence_length // mask_length # SpecAugment mask to fill spec_aug_mask =\",\n \"name=\\\"encoder\\\") def build(self, input_shape: tf.TensorShape): self.masked_spec_embed = self.add_weight( shape=(self.config.hidden_size,), initializer=\\\"uniform\\\", trainable=True, name=\\\"masked_spec_embed\\\" )\",\n \"be smaller (unless no_overlap is True) mask_length: size of the mask min_masks: minimum\",\n \"= self._shape(self.k_proj(key_value_states), -1, bsz) value_states = self._shape(self.v_proj(key_value_states), -1, bsz) elif past_key_value is not\",\n \"labels = processor(transcription, return_tensors=\\\"tf\\\").input_values >>> loss = model(input_values, labels=labels).loss ```\\\"\\\"\\\" inputs = input_values_processing(\",\n \"as np import tensorflow as tf from ...activations_tf import get_tf_activation from ...modeling_tf_outputs import\",\n \"[1, -1])], 0)) # scatter values to pair indices return tf.scatter_nd(pair_indices, tf.reshape(values, [-1]),\",\n \"self.dropout(hidden_states, training=training) return hidden_states # Copied from transformers.models.bart.modeling_tf_bart.TFBartAttention with TFBart->TFHubert class TFHubertAttention(tf.keras.layers.Layer): \\\"\\\"\\\"Multi-headed\",\n \"config.conv_dim[layer_id] if layer_id > 0 else 1 self.out_conv_dim = config.conv_dim[layer_id] self.conv = tf.keras.layers.Conv1D(\",\n \"instead.\\\", FutureWarning, ) output[\\\"input_values\\\"] = input_values.pop(\\\"inputs\\\") if \\\"decoder_cached_states\\\" in input_values: warnings.warn( \\\"The `decoder_cached_states`\",\n \"def call(self, inputs): input_shape = tf.keras.backend.int_shape(inputs) tensor_input_shape = tf.shape(inputs) reshaped_inputs, group_shape = self._reshape_into_groups(inputs,\",\n \"graph mode the value in the config will be used instead. return_dict (`bool`,\",\n \") self.dropout = tf.keras.layers.Dropout(rate=config.feat_proj_dropout) def call(self, hidden_states: tf.Tensor, training: bool = False) ->\",\n \"*optional*): Whether or not to return a [`~file_utils.ModelOutput`] instead of a plain tuple.\",\n \"output_attentions else None if attention_mask is not None: hidden_states = hidden_states * tf.expand_dims(attention_mask,\",\n \"and second portions of the inputs. Indices are selected in `[0, 1]`: -\",\n \"TFBaseModelOutput( last_hidden_state=hidden_states, hidden_states=encoder_outputs.hidden_states, attentions=encoder_outputs.attentions, ) class TFHubertPreTrainedModel(TFPreTrainedModel): \\\"\\\"\\\" An abstract class to handle\",\n \"shape \\\" + str(input_shape) + \\\".\\\" ) def _set_number_of_groups_for_instance_norm(self, input_shape): dim = input_shape[self.axis]\",\n \"from transformers.models.bart.modeling_tf_bart.TFBartAttention with TFBart->TFHubert class TFHubertAttention(tf.keras.layers.Layer): \\\"\\\"\\\"Multi-headed attention from \\\"Attention Is All You\",\n \"= -tf.math.log(tf.random.uniform(shape_list(distribution), 0, 1)) _, indices = tf.nn.top_k(distribution + z, num_samples) return indices\",\n \"def call(self, hidden_states: tf.Tensor) -> tf.Tensor: hidden_states = self.conv(hidden_states) hidden_states = self.padding(hidden_states) hidden_states\",\n \"Categorical sampling without replacement is currently not implemented. The gumbel-max trick will do\",\n \") if dim % self.groups != 0: raise ValueError( \\\"Number of groups (\\\"\",\n \"self.layer_norm = tf.keras.layers.LayerNormalization(epsilon=config.layer_norm_eps, name=\\\"layer_norm\\\") self.dropout = tf.keras.layers.Dropout(config.hidden_dropout) self.layer = [ TFHubertEncoderLayerStableLayerNorm(config, name=f\\\"layers.{i}\\\") for\",\n \"kernel_size=config.conv_kernel[layer_id], strides=config.conv_stride[layer_id], use_bias=config.conv_bias, name=\\\"conv\\\", ) self.activation = get_tf_activation(config.feat_extract_activation) self.layer_norm = TFHubertGroupNorm(groups=self.out_conv_dim, epsilon=config.layer_norm_eps, name=\\\"layer_norm\\\")\",\n \") return spec_aug_mask # Copied from transformers.models.bart.modeling_tf_bart._expand_mask def _expand_mask(mask: tf.Tensor, tgt_len: Optional[int] =\",\n \"num_masked_spans * mask_length)) spec_aug_mask_idxs = spec_aug_mask_idxs + offsets # scatter indices to mask\",\n \"(1, 1, mask_length)) spec_aug_mask_idxs = tf.reshape(spec_aug_mask_idxs, (batch_size, num_masked_spans * mask_length)) offsets = tf.range(mask_length)[tf.newaxis,\",\n \"norm of the weight vector.\\\"\\\"\\\" kernel_norm = tf.sqrt(tf.reduce_sum(tf.square(self.weight_v), axis=self.kernel_norm_axes)) self.weight_g.assign(kernel_norm[:, tf.newaxis, tf.newaxis]) def\",\n \"return spec_aug_mask # Copied from transformers.models.bart.modeling_tf_bart._expand_mask def _expand_mask(mask: tf.Tensor, tgt_len: Optional[int] = None,\",\n \"in Transformers v5.\\\" \\\"Please use the equivalent `freeze_feature_encoder` method instead.\\\", FutureWarning, ) self.freeze_feature_encoder()\",\n \"_, indices = tf.nn.top_k(distribution + z, num_samples) return indices # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2._scatter_values_on_batch_indices\",\n \"conv_layer in self.conv_layers: hidden_states = conv_layer(hidden_states) return hidden_states class TFHubertFeatureExtractor(TFHubertFeatureEncoder): def __init__(self, config,\",\n \"outputs def serving_output(self, output): hs = tf.convert_to_tensor(output.hidden_states) if self.config.output_hidden_states else None attns =\",\n \"kwargs.pop(name, signature[name].default) # When creating a SavedModel TF calls the method with LayerCall.__call__(args,\",\n \"else None if attention_mask is not None: hidden_states = hidden_states * tf.expand_dims(attention_mask, -1)\",\n \"useful if you want more control over how to convert `input_values` indices into\",\n \"= all_hidden_states + (hidden_states,) if not return_dict: return tuple(v for v in [hidden_states,\",\n \"= tf.tile(mask[:, None, None, :], (1, 1, tgt_len, 1)) return (one_cst - expanded_mask)\",\n \"varying length with one or several input Tensors IN THE ORDER given in\",\n \"inputs[\\\"return_dict\\\"] else self.config.return_dict outputs = self.hubert( input_values=inputs[\\\"input_values\\\"], attention_mask=inputs[\\\"attention_mask\\\"], token_type_ids=inputs[\\\"token_type_ids\\\"], position_ids=inputs[\\\"position_ids\\\"], head_mask=inputs[\\\"head_mask\\\"], inputs_embeds=inputs[\\\"inputs_embeds\\\"], output_attentions=inputs[\\\"output_attentions\\\"],\",\n \"None) if inputs[\\\"training\\\"]: hidden_states = self._mask_hidden_states(hidden_states, mask_time_indices=mask_time_indices) encoder_outputs = self.encoder( hidden_states, attention_mask=attention_mask, output_attentions=inputs[\\\"output_attentions\\\"],\",\n \"tf.keras.backend.int_shape(inputs) tensor_input_shape = tf.shape(inputs) reshaped_inputs, group_shape = self._reshape_into_groups(inputs, input_shape, tensor_input_shape) normalized_inputs = self._apply_normalization(reshaped_inputs,\",\n \"permissions and # limitations under the License. \\\"\\\"\\\" TensorFlow Hubert model.\\\"\\\"\\\" import inspect\",\n \": -self.num_pad_remove, :] return hidden_states class TFHubertFeatureEncoder(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs: Any)\",\n \"tf.Tensor): \\\"\\\"\\\" Computes the output length of the convolutional layers \\\"\\\"\\\" def _conv_out_length(input_length,\",\n \"tf.reshape(attn_output, (bsz, tgt_len, embed_dim)) attn_output = self.out_proj(attn_output) attn_weights: tf.Tensor = tf.reshape(attn_weights, (bsz, self.num_heads,\",\n \"`False``): Whether or not to use the model in training mode (some modules\",\n \"type {type(input)} is not allowed only {allowed_types} is accepted for {parameter_names[i]}.\\\" ) elif\",\n \">>> ds = load_dataset(\\\"hf-internal-testing/librispeech_asr_dummy\\\", \\\"clean\\\", split=\\\"validation\\\") >>> ds = ds.map(map_to_array) >>> input_values =\",\n \"1, tgt_len, src_len], message=f\\\"Attention mask should be of size {(bsz, 1, tgt_len, src_len)},\",\n \"Dict, Optional, Tuple, Union import numpy as np import tensorflow as tf from\",\n \"group_shape = tf.stack(group_shape) reshaped_inputs = tf.reshape(inputs, group_shape) return reshaped_inputs, group_shape else: return inputs,\",\n \"output[\\\"args\\\"] if \\\"kwargs\\\" in output: del output[\\\"kwargs\\\"] boolean_dict = { k: v for\",\n \"from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2LayerNormConvLayer with Wav2Vec2->Hubert class TFHubertLayerNormConvLayer(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, layer_id: int =\",\n \"# Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2FeedForward with Wav2Vec2->Hubert class TFHubertFeedForward(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs):\",\n \"= normalized_inputs return outputs def get_config(self): config = { \\\"groups\\\": self.groups, \\\"axis\\\": self.axis,\",\n \"or `tf.Tensor` of shape `({0})`, *optional*): Mask to avoid performing attention on padding\",\n \"offsets # scatter indices to mask spec_aug_mask = _scatter_values_on_batch_indices( tf.ones_like(spec_aug_mask_idxs), spec_aug_mask_idxs, spec_aug_mask.shape )\",\n \"soundfile as sf >>> processor = Wav2Vec2Processor.from_pretrained(\\\"facebook/hubert-base-960h\\\") >>> model = TFHubertForCTC.from_pretrained(\\\"facebook/hubert-base-960h\\\") >>> def\",\n \"hidden_states = self._mask_hidden_states(hidden_states, mask_time_indices=mask_time_indices) encoder_outputs = self.encoder( hidden_states, attention_mask=attention_mask, output_attentions=inputs[\\\"output_attentions\\\"], output_hidden_states=inputs[\\\"output_hidden_states\\\"], return_dict=inputs[\\\"return_dict\\\"], training=inputs[\\\"training\\\"],\",\n \"None def _create_broadcast_shape(self, input_shape): broadcast_shape = [1] * len(input_shape) is_instance_norm = (input_shape[self.axis] //\",\n \") def _set_number_of_groups_for_instance_norm(self, input_shape): dim = input_shape[self.axis] if self.groups == -1: self.groups =\",\n \"with shape \\\" + str(input_shape) + \\\".\\\" ) def _set_number_of_groups_for_instance_norm(self, input_shape): dim =\",\n \"should be of size {(bsz * self.num_heads, tgt_len, src_len)}, but is {shape_list(attn_weights)}\\\", )\",\n \"= tf.reshape(attn_output, (bsz, tgt_len, embed_dim)) attn_output = self.out_proj(attn_output) attn_weights: tf.Tensor = tf.reshape(attn_weights, (bsz,\",\n \"broadcast_shape) return gamma, beta def _check_if_input_shape_is_none(self, input_shape): dim = input_shape[self.axis] if dim is\",\n \"self.encoder = TFHubertEncoderStableLayerNorm(config, name=\\\"encoder\\\") else: self.encoder = TFHubertEncoder(config, name=\\\"encoder\\\") def build(self, input_shape: tf.TensorShape):\",\n \"= () if output_hidden_states else None all_self_attentions = () if output_attentions else None\",\n \"def _set_number_of_groups_for_instance_norm(self, input_shape): dim = input_shape[self.axis] if self.groups == -1: self.groups = dim\",\n \"num_masked_spans = max(num_masked_spans, min_masks) # make sure num masked indices <= sequence_length if\",\n \"= None, inputs_embeds: Optional[tf.Tensor] = None, output_attentions: Optional[tf.Tensor] = None, output_hidden_states: Optional[tf.Tensor] =\",\n \"calls the method with LayerCall.__call__(args, **kwargs) # So to respect the proper output\",\n \"key/value_states. # Further calls to cross_attention layer can then reuse all cross-attention #\",\n \"= self.hubert._get_feat_extract_output_lengths(tf.reduce_sum(attention_mask, axis=-1)) # assuming that padded tokens are filled with -100 #\",\n \"shape `({0}, hidden_size)`, *optional*): Optionally, instead of passing `input_values` you can choose to\",\n \"input_values, **kwargs): \\\"\\\"\\\" Process the input of each TensorFlow model including the booleans.\",\n \"self.num_heads, tgt_len, src_len], message=f\\\"Attention weights should be of size {(bsz * self.num_heads, tgt_len,\",\n \"inputs[\\\"attention_mask\\\"] is not None else tf.ones_like(inputs[\\\"input_values\\\"], dtype=tf.float32) ) input_lengths = self.hubert._get_feat_extract_output_lengths(tf.reduce_sum(attention_mask, axis=-1)) #\",\n \"`decoder_cached_states` argument is deprecated and will be removed in a future version, use\",\n \"gather all the input Tensors in the first positional argument : - a\",\n \"config file does not load the weights associated with the model, only the\",\n \"name=\\\"pos_conv_embed\\\") self.layer_norm = tf.keras.layers.LayerNormalization(epsilon=config.layer_norm_eps, name=\\\"layer_norm\\\") self.dropout = tf.keras.layers.Dropout(config.hidden_dropout) self.layer = [TFHubertEncoderLayer(config, name=f\\\"layers.{i}\\\") for\",\n \"if self.axis == -1 else self.axis - 1 else: axis = -1 if\",\n \"mask_prob=self.config.mask_time_prob, mask_length=self.config.mask_time_length, min_masks=2, ) hidden_states = tf.where( tf.cast(mask_time_indices[:, :, tf.newaxis], tf.bool), self.masked_spec_embed[tf.newaxis, tf.newaxis,\",\n \"# Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2EncoderLayer with Wav2Vec2->Hubert class TFHubertEncoderLayer(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs):\",\n \"for padding input_shape[-2] += self.explicit_padding * 2 super().build(input_shape) self.kernel = tf.Variable(tf.transpose(self.kernel), name=\\\"weight_v\\\", trainable=True)\",\n \"range `[0, config.max_position_embeddings - 1]`. [What are position IDs?](../glossary#position-ids) head_mask (`np.ndarray` or `tf.Tensor`\",\n \"0, ) -> tf.Tensor: \\\"\\\"\\\" Computes random mask spans for a given shape\",\n \"control over how to convert `input_values` indices into associated vectors than the model's\",\n \"\\\" of \\\" \\\"input tensor should have a defined dimension \\\" \\\"but the\",\n \"output: TFCausalLMOutput) -> TFCausalLMOutput: hs = tf.convert_to_tensor(output.hidden_states) if self.config.output_hidden_states else None attns =\",\n \"class TFHubertModel(TFHubertPreTrainedModel): def __init__(self, config: HubertConfig, *inputs, **kwargs): super().__init__(config, *inputs, **kwargs) self.config =\",\n \"loss. Indices should be in `[-100, 0, ..., config.vocab_size]` (see `input_values` docstring) Tokens\",\n \"== \\\"layer\\\": conv_layers = [ TFHubertLayerNormConvLayer(config, layer_id=i, name=f\\\"conv_layers.{i}\\\") for i in range(config.num_feat_extract_layers) ]\",\n \"input_shape): if not self.built: input_shape = input_shape.as_list() # Conv1D output shapes are checked\",\n \"of the convolutional layers \\\"\\\"\\\" def _conv_out_length(input_length, kernel_size, stride): # 1D convolutional layer\",\n \") attn_output = tf.transpose( tf.reshape(attn_output, (bsz, self.num_heads, tgt_len, self.head_dim)), (0, 2, 1, 3)\",\n \"sequence_length)`, *optional*): Labels for computing the masked language modeling loss. Indices should be\",\n \"make sure that offset samples are < sequence_length uniform_dist = tf.ones((batch_size, sequence_length -\",\n \"tf.concat([past_key_value[1], value_states], axis=2) else: # self_attention key_states = self._shape(self.k_proj(hidden_states), -1, bsz) value_states =\",\n \"is_decoder=False, name=\\\"attention\\\", ) self.dropout = tf.keras.layers.Dropout(config.hidden_dropout) self.layer_norm = tf.keras.layers.LayerNormalization(epsilon=config.layer_norm_eps, name=\\\"layer_norm\\\") self.feed_forward = TFHubertFeedForward(config,\",\n \"(third \\\"elif\\\" case) # if encoder bi-directional self-attention `past_key_value` is always `None` past_key_value\",\n \"class TFHubertPositionalConvEmbedding(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs: Any) -> None: super().__init__(**kwargs) self.conv =\",\n \"bool = False, bias: bool = True, **kwargs, ): super().__init__(**kwargs) self.embed_dim = embed_dim\",\n \"abstract class to handle weights initialization and a simple interface for downloading and\",\n \"# get query proj query_states = self.q_proj(hidden_states) * self.scaling # get key, value\",\n \"`({0}, hidden_size)`, *optional*): Optionally, instead of passing `input_values` you can choose to directly\",\n \"target processor to encode labels >>> with processor.as_target_processor(): ... labels = processor(transcription, return_tensors=\\\"tf\\\").input_values\",\n \"Optional[tf.Tensor] = None, output_attentions: Optional[bool] = None, output_hidden_states: Optional[bool] = None, return_dict: Optional[bool]\",\n \"str(input_shape) + \\\".\\\" ) def _set_number_of_groups_for_instance_norm(self, input_shape): dim = input_shape[self.axis] if self.groups ==\",\n \"axis if self.config.mask_feature_prob > 0: mask_feature_indices = _compute_mask_indices( (batch_size, hidden_size), mask_prob=self.config.mask_feature_prob, mask_length=self.config.mask_feature_length, )\",\n \"model = TFHubertForCTC.from_pretrained(\\\"facebook/hubert-base-960h\\\") >>> def map_to_array(batch): ... speech, _ = sf.read(batch[\\\"file\\\"]) ... batch[\\\"speech\\\"]\",\n \"None: super().__init__(**kwargs) if config.feat_extract_norm == \\\"group\\\": conv_layers = [TFHubertGroupNormConvLayer(config, layer_id=0, name=f\\\"conv_layers.{0}\\\")] + [\",\n \"optional padding mask of the same size as shape, which will prevent masking\",\n \"{allowed_types} is accepted for {k}.\\\") else: if isinstance(input_values, tf.Tensor) or input_values is None:\",\n \"constraint=self.beta_constraint, ) else: self.beta = None def _create_broadcast_shape(self, input_shape): broadcast_shape = [1] *\",\n \"License. # You may obtain a copy of the License at # #\",\n \"group_shape else: return inputs, group_shape def _apply_normalization(self, reshaped_inputs, input_shape): group_shape = tf.keras.backend.int_shape(reshaped_inputs) group_reduction_axes\",\n \"TF calls the method with LayerCall.__call__(args, **kwargs) # So to respect the proper\",\n \"if tf.executing_eagerly(): tf.debugging.assert_equal( shape_list(attn_weights), [bsz * self.num_heads, tgt_len, src_len], message=f\\\"Attention weights should be\",\n \"be obtained using [`BertTokenizer`]. See [`PreTrainedTokenizer.__call__`] and [`PreTrainedTokenizer.encode`] for details. [What are input\",\n \"TFHubertEncoderLayer(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs): super().__init__(**kwargs) self.attention = TFHubertAttention( embed_dim=config.hidden_size, num_heads=config.num_attention_heads, dropout=config.attention_dropout,\",\n \"# transform batch_indices to pair_indices pair_indices = tf.transpose(tf.concat([broad_casted_batch_dims, tf.reshape(batch_indices, [1, -1])], 0)) #\",\n \"spec_aug_mask_idxs = spec_aug_mask_idxs + offsets # scatter indices to mask spec_aug_mask = _scatter_values_on_batch_indices(\",\n \"`input_values` docstring) Tokens with indices set to `-100` are ignored (masked), the loss\",\n \"\\\"\\\"\\\" self.hubert.feature_extractor.trainable = False @add_start_docstrings_to_model_forward(HUBERT_INPUTS_DOCSTRING) @replace_return_docstrings(output_type=TFCausalLMOutput, config_class=_CONFIG_FOR_DOC) def call( self, input_values: tf.Tensor, attention_mask:\",\n \"serving(self, inputs): output = self.call(input_values=inputs, training=False) return self.serving_output(output) HUBERT_START_DOCSTRING = r\\\"\\\"\\\" This model\",\n \"# compute real output lengths according to convolution formula output_lengths = self._get_feat_extract_output_lengths(tf.reduce_sum(inputs[\\\"attention_mask\\\"], -1))\",\n \"ds.map(map_to_array) >>> input_values = processor(ds[\\\"speech\\\"][0], return_tensors=\\\"tf\\\").input_values # Batch size 1 >>> hidden_states =\",\n \"= (key_states, value_states) proj_shape = (bsz * self.num_heads, -1, self.head_dim) query_states = tf.reshape(self._shape(query_states,\",\n \"else: raise ValueError( f\\\"Data of type {type(input)} is not allowed only {allowed_types} is\",\n \"add_start_docstrings_to_model_forward, logging, replace_return_docstrings, ) from .configuration_hubert import HubertConfig logger = logging.get_logger(__name__) _CONFIG_FOR_DOC =\",\n \"= None, output_attentions: Optional[bool] = None, output_hidden_states: Optional[bool] = None, return_dict: Optional[bool] =\",\n \"= self.dropout(hidden_states, training=inputs[\\\"training\\\"]) logits = self.lm_head(hidden_states) if labels is not None: if tf.reduce_max(labels)\",\n \"and each example must have the shape `({0})`): Indices of input sequence tokens\",\n \"= True self._normalize_kernel() padded_inputs = tf.pad(inputs, ((0, 0), (self.explicit_padding, self.explicit_padding), (0, 0))) output\",\n \"# Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2PositionalConvEmbedding with Wav2Vec2->Hubert class TFHubertPositionalConvEmbedding(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs:\",\n \"self.conv(hidden_states) hidden_states = self.layer_norm(hidden_states) hidden_states = self.activation(hidden_states) return hidden_states # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2GroupNormConvLayer\",\n \"output_attentions=inputs[\\\"output_attentions\\\"], output_hidden_states=inputs[\\\"output_hidden_states\\\"], return_dict=inputs[\\\"return_dict\\\"], training=inputs[\\\"training\\\"], ) return outputs def serving_output(self, output): hs = tf.convert_to_tensor(output.hidden_states)\",\n \"be named accordingly to the parameters name, i.e. `input_values = tf.keras.Input(shape=(128,), dtype='float32', name=\\\"input_values\\\")`\",\n \"class TFHubertWeightNormConv1D(tf.keras.layers.Conv1D): \\\"\\\"\\\"Adapted from https://www.tensorflow.org/probability/api_docs/python/tfp/layers/weight_norm/WeightNorm\\\"\\\"\\\" def __init__(self, filters, kernel_size, groups, explicit_padding, **kwargs): super().__init__(\",\n \"ignored (masked), the loss is only computed for the tokens with labels in\",\n \"broadcast_shape.insert(self.axis, self.groups) else: broadcast_shape[self.axis] = self.groups return broadcast_shape # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2WeightNormConv1D with\",\n \"tensors of all attention layers. See `attentions` under returned tensors for more detail.\",\n \"**kwargs): super().__init__( filters=filters, kernel_size=kernel_size, groups=groups, padding=\\\"valid\\\", use_bias=True, bias_initializer=\\\"he_normal\\\", **kwargs, ) self.explicit_padding = explicit_padding\",\n \"order of the tensors will not be guaranteed during the training. Args: func\",\n \"use the .name property so we check for a real Tensor if type(input)\",\n \"1]`: - 1 for tokens that are **not masked**, - 0 for tokens\",\n \"ValueError( f\\\"`mask_length` has to be smaller than `sequence_length`, but got `mask_length`: {mask_length} and\",\n \"accepted for {parameter_names[i]}.\\\" ) elif isinstance(input_values, (dict, BatchEncoding)): if \\\"inputs\\\" in input_values: warnings.warn(\",\n \"to indicate first and second portions of the inputs. Indices are selected in\",\n \"= tf.keras.layers.Dense(embed_dim, use_bias=bias, name=\\\"out_proj\\\") def _shape(self, tensor: tf.Tensor, seq_len: int, bsz: int): return\",\n \"indicates the head is **not masked**, - 0 indicates the head is **masked**.\",\n \"0: # generate indices & apply SpecAugment along time axis mask_time_indices = _compute_mask_indices(\",\n \"to respect the proper output we have to add this exception if \\\"args\\\"\",\n \"hidden_states hidden_states, attn_weights, _ = self.attention( hidden_states, attention_mask=attention_mask, training=training ) hidden_states = self.dropout(hidden_states,\",\n \"+ position_embeddings hidden_states = self.dropout(hidden_states, training=training) for i, layer_module in enumerate(self.layer): if output_hidden_states:\",\n \"num_heads) != self.embed_dim: raise ValueError( f\\\"embed_dim must be divisible by num_heads (got `embed_dim`:\",\n \"Fairseq Authors and the HuggingFace Inc. team. All rights reserved. # # Licensed\",\n \"add LayerDrop (see https://arxiv.org/abs/1909.11556 for description) dropout_probability = np.random.uniform(0, 1) if training and\",\n \"\\\" \\\"input tensor should have a defined dimension \\\" \\\"but the layer received\",\n \"of type {type(input)} is not allowed only {allowed_types} is accepted for {parameter_names[i]}.\\\" )\",\n \"= hidden_states * tf.expand_dims(attention_mask, -1) attention_mask = _expand_mask(attention_mask) else: attention_mask = None position_embeddings\",\n \"and loading pretrained models. \\\"\\\"\\\" config_class = HubertConfig base_model_prefix = \\\"hubert\\\" main_input_name =\",\n \"from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2FeedForward with Wav2Vec2->Hubert class TFHubertFeedForward(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs): super().__init__(**kwargs) self.intermediate_dropout\",\n \"in a future version, use `past_key_values` instead.\\\", FutureWarning, ) output[\\\"past_key_values\\\"] = input_values.pop(\\\"decoder_cached_states\\\") for\",\n \"= [1] * len(input_shape) is_instance_norm = (input_shape[self.axis] // self.groups) == 1 if not\",\n \"hidden_states = self.dropout(hidden_states, training=training) hidden_states = attn_residual + hidden_states hidden_states = self.layer_norm(hidden_states) hidden_states\",\n \") hidden_states = self.dropout(hidden_states, training=training) hidden_states = attn_residual + hidden_states hidden_states = self.layer_norm(hidden_states)\",\n \"+ (hidden_states,) if not return_dict: return tuple(v for v in [hidden_states, all_hidden_states, all_self_attentions]\",\n \"= None, head_mask: Optional[tf.Tensor] = None, inputs_embeds: Optional[tf.Tensor] = None, output_attentions: Optional[bool] =\",\n \"several input Tensors IN THE ORDER given in the docstring: `model([input_values, attention_mask])` or\",\n \"using [`BertTokenizer`]. See [`PreTrainedTokenizer.__call__`] and [`PreTrainedTokenizer.encode`] for details. [What are input IDs?](../glossary#input-ids) attention_mask\",\n \"`freeze_feature_encoder` method instead.\\\", FutureWarning, ) self.freeze_feature_encoder() def freeze_feature_encoder(self): \\\"\\\"\\\" Calling this function will\",\n \"</Tip> Args: config ([`HubertConfig`]): Model configuration class with all the parameters of the\",\n \"def freeze_feature_encoder(self): \\\"\\\"\\\" Calling this function will disable the gradient computation for the\",\n \"BatchEncoding)): if \\\"inputs\\\" in input_values: warnings.warn( \\\"The `inputs` argument is deprecated and will\",\n \"TFHubertFeatureProjection(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs): super().__init__(**kwargs) self.layer_norm = tf.keras.layers.LayerNormalization(epsilon=config.layer_norm_eps, name=\\\"layer_norm\\\") self.projection =\",\n \"(0, 2, 1, 3) ) attn_output = tf.reshape(attn_output, (bsz, tgt_len, embed_dim)) attn_output =\",\n \"transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2Encoder with Wav2Vec2->Hubert class TFHubertEncoder(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs): super().__init__(**kwargs) self.config =\",\n \"in graph mode the value in the config will be used instead. output_hidden_states\",\n \"if self.axis == -1 else self.axis - 1 group_reduction_axes.pop(axis) mean, variance = tf.nn.moments(reshaped_inputs,\",\n \"from ...tokenization_utils_base import BatchEncoding from ...utils import ( ModelOutput, add_start_docstrings, add_start_docstrings_to_model_forward, logging, replace_return_docstrings,\",\n \"\\\"The `inputs` argument is deprecated and will be removed in a future version,\",\n \"self.conv = tf.keras.layers.Conv1D( filters=self.out_conv_dim, kernel_size=config.conv_kernel[layer_id], strides=config.conv_stride[layer_id], use_bias=config.conv_bias, name=\\\"conv\\\", ) self.activation = get_tf_activation(config.feat_extract_activation) def\",\n \"__init__(self, config: HubertConfig, **kwargs): super().__init__(**kwargs) self.attention = TFHubertAttention( embed_dim=config.hidden_size, num_heads=config.num_attention_heads, dropout=config.attention_dropout, is_decoder=False, name=\\\"attention\\\",\",\n \"axis=2) value_states = tf.concat([past_key_value[1], value_states], axis=2) else: # self_attention key_states = self._shape(self.k_proj(hidden_states), -1,\",\n \"super().__init__(**kwargs) self.embed_dim = embed_dim self.num_heads = num_heads self.dropout = tf.keras.layers.Dropout(dropout) self.head_dim = embed_dim\",\n \"selected heads of the self-attention modules. Mask values selected in `[0, 1]`: -\",\n \"all its model (such as downloading or saving, resizing the input embeddings, pruning\",\n \"2 where first element is batch size and 2nd is timesteps attention_mask: optional\",\n \"pass an embedded representation. This is useful if you want more control over\",\n \"head_mask=inputs[\\\"head_mask\\\"], inputs_embeds=inputs[\\\"inputs_embeds\\\"], output_attentions=inputs[\\\"output_attentions\\\"], output_hidden_states=inputs[\\\"output_hidden_states\\\"], return_dict=inputs[\\\"return_dict\\\"], training=inputs[\\\"training\\\"], ) hidden_states = outputs[0] hidden_states = self.dropout(hidden_states,\",\n \"... batch[\\\"speech\\\"] = speech ... return batch >>> ds = load_dataset(\\\"hf-internal-testing/librispeech_asr_dummy\\\", \\\"clean\\\", split=\\\"validation\\\")\",\n \"the feature encoder so that its parameter will not be updated during training.\",\n \"gumbel-max trick will do for now - see https://github.com/tensorflow/tensorflow/issues/9260 for more info \\\"\\\"\\\"\",\n \"= (logits,) + outputs[1:] return ((loss,) + output) if loss is not None\",\n \"corresponds to a *sentence A* token, - 1 corresponds to a *sentence B*\",\n \"-1) attention_mask = _expand_mask(attention_mask) else: attention_mask = None position_embeddings = self.pos_conv_embed(hidden_states) hidden_states =\",\n \"# Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2EncoderStableLayerNorm with Wav2Vec2->Hubert class TFHubertEncoderStableLayerNorm(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs):\",\n \"to return the attentions tensors of all attention layers. See `attentions` under returned\",\n \"always `None` past_key_value = (key_states, value_states) proj_shape = (bsz * self.num_heads, -1, self.head_dim)\",\n \"group_shape = [tensor_input_shape[i] for i in range(len(input_shape))] is_instance_norm = (input_shape[self.axis] // self.groups) ==\",\n \"= tf.constant(1.0) mask = tf.cast(mask, dtype=one_cst.dtype) expanded_mask = tf.tile(mask[:, None, None, :], (1,\",\n \"have a defined dimension \\\" \\\"but the layer received an input with shape\",\n \"epsilon: float = 1e-3, center: bool = True, scale: bool = True, beta_initializer:\",\n \"from ...tf_utils import shape_list from ...tokenization_utils_base import BatchEncoding from ...utils import ( ModelOutput,\",\n \"HubertConfig, *inputs, **kwargs): super().__init__(config, *inputs, **kwargs) self.hubert = TFHubertMainLayer(config, name=\\\"hubert\\\") self.dropout = tf.keras.layers.Dropout(config.final_dropout)\",\n \"smaller than `sequence_length`, but got `mask_length`: {mask_length} and `sequence_length`: {sequence_length}`\\\" ) # compute\",\n \"= sequence_length // mask_length # SpecAugment mask to fill spec_aug_mask = tf.zeros((batch_size, sequence_length),\",\n \"name=\\\"weight_v\\\", trainable=True) self.weight_v = self.kernel self.weight_g = self.add_weight( name=\\\"weight_g\\\", shape=(int(self.weight_v.shape[self.filter_axis]), 1, 1), initializer=\\\"ones\\\",\",\n \"use this file except in compliance with the License. # You may obtain\",\n \"accordingly to the parameters name, i.e. `input_values = tf.keras.Input(shape=(128,), dtype='float32', name=\\\"input_values\\\")` otherwise the\",\n \"] def call( self, hidden_states: tf.Tensor, attention_mask: Optional[tf.Tensor] = None, output_attentions: Optional[bool] =\",\n \"dtype='float32', name=\\\"input_values\\\")` otherwise the order of the tensors will not be guaranteed during\",\n \"**kwargs): super().__init__(**kwargs) self.layer_norm = tf.keras.layers.LayerNormalization(epsilon=config.layer_norm_eps, name=\\\"layer_norm\\\") self.projection = tf.keras.layers.Dense( units=config.hidden_size, kernel_initializer=get_initializer(config.initializer_range), bias_initializer=\\\"zeros\\\", name=\\\"projection\\\",\",\n \"= self.add_weight( name=\\\"weight_g\\\", shape=(int(self.weight_v.shape[self.filter_axis]), 1, 1), initializer=\\\"ones\\\", dtype=self.weight_v.dtype, trainable=True, ) self.bias = self.add_weight(name=\\\"bias\\\",\",\n \"i, layer_module in enumerate(self.layer): if output_hidden_states: all_hidden_states = all_hidden_states + (hidden_states,) # add\",\n \"not be guaranteed during the training. Args: func (`callable`): The callable function of\",\n \"group_reduction_axes = list(range(1, len(group_shape))) is_instance_norm = (input_shape[self.axis] // self.groups) == 1 if not\",\n \"def _sample_without_replacement(distribution, num_samples): \\\"\\\"\\\" Categorical sampling without replacement is currently not implemented. The\",\n \"dtype=tf.float32) ) input_lengths = self.hubert._get_feat_extract_output_lengths(tf.reduce_sum(attention_mask, axis=-1)) # assuming that padded tokens are filled\",\n \"the actual number will be smaller (unless no_overlap is True) mask_length: size of\",\n \"output[\\\"args\\\"] is not None and type(output[\\\"args\\\"]) == tf.Tensor: tensor_name = output[\\\"args\\\"].name.split(\\\":\\\")[0] output[tensor_name] =\",\n \"r\\\"\\\"\\\" labels (`tf.Tensor` or `np.ndarray` of shape `(batch_size, sequence_length)`, *optional*): Labels for computing\",\n \"\\\"inputs\\\" in input_values: warnings.warn( \\\"The `inputs` argument is deprecated and will be removed\",\n \"= self.kernel self.weight_g = self.add_weight( name=\\\"weight_g\\\", shape=(int(self.weight_v.shape[self.filter_axis]), 1, 1), initializer=\\\"ones\\\", dtype=self.weight_v.dtype, trainable=True, )\",\n \"have always the pattern `name:id` then we check only the # `name` part\",\n \"in batch num_masked_spans = int(mask_prob * sequence_length / mask_length + tf.random.uniform((1,))) num_masked_spans =\",\n \"-> Dict[str, tf.Tensor]: pad_token = 0.0 input_values = tf.convert_to_tensor(np.random.rand(1, 16000), tf.float32) dummy_inputs =\",\n \"PyTorch with indices in format (batch_dim, indixes) \\\"\\\"\\\" indices_shape = shape_list(batch_indices) # broadcast\",\n \"then reuse all cross-attention # key/value_states (first \\\"if\\\" case) # if uni-directional self-attention\",\n \"# Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2Encoder with Wav2Vec2->Hubert class TFHubertEncoder(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs):\",\n \"a plain tuple. This argument can be used in eager mode, in graph\",\n \"1, tgt_len, src_len)}, but is {shape_list(attention_mask)}\\\", ) attention_mask = tf.cast(attention_mask, dtype=attn_weights.dtype) attn_weights =\",\n \"tf.Tensor: tensor_name = output[\\\"args\\\"].name.split(\\\":\\\")[0] output[tensor_name] = output[\\\"args\\\"] else: # `args` in this case\",\n \"allowed_types) or v is None: output[k] = v else: raise ValueError(f\\\"Data of type\",\n \"(input_length - kernel_size) // stride + 1 for kernel_size, stride in zip(self.config.conv_kernel, self.config.conv_stride):\",\n \"self.groups) == 1 if not is_instance_norm: outputs = tf.reshape(normalized_inputs, tensor_input_shape) else: outputs =\",\n \"str(self.groups) + \\\") must be a \\\" \\\"multiple of the number of channels\",\n \"= TFHubertFeatureEncoder(config, name=\\\"feature_extractor\\\") self.feature_projection = TFHubertFeatureProjection(config, name=\\\"feature_projection\\\") if config.do_stable_layer_norm: self.encoder = TFHubertEncoderStableLayerNorm(config, name=\\\"encoder\\\")\",\n \"spec_aug_mask # Copied from transformers.models.bart.modeling_tf_bart._expand_mask def _expand_mask(mask: tf.Tensor, tgt_len: Optional[int] = None, past_key_values_length:\",\n \"\\\"multiple of the number of channels (\\\" + str(dim) + \\\").\\\" ) def\",\n \"in PyTorch with indices in format (batch_dim, indixes) \\\"\\\"\\\" indices_shape = shape_list(batch_indices) #\",\n \"class TFHubertNoLayerNormConvLayer(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, layer_id: int = 0, **kwargs: Any) ->\",\n \"`freeze_feature_extractor` is deprecated and will be removed in Transformers v5.\\\" \\\"Please use the\",\n \"# Add last layer if output_hidden_states: all_hidden_states = all_hidden_states + (hidden_states,) if not\",\n \"+ hidden_states hidden_states = hidden_states + self.feed_forward(self.final_layer_norm(hidden_states)) outputs = (hidden_states,) if output_attentions: outputs\",\n \"is not None: # apply SpecAugment along time axis with given mask_time_indices hidden_states\",\n \"removed in a future version, use `past_key_values` instead.\\\", FutureWarning, ) output[\\\"past_key_values\\\"] = input_values.pop(\\\"decoder_cached_states\\\")\",\n \"so we need to account for padding input_shape[-2] += self.explicit_padding * 2 super().build(input_shape)\",\n \"Indices of positions of each input sequence tokens in the position embeddings. Selected\",\n \"# distributed under the License is distributed on an \\\"AS IS\\\" BASIS, #\",\n \"= tf.transpose( tf.reshape(attn_output, (bsz, self.num_heads, tgt_len, self.head_dim)), (0, 2, 1, 3) ) attn_output\",\n \"None, training: bool = False, **kwargs: Any, ): inputs = input_values_processing( func=self.call, config=self.config,\",\n \"filters=filters, kernel_size=kernel_size, groups=groups, padding=\\\"valid\\\", use_bias=True, bias_initializer=\\\"he_normal\\\", **kwargs, ) self.explicit_padding = explicit_padding self.filter_axis =\",\n \"the convolutional layers \\\"\\\"\\\" def _conv_out_length(input_length, kernel_size, stride): # 1D convolutional layer output\",\n \"broadcast_shape = [1] * len(input_shape) is_instance_norm = (input_shape[self.axis] // self.groups) == 1 if\",\n \"span to mask approximately this percentage of all elements. however due to overlaps,\",\n \"inputs): if not self.initialized: self._init_norm() self.initialized = True self._normalize_kernel() padded_inputs = tf.pad(inputs, ((0,\",\n \"tf.transpose(tf.reshape(tensor, (bsz, seq_len, self.num_heads, self.head_dim)), (0, 2, 1, 3)) def call( self, hidden_states:\",\n \"in the vocabulary. Indices can be obtained using [`BertTokenizer`]. See [`PreTrainedTokenizer.__call__`] and [`PreTrainedTokenizer.encode`]\",\n \"= input else: raise ValueError( f\\\"Data of type {type(input)} is not allowed only\",\n \"`model(inputs)`. If you choose this second option, there are three possibilities you can\",\n \"if tf.executing_eagerly(): tf.debugging.assert_equal( shape_list(attn_output), [bsz * self.num_heads, tgt_len, self.head_dim], message=f\\\"`attn_output` should be of\",\n \"self.k_proj = tf.keras.layers.Dense(embed_dim, use_bias=bias, name=\\\"k_proj\\\") self.q_proj = tf.keras.layers.Dense(embed_dim, use_bias=bias, name=\\\"q_proj\\\") self.v_proj = tf.keras.layers.Dense(embed_dim,\",\n \"bool = True, beta_initializer: tf.keras.initializers.Initializer = \\\"zeros\\\", gamma_initializer: tf.keras.initializers.Initializer = \\\"ones\\\", beta_regularizer: tf.keras.regularizers.Regularizer\",\n \"= layer_outputs[0] if output_attentions: all_self_attentions = all_self_attentions + (layer_outputs[1],) hidden_states = self.layer_norm(hidden_states) if\",\n \"tgt_len, src_len)) attn_probs = self.dropout(attn_weights, training=training) attn_output = tf.matmul(attn_probs, value_states) # The tf.debugging\",\n \"input_values=input_values, attention_mask=attention_mask, token_type_ids=token_type_ids, position_ids=position_ids, head_mask=head_mask, inputs_embeds=inputs_embeds, output_attentions=output_attentions, output_hidden_states=output_hidden_states, return_dict=return_dict, training=training, ) inputs[\\\"output_hidden_states\\\"] =\",\n \"return hidden_states # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2EncoderLayer with Wav2Vec2->Hubert class TFHubertEncoderLayer(tf.keras.layers.Layer): def __init__(self, config:\",\n \"head_mask: Optional[tf.Tensor] = None, inputs_embeds: Optional[tf.Tensor] = None, output_attentions: Optional[tf.Tensor] = None, output_hidden_states:\",\n \"= self._shape(self.k_proj(hidden_states), -1, bsz) value_states = self._shape(self.v_proj(hidden_states), -1, bsz) key_states = tf.concat([past_key_value[0], key_states],\",\n \"False, bias: bool = True, **kwargs, ): super().__init__(**kwargs) self.embed_dim = embed_dim self.num_heads =\",\n \"tgt_len, src_len)) return attn_output, attn_weights, past_key_value # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2FeedForward with Wav2Vec2->Hubert class\",\n \") return normalized_inputs def _get_reshaped_weights(self, input_shape): broadcast_shape = self._create_broadcast_shape(input_shape) gamma = None beta\",\n \"wish \\\" \\\"to train/fine-tine this model, you need a GPU or a TPU\\\"\",\n \"func (`callable`): The callable function of the TensorFlow model. config ([`PretrainedConfig`]): The config\",\n \"tf.expand_dims(spec_aug_mask_idxs, -1) spec_aug_mask_idxs = tf.tile(spec_aug_mask_idxs, (1, 1, mask_length)) spec_aug_mask_idxs = tf.reshape(spec_aug_mask_idxs, (batch_size, num_masked_spans\",\n \"the equivalent `freeze_feature_encoder` method instead.\\\", FutureWarning, ) self.freeze_feature_encoder() def freeze_feature_encoder(self): \\\"\\\"\\\" Calling this\",\n \"all Hubert models at https://huggingface.co/models?filter=hubert ] LARGE_NEGATIVE = -1e8 # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.input_values_processing\",\n \"3)) def call( self, hidden_states: tf.Tensor, key_value_states: Optional[tf.Tensor] = None, past_key_value: Optional[Tuple[Tuple[tf.Tensor]]] =\",\n \"EagerTensors don't allow to use the .name property so we check for a\",\n \"to pair_indices pair_indices = tf.transpose(tf.concat([broad_casted_batch_dims, tf.reshape(batch_indices, [1, -1])], 0)) # scatter values to\",\n \"2nd is timesteps attention_mask: optional padding mask of the same size as shape,\",\n \"- having all inputs as keyword arguments (like PyTorch models), or - having\",\n \"num_samples): \\\"\\\"\\\" Categorical sampling without replacement is currently not implemented. The gumbel-max trick\",\n \"are < sequence_length uniform_dist = tf.ones((batch_size, sequence_length - (mask_length - 1))) # get\",\n \"scatter values to pair indices return tf.scatter_nd(pair_indices, tf.reshape(values, [-1]), output_shape) # Copied from\",\n \"`-100` are ignored (masked), the loss is only computed for the tokens with\",\n \"BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\",\n \"`sequence_length`: {sequence_length}`\\\" ) # compute number of masked spans in batch num_masked_spans =\",\n \"graph mode the value in the config will be used instead. output_hidden_states (`bool`,\",\n \"= self.add_weight( shape=shape, name=\\\"beta\\\", initializer=self.beta_initializer, regularizer=self.beta_regularizer, constraint=self.beta_constraint, ) else: self.beta = None def\",\n \"Do you want to \\\" \\\"use tf.layer.batch_normalization instead\\\" ) def _create_input_spec(self, input_shape): dim\",\n \"a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required\",\n \"False self.kernel_norm_axes = tf.constant([0, 1]) def _init_norm(self): \\\"\\\"\\\"Set the norm of the weight\",\n \"def _check_size_of_dimensions(self, input_shape): dim = input_shape[self.axis] if dim < self.groups: raise ValueError( \\\"Number\",\n \"tf.nn.batch_normalization( reshaped_inputs, mean=mean, variance=variance, scale=gamma, offset=beta, variance_epsilon=self.epsilon, ) return normalized_inputs def _get_reshaped_weights(self, input_shape):\",\n \"Union[TFCausalLMOutput, Tuple[tf.Tensor]]: r\\\"\\\"\\\" labels (`tf.Tensor` or `np.ndarray` of shape `(batch_size, sequence_length)`, *optional*): Labels\",\n \"provided this layer is used as a cross-attention layer # for the decoder\",\n \"hidden_states = tf.where( tf.cast(mask_time_indices[:, :, tf.newaxis], tf.bool), self.masked_spec_embed[tf.newaxis, tf.newaxis, :], hidden_states, ) #\",\n \"Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2PositionalConvEmbedding with Wav2Vec2->Hubert class TFHubertPositionalConvEmbedding(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs: Any)\",\n \"= tf.keras.layers.LayerNormalization( epsilon=config.layer_norm_eps, name=\\\"final_layer_norm\\\" ) def call( self, hidden_states: tf.Tensor, attention_mask: Optional[tf.Tensor] =\",\n \"Expands attention_mask from `[bsz, seq_len]` to `[bsz, 1, tgt_seq_len, src_seq_len]`. \\\"\\\"\\\" src_len =\",\n \"super().__init__(**kwargs) if config.feat_extract_norm == \\\"group\\\": conv_layers = [TFHubertGroupNormConvLayer(config, layer_id=0, name=f\\\"conv_layers.{0}\\\")] + [ TFHubertNoLayerNormConvLayer(config,\",\n \"is not None) return TFBaseModelOutput( last_hidden_state=hidden_states, hidden_states=all_hidden_states, attentions=all_self_attentions, ) # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2EncoderStableLayerNorm\",\n \"shape, which will prevent masking padded elements mask_prob: probability for each token to\",\n \"in parameter_names: output[tensor_name] = input else: output[parameter_names[i]] = input elif isinstance(input, allowed_types) or\",\n \"detail. This argument can be used only in eager mode, in graph mode\",\n \"input_values=inputs[\\\"input_values\\\"], attention_mask=inputs[\\\"attention_mask\\\"], token_type_ids=inputs[\\\"token_type_ids\\\"], position_ids=inputs[\\\"position_ids\\\"], head_mask=inputs[\\\"head_mask\\\"], inputs_embeds=inputs[\\\"inputs_embeds\\\"], output_attentions=inputs[\\\"output_attentions\\\"], output_hidden_states=inputs[\\\"output_hidden_states\\\"], return_dict=inputs[\\\"return_dict\\\"], training=inputs[\\\"training\\\"], ) hidden_states =\",\n \"None, gamma_regularizer: tf.keras.regularizers.Regularizer = None, beta_constraint: tf.keras.constraints.Constraint = None, gamma_constraint: tf.keras.constraints.Constraint = None,\",\n \"accepted for {k}.\\\") if isinstance(input_values, (tuple, list)): for i, input in enumerate(input_values): #\",\n \"token_type_ids: Optional[tf.Tensor] = None, position_ids: Optional[tf.Tensor] = None, head_mask: Optional[tf.Tensor] = None, inputs_embeds:\",\n \"hidden_states = self.intermediate_act_fn(hidden_states) hidden_states = self.intermediate_dropout(hidden_states, training=training) hidden_states = self.output_dense(hidden_states) hidden_states = self.output_dropout(hidden_states,\",\n \"Optional[bool] = None, output_hidden_states: Optional[bool] = None, return_dict: Optional[bool] = None, training: bool\",\n \"must be <= vocab_size: {self.config.vocab_size}\\\") attention_mask = ( inputs[\\\"attention_mask\\\"] if inputs[\\\"attention_mask\\\"] is not\",\n \"= tf.keras.layers.Dense(embed_dim, use_bias=bias, name=\\\"q_proj\\\") self.v_proj = tf.keras.layers.Dense(embed_dim, use_bias=bias, name=\\\"v_proj\\\") self.out_proj = tf.keras.layers.Dense(embed_dim, use_bias=bias,\",\n \"TFHubertWeightNormConv1D(tf.keras.layers.Conv1D): \\\"\\\"\\\"Adapted from https://www.tensorflow.org/probability/api_docs/python/tfp/layers/weight_norm/WeightNorm\\\"\\\"\\\" def __init__(self, filters, kernel_size, groups, explicit_padding, **kwargs): super().__init__( filters=filters,\",\n \"= dict(inspect.signature(func).parameters) signature.pop(\\\"kwargs\\\", None) signature.pop(\\\"self\\\", None) parameter_names = list(signature.keys()) output = {} allowed_types\",\n \"config will be used instead. output_hidden_states (`bool`, *optional*): Whether or not to return\",\n \"config: HubertConfig, **kwargs): super().__init__(**kwargs) self.layer_norm = tf.keras.layers.LayerNormalization(epsilon=config.layer_norm_eps, name=\\\"layer_norm\\\") self.projection = tf.keras.layers.Dense( units=config.hidden_size, kernel_initializer=get_initializer(config.initializer_range),\",\n \"wrap processor as target processor to encode labels >>> with processor.as_target_processor(): ... labels\",\n \"processor.decode(predicted_ids[0]) >>> # compute loss >>> target_transcription = \\\"A MAN SAID TO THE\",\n \"* num_heads) != self.embed_dim: raise ValueError( f\\\"embed_dim must be divisible by num_heads (got\",\n \"deprecated and will be removed in Transformers v5.\\\" \\\"Please use the equivalent `freeze_feature_encoder`\",\n \"only the # `name` part tensor_name = input.name.split(\\\":\\\")[0] if tensor_name in parameter_names: output[tensor_name]\",\n \"TFHubertGroupNormConvLayer(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, layer_id: int = 0, **kwargs: Any) -> None:\",\n \"# get key, value proj if is_cross_attention and past_key_value is not None: #\",\n \"False) -> tf.Tensor: hidden_states = self.layer_norm(hidden_states) hidden_states = self.projection(hidden_states) hidden_states = self.dropout(hidden_states, training=training)\",\n \"tf.Tensor, tgt_len: Optional[int] = None, past_key_values_length: int = 0): \\\"\\\"\\\" Expands attention_mask from\",\n \"have different behaviors between training and evaluation). \\\"\\\"\\\" @add_start_docstrings( \\\"The bare TFHubert Model\",\n \"the first positional argument : - a single Tensor with `input_values` only and\",\n \"hidden_states: tf.Tensor) -> tf.Tensor: hidden_states = self.conv(hidden_states) hidden_states = self.padding(hidden_states) hidden_states = self.activation(hidden_states)\",\n \"tf.keras.regularizers.get(beta_regularizer) self.gamma_regularizer = tf.keras.regularizers.get(gamma_regularizer) self.beta_constraint = tf.keras.constraints.get(beta_constraint) self.gamma_constraint = tf.keras.constraints.get(gamma_constraint) self._check_axis() def build(self,\",\n \"tf.transpose(kernel) def build(self, input_shape): if not self.built: input_shape = input_shape.as_list() # Conv1D output\",\n \"tensorflow as tf >>> from transformers import Wav2Vec2Processor, TFHubertForCTC >>> from datasets import\",\n \"if output_hidden_states else None all_self_attentions = () if output_attentions else None if attention_mask\",\n \"token_type_ids=token_type_ids, position_ids=position_ids, head_mask=head_mask, inputs_embeds=inputs_embeds, output_attentions=output_attentions, output_hidden_states=output_hidden_states, return_dict=return_dict, training=training, ) outputs = self.hubert( input_values=inputs[\\\"input_values\\\"],\",\n \"-1 else self.axis - 1 else: axis = -1 if self.axis == -1\",\n \"with one or several input Tensors associated to the input names given in\",\n \"num_masked_spans = int(mask_prob * sequence_length / mask_length + tf.random.uniform((1,))) num_masked_spans = max(num_masked_spans, min_masks)\",\n \"attn_probs = self.dropout(attn_weights, training=training) attn_output = tf.matmul(attn_probs, value_states) # The tf.debugging asserts are\",\n \"self.weight_g.assign(kernel_norm[:, tf.newaxis, tf.newaxis]) def _normalize_kernel(self): \\\"\\\"\\\"Generate normalized weights.\\\"\\\"\\\" kernel = tf.nn.l2_normalize(self.weight_v, axis=self.kernel_norm_axes) *\",\n \"= tf.keras.constraints.get(beta_constraint) self.gamma_constraint = tf.keras.constraints.get(gamma_constraint) self._check_axis() def build(self, input_shape): self._check_if_input_shape_is_none(input_shape) self._set_number_of_groups_for_instance_norm(input_shape) self._check_size_of_dimensions(input_shape) self._create_input_spec(input_shape)\",\n \"attended to labels_mask = tf.cast(labels >= 0, tf.int32) target_lengths = tf.reduce_sum(labels_mask, axis=-1) loss\",\n \"with given mask_time_indices hidden_states = tf.where( tf.cast(mask_time_indices[:, :, tf.newaxis], tf.bool), self.masked_spec_embed[tf.newaxis, tf.newaxis, :],\",\n \"`tf.Tensor` of shape `({0})`, *optional*): Indices of positions of each input sequence tokens\",\n \"all_self_attentions = all_self_attentions + (layer_outputs[1],) hidden_states = self.layer_norm(hidden_states) if output_hidden_states: all_hidden_states = all_hidden_states\",\n \"self.groups group_shape.insert(self.axis, self.groups) group_shape = tf.stack(group_shape) reshaped_inputs = tf.reshape(inputs, group_shape) return reshaped_inputs, group_shape\",\n \"of size {(self.num_heads)}, but is {shape_list(layer_head_mask)}\\\", ) attn_weights = tf.reshape(layer_head_mask, (1, -1, 1,\",\n \"def _create_input_spec(self, input_shape): dim = input_shape[self.axis] self.input_spec = tf.keras.layers.InputSpec(ndim=len(input_shape), axes={self.axis: dim}) def _add_gamma_weight(self,\",\n \"= tf.keras.layers.LayerNormalization(epsilon=config.layer_norm_eps, name=\\\"layer_norm\\\") self.dropout = tf.keras.layers.Dropout(config.hidden_dropout) self.layer = [TFHubertEncoderLayer(config, name=f\\\"layers.{i}\\\") for i in\",\n \"= tf.reshape(key_states, proj_shape) value_states = tf.reshape(value_states, proj_shape) src_len = shape_list(key_states)[1] attn_weights = tf.matmul(query_states,\",\n \"An abstract class to handle weights initialization and a simple interface for downloading\",\n \"name=f\\\"layers.{i}\\\") for i in range(config.num_hidden_layers)] def call( self, hidden_states: tf.Tensor, attention_mask: Optional[tf.Tensor] =\",\n \"shape: the the shape for which to compute masks. should be of size\",\n \"name=\\\"feature_extractor\\\") self.feature_projection = TFHubertFeatureProjection(config, name=\\\"feature_projection\\\") if config.do_stable_layer_norm: self.encoder = TFHubertEncoderStableLayerNorm(config, name=\\\"encoder\\\") else: self.encoder\",\n \"mask_time_indices = _compute_mask_indices( (batch_size, sequence_length), mask_prob=self.config.mask_time_prob, mask_length=self.config.mask_time_length, min_masks=2, ) hidden_states = tf.where( tf.cast(mask_time_indices[:,\",\n \"# Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2._compute_mask_indices def _compute_mask_indices( shape: Tuple[int, int], mask_prob: float, mask_length: int,\",\n \"if loss is not None else output return TFCausalLMOutput( loss=loss, logits=logits, hidden_states=outputs.hidden_states, attentions=outputs.attentions,\",\n \"and will be removed in a future version, use `past_key_values` instead.\\\", FutureWarning, )\",\n \"the weight vector.\\\"\\\"\\\" kernel_norm = tf.sqrt(tf.reduce_sum(tf.square(self.weight_v), axis=self.kernel_norm_axes)) self.weight_g.assign(kernel_norm[:, tf.newaxis, tf.newaxis]) def _normalize_kernel(self): \\\"\\\"\\\"Generate\",\n \"when using [`tf.keras.Model.fit`] method which currently requires having all the tensors in the\",\n \"{type(v)} is not allowed only {allowed_types} is accepted for {k}.\\\") else: if isinstance(input_values,\",\n \"tensor: tf.Tensor, seq_len: int, bsz: int): return tf.transpose(tf.reshape(tensor, (bsz, seq_len, self.num_heads, self.head_dim)), (0,\",\n \"else: axis = -1 if self.axis == -1 else self.axis - 1 group_reduction_axes.pop(axis)\",\n \"details. [What are input IDs?](../glossary#input-ids) attention_mask (`np.ndarray` or `tf.Tensor` of shape `({0})`, *optional*):\",\n \"def input_values_processing(func, config, input_values, **kwargs): \\\"\\\"\\\" Process the input of each TensorFlow model\",\n \"inherits from [`TFPreTrainedModel`]. Check the superclass documentation for the generic methods the library\",\n \"# wrap processor as target processor to encode labels >>> with processor.as_target_processor(): ...\",\n \"Optional[bool] = False, ) -> Union[TFBaseModelOutput, Tuple[tf.Tensor]]: all_hidden_states = () if output_hidden_states else\",\n \"offsets = tf.tile(offsets, (batch_size, num_masked_spans, 1)) offsets = tf.reshape(offsets, (batch_size, num_masked_spans * mask_length))\",\n \"serving_output(self, output): hs = tf.convert_to_tensor(output.hidden_states) if self.config.output_hidden_states else None attns = tf.convert_to_tensor(output.attentions) if\",\n \"1 corresponds to a *sentence B* token. [What are token type IDs?](../glossary#token-type-ids) position_ids\",\n \"not implemented. The gumbel-max trick will do for now - see https://github.com/tensorflow/tensorflow/issues/9260 for\",\n \"return batch >>> ds = load_dataset(\\\"hf-internal-testing/librispeech_asr_dummy\\\", \\\"clean\\\", split=\\\"validation\\\") >>> ds = ds.map(map_to_array) >>>\",\n \"variance = tf.nn.moments(reshaped_inputs, group_reduction_axes, keepdims=True) gamma, beta = self._get_reshaped_weights(input_shape) normalized_inputs = tf.nn.batch_normalization( reshaped_inputs,\",\n \") self.activation = get_tf_activation(config.feat_extract_activation) self.layer_norm = TFHubertGroupNorm(groups=self.out_conv_dim, epsilon=config.layer_norm_eps, name=\\\"layer_norm\\\") def call(self, hidden_states: tf.Tensor)\",\n \"like dropout modules have different behaviors between training and evaluation). \\\"\\\"\\\" @add_start_docstrings( \\\"The\",\n \"all_hidden_states + (hidden_states,) # add LayerDrop (see https://arxiv.org/abs/1909.11556 for description) dropout_probability = np.random.uniform(0,\",\n \"_conv_out_length(input_length, kernel_size, stride): # 1D convolutional layer output length formula taken # from\",\n \"training: bool = False, **kwargs: Any, ): inputs = input_values_processing( func=self.call, config=self.config, input_values=input_values,\",\n \"self.layer_norm = tf.keras.layers.LayerNormalization(epsilon=config.layer_norm_eps, name=\\\"layer_norm\\\") self.dropout = tf.keras.layers.Dropout(config.hidden_dropout) self.layer = [TFHubertEncoderLayer(config, name=f\\\"layers.{i}\\\") for i\",\n \"typing import Any, Dict, Optional, Tuple, Union import numpy as np import tensorflow\",\n \"got `mask_length`: {mask_length} and `sequence_length`: {sequence_length}`\\\" ) # compute number of masked spans\",\n \"config: HubertConfig, **kwargs: Any) -> None: super().__init__(**kwargs) self.conv = TFHubertWeightNormConv1D( filters=config.hidden_size, kernel_size=config.num_conv_pos_embeddings, groups=config.num_conv_pos_embedding_groups,\",\n \"axis=self.kernel_norm_axes)) self.weight_g.assign(kernel_norm[:, tf.newaxis, tf.newaxis]) def _normalize_kernel(self): \\\"\\\"\\\"Generate normalized weights.\\\"\\\"\\\" kernel = tf.nn.l2_normalize(self.weight_v, axis=self.kernel_norm_axes)\",\n \"performing attention on padding token indices. Mask values selected in `[0, 1]`: -\",\n \"config ([`PretrainedConfig`]): The config of the running model. **kwargs: The inputs of the\",\n \"# reuse k,v, cross_attentions key_states = past_key_value[0] value_states = past_key_value[1] elif is_cross_attention: #\",\n \"input names given in the docstring: `model({\\\"input_values\\\": input_values, \\\"token_type_ids\\\": token_type_ids})` </Tip> Args: config\",\n \"mask_length: int, min_masks: int = 0, ) -> tf.Tensor: \\\"\\\"\\\" Computes random mask\",\n \"# scatter indices to mask spec_aug_mask = _scatter_values_on_batch_indices( tf.ones_like(spec_aug_mask_idxs), spec_aug_mask_idxs, spec_aug_mask.shape ) return\",\n \"tf.keras.layers.LayerNormalization(epsilon=config.layer_norm_eps, name=\\\"layer_norm\\\") self.feed_forward = TFHubertFeedForward(config, name=\\\"feed_forward\\\") self.final_layer_norm = tf.keras.layers.LayerNormalization( epsilon=config.layer_norm_eps, name=\\\"final_layer_norm\\\" ) def\",\n \"for {k}.\\\") else: if isinstance(input_values, tf.Tensor) or input_values is None: output[parameter_names[0]] = input_values\",\n \"min_masks=2, ) hidden_states = tf.where( tf.cast(mask_time_indices[:, :, tf.newaxis], tf.bool), self.masked_spec_embed[tf.newaxis, tf.newaxis, :], hidden_states,\",\n \"tf.cast(attention_mask, dtype=attn_weights.dtype) attn_weights = tf.reshape(attn_weights, (bsz, self.num_heads, tgt_len, src_len)) + attention_mask attn_weights =\",\n \"# # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to\",\n \"key_states = self._shape(self.k_proj(key_value_states), -1, bsz) value_states = self._shape(self.v_proj(key_value_states), -1, bsz) elif past_key_value is\",\n \"\\\" f\\\"Use `{self.__class__.__bases__[0].__name__}` instead.\\\", FutureWarning, ) class TFHubertFeatureProjection(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs):\",\n \"the parameter list {parameter_names} and will be ignored.\\\" ) continue else: raise ValueError(f\\\"Data\",\n \"mask_length < 1: raise ValueError(\\\"`mask_length` has to be bigger than 0.\\\") if mask_length\",\n \"`sequence_length`, but got `mask_length`: {mask_length} and `sequence_length`: {sequence_length}`\\\" ) # compute number of\",\n \"None) parameter_names = list(signature.keys()) output = {} allowed_types = (tf.Tensor, bool, int, ModelOutput,\",\n \"attn_output = tf.reshape(attn_output, (bsz, tgt_len, embed_dim)) attn_output = self.out_proj(attn_output) attn_weights: tf.Tensor = tf.reshape(attn_weights,\",\n \"assuming that padded tokens are filled with -100 # when not being attended\",\n \"= tf.keras.regularizers.get(gamma_regularizer) self.beta_constraint = tf.keras.constraints.get(beta_constraint) self.gamma_constraint = tf.keras.constraints.get(gamma_constraint) self._check_axis() def build(self, input_shape): self._check_if_input_shape_is_none(input_shape)\",\n \"self.attention( hidden_states, attention_mask=attention_mask, training=training ) hidden_states = self.dropout(hidden_states, training=training) hidden_states = attn_residual +\",\n \">>> from datasets import load_dataset >>> import soundfile as sf >>> processor =\",\n \"# apply SpecAugment along time axis with given mask_time_indices hidden_states = tf.where( tf.cast(mask_time_indices[:,\",\n \"EXIST\\\" >>> # wrap processor as target processor to encode labels >>> with\",\n \"token_type_ids})` </Tip> Args: config ([`HubertConfig`]): Model configuration class with all the parameters of\",\n \">>> # wrap processor as target processor to encode labels >>> with processor.as_target_processor():\",\n \"the hidden states of all layers. See `hidden_states` under returned tensors for more\",\n \") elif isinstance(input_values, (dict, BatchEncoding)): if \\\"inputs\\\" in input_values: warnings.warn( \\\"The `inputs` argument\",\n \"mask_time_indices = kwargs.get(\\\"mask_time_indices\\\", None) if inputs[\\\"training\\\"]: hidden_states = self._mask_hidden_states(hidden_states, mask_time_indices=mask_time_indices) encoder_outputs = self.encoder(\",\n \"Optional[bool] = False, training: bool = False, ) -> Tuple[tf.Tensor]: attn_residual = hidden_states\",\n \"for i, input in enumerate(input_values): # EagerTensors don't allow to use the .name\",\n \"`args` in this case is always the first parameter, then `input_values` output[\\\"input_values\\\"] =\",\n \"`input_values` instead.\\\", FutureWarning, ) output[\\\"input_values\\\"] = input_values.pop(\\\"inputs\\\") if \\\"decoder_cached_states\\\" in input_values: warnings.warn( \\\"The\",\n \"masked**, - 0 indicates the head is **masked**. inputs_embeds (`np.ndarray` or `tf.Tensor` of\",\n \"batch size and 2nd is timesteps attention_mask: optional padding mask of the same\",\n \"= tf.reshape(spec_aug_mask_idxs, (batch_size, num_masked_spans * mask_length)) offsets = tf.range(mask_length)[tf.newaxis, tf.newaxis, :] offsets =\",\n \"= tf.transpose(kernel) def build(self, input_shape): if not self.built: input_shape = input_shape.as_list() # Conv1D\",\n \"the docstring: `model({\\\"input_values\\\": input_values, \\\"token_type_ids\\\": token_type_ids})` </Tip> Args: config ([`HubertConfig`]): Model configuration class\",\n \"+ self.feed_forward(self.final_layer_norm(hidden_states)) outputs = (hidden_states,) if output_attentions: outputs += (attn_weights,) return outputs #\",\n \"decoder key/value_states. Further calls to uni-directional self-attention # can concat previous decoder key/value_states\",\n \"MAN SAID TO THE UNIVERSE SIR I EXIST\\\" >>> # wrap processor as\",\n \"this model, you need a GPU or a TPU\\\" ) @tf.function def serving(self,\",\n \"def __init__( self, embed_dim: int, num_heads: int, dropout: float = 0.0, is_decoder: bool\",\n \"== -1: self.groups = dim def _check_size_of_dimensions(self, input_shape): dim = input_shape[self.axis] if dim\",\n \"You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 #\",\n \"{type(v)} is not allowed only {allowed_types} is accepted for {k}.\\\") if isinstance(input_values, (tuple,\",\n \"Wav2Vec2->Hubert class TFHubertLayerNormConvLayer(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, layer_id: int = 0, **kwargs: Any)\",\n \"spec_aug_mask_idxs + offsets # scatter indices to mask spec_aug_mask = _scatter_values_on_batch_indices( tf.ones_like(spec_aug_mask_idxs), spec_aug_mask_idxs,\",\n \"self.axis == 0: raise ValueError( \\\"You are trying to normalize your batch axis.\",\n \"used instead. output_hidden_states (`bool`, *optional*): Whether or not to return the hidden states\",\n \"= None, output_hidden_states: Optional[bool] = None, return_dict: Optional[bool] = None, training: bool =\",\n \"group_shape) return reshaped_inputs, group_shape else: return inputs, group_shape def _apply_normalization(self, reshaped_inputs, input_shape): group_shape\",\n \"\\\"\\\"\\\" signature = dict(inspect.signature(func).parameters) signature.pop(\\\"kwargs\\\", None) signature.pop(\\\"self\\\", None) parameter_names = list(signature.keys()) output =\",\n \"not None else output return TFCausalLMOutput( loss=loss, logits=logits, hidden_states=outputs.hidden_states, attentions=outputs.attentions, ) def serving_output(self,\",\n \"masked spans spec_aug_mask_idxs = tf.expand_dims(spec_aug_mask_idxs, -1) spec_aug_mask_idxs = tf.tile(spec_aug_mask_idxs, (1, 1, mask_length)) spec_aug_mask_idxs\",\n \"can then reuse all cross-attention # key/value_states (first \\\"if\\\" case) # if uni-directional\",\n \"tf.reshape(self.gamma, broadcast_shape) if self.center: beta = tf.reshape(self.beta, broadcast_shape) return gamma, beta def _check_if_input_shape_is_none(self,\",\n \"self.num_pad_remove > 0: hidden_states = hidden_states[:, : -self.num_pad_remove, :] return hidden_states class TFHubertFeatureEncoder(tf.keras.layers.Layer):\",\n \"_mask_hidden_states(self, hidden_states: tf.Tensor, mask_time_indices: Optional[tf.Tensor] = None): \\\"\\\"\\\" Masks extracted features along time\",\n \") def call( self, hidden_states: tf.Tensor, attention_mask: Optional[tf.Tensor] = None, output_attentions: Optional[bool] =\",\n \"more detail. This argument can be used only in eager mode, in graph\",\n \"None: # apply SpecAugment along time axis with given mask_time_indices hidden_states = tf.where(\",\n \"tf.reshape(value_states, proj_shape) src_len = shape_list(key_states)[1] attn_weights = tf.matmul(query_states, key_states, transpose_b=True) # The tf.debugging\",\n \"tf.keras.layers.Dropout(rate=config.feat_proj_dropout) def call(self, hidden_states: tf.Tensor, training: bool = False) -> tf.Tensor: hidden_states =\",\n \"to uni-directional self-attention # can concat previous decoder key/value_states to current projected key/value_states\",\n \"training. \\\"\\\"\\\" self.hubert.feature_extractor.trainable = False @add_start_docstrings_to_model_forward(HUBERT_INPUTS_DOCSTRING) @replace_return_docstrings(output_type=TFCausalLMOutput, config_class=_CONFIG_FOR_DOC) def call( self, input_values: tf.Tensor,\",\n \"mask should be of size {(bsz, 1, tgt_len, src_len)}, but is {shape_list(attention_mask)}\\\", )\",\n \"output_attentions: outputs += (attn_weights,) return outputs # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2EncoderLayerStableLayerNorm with Wav2Vec2->Hubert class\",\n \"\\\"to train/fine-tine this model, you need a GPU or a TPU\\\" ) @tf.function\",\n \"output_lengths = self._get_feat_extract_output_lengths(tf.reduce_sum(inputs[\\\"attention_mask\\\"], -1)) attention_mask = tf.sequence_mask( output_lengths, maxlen=shape_list(hidden_states)[1], dtype=hidden_states.dtype ) hidden_states =\",\n \"self.pos_conv_embed(hidden_states) hidden_states = hidden_states + position_embeddings hidden_states = self.dropout(hidden_states, training=training) for i, layer_module\",\n \"output) if loss is not None else output return TFCausalLMOutput( loss=loss, logits=logits, hidden_states=outputs.hidden_states,\",\n \"\\\"beta_initializer\\\": tf.keras.initializers.serialize(self.beta_initializer), \\\"gamma_initializer\\\": tf.keras.initializers.serialize(self.gamma_initializer), \\\"beta_regularizer\\\": tf.keras.regularizers.serialize(self.beta_regularizer), \\\"gamma_regularizer\\\": tf.keras.regularizers.serialize(self.gamma_regularizer), \\\"beta_constraint\\\": tf.keras.constraints.serialize(self.beta_constraint), \\\"gamma_constraint\\\": tf.keras.constraints.serialize(self.gamma_constraint), }\",\n \"blank_index=self.config.pad_token_id, logits_time_major=False, ) if self.config.ctc_loss_reduction == \\\"sum\\\": loss = tf.reduce_sum(loss) if self.config.ctc_loss_reduction ==\",\n \"the layer received an input with shape \\\" + str(input_shape) + \\\".\\\" )\",\n \"TFHubertSamePadLayer(tf.keras.layers.Layer): def __init__(self, num_conv_pos_embeddings, **kwargs): super().__init__(**kwargs) self.num_pad_remove = 1 if num_conv_pos_embeddings % 2\",\n \"tf.nn.top_k(distribution + z, num_samples) return indices # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2._scatter_values_on_batch_indices def _scatter_values_on_batch_indices(values, batch_indices,\",\n \"# you may not use this file except in compliance with the License.\",\n \"first element is batch size and 2nd is timesteps attention_mask: optional padding mask\",\n \"None else src_len one_cst = tf.constant(1.0) mask = tf.cast(mask, dtype=one_cst.dtype) expanded_mask = tf.tile(mask[:,\",\n \"call( self, hidden_states: tf.Tensor, key_value_states: Optional[tf.Tensor] = None, past_key_value: Optional[Tuple[Tuple[tf.Tensor]]] = None, attention_mask:\",\n \"= config self.feature_extractor = TFHubertFeatureEncoder(config, name=\\\"feature_extractor\\\") self.feature_projection = TFHubertFeatureProjection(config, name=\\\"feature_projection\\\") if config.do_stable_layer_norm: self.encoder\",\n \"positional argument : - a single Tensor with `input_values` only and nothing else:\",\n \"= _sample_without_replacement(uniform_dist, num_masked_spans) # expand masked indices to masked spans spec_aug_mask_idxs = tf.expand_dims(spec_aug_mask_idxs,\",\n \"min_masks) # make sure num masked indices <= sequence_length if num_masked_spans * mask_length\",\n \"be masked. this will be multiplied by number of timesteps divided by length\",\n \"else: return inputs, group_shape def _apply_normalization(self, reshaped_inputs, input_shape): group_shape = tf.keras.backend.int_shape(reshaped_inputs) group_reduction_axes =\",\n \"trainable=True, ) self.bias = self.add_weight(name=\\\"bias\\\", shape=(self.filters,), initializer=\\\"zeros\\\", trainable=True) def call(self, inputs): if not\",\n \"= self.conv(hidden_states) hidden_states = self.activation(hidden_states) return hidden_states # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2LayerNormConvLayer with Wav2Vec2->Hubert\",\n \"TFHubertFeatureEncoder(config, name=\\\"feature_extractor\\\") self.feature_projection = TFHubertFeatureProjection(config, name=\\\"feature_projection\\\") if config.do_stable_layer_norm: self.encoder = TFHubertEncoderStableLayerNorm(config, name=\\\"encoder\\\") else:\",\n \"first positional arguments. This second option is useful when using [`tf.keras.Model.fit`] method which\",\n \"deprecated and will be removed in a future version, use `input_values` instead.\\\", FutureWarning,\",\n \"Conv1D output shapes are checked at build time since TF 2.7, so we\",\n \"= None, past_key_values_length: int = 0): \\\"\\\"\\\" Expands attention_mask from `[bsz, seq_len]` to\",\n \"output_hidden_states: Optional[bool] = False, return_dict: Optional[bool] = True, training: Optional[bool] = False, )\",\n \"= num_heads self.dropout = tf.keras.layers.Dropout(dropout) self.head_dim = embed_dim // num_heads if (self.head_dim *\",\n \"License for the specific language governing permissions and # limitations under the License.\",\n \"processor = Wav2Vec2Processor.from_pretrained(\\\"facebook/hubert-base-960h\\\") >>> model = TFHubertForCTC.from_pretrained(\\\"facebook/hubert-base-960h\\\") >>> def map_to_array(batch): ... speech, _\",\n \"+ str(input_shape) + \\\".\\\" ) def _set_number_of_groups_for_instance_norm(self, input_shape): dim = input_shape[self.axis] if self.groups\",\n \"self.explicit_padding * 2 super().build(input_shape) self.kernel = tf.Variable(tf.transpose(self.kernel), name=\\\"weight_v\\\", trainable=True) self.weight_v = self.kernel self.weight_g\",\n \"evaluation). \\\"\\\"\\\" @add_start_docstrings( \\\"The bare TFHubert Model transformer outputing raw hidden-states without any\",\n \"= (bsz * self.num_heads, -1, self.head_dim) query_states = tf.reshape(self._shape(query_states, tgt_len, bsz), proj_shape) key_states\",\n \"embeddings, pruning heads etc.) This model is also a [tf.keras.Model](https://www.tensorflow.org/api_docs/python/tf/keras/Model) subclass. Use it\",\n \"Transformers v5. \\\" f\\\"Use `{self.__class__.__bases__[0].__name__}` instead.\\\", FutureWarning, ) class TFHubertFeatureProjection(tf.keras.layers.Layer): def __init__(self, config:\",\n \"**kwargs): \\\"\\\"\\\" Process the input of each TensorFlow model including the booleans. In\",\n \"self.config = config self.feature_extractor = TFHubertFeatureEncoder(config, name=\\\"feature_extractor\\\") self.feature_projection = TFHubertFeatureProjection(config, name=\\\"feature_projection\\\") if config.do_stable_layer_norm:\",\n \"output[name] = kwargs.pop(name, signature[name].default) # When creating a SavedModel TF calls the method\",\n \"respect the proper output we have to add this exception if \\\"args\\\" in\",\n \"```python >>> from transformers import Wav2Vec2Processor, TFHubertModel >>> from datasets import load_dataset >>>\",\n \"] LARGE_NEGATIVE = -1e8 # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.input_values_processing def input_values_processing(func, config, input_values, **kwargs):\",\n \"{parameter_names} and will be ignored.\\\" ) continue else: raise ValueError(f\\\"Data of type {type(v)}\",\n \"-1, bsz) key_states = tf.concat([past_key_value[0], key_states], axis=2) value_states = tf.concat([past_key_value[1], value_states], axis=2) else:\",\n \"dim = input_shape[self.axis] if dim < self.groups: raise ValueError( \\\"Number of groups (\\\"\",\n \"0.0 input_values = tf.convert_to_tensor(np.random.rand(1, 16000), tf.float32) dummy_inputs = { \\\"input_values\\\": input_values, \\\"attention_mask\\\": tf.cast(tf.not_equal(input_values,\",\n \"case) # if encoder bi-directional self-attention `past_key_value` is always `None` past_key_value = (key_states,\",\n \"as inputs: - having all inputs as keyword arguments (like PyTorch models), or\",\n \"= input_shape[self.axis] shape = (dim,) if self.center: self.beta = self.add_weight( shape=shape, name=\\\"beta\\\", initializer=self.beta_initializer,\",\n \"attentions=all_self_attentions, ) @keras_serializable class TFHubertMainLayer(tf.keras.layers.Layer): config_class = HubertConfig def __init__(self, config: HubertConfig, **kwargs):\",\n \"= super().call(padded_inputs) return output # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2NoLayerNormConvLayer with Wav2Vec2->Hubert class TFHubertNoLayerNormConvLayer(tf.keras.layers.Layer): def\",\n \"for k, v in kwargs.items(): if isinstance(v, allowed_types) or v is None: output[k]\",\n \"is None: output[parameter_names[i]] = input else: raise ValueError( f\\\"Data of type {type(input)} is\",\n \"does not belongs to the parameter list {parameter_names} and will be ignored.\\\" )\",\n \"deprecated and will be removed in a future version, use `past_key_values` instead.\\\", FutureWarning,\",\n \"super().__init__(**kwargs) self.config = config self.feature_extractor = TFHubertFeatureEncoder(config, name=\\\"feature_extractor\\\") self.feature_projection = TFHubertFeatureProjection(config, name=\\\"feature_projection\\\") if\",\n \"transcription = processor.decode(predicted_ids[0]) >>> # compute loss >>> target_transcription = \\\"A MAN SAID\",\n \"embed_dim: int, num_heads: int, dropout: float = 0.0, is_decoder: bool = False, bias:\",\n \"(1, -1, 1, 1)) * tf.reshape( attn_weights, (bsz, self.num_heads, tgt_len, src_len) ) attn_weights\",\n \"of varying length with one or several input Tensors IN THE ORDER given\",\n \"processor(ds[\\\"speech\\\"][0], return_tensors=\\\"tf\\\").input_values # Batch size 1 >>> hidden_states = model(input_values).last_hidden_state ```\\\"\\\"\\\" inputs =\",\n \"tf.keras.initializers.serialize(self.gamma_initializer), \\\"beta_regularizer\\\": tf.keras.regularizers.serialize(self.beta_regularizer), \\\"gamma_regularizer\\\": tf.keras.regularizers.serialize(self.gamma_regularizer), \\\"beta_constraint\\\": tf.keras.constraints.serialize(self.beta_constraint), \\\"gamma_constraint\\\": tf.keras.constraints.serialize(self.gamma_constraint), } base_config = super().get_config()\",\n \"parameter, then `input_values` output[\\\"input_values\\\"] = output[\\\"args\\\"] del output[\\\"args\\\"] if \\\"kwargs\\\" in output: del\",\n \"TF 2.0 documentation for all matter related to general usage and behavior. <Tip>\",\n \"if output_attentions else None if attention_mask is not None: hidden_states = hidden_states *\",\n \"k, v in kwargs.items(): if isinstance(v, allowed_types) or v is None: output[k] =\",\n \"tf.nn.softmax(attn_weights, axis=-1) if layer_head_mask is not None: # The tf.debugging asserts are not\",\n \"self.activation(hidden_states) return hidden_states # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2PositionalConvEmbedding with Wav2Vec2->Hubert class TFHubertPositionalConvEmbedding(tf.keras.layers.Layer): def __init__(self,\",\n \"Model transformer outputing raw hidden-states without any specific head on top.\\\", HUBERT_START_DOCSTRING, )\",\n \"return gamma, beta def _check_if_input_shape_is_none(self, input_shape): dim = input_shape[self.axis] if dim is None:\",\n \"docstring) Tokens with indices set to `-100` are ignored (masked), the loss is\",\n \"tf.keras.layers.Dense(embed_dim, use_bias=bias, name=\\\"q_proj\\\") self.v_proj = tf.keras.layers.Dense(embed_dim, use_bias=bias, name=\\\"v_proj\\\") self.out_proj = tf.keras.layers.Dense(embed_dim, use_bias=bias, name=\\\"out_proj\\\")\",\n \"mask_length=self.config.mask_feature_length, ) hidden_states = tf.where(mask_feature_indices[:, tf.newaxis, :], hidden_states, 0) return hidden_states def call(\",\n \"def __init__( self, groups: int = 32, axis: int = -1, epsilon: float\",\n \"is not None else output return TFCausalLMOutput( loss=loss, logits=logits, hidden_states=outputs.hidden_states, attentions=outputs.attentions, ) def\",\n \"\\\"decoder_cached_states\\\" in input_values: warnings.warn( \\\"The `decoder_cached_states` argument is deprecated and will be removed\",\n \"= Wav2Vec2Processor.from_pretrained(\\\"facebook/hubert-base-960h\\\") >>> model = TFHubertModel.from_pretrained(\\\"facebook/hubert-base-960h\\\") >>> def map_to_array(batch): ... speech, _ =\",\n \"= np.random.uniform(0, 1) if training and (dropout_probability < self.config.layerdrop): # skip the layer\",\n \"import ( ModelOutput, add_start_docstrings, add_start_docstrings_to_model_forward, logging, replace_return_docstrings, ) from .configuration_hubert import HubertConfig logger\",\n \"is accepted for {k}.\\\") if isinstance(input_values, (tuple, list)): for i, input in enumerate(input_values):\",\n \"positional arguments. This second option is useful when using [`tf.keras.Model.fit`] method which currently\",\n \"conv_layers = [TFHubertGroupNormConvLayer(config, layer_id=0, name=f\\\"conv_layers.{0}\\\")] + [ TFHubertNoLayerNormConvLayer(config, layer_id=i + 1, name=f\\\"conv_layers.{i+1}\\\") for\",\n \"# Copyright 2021 The Fairseq Authors and the HuggingFace Inc. team. All rights\",\n \"spec_aug_mask_idxs = _sample_without_replacement(uniform_dist, num_masked_spans) # expand masked indices to masked spans spec_aug_mask_idxs =\",\n \"= model(input_values).logits >>> predicted_ids = tf.argmax(logits, axis=-1) >>> transcription = processor.decode(predicted_ids[0]) >>> #\",\n \"See all Hubert models at https://huggingface.co/models?filter=hubert ] LARGE_NEGATIVE = -1e8 # Copied from\",\n \"be <= vocab_size: {self.config.vocab_size}\\\") attention_mask = ( inputs[\\\"attention_mask\\\"] if inputs[\\\"attention_mask\\\"] is not None\",\n \"size {(bsz * self.num_heads, tgt_len, src_len)}, but is {shape_list(attn_weights)}\\\", ) if attention_mask is\",\n \"// self.groups) == 1 if not is_instance_norm: axis = -2 if self.axis ==\",\n \"Copied from transformers.models.bart.modeling_tf_bart.TFBartAttention with TFBart->TFHubert class TFHubertAttention(tf.keras.layers.Layer): \\\"\\\"\\\"Multi-headed attention from \\\"Attention Is All\",\n \"super().__init__( filters=filters, kernel_size=kernel_size, groups=groups, padding=\\\"valid\\\", use_bias=True, bias_initializer=\\\"he_normal\\\", **kwargs, ) self.explicit_padding = explicit_padding self.filter_axis\",\n \"vector.\\\"\\\"\\\" kernel_norm = tf.sqrt(tf.reduce_sum(tf.square(self.weight_v), axis=self.kernel_norm_axes)) self.weight_g.assign(kernel_norm[:, tf.newaxis, tf.newaxis]) def _normalize_kernel(self): \\\"\\\"\\\"Generate normalized weights.\\\"\\\"\\\"\",\n \"False @add_start_docstrings_to_model_forward(HUBERT_INPUTS_DOCSTRING) @replace_return_docstrings(output_type=TFCausalLMOutput, config_class=_CONFIG_FOR_DOC) def call( self, input_values: tf.Tensor, attention_mask: Optional[tf.Tensor] = None,\",\n \"saving, resizing the input embeddings, pruning heads etc.) This model is also a\",\n \"labels is not None: if tf.reduce_max(labels) >= self.config.vocab_size: raise ValueError(f\\\"Label values must be\",\n \"= { \\\"groups\\\": self.groups, \\\"axis\\\": self.axis, \\\"epsilon\\\": self.epsilon, \\\"center\\\": self.center, \\\"scale\\\": self.scale, \\\"beta_initializer\\\":\",\n \"of the same size as shape, which will prevent masking padded elements mask_prob:\",\n \"group_reduction_axes.pop(axis) mean, variance = tf.nn.moments(reshaped_inputs, group_reduction_axes, keepdims=True) gamma, beta = self._get_reshaped_weights(input_shape) normalized_inputs =\",\n \"are token type IDs?](../glossary#token-type-ids) position_ids (`np.ndarray` or `tf.Tensor` of shape `({0})`, *optional*): Indices\",\n \"* LARGE_NEGATIVE # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2GroupNorm with Wav2Vec2->Hubert class TFHubertGroupNorm(tf.keras.layers.Layer): \\\"\\\"\\\" From tensorflow-addons\",\n \"(\\\" + str(dim) + \\\").\\\" ) def _check_axis(self): if self.axis == 0: raise\",\n \"(one_cst - expanded_mask) * LARGE_NEGATIVE # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2GroupNorm with Wav2Vec2->Hubert class TFHubertGroupNorm(tf.keras.layers.Layer):\",\n \"sf >>> processor = Wav2Vec2Processor.from_pretrained(\\\"facebook/hubert-base-960h\\\") >>> model = TFHubertModel.from_pretrained(\\\"facebook/hubert-base-960h\\\") >>> def map_to_array(batch): ...\",\n \"associated vectors than the model's internal embedding lookup matrix. output_attentions (`bool`, *optional*): Whether\",\n \"Optional[bool] = None, labels: Optional[tf.Tensor] = None, output_hidden_states: Optional[bool] = None, return_dict: Optional[bool]\",\n \"{sequence_length}`\\\" ) # compute number of masked spans in batch num_masked_spans = int(mask_prob\",\n \"self.head_dim], message=f\\\"`attn_output` should be of size {(bsz, self.num_heads, tgt_len, self.head_dim)}, but is {shape_list(attn_output)}\\\",\",\n \"+ 1 for kernel_size, stride in zip(self.config.conv_kernel, self.config.conv_stride): input_lengths = _conv_out_length(input_lengths, kernel_size, stride)\",\n \"self.dropout = tf.keras.layers.Dropout(config.final_dropout) self.lm_head = tf.keras.layers.Dense(config.vocab_size, name=\\\"lm_head\\\") def freeze_feature_extractor(self): \\\"\\\"\\\" Calling this function\",\n \"= (input_shape[self.axis] // self.groups) == 1 if not is_instance_norm: outputs = tf.reshape(normalized_inputs, tensor_input_shape)\",\n \"of the model. Initializing with a config file does not load the weights\",\n \"inputs): input_shape = tf.keras.backend.int_shape(inputs) tensor_input_shape = tf.shape(inputs) reshaped_inputs, group_shape = self._reshape_into_groups(inputs, input_shape, tensor_input_shape)\",\n \"distribution to sample from, make sure that offset samples are < sequence_length uniform_dist\",\n \"bool = False, ) -> Tuple[tf.Tensor]: attn_residual = hidden_states hidden_states, attn_weights, _ =\",\n \"v5.\\\" \\\"Please use the equivalent `freeze_feature_encoder` method instead.\\\", FutureWarning, ) self.freeze_feature_encoder() def freeze_feature_encoder(self):\",\n \"else self.config.output_hidden_states ) inputs[\\\"output_attentions\\\"] = ( inputs[\\\"output_attentions\\\"] if inputs[\\\"output_attentions\\\"] else self.config.output_attentions ) inputs[\\\"return_dict\\\"]\",\n \"group_shape.insert(self.axis, self.groups) group_shape = tf.stack(group_shape) reshaped_inputs = tf.reshape(inputs, group_shape) return reshaped_inputs, group_shape else:\",\n \"hidden_states = self.layer_norm(hidden_states) hidden_states = hidden_states + self.feed_forward(hidden_states) hidden_states = self.final_layer_norm(hidden_states) outputs =\",\n \") @tf.function def serving(self, inputs): output = self.call(input_values=inputs, training=False) return self.serving_output(output) HUBERT_START_DOCSTRING =\",\n \"Args: config ([`HubertConfig`]): Model configuration class with all the parameters of the model.\",\n \"with Wav2Vec2->Hubert class TFHubertGroupNormConvLayer(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, layer_id: int = 0, **kwargs:\",\n \"is only computed for the tokens with labels in `[0, ..., config.vocab_size]` Returns:\",\n \"all cross-attention # key/value_states (first \\\"if\\\" case) # if uni-directional self-attention (decoder) save\",\n \"the gradient computation for the feature encoder so that its parameters will not\",\n \"shape_list from ...tokenization_utils_base import BatchEncoding from ...utils import ( ModelOutput, add_start_docstrings, add_start_docstrings_to_model_forward, logging,\",\n \"z, num_samples) return indices # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2._scatter_values_on_batch_indices def _scatter_values_on_batch_indices(values, batch_indices, output_shape): \\\"\\\"\\\"\",\n \"head is **masked**. inputs_embeds (`np.ndarray` or `tf.Tensor` of shape `({0}, hidden_size)`, *optional*): Optionally,\",\n \"inspect import warnings from typing import Any, Dict, Optional, Tuple, Union import numpy\",\n \"allowed_types) or v is None: output[k] = v elif k not in parameter_names\",\n \"= tf.reshape(inputs, group_shape) return reshaped_inputs, group_shape else: return inputs, group_shape def _apply_normalization(self, reshaped_inputs,\",\n \"k: v for k, v in output.items() if k in [\\\"return_dict\\\", \\\"output_attentions\\\", \\\"output_hidden_states\\\",\",\n \"def __init__(self, config: HubertConfig, **kwargs): super().__init__(**kwargs) self.attention = TFHubertAttention( embed_dim=config.hidden_size, num_heads=config.num_attention_heads, dropout=config.attention_dropout, is_decoder=False,\",\n \"model, only the configuration. Check out the [`~PreTrainedModel.from_pretrained`] method to load the model\",\n \"\\\"\\\"\\\" Process the input of each TensorFlow model including the booleans. In case\",\n \"length with one or several input Tensors IN THE ORDER given in the\",\n \"Optional[tf.Tensor] = None, output_attentions: Optional[bool] = False, output_hidden_states: Optional[bool] = False, return_dict: Optional[bool]\",\n \"self.conv_layers: hidden_states = conv_layer(hidden_states) return hidden_states class TFHubertFeatureExtractor(TFHubertFeatureEncoder): def __init__(self, config, **kwargs): super().__init__(config,\",\n \"proj query_states = self.q_proj(hidden_states) * self.scaling # get key, value proj if is_cross_attention\",\n \"to `[bsz, 1, tgt_seq_len, src_seq_len]`. \\\"\\\"\\\" src_len = shape_list(mask)[1] tgt_len = tgt_len if\",\n \"self_attention key_states = self._shape(self.k_proj(hidden_states), -1, bsz) value_states = self._shape(self.v_proj(hidden_states), -1, bsz) if self.is_decoder:\",\n \"parameter_names = list(signature.keys()) output = {} allowed_types = (tf.Tensor, bool, int, ModelOutput, tuple,\",\n \"be in `[-100, 0, ..., config.vocab_size]` (see `input_values` docstring) Tokens with indices set\",\n \"_get_feat_extract_output_lengths(self, input_lengths: tf.Tensor): \\\"\\\"\\\" Computes the output length of the convolutional layers \\\"\\\"\\\"\",\n \"input_lengths = self.hubert._get_feat_extract_output_lengths(tf.reduce_sum(attention_mask, axis=-1)) # assuming that padded tokens are filled with -100\",\n \"__init__( self, groups: int = 32, axis: int = -1, epsilon: float =\",\n \"indices to masked spans spec_aug_mask_idxs = tf.expand_dims(spec_aug_mask_idxs, -1) spec_aug_mask_idxs = tf.tile(spec_aug_mask_idxs, (1, 1,\",\n \"tgt_len, src_len)) attn_weights = tf.nn.softmax(attn_weights, axis=-1) if layer_head_mask is not None: # The\",\n \"= hidden_states hidden_states, attn_weights, _ = self.attention( hidden_states, attention_mask=attention_mask, training=training ) hidden_states =\",\n \"= self.feature_projection(hidden_states, training=inputs[\\\"training\\\"]) mask_time_indices = kwargs.get(\\\"mask_time_indices\\\", None) if inputs[\\\"training\\\"]: hidden_states = self._mask_hidden_states(hidden_states, mask_time_indices=mask_time_indices)\",\n \"random indices to mask spec_aug_mask_idxs = _sample_without_replacement(uniform_dist, num_masked_spans) # expand masked indices to\",\n \"group_shape = tf.keras.backend.int_shape(reshaped_inputs) group_reduction_axes = list(range(1, len(group_shape))) is_instance_norm = (input_shape[self.axis] // self.groups) ==\",\n \"= self.activation(hidden_states) return hidden_states # Copied from transformers.models.wav2vec2.modeling_tf_wav2vec2.TFWav2Vec2SamePadLayer with Wav2Vec2->Hubert class TFHubertSamePadLayer(tf.keras.layers.Layer): def\",\n \"ValueError( f\\\"`config.feat_extract_norm` is {config.feat_extract_norm}, but has to be one of ['group', 'layer']\\\" )\",\n \"the input embeddings, pruning heads etc.) This model is also a [tf.keras.Model](https://www.tensorflow.org/api_docs/python/tf/keras/Model) subclass.\",\n \"regularizer=self.gamma_regularizer, constraint=self.gamma_constraint, ) else: self.gamma = None def _add_beta_weight(self, input_shape): dim = input_shape[self.axis]\",\n \"// self.groups group_shape.insert(self.axis, self.groups) group_shape = tf.stack(group_shape) reshaped_inputs = tf.reshape(inputs, group_shape) return reshaped_inputs,\",\n \"model(input_values).last_hidden_state ```\\\"\\\"\\\" inputs = input_values_processing( func=self.call, config=self.config, input_values=input_values, attention_mask=attention_mask, token_type_ids=token_type_ids, position_ids=position_ids, head_mask=head_mask, inputs_embeds=inputs_embeds,\",\n \"shape Args: shape: the the shape for which to compute masks. should be\",\n \"be of size {(bsz, self.num_heads, tgt_len, self.head_dim)}, but is {shape_list(attn_output)}\\\", ) attn_output =\",\n \"float = 0.0, is_decoder: bool = False, bias: bool = True, **kwargs, ):\",\n \"(`np.ndarray` or `tf.Tensor` of shape `({0})`, *optional*): Segment token indices to indicate first\",\n \"loss = model(input_values, labels=labels).loss ```\\\"\\\"\\\" inputs = input_values_processing( func=self.call, config=self.config, input_values=input_values, attention_mask=attention_mask, token_type_ids=token_type_ids,\",\n \"is None: output[k] = v else: raise ValueError(f\\\"Data of type {type(v)} is not\",\n \"in eager mode, in graph mode the value will always be set to\",\n \"NOT supported on CPU. If you wish \\\" \\\"to train/fine-tine this model, you\",\n \"indices set to `-100` are ignored (masked), the loss is only computed for\",\n \"-1, bsz) if self.is_decoder: # if cross_attention save Tuple(tf.Tensor, tf.Tensor) of all cross\",\n \"parameters of the model. Initializing with a config file does not load the\",\n \"output: del output[\\\"kwargs\\\"] boolean_dict = { k: v for k, v in output.items()\",\n \"**kwargs): super().__init__(**kwargs) self.config = config self.feature_extractor = TFHubertFeatureEncoder(config, name=\\\"feature_extractor\\\") self.feature_projection = TFHubertFeatureProjection(config, name=\\\"feature_projection\\\")\",\n \"[What are position IDs?](../glossary#position-ids) head_mask (`np.ndarray` or `tf.Tensor` of shape `(num_heads,)` or `(num_layers,\",\n \"with LayerCall.__call__(args, **kwargs) # So to respect the proper output we have to\",\n \"on padding token indices. Mask values selected in `[0, 1]`: - 1 for\",\n \"with Wav2Vec2->Hubert class TFHubertPositionalConvEmbedding(tf.keras.layers.Layer): def __init__(self, config: HubertConfig, **kwargs: Any) -> None: super().__init__(**kwargs)\",\n \"call(self, hidden_states: tf.Tensor, training: bool = False) -> tf.Tensor: hidden_states = self.layer_norm(hidden_states) hidden_states\",\n \"implements for all its model (such as downloading or saving, resizing the input\",\n \"self.initialized = True self._normalize_kernel() padded_inputs = tf.pad(inputs, ((0, 0), (self.explicit_padding, self.explicit_padding), (0, 0)))\",\n \"has backpropagation operations that are NOT supported on CPU. If you wish \\\"\",\n \"* self.num_heads, tgt_len, self.head_dim], message=f\\\"`attn_output` should be of size {(bsz, self.num_heads, tgt_len, self.head_dim)},\",\n \"None: hidden_states = hidden_states * tf.expand_dims(attention_mask, -1) attention_mask = _expand_mask(attention_mask) else: attention_mask =\",\n \"tf.transpose( tf.reshape(attn_output, (bsz, self.num_heads, tgt_len, self.head_dim)), (0, 2, 1, 3) ) attn_output =\",\n \"tf.float32) dummy_inputs = { \\\"input_values\\\": input_values, \\\"attention_mask\\\": tf.cast(tf.not_equal(input_values, pad_token), tf.float32), } return dummy_inputs\",\n \"(dict, BatchEncoding)): if \\\"inputs\\\" in input_values: warnings.warn( \\\"The `inputs` argument is deprecated and\",\n \"in the config will be used instead. return_dict (`bool`, *optional*): Whether or not\",\n \"== \\\"sum\\\": loss = tf.reduce_sum(loss) if self.config.ctc_loss_reduction == \\\"mean\\\": loss = tf.reduce_mean(loss) else:\",\n \"self.scaling # get key, value proj if is_cross_attention and past_key_value is not None:\",\n \"output[k] = v elif k not in parameter_names and \\\"args\\\" not in parameter_names:\",\n \"this layer is used as a cross-attention layer # for the decoder is_cross_attention\",\n \"or `(num_layers, num_heads)`, *optional*): Mask to nullify selected heads of the self-attention modules.\",\n \"method instead.\\\", FutureWarning, ) self.freeze_feature_encoder() def freeze_feature_encoder(self): \\\"\\\"\\\" Calling this function will disable\",\n \"or `Dict[str, np.ndarray]` and each example must have the shape `({0})`): Indices of\",\n \"self._apply_normalization(reshaped_inputs, input_shape) is_instance_norm = (input_shape[self.axis] // self.groups) == 1 if not is_instance_norm: outputs\"\n]","isConversational":false}}},{"rowIdx":2395,"cells":{"ngram":{"kind":"list like","value":["random.choice(wordlist) # end of helper code # ----------------------------------- # load the list of","valid words. Words are strings of lowercase letters. Depending on the size of","anywhere in the program wordlist = load_words() def partial_word(secret_word, guessed_letters): \"\"\" Return the","' + str(len(secret_word)) + ' letters long.' num_guesses = 8 word_guessed = False","how to use the functions import random import string WORDLIST_FILENAME = \"words.txt\" def","word has yet been correctly guessed. while num_guesses > 0 and not word_guessed:","code # ----------------------------------- # load the list of words into the wordlist variable","in secret_word: if letter in guessed_letters: result = result + letter else: result","Hangman # Name : Solutions # Collaborators : <your collaborators> # Time spent","# Helper code # You don't need to understand this helper code, #","respond to the # user based on whether the word has yet been","\"words loaded.\" return wordlist def choose_word(wordlist): \"\"\" wordlist (list): list of words (strings)","'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q',","been guessed. \"\"\" result = '' for letter in secret_word: if letter in","partial_word(secret_word, guessed_letters) if secret_word == partial_word(secret_word, guessed_letters): word_guessed = True if word_guessed: print","Problem Set 2 # # Hangman # Name : Solutions # Collaborators :","def hangman(): \"\"\" Runs the hangman game. \"\"\" print 'Welcome to the game,","and respond to the # user based on whether the word has yet","wordlist = string.split(line) print \" \", len(wordlist), \"words loaded.\" return wordlist def choose_word(wordlist):","open(WORDLIST_FILENAME, 'r', 0) # line: string line = inFile.readline() # wordlist: list of","guessed_letters: result = result + letter else: result = result + '_' return","yet been correctly guessed. while num_guesses > 0 and not word_guessed: print '-------------'","user-visible format, with underscores used to replace characters that have not yet been","so that it can be accessed from anywhere in the program wordlist =","print 'I am thinking of a word that is ' + str(len(secret_word)) +","available_letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k',","# load the list of words into the wordlist variable # so that","words. Words are strings of lowercase letters. Depending on the size of the","Letter-guessing loop. Ask the user to guess a letter and respond to the","+ ''.join(available_letters) guess = raw_input('Please guess a letter:') if guess not in available_letters:","word list, this function may take a while to finish. \"\"\" print \"Loading","load_words(): \"\"\" Returns a list of valid words. Words are strings of lowercase","print 'You have ' + str(num_guesses) + ' guesses left.' print 'Available letters:","use the functions import random import string WORDLIST_FILENAME = \"words.txt\" def load_words(): \"\"\"","string.split(line) print \" \", len(wordlist), \"words loaded.\" return wordlist def choose_word(wordlist): \"\"\" wordlist","if guess not in available_letters: print 'Oops! You\\'ve already guessed that letter: '","num_guesses -= 1 available_letters.remove(guess) print 'Oops! That letter is not in my word:","letters long.' num_guesses = 8 word_guessed = False guessed_letters = '' available_letters =","inFile.readline() # wordlist: list of strings wordlist = string.split(line) print \" \", len(wordlist),","game. \"\"\" print 'Welcome to the game, Hangman!' secret_word = choose_word(wordlist) print 'I","game, Hangman!' secret_word = choose_word(wordlist) print 'I am thinking of a word that","\"\"\" wordlist (list): list of words (strings) Returns a word from wordlist at","to understand this helper code, # but you will have to know how","# end of helper code # ----------------------------------- # load the list of words","of words (strings) Returns a word from wordlist at random \"\"\" return random.choice(wordlist)","result + '_' return result def hangman(): \"\"\" Runs the hangman game. \"\"\"","already guessed that letter: ' + partial_word(secret_word, guessed_letters) elif guess not in secret_word:","the word list, this function may take a while to finish. \"\"\" print","= inFile.readline() # wordlist: list of strings wordlist = string.split(line) print \" \",","are strings of lowercase letters. Depending on the size of the word list,","the functions import random import string WORDLIST_FILENAME = \"words.txt\" def load_words(): \"\"\" Returns","random import string WORDLIST_FILENAME = \"words.txt\" def load_words(): \"\"\" Returns a list of","'x', 'y', 'z'] # Letter-guessing loop. Ask the user to guess a letter","available_letters.remove(guess) guessed_letters += guess print 'Good guess: ' + partial_word(secret_word, guessed_letters) if secret_word","of the word list, this function may take a while to finish. \"\"\"","replace characters that have not yet been guessed. \"\"\" result = '' for","= '' for letter in secret_word: if letter in guessed_letters: result = result","'m', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y',","have not yet been guessed. \"\"\" result = '' for letter in secret_word:","'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'] #","# but you will have to know how to use the functions import","else: result = result + '_' return result def hangman(): \"\"\" Runs the","hangman(): \"\"\" Runs the hangman game. \"\"\" print 'Welcome to the game, Hangman!'","file...\" # inFile: file inFile = open(WORDLIST_FILENAME, 'r', 0) # line: string line","2 # # Hangman # Name : Solutions # Collaborators : <your collaborators>","str(len(secret_word)) + ' letters long.' num_guesses = 8 word_guessed = False guessed_letters =","may take a while to finish. \"\"\" print \"Loading word list from file...\"","<your collaborators> # Time spent : <total time> # ----------------------------------- # Helper code","list of words (strings) Returns a word from wordlist at random \"\"\" return","print 'Welcome to the game, Hangman!' secret_word = choose_word(wordlist) print 'I am thinking","<total time> # ----------------------------------- # Helper code # You don't need to understand","print 'Good guess: ' + partial_word(secret_word, guessed_letters) if secret_word == partial_word(secret_word, guessed_letters): word_guessed","= string.split(line) print \" \", len(wordlist), \"words loaded.\" return wordlist def choose_word(wordlist): \"\"\"","That letter is not in my word: ' + partial_word(secret_word, guessed_letters) else: available_letters.remove(guess)","string WORDLIST_FILENAME = \"words.txt\" def load_words(): \"\"\" Returns a list of valid words.","+ str(num_guesses) + ' guesses left.' print 'Available letters: ' + ''.join(available_letters) guess","word: ' + partial_word(secret_word, guessed_letters) else: available_letters.remove(guess) guessed_letters += guess print 'Good guess:","a list of valid words. Words are strings of lowercase letters. Depending on","long.' num_guesses = 8 word_guessed = False guessed_letters = '' available_letters = ['a',","Solutions # Collaborators : <your collaborators> # Time spent : <total time> #","guess not in secret_word: num_guesses -= 1 available_letters.remove(guess) print 'Oops! That letter is","time> # ----------------------------------- # Helper code # You don't need to understand this","the wordlist variable # so that it can be accessed from anywhere in","a word from wordlist at random \"\"\" return random.choice(wordlist) # end of helper","a while to finish. \"\"\" print \"Loading word list from file...\" # inFile:","+ ' guesses left.' print 'Available letters: ' + ''.join(available_letters) guess = raw_input('Please","guess a letter:') if guess not in available_letters: print 'Oops! You\\'ve already guessed","been correctly guessed. while num_guesses > 0 and not word_guessed: print '-------------' print","left.' print 'Available letters: ' + ''.join(available_letters) guess = raw_input('Please guess a letter:')","Name : Solutions # Collaborators : <your collaborators> # Time spent : <total","= result + letter else: result = result + '_' return result def","thinking of a word that is ' + str(len(secret_word)) + ' letters long.'","loop. Ask the user to guess a letter and respond to the #","letters. Depending on the size of the word list, this function may take","available_letters: print 'Oops! You\\'ve already guessed that letter: ' + partial_word(secret_word, guessed_letters) elif","that it can be accessed from anywhere in the program wordlist = load_words()","guess: ' + partial_word(secret_word, guessed_letters) if secret_word == partial_word(secret_word, guessed_letters): word_guessed = True","partial_word(secret_word, guessed_letters): \"\"\" Return the secret_word in user-visible format, with underscores used to","this helper code, # but you will have to know how to use","from file...\" # inFile: file inFile = open(WORDLIST_FILENAME, 'r', 0) # line: string","strings wordlist = string.split(line) print \" \", len(wordlist), \"words loaded.\" return wordlist def","'Oops! You\\'ve already guessed that letter: ' + partial_word(secret_word, guessed_letters) elif guess not","' + partial_word(secret_word, guessed_letters) elif guess not in secret_word: num_guesses -= 1 available_letters.remove(guess)","in guessed_letters: result = result + letter else: result = result + '_'","print 'Oops! You\\'ve already guessed that letter: ' + partial_word(secret_word, guessed_letters) elif guess","list from file...\" # inFile: file inFile = open(WORDLIST_FILENAME, 'r', 0) # line:","word list from file...\" # inFile: file inFile = open(WORDLIST_FILENAME, 'r', 0) #","'Available letters: ' + ''.join(available_letters) guess = raw_input('Please guess a letter:') if guess","Depending on the size of the word list, this function may take a","word that is ' + str(len(secret_word)) + ' letters long.' num_guesses = 8","== partial_word(secret_word, guessed_letters): word_guessed = True if word_guessed: print 'Congratulations, you won!' else:","def choose_word(wordlist): \"\"\" wordlist (list): list of words (strings) Returns a word from","guesses left.' print 'Available letters: ' + ''.join(available_letters) guess = raw_input('Please guess a","line: string line = inFile.readline() # wordlist: list of strings wordlist = string.split(line)","my word: ' + partial_word(secret_word, guessed_letters) else: available_letters.remove(guess) guessed_letters += guess print 'Good","available_letters.remove(guess) print 'Oops! That letter is not in my word: ' + partial_word(secret_word,","import random import string WORDLIST_FILENAME = \"words.txt\" def load_words(): \"\"\" Returns a list","Runs the hangman game. \"\"\" print 'Welcome to the game, Hangman!' secret_word =","the word has yet been correctly guessed. while num_guesses > 0 and not","list of strings wordlist = string.split(line) print \" \", len(wordlist), \"words loaded.\" return","0) # line: string line = inFile.readline() # wordlist: list of strings wordlist","'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']","of words into the wordlist variable # so that it can be accessed","in my word: ' + partial_word(secret_word, guessed_letters) else: available_letters.remove(guess) guessed_letters += guess print","of helper code # ----------------------------------- # load the list of words into the","secret_word in user-visible format, with underscores used to replace characters that have not","inFile = open(WORDLIST_FILENAME, 'r', 0) # line: string line = inFile.readline() # wordlist:","user to guess a letter and respond to the # user based on","guessed. while num_guesses > 0 and not word_guessed: print '-------------' print 'You have","+ letter else: result = result + '_' return result def hangman(): \"\"\"","secret_word: if letter in guessed_letters: result = result + letter else: result =","word_guessed: print '-------------' print 'You have ' + str(num_guesses) + ' guesses left.'","letter else: result = result + '_' return result def hangman(): \"\"\" Runs","wordlist: list of strings wordlist = string.split(line) print \" \", len(wordlist), \"words loaded.\"","a letter and respond to the # user based on whether the word","'Welcome to the game, Hangman!' secret_word = choose_word(wordlist) print 'I am thinking of","----------------------------------- # Helper code # You don't need to understand this helper code,","a word that is ' + str(len(secret_word)) + ' letters long.' num_guesses =","'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'] # Letter-guessing loop.","words into the wordlist variable # so that it can be accessed from","= \"words.txt\" def load_words(): \"\"\" Returns a list of valid words. Words are","the user to guess a letter and respond to the # user based","----------------------------------- # load the list of words into the wordlist variable # so","secret_word == partial_word(secret_word, guessed_letters): word_guessed = True if word_guessed: print 'Congratulations, you won!'","strings of lowercase letters. Depending on the size of the word list, this","> 0 and not word_guessed: print '-------------' print 'You have ' + str(num_guesses)","' + partial_word(secret_word, guessed_letters) else: available_letters.remove(guess) guessed_letters += guess print 'Good guess: '","+ ' letters long.' num_guesses = 8 word_guessed = False guessed_letters = ''","guessed_letters) elif guess not in secret_word: num_guesses -= 1 available_letters.remove(guess) print 'Oops! That","= choose_word(wordlist) print 'I am thinking of a word that is ' +","+ partial_word(secret_word, guessed_letters) else: available_letters.remove(guess) guessed_letters += guess print 'Good guess: ' +","'u', 'v', 'w', 'x', 'y', 'z'] # Letter-guessing loop. Ask the user to","guess a letter and respond to the # user based on whether the","file inFile = open(WORDLIST_FILENAME, 'r', 0) # line: string line = inFile.readline() #","words (strings) Returns a word from wordlist at random \"\"\" return random.choice(wordlist) #","# line: string line = inFile.readline() # wordlist: list of strings wordlist =","6.00 Problem Set 2 # # Hangman # Name : Solutions # Collaborators","# Hangman # Name : Solutions # Collaborators : <your collaborators> # Time","\"Loading word list from file...\" # inFile: file inFile = open(WORDLIST_FILENAME, 'r', 0)","have ' + str(num_guesses) + ' guesses left.' print 'Available letters: ' +","while num_guesses > 0 and not word_guessed: print '-------------' print 'You have '","from wordlist at random \"\"\" return random.choice(wordlist) # end of helper code #","'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w',","and not word_guessed: print '-------------' print 'You have ' + str(num_guesses) + '","\"words.txt\" def load_words(): \"\"\" Returns a list of valid words. Words are strings","have to know how to use the functions import random import string WORDLIST_FILENAME","wordlist at random \"\"\" return random.choice(wordlist) # end of helper code # -----------------------------------","format, with underscores used to replace characters that have not yet been guessed.","print \" \", len(wordlist), \"words loaded.\" return wordlist def choose_word(wordlist): \"\"\" wordlist (list):","variable # so that it can be accessed from anywhere in the program","to the # user based on whether the word has yet been correctly","You don't need to understand this helper code, # but you will have","raw_input('Please guess a letter:') if guess not in available_letters: print 'Oops! You\\'ve already","string line = inFile.readline() # wordlist: list of strings wordlist = string.split(line) print","def load_words(): \"\"\" Returns a list of valid words. Words are strings of","+ str(len(secret_word)) + ' letters long.' num_guesses = 8 word_guessed = False guessed_letters","+ partial_word(secret_word, guessed_letters) if secret_word == partial_word(secret_word, guessed_letters): word_guessed = True if word_guessed:","not in my word: ' + partial_word(secret_word, guessed_letters) else: available_letters.remove(guess) guessed_letters += guess","\"\"\" Returns a list of valid words. Words are strings of lowercase letters.","'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o',","(list): list of words (strings) Returns a word from wordlist at random \"\"\"","\", len(wordlist), \"words loaded.\" return wordlist def choose_word(wordlist): \"\"\" wordlist (list): list of","program wordlist = load_words() def partial_word(secret_word, guessed_letters): \"\"\" Return the secret_word in user-visible","guessed_letters += guess print 'Good guess: ' + partial_word(secret_word, guessed_letters) if secret_word ==","['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',","yet been guessed. \"\"\" result = '' for letter in secret_word: if letter","\"\"\" print 'Welcome to the game, Hangman!' secret_word = choose_word(wordlist) print 'I am","at random \"\"\" return random.choice(wordlist) # end of helper code # ----------------------------------- #","with underscores used to replace characters that have not yet been guessed. \"\"\"","the hangman game. \"\"\" print 'Welcome to the game, Hangman!' secret_word = choose_word(wordlist)","finish. \"\"\" print \"Loading word list from file...\" # inFile: file inFile =","to use the functions import random import string WORDLIST_FILENAME = \"words.txt\" def load_words():","return random.choice(wordlist) # end of helper code # ----------------------------------- # load the list","\"\"\" result = '' for letter in secret_word: if letter in guessed_letters: result","elif guess not in secret_word: num_guesses -= 1 available_letters.remove(guess) print 'Oops! That letter","result + letter else: result = result + '_' return result def hangman():","characters that have not yet been guessed. \"\"\" result = '' for letter","= '' available_letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i',","functions import random import string WORDLIST_FILENAME = \"words.txt\" def load_words(): \"\"\" Returns a","-= 1 available_letters.remove(guess) print 'Oops! That letter is not in my word: '","guessed that letter: ' + partial_word(secret_word, guessed_letters) elif guess not in secret_word: num_guesses","guessed_letters) else: available_letters.remove(guess) guessed_letters += guess print 'Good guess: ' + partial_word(secret_word, guessed_letters)","Helper code # You don't need to understand this helper code, # but","\"\"\" Return the secret_word in user-visible format, with underscores used to replace characters","to the game, Hangman!' secret_word = choose_word(wordlist) print 'I am thinking of a","partial_word(secret_word, guessed_letters) else: available_letters.remove(guess) guessed_letters += guess print 'Good guess: ' + partial_word(secret_word,","# Letter-guessing loop. Ask the user to guess a letter and respond to","will have to know how to use the functions import random import string","'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's',","wordlist def choose_word(wordlist): \"\"\" wordlist (list): list of words (strings) Returns a word","letter in guessed_letters: result = result + letter else: result = result +","size of the word list, this function may take a while to finish.","num_guesses > 0 and not word_guessed: print '-------------' print 'You have ' +","'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'] # Letter-guessing","the # user based on whether the word has yet been correctly guessed.","'t', 'u', 'v', 'w', 'x', 'y', 'z'] # Letter-guessing loop. Ask the user",": Solutions # Collaborators : <your collaborators> # Time spent : <total time>","'w', 'x', 'y', 'z'] # Letter-guessing loop. Ask the user to guess a","return wordlist def choose_word(wordlist): \"\"\" wordlist (list): list of words (strings) Returns a","wordlist variable # so that it can be accessed from anywhere in the","can be accessed from anywhere in the program wordlist = load_words() def partial_word(secret_word,","if secret_word == partial_word(secret_word, guessed_letters): word_guessed = True if word_guessed: print 'Congratulations, you","list of valid words. Words are strings of lowercase letters. Depending on the","= raw_input('Please guess a letter:') if guess not in available_letters: print 'Oops! You\\'ve","' guesses left.' print 'Available letters: ' + ''.join(available_letters) guess = raw_input('Please guess","used to replace characters that have not yet been guessed. \"\"\" result =","loaded.\" return wordlist def choose_word(wordlist): \"\"\" wordlist (list): list of words (strings) Returns","choose_word(wordlist): \"\"\" wordlist (list): list of words (strings) Returns a word from wordlist","else: available_letters.remove(guess) guessed_letters += guess print 'Good guess: ' + partial_word(secret_word, guessed_letters) if","guess not in available_letters: print 'Oops! You\\'ve already guessed that letter: ' +","guessed_letters): word_guessed = True if word_guessed: print 'Congratulations, you won!' else: print 'Game","spent : <total time> # ----------------------------------- # Helper code # You don't need","print '-------------' print 'You have ' + str(num_guesses) + ' guesses left.' print","'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v',","load_words() def partial_word(secret_word, guessed_letters): \"\"\" Return the secret_word in user-visible format, with underscores","= False guessed_letters = '' available_letters = ['a', 'b', 'c', 'd', 'e', 'f',","' letters long.' num_guesses = 8 word_guessed = False guessed_letters = '' available_letters","import string WORDLIST_FILENAME = \"words.txt\" def load_words(): \"\"\" Returns a list of valid","\" \", len(wordlist), \"words loaded.\" return wordlist def choose_word(wordlist): \"\"\" wordlist (list): list","the list of words into the wordlist variable # so that it can","letters: ' + ''.join(available_letters) guess = raw_input('Please guess a letter:') if guess not","in secret_word: num_guesses -= 1 available_letters.remove(guess) print 'Oops! That letter is not in","'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u',","end of helper code # ----------------------------------- # load the list of words into","take a while to finish. \"\"\" print \"Loading word list from file...\" #","to finish. \"\"\" print \"Loading word list from file...\" # inFile: file inFile","list, this function may take a while to finish. \"\"\" print \"Loading word","# inFile: file inFile = open(WORDLIST_FILENAME, 'r', 0) # line: string line =","to guess a letter and respond to the # user based on whether","in available_letters: print 'Oops! You\\'ve already guessed that letter: ' + partial_word(secret_word, guessed_letters)","'' available_letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j',","function may take a while to finish. \"\"\" print \"Loading word list from","this function may take a while to finish. \"\"\" print \"Loading word list","' + ''.join(available_letters) guess = raw_input('Please guess a letter:') if guess not in","'d', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p',",": <your collaborators> # Time spent : <total time> # ----------------------------------- # Helper","= result + '_' return result def hangman(): \"\"\" Runs the hangman game.","code # You don't need to understand this helper code, # but you","# Time spent : <total time> # ----------------------------------- # Helper code # You","guessed_letters = '' available_letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h',","but you will have to know how to use the functions import random","not word_guessed: print '-------------' print 'You have ' + str(num_guesses) + ' guesses","' + str(num_guesses) + ' guesses left.' print 'Available letters: ' + ''.join(available_letters)","+= guess print 'Good guess: ' + partial_word(secret_word, guessed_letters) if secret_word == partial_word(secret_word,","letter and respond to the # user based on whether the word has","result = '' for letter in secret_word: if letter in guessed_letters: result =","understand this helper code, # but you will have to know how to","Hangman!' secret_word = choose_word(wordlist) print 'I am thinking of a word that is","+ '_' return result def hangman(): \"\"\" Runs the hangman game. \"\"\" print","is ' + str(len(secret_word)) + ' letters long.' num_guesses = 8 word_guessed =","\"\"\" print \"Loading word list from file...\" # inFile: file inFile = open(WORDLIST_FILENAME,","it can be accessed from anywhere in the program wordlist = load_words() def","of strings wordlist = string.split(line) print \" \", len(wordlist), \"words loaded.\" return wordlist","on whether the word has yet been correctly guessed. while num_guesses > 0","False guessed_letters = '' available_letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g',","guessed. \"\"\" result = '' for letter in secret_word: if letter in guessed_letters:","\"\"\" return random.choice(wordlist) # end of helper code # ----------------------------------- # load the","# user based on whether the word has yet been correctly guessed. while","helper code # ----------------------------------- # load the list of words into the wordlist","= open(WORDLIST_FILENAME, 'r', 0) # line: string line = inFile.readline() # wordlist: list","# ----------------------------------- # load the list of words into the wordlist variable #","secret_word = choose_word(wordlist) print 'I am thinking of a word that is '","word_guessed = False guessed_letters = '' available_letters = ['a', 'b', 'c', 'd', 'e',","wordlist = load_words() def partial_word(secret_word, guessed_letters): \"\"\" Return the secret_word in user-visible format,","that have not yet been guessed. \"\"\" result = '' for letter in","guess = raw_input('Please guess a letter:') if guess not in available_letters: print 'Oops!","guessed_letters): \"\"\" Return the secret_word in user-visible format, with underscores used to replace","'I am thinking of a word that is ' + str(len(secret_word)) + '","return result def hangman(): \"\"\" Runs the hangman game. \"\"\" print 'Welcome to","underscores used to replace characters that have not yet been guessed. \"\"\" result","partial_word(secret_word, guessed_letters): word_guessed = True if word_guessed: print 'Congratulations, you won!' else: print","whether the word has yet been correctly guessed. while num_guesses > 0 and","''.join(available_letters) guess = raw_input('Please guess a letter:') if guess not in available_letters: print","while to finish. \"\"\" print \"Loading word list from file...\" # inFile: file","accessed from anywhere in the program wordlist = load_words() def partial_word(secret_word, guessed_letters): \"\"\"","Return the secret_word in user-visible format, with underscores used to replace characters that","(strings) Returns a word from wordlist at random \"\"\" return random.choice(wordlist) # end","# 6.00 Problem Set 2 # # Hangman # Name : Solutions #","partial_word(secret_word, guessed_letters) elif guess not in secret_word: num_guesses -= 1 available_letters.remove(guess) print 'Oops!","is not in my word: ' + partial_word(secret_word, guessed_letters) else: available_letters.remove(guess) guessed_letters +=","letter in secret_word: if letter in guessed_letters: result = result + letter else:","result = result + '_' return result def hangman(): \"\"\" Runs the hangman","into the wordlist variable # so that it can be accessed from anywhere","'v', 'w', 'x', 'y', 'z'] # Letter-guessing loop. Ask the user to guess","the size of the word list, this function may take a while to","need to understand this helper code, # but you will have to know","You\\'ve already guessed that letter: ' + partial_word(secret_word, guessed_letters) elif guess not in","Collaborators : <your collaborators> # Time spent : <total time> # ----------------------------------- #","not in available_letters: print 'Oops! You\\'ve already guessed that letter: ' + partial_word(secret_word,","the secret_word in user-visible format, with underscores used to replace characters that have","in the program wordlist = load_words() def partial_word(secret_word, guessed_letters): \"\"\" Return the secret_word","secret_word: num_guesses -= 1 available_letters.remove(guess) print 'Oops! That letter is not in my","to replace characters that have not yet been guessed. \"\"\" result = ''","hangman game. \"\"\" print 'Welcome to the game, Hangman!' secret_word = choose_word(wordlist) print","wordlist (list): list of words (strings) Returns a word from wordlist at random","random \"\"\" return random.choice(wordlist) # end of helper code # ----------------------------------- # load","letter:') if guess not in available_letters: print 'Oops! You\\'ve already guessed that letter:","result = result + letter else: result = result + '_' return result","'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'] # Letter-guessing loop. Ask","the game, Hangman!' secret_word = choose_word(wordlist) print 'I am thinking of a word","print \"Loading word list from file...\" # inFile: file inFile = open(WORDLIST_FILENAME, 'r',","correctly guessed. while num_guesses > 0 and not word_guessed: print '-------------' print 'You","' + partial_word(secret_word, guessed_letters) if secret_word == partial_word(secret_word, guessed_letters): word_guessed = True if","'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r',","# wordlist: list of strings wordlist = string.split(line) print \" \", len(wordlist), \"words","'y', 'z'] # Letter-guessing loop. Ask the user to guess a letter and","'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x',","of valid words. Words are strings of lowercase letters. Depending on the size","a letter:') if guess not in available_letters: print 'Oops! You\\'ve already guessed that","letter is not in my word: ' + partial_word(secret_word, guessed_letters) else: available_letters.remove(guess) guessed_letters","from anywhere in the program wordlist = load_words() def partial_word(secret_word, guessed_letters): \"\"\" Return","helper code, # but you will have to know how to use the","'z'] # Letter-guessing loop. Ask the user to guess a letter and respond","1 available_letters.remove(guess) print 'Oops! That letter is not in my word: ' +","8 word_guessed = False guessed_letters = '' available_letters = ['a', 'b', 'c', 'd',","that letter: ' + partial_word(secret_word, guessed_letters) elif guess not in secret_word: num_guesses -=","list of words into the wordlist variable # so that it can be","guessed_letters) if secret_word == partial_word(secret_word, guessed_letters): word_guessed = True if word_guessed: print 'Congratulations,","to know how to use the functions import random import string WORDLIST_FILENAME =","for letter in secret_word: if letter in guessed_letters: result = result + letter","inFile: file inFile = open(WORDLIST_FILENAME, 'r', 0) # line: string line = inFile.readline()","in user-visible format, with underscores used to replace characters that have not yet","am thinking of a word that is ' + str(len(secret_word)) + ' letters","has yet been correctly guessed. while num_guesses > 0 and not word_guessed: print","result def hangman(): \"\"\" Runs the hangman game. \"\"\" print 'Welcome to the","# so that it can be accessed from anywhere in the program wordlist","# You don't need to understand this helper code, # but you will","line = inFile.readline() # wordlist: list of strings wordlist = string.split(line) print \"","= 8 word_guessed = False guessed_letters = '' available_letters = ['a', 'b', 'c',","num_guesses = 8 word_guessed = False guessed_letters = '' available_letters = ['a', 'b',","word from wordlist at random \"\"\" return random.choice(wordlist) # end of helper code","know how to use the functions import random import string WORDLIST_FILENAME = \"words.txt\"","choose_word(wordlist) print 'I am thinking of a word that is ' + str(len(secret_word))","not yet been guessed. \"\"\" result = '' for letter in secret_word: if",": <total time> # ----------------------------------- # Helper code # You don't need to","'-------------' print 'You have ' + str(num_guesses) + ' guesses left.' print 'Available","Ask the user to guess a letter and respond to the # user","print 'Oops! That letter is not in my word: ' + partial_word(secret_word, guessed_letters)","word_guessed = True if word_guessed: print 'Congratulations, you won!' else: print 'Game over.'","Set 2 # # Hangman # Name : Solutions # Collaborators : <your","of a word that is ' + str(len(secret_word)) + ' letters long.' num_guesses","'_' return result def hangman(): \"\"\" Runs the hangman game. \"\"\" print 'Welcome","be accessed from anywhere in the program wordlist = load_words() def partial_word(secret_word, guessed_letters):","based on whether the word has yet been correctly guessed. while num_guesses >","= load_words() def partial_word(secret_word, guessed_letters): \"\"\" Return the secret_word in user-visible format, with","'Oops! That letter is not in my word: ' + partial_word(secret_word, guessed_letters) else:","\"\"\" Runs the hangman game. \"\"\" print 'Welcome to the game, Hangman!' secret_word","'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't',","letter: ' + partial_word(secret_word, guessed_letters) elif guess not in secret_word: num_guesses -= 1","WORDLIST_FILENAME = \"words.txt\" def load_words(): \"\"\" Returns a list of valid words. Words","+ partial_word(secret_word, guessed_letters) elif guess not in secret_word: num_guesses -= 1 available_letters.remove(guess) print","# Collaborators : <your collaborators> # Time spent : <total time> # -----------------------------------","len(wordlist), \"words loaded.\" return wordlist def choose_word(wordlist): \"\"\" wordlist (list): list of words","# ----------------------------------- # Helper code # You don't need to understand this helper","load the list of words into the wordlist variable # so that it","not in secret_word: num_guesses -= 1 available_letters.remove(guess) print 'Oops! That letter is not","'s', 't', 'u', 'v', 'w', 'x', 'y', 'z'] # Letter-guessing loop. Ask the","Returns a list of valid words. Words are strings of lowercase letters. Depending","str(num_guesses) + ' guesses left.' print 'Available letters: ' + ''.join(available_letters) guess =","'Good guess: ' + partial_word(secret_word, guessed_letters) if secret_word == partial_word(secret_word, guessed_letters): word_guessed =","on the size of the word list, this function may take a while","if letter in guessed_letters: result = result + letter else: result = result","def partial_word(secret_word, guessed_letters): \"\"\" Return the secret_word in user-visible format, with underscores used","Returns a word from wordlist at random \"\"\" return random.choice(wordlist) # end of","the program wordlist = load_words() def partial_word(secret_word, guessed_letters): \"\"\" Return the secret_word in","of lowercase letters. Depending on the size of the word list, this function","'' for letter in secret_word: if letter in guessed_letters: result = result +","= ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l',","'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',","'You have ' + str(num_guesses) + ' guesses left.' print 'Available letters: '","print 'Available letters: ' + ''.join(available_letters) guess = raw_input('Please guess a letter:') if","'r', 0) # line: string line = inFile.readline() # wordlist: list of strings","# # Hangman # Name : Solutions # Collaborators : <your collaborators> #","lowercase letters. Depending on the size of the word list, this function may","user based on whether the word has yet been correctly guessed. while num_guesses","Time spent : <total time> # ----------------------------------- # Helper code # You don't","# Name : Solutions # Collaborators : <your collaborators> # Time spent :","don't need to understand this helper code, # but you will have to","guess print 'Good guess: ' + partial_word(secret_word, guessed_letters) if secret_word == partial_word(secret_word, guessed_letters):","0 and not word_guessed: print '-------------' print 'You have ' + str(num_guesses) +","that is ' + str(len(secret_word)) + ' letters long.' num_guesses = 8 word_guessed","Words are strings of lowercase letters. Depending on the size of the word","collaborators> # Time spent : <total time> # ----------------------------------- # Helper code #","code, # but you will have to know how to use the functions","you will have to know how to use the functions import random import"],"string":"[\n \"random.choice(wordlist) # end of helper code # ----------------------------------- # load the list of\",\n \"valid words. Words are strings of lowercase letters. Depending on the size of\",\n \"anywhere in the program wordlist = load_words() def partial_word(secret_word, guessed_letters): \\\"\\\"\\\" Return the\",\n \"' + str(len(secret_word)) + ' letters long.' num_guesses = 8 word_guessed = False\",\n \"how to use the functions import random import string WORDLIST_FILENAME = \\\"words.txt\\\" def\",\n \"word has yet been correctly guessed. while num_guesses > 0 and not word_guessed:\",\n \"code # ----------------------------------- # load the list of words into the wordlist variable\",\n \"in secret_word: if letter in guessed_letters: result = result + letter else: result\",\n \"Hangman # Name : Solutions # Collaborators : <your collaborators> # Time spent\",\n \"# Helper code # You don't need to understand this helper code, #\",\n \"respond to the # user based on whether the word has yet been\",\n \"\\\"words loaded.\\\" return wordlist def choose_word(wordlist): \\\"\\\"\\\" wordlist (list): list of words (strings)\",\n \"'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q',\",\n \"been guessed. \\\"\\\"\\\" result = '' for letter in secret_word: if letter in\",\n \"partial_word(secret_word, guessed_letters) if secret_word == partial_word(secret_word, guessed_letters): word_guessed = True if word_guessed: print\",\n \"Problem Set 2 # # Hangman # Name : Solutions # Collaborators :\",\n \"def hangman(): \\\"\\\"\\\" Runs the hangman game. \\\"\\\"\\\" print 'Welcome to the game,\",\n \"and respond to the # user based on whether the word has yet\",\n \"wordlist = string.split(line) print \\\" \\\", len(wordlist), \\\"words loaded.\\\" return wordlist def choose_word(wordlist):\",\n \"open(WORDLIST_FILENAME, 'r', 0) # line: string line = inFile.readline() # wordlist: list of\",\n \"guessed_letters: result = result + letter else: result = result + '_' return\",\n \"yet been correctly guessed. while num_guesses > 0 and not word_guessed: print '-------------'\",\n \"user-visible format, with underscores used to replace characters that have not yet been\",\n \"so that it can be accessed from anywhere in the program wordlist =\",\n \"print 'I am thinking of a word that is ' + str(len(secret_word)) +\",\n \"available_letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k',\",\n \"# load the list of words into the wordlist variable # so that\",\n \"words. Words are strings of lowercase letters. Depending on the size of the\",\n \"Letter-guessing loop. Ask the user to guess a letter and respond to the\",\n \"+ ''.join(available_letters) guess = raw_input('Please guess a letter:') if guess not in available_letters:\",\n \"word list, this function may take a while to finish. \\\"\\\"\\\" print \\\"Loading\",\n \"load_words(): \\\"\\\"\\\" Returns a list of valid words. Words are strings of lowercase\",\n \"print 'You have ' + str(num_guesses) + ' guesses left.' print 'Available letters:\",\n \"use the functions import random import string WORDLIST_FILENAME = \\\"words.txt\\\" def load_words(): \\\"\\\"\\\"\",\n \"string.split(line) print \\\" \\\", len(wordlist), \\\"words loaded.\\\" return wordlist def choose_word(wordlist): \\\"\\\"\\\" wordlist\",\n \"if guess not in available_letters: print 'Oops! You\\\\'ve already guessed that letter: '\",\n \"num_guesses -= 1 available_letters.remove(guess) print 'Oops! That letter is not in my word:\",\n \"letters long.' num_guesses = 8 word_guessed = False guessed_letters = '' available_letters =\",\n \"inFile.readline() # wordlist: list of strings wordlist = string.split(line) print \\\" \\\", len(wordlist),\",\n \"game. \\\"\\\"\\\" print 'Welcome to the game, Hangman!' secret_word = choose_word(wordlist) print 'I\",\n \"game, Hangman!' secret_word = choose_word(wordlist) print 'I am thinking of a word that\",\n \"\\\"\\\"\\\" wordlist (list): list of words (strings) Returns a word from wordlist at\",\n \"to understand this helper code, # but you will have to know how\",\n \"# end of helper code # ----------------------------------- # load the list of words\",\n \"of words (strings) Returns a word from wordlist at random \\\"\\\"\\\" return random.choice(wordlist)\",\n \"result + '_' return result def hangman(): \\\"\\\"\\\" Runs the hangman game. \\\"\\\"\\\"\",\n \"already guessed that letter: ' + partial_word(secret_word, guessed_letters) elif guess not in secret_word:\",\n \"the word list, this function may take a while to finish. \\\"\\\"\\\" print\",\n \"= inFile.readline() # wordlist: list of strings wordlist = string.split(line) print \\\" \\\",\",\n \"are strings of lowercase letters. Depending on the size of the word list,\",\n \"the functions import random import string WORDLIST_FILENAME = \\\"words.txt\\\" def load_words(): \\\"\\\"\\\" Returns\",\n \"random import string WORDLIST_FILENAME = \\\"words.txt\\\" def load_words(): \\\"\\\"\\\" Returns a list of\",\n \"'x', 'y', 'z'] # Letter-guessing loop. Ask the user to guess a letter\",\n \"available_letters.remove(guess) guessed_letters += guess print 'Good guess: ' + partial_word(secret_word, guessed_letters) if secret_word\",\n \"of the word list, this function may take a while to finish. \\\"\\\"\\\"\",\n \"replace characters that have not yet been guessed. \\\"\\\"\\\" result = '' for\",\n \"= '' for letter in secret_word: if letter in guessed_letters: result = result\",\n \"'m', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y',\",\n \"have not yet been guessed. \\\"\\\"\\\" result = '' for letter in secret_word:\",\n \"'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'] #\",\n \"# but you will have to know how to use the functions import\",\n \"else: result = result + '_' return result def hangman(): \\\"\\\"\\\" Runs the\",\n \"hangman(): \\\"\\\"\\\" Runs the hangman game. \\\"\\\"\\\" print 'Welcome to the game, Hangman!'\",\n \"file...\\\" # inFile: file inFile = open(WORDLIST_FILENAME, 'r', 0) # line: string line\",\n \"2 # # Hangman # Name : Solutions # Collaborators : <your collaborators>\",\n \"str(len(secret_word)) + ' letters long.' num_guesses = 8 word_guessed = False guessed_letters =\",\n \"may take a while to finish. \\\"\\\"\\\" print \\\"Loading word list from file...\\\"\",\n \"<your collaborators> # Time spent : <total time> # ----------------------------------- # Helper code\",\n \"list of words (strings) Returns a word from wordlist at random \\\"\\\"\\\" return\",\n \"print 'Welcome to the game, Hangman!' secret_word = choose_word(wordlist) print 'I am thinking\",\n \"<total time> # ----------------------------------- # Helper code # You don't need to understand\",\n \"print 'Good guess: ' + partial_word(secret_word, guessed_letters) if secret_word == partial_word(secret_word, guessed_letters): word_guessed\",\n \"= string.split(line) print \\\" \\\", len(wordlist), \\\"words loaded.\\\" return wordlist def choose_word(wordlist): \\\"\\\"\\\"\",\n \"That letter is not in my word: ' + partial_word(secret_word, guessed_letters) else: available_letters.remove(guess)\",\n \"string WORDLIST_FILENAME = \\\"words.txt\\\" def load_words(): \\\"\\\"\\\" Returns a list of valid words.\",\n \"+ str(num_guesses) + ' guesses left.' print 'Available letters: ' + ''.join(available_letters) guess\",\n \"word: ' + partial_word(secret_word, guessed_letters) else: available_letters.remove(guess) guessed_letters += guess print 'Good guess:\",\n \"a list of valid words. Words are strings of lowercase letters. Depending on\",\n \"long.' num_guesses = 8 word_guessed = False guessed_letters = '' available_letters = ['a',\",\n \"Solutions # Collaborators : <your collaborators> # Time spent : <total time> #\",\n \"guess not in secret_word: num_guesses -= 1 available_letters.remove(guess) print 'Oops! That letter is\",\n \"time> # ----------------------------------- # Helper code # You don't need to understand this\",\n \"the wordlist variable # so that it can be accessed from anywhere in\",\n \"a word from wordlist at random \\\"\\\"\\\" return random.choice(wordlist) # end of helper\",\n \"a while to finish. \\\"\\\"\\\" print \\\"Loading word list from file...\\\" # inFile:\",\n \"+ ' guesses left.' print 'Available letters: ' + ''.join(available_letters) guess = raw_input('Please\",\n \"guess a letter:') if guess not in available_letters: print 'Oops! You\\\\'ve already guessed\",\n \"been correctly guessed. while num_guesses > 0 and not word_guessed: print '-------------' print\",\n \"left.' print 'Available letters: ' + ''.join(available_letters) guess = raw_input('Please guess a letter:')\",\n \"Name : Solutions # Collaborators : <your collaborators> # Time spent : <total\",\n \"= result + letter else: result = result + '_' return result def\",\n \"thinking of a word that is ' + str(len(secret_word)) + ' letters long.'\",\n \"loop. Ask the user to guess a letter and respond to the #\",\n \"letters. Depending on the size of the word list, this function may take\",\n \"available_letters: print 'Oops! You\\\\'ve already guessed that letter: ' + partial_word(secret_word, guessed_letters) elif\",\n \"that it can be accessed from anywhere in the program wordlist = load_words()\",\n \"guess: ' + partial_word(secret_word, guessed_letters) if secret_word == partial_word(secret_word, guessed_letters): word_guessed = True\",\n \"partial_word(secret_word, guessed_letters): \\\"\\\"\\\" Return the secret_word in user-visible format, with underscores used to\",\n \"this helper code, # but you will have to know how to use\",\n \"from file...\\\" # inFile: file inFile = open(WORDLIST_FILENAME, 'r', 0) # line: string\",\n \"strings wordlist = string.split(line) print \\\" \\\", len(wordlist), \\\"words loaded.\\\" return wordlist def\",\n \"'Oops! You\\\\'ve already guessed that letter: ' + partial_word(secret_word, guessed_letters) elif guess not\",\n \"' + partial_word(secret_word, guessed_letters) elif guess not in secret_word: num_guesses -= 1 available_letters.remove(guess)\",\n \"in guessed_letters: result = result + letter else: result = result + '_'\",\n \"print 'Oops! You\\\\'ve already guessed that letter: ' + partial_word(secret_word, guessed_letters) elif guess\",\n \"list from file...\\\" # inFile: file inFile = open(WORDLIST_FILENAME, 'r', 0) # line:\",\n \"word list from file...\\\" # inFile: file inFile = open(WORDLIST_FILENAME, 'r', 0) #\",\n \"'Available letters: ' + ''.join(available_letters) guess = raw_input('Please guess a letter:') if guess\",\n \"Depending on the size of the word list, this function may take a\",\n \"word that is ' + str(len(secret_word)) + ' letters long.' num_guesses = 8\",\n \"== partial_word(secret_word, guessed_letters): word_guessed = True if word_guessed: print 'Congratulations, you won!' else:\",\n \"def choose_word(wordlist): \\\"\\\"\\\" wordlist (list): list of words (strings) Returns a word from\",\n \"guesses left.' print 'Available letters: ' + ''.join(available_letters) guess = raw_input('Please guess a\",\n \"line: string line = inFile.readline() # wordlist: list of strings wordlist = string.split(line)\",\n \"my word: ' + partial_word(secret_word, guessed_letters) else: available_letters.remove(guess) guessed_letters += guess print 'Good\",\n \"available_letters.remove(guess) print 'Oops! That letter is not in my word: ' + partial_word(secret_word,\",\n \"import random import string WORDLIST_FILENAME = \\\"words.txt\\\" def load_words(): \\\"\\\"\\\" Returns a list\",\n \"Runs the hangman game. \\\"\\\"\\\" print 'Welcome to the game, Hangman!' secret_word =\",\n \"the word has yet been correctly guessed. while num_guesses > 0 and not\",\n \"list of strings wordlist = string.split(line) print \\\" \\\", len(wordlist), \\\"words loaded.\\\" return\",\n \"0) # line: string line = inFile.readline() # wordlist: list of strings wordlist\",\n \"'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']\",\n \"of words into the wordlist variable # so that it can be accessed\",\n \"in my word: ' + partial_word(secret_word, guessed_letters) else: available_letters.remove(guess) guessed_letters += guess print\",\n \"of helper code # ----------------------------------- # load the list of words into the\",\n \"secret_word in user-visible format, with underscores used to replace characters that have not\",\n \"inFile = open(WORDLIST_FILENAME, 'r', 0) # line: string line = inFile.readline() # wordlist:\",\n \"user to guess a letter and respond to the # user based on\",\n \"guessed. while num_guesses > 0 and not word_guessed: print '-------------' print 'You have\",\n \"+ letter else: result = result + '_' return result def hangman(): \\\"\\\"\\\"\",\n \"secret_word: if letter in guessed_letters: result = result + letter else: result =\",\n \"word_guessed: print '-------------' print 'You have ' + str(num_guesses) + ' guesses left.'\",\n \"letter else: result = result + '_' return result def hangman(): \\\"\\\"\\\" Runs\",\n \"wordlist: list of strings wordlist = string.split(line) print \\\" \\\", len(wordlist), \\\"words loaded.\\\"\",\n \"a letter and respond to the # user based on whether the word\",\n \"'Welcome to the game, Hangman!' secret_word = choose_word(wordlist) print 'I am thinking of\",\n \"----------------------------------- # Helper code # You don't need to understand this helper code,\",\n \"a word that is ' + str(len(secret_word)) + ' letters long.' num_guesses =\",\n \"'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'] # Letter-guessing loop.\",\n \"words into the wordlist variable # so that it can be accessed from\",\n \"= \\\"words.txt\\\" def load_words(): \\\"\\\"\\\" Returns a list of valid words. Words are\",\n \"the user to guess a letter and respond to the # user based\",\n \"----------------------------------- # load the list of words into the wordlist variable # so\",\n \"secret_word == partial_word(secret_word, guessed_letters): word_guessed = True if word_guessed: print 'Congratulations, you won!'\",\n \"strings of lowercase letters. Depending on the size of the word list, this\",\n \"> 0 and not word_guessed: print '-------------' print 'You have ' + str(num_guesses)\",\n \"' + partial_word(secret_word, guessed_letters) else: available_letters.remove(guess) guessed_letters += guess print 'Good guess: '\",\n \"+ ' letters long.' num_guesses = 8 word_guessed = False guessed_letters = ''\",\n \"guessed_letters) elif guess not in secret_word: num_guesses -= 1 available_letters.remove(guess) print 'Oops! That\",\n \"= choose_word(wordlist) print 'I am thinking of a word that is ' +\",\n \"+ partial_word(secret_word, guessed_letters) else: available_letters.remove(guess) guessed_letters += guess print 'Good guess: ' +\",\n \"'u', 'v', 'w', 'x', 'y', 'z'] # Letter-guessing loop. Ask the user to\",\n \"guess a letter and respond to the # user based on whether the\",\n \"file inFile = open(WORDLIST_FILENAME, 'r', 0) # line: string line = inFile.readline() #\",\n \"words (strings) Returns a word from wordlist at random \\\"\\\"\\\" return random.choice(wordlist) #\",\n \"# line: string line = inFile.readline() # wordlist: list of strings wordlist =\",\n \"6.00 Problem Set 2 # # Hangman # Name : Solutions # Collaborators\",\n \"# Hangman # Name : Solutions # Collaborators : <your collaborators> # Time\",\n \"\\\"Loading word list from file...\\\" # inFile: file inFile = open(WORDLIST_FILENAME, 'r', 0)\",\n \"have ' + str(num_guesses) + ' guesses left.' print 'Available letters: ' +\",\n \"while num_guesses > 0 and not word_guessed: print '-------------' print 'You have '\",\n \"from wordlist at random \\\"\\\"\\\" return random.choice(wordlist) # end of helper code #\",\n \"'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w',\",\n \"and not word_guessed: print '-------------' print 'You have ' + str(num_guesses) + '\",\n \"\\\"words.txt\\\" def load_words(): \\\"\\\"\\\" Returns a list of valid words. Words are strings\",\n \"have to know how to use the functions import random import string WORDLIST_FILENAME\",\n \"wordlist at random \\\"\\\"\\\" return random.choice(wordlist) # end of helper code # -----------------------------------\",\n \"format, with underscores used to replace characters that have not yet been guessed.\",\n \"print \\\" \\\", len(wordlist), \\\"words loaded.\\\" return wordlist def choose_word(wordlist): \\\"\\\"\\\" wordlist (list):\",\n \"variable # so that it can be accessed from anywhere in the program\",\n \"to the # user based on whether the word has yet been correctly\",\n \"You don't need to understand this helper code, # but you will have\",\n \"raw_input('Please guess a letter:') if guess not in available_letters: print 'Oops! You\\\\'ve already\",\n \"string line = inFile.readline() # wordlist: list of strings wordlist = string.split(line) print\",\n \"def load_words(): \\\"\\\"\\\" Returns a list of valid words. Words are strings of\",\n \"+ str(len(secret_word)) + ' letters long.' num_guesses = 8 word_guessed = False guessed_letters\",\n \"+ partial_word(secret_word, guessed_letters) if secret_word == partial_word(secret_word, guessed_letters): word_guessed = True if word_guessed:\",\n \"not in my word: ' + partial_word(secret_word, guessed_letters) else: available_letters.remove(guess) guessed_letters += guess\",\n \"\\\"\\\"\\\" Returns a list of valid words. Words are strings of lowercase letters.\",\n \"'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o',\",\n \"(list): list of words (strings) Returns a word from wordlist at random \\\"\\\"\\\"\",\n \"\\\", len(wordlist), \\\"words loaded.\\\" return wordlist def choose_word(wordlist): \\\"\\\"\\\" wordlist (list): list of\",\n \"program wordlist = load_words() def partial_word(secret_word, guessed_letters): \\\"\\\"\\\" Return the secret_word in user-visible\",\n \"guessed_letters += guess print 'Good guess: ' + partial_word(secret_word, guessed_letters) if secret_word ==\",\n \"['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',\",\n \"yet been guessed. \\\"\\\"\\\" result = '' for letter in secret_word: if letter\",\n \"\\\"\\\"\\\" print 'Welcome to the game, Hangman!' secret_word = choose_word(wordlist) print 'I am\",\n \"at random \\\"\\\"\\\" return random.choice(wordlist) # end of helper code # ----------------------------------- #\",\n \"with underscores used to replace characters that have not yet been guessed. \\\"\\\"\\\"\",\n \"the hangman game. \\\"\\\"\\\" print 'Welcome to the game, Hangman!' secret_word = choose_word(wordlist)\",\n \"finish. \\\"\\\"\\\" print \\\"Loading word list from file...\\\" # inFile: file inFile =\",\n \"to use the functions import random import string WORDLIST_FILENAME = \\\"words.txt\\\" def load_words():\",\n \"return random.choice(wordlist) # end of helper code # ----------------------------------- # load the list\",\n \"\\\"\\\"\\\" result = '' for letter in secret_word: if letter in guessed_letters: result\",\n \"elif guess not in secret_word: num_guesses -= 1 available_letters.remove(guess) print 'Oops! That letter\",\n \"result + letter else: result = result + '_' return result def hangman():\",\n \"characters that have not yet been guessed. \\\"\\\"\\\" result = '' for letter\",\n \"= '' available_letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i',\",\n \"functions import random import string WORDLIST_FILENAME = \\\"words.txt\\\" def load_words(): \\\"\\\"\\\" Returns a\",\n \"-= 1 available_letters.remove(guess) print 'Oops! That letter is not in my word: '\",\n \"guessed that letter: ' + partial_word(secret_word, guessed_letters) elif guess not in secret_word: num_guesses\",\n \"guessed_letters) else: available_letters.remove(guess) guessed_letters += guess print 'Good guess: ' + partial_word(secret_word, guessed_letters)\",\n \"Helper code # You don't need to understand this helper code, # but\",\n \"\\\"\\\"\\\" Return the secret_word in user-visible format, with underscores used to replace characters\",\n \"to the game, Hangman!' secret_word = choose_word(wordlist) print 'I am thinking of a\",\n \"partial_word(secret_word, guessed_letters) else: available_letters.remove(guess) guessed_letters += guess print 'Good guess: ' + partial_word(secret_word,\",\n \"# Letter-guessing loop. Ask the user to guess a letter and respond to\",\n \"will have to know how to use the functions import random import string\",\n \"'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's',\",\n \"wordlist def choose_word(wordlist): \\\"\\\"\\\" wordlist (list): list of words (strings) Returns a word\",\n \"letter in guessed_letters: result = result + letter else: result = result +\",\n \"size of the word list, this function may take a while to finish.\",\n \"num_guesses > 0 and not word_guessed: print '-------------' print 'You have ' +\",\n \"'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'] # Letter-guessing\",\n \"the # user based on whether the word has yet been correctly guessed.\",\n \"'t', 'u', 'v', 'w', 'x', 'y', 'z'] # Letter-guessing loop. Ask the user\",\n \": Solutions # Collaborators : <your collaborators> # Time spent : <total time>\",\n \"'w', 'x', 'y', 'z'] # Letter-guessing loop. Ask the user to guess a\",\n \"return wordlist def choose_word(wordlist): \\\"\\\"\\\" wordlist (list): list of words (strings) Returns a\",\n \"wordlist variable # so that it can be accessed from anywhere in the\",\n \"can be accessed from anywhere in the program wordlist = load_words() def partial_word(secret_word,\",\n \"if secret_word == partial_word(secret_word, guessed_letters): word_guessed = True if word_guessed: print 'Congratulations, you\",\n \"list of valid words. Words are strings of lowercase letters. Depending on the\",\n \"= raw_input('Please guess a letter:') if guess not in available_letters: print 'Oops! You\\\\'ve\",\n \"' guesses left.' print 'Available letters: ' + ''.join(available_letters) guess = raw_input('Please guess\",\n \"used to replace characters that have not yet been guessed. \\\"\\\"\\\" result =\",\n \"loaded.\\\" return wordlist def choose_word(wordlist): \\\"\\\"\\\" wordlist (list): list of words (strings) Returns\",\n \"choose_word(wordlist): \\\"\\\"\\\" wordlist (list): list of words (strings) Returns a word from wordlist\",\n \"else: available_letters.remove(guess) guessed_letters += guess print 'Good guess: ' + partial_word(secret_word, guessed_letters) if\",\n \"guess not in available_letters: print 'Oops! You\\\\'ve already guessed that letter: ' +\",\n \"guessed_letters): word_guessed = True if word_guessed: print 'Congratulations, you won!' else: print 'Game\",\n \"spent : <total time> # ----------------------------------- # Helper code # You don't need\",\n \"print '-------------' print 'You have ' + str(num_guesses) + ' guesses left.' print\",\n \"'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v',\",\n \"load_words() def partial_word(secret_word, guessed_letters): \\\"\\\"\\\" Return the secret_word in user-visible format, with underscores\",\n \"= False guessed_letters = '' available_letters = ['a', 'b', 'c', 'd', 'e', 'f',\",\n \"' letters long.' num_guesses = 8 word_guessed = False guessed_letters = '' available_letters\",\n \"import string WORDLIST_FILENAME = \\\"words.txt\\\" def load_words(): \\\"\\\"\\\" Returns a list of valid\",\n \"\\\" \\\", len(wordlist), \\\"words loaded.\\\" return wordlist def choose_word(wordlist): \\\"\\\"\\\" wordlist (list): list\",\n \"the list of words into the wordlist variable # so that it can\",\n \"letters: ' + ''.join(available_letters) guess = raw_input('Please guess a letter:') if guess not\",\n \"in secret_word: num_guesses -= 1 available_letters.remove(guess) print 'Oops! That letter is not in\",\n \"'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u',\",\n \"end of helper code # ----------------------------------- # load the list of words into\",\n \"take a while to finish. \\\"\\\"\\\" print \\\"Loading word list from file...\\\" #\",\n \"to finish. \\\"\\\"\\\" print \\\"Loading word list from file...\\\" # inFile: file inFile\",\n \"list, this function may take a while to finish. \\\"\\\"\\\" print \\\"Loading word\",\n \"# inFile: file inFile = open(WORDLIST_FILENAME, 'r', 0) # line: string line =\",\n \"to guess a letter and respond to the # user based on whether\",\n \"in available_letters: print 'Oops! You\\\\'ve already guessed that letter: ' + partial_word(secret_word, guessed_letters)\",\n \"'' available_letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j',\",\n \"function may take a while to finish. \\\"\\\"\\\" print \\\"Loading word list from\",\n \"this function may take a while to finish. \\\"\\\"\\\" print \\\"Loading word list\",\n \"' + ''.join(available_letters) guess = raw_input('Please guess a letter:') if guess not in\",\n \"'d', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p',\",\n \": <your collaborators> # Time spent : <total time> # ----------------------------------- # Helper\",\n \"= result + '_' return result def hangman(): \\\"\\\"\\\" Runs the hangman game.\",\n \"code # You don't need to understand this helper code, # but you\",\n \"# Time spent : <total time> # ----------------------------------- # Helper code # You\",\n \"guessed_letters = '' available_letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h',\",\n \"but you will have to know how to use the functions import random\",\n \"not word_guessed: print '-------------' print 'You have ' + str(num_guesses) + ' guesses\",\n \"' + str(num_guesses) + ' guesses left.' print 'Available letters: ' + ''.join(available_letters)\",\n \"+= guess print 'Good guess: ' + partial_word(secret_word, guessed_letters) if secret_word == partial_word(secret_word,\",\n \"letter and respond to the # user based on whether the word has\",\n \"result = '' for letter in secret_word: if letter in guessed_letters: result =\",\n \"understand this helper code, # but you will have to know how to\",\n \"Hangman!' secret_word = choose_word(wordlist) print 'I am thinking of a word that is\",\n \"+ '_' return result def hangman(): \\\"\\\"\\\" Runs the hangman game. \\\"\\\"\\\" print\",\n \"is ' + str(len(secret_word)) + ' letters long.' num_guesses = 8 word_guessed =\",\n \"\\\"\\\"\\\" print \\\"Loading word list from file...\\\" # inFile: file inFile = open(WORDLIST_FILENAME,\",\n \"it can be accessed from anywhere in the program wordlist = load_words() def\",\n \"of strings wordlist = string.split(line) print \\\" \\\", len(wordlist), \\\"words loaded.\\\" return wordlist\",\n \"on whether the word has yet been correctly guessed. while num_guesses > 0\",\n \"False guessed_letters = '' available_letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g',\",\n \"guessed. \\\"\\\"\\\" result = '' for letter in secret_word: if letter in guessed_letters:\",\n \"\\\"\\\"\\\" return random.choice(wordlist) # end of helper code # ----------------------------------- # load the\",\n \"# user based on whether the word has yet been correctly guessed. while\",\n \"helper code # ----------------------------------- # load the list of words into the wordlist\",\n \"= open(WORDLIST_FILENAME, 'r', 0) # line: string line = inFile.readline() # wordlist: list\",\n \"# ----------------------------------- # load the list of words into the wordlist variable #\",\n \"secret_word = choose_word(wordlist) print 'I am thinking of a word that is '\",\n \"word_guessed = False guessed_letters = '' available_letters = ['a', 'b', 'c', 'd', 'e',\",\n \"wordlist = load_words() def partial_word(secret_word, guessed_letters): \\\"\\\"\\\" Return the secret_word in user-visible format,\",\n \"that have not yet been guessed. \\\"\\\"\\\" result = '' for letter in\",\n \"guess = raw_input('Please guess a letter:') if guess not in available_letters: print 'Oops!\",\n \"guessed_letters): \\\"\\\"\\\" Return the secret_word in user-visible format, with underscores used to replace\",\n \"'I am thinking of a word that is ' + str(len(secret_word)) + '\",\n \"return result def hangman(): \\\"\\\"\\\" Runs the hangman game. \\\"\\\"\\\" print 'Welcome to\",\n \"underscores used to replace characters that have not yet been guessed. \\\"\\\"\\\" result\",\n \"partial_word(secret_word, guessed_letters): word_guessed = True if word_guessed: print 'Congratulations, you won!' else: print\",\n \"whether the word has yet been correctly guessed. while num_guesses > 0 and\",\n \"''.join(available_letters) guess = raw_input('Please guess a letter:') if guess not in available_letters: print\",\n \"while to finish. \\\"\\\"\\\" print \\\"Loading word list from file...\\\" # inFile: file\",\n \"accessed from anywhere in the program wordlist = load_words() def partial_word(secret_word, guessed_letters): \\\"\\\"\\\"\",\n \"Return the secret_word in user-visible format, with underscores used to replace characters that\",\n \"(strings) Returns a word from wordlist at random \\\"\\\"\\\" return random.choice(wordlist) # end\",\n \"# 6.00 Problem Set 2 # # Hangman # Name : Solutions #\",\n \"partial_word(secret_word, guessed_letters) elif guess not in secret_word: num_guesses -= 1 available_letters.remove(guess) print 'Oops!\",\n \"is not in my word: ' + partial_word(secret_word, guessed_letters) else: available_letters.remove(guess) guessed_letters +=\",\n \"letter in secret_word: if letter in guessed_letters: result = result + letter else:\",\n \"result = result + '_' return result def hangman(): \\\"\\\"\\\" Runs the hangman\",\n \"into the wordlist variable # so that it can be accessed from anywhere\",\n \"'v', 'w', 'x', 'y', 'z'] # Letter-guessing loop. Ask the user to guess\",\n \"the size of the word list, this function may take a while to\",\n \"need to understand this helper code, # but you will have to know\",\n \"You\\\\'ve already guessed that letter: ' + partial_word(secret_word, guessed_letters) elif guess not in\",\n \"Collaborators : <your collaborators> # Time spent : <total time> # ----------------------------------- #\",\n \"not in available_letters: print 'Oops! You\\\\'ve already guessed that letter: ' + partial_word(secret_word,\",\n \"the secret_word in user-visible format, with underscores used to replace characters that have\",\n \"in the program wordlist = load_words() def partial_word(secret_word, guessed_letters): \\\"\\\"\\\" Return the secret_word\",\n \"secret_word: num_guesses -= 1 available_letters.remove(guess) print 'Oops! That letter is not in my\",\n \"to replace characters that have not yet been guessed. \\\"\\\"\\\" result = ''\",\n \"hangman game. \\\"\\\"\\\" print 'Welcome to the game, Hangman!' secret_word = choose_word(wordlist) print\",\n \"wordlist (list): list of words (strings) Returns a word from wordlist at random\",\n \"random \\\"\\\"\\\" return random.choice(wordlist) # end of helper code # ----------------------------------- # load\",\n \"letter:') if guess not in available_letters: print 'Oops! You\\\\'ve already guessed that letter:\",\n \"result = result + letter else: result = result + '_' return result\",\n \"'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'] # Letter-guessing loop. Ask\",\n \"the game, Hangman!' secret_word = choose_word(wordlist) print 'I am thinking of a word\",\n \"print \\\"Loading word list from file...\\\" # inFile: file inFile = open(WORDLIST_FILENAME, 'r',\",\n \"correctly guessed. while num_guesses > 0 and not word_guessed: print '-------------' print 'You\",\n \"' + partial_word(secret_word, guessed_letters) if secret_word == partial_word(secret_word, guessed_letters): word_guessed = True if\",\n \"'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r',\",\n \"# wordlist: list of strings wordlist = string.split(line) print \\\" \\\", len(wordlist), \\\"words\",\n \"'y', 'z'] # Letter-guessing loop. Ask the user to guess a letter and\",\n \"'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x',\",\n \"of valid words. Words are strings of lowercase letters. Depending on the size\",\n \"a letter:') if guess not in available_letters: print 'Oops! You\\\\'ve already guessed that\",\n \"letter is not in my word: ' + partial_word(secret_word, guessed_letters) else: available_letters.remove(guess) guessed_letters\",\n \"from anywhere in the program wordlist = load_words() def partial_word(secret_word, guessed_letters): \\\"\\\"\\\" Return\",\n \"helper code, # but you will have to know how to use the\",\n \"'z'] # Letter-guessing loop. Ask the user to guess a letter and respond\",\n \"1 available_letters.remove(guess) print 'Oops! That letter is not in my word: ' +\",\n \"8 word_guessed = False guessed_letters = '' available_letters = ['a', 'b', 'c', 'd',\",\n \"that letter: ' + partial_word(secret_word, guessed_letters) elif guess not in secret_word: num_guesses -=\",\n \"list of words into the wordlist variable # so that it can be\",\n \"guessed_letters) if secret_word == partial_word(secret_word, guessed_letters): word_guessed = True if word_guessed: print 'Congratulations,\",\n \"to know how to use the functions import random import string WORDLIST_FILENAME =\",\n \"for letter in secret_word: if letter in guessed_letters: result = result + letter\",\n \"inFile: file inFile = open(WORDLIST_FILENAME, 'r', 0) # line: string line = inFile.readline()\",\n \"in user-visible format, with underscores used to replace characters that have not yet\",\n \"am thinking of a word that is ' + str(len(secret_word)) + ' letters\",\n \"has yet been correctly guessed. while num_guesses > 0 and not word_guessed: print\",\n \"result def hangman(): \\\"\\\"\\\" Runs the hangman game. \\\"\\\"\\\" print 'Welcome to the\",\n \"# so that it can be accessed from anywhere in the program wordlist\",\n \"# You don't need to understand this helper code, # but you will\",\n \"line = inFile.readline() # wordlist: list of strings wordlist = string.split(line) print \\\"\",\n \"= 8 word_guessed = False guessed_letters = '' available_letters = ['a', 'b', 'c',\",\n \"num_guesses = 8 word_guessed = False guessed_letters = '' available_letters = ['a', 'b',\",\n \"word from wordlist at random \\\"\\\"\\\" return random.choice(wordlist) # end of helper code\",\n \"know how to use the functions import random import string WORDLIST_FILENAME = \\\"words.txt\\\"\",\n \"choose_word(wordlist) print 'I am thinking of a word that is ' + str(len(secret_word))\",\n \"not yet been guessed. \\\"\\\"\\\" result = '' for letter in secret_word: if\",\n \": <total time> # ----------------------------------- # Helper code # You don't need to\",\n \"'-------------' print 'You have ' + str(num_guesses) + ' guesses left.' print 'Available\",\n \"Ask the user to guess a letter and respond to the # user\",\n \"print 'Oops! That letter is not in my word: ' + partial_word(secret_word, guessed_letters)\",\n \"word_guessed = True if word_guessed: print 'Congratulations, you won!' else: print 'Game over.'\",\n \"Set 2 # # Hangman # Name : Solutions # Collaborators : <your\",\n \"of a word that is ' + str(len(secret_word)) + ' letters long.' num_guesses\",\n \"'_' return result def hangman(): \\\"\\\"\\\" Runs the hangman game. \\\"\\\"\\\" print 'Welcome\",\n \"be accessed from anywhere in the program wordlist = load_words() def partial_word(secret_word, guessed_letters):\",\n \"based on whether the word has yet been correctly guessed. while num_guesses >\",\n \"= load_words() def partial_word(secret_word, guessed_letters): \\\"\\\"\\\" Return the secret_word in user-visible format, with\",\n \"'Oops! That letter is not in my word: ' + partial_word(secret_word, guessed_letters) else:\",\n \"\\\"\\\"\\\" Runs the hangman game. \\\"\\\"\\\" print 'Welcome to the game, Hangman!' secret_word\",\n \"'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't',\",\n \"letter: ' + partial_word(secret_word, guessed_letters) elif guess not in secret_word: num_guesses -= 1\",\n \"WORDLIST_FILENAME = \\\"words.txt\\\" def load_words(): \\\"\\\"\\\" Returns a list of valid words. Words\",\n \"+ partial_word(secret_word, guessed_letters) elif guess not in secret_word: num_guesses -= 1 available_letters.remove(guess) print\",\n \"# Collaborators : <your collaborators> # Time spent : <total time> # -----------------------------------\",\n \"len(wordlist), \\\"words loaded.\\\" return wordlist def choose_word(wordlist): \\\"\\\"\\\" wordlist (list): list of words\",\n \"# ----------------------------------- # Helper code # You don't need to understand this helper\",\n \"load the list of words into the wordlist variable # so that it\",\n \"not in secret_word: num_guesses -= 1 available_letters.remove(guess) print 'Oops! That letter is not\",\n \"'s', 't', 'u', 'v', 'w', 'x', 'y', 'z'] # Letter-guessing loop. Ask the\",\n \"Returns a list of valid words. Words are strings of lowercase letters. Depending\",\n \"str(num_guesses) + ' guesses left.' print 'Available letters: ' + ''.join(available_letters) guess =\",\n \"'Good guess: ' + partial_word(secret_word, guessed_letters) if secret_word == partial_word(secret_word, guessed_letters): word_guessed =\",\n \"on the size of the word list, this function may take a while\",\n \"if letter in guessed_letters: result = result + letter else: result = result\",\n \"def partial_word(secret_word, guessed_letters): \\\"\\\"\\\" Return the secret_word in user-visible format, with underscores used\",\n \"Returns a word from wordlist at random \\\"\\\"\\\" return random.choice(wordlist) # end of\",\n \"the program wordlist = load_words() def partial_word(secret_word, guessed_letters): \\\"\\\"\\\" Return the secret_word in\",\n \"of lowercase letters. Depending on the size of the word list, this function\",\n \"'' for letter in secret_word: if letter in guessed_letters: result = result +\",\n \"= ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l',\",\n \"'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',\",\n \"'You have ' + str(num_guesses) + ' guesses left.' print 'Available letters: '\",\n \"print 'Available letters: ' + ''.join(available_letters) guess = raw_input('Please guess a letter:') if\",\n \"'r', 0) # line: string line = inFile.readline() # wordlist: list of strings\",\n \"# # Hangman # Name : Solutions # Collaborators : <your collaborators> #\",\n \"lowercase letters. Depending on the size of the word list, this function may\",\n \"user based on whether the word has yet been correctly guessed. while num_guesses\",\n \"Time spent : <total time> # ----------------------------------- # Helper code # You don't\",\n \"# Name : Solutions # Collaborators : <your collaborators> # Time spent :\",\n \"don't need to understand this helper code, # but you will have to\",\n \"guess print 'Good guess: ' + partial_word(secret_word, guessed_letters) if secret_word == partial_word(secret_word, guessed_letters):\",\n \"0 and not word_guessed: print '-------------' print 'You have ' + str(num_guesses) +\",\n \"that is ' + str(len(secret_word)) + ' letters long.' num_guesses = 8 word_guessed\",\n \"Words are strings of lowercase letters. Depending on the size of the word\",\n \"collaborators> # Time spent : <total time> # ----------------------------------- # Helper code #\",\n \"code, # but you will have to know how to use the functions\",\n \"you will have to know how to use the functions import random import\"\n]","isConversational":false}}},{"rowIdx":2396,"cells":{"ngram":{"kind":"list like","value":["auto_sdk on 2016.04.13 ''' from top.api.base import RestApi class FenxiaoRefundMessageAddRequest(RestApi): def __init__(self,domain='gw.api.taobao.com',port=80): RestApi.__init__(self,domain,","= None self.sub_order_id = None def getapiname(self): return 'taobao.fenxiao.refund.message.add' def getMultipartParas(self): return ['image']","def __init__(self,domain='gw.api.taobao.com',port=80): RestApi.__init__(self,domain, port) self.image = None self.message_content = None self.sub_order_id = None","''' Created by auto_sdk on 2016.04.13 ''' from top.api.base import RestApi class FenxiaoRefundMessageAddRequest(RestApi):","RestApi.__init__(self,domain, port) self.image = None self.message_content = None self.sub_order_id = None def getapiname(self):","None self.message_content = None self.sub_order_id = None def getapiname(self): return 'taobao.fenxiao.refund.message.add' def getMultipartParas(self):","class FenxiaoRefundMessageAddRequest(RestApi): def __init__(self,domain='gw.api.taobao.com',port=80): RestApi.__init__(self,domain, port) self.image = None self.message_content = None self.sub_order_id","__init__(self,domain='gw.api.taobao.com',port=80): RestApi.__init__(self,domain, port) self.image = None self.message_content = None self.sub_order_id = None def","Created by auto_sdk on 2016.04.13 ''' from top.api.base import RestApi class FenxiaoRefundMessageAddRequest(RestApi): def","on 2016.04.13 ''' from top.api.base import RestApi class FenxiaoRefundMessageAddRequest(RestApi): def __init__(self,domain='gw.api.taobao.com',port=80): RestApi.__init__(self,domain, port)","by auto_sdk on 2016.04.13 ''' from top.api.base import RestApi class FenxiaoRefundMessageAddRequest(RestApi): def __init__(self,domain='gw.api.taobao.com',port=80):","self.image = None self.message_content = None self.sub_order_id = None def getapiname(self): return 'taobao.fenxiao.refund.message.add'","port) self.image = None self.message_content = None self.sub_order_id = None def getapiname(self): return","self.message_content = None self.sub_order_id = None def getapiname(self): return 'taobao.fenxiao.refund.message.add' def getMultipartParas(self): return","from top.api.base import RestApi class FenxiaoRefundMessageAddRequest(RestApi): def __init__(self,domain='gw.api.taobao.com',port=80): RestApi.__init__(self,domain, port) self.image = None","2016.04.13 ''' from top.api.base import RestApi class FenxiaoRefundMessageAddRequest(RestApi): def __init__(self,domain='gw.api.taobao.com',port=80): RestApi.__init__(self,domain, port) self.image","<reponame>forestsheep/middleman ''' Created by auto_sdk on 2016.04.13 ''' from top.api.base import RestApi class","top.api.base import RestApi class FenxiaoRefundMessageAddRequest(RestApi): def __init__(self,domain='gw.api.taobao.com',port=80): RestApi.__init__(self,domain, port) self.image = None self.message_content","= None self.message_content = None self.sub_order_id = None def getapiname(self): return 'taobao.fenxiao.refund.message.add' def","RestApi class FenxiaoRefundMessageAddRequest(RestApi): def __init__(self,domain='gw.api.taobao.com',port=80): RestApi.__init__(self,domain, port) self.image = None self.message_content = None","FenxiaoRefundMessageAddRequest(RestApi): def __init__(self,domain='gw.api.taobao.com',port=80): RestApi.__init__(self,domain, port) self.image = None self.message_content = None self.sub_order_id =","import RestApi class FenxiaoRefundMessageAddRequest(RestApi): def __init__(self,domain='gw.api.taobao.com',port=80): RestApi.__init__(self,domain, port) self.image = None self.message_content =","''' from top.api.base import RestApi class FenxiaoRefundMessageAddRequest(RestApi): def __init__(self,domain='gw.api.taobao.com',port=80): RestApi.__init__(self,domain, port) self.image ="],"string":"[\n \"auto_sdk on 2016.04.13 ''' from top.api.base import RestApi class FenxiaoRefundMessageAddRequest(RestApi): def __init__(self,domain='gw.api.taobao.com',port=80): RestApi.__init__(self,domain,\",\n \"= None self.sub_order_id = None def getapiname(self): return 'taobao.fenxiao.refund.message.add' def getMultipartParas(self): return ['image']\",\n \"def __init__(self,domain='gw.api.taobao.com',port=80): RestApi.__init__(self,domain, port) self.image = None self.message_content = None self.sub_order_id = None\",\n \"''' Created by auto_sdk on 2016.04.13 ''' from top.api.base import RestApi class FenxiaoRefundMessageAddRequest(RestApi):\",\n \"RestApi.__init__(self,domain, port) self.image = None self.message_content = None self.sub_order_id = None def getapiname(self):\",\n \"None self.message_content = None self.sub_order_id = None def getapiname(self): return 'taobao.fenxiao.refund.message.add' def getMultipartParas(self):\",\n \"class FenxiaoRefundMessageAddRequest(RestApi): def __init__(self,domain='gw.api.taobao.com',port=80): RestApi.__init__(self,domain, port) self.image = None self.message_content = None self.sub_order_id\",\n \"__init__(self,domain='gw.api.taobao.com',port=80): RestApi.__init__(self,domain, port) self.image = None self.message_content = None self.sub_order_id = None def\",\n \"Created by auto_sdk on 2016.04.13 ''' from top.api.base import RestApi class FenxiaoRefundMessageAddRequest(RestApi): def\",\n \"on 2016.04.13 ''' from top.api.base import RestApi class FenxiaoRefundMessageAddRequest(RestApi): def __init__(self,domain='gw.api.taobao.com',port=80): RestApi.__init__(self,domain, port)\",\n \"by auto_sdk on 2016.04.13 ''' from top.api.base import RestApi class FenxiaoRefundMessageAddRequest(RestApi): def __init__(self,domain='gw.api.taobao.com',port=80):\",\n \"self.image = None self.message_content = None self.sub_order_id = None def getapiname(self): return 'taobao.fenxiao.refund.message.add'\",\n \"port) self.image = None self.message_content = None self.sub_order_id = None def getapiname(self): return\",\n \"self.message_content = None self.sub_order_id = None def getapiname(self): return 'taobao.fenxiao.refund.message.add' def getMultipartParas(self): return\",\n \"from top.api.base import RestApi class FenxiaoRefundMessageAddRequest(RestApi): def __init__(self,domain='gw.api.taobao.com',port=80): RestApi.__init__(self,domain, port) self.image = None\",\n \"2016.04.13 ''' from top.api.base import RestApi class FenxiaoRefundMessageAddRequest(RestApi): def __init__(self,domain='gw.api.taobao.com',port=80): RestApi.__init__(self,domain, port) self.image\",\n \"<reponame>forestsheep/middleman ''' Created by auto_sdk on 2016.04.13 ''' from top.api.base import RestApi class\",\n \"top.api.base import RestApi class FenxiaoRefundMessageAddRequest(RestApi): def __init__(self,domain='gw.api.taobao.com',port=80): RestApi.__init__(self,domain, port) self.image = None self.message_content\",\n \"= None self.message_content = None self.sub_order_id = None def getapiname(self): return 'taobao.fenxiao.refund.message.add' def\",\n \"RestApi class FenxiaoRefundMessageAddRequest(RestApi): def __init__(self,domain='gw.api.taobao.com',port=80): RestApi.__init__(self,domain, port) self.image = None self.message_content = None\",\n \"FenxiaoRefundMessageAddRequest(RestApi): def __init__(self,domain='gw.api.taobao.com',port=80): RestApi.__init__(self,domain, port) self.image = None self.message_content = None self.sub_order_id =\",\n \"import RestApi class FenxiaoRefundMessageAddRequest(RestApi): def __init__(self,domain='gw.api.taobao.com',port=80): RestApi.__init__(self,domain, port) self.image = None self.message_content =\",\n \"''' from top.api.base import RestApi class FenxiaoRefundMessageAddRequest(RestApi): def __init__(self,domain='gw.api.taobao.com',port=80): RestApi.__init__(self,domain, port) self.image =\"\n]","isConversational":false}}},{"rowIdx":2397,"cells":{"ngram":{"kind":"list like","value":["# # Licensed under the Apache License, Version 2.0 (the \"License\"); # you","writing, software # distributed under the License is distributed on an \"AS IS\"","help=\"Max iterations.\") parser.add_argument(\"--save-interval\", type=int, default=50000, help=\"Interval for saving models.\") parser.add_argument(\"--test-interval\", type=int, default=5000, help=\"Interval","KIND, either express or implied. # See the License for the specific language","parser.add_argument(\"--img-path\", type=str, default=\"~/AnimalFace-dog\", help=\"Image path.\") parser.add_argument(\"--image-size\", type=int, default=image_size, help=\"Image size.\") parser.add_argument(\"--batch-size\", \"-b\", type=int,","Unless required by applicable law or agreed to in writing, software # distributed","mode=\"train\"): from nnabla import logger import os if not os.path.exists(args.monitor_path): os.makedirs(args.monitor_path) path =","You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 #","the License is distributed on an \"AS IS\" BASIS, # WITHOUT WARRANTIES OR","# See the License for the specific language governing permissions and # limitations","= parser.parse_args() return args def save_args(args, mode=\"train\"): from nnabla import logger import os","License. # You may obtain a copy of the License at # #","os if not os.path.exists(args.monitor_path): os.makedirs(args.monitor_path) path = \"{}/Arguments-{}.txt\".format(args.monitor_path, mode) logger.info(\"Arguments are saved to","the default values of command line arguments. \"\"\" import argparse import os description","be used. When -1 is set all data is used.\") parser.add_argument(\"--lr\", type=float, default=2e-4,","and # limitations under the License. def get_args(batch_size=8, image_size=256, max_iter=100000): \"\"\" Get command","law or agreed to in writing, software # distributed under the License is","the License for the specific language governing permissions and # limitations under the","help=\"Interval for saving models.\") parser.add_argument(\"--test-interval\", type=int, default=5000, help=\"Interval for testing models.\") parser.add_argument(\"--latent\", type=int,","line arguments. Arguments set the default values of command line arguments. \"\"\" import","compliance with the License. # You may obtain a copy of the License","parser.add_argument(\"--type-config\", \"-t\", type=str, default='float', help='Type of computation. e.g. \"float\", \"half\".') parser.add_argument(\"--img-path\", type=str, default=\"~/AnimalFace-dog\",","return args def save_args(args, mode=\"train\"): from nnabla import logger import os if not","type=int, default=50000, help=\"Interval for saving models.\") parser.add_argument(\"--test-interval\", type=int, default=5000, help=\"Interval for testing models.\")","-1 is set all data is used.\") parser.add_argument(\"--lr\", type=float, default=2e-4, help=\"Learning rate\") parser.add_argument(\"--aug-list\",","with open(path, \"w\") as fp: for k, v in sorted(vars(args).items()): logger.info(\"{}={}\".format(k, v)) fp.write(\"{}={}\\n\".format(k,","logger import os if not os.path.exists(args.monitor_path): os.makedirs(args.monitor_path) path = \"{}/Arguments-{}.txt\".format(args.monitor_path, mode) logger.info(\"Arguments are","specific language governing permissions and # limitations under the License. def get_args(batch_size=8, image_size=256,","line arguments. \"\"\" import argparse import os description = \"Example of Lightweight GAN.\"","on an \"AS IS\" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,","default='float', help='Type of computation. e.g. \"float\", \"half\".') parser.add_argument(\"--img-path\", type=str, default=\"~/AnimalFace-dog\", help=\"Image path.\") parser.add_argument(\"--image-size\",","\"Example of Lightweight GAN.\" parser = argparse.ArgumentParser(description) parser.add_argument(\"-d\", \"--device-id\", type=str, default=\"0\", help=\"Device id.\")","this file except in compliance with the License. # You may obtain a","size.\") parser.add_argument(\"--max-iter\", \"-i\", type=int, default=max_iter, help=\"Max iterations.\") parser.add_argument(\"--save-interval\", type=int, default=50000, help=\"Interval for saving","2021 Sony Corporation. # Copyright 2021 Sony Group Corporation. # # Licensed under","\"-i\", type=int, default=max_iter, help=\"Max iterations.\") parser.add_argument(\"--save-interval\", type=int, default=50000, help=\"Interval for saving models.\") parser.add_argument(\"--test-interval\",","description = \"Example of Lightweight GAN.\" parser = argparse.ArgumentParser(description) parser.add_argument(\"-d\", \"--device-id\", type=str, default=\"0\",","default=\".\", help=\"Path to load parameters from\") parser.add_argument(\"--train-samples\", type=int, default=-1, help=\"Number of data to","the Apache License, Version 2.0 (the \"License\"); # you may not use this","default values of command line arguments. \"\"\" import argparse import os description =","you may not use this file except in compliance with the License. #","parameters from\") parser.add_argument(\"--train-samples\", type=int, default=-1, help=\"Number of data to be used. When -1","set all data is used.\") parser.add_argument(\"--lr\", type=float, default=2e-4, help=\"Learning rate\") parser.add_argument(\"--aug-list\", nargs=\"+\", default=[\"lrflip\",","of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable","iterations.\") parser.add_argument(\"--save-interval\", type=int, default=50000, help=\"Interval for saving models.\") parser.add_argument(\"--test-interval\", type=int, default=5000, help=\"Interval for","os description = \"Example of Lightweight GAN.\" parser = argparse.ArgumentParser(description) parser.add_argument(\"-d\", \"--device-id\", type=str,","args def save_args(args, mode=\"train\"): from nnabla import logger import os if not os.path.exists(args.monitor_path):","help=\"Device id.\") parser.add_argument(\"-c\", \"--context\", type=str, default=\"cudnn\", help=\"Context.\") parser.add_argument(\"--type-config\", \"-t\", type=str, default='float', help='Type of","GAN.\" parser = argparse.ArgumentParser(description) parser.add_argument(\"-d\", \"--device-id\", type=str, default=\"0\", help=\"Device id.\") parser.add_argument(\"-c\", \"--context\", type=str,","type=int, default=5000, help=\"Interval for testing models.\") parser.add_argument(\"--latent\", type=int, default=256, help=\"Number of latent variables.\")","under the License. def get_args(batch_size=8, image_size=256, max_iter=100000): \"\"\" Get command line arguments. Arguments","parser.add_argument(\"--lr\", type=float, default=2e-4, help=\"Learning rate\") parser.add_argument(\"--aug-list\", nargs=\"+\", default=[\"lrflip\", \"translation\", \"color\"]) args = parser.parse_args()","Copyright 2021 Sony Group Corporation. # # Licensed under the Apache License, Version","arguments. Arguments set the default values of command line arguments. \"\"\" import argparse","ANY KIND, either express or implied. # See the License for the specific","to load parameters from\") parser.add_argument(\"--train-samples\", type=int, default=-1, help=\"Number of data to be used.","default=[\"lrflip\", \"translation\", \"color\"]) args = parser.parse_args() return args def save_args(args, mode=\"train\"): from nnabla","values of command line arguments. \"\"\" import argparse import os description = \"Example","\"\"\" Get command line arguments. Arguments set the default values of command line","default=image_size, help=\"Image size.\") parser.add_argument(\"--batch-size\", \"-b\", type=int, default=batch_size, help=\"Batch size.\") parser.add_argument(\"--max-iter\", \"-i\", type=int, default=max_iter,","in compliance with the License. # You may obtain a copy of the","{}.\".format(path)) with open(path, \"w\") as fp: for k, v in sorted(vars(args).items()): logger.info(\"{}={}\".format(k, v))","License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or","argparse.ArgumentParser(description) parser.add_argument(\"-d\", \"--device-id\", type=str, default=\"0\", help=\"Device id.\") parser.add_argument(\"-c\", \"--context\", type=str, default=\"cudnn\", help=\"Context.\") parser.add_argument(\"--type-config\",","# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. #","use this file except in compliance with the License. # You may obtain","at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed","not use this file except in compliance with the License. # You may","Sony Corporation. # Copyright 2021 Sony Group Corporation. # # Licensed under the","WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See","help=\"Path to load parameters from\") parser.add_argument(\"--train-samples\", type=int, default=-1, help=\"Number of data to be","default=\"0\", help=\"Device id.\") parser.add_argument(\"-c\", \"--context\", type=str, default=\"cudnn\", help=\"Context.\") parser.add_argument(\"--type-config\", \"-t\", type=str, default='float', help='Type","parser.add_argument(\"--max-iter\", \"-i\", type=int, default=max_iter, help=\"Max iterations.\") parser.add_argument(\"--save-interval\", type=int, default=50000, help=\"Interval for saving models.\")","type=int, default=max_iter, help=\"Max iterations.\") parser.add_argument(\"--save-interval\", type=int, default=50000, help=\"Interval for saving models.\") parser.add_argument(\"--test-interval\", type=int,","data to be used. When -1 is set all data is used.\") parser.add_argument(\"--lr\",","See the License for the specific language governing permissions and # limitations under","parser.add_argument(\"-d\", \"--device-id\", type=str, default=\"0\", help=\"Device id.\") parser.add_argument(\"-c\", \"--context\", type=str, default=\"cudnn\", help=\"Context.\") parser.add_argument(\"--type-config\", \"-t\",","2021 Sony Group Corporation. # # Licensed under the Apache License, Version 2.0","of command line arguments. \"\"\" import argparse import os description = \"Example of","BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.","\"--context\", type=str, default=\"cudnn\", help=\"Context.\") parser.add_argument(\"--type-config\", \"-t\", type=str, default='float', help='Type of computation. e.g. \"float\",","computation. e.g. \"float\", \"half\".') parser.add_argument(\"--img-path\", type=str, default=\"~/AnimalFace-dog\", help=\"Image path.\") parser.add_argument(\"--image-size\", type=int, default=image_size, help=\"Image","License, Version 2.0 (the \"License\"); # you may not use this file except","help=\"Batch size.\") parser.add_argument(\"--max-iter\", \"-i\", type=int, default=max_iter, help=\"Max iterations.\") parser.add_argument(\"--save-interval\", type=int, default=50000, help=\"Interval for","# Licensed under the Apache License, Version 2.0 (the \"License\"); # you may","help=\"Number of latent variables.\") parser.add_argument(\"--monitor-path\", type=str, default=\"./result/tmp\", help=\"Monitor path.\") parser.add_argument(\"--model-load-path\", type=str, default=\".\", help=\"Path","IS\" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or","a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required","parser.add_argument(\"--train-samples\", type=int, default=-1, help=\"Number of data to be used. When -1 is set","os.path.exists(args.monitor_path): os.makedirs(args.monitor_path) path = \"{}/Arguments-{}.txt\".format(args.monitor_path, mode) logger.info(\"Arguments are saved to {}.\".format(path)) with open(path,","Arguments set the default values of command line arguments. \"\"\" import argparse import","saving models.\") parser.add_argument(\"--test-interval\", type=int, default=5000, help=\"Interval for testing models.\") parser.add_argument(\"--latent\", type=int, default=256, help=\"Number","\"--device-id\", type=str, default=\"0\", help=\"Device id.\") parser.add_argument(\"-c\", \"--context\", type=str, default=\"cudnn\", help=\"Context.\") parser.add_argument(\"--type-config\", \"-t\", type=str,","distributed on an \"AS IS\" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY","= \"Example of Lightweight GAN.\" parser = argparse.ArgumentParser(description) parser.add_argument(\"-d\", \"--device-id\", type=str, default=\"0\", help=\"Device","of data to be used. When -1 is set all data is used.\")","data is used.\") parser.add_argument(\"--lr\", type=float, default=2e-4, help=\"Learning rate\") parser.add_argument(\"--aug-list\", nargs=\"+\", default=[\"lrflip\", \"translation\", \"color\"])","# http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in","type=int, default=256, help=\"Number of latent variables.\") parser.add_argument(\"--monitor-path\", type=str, default=\"./result/tmp\", help=\"Monitor path.\") parser.add_argument(\"--model-load-path\", type=str,","is used.\") parser.add_argument(\"--lr\", type=float, default=2e-4, help=\"Learning rate\") parser.add_argument(\"--aug-list\", nargs=\"+\", default=[\"lrflip\", \"translation\", \"color\"]) args","import os if not os.path.exists(args.monitor_path): os.makedirs(args.monitor_path) path = \"{}/Arguments-{}.txt\".format(args.monitor_path, mode) logger.info(\"Arguments are saved","type=float, default=2e-4, help=\"Learning rate\") parser.add_argument(\"--aug-list\", nargs=\"+\", default=[\"lrflip\", \"translation\", \"color\"]) args = parser.parse_args() return","type=str, default=\".\", help=\"Path to load parameters from\") parser.add_argument(\"--train-samples\", type=int, default=-1, help=\"Number of data","parser.add_argument(\"--test-interval\", type=int, default=5000, help=\"Interval for testing models.\") parser.add_argument(\"--latent\", type=int, default=256, help=\"Number of latent","\"{}/Arguments-{}.txt\".format(args.monitor_path, mode) logger.info(\"Arguments are saved to {}.\".format(path)) with open(path, \"w\") as fp: for","are saved to {}.\".format(path)) with open(path, \"w\") as fp: for k, v in","parser.add_argument(\"--save-interval\", type=int, default=50000, help=\"Interval for saving models.\") parser.add_argument(\"--test-interval\", type=int, default=5000, help=\"Interval for testing","OF ANY KIND, either express or implied. # See the License for the","# Copyright 2021 Sony Group Corporation. # # Licensed under the Apache License,","2.0 (the \"License\"); # you may not use this file except in compliance","used. When -1 is set all data is used.\") parser.add_argument(\"--lr\", type=float, default=2e-4, help=\"Learning","for testing models.\") parser.add_argument(\"--latent\", type=int, default=256, help=\"Number of latent variables.\") parser.add_argument(\"--monitor-path\", type=str, default=\"./result/tmp\",","save_args(args, mode=\"train\"): from nnabla import logger import os if not os.path.exists(args.monitor_path): os.makedirs(args.monitor_path) path","testing models.\") parser.add_argument(\"--latent\", type=int, default=256, help=\"Number of latent variables.\") parser.add_argument(\"--monitor-path\", type=str, default=\"./result/tmp\", help=\"Monitor","# you may not use this file except in compliance with the License.","def save_args(args, mode=\"train\"): from nnabla import logger import os if not os.path.exists(args.monitor_path): os.makedirs(args.monitor_path)","load parameters from\") parser.add_argument(\"--train-samples\", type=int, default=-1, help=\"Number of data to be used. When","help='Type of computation. e.g. \"float\", \"half\".') parser.add_argument(\"--img-path\", type=str, default=\"~/AnimalFace-dog\", help=\"Image path.\") parser.add_argument(\"--image-size\", type=int,","<filename>image-generation/slegan/args.py # Copyright 2021 Sony Corporation. # Copyright 2021 Sony Group Corporation. #","agreed to in writing, software # distributed under the License is distributed on","help=\"Learning rate\") parser.add_argument(\"--aug-list\", nargs=\"+\", default=[\"lrflip\", \"translation\", \"color\"]) args = parser.parse_args() return args def","id.\") parser.add_argument(\"-c\", \"--context\", type=str, default=\"cudnn\", help=\"Context.\") parser.add_argument(\"--type-config\", \"-t\", type=str, default='float', help='Type of computation.","WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the","default=-1, help=\"Number of data to be used. When -1 is set all data","(the \"License\"); # you may not use this file except in compliance with","Lightweight GAN.\" parser = argparse.ArgumentParser(description) parser.add_argument(\"-d\", \"--device-id\", type=str, default=\"0\", help=\"Device id.\") parser.add_argument(\"-c\", \"--context\",","When -1 is set all data is used.\") parser.add_argument(\"--lr\", type=float, default=2e-4, help=\"Learning rate\")","default=max_iter, help=\"Max iterations.\") parser.add_argument(\"--save-interval\", type=int, default=50000, help=\"Interval for saving models.\") parser.add_argument(\"--test-interval\", type=int, default=5000,","all data is used.\") parser.add_argument(\"--lr\", type=float, default=2e-4, help=\"Learning rate\") parser.add_argument(\"--aug-list\", nargs=\"+\", default=[\"lrflip\", \"translation\",","nnabla import logger import os if not os.path.exists(args.monitor_path): os.makedirs(args.monitor_path) path = \"{}/Arguments-{}.txt\".format(args.monitor_path, mode)","import os description = \"Example of Lightweight GAN.\" parser = argparse.ArgumentParser(description) parser.add_argument(\"-d\", \"--device-id\",","path.\") parser.add_argument(\"--model-load-path\", type=str, default=\".\", help=\"Path to load parameters from\") parser.add_argument(\"--train-samples\", type=int, default=-1, help=\"Number","# # Unless required by applicable law or agreed to in writing, software","help=\"Monitor path.\") parser.add_argument(\"--model-load-path\", type=str, default=\".\", help=\"Path to load parameters from\") parser.add_argument(\"--train-samples\", type=int, default=-1,","e.g. \"float\", \"half\".') parser.add_argument(\"--img-path\", type=str, default=\"~/AnimalFace-dog\", help=\"Image path.\") parser.add_argument(\"--image-size\", type=int, default=image_size, help=\"Image size.\")","import logger import os if not os.path.exists(args.monitor_path): os.makedirs(args.monitor_path) path = \"{}/Arguments-{}.txt\".format(args.monitor_path, mode) logger.info(\"Arguments","express or implied. # See the License for the specific language governing permissions","is set all data is used.\") parser.add_argument(\"--lr\", type=float, default=2e-4, help=\"Learning rate\") parser.add_argument(\"--aug-list\", nargs=\"+\",","Version 2.0 (the \"License\"); # you may not use this file except in","# Unless required by applicable law or agreed to in writing, software #","except in compliance with the License. # You may obtain a copy of","default=\"./result/tmp\", help=\"Monitor path.\") parser.add_argument(\"--model-load-path\", type=str, default=\".\", help=\"Path to load parameters from\") parser.add_argument(\"--train-samples\", type=int,","path.\") parser.add_argument(\"--image-size\", type=int, default=image_size, help=\"Image size.\") parser.add_argument(\"--batch-size\", \"-b\", type=int, default=batch_size, help=\"Batch size.\") parser.add_argument(\"--max-iter\",","by applicable law or agreed to in writing, software # distributed under the","os.makedirs(args.monitor_path) path = \"{}/Arguments-{}.txt\".format(args.monitor_path, mode) logger.info(\"Arguments are saved to {}.\".format(path)) with open(path, \"w\")","copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by","language governing permissions and # limitations under the License. def get_args(batch_size=8, image_size=256, max_iter=100000):","used.\") parser.add_argument(\"--lr\", type=float, default=2e-4, help=\"Learning rate\") parser.add_argument(\"--aug-list\", nargs=\"+\", default=[\"lrflip\", \"translation\", \"color\"]) args =","# limitations under the License. def get_args(batch_size=8, image_size=256, max_iter=100000): \"\"\" Get command line","either express or implied. # See the License for the specific language governing","parser.add_argument(\"--monitor-path\", type=str, default=\"./result/tmp\", help=\"Monitor path.\") parser.add_argument(\"--model-load-path\", type=str, default=\".\", help=\"Path to load parameters from\")","software # distributed under the License is distributed on an \"AS IS\" BASIS,","help=\"Image size.\") parser.add_argument(\"--batch-size\", \"-b\", type=int, default=batch_size, help=\"Batch size.\") parser.add_argument(\"--max-iter\", \"-i\", type=int, default=max_iter, help=\"Max","models.\") parser.add_argument(\"--test-interval\", type=int, default=5000, help=\"Interval for testing models.\") parser.add_argument(\"--latent\", type=int, default=256, help=\"Number of","max_iter=100000): \"\"\" Get command line arguments. Arguments set the default values of command","# You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0","may not use this file except in compliance with the License. # You","License is distributed on an \"AS IS\" BASIS, # WITHOUT WARRANTIES OR CONDITIONS","type=str, default=\"0\", help=\"Device id.\") parser.add_argument(\"-c\", \"--context\", type=str, default=\"cudnn\", help=\"Context.\") parser.add_argument(\"--type-config\", \"-t\", type=str, default='float',","\"half\".') parser.add_argument(\"--img-path\", type=str, default=\"~/AnimalFace-dog\", help=\"Image path.\") parser.add_argument(\"--image-size\", type=int, default=image_size, help=\"Image size.\") parser.add_argument(\"--batch-size\", \"-b\",","= argparse.ArgumentParser(description) parser.add_argument(\"-d\", \"--device-id\", type=str, default=\"0\", help=\"Device id.\") parser.add_argument(\"-c\", \"--context\", type=str, default=\"cudnn\", help=\"Context.\")","command line arguments. \"\"\" import argparse import os description = \"Example of Lightweight","Licensed under the Apache License, Version 2.0 (the \"License\"); # you may not","an \"AS IS\" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either","# # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to","the specific language governing permissions and # limitations under the License. def get_args(batch_size=8,","default=\"cudnn\", help=\"Context.\") parser.add_argument(\"--type-config\", \"-t\", type=str, default='float', help='Type of computation. e.g. \"float\", \"half\".') parser.add_argument(\"--img-path\",","parser.add_argument(\"-c\", \"--context\", type=str, default=\"cudnn\", help=\"Context.\") parser.add_argument(\"--type-config\", \"-t\", type=str, default='float', help='Type of computation. e.g.","file except in compliance with the License. # You may obtain a copy","help=\"Interval for testing models.\") parser.add_argument(\"--latent\", type=int, default=256, help=\"Number of latent variables.\") parser.add_argument(\"--monitor-path\", type=str,","image_size=256, max_iter=100000): \"\"\" Get command line arguments. Arguments set the default values of","default=5000, help=\"Interval for testing models.\") parser.add_argument(\"--latent\", type=int, default=256, help=\"Number of latent variables.\") parser.add_argument(\"--monitor-path\",","parser.add_argument(\"--batch-size\", \"-b\", type=int, default=batch_size, help=\"Batch size.\") parser.add_argument(\"--max-iter\", \"-i\", type=int, default=max_iter, help=\"Max iterations.\") parser.add_argument(\"--save-interval\",","latent variables.\") parser.add_argument(\"--monitor-path\", type=str, default=\"./result/tmp\", help=\"Monitor path.\") parser.add_argument(\"--model-load-path\", type=str, default=\".\", help=\"Path to load","default=256, help=\"Number of latent variables.\") parser.add_argument(\"--monitor-path\", type=str, default=\"./result/tmp\", help=\"Monitor path.\") parser.add_argument(\"--model-load-path\", type=str, default=\".\",","parser.add_argument(\"--aug-list\", nargs=\"+\", default=[\"lrflip\", \"translation\", \"color\"]) args = parser.parse_args() return args def save_args(args, mode=\"train\"):","under the License is distributed on an \"AS IS\" BASIS, # WITHOUT WARRANTIES","= \"{}/Arguments-{}.txt\".format(args.monitor_path, mode) logger.info(\"Arguments are saved to {}.\".format(path)) with open(path, \"w\") as fp:","Corporation. # # Licensed under the Apache License, Version 2.0 (the \"License\"); #","License for the specific language governing permissions and # limitations under the License.","Group Corporation. # # Licensed under the Apache License, Version 2.0 (the \"License\");","the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law","of computation. e.g. \"float\", \"half\".') parser.add_argument(\"--img-path\", type=str, default=\"~/AnimalFace-dog\", help=\"Image path.\") parser.add_argument(\"--image-size\", type=int, default=image_size,","to {}.\".format(path)) with open(path, \"w\") as fp: for k, v in sorted(vars(args).items()): logger.info(\"{}={}\".format(k,","default=batch_size, help=\"Batch size.\") parser.add_argument(\"--max-iter\", \"-i\", type=int, default=max_iter, help=\"Max iterations.\") parser.add_argument(\"--save-interval\", type=int, default=50000, help=\"Interval","args = parser.parse_args() return args def save_args(args, mode=\"train\"): from nnabla import logger import","open(path, \"w\") as fp: for k, v in sorted(vars(args).items()): logger.info(\"{}={}\".format(k, v)) fp.write(\"{}={}\\n\".format(k, v))","the License. # You may obtain a copy of the License at #","\"float\", \"half\".') parser.add_argument(\"--img-path\", type=str, default=\"~/AnimalFace-dog\", help=\"Image path.\") parser.add_argument(\"--image-size\", type=int, default=image_size, help=\"Image size.\") parser.add_argument(\"--batch-size\",","parser.add_argument(\"--image-size\", type=int, default=image_size, help=\"Image size.\") parser.add_argument(\"--batch-size\", \"-b\", type=int, default=batch_size, help=\"Batch size.\") parser.add_argument(\"--max-iter\", \"-i\",","to in writing, software # distributed under the License is distributed on an","type=str, default=\"~/AnimalFace-dog\", help=\"Image path.\") parser.add_argument(\"--image-size\", type=int, default=image_size, help=\"Image size.\") parser.add_argument(\"--batch-size\", \"-b\", type=int, default=batch_size,","\"AS IS\" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express","help=\"Context.\") parser.add_argument(\"--type-config\", \"-t\", type=str, default='float', help='Type of computation. e.g. \"float\", \"half\".') parser.add_argument(\"--img-path\", type=str,","Get command line arguments. Arguments set the default values of command line arguments.","# distributed under the License is distributed on an \"AS IS\" BASIS, #","of latent variables.\") parser.add_argument(\"--monitor-path\", type=str, default=\"./result/tmp\", help=\"Monitor path.\") parser.add_argument(\"--model-load-path\", type=str, default=\".\", help=\"Path to","implied. # See the License for the specific language governing permissions and #","type=str, default='float', help='Type of computation. e.g. \"float\", \"half\".') parser.add_argument(\"--img-path\", type=str, default=\"~/AnimalFace-dog\", help=\"Image path.\")","\"License\"); # you may not use this file except in compliance with the","is distributed on an \"AS IS\" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF","obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless","from\") parser.add_argument(\"--train-samples\", type=int, default=-1, help=\"Number of data to be used. When -1 is","required by applicable law or agreed to in writing, software # distributed under","type=int, default=-1, help=\"Number of data to be used. When -1 is set all","type=int, default=batch_size, help=\"Batch size.\") parser.add_argument(\"--max-iter\", \"-i\", type=int, default=max_iter, help=\"Max iterations.\") parser.add_argument(\"--save-interval\", type=int, default=50000,","default=2e-4, help=\"Learning rate\") parser.add_argument(\"--aug-list\", nargs=\"+\", default=[\"lrflip\", \"translation\", \"color\"]) args = parser.parse_args() return args","models.\") parser.add_argument(\"--latent\", type=int, default=256, help=\"Number of latent variables.\") parser.add_argument(\"--monitor-path\", type=str, default=\"./result/tmp\", help=\"Monitor path.\")","help=\"Number of data to be used. When -1 is set all data is","applicable law or agreed to in writing, software # distributed under the License","of Lightweight GAN.\" parser = argparse.ArgumentParser(description) parser.add_argument(\"-d\", \"--device-id\", type=str, default=\"0\", help=\"Device id.\") parser.add_argument(\"-c\",","Sony Group Corporation. # # Licensed under the Apache License, Version 2.0 (the","Corporation. # Copyright 2021 Sony Group Corporation. # # Licensed under the Apache","variables.\") parser.add_argument(\"--monitor-path\", type=str, default=\"./result/tmp\", help=\"Monitor path.\") parser.add_argument(\"--model-load-path\", type=str, default=\".\", help=\"Path to load parameters","parser.add_argument(\"--model-load-path\", type=str, default=\".\", help=\"Path to load parameters from\") parser.add_argument(\"--train-samples\", type=int, default=-1, help=\"Number of","argparse import os description = \"Example of Lightweight GAN.\" parser = argparse.ArgumentParser(description) parser.add_argument(\"-d\",","logger.info(\"Arguments are saved to {}.\".format(path)) with open(path, \"w\") as fp: for k, v","limitations under the License. def get_args(batch_size=8, image_size=256, max_iter=100000): \"\"\" Get command line arguments.","governing permissions and # limitations under the License. def get_args(batch_size=8, image_size=256, max_iter=100000): \"\"\"","parser.add_argument(\"--latent\", type=int, default=256, help=\"Number of latent variables.\") parser.add_argument(\"--monitor-path\", type=str, default=\"./result/tmp\", help=\"Monitor path.\") parser.add_argument(\"--model-load-path\",","for saving models.\") parser.add_argument(\"--test-interval\", type=int, default=5000, help=\"Interval for testing models.\") parser.add_argument(\"--latent\", type=int, default=256,","get_args(batch_size=8, image_size=256, max_iter=100000): \"\"\" Get command line arguments. Arguments set the default values","or agreed to in writing, software # distributed under the License is distributed","path = \"{}/Arguments-{}.txt\".format(args.monitor_path, mode) logger.info(\"Arguments are saved to {}.\".format(path)) with open(path, \"w\") as","# Copyright 2021 Sony Corporation. # Copyright 2021 Sony Group Corporation. # #","def get_args(batch_size=8, image_size=256, max_iter=100000): \"\"\" Get command line arguments. Arguments set the default","\"color\"]) args = parser.parse_args() return args def save_args(args, mode=\"train\"): from nnabla import logger","parser.parse_args() return args def save_args(args, mode=\"train\"): from nnabla import logger import os if","mode) logger.info(\"Arguments are saved to {}.\".format(path)) with open(path, \"w\") as fp: for k,","or implied. # See the License for the specific language governing permissions and","command line arguments. Arguments set the default values of command line arguments. \"\"\"","default=50000, help=\"Interval for saving models.\") parser.add_argument(\"--test-interval\", type=int, default=5000, help=\"Interval for testing models.\") parser.add_argument(\"--latent\",","the License. def get_args(batch_size=8, image_size=256, max_iter=100000): \"\"\" Get command line arguments. Arguments set","parser = argparse.ArgumentParser(description) parser.add_argument(\"-d\", \"--device-id\", type=str, default=\"0\", help=\"Device id.\") parser.add_argument(\"-c\", \"--context\", type=str, default=\"cudnn\",","import argparse import os description = \"Example of Lightweight GAN.\" parser = argparse.ArgumentParser(description)","distributed under the License is distributed on an \"AS IS\" BASIS, # WITHOUT","CONDITIONS OF ANY KIND, either express or implied. # See the License for","arguments. \"\"\" import argparse import os description = \"Example of Lightweight GAN.\" parser","\"-t\", type=str, default='float', help='Type of computation. e.g. \"float\", \"half\".') parser.add_argument(\"--img-path\", type=str, default=\"~/AnimalFace-dog\", help=\"Image","Apache License, Version 2.0 (the \"License\"); # you may not use this file","type=str, default=\"cudnn\", help=\"Context.\") parser.add_argument(\"--type-config\", \"-t\", type=str, default='float', help='Type of computation. e.g. \"float\", \"half\".')","default=\"~/AnimalFace-dog\", help=\"Image path.\") parser.add_argument(\"--image-size\", type=int, default=image_size, help=\"Image size.\") parser.add_argument(\"--batch-size\", \"-b\", type=int, default=batch_size, help=\"Batch","type=int, default=image_size, help=\"Image size.\") parser.add_argument(\"--batch-size\", \"-b\", type=int, default=batch_size, help=\"Batch size.\") parser.add_argument(\"--max-iter\", \"-i\", type=int,","OR CONDITIONS OF ANY KIND, either express or implied. # See the License","may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # #","type=str, default=\"./result/tmp\", help=\"Monitor path.\") parser.add_argument(\"--model-load-path\", type=str, default=\".\", help=\"Path to load parameters from\") parser.add_argument(\"--train-samples\",","if not os.path.exists(args.monitor_path): os.makedirs(args.monitor_path) path = \"{}/Arguments-{}.txt\".format(args.monitor_path, mode) logger.info(\"Arguments are saved to {}.\".format(path))","saved to {}.\".format(path)) with open(path, \"w\") as fp: for k, v in sorted(vars(args).items()):","License. def get_args(batch_size=8, image_size=256, max_iter=100000): \"\"\" Get command line arguments. Arguments set the","\"\"\" import argparse import os description = \"Example of Lightweight GAN.\" parser =","with the License. # You may obtain a copy of the License at","Copyright 2021 Sony Corporation. # Copyright 2021 Sony Group Corporation. # # Licensed","http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing,","set the default values of command line arguments. \"\"\" import argparse import os","rate\") parser.add_argument(\"--aug-list\", nargs=\"+\", default=[\"lrflip\", \"translation\", \"color\"]) args = parser.parse_args() return args def save_args(args,","help=\"Image path.\") parser.add_argument(\"--image-size\", type=int, default=image_size, help=\"Image size.\") parser.add_argument(\"--batch-size\", \"-b\", type=int, default=batch_size, help=\"Batch size.\")","in writing, software # distributed under the License is distributed on an \"AS","\"-b\", type=int, default=batch_size, help=\"Batch size.\") parser.add_argument(\"--max-iter\", \"-i\", type=int, default=max_iter, help=\"Max iterations.\") parser.add_argument(\"--save-interval\", type=int,","for the specific language governing permissions and # limitations under the License. def","to be used. When -1 is set all data is used.\") parser.add_argument(\"--lr\", type=float,","from nnabla import logger import os if not os.path.exists(args.monitor_path): os.makedirs(args.monitor_path) path = \"{}/Arguments-{}.txt\".format(args.monitor_path,","\"translation\", \"color\"]) args = parser.parse_args() return args def save_args(args, mode=\"train\"): from nnabla import","permissions and # limitations under the License. def get_args(batch_size=8, image_size=256, max_iter=100000): \"\"\" Get","under the Apache License, Version 2.0 (the \"License\"); # you may not use","nargs=\"+\", default=[\"lrflip\", \"translation\", \"color\"]) args = parser.parse_args() return args def save_args(args, mode=\"train\"): from","size.\") parser.add_argument(\"--batch-size\", \"-b\", type=int, default=batch_size, help=\"Batch size.\") parser.add_argument(\"--max-iter\", \"-i\", type=int, default=max_iter, help=\"Max iterations.\")","not os.path.exists(args.monitor_path): os.makedirs(args.monitor_path) path = \"{}/Arguments-{}.txt\".format(args.monitor_path, mode) logger.info(\"Arguments are saved to {}.\".format(path)) with"],"string":"[\n \"# # Licensed under the Apache License, Version 2.0 (the \\\"License\\\"); # you\",\n \"writing, software # distributed under the License is distributed on an \\\"AS IS\\\"\",\n \"help=\\\"Max iterations.\\\") parser.add_argument(\\\"--save-interval\\\", type=int, default=50000, help=\\\"Interval for saving models.\\\") parser.add_argument(\\\"--test-interval\\\", type=int, default=5000, help=\\\"Interval\",\n \"KIND, either express or implied. # See the License for the specific language\",\n \"parser.add_argument(\\\"--img-path\\\", type=str, default=\\\"~/AnimalFace-dog\\\", help=\\\"Image path.\\\") parser.add_argument(\\\"--image-size\\\", type=int, default=image_size, help=\\\"Image size.\\\") parser.add_argument(\\\"--batch-size\\\", \\\"-b\\\", type=int,\",\n \"Unless required by applicable law or agreed to in writing, software # distributed\",\n \"mode=\\\"train\\\"): from nnabla import logger import os if not os.path.exists(args.monitor_path): os.makedirs(args.monitor_path) path =\",\n \"You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 #\",\n \"the License is distributed on an \\\"AS IS\\\" BASIS, # WITHOUT WARRANTIES OR\",\n \"# See the License for the specific language governing permissions and # limitations\",\n \"= parser.parse_args() return args def save_args(args, mode=\\\"train\\\"): from nnabla import logger import os\",\n \"License. # You may obtain a copy of the License at # #\",\n \"os if not os.path.exists(args.monitor_path): os.makedirs(args.monitor_path) path = \\\"{}/Arguments-{}.txt\\\".format(args.monitor_path, mode) logger.info(\\\"Arguments are saved to\",\n \"the default values of command line arguments. \\\"\\\"\\\" import argparse import os description\",\n \"be used. When -1 is set all data is used.\\\") parser.add_argument(\\\"--lr\\\", type=float, default=2e-4,\",\n \"and # limitations under the License. def get_args(batch_size=8, image_size=256, max_iter=100000): \\\"\\\"\\\" Get command\",\n \"law or agreed to in writing, software # distributed under the License is\",\n \"the License for the specific language governing permissions and # limitations under the\",\n \"help=\\\"Interval for saving models.\\\") parser.add_argument(\\\"--test-interval\\\", type=int, default=5000, help=\\\"Interval for testing models.\\\") parser.add_argument(\\\"--latent\\\", type=int,\",\n \"line arguments. Arguments set the default values of command line arguments. \\\"\\\"\\\" import\",\n \"compliance with the License. # You may obtain a copy of the License\",\n \"parser.add_argument(\\\"--type-config\\\", \\\"-t\\\", type=str, default='float', help='Type of computation. e.g. \\\"float\\\", \\\"half\\\".') parser.add_argument(\\\"--img-path\\\", type=str, default=\\\"~/AnimalFace-dog\\\",\",\n \"return args def save_args(args, mode=\\\"train\\\"): from nnabla import logger import os if not\",\n \"type=int, default=50000, help=\\\"Interval for saving models.\\\") parser.add_argument(\\\"--test-interval\\\", type=int, default=5000, help=\\\"Interval for testing models.\\\")\",\n \"-1 is set all data is used.\\\") parser.add_argument(\\\"--lr\\\", type=float, default=2e-4, help=\\\"Learning rate\\\") parser.add_argument(\\\"--aug-list\\\",\",\n \"with open(path, \\\"w\\\") as fp: for k, v in sorted(vars(args).items()): logger.info(\\\"{}={}\\\".format(k, v)) fp.write(\\\"{}={}\\\\n\\\".format(k,\",\n \"logger import os if not os.path.exists(args.monitor_path): os.makedirs(args.monitor_path) path = \\\"{}/Arguments-{}.txt\\\".format(args.monitor_path, mode) logger.info(\\\"Arguments are\",\n \"specific language governing permissions and # limitations under the License. def get_args(batch_size=8, image_size=256,\",\n \"line arguments. \\\"\\\"\\\" import argparse import os description = \\\"Example of Lightweight GAN.\\\"\",\n \"on an \\\"AS IS\\\" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\",\n \"default='float', help='Type of computation. e.g. \\\"float\\\", \\\"half\\\".') parser.add_argument(\\\"--img-path\\\", type=str, default=\\\"~/AnimalFace-dog\\\", help=\\\"Image path.\\\") parser.add_argument(\\\"--image-size\\\",\",\n \"\\\"Example of Lightweight GAN.\\\" parser = argparse.ArgumentParser(description) parser.add_argument(\\\"-d\\\", \\\"--device-id\\\", type=str, default=\\\"0\\\", help=\\\"Device id.\\\")\",\n \"this file except in compliance with the License. # You may obtain a\",\n \"size.\\\") parser.add_argument(\\\"--max-iter\\\", \\\"-i\\\", type=int, default=max_iter, help=\\\"Max iterations.\\\") parser.add_argument(\\\"--save-interval\\\", type=int, default=50000, help=\\\"Interval for saving\",\n \"2021 Sony Corporation. # Copyright 2021 Sony Group Corporation. # # Licensed under\",\n \"\\\"-i\\\", type=int, default=max_iter, help=\\\"Max iterations.\\\") parser.add_argument(\\\"--save-interval\\\", type=int, default=50000, help=\\\"Interval for saving models.\\\") parser.add_argument(\\\"--test-interval\\\",\",\n \"description = \\\"Example of Lightweight GAN.\\\" parser = argparse.ArgumentParser(description) parser.add_argument(\\\"-d\\\", \\\"--device-id\\\", type=str, default=\\\"0\\\",\",\n \"default=\\\".\\\", help=\\\"Path to load parameters from\\\") parser.add_argument(\\\"--train-samples\\\", type=int, default=-1, help=\\\"Number of data to\",\n \"the Apache License, Version 2.0 (the \\\"License\\\"); # you may not use this\",\n \"default values of command line arguments. \\\"\\\"\\\" import argparse import os description =\",\n \"you may not use this file except in compliance with the License. #\",\n \"parameters from\\\") parser.add_argument(\\\"--train-samples\\\", type=int, default=-1, help=\\\"Number of data to be used. When -1\",\n \"set all data is used.\\\") parser.add_argument(\\\"--lr\\\", type=float, default=2e-4, help=\\\"Learning rate\\\") parser.add_argument(\\\"--aug-list\\\", nargs=\\\"+\\\", default=[\\\"lrflip\\\",\",\n \"of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable\",\n \"iterations.\\\") parser.add_argument(\\\"--save-interval\\\", type=int, default=50000, help=\\\"Interval for saving models.\\\") parser.add_argument(\\\"--test-interval\\\", type=int, default=5000, help=\\\"Interval for\",\n \"os description = \\\"Example of Lightweight GAN.\\\" parser = argparse.ArgumentParser(description) parser.add_argument(\\\"-d\\\", \\\"--device-id\\\", type=str,\",\n \"args def save_args(args, mode=\\\"train\\\"): from nnabla import logger import os if not os.path.exists(args.monitor_path):\",\n \"help=\\\"Device id.\\\") parser.add_argument(\\\"-c\\\", \\\"--context\\\", type=str, default=\\\"cudnn\\\", help=\\\"Context.\\\") parser.add_argument(\\\"--type-config\\\", \\\"-t\\\", type=str, default='float', help='Type of\",\n \"GAN.\\\" parser = argparse.ArgumentParser(description) parser.add_argument(\\\"-d\\\", \\\"--device-id\\\", type=str, default=\\\"0\\\", help=\\\"Device id.\\\") parser.add_argument(\\\"-c\\\", \\\"--context\\\", type=str,\",\n \"type=int, default=5000, help=\\\"Interval for testing models.\\\") parser.add_argument(\\\"--latent\\\", type=int, default=256, help=\\\"Number of latent variables.\\\")\",\n \"under the License. def get_args(batch_size=8, image_size=256, max_iter=100000): \\\"\\\"\\\" Get command line arguments. Arguments\",\n \"parser.add_argument(\\\"--lr\\\", type=float, default=2e-4, help=\\\"Learning rate\\\") parser.add_argument(\\\"--aug-list\\\", nargs=\\\"+\\\", default=[\\\"lrflip\\\", \\\"translation\\\", \\\"color\\\"]) args = parser.parse_args()\",\n \"Copyright 2021 Sony Group Corporation. # # Licensed under the Apache License, Version\",\n \"arguments. Arguments set the default values of command line arguments. \\\"\\\"\\\" import argparse\",\n \"ANY KIND, either express or implied. # See the License for the specific\",\n \"to load parameters from\\\") parser.add_argument(\\\"--train-samples\\\", type=int, default=-1, help=\\\"Number of data to be used.\",\n \"default=[\\\"lrflip\\\", \\\"translation\\\", \\\"color\\\"]) args = parser.parse_args() return args def save_args(args, mode=\\\"train\\\"): from nnabla\",\n \"values of command line arguments. \\\"\\\"\\\" import argparse import os description = \\\"Example\",\n \"\\\"\\\"\\\" Get command line arguments. Arguments set the default values of command line\",\n \"default=image_size, help=\\\"Image size.\\\") parser.add_argument(\\\"--batch-size\\\", \\\"-b\\\", type=int, default=batch_size, help=\\\"Batch size.\\\") parser.add_argument(\\\"--max-iter\\\", \\\"-i\\\", type=int, default=max_iter,\",\n \"in compliance with the License. # You may obtain a copy of the\",\n \"{}.\\\".format(path)) with open(path, \\\"w\\\") as fp: for k, v in sorted(vars(args).items()): logger.info(\\\"{}={}\\\".format(k, v))\",\n \"License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or\",\n \"argparse.ArgumentParser(description) parser.add_argument(\\\"-d\\\", \\\"--device-id\\\", type=str, default=\\\"0\\\", help=\\\"Device id.\\\") parser.add_argument(\\\"-c\\\", \\\"--context\\\", type=str, default=\\\"cudnn\\\", help=\\\"Context.\\\") parser.add_argument(\\\"--type-config\\\",\",\n \"# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. #\",\n \"use this file except in compliance with the License. # You may obtain\",\n \"at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed\",\n \"not use this file except in compliance with the License. # You may\",\n \"Sony Corporation. # Copyright 2021 Sony Group Corporation. # # Licensed under the\",\n \"WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See\",\n \"help=\\\"Path to load parameters from\\\") parser.add_argument(\\\"--train-samples\\\", type=int, default=-1, help=\\\"Number of data to be\",\n \"default=\\\"0\\\", help=\\\"Device id.\\\") parser.add_argument(\\\"-c\\\", \\\"--context\\\", type=str, default=\\\"cudnn\\\", help=\\\"Context.\\\") parser.add_argument(\\\"--type-config\\\", \\\"-t\\\", type=str, default='float', help='Type\",\n \"parser.add_argument(\\\"--max-iter\\\", \\\"-i\\\", type=int, default=max_iter, help=\\\"Max iterations.\\\") parser.add_argument(\\\"--save-interval\\\", type=int, default=50000, help=\\\"Interval for saving models.\\\")\",\n \"type=int, default=max_iter, help=\\\"Max iterations.\\\") parser.add_argument(\\\"--save-interval\\\", type=int, default=50000, help=\\\"Interval for saving models.\\\") parser.add_argument(\\\"--test-interval\\\", type=int,\",\n \"data to be used. When -1 is set all data is used.\\\") parser.add_argument(\\\"--lr\\\",\",\n \"See the License for the specific language governing permissions and # limitations under\",\n \"parser.add_argument(\\\"-d\\\", \\\"--device-id\\\", type=str, default=\\\"0\\\", help=\\\"Device id.\\\") parser.add_argument(\\\"-c\\\", \\\"--context\\\", type=str, default=\\\"cudnn\\\", help=\\\"Context.\\\") parser.add_argument(\\\"--type-config\\\", \\\"-t\\\",\",\n \"2021 Sony Group Corporation. # # Licensed under the Apache License, Version 2.0\",\n \"of command line arguments. \\\"\\\"\\\" import argparse import os description = \\\"Example of\",\n \"BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\",\n \"\\\"--context\\\", type=str, default=\\\"cudnn\\\", help=\\\"Context.\\\") parser.add_argument(\\\"--type-config\\\", \\\"-t\\\", type=str, default='float', help='Type of computation. e.g. \\\"float\\\",\",\n \"computation. e.g. \\\"float\\\", \\\"half\\\".') parser.add_argument(\\\"--img-path\\\", type=str, default=\\\"~/AnimalFace-dog\\\", help=\\\"Image path.\\\") parser.add_argument(\\\"--image-size\\\", type=int, default=image_size, help=\\\"Image\",\n \"License, Version 2.0 (the \\\"License\\\"); # you may not use this file except\",\n \"help=\\\"Batch size.\\\") parser.add_argument(\\\"--max-iter\\\", \\\"-i\\\", type=int, default=max_iter, help=\\\"Max iterations.\\\") parser.add_argument(\\\"--save-interval\\\", type=int, default=50000, help=\\\"Interval for\",\n \"# Licensed under the Apache License, Version 2.0 (the \\\"License\\\"); # you may\",\n \"help=\\\"Number of latent variables.\\\") parser.add_argument(\\\"--monitor-path\\\", type=str, default=\\\"./result/tmp\\\", help=\\\"Monitor path.\\\") parser.add_argument(\\\"--model-load-path\\\", type=str, default=\\\".\\\", help=\\\"Path\",\n \"IS\\\" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or\",\n \"a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required\",\n \"parser.add_argument(\\\"--train-samples\\\", type=int, default=-1, help=\\\"Number of data to be used. When -1 is set\",\n \"os.path.exists(args.monitor_path): os.makedirs(args.monitor_path) path = \\\"{}/Arguments-{}.txt\\\".format(args.monitor_path, mode) logger.info(\\\"Arguments are saved to {}.\\\".format(path)) with open(path,\",\n \"Arguments set the default values of command line arguments. \\\"\\\"\\\" import argparse import\",\n \"saving models.\\\") parser.add_argument(\\\"--test-interval\\\", type=int, default=5000, help=\\\"Interval for testing models.\\\") parser.add_argument(\\\"--latent\\\", type=int, default=256, help=\\\"Number\",\n \"\\\"--device-id\\\", type=str, default=\\\"0\\\", help=\\\"Device id.\\\") parser.add_argument(\\\"-c\\\", \\\"--context\\\", type=str, default=\\\"cudnn\\\", help=\\\"Context.\\\") parser.add_argument(\\\"--type-config\\\", \\\"-t\\\", type=str,\",\n \"distributed on an \\\"AS IS\\\" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY\",\n \"= \\\"Example of Lightweight GAN.\\\" parser = argparse.ArgumentParser(description) parser.add_argument(\\\"-d\\\", \\\"--device-id\\\", type=str, default=\\\"0\\\", help=\\\"Device\",\n \"of data to be used. When -1 is set all data is used.\\\")\",\n \"data is used.\\\") parser.add_argument(\\\"--lr\\\", type=float, default=2e-4, help=\\\"Learning rate\\\") parser.add_argument(\\\"--aug-list\\\", nargs=\\\"+\\\", default=[\\\"lrflip\\\", \\\"translation\\\", \\\"color\\\"])\",\n \"# http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in\",\n \"type=int, default=256, help=\\\"Number of latent variables.\\\") parser.add_argument(\\\"--monitor-path\\\", type=str, default=\\\"./result/tmp\\\", help=\\\"Monitor path.\\\") parser.add_argument(\\\"--model-load-path\\\", type=str,\",\n \"is used.\\\") parser.add_argument(\\\"--lr\\\", type=float, default=2e-4, help=\\\"Learning rate\\\") parser.add_argument(\\\"--aug-list\\\", nargs=\\\"+\\\", default=[\\\"lrflip\\\", \\\"translation\\\", \\\"color\\\"]) args\",\n \"import os if not os.path.exists(args.monitor_path): os.makedirs(args.monitor_path) path = \\\"{}/Arguments-{}.txt\\\".format(args.monitor_path, mode) logger.info(\\\"Arguments are saved\",\n \"type=float, default=2e-4, help=\\\"Learning rate\\\") parser.add_argument(\\\"--aug-list\\\", nargs=\\\"+\\\", default=[\\\"lrflip\\\", \\\"translation\\\", \\\"color\\\"]) args = parser.parse_args() return\",\n \"type=str, default=\\\".\\\", help=\\\"Path to load parameters from\\\") parser.add_argument(\\\"--train-samples\\\", type=int, default=-1, help=\\\"Number of data\",\n \"parser.add_argument(\\\"--test-interval\\\", type=int, default=5000, help=\\\"Interval for testing models.\\\") parser.add_argument(\\\"--latent\\\", type=int, default=256, help=\\\"Number of latent\",\n \"\\\"{}/Arguments-{}.txt\\\".format(args.monitor_path, mode) logger.info(\\\"Arguments are saved to {}.\\\".format(path)) with open(path, \\\"w\\\") as fp: for\",\n \"are saved to {}.\\\".format(path)) with open(path, \\\"w\\\") as fp: for k, v in\",\n \"parser.add_argument(\\\"--save-interval\\\", type=int, default=50000, help=\\\"Interval for saving models.\\\") parser.add_argument(\\\"--test-interval\\\", type=int, default=5000, help=\\\"Interval for testing\",\n \"OF ANY KIND, either express or implied. # See the License for the\",\n \"# Copyright 2021 Sony Group Corporation. # # Licensed under the Apache License,\",\n \"2.0 (the \\\"License\\\"); # you may not use this file except in compliance\",\n \"used. When -1 is set all data is used.\\\") parser.add_argument(\\\"--lr\\\", type=float, default=2e-4, help=\\\"Learning\",\n \"for testing models.\\\") parser.add_argument(\\\"--latent\\\", type=int, default=256, help=\\\"Number of latent variables.\\\") parser.add_argument(\\\"--monitor-path\\\", type=str, default=\\\"./result/tmp\\\",\",\n \"save_args(args, mode=\\\"train\\\"): from nnabla import logger import os if not os.path.exists(args.monitor_path): os.makedirs(args.monitor_path) path\",\n \"testing models.\\\") parser.add_argument(\\\"--latent\\\", type=int, default=256, help=\\\"Number of latent variables.\\\") parser.add_argument(\\\"--monitor-path\\\", type=str, default=\\\"./result/tmp\\\", help=\\\"Monitor\",\n \"# you may not use this file except in compliance with the License.\",\n \"def save_args(args, mode=\\\"train\\\"): from nnabla import logger import os if not os.path.exists(args.monitor_path): os.makedirs(args.monitor_path)\",\n \"load parameters from\\\") parser.add_argument(\\\"--train-samples\\\", type=int, default=-1, help=\\\"Number of data to be used. When\",\n \"help='Type of computation. e.g. \\\"float\\\", \\\"half\\\".') parser.add_argument(\\\"--img-path\\\", type=str, default=\\\"~/AnimalFace-dog\\\", help=\\\"Image path.\\\") parser.add_argument(\\\"--image-size\\\", type=int,\",\n \"<filename>image-generation/slegan/args.py # Copyright 2021 Sony Corporation. # Copyright 2021 Sony Group Corporation. #\",\n \"agreed to in writing, software # distributed under the License is distributed on\",\n \"help=\\\"Learning rate\\\") parser.add_argument(\\\"--aug-list\\\", nargs=\\\"+\\\", default=[\\\"lrflip\\\", \\\"translation\\\", \\\"color\\\"]) args = parser.parse_args() return args def\",\n \"id.\\\") parser.add_argument(\\\"-c\\\", \\\"--context\\\", type=str, default=\\\"cudnn\\\", help=\\\"Context.\\\") parser.add_argument(\\\"--type-config\\\", \\\"-t\\\", type=str, default='float', help='Type of computation.\",\n \"WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the\",\n \"default=-1, help=\\\"Number of data to be used. When -1 is set all data\",\n \"(the \\\"License\\\"); # you may not use this file except in compliance with\",\n \"Lightweight GAN.\\\" parser = argparse.ArgumentParser(description) parser.add_argument(\\\"-d\\\", \\\"--device-id\\\", type=str, default=\\\"0\\\", help=\\\"Device id.\\\") parser.add_argument(\\\"-c\\\", \\\"--context\\\",\",\n \"When -1 is set all data is used.\\\") parser.add_argument(\\\"--lr\\\", type=float, default=2e-4, help=\\\"Learning rate\\\")\",\n \"default=max_iter, help=\\\"Max iterations.\\\") parser.add_argument(\\\"--save-interval\\\", type=int, default=50000, help=\\\"Interval for saving models.\\\") parser.add_argument(\\\"--test-interval\\\", type=int, default=5000,\",\n \"all data is used.\\\") parser.add_argument(\\\"--lr\\\", type=float, default=2e-4, help=\\\"Learning rate\\\") parser.add_argument(\\\"--aug-list\\\", nargs=\\\"+\\\", default=[\\\"lrflip\\\", \\\"translation\\\",\",\n \"nnabla import logger import os if not os.path.exists(args.monitor_path): os.makedirs(args.monitor_path) path = \\\"{}/Arguments-{}.txt\\\".format(args.monitor_path, mode)\",\n \"import os description = \\\"Example of Lightweight GAN.\\\" parser = argparse.ArgumentParser(description) parser.add_argument(\\\"-d\\\", \\\"--device-id\\\",\",\n \"path.\\\") parser.add_argument(\\\"--model-load-path\\\", type=str, default=\\\".\\\", help=\\\"Path to load parameters from\\\") parser.add_argument(\\\"--train-samples\\\", type=int, default=-1, help=\\\"Number\",\n \"# # Unless required by applicable law or agreed to in writing, software\",\n \"help=\\\"Monitor path.\\\") parser.add_argument(\\\"--model-load-path\\\", type=str, default=\\\".\\\", help=\\\"Path to load parameters from\\\") parser.add_argument(\\\"--train-samples\\\", type=int, default=-1,\",\n \"e.g. \\\"float\\\", \\\"half\\\".') parser.add_argument(\\\"--img-path\\\", type=str, default=\\\"~/AnimalFace-dog\\\", help=\\\"Image path.\\\") parser.add_argument(\\\"--image-size\\\", type=int, default=image_size, help=\\\"Image size.\\\")\",\n \"import logger import os if not os.path.exists(args.monitor_path): os.makedirs(args.monitor_path) path = \\\"{}/Arguments-{}.txt\\\".format(args.monitor_path, mode) logger.info(\\\"Arguments\",\n \"express or implied. # See the License for the specific language governing permissions\",\n \"is set all data is used.\\\") parser.add_argument(\\\"--lr\\\", type=float, default=2e-4, help=\\\"Learning rate\\\") parser.add_argument(\\\"--aug-list\\\", nargs=\\\"+\\\",\",\n \"Version 2.0 (the \\\"License\\\"); # you may not use this file except in\",\n \"# Unless required by applicable law or agreed to in writing, software #\",\n \"except in compliance with the License. # You may obtain a copy of\",\n \"default=\\\"./result/tmp\\\", help=\\\"Monitor path.\\\") parser.add_argument(\\\"--model-load-path\\\", type=str, default=\\\".\\\", help=\\\"Path to load parameters from\\\") parser.add_argument(\\\"--train-samples\\\", type=int,\",\n \"path.\\\") parser.add_argument(\\\"--image-size\\\", type=int, default=image_size, help=\\\"Image size.\\\") parser.add_argument(\\\"--batch-size\\\", \\\"-b\\\", type=int, default=batch_size, help=\\\"Batch size.\\\") parser.add_argument(\\\"--max-iter\\\",\",\n \"by applicable law or agreed to in writing, software # distributed under the\",\n \"os.makedirs(args.monitor_path) path = \\\"{}/Arguments-{}.txt\\\".format(args.monitor_path, mode) logger.info(\\\"Arguments are saved to {}.\\\".format(path)) with open(path, \\\"w\\\")\",\n \"copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by\",\n \"language governing permissions and # limitations under the License. def get_args(batch_size=8, image_size=256, max_iter=100000):\",\n \"used.\\\") parser.add_argument(\\\"--lr\\\", type=float, default=2e-4, help=\\\"Learning rate\\\") parser.add_argument(\\\"--aug-list\\\", nargs=\\\"+\\\", default=[\\\"lrflip\\\", \\\"translation\\\", \\\"color\\\"]) args =\",\n \"# limitations under the License. def get_args(batch_size=8, image_size=256, max_iter=100000): \\\"\\\"\\\" Get command line\",\n \"either express or implied. # See the License for the specific language governing\",\n \"parser.add_argument(\\\"--monitor-path\\\", type=str, default=\\\"./result/tmp\\\", help=\\\"Monitor path.\\\") parser.add_argument(\\\"--model-load-path\\\", type=str, default=\\\".\\\", help=\\\"Path to load parameters from\\\")\",\n \"software # distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\",\n \"help=\\\"Image size.\\\") parser.add_argument(\\\"--batch-size\\\", \\\"-b\\\", type=int, default=batch_size, help=\\\"Batch size.\\\") parser.add_argument(\\\"--max-iter\\\", \\\"-i\\\", type=int, default=max_iter, help=\\\"Max\",\n \"models.\\\") parser.add_argument(\\\"--test-interval\\\", type=int, default=5000, help=\\\"Interval for testing models.\\\") parser.add_argument(\\\"--latent\\\", type=int, default=256, help=\\\"Number of\",\n \"max_iter=100000): \\\"\\\"\\\" Get command line arguments. Arguments set the default values of command\",\n \"# You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0\",\n \"may not use this file except in compliance with the License. # You\",\n \"License is distributed on an \\\"AS IS\\\" BASIS, # WITHOUT WARRANTIES OR CONDITIONS\",\n \"type=str, default=\\\"0\\\", help=\\\"Device id.\\\") parser.add_argument(\\\"-c\\\", \\\"--context\\\", type=str, default=\\\"cudnn\\\", help=\\\"Context.\\\") parser.add_argument(\\\"--type-config\\\", \\\"-t\\\", type=str, default='float',\",\n \"\\\"half\\\".') parser.add_argument(\\\"--img-path\\\", type=str, default=\\\"~/AnimalFace-dog\\\", help=\\\"Image path.\\\") parser.add_argument(\\\"--image-size\\\", type=int, default=image_size, help=\\\"Image size.\\\") parser.add_argument(\\\"--batch-size\\\", \\\"-b\\\",\",\n \"= argparse.ArgumentParser(description) parser.add_argument(\\\"-d\\\", \\\"--device-id\\\", type=str, default=\\\"0\\\", help=\\\"Device id.\\\") parser.add_argument(\\\"-c\\\", \\\"--context\\\", type=str, default=\\\"cudnn\\\", help=\\\"Context.\\\")\",\n \"command line arguments. \\\"\\\"\\\" import argparse import os description = \\\"Example of Lightweight\",\n \"Licensed under the Apache License, Version 2.0 (the \\\"License\\\"); # you may not\",\n \"an \\\"AS IS\\\" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either\",\n \"# # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to\",\n \"the specific language governing permissions and # limitations under the License. def get_args(batch_size=8,\",\n \"default=\\\"cudnn\\\", help=\\\"Context.\\\") parser.add_argument(\\\"--type-config\\\", \\\"-t\\\", type=str, default='float', help='Type of computation. e.g. \\\"float\\\", \\\"half\\\".') parser.add_argument(\\\"--img-path\\\",\",\n \"parser.add_argument(\\\"-c\\\", \\\"--context\\\", type=str, default=\\\"cudnn\\\", help=\\\"Context.\\\") parser.add_argument(\\\"--type-config\\\", \\\"-t\\\", type=str, default='float', help='Type of computation. e.g.\",\n \"file except in compliance with the License. # You may obtain a copy\",\n \"help=\\\"Interval for testing models.\\\") parser.add_argument(\\\"--latent\\\", type=int, default=256, help=\\\"Number of latent variables.\\\") parser.add_argument(\\\"--monitor-path\\\", type=str,\",\n \"image_size=256, max_iter=100000): \\\"\\\"\\\" Get command line arguments. Arguments set the default values of\",\n \"default=5000, help=\\\"Interval for testing models.\\\") parser.add_argument(\\\"--latent\\\", type=int, default=256, help=\\\"Number of latent variables.\\\") parser.add_argument(\\\"--monitor-path\\\",\",\n \"parser.add_argument(\\\"--batch-size\\\", \\\"-b\\\", type=int, default=batch_size, help=\\\"Batch size.\\\") parser.add_argument(\\\"--max-iter\\\", \\\"-i\\\", type=int, default=max_iter, help=\\\"Max iterations.\\\") parser.add_argument(\\\"--save-interval\\\",\",\n \"latent variables.\\\") parser.add_argument(\\\"--monitor-path\\\", type=str, default=\\\"./result/tmp\\\", help=\\\"Monitor path.\\\") parser.add_argument(\\\"--model-load-path\\\", type=str, default=\\\".\\\", help=\\\"Path to load\",\n \"default=256, help=\\\"Number of latent variables.\\\") parser.add_argument(\\\"--monitor-path\\\", type=str, default=\\\"./result/tmp\\\", help=\\\"Monitor path.\\\") parser.add_argument(\\\"--model-load-path\\\", type=str, default=\\\".\\\",\",\n \"parser.add_argument(\\\"--aug-list\\\", nargs=\\\"+\\\", default=[\\\"lrflip\\\", \\\"translation\\\", \\\"color\\\"]) args = parser.parse_args() return args def save_args(args, mode=\\\"train\\\"):\",\n \"under the License is distributed on an \\\"AS IS\\\" BASIS, # WITHOUT WARRANTIES\",\n \"= \\\"{}/Arguments-{}.txt\\\".format(args.monitor_path, mode) logger.info(\\\"Arguments are saved to {}.\\\".format(path)) with open(path, \\\"w\\\") as fp:\",\n \"Corporation. # # Licensed under the Apache License, Version 2.0 (the \\\"License\\\"); #\",\n \"License for the specific language governing permissions and # limitations under the License.\",\n \"Group Corporation. # # Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\",\n \"the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law\",\n \"of computation. e.g. \\\"float\\\", \\\"half\\\".') parser.add_argument(\\\"--img-path\\\", type=str, default=\\\"~/AnimalFace-dog\\\", help=\\\"Image path.\\\") parser.add_argument(\\\"--image-size\\\", type=int, default=image_size,\",\n \"to {}.\\\".format(path)) with open(path, \\\"w\\\") as fp: for k, v in sorted(vars(args).items()): logger.info(\\\"{}={}\\\".format(k,\",\n \"default=batch_size, help=\\\"Batch size.\\\") parser.add_argument(\\\"--max-iter\\\", \\\"-i\\\", type=int, default=max_iter, help=\\\"Max iterations.\\\") parser.add_argument(\\\"--save-interval\\\", type=int, default=50000, help=\\\"Interval\",\n \"args = parser.parse_args() return args def save_args(args, mode=\\\"train\\\"): from nnabla import logger import\",\n \"open(path, \\\"w\\\") as fp: for k, v in sorted(vars(args).items()): logger.info(\\\"{}={}\\\".format(k, v)) fp.write(\\\"{}={}\\\\n\\\".format(k, v))\",\n \"the License. # You may obtain a copy of the License at #\",\n \"\\\"float\\\", \\\"half\\\".') parser.add_argument(\\\"--img-path\\\", type=str, default=\\\"~/AnimalFace-dog\\\", help=\\\"Image path.\\\") parser.add_argument(\\\"--image-size\\\", type=int, default=image_size, help=\\\"Image size.\\\") parser.add_argument(\\\"--batch-size\\\",\",\n \"parser.add_argument(\\\"--image-size\\\", type=int, default=image_size, help=\\\"Image size.\\\") parser.add_argument(\\\"--batch-size\\\", \\\"-b\\\", type=int, default=batch_size, help=\\\"Batch size.\\\") parser.add_argument(\\\"--max-iter\\\", \\\"-i\\\",\",\n \"to in writing, software # distributed under the License is distributed on an\",\n \"type=str, default=\\\"~/AnimalFace-dog\\\", help=\\\"Image path.\\\") parser.add_argument(\\\"--image-size\\\", type=int, default=image_size, help=\\\"Image size.\\\") parser.add_argument(\\\"--batch-size\\\", \\\"-b\\\", type=int, default=batch_size,\",\n \"\\\"AS IS\\\" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express\",\n \"help=\\\"Context.\\\") parser.add_argument(\\\"--type-config\\\", \\\"-t\\\", type=str, default='float', help='Type of computation. e.g. \\\"float\\\", \\\"half\\\".') parser.add_argument(\\\"--img-path\\\", type=str,\",\n \"Get command line arguments. Arguments set the default values of command line arguments.\",\n \"# distributed under the License is distributed on an \\\"AS IS\\\" BASIS, #\",\n \"of latent variables.\\\") parser.add_argument(\\\"--monitor-path\\\", type=str, default=\\\"./result/tmp\\\", help=\\\"Monitor path.\\\") parser.add_argument(\\\"--model-load-path\\\", type=str, default=\\\".\\\", help=\\\"Path to\",\n \"implied. # See the License for the specific language governing permissions and #\",\n \"type=str, default='float', help='Type of computation. e.g. \\\"float\\\", \\\"half\\\".') parser.add_argument(\\\"--img-path\\\", type=str, default=\\\"~/AnimalFace-dog\\\", help=\\\"Image path.\\\")\",\n \"\\\"License\\\"); # you may not use this file except in compliance with the\",\n \"is distributed on an \\\"AS IS\\\" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF\",\n \"obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless\",\n \"from\\\") parser.add_argument(\\\"--train-samples\\\", type=int, default=-1, help=\\\"Number of data to be used. When -1 is\",\n \"required by applicable law or agreed to in writing, software # distributed under\",\n \"type=int, default=-1, help=\\\"Number of data to be used. When -1 is set all\",\n \"type=int, default=batch_size, help=\\\"Batch size.\\\") parser.add_argument(\\\"--max-iter\\\", \\\"-i\\\", type=int, default=max_iter, help=\\\"Max iterations.\\\") parser.add_argument(\\\"--save-interval\\\", type=int, default=50000,\",\n \"default=2e-4, help=\\\"Learning rate\\\") parser.add_argument(\\\"--aug-list\\\", nargs=\\\"+\\\", default=[\\\"lrflip\\\", \\\"translation\\\", \\\"color\\\"]) args = parser.parse_args() return args\",\n \"models.\\\") parser.add_argument(\\\"--latent\\\", type=int, default=256, help=\\\"Number of latent variables.\\\") parser.add_argument(\\\"--monitor-path\\\", type=str, default=\\\"./result/tmp\\\", help=\\\"Monitor path.\\\")\",\n \"help=\\\"Number of data to be used. When -1 is set all data is\",\n \"applicable law or agreed to in writing, software # distributed under the License\",\n \"of Lightweight GAN.\\\" parser = argparse.ArgumentParser(description) parser.add_argument(\\\"-d\\\", \\\"--device-id\\\", type=str, default=\\\"0\\\", help=\\\"Device id.\\\") parser.add_argument(\\\"-c\\\",\",\n \"Sony Group Corporation. # # Licensed under the Apache License, Version 2.0 (the\",\n \"Corporation. # Copyright 2021 Sony Group Corporation. # # Licensed under the Apache\",\n \"variables.\\\") parser.add_argument(\\\"--monitor-path\\\", type=str, default=\\\"./result/tmp\\\", help=\\\"Monitor path.\\\") parser.add_argument(\\\"--model-load-path\\\", type=str, default=\\\".\\\", help=\\\"Path to load parameters\",\n \"parser.add_argument(\\\"--model-load-path\\\", type=str, default=\\\".\\\", help=\\\"Path to load parameters from\\\") parser.add_argument(\\\"--train-samples\\\", type=int, default=-1, help=\\\"Number of\",\n \"argparse import os description = \\\"Example of Lightweight GAN.\\\" parser = argparse.ArgumentParser(description) parser.add_argument(\\\"-d\\\",\",\n \"logger.info(\\\"Arguments are saved to {}.\\\".format(path)) with open(path, \\\"w\\\") as fp: for k, v\",\n \"limitations under the License. def get_args(batch_size=8, image_size=256, max_iter=100000): \\\"\\\"\\\" Get command line arguments.\",\n \"governing permissions and # limitations under the License. def get_args(batch_size=8, image_size=256, max_iter=100000): \\\"\\\"\\\"\",\n \"parser.add_argument(\\\"--latent\\\", type=int, default=256, help=\\\"Number of latent variables.\\\") parser.add_argument(\\\"--monitor-path\\\", type=str, default=\\\"./result/tmp\\\", help=\\\"Monitor path.\\\") parser.add_argument(\\\"--model-load-path\\\",\",\n \"for saving models.\\\") parser.add_argument(\\\"--test-interval\\\", type=int, default=5000, help=\\\"Interval for testing models.\\\") parser.add_argument(\\\"--latent\\\", type=int, default=256,\",\n \"get_args(batch_size=8, image_size=256, max_iter=100000): \\\"\\\"\\\" Get command line arguments. Arguments set the default values\",\n \"or agreed to in writing, software # distributed under the License is distributed\",\n \"path = \\\"{}/Arguments-{}.txt\\\".format(args.monitor_path, mode) logger.info(\\\"Arguments are saved to {}.\\\".format(path)) with open(path, \\\"w\\\") as\",\n \"# Copyright 2021 Sony Corporation. # Copyright 2021 Sony Group Corporation. # #\",\n \"def get_args(batch_size=8, image_size=256, max_iter=100000): \\\"\\\"\\\" Get command line arguments. Arguments set the default\",\n \"\\\"color\\\"]) args = parser.parse_args() return args def save_args(args, mode=\\\"train\\\"): from nnabla import logger\",\n \"parser.parse_args() return args def save_args(args, mode=\\\"train\\\"): from nnabla import logger import os if\",\n \"mode) logger.info(\\\"Arguments are saved to {}.\\\".format(path)) with open(path, \\\"w\\\") as fp: for k,\",\n \"or implied. # See the License for the specific language governing permissions and\",\n \"command line arguments. Arguments set the default values of command line arguments. \\\"\\\"\\\"\",\n \"default=50000, help=\\\"Interval for saving models.\\\") parser.add_argument(\\\"--test-interval\\\", type=int, default=5000, help=\\\"Interval for testing models.\\\") parser.add_argument(\\\"--latent\\\",\",\n \"the License. def get_args(batch_size=8, image_size=256, max_iter=100000): \\\"\\\"\\\" Get command line arguments. Arguments set\",\n \"parser = argparse.ArgumentParser(description) parser.add_argument(\\\"-d\\\", \\\"--device-id\\\", type=str, default=\\\"0\\\", help=\\\"Device id.\\\") parser.add_argument(\\\"-c\\\", \\\"--context\\\", type=str, default=\\\"cudnn\\\",\",\n \"import argparse import os description = \\\"Example of Lightweight GAN.\\\" parser = argparse.ArgumentParser(description)\",\n \"distributed under the License is distributed on an \\\"AS IS\\\" BASIS, # WITHOUT\",\n \"CONDITIONS OF ANY KIND, either express or implied. # See the License for\",\n \"arguments. \\\"\\\"\\\" import argparse import os description = \\\"Example of Lightweight GAN.\\\" parser\",\n \"\\\"-t\\\", type=str, default='float', help='Type of computation. e.g. \\\"float\\\", \\\"half\\\".') parser.add_argument(\\\"--img-path\\\", type=str, default=\\\"~/AnimalFace-dog\\\", help=\\\"Image\",\n \"Apache License, Version 2.0 (the \\\"License\\\"); # you may not use this file\",\n \"type=str, default=\\\"cudnn\\\", help=\\\"Context.\\\") parser.add_argument(\\\"--type-config\\\", \\\"-t\\\", type=str, default='float', help='Type of computation. e.g. \\\"float\\\", \\\"half\\\".')\",\n \"default=\\\"~/AnimalFace-dog\\\", help=\\\"Image path.\\\") parser.add_argument(\\\"--image-size\\\", type=int, default=image_size, help=\\\"Image size.\\\") parser.add_argument(\\\"--batch-size\\\", \\\"-b\\\", type=int, default=batch_size, help=\\\"Batch\",\n \"type=int, default=image_size, help=\\\"Image size.\\\") parser.add_argument(\\\"--batch-size\\\", \\\"-b\\\", type=int, default=batch_size, help=\\\"Batch size.\\\") parser.add_argument(\\\"--max-iter\\\", \\\"-i\\\", type=int,\",\n \"OR CONDITIONS OF ANY KIND, either express or implied. # See the License\",\n \"may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # #\",\n \"type=str, default=\\\"./result/tmp\\\", help=\\\"Monitor path.\\\") parser.add_argument(\\\"--model-load-path\\\", type=str, default=\\\".\\\", help=\\\"Path to load parameters from\\\") parser.add_argument(\\\"--train-samples\\\",\",\n \"if not os.path.exists(args.monitor_path): os.makedirs(args.monitor_path) path = \\\"{}/Arguments-{}.txt\\\".format(args.monitor_path, mode) logger.info(\\\"Arguments are saved to {}.\\\".format(path))\",\n \"saved to {}.\\\".format(path)) with open(path, \\\"w\\\") as fp: for k, v in sorted(vars(args).items()):\",\n \"License. def get_args(batch_size=8, image_size=256, max_iter=100000): \\\"\\\"\\\" Get command line arguments. Arguments set the\",\n \"\\\"\\\"\\\" import argparse import os description = \\\"Example of Lightweight GAN.\\\" parser =\",\n \"with the License. # You may obtain a copy of the License at\",\n \"Copyright 2021 Sony Corporation. # Copyright 2021 Sony Group Corporation. # # Licensed\",\n \"http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing,\",\n \"set the default values of command line arguments. \\\"\\\"\\\" import argparse import os\",\n \"rate\\\") parser.add_argument(\\\"--aug-list\\\", nargs=\\\"+\\\", default=[\\\"lrflip\\\", \\\"translation\\\", \\\"color\\\"]) args = parser.parse_args() return args def save_args(args,\",\n \"help=\\\"Image path.\\\") parser.add_argument(\\\"--image-size\\\", type=int, default=image_size, help=\\\"Image size.\\\") parser.add_argument(\\\"--batch-size\\\", \\\"-b\\\", type=int, default=batch_size, help=\\\"Batch size.\\\")\",\n \"in writing, software # distributed under the License is distributed on an \\\"AS\",\n \"\\\"-b\\\", type=int, default=batch_size, help=\\\"Batch size.\\\") parser.add_argument(\\\"--max-iter\\\", \\\"-i\\\", type=int, default=max_iter, help=\\\"Max iterations.\\\") parser.add_argument(\\\"--save-interval\\\", type=int,\",\n \"for the specific language governing permissions and # limitations under the License. def\",\n \"to be used. When -1 is set all data is used.\\\") parser.add_argument(\\\"--lr\\\", type=float,\",\n \"from nnabla import logger import os if not os.path.exists(args.monitor_path): os.makedirs(args.monitor_path) path = \\\"{}/Arguments-{}.txt\\\".format(args.monitor_path,\",\n \"\\\"translation\\\", \\\"color\\\"]) args = parser.parse_args() return args def save_args(args, mode=\\\"train\\\"): from nnabla import\",\n \"permissions and # limitations under the License. def get_args(batch_size=8, image_size=256, max_iter=100000): \\\"\\\"\\\" Get\",\n \"under the Apache License, Version 2.0 (the \\\"License\\\"); # you may not use\",\n \"nargs=\\\"+\\\", default=[\\\"lrflip\\\", \\\"translation\\\", \\\"color\\\"]) args = parser.parse_args() return args def save_args(args, mode=\\\"train\\\"): from\",\n \"size.\\\") parser.add_argument(\\\"--batch-size\\\", \\\"-b\\\", type=int, default=batch_size, help=\\\"Batch size.\\\") parser.add_argument(\\\"--max-iter\\\", \\\"-i\\\", type=int, default=max_iter, help=\\\"Max iterations.\\\")\",\n \"not os.path.exists(args.monitor_path): os.makedirs(args.monitor_path) path = \\\"{}/Arguments-{}.txt\\\".format(args.monitor_path, mode) logger.info(\\\"Arguments are saved to {}.\\\".format(path)) with\"\n]","isConversational":false}}},{"rowIdx":2398,"cells":{"ngram":{"kind":"list like","value":["print(\"-\" * 60) f.seek(0) my_content = f.readlines() print(\"\\nUse readlines method\") print(\"-\" * 60)","f = open(\"my_file.txt\") print(\"\\nLoop directly over file\") print(\"-\" * 60) for line in","f.seek(0) my_content = f.read() print(\"\\nUse read + splitlines\") print(\"-\" * 60) for line","for line in f: print(line.strip()) print(\"-\" * 60) # WRITE #### print(\"\\nWriting file.\")","f.read() print(\"\\nUse read + splitlines\") print(\"-\" * 60) for line in my_content.splitlines(): print(line)","f.readlines() print(\"\\nUse readlines method\") print(\"-\" * 60) for line in my_content: print(line.strip()) print(\"-\"","print(\"\\nWriting file.\") f = open(\"new_file.txt\", \"w\") f.write(\"whatever2\\n\") f.close() # APPEND #### print(\"\\nAppending file.\")","line in f: print(line.strip()) print(\"-\" * 60) # WRITE #### print(\"\\nWriting file.\") f","method\") print(\"-\" * 60) for line in my_content: print(line.strip()) print(\"-\" * 60) f.seek(0)","file\") print(\"-\" * 60) for line in f: print(line.strip()) print(\"-\" * 60) #","= f.readlines() print(\"\\nUse readlines method\") print(\"-\" * 60) for line in my_content: print(line.strip())","print(\"\\nUse read + splitlines\") print(\"-\" * 60) for line in my_content.splitlines(): print(line) print(\"-\"","print(line) print(\"-\" * 60) f.close() with open(\"my_file.txt\") as f: print(\"\\nUse with and loop","my_content.splitlines(): print(line) print(\"-\" * 60) f.close() with open(\"my_file.txt\") as f: print(\"\\nUse with and","in f: print(line.strip()) print(\"-\" * 60) # WRITE #### print(\"\\nWriting file.\") f =","print(\"\\nUse readlines method\") print(\"-\" * 60) for line in my_content: print(line.strip()) print(\"-\" *","print_function # READ #### f = open(\"my_file.txt\") print(\"\\nLoop directly over file\") print(\"-\" *","line in my_content: print(line.strip()) print(\"-\" * 60) f.seek(0) my_content = f.read() print(\"\\nUse read","read + splitlines\") print(\"-\" * 60) for line in my_content.splitlines(): print(line) print(\"-\" *","print(\"\\nUse with and loop over file\") print(\"-\" * 60) for line in f:","\"w\") f.write(\"whatever2\\n\") f.close() # APPEND #### print(\"\\nAppending file.\") with open(\"new_file.txt\", \"a\") as f:","* 60) for line in my_content: print(line.strip()) print(\"-\" * 60) f.seek(0) my_content =","__future__ import print_function # READ #### f = open(\"my_file.txt\") print(\"\\nLoop directly over file\")","print(\"\\nLoop directly over file\") print(\"-\" * 60) for line in f: print(line.strip()) print(\"-\"","readlines method\") print(\"-\" * 60) for line in my_content: print(line.strip()) print(\"-\" * 60)","* 60) for line in my_content.splitlines(): print(line) print(\"-\" * 60) f.close() with open(\"my_file.txt\")","60) # WRITE #### print(\"\\nWriting file.\") f = open(\"new_file.txt\", \"w\") f.write(\"whatever2\\n\") f.close() #","# READ #### f = open(\"my_file.txt\") print(\"\\nLoop directly over file\") print(\"-\" * 60)","= f.read() print(\"\\nUse read + splitlines\") print(\"-\" * 60) for line in my_content.splitlines():","f: print(line.strip()) print(\"-\" * 60) f.seek(0) my_content = f.readlines() print(\"\\nUse readlines method\") print(\"-\"","= open(\"my_file.txt\") print(\"\\nLoop directly over file\") print(\"-\" * 60) for line in f:","line in f: print(line.strip()) print(\"-\" * 60) f.seek(0) my_content = f.readlines() print(\"\\nUse readlines","file\") print(\"-\" * 60) for line in f: print(line.strip()) print(\"-\" * 60) f.seek(0)","<gh_stars>0 #!/usr/bin/env python from __future__ import print_function # READ #### f = open(\"my_file.txt\")","from __future__ import print_function # READ #### f = open(\"my_file.txt\") print(\"\\nLoop directly over","READ #### f = open(\"my_file.txt\") print(\"\\nLoop directly over file\") print(\"-\" * 60) for","print(\"-\" * 60) f.seek(0) my_content = f.read() print(\"\\nUse read + splitlines\") print(\"-\" *","import print_function # READ #### f = open(\"my_file.txt\") print(\"\\nLoop directly over file\") print(\"-\"","in f: print(line.strip()) print(\"-\" * 60) f.seek(0) my_content = f.readlines() print(\"\\nUse readlines method\")","for line in my_content: print(line.strip()) print(\"-\" * 60) f.seek(0) my_content = f.read() print(\"\\nUse","f: print(\"\\nUse with and loop over file\") print(\"-\" * 60) for line in","f.write(\"whatever2\\n\") f.close() # APPEND #### print(\"\\nAppending file.\") with open(\"new_file.txt\", \"a\") as f: f.write(\"something","60) for line in my_content: print(line.strip()) print(\"-\" * 60) f.seek(0) my_content = f.read()","splitlines\") print(\"-\" * 60) for line in my_content.splitlines(): print(line) print(\"-\" * 60) f.close()","# WRITE #### print(\"\\nWriting file.\") f = open(\"new_file.txt\", \"w\") f.write(\"whatever2\\n\") f.close() # APPEND","# APPEND #### print(\"\\nAppending file.\") with open(\"new_file.txt\", \"a\") as f: f.write(\"something else\\n\") print()","* 60) # WRITE #### print(\"\\nWriting file.\") f = open(\"new_file.txt\", \"w\") f.write(\"whatever2\\n\") f.close()","= open(\"new_file.txt\", \"w\") f.write(\"whatever2\\n\") f.close() # APPEND #### print(\"\\nAppending file.\") with open(\"new_file.txt\", \"a\")","#### print(\"\\nWriting file.\") f = open(\"new_file.txt\", \"w\") f.write(\"whatever2\\n\") f.close() # APPEND #### print(\"\\nAppending","line in my_content.splitlines(): print(line) print(\"-\" * 60) f.close() with open(\"my_file.txt\") as f: print(\"\\nUse","with and loop over file\") print(\"-\" * 60) for line in f: print(line.strip())","* 60) f.close() with open(\"my_file.txt\") as f: print(\"\\nUse with and loop over file\")","* 60) f.seek(0) my_content = f.read() print(\"\\nUse read + splitlines\") print(\"-\" * 60)","60) for line in my_content.splitlines(): print(line) print(\"-\" * 60) f.close() with open(\"my_file.txt\") as","over file\") print(\"-\" * 60) for line in f: print(line.strip()) print(\"-\" * 60)","* 60) for line in f: print(line.strip()) print(\"-\" * 60) # WRITE ####","loop over file\") print(\"-\" * 60) for line in f: print(line.strip()) print(\"-\" *","+ splitlines\") print(\"-\" * 60) for line in my_content.splitlines(): print(line) print(\"-\" * 60)","f = open(\"new_file.txt\", \"w\") f.write(\"whatever2\\n\") f.close() # APPEND #### print(\"\\nAppending file.\") with open(\"new_file.txt\",","open(\"new_file.txt\", \"w\") f.write(\"whatever2\\n\") f.close() # APPEND #### print(\"\\nAppending file.\") with open(\"new_file.txt\", \"a\") as","f: print(line.strip()) print(\"-\" * 60) # WRITE #### print(\"\\nWriting file.\") f = open(\"new_file.txt\",","in my_content.splitlines(): print(line) print(\"-\" * 60) f.close() with open(\"my_file.txt\") as f: print(\"\\nUse with","60) for line in f: print(line.strip()) print(\"-\" * 60) # WRITE #### print(\"\\nWriting","as f: print(\"\\nUse with and loop over file\") print(\"-\" * 60) for line","f.close() # APPEND #### print(\"\\nAppending file.\") with open(\"new_file.txt\", \"a\") as f: f.write(\"something else\\n\")","in my_content: print(line.strip()) print(\"-\" * 60) f.seek(0) my_content = f.read() print(\"\\nUse read +","my_content = f.read() print(\"\\nUse read + splitlines\") print(\"-\" * 60) for line in","print(\"-\" * 60) for line in my_content.splitlines(): print(line) print(\"-\" * 60) f.close() with","print(line.strip()) print(\"-\" * 60) # WRITE #### print(\"\\nWriting file.\") f = open(\"new_file.txt\", \"w\")","print(\"-\" * 60) # WRITE #### print(\"\\nWriting file.\") f = open(\"new_file.txt\", \"w\") f.write(\"whatever2\\n\")","* 60) for line in f: print(line.strip()) print(\"-\" * 60) f.seek(0) my_content =","print(\"-\" * 60) f.close() with open(\"my_file.txt\") as f: print(\"\\nUse with and loop over","python from __future__ import print_function # READ #### f = open(\"my_file.txt\") print(\"\\nLoop directly","print(line.strip()) print(\"-\" * 60) f.seek(0) my_content = f.readlines() print(\"\\nUse readlines method\") print(\"-\" *","60) f.seek(0) my_content = f.read() print(\"\\nUse read + splitlines\") print(\"-\" * 60) for","print(\"-\" * 60) for line in f: print(line.strip()) print(\"-\" * 60) f.seek(0) my_content","and loop over file\") print(\"-\" * 60) for line in f: print(line.strip()) print(\"-\"","directly over file\") print(\"-\" * 60) for line in f: print(line.strip()) print(\"-\" *","60) f.seek(0) my_content = f.readlines() print(\"\\nUse readlines method\") print(\"-\" * 60) for line","WRITE #### print(\"\\nWriting file.\") f = open(\"new_file.txt\", \"w\") f.write(\"whatever2\\n\") f.close() # APPEND ####","#!/usr/bin/env python from __future__ import print_function # READ #### f = open(\"my_file.txt\") print(\"\\nLoop","f.close() with open(\"my_file.txt\") as f: print(\"\\nUse with and loop over file\") print(\"-\" *","#### f = open(\"my_file.txt\") print(\"\\nLoop directly over file\") print(\"-\" * 60) for line","with open(\"my_file.txt\") as f: print(\"\\nUse with and loop over file\") print(\"-\" * 60)","for line in f: print(line.strip()) print(\"-\" * 60) f.seek(0) my_content = f.readlines() print(\"\\nUse","60) f.close() with open(\"my_file.txt\") as f: print(\"\\nUse with and loop over file\") print(\"-\"","print(\"-\" * 60) for line in my_content: print(line.strip()) print(\"-\" * 60) f.seek(0) my_content","print(line.strip()) print(\"-\" * 60) f.seek(0) my_content = f.read() print(\"\\nUse read + splitlines\") print(\"-\"","for line in my_content.splitlines(): print(line) print(\"-\" * 60) f.close() with open(\"my_file.txt\") as f:","my_content: print(line.strip()) print(\"-\" * 60) f.seek(0) my_content = f.read() print(\"\\nUse read + splitlines\")","* 60) f.seek(0) my_content = f.readlines() print(\"\\nUse readlines method\") print(\"-\" * 60) for","open(\"my_file.txt\") as f: print(\"\\nUse with and loop over file\") print(\"-\" * 60) for","my_content = f.readlines() print(\"\\nUse readlines method\") print(\"-\" * 60) for line in my_content:","print(\"-\" * 60) for line in f: print(line.strip()) print(\"-\" * 60) # WRITE","file.\") f = open(\"new_file.txt\", \"w\") f.write(\"whatever2\\n\") f.close() # APPEND #### print(\"\\nAppending file.\") with","60) for line in f: print(line.strip()) print(\"-\" * 60) f.seek(0) my_content = f.readlines()","f.seek(0) my_content = f.readlines() print(\"\\nUse readlines method\") print(\"-\" * 60) for line in","open(\"my_file.txt\") print(\"\\nLoop directly over file\") print(\"-\" * 60) for line in f: print(line.strip())"],"string":"[\n \"print(\\\"-\\\" * 60) f.seek(0) my_content = f.readlines() print(\\\"\\\\nUse readlines method\\\") print(\\\"-\\\" * 60)\",\n \"f = open(\\\"my_file.txt\\\") print(\\\"\\\\nLoop directly over file\\\") print(\\\"-\\\" * 60) for line in\",\n \"f.seek(0) my_content = f.read() print(\\\"\\\\nUse read + splitlines\\\") print(\\\"-\\\" * 60) for line\",\n \"for line in f: print(line.strip()) print(\\\"-\\\" * 60) # WRITE #### print(\\\"\\\\nWriting file.\\\")\",\n \"f.read() print(\\\"\\\\nUse read + splitlines\\\") print(\\\"-\\\" * 60) for line in my_content.splitlines(): print(line)\",\n \"f.readlines() print(\\\"\\\\nUse readlines method\\\") print(\\\"-\\\" * 60) for line in my_content: print(line.strip()) print(\\\"-\\\"\",\n \"print(\\\"\\\\nWriting file.\\\") f = open(\\\"new_file.txt\\\", \\\"w\\\") f.write(\\\"whatever2\\\\n\\\") f.close() # APPEND #### print(\\\"\\\\nAppending file.\\\")\",\n \"line in f: print(line.strip()) print(\\\"-\\\" * 60) # WRITE #### print(\\\"\\\\nWriting file.\\\") f\",\n \"method\\\") print(\\\"-\\\" * 60) for line in my_content: print(line.strip()) print(\\\"-\\\" * 60) f.seek(0)\",\n \"file\\\") print(\\\"-\\\" * 60) for line in f: print(line.strip()) print(\\\"-\\\" * 60) #\",\n \"= f.readlines() print(\\\"\\\\nUse readlines method\\\") print(\\\"-\\\" * 60) for line in my_content: print(line.strip())\",\n \"print(\\\"\\\\nUse read + splitlines\\\") print(\\\"-\\\" * 60) for line in my_content.splitlines(): print(line) print(\\\"-\\\"\",\n \"print(line) print(\\\"-\\\" * 60) f.close() with open(\\\"my_file.txt\\\") as f: print(\\\"\\\\nUse with and loop\",\n \"my_content.splitlines(): print(line) print(\\\"-\\\" * 60) f.close() with open(\\\"my_file.txt\\\") as f: print(\\\"\\\\nUse with and\",\n \"in f: print(line.strip()) print(\\\"-\\\" * 60) # WRITE #### print(\\\"\\\\nWriting file.\\\") f =\",\n \"print(\\\"\\\\nUse readlines method\\\") print(\\\"-\\\" * 60) for line in my_content: print(line.strip()) print(\\\"-\\\" *\",\n \"print_function # READ #### f = open(\\\"my_file.txt\\\") print(\\\"\\\\nLoop directly over file\\\") print(\\\"-\\\" *\",\n \"line in my_content: print(line.strip()) print(\\\"-\\\" * 60) f.seek(0) my_content = f.read() print(\\\"\\\\nUse read\",\n \"read + splitlines\\\") print(\\\"-\\\" * 60) for line in my_content.splitlines(): print(line) print(\\\"-\\\" *\",\n \"print(\\\"\\\\nUse with and loop over file\\\") print(\\\"-\\\" * 60) for line in f:\",\n \"\\\"w\\\") f.write(\\\"whatever2\\\\n\\\") f.close() # APPEND #### print(\\\"\\\\nAppending file.\\\") with open(\\\"new_file.txt\\\", \\\"a\\\") as f:\",\n \"* 60) for line in my_content: print(line.strip()) print(\\\"-\\\" * 60) f.seek(0) my_content =\",\n \"__future__ import print_function # READ #### f = open(\\\"my_file.txt\\\") print(\\\"\\\\nLoop directly over file\\\")\",\n \"print(\\\"\\\\nLoop directly over file\\\") print(\\\"-\\\" * 60) for line in f: print(line.strip()) print(\\\"-\\\"\",\n \"readlines method\\\") print(\\\"-\\\" * 60) for line in my_content: print(line.strip()) print(\\\"-\\\" * 60)\",\n \"* 60) for line in my_content.splitlines(): print(line) print(\\\"-\\\" * 60) f.close() with open(\\\"my_file.txt\\\")\",\n \"60) # WRITE #### print(\\\"\\\\nWriting file.\\\") f = open(\\\"new_file.txt\\\", \\\"w\\\") f.write(\\\"whatever2\\\\n\\\") f.close() #\",\n \"# READ #### f = open(\\\"my_file.txt\\\") print(\\\"\\\\nLoop directly over file\\\") print(\\\"-\\\" * 60)\",\n \"= f.read() print(\\\"\\\\nUse read + splitlines\\\") print(\\\"-\\\" * 60) for line in my_content.splitlines():\",\n \"f: print(line.strip()) print(\\\"-\\\" * 60) f.seek(0) my_content = f.readlines() print(\\\"\\\\nUse readlines method\\\") print(\\\"-\\\"\",\n \"= open(\\\"my_file.txt\\\") print(\\\"\\\\nLoop directly over file\\\") print(\\\"-\\\" * 60) for line in f:\",\n \"line in f: print(line.strip()) print(\\\"-\\\" * 60) f.seek(0) my_content = f.readlines() print(\\\"\\\\nUse readlines\",\n \"file\\\") print(\\\"-\\\" * 60) for line in f: print(line.strip()) print(\\\"-\\\" * 60) f.seek(0)\",\n \"<gh_stars>0 #!/usr/bin/env python from __future__ import print_function # READ #### f = open(\\\"my_file.txt\\\")\",\n \"from __future__ import print_function # READ #### f = open(\\\"my_file.txt\\\") print(\\\"\\\\nLoop directly over\",\n \"READ #### f = open(\\\"my_file.txt\\\") print(\\\"\\\\nLoop directly over file\\\") print(\\\"-\\\" * 60) for\",\n \"print(\\\"-\\\" * 60) f.seek(0) my_content = f.read() print(\\\"\\\\nUse read + splitlines\\\") print(\\\"-\\\" *\",\n \"import print_function # READ #### f = open(\\\"my_file.txt\\\") print(\\\"\\\\nLoop directly over file\\\") print(\\\"-\\\"\",\n \"in f: print(line.strip()) print(\\\"-\\\" * 60) f.seek(0) my_content = f.readlines() print(\\\"\\\\nUse readlines method\\\")\",\n \"for line in my_content: print(line.strip()) print(\\\"-\\\" * 60) f.seek(0) my_content = f.read() print(\\\"\\\\nUse\",\n \"f: print(\\\"\\\\nUse with and loop over file\\\") print(\\\"-\\\" * 60) for line in\",\n \"f.write(\\\"whatever2\\\\n\\\") f.close() # APPEND #### print(\\\"\\\\nAppending file.\\\") with open(\\\"new_file.txt\\\", \\\"a\\\") as f: f.write(\\\"something\",\n \"60) for line in my_content: print(line.strip()) print(\\\"-\\\" * 60) f.seek(0) my_content = f.read()\",\n \"splitlines\\\") print(\\\"-\\\" * 60) for line in my_content.splitlines(): print(line) print(\\\"-\\\" * 60) f.close()\",\n \"# WRITE #### print(\\\"\\\\nWriting file.\\\") f = open(\\\"new_file.txt\\\", \\\"w\\\") f.write(\\\"whatever2\\\\n\\\") f.close() # APPEND\",\n \"# APPEND #### print(\\\"\\\\nAppending file.\\\") with open(\\\"new_file.txt\\\", \\\"a\\\") as f: f.write(\\\"something else\\\\n\\\") print()\",\n \"* 60) # WRITE #### print(\\\"\\\\nWriting file.\\\") f = open(\\\"new_file.txt\\\", \\\"w\\\") f.write(\\\"whatever2\\\\n\\\") f.close()\",\n \"= open(\\\"new_file.txt\\\", \\\"w\\\") f.write(\\\"whatever2\\\\n\\\") f.close() # APPEND #### print(\\\"\\\\nAppending file.\\\") with open(\\\"new_file.txt\\\", \\\"a\\\")\",\n \"#### print(\\\"\\\\nWriting file.\\\") f = open(\\\"new_file.txt\\\", \\\"w\\\") f.write(\\\"whatever2\\\\n\\\") f.close() # APPEND #### print(\\\"\\\\nAppending\",\n \"line in my_content.splitlines(): print(line) print(\\\"-\\\" * 60) f.close() with open(\\\"my_file.txt\\\") as f: print(\\\"\\\\nUse\",\n \"with and loop over file\\\") print(\\\"-\\\" * 60) for line in f: print(line.strip())\",\n \"* 60) f.close() with open(\\\"my_file.txt\\\") as f: print(\\\"\\\\nUse with and loop over file\\\")\",\n \"* 60) f.seek(0) my_content = f.read() print(\\\"\\\\nUse read + splitlines\\\") print(\\\"-\\\" * 60)\",\n \"60) for line in my_content.splitlines(): print(line) print(\\\"-\\\" * 60) f.close() with open(\\\"my_file.txt\\\") as\",\n \"over file\\\") print(\\\"-\\\" * 60) for line in f: print(line.strip()) print(\\\"-\\\" * 60)\",\n \"* 60) for line in f: print(line.strip()) print(\\\"-\\\" * 60) # WRITE ####\",\n \"loop over file\\\") print(\\\"-\\\" * 60) for line in f: print(line.strip()) print(\\\"-\\\" *\",\n \"+ splitlines\\\") print(\\\"-\\\" * 60) for line in my_content.splitlines(): print(line) print(\\\"-\\\" * 60)\",\n \"f = open(\\\"new_file.txt\\\", \\\"w\\\") f.write(\\\"whatever2\\\\n\\\") f.close() # APPEND #### print(\\\"\\\\nAppending file.\\\") with open(\\\"new_file.txt\\\",\",\n \"open(\\\"new_file.txt\\\", \\\"w\\\") f.write(\\\"whatever2\\\\n\\\") f.close() # APPEND #### print(\\\"\\\\nAppending file.\\\") with open(\\\"new_file.txt\\\", \\\"a\\\") as\",\n \"f: print(line.strip()) print(\\\"-\\\" * 60) # WRITE #### print(\\\"\\\\nWriting file.\\\") f = open(\\\"new_file.txt\\\",\",\n \"in my_content.splitlines(): print(line) print(\\\"-\\\" * 60) f.close() with open(\\\"my_file.txt\\\") as f: print(\\\"\\\\nUse with\",\n \"60) for line in f: print(line.strip()) print(\\\"-\\\" * 60) # WRITE #### print(\\\"\\\\nWriting\",\n \"as f: print(\\\"\\\\nUse with and loop over file\\\") print(\\\"-\\\" * 60) for line\",\n \"f.close() # APPEND #### print(\\\"\\\\nAppending file.\\\") with open(\\\"new_file.txt\\\", \\\"a\\\") as f: f.write(\\\"something else\\\\n\\\")\",\n \"in my_content: print(line.strip()) print(\\\"-\\\" * 60) f.seek(0) my_content = f.read() print(\\\"\\\\nUse read +\",\n \"my_content = f.read() print(\\\"\\\\nUse read + splitlines\\\") print(\\\"-\\\" * 60) for line in\",\n \"print(\\\"-\\\" * 60) for line in my_content.splitlines(): print(line) print(\\\"-\\\" * 60) f.close() with\",\n \"print(line.strip()) print(\\\"-\\\" * 60) # WRITE #### print(\\\"\\\\nWriting file.\\\") f = open(\\\"new_file.txt\\\", \\\"w\\\")\",\n \"print(\\\"-\\\" * 60) # WRITE #### print(\\\"\\\\nWriting file.\\\") f = open(\\\"new_file.txt\\\", \\\"w\\\") f.write(\\\"whatever2\\\\n\\\")\",\n \"* 60) for line in f: print(line.strip()) print(\\\"-\\\" * 60) f.seek(0) my_content =\",\n \"print(\\\"-\\\" * 60) f.close() with open(\\\"my_file.txt\\\") as f: print(\\\"\\\\nUse with and loop over\",\n \"python from __future__ import print_function # READ #### f = open(\\\"my_file.txt\\\") print(\\\"\\\\nLoop directly\",\n \"print(line.strip()) print(\\\"-\\\" * 60) f.seek(0) my_content = f.readlines() print(\\\"\\\\nUse readlines method\\\") print(\\\"-\\\" *\",\n \"60) f.seek(0) my_content = f.read() print(\\\"\\\\nUse read + splitlines\\\") print(\\\"-\\\" * 60) for\",\n \"print(\\\"-\\\" * 60) for line in f: print(line.strip()) print(\\\"-\\\" * 60) f.seek(0) my_content\",\n \"and loop over file\\\") print(\\\"-\\\" * 60) for line in f: print(line.strip()) print(\\\"-\\\"\",\n \"directly over file\\\") print(\\\"-\\\" * 60) for line in f: print(line.strip()) print(\\\"-\\\" *\",\n \"60) f.seek(0) my_content = f.readlines() print(\\\"\\\\nUse readlines method\\\") print(\\\"-\\\" * 60) for line\",\n \"WRITE #### print(\\\"\\\\nWriting file.\\\") f = open(\\\"new_file.txt\\\", \\\"w\\\") f.write(\\\"whatever2\\\\n\\\") f.close() # APPEND ####\",\n \"#!/usr/bin/env python from __future__ import print_function # READ #### f = open(\\\"my_file.txt\\\") print(\\\"\\\\nLoop\",\n \"f.close() with open(\\\"my_file.txt\\\") as f: print(\\\"\\\\nUse with and loop over file\\\") print(\\\"-\\\" *\",\n \"#### f = open(\\\"my_file.txt\\\") print(\\\"\\\\nLoop directly over file\\\") print(\\\"-\\\" * 60) for line\",\n \"with open(\\\"my_file.txt\\\") as f: print(\\\"\\\\nUse with and loop over file\\\") print(\\\"-\\\" * 60)\",\n \"for line in f: print(line.strip()) print(\\\"-\\\" * 60) f.seek(0) my_content = f.readlines() print(\\\"\\\\nUse\",\n \"60) f.close() with open(\\\"my_file.txt\\\") as f: print(\\\"\\\\nUse with and loop over file\\\") print(\\\"-\\\"\",\n \"print(\\\"-\\\" * 60) for line in my_content: print(line.strip()) print(\\\"-\\\" * 60) f.seek(0) my_content\",\n \"print(line.strip()) print(\\\"-\\\" * 60) f.seek(0) my_content = f.read() print(\\\"\\\\nUse read + splitlines\\\") print(\\\"-\\\"\",\n \"for line in my_content.splitlines(): print(line) print(\\\"-\\\" * 60) f.close() with open(\\\"my_file.txt\\\") as f:\",\n \"my_content: print(line.strip()) print(\\\"-\\\" * 60) f.seek(0) my_content = f.read() print(\\\"\\\\nUse read + splitlines\\\")\",\n \"* 60) f.seek(0) my_content = f.readlines() print(\\\"\\\\nUse readlines method\\\") print(\\\"-\\\" * 60) for\",\n \"open(\\\"my_file.txt\\\") as f: print(\\\"\\\\nUse with and loop over file\\\") print(\\\"-\\\" * 60) for\",\n \"my_content = f.readlines() print(\\\"\\\\nUse readlines method\\\") print(\\\"-\\\" * 60) for line in my_content:\",\n \"print(\\\"-\\\" * 60) for line in f: print(line.strip()) print(\\\"-\\\" * 60) # WRITE\",\n \"file.\\\") f = open(\\\"new_file.txt\\\", \\\"w\\\") f.write(\\\"whatever2\\\\n\\\") f.close() # APPEND #### print(\\\"\\\\nAppending file.\\\") with\",\n \"60) for line in f: print(line.strip()) print(\\\"-\\\" * 60) f.seek(0) my_content = f.readlines()\",\n \"f.seek(0) my_content = f.readlines() print(\\\"\\\\nUse readlines method\\\") print(\\\"-\\\" * 60) for line in\",\n \"open(\\\"my_file.txt\\\") print(\\\"\\\\nLoop directly over file\\\") print(\\\"-\\\" * 60) for line in f: print(line.strip())\"\n]","isConversational":false}}},{"rowIdx":2399,"cells":{"ngram":{"kind":"list like","value":["= str(uuid.uuid4()) cls.created_dataset: DatasetType = cls.client.create_dataset( name=cls.unique_name, dataset_format='ini', content='aGVsbG8sIHdvcmxkIQ==', tags=['test_tag'] ) @classmethod def","None: self.client.update_dataset( dataset_uuid=self.created_dataset['uuid'], name=f'{self.created_dataset[\"name\"]} Updated', dataset_format='json', tags=['updated'] ) fetched_dataset: DatasetType = self.client.get_dataset(self.created_dataset['uuid']) self.assertEqual(fetched_dataset['name'],","return HTTP 429 Too Many Requests otherwise. \"\"\" @classmethod def setUpClass(cls) -> None:","str(uuid.uuid4()) cls.created_dataset: DatasetType = cls.client.create_dataset( name=cls.unique_name, dataset_format='ini', content='aGVsbG8sIHdvcmxkIQ==', tags=['test_tag'] ) @classmethod def tearDownClass(cls)","cls.client.create_dataset( name=cls.unique_name, dataset_format='ini', content='aGVsbG8sIHdvcmxkIQ==', tags=['test_tag'] ) @classmethod def tearDownClass(cls) -> None: cls.client.delete_dataset(cls.created_dataset['uuid']) def","429 Too Many Requests otherwise. \"\"\" @classmethod def setUpClass(cls) -> None: cls.client: SelfHostClient","DatasetType = cls.client.create_dataset( name=cls.unique_name, dataset_format='ini', content='aGVsbG8sIHdvcmxkIQ==', tags=['test_tag'] ) @classmethod def tearDownClass(cls) -> None:","these tests individually because Self-Host will return HTTP 429 Too Many Requests otherwise.","Updated') self.assertEqual(fetched_dataset['format'], 'json') self.assertEqual(fetched_dataset['tags'], ['updated']) def test_get_dataset_raw_content(self) -> None: fetched_content: Any = self.client.get_dataset_raw_content(self.created_dataset['uuid'])","-> None: cls.client: SelfHostClient = SelfHostClient( base_url='http://127.0.0.1:8080', username='test', password='<PASSWORD>' ) cls.unique_name: str =","DatasetType = self.client.get_dataset(self.created_dataset['uuid']) self.assertEqual(fetched_dataset['name'], f'{self.created_dataset[\"name\"]} Updated') self.assertEqual(fetched_dataset['format'], 'json') self.assertEqual(fetched_dataset['tags'], ['updated']) def test_get_dataset_raw_content(self) ->","-> None: fetched_dataset: DatasetType = self.client.get_dataset(self.created_dataset['uuid']) self.assertEqual(fetched_dataset['name'], self.created_dataset['name']) def test_update_dataset(self) -> None: self.client.update_dataset(","tests individually because Self-Host will return HTTP 429 Too Many Requests otherwise. \"\"\"","def test_get_dataset(self) -> None: fetched_dataset: DatasetType = self.client.get_dataset(self.created_dataset['uuid']) self.assertEqual(fetched_dataset['name'], self.created_dataset['name']) def test_update_dataset(self) ->","self.client.get_dataset(self.created_dataset['uuid']) self.assertEqual(fetched_dataset['name'], self.created_dataset['name']) def test_update_dataset(self) -> None: self.client.update_dataset( dataset_uuid=self.created_dataset['uuid'], name=f'{self.created_dataset[\"name\"]} Updated', dataset_format='json', tags=['updated']","self.assertIsNotNone(datasets) def test_create_and_delete_dataset(self) -> None: # Create and delete happens in setup and","selfhost_client import SelfHostClient, DatasetType class TestIntegrationDatasetsClient(unittest.TestCase): \"\"\" Run these tests individually because Self-Host","SelfHostClient( base_url='http://127.0.0.1:8080', username='test', password='<PASSWORD>' ) cls.unique_name: str = str(uuid.uuid4()) cls.created_dataset: DatasetType = cls.client.create_dataset(","datasets: List[DatasetType] = self.client.get_datasets(**params) self.assertIsNotNone(datasets) def test_create_and_delete_dataset(self) -> None: # Create and delete",") cls.unique_name: str = str(uuid.uuid4()) cls.created_dataset: DatasetType = cls.client.create_dataset( name=cls.unique_name, dataset_format='ini', content='aGVsbG8sIHdvcmxkIQ==', tags=['test_tag']","Many Requests otherwise. \"\"\" @classmethod def setUpClass(cls) -> None: cls.client: SelfHostClient = SelfHostClient(","self.assertEqual(self.created_dataset['name'], self.unique_name) def test_get_dataset(self) -> None: fetched_dataset: DatasetType = self.client.get_dataset(self.created_dataset['uuid']) self.assertEqual(fetched_dataset['name'], self.created_dataset['name']) def","from typing import List, Dict, Any import unittest from selfhost_client import SelfHostClient, DatasetType","in setup and teardown methods. self.assertEqual(self.created_dataset['name'], self.unique_name) def test_get_dataset(self) -> None: fetched_dataset: DatasetType","None: params: Dict[str, int] = { 'limit': 20, 'offset': 0 } datasets: List[DatasetType]","= cls.client.create_dataset( name=cls.unique_name, dataset_format='ini', content='aGVsbG8sIHdvcmxkIQ==', tags=['test_tag'] ) @classmethod def tearDownClass(cls) -> None: cls.client.delete_dataset(cls.created_dataset['uuid'])",") @classmethod def tearDownClass(cls) -> None: cls.client.delete_dataset(cls.created_dataset['uuid']) def test_get_datasets(self) -> None: params: Dict[str,","str = str(uuid.uuid4()) cls.created_dataset: DatasetType = cls.client.create_dataset( name=cls.unique_name, dataset_format='ini', content='aGVsbG8sIHdvcmxkIQ==', tags=['test_tag'] ) @classmethod","List, Dict, Any import unittest from selfhost_client import SelfHostClient, DatasetType class TestIntegrationDatasetsClient(unittest.TestCase): \"\"\"","teardown methods. self.assertEqual(self.created_dataset['name'], self.unique_name) def test_get_dataset(self) -> None: fetched_dataset: DatasetType = self.client.get_dataset(self.created_dataset['uuid']) self.assertEqual(fetched_dataset['name'],","self.client.get_dataset(self.created_dataset['uuid']) self.assertEqual(fetched_dataset['name'], f'{self.created_dataset[\"name\"]} Updated') self.assertEqual(fetched_dataset['format'], 'json') self.assertEqual(fetched_dataset['tags'], ['updated']) def test_get_dataset_raw_content(self) -> None: fetched_content:","Run these tests individually because Self-Host will return HTTP 429 Too Many Requests","content='aGVsbG8sIHdvcmxkIQ==', tags=['test_tag'] ) @classmethod def tearDownClass(cls) -> None: cls.client.delete_dataset(cls.created_dataset['uuid']) def test_get_datasets(self) -> None:","Self-Host will return HTTP 429 Too Many Requests otherwise. \"\"\" @classmethod def setUpClass(cls)","Updated', dataset_format='json', tags=['updated'] ) fetched_dataset: DatasetType = self.client.get_dataset(self.created_dataset['uuid']) self.assertEqual(fetched_dataset['name'], f'{self.created_dataset[\"name\"]} Updated') self.assertEqual(fetched_dataset['format'], 'json')","setUpClass(cls) -> None: cls.client: SelfHostClient = SelfHostClient( base_url='http://127.0.0.1:8080', username='test', password='<PASSWORD>' ) cls.unique_name: str","test_create_and_delete_dataset(self) -> None: # Create and delete happens in setup and teardown methods.","self.unique_name) def test_get_dataset(self) -> None: fetched_dataset: DatasetType = self.client.get_dataset(self.created_dataset['uuid']) self.assertEqual(fetched_dataset['name'], self.created_dataset['name']) def test_update_dataset(self)","typing import List, Dict, Any import unittest from selfhost_client import SelfHostClient, DatasetType class","dataset_uuid=self.created_dataset['uuid'], name=f'{self.created_dataset[\"name\"]} Updated', dataset_format='json', tags=['updated'] ) fetched_dataset: DatasetType = self.client.get_dataset(self.created_dataset['uuid']) self.assertEqual(fetched_dataset['name'], f'{self.created_dataset[\"name\"]} Updated')","cls.client.delete_dataset(cls.created_dataset['uuid']) def test_get_datasets(self) -> None: params: Dict[str, int] = { 'limit': 20, 'offset':","def test_get_datasets(self) -> None: params: Dict[str, int] = { 'limit': 20, 'offset': 0","HTTP 429 Too Many Requests otherwise. \"\"\" @classmethod def setUpClass(cls) -> None: cls.client:","def setUpClass(cls) -> None: cls.client: SelfHostClient = SelfHostClient( base_url='http://127.0.0.1:8080', username='test', password='<PASSWORD>' ) cls.unique_name:","TestIntegrationDatasetsClient(unittest.TestCase): \"\"\" Run these tests individually because Self-Host will return HTTP 429 Too","def tearDownClass(cls) -> None: cls.client.delete_dataset(cls.created_dataset['uuid']) def test_get_datasets(self) -> None: params: Dict[str, int] =","self.client.update_dataset( dataset_uuid=self.created_dataset['uuid'], name=f'{self.created_dataset[\"name\"]} Updated', dataset_format='json', tags=['updated'] ) fetched_dataset: DatasetType = self.client.get_dataset(self.created_dataset['uuid']) self.assertEqual(fetched_dataset['name'], f'{self.created_dataset[\"name\"]}","-> None: self.client.update_dataset( dataset_uuid=self.created_dataset['uuid'], name=f'{self.created_dataset[\"name\"]} Updated', dataset_format='json', tags=['updated'] ) fetched_dataset: DatasetType = self.client.get_dataset(self.created_dataset['uuid'])","self.client.get_datasets(**params) self.assertIsNotNone(datasets) def test_create_and_delete_dataset(self) -> None: # Create and delete happens in setup","self.created_dataset['name']) def test_update_dataset(self) -> None: self.client.update_dataset( dataset_uuid=self.created_dataset['uuid'], name=f'{self.created_dataset[\"name\"]} Updated', dataset_format='json', tags=['updated'] ) fetched_dataset:","username='test', password='<PASSWORD>' ) cls.unique_name: str = str(uuid.uuid4()) cls.created_dataset: DatasetType = cls.client.create_dataset( name=cls.unique_name, dataset_format='ini',","will return HTTP 429 Too Many Requests otherwise. \"\"\" @classmethod def setUpClass(cls) ->","= SelfHostClient( base_url='http://127.0.0.1:8080', username='test', password='<PASSWORD>' ) cls.unique_name: str = str(uuid.uuid4()) cls.created_dataset: DatasetType =","= { 'limit': 20, 'offset': 0 } datasets: List[DatasetType] = self.client.get_datasets(**params) self.assertIsNotNone(datasets) def","None: # Create and delete happens in setup and teardown methods. self.assertEqual(self.created_dataset['name'], self.unique_name)","base_url='http://127.0.0.1:8080', username='test', password='<PASSWORD>' ) cls.unique_name: str = str(uuid.uuid4()) cls.created_dataset: DatasetType = cls.client.create_dataset( name=cls.unique_name,","tags=['test_tag'] ) @classmethod def tearDownClass(cls) -> None: cls.client.delete_dataset(cls.created_dataset['uuid']) def test_get_datasets(self) -> None: params:","tags=['updated'] ) fetched_dataset: DatasetType = self.client.get_dataset(self.created_dataset['uuid']) self.assertEqual(fetched_dataset['name'], f'{self.created_dataset[\"name\"]} Updated') self.assertEqual(fetched_dataset['format'], 'json') self.assertEqual(fetched_dataset['tags'], ['updated'])","-> None: cls.client.delete_dataset(cls.created_dataset['uuid']) def test_get_datasets(self) -> None: params: Dict[str, int] = { 'limit':","None: cls.client.delete_dataset(cls.created_dataset['uuid']) def test_get_datasets(self) -> None: params: Dict[str, int] = { 'limit': 20,","= self.client.get_datasets(**params) self.assertIsNotNone(datasets) def test_create_and_delete_dataset(self) -> None: # Create and delete happens in","f'{self.created_dataset[\"name\"]} Updated') self.assertEqual(fetched_dataset['format'], 'json') self.assertEqual(fetched_dataset['tags'], ['updated']) def test_get_dataset_raw_content(self) -> None: fetched_content: Any =","otherwise. \"\"\" @classmethod def setUpClass(cls) -> None: cls.client: SelfHostClient = SelfHostClient( base_url='http://127.0.0.1:8080', username='test',","self.assertEqual(fetched_dataset['name'], f'{self.created_dataset[\"name\"]} Updated') self.assertEqual(fetched_dataset['format'], 'json') self.assertEqual(fetched_dataset['tags'], ['updated']) def test_get_dataset_raw_content(self) -> None: fetched_content: Any","name=f'{self.created_dataset[\"name\"]} Updated', dataset_format='json', tags=['updated'] ) fetched_dataset: DatasetType = self.client.get_dataset(self.created_dataset['uuid']) self.assertEqual(fetched_dataset['name'], f'{self.created_dataset[\"name\"]} Updated') self.assertEqual(fetched_dataset['format'],","def test_create_and_delete_dataset(self) -> None: # Create and delete happens in setup and teardown","uuid from typing import List, Dict, Any import unittest from selfhost_client import SelfHostClient,","None: cls.client: SelfHostClient = SelfHostClient( base_url='http://127.0.0.1:8080', username='test', password='<PASSWORD>' ) cls.unique_name: str = str(uuid.uuid4())","params: Dict[str, int] = { 'limit': 20, 'offset': 0 } datasets: List[DatasetType] =","unittest from selfhost_client import SelfHostClient, DatasetType class TestIntegrationDatasetsClient(unittest.TestCase): \"\"\" Run these tests individually","@classmethod def setUpClass(cls) -> None: cls.client: SelfHostClient = SelfHostClient( base_url='http://127.0.0.1:8080', username='test', password='<PASSWORD>' )","because Self-Host will return HTTP 429 Too Many Requests otherwise. \"\"\" @classmethod def","SelfHostClient = SelfHostClient( base_url='http://127.0.0.1:8080', username='test', password='<PASSWORD>' ) cls.unique_name: str = str(uuid.uuid4()) cls.created_dataset: DatasetType","methods. self.assertEqual(self.created_dataset['name'], self.unique_name) def test_get_dataset(self) -> None: fetched_dataset: DatasetType = self.client.get_dataset(self.created_dataset['uuid']) self.assertEqual(fetched_dataset['name'], self.created_dataset['name'])","test_update_dataset(self) -> None: self.client.update_dataset( dataset_uuid=self.created_dataset['uuid'], name=f'{self.created_dataset[\"name\"]} Updated', dataset_format='json', tags=['updated'] ) fetched_dataset: DatasetType =","tearDownClass(cls) -> None: cls.client.delete_dataset(cls.created_dataset['uuid']) def test_get_datasets(self) -> None: params: Dict[str, int] = {","{ 'limit': 20, 'offset': 0 } datasets: List[DatasetType] = self.client.get_datasets(**params) self.assertIsNotNone(datasets) def test_create_and_delete_dataset(self)","setup and teardown methods. self.assertEqual(self.created_dataset['name'], self.unique_name) def test_get_dataset(self) -> None: fetched_dataset: DatasetType =","DatasetType = self.client.get_dataset(self.created_dataset['uuid']) self.assertEqual(fetched_dataset['name'], self.created_dataset['name']) def test_update_dataset(self) -> None: self.client.update_dataset( dataset_uuid=self.created_dataset['uuid'], name=f'{self.created_dataset[\"name\"]} Updated',","Create and delete happens in setup and teardown methods. self.assertEqual(self.created_dataset['name'], self.unique_name) def test_get_dataset(self)","fetched_dataset: DatasetType = self.client.get_dataset(self.created_dataset['uuid']) self.assertEqual(fetched_dataset['name'], f'{self.created_dataset[\"name\"]} Updated') self.assertEqual(fetched_dataset['format'], 'json') self.assertEqual(fetched_dataset['tags'], ['updated']) def test_get_dataset_raw_content(self)","import SelfHostClient, DatasetType class TestIntegrationDatasetsClient(unittest.TestCase): \"\"\" Run these tests individually because Self-Host will",") fetched_dataset: DatasetType = self.client.get_dataset(self.created_dataset['uuid']) self.assertEqual(fetched_dataset['name'], f'{self.created_dataset[\"name\"]} Updated') self.assertEqual(fetched_dataset['format'], 'json') self.assertEqual(fetched_dataset['tags'], ['updated']) def","import List, Dict, Any import unittest from selfhost_client import SelfHostClient, DatasetType class TestIntegrationDatasetsClient(unittest.TestCase):","class TestIntegrationDatasetsClient(unittest.TestCase): \"\"\" Run these tests individually because Self-Host will return HTTP 429","\"\"\" @classmethod def setUpClass(cls) -> None: cls.client: SelfHostClient = SelfHostClient( base_url='http://127.0.0.1:8080', username='test', password='<PASSWORD>'","'limit': 20, 'offset': 0 } datasets: List[DatasetType] = self.client.get_datasets(**params) self.assertIsNotNone(datasets) def test_create_and_delete_dataset(self) ->","DatasetType class TestIntegrationDatasetsClient(unittest.TestCase): \"\"\" Run these tests individually because Self-Host will return HTTP","= self.client.get_dataset(self.created_dataset['uuid']) self.assertEqual(fetched_dataset['name'], f'{self.created_dataset[\"name\"]} Updated') self.assertEqual(fetched_dataset['format'], 'json') self.assertEqual(fetched_dataset['tags'], ['updated']) def test_get_dataset_raw_content(self) -> None:","Dict[str, int] = { 'limit': 20, 'offset': 0 } datasets: List[DatasetType] = self.client.get_datasets(**params)","@classmethod def tearDownClass(cls) -> None: cls.client.delete_dataset(cls.created_dataset['uuid']) def test_get_datasets(self) -> None: params: Dict[str, int]","None: fetched_dataset: DatasetType = self.client.get_dataset(self.created_dataset['uuid']) self.assertEqual(fetched_dataset['name'], self.created_dataset['name']) def test_update_dataset(self) -> None: self.client.update_dataset( dataset_uuid=self.created_dataset['uuid'],","test_get_datasets(self) -> None: params: Dict[str, int] = { 'limit': 20, 'offset': 0 }","delete happens in setup and teardown methods. self.assertEqual(self.created_dataset['name'], self.unique_name) def test_get_dataset(self) -> None:","int] = { 'limit': 20, 'offset': 0 } datasets: List[DatasetType] = self.client.get_datasets(**params) self.assertIsNotNone(datasets)","from selfhost_client import SelfHostClient, DatasetType class TestIntegrationDatasetsClient(unittest.TestCase): \"\"\" Run these tests individually because","import unittest from selfhost_client import SelfHostClient, DatasetType class TestIntegrationDatasetsClient(unittest.TestCase): \"\"\" Run these tests","20, 'offset': 0 } datasets: List[DatasetType] = self.client.get_datasets(**params) self.assertIsNotNone(datasets) def test_create_and_delete_dataset(self) -> None:","= self.client.get_dataset(self.created_dataset['uuid']) self.assertEqual(fetched_dataset['name'], self.created_dataset['name']) def test_update_dataset(self) -> None: self.client.update_dataset( dataset_uuid=self.created_dataset['uuid'], name=f'{self.created_dataset[\"name\"]} Updated', dataset_format='json',","and delete happens in setup and teardown methods. self.assertEqual(self.created_dataset['name'], self.unique_name) def test_get_dataset(self) ->","password='<PASSWORD>' ) cls.unique_name: str = str(uuid.uuid4()) cls.created_dataset: DatasetType = cls.client.create_dataset( name=cls.unique_name, dataset_format='ini', content='aGVsbG8sIHdvcmxkIQ==',","Dict, Any import unittest from selfhost_client import SelfHostClient, DatasetType class TestIntegrationDatasetsClient(unittest.TestCase): \"\"\" Run","} datasets: List[DatasetType] = self.client.get_datasets(**params) self.assertIsNotNone(datasets) def test_create_and_delete_dataset(self) -> None: # Create and","fetched_dataset: DatasetType = self.client.get_dataset(self.created_dataset['uuid']) self.assertEqual(fetched_dataset['name'], self.created_dataset['name']) def test_update_dataset(self) -> None: self.client.update_dataset( dataset_uuid=self.created_dataset['uuid'], name=f'{self.created_dataset[\"name\"]}","Too Many Requests otherwise. \"\"\" @classmethod def setUpClass(cls) -> None: cls.client: SelfHostClient =","cls.created_dataset: DatasetType = cls.client.create_dataset( name=cls.unique_name, dataset_format='ini', content='aGVsbG8sIHdvcmxkIQ==', tags=['test_tag'] ) @classmethod def tearDownClass(cls) ->","test_get_dataset(self) -> None: fetched_dataset: DatasetType = self.client.get_dataset(self.created_dataset['uuid']) self.assertEqual(fetched_dataset['name'], self.created_dataset['name']) def test_update_dataset(self) -> None:","Requests otherwise. \"\"\" @classmethod def setUpClass(cls) -> None: cls.client: SelfHostClient = SelfHostClient( base_url='http://127.0.0.1:8080',","def test_update_dataset(self) -> None: self.client.update_dataset( dataset_uuid=self.created_dataset['uuid'], name=f'{self.created_dataset[\"name\"]} Updated', dataset_format='json', tags=['updated'] ) fetched_dataset: DatasetType","dataset_format='ini', content='aGVsbG8sIHdvcmxkIQ==', tags=['test_tag'] ) @classmethod def tearDownClass(cls) -> None: cls.client.delete_dataset(cls.created_dataset['uuid']) def test_get_datasets(self) ->","-> None: # Create and delete happens in setup and teardown methods. self.assertEqual(self.created_dataset['name'],","self.assertEqual(fetched_dataset['name'], self.created_dataset['name']) def test_update_dataset(self) -> None: self.client.update_dataset( dataset_uuid=self.created_dataset['uuid'], name=f'{self.created_dataset[\"name\"]} Updated', dataset_format='json', tags=['updated'] )","self.assertEqual(fetched_dataset['format'], 'json') self.assertEqual(fetched_dataset['tags'], ['updated']) def test_get_dataset_raw_content(self) -> None: fetched_content: Any = self.client.get_dataset_raw_content(self.created_dataset['uuid']) self.assertIsNotNone(fetched_content)","List[DatasetType] = self.client.get_datasets(**params) self.assertIsNotNone(datasets) def test_create_and_delete_dataset(self) -> None: # Create and delete happens","import uuid from typing import List, Dict, Any import unittest from selfhost_client import","dataset_format='json', tags=['updated'] ) fetched_dataset: DatasetType = self.client.get_dataset(self.created_dataset['uuid']) self.assertEqual(fetched_dataset['name'], f'{self.created_dataset[\"name\"]} Updated') self.assertEqual(fetched_dataset['format'], 'json') self.assertEqual(fetched_dataset['tags'],","# Create and delete happens in setup and teardown methods. self.assertEqual(self.created_dataset['name'], self.unique_name) def","0 } datasets: List[DatasetType] = self.client.get_datasets(**params) self.assertIsNotNone(datasets) def test_create_and_delete_dataset(self) -> None: # Create","and teardown methods. self.assertEqual(self.created_dataset['name'], self.unique_name) def test_get_dataset(self) -> None: fetched_dataset: DatasetType = self.client.get_dataset(self.created_dataset['uuid'])","cls.unique_name: str = str(uuid.uuid4()) cls.created_dataset: DatasetType = cls.client.create_dataset( name=cls.unique_name, dataset_format='ini', content='aGVsbG8sIHdvcmxkIQ==', tags=['test_tag'] )","individually because Self-Host will return HTTP 429 Too Many Requests otherwise. \"\"\" @classmethod","Any import unittest from selfhost_client import SelfHostClient, DatasetType class TestIntegrationDatasetsClient(unittest.TestCase): \"\"\" Run these","'offset': 0 } datasets: List[DatasetType] = self.client.get_datasets(**params) self.assertIsNotNone(datasets) def test_create_and_delete_dataset(self) -> None: #","\"\"\" Run these tests individually because Self-Host will return HTTP 429 Too Many","cls.client: SelfHostClient = SelfHostClient( base_url='http://127.0.0.1:8080', username='test', password='<PASSWORD>' ) cls.unique_name: str = str(uuid.uuid4()) cls.created_dataset:","name=cls.unique_name, dataset_format='ini', content='aGVsbG8sIHdvcmxkIQ==', tags=['test_tag'] ) @classmethod def tearDownClass(cls) -> None: cls.client.delete_dataset(cls.created_dataset['uuid']) def test_get_datasets(self)","-> None: params: Dict[str, int] = { 'limit': 20, 'offset': 0 } datasets:","happens in setup and teardown methods. self.assertEqual(self.created_dataset['name'], self.unique_name) def test_get_dataset(self) -> None: fetched_dataset:","SelfHostClient, DatasetType class TestIntegrationDatasetsClient(unittest.TestCase): \"\"\" Run these tests individually because Self-Host will return"],"string":"[\n \"= str(uuid.uuid4()) cls.created_dataset: DatasetType = cls.client.create_dataset( name=cls.unique_name, dataset_format='ini', content='aGVsbG8sIHdvcmxkIQ==', tags=['test_tag'] ) @classmethod def\",\n \"None: self.client.update_dataset( dataset_uuid=self.created_dataset['uuid'], name=f'{self.created_dataset[\\\"name\\\"]} Updated', dataset_format='json', tags=['updated'] ) fetched_dataset: DatasetType = self.client.get_dataset(self.created_dataset['uuid']) self.assertEqual(fetched_dataset['name'],\",\n \"return HTTP 429 Too Many Requests otherwise. \\\"\\\"\\\" @classmethod def setUpClass(cls) -> None:\",\n \"str(uuid.uuid4()) cls.created_dataset: DatasetType = cls.client.create_dataset( name=cls.unique_name, dataset_format='ini', content='aGVsbG8sIHdvcmxkIQ==', tags=['test_tag'] ) @classmethod def tearDownClass(cls)\",\n \"cls.client.create_dataset( name=cls.unique_name, dataset_format='ini', content='aGVsbG8sIHdvcmxkIQ==', tags=['test_tag'] ) @classmethod def tearDownClass(cls) -> None: cls.client.delete_dataset(cls.created_dataset['uuid']) def\",\n \"429 Too Many Requests otherwise. \\\"\\\"\\\" @classmethod def setUpClass(cls) -> None: cls.client: SelfHostClient\",\n \"DatasetType = cls.client.create_dataset( name=cls.unique_name, dataset_format='ini', content='aGVsbG8sIHdvcmxkIQ==', tags=['test_tag'] ) @classmethod def tearDownClass(cls) -> None:\",\n \"these tests individually because Self-Host will return HTTP 429 Too Many Requests otherwise.\",\n \"Updated') self.assertEqual(fetched_dataset['format'], 'json') self.assertEqual(fetched_dataset['tags'], ['updated']) def test_get_dataset_raw_content(self) -> None: fetched_content: Any = self.client.get_dataset_raw_content(self.created_dataset['uuid'])\",\n \"-> None: cls.client: SelfHostClient = SelfHostClient( base_url='http://127.0.0.1:8080', username='test', password='<PASSWORD>' ) cls.unique_name: str =\",\n \"DatasetType = self.client.get_dataset(self.created_dataset['uuid']) self.assertEqual(fetched_dataset['name'], f'{self.created_dataset[\\\"name\\\"]} Updated') self.assertEqual(fetched_dataset['format'], 'json') self.assertEqual(fetched_dataset['tags'], ['updated']) def test_get_dataset_raw_content(self) ->\",\n \"-> None: fetched_dataset: DatasetType = self.client.get_dataset(self.created_dataset['uuid']) self.assertEqual(fetched_dataset['name'], self.created_dataset['name']) def test_update_dataset(self) -> None: self.client.update_dataset(\",\n \"tests individually because Self-Host will return HTTP 429 Too Many Requests otherwise. \\\"\\\"\\\"\",\n \"def test_get_dataset(self) -> None: fetched_dataset: DatasetType = self.client.get_dataset(self.created_dataset['uuid']) self.assertEqual(fetched_dataset['name'], self.created_dataset['name']) def test_update_dataset(self) ->\",\n \"self.client.get_dataset(self.created_dataset['uuid']) self.assertEqual(fetched_dataset['name'], self.created_dataset['name']) def test_update_dataset(self) -> None: self.client.update_dataset( dataset_uuid=self.created_dataset['uuid'], name=f'{self.created_dataset[\\\"name\\\"]} Updated', dataset_format='json', tags=['updated']\",\n \"self.assertIsNotNone(datasets) def test_create_and_delete_dataset(self) -> None: # Create and delete happens in setup and\",\n \"selfhost_client import SelfHostClient, DatasetType class TestIntegrationDatasetsClient(unittest.TestCase): \\\"\\\"\\\" Run these tests individually because Self-Host\",\n \"SelfHostClient( base_url='http://127.0.0.1:8080', username='test', password='<PASSWORD>' ) cls.unique_name: str = str(uuid.uuid4()) cls.created_dataset: DatasetType = cls.client.create_dataset(\",\n \"datasets: List[DatasetType] = self.client.get_datasets(**params) self.assertIsNotNone(datasets) def test_create_and_delete_dataset(self) -> None: # Create and delete\",\n \") cls.unique_name: str = str(uuid.uuid4()) cls.created_dataset: DatasetType = cls.client.create_dataset( name=cls.unique_name, dataset_format='ini', content='aGVsbG8sIHdvcmxkIQ==', tags=['test_tag']\",\n \"Many Requests otherwise. \\\"\\\"\\\" @classmethod def setUpClass(cls) -> None: cls.client: SelfHostClient = SelfHostClient(\",\n \"self.assertEqual(self.created_dataset['name'], self.unique_name) def test_get_dataset(self) -> None: fetched_dataset: DatasetType = self.client.get_dataset(self.created_dataset['uuid']) self.assertEqual(fetched_dataset['name'], self.created_dataset['name']) def\",\n \"from typing import List, Dict, Any import unittest from selfhost_client import SelfHostClient, DatasetType\",\n \"in setup and teardown methods. self.assertEqual(self.created_dataset['name'], self.unique_name) def test_get_dataset(self) -> None: fetched_dataset: DatasetType\",\n \"None: params: Dict[str, int] = { 'limit': 20, 'offset': 0 } datasets: List[DatasetType]\",\n \"= cls.client.create_dataset( name=cls.unique_name, dataset_format='ini', content='aGVsbG8sIHdvcmxkIQ==', tags=['test_tag'] ) @classmethod def tearDownClass(cls) -> None: cls.client.delete_dataset(cls.created_dataset['uuid'])\",\n \") @classmethod def tearDownClass(cls) -> None: cls.client.delete_dataset(cls.created_dataset['uuid']) def test_get_datasets(self) -> None: params: Dict[str,\",\n \"str = str(uuid.uuid4()) cls.created_dataset: DatasetType = cls.client.create_dataset( name=cls.unique_name, dataset_format='ini', content='aGVsbG8sIHdvcmxkIQ==', tags=['test_tag'] ) @classmethod\",\n \"List, Dict, Any import unittest from selfhost_client import SelfHostClient, DatasetType class TestIntegrationDatasetsClient(unittest.TestCase): \\\"\\\"\\\"\",\n \"teardown methods. self.assertEqual(self.created_dataset['name'], self.unique_name) def test_get_dataset(self) -> None: fetched_dataset: DatasetType = self.client.get_dataset(self.created_dataset['uuid']) self.assertEqual(fetched_dataset['name'],\",\n \"self.client.get_dataset(self.created_dataset['uuid']) self.assertEqual(fetched_dataset['name'], f'{self.created_dataset[\\\"name\\\"]} Updated') self.assertEqual(fetched_dataset['format'], 'json') self.assertEqual(fetched_dataset['tags'], ['updated']) def test_get_dataset_raw_content(self) -> None: fetched_content:\",\n \"Run these tests individually because Self-Host will return HTTP 429 Too Many Requests\",\n \"content='aGVsbG8sIHdvcmxkIQ==', tags=['test_tag'] ) @classmethod def tearDownClass(cls) -> None: cls.client.delete_dataset(cls.created_dataset['uuid']) def test_get_datasets(self) -> None:\",\n \"Self-Host will return HTTP 429 Too Many Requests otherwise. \\\"\\\"\\\" @classmethod def setUpClass(cls)\",\n \"Updated', dataset_format='json', tags=['updated'] ) fetched_dataset: DatasetType = self.client.get_dataset(self.created_dataset['uuid']) self.assertEqual(fetched_dataset['name'], f'{self.created_dataset[\\\"name\\\"]} Updated') self.assertEqual(fetched_dataset['format'], 'json')\",\n \"setUpClass(cls) -> None: cls.client: SelfHostClient = SelfHostClient( base_url='http://127.0.0.1:8080', username='test', password='<PASSWORD>' ) cls.unique_name: str\",\n \"test_create_and_delete_dataset(self) -> None: # Create and delete happens in setup and teardown methods.\",\n \"self.unique_name) def test_get_dataset(self) -> None: fetched_dataset: DatasetType = self.client.get_dataset(self.created_dataset['uuid']) self.assertEqual(fetched_dataset['name'], self.created_dataset['name']) def test_update_dataset(self)\",\n \"typing import List, Dict, Any import unittest from selfhost_client import SelfHostClient, DatasetType class\",\n \"dataset_uuid=self.created_dataset['uuid'], name=f'{self.created_dataset[\\\"name\\\"]} Updated', dataset_format='json', tags=['updated'] ) fetched_dataset: DatasetType = self.client.get_dataset(self.created_dataset['uuid']) self.assertEqual(fetched_dataset['name'], f'{self.created_dataset[\\\"name\\\"]} Updated')\",\n \"cls.client.delete_dataset(cls.created_dataset['uuid']) def test_get_datasets(self) -> None: params: Dict[str, int] = { 'limit': 20, 'offset':\",\n \"def test_get_datasets(self) -> None: params: Dict[str, int] = { 'limit': 20, 'offset': 0\",\n \"HTTP 429 Too Many Requests otherwise. \\\"\\\"\\\" @classmethod def setUpClass(cls) -> None: cls.client:\",\n \"def setUpClass(cls) -> None: cls.client: SelfHostClient = SelfHostClient( base_url='http://127.0.0.1:8080', username='test', password='<PASSWORD>' ) cls.unique_name:\",\n \"TestIntegrationDatasetsClient(unittest.TestCase): \\\"\\\"\\\" Run these tests individually because Self-Host will return HTTP 429 Too\",\n \"def tearDownClass(cls) -> None: cls.client.delete_dataset(cls.created_dataset['uuid']) def test_get_datasets(self) -> None: params: Dict[str, int] =\",\n \"self.client.update_dataset( dataset_uuid=self.created_dataset['uuid'], name=f'{self.created_dataset[\\\"name\\\"]} Updated', dataset_format='json', tags=['updated'] ) fetched_dataset: DatasetType = self.client.get_dataset(self.created_dataset['uuid']) self.assertEqual(fetched_dataset['name'], f'{self.created_dataset[\\\"name\\\"]}\",\n \"-> None: self.client.update_dataset( dataset_uuid=self.created_dataset['uuid'], name=f'{self.created_dataset[\\\"name\\\"]} Updated', dataset_format='json', tags=['updated'] ) fetched_dataset: DatasetType = self.client.get_dataset(self.created_dataset['uuid'])\",\n \"self.client.get_datasets(**params) self.assertIsNotNone(datasets) def test_create_and_delete_dataset(self) -> None: # Create and delete happens in setup\",\n \"self.created_dataset['name']) def test_update_dataset(self) -> None: self.client.update_dataset( dataset_uuid=self.created_dataset['uuid'], name=f'{self.created_dataset[\\\"name\\\"]} Updated', dataset_format='json', tags=['updated'] ) fetched_dataset:\",\n \"username='test', password='<PASSWORD>' ) cls.unique_name: str = str(uuid.uuid4()) cls.created_dataset: DatasetType = cls.client.create_dataset( name=cls.unique_name, dataset_format='ini',\",\n \"will return HTTP 429 Too Many Requests otherwise. \\\"\\\"\\\" @classmethod def setUpClass(cls) ->\",\n \"= SelfHostClient( base_url='http://127.0.0.1:8080', username='test', password='<PASSWORD>' ) cls.unique_name: str = str(uuid.uuid4()) cls.created_dataset: DatasetType =\",\n \"= { 'limit': 20, 'offset': 0 } datasets: List[DatasetType] = self.client.get_datasets(**params) self.assertIsNotNone(datasets) def\",\n \"None: # Create and delete happens in setup and teardown methods. self.assertEqual(self.created_dataset['name'], self.unique_name)\",\n \"base_url='http://127.0.0.1:8080', username='test', password='<PASSWORD>' ) cls.unique_name: str = str(uuid.uuid4()) cls.created_dataset: DatasetType = cls.client.create_dataset( name=cls.unique_name,\",\n \"tags=['test_tag'] ) @classmethod def tearDownClass(cls) -> None: cls.client.delete_dataset(cls.created_dataset['uuid']) def test_get_datasets(self) -> None: params:\",\n \"tags=['updated'] ) fetched_dataset: DatasetType = self.client.get_dataset(self.created_dataset['uuid']) self.assertEqual(fetched_dataset['name'], f'{self.created_dataset[\\\"name\\\"]} Updated') self.assertEqual(fetched_dataset['format'], 'json') self.assertEqual(fetched_dataset['tags'], ['updated'])\",\n \"-> None: cls.client.delete_dataset(cls.created_dataset['uuid']) def test_get_datasets(self) -> None: params: Dict[str, int] = { 'limit':\",\n \"None: cls.client.delete_dataset(cls.created_dataset['uuid']) def test_get_datasets(self) -> None: params: Dict[str, int] = { 'limit': 20,\",\n \"= self.client.get_datasets(**params) self.assertIsNotNone(datasets) def test_create_and_delete_dataset(self) -> None: # Create and delete happens in\",\n \"f'{self.created_dataset[\\\"name\\\"]} Updated') self.assertEqual(fetched_dataset['format'], 'json') self.assertEqual(fetched_dataset['tags'], ['updated']) def test_get_dataset_raw_content(self) -> None: fetched_content: Any =\",\n \"otherwise. \\\"\\\"\\\" @classmethod def setUpClass(cls) -> None: cls.client: SelfHostClient = SelfHostClient( base_url='http://127.0.0.1:8080', username='test',\",\n \"self.assertEqual(fetched_dataset['name'], f'{self.created_dataset[\\\"name\\\"]} Updated') self.assertEqual(fetched_dataset['format'], 'json') self.assertEqual(fetched_dataset['tags'], ['updated']) def test_get_dataset_raw_content(self) -> None: fetched_content: Any\",\n \"name=f'{self.created_dataset[\\\"name\\\"]} Updated', dataset_format='json', tags=['updated'] ) fetched_dataset: DatasetType = self.client.get_dataset(self.created_dataset['uuid']) self.assertEqual(fetched_dataset['name'], f'{self.created_dataset[\\\"name\\\"]} Updated') self.assertEqual(fetched_dataset['format'],\",\n \"def test_create_and_delete_dataset(self) -> None: # Create and delete happens in setup and teardown\",\n \"uuid from typing import List, Dict, Any import unittest from selfhost_client import SelfHostClient,\",\n \"None: cls.client: SelfHostClient = SelfHostClient( base_url='http://127.0.0.1:8080', username='test', password='<PASSWORD>' ) cls.unique_name: str = str(uuid.uuid4())\",\n \"params: Dict[str, int] = { 'limit': 20, 'offset': 0 } datasets: List[DatasetType] =\",\n \"unittest from selfhost_client import SelfHostClient, DatasetType class TestIntegrationDatasetsClient(unittest.TestCase): \\\"\\\"\\\" Run these tests individually\",\n \"@classmethod def setUpClass(cls) -> None: cls.client: SelfHostClient = SelfHostClient( base_url='http://127.0.0.1:8080', username='test', password='<PASSWORD>' )\",\n \"because Self-Host will return HTTP 429 Too Many Requests otherwise. \\\"\\\"\\\" @classmethod def\",\n \"SelfHostClient = SelfHostClient( base_url='http://127.0.0.1:8080', username='test', password='<PASSWORD>' ) cls.unique_name: str = str(uuid.uuid4()) cls.created_dataset: DatasetType\",\n \"methods. self.assertEqual(self.created_dataset['name'], self.unique_name) def test_get_dataset(self) -> None: fetched_dataset: DatasetType = self.client.get_dataset(self.created_dataset['uuid']) self.assertEqual(fetched_dataset['name'], self.created_dataset['name'])\",\n \"test_update_dataset(self) -> None: self.client.update_dataset( dataset_uuid=self.created_dataset['uuid'], name=f'{self.created_dataset[\\\"name\\\"]} Updated', dataset_format='json', tags=['updated'] ) fetched_dataset: DatasetType =\",\n \"tearDownClass(cls) -> None: cls.client.delete_dataset(cls.created_dataset['uuid']) def test_get_datasets(self) -> None: params: Dict[str, int] = {\",\n \"{ 'limit': 20, 'offset': 0 } datasets: List[DatasetType] = self.client.get_datasets(**params) self.assertIsNotNone(datasets) def test_create_and_delete_dataset(self)\",\n \"setup and teardown methods. self.assertEqual(self.created_dataset['name'], self.unique_name) def test_get_dataset(self) -> None: fetched_dataset: DatasetType =\",\n \"DatasetType = self.client.get_dataset(self.created_dataset['uuid']) self.assertEqual(fetched_dataset['name'], self.created_dataset['name']) def test_update_dataset(self) -> None: self.client.update_dataset( dataset_uuid=self.created_dataset['uuid'], name=f'{self.created_dataset[\\\"name\\\"]} Updated',\",\n \"Create and delete happens in setup and teardown methods. self.assertEqual(self.created_dataset['name'], self.unique_name) def test_get_dataset(self)\",\n \"fetched_dataset: DatasetType = self.client.get_dataset(self.created_dataset['uuid']) self.assertEqual(fetched_dataset['name'], f'{self.created_dataset[\\\"name\\\"]} Updated') self.assertEqual(fetched_dataset['format'], 'json') self.assertEqual(fetched_dataset['tags'], ['updated']) def test_get_dataset_raw_content(self)\",\n \"import SelfHostClient, DatasetType class TestIntegrationDatasetsClient(unittest.TestCase): \\\"\\\"\\\" Run these tests individually because Self-Host will\",\n \") fetched_dataset: DatasetType = self.client.get_dataset(self.created_dataset['uuid']) self.assertEqual(fetched_dataset['name'], f'{self.created_dataset[\\\"name\\\"]} Updated') self.assertEqual(fetched_dataset['format'], 'json') self.assertEqual(fetched_dataset['tags'], ['updated']) def\",\n \"import List, Dict, Any import unittest from selfhost_client import SelfHostClient, DatasetType class TestIntegrationDatasetsClient(unittest.TestCase):\",\n \"class TestIntegrationDatasetsClient(unittest.TestCase): \\\"\\\"\\\" Run these tests individually because Self-Host will return HTTP 429\",\n \"\\\"\\\"\\\" @classmethod def setUpClass(cls) -> None: cls.client: SelfHostClient = SelfHostClient( base_url='http://127.0.0.1:8080', username='test', password='<PASSWORD>'\",\n \"'limit': 20, 'offset': 0 } datasets: List[DatasetType] = self.client.get_datasets(**params) self.assertIsNotNone(datasets) def test_create_and_delete_dataset(self) ->\",\n \"DatasetType class TestIntegrationDatasetsClient(unittest.TestCase): \\\"\\\"\\\" Run these tests individually because Self-Host will return HTTP\",\n \"= self.client.get_dataset(self.created_dataset['uuid']) self.assertEqual(fetched_dataset['name'], f'{self.created_dataset[\\\"name\\\"]} Updated') self.assertEqual(fetched_dataset['format'], 'json') self.assertEqual(fetched_dataset['tags'], ['updated']) def test_get_dataset_raw_content(self) -> None:\",\n \"Dict[str, int] = { 'limit': 20, 'offset': 0 } datasets: List[DatasetType] = self.client.get_datasets(**params)\",\n \"@classmethod def tearDownClass(cls) -> None: cls.client.delete_dataset(cls.created_dataset['uuid']) def test_get_datasets(self) -> None: params: Dict[str, int]\",\n \"None: fetched_dataset: DatasetType = self.client.get_dataset(self.created_dataset['uuid']) self.assertEqual(fetched_dataset['name'], self.created_dataset['name']) def test_update_dataset(self) -> None: self.client.update_dataset( dataset_uuid=self.created_dataset['uuid'],\",\n \"test_get_datasets(self) -> None: params: Dict[str, int] = { 'limit': 20, 'offset': 0 }\",\n \"delete happens in setup and teardown methods. self.assertEqual(self.created_dataset['name'], self.unique_name) def test_get_dataset(self) -> None:\",\n \"int] = { 'limit': 20, 'offset': 0 } datasets: List[DatasetType] = self.client.get_datasets(**params) self.assertIsNotNone(datasets)\",\n \"from selfhost_client import SelfHostClient, DatasetType class TestIntegrationDatasetsClient(unittest.TestCase): \\\"\\\"\\\" Run these tests individually because\",\n \"import unittest from selfhost_client import SelfHostClient, DatasetType class TestIntegrationDatasetsClient(unittest.TestCase): \\\"\\\"\\\" Run these tests\",\n \"20, 'offset': 0 } datasets: List[DatasetType] = self.client.get_datasets(**params) self.assertIsNotNone(datasets) def test_create_and_delete_dataset(self) -> None:\",\n \"= self.client.get_dataset(self.created_dataset['uuid']) self.assertEqual(fetched_dataset['name'], self.created_dataset['name']) def test_update_dataset(self) -> None: self.client.update_dataset( dataset_uuid=self.created_dataset['uuid'], name=f'{self.created_dataset[\\\"name\\\"]} Updated', dataset_format='json',\",\n \"and delete happens in setup and teardown methods. self.assertEqual(self.created_dataset['name'], self.unique_name) def test_get_dataset(self) ->\",\n \"password='<PASSWORD>' ) cls.unique_name: str = str(uuid.uuid4()) cls.created_dataset: DatasetType = cls.client.create_dataset( name=cls.unique_name, dataset_format='ini', content='aGVsbG8sIHdvcmxkIQ==',\",\n \"Dict, Any import unittest from selfhost_client import SelfHostClient, DatasetType class TestIntegrationDatasetsClient(unittest.TestCase): \\\"\\\"\\\" Run\",\n \"} datasets: List[DatasetType] = self.client.get_datasets(**params) self.assertIsNotNone(datasets) def test_create_and_delete_dataset(self) -> None: # Create and\",\n \"fetched_dataset: DatasetType = self.client.get_dataset(self.created_dataset['uuid']) self.assertEqual(fetched_dataset['name'], self.created_dataset['name']) def test_update_dataset(self) -> None: self.client.update_dataset( dataset_uuid=self.created_dataset['uuid'], name=f'{self.created_dataset[\\\"name\\\"]}\",\n \"Too Many Requests otherwise. \\\"\\\"\\\" @classmethod def setUpClass(cls) -> None: cls.client: SelfHostClient =\",\n \"cls.created_dataset: DatasetType = cls.client.create_dataset( name=cls.unique_name, dataset_format='ini', content='aGVsbG8sIHdvcmxkIQ==', tags=['test_tag'] ) @classmethod def tearDownClass(cls) ->\",\n \"test_get_dataset(self) -> None: fetched_dataset: DatasetType = self.client.get_dataset(self.created_dataset['uuid']) self.assertEqual(fetched_dataset['name'], self.created_dataset['name']) def test_update_dataset(self) -> None:\",\n \"Requests otherwise. \\\"\\\"\\\" @classmethod def setUpClass(cls) -> None: cls.client: SelfHostClient = SelfHostClient( base_url='http://127.0.0.1:8080',\",\n \"def test_update_dataset(self) -> None: self.client.update_dataset( dataset_uuid=self.created_dataset['uuid'], name=f'{self.created_dataset[\\\"name\\\"]} Updated', dataset_format='json', tags=['updated'] ) fetched_dataset: DatasetType\",\n \"dataset_format='ini', content='aGVsbG8sIHdvcmxkIQ==', tags=['test_tag'] ) @classmethod def tearDownClass(cls) -> None: cls.client.delete_dataset(cls.created_dataset['uuid']) def test_get_datasets(self) ->\",\n \"-> None: # Create and delete happens in setup and teardown methods. self.assertEqual(self.created_dataset['name'],\",\n \"self.assertEqual(fetched_dataset['name'], self.created_dataset['name']) def test_update_dataset(self) -> None: self.client.update_dataset( dataset_uuid=self.created_dataset['uuid'], name=f'{self.created_dataset[\\\"name\\\"]} Updated', dataset_format='json', tags=['updated'] )\",\n \"self.assertEqual(fetched_dataset['format'], 'json') self.assertEqual(fetched_dataset['tags'], ['updated']) def test_get_dataset_raw_content(self) -> None: fetched_content: Any = self.client.get_dataset_raw_content(self.created_dataset['uuid']) self.assertIsNotNone(fetched_content)\",\n \"List[DatasetType] = self.client.get_datasets(**params) self.assertIsNotNone(datasets) def test_create_and_delete_dataset(self) -> None: # Create and delete happens\",\n \"import uuid from typing import List, Dict, Any import unittest from selfhost_client import\",\n \"dataset_format='json', tags=['updated'] ) fetched_dataset: DatasetType = self.client.get_dataset(self.created_dataset['uuid']) self.assertEqual(fetched_dataset['name'], f'{self.created_dataset[\\\"name\\\"]} Updated') self.assertEqual(fetched_dataset['format'], 'json') self.assertEqual(fetched_dataset['tags'],\",\n \"# Create and delete happens in setup and teardown methods. self.assertEqual(self.created_dataset['name'], self.unique_name) def\",\n \"0 } datasets: List[DatasetType] = self.client.get_datasets(**params) self.assertIsNotNone(datasets) def test_create_and_delete_dataset(self) -> None: # Create\",\n \"and teardown methods. self.assertEqual(self.created_dataset['name'], self.unique_name) def test_get_dataset(self) -> None: fetched_dataset: DatasetType = self.client.get_dataset(self.created_dataset['uuid'])\",\n \"cls.unique_name: str = str(uuid.uuid4()) cls.created_dataset: DatasetType = cls.client.create_dataset( name=cls.unique_name, dataset_format='ini', content='aGVsbG8sIHdvcmxkIQ==', tags=['test_tag'] )\",\n \"individually because Self-Host will return HTTP 429 Too Many Requests otherwise. \\\"\\\"\\\" @classmethod\",\n \"Any import unittest from selfhost_client import SelfHostClient, DatasetType class TestIntegrationDatasetsClient(unittest.TestCase): \\\"\\\"\\\" Run these\",\n \"'offset': 0 } datasets: List[DatasetType] = self.client.get_datasets(**params) self.assertIsNotNone(datasets) def test_create_and_delete_dataset(self) -> None: #\",\n \"\\\"\\\"\\\" Run these tests individually because Self-Host will return HTTP 429 Too Many\",\n \"cls.client: SelfHostClient = SelfHostClient( base_url='http://127.0.0.1:8080', username='test', password='<PASSWORD>' ) cls.unique_name: str = str(uuid.uuid4()) cls.created_dataset:\",\n \"name=cls.unique_name, dataset_format='ini', content='aGVsbG8sIHdvcmxkIQ==', tags=['test_tag'] ) @classmethod def tearDownClass(cls) -> None: cls.client.delete_dataset(cls.created_dataset['uuid']) def test_get_datasets(self)\",\n \"-> None: params: Dict[str, int] = { 'limit': 20, 'offset': 0 } datasets:\",\n \"happens in setup and teardown methods. self.assertEqual(self.created_dataset['name'], self.unique_name) def test_get_dataset(self) -> None: fetched_dataset:\",\n \"SelfHostClient, DatasetType class TestIntegrationDatasetsClient(unittest.TestCase): \\\"\\\"\\\" Run these tests individually because Self-Host will return\"\n]","isConversational":false}}}],"truncated":false,"partial":false},"paginationData":{"pageIndex":23,"numItemsPerPage":100,"numTotalItems":12866649,"offset":2300,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6Im1sR1pFYktIVHRVSGRhX1RRdEczQ0N1S3k5ME9Qd25DNHY5elRjM3FVYzgifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4MzQ0NTI3OSwianRpIjoiOTQ2NWI3NjMtZDc3Ny00ZDk3LWFjYTItM2M4NzNmNGY1ZDNiIiwic3ViIjoiL2RhdGFzZXRzL3RlcnJ5eXovc3RhcmNvZGVyZGF0YV9uZ3JhbV8xMyIsImV4cCI6MTc4MzQ0ODg3OSwiaXNzIjoiaHR0cHM6Ly9odWdnaW5nZmFjZS5jbyJ9.ixa5eqgBGRAHeFn09uQizjHCPeK31YrZMejaP2rDY5cXDFsM1MhvxJa0N52ePQoMq_eASkbwd7pkOEY9AbwQCg","displayUrls":true,"splitSizeSummaries":[{"config":"default","split":"train","numRows":12866649,"numBytesParquet":149232926747}]},"discussionsStats":{"closed":0,"open":0,"total":0},"fullWidth":true,"hasGatedAccess":true,"hasFullAccess":true,"isEmbedded":false,"savedQueries":{"community":[],"user":[]}}">
ngram listlengths 0 67.8k |
|---|
[
"= self.read_option('odo_uri', None) self.flatson = Flatson(schema) self.logger.info('ODOWriter has been initiated. Writing to: {}'.format(self.odo_uri))",
"items to a odo destination. https://odo.readthedocs.org/en/latest/ Needed parameters: - schema (object) schema object.",
"flattened_lines = (self.flatson.f... |
[
"that maketests is working. Call maketests via: >>> from x7.shell import *; maketests('x7.sample.needs_tests')",
"maketests is working. Call maketests via: >>> from x7.shell import *; maketests('x7.sample.needs_tests') \"\"\"",
"Simple file to validate that maketests is working. Call maketests via: >>> from",
... |
[
"the CHI function in a practically noiseless computer simulation (see \"chi_cpa.py\") takes around",
"MSB to LSB for i in range(len(IV0s)-1, -1, -1): # addressing \"MSB\" of",
"hash.update(IV) # needs to be copied again because of object orientation hash_copies[nz] =",
">>= 1 nz += 1 # initialize hash to the ... |
[
"ordered route list from start to finish with all node ids needed to",
"output += p[i-1] # Consider the next node i += 1 # We’ve",
"if len(p) == 2: return p # Compile an output path output =",
"the last item in the input while i < len(p)-1: # Do the",
"output list output += p[i-1] # Consider the next node i... |
[
"Event: def __init__(self): self.handlers = set() def subscribe(self, func): self.handlers.add(func) def unsubscribe(self, func):",
"class Event: def __init__(self): self.handlers = set() def subscribe(self, func): self.handlers.add(func) def unsubscribe(self,",
"subscribe(self, func): self.handlers.add(func) d... |
[
"an environment variable. supported types: None Integer String @param env_var_name: environment variable name",
"variable name @return: string of the type name. \"\"\" try: val = os.getenv(env_var_name)",
"ex: return \"None\" try: int_val = int(val) return 'Integer' except ValueError: return 'String'",
"def c... |
[
"fields = \"__all__\" class AlbumSerializer(serializers.ModelSerializer): sound = serializers.SerializerMethodField() class Meta: model = Album",
"fields = [\"name\" , \"song_image\" , \"pk\" , \"like\" , \"played\" , \"tag\"",
", \"sound\"] depth = 1 def get_sound(self , obj): print(\"WORKING\") return SoundSe... |
[
"near top'), ('tracker-head-bottom', 'Head - near bottom'), ('tracker-body-top', 'Body - near top'), ('tracker-body-bottom',",
"the Admin for where to put each tracker. It defaults to the obvious",
"of 3-ples in the settings file under ADDITIONAL_TRACKER_POSITIONS. (2-letter-code, description, block name), e.g.... |
[
"import APIRouter router = APIRouter() @router.get(\"\", tags=[\"health\"]) async def get_health(): return { \"results\":",
"fastapi import APIRouter router = APIRouter() @router.get(\"\", tags=[\"health\"]) async def get_health(): return {",
"= APIRouter() @router.get(\"\", tags=[\"health\"]) async def get_hea... |
[
"open('../data/' + 'inputsize.txt', 'r') as f: reqsize = int(f.readline().split('\\n')[0]) #print(reqsize) #image_filename = '../data/'",
"from PIL import Image import json import time import cv2 PATH_TO_FROZEN_GRAPH = '../data/mobilenet_v2_1.4_224/mobilenet_v2_1.4_224_frozen.pb'",
"if cat != 'classes': categor... |
[
"where user=\"{user}\" '''.format(user = user.user), as_dict=True) for setting in user_settings: data = frappe.parse_json(setting.get('data'))",
"+ timespan_map[f[3]] f[2] = 'Timespan' if update: data[key]['filters'] = filters update_user_settings(user_setting['doctype'], json.dumps(data), for_update=True)",
"u... |
[
"steps), let us know that the training # is still running if current_step%50000",
"10 training_size = 100000 # the amount of hidden units was set by",
"= 0.005 # the amount of steps was set by trial and error",
"dw): # Every now and then (every 50k steps), let us know that",
"n_max = 10 training_size = 1000... |
[
"name\", required=True) parser.add_argument('-s', '--service_account', help=(\"Path to gcloud service account, is for circleCI usage.",
"def add_private_packs_from_dummy_index(private_packs, dummy_index_blob): downloaded_dummy_index_path = 'current_dummy_index.zip' extracted_dummy_index_path = 'dummy_index' dummy... |
[] |
[
"**img_norm_cfg), dict(type='GaussianNoise', sigma_range=(0, 0.04), clamp_range=(0., 1.)), dict(type='RandomFlip', prob=0.5, direction='horizontal'), dict(type='RandomFlip', prob=0.5, direction='vertical'), dict(",
"= dict( translates=(0.05, 0.05), zoom=(1.0, 1.5), shear=(0.86, 1.16), rotate=(-10., 10.)) relative... |
[
"x def dim_op(op, *args): args = [wrap_dim(x) for x in args] raw_args =",
"# Represents a combo_op of MULTIPLY in a contraction def __mul__(self, rhs): return",
"value.encode('utf-8')) elif isinstance(value, ffi.CData) and ffi.typeof(value) is ffi.typeof('plaidml_value*'): ffi_obj = value else: raise",
"pass ... |
[
"(c) 2018 Intel Corporation Licensed under the Apache License, Version 2.0 (the \"License\");",
"import se_resnet50, se_resnet101, se_resnet152 from .backbones.resnet import resnet50 from .backbones.se_resnext import se_resnext50, se_resnext101,",
"dropout ratio of the model\"\"\" @abstractmethod def get_input_... |
[
"= msg % args # Exceptions must be formatted (they are not JSON-serializable",
"class JSONFormatter(logging.Formatter): \"\"\"Simple JSON formatter for the logging facility.\"\"\" def format(self, obj): \"\"\"Note",
"obj is a LogRecord instance.\"\"\" # Copy the dictionary ret = dict(obj.__dict__) #",
"% args... |
[
"# Orthogonal linear system solver tests from math import sqrt import numpy as",
"orthogonal matrix A = np.matrix('2 -2 1;' '1 2 2;' '2 1 -2',",
"= np.matrix('2 -2 1;' '1 2 2;' '2 1 -2', float) A =",
"3') # Solve the system x = orthogonal(A, b, 1) # Check if",
"##############################################... |
[
"files\"), (\"❌\", \"Failed to upload processed data files to the huggingface hub\"), )",
"\"\"\"Build a Project from the API response, JSON-encoded\"\"\" return cls( proj_id=json_resp[\"id\"], name=json_resp[\"proj_name\"], user=json_resp[\"username\"],",
"f\"{CYAN_TAG}{self.dataset_id}{RESET_TAG}\", \"\", ] +... |
[
"including the alert text. aps['alert'] = alert encoded = escape.utf8(json.dumps(escape.recursive_unicode(data), separators=(',', ':'), ensure_ascii=False))",
"import base64 import json import struct import time from tornado import escape _MAX_PAYLOAD_BYTES",
"representation rather than \"\\u1234\" escaping). T... |
[
"= dev.wires.tolist() ############################################################################## # Let us now define the quantum circuit that realizes",
"We will forgo one tiny step, but it can be shown that for",
"some imports: from pennylane import numpy as np import matplotlib as mpl np.random.seed(1359)... |
[
"#draw board gameboard.draw(screen,font) #update da screeeeeen pygame.display.update() #end the game if gameboard.is_solved() and",
"[] for i in range(0,self.size): new.append(self.content[(i+1)%self.size][y]) for i in range(0,self.size): self.content[i][y] = new[i]",
"##VARIABLES TO CHANGE width = 500 height =... |
[
"for i in range(1,11): if i == 6: continue; print(i); print(i); print(i); print(i);",
"# for문에서 continue 사용하기, continue = skip개념!!! for i in range(1,11): if i",
"사용하기, continue = skip개념!!! for i in range(1,11): if i == 6: continue;",
"skip개념!!! for i in range(1,11): if i == 6: continue; print(i); print(i); pr... |
[
"and the following disclaimer in the documentation # and/or other materials provided with",
"version string # External Name: ncs5k-goldenk9-x.iso-6.3.1.11I.0, Internal Name: ncs5k-goldenk9-x-6.3.1.11I if not match and",
"(c) 2016, Cisco Systems # All rights reserved. # # Redistribution and use",
"EXPRESS OR I... |
[
"an object Usage: >>> setElementByTag(FromUserName='the_wechat_server',ToUserName='the_wechat_client',Content='Hello dude!') # In this way we can then",
"'voice', 'video', 'location', 'link', 'event']: # Check if the incomingMessage has tag 'Recognition'",
"## Load the template #for i in tpl_list: # if MsgType ... |
[] |
[
"colors['darkred'] = latex2htmlcolor('0.8,0,0') colors['middlered'] = latex2htmlcolor('0.9,0,0') colors['lightred'] = latex2htmlcolor('1,0,0') colors['darkgreen'] = latex2htmlcolor('0,0.6,0') colors['middlegreen']",
"return arg.strip() else: try: red = green = blue = float(arg) except ValueError:",
"- m * (1 - ... |
[
"Transparente\\033[m\") print(\" - - - Testando os 30 - - -\") print(\"\\033[0;37;40mTeste\\033[m\") print(\"\\033[0;31;40mTeste\\033[m\")",
"print(\"\\033[0;30;42mVerde\\033[m\") print(\"\\033[0;30;43mAmarelo\\033[m\") print(\"\\033[0;30;44mRoxo\\033[m\") print(\"\\033[0;30;45mLilás\\033[m\") print(\"\\033[0;30;... |
[
"Relational Mappers (SQLAlchemy) The latest development version is available in the `TurboGears Git",
"= \"\"\"Copyright 2005-2020 <NAME>, <NAME>, <NAME>, <NAME>, <NAME> and contributors\"\"\" license = \"MIT\"",
".. _TurboGears Git repositories: https://github.com/TurboGears \"\"\" url=\"http://www.turbogears.... |
[
"done.') ## STORING dic = dict() all_var2export = ['em'] for v in all_var2export:",
"mean em = e.mean(axis=0) print('e mean done.') ## STORING dic = dict() all_var2export",
"em = e.mean(axis=0) print('e mean done.') ## STORING dic = dict() all_var2export =",
"pass ## U,V,H mean em = e.mean(axis=0) print('e me... |
[
"the boggle grid. None if given invalid grid. \"\"\" if self.trie is None:",
"a boggle grid, from top left to bottom right. \"\"\" for y in",
"import trie if sys.version < '3': range = xrange class BoggleSolver(object): \"\"\" This",
"' + words_file) print('creating dictionary...') root = trie.Trie() word_cou... |
[
"pytest from ocs_ci.framework.testlib import ( managed_service_required, skipif_ms_consumer, tier4, tier4a, ) from ocs_ci.ocs import",
"scaled down incidents = measure_corrupt_pg.get(\"pagerduty_incidents\") target_label = constants.ALERT_CLUSTERERRORSTATE # TODO(fbalak): check the whole",
"constants.ALERT_CLUS... |
[
"open(modelfile, \"w\") as file: file.write(\"\"\" data { int N; // the number of",
"data.info() feature_names = data.columns.str.startswith(\"var_\") predictors = data[data.columns[feature_names]] labels = data[\"Target_Practice\"] ix_training = data.train",
"ix_training.sum().tolist(), 'N2': ix_testing.sum().... |
[
"an 'error' event if the load fails. Automatically runs as a daemon \"\"\"",
"the queue to report the results into \"\"\" threading.Thread.__init__(self) self.queue = queue self.filename",
"from tsv is completed {} entries\".format(len(res))) else: error(\"Async remote mats loader failed -",
"res: with open(s... |
[
"return item class LuoxiaImagePipeline(ImagesPipeline): def get_media_requests(self, item, info): for url in item['image_urls']: yield",
"# Define your item pipelines here # # Don't forget to add your",
"to add your pipeline to the ITEM_PIPELINES setting # See: https://doc.scrapy.org/en/latest/topics/item-pipel... |
[
"tf.estimator.inputs.numpy_input_fn( x={'x': train_data}, y=train_labels, batch_size=100, num_epochs=None, shuffle=True ) # Evaluate the model and",
"with 1024 neurons # Input Tensor Shape: [batch_size, 7 * 7 * 64]",
"strides=2) # Flatten tensor into a batch of vectors # Input Tensor Shape:",
"# Flatten tenso... |
[
"in self._pub_pose_map: topic_ns = \"/autoware_debug_tools/stop_reason2pose/\" self._pub_pose_map[snake_case_stop_reason] = self.create_publisher( PoseStamped, topic_ns + snake_case_stop_reason, 1",
"KIND, either express or implied. # See the License for the specific language",
"if nearest_pose_id: self._update... |
[
"default, leaving asyncio clean. .. note:: In the most common cases you don't",
"new event loop everytime. After completion, the loop is closed and then recreated,",
"async def async_add(x, y, delay=0.1): await asyncio.sleep(delay) return x + y async def",
"y async def async_one(): await async_nested_exc() as... |
[
"gotoy = gotoy - 28 for counter in range(6): star(9,5,'white') t.setheading(0) t.forward(84) t.penup()",
"t.setheading(-90) rectangle(40,988,'#B22234') t.setheading(-90) t.forward(80) t.penup() t.setheading(0) t.goto(-494,260) t.pendown() rectangle(494,280,'#3C3B6E') t.goto(-474,245) for counter in",
"bigangle ... |
[
"10, -18, 20, 25] s3 = [2, 3, -5, 10, 10, -5, -5,",
"remove consecutive nodes that sums up to zero # https://www.careercup.com/question?id=5717797377146880 from util import",
"= [2, 3, -5, 10, 10, -5, -5, 20, 5, -5] samples =",
"not new: new = Node(start.value) root = new elif not zero and new:",
"total += ... |
[
"( MapsAccountCreateParameters, Sku) ACCOUNT_LOCATION = 'global' logger = get_logger(__name__) def create_account(client, resource_group_name, account_name,",
"= prompt_y_n(hint) if not option: raise CLIError(client_denied_terms) # Submit query sku = Sku(name=sku_name)",
"to the user logger.warning(terms) # Pro... |
[
"Timer from recommenders.utils.constants import SEED from recommenders.models.deeprec.deeprec_utils import ( prepare_hparams ) from recommenders.datasets.amazon_reviews",
"\"model_20220118_20k_0.8923\", 'step_20000')) with Timer() as train_time: model = model.fit(train_file, valid_file, valid_num_ngs=9, eval_metr... |
[
"ctypesgen, CtypesType and its subclasses are completely independent of the parser module. The",
"py_string(self, ignore_can_be_ctype=None): return \"%s_%s\" % (self.variety, self.tag) last_tagnum = 0 def anonymous_enum_tag(): global",
"versions of ctypesgen, CtypesType and its subclasses are completely indepen... |
[
"def r(self, r): self._r = r @property def col(self): return self._col @col.setter def",
"def y(self): return self._y def respawn(self): self._x = randint(self._r, Screen.width - self._r) self._y",
"f\"Score: {self.score}\", (Screen.bg - 2) % 16) class Circle: def __init__(self): self._r =",
"self.respawn() @... |
[
"DB(Constants.DB_BACKUP) db_backup.update_or_insert_value( self.mark_of_local_verification, b'1') self.messenger.code_type = Constants.BACKUP_SCHEDULED self.messenger.set_message = 'backup scheduled' except Exception",
"Utils() self.messenger = Messenger() self.mark_of_local_verification = b'varidb_execute_file_v... |
[
"scanning of unaltered VM using every profile according to input. Also perform remediation",
"logging.error(\"Nothing has been tested!\") snapshot_stack.delete() # depending on number of profiles we have",
"domain_ip = ssg_test_suite.virt.determine_ip(dom) has_worked = False profiles = get_viable_profiles(optio... |
[
"each option. If a one-argument callable, this callable will be passed model instance",
"= valuelist[0] def pre_validate(self, form): if not self.allow_blank or self.data is not None:",
"process_formdata(self, valuelist): if valuelist: try: lat, lon = valuelist[0].split(',') self.data = u'%s,%s' %",
"select. ... |
[
"If collect_data is on, the players are selected randomly each game from: [\"Random\",",
"when collect_data is off\") modes = players #Simulates num_games of games scores =",
"run the game with the default params if unchanged. If collect_data is on,",
".xlsx file if collect_data: filename = \"PlayData/data\" ... |
[
"in this module.\"\"\" pass class DecodeError(DottedMarkupLanguageException): \"\"\"Raised when there is an error decoding",
"for all exceptions in this module.\"\"\" pass class DecodeError(DottedMarkupLanguageException): \"\"\"Raised when there is",
"class DottedMarkupLanguageException(Exception): \"\"\"Base c... |
[
"def load_voc_instances(dirname: str, split: str): \"\"\" Load licenseplates VOC detection annotations to Detectron2",
"np.loadtxt(f, dtype=np.str) dicts = [] for fileid in fileids: anno_file = os.path.join(dirname, \"annotations\",",
"Visualizer(img[:, :, ::-1], metadata=MetadataCatalog.get(dataset_name), scal... |
[
"open(f, \"rb\") as fin: result = fin.read() end = time.time() print(\"%.1f images/s\" %",
"as fin: result = fin.read() end = time.time() print(\"%.1f images/s\" % (10000 /",
"import glob import time import random filelist = glob.glob('/mnt/lustre/chenyuntao1/datasets/imagenet/train/*/*') random.shuffle(filelis... |
[
"inp_dict.get_value('function', required_type='any') description = 'boundary condititon for %s' % var_name self.velocity = verify_field_variable_definition(",
"( CodedExpression, OcellarisCppExpression, OcellarisError, verify_field_variable_definition, ) class OcellarisDirichletBC(dolfin.DirichletBC): def __init_... |
[
"import count_inversions class TestCountSplitInversions(unittest.TestCase): def test_count_inversions(self): input = [1, 3, 5, 2, 4,",
"test_count_inversions(self): input = [1, 3, 5, 2, 4, 6] result = count_inversions(input) self.assertEqual(result,",
"import unittest from count_split_inversions import count_in... |
[
"# # Licensed under the Apache License, Version 2.0 (the \"License\"); # you",
"# Copyright 2016 The BigDL Authors. # # Licensed under the Apache License,",
"writing, software # distributed under the License is distributed on an \"AS IS\"",
"400 input_feature_num = 10 output_feature_num = 2 past_seq_len = 10 ... |
[
"event = conn.krpc.add_event(expr) with event.condition: event.wait() print('Booster separation') vessel.control.activate_next_stage() mean_altitude = conn.get_call(getattr, vessel.flight(),",
"krpc conn = krpc.connect(name='Sub-orbital flight') vessel = conn.space_center.active_vessel vessel.auto_pilot.target_pi... |
[
"def get_columns(a): return list(a.T) def main(): np.random.seed(0) a=np.random.randint(0,10, (4,4)) print(\"a:\", a) print(\"Rows:\", get_rows(a))",
"<gh_stars>0 #!/usr/bin/env python3 import numpy as np def get_rows(a): return list(a) def get_columns(a):",
"as np def get_rows(a): return list(a) def get_column... |
[
"private_leaderboard = _compute_leaderboard(session, submissions, 'private', event_name, with_links=False) time_list = (['train time [s]', 'validation",
"contributivity'] if (df[contrib_columns] == 0).all(axis=0).all(): df = df.drop(columns=contrib_columns) df = df.sort_values( \"bag {}",
"best_df[['public ' + ... |
[
"for 1/10th of a second if indent_Increasing: indent = indent + 1 if",
"Python import time, sys indent = 0 # How many spaces to indent",
"while True: # The main program loop print(' ' * indent, end='') print('********')",
"20: indent_Increasing = False else: indent = indent - 1 if indent ==",
"indentation i... |
[
"'\\Compensation: %s' % compensation['original_filename'] print 'Samples:' if sample: print '\\t%s' % sample['original_filename'] else:",
"{'site_pk': site['id']} if subject: sample_kwargs['subject_pk'] = subject['id'] sample_list = get_samples(*sample_args, **sample_kwargs) if not",
"compensation_choice = raw_... |
[
"static from . import views from . import jobs urlpatterns = [ url(r'^choose_company/(?P<company_id>.*)/$',",
"[ url(r'^choose_company/(?P<company_id>.*)/$', views.choose_company, name='choose_company'), url(r'^cleanlogs/$', jobs.cleanlogs, name='cleanlogs'), url(r'^primecache/$', jobs.primecache, name='primecach... |
[
"\"Intended Audience :: End Users/Desktop\", \"License :: OSI Approved :: MIT License\", \"Operating",
"long_description=long_description, long_description_content_type=\"text/markdown\", version=\"1.1.0\", url='https://github.com/einzigartigername/i3-workspace-swap', license='MIT', author='<NAME>', author_email=... |
[
"specify the generated XML files # generated_xml = [_msg_serializable_xml_name(f) for f in sorted(msg_types)]",
"RIGHTS RESERVED. United States Government Sponsorship # acknowledged. Any commercial use must be",
"States Government Sponsorship # acknowledged. Any commercial use must be negotiated with the",
"#... |
[
"with pytest.raises(NotebookDifference): compare_notebooks(ref, test, 'py:light', allow_expected_differences=False) def test_dont_raise_on_different_outputs(): ref = new_notebook(cells=[new_code_cell('1+1')]) test =",
"def test_raise_on_different_cell_metadata(): ref = new_notebook(cells=[new_code_cell('1+1')]) t... |
[
"str = None): \"\"\"sp00ktober by camiel.\"\"\" if datetime.date.today().month == 10: # make it",
"*{}*\\'s snoot - it feels satisfying.', 'you happily boop *{}*, it\\'s lovely!', 'you",
"no one there.', 'you look around the channel for someone to boop.', 'you",
"'you boop *{}*.', '*{}* feels annoyed from you... |
[
"else full_config['gamma'] elif full_config['exp_name'] == \"IMP\": full_config['gamma'] = 0.9 if full_config['gamma'] is None",
"# \"exp_name\": \"AsymCoinGame\", \"pseudo\": False, \"grid_size\": 3, \"lola_update\": True, \"opp_model\": False, \"mem_efficient\": True,",
"== \"CoinGame\" or full_config['exp_na... |
[
"json_data_func(instance): ''' Return json format data, ready for passing into AmCharts. Contains 2",
"into AmCharts. Contains 2 items - name of the month and count of",
"add results above result = [] for month in range(1, len(month_name)): count_use =",
"import string import random import json from calendar ... |
[
"None: print \"The XML file \", user_info_config, \" seems to be invalid, using",
"print exit(1) else: exit(0) else: exit(0) exit(0) def admin_user_info( config_parser ): user_info_config =",
"'hgweb_config_dir' ) hgweb_config_file = os.path.join( hgweb_dir, 'hgweb.config' ) if not os.path.exists( hgweb_config_... |
[
"get_shard_iterator(self): arn = self._get_param(\"StreamArn\") shard_id = self._get_param(\"ShardId\") shard_iterator_type = self._get_param(\"ShardIteratorType\") sequence_number = self._get_param(\"SequenceNumber\")",
"from .models import dynamodbstreams_backends from six import string_types class DynamoDBStre... |
[
"ZerosFrontExtractor(FrontExtractorOp): op = '_zeros' enabled = True @classmethod def extract(cls, node): attrs =",
"SPDX-License-Identifier: Apache-2.0 import numpy as np from openvino.tools.mo.front.extractor import FrontExtractorOp from openvino.tools.mo.front.mxnet.extractors.utils import",
"openvino.tools.... |
[
"= j.do.pullGitRepo(url) # res = j.sal.process.executeWithoutPipe(\"cd %s;%s install\" % (cdest, self.npm)) # #",
"= \"https://github.com/Famous/engine-seed\" # cdest = j.do.pullGitRepo(url) # res = j.sal.process.executeWithoutPipe(\"cd %s;%s install\" %",
"# @property # def npm(self): # if self._npm == False: ... |
[
"RF state PC.update(new_PC) # Update PC cycle += 1 MEM.dump() # Print memory",
"instruction IM.imgx.append(cycle) IM.imgy.append(PC.PC) halted, new_PC, new_regs = EE.execute(Instruction, RF.asdct(), IM, cycle) # Update",
"plot warnings.filterwarnings(\"ignore\") MEM = IMACC(sys.stdin.read()) # Load memory from ... |
[
"= self._get_id_match(argument) or re.match(r\"<(?:@(?:!|&)?|#)([0-9]{15,20})>$\", argument) if match is None: raise discord.errors.ObjectNotFound(argument) result =",
"user is None: tag = re.match(r\"#?(\\d{4})\", argument) if tag: if ctx.guild: test =",
"sorted(filter(lambda x: x.isdigit(), argument)) argumen... |
[
"except ValueError: structure_klifs_ids = np.genfromtxt(fname=args_input[0], dtype=int).tolist() else: structure_klifs_ids = [int(i) for i in",
"\"\"\" import numpy as np from kissim.api import encode from kissim.cli.utils import configure_logger",
"structures. Parameters ---------- args : argsparse.Namespace C... |
[
"tsB[i : i + m])) if selfJoin: trivialMatchRange = (max(0, idxToProcess - m",
"(distanceProfile, np.full(n - m + 1, idx, dtype = float)) if __name__ ==",
"1, 0, 0, -1, 1])), 3) array([[ 2. , 2.828, 2. ], [",
"tsB is None: selfJoin = True tsB = tsA query = tsA[idx :",
"= False if tsB is None: selfJoin = True... |
[] |
[
"self.app.setStyleSheet(self.sheets[1]) self.sheets = [self.sheets[1], self.sheets[0]] ######################################################################## class AboutWidget(QDialog): \"\"\"显示关于信息\"\"\" # ---------------------------------------------------------------------- def __init__(self,",
"as wgs #from... |
[
"line_bot_api.reply_message(event.reply_token,TextSendMessage(text=notice)) elif 'del' == mage[0]: notice = del_item(mage[1],user_id) line_bot_api.reply_message(event.reply_token,TextSendMessage(text=notice)) elif 'list' == mage[0]:",
"WHERE user_id LIKE '%s'\"%(user_id)) sub_item = cursor.fetchall() price_list =... |
[
"FixedMarginBusiness(country, 'BUS', profit_margin=.025) Market(country, 'GOOD') Market(country, 'LAB') TaxFlow(country, 'TAX', taxrate=.2) # At time",
"= mod.GetTimeSeries('k') Rat = mod.GetTimeSeries('DEBT_GDP') Def = mod.GetTimeSeries('GOV__INC') spend = mod.GetTimeSeries('GOV__DEM_GOOD') p =",
"Quick2DPlot ... |
[
"user_settings: self._user_settings = user_settings self.defaults = defaults or DEFAULTS self._cached_attrs = set() @property",
"hasattr(self, '_user_settings'): delattr(self, '_user_settings') app_settings = AuthSettings(None, DEFAULTS) def reload_app_settings(*args, **kwargs): setting =",
"'SIGNUP_SERIALIZER'... |
[
"django.db import models from shorty.manager import UrlManager class Url(models.Model): long_url = models.URLField() short_id",
"models.URLField() short_id = models.SlugField() counter = models.IntegerField(default=0) def __str__(self): return \"%s -- %s\"",
"import UrlManager class Url(models.Model): long_url ... |
[
"(Edit for \"area\" only) User is allowed to edit category (Edit for \"category\"",
"contact (View for \"contact\" only) User is allowed to access customer (View for",
"only) (Retire for \"room\" only) User is allowed Edit on (Edit for \"daily_record\":",
"View on it_project if it_project is non-confidential ... |
[
"r = map(int, input().split()) if x >= s: best = max(best, r) print(best)",
"map(int, input().split()) for i in range(n): s, r = map(int, input().split()) if x",
"s, r = map(int, input().split()) if x >= s: best = max(best, r)",
"while tc: tc -= 1 best = 0 n, x = map(int, input().split())",
"tc -= 1 best = ... |
[
"'Johnson') def test_insert_helper(self): w = self.wrp w.query_mode = 'dict' res = w.insert('users', first_name='Dave',",
"w.list_tables() self.assertIn('users', tables) self.assertIn('items', tables) w.drop_schemas() tables = w.list_tables() self.assertNotIn('users', tables) self.assertNotIn('items', tables)",
... |
[
"depends_on('mpi', when='+mpi') depends_on('blas') depends_on('lapack') depends_on('scalapack', when='+mpi') depends_on('metis') depends_on('parmetis', when='+parmetis') depends_on('scotch~metis', when='+scotch') depends_on('scotch~metis+mpi', when='+scotch+mpi')",
"dense rank-structured matrices, i.e., matrices ... |
[
"from rasa_sdk.forms import FormAction from rasa_sdk.events import UserUtteranceReverted, UserUttered, FollowupAction # from rasa_core.events",
"Frendy Shopping\" }); return [UserUttered(text=\"/greet\", parse_data={ \"intent\": {\"confidence\": 1.0, \"name\": \"greet\"}, \"entities\": []",
"1.0, \"name\": \"gr... |
[
"for sensor in [\"p1\", \"p2\", \"p3\"]: series = dataframe[sensor] scatter = go.Scatter(x =",
"series, name = f\"Sensor {sensor}\", opacity = 0.4) pressure_plots.append(scatter) pressure_figure = go.Figure( data",
"timeseries ''' def generate_timeseries_plot(self, dataframe): pressure_plots = [] for sensor in ... |
[
"Changes may cause incorrect behavior and will be lost if the code is",
"resource Id. :type key_vault_id: str :param key_vault_secret_name: Key Vault secret name. :type key_vault_secret_name:",
"\"\"\"Key Vault container ARM resource for a certificate that is purchased through Azure.",
"Key Vault secret. Poss... |
[
"\"\"\" :param TypeInputUser user_id: :param str title: :param str short_name: :param List[TypeInputStickerSetItem] stickers:",
"bytes(self.sticker), struct.pack('<i', self.position), )) @classmethod def from_reader(cls, reader): _sticker = reader.tgread_object() _position =",
"= masks # type: Optional[bool] as... |
[
"files for Paraview\", \"Parameters\" : { \"model_part_name\" : \"FluidModelPart.Parts_patch_surface\", \"output_control_type\" : \"step\", \"output_frequency\"",
"3, \"output_sub_model_parts\" : false, \"write_deformed_configuration\" : true, \"folder_name\" : \"test_vtk_output\", \"save_output_files_in_folder\"... |
[
"getlist(self) -> list[dict[str, str]]: ENTRY = r\"{http://www.w3.org/2005/Atom}\" MEDIA = r\"{http://search.yahoo.com/mrss/}\" YOUTUBE = r\"{http://www.youtube.com/xml/schemas/2015}\"",
"xml.etree.ElementTree class RSS10Parser: def __init__(self, url: str) -> None: self.url = url def",
"YOUTUBE = r\"{http://ww... |
[
"= 9559 simulation = False with pepper_interface.get(IP,PORT,simulation) as pepper: time.sleep(1.0) values,time_stamp = pepper.laser.get()",
"import pepper_interface IP = \"192.168.0.147\" PORT = 9559 simulation = False with pepper_interface.get(IP,PORT,simulation)",
"print values[\"Front\"] print print \"Left\... |
[
"doc = ____(\"I like tree kangaroos and narwhals.\") # Selecionar o primeiro token",
"kangaroos and narwhals.\") # Selecionar o primeiro token first_token = doc[____] # Imprimir",
"objeto nlp from ____ import ____ nlp = ____ # Processar o texto",
"criar um objeto nlp from ____ import ____ nlp = ____ # Process... |
[
"Questionnaire' } resp = self.client.post('/questionnaire/' + eq_id + '/' + form_type_id + '/789/introduction',",
"form_type_id + '/789/introduction', data=post_data, follow_redirects=False) self.assertEqual(resp.status_code, 302) block_one_url = resp.location resp = self.client.get(block_one_url,",
"from tests... |
[
"= _compute_mask_indices( (batch_size, sequence_length), mask_prob=self.config.mask_time_prob, mask_length=self.config.mask_time_length, min_masks=2, ) hidden_states = tf.where( tf.cast(mask_time_indices[:, :,",
"length of the convolutional layers \"\"\" def _conv_out_length(input_length, kernel_size, stride): # ... |
[
"random.choice(wordlist) # end of helper code # ----------------------------------- # load the list of",
"valid words. Words are strings of lowercase letters. Depending on the size of",
"anywhere in the program wordlist = load_words() def partial_word(secret_word, guessed_letters): \"\"\" Return the",
"' + st... |
[
"auto_sdk on 2016.04.13 ''' from top.api.base import RestApi class FenxiaoRefundMessageAddRequest(RestApi): def __init__(self,domain='gw.api.taobao.com',port=80): RestApi.__init__(self,domain,",
"= None self.sub_order_id = None def getapiname(self): return 'taobao.fenxiao.refund.message.add' def getMultipartParas... |
[
"# # Licensed under the Apache License, Version 2.0 (the \"License\"); # you",
"writing, software # distributed under the License is distributed on an \"AS IS\"",
"help=\"Max iterations.\") parser.add_argument(\"--save-interval\", type=int, default=50000, help=\"Interval for saving models.\") parser.add_argumen... |
[
"print(\"-\" * 60) f.seek(0) my_content = f.readlines() print(\"\\nUse readlines method\") print(\"-\" * 60)",
"f = open(\"my_file.txt\") print(\"\\nLoop directly over file\") print(\"-\" * 60) for line in",
"f.seek(0) my_content = f.read() print(\"\\nUse read + splitlines\") print(\"-\" * 60) for line",
"for... |
[
"= str(uuid.uuid4()) cls.created_dataset: DatasetType = cls.client.create_dataset( name=cls.unique_name, dataset_format='ini', content='aGVsbG8sIHdvcmxkIQ==', tags=['test_tag'] ) @classmethod def",
"None: self.client.update_dataset( dataset_uuid=self.created_dataset['uuid'], name=f'{self.created_dataset[\"name\"]... |