

'''simple docstring'''



import inspect
import unittest

from huggingface_hub import hf_hub_download

from transformers import ConvNextConfig, UperNetConfig
from transformers.testing_utils import require_torch, require_torch_multi_gpu, require_vision, slow, torch_device
from transformers.utils import is_torch_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, _config_zero_init, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
     import torch

     from transformers import UperNetForSemanticSegmentation
     from transformers.models.upernet.modeling_upernet import UPERNET_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
     from PIL import Image

     from transformers import AutoImageProcessor



class 				_snake_case					:

  def __init__(				self      , _SCREAMING_SNAKE_CASE      , _SCREAMING_SNAKE_CASE=13      , _SCREAMING_SNAKE_CASE=32      , _SCREAMING_SNAKE_CASE=3      , _SCREAMING_SNAKE_CASE=4      , _SCREAMING_SNAKE_CASE=[10, 20, 30, 40]      , _SCREAMING_SNAKE_CASE=[2, 2, 3, 2]      , _SCREAMING_SNAKE_CASE=True      , _SCREAMING_SNAKE_CASE=True      , _SCREAMING_SNAKE_CASE=37      , _SCREAMING_SNAKE_CASE="gelu"      , _SCREAMING_SNAKE_CASE=10      , _SCREAMING_SNAKE_CASE=0.02      , _SCREAMING_SNAKE_CASE=["stage2", "stage3", "stage4"]      , _SCREAMING_SNAKE_CASE=3      , _SCREAMING_SNAKE_CASE=None      , ):





      '''simple docstring'''

      lowerCAmelCase 						=							parent
      lowerCAmelCase 						=							batch_size
      lowerCAmelCase 						=							image_size
      lowerCAmelCase 						=							num_channels
      lowerCAmelCase 						=							num_stages
      lowerCAmelCase 						=							hidden_sizes
      lowerCAmelCase 						=							depths
      lowerCAmelCase 						=							is_training
      lowerCAmelCase 						=							use_labels
      lowerCAmelCase 						=							intermediate_size
      lowerCAmelCase 						=							hidden_act
      lowerCAmelCase 						=							type_sequence_label_size
      lowerCAmelCase 						=							initializer_range
      lowerCAmelCase 						=							out_features
      lowerCAmelCase 						=							num_labels
      lowerCAmelCase 						=							scope
      lowerCAmelCase 						=							num_stages

  def   _SCREAMING_SNAKE_CASE				(				self	):





      '''simple docstring'''

      lowerCAmelCase 						=							floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]	)

      lowerCAmelCase 						=							None
      if self.use_labels:
          lowerCAmelCase 						=							ids_tensor([self.batch_size]      , self.type_sequence_label_size	)

      lowerCAmelCase 						=							self.get_config()

      return config, pixel_values, labels

  def   _SCREAMING_SNAKE_CASE				(				self	):





      '''simple docstring'''

      return ConvNextConfig(
          num_channels=self.num_channels      , num_stages=self.num_stages      , hidden_sizes=self.hidden_sizes      , depths=self.depths      , is_training=self.is_training      , intermediate_size=self.intermediate_size      , hidden_act=self.hidden_act      , out_features=self.out_features      , )

  def   _SCREAMING_SNAKE_CASE				(				self	):





      '''simple docstring'''

      return UperNetConfig(
          backbone_config=self.get_backbone_config()      , hidden_size=5_12      , pool_scales=[1, 2, 3, 6]      , use_auxiliary_head=_SCREAMING_SNAKE_CASE      , auxiliary_loss_weight=0.4      , auxiliary_in_channels=40      , auxiliary_channels=2_56      , auxiliary_num_convs=1      , auxiliary_concat_input=_SCREAMING_SNAKE_CASE      , loss_ignore_index=2_55      , num_labels=self.num_labels      , )

  def   _SCREAMING_SNAKE_CASE				(				self      , _SCREAMING_SNAKE_CASE      , _SCREAMING_SNAKE_CASE      , _SCREAMING_SNAKE_CASE	):





      '''simple docstring'''

      lowerCAmelCase 						=							UperNetForSemanticSegmentation(config=_SCREAMING_SNAKE_CASE	)
      model.to(_SCREAMING_SNAKE_CASE	)
      model.eval()
      lowerCAmelCase 						=							model(_SCREAMING_SNAKE_CASE	)
      self.parent.assertEqual(
          result.logits.shape      , (self.batch_size, self.num_labels, self.image_size, self.image_size)	)


  def   _SCREAMING_SNAKE_CASE				(				self	):





      '''simple docstring'''

      lowerCAmelCase 						=							self.prepare_config_and_inputs()
      (
          (
          lowerCAmelCase
      )						,   (
          lowerCAmelCase
      )						,   (
          lowerCAmelCase
      )						,   
      ) 						=							config_and_inputs
      lowerCAmelCase 						=							{'pixel_values': pixel_values}
      return config, inputs_dict



