






"""simple docstring"""
import inspect
import unittest
from typing import List

import numpy as np

from transformers import EfficientFormerConfig
from transformers.testing_utils import require_tf, require_vision, slow
from transformers.utils import cached_property, is_tf_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
			import tensorflow as tf

			from transformers import (
			    TFEfficientFormerForImageClassification,
			    TFEfficientFormerForImageClassificationWithTeacher,
			    TFEfficientFormerModel,
			)
			from transformers.models.efficientformer.modeling_tf_efficientformer import (
			    TF_EFFICIENTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
			)


if is_vision_available():
			from PIL import Image

			from transformers import EfficientFormerImageProcessor







class 			UpperCamelCase_       :





	def __init__(      self					: Optional[int]	,	lowerCAmelCase_					: List[str]	,	lowerCAmelCase_					: int = 13	,	lowerCAmelCase_					: int = 64	,	lowerCAmelCase_					: int = 2	,	lowerCAmelCase_					: int = 3	,	lowerCAmelCase_					: int = 3	,	lowerCAmelCase_					: bool = True	,	lowerCAmelCase_					: bool = True	,	lowerCAmelCase_					: int = 128	,	lowerCAmelCase_					: str=[16, 32, 64, 128]	,	lowerCAmelCase_					: int = 7	,	lowerCAmelCase_					: int = 4	,	lowerCAmelCase_					: int = 37	,	lowerCAmelCase_					: str = "gelu"	,	lowerCAmelCase_					: float = 0.1	,	lowerCAmelCase_					: float = 0.1	,	lowerCAmelCase_					: int = 10	,	lowerCAmelCase_					: float = 0.0_2	,	lowerCAmelCase_					: int = 2	,	lowerCAmelCase_					: int = 1	,	lowerCAmelCase_					: int = 128	,	lowerCAmelCase_					: List[int] = [2, 2, 2, 2]	,	lowerCAmelCase_					: int = 2	,	lowerCAmelCase_					: int = 2	,	)						->			Tuple:
				UpperCAmelCase_     : Dict			     =					parent
				UpperCAmelCase_     : Optional[Any]			     =					batch_size
				UpperCAmelCase_     : Dict			     =					image_size
				UpperCAmelCase_     : Union[str, Any]			     =					patch_size
				UpperCAmelCase_     : List[Any]			     =					num_channels
				UpperCAmelCase_     : Optional[int]			     =					is_training
				UpperCAmelCase_     : Optional[int]			     =					use_labels
				UpperCAmelCase_     : Optional[Any]			     =					hidden_size
				UpperCAmelCase_     : Optional[Any]			     =					num_hidden_layers
				UpperCAmelCase_     : Optional[int]			     =					num_attention_heads
				UpperCAmelCase_     : Optional[int]			     =					intermediate_size
				UpperCAmelCase_     : Any			     =					hidden_act
				UpperCAmelCase_     : List[Any]			     =					hidden_dropout_prob
				UpperCAmelCase_     : Optional[Any]			     =					attention_probs_dropout_prob
				UpperCAmelCase_     : int			     =					type_sequence_label_size
				UpperCAmelCase_     : Optional[int]			     =					initializer_range
				UpperCAmelCase_     : Tuple			     =					encoder_stride
				UpperCAmelCase_     : List[Any]			     =					num_attention_outputs
				UpperCAmelCase_     : int			     =					embed_dim
				UpperCAmelCase_     : Dict			     =					embed_dim + 1
				UpperCAmelCase_     : List[Any]			     =					resolution
				UpperCAmelCase_     : List[str]			     =					depths
				UpperCAmelCase_     : Optional[Any]			     =					hidden_sizes
				UpperCAmelCase_     : Optional[Any]			     =					dim
				UpperCAmelCase_     : Any			     =					mlp_expansion_ratio





	def      _SCREAMING_SNAKE_CASE      (      self					: str						)						->			Union[str, Any]:
				UpperCAmelCase_     : Optional[Any]			     =					floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]						)

				UpperCAmelCase_     : Optional[Any]			     =					None
				if self.use_labels:
							UpperCAmelCase_     : Dict			     =					ids_tensor([self.batch_size]	,	self.type_sequence_label_size						)

				UpperCAmelCase_     : str			     =					self.get_config()

				return config, pixel_values, labels





	def      _SCREAMING_SNAKE_CASE      (      self					: List[Any]						)						->			List[str]:
				return EfficientFormerConfig(
				    image_size=self.image_size	,	patch_size=self.patch_size	,	num_channels=self.num_channels	,	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	,	is_decoder=lowerCAmelCase_	,	initializer_range=self.initializer_range	,	encoder_stride=self.encoder_stride	,	resolution=self.resolution	,	depths=self.depths	,	hidden_sizes=self.hidden_sizes	,	dim=self.dim	,	mlp_expansion_ratio=self.mlp_expansion_ratio	,	)





	def      _SCREAMING_SNAKE_CASE      (      self					: Tuple	,	lowerCAmelCase_					: str	,	lowerCAmelCase_					: str	,	lowerCAmelCase_					: str						)						->			Optional[Any]:
				UpperCAmelCase_     : List[str]			     =					TFEfficientFormerModel(config=lowerCAmelCase_						)
				UpperCAmelCase_     : List[str]			     =					model(lowerCAmelCase_	,	training=lowerCAmelCase_						)
				self.parent.assertEqual(result.last_hidden_state.shape	,	(self.batch_size, self.seq_length, self.hidden_size)						)





	def      _SCREAMING_SNAKE_CASE      (      self					: Dict	,	lowerCAmelCase_					: Optional[Any]	,	lowerCAmelCase_					: Optional[Any]	,	lowerCAmelCase_					: Any						)						->			Any:
				UpperCAmelCase_     : int			     =					self.type_sequence_label_size
				UpperCAmelCase_     : Optional[int]			     =					TFEfficientFormerForImageClassification(lowerCAmelCase_						)
				UpperCAmelCase_     : Any			     =					model(lowerCAmelCase_	,	labels=lowerCAmelCase_	,	training=lowerCAmelCase_						)
				self.parent.assertEqual(result.logits.shape	,	(self.batch_size, self.type_sequence_label_size)						)

				# test greyscale images
				UpperCAmelCase_     : List[Any]			     =					1
				UpperCAmelCase_     : List[str]			     =					TFEfficientFormerForImageClassification(lowerCAmelCase_						)

				UpperCAmelCase_     : Tuple			     =					floats_tensor([self.batch_size, 1, self.image_size, self.image_size]						)
				UpperCAmelCase_     : Optional[Any]			     =					model(lowerCAmelCase_	,	labels=lowerCAmelCase_						)
				self.parent.assertEqual(result.logits.shape	,	(self.batch_size, self.type_sequence_label_size)						)





	def      _SCREAMING_SNAKE_CASE      (      self					: Dict						)						->			List[str]:
				UpperCAmelCase_     : List[str]			     =					self.prepare_config_and_inputs()
				UpperCAmelCase_     ,	UpperCAmelCase_     ,	UpperCAmelCase_     : List[Any]			     =					config_and_inputs
				UpperCAmelCase_     : str			     =					{"pixel_values": pixel_values}
				return config, inputs_dict







