




import re
import string
from collections import Counter

import sacrebleu
import sacremoses
from packaging import version

import datasets


__lowerCAmelCase		:				int       			=		'\n@inproceedings{xu-etal-2016-optimizing,\n    title = {Optimizing Statistical Machine Translation for Text Simplification},\n    authors={Xu, Wei and Napoles, Courtney and Pavlick, Ellie and Chen, Quanze and Callison-Burch, Chris},\n    journal = {Transactions of the Association for Computational Linguistics},\n    volume = {4},\n    year={2016},\n    url = {https://www.aclweb.org/anthology/Q16-1029},\n    pages = {401--415\n},\n@inproceedings{post-2018-call,\n    title = "A Call for Clarity in Reporting {BLEU} Scores",\n    author = "Post, Matt",\n    booktitle = "Proceedings of the Third Conference on Machine Translation: Research Papers",\n    month = oct,\n    year = "2018",\n    address = "Belgium, Brussels",\n    publisher = "Association for Computational Linguistics",\n    url = "https://www.aclweb.org/anthology/W18-6319",\n    pages = "186--191",\n}\n'

__lowerCAmelCase		:				Any       			=		'\\nWIKI_SPLIT is the combination of three metrics SARI, EXACT and SACREBLEU\nIt can be used to evaluate the quality of machine-generated texts.\n'


__lowerCAmelCase		:				Optional[int]       			=		'\nCalculates sari score (between 0 and 100) given a list of source and predicted\nsentences, and a list of lists of reference sentences. It also computes the BLEU score as well as the exact match score.\nArgs:\n    sources: list of source sentences where each sentence should be a string.\n    predictions: list of predicted sentences where each sentence should be a string.\n    references: list of lists of reference sentences where each sentence should be a string.\nReturns:\n    sari: sari score\n    sacrebleu: sacrebleu score\n    exact: exact score\n\nExamples:\n    >>> sources=["About 95 species are currently accepted ."]\n    >>> predictions=["About 95 you now get in ."]\n    >>> references=[["About 95 species are currently known ."]]\n    >>> wiki_split = datasets.load_metric("wiki_split")\n    >>> results = wiki_split.compute(sources=sources, predictions=predictions, references=references)\n    >>> print(results)\n    {\'sari\': 21.805555555555557, \'sacrebleu\': 14.535768424205482, \'exact\': 0.0}\n'




def 			__magic_name__				( A		:					Dict   ):






			'''simple docstring'''







			def remove_articles(A		:					List[Any]   ):
						a    =			re.compile(R"\b(a|an|the)\b",  re.UNICODE   )
						return re.sub(A,  " ",  A   )

			def white_space_fix(A		:					str   ):
						return " ".join(text.split()   )

			def remove_punc(A		:					List[Any]   ):
						a    =			set(string.punctuation   )
						return "".join(ch for ch in text if ch not in exclude   )

			def lower(A		:					int   ):
						return text.lower()

			return white_space_fix(remove_articles(remove_punc(lower(A   )   )   )   )




def 			__magic_name__				( A		:					Optional[int],  A		:					int   ):






			'''simple docstring'''







			return int(normalize_answer(A   ) == normalize_answer(A   )   )




def 			__magic_name__				( A		:					Dict,  A		:					List[Any]   ):






			'''simple docstring'''







			a    =			[any(compute_exact(A,  A   ) for ref in refs   ) for pred, refs in zip(A,  A   )]
			return (sum(A   ) / len(A   )) * 100




