
import gc
import unittest

from transformers import MODEL_FOR_MASKED_LM_MAPPING, TF_MODEL_FOR_MASKED_LM_MAPPING, FillMaskPipeline, pipeline
from transformers.pipelines import PipelineException
from transformers.testing_utils import (
    is_pipeline_test,
    is_torch_available,
    nested_simplify,
    require_tf,
    require_torch,
    require_torch_gpu,
    slow,
)

from .test_pipelines_common import ANY


@is_pipeline_test
class 				lowercase					(		unittest.TestCase   ):
		__lowercase       :       Optional[int]	     =				MODEL_FOR_MASKED_LM_MAPPING
		__lowercase       :       List[Any]	     =				TF_MODEL_FOR_MASKED_LM_MAPPING



		def __UpperCamelCase ( self       )  ->					Optional[int]:
				"""simple docstring"""
				super().tearDown()
				# clean-up as much as possible GPU memory occupied by PyTorch
				gc.collect()
				if is_torch_available():
						import torch

						torch.cuda.empty_cache()



		@require_tf
		def __UpperCamelCase ( self       )  ->					Optional[Any]:
				"""simple docstring"""
				UpperCamelCase		=     pipeline(task='fill-mask'				,      model='sshleifer/tiny-distilroberta-base'				,      top_k=2				,      framework='tf'       )
				UpperCamelCase		=     unmasker('My name is <mask>'       )
				self.assertEqual(
				    nested_simplify(A_				,      decimals=6       )				,      [
				        {'sequence': 'My name is grouped', 'score': 2.1e-05, 'token': 38_015, 'token_str': ' grouped'},
				        {'sequence': 'My name is accuser', 'score': 2.1e-05, 'token': 25_506, 'token_str': ' accuser'},
				    ]				,      )

				UpperCamelCase		=     unmasker('The largest city in France is <mask>'       )
				self.assertEqual(
				    nested_simplify(A_				,      decimals=6       )				,      [
				        {
				            'sequence': 'The largest city in France is grouped',
				            'score': 2.1e-05,
				            'token': 38_015,
				            'token_str': ' grouped',
				        },
				        {
				            'sequence': 'The largest city in France is accuser',
				            'score': 2.1e-05,
				            'token': 25_506,
				            'token_str': ' accuser',
				        },
				    ]				,      )

				UpperCamelCase		=     unmasker('My name is <mask>'				,      targets=[' Patrick', ' Clara', ' Teven']				,      top_k=3       )
				self.assertEqual(
				    nested_simplify(A_				,      decimals=6       )				,      [
				        {'sequence': 'My name is Clara', 'score': 2e-05, 'token': 13_606, 'token_str': ' Clara'},
				        {'sequence': 'My name is Patrick', 'score': 2e-05, 'token': 3_499, 'token_str': ' Patrick'},
				        {'sequence': 'My name is Te', 'score': 1.9e-05, 'token': 2_941, 'token_str': ' Te'},
				    ]				,      )



		@require_torch
		def __UpperCamelCase ( self       )  ->					List[str]:
				"""simple docstring"""
				UpperCamelCase		=     pipeline(task='fill-mask'				,      model='sshleifer/tiny-distilroberta-base'				,      top_k=2				,      framework='pt'       )

				UpperCamelCase		=     unmasker('My name is <mask>'       )
				self.assertEqual(
				    nested_simplify(A_				,      decimals=6       )				,      [
				        {'sequence': 'My name is Maul', 'score': 2.2e-05, 'token': 35_676, 'token_str': ' Maul'},
				        {'sequence': 'My name isELS', 'score': 2.2e-05, 'token': 16_416, 'token_str': 'ELS'},
				    ]				,      )

				UpperCamelCase		=     unmasker('The largest city in France is <mask>'       )
				self.assertEqual(
				    nested_simplify(A_				,      decimals=6       )				,      [
				        {
				            'sequence': 'The largest city in France is Maul',
				            'score': 2.2e-05,
				            'token': 35_676,
				            'token_str': ' Maul',
				        },
				        {'sequence': 'The largest city in France isELS', 'score': 2.2e-05, 'token': 16_416, 'token_str': 'ELS'},
				    ]				,      )

				UpperCamelCase		=     unmasker('My name is <mask>'				,      targets=[' Patrick', ' Clara', ' Teven']				,      top_k=3       )
				self.assertEqual(
				    nested_simplify(A_				,      decimals=6       )				,      [
				        {'sequence': 'My name is Patrick', 'score': 2.1e-05, 'token': 3_499, 'token_str': ' Patrick'},
				        {'sequence': 'My name is Te', 'score': 2e-05, 'token': 2_941, 'token_str': ' Te'},
				        {'sequence': 'My name is Clara', 'score': 2e-05, 'token': 13_606, 'token_str': ' Clara'},
				    ]				,      )

				UpperCamelCase		=     unmasker('My name is <mask> <mask>'				,      top_k=2       )

				self.assertEqual(
				    nested_simplify(A_				,      decimals=6       )				,      [
				        [
				            {
				                'score': 2.2e-05,
				                'token': 35_676,
				                'token_str': ' Maul',
				                'sequence': '<s>My name is Maul<mask></s>',
				            },
				            {'score': 2.2e-05, 'token': 16_416, 'token_str': 'ELS', 'sequence': '<s>My name isELS<mask></s>'},
				        ],
				        [
				            {
				                'score': 2.2e-05,
				                'token': 35_676,
				                'token_str': ' Maul',
				                'sequence': '<s>My name is<mask> Maul</s>',
				            },
				            {'score': 2.2e-05, 'token': 16_416, 'token_str': 'ELS', 'sequence': '<s>My name is<mask>ELS</s>'},
				        ],
				    ]				,      )



		@require_torch_gpu
		def __UpperCamelCase ( self       )  ->					Tuple:
				"""simple docstring"""
				UpperCamelCase		=     pipeline('fill-mask'				,      model='hf-internal-testing/tiny-random-distilbert'				,      device=0				,      framework='pt'       )

				# convert model to fp16
				pipe.model.half()

				UpperCamelCase		=     pipe('Paris is the [MASK] of France.'       )
				# We actually don't care about the result, we just want to make sure
				# it works, meaning the float16 tensor got casted back to float32
				# for postprocessing.
				self.assertIsInstance(A_				,      A_       )



		@slow
		@require_torch
		def __UpperCamelCase ( self       )  ->					Optional[int]:
				"""simple docstring"""
				UpperCamelCase		=     pipeline(task='fill-mask'				,      model='distilroberta-base'				,      top_k=2				,      framework='pt'       )
				self.run_large_test(A_       )



		@slow
		@require_tf
		def __UpperCamelCase ( self       )  ->					List[Any]:
				"""simple docstring"""
				UpperCamelCase		=     pipeline(task='fill-mask'				,      model='distilroberta-base'				,      top_k=2				,      framework='tf'       )
				self.run_large_test(A_       )



		def __UpperCamelCase ( self				,      A_       )  ->					Tuple:
				"""simple docstring"""
				UpperCamelCase		=     unmasker('My name is <mask>'       )
				self.assertEqual(
				    nested_simplify(A_       )				,      [
				        {'sequence': 'My name is John', 'score': 0.008, 'token': 610, 'token_str': ' John'},
				        {'sequence': 'My name is Chris', 'score': 0.007, 'token': 1_573, 'token_str': ' Chris'},
				    ]				,      )
				UpperCamelCase		=     unmasker('The largest city in France is <mask>'       )
				self.assertEqual(
				    nested_simplify(A_       )				,      [
				        {
				            'sequence': 'The largest city in France is Paris',
				            'score': 0.251,
				            'token': 2_201,
				            'token_str': ' Paris',
				        },
				        {
				            'sequence': 'The largest city in France is Lyon',
				            'score': 0.214,
				            'token': 12_790,
				            'token_str': ' Lyon',
				        },
				    ]				,      )

				UpperCamelCase		=     unmasker('My name is <mask>'				,      targets=[' Patrick', ' Clara', ' Teven']				,      top_k=3       )
				self.assertEqual(
				    nested_simplify(A_       )				,      [
				        {'sequence': 'My name is Patrick', 'score': 0.005, 'token': 3_499, 'token_str': ' Patrick'},
				        {'sequence': 'My name is Clara', 'score': 0.000, 'token': 13_606, 'token_str': ' Clara'},
				        {'sequence': 'My name is Te', 'score': 0.000, 'token': 2_941, 'token_str': ' Te'},
				    ]				,      )



		@require_torch
		def __UpperCamelCase ( self       )  ->					Optional[Any]:
				"""simple docstring"""
				UpperCamelCase		=     pipeline(task='fill-mask'				,      model='sshleifer/tiny-distilroberta-base'				,      framework='pt'       )
				UpperCamelCase		=     None
				UpperCamelCase		=     None
				self.run_pipeline_test(A_				,      []       )



		@require_tf
		def __UpperCamelCase ( self       )  ->					Dict:
				"""simple docstring"""
				UpperCamelCase		=     pipeline(task='fill-mask'				,      model='sshleifer/tiny-distilroberta-base'				,      framework='tf'       )
				UpperCamelCase		=     None
				UpperCamelCase		=     None
				self.run_pipeline_test(A_				,      []       )



		def __UpperCamelCase ( self				,      A_				,      A_				,      A_       )  ->					Dict:
				"""simple docstring"""
				if tokenizer is None or tokenizer.mask_token_id is None:
						self.skipTest('The provided tokenizer has no mask token, (probably reformer or wav2vec2)'       )

				UpperCamelCase		=     FillMaskPipeline(model=A_				,      tokenizer=A_       )
				UpperCamelCase		=     [
				    F'''This is another {tokenizer.mask_token} test''',
				]
				return fill_masker, examples



		def __UpperCamelCase ( self				,      A_				,      A_       )  ->					Any:
				"""simple docstring"""
				UpperCamelCase		=     fill_masker.tokenizer
				UpperCamelCase		=     fill_masker.model

				UpperCamelCase		=     fill_masker(
				    F'''This is a {tokenizer.mask_token}'''				,      )
				self.assertEqual(
				    A_				,      [
				        {'sequence': ANY(A_       ), 'score': ANY(A_       ), 'token': ANY(A_       ), 'token_str': ANY(A_       )},
				        {'sequence': ANY(A_       ), 'score': ANY(A_       ), 'token': ANY(A_       ), 'token_str': ANY(A_       )},
				        {'sequence': ANY(A_       ), 'score': ANY(A_       ), 'token': ANY(A_       ), 'token_str': ANY(A_       )},
				        {'sequence': ANY(A_       ), 'score': ANY(A_       ), 'token': ANY(A_       ), 'token_str': ANY(A_       )},
				        {'sequence': ANY(A_       ), 'score': ANY(A_       ), 'token': ANY(A_       ), 'token_str': ANY(A_       )},
				    ]				,      )

				UpperCamelCase		=     fill_masker([F'''This is a {tokenizer.mask_token}''']       )
				self.assertEqual(
				    A_				,      [
				        {'sequence': ANY(A_       ), 'score': ANY(A_       ), 'token': ANY(A_       ), 'token_str': ANY(A_       )},
				        {'sequence': ANY(A_       ), 'score': ANY(A_       ), 'token': ANY(A_       ), 'token_str': ANY(A_       )},
				        {'sequence': ANY(A_       ), 'score': ANY(A_       ), 'token': ANY(A_       ), 'token_str': ANY(A_       )},
				        {'sequence': ANY(A_       ), 'score': ANY(A_       ), 'token': ANY(A_       ), 'token_str': ANY(A_       )},
				        {'sequence': ANY(A_       ), 'score': ANY(A_       ), 'token': ANY(A_       ), 'token_str': ANY(A_       )},
				    ]				,      )

				UpperCamelCase		=     fill_masker([F'''This is a {tokenizer.mask_token}''', F'''Another {tokenizer.mask_token} great test.''']       )
				self.assertEqual(
				    A_				,      [
				        [
				            {'sequence': ANY(A_       ), 'score': ANY(A_       ), 'token': ANY(A_       ), 'token_str': ANY(A_       )},
				            {'sequence': ANY(A_       ), 'score': ANY(A_       ), 'token': ANY(A_       ), 'token_str': ANY(A_       )},
				            {'sequence': ANY(A_       ), 'score': ANY(A_       ), 'token': ANY(A_       ), 'token_str': ANY(A_       )},
				            {'sequence': ANY(A_       ), 'score': ANY(A_       ), 'token': ANY(A_       ), 'token_str': ANY(A_       )},
				            {'sequence': ANY(A_       ), 'score': ANY(A_       ), 'token': ANY(A_       ), 'token_str': ANY(A_       )},
				        ],
				        [
				            {'sequence': ANY(A_       ), 'score': ANY(A_       ), 'token': ANY(A_       ), 'token_str': ANY(A_       )},
				            {'sequence': ANY(A_       ), 'score': ANY(A_       ), 'token': ANY(A_       ), 'token_str': ANY(A_       )},
				            {'sequence': ANY(A_       ), 'score': ANY(A_       ), 'token': ANY(A_       ), 'token_str': ANY(A_       )},
				            {'sequence': ANY(A_       ), 'score': ANY(A_       ), 'token': ANY(A_       ), 'token_str': ANY(A_       )},
				            {'sequence': ANY(A_       ), 'score': ANY(A_       ), 'token': ANY(A_       ), 'token_str': ANY(A_       )},
				        ],
				    ]				,      )

				with self.assertRaises(A_       ):
						fill_masker([None]       )
				# No mask_token is not supported
				with self.assertRaises(A_       ):
						fill_masker('This is'       )

				self.run_test_top_k(A_				,      A_       )
				self.run_test_targets(A_				,      A_       )
				self.run_test_top_k_targets(A_				,      A_       )
				self.fill_mask_with_duplicate_targets_and_top_k(A_				,      A_       )
				self.fill_mask_with_multiple_masks(A_				,      A_       )



		def __UpperCamelCase ( self				,      A_				,      A_       )  ->					Optional[int]:
				"""simple docstring"""
				UpperCamelCase		=     tokenizer.get_vocab()
				UpperCamelCase		=     sorted(vocab.keys()       )[:2]
				# Pipeline argument
				UpperCamelCase		=     FillMaskPipeline(model=A_				,      tokenizer=A_				,      targets=A_       )
				UpperCamelCase		=     fill_masker(F'''This is a {tokenizer.mask_token}'''       )
				self.assertEqual(
				    A_				,      [
				        {'sequence': ANY(A_       ), 'score': ANY(A_       ), 'token': ANY(A_       ), 'token_str': ANY(A_       )},
				        {'sequence': ANY(A_       ), 'score': ANY(A_       ), 'token': ANY(A_       ), 'token_str': ANY(A_       )},
				    ]				,      )
				UpperCamelCase		=     {vocab[el] for el in targets}
				self.assertEqual({el['token'] for el in outputs}				,      A_       )
				UpperCamelCase		=     [tokenizer.decode([x]       ) for x in target_ids]
				self.assertEqual({el['token_str'] for el in outputs}				,      set(A_       )       )

				# Call argument
				UpperCamelCase		=     FillMaskPipeline(model=A_				,      tokenizer=A_       )
				UpperCamelCase		=     fill_masker(F'''This is a {tokenizer.mask_token}'''				,      targets=A_       )
				self.assertEqual(
				    A_				,      [
				        {'sequence': ANY(A_       ), 'score': ANY(A_       ), 'token': ANY(A_       ), 'token_str': ANY(A_       )},
				        {'sequence': ANY(A_       ), 'score': ANY(A_       ), 'token': ANY(A_       ), 'token_str': ANY(A_       )},
				    ]				,      )
				UpperCamelCase		=     {vocab[el] for el in targets}
				self.assertEqual({el['token'] for el in outputs}				,      A_       )
				UpperCamelCase		=     [tokenizer.decode([x]       ) for x in target_ids]
				self.assertEqual({el['token_str'] for el in outputs}				,      set(A_       )       )

				# Score equivalence
				UpperCamelCase		=     fill_masker(F'''This is a {tokenizer.mask_token}'''				,      targets=A_       )
				UpperCamelCase		=     [top_mask['token_str'] for top_mask in outputs]
				UpperCamelCase		=     [top_mask['score'] for top_mask in outputs]

				# For some BPE tokenizers, `</w>` is removed during decoding, so `token_str` won't be the same as in `targets`.
				if set(A_       ) == set(A_       ):
						UpperCamelCase		=     fill_masker(F'''This is a {tokenizer.mask_token}'''				,      targets=A_       )
						UpperCamelCase		=     [top_mask['score'] for top_mask in unmasked_targets]
						self.assertEqual(nested_simplify(A_       )				,      nested_simplify(A_       )       )

				# Raises with invalid
				with self.assertRaises(A_       ):
						UpperCamelCase		=     fill_masker(F'''This is a {tokenizer.mask_token}'''				,      targets=[]       )
				# For some tokenizers, `""` is actually in the vocabulary and the expected error won't raised
				if "" not in tokenizer.get_vocab():
						with self.assertRaises(A_       ):
								UpperCamelCase		=     fill_masker(F'''This is a {tokenizer.mask_token}'''				,      targets=['']       )
						with self.assertRaises(A_       ):
								UpperCamelCase		=     fill_masker(F'''This is a {tokenizer.mask_token}'''				,      targets=''       )



		def __UpperCamelCase ( self				,      A_				,      A_       )  ->					Optional[int]:
				"""simple docstring"""
				UpperCamelCase		=     FillMaskPipeline(model=A_				,      tokenizer=A_				,      top_k=2       )
				UpperCamelCase		=     fill_masker(F'''This is a {tokenizer.mask_token}'''       )
				self.assertEqual(
				    A_				,      [
				        {'sequence': ANY(A_       ), 'score': ANY(A_       ), 'token': ANY(A_       ), 'token_str': ANY(A_       )},
				        {'sequence': ANY(A_       ), 'score': ANY(A_       ), 'token': ANY(A_       ), 'token_str': ANY(A_       )},
				    ]				,      )

				UpperCamelCase		=     FillMaskPipeline(model=A_				,      tokenizer=A_       )
				UpperCamelCase		=     fill_masker(F'''This is a {tokenizer.mask_token}'''				,      top_k=2       )
				self.assertEqual(
				    A_				,      [
				        {'sequence': ANY(A_       ), 'score': ANY(A_       ), 'token': ANY(A_       ), 'token_str': ANY(A_       )},
				        {'sequence': ANY(A_       ), 'score': ANY(A_       ), 'token': ANY(A_       ), 'token_str': ANY(A_       )},
				    ]				,      )
				self.assertEqual(nested_simplify(A_       )				,      nested_simplify(A_       )       )



		def __UpperCamelCase ( self				,      A_				,      A_       )  ->					Optional[Any]:
				"""simple docstring"""
				UpperCamelCase		=     tokenizer.get_vocab()
				UpperCamelCase		=     FillMaskPipeline(model=A_				,      tokenizer=A_       )

				# top_k=2, ntargets=3
				UpperCamelCase		=     sorted(vocab.keys()       )[:3]
				UpperCamelCase		=     fill_masker(F'''This is a {tokenizer.mask_token}'''				,      top_k=2				,      targets=A_       )

				# If we use the most probably targets, and filter differently, we should still
				# have the same results
				UpperCamelCase		=     [el['token_str'] for el in sorted(A_				,      key=lambda A_       : x["score"]				,      reverse=A_       )]
				# For some BPE tokenizers, `</w>` is removed during decoding, so `token_str` won't be the same as in `targets`.
				if set(A_       ).issubset(A_       ):
						UpperCamelCase		=     fill_masker(F'''This is a {tokenizer.mask_token}'''				,      top_k=3				,      targets=A_       )
						# They should yield exactly the same result
						self.assertEqual(nested_simplify(A_       )				,      nested_simplify(A_       )       )



		def __UpperCamelCase ( self				,      A_				,      A_       )  ->					Union[str, Any]:
				"""simple docstring"""
				UpperCamelCase		=     FillMaskPipeline(model=A_				,      tokenizer=A_       )
				UpperCamelCase		=     tokenizer.get_vocab()
				# String duplicates + id duplicates
				UpperCamelCase		=     sorted(vocab.keys()       )[:3]
				UpperCamelCase		=     [targets[0], targets[1], targets[0], targets[2], targets[1]]
				UpperCamelCase		=     fill_masker(F'''My name is {tokenizer.mask_token}'''				,      targets=A_				,      top_k=10       )

				# The target list contains duplicates, so we can't output more
				# than them
				self.assertEqual(len(A_       )				,      3       )



		def __UpperCamelCase ( self				,      A_				,      A_       )  ->					Optional[int]:
				"""simple docstring"""
				UpperCamelCase		=     FillMaskPipeline(model=A_				,      tokenizer=A_       )

				UpperCamelCase		=     fill_masker(
				    F'''This is a {tokenizer.mask_token} {tokenizer.mask_token} {tokenizer.mask_token}'''				,      top_k=2       )
				self.assertEqual(
				    A_				,      [
				        [
				            {'sequence': ANY(A_       ), 'score': ANY(A_       ), 'token': ANY(A_       ), 'token_str': ANY(A_       )},
				            {'sequence': ANY(A_       ), 'score': ANY(A_       ), 'token': ANY(A_       ), 'token_str': ANY(A_       )},
				        ],
				        [
				            {'sequence': ANY(A_       ), 'score': ANY(A_       ), 'token': ANY(A_       ), 'token_str': ANY(A_       )},
				            {'sequence': ANY(A_       ), 'score': ANY(A_       ), 'token': ANY(A_       ), 'token_str': ANY(A_       )},
				        ],
				        [
				            {'sequence': ANY(A_       ), 'score': ANY(A_       ), 'token': ANY(A_       ), 'token_str': ANY(A_       )},
				            {'sequence': ANY(A_       ), 'score': ANY(A_       ), 'token': ANY(A_       ), 'token_str': ANY(A_       )},
				        ],
				    ]				,      )


