



import unittest

import numpy as np

from transformers import RobertaConfig, is_flax_available
from transformers.testing_utils import require_flax, slow

from ...test_modeling_flax_common import FlaxModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask


if is_flax_available():
	from transformers.models.roberta.modeling_flax_roberta import (
	    FlaxRobertaForCausalLM,
	    FlaxRobertaForMaskedLM,
	    FlaxRobertaForMultipleChoice,
	    FlaxRobertaForQuestionAnswering,
	    FlaxRobertaForSequenceClassification,
	    FlaxRobertaForTokenClassification,
	    FlaxRobertaModel,
	)

class  __snake_case      (   unittest.TestCase):







							'''simple docstring'''






							def __init__(							self  ,  a_  ,  a_=13  ,  a_=7  ,  a_=True  ,  a_=True  ,  a_=True  ,  a_=True  ,  a_=99  ,  a_=32  ,  a_=5  ,  a_=4  ,  a_=37  ,  a_="gelu"  ,  a_=0.1  ,  a_=0.1  ,  a_=512  ,  a_=16  ,  a_=2  ,  a_=0.02  ,  a_=4  ,  ):
											a__				      =		parent
											a__				      =		batch_size
											a__				      =		seq_length
											a__				      =		is_training
											a__				      =		use_attention_mask
											a__				      =		use_token_type_ids
											a__				      =		use_labels
											a__				      =		vocab_size
											a__				      =		hidden_size
											a__				      =		num_hidden_layers
											a__				      =		num_attention_heads
											a__				      =		intermediate_size
											a__				      =		hidden_act
											a__				      =		hidden_dropout_prob
											a__				      =		attention_probs_dropout_prob
											a__				      =		max_position_embeddings
											a__				      =		type_vocab_size
											a__				      =		type_sequence_label_size
											a__				      =		initializer_range
											a__				      =		num_choices


							def _a      (							self		):
											a__				      =		ids_tensor([self.batch_size, self.seq_length]  ,  self.vocab_size		)

											a__				      =		None
											if self.use_attention_mask:
															a__				      =		random_attention_mask([self.batch_size, self.seq_length]		)

											a__				      =		None
											if self.use_token_type_ids:
															a__				      =		ids_tensor([self.batch_size, self.seq_length]  ,  self.type_vocab_size		)

											a__				      =		RobertaConfig(
											    vocab_size=self.vocab_size  ,  hidden_size=self.hidden_size  ,  num_hidden_layers=self.num_hidden_layers  ,  num_attention_heads=self.num_attention_heads  ,  intermediate_size=self.intermediate_size  ,  hidden_act=self.hidden_act  ,  hidden_dropout_prob=self.hidden_dropout_prob  ,  attention_probs_dropout_prob=self.attention_probs_dropout_prob  ,  max_position_embeddings=self.max_position_embeddings  ,  type_vocab_size=self.type_vocab_size  ,  is_decoder=a_  ,  initializer_range=self.initializer_range  ,  )

											return config, input_ids, token_type_ids, attention_mask


							def _a      (							self		):
											a__				      =		self.prepare_config_and_inputs()
											a__      ,			a__      ,			a__      ,			a__				      =		config_and_inputs
											a__				      =		{"""input_ids""": input_ids, """token_type_ids""": token_type_ids, """attention_mask""": attention_mask}
											return config, inputs_dict







							def _a      (							self		):
											a__				      =		self.prepare_config_and_inputs()
											a__      ,			a__      ,			a__      ,			a__				      =		config_and_inputs

											a__				      =		True
											a__				      =		floats_tensor([self.batch_size, self.seq_length, self.hidden_size]		)
											a__				      =		ids_tensor([self.batch_size, self.seq_length]  ,  vocab_size=2		)

											return (
											    config,
											    input_ids,
											    token_type_ids,
											    encoder_hidden_states,
											    encoder_attention_mask,
											)