def 			__magic_name__				( A		:					Dict,  A		:					Optional[Any],  A		:					str,  A		:					Union[str, Any]   ):






			'''simple docstring'''







			a    =			[rgram for rgrams in rgramslist for rgram in rgrams]
			a    =			Counter(A   )

			a    =			Counter(A   )
			a    =			Counter()
			for sgram, scount in sgramcounter.items():
						a    =			scount * numref

			a    =			Counter(A   )
			a    =			Counter()
			for cgram, ccount in cgramcounter.items():
						a    =			ccount * numref

			# KEEP
			a    =			sgramcounter_rep & cgramcounter_rep
			a    =			keepgramcounter_rep & rgramcounter
			a    =			sgramcounter_rep & rgramcounter

			a    =			0
			a    =			0
			for keepgram in keepgramcountergood_rep:
						keeptmpscorea += keepgramcountergood_rep[keepgram] / keepgramcounter_rep[keepgram]
						# Fix an alleged bug [2] in the keep score computation.
						# keeptmpscore2 += keepgramcountergood_rep[keepgram] / keepgramcounterall_rep[keepgram]
						keeptmpscorea += keepgramcountergood_rep[keepgram]
			# Define 0/0=1 instead of 0 to give higher scores for predictions that match
			#      a target exactly.
			a    =			1
			a    =			1
			if len(A   ) > 0:
						a    =			keeptmpscorea / len(A   )
			if len(A   ) > 0:
						# Fix an alleged bug [2] in the keep score computation.
						# keepscore_recall = keeptmpscore2 / len(keepgramcounterall_rep)
						a    =			keeptmpscorea / sum(keepgramcounterall_rep.values()   )
			a    =			0
			if keepscore_precision > 0 or keepscore_recall > 0:
						a    =			2 * keepscore_precision * keepscore_recall / (keepscore_precision + keepscore_recall)

			# DELETION
			a    =			sgramcounter_rep - cgramcounter_rep
			a    =			delgramcounter_rep - rgramcounter
			a    =			sgramcounter_rep - rgramcounter
			a    =			0
			a    =			0
			for delgram in delgramcountergood_rep:
						deltmpscorea += delgramcountergood_rep[delgram] / delgramcounter_rep[delgram]
						deltmpscorea += delgramcountergood_rep[delgram] / delgramcounterall_rep[delgram]
			# Define 0/0=1 instead of 0 to give higher scores for predictions that match
			# a target exactly.
			a    =			1
			if len(A   ) > 0:
						a    =			deltmpscorea / len(A   )

			# ADDITION
			a    =			set(A   ) - set(A   )
			a    =			set(A   ) & set(A   )
			a    =			set(A   ) - set(A   )

			a    =			0
			for addgram in addgramcountergood:
						addtmpscore += 1

			# Define 0/0=1 instead of 0 to give higher scores for predictions that match
			# a target exactly.
			a    =			1
			a    =			1
			if len(A   ) > 0:
						a    =			addtmpscore / len(A   )
			if len(A   ) > 0:
						a    =			addtmpscore / len(A   )
			a    =			0
			if addscore_precision > 0 or addscore_recall > 0:
						a    =			2 * addscore_precision * addscore_recall / (addscore_precision + addscore_recall)

			return (keepscore, delscore_precision, addscore)




def 			__magic_name__				( A		:					Dict,  A		:					List[str],  A		:					Dict   ):






			'''simple docstring'''







			a    =			len(A   )

			a    =			ssent.split(" "   )
			a    =			csent.split(" "   )
			a    =			[]
			a    =			[]
			a    =			[]
			a    =			[]
			a    =			[]
			a    =			[]

			a    =			[]
			a    =			[]
			a    =			[]
			a    =			[]
			for rsent in rsents:
						a    =			rsent.split(" "   )
						a    =			[]
						a    =			[]
						a    =			[]
						ragramslist.append(A   )
						for i in range(0,  len(A   ) - 1   ):
									if i < len(A   ) - 1:
												a    =			ragrams[i] + " " + ragrams[i + 1]
												ragrams.append(A   )
									if i < len(A   ) - 2:
												a    =			ragrams[i] + " " + ragrams[i + 1] + " " + ragrams[i + 2]
												ragrams.append(A   )
									if i < len(A   ) - 3:
												a    =			ragrams[i] + " " + ragrams[i + 1] + " " + ragrams[i + 2] + " " + ragrams[i + 3]
												ragrams.append(A   )
						ragramslist.append(A   )
						ragramslist.append(A   )
						ragramslist.append(A   )

			for i in range(0,  len(A   ) - 1   ):
						if i < len(A   ) - 1:
									a    =			sagrams[i] + " " + sagrams[i + 1]
									sagrams.append(A   )
						if i < len(A   ) - 2:
									a    =			sagrams[i] + " " + sagrams[i + 1] + " " + sagrams[i + 2]
									sagrams.append(A   )
						if i < len(A   ) - 3:
									a    =			sagrams[i] + " " + sagrams[i + 1] + " " + sagrams[i + 2] + " " + sagrams[i + 3]
									sagrams.append(A   )

			for i in range(0,  len(A   ) - 1   ):
						if i < len(A   ) - 1:
									a    =			cagrams[i] + " " + cagrams[i + 1]
									cagrams.append(A   )
						if i < len(A   ) - 2:
									a    =			cagrams[i] + " " + cagrams[i + 1] + " " + cagrams[i + 2]
									cagrams.append(A   )
						if i < len(A   ) - 3:
									a    =			cagrams[i] + " " + cagrams[i + 1] + " " + cagrams[i + 2] + " " + cagrams[i + 3]
									cagrams.append(A   )

			((a)    ,		(a)    ,		(a))    =			SARIngram(A,  A,  A,  A   )
			((a)    ,		(a)    ,		(a))    =			SARIngram(A,  A,  A,  A   )
			((a)    ,		(a)    ,		(a))    =			SARIngram(A,  A,  A,  A   )
			((a)    ,		(a)    ,		(a))    =			SARIngram(A,  A,  A,  A   )
			a    =			sum([keepascore, keepascore, keepascore, keepascore]   ) / 4
			a    =			sum([delascore, delascore, delascore, delascore]   ) / 4
			a    =			sum([addascore, addascore, addascore, addascore]   ) / 4
			a    =			(avgkeepscore + avgdelscore + avgaddscore) / 3
			return finalscore




