'''simple docstring'''

import json
import os
from dataclasses import dataclass
from functools import partial
from typing import Callable

import flax.linen as nn
import jax
import jax.numpy as jnp
import joblib
import optax
import wandb
from flax import jax_utils, struct, traverse_util
from flax.serialization import from_bytes, to_bytes
from flax.training import train_state
from flax.training.common_utils import shard
from tqdm.auto import tqdm

from transformers import BigBirdConfig, FlaxBigBirdForQuestionAnswering
from transformers.models.big_bird.modeling_flax_big_bird import FlaxBigBirdForQuestionAnsweringModule







class 				_lowercase     (				UpperCAmelCase__			):


 '''simple docstring'''






 _SCREAMING_SNAKE_CASE     :       BigBirdConfig
 _SCREAMING_SNAKE_CASE     :       jnp.dtype      	=					jnp.floataa
 _SCREAMING_SNAKE_CASE     :       bool      	=					True
 def a					(      self   :	Dict							)  ->    List[str]:
  super().setup()
  __lowerCAmelCase											=						nn.Dense(5      ,       dtype=self.dtype							)





 def __call__(      self   :	List[str]      ,       *SCREAMING_SNAKE_CASE__   :	int      ,       **SCREAMING_SNAKE_CASE__   :	List[Any]							)  ->    Optional[int]:
  __lowerCAmelCase											=						super().__call__(*SCREAMING_SNAKE_CASE__      ,       **SCREAMING_SNAKE_CASE__							)
  __lowerCAmelCase											=						self.cls(outputs[2]							)
  return outputs[:2] + (cls_out,)







class 				_lowercase     (				UpperCAmelCase__			):


 '''simple docstring'''






 _SCREAMING_SNAKE_CASE     :       List[Any]      	=					FlaxBigBirdForNaturalQuestionsModule







def      UpperCamelCase_						(					snake_case_       :       Dict						,		snake_case_       :       Union[str, Any]						,		snake_case_       :       Tuple						,		snake_case_       :       Union[str, Any]						,		snake_case_       :       Dict						,		snake_case_       :       str      )					->     List[str]:






 '''simple docstring'''

 def cross_entropy(snake_case_       :       List[Any]						,		snake_case_       :       List[str]						,		snake_case_       :       List[str]=None      ):
  __lowerCAmelCase											=						logits.shape[-1]
  __lowerCAmelCase											=						(labels[..., None] == jnp.arange(SCREAMING_SNAKE_CASE__      )[None]).astype("""f4"""      )
  __lowerCAmelCase											=						jax.nn.log_softmax(SCREAMING_SNAKE_CASE__						,		axis=-1      )
  __lowerCAmelCase											=						-jnp.sum(labels * logits						,		axis=-1      )
  if reduction is not None:
   __lowerCAmelCase											=						reduction(SCREAMING_SNAKE_CASE__      )
  return loss

 __lowerCAmelCase											=						partial(SCREAMING_SNAKE_CASE__						,		reduction=jnp.mean      )
 __lowerCAmelCase											=						cross_entropy(SCREAMING_SNAKE_CASE__						,		SCREAMING_SNAKE_CASE__      )
 __lowerCAmelCase											=						cross_entropy(SCREAMING_SNAKE_CASE__						,		SCREAMING_SNAKE_CASE__      )
 __lowerCAmelCase											=						cross_entropy(SCREAMING_SNAKE_CASE__						,		SCREAMING_SNAKE_CASE__      )
 return (start_loss + end_loss + pooled_loss) / 3







