





'''simple docstring'''






from typing import List, Optional, Tuple, Union

import torch
from torch import nn
from torch.nn import CrossEntropyLoss

from ... import AutoBackbone
from ...modeling_outputs import SemanticSegmenterOutput
from ...modeling_utils import PreTrainedModel
from ...utils import add_start_docstrings, add_start_docstrings_to_model_forward, replace_return_docstrings
from ...utils.backbone_utils import BackboneMixin
from .configuration_upernet import UperNetConfig


lowerCAmelCase									=   [
    """openmmlab/upernet-convnext-tiny""",
    # See all UperNet models at https://huggingface.co/models?filter=upernet
]

# General docstring
lowerCAmelCase									=   """UperNetConfig"""
class 		lowerCamelCase	(   nn.Module							):



	def __init__( self		,   a_		,   a_		,   a_		,   a_ = 0		,   a_ = False		,   a_ = 1		,   ):
			super().__init__()
			lowerCAmelCase  :     List[Any]       						= nn.Convad(
			    in_channels=a_		,   out_channels=a_		,   kernel_size=a_		,   padding=a_		,   bias=a_		,   dilation=a_		,   )
			lowerCAmelCase  :     List[Any]       						= nn.BatchNormad(a_						)
			lowerCAmelCase  :     int       						= nn.ReLU()





	def 	_lowerCamelCase     ( self		,   a_						):
			lowerCAmelCase  :     Optional[Any]       						= self.conv(a_						)
			lowerCAmelCase  :     Any       						= self.batch_norm(a_						)
			lowerCAmelCase  :     Any       						= self.activation(a_						)

			return output






class 		lowerCamelCase	(   nn.Module							):



	def __init__( self		,   a_		,   a_		,   a_						):
			super().__init__()
			lowerCAmelCase  :     Union[str, Any]       						= [
			    nn.AdaptiveAvgPoolad(a_						),
			    UperNetConvModule(a_		,   a_		,   kernel_size=1						),
			]
			for i, layer in enumerate(self.layers						):
					self.add_module(str(a_						)		,   a_						)





	def 	_lowerCamelCase     ( self		,   a_						):
			lowerCAmelCase  :     Optional[Any]       						= input
			for layer in self.layers:
					lowerCAmelCase  :     Union[str, Any]       						= layer(a_						)
			return hidden_state






class 		lowerCamelCase	(   nn.Module							):



	def __init__( self		,   a_		,   a_		,   a_		,   a_						):
			super().__init__()
			lowerCAmelCase  :     Optional[int]       						= pool_scales
			lowerCAmelCase  :     int       						= align_corners
			lowerCAmelCase  :     Optional[int]       						= in_channels
			lowerCAmelCase  :     Dict       						= channels
			lowerCAmelCase  :     Union[str, Any]       						= []
			for i, pool_scale in enumerate(a_						):
					lowerCAmelCase  :     Dict       						= UperNetPyramidPoolingBlock(pool_scale=a_		,   in_channels=a_		,   channels=a_						)
					self.blocks.append(a_						)
					self.add_module(str(a_						)		,   a_						)





	def 	_lowerCamelCase     ( self		,   a_						):
			lowerCAmelCase  :     int       						= []
			for ppm in self.blocks:
					lowerCAmelCase  :     Optional[int]       						= ppm(a_						)
					lowerCAmelCase  :     Optional[Any]       						= nn.functional.interpolate(
					    a_		,   size=x.size()[2:]		,   mode="bilinear"		,   align_corners=self.align_corners						)
					ppm_outs.append(a_						)
			return ppm_outs