@require_flax
class  __snake_case      (   SCREAMING_SNAKE_CASE			,unittest.TestCase):







							'''simple docstring'''






							UpperCamelCase__				:      str         =					True

							UpperCamelCase__				:      int         =					(
							    (
							        FlaxRobertaModel,
							        FlaxRobertaForCausalLM,
							        FlaxRobertaForMaskedLM,
							        FlaxRobertaForSequenceClassification,
							        FlaxRobertaForTokenClassification,
							        FlaxRobertaForMultipleChoice,
							        FlaxRobertaForQuestionAnswering,
							    )
							    if is_flax_available()
							    else ()
							)


							def _a      (							self		):
											a__				      =		FlaxRobertaModelTester(self		)







							@slow
							def _a      (							self		):
											for model_class_name in self.all_model_classes:
															a__				      =		model_class_name.from_pretrained("""roberta-base"""  ,  from_pt=a_		)
															a__				      =		model(np.ones((1, 1)		)		)
															self.assertIsNotNone(a_		)






import math

import torch
from torch import nn

from ..configuration_utils import ConfigMixin, register_to_config
from .attention_processor import Attention
from .embeddings import get_timestep_embedding
from .modeling_utils import ModelMixin

class  __snake_case      (   SCREAMING_SNAKE_CASE			,SCREAMING_SNAKE_CASE):







							'''simple docstring'''






							@register_to_config
							def __init__(							self  ,  a_ = 128  ,  a_ = 256  ,  a_ = 2_000.0  ,  a_ = 768  ,  a_ = 12  ,  a_ = 12  ,  a_ = 64  ,  a_ = 2_048  ,  a_ = 0.1  ,  ):
											super().__init__()

											a__				      =		nn.Sequential(
											    nn.Linear(a_  ,  d_model * 4  ,  bias=a_		)  ,  nn.SiLU()  ,  nn.Linear(d_model * 4  ,  d_model * 4  ,  bias=a_		)  ,  nn.SiLU()  ,  )

											a__				      =		nn.Embedding(a_  ,  a_		)
											a__				      =		False

											a__				      =		nn.Linear(a_  ,  a_  ,  bias=a_		)

											a__				      =		nn.Dropout(p=a_		)

											a__				      =		nn.ModuleList()
											for lyr_num in range(a_		):
															# FiLM conditional T5 decoder
															a__				      =		DecoderLayer(d_model=a_  ,  d_kv=a_  ,  num_heads=a_  ,  d_ff=a_  ,  dropout_rate=a_		)
															self.decoders.append(a_		)

											a__				      =		TaLayerNorm(a_		)

											a__				      =		nn.Dropout(p=a_		)
											a__				      =		nn.Linear(a_  ,  a_  ,  bias=a_		)


							def _a      (							self  ,  a_  ,  a_		):
											a__				      =		torch.mul(query_input.unsqueeze(-1		)  ,  key_input.unsqueeze(-2		)		)
											return mask.unsqueeze(-3		)







							def _a      (							self  ,  a_  ,  a_  ,  a_		):
											a__      ,			a__      ,			a__				      =		decoder_input_tokens.shape
											assert decoder_noise_time.shape == (batch,)

											# decoder_noise_time is in [0, 1), so rescale to expected timing range.
											a__				      =		get_timestep_embedding(
											    decoder_noise_time * self.config.max_decoder_noise_time  ,  embedding_dim=self.config.d_model  ,  max_period=self.config.max_decoder_noise_time  ,  ).to(dtype=self.dtype		)

											a__				      =		self.conditioning_emb(a_		).unsqueeze(1		)

											assert conditioning_emb.shape == (batch, 1, self.config.d_model * 4)

											a__				      =		decoder_input_tokens.shape[1]

											# If we want to use relative positions for audio context, we can just offset
											# this sequence by the length of encodings_and_masks.
											a__				      =		torch.broadcast_to(
											    torch.arange(a_  ,  device=decoder_input_tokens.device		)  ,  (batch, seq_length)  ,  )

											a__				      =		self.position_encoding(a_		)

											a__				      =		self.continuous_inputs_projection(a_		)
											inputs += position_encodings
											a__				      =		self.dropout(a_		)

											# decoder: No padding present.
											a__				      =		torch.ones(
											    decoder_input_tokens.shape[:2]  ,  device=decoder_input_tokens.device  ,  dtype=inputs.dtype		)

											# Translate encoding masks to encoder-decoder masks.
											a__				      =		[(x, self.encoder_decoder_mask(a_  ,  a_		)) for x, y in encodings_and_masks]

											# cross attend style: concat encodings
											a__				      =		torch.cat([x[0] for x in encodings_and_encdec_masks]  ,  dim=1		)
											a__				      =		torch.cat([x[1] for x in encodings_and_encdec_masks]  ,  dim=-1		)

											for lyr in self.decoders:
															a__				      =		lyr(
															    a_  ,  conditioning_emb=a_  ,  encoder_hidden_states=a_  ,  encoder_attention_mask=a_  ,  )[0]

											a__				      =		self.decoder_norm(a_		)
											a__				      =		self.post_dropout(a_		)

											a__				      =		self.spec_out(a_		)
											return spec_out