@dataclass
class 				_lowercase     :


 '''simple docstring'''






 _SCREAMING_SNAKE_CASE     :       str      	=					"google/bigbird-roberta-base"
 _SCREAMING_SNAKE_CASE     :       int      	=					3000
 _SCREAMING_SNAKE_CASE     :       int      	=					10500

 _SCREAMING_SNAKE_CASE     :       int      	=					128
 _SCREAMING_SNAKE_CASE     :       int      	=					3

 _SCREAMING_SNAKE_CASE     :       int      	=					1
 _SCREAMING_SNAKE_CASE     :       int      	=					5

 # tx_args
 _SCREAMING_SNAKE_CASE     :       float      	=					3e-5
 _SCREAMING_SNAKE_CASE     :       float      	=					0.0
 _SCREAMING_SNAKE_CASE     :       int      	=					20000
 _SCREAMING_SNAKE_CASE     :       float      	=					0.0095

 _SCREAMING_SNAKE_CASE     :       str      	=					"bigbird-roberta-natural-questions"
 _SCREAMING_SNAKE_CASE     :       str      	=					"training-expt"
 _SCREAMING_SNAKE_CASE     :       str      	=					"data/nq-training.jsonl"
 _SCREAMING_SNAKE_CASE     :       str      	=					"data/nq-validation.jsonl"
 def a					(      self   :	List[str]							)  ->    List[Any]:
  os.makedirs(self.base_dir      ,       exist_ok=SCREAMING_SNAKE_CASE__							)
  __lowerCAmelCase											=						os.path.join(self.base_dir      ,       self.save_dir							)
  __lowerCAmelCase											=						self.batch_size_per_device * jax.device_count()







@dataclass
class 				_lowercase     :


 '''simple docstring'''






 _SCREAMING_SNAKE_CASE     :       int
 _SCREAMING_SNAKE_CASE     :       int      	=					4096  # no dynamic padding on TPUs
 def __call__(      self   :	List[str]      ,       SCREAMING_SNAKE_CASE__   :	Union[str, Any]							)  ->    int:
  __lowerCAmelCase											=						self.collate_fn(SCREAMING_SNAKE_CASE__							)
  __lowerCAmelCase											=						jax.tree_util.tree_map(SCREAMING_SNAKE_CASE__      ,       SCREAMING_SNAKE_CASE__							)
  return batch
 def a					(      self   :	Union[str, Any]      ,       SCREAMING_SNAKE_CASE__   :	int							)  ->    Dict:
  __lowerCAmelCase											=						self.fetch_inputs(features["""input_ids"""]							)
  __lowerCAmelCase											=						{
      """input_ids""": jnp.array(SCREAMING_SNAKE_CASE__      ,       dtype=jnp.intaa							),
      """attention_mask""": jnp.array(SCREAMING_SNAKE_CASE__      ,       dtype=jnp.intaa							),
      """start_labels""": jnp.array(features["""start_token"""]      ,       dtype=jnp.intaa							),
      """end_labels""": jnp.array(features["""end_token"""]      ,       dtype=jnp.intaa							),
      """pooled_labels""": jnp.array(features["""category"""]      ,       dtype=jnp.intaa							),
  }
  return batch
 def a					(      self   :	int      ,       SCREAMING_SNAKE_CASE__   :	Dict							)  ->    List[Any]:
  __lowerCAmelCase											=						[self._fetch_inputs(SCREAMING_SNAKE_CASE__							) for ids in input_ids]
  return zip(*SCREAMING_SNAKE_CASE__							)





 def a					(      self   :	List[Any]      ,       SCREAMING_SNAKE_CASE__   :	List[str]							)  ->    Any:
  __lowerCAmelCase											=						[1 for _ in range(len(SCREAMING_SNAKE_CASE__							)							)]
  while len(SCREAMING_SNAKE_CASE__							) < self.max_length:
   input_ids.append(self.pad_id							)
   attention_mask.append(0							)
  return input_ids, attention_mask