def 			__magic_name__				( A		:					Any,  A		:					bool = True,  A		:					str = "13a",  A		:					bool = True   ):






			'''simple docstring'''







			if lowercase:
						a    =			sentence.lower()

			if tokenizer in ["13a", "intl"]:
						if version.parse(sacrebleu.__version__   ).major >= 2:
									a    =			sacrebleu.metrics.bleu._get_tokenizer(A   )()(A   )
						else:
									a    =			sacrebleu.TOKENIZERS[tokenizer]()(A   )
			elif tokenizer == "moses":
						a    =			sacremoses.MosesTokenizer().tokenize(A,  return_str=A,  escape=A   )
			elif tokenizer == "penn":
						a    =			sacremoses.MosesTokenizer().penn_tokenize(A,  return_str=A   )
			else:
						a    =			sentence

			if not return_str:
						a    =			normalized_sent.split()

			return normalized_sent




def 			__magic_name__				( A		:					Optional[int],  A		:					Optional[Any],  A		:					Tuple   ):






			'''simple docstring'''







			if not (len(A   ) == len(A   ) == len(A   )):
						raise ValueError("Sources length must match predictions and references lengths."   )
			a    =			0
			for src, pred, refs in zip(A,  A,  A   ):
						sari_score += SARIsent(normalize(A   ),  normalize(A   ),  [normalize(A   ) for sent in refs]   )
			a    =			sari_score / len(A   )
			return 100 * sari_score




def 			__magic_name__				( A		:					List[str],  A		:					Dict,  A		:					Dict="exp",  A		:					str=None,  A		:					List[Any]=False,  A		:					int=False,  A		:					str=False,  ):






			'''simple docstring'''







			a    =			len(references[0]   )
			if any(len(A   ) != references_per_prediction for refs in references   ):
						raise ValueError("Sacrebleu requires the same number of references for each prediction"   )
			a    =			[[refs[i] for refs in references] for i in range(A   )]
			a    =			sacrebleu.corpus_bleu(
			    A,  A,  smooth_method=A,  smooth_value=A,  force=A,  lowercase=A,  use_effective_order=A,  )
			return output.score






@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION    ,       _KWARGS_DESCRIPTION   )
class     snake_case__							(datasets.Metric   ):
				"""simple docstring"""



				def 							__UpperCAmelCase							(      self				:     Any							)					->     List[Any]:
							return datasets.MetricInfo(
							    description=_DESCRIPTION					,      citation=_CITATION					,      inputs_description=_KWARGS_DESCRIPTION					,      features=datasets.Features(
							        {
							            "predictions": datasets.Value("string"					,      id="sequence"							),
							            "references": datasets.Sequence(datasets.Value("string"					,      id="sequence"							)					,      id="references"							),
							        }							)					,      codebase_urls=[
							        "https://github.com/huggingface/transformers/blob/master/src/transformers/data/metrics/squad_metrics.py",
							        "https://github.com/cocoxu/simplification/blob/master/SARI.py",
							        "https://github.com/tensorflow/tensor2tensor/blob/master/tensor2tensor/utils/sari_hook.py",
							        "https://github.com/mjpost/sacreBLEU",
							    ]					,      reference_urls=[
							        "https://www.aclweb.org/anthology/Q16-1029.pdf",
							        "https://github.com/mjpost/sacreBLEU",
							        "https://en.wikipedia.org/wiki/BLEU",
							        "https://towardsdatascience.com/evaluating-text-output-in-nlp-bleu-at-your-own-risk-e8609665a213",
							    ]					,      )





				def 							__UpperCAmelCase							(      self				:     Union[str, Any]					,      __lowerCamelCase				:     Optional[int]					,      __lowerCamelCase				:     str					,      __lowerCamelCase				:     Tuple							)					->     List[str]:
							a    =			{}
							result.update({"sari": compute_sari(sources=__lowerCamelCase					,      predictions=__lowerCamelCase					,      references=__lowerCamelCase							)}							)
							result.update({"sacrebleu": compute_sacrebleu(predictions=__lowerCamelCase					,      references=__lowerCamelCase							)}							)
							result.update({"exact": compute_em(predictions=__lowerCamelCase					,      references=__lowerCamelCase							)}							)
							return result