class 		lowerCamelCase	(   nn.Module							):



	def __init__( self		,   a_		,   a_						):
			super().__init__()

			lowerCAmelCase  :     Union[str, Any]       						= config
			lowerCAmelCase  :     Optional[int]       						= config.pool_scales  # e.g. (1, 2, 3, 6)
			lowerCAmelCase  :     List[Any]       						= in_channels
			lowerCAmelCase  :     int       						= config.hidden_size
			lowerCAmelCase  :     List[str]       						= False
			lowerCAmelCase  :     Any       						= nn.Convad(self.channels		,   config.num_labels		,   kernel_size=1						)

			# PSP Module
			lowerCAmelCase  :     List[str]       						= UperNetPyramidPoolingModule(
			    self.pool_scales		,   self.in_channels[-1]		,   self.channels		,   align_corners=self.align_corners		,   )
			lowerCAmelCase  :     List[str]       						= UperNetConvModule(
			    self.in_channels[-1] + len(self.pool_scales						) * self.channels		,   self.channels		,   kernel_size=3		,   padding=1		,   )
			# FPN Module
			lowerCAmelCase  :     str       						= nn.ModuleList()
			lowerCAmelCase  :     List[str]       						= nn.ModuleList()
			for in_channels in self.in_channels[:-1]:  # skip the top layer
					lowerCAmelCase  :     Any       						= UperNetConvModule(a_		,   self.channels		,   kernel_size=1						)
					lowerCAmelCase  :     List[str]       						= UperNetConvModule(self.channels		,   self.channels		,   kernel_size=3		,   padding=1						)
					self.lateral_convs.append(a_						)
					self.fpn_convs.append(a_						)

			lowerCAmelCase  :     str       						= UperNetConvModule(
			    len(self.in_channels						) * self.channels		,   self.channels		,   kernel_size=3		,   padding=1		,   )



	def 	_lowerCamelCase     ( self						):
			self.apply(self._init_weights						)



	def 	_lowerCamelCase     ( self		,   a_						):
			if isinstance(a_		,   nn.Convad						):
					module.weight.data.normal_(mean=0.0		,   std=self.config.initializer_range						)
					if module.bias is not None:
							module.bias.data.zero_()



	def 	_lowerCamelCase     ( self		,   a_						):
			lowerCAmelCase  :     Optional[Any]       						= inputs[-1]
			lowerCAmelCase  :     Union[str, Any]       						= [x]
			psp_outs.extend(self.psp_modules(a_						)						)
			lowerCAmelCase  :     Union[str, Any]       						= torch.cat(a_		,   dim=1						)
			lowerCAmelCase  :     Optional[Any]       						= self.bottleneck(a_						)

			return output





	def 	_lowerCamelCase     ( self		,   a_						):
			# build laterals
			lowerCAmelCase  :     int       						= [lateral_conv(encoder_hidden_states[i]						) for i, lateral_conv in enumerate(self.lateral_convs						)]

			laterals.append(self.psp_forward(a_						)						)

			# build top-down path
			lowerCAmelCase  :     List[Any]       						= len(a_						)
			for i in range(used_backbone_levels - 1		,   0		,   -1						):
					lowerCAmelCase  :     Optional[int]       						= laterals[i - 1].shape[2:]
					lowerCAmelCase  :     str       						= laterals[i - 1] + nn.functional.interpolate(
					    laterals[i]		,   size=a_		,   mode="bilinear"		,   align_corners=self.align_corners						)

			# build outputs
			lowerCAmelCase  :     int       						= [self.fpn_convs[i](laterals[i]						) for i in range(used_backbone_levels - 1						)]
			# append psp feature
			fpn_outs.append(laterals[-1]						)

			for i in range(used_backbone_levels - 1		,   0		,   -1						):
					lowerCAmelCase  :     Optional[Any]       						= nn.functional.interpolate(
					    fpn_outs[i]		,   size=fpn_outs[0].shape[2:]		,   mode="bilinear"		,   align_corners=self.align_corners						)
			lowerCAmelCase  :     str       						= torch.cat(a_		,   dim=1						)
			lowerCAmelCase  :     List[str]       						= self.fpn_bottleneck(a_						)
			lowerCAmelCase  :     Union[str, Any]       						= self.classifier(a_						)

			return output