import unittest

from huggingface_hub import hf_hub_download

from transformers import MODEL_FOR_VIDEO_CLASSIFICATION_MAPPING, VideoMAEFeatureExtractor
from transformers.pipelines import VideoClassificationPipeline, pipeline
from transformers.testing_utils import (
    is_pipeline_test,
    nested_simplify,
    require_decord,
    require_tf,
    require_torch,
    require_torch_or_tf,
    require_vision,
)

from .test_pipelines_common import ANY


@is_pipeline_test
@require_torch_or_tf
@require_vision
@require_decord
class 				lowercase					(		unittest.TestCase   ):
		__lowercase       :       Any	     =				MODEL_FOR_VIDEO_CLASSIFICATION_MAPPING



		def __UpperCamelCase ( self				,      A_				,      A_				,      A_       )  ->					List[Any]:
				"""simple docstring"""
				UpperCamelCase		=     hf_hub_download(
				    repo_id='nateraw/video-demo'				,      filename='archery.mp4'				,      repo_type='dataset'       )
				UpperCamelCase		=     VideoClassificationPipeline(model=A_				,      image_processor=A_				,      top_k=2       )
				UpperCamelCase		=     [
				    example_video_filepath,
				    'https://huggingface.co/datasets/nateraw/video-demo/resolve/main/archery.mp4',
				]
				return video_classifier, examples



		def __UpperCamelCase ( self				,      A_				,      A_       )  ->					Optional[int]:
				"""simple docstring"""
				for example in examples:
						UpperCamelCase		=     video_classifier(A_       )

						self.assertEqual(
						    A_				,      [
						        {'score': ANY(A_       ), 'label': ANY(A_       )},
						        {'score': ANY(A_       ), 'label': ANY(A_       )},
						    ]				,      )



		@require_torch
		def __UpperCamelCase ( self       )  ->					Optional[Any]:
				"""simple docstring"""
				UpperCamelCase		=     'hf-internal-testing/tiny-random-VideoMAEForVideoClassification'
				UpperCamelCase		=     VideoMAEFeatureExtractor(
				    size={'shortest_edge': 10}				,      crop_size={'height': 10, 'width': 10}       )
				UpperCamelCase		=     pipeline(
				    'video-classification'				,      model=A_				,      feature_extractor=A_				,      frame_sampling_rate=4       )

				UpperCamelCase		=     hf_hub_download(repo_id='nateraw/video-demo'				,      filename='archery.mp4'				,      repo_type='dataset'       )
				UpperCamelCase		=     video_classifier(A_				,      top_k=2       )
				self.assertEqual(
				    nested_simplify(A_				,      decimals=4       )				,      [{'score': 0.5199, 'label': 'LABEL_0'}, {'score': 0.4801, 'label': 'LABEL_1'}]				,      )

				UpperCamelCase		=     video_classifier(
				    [
				        video_file_path,
				        video_file_path,
				    ]				,      top_k=2				,      )
				self.assertEqual(
				    nested_simplify(A_				,      decimals=4       )				,      [
				        [{'score': 0.5199, 'label': 'LABEL_0'}, {'score': 0.4801, 'label': 'LABEL_1'}],
				        [{'score': 0.5199, 'label': 'LABEL_0'}, {'score': 0.4801, 'label': 'LABEL_1'}],
				    ]				,      )



		@require_tf
		def __UpperCamelCase ( self       )  ->					Tuple:
				"""simple docstring"""
				pass