class  __snake_case      (   nn.Module):







							'''simple docstring'''






							def __init__(							self  ,  a_  ,  a_  ,  a_  ,  a_  ,  a_  ,  a_=1E-6		):
											super().__init__()
											a__				      =		nn.ModuleList()

											# cond self attention: layer 0
											self.layer.append(
											    TaLayerSelfAttentionCond(d_model=a_  ,  d_kv=a_  ,  num_heads=a_  ,  dropout_rate=a_		)		)

											# cross attention: layer 1
											self.layer.append(
											    TaLayerCrossAttention(
											        d_model=a_  ,  d_kv=a_  ,  num_heads=a_  ,  dropout_rate=a_  ,  layer_norm_epsilon=a_  ,  )		)

											# Film Cond MLP + dropout: last layer
											self.layer.append(
											    TaLayerFFCond(d_model=a_  ,  d_ff=a_  ,  dropout_rate=a_  ,  layer_norm_epsilon=a_		)		)







							def _a      (							self  ,  a_  ,  a_=None  ,  a_=None  ,  a_=None  ,  a_=None  ,  a_=None  ,  ):
											a__				      =		self.layer[0](
											    a_  ,  conditioning_emb=a_  ,  attention_mask=a_  ,  )

											if encoder_hidden_states is not None:
															a__				      =		torch.where(encoder_attention_mask > 0  ,  0  ,  -1E1_0		).to(
															    encoder_hidden_states.dtype		)

															a__				      =		self.layer[1](
															    a_  ,  key_value_states=a_  ,  attention_mask=a_  ,  )

											# Apply Film Conditional Feed Forward layer
											a__				      =		self.layer[-1](a_  ,  a_		)

											return (hidden_states,)




class  __snake_case      (   nn.Module):







							'''simple docstring'''






							def __init__(							self  ,  a_  ,  a_  ,  a_  ,  a_		):
											super().__init__()
											a__				      =		TaLayerNorm(a_		)
											a__				      =		TaFiLMLayer(in_features=d_model * 4  ,  out_features=a_		)
											a__				      =		Attention(query_dim=a_  ,  heads=a_  ,  dim_head=a_  ,  out_bias=a_  ,  scale_qk=a_		)
											a__				      =		nn.Dropout(a_		)







							def _a      (							self  ,  a_  ,  a_=None  ,  a_=None  ,  ):
											# pre_self_attention_layer_norm
											a__				      =		self.layer_norm(a_		)

											if conditioning_emb is not None:
															a__				      =		self.FiLMLayer(a_  ,  a_		)

											# Self-attention block
											a__				      =		self.attention(a_		)

											a__				      =		hidden_states + self.dropout(a_		)

											return hidden_states