@require_tf
class 			UpperCamelCase_       (__A				,						__A				,						unittest.TestCase     ):
	__magic_name__	      =				(
	    (
	        TFEfficientFormerModel,
	        TFEfficientFormerForImageClassificationWithTeacher,
	        TFEfficientFormerForImageClassification,
	    )
	    if is_tf_available()
	    else ()
	)
	__magic_name__	      =				(
	    {
	        '''feature-extraction''': TFEfficientFormerModel,
	        '''image-classification''': (
	            TFEfficientFormerForImageClassification,
	            TFEfficientFormerForImageClassificationWithTeacher,
	        ),
	    }
	    if is_tf_available()
	    else {}
	)

	__magic_name__	      =				False

	__magic_name__	      =				False
	__magic_name__	      =				False
	__magic_name__	      =				False
	__magic_name__	      =				False





	def      _SCREAMING_SNAKE_CASE      (      self					: Dict						)						->			Tuple:
				UpperCAmelCase_     : Tuple			     =					TFEfficientFormerModelTester(self						)
				UpperCAmelCase_     : Dict			     =					ConfigTester(
				    self	,	config_class=lowerCAmelCase_	,	has_text_modality=lowerCAmelCase_	,	hidden_size=37						)





	def      _SCREAMING_SNAKE_CASE      (      self					: Union[str, Any]						)						->			Optional[Any]:
				self.config_tester.run_common_tests()





	@unittest.skip(reason="EfficientFormer does not use inputs_embeds"						)
	def      _SCREAMING_SNAKE_CASE      (      self					: List[str]						)						->			List[Any]:
				pass





	@unittest.skip(reason="EfficientFormer does not support input and output embeddings"						)
	def      _SCREAMING_SNAKE_CASE      (      self					: Union[str, Any]						)						->			Optional[int]:
				pass





	def      _SCREAMING_SNAKE_CASE      (      self					: Optional[int]						)						->			Tuple:
				UpperCAmelCase_     ,	UpperCAmelCase_     : Union[str, Any]			     =					self.model_tester.prepare_config_and_inputs_for_common()

				for model_class in self.all_model_classes:
							UpperCAmelCase_     : Optional[int]			     =					model_class(lowerCAmelCase_						)
							UpperCAmelCase_     : List[str]			     =					inspect.signature(model.call						)
							# signature.parameters is an OrderedDict => so arg_names order is deterministic
							UpperCAmelCase_     : List[Any]			     =					[*signature.parameters.keys()]

							UpperCAmelCase_     : Tuple			     =					["pixel_values"]
							self.assertListEqual(arg_names[:1]	,	lowerCAmelCase_						)





	def      _SCREAMING_SNAKE_CASE      (      self					: str						)						->			int:
				def check_hidden_states_output(lowerCAmelCase_					: Optional[int]	,	lowerCAmelCase_					: List[str]	,	lowerCAmelCase_					: str						):
							UpperCAmelCase_     : List[Any]			     =					model_class(lowerCAmelCase_						)

							UpperCAmelCase_     : Dict			     =					model(**self._prepare_for_class(lowerCAmelCase_	,	lowerCAmelCase_						)	,	training=lowerCAmelCase_						)
							UpperCAmelCase_     : Optional[Any]			     =					outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

							UpperCAmelCase_     : List[str]			     =					getattr(
							    self.model_tester	,	"expected_num_hidden_layers"	,	self.model_tester.num_hidden_layers + 1						)
							self.assertEqual(len(lowerCAmelCase_						)	,	lowerCAmelCase_						)

							if hasattr(self.model_tester	,	"encoder_seq_length"						):
										UpperCAmelCase_     : Tuple			     =					self.model_tester.encoder_seq_length
										if hasattr(self.model_tester	,	"chunk_length"						) and self.model_tester.chunk_length > 1:
													UpperCAmelCase_     : int			     =					seq_length * self.model_tester.chunk_length
							else:
										UpperCAmelCase_     : List[str]			     =					self.model_tester.seq_length

							self.assertListEqual(
							    list(hidden_states[-1].shape[-2:]						)	,	[seq_length, self.model_tester.hidden_size]	,	)

							if config.is_encoder_decoder:
										UpperCAmelCase_     : List[str]			     =					outputs.decoder_hidden_states

										self.asseretIsInstance(lowerCAmelCase_	,	(list, tuple)						)
										self.assertEqual(len(lowerCAmelCase_						)	,	lowerCAmelCase_						)
										UpperCAmelCase_     : Dict			     =					getattr(self.model_tester	,	"seq_length"	,	lowerCAmelCase_						)
										UpperCAmelCase_     : List[str]			     =					getattr(self.model_tester	,	"decoder_seq_length"	,	lowerCAmelCase_						)

										self.assertListEqual(
										    list(hidden_states[-1].shape[-2:]						)	,	[decoder_seq_length, self.model_tester.hidden_size]	,	)

				UpperCAmelCase_     ,	UpperCAmelCase_     : Any			     =					self.model_tester.prepare_config_and_inputs_for_common()

				for model_class in self.all_model_classes:
							UpperCAmelCase_     : str			     =					True
							check_hidden_states_output(lowerCAmelCase_	,	lowerCAmelCase_	,	lowerCAmelCase_						)

							# check that output_hidden_states also work using config
							del inputs_dict["output_hidden_states"]
							UpperCAmelCase_     : Optional[int]			     =					True

							check_hidden_states_output(lowerCAmelCase_	,	lowerCAmelCase_	,	lowerCAmelCase_						)





	def      _SCREAMING_SNAKE_CASE      (      self					: Any	,	lowerCAmelCase_					: Union[str, Any]	,	lowerCAmelCase_					: Dict	,	lowerCAmelCase_					: Optional[Any]=False						)						->			Any:
				UpperCAmelCase_     : Any			     =					super()._prepare_for_class(lowerCAmelCase_	,	lowerCAmelCase_	,	return_labels=lowerCAmelCase_						)

				if return_labels:
							if model_class.__name__ == "TFEfficientFormerForImageClassificationWithTeacher":
										del inputs_dict["labels"]

				return inputs_dict





	def      _SCREAMING_SNAKE_CASE      (      self					: List[Any]						)						->			Tuple:
				UpperCAmelCase_     : Tuple			     =					self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_model(*lowerCAmelCase_						)





	@unittest.skip(reason="EfficientFormer does not implement masked image modeling yet"						)
	def      _SCREAMING_SNAKE_CASE      (      self					: Optional[Any]						)						->			Tuple:
				UpperCAmelCase_     : Tuple			     =					self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_for_masked_image_modeling(*lowerCAmelCase_						)





	def      _SCREAMING_SNAKE_CASE      (      self					: int						)						->			List[Any]:
				UpperCAmelCase_     : List[Any]			     =					self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_for_image_classification(*lowerCAmelCase_						)





	@slow
	def      _SCREAMING_SNAKE_CASE      (      self					: List[Any]						)						->			Optional[int]:
				for model_name in TF_EFFICIENTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
							UpperCAmelCase_     : Dict			     =					TFEfficientFormerModel.from_pretrained(lowerCAmelCase_						)
							self.assertIsNotNone(lowerCAmelCase_						)





	def      _SCREAMING_SNAKE_CASE      (      self					: Tuple						)						->			Optional[int]:
				UpperCAmelCase_     ,	UpperCAmelCase_     : int			     =					self.model_tester.prepare_config_and_inputs_for_common()
				UpperCAmelCase_     : List[Any]			     =					True

				UpperCAmelCase_     : Optional[Any]			     =					getattr(self.model_tester	,	"seq_length"	,	lowerCAmelCase_						)
				UpperCAmelCase_     : Optional[Any]			     =					getattr(self.model_tester	,	"encoder_seq_length"	,	lowerCAmelCase_						)
				UpperCAmelCase_     : Tuple			     =					getattr(self.model_tester	,	"key_length"	,	lowerCAmelCase_						)
				UpperCAmelCase_     : Dict			     =					getattr(self.model_tester	,	"chunk_length"	,	lowerCAmelCase_						)

				if chunk_length is not None and hasattr(self.model_tester	,	"num_hashes"						):
							UpperCAmelCase_     : Tuple			     =					encoder_seq_length * self.model_tester.num_hashes

				for model_class in self.all_model_classes:
							UpperCAmelCase_     : Optional[Any]			     =					True
							UpperCAmelCase_     : Optional[int]			     =					False
							UpperCAmelCase_     : Optional[Any]			     =					True
							UpperCAmelCase_     : Any			     =					model_class(lowerCAmelCase_						)

							UpperCAmelCase_     : Union[str, Any]			     =					model(**self._prepare_for_class(lowerCAmelCase_	,	lowerCAmelCase_						)	,	training=lowerCAmelCase_						)
							UpperCAmelCase_     : str			     =					outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions
							self.assertEqual(len(lowerCAmelCase_						)	,	self.model_tester.num_attention_outputs						)

							# check that output_attentions also work using config
							del inputs_dict["output_attentions"]
							UpperCAmelCase_     : Any			     =					True
							UpperCAmelCase_     : Tuple			     =					model_class(lowerCAmelCase_						)
							UpperCAmelCase_     : Dict			     =					model(**self._prepare_for_class(lowerCAmelCase_	,	lowerCAmelCase_						)	,	training=lowerCAmelCase_						)

							UpperCAmelCase_     : int			     =					outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions
							self.assertEqual(len(lowerCAmelCase_						)	,	self.model_tester.num_attention_outputs						)

							if chunk_length is not None:
										self.assertListEqual(
										    list(attentions[0].shape[-4:]						)	,	[self.model_tester.num_attention_heads, encoder_seq_length, chunk_length, encoder_key_length]	,	)
							else:
										self.assertListEqual(
										    list(attentions[0].shape[-3:]						)	,	[self.model_tester.num_attention_heads, encoder_seq_length, encoder_key_length]	,	)





	def      _SCREAMING_SNAKE_CASE      (      self					: Any						)						->			Optional[Any]:
				# We use a simplified version of this test for EfficientFormer because it requires training=False
				# and Keras refuses to let us force that during functional construction
				UpperCAmelCase_     ,	UpperCAmelCase_     : Tuple			     =					self.model_tester.prepare_config_and_inputs_for_common()

				for model_class in self.all_model_classes:
							# Prepare our model
							UpperCAmelCase_     : List[Any]			     =					model_class(lowerCAmelCase_						)
							# These are maximally general inputs for the model, with multiple None dimensions
							# Hopefully this will catch any conditionals that fail for flexible shapes
							UpperCAmelCase_     : str			     =					{
							    key: tf.keras.Input(shape=val.shape[1:]	,	dtype=val.dtype	,	name=lowerCAmelCase_						)
							    for key, val in model.input_signature.items()
							    if key in model.dummy_inputs
							}
							UpperCAmelCase_     : List[Any]			     =					model(lowerCAmelCase_						)
							self.assertTrue(outputs_dict is not None						)





