

import json
import os
import shutil
import tempfile
import unittest

import numpy as np
import pytest

from transformers import BertTokenizer, BertTokenizerFast
from transformers.models.bert.tokenization_bert import VOCAB_FILES_NAMES
from transformers.testing_utils import require_vision
from transformers.utils import IMAGE_PROCESSOR_NAME, is_vision_available


if is_vision_available():
   from PIL import Image

   from transformers import AlignProcessor, EfficientNetImageProcessor



@require_vision
class SCREAMING_SNAKE_CASE     (  unittest.TestCase			):
  """simple docstring"""






  def 	SCREAMING_SNAKE_CASE   (      self			:   Tuple   )							->     Optional[Any]:






     """simple docstring"""







     __lowerCAmelCase  :      List[str]    =						tempfile.mkdtemp()

     __lowerCAmelCase  :      Optional[int]    =						[
         """[UNK]""",
         """[CLS]""",
         """[SEP]""",
         """[PAD]""",
         """[MASK]""",
         """want""",
         """##want""",
         """##ed""",
         """wa""",
         """un""",
         """runn""",
         """##ing""",
         """,""",
         """low""",
         """lowest""",
     ]
     __lowerCAmelCase  :      List[str]    =						os.path.join(self.tmpdirname	,							VOCAB_FILES_NAMES["""vocab_file"""]   )
     with open(self.vocab_file	,							"""w"""	,							encoding="""utf-8"""   ) as vocab_writer:
        vocab_writer.write("""""".join([x + """\n""" for x in vocab_tokens]   )   )

     __lowerCAmelCase  :      Any    =						{
         """do_resize""": True,
         """size""": 20,
         """do_center_crop""": True,
         """crop_size""": 18,
         """do_normalize""": True,
         """image_mean""": [0.4814_5466, 0.457_8275, 0.4082_1073],
         """image_std""": [0.2686_2954, 0.2613_0258, 0.2757_7711],
     }
     __lowerCAmelCase  :      Tuple    =						os.path.join(self.tmpdirname	,							lowerCAmelCase   )
     with open(self.image_processor_file	,							"""w"""	,							encoding="""utf-8"""   ) as fp:
        json.dump(lowerCAmelCase	,							lowerCAmelCase   )







  def 	SCREAMING_SNAKE_CASE   (      self			:   str	,							**lowerCAmelCase			:   str   )							->     int:






     """simple docstring"""







     return BertTokenizer.from_pretrained(self.tmpdirname	,							**lowerCAmelCase   )







  def 	SCREAMING_SNAKE_CASE   (      self			:   Any	,							**lowerCAmelCase			:   Any   )							->     Dict:






     """simple docstring"""







     return BertTokenizerFast.from_pretrained(self.tmpdirname	,							**lowerCAmelCase   )







  def 	SCREAMING_SNAKE_CASE   (      self			:   Tuple	,							**lowerCAmelCase			:   List[str]   )							->     Any:






     """simple docstring"""







     return EfficientNetImageProcessor.from_pretrained(self.tmpdirname	,							**lowerCAmelCase   )







  def 	SCREAMING_SNAKE_CASE   (      self			:   Tuple   )							->     str:






     """simple docstring"""







     shutil.rmtree(self.tmpdirname   )







  def 	SCREAMING_SNAKE_CASE   (      self			:   Tuple   )							->     Dict:






     """simple docstring"""







     __lowerCAmelCase  :      Any    =						[np.random.randint(2_55	,							size=(3, 30, 4_00)	,							dtype=np.uinta   )]
     __lowerCAmelCase  :      Any    =						[Image.fromarray(np.moveaxis(lowerCAmelCase	,							0	,							-1   )   ) for x in image_inputs]
     return image_inputs







  def 	SCREAMING_SNAKE_CASE   (      self			:   Any   )							->     Dict:






     """simple docstring"""







     __lowerCAmelCase  :      Dict    =						self.get_tokenizer()
     __lowerCAmelCase  :      List[str]    =						self.get_rust_tokenizer()
     __lowerCAmelCase  :      Optional[int]    =						self.get_image_processor()

     __lowerCAmelCase  :      Dict    =						AlignProcessor(tokenizer=lowerCAmelCase	,							image_processor=lowerCAmelCase   )
     processor_slow.save_pretrained(self.tmpdirname   )
     __lowerCAmelCase  :      str    =						AlignProcessor.from_pretrained(self.tmpdirname	,							use_fast=lowerCAmelCase   )

     __lowerCAmelCase  :      str    =						AlignProcessor(tokenizer=lowerCAmelCase	,							image_processor=lowerCAmelCase   )
     processor_fast.save_pretrained(self.tmpdirname   )
     __lowerCAmelCase  :      List[Any]    =						AlignProcessor.from_pretrained(self.tmpdirname   )

     self.assertEqual(processor_slow.tokenizer.get_vocab()	,							tokenizer_slow.get_vocab()   )
     self.assertEqual(processor_fast.tokenizer.get_vocab()	,							tokenizer_fast.get_vocab()   )
     self.assertEqual(tokenizer_slow.get_vocab()	,							tokenizer_fast.get_vocab()   )
     self.assertIsInstance(processor_slow.tokenizer	,							lowerCAmelCase   )
     self.assertIsInstance(processor_fast.tokenizer	,							lowerCAmelCase   )

     self.assertEqual(processor_slow.image_processor.to_json_string()	,							image_processor.to_json_string()   )
     self.assertEqual(processor_fast.image_processor.to_json_string()	,							image_processor.to_json_string()   )
     self.assertIsInstance(processor_slow.image_processor	,							lowerCAmelCase   )
     self.assertIsInstance(processor_fast.image_processor	,							lowerCAmelCase   )







  def 	SCREAMING_SNAKE_CASE   (      self			:   Union[str, Any]   )							->     Optional[Any]:






     """simple docstring"""







     __lowerCAmelCase  :      Optional[Any]    =						AlignProcessor(tokenizer=self.get_tokenizer()	,							image_processor=self.get_image_processor()   )
     processor.save_pretrained(self.tmpdirname   )

     __lowerCAmelCase  :      List[str]    =						self.get_tokenizer(bos_token="""(BOS)"""	,							eos_token="""(EOS)"""   )
     __lowerCAmelCase  :      List[Any]    =						self.get_image_processor(do_normalize=lowerCAmelCase	,							padding_value=1.0   )

     __lowerCAmelCase  :      int    =						AlignProcessor.from_pretrained(
         self.tmpdirname	,							bos_token="""(BOS)"""	,							eos_token="""(EOS)"""	,							do_normalize=lowerCAmelCase	,							padding_value=1.0   )

     self.assertEqual(processor.tokenizer.get_vocab()	,							tokenizer_add_kwargs.get_vocab()   )
     self.assertIsInstance(processor.tokenizer	,							lowerCAmelCase   )

     self.assertEqual(processor.image_processor.to_json_string()	,							image_processor_add_kwargs.to_json_string()   )
     self.assertIsInstance(processor.image_processor	,							lowerCAmelCase   )







  def 	SCREAMING_SNAKE_CASE   (      self			:   Tuple   )							->     List[str]:






     """simple docstring"""







     __lowerCAmelCase  :      Union[str, Any]    =						self.get_image_processor()
     __lowerCAmelCase  :      Tuple    =						self.get_tokenizer()

     __lowerCAmelCase  :      Optional[int]    =						AlignProcessor(tokenizer=lowerCAmelCase	,							image_processor=lowerCAmelCase   )

     __lowerCAmelCase  :      Optional[Any]    =						self.prepare_image_inputs()

     __lowerCAmelCase  :      Optional[int]    =						image_processor(lowerCAmelCase	,							return_tensors="""np"""   )
     __lowerCAmelCase  :      Any    =						processor(images=lowerCAmelCase	,							return_tensors="""np"""   )

     for key in input_image_proc.keys():
        self.assertAlmostEqual(input_image_proc[key].sum()	,							input_processor[key].sum()	,							delta=1e-2   )







  def 	SCREAMING_SNAKE_CASE   (      self			:   Optional[Any]   )							->     str:






     """simple docstring"""







     __lowerCAmelCase  :      int    =						self.get_image_processor()
     __lowerCAmelCase  :      List[Any]    =						self.get_tokenizer()

     __lowerCAmelCase  :      str    =						AlignProcessor(tokenizer=lowerCAmelCase	,							image_processor=lowerCAmelCase   )

     __lowerCAmelCase  :      List[Any]    =						"""lower newer"""

     __lowerCAmelCase  :      str    =						processor(text=lowerCAmelCase   )

     __lowerCAmelCase  :      Tuple    =						tokenizer(lowerCAmelCase	,							padding="""max_length"""	,							max_length=64   )

     for key in encoded_tok.keys():
        self.assertListEqual(encoded_tok[key]	,							encoded_processor[key]   )







  def 	SCREAMING_SNAKE_CASE   (      self			:   Tuple   )							->     str:






     """simple docstring"""







     __lowerCAmelCase  :      Union[str, Any]    =						self.get_image_processor()
     __lowerCAmelCase  :      int    =						self.get_tokenizer()

     __lowerCAmelCase  :      str    =						AlignProcessor(tokenizer=lowerCAmelCase	,							image_processor=lowerCAmelCase   )

     __lowerCAmelCase  :      Any    =						"""lower newer"""
     __lowerCAmelCase  :      List[str]    =						self.prepare_image_inputs()

     __lowerCAmelCase  :      List[str]    =						processor(text=lowerCAmelCase	,							images=lowerCAmelCase   )

     self.assertListEqual(list(inputs.keys()   )	,							["""input_ids""", """token_type_ids""", """attention_mask""", """pixel_values"""]   )

     # test if it raises when no input is passed
     with pytest.raises(lowerCAmelCase   ):
        processor()







  def 	SCREAMING_SNAKE_CASE   (      self			:   List[Any]   )							->     List[Any]:






     """simple docstring"""







     __lowerCAmelCase  :      Union[str, Any]    =						self.get_image_processor()
     __lowerCAmelCase  :      List[str]    =						self.get_tokenizer()

     __lowerCAmelCase  :      List[str]    =						AlignProcessor(tokenizer=lowerCAmelCase	,							image_processor=lowerCAmelCase   )

     __lowerCAmelCase  :      List[str]    =						[[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

     __lowerCAmelCase  :      Dict    =						processor.batch_decode(lowerCAmelCase   )
     __lowerCAmelCase  :      Tuple    =						tokenizer.batch_decode(lowerCAmelCase   )

     self.assertListEqual(lowerCAmelCase	,							lowerCAmelCase   )







  def 	SCREAMING_SNAKE_CASE   (      self			:   int   )							->     List[str]:






     """simple docstring"""







     __lowerCAmelCase  :      Optional[Any]    =						self.get_image_processor()
     __lowerCAmelCase  :      Dict    =						self.get_tokenizer()

     __lowerCAmelCase  :      Any    =						AlignProcessor(tokenizer=lowerCAmelCase	,							image_processor=lowerCAmelCase   )

     __lowerCAmelCase  :      List[Any]    =						"""lower newer"""
     __lowerCAmelCase  :      Union[str, Any]    =						self.prepare_image_inputs()

     __lowerCAmelCase  :      List[Any]    =						processor(text=lowerCAmelCase	,							images=lowerCAmelCase   )

     self.assertListEqual(list(inputs.keys()   )	,							processor.model_input_names   )





import unittest

from transformers import EsmConfig, is_torch_available
from transformers.testing_utils import TestCasePlus, require_torch, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
   import torch

   from transformers.models.esm.modeling_esmfold import EsmForProteinFolding



class SCREAMING_SNAKE_CASE     :
  """simple docstring"""






  def __init__(      self			:   Any	,							lowerCAmelCase			:   str	,							lowerCAmelCase			:   List[Any]=13	,							lowerCAmelCase			:   List[str]=7	,							lowerCAmelCase			:   int=False	,							lowerCAmelCase			:   List[str]=True	,							lowerCAmelCase			:   List[Any]=False	,							lowerCAmelCase			:   List[str]=False	,							lowerCAmelCase			:   Optional[int]=19	,							lowerCAmelCase			:   Any=32	,							lowerCAmelCase			:   int=5	,							lowerCAmelCase			:   Optional[Any]=4	,							lowerCAmelCase			:   Optional[Any]=37	,							lowerCAmelCase			:   Dict="gelu"	,							lowerCAmelCase			:   Dict=0.1	,							lowerCAmelCase			:   Dict=0.1	,							lowerCAmelCase			:   List[str]=5_12	,							lowerCAmelCase			:   Dict=16	,							lowerCAmelCase			:   List[Any]=2	,							lowerCAmelCase			:   Union[str, Any]=0.02	,							lowerCAmelCase			:   Dict=3	,							lowerCAmelCase			:   List[Any]=4	,							lowerCAmelCase			:   Union[str, Any]=None	,							)							->     List[str]:






     """simple docstring"""







     __lowerCAmelCase  :      List[str]    =						parent
     __lowerCAmelCase  :      Tuple    =						batch_size
     __lowerCAmelCase  :      Union[str, Any]    =						seq_length
     __lowerCAmelCase  :      int    =						is_training
     __lowerCAmelCase  :      Dict    =						use_input_mask
     __lowerCAmelCase  :      Dict    =						use_token_type_ids
     __lowerCAmelCase  :      Optional[int]    =						use_labels
     __lowerCAmelCase  :      str    =						vocab_size
     __lowerCAmelCase  :      Optional[int]    =						hidden_size
     __lowerCAmelCase  :      Union[str, Any]    =						num_hidden_layers
     __lowerCAmelCase  :      Union[str, Any]    =						num_attention_heads
     __lowerCAmelCase  :      Tuple    =						intermediate_size
     __lowerCAmelCase  :      List[str]    =						hidden_act
     __lowerCAmelCase  :      Optional[int]    =						hidden_dropout_prob
     __lowerCAmelCase  :      Any    =						attention_probs_dropout_prob
     __lowerCAmelCase  :      List[str]    =						max_position_embeddings
     __lowerCAmelCase  :      Any    =						type_vocab_size
     __lowerCAmelCase  :      Union[str, Any]    =						type_sequence_label_size
     __lowerCAmelCase  :      List[str]    =						initializer_range
     __lowerCAmelCase  :      int    =						num_labels
     __lowerCAmelCase  :      Tuple    =						num_choices
     __lowerCAmelCase  :      str    =						scope







  def 	SCREAMING_SNAKE_CASE   (      self			:   Dict   )							->     Tuple:






     """simple docstring"""







     __lowerCAmelCase  :      int    =						ids_tensor([self.batch_size, self.seq_length]	,							self.vocab_size   )

     __lowerCAmelCase  :      int    =						None
     if self.use_input_mask:
        __lowerCAmelCase  :      Optional[Any]    =						random_attention_mask([self.batch_size, self.seq_length]   )

     __lowerCAmelCase  :      Any    =						None
     __lowerCAmelCase  :      Optional[Any]    =						None
     __lowerCAmelCase  :      Optional[int]    =						None
     if self.use_labels:
        __lowerCAmelCase  :      Dict    =						ids_tensor([self.batch_size]	,							self.type_sequence_label_size   )
        __lowerCAmelCase  :      Optional[Any]    =						ids_tensor([self.batch_size, self.seq_length]	,							self.num_labels   )
        __lowerCAmelCase  :      List[Any]    =						ids_tensor([self.batch_size]	,							self.num_choices   )

     __lowerCAmelCase  :      Tuple    =						self.get_config()

     return config, input_ids, input_mask, sequence_labels, token_labels, choice_labels







  def 	SCREAMING_SNAKE_CASE   (      self			:   Optional[int]   )							->     Tuple:






     """simple docstring"""







     __lowerCAmelCase  :      Tuple    =						EsmConfig(
         vocab_size=33	,							hidden_size=self.hidden_size	,							pad_token_id=1	,							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	,							max_position_embeddings=self.max_position_embeddings	,							type_vocab_size=self.type_vocab_size	,							initializer_range=self.initializer_range	,							is_folding_model=lowerCAmelCase	,							esmfold_config={"""trunk""": {"""num_blocks""": 2}, """fp16_esm""": False}	,							)
     return config







  def 	SCREAMING_SNAKE_CASE   (      self			:   Union[str, Any]	,							lowerCAmelCase			:   Any	,							lowerCAmelCase			:   Union[str, Any]	,							lowerCAmelCase			:   Any	,							lowerCAmelCase			:   Dict	,							lowerCAmelCase			:   List[Any]	,							lowerCAmelCase			:   Dict   )							->     Tuple:






     """simple docstring"""







     __lowerCAmelCase  :      List[Any]    =						EsmForProteinFolding(config=lowerCAmelCase   ).float()
     model.to(lowerCAmelCase   )
     model.eval()
     __lowerCAmelCase  :      Any    =						model(lowerCAmelCase	,							attention_mask=lowerCAmelCase   )
     __lowerCAmelCase  :      str    =						model(lowerCAmelCase   )
     __lowerCAmelCase  :      Optional[int]    =						model(lowerCAmelCase   )

     self.parent.assertEqual(result.positions.shape	,							(8, self.batch_size, self.seq_length, 14, 3)   )
     self.parent.assertEqual(result.angles.shape	,							(8, self.batch_size, self.seq_length, 7, 2)   )







  def 	SCREAMING_SNAKE_CASE   (      self			:   Union[str, Any]   )							->     str:






     """simple docstring"""







     __lowerCAmelCase  :      Optional[Any]    =						self.prepare_config_and_inputs()
     (
         (
         __lowerCAmelCase
     )   ,(
         __lowerCAmelCase
     )   ,(
         __lowerCAmelCase
     )   ,(
         __lowerCAmelCase
     )   ,(
         __lowerCAmelCase
     )   ,(
         __lowerCAmelCase
     )   ,
     )  :      Optional[int]    =						config_and_inputs
     __lowerCAmelCase  :      int    =						{"""input_ids""": input_ids, """attention_mask""": input_mask}
     return config, inputs_dict






@require_torch
class SCREAMING_SNAKE_CASE     (  a_       ,							a_       ,							unittest.TestCase			):
  """simple docstring"""






  lowerCamelCase   :      Tuple										=False

  lowerCamelCase   :      int										=(EsmForProteinFolding,) if is_torch_available() else ()
  lowerCamelCase   :      int										=()
  lowerCamelCase   :      Dict										={} if is_torch_available() else {}
  lowerCamelCase   :      str										=False







  def 	SCREAMING_SNAKE_CASE   (      self			:   int   )							->     Any:






     """simple docstring"""







     __lowerCAmelCase  :      Union[str, Any]    =						EsmFoldModelTester(self   )
     __lowerCAmelCase  :      Optional[Any]    =						ConfigTester(self	,							config_class=lowerCAmelCase	,							hidden_size=37   )







  def 	SCREAMING_SNAKE_CASE   (      self			:   Optional[int]   )							->     int:






     """simple docstring"""







     self.config_tester.run_common_tests()







  def 	SCREAMING_SNAKE_CASE   (      self			:   str   )							->     int:






     """simple docstring"""







     __lowerCAmelCase  :      List[Any]    =						self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_model(*lowerCAmelCase   )







  @unittest.skip("""Does not support attention outputs"""   )
  def 	SCREAMING_SNAKE_CASE   (      self			:   Dict   )							->     List[Any]:






     """simple docstring"""







     pass







  @unittest.skip
  def 	SCREAMING_SNAKE_CASE   (      self			:   Union[str, Any]   )							->     List[Any]:






     """simple docstring"""







     pass







  @unittest.skip("""Esm does not support embedding resizing"""   )
  def 	SCREAMING_SNAKE_CASE   (      self			:   str   )							->     Tuple:






     """simple docstring"""







     pass







  @unittest.skip("""Esm does not support embedding resizing"""   )
  def 	SCREAMING_SNAKE_CASE   (      self			:   Tuple   )							->     Union[str, Any]:






     """simple docstring"""







     pass







  @unittest.skip("""ESMFold does not support passing input embeds!"""   )
  def 	SCREAMING_SNAKE_CASE   (      self			:   List[str]   )							->     Optional[Any]:






     """simple docstring"""







     pass







  @unittest.skip("""ESMFold does not support head pruning."""   )
  def 	SCREAMING_SNAKE_CASE   (      self			:   Dict   )							->     Optional[int]:






     """simple docstring"""







     pass







  @unittest.skip("""ESMFold does not support head pruning."""   )
  def 	SCREAMING_SNAKE_CASE   (      self			:   Tuple   )							->     int:






     """simple docstring"""







     pass







  @unittest.skip("""ESMFold does not support head pruning."""   )
  def 	SCREAMING_SNAKE_CASE   (      self			:   Any   )							->     Dict:






     """simple docstring"""







     pass







  @unittest.skip("""ESMFold does not support head pruning."""   )
  def 	SCREAMING_SNAKE_CASE   (      self			:   Any   )							->     str:






     """simple docstring"""







     pass







  @unittest.skip("""ESMFold does not support head pruning."""   )
  def 	SCREAMING_SNAKE_CASE   (      self			:   List[Any]   )							->     Dict:






     """simple docstring"""







     pass







  @unittest.skip("""ESMFold does not output hidden states in the normal way."""   )
  def 	SCREAMING_SNAKE_CASE   (      self			:   Tuple   )							->     List[Any]:






     """simple docstring"""







     pass







  @unittest.skip("""ESMfold does not output hidden states in the normal way."""   )
  def 	SCREAMING_SNAKE_CASE   (      self			:   Optional[int]   )							->     List[str]:






     """simple docstring"""







     pass







  @unittest.skip("""ESMFold only has one output format."""   )
  def 	SCREAMING_SNAKE_CASE   (      self			:   Optional[int]   )							->     Union[str, Any]:






     """simple docstring"""







     pass







  @unittest.skip("""This test doesn't work for ESMFold and doesn't test core functionality"""   )
  def 	SCREAMING_SNAKE_CASE   (      self			:   Tuple   )							->     Optional[Any]:






     """simple docstring"""







     pass







  @unittest.skip("""ESMFold does not support input chunking."""   )
  def 	SCREAMING_SNAKE_CASE   (      self			:   Any   )							->     Any:






     """simple docstring"""







     pass







  @unittest.skip("""ESMFold doesn't respect you and it certainly doesn't respect your initialization arguments."""   )
  def 	SCREAMING_SNAKE_CASE   (      self			:   List[Any]   )							->     Union[str, Any]:






     """simple docstring"""







     pass







  @unittest.skip("""ESMFold doesn't support torchscript compilation."""   )
  def 	SCREAMING_SNAKE_CASE   (      self			:   int   )							->     Dict:






     """simple docstring"""







     pass







  @unittest.skip("""ESMFold doesn't support torchscript compilation."""   )
  def 	SCREAMING_SNAKE_CASE   (      self			:   Optional[Any]   )							->     Optional[Any]:






     """simple docstring"""







     pass







  @unittest.skip("""ESMFold doesn't support torchscript compilation."""   )
  def 	SCREAMING_SNAKE_CASE   (      self			:   int   )							->     Any:






     """simple docstring"""







     pass







  @unittest.skip("""ESMFold doesn't support data parallel."""   )
  def 	SCREAMING_SNAKE_CASE   (      self			:   Union[str, Any]   )							->     int:






     """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			:   List[Any]   )							->     List[Any]:






     """simple docstring"""







     pass






@require_torch
class SCREAMING_SNAKE_CASE     (  a_			):
  """simple docstring"""






  @slow
  def 	SCREAMING_SNAKE_CASE   (      self			:   Any   )							->     List[str]:






     """simple docstring"""







     __lowerCAmelCase  :      Dict    =						EsmForProteinFolding.from_pretrained("""facebook/esmfold_v1"""   ).float()
     model.eval()
     __lowerCAmelCase  :      Union[str, Any]    =						torch.tensor([[0, 6, 4, 13, 5, 4, 16, 12, 11, 7, 2]]   )
     __lowerCAmelCase  :      str    =						model(lowerCAmelCase   )["""positions"""]
     __lowerCAmelCase  :      str    =						torch.tensor([2.5828, 0.7993, -10.9334]	,							dtype=torch.floataa   )
     self.assertTrue(torch.allclose(position_outputs[0, 0, 0, 0]	,							lowerCAmelCase	,							atol=1e-4   )   )