class 		lowerCamelCase	(   nn.Module							):



	def __init__( self		,   a_		,   a_ = 2		,   a_ = 3		,   a_ = 1						):
			super().__init__()

			lowerCAmelCase  :     Optional[int]       						= config
			lowerCAmelCase  :     Optional[Any]       						= config.auxiliary_in_channels
			lowerCAmelCase  :     List[Any]       						= config.auxiliary_channels
			lowerCAmelCase  :     Any       						= config.auxiliary_num_convs
			lowerCAmelCase  :     Tuple       						= config.auxiliary_concat_input
			lowerCAmelCase  :     List[Any]       						= in_index

			lowerCAmelCase  :     str       						= (kernel_size // 2) * dilation
			lowerCAmelCase  :     int       						= []
			convs.append(
			    UperNetConvModule(
			        self.in_channels		,   self.channels		,   kernel_size=a_		,   padding=a_		,   dilation=a_						)						)
			for i in range(self.num_convs - 1						):
					convs.append(
					    UperNetConvModule(
					        self.channels		,   self.channels		,   kernel_size=a_		,   padding=a_		,   dilation=a_						)						)
			if self.num_convs == 0:
					lowerCAmelCase  :     Union[str, Any]       						= nn.Identity()
			else:
					lowerCAmelCase  :     List[str]       						= nn.Sequential(*a_						)
			if self.concat_input:
					lowerCAmelCase  :     Optional[Any]       						= UperNetConvModule(
					    self.in_channels + self.channels		,   self.channels		,   kernel_size=a_		,   padding=kernel_size // 2						)

			lowerCAmelCase  :     List[Any]       						= nn.Convad(self.channels		,   config.num_labels		,   kernel_size=1						)



	def 	_lowerCamelCase     ( self						):
			self.apply(self._init_weights						)



	def 	_lowerCamelCase     ( self		,   a_						):
			if isinstance(a_		,   nn.Convad						):
					module.weight.data.normal_(mean=0.0		,   std=self.config.initializer_range						)
					if module.bias is not None:
							module.bias.data.zero_()





	def 	_lowerCamelCase     ( self		,   a_						):
			# just take the relevant feature maps
			lowerCAmelCase  :     Dict       						= encoder_hidden_states[self.in_index]
			lowerCAmelCase  :     Union[str, Any]       						= self.convs(a_						)
			if self.concat_input:
					lowerCAmelCase  :     Dict       						= self.conv_cat(torch.cat([hidden_states, output]		,   dim=1						)						)
			lowerCAmelCase  :     List[str]       						= self.classifier(a_						)
			return output






class 		lowerCamelCase	(   _A							):
	snake_case_   = UperNetConfig
	snake_case_   = "pixel_values"
	snake_case_   = True



	def 	_lowerCamelCase     ( self		,   a_						):
			if isinstance(a_		,   a_						):
					module.backbone.init_weights()
					module.decode_head.init_weights()
					module.auxiliary_head.init_weights()



	def 	_lowerCamelCase     ( self						):
			self.backbone.init_weights()
			self.decode_head.init_weights()
			self.auxiliary_head.init_weights()





	def 	_lowerCamelCase     ( self		,   a_		,   a_=False						):
			if isinstance(a_		,   a_						):
					lowerCAmelCase  :     List[str]       						= value






lowerCAmelCase									=   R"""
    Parameters:
    This model is a PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) sub-class. Use
    it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage and
    behavior.
        config ([`UperNetConfig`]): Model configuration class with all the parameters of the model.
            Initializing with a config file does not load the weights associated with the model, only the
            configuration. Check out the [`~PreTrainedModel.from_pretrained`] method to load the model weights.
"""

lowerCAmelCase									=   R"""
    Args:
        pixel_values (`torch.FloatTensor` of shape `(batch_size, num_channels, height, width)`):
            Pixel values. Padding will be ignored by default should you provide it. Pixel values can be obtained using
            [`AutoImageProcessor`]. See [`SegformerImageProcessor.__call__`] for details.
        output_attentions (`bool`, *optional*):
            Whether or not to return the attentions tensors of all attention layers in case the backbone has them. See
            `attentions` under returned tensors for more detail.
        output_hidden_states (`bool`, *optional*):
            Whether or not to return the hidden states of all layers of the backbone. See `hidden_states` under
            returned tensors for more detail.
        return_dict (`bool`, *optional*):
            Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple.
"""
@add_start_docstrings(
    "UperNet framework leveraging any vision backbone e.g. for ADE20k, CityScapes."   , _A   , )
class 		lowerCamelCase	(   _A							):



	def __init__( self		,   a_						):
			super().__init__(a_						)

			lowerCAmelCase  :     Any       						= AutoBackbone.from_config(config.backbone_config						)

			# Semantic segmentation head(s)
			lowerCAmelCase  :     Optional[int]       						= UperNetHead(a_		,   in_channels=self.backbone.channels						)
			lowerCAmelCase  :     List[str]       						= UperNetFCNHead(a_						) if config.use_auxiliary_head else None

			# Initialize weights and apply final processing
			self.post_init()





	@add_start_docstrings_to_model_forward(UPERNET_INPUTS_DOCSTRING.format("batch_size, sequence_length"						)						)
	@replace_return_docstrings(output_type=a_		,   config_class=_CONFIG_FOR_DOC						)
	def 	_lowerCamelCase     ( self		,   a_ = None		,   a_ = None		,   a_ = None		,   a_ = None		,   a_ = None		,   ):
			lowerCAmelCase  :     int       						= return_dict if return_dict is not None else self.config.use_return_dict
			lowerCAmelCase  :     str       						= (
			    output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
			)
			lowerCAmelCase  :     Optional[Any]       						= output_attentions if output_attentions is not None else self.config.output_attentions

			lowerCAmelCase  :     Optional[int]       						= self.backbone.forward_with_filtered_kwargs(
			    a_		,   output_hidden_states=a_		,   output_attentions=a_						)
			lowerCAmelCase  :     Any       						= outputs.feature_maps

			lowerCAmelCase  :     List[Any]       						= self.decode_head(a_						)
			lowerCAmelCase  :     Dict       						= nn.functional.interpolate(a_		,   size=pixel_values.shape[2:]		,   mode="bilinear"		,   align_corners=a_						)

			lowerCAmelCase  :     Tuple       						= None
			if self.auxiliary_head is not None:
					lowerCAmelCase  :     List[str]       						= self.auxiliary_head(a_						)
					lowerCAmelCase  :     Union[str, Any]       						= nn.functional.interpolate(
					    a_		,   size=pixel_values.shape[2:]		,   mode="bilinear"		,   align_corners=a_						)

			lowerCAmelCase  :     List[str]       						= None
			if labels is not None:
					if self.config.num_labels == 1:
							raise ValueError("The number of labels should be greater than one"						)
					else:
							# compute weighted loss
							lowerCAmelCase  :     Optional[int]       						= CrossEntropyLoss(ignore_index=self.config.loss_ignore_index						)
							lowerCAmelCase  :     Optional[int]       						= loss_fct(a_		,   a_						)
							lowerCAmelCase  :     List[Any]       						= loss_fct(a_		,   a_						)
							lowerCAmelCase  :     Any       						= main_loss + self.config.auxiliary_loss_weight * auxiliary_loss

			if not return_dict:
					if output_hidden_states:
							lowerCAmelCase  :     List[Any]       						= (logits,) + outputs[1:]
					else:
							lowerCAmelCase  :     Tuple       						= (logits,) + outputs[2:]
					return ((loss,) + output) if loss is not None else output

			return SemanticSegmenterOutput(
			    loss=a_		,   logits=a_		,   hidden_states=outputs.hidden_states		,   attentions=outputs.attentions		,   )










'''simple docstring'''






import unittest

import numpy as np
import timeout_decorator  # noqa

from transformers import BlenderbotConfig, is_flax_available
from transformers.testing_utils import jax_device, require_flax, slow

from ...generation.test_flax_utils import FlaxGenerationTesterMixin
from ...test_modeling_flax_common import FlaxModelTesterMixin, ids_tensor


if is_flax_available():
					import os

					# The slow tests are often failing with OOM error on GPU
					# This makes JAX allocate exactly what is needed on demand, and deallocate memory that is no longer needed
					# but will be slower as stated here https://jax.readthedocs.io/en/latest/gpu_memory_allocation.html
					lowerCAmelCase									=   """platform"""

					import jax
					import jax.numpy as jnp

					from transformers import BlenderbotTokenizer
					from transformers.models.blenderbot.modeling_flax_blenderbot import (
					    FlaxBlenderbotForConditionalGeneration,
					    FlaxBlenderbotModel,
					    shift_tokens_right,
					)






def   __A    (				a_    :	Dict   ,a_    :	List[Any]   ,a_    :	List[str]=None   ,a_    :	Optional[int]=None   ,a_    :	Any=None   ,a_    :	Any=None   ,a_    :	str=None   ,a_    :	Union[str, Any]=None   ,):
		if attention_mask is None:
				lowerCAmelCase  :     List[Any]       						= np.where(input_ids != config.pad_token_id   ,1   ,0						)
		if decoder_attention_mask is None:
				lowerCAmelCase  :     Union[str, Any]       						= np.where(decoder_input_ids != config.pad_token_id   ,1   ,0						)
		if head_mask is None:
				lowerCAmelCase  :     Dict       						= np.ones((config.encoder_layers, config.encoder_attention_heads)						)
		if decoder_head_mask is None:
				lowerCAmelCase  :     int       						= np.ones((config.decoder_layers, config.decoder_attention_heads)						)
		if cross_attn_head_mask is None:
				lowerCAmelCase  :     Union[str, Any]       						= np.ones((config.decoder_layers, config.decoder_attention_heads)						)
		return {
		    "input_ids": input_ids,
		    "decoder_input_ids": decoder_input_ids,
		    "attention_mask": attention_mask,
		    "decoder_attention_mask": attention_mask,
		}
class 		lowerCamelCase	:



	def __init__( self		,   a_		,   a_=13		,   a_=7		,   a_=True		,   a_=False		,   a_=99		,   a_=16		,   a_=2		,   a_=4		,   a_=4		,   a_="gelu"		,   a_=0.1		,   a_=0.1		,   a_=32		,   a_=2		,   a_=1		,   a_=0		,   a_=0.02		,   ):
			lowerCAmelCase  :     Optional[int]       						= parent
			lowerCAmelCase  :     Tuple       						= batch_size
			lowerCAmelCase  :     Any       						= seq_length
			lowerCAmelCase  :     int       						= is_training
			lowerCAmelCase  :     int       						= use_labels
			lowerCAmelCase  :     Any       						= vocab_size
			lowerCAmelCase  :     Tuple       						= hidden_size
			lowerCAmelCase  :     Optional[int]       						= num_hidden_layers
			lowerCAmelCase  :     int       						= num_attention_heads
			lowerCAmelCase  :     int       						= intermediate_size
			lowerCAmelCase  :     str       						= hidden_act
			lowerCAmelCase  :     List[Any]       						= hidden_dropout_prob
			lowerCAmelCase  :     List[str]       						= attention_probs_dropout_prob
			lowerCAmelCase  :     Dict       						= max_position_embeddings
			lowerCAmelCase  :     Optional[int]       						= eos_token_id
			lowerCAmelCase  :     Union[str, Any]       						= pad_token_id
			lowerCAmelCase  :     Tuple       						= bos_token_id
			lowerCAmelCase  :     Tuple       						= initializer_range



	def 	_lowerCamelCase     ( self						):
			lowerCAmelCase  :     Optional[Any]       						= np.clip(ids_tensor([self.batch_size, self.seq_length - 1]		,   self.vocab_size						)		,   3		,   self.vocab_size						)
			lowerCAmelCase  :     str       						= np.concatenate((input_ids, 2 * np.ones((self.batch_size, 1)		,   dtype=np.intaa						))		,   -1						)

			lowerCAmelCase  :     List[str]       						= shift_tokens_right(a_		,   1		,   2						)

			lowerCAmelCase  :     Union[str, Any]       						= BlenderbotConfig(
			    vocab_size=self.vocab_size		,   d_model=self.hidden_size		,   encoder_layers=self.num_hidden_layers		,   decoder_layers=self.num_hidden_layers		,   encoder_attention_heads=self.num_attention_heads		,   decoder_attention_heads=self.num_attention_heads		,   encoder_ffn_dim=self.intermediate_size		,   decoder_ffn_dim=self.intermediate_size		,   dropout=self.hidden_dropout_prob		,   attention_dropout=self.attention_probs_dropout_prob		,   max_position_embeddings=self.max_position_embeddings		,   eos_token_id=self.eos_token_id		,   bos_token_id=self.bos_token_id		,   pad_token_id=self.pad_token_id		,   initializer_range=self.initializer_range		,   use_cache=a_		,   )
			lowerCAmelCase  :     Tuple       						= prepare_blenderbot_inputs_dict(a_		,   a_		,   a_						)
			return config, inputs_dict



	def 	_lowerCamelCase     ( self						):
			lowerCAmelCase						,		lowerCAmelCase  :     Union[str, Any]       						= self.prepare_config_and_inputs()
			return config, inputs_dict



	def 	_lowerCamelCase     ( self		,   a_		,   a_		,   a_						):
			lowerCAmelCase  :     Any       						= 20
			lowerCAmelCase  :     int       						= model_class_name(a_						)

			lowerCAmelCase  :     Tuple       						= model.encode(inputs_dict["input_ids"]						)

			lowerCAmelCase						,		lowerCAmelCase  :     List[Any]       						= (
			    inputs_dict["decoder_input_ids"],
			    inputs_dict["decoder_attention_mask"],
			)

			lowerCAmelCase  :     Tuple       						= model.init_cache(decoder_input_ids.shape[0]		,   a_		,   a_						)
			lowerCAmelCase  :     Any       						= jnp.ones((decoder_input_ids.shape[0], max_decoder_length)		,   dtype="i4"						)

			lowerCAmelCase  :     Dict       						= jnp.broadcast_to(
			    jnp.arange(decoder_input_ids.shape[-1] - 1						)[None, :]		,   (decoder_input_ids.shape[0], decoder_input_ids.shape[-1] - 1)		,   )
			lowerCAmelCase  :     Union[str, Any]       						= model.decode(
			    decoder_input_ids[:, :-1]		,   a_		,   decoder_attention_mask=a_		,   past_key_values=a_		,   decoder_position_ids=a_		,   )

			lowerCAmelCase  :     Tuple       						= jnp.array(decoder_input_ids.shape[0] * [[decoder_input_ids.shape[-1] - 1]]		,   dtype="i4"						)
			lowerCAmelCase  :     Optional[Any]       						= model.decode(
			    decoder_input_ids[:, -1:]		,   a_		,   decoder_attention_mask=a_		,   past_key_values=outputs_cache.past_key_values		,   decoder_position_ids=a_		,   )

			lowerCAmelCase  :     int       						= model.decode(a_		,   a_						)

			lowerCAmelCase  :     List[str]       						= np.max(np.abs((outputs_cache_next[0][:, -1, :5] - outputs[0][:, -1, :5])						)						)
			self.parent.assertTrue(diff < 1e-3		,   msg=F'''Max diff is {diff}'''						)





	def 	_lowerCamelCase     ( self		,   a_		,   a_		,   a_						):
			lowerCAmelCase  :     Union[str, Any]       						= 20
			lowerCAmelCase  :     Tuple       						= model_class_name(a_						)

			lowerCAmelCase  :     Dict       						= model.encode(inputs_dict["input_ids"]						)

			lowerCAmelCase						,		lowerCAmelCase  :     str       						= (
			    inputs_dict["decoder_input_ids"],
			    inputs_dict["decoder_attention_mask"],
			)

			lowerCAmelCase  :     Any       						= jnp.concatenate(
			    [
			        decoder_attention_mask,
			        jnp.zeros((decoder_attention_mask.shape[0], max_decoder_length - decoder_attention_mask.shape[1])						),
			    ]		,   axis=-1		,   )

			lowerCAmelCase  :     Union[str, Any]       						= model.init_cache(decoder_input_ids.shape[0]		,   a_		,   a_						)
			lowerCAmelCase  :     Any       						= jnp.broadcast_to(
			    jnp.arange(decoder_input_ids.shape[-1] - 1						)[None, :]		,   (decoder_input_ids.shape[0], decoder_input_ids.shape[-1] - 1)		,   )

			lowerCAmelCase  :     Any       						= model.decode(
			    decoder_input_ids[:, :-1]		,   a_		,   decoder_attention_mask=a_		,   past_key_values=a_		,   decoder_position_ids=a_		,   )
			lowerCAmelCase  :     int       						= jnp.array(decoder_input_ids.shape[0] * [[decoder_input_ids.shape[-1] - 1]]		,   dtype="i4"						)
			lowerCAmelCase  :     Any       						= model.decode(
			    decoder_input_ids[:, -1:]		,   a_		,   past_key_values=outputs_cache.past_key_values		,   decoder_attention_mask=a_		,   decoder_position_ids=a_		,   )

			lowerCAmelCase  :     List[str]       						= model.decode(a_		,   a_		,   decoder_attention_mask=a_						)

			lowerCAmelCase  :     int       						= np.max(np.abs((outputs_cache_next[0][:, -1, :5] - outputs[0][:, -1, :5])						)						)
			self.parent.assertTrue(diff < 1e-3		,   msg=F'''Max diff is {diff}'''						)






@require_flax
class 		lowerCamelCase	(   unittest.TestCase							):
	snake_case_   = 99



	def 	_lowerCamelCase     ( self						):
			lowerCAmelCase  :     List[Any]       						= np.array(
			    [
			        [71, 82, 18, 33, 46, 91, 2],
			        [68, 34, 26, 58, 30, 82, 2],
			        [5, 97, 17, 39, 94, 40, 2],
			        [76, 83, 94, 25, 70, 78, 2],
			        [87, 59, 41, 35, 48, 66, 2],
			        [55, 13, 16, 58, 5, 2, 1],  # note padding
			        [64, 27, 31, 51, 12, 75, 2],
			        [52, 64, 86, 17, 83, 39, 2],
			        [48, 61, 9, 24, 71, 82, 2],
			        [26, 1, 60, 48, 22, 13, 2],
			        [21, 5, 62, 28, 14, 76, 2],
			        [45, 98, 37, 86, 59, 48, 2],
			        [70, 70, 50, 9, 28, 0, 2],
			    ]		,   dtype=np.intaa		,   )

			lowerCAmelCase  :     Union[str, Any]       						= input_ids.shape[0]
			lowerCAmelCase  :     Dict       						= BlenderbotConfig(
			    vocab_size=self.vocab_size		,   d_model=24		,   encoder_layers=2		,   decoder_layers=2		,   encoder_attention_heads=2		,   decoder_attention_heads=2		,   encoder_ffn_dim=32		,   decoder_ffn_dim=32		,   max_position_embeddings=48		,   eos_token_id=2		,   pad_token_id=1		,   bos_token_id=0		,   )
			return config, input_ids, batch_size



	def 	_lowerCamelCase     ( self						):
			lowerCAmelCase						,		lowerCAmelCase						,		lowerCAmelCase  :     List[str]       						= self._get_config_and_data()
			lowerCAmelCase  :     Tuple       						= FlaxBlenderbotForConditionalGeneration(a_						)
			lowerCAmelCase  :     str       						= lm_model(input_ids=a_						)
			lowerCAmelCase  :     Tuple       						= (batch_size, input_ids.shape[1], config.vocab_size)
			self.assertEqual(outputs["logits"].shape		,   a_						)



	def 	_lowerCamelCase     ( self						):
			lowerCAmelCase  :     Union[str, Any]       						= BlenderbotConfig(
			    vocab_size=self.vocab_size		,   d_model=14		,   encoder_layers=2		,   decoder_layers=2		,   encoder_attention_heads=2		,   decoder_attention_heads=2		,   encoder_ffn_dim=8		,   decoder_ffn_dim=8		,   max_position_embeddings=48		,   )
			lowerCAmelCase  :     int       						= FlaxBlenderbotForConditionalGeneration(a_						)
			lowerCAmelCase  :     Optional[Any]       						= np.array([[71, 82, 18, 33, 46, 91, 2], [68, 34, 26, 58, 30, 2, 1]]		,   dtype=np.intaa						)
			lowerCAmelCase  :     List[str]       						= np.array([[82, 71, 82, 18, 2], [58, 68, 2, 1, 1]]		,   dtype=np.intaa						)
			lowerCAmelCase  :     List[str]       						= lm_model(input_ids=a_		,   decoder_input_ids=a_						)
			lowerCAmelCase  :     List[str]       						= (*summary.shape, config.vocab_size)
			self.assertEqual(outputs["logits"].shape		,   a_						)





	def 	_lowerCamelCase     ( self						):
			lowerCAmelCase  :     int       						= np.array([[71, 82, 18, 33, 2, 1, 1], [68, 34, 26, 58, 30, 82, 2]]		,   dtype=np.intaa						)
			lowerCAmelCase  :     Dict       						= shift_tokens_right(a_		,   1		,   2						)
			lowerCAmelCase  :     Optional[Any]       						= np.equal(a_		,   1						).astype(np.floataa						).sum()
			lowerCAmelCase  :     Any       						= np.equal(a_		,   1						).astype(np.floataa						).sum()
			self.assertEqual(shifted.shape		,   input_ids.shape						)
			self.assertEqual(a_		,   n_pad_before - 1						)
			self.assertTrue(np.equal(shifted[:, 0]		,   2						).all()						)






@require_flax
class 		lowerCamelCase	(   _A   , unittest.TestCase   , _A							):
	snake_case_   = True
	snake_case_   = (
	    (
	        FlaxBlenderbotModel,
	        FlaxBlenderbotForConditionalGeneration,
	    )
	    if is_flax_available()
	    else ()
	)
	snake_case_   = (FlaxBlenderbotForConditionalGeneration,) if is_flax_available() else ()



	def 	_lowerCamelCase     ( self						):
			lowerCAmelCase  :     Optional[Any]       						= FlaxBlenderbotModelTester(self						)



	def 	_lowerCamelCase     ( self						):
			lowerCAmelCase						,		lowerCAmelCase  :     Optional[int]       						= self.model_tester.prepare_config_and_inputs()
			for model_class in self.all_model_classes:
					self.model_tester.check_use_cache_forward(a_		,   a_		,   a_						)



	def 	_lowerCamelCase     ( self						):
			lowerCAmelCase						,		lowerCAmelCase  :     List[str]       						= self.model_tester.prepare_config_and_inputs()
			for model_class in self.all_model_classes:
					self.model_tester.check_use_cache_forward_with_attn_mask(a_		,   a_		,   a_						)



	def 	_lowerCamelCase     ( self						):
			lowerCAmelCase						,		lowerCAmelCase  :     Optional[Any]       						= self.model_tester.prepare_config_and_inputs_for_common()

			for model_class in self.all_model_classes:
					with self.subTest(model_class.__name__						):
							lowerCAmelCase  :     List[str]       						= self._prepare_for_class(a_		,   a_						)
							lowerCAmelCase  :     str       						= model_class(a_						)

							@jax.jit
							def encode_jitted(a_		,   a_=None		,   **a_						):
									return model.encode(input_ids=a_		,   attention_mask=a_						)

							with self.subTest("JIT Enabled"						):
									lowerCAmelCase  :     List[Any]       						= encode_jitted(**a_						).to_tuple()

							with self.subTest("JIT Disabled"						):
									with jax.disable_jit():
											lowerCAmelCase  :     Tuple       						= encode_jitted(**a_						).to_tuple()

							self.assertEqual(len(a_						)		,   len(a_						)						)
							for jitted_output, output in zip(a_		,   a_						):
									self.assertEqual(jitted_output.shape		,   output.shape						)



	def 	_lowerCamelCase     ( self						):
			lowerCAmelCase						,		lowerCAmelCase  :     Optional[int]       						= self.model_tester.prepare_config_and_inputs_for_common()

			for model_class in self.all_model_classes:
					with self.subTest(model_class.__name__						):
							lowerCAmelCase  :     int       						= model_class(a_						)
							lowerCAmelCase  :     Optional[int]       						= model.encode(inputs_dict["input_ids"]		,   inputs_dict["attention_mask"]						)

							lowerCAmelCase  :     Optional[Any]       						= {
							    "decoder_input_ids": inputs_dict["decoder_input_ids"],
							    "decoder_attention_mask": inputs_dict["decoder_attention_mask"],
							    "encoder_outputs": encoder_outputs,
							}

							@jax.jit
							def decode_jitted(a_		,   a_		,   a_						):
									return model.decode(
									    decoder_input_ids=a_		,   decoder_attention_mask=a_		,   encoder_outputs=a_		,   )

							with self.subTest("JIT Enabled"						):
									lowerCAmelCase  :     str       						= decode_jitted(**a_						).to_tuple()

							with self.subTest("JIT Disabled"						):
									with jax.disable_jit():
											lowerCAmelCase  :     Optional[Any]       						= decode_jitted(**a_						).to_tuple()

							self.assertEqual(len(a_						)		,   len(a_						)						)
							for jitted_output, output in zip(a_		,   a_						):
									self.assertEqual(jitted_output.shape		,   output.shape						)



	@slow
	def 	_lowerCamelCase     ( self						):
			for model_class_name in self.all_model_classes:
					lowerCAmelCase  :     List[str]       						= model_class_name.from_pretrained("facebook/blenderbot-400M-distill"						)
					# FlaxBlenderbotForSequenceClassification expects eos token in input_ids
					lowerCAmelCase  :     Union[str, Any]       						= np.ones((1, 1)						) * model.config.eos_token_id
					lowerCAmelCase  :     Dict       						= model(a_						)
					self.assertIsNotNone(a_						)





	@unittest.skipUnless(jax_device != "cpu"		,   "3B test too slow on CPU."						)
	@slow
	def 	_lowerCamelCase     ( self						):
			lowerCAmelCase  :     Dict       						= {"num_beams": 1, "early_stopping": True, "min_length": 15, "max_length": 25}
			lowerCAmelCase  :     Any       						= {"skip_special_tokens": True, "clean_up_tokenization_spaces": True}

			lowerCAmelCase  :     Optional[int]       						= FlaxBlenderbotForConditionalGeneration.from_pretrained("facebook/blenderbot-3B"		,   from_pt=a_						)
			lowerCAmelCase  :     List[str]       						= BlenderbotTokenizer.from_pretrained("facebook/blenderbot-3B"						)

			lowerCAmelCase  :     Any       						= ["Sam"]
			lowerCAmelCase  :     int       						= tokenizer(a_		,   return_tensors="jax"						)

			lowerCAmelCase  :     List[Any]       						= model.generate(**a_		,   **a_						)
			lowerCAmelCase  :     Optional[Any]       						= "Sam is a great name. It means \"sun\" in Gaelic."

			lowerCAmelCase  :     Optional[Any]       						= tokenizer.batch_decode(a_		,   **a_						)
			assert generated_txt[0].strip() == tgt_text