def 				snake_case      (   ):
			UpperCAmelCase_     : Union[str, Any]			     =					Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"						)
			return image







@require_tf
@require_vision
class 			UpperCamelCase_       (unittest.TestCase     ):





	@cached_property
	def      _SCREAMING_SNAKE_CASE      (      self					: Dict						)						->			Optional[int]:
				return (
				    EfficientFormerImageProcessor.from_pretrained("snap-research/efficientformer-l1-300"						)
				    if is_vision_available()
				    else None
				)





	@slow
	def      _SCREAMING_SNAKE_CASE      (      self					: List[Any]						)						->			List[str]:
				UpperCAmelCase_     : Optional[int]			     =					TFEfficientFormerForImageClassification.from_pretrained("snap-research/efficientformer-l1-300"						)
				UpperCAmelCase_     : Optional[int]			     =					self.default_image_processor
				UpperCAmelCase_     : Optional[int]			     =					prepare_img()
				UpperCAmelCase_     : Optional[Any]			     =					image_processor(images=lowerCAmelCase_	,	return_tensors="tf"						)
				# forward pass
				UpperCAmelCase_     : Optional[Any]			     =					model(**lowerCAmelCase_	,	training=lowerCAmelCase_						)
				# verify the logits
				UpperCAmelCase_     : Any			     =					tf.TensorShape((1, 1_000)						)
				self.assertEqual(outputs.logits.shape	,	lowerCAmelCase_						)
				UpperCAmelCase_     : Union[str, Any]			     =					tf.constant([-0.0_5_5_5, 0.4_8_2_5, -0.0_8_5_2]						)
				self.assertTrue(np.allclose(outputs.logits[0, :3]	,	lowerCAmelCase_	,	atol=1e-4						)						)





	@slow
	def      _SCREAMING_SNAKE_CASE      (      self					: Tuple						)						->			Any:
				UpperCAmelCase_     : Optional[Any]			     =					TFEfficientFormerForImageClassificationWithTeacher.from_pretrained(
				    "snap-research/efficientformer-l1-300"						)
				UpperCAmelCase_     : int			     =					self.default_image_processor
				UpperCAmelCase_     : List[str]			     =					prepare_img()
				UpperCAmelCase_     : List[str]			     =					image_processor(images=lowerCAmelCase_	,	return_tensors="tf"						)
				# forward pass
				UpperCAmelCase_     : Union[str, Any]			     =					model(**lowerCAmelCase_	,	training=lowerCAmelCase_						)
				# verify the logits
				UpperCAmelCase_     : List[Any]			     =					tf.TensorShape((1, 1_000)						)
				self.assertEqual(outputs.logits.shape	,	lowerCAmelCase_						)
				UpperCAmelCase_     : List[str]			     =					tf.constant([-0.1_3_1_2, 0.4_3_5_3, -1.0_4_9_9]						)
				self.assertTrue(np.allclose(outputs.logits[0, :3]	,	lowerCAmelCase_	,	atol=1e-4						)						)











