






'''simple docstring'''



import csv
from collections import defaultdict
from dataclasses import dataclass, field
from typing import List, Optional

import matplotlib.pyplot as plt
import numpy as np
from matplotlib.ticker import ScalarFormatter

from transformers import HfArgumentParser

def   lowerCamelCase__       (      a__=None			,      a__=None)		->    Optional[Any]:



    """simple docstring"""







    return field(default_factory=lambda: default			,      metadata=a__)

@dataclass
class 			SCREAMING_SNAKE_CASE					:






      '''simple docstring'''






      SCREAMING_SNAKE_CASE__ :				str    =				field(
          metadata={'''help''': '''The csv file to plot.'''}      ,)
      SCREAMING_SNAKE_CASE__ :				bool    =				field(
          default=lowercase_      ,metadata={'''help''': '''Whether to plot along batch size or sequence length. Defaults to sequence length.'''}      ,)
      SCREAMING_SNAKE_CASE__ :				bool    =				field(
          default=lowercase_      ,metadata={'''help''': '''Whether the csv file has time results or memory results. Defaults to memory results.'''}      ,)
      SCREAMING_SNAKE_CASE__ :				bool    =				field(
          default=lowercase_      ,metadata={'''help''': '''Disable logarithmic scale when plotting'''}      ,)
      SCREAMING_SNAKE_CASE__ :				bool    =				field(
          default=lowercase_      ,metadata={
              '''help''': '''Whether the csv file has training results or inference results. Defaults to inference results.'''
          }      ,)
      SCREAMING_SNAKE_CASE__ :				Optional[str]    =				field(
          default=lowercase_      ,metadata={'''help''': '''Filename under which the plot will be saved. If unused no plot is saved.'''}      ,)
      SCREAMING_SNAKE_CASE__ :				Optional[List[str]]    =				list_field(
          default=lowercase_      ,metadata={'''help''': '''List of model names that are used instead of the ones in the csv file.'''}					)



def   lowerCamelCase__       (      a__)		->    List[Any]:



    """simple docstring"""







    try:
        int(a__)
        return True
    except ValueError:
        return False

def   lowerCamelCase__       (      a__)		->    List[Any]:



    """simple docstring"""







    try:
        float(a__)
        return True
    except ValueError:
        return False

