code: 
  """simple docstring"""
  
  
  
  
  
  
  
  import os
  from argparse import ArgumentParser
  from pathlib import Path
  from shutil import copyfile
  from typing import List
  
  from datasets import config
  from datasets.builder import DatasetBuilder
  from datasets.commands import BaseDatasetsCLICommand
  from datasets.download.download_config import DownloadConfig
  from datasets.download.download_manager import DownloadMode
  from datasets.load import dataset_module_factory, import_main_class
  from datasets.utils.info_utils import VerificationMode
  def 			__UpperCAmelCase		(		a_			:		Optional[int]    ,  **a_			:		Optional[int]				)     ->       Optional[int]:
     return RunBeamCommand(
         args.dataset    ,  args.name    ,  args.cache_dir    ,  args.beam_pipeline_options    ,  args.data_dir    ,  args.all_configs    ,  args.save_info or args.save_infos    ,  args.ignore_verifications    ,  args.force_redownload    ,  **a_    ,  )
  
  
  
  
  
  
  class     __a			(					lowerCAmelCase_			):
  
  
  
  
  
  
  
         @staticmethod
         def    _snake_case			(					lowerCamelCase_		):
  
  
  
            '''simple docstring'''
  
            _UpperCAmelCase   	=					parser.add_parser("run_beam"							,help="Run a Beam dataset processing pipeline"		)
            run_beam_parser.add_argument("dataset"							,type=lowerCamelCase_							,help="Name of the dataset to download"		)
            run_beam_parser.add_argument("--name"							,type=lowerCamelCase_							,default=lowerCamelCase_							,help="Dataset config name"		)
            run_beam_parser.add_argument(
                "--cache_dir"							,type=lowerCamelCase_							,default=lowerCamelCase_							,help="Cache directory where the datasets are stored"							,)
            run_beam_parser.add_argument(
                "--beam_pipeline_options"							,type=lowerCamelCase_							,default=""							,help="Beam pipeline options, separated by commas. Example:: `--beam_pipeline_options=job_name=my-job,project=my-project`"							,)
            run_beam_parser.add_argument(
                "--data_dir"							,type=lowerCamelCase_							,default=lowerCamelCase_							,help="Can be used to specify a manual directory to get the files from"							,)
            run_beam_parser.add_argument("--all_configs"							,action="store_true"							,help="Test all dataset configurations"		)
            run_beam_parser.add_argument("--save_info"							,action="store_true"							,help="Save the dataset infos file"		)
            run_beam_parser.add_argument(
                "--ignore_verifications"							,action="store_true"							,help="Run the test without checksums and splits checks"		)
            run_beam_parser.add_argument("--force_redownload"							,action="store_true"							,help="Force dataset redownload"		)
            # aliases
            run_beam_parser.add_argument("--save_infos"							,action="store_true"							,help="alias for save_info"		)
            run_beam_parser.set_defaults(func=lowerCamelCase_		)
  
  
  
  
  
  
  
         def __init__(					self							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_							,**lowerCamelCase_							,):
  
  
  
            '''simple docstring'''
  
            _UpperCAmelCase   	=					dataset
            _UpperCAmelCase   	=					name
            _UpperCAmelCase   	=					cache_dir
            _UpperCAmelCase   	=					beam_pipeline_options
            _UpperCAmelCase   	=					data_dir
            _UpperCAmelCase   	=					all_configs
            _UpperCAmelCase   	=					save_infos
            _UpperCAmelCase   	=					ignore_verifications
            _UpperCAmelCase   	=					force_redownload
            _UpperCAmelCase   	=					config_kwargs
  
  
  
  
  
  
  
         def    _snake_case			(					self		):
  
  
  
            '''simple docstring'''
  
            import apache_beam as beam
  
            if self._name is not None and self._all_configs:
               print("Both parameters `name` and `all_configs` can't be used at once."		)
               exit(1		)
            _UpperCAmelCase	,							_UpperCAmelCase   	=					self._dataset, self._name
            _UpperCAmelCase   	=					dataset_module_factory(lowerCamelCase_		)
            _UpperCAmelCase   	=					import_main_class(dataset_module.module_path		)
            _UpperCAmelCase   	=					[]
            if self._beam_pipeline_options:
               _UpperCAmelCase   	=					beam.options.pipeline_options.PipelineOptions(
                   flags=[f'''--{opt.strip()}''' for opt in self._beam_pipeline_options.split(","		) if opt]		)
            else:
               _UpperCAmelCase   	=					None
            if self._all_configs and len(builder_cls.BUILDER_CONFIGS		) > 0:
               for builder_config in builder_cls.BUILDER_CONFIGS:
                  builders.append(
                      builder_cls(
                          config_name=builder_config.name							,data_dir=self._data_dir							,hash=dataset_module.hash							,beam_options=lowerCamelCase_							,cache_dir=self._cache_dir							,base_path=dataset_module.builder_kwargs.get("base_path"		)							,)		)
            else:
               builders.append(
                   builder_cls(
                       config_name=lowerCamelCase_							,data_dir=self._data_dir							,beam_options=lowerCamelCase_							,cache_dir=self._cache_dir							,base_path=dataset_module.builder_kwargs.get("base_path"		)							,**self._config_kwargs							,)		)
  
            for builder in builders:
               builder.download_and_prepare(
                   download_mode=DownloadMode.REUSE_CACHE_IF_EXISTS
                   if not self._force_redownload
                   else DownloadMode.FORCE_REDOWNLOAD							,download_config=DownloadConfig(cache_dir=config.DOWNLOADED_DATASETS_PATH		)							,verification_mode=VerificationMode.NO_CHECKS
                   if self._ignore_verifications
                   else VerificationMode.ALL_CHECKS							,try_from_hf_gcs=lowerCamelCase_							,)
               if self._save_infos:
                  builder._save_infos()
  
            print("Apache beam run successful."		)
  
            # If save_infos=True, the dataset infos file is created next to the loaded module file.
            # Let's move it to the original directory of the dataset script, to allow the user to
            # upload them on S3 at the same time afterwards.
            if self._save_infos:
               _UpperCAmelCase   	=					os.path.join(builder_cls.get_imported_module_dir()							,config.DATASETDICT_INFOS_FILENAME		)
  
               _UpperCAmelCase   	=					Path(lowerCamelCase_		).name + ".py"
  
               _UpperCAmelCase   	=					os.path.join(lowerCamelCase_							,lowerCamelCase_		)
               if os.path.isfile(lowerCamelCase_		):
                  _UpperCAmelCase   	=					os.path.dirname(lowerCamelCase_		)
               elif os.path.isfile(lowerCamelCase_		):
                  _UpperCAmelCase   	=					path
               else:  # in case of a remote dataset
                  print(f'''Dataset Infos file saved at {dataset_infos_path}'''		)
                  exit(1		)
  
               # Move datasetinfo back to the user
               _UpperCAmelCase   	=					os.path.join(lowerCamelCase_							,config.DATASETDICT_INFOS_FILENAME		)
               copyfile(lowerCamelCase_							,lowerCamelCase_		)
               print(f'''Dataset Infos file saved at {user_dataset_infos_path}'''		)
  
  