def      UpperCamelCase_						(					snake_case_       :       int						,		snake_case_       :       Dict						,		snake_case_       :       Optional[int]=None      )					->     Any:






 '''simple docstring'''

 if seed is not None:
  __lowerCAmelCase											=						dataset.shuffle(seed=SCREAMING_SNAKE_CASE__      )
 for i in range(len(SCREAMING_SNAKE_CASE__      ) // batch_size      ):
  __lowerCAmelCase											=						dataset[i * batch_size : (i + 1) * batch_size]
  yield dict(SCREAMING_SNAKE_CASE__      )







@partial(jax.pmap						,		axis_name="""batch"""      )
def      UpperCamelCase_						(					snake_case_       :       Union[str, Any]						,		snake_case_       :       str						,		**snake_case_       :       Union[str, Any]      )					->     List[Any]:






 '''simple docstring'''

 def loss_fn(snake_case_       :       Union[str, Any]      ):
  __lowerCAmelCase											=						model_inputs.pop("""start_labels"""      )
  __lowerCAmelCase											=						model_inputs.pop("""end_labels"""      )
  __lowerCAmelCase											=						model_inputs.pop("""pooled_labels"""      )

  __lowerCAmelCase											=						state.apply_fn(**SCREAMING_SNAKE_CASE__						,		params=SCREAMING_SNAKE_CASE__						,		dropout_rng=SCREAMING_SNAKE_CASE__						,		train=SCREAMING_SNAKE_CASE__      )
  __lowerCAmelCase											=						outputs

  return state.loss_fn(
      SCREAMING_SNAKE_CASE__						,		SCREAMING_SNAKE_CASE__						,		SCREAMING_SNAKE_CASE__						,		SCREAMING_SNAKE_CASE__						,		SCREAMING_SNAKE_CASE__						,		SCREAMING_SNAKE_CASE__						,		)

 __lowerCAmelCase											=						jax.random.split(SCREAMING_SNAKE_CASE__      )
 __lowerCAmelCase											=						jax.value_and_grad(SCREAMING_SNAKE_CASE__      )
 __lowerCAmelCase											=						grad_fn(state.params      )
 __lowerCAmelCase											=						jax.lax.pmean({"""loss""": loss}						,		axis_name="""batch"""      )
 __lowerCAmelCase											=						jax.lax.pmean(SCREAMING_SNAKE_CASE__						,		"""batch"""      )

 __lowerCAmelCase											=						state.apply_gradients(grads=SCREAMING_SNAKE_CASE__      )
 return state, metrics, new_drp_rng







@partial(jax.pmap						,		axis_name="""batch"""      )
def      UpperCamelCase_						(					snake_case_       :       str						,		**snake_case_       :       int      )					->     List[str]:






 '''simple docstring'''

 __lowerCAmelCase											=						model_inputs.pop("""start_labels"""      )
 __lowerCAmelCase											=						model_inputs.pop("""end_labels"""      )
 __lowerCAmelCase											=						model_inputs.pop("""pooled_labels"""      )

 __lowerCAmelCase											=						state.apply_fn(**SCREAMING_SNAKE_CASE__						,		params=state.params						,		train=SCREAMING_SNAKE_CASE__      )
 __lowerCAmelCase											=						outputs

 __lowerCAmelCase											=						state.loss_fn(SCREAMING_SNAKE_CASE__						,		SCREAMING_SNAKE_CASE__						,		SCREAMING_SNAKE_CASE__						,		SCREAMING_SNAKE_CASE__						,		SCREAMING_SNAKE_CASE__						,		SCREAMING_SNAKE_CASE__      )
 __lowerCAmelCase											=						jax.lax.pmean({"""loss""": loss}						,		axis_name="""batch"""      )
 return metrics







class 				_lowercase     (				train_state.TrainState			):


 '''simple docstring'''






 _SCREAMING_SNAKE_CASE     :       Callable      	=					struct.field(pytree_node=UpperCAmelCase__			)







@dataclass
class 				_lowercase     :


 '''simple docstring'''






 _SCREAMING_SNAKE_CASE     :       Args
 _SCREAMING_SNAKE_CASE     :       Callable
 _SCREAMING_SNAKE_CASE     :       Callable
 _SCREAMING_SNAKE_CASE     :       Callable
 _SCREAMING_SNAKE_CASE     :       Callable
 _SCREAMING_SNAKE_CASE     :       wandb
 _SCREAMING_SNAKE_CASE     :       Callable      	=					None
 def a					(      self   :	Optional[int]      ,       SCREAMING_SNAKE_CASE__   :	Dict      ,       SCREAMING_SNAKE_CASE__   :	Any      ,       SCREAMING_SNAKE_CASE__   :	str      ,       SCREAMING_SNAKE_CASE__   :	Tuple=None							)  ->    List[str]:
  __lowerCAmelCase											=						model.params
  __lowerCAmelCase											=						TrainState.create(
      apply_fn=model.__call__      ,       params=SCREAMING_SNAKE_CASE__      ,       tx=SCREAMING_SNAKE_CASE__      ,       loss_fn=SCREAMING_SNAKE_CASE__      ,       )
  if ckpt_dir is not None:
   __lowerCAmelCase											=						restore_checkpoint(SCREAMING_SNAKE_CASE__      ,       SCREAMING_SNAKE_CASE__							)
   __lowerCAmelCase											=						{
       """lr""": args.lr,
       """init_lr""": args.init_lr,
       """warmup_steps""": args.warmup_steps,
       """num_train_steps""": num_train_steps,
       """weight_decay""": args.weight_decay,
   }
   __lowerCAmelCase											=						build_tx(**SCREAMING_SNAKE_CASE__							)
   __lowerCAmelCase											=						train_state.TrainState(
       step=SCREAMING_SNAKE_CASE__      ,       apply_fn=model.__call__      ,       params=SCREAMING_SNAKE_CASE__      ,       tx=SCREAMING_SNAKE_CASE__      ,       opt_state=SCREAMING_SNAKE_CASE__      ,       )
   __lowerCAmelCase											=						args
   __lowerCAmelCase											=						data_collator
   __lowerCAmelCase											=						lr
   __lowerCAmelCase											=						params
  __lowerCAmelCase											=						jax_utils.replicate(SCREAMING_SNAKE_CASE__							)
  return state
 def a					(      self   :	Tuple      ,       SCREAMING_SNAKE_CASE__   :	Union[str, Any]      ,       SCREAMING_SNAKE_CASE__   :	List[str]      ,       SCREAMING_SNAKE_CASE__   :	Optional[int]							)  ->    Dict:
  __lowerCAmelCase											=						self.args
  __lowerCAmelCase											=						len(SCREAMING_SNAKE_CASE__							) // args.batch_size

  __lowerCAmelCase											=						jax.random.PRNGKey(0							)
  __lowerCAmelCase											=						jax.random.split(SCREAMING_SNAKE_CASE__      ,       jax.device_count()							)
  for epoch in range(args.max_epochs							):
   __lowerCAmelCase											=						jnp.array(0      ,       dtype=jnp.floataa							)
   __lowerCAmelCase											=						get_batched_dataset(SCREAMING_SNAKE_CASE__      ,       args.batch_size      ,       seed=SCREAMING_SNAKE_CASE__							)
   __lowerCAmelCase											=						0
   for batch in tqdm(SCREAMING_SNAKE_CASE__      ,       total=SCREAMING_SNAKE_CASE__      ,       desc=f"""Running EPOCH-{epoch}"""							):
    __lowerCAmelCase											=						self.data_collator(SCREAMING_SNAKE_CASE__							)
    __lowerCAmelCase											=						self.train_step_fn(SCREAMING_SNAKE_CASE__      ,       SCREAMING_SNAKE_CASE__      ,       **SCREAMING_SNAKE_CASE__							)
    running_loss += jax_utils.unreplicate(metrics["""loss"""]							)
    i += 1
    if i % args.logging_steps == 0:
     __lowerCAmelCase											=						jax_utils.unreplicate(state.step							)
     __lowerCAmelCase											=						running_loss.item() / i
     __lowerCAmelCase											=						self.scheduler_fn(state_step - 1							)

     __lowerCAmelCase											=						self.evaluate(SCREAMING_SNAKE_CASE__      ,       SCREAMING_SNAKE_CASE__							)
     __lowerCAmelCase											=						{
         """step""": state_step.item(),
         """eval_loss""": eval_loss.item(),
         """tr_loss""": tr_loss,
         """lr""": lr.item(),
     }
     tqdm.write(str(SCREAMING_SNAKE_CASE__							)							)
     self.logger.log(SCREAMING_SNAKE_CASE__      ,       commit=SCREAMING_SNAKE_CASE__							)

    if i % args.save_steps == 0:
     self.save_checkpoint(args.save_dir + f"""-e{epoch}-s{i}"""      ,       state=SCREAMING_SNAKE_CASE__							)
 def a					(      self   :	int      ,       SCREAMING_SNAKE_CASE__   :	Union[str, Any]      ,       SCREAMING_SNAKE_CASE__   :	List[Any]							)  ->    Any:
  __lowerCAmelCase											=						get_batched_dataset(SCREAMING_SNAKE_CASE__      ,       self.args.batch_size							)
  __lowerCAmelCase											=						len(SCREAMING_SNAKE_CASE__							) // self.args.batch_size
  __lowerCAmelCase											=						jnp.array(0      ,       dtype=jnp.floataa							)
  __lowerCAmelCase											=						0
  for batch in tqdm(SCREAMING_SNAKE_CASE__      ,       total=SCREAMING_SNAKE_CASE__      ,       desc="""Evaluating ... """							):
   __lowerCAmelCase											=						self.data_collator(SCREAMING_SNAKE_CASE__							)
   __lowerCAmelCase											=						self.val_step_fn(SCREAMING_SNAKE_CASE__      ,       **SCREAMING_SNAKE_CASE__							)
   running_loss += jax_utils.unreplicate(metrics["""loss"""]							)
   i += 1
  return running_loss / i





 def a					(      self   :	Union[str, Any]      ,       SCREAMING_SNAKE_CASE__   :	Tuple      ,       SCREAMING_SNAKE_CASE__   :	Optional[int]							)  ->    List[str]:
  __lowerCAmelCase											=						jax_utils.unreplicate(SCREAMING_SNAKE_CASE__							)
  print(f"""SAVING CHECKPOINT IN {save_dir}"""      ,       end=""" ... """							)
  self.model_save_fn(SCREAMING_SNAKE_CASE__      ,       params=state.params							)
  with open(os.path.join(SCREAMING_SNAKE_CASE__      ,       """opt_state.msgpack"""							)      ,       """wb"""							) as f:
   f.write(to_bytes(state.opt_state							)							)
  joblib.dump(self.args      ,       os.path.join(SCREAMING_SNAKE_CASE__      ,       """args.joblib"""							)							)
  joblib.dump(self.data_collator      ,       os.path.join(SCREAMING_SNAKE_CASE__      ,       """data_collator.joblib"""							)							)
  with open(os.path.join(SCREAMING_SNAKE_CASE__      ,       """training_state.json"""							)      ,       """w"""							) as f:
   json.dump({"""step""": state.step.item()}      ,       SCREAMING_SNAKE_CASE__							)
  print("""DONE"""							)







def      UpperCamelCase_						(					snake_case_       :       Union[str, Any]						,		snake_case_       :       List[Any]      )					->     Union[str, Any]:






 '''simple docstring'''

 print(f"""RESTORING CHECKPOINT FROM {save_dir}"""						,		end=""" ... """      )
 with open(os.path.join(SCREAMING_SNAKE_CASE__						,		"""flax_model.msgpack"""      )						,		"""rb"""      ) as f:
  __lowerCAmelCase											=						from_bytes(state.params						,		f.read()      )

 with open(os.path.join(SCREAMING_SNAKE_CASE__						,		"""opt_state.msgpack"""      )						,		"""rb"""      ) as f:
  __lowerCAmelCase											=						from_bytes(state.opt_state						,		f.read()      )

 __lowerCAmelCase											=						joblib.load(os.path.join(SCREAMING_SNAKE_CASE__						,		"""args.joblib"""      )      )
 __lowerCAmelCase											=						joblib.load(os.path.join(SCREAMING_SNAKE_CASE__						,		"""data_collator.joblib"""      )      )

 with open(os.path.join(SCREAMING_SNAKE_CASE__						,		"""training_state.json"""      )						,		"""r"""      ) as f:
  __lowerCAmelCase											=						json.load(SCREAMING_SNAKE_CASE__      )
 __lowerCAmelCase											=						training_state["""step"""]

 print("""DONE"""      )
 return params, opt_state, step, args, data_collator







def      UpperCamelCase_						(					snake_case_       :       int						,		snake_case_       :       int						,		snake_case_       :       Optional[Any]						,		snake_case_       :       List[Any]      )					->     List[Any]:






 '''simple docstring'''

 __lowerCAmelCase											=						num_train_steps - warmup_steps
 __lowerCAmelCase											=						optax.linear_schedule(init_value=SCREAMING_SNAKE_CASE__						,		end_value=SCREAMING_SNAKE_CASE__						,		transition_steps=SCREAMING_SNAKE_CASE__      )
 __lowerCAmelCase											=						optax.linear_schedule(init_value=SCREAMING_SNAKE_CASE__						,		end_value=1E-7						,		transition_steps=SCREAMING_SNAKE_CASE__      )
 __lowerCAmelCase											=						optax.join_schedules(schedules=[warmup_fn, decay_fn]						,		boundaries=[warmup_steps]      )
 return lr







def      UpperCamelCase_						(					snake_case_       :       int						,		snake_case_       :       Any						,		snake_case_       :       List[Any]						,		snake_case_       :       Any						,		snake_case_       :       str      )					->     Optional[Any]:






 '''simple docstring'''

 def weight_decay_mask(snake_case_       :       int      ):
  __lowerCAmelCase											=						traverse_util.flatten_dict(SCREAMING_SNAKE_CASE__      )
  __lowerCAmelCase											=						{k: (v[-1] != """bias""" and v[-2:] != ("""LayerNorm""", """scale""")) for k, v in params.items()}
  return traverse_util.unflatten_dict(SCREAMING_SNAKE_CASE__      )

 __lowerCAmelCase											=						scheduler_fn(SCREAMING_SNAKE_CASE__						,		SCREAMING_SNAKE_CASE__						,		SCREAMING_SNAKE_CASE__						,		SCREAMING_SNAKE_CASE__      )

 __lowerCAmelCase											=						optax.adamw(learning_rate=SCREAMING_SNAKE_CASE__						,		weight_decay=SCREAMING_SNAKE_CASE__						,		mask=SCREAMING_SNAKE_CASE__      )
 return tx, lr








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 __snake_case		(      unittest.TestCase     ):
    _a		:						Optional[int]=				MODEL_FOR_VIDEO_CLASSIFICATION_MAPPING
    def       _SCREAMING_SNAKE_CASE       (  self		,snake_case		,snake_case		,snake_case      ):



           '''simple docstring'''







           lowercase							:     Any       	=      hf_hub_download(
               repo_id="""nateraw/video-demo"""		,filename="""archery.mp4"""		,repo_type="""dataset"""      )
           lowercase							:     List[str]       	=      VideoClassificationPipeline(model=snake_case		,image_processor=snake_case		,top_k=2      )
           lowercase							:     Dict       	=      [
               example_video_filepath,
               """https://huggingface.co/datasets/nateraw/video-demo/resolve/main/archery.mp4""",
           ]
           return video_classifier, examples
    def       _SCREAMING_SNAKE_CASE       (  self		,snake_case		,snake_case      ):



           '''simple docstring'''







           for example in examples:
                  lowercase							:     int       	=      video_classifier(snake_case      )

                  self.assertEqual(
                      snake_case		,[
                          {"""score""": ANY(snake_case      ), """label""": ANY(snake_case      )},
                          {"""score""": ANY(snake_case      ), """label""": ANY(snake_case      )},
                      ]		,)
    @require_torch
    def       _SCREAMING_SNAKE_CASE       (  self      ):



           '''simple docstring'''







           lowercase							:     Any       	=      """hf-internal-testing/tiny-random-VideoMAEForVideoClassification"""
           lowercase							:     str       	=      VideoMAEFeatureExtractor(
               size={"""shortest_edge""": 10}		,crop_size={"""height""": 10, """width""": 10}      )
           lowercase							:     List[Any]       	=      pipeline(
               """video-classification"""		,model=snake_case		,feature_extractor=snake_case		,frame_sampling_rate=4      )

           lowercase							:     Dict       	=      hf_hub_download(repo_id="""nateraw/video-demo"""		,filename="""archery.mp4"""		,repo_type="""dataset"""      )
           lowercase							:     Any       	=      video_classifier(snake_case		,top_k=2      )
           self.assertEqual(
               nested_simplify(snake_case		,decimals=4      )		,[{"""score""": 0.5_199, """label""": """LABEL_0"""}, {"""score""": 0.4_801, """label""": """LABEL_1"""}]		,)

           lowercase							:     str       	=      video_classifier(
               [
                   video_file_path,
                   video_file_path,
               ]		,top_k=2		,)
           self.assertEqual(
               nested_simplify(snake_case		,decimals=4      )		,[
                   [{"""score""": 0.5_199, """label""": """LABEL_0"""}, {"""score""": 0.4_801, """label""": """LABEL_1"""}],
                   [{"""score""": 0.5_199, """label""": """LABEL_0"""}, {"""score""": 0.4_801, """label""": """LABEL_1"""}],
               ]		,)
    @require_tf
    def       _SCREAMING_SNAKE_CASE       (  self      ):



           '''simple docstring'''







           pass