class 			SCREAMING_SNAKE_CASE					:






      '''simple docstring'''






      def __init__(					self :		Union[str, Any]     ,					snake_case :		List[str]   ):



          """simple docstring"""





          _snake_case : Tuple												=		args
          _snake_case : Union[str, Any]												=		defaultdict(lambda: {"bsz": [], "seq_len": [], "result": {}}   )

          with open(self.args.csv_file     ,					newline=''   ) as csv_file:
              _snake_case : Any												=		csv.DictReader(snake_case   )
              for row in reader:
                  _snake_case : List[Any]												=		row['model']
                  self.result_dict[model_name]["bsz"].append(int(row['batch_size']   )   )
                  self.result_dict[model_name]["seq_len"].append(int(row['sequence_length']   )   )
                  if can_convert_to_int(row['result']   ):
                      # value is not None
                      _snake_case : Optional[int]												=		int(row['result']   )
                  elif can_convert_to_float(row['result']   ):
                      # value is not None
                      _snake_case : Tuple												=		float(row['result']   )




      def 	__UpperCAmelCase			(					self :		Optional[Any]   ):



          """simple docstring"""





          _snake_case : str												=		plt.subplots()
          _snake_case : int												=		'Time usage' if self.args.is_time else 'Memory usage'
          _snake_case : Dict												=		title_str + ' for training' if self.args.is_train else title_str + ' for inference'

          if not self.args.no_log_scale:
              # set logarithm scales
              ax.set_xscale('log'   )
              ax.set_yscale('log'   )

          for axis in [ax.xaxis, ax.yaxis]:
              axis.set_major_formatter(ScalarFormatter()   )

          for model_name_idx, model_name in enumerate(self.result_dict.keys()   ):
              _snake_case : Tuple												=		sorted(set(self.result_dict[model_name]['bsz']   )   )
              _snake_case : Optional[int]												=		sorted(set(self.result_dict[model_name]['seq_len']   )   )
              _snake_case : Optional[int]												=		self.result_dict[model_name]['result']

              (_snake_case) : Dict												=		(
                  (batch_sizes, sequence_lengths) if self.args.plot_along_batch else (sequence_lengths, batch_sizes)
              )

              _snake_case : Any												=		(
                  model_name if self.args.short_model_names is None else self.args.short_model_names[model_name_idx]
              )

              for inner_loop_value in inner_loop_array:
                  if self.args.plot_along_batch:
                      _snake_case : Union[str, Any]												=		np.asarray(
                          [results[(x, inner_loop_value)] for x in x_axis_array if (x, inner_loop_value) in results]     ,					dtype=snake_case     ,					)
                  else:
                      _snake_case : Union[str, Any]												=		np.asarray(
                          [results[(inner_loop_value, x)] for x in x_axis_array if (inner_loop_value, x) in results]     ,					dtype=np.floataa     ,					)

                  (_snake_case) : Any												=		(
                      ('batch_size', 'len') if self.args.plot_along_batch else ('in #tokens', 'bsz')
                  )

                  _snake_case : List[Any]												=		np.asarray(snake_case     ,					snake_case   )[: len(snake_case   )]
                  plt.scatter(
                      snake_case     ,					snake_case     ,					label=F"""{label_model_name} - {inner_loop_label}: {inner_loop_value}"""   )
                  plt.plot(snake_case     ,					snake_case     ,					'--'   )

              title_str += F""" {label_model_name} vs."""

          _snake_case : int												=		title_str[:-4]
          _snake_case : Union[str, Any]												=		'Time in s' if self.args.is_time else 'Memory in MB'

          # plot
          plt.title(snake_case   )
          plt.xlabel(snake_case   )
          plt.ylabel(snake_case   )
          plt.legend()

          if self.args.figure_png_file is not None:
              plt.savefig(self.args.figure_png_file   )
          else:
              plt.show()



def   lowerCamelCase__       (      )		->    Any:



    """simple docstring"""







    _snake_case : Optional[Any]												=		HfArgumentParser(a__)
    _snake_case : int												=		parser.parse_args_into_dataclasses()[0]
    _snake_case : Union[str, Any]												=		Plot(args=a__)
    plot.plot()


if __name__ == "__main__":
   main()






'''simple docstring'''



from __future__ import annotations

import inspect
import unittest

import numpy as np

from transformers import SwinConfig
from transformers.testing_utils import require_tf, require_vision, slow, to_atuple
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.models.swin.modeling_tf_swin import (
       TF_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST,
       TFSwinForImageClassification,
       TFSwinForMaskedImageModeling,
       TFSwinModel,
   )


if is_vision_available():
   from PIL import Image

   from transformers import AutoImageProcessor