"""simple docstring"""
import torch
from torch import nn
from transformers import CLIPPreTrainedModel, CLIPVisionModel

from ...models.attention import BasicTransformerBlock
from ...utils import logging


lowerCamelCase_					=      logging.get_logger(__name__)  # pylint: disable=invalid-name







class 			UpperCamelCase_       (__A     ):





	def __init__(      self					: Optional[int]	,	lowerCAmelCase_					: List[Any]	,	lowerCAmelCase_					: Dict=768						)						->			List[Any]:
				super().__init__(lowerCAmelCase_						)
				UpperCAmelCase_     : Dict			     =					proj_size

				UpperCAmelCase_     : Optional[Any]			     =					CLIPVisionModel(lowerCAmelCase_						)
				UpperCAmelCase_     : Tuple			     =					PaintByExampleMapper(lowerCAmelCase_						)
				UpperCAmelCase_     : str			     =					nn.LayerNorm(config.hidden_size						)
				UpperCAmelCase_     : List[Any]			     =					nn.Linear(config.hidden_size	,	self.proj_size						)

				# uncondition for scaling
				UpperCAmelCase_     : Optional[int]			     =					nn.Parameter(torch.randn((1, 1, self.proj_size)						)						)





	def      _SCREAMING_SNAKE_CASE      (      self					: int	,	lowerCAmelCase_					: int	,	lowerCAmelCase_					: Dict=False						)						->			Union[str, Any]:
				UpperCAmelCase_     : Optional[int]			     =					self.model(pixel_values=lowerCAmelCase_						)
				UpperCAmelCase_     : Optional[Any]			     =					clip_output.pooler_output
				UpperCAmelCase_     : List[Any]			     =					self.mapper(latent_states[:, None]						)
				UpperCAmelCase_     : List[str]			     =					self.final_layer_norm(lowerCAmelCase_						)
				UpperCAmelCase_     : Union[str, Any]			     =					self.proj_out(lowerCAmelCase_						)
				if return_uncond_vector:
							return latent_states, self.uncond_vector

				return latent_states







class 			UpperCamelCase_       (nn.Module     ):





	def __init__(      self					: Dict	,	lowerCAmelCase_					: Union[str, Any]						)						->			Tuple:
				super().__init__()
				UpperCAmelCase_     : List[Any]			     =					(config.num_hidden_layers + 1) // 5
				UpperCAmelCase_     : Optional[Any]			     =					config.hidden_size
				UpperCAmelCase_     : List[str]			     =					1
				UpperCAmelCase_     : Union[str, Any]			     =					nn.ModuleList(
				    [
				        BasicTransformerBlock(lowerCAmelCase_	,	lowerCAmelCase_	,	lowerCAmelCase_	,	activation_fn="gelu"	,	attention_bias=lowerCAmelCase_						)
				        for _ in range(lowerCAmelCase_						)
				    ]						)





	def      _SCREAMING_SNAKE_CASE      (      self					: List[str]	,	lowerCAmelCase_					: List[str]						)						->			str:
				for block in self.blocks:
							UpperCAmelCase_     : int			     =					block(lowerCAmelCase_						)

				return hidden_states