import flax.linen as nn
import jax.numpy as jnp

from .attention_flax import FlaxTransformeraDModel
from .resnet_flax import FlaxDownsampleaD, FlaxResnetBlockaD, FlaxUpsampleaD




class A  (   nn.Module     ):
      UpperCamelCase__							:  int
      UpperCamelCase__							:  int
      UpperCamelCase__							:  float      =0.0
      UpperCamelCase__							:  int      =1
      UpperCamelCase__							:  int      =1
      UpperCamelCase__							:  bool      =True
      UpperCamelCase__							:  bool      =False
      UpperCamelCase__							:  bool      =False
      UpperCamelCase__							:  bool      =False
      UpperCamelCase__							:  jnp.dtype      =jnp.floataa






      def        lowerCamelCase       (					self						:     Any )					->						Any:
             """simple docstring"""




             _lowerCamelCase       :		str		=[]
             _lowerCamelCase       :		Dict		=[]

             for i in range(self.num_layers ):
                    _lowerCamelCase       :		Union[str, Any]		=self.in_channels if i == 0 else self.out_channels

                    _lowerCamelCase       :		Any		=FlaxResnetBlockaD(
                        in_channels=lowercase_			,   out_channels=self.out_channels			,   dropout_prob=self.dropout			,   dtype=self.dtype			,   )
                    resnets.append(lowercase_ )

                    _lowerCamelCase       :		Dict		=FlaxTransformeraDModel(
                        in_channels=self.out_channels			,   n_heads=self.num_attention_heads			,   d_head=self.out_channels // self.num_attention_heads			,   depth=1			,   use_linear_projection=self.use_linear_projection			,   only_cross_attention=self.only_cross_attention			,   use_memory_efficient_attention=self.use_memory_efficient_attention			,   dtype=self.dtype			,   )
                    attentions.append(lowercase_ )

             _lowerCamelCase       :		Optional[int]		=resnets
             _lowerCamelCase       :		Dict		=attentions

             if self.add_downsample:
                    _lowerCamelCase       :		Union[str, Any]		=FlaxDownsampleaD(self.out_channels			,   dtype=self.dtype )






      def __call__(					self						:     Any			,   lowercase_						:     Optional[Any]			,   lowercase_						:     List[Any]			,   lowercase_						:     Union[str, Any]			,   lowercase_						:     List[str]=True )					->						Union[str, Any]:
             """simple docstring"""




             _lowerCamelCase       :		Tuple		=()

             for resnet, attn in zip(self.resnets			,   self.attentions ):
                    _lowerCamelCase       :		Union[str, Any]		=resnet(lowercase_			,   lowercase_			,   deterministic=lowercase_ )
                    _lowerCamelCase       :		Union[str, Any]		=attn(lowercase_			,   lowercase_			,   deterministic=lowercase_ )
                    output_states += (hidden_states,)

             if self.add_downsample:
                    _lowerCamelCase       :		Optional[int]		=self.downsamplers_a(lowercase_ )
                    output_states += (hidden_states,)

             return hidden_states, output_states




class A  (   nn.Module     ):
      UpperCamelCase__							:  int
      UpperCamelCase__							:  int
      UpperCamelCase__							:  float      =0.0
      UpperCamelCase__							:  int      =1
      UpperCamelCase__							:  bool      =True
      UpperCamelCase__							:  jnp.dtype      =jnp.floataa






      def        lowerCamelCase       (					self						:     Optional[int] )					->						int:
             """simple docstring"""




             _lowerCamelCase       :		str		=[]

             for i in range(self.num_layers ):
                    _lowerCamelCase       :		Tuple		=self.in_channels if i == 0 else self.out_channels

                    _lowerCamelCase       :		Any		=FlaxResnetBlockaD(
                        in_channels=lowercase_			,   out_channels=self.out_channels			,   dropout_prob=self.dropout			,   dtype=self.dtype			,   )
                    resnets.append(lowercase_ )
             _lowerCamelCase       :		Union[str, Any]		=resnets

             if self.add_downsample:
                    _lowerCamelCase       :		List[str]		=FlaxDownsampleaD(self.out_channels			,   dtype=self.dtype )






      def __call__(					self						:     Any			,   lowercase_						:     Dict			,   lowercase_						:     Union[str, Any]			,   lowercase_						:     Optional[Any]=True )					->						Dict:
             """simple docstring"""




             _lowerCamelCase       :		Optional[int]		=()

             for resnet in self.resnets:
                    _lowerCamelCase       :		Tuple		=resnet(lowercase_			,   lowercase_			,   deterministic=lowercase_ )
                    output_states += (hidden_states,)

             if self.add_downsample:
                    _lowerCamelCase       :		Tuple		=self.downsamplers_a(lowercase_ )
                    output_states += (hidden_states,)

             return hidden_states, output_states




class A  (   nn.Module     ):
      UpperCamelCase__							:  int
      UpperCamelCase__							:  int
      UpperCamelCase__							:  int
      UpperCamelCase__							:  float      =0.0
      UpperCamelCase__							:  int      =1
      UpperCamelCase__							:  int      =1
      UpperCamelCase__							:  bool      =True
      UpperCamelCase__							:  bool      =False
      UpperCamelCase__							:  bool      =False
      UpperCamelCase__							:  bool      =False
      UpperCamelCase__							:  jnp.dtype      =jnp.floataa






      def        lowerCamelCase       (					self						:     Dict )					->						Tuple:
             """simple docstring"""




             _lowerCamelCase       :		str		=[]
             _lowerCamelCase       :		List[str]		=[]

             for i in range(self.num_layers ):
                    _lowerCamelCase       :		List[str]		=self.in_channels if (i == self.num_layers - 1) else self.out_channels
                    _lowerCamelCase       :		Tuple		=self.prev_output_channel if i == 0 else self.out_channels

                    _lowerCamelCase       :		List[str]		=FlaxResnetBlockaD(
                        in_channels=resnet_in_channels + res_skip_channels			,   out_channels=self.out_channels			,   dropout_prob=self.dropout			,   dtype=self.dtype			,   )
                    resnets.append(lowercase_ )

                    _lowerCamelCase       :		Tuple		=FlaxTransformeraDModel(
                        in_channels=self.out_channels			,   n_heads=self.num_attention_heads			,   d_head=self.out_channels // self.num_attention_heads			,   depth=1			,   use_linear_projection=self.use_linear_projection			,   only_cross_attention=self.only_cross_attention			,   use_memory_efficient_attention=self.use_memory_efficient_attention			,   dtype=self.dtype			,   )
                    attentions.append(lowercase_ )

             _lowerCamelCase       :		int		=resnets
             _lowerCamelCase       :		Dict		=attentions

             if self.add_upsample:
                    _lowerCamelCase       :		str		=FlaxUpsampleaD(self.out_channels			,   dtype=self.dtype )






      def __call__(					self						:     Optional[Any]			,   lowercase_						:     Any			,   lowercase_						:     Any			,   lowercase_						:     List[Any]			,   lowercase_						:     Dict			,   lowercase_						:     Union[str, Any]=True )					->						Optional[int]:
             """simple docstring"""




             for resnet, attn in zip(self.resnets			,   self.attentions ):
                    # pop res hidden states
                    _lowerCamelCase       :		Optional[int]		=res_hidden_states_tuple[-1]
                    _lowerCamelCase       :		Union[str, Any]		=res_hidden_states_tuple[:-1]
                    _lowerCamelCase       :		Any		=jnp.concatenate((hidden_states, res_hidden_states)			,   axis=-1 )

                    _lowerCamelCase       :		Optional[Any]		=resnet(lowercase_			,   lowercase_			,   deterministic=lowercase_ )
                    _lowerCamelCase       :		List[Any]		=attn(lowercase_			,   lowercase_			,   deterministic=lowercase_ )

             if self.add_upsample:
                    _lowerCamelCase       :		Optional[Any]		=self.upsamplers_a(lowercase_ )

             return hidden_states




class A  (   nn.Module     ):
      UpperCamelCase__							:  int
      UpperCamelCase__							:  int
      UpperCamelCase__							:  int
      UpperCamelCase__							:  float      =0.0
      UpperCamelCase__							:  int      =1
      UpperCamelCase__							:  bool      =True
      UpperCamelCase__							:  jnp.dtype      =jnp.floataa






      def        lowerCamelCase       (					self						:     List[Any] )					->						Dict:
             """simple docstring"""




             _lowerCamelCase       :		List[str]		=[]

             for i in range(self.num_layers ):
                    _lowerCamelCase       :		Tuple		=self.in_channels if (i == self.num_layers - 1) else self.out_channels
                    _lowerCamelCase       :		int		=self.prev_output_channel if i == 0 else self.out_channels

                    _lowerCamelCase       :		str		=FlaxResnetBlockaD(
                        in_channels=resnet_in_channels + res_skip_channels			,   out_channels=self.out_channels			,   dropout_prob=self.dropout			,   dtype=self.dtype			,   )
                    resnets.append(lowercase_ )

             _lowerCamelCase       :		str		=resnets

             if self.add_upsample:
                    _lowerCamelCase       :		List[str]		=FlaxUpsampleaD(self.out_channels			,   dtype=self.dtype )






      def __call__(					self						:     List[str]			,   lowercase_						:     str			,   lowercase_						:     Dict			,   lowercase_						:     Union[str, Any]			,   lowercase_						:     Any=True )					->						int:
             """simple docstring"""




             for resnet in self.resnets:
                    # pop res hidden states
                    _lowerCamelCase       :		List[str]		=res_hidden_states_tuple[-1]
                    _lowerCamelCase       :		str		=res_hidden_states_tuple[:-1]
                    _lowerCamelCase       :		List[str]		=jnp.concatenate((hidden_states, res_hidden_states)			,   axis=-1 )

                    _lowerCamelCase       :		Optional[Any]		=resnet(lowercase_			,   lowercase_			,   deterministic=lowercase_ )

             if self.add_upsample:
                    _lowerCamelCase       :		Union[str, Any]		=self.upsamplers_a(lowercase_ )

             return hidden_states




class A  (   nn.Module     ):
      UpperCamelCase__							:  int
      UpperCamelCase__							:  float      =0.0
      UpperCamelCase__							:  int      =1
      UpperCamelCase__							:  int      =1
      UpperCamelCase__							:  bool      =False
      UpperCamelCase__							:  bool      =False
      UpperCamelCase__							:  jnp.dtype      =jnp.floataa






      def        lowerCamelCase       (					self						:     int )					->						Tuple:
             """simple docstring"""




             _lowerCamelCase       :		Optional[Any]		=[
                 FlaxResnetBlockaD(
                     in_channels=self.in_channels			,   out_channels=self.in_channels			,   dropout_prob=self.dropout			,   dtype=self.dtype			,   )
             ]

             _lowerCamelCase       :		Any		=[]

             for _ in range(self.num_layers ):
                    _lowerCamelCase       :		Optional[int]		=FlaxTransformeraDModel(
                        in_channels=self.in_channels			,   n_heads=self.num_attention_heads			,   d_head=self.in_channels // self.num_attention_heads			,   depth=1			,   use_linear_projection=self.use_linear_projection			,   use_memory_efficient_attention=self.use_memory_efficient_attention			,   dtype=self.dtype			,   )
                    attentions.append(lowercase_ )

                    _lowerCamelCase       :		Tuple		=FlaxResnetBlockaD(
                        in_channels=self.in_channels			,   out_channels=self.in_channels			,   dropout_prob=self.dropout			,   dtype=self.dtype			,   )
                    resnets.append(lowercase_ )

             _lowerCamelCase       :		List[Any]		=resnets
             _lowerCamelCase       :		List[str]		=attentions






      def __call__(					self						:     Optional[int]			,   lowercase_						:     List[Any]			,   lowercase_						:     Dict			,   lowercase_						:     Tuple			,   lowercase_						:     List[str]=True )					->						int:
             """simple docstring"""




             _lowerCamelCase       :		Dict		=self.resnets[0](lowercase_			,   lowercase_ )
             for attn, resnet in zip(self.attentions			,   self.resnets[1:] ):
                    _lowerCamelCase       :		Tuple		=attn(lowercase_			,   lowercase_			,   deterministic=lowercase_ )
                    _lowerCamelCase       :		List[str]		=resnet(lowercase_			,   lowercase_			,   deterministic=lowercase_ )

             return hidden_states