class 			SCREAMING_SNAKE_CASE					:






      '''simple docstring'''






      def __init__(					self :		List[str]     ,					snake_case :		Any     ,					snake_case :		List[Any]=13     ,					snake_case :		Dict=32     ,					snake_case :		Any=2     ,					snake_case :		List[Any]=3     ,					snake_case :		Tuple=16     ,					snake_case :		Union[str, Any]=[1, 2, 1]     ,					snake_case :		int=[2, 2, 4]     ,					snake_case :		Any=2     ,					snake_case :		Any=2.0     ,					snake_case :		List[str]=True     ,					snake_case :		Tuple=0.0     ,					snake_case :		Any=0.0     ,					snake_case :		Dict=0.1     ,					snake_case :		Union[str, Any]="gelu"     ,					snake_case :		Optional[Any]=False     ,					snake_case :		List[Any]=True     ,					snake_case :		str=0.02     ,					snake_case :		int=1e-5     ,					snake_case :		Optional[Any]=True     ,					snake_case :		Tuple=None     ,					snake_case :		List[str]=True     ,					snake_case :		int=10     ,					snake_case :		Optional[int]=8     ,					):



          """simple docstring"""





          _snake_case : List[str]												=		parent
          _snake_case : Tuple												=		batch_size
          _snake_case : str												=		image_size
          _snake_case : List[str]												=		patch_size
          _snake_case : Optional[int]												=		num_channels
          _snake_case : List[str]												=		embed_dim
          _snake_case : Union[str, Any]												=		depths
          _snake_case : Optional[int]												=		num_heads
          _snake_case : str												=		window_size
          _snake_case : Union[str, Any]												=		mlp_ratio
          _snake_case : str												=		qkv_bias
          _snake_case : Any												=		hidden_dropout_prob
          _snake_case : List[str]												=		attention_probs_dropout_prob
          _snake_case : Dict												=		drop_path_rate
          _snake_case : Dict												=		hidden_act
          _snake_case : Tuple												=		use_absolute_embeddings
          _snake_case : List[str]												=		patch_norm
          _snake_case : str												=		layer_norm_eps
          _snake_case : List[str]												=		initializer_range
          _snake_case : Optional[Any]												=		is_training
          _snake_case : Tuple												=		scope
          _snake_case : List[str]												=		use_labels
          _snake_case : List[str]												=		type_sequence_label_size
          _snake_case : int												=		encoder_stride




      def 	__UpperCAmelCase			(					self :		int   ):



          """simple docstring"""





          _snake_case : Optional[int]												=		floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]   )

          _snake_case : str												=		None
          if self.use_labels:
              _snake_case : Optional[int]												=		ids_tensor([self.batch_size]     ,					self.type_sequence_label_size   )

          _snake_case : Optional[int]												=		self.get_config()

          return config, pixel_values, labels




      def 	__UpperCAmelCase			(					self :		Any   ):



          """simple docstring"""





          return SwinConfig(
              image_size=self.image_size     ,					patch_size=self.patch_size     ,					num_channels=self.num_channels     ,					embed_dim=self.embed_dim     ,					depths=self.depths     ,					num_heads=self.num_heads     ,					window_size=self.window_size     ,					mlp_ratio=self.mlp_ratio     ,					qkv_bias=self.qkv_bias     ,					hidden_dropout_prob=self.hidden_dropout_prob     ,					attention_probs_dropout_prob=self.attention_probs_dropout_prob     ,					drop_path_rate=self.drop_path_rate     ,					hidden_act=self.hidden_act     ,					use_absolute_embeddings=self.use_absolute_embeddings     ,					path_norm=self.patch_norm     ,					layer_norm_eps=self.layer_norm_eps     ,					initializer_range=self.initializer_range     ,					encoder_stride=self.encoder_stride     ,					)




      def 	__UpperCAmelCase			(					self :		Tuple     ,					snake_case :		Any     ,					snake_case :		str     ,					snake_case :		List[str]   ):



          """simple docstring"""





          _snake_case : Any												=		TFSwinModel(config=snake_case   )
          _snake_case : List[str]												=		model(snake_case   )

          _snake_case : Tuple												=		((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths   ) - 1))
          _snake_case : Any												=		int(config.embed_dim * 2 ** (len(config.depths   ) - 1)   )

          self.parent.assertEqual(result.last_hidden_state.shape     ,					(self.batch_size, expected_seq_len, expected_dim)   )




      def 	__UpperCAmelCase			(					self :		Optional[Any]     ,					snake_case :		Union[str, Any]     ,					snake_case :		List[str]     ,					snake_case :		List[str]   ):



          """simple docstring"""





          _snake_case : Any												=		TFSwinForMaskedImageModeling(config=snake_case   )
          _snake_case : Tuple												=		model(snake_case   )
          self.parent.assertEqual(
              result.logits.shape     ,					(self.batch_size, self.num_channels, self.image_size, self.image_size)   )

          # test greyscale images
          _snake_case : Any												=		1
          _snake_case : Any												=		TFSwinForMaskedImageModeling(snake_case   )

          _snake_case : int												=		floats_tensor([self.batch_size, 1, self.image_size, self.image_size]   )
          _snake_case : List[Any]												=		model(snake_case   )
          self.parent.assertEqual(result.logits.shape     ,					(self.batch_size, 1, self.image_size, self.image_size)   )




      def 	__UpperCAmelCase			(					self :		Any     ,					snake_case :		str     ,					snake_case :		int     ,					snake_case :		Union[str, Any]   ):



          """simple docstring"""





          _snake_case : List[str]												=		self.type_sequence_label_size
          _snake_case : int												=		TFSwinForImageClassification(snake_case   )
          _snake_case : int												=		model(snake_case     ,					labels=snake_case   )
          self.parent.assertEqual(result.logits.shape     ,					(self.batch_size, self.type_sequence_label_size)   )

          # test greyscale images
          _snake_case : Union[str, Any]												=		1
          _snake_case : Tuple												=		TFSwinForImageClassification(snake_case   )
          _snake_case : Any												=		floats_tensor([self.batch_size, 1, self.image_size, self.image_size]   )
          _snake_case : Union[str, Any]												=		model(snake_case   )
          self.parent.assertEqual(result.logits.shape     ,					(self.batch_size, self.type_sequence_label_size)   )




      def 	__UpperCAmelCase			(					self :		Dict   ):



          """simple docstring"""





          _snake_case : str												=		self.prepare_config_and_inputs()
          _snake_case					,							_snake_case					,							_snake_case : Any												=		config_and_inputs
          _snake_case : Tuple												=		{'pixel_values': pixel_values}
          return config, inputs_dict