class  __snake_case      (   nn.Module):







							'''simple docstring'''






							def __init__(							self  ,  a_  ,  a_  ,  a_  ,  a_  ,  a_		):
											super().__init__()
											a__				      =		Attention(query_dim=a_  ,  heads=a_  ,  dim_head=a_  ,  out_bias=a_  ,  scale_qk=a_		)
											a__				      =		TaLayerNorm(a_  ,  eps=a_		)
											a__				      =		nn.Dropout(a_		)







							def _a      (							self  ,  a_  ,  a_=None  ,  a_=None  ,  ):
											a__				      =		self.layer_norm(a_		)
											a__				      =		self.attention(
											    a_  ,  encoder_hidden_states=a_  ,  attention_mask=attention_mask.squeeze(1		)  ,  )
											a__				      =		hidden_states + self.dropout(a_		)
											return layer_output




class  __snake_case      (   nn.Module):







							'''simple docstring'''






							def __init__(							self  ,  a_  ,  a_  ,  a_  ,  a_		):
											super().__init__()
											a__				      =		TaDenseGatedActDense(d_model=a_  ,  d_ff=a_  ,  dropout_rate=a_		)
											a__				      =		TaFiLMLayer(in_features=d_model * 4  ,  out_features=a_		)
											a__				      =		TaLayerNorm(a_  ,  eps=a_		)
											a__				      =		nn.Dropout(a_		)







							def _a      (							self  ,  a_  ,  a_=None		):
											a__				      =		self.layer_norm(a_		)
											if conditioning_emb is not None:
															a__				      =		self.film(a_  ,  a_		)

											a__				      =		self.DenseReluDense(a_		)
											a__				      =		hidden_states + self.dropout(a_		)
											return hidden_states




class  __snake_case      (   nn.Module):







							'''simple docstring'''






							def __init__(							self  ,  a_  ,  a_  ,  a_		):
											super().__init__()
											a__				      =		nn.Linear(a_  ,  a_  ,  bias=a_		)
											a__				      =		nn.Linear(a_  ,  a_  ,  bias=a_		)
											a__				      =		nn.Linear(a_  ,  a_  ,  bias=a_		)
											a__				      =		nn.Dropout(a_		)
											a__				      =		NewGELUActivation()







							def _a      (							self  ,  a_		):
											a__				      =		self.act(self.wi_a(a_		)		)
											a__				      =		self.wi_a(a_		)
											a__				      =		hidden_gelu * hidden_linear
											a__				      =		self.dropout(a_		)

											a__				      =		self.wo(a_		)
											return hidden_states




class  __snake_case      (   nn.Module):







							'''simple docstring'''






							def __init__(							self  ,  a_  ,  a_=1E-6		):
											super().__init__()
											a__				      =		nn.Parameter(torch.ones(a_		)		)
											a__				      =		eps







							def _a      (							self  ,  a_		):
											# T5 uses a layer_norm which only scales and doesn't shift, which is also known as Root Mean
											# Square Layer Normalization https://arxiv.org/abs/1910.07467 thus variance is calculated
											# w/o mean and there is no bias. Additionally we want to make sure that the accumulation for
											# half-precision inputs is done in fp32

											a__				      =		hidden_states.to(torch.floataa		).pow(2		).mean(-1  ,  keepdim=a_		)
											a__				      =		hidden_states * torch.rsqrt(variance + self.variance_epsilon		)

											# convert into half-precision if necessary
											if self.weight.dtype in [torch.floataa, torch.bfloataa]:
															a__				      =		hidden_states.to(self.weight.dtype		)

											return self.weight * hidden_states




class  __snake_case      (   nn.Module):







							'''simple docstring'''






							def _a      (							self  ,  a_		):
											return 0.5 * input * (1.0 + torch.tanh(math.sqrt(2.0 / math.pi		) * (input + 0.044_715 * torch.pow(a_  ,  3.0		))		))




class  __snake_case      (   nn.Module):







							'''simple docstring'''






							def __init__(							self  ,  a_  ,  a_		):
											super().__init__()
											a__				      =		nn.Linear(a_  ,  out_features * 2  ,  bias=a_		)







							def _a      (							self  ,  a_  ,  a_		):
											a__				      =		self.scale_bias(a_		)
											a__      ,			a__				      =		torch.chunk(a_  ,  2  ,  -1		)
											a__				      =		x * (1 + scale) + shift
											return x