@require_torch
class 				_snake_case					(   a_     , a_     , unittest.TestCase			):
  SCREAMING_SNAKE_CASE			:       Any				=     (UperNetForSemanticSegmentation,) if is_torch_available() else ()
  SCREAMING_SNAKE_CASE			:       Any				=     {'''image-segmentation''': UperNetForSemanticSegmentation} if is_torch_available() else {}
  SCREAMING_SNAKE_CASE			:       Dict				=     False
  SCREAMING_SNAKE_CASE			:       Union[str, Any]				=     False
  SCREAMING_SNAKE_CASE			:       Optional[Any]				=     False
  SCREAMING_SNAKE_CASE			:       Optional[Any]				=     False
  SCREAMING_SNAKE_CASE			:       Any				=     False
  SCREAMING_SNAKE_CASE			:       str				=     False

  def   _SCREAMING_SNAKE_CASE				(				self	):





      '''simple docstring'''

      lowerCAmelCase 						=							UperNetModelTester(self	)
      lowerCAmelCase 						=							ConfigTester(self      , config_class=_SCREAMING_SNAKE_CASE      , has_text_modality=_SCREAMING_SNAKE_CASE      , hidden_size=37	)

  def   _SCREAMING_SNAKE_CASE				(				self	):





      '''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   _SCREAMING_SNAKE_CASE				(				self	):





      '''simple docstring'''

      return

  def   _SCREAMING_SNAKE_CASE				(				self	):





      '''simple docstring'''

      lowerCAmelCase						,   lowerCAmelCase 						=							self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
          lowerCAmelCase 						=							model_class(_SCREAMING_SNAKE_CASE	)
          lowerCAmelCase 						=							inspect.signature(model.forward	)
          # signature.parameters is an OrderedDict => so arg_names order is deterministic
          lowerCAmelCase 						=							[*signature.parameters.keys()]

          lowerCAmelCase 						=							['pixel_values']
          self.assertListEqual(arg_names[:1]      , _SCREAMING_SNAKE_CASE	)

  def   _SCREAMING_SNAKE_CASE				(				self	):





      '''simple docstring'''

      lowerCAmelCase 						=							self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_semantic_segmentation(*_SCREAMING_SNAKE_CASE	)

  @unittest.skip(reason='UperNet does not use inputs_embeds'	)
  def   _SCREAMING_SNAKE_CASE				(				self	):





      '''simple docstring'''

      pass

  @unittest.skip(reason='UperNet does not support input and output embeddings'	)
  def   _SCREAMING_SNAKE_CASE				(				self	):





      '''simple docstring'''

      pass

  @unittest.skip(reason='UperNet does not have a base model'	)
  def   _SCREAMING_SNAKE_CASE				(				self	):





      '''simple docstring'''

      pass

  @unittest.skip(reason='UperNet does not have a base model'	)
  def   _SCREAMING_SNAKE_CASE				(				self	):





      '''simple docstring'''

      pass

  @require_torch_multi_gpu
  @unittest.skip(reason='UperNet has some layers using `add_module` which doesn\'t work well with `nn.DataParallel`'	)
  def   _SCREAMING_SNAKE_CASE				(				self	):





      '''simple docstring'''

      pass

  @unittest.skip('Will be fixed soon by reducing the size of the model used for common tests.'	)
  def   _SCREAMING_SNAKE_CASE				(				self	):





      '''simple docstring'''

      pass

  def   _SCREAMING_SNAKE_CASE				(				self	):





      '''simple docstring'''

      def check_hidden_states_output(_SCREAMING_SNAKE_CASE      , _SCREAMING_SNAKE_CASE      , _SCREAMING_SNAKE_CASE	):
          lowerCAmelCase 						=							model_class(_SCREAMING_SNAKE_CASE	)
          model.to(_SCREAMING_SNAKE_CASE	)
          model.eval()

          with torch.no_grad():
              lowerCAmelCase 						=							model(**self._prepare_for_class(_SCREAMING_SNAKE_CASE      , _SCREAMING_SNAKE_CASE	)	)

          lowerCAmelCase 						=							outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

          lowerCAmelCase 						=							self.model_tester.num_stages
          self.assertEqual(len(_SCREAMING_SNAKE_CASE	)      , expected_num_stages + 1	)

          # ConvNext's feature maps are of shape (batch_size, num_channels, height, width)
          self.assertListEqual(
              list(hidden_states[0].shape[-2:]	)      , [self.model_tester.image_size // 4, self.model_tester.image_size // 4]      , )

      lowerCAmelCase						,   lowerCAmelCase 						=							self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
          lowerCAmelCase 						=							True
          check_hidden_states_output(_SCREAMING_SNAKE_CASE      , _SCREAMING_SNAKE_CASE      , _SCREAMING_SNAKE_CASE	)

          # check that output_hidden_states also work using config
          del inputs_dict["output_hidden_states"]
          lowerCAmelCase 						=							True

          check_hidden_states_output(_SCREAMING_SNAKE_CASE      , _SCREAMING_SNAKE_CASE      , _SCREAMING_SNAKE_CASE	)

  def   _SCREAMING_SNAKE_CASE				(				self	):





      '''simple docstring'''

      lowerCAmelCase						,   lowerCAmelCase 						=							self.model_tester.prepare_config_and_inputs_for_common()

      lowerCAmelCase 						=							_config_zero_init(_SCREAMING_SNAKE_CASE	)
      lowerCAmelCase 						=							_config_zero_init(configs_no_init.backbone_config	)
      for model_class in self.all_model_classes:
          lowerCAmelCase 						=							model_class(config=_SCREAMING_SNAKE_CASE	)
          for name, param in model.named_parameters():
              if param.requires_grad:
                  self.assertIn(
                      ((param.data.mean() * 1e9).round() / 1e9).item()      , [0.0, 1.0]      , msg=F'Parameter {name} of model {model_class} seems not properly initialized'      , )

  @unittest.skip(reason='UperNet does not have tied weights'	)
  def   _SCREAMING_SNAKE_CASE				(				self	):





      '''simple docstring'''

      pass


  @slow
  def   _SCREAMING_SNAKE_CASE				(				self	):





      '''simple docstring'''

      for model_name in UPERNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
          lowerCAmelCase 						=							UperNetForSemanticSegmentation.from_pretrained(_SCREAMING_SNAKE_CASE	)
          self.assertIsNotNone(_SCREAMING_SNAKE_CASE	)



def       snake_case   (	) ->  Tuple:


    """simple docstring"""


    lowerCAmelCase 						=							hf_hub_download(
        repo_id='hf-internal-testing/fixtures_ade20k'					,		repo_type='dataset'					,		filename='ADE_val_00000001.jpg'			)
    lowerCAmelCase 						=							Image.open(snake_case			).convert('RGB'			)
    return image



@require_torch
@require_vision
@slow
class 				_snake_case					(   unittest.TestCase			):

  def   _SCREAMING_SNAKE_CASE				(				self	):





      '''simple docstring'''

      lowerCAmelCase 						=							AutoImageProcessor.from_pretrained('openmmlab/upernet-swin-tiny'	)
      lowerCAmelCase 						=							UperNetForSemanticSegmentation.from_pretrained('openmmlab/upernet-swin-tiny'	).to(_SCREAMING_SNAKE_CASE	)

      lowerCAmelCase 						=							prepare_img()
      lowerCAmelCase 						=							processor(images=_SCREAMING_SNAKE_CASE      , return_tensors='pt'	).to(_SCREAMING_SNAKE_CASE	)

      with torch.no_grad():
          lowerCAmelCase 						=							model(**_SCREAMING_SNAKE_CASE	)

      lowerCAmelCase 						=							torch.Size((1, model.config.num_labels, 5_12, 5_12)	)
      self.assertEqual(outputs.logits.shape      , _SCREAMING_SNAKE_CASE	)

      lowerCAmelCase 						=							torch.tensor(
          [[-7.5_958, -7.5_958, -7.4_302], [-7.5_958, -7.5_958, -7.4_302], [-7.4_797, -7.4_797, -7.3_068]]	).to(_SCREAMING_SNAKE_CASE	)
      self.assertTrue(torch.allclose(outputs.logits[0, 0, :3, :3]      , _SCREAMING_SNAKE_CASE      , atol=1e-4	)	)


  def   _SCREAMING_SNAKE_CASE				(				self	):





      '''simple docstring'''

      lowerCAmelCase 						=							AutoImageProcessor.from_pretrained('openmmlab/upernet-convnext-tiny'	)
      lowerCAmelCase 						=							UperNetForSemanticSegmentation.from_pretrained('openmmlab/upernet-convnext-tiny'	).to(_SCREAMING_SNAKE_CASE	)

      lowerCAmelCase 						=							prepare_img()
      lowerCAmelCase 						=							processor(images=_SCREAMING_SNAKE_CASE      , return_tensors='pt'	).to(_SCREAMING_SNAKE_CASE	)

      with torch.no_grad():
          lowerCAmelCase 						=							model(**_SCREAMING_SNAKE_CASE	)

      lowerCAmelCase 						=							torch.Size((1, model.config.num_labels, 5_12, 5_12)	)
      self.assertEqual(outputs.logits.shape      , _SCREAMING_SNAKE_CASE	)

      lowerCAmelCase 						=							torch.tensor(
          [[-8.8_110, -8.8_110, -8.6_521], [-8.8_110, -8.8_110, -8.6_521], [-8.7_746, -8.7_746, -8.6_130]]	).to(_SCREAMING_SNAKE_CASE	)
      self.assertTrue(torch.allclose(outputs.logits[0, 0, :3, :3]      , _SCREAMING_SNAKE_CASE      , atol=1e-4	)	)








'''simple docstring'''



import unittest

from transformers import GPTSwaTokenizer
from transformers.testing_utils import get_tests_dir, require_sentencepiece, require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin


_UpperCamelCase						:  Dict							       =				get_tests_dir("fixtures/test_sentencepiece_with_bytefallback.model")



@require_sentencepiece
@require_tokenizers
class 				_snake_case					(   a_     , unittest.TestCase			):
  SCREAMING_SNAKE_CASE			:       int				=     GPTSwaTokenizer
  SCREAMING_SNAKE_CASE			:       Union[str, Any]				=     False
  SCREAMING_SNAKE_CASE			:       Any				=     True
  SCREAMING_SNAKE_CASE			:       Any				=     False

  def   _SCREAMING_SNAKE_CASE				(				self	):





      '''simple docstring'''

      super().setUp()

      # We have a SentencePiece fixture for testing
      lowerCAmelCase 						=							GPTSwaTokenizer(_SCREAMING_SNAKE_CASE      , eos_token='<unk>'      , bos_token='<unk>'      , pad_token='<unk>'	)

      tokenizer.save_pretrained(self.tmpdirname	)

  def   _SCREAMING_SNAKE_CASE				(				self      , _SCREAMING_SNAKE_CASE	):





      '''simple docstring'''

      lowerCAmelCase 						=							'This is a test'
      lowerCAmelCase 						=							'This is a test'
      return input_text, output_text

  def   _SCREAMING_SNAKE_CASE				(				self	):





      '''simple docstring'''

      lowerCAmelCase 						=							'<s>'
      lowerCAmelCase 						=							1

      self.assertEqual(self.get_tokenizer()._convert_token_to_id(_SCREAMING_SNAKE_CASE	)      , _SCREAMING_SNAKE_CASE	)
      self.assertEqual(self.get_tokenizer()._convert_id_to_token(_SCREAMING_SNAKE_CASE	)      , _SCREAMING_SNAKE_CASE	)

  def   _SCREAMING_SNAKE_CASE				(				self	):





      '''simple docstring'''

      lowerCAmelCase 						=							list(self.get_tokenizer().get_vocab().keys()	)

      self.assertEqual(vocab_keys[0]      , '<unk>'	)
      self.assertEqual(vocab_keys[1]      , '<s>'	)
      self.assertEqual(vocab_keys[-1]      , 'j'	)
      self.assertEqual(len(_SCREAMING_SNAKE_CASE	)      , 20_00	)

  def   _SCREAMING_SNAKE_CASE				(				self	):





      '''simple docstring'''

      self.assertEqual(self.get_tokenizer().vocab_size      , 20_00	)

  def   _SCREAMING_SNAKE_CASE				(				self	):





      '''simple docstring'''

      lowerCAmelCase 						=							GPTSwaTokenizer(_SCREAMING_SNAKE_CASE	)

      lowerCAmelCase 						=							tokenizer.tokenize('This is a test'	)
      self.assertListEqual(_SCREAMING_SNAKE_CASE      , ['▁This', '▁is', '▁a', '▁t', 'est']	)

      self.assertListEqual(tokenizer.convert_tokens_to_ids(_SCREAMING_SNAKE_CASE	)      , [4_65, 2_87, 2_65, 6_31, 8_42]	)

      lowerCAmelCase 						=							tokenizer.tokenize('I was born in 92000, and this is falsé.'	)
      # fmt: off
      self.assertListEqual(
          _SCREAMING_SNAKE_CASE      , ['▁I', '▁was', '▁bor', 'n', '▁in', '▁', '<0x39>', '2', '0', '0', '0', ',', '▁and', '▁this', '▁is', '▁f', 'al', 's', '<0xC3>', '<0xA9>', '.']      , )
      # fmt: on

      lowerCAmelCase 						=							tokenizer.convert_tokens_to_ids(_SCREAMING_SNAKE_CASE	)
      self.assertListEqual(
          _SCREAMING_SNAKE_CASE      , [2_62, 2_72, 15_25, 2_86, 2_71, 2_68, 60, 9_16, 6_33, 6_33, 6_33, 2_59, 2_66, 3_01, 2_87, 3_84, 3_67, 2_63, 1_98, 1_72, 2_60]      , )

      lowerCAmelCase 						=							tokenizer.convert_ids_to_tokens(_SCREAMING_SNAKE_CASE	)
      # fmt: off
      self.assertListEqual(
          _SCREAMING_SNAKE_CASE      , ['▁I', '▁was', '▁bor', 'n', '▁in', '▁', '<0x39>', '2', '0', '0', '0', ',', '▁and', '▁this', '▁is', '▁f', 'al', 's', '<0xC3>', '<0xA9>', '.']	)
      # fmt: on

  def   _SCREAMING_SNAKE_CASE				(				self	):





      '''simple docstring'''

      lowerCAmelCase 						=							GPTSwaTokenizer(_SCREAMING_SNAKE_CASE	)
      lowerCAmelCase 						=							['This is a test', 'I was born in 92000, and this is falsé.']
      lowerCAmelCase 						=							[
          [4_65, 2_87, 2_65, 6_31, 8_42],
          [2_62, 2_72, 15_25, 2_86, 2_71, 2_68, 60, 9_16, 6_33, 6_33, 6_33, 2_59, 2_66, 3_01, 2_87, 3_84, 3_67, 2_63, 1_98, 1_72, 2_60],
      ]

      # Test that encode_fast returns the same as tokenize + convert_tokens_to_ids
      for text, expected_ids in zip(_SCREAMING_SNAKE_CASE      , _SCREAMING_SNAKE_CASE	):
          self.assertListEqual(tokenizer.encode_fast(_SCREAMING_SNAKE_CASE	)      , _SCREAMING_SNAKE_CASE	)

      # Test that decode_fast returns the input text
      for text, token_ids in zip(_SCREAMING_SNAKE_CASE      , _SCREAMING_SNAKE_CASE	):
          self.assertEqual(tokenizer.decode_fast(_SCREAMING_SNAKE_CASE	)      , _SCREAMING_SNAKE_CASE	)


  @slow
  def   _SCREAMING_SNAKE_CASE				(				self	):





      '''simple docstring'''

      lowerCAmelCase 						=							[
          '<|python|>def fibonacci(n)\n    if n < 0:\n        print(\'Incorrect input\')',
          'Hey there, how are you doing this fine day?',
          'This is a text with a trailing spaces followed by a dot     .',
          'Häj sväjs lillebrör! =)',
          'Det är inget fel på Mr. Cool',
      ]

      # fmt: off
      lowerCAmelCase 						=							{'input_ids': [[6_34_23, 5, 68_11, 1_49_54, 2_82, 8_16, 38_21, 6_34_66, 6_34_25, 6_34_62, 18, 6_39_78, 6_78, 3_01, 13_20, 6_34_23, 6_34_55, 6_34_58, 18, 6_39_82, 42_46, 39_40, 19_01, 4_77_89, 55_47, 1_89_94], [1_96_30, 11_00, 6_34_46, 13_42, 6_33, 5_44, 44_88, 5_93, 51_02, 24_16, 6_34_95, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [16_52, 4_28, 2_68, 19_36, 5_15, 2_68, 5_85_93, 2_24_13, 91_06, 5_46, 2_68, 3_32_13, 6_39_79, 6_98, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [5_51_30, 6_34_50, 9_24, 6_34_49, 22_49, 40_62, 15_58, 3_18, 6_35_04, 2_14_98, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [5_09, 3_77, 28_27, 25_59, 3_32, 65_75, 6_34_43, 2_68_01, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], 'token_type_ids': [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], 'attention_mask': [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]}
      # fmt: on
      self.tokenizer_integration_test_util(
          expected_encoding=_SCREAMING_SNAKE_CASE      , model_name='AI-Sweden/gpt-sw3-126m'      , sequences=_SCREAMING_SNAKE_CASE      , )