@require_tf
class 			SCREAMING_SNAKE_CASE					(							lowercase_      ,lowercase_      ,unittest.TestCase					):






      '''simple docstring'''






      SCREAMING_SNAKE_CASE__ :				List[Any]    =				(
          (
              TFSwinModel,
              TFSwinForImageClassification,
              TFSwinForMaskedImageModeling,
          )
          if is_tf_available()
          else ()
      )
      SCREAMING_SNAKE_CASE__ :				List[Any]    =				(
          {'''feature-extraction''': TFSwinModel, '''image-classification''': TFSwinForImageClassification}
          if is_tf_available()
          else {}
      )

      SCREAMING_SNAKE_CASE__ :				Optional[Any]    =				False
      SCREAMING_SNAKE_CASE__ :				List[Any]    =				False
      SCREAMING_SNAKE_CASE__ :				str    =				False
      SCREAMING_SNAKE_CASE__ :				Optional[Any]    =				False




      def 	__UpperCAmelCase			(					self :		Dict   ):



          """simple docstring"""





          _snake_case : List[str]												=		TFSwinModelTester(self   )
          _snake_case : Tuple												=		ConfigTester(self     ,					config_class=snake_case     ,					embed_dim=37   )




      def 	__UpperCAmelCase			(					self :		Optional[int]   ):



          """simple docstring"""





          self.create_and_test_config_common_properties()
          self.config_tester.create_and_test_config_to_json_string()
          self.config_tester.create_and_test_config_to_json_file()
          self.config_tester.create_and_test_config_from_and_save_pretrained()
          self.config_tester.create_and_test_config_with_num_labels()
          self.config_tester.check_config_can_be_init_without_params()
          self.config_tester.check_config_arguments_init()




      def 	__UpperCAmelCase			(					self :		str   ):



          """simple docstring"""





          return




      def 	__UpperCAmelCase			(					self :		Union[str, Any]   ):



          """simple docstring"""





          _snake_case : Tuple												=		self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_model(*snake_case   )




      def 	__UpperCAmelCase			(					self :		Dict   ):



          """simple docstring"""





          _snake_case : Union[str, Any]												=		self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_masked_image_modeling(*snake_case   )




      def 	__UpperCAmelCase			(					self :		Any   ):



          """simple docstring"""





          _snake_case : List[Any]												=		self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_image_classification(*snake_case   )




      @unittest.skip(reason='Swin does not use inputs_embeds'   )
      def 	__UpperCAmelCase			(					self :		Optional[Any]   ):



          """simple docstring"""





          pass




      def 	__UpperCAmelCase			(					self :		Union[str, Any]   ):



          """simple docstring"""





          _snake_case					,							_snake_case : Tuple												=		self.model_tester.prepare_config_and_inputs_for_common()

          for model_class in self.all_model_classes:
              _snake_case : Any												=		model_class(snake_case   )
              self.assertIsInstance(model.get_input_embeddings()     ,					tf.keras.layers.Layer   )
              _snake_case : str												=		model.get_output_embeddings()
              self.assertTrue(x is None or isinstance(snake_case     ,					tf.keras.layers.Dense   )   )




      def 	__UpperCAmelCase			(					self :		Optional[Any]   ):



          """simple docstring"""





          _snake_case					,							_snake_case : Optional[int]												=		self.model_tester.prepare_config_and_inputs_for_common()

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

              _snake_case : List[Any]												=		['pixel_values']
              self.assertListEqual(arg_names[:1]     ,					snake_case   )




      def 	__UpperCAmelCase			(					self :		str   ):



          """simple docstring"""





          _snake_case					,							_snake_case : Dict												=		self.model_tester.prepare_config_and_inputs_for_common()
          _snake_case : Any												=		True

          for model_class in self.all_model_classes:
              _snake_case : Optional[int]												=		True
              _snake_case : int												=		False
              _snake_case : Tuple												=		True
              _snake_case : Dict												=		model_class(snake_case   )
              _snake_case : int												=		model(**self._prepare_for_class(snake_case     ,					snake_case   )   )
              _snake_case : Any												=		outputs.attentions
              _snake_case : Optional[int]												=		len(self.model_tester.depths   )
              self.assertEqual(len(snake_case   )     ,					snake_case   )

              # check that output_attentions also work using config
              del inputs_dict["output_attentions"]
              _snake_case : Any												=		True
              _snake_case : str												=		config.window_size**2
              _snake_case : Optional[int]												=		model_class(snake_case   )
              _snake_case : Optional[int]												=		model(**self._prepare_for_class(snake_case     ,					snake_case   )   )
              _snake_case : List[Any]												=		outputs.attentions
              self.assertEqual(len(snake_case   )     ,					snake_case   )

              self.assertListEqual(
                  list(attentions[0].shape[-3:]   )     ,					[self.model_tester.num_heads[0], window_size_squared, window_size_squared]     ,					)
              _snake_case : Optional[int]												=		len(snake_case   )

              # Check attention is always last and order is fine
              _snake_case : Any												=		True
              _snake_case : Tuple												=		True
              _snake_case : int												=		model_class(snake_case   )
              _snake_case : Dict												=		model(**self._prepare_for_class(snake_case     ,					snake_case   )   )

              if hasattr(self.model_tester     ,					'num_hidden_states_types'   ):
                  _snake_case : Any												=		self.model_tester.num_hidden_states_types
              else:
                  # also another +1 for reshaped_hidden_states
                  _snake_case : Union[str, Any]												=		2
              self.assertEqual(out_len + added_hidden_states     ,					len(snake_case   )   )

              _snake_case : Tuple												=		outputs.attentions

              self.assertEqual(len(snake_case   )     ,					snake_case   )

              self.assertListEqual(
                  list(self_attentions[0].shape[-3:]   )     ,					[self.model_tester.num_heads[0], window_size_squared, window_size_squared]     ,					)




      def 	__UpperCAmelCase			(					self :		int     ,					snake_case :		List[str]     ,					snake_case :		Union[str, Any]     ,					snake_case :		Dict     ,					snake_case :		Tuple   ):



          """simple docstring"""





          _snake_case : int												=		model_class(snake_case   )
          _snake_case : Any												=		model(**self._prepare_for_class(snake_case     ,					snake_case   )   )
          _snake_case : Optional[int]												=		outputs.hidden_states

          _snake_case : List[str]												=		getattr(
              self.model_tester     ,					'expected_num_hidden_layers'     ,					len(self.model_tester.depths   ) + 1   )
          self.assertEqual(len(snake_case   )     ,					snake_case   )

          # Swin has a different seq_length
          _snake_case : Optional[int]												=		to_atuple(config.patch_size   )

          _snake_case : Optional[int]												=		(image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])

          self.assertListEqual(
              list(hidden_states[0].shape[-2:]   )     ,					[num_patches, self.model_tester.embed_dim]     ,					)

          _snake_case : Optional[int]												=		outputs.reshaped_hidden_states
          self.assertEqual(len(snake_case   )     ,					snake_case   )

          _snake_case					,							_snake_case					,							_snake_case					,							_snake_case : List[str]												=		reshaped_hidden_states[0].shape

          _snake_case : Any												=		tf.reshape(reshaped_hidden_states[0]     ,					(batch_size, num_channels, height * width)   )
          _snake_case : List[Any]												=		tf.transpose(snake_case     ,					(0, 2, 1)   )

          self.assertListEqual(
              list(reshaped_hidden_states.shape[-2:]   )     ,					[num_patches, self.model_tester.embed_dim]     ,					)




      def 	__UpperCAmelCase			(					self :		Any   ):



          """simple docstring"""





          _snake_case					,							_snake_case : List[Any]												=		self.model_tester.prepare_config_and_inputs_for_common()

          _snake_case : Optional[int]												=		to_atuple(self.model_tester.image_size   )

          for model_class in self.all_model_classes:
              _snake_case : Dict												=		True
              self.check_hidden_states_output(snake_case     ,					snake_case     ,					snake_case     ,					snake_case   )

              # check that output_hidden_states also work using config
              del inputs_dict["output_hidden_states"]
              _snake_case : Dict												=		True

              self.check_hidden_states_output(snake_case     ,					snake_case     ,					snake_case     ,					snake_case   )




      def 	__UpperCAmelCase			(					self :		Union[str, Any]   ):



          """simple docstring"""





          _snake_case					,							_snake_case : Tuple												=		self.model_tester.prepare_config_and_inputs_for_common()
          _snake_case : Tuple												=		3

          _snake_case : Any												=		to_atuple(self.model_tester.image_size   )
          _snake_case : str												=		to_atuple(config.patch_size   )

          _snake_case : List[str]												=		image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
          _snake_case : Tuple												=		image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

          for model_class in self.all_model_classes:
              _snake_case : Union[str, Any]												=		True
              self.check_hidden_states_output(snake_case     ,					snake_case     ,					snake_case     ,					(padded_height, padded_width)   )

              # check that output_hidden_states also work using config
              del inputs_dict["output_hidden_states"]
              _snake_case : int												=		True
              self.check_hidden_states_output(snake_case     ,					snake_case     ,					snake_case     ,					(padded_height, padded_width)   )




      @slow
      def 	__UpperCAmelCase			(					self :		int   ):



          """simple docstring"""





          for model_name in TF_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
              _snake_case : Optional[int]												=		TFSwinModel.from_pretrained(snake_case   )
              self.assertIsNotNone(snake_case   )



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






      '''simple docstring'''






      @cached_property
      def 	__UpperCAmelCase			(					self :		List[str]   ):



          """simple docstring"""





          return (
              AutoImageProcessor.from_pretrained('microsoft/swin-tiny-patch4-window7-224'   )
              if is_vision_available()
              else None
          )




      @slow
      def 	__UpperCAmelCase			(					self :		Any   ):



          """simple docstring"""





          _snake_case : Dict												=		TFSwinForImageClassification.from_pretrained('microsoft/swin-tiny-patch4-window7-224'   )
          _snake_case : str												=		self.default_image_processor

          _snake_case : List[str]												=		Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'   )
          _snake_case : int												=		image_processor(images=snake_case     ,					return_tensors='tf'   )

          # forward pass
          _snake_case : Union[str, Any]												=		model(snake_case   )

          # verify the logits
          _snake_case : List[Any]												=		tf.TensorShape((1, 1000)   )
          self.assertEqual(outputs.logits.shape     ,					snake_case   )
          _snake_case : List[Any]												=		tf.constant([-0.0948, -0.6454, -0.0921]   )
          self.assertTrue(np.allclose(outputs.logits[0, :3]     ,					snake_case     ,					atol=1e-4   )   )