style_context: 
  """simple docstring"""
  
  
  
  
  
  
  
  from __future__ import annotations
  
  import unittest
  
  from transformers import AlbertConfig, is_tf_available
  from transformers.models.auto import get_values
  from transformers.testing_utils import require_tf, slow
  
  from ...test_configuration_common import ConfigTester
  from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask
  from ...test_pipeline_mixin import PipelineTesterMixin
  
  
  if is_tf_available():
    import tensorflow as tf
  
    from transformers import TF_MODEL_FOR_PRETRAINING_MAPPING
    from transformers.models.albert.modeling_tf_albert import (
        TF_ALBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
        TFAlbertForMaskedLM,
        TFAlbertForMultipleChoice,
        TFAlbertForPreTraining,
        TFAlbertForQuestionAnswering,
        TFAlbertForSequenceClassification,
        TFAlbertForTokenClassification,
        TFAlbertModel,
    )
  
  
  
  
  
  
  class     __a			:
  
  
  
  
  
  
  
         def __init__(					self							,lowerCamelCase_							,lowerCamelCase_=13							,lowerCamelCase_=7							,lowerCamelCase_=True							,lowerCamelCase_=True							,lowerCamelCase_=True							,lowerCamelCase_=True							,lowerCamelCase_=99							,lowerCamelCase_=16							,lowerCamelCase_=32							,lowerCamelCase_=2							,lowerCamelCase_=4							,lowerCamelCase_=37							,lowerCamelCase_="gelu"							,lowerCamelCase_=0.1							,lowerCamelCase_=0.1							,lowerCamelCase_=512							,lowerCamelCase_=16							,lowerCamelCase_=2							,lowerCamelCase_=0.0_2							,lowerCamelCase_=3							,lowerCamelCase_=4							,lowerCamelCase_=None							,):
  
  
  
            '''simple docstring'''
  
            _UpperCAmelCase   	=					parent
            _UpperCAmelCase   	=					13
            _UpperCAmelCase   	=					7
            _UpperCAmelCase   	=					True
            _UpperCAmelCase   	=					True
            _UpperCAmelCase   	=					True
            _UpperCAmelCase   	=					True
            _UpperCAmelCase   	=					99
            _UpperCAmelCase   	=					16
            _UpperCAmelCase   	=					32
            _UpperCAmelCase   	=					2
            _UpperCAmelCase   	=					4
            _UpperCAmelCase   	=					37
            _UpperCAmelCase   	=					"gelu"
            _UpperCAmelCase   	=					0.1
            _UpperCAmelCase   	=					0.1
            _UpperCAmelCase   	=					512
            _UpperCAmelCase   	=					16
            _UpperCAmelCase   	=					2
            _UpperCAmelCase   	=					0.0_2
            _UpperCAmelCase   	=					3
            _UpperCAmelCase   	=					4
            _UpperCAmelCase   	=					None
  
  
  
  
  
  
  
         def    _snake_case			(					self		):
  
  
  
            '''simple docstring'''
  
            _UpperCAmelCase   	=					ids_tensor([self.batch_size, self.seq_length]							,self.vocab_size		)
  
            _UpperCAmelCase   	=					None
            if self.use_input_mask:
               _UpperCAmelCase   	=					random_attention_mask([self.batch_size, self.seq_length]		)
  
            _UpperCAmelCase   	=					None
            if self.use_token_type_ids:
               _UpperCAmelCase   	=					ids_tensor([self.batch_size, self.seq_length]							,self.type_vocab_size		)
  
            _UpperCAmelCase   	=					None
            _UpperCAmelCase   	=					None
            _UpperCAmelCase   	=					None
            if self.use_labels:
               _UpperCAmelCase   	=					ids_tensor([self.batch_size]							,self.type_sequence_label_size		)
               _UpperCAmelCase   	=					ids_tensor([self.batch_size, self.seq_length]							,self.num_labels		)
               _UpperCAmelCase   	=					ids_tensor([self.batch_size]							,self.num_choices		)
  
            _UpperCAmelCase   	=					AlbertConfig(
                vocab_size=self.vocab_size							,hidden_size=self.hidden_size							,embedding_size=self.embedding_size							,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							,)
  
            return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels
  
  
  
  
  
  
  
         def    _snake_case			(					self							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_		):
  
  
  
            '''simple docstring'''
  
            _UpperCAmelCase   	=					TFAlbertModel(config=lowerCamelCase_		)
            # inputs = {'input_ids': input_ids,
            #           'attention_mask': input_mask,
            #           'token_type_ids': token_type_ids}
            # sequence_output, pooled_output = model(**inputs)
            _UpperCAmelCase   	=					{"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
            _UpperCAmelCase   	=					model(lowerCamelCase_		)
  
            _UpperCAmelCase   	=					[input_ids, input_mask]
            _UpperCAmelCase   	=					model(lowerCamelCase_		)
  
            _UpperCAmelCase   	=					model(lowerCamelCase_		)
  
            self.parent.assertEqual(result.last_hidden_state.shape							,(self.batch_size, self.seq_length, self.hidden_size)		)
            self.parent.assertEqual(result.pooler_output.shape							,(self.batch_size, self.hidden_size)		)
  
  
  
  
  
  
  
         def    _snake_case			(					self							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_		):
  
  
  
            '''simple docstring'''
  
            _UpperCAmelCase   	=					self.num_labels
            _UpperCAmelCase   	=					TFAlbertForPreTraining(config=lowerCamelCase_		)
            _UpperCAmelCase   	=					{"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
            _UpperCAmelCase   	=					model(lowerCamelCase_		)
            self.parent.assertEqual(result.prediction_logits.shape							,(self.batch_size, self.seq_length, self.vocab_size)		)
            self.parent.assertEqual(result.sop_logits.shape							,(self.batch_size, self.num_labels)		)
  
  
  
  
  
  
  
         def    _snake_case			(					self							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_		):
  
  
  
            '''simple docstring'''
  
            _UpperCAmelCase   	=					TFAlbertForMaskedLM(config=lowerCamelCase_		)
            _UpperCAmelCase   	=					{"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
            _UpperCAmelCase   	=					model(lowerCamelCase_		)
            self.parent.assertEqual(result.logits.shape							,(self.batch_size, self.seq_length, self.vocab_size)		)
  
  
  
  
  
  
  
         def    _snake_case			(					self							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_		):
  
  
  
            '''simple docstring'''
  
            _UpperCAmelCase   	=					self.num_labels
            _UpperCAmelCase   	=					TFAlbertForSequenceClassification(config=lowerCamelCase_		)
            _UpperCAmelCase   	=					{"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
            _UpperCAmelCase   	=					model(lowerCamelCase_		)
            self.parent.assertEqual(result.logits.shape							,(self.batch_size, self.num_labels)		)
  
  
  
  
  
  
  
         def    _snake_case			(					self							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_		):
  
  
  
            '''simple docstring'''
  
            _UpperCAmelCase   	=					TFAlbertForQuestionAnswering(config=lowerCamelCase_		)
            _UpperCAmelCase   	=					{"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
            _UpperCAmelCase   	=					model(lowerCamelCase_		)
            self.parent.assertEqual(result.start_logits.shape							,(self.batch_size, self.seq_length)		)
            self.parent.assertEqual(result.end_logits.shape							,(self.batch_size, self.seq_length)		)
  
  
  
  
  
  
  
         def    _snake_case			(					self							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_		):
  
  
  
            '''simple docstring'''
  
            _UpperCAmelCase   	=					self.num_choices
            _UpperCAmelCase   	=					TFAlbertForMultipleChoice(config=lowerCamelCase_		)
            _UpperCAmelCase   	=					tf.tile(tf.expand_dims(lowerCamelCase_							,1		)							,(1, self.num_choices, 1)		)
            _UpperCAmelCase   	=					tf.tile(tf.expand_dims(lowerCamelCase_							,1		)							,(1, self.num_choices, 1)		)
            _UpperCAmelCase   	=					tf.tile(tf.expand_dims(lowerCamelCase_							,1		)							,(1, self.num_choices, 1)		)
            _UpperCAmelCase   	=					{
                "input_ids": multiple_choice_inputs_ids,
                "attention_mask": multiple_choice_input_mask,
                "token_type_ids": multiple_choice_token_type_ids,
            }
            _UpperCAmelCase   	=					model(lowerCamelCase_		)
            self.parent.assertListEqual(list(result["logits"].shape		)							,[self.batch_size, self.num_choices]		)
  
  
  
  
  
  
  
         def    _snake_case			(					self							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_		):
  
  
  
            '''simple docstring'''
  
            _UpperCAmelCase   	=					self.num_labels
            _UpperCAmelCase   	=					TFAlbertForTokenClassification(config=lowerCamelCase_		)
            _UpperCAmelCase   	=					{
                "input_ids": input_ids,
                "attention_mask": input_mask,
                "token_type_ids": token_type_ids,
            }
            _UpperCAmelCase   	=					model(lowerCamelCase_		)
            self.parent.assertListEqual(list(result["logits"].shape		)							,[self.batch_size, self.seq_length, self.num_labels]		)
  
  
  
  
  
  
  
         def    _snake_case			(					self		):
  
  
  
            '''simple docstring'''
  
            _UpperCAmelCase   	=					self.prepare_config_and_inputs()
            (
                (
                _UpperCAmelCase
            )	,							(
                _UpperCAmelCase
            )	,							(
                _UpperCAmelCase
            )	,							(
                _UpperCAmelCase
            )	,							(
                _UpperCAmelCase
            )	,							(
                _UpperCAmelCase
            )	,							(
                _UpperCAmelCase
            )	,							
            )   	=					config_and_inputs
            _UpperCAmelCase   	=					{"input_ids": input_ids, "token_type_ids": token_type_ids, "attention_mask": input_mask}
            return config, inputs_dict
  
  
  
  
  
  
  @require_tf
  class     __a			(					lowerCAmelCase_				,	lowerCAmelCase_				,	unittest.TestCase			):
         _lowerCamelCase							:							Any       =			(
             (
                 TFAlbertModel,
                 TFAlbertForPreTraining,
                 TFAlbertForMaskedLM,
                 TFAlbertForSequenceClassification,
                 TFAlbertForQuestionAnswering,
                 TFAlbertForTokenClassification,
                 TFAlbertForMultipleChoice,
             )
             if is_tf_available()
             else ()
         )
         _lowerCamelCase							:							int       =			(
             {
                 'feature-extraction': TFAlbertModel,
                 'fill-mask': TFAlbertForMaskedLM,
                 'question-answering': TFAlbertForQuestionAnswering,
                 'text-classification': TFAlbertForSequenceClassification,
                 'token-classification': TFAlbertForTokenClassification,
                 'zero-shot': TFAlbertForSequenceClassification,
             }
             if is_tf_available()
             else {}
         )
         _lowerCamelCase							:							List[str]       =			False
         _lowerCamelCase							:							Optional[Any]       =			False
  
  
  
  
  
  
  
         def    _snake_case			(					self							,lowerCamelCase_							,lowerCamelCase_							,lowerCamelCase_=False		):
  
  
  
            '''simple docstring'''
  
            _UpperCAmelCase   	=					super()._prepare_for_class(lowerCamelCase_							,lowerCamelCase_							,return_labels=lowerCamelCase_		)
  
            if return_labels:
               if model_class in get_values(lowerCamelCase_		):
                  _UpperCAmelCase   	=					tf.zeros(self.model_tester.batch_size							,dtype=tf.intaa		)
  
            return inputs_dict
  
  
  
  
  
  
  
         def    _snake_case			(					self		):
  
  
  
            '''simple docstring'''
  
            _UpperCAmelCase   	=					TFAlbertModelTester(self		)
            _UpperCAmelCase   	=					ConfigTester(self							,config_class=lowerCamelCase_							,hidden_size=37		)
  
  
  
  
  
  
  
         def    _snake_case			(					self		):
  
  
  
            '''simple docstring'''
  
            self.config_tester.run_common_tests()
  
  
  
  
  
  
  
         def    _snake_case			(					self		):
  
  
  
            '''simple docstring'''
  
            _UpperCAmelCase   	=					self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_albert_model(*lowerCamelCase_		)
  
  
  
  
  
  
  
         def    _snake_case			(					self		):
  
  
  
            '''simple docstring'''
  
            _UpperCAmelCase   	=					self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_albert_for_pretraining(*lowerCamelCase_		)
  
  
  
  
  
  
  
         def    _snake_case			(					self		):
  
  
  
            '''simple docstring'''
  
            _UpperCAmelCase   	=					self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_albert_for_masked_lm(*lowerCamelCase_		)
  
  
  
  
  
  
  
         def    _snake_case			(					self		):
  
  
  
            '''simple docstring'''
  
            _UpperCAmelCase   	=					self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_albert_for_multiple_choice(*lowerCamelCase_		)
  
  
  
  
  
  
  
         def    _snake_case			(					self		):
  
  
  
            '''simple docstring'''
  
            _UpperCAmelCase   	=					self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_albert_for_sequence_classification(*lowerCamelCase_		)
  
  
  
  
  
  
  
         def    _snake_case			(					self		):
  
  
  
            '''simple docstring'''
  
            _UpperCAmelCase   	=					self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_albert_for_question_answering(*lowerCamelCase_		)
  
  
  
  
  
  
  
         @slow
         def    _snake_case			(					self		):
  
  
  
            '''simple docstring'''
  
            for model_name in TF_ALBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
               _UpperCAmelCase   	=					TFAlbertModel.from_pretrained(lowerCamelCase_		)
               self.assertIsNotNone(lowerCamelCase_		)
  
  
  
  
  
  
  @require_tf
  class     __a			(					unittest.TestCase			):
  
  
  
  
  
  
  
         @slow
         def    _snake_case			(					self		):
  
  
  
            '''simple docstring'''
  
            _UpperCAmelCase   	=					TFAlbertForPreTraining.from_pretrained("albert-base-v2"		)
            _UpperCAmelCase   	=					tf.constant([[0, 1, 2, 3, 4, 5]]		)
            _UpperCAmelCase   	=					model(lowerCamelCase_		)[0]
  
            _UpperCAmelCase   	=					[1, 6, 3_0000]
            self.assertEqual(output.shape							,lowerCamelCase_		)
  
            _UpperCAmelCase   	=					tf.constant(
                [
                    [
                        [4.5_9_5_6_6_8, 0.7_4_4_6_2_7_5_4, -1.8_1_8_1_4_7],
                        [4.5_9_5_4_3_4_7, 0.7_4_5_4_1_8_4, -1.8_1_8_8_2_5_8],
                        [4.5_9_5_4_9_0_5, 0.7_4_4_8_2_3_5, -1.8_1_8_2_3_1_6],
                    ]
                ]		)
            tf.debugging.assert_near(output[:, :3, :3]							,lowerCamelCase_							,atol=1e-4		)
  
  