


import itertools
from dataclasses import dataclass
from typing import Any, Callable, Dict, List, Optional, Union

import pandas as pd
import pyarrow as pa

import datasets
import datasets.config
from datasets.features.features import require_storage_cast
from datasets.table import table_cast
from datasets.utils.py_utils import Literal


A      :    int		=					datasets.utils.logging.get_logger(__name__)

A      :    str		=					['names', 'prefix']
A      :    List[Any]		=					['warn_bad_lines', 'error_bad_lines', 'mangle_dupe_cols']
A      :    Dict		=					['encoding_errors', 'on_bad_lines']
A      :    int		=					['date_format']







@dataclass
class 			_lowercase (							datasets.BuilderConfig):


       """simple docstring"""




       A__											=			","
       A__											=			None
       A__											=			"infer"
       A__											=			None
       A__											=			None
       A__											=			None
       A__											=			None
       A__											=			None
       A__											=			True
       A__											=			None
       A__											=			None
       A__											=			None
       A__											=			None
       A__											=			False
       A__											=			None
       A__											=			None
       A__											=			None
       A__											=			True
       A__											=			True
       A__											=			False
       A__											=			True
       A__											=			None
       A__											=			"."
       A__											=			None
       A__											=			"\""
       A__											=			0
       A__											=			None
       A__											=			None
       A__											=			None
       A__											=			None
       A__											=			True
       A__											=			True
       A__											=			0
       A__											=			True
       A__											=			False
       A__											=			None
       A__											=			1_00_00
       A__											=			None
       A__											=			"strict"
       A__											=			"error"
       A__											=			None





       def 						lowerCAmelCase     (   self							:			Tuple       ):


             '''simple docstring'''



             if self.delimiter is not None:
                   lowerCamelCase__		:				Tuple    =  self.delimiter
             if self.column_names is not None:
                   lowerCamelCase__		:				Tuple    =  self.column_names





       @property
       def 						lowerCAmelCase     (   self							:			Any       ):


             '''simple docstring'''



             lowerCamelCase__		:				Tuple    =  {
                 "sep": self.sep,
                 "header": self.header,
                 "names": self.names,
                 "index_col": self.index_col,
                 "usecols": self.usecols,
                 "prefix": self.prefix,
                 "mangle_dupe_cols": self.mangle_dupe_cols,
                 "engine": self.engine,
                 "converters": self.converters,
                 "true_values": self.true_values,
                 "false_values": self.false_values,
                 "skipinitialspace": self.skipinitialspace,
                 "skiprows": self.skiprows,
                 "nrows": self.nrows,
                 "na_values": self.na_values,
                 "keep_default_na": self.keep_default_na,
                 "na_filter": self.na_filter,
                 "verbose": self.verbose,
                 "skip_blank_lines": self.skip_blank_lines,
                 "thousands": self.thousands,
                 "decimal": self.decimal,
                 "lineterminator": self.lineterminator,
                 "quotechar": self.quotechar,
                 "quoting": self.quoting,
                 "escapechar": self.escapechar,
                 "comment": self.comment,
                 "encoding": self.encoding,
                 "dialect": self.dialect,
                 "error_bad_lines": self.error_bad_lines,
                 "warn_bad_lines": self.warn_bad_lines,
                 "skipfooter": self.skipfooter,
                 "doublequote": self.doublequote,
                 "memory_map": self.memory_map,
                 "float_precision": self.float_precision,
                 "chunksize": self.chunksize,
                 "encoding_errors": self.encoding_errors,
                 "on_bad_lines": self.on_bad_lines,
                 "date_format": self.date_format,
             }

             # some kwargs must not be passed if they don't have a default value
             # some others are deprecated and we can also not pass them if they are the default value
             for pd_read_csv_parameter in _PANDAS_READ_CSV_NO_DEFAULT_PARAMETERS + _PANDAS_READ_CSV_DEPRECATED_PARAMETERS:
                   if pd_read_csv_kwargs[pd_read_csv_parameter] == getattr(CsvConfig()					,      UpperCamelCase__       ):
                         del pd_read_csv_kwargs[pd_read_csv_parameter]

                         # Remove 2.0 new arguments
             if not (datasets.config.PANDAS_VERSION.major >= 2):
                   for pd_read_csv_parameter in _PANDAS_READ_CSV_NEW_2_0_0_PARAMETERS:
                         del pd_read_csv_kwargs[pd_read_csv_parameter]

                         # Remove 1.3 new arguments
             if not (datasets.config.PANDAS_VERSION.major >= 1 and datasets.config.PANDAS_VERSION.minor >= 3):
                   for pd_read_csv_parameter in _PANDAS_READ_CSV_NEW_1_3_0_PARAMETERS:
                         del pd_read_csv_kwargs[pd_read_csv_parameter]

             return pd_read_csv_kwargs







class 			_lowercase (							datasets.ArrowBasedBuilder):


       """simple docstring"""




       A__											=			CsvConfig





       def 						lowerCAmelCase     (   self							:			Union[str, Any]       ):


             '''simple docstring'''



             return datasets.DatasetInfo(features=self.config.features       )





       def 						lowerCAmelCase     (   self							:			Any					,      __lowerCamelCase							:			List[Any]       ):


             '''simple docstring'''



             if not self.config.data_files:
                   raise ValueError(f"At least one data file must be specified, but got data_files={self.config.data_files}"       )
             lowerCamelCase__		:				int    =  dl_manager.download_and_extract(self.config.data_files       )
             if isinstance(UpperCamelCase__					,      (str, list, tuple)       ):
                   lowerCamelCase__		:				str    =  data_files
                   if isinstance(UpperCamelCase__					,      UpperCamelCase__       ):
                         lowerCamelCase__		:				Union[str, Any]    =  [files]
                   lowerCamelCase__		:				List[Any]    =  [dl_manager.iter_files(UpperCamelCase__       ) for file in files]
                   return [datasets.SplitGenerator(name=datasets.Split.TRAIN					,      gen_kwargs={"files": files}       )]
             lowerCamelCase__		:				int    =  []
             for split_name, files in data_files.items():
                   if isinstance(UpperCamelCase__					,      UpperCamelCase__       ):
                         lowerCamelCase__		:				int    =  [files]
                   lowerCamelCase__		:				List[str]    =  [dl_manager.iter_files(UpperCamelCase__       ) for file in files]
                   splits.append(datasets.SplitGenerator(name=UpperCamelCase__					,      gen_kwargs={"files": files}       )       )
             return splits





       def 						lowerCAmelCase     (   self							:			Dict					,      __lowerCamelCase							:			pa.Table       ):


             '''simple docstring'''



             if self.config.features is not None:
                   lowerCamelCase__		:				Dict    =  self.config.features.arrow_schema
                   if all(not require_storage_cast(UpperCamelCase__       ) for feature in self.config.features.values()       ):
                         # cheaper cast
                         lowerCamelCase__		:				str    =  pa.Table.from_arrays([pa_table[field.name] for field in schema]					,      schema=UpperCamelCase__       )
                   else:
                         # more expensive cast; allows str <-> int/float or str to Audio for example
                         lowerCamelCase__		:				Any    =  table_cast(UpperCamelCase__					,      UpperCamelCase__       )
             return pa_table





       def 						lowerCAmelCase     (   self							:			Any					,      __lowerCamelCase							:			List[Any]       ):


             '''simple docstring'''



             lowerCamelCase__		:				Union[str, Any]    =  self.config.features.arrow_schema if self.config.features else None
             # dtype allows reading an int column as str
             lowerCamelCase__		:				Optional[Any]    =  (
                 {
                     name: dtype.to_pandas_dtype() if not require_storage_cast(UpperCamelCase__       ) else object
                     for name, dtype, feature in zip(schema.names					,      schema.types					,      self.config.features.values()       )
                 }
                 if schema is not None
                 else None
             )
             for file_idx, file in enumerate(itertools.chain.from_iterable(UpperCamelCase__       )       ):
                   lowerCamelCase__		:				Tuple    =  pd.read_csv(UpperCamelCase__					,      iterator=UpperCamelCase__					,      dtype=UpperCamelCase__					,      **self.config.pd_read_csv_kwargs       )
                   try:
                         for batch_idx, df in enumerate(UpperCamelCase__       ):
                               lowerCamelCase__		:				str    =  pa.Table.from_pandas(UpperCamelCase__       )
                               # Uncomment for debugging (will print the Arrow table size and elements)
                               # logger.warning(f"pa_table: {pa_table} num rows: {pa_table.num_rows}")
                               # logger.warning('\n'.join(str(pa_table.slice(i, 1).to_pydict()) for i in range(pa_table.num_rows)))
                               yield (file_idx, batch_idx), self._cast_table(UpperCamelCase__       )
                   except ValueError as e:
                         logger.error(f"Failed to read file \'{file}\' with error {type(UpperCamelCase__       )}: {e}"       )
                         raise




import unittest

from transformers import AlbertConfig, is_torch_available
from transformers.models.auto import get_values
from transformers.testing_utils import 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 import (
        MODEL_FOR_PRETRAINING_MAPPING,
        AlbertForMaskedLM,
        AlbertForMultipleChoice,
        AlbertForPreTraining,
        AlbertForQuestionAnswering,
        AlbertForSequenceClassification,
        AlbertForTokenClassification,
        AlbertModel,
    )
    from transformers.models.albert.modeling_albert import ALBERT_PRETRAINED_MODEL_ARCHIVE_LIST




class        UpperCAmelCase_			:


  '''simple docstring'''







  def __init__( self			: Optional[Any]			,							UpperCamelCase__			: Optional[Any]			,							UpperCamelCase__			: int=13			,							UpperCamelCase__			: Optional[int]=7			,							UpperCamelCase__			: Any=True			,							UpperCamelCase__			: Optional[int]=True			,							UpperCamelCase__			: int=True			,							UpperCamelCase__			: Optional[Any]=True			,							UpperCamelCase__			: int=99			,							UpperCamelCase__			: Any=16			,							UpperCamelCase__			: str=36			,							UpperCamelCase__			: List[str]=6			,							UpperCamelCase__			: List[str]=6			,							UpperCamelCase__			: Union[str, Any]=6			,							UpperCamelCase__			: int=37			,							UpperCamelCase__			: Optional[int]="gelu"			,							UpperCamelCase__			: List[Any]=0.1			,							UpperCamelCase__			: Optional[int]=0.1			,							UpperCamelCase__			: int=512			,							UpperCamelCase__			: str=16			,							UpperCamelCase__			: int=2			,							UpperCamelCase__			: List[Any]=0.02			,							UpperCamelCase__			: Optional[int]=3			,							UpperCamelCase__			: Optional[Any]=4			,							UpperCamelCase__			: Dict=None			,							)			->	Any:







    """simple docstring"""






    __magic_name__				     =       parent
    __magic_name__				     =       batch_size
    __magic_name__				     =       seq_length
    __magic_name__				     =       is_training
    __magic_name__				     =       use_input_mask
    __magic_name__				     =       use_token_type_ids
    __magic_name__				     =       use_labels
    __magic_name__				     =       vocab_size
    __magic_name__				     =       embedding_size
    __magic_name__				     =       hidden_size
    __magic_name__				     =       num_hidden_layers
    __magic_name__				     =       num_hidden_groups
    __magic_name__				     =       num_attention_heads
    __magic_name__				     =       intermediate_size
    __magic_name__				     =       hidden_act
    __magic_name__				     =       hidden_dropout_prob
    __magic_name__				     =       attention_probs_dropout_prob
    __magic_name__				     =       max_position_embeddings
    __magic_name__				     =       type_vocab_size
    __magic_name__				     =       type_sequence_label_size
    __magic_name__				     =       initializer_range
    __magic_name__				     =       num_labels
    __magic_name__				     =       num_choices
    __magic_name__				     =       scope
  def 							_lowercase							( self			: Tuple    )			->	Dict:







    """simple docstring"""






    __magic_name__				     =       ids_tensor([self.batch_size, self.seq_length]			,							self.vocab_size    )

    __magic_name__				     =       None
    if self.use_input_mask:
      __magic_name__				     =       random_attention_mask([self.batch_size, self.seq_length]    )

    __magic_name__				     =       None
    if self.use_token_type_ids:
      __magic_name__				     =       ids_tensor([self.batch_size, self.seq_length]			,							self.type_vocab_size    )

    __magic_name__				     =       None
    __magic_name__				     =       None
    __magic_name__				     =       None
    if self.use_labels:
      __magic_name__				     =       ids_tensor([self.batch_size]			,							self.type_sequence_label_size    )
      __magic_name__				     =       ids_tensor([self.batch_size, self.seq_length]			,							self.num_labels    )
      __magic_name__				     =       ids_tensor([self.batch_size]			,							self.num_choices    )

    __magic_name__				     =       self.get_config()

    return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels
  def 							_lowercase							( self			: Any    )			->	List[Any]:







    """simple docstring"""






    return AlbertConfig(
        vocab_size=self.vocab_size			,							hidden_size=self.hidden_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			,							num_hidden_groups=self.num_hidden_groups			,							)
  def 							_lowercase							( self			: int			,							UpperCamelCase__			: Any			,							UpperCamelCase__			: Tuple			,							UpperCamelCase__			: int			,							UpperCamelCase__			: Dict			,							UpperCamelCase__			: List[Any]			,							UpperCamelCase__			: Optional[Any]			,							UpperCamelCase__			: Optional[Any]    )			->	Tuple:







    """simple docstring"""






    __magic_name__				     =       AlbertModel(config=UpperCamelCase__    )
    model.to(UpperCamelCase__    )
    model.eval()
    __magic_name__				     =       model(UpperCamelCase__			,							attention_mask=UpperCamelCase__			,							token_type_ids=UpperCamelCase__    )
    __magic_name__				     =       model(UpperCamelCase__			,							token_type_ids=UpperCamelCase__    )
    __magic_name__				     =       model(UpperCamelCase__    )
    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 							_lowercase							( self			: Optional[int]			,							UpperCamelCase__			: int			,							UpperCamelCase__			: Optional[int]			,							UpperCamelCase__			: Dict			,							UpperCamelCase__			: int			,							UpperCamelCase__			: Union[str, Any]			,							UpperCamelCase__			: Union[str, Any]			,							UpperCamelCase__			: Union[str, Any]    )			->	str:







    """simple docstring"""






    __magic_name__				     =       AlbertForPreTraining(config=UpperCamelCase__    )
    model.to(UpperCamelCase__    )
    model.eval()
    __magic_name__				     =       model(
        UpperCamelCase__			,							attention_mask=UpperCamelCase__			,							token_type_ids=UpperCamelCase__			,							labels=UpperCamelCase__			,							sentence_order_label=UpperCamelCase__			,							)
    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, config.num_labels)    )
  def 							_lowercase							( self			: Union[str, Any]			,							UpperCamelCase__			: Union[str, Any]			,							UpperCamelCase__			: int			,							UpperCamelCase__			: List[Any]			,							UpperCamelCase__			: Tuple			,							UpperCamelCase__			: Any			,							UpperCamelCase__			: List[str]			,							UpperCamelCase__			: Tuple    )			->	Dict:







    """simple docstring"""






    __magic_name__				     =       AlbertForMaskedLM(config=UpperCamelCase__    )
    model.to(UpperCamelCase__    )
    model.eval()
    __magic_name__				     =       model(UpperCamelCase__			,							attention_mask=UpperCamelCase__			,							token_type_ids=UpperCamelCase__			,							labels=UpperCamelCase__    )
    self.parent.assertEqual(result.logits.shape			,							(self.batch_size, self.seq_length, self.vocab_size)    )
  def 							_lowercase							( self			: Union[str, Any]			,							UpperCamelCase__			: int			,							UpperCamelCase__			: Union[str, Any]			,							UpperCamelCase__			: str			,							UpperCamelCase__			: str			,							UpperCamelCase__			: Union[str, Any]			,							UpperCamelCase__			: Optional[int]			,							UpperCamelCase__			: Tuple    )			->	List[Any]:







    """simple docstring"""






    __magic_name__				     =       AlbertForQuestionAnswering(config=UpperCamelCase__    )
    model.to(UpperCamelCase__    )
    model.eval()
    __magic_name__				     =       model(
        UpperCamelCase__			,							attention_mask=UpperCamelCase__			,							token_type_ids=UpperCamelCase__			,							start_positions=UpperCamelCase__			,							end_positions=UpperCamelCase__			,							)
    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 							_lowercase							( self			: Union[str, Any]			,							UpperCamelCase__			: Union[str, Any]			,							UpperCamelCase__			: str			,							UpperCamelCase__			: Optional[Any]			,							UpperCamelCase__			: List[str]			,							UpperCamelCase__			: Tuple			,							UpperCamelCase__			: Tuple			,							UpperCamelCase__			: int    )			->	Tuple:







    """simple docstring"""






    __magic_name__				     =       self.num_labels
    __magic_name__				     =       AlbertForSequenceClassification(UpperCamelCase__    )
    model.to(UpperCamelCase__    )
    model.eval()
    __magic_name__				     =       model(UpperCamelCase__			,							attention_mask=UpperCamelCase__			,							token_type_ids=UpperCamelCase__			,							labels=UpperCamelCase__    )
    self.parent.assertEqual(result.logits.shape			,							(self.batch_size, self.num_labels)    )
  def 							_lowercase							( self			: int			,							UpperCamelCase__			: List[Any]			,							UpperCamelCase__			: Tuple			,							UpperCamelCase__			: str			,							UpperCamelCase__			: Union[str, Any]			,							UpperCamelCase__			: Union[str, Any]			,							UpperCamelCase__			: List[str]			,							UpperCamelCase__			: Optional[int]    )			->	int:







    """simple docstring"""






    __magic_name__				     =       self.num_labels
    __magic_name__				     =       AlbertForTokenClassification(config=UpperCamelCase__    )
    model.to(UpperCamelCase__    )
    model.eval()
    __magic_name__				     =       model(UpperCamelCase__			,							attention_mask=UpperCamelCase__			,							token_type_ids=UpperCamelCase__			,							labels=UpperCamelCase__    )
    self.parent.assertEqual(result.logits.shape			,							(self.batch_size, self.seq_length, self.num_labels)    )
  def 							_lowercase							( self			: Optional[int]			,							UpperCamelCase__			: Tuple			,							UpperCamelCase__			: Optional[Any]			,							UpperCamelCase__			: List[str]			,							UpperCamelCase__			: List[Any]			,							UpperCamelCase__			: List[str]			,							UpperCamelCase__			: int			,							UpperCamelCase__			: str    )			->	List[Any]:







    """simple docstring"""






    __magic_name__				     =       self.num_choices
    __magic_name__				     =       AlbertForMultipleChoice(config=UpperCamelCase__    )
    model.to(UpperCamelCase__    )
    model.eval()
    __magic_name__				     =       input_ids.unsqueeze(1    ).expand(-1			,							self.num_choices			,							-1    ).contiguous()
    __magic_name__				     =       token_type_ids.unsqueeze(1    ).expand(-1			,							self.num_choices			,							-1    ).contiguous()
    __magic_name__				     =       input_mask.unsqueeze(1    ).expand(-1			,							self.num_choices			,							-1    ).contiguous()
    __magic_name__				     =       model(
        UpperCamelCase__			,							attention_mask=UpperCamelCase__			,							token_type_ids=UpperCamelCase__			,							labels=UpperCamelCase__			,							)
    self.parent.assertEqual(result.logits.shape			,							(self.batch_size, self.num_choices)    )





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







    """simple docstring"""






    __magic_name__				     =       self.prepare_config_and_inputs()
    (
        (
        __magic_name__
    )     ,    (
        __magic_name__
    )     ,    (
        __magic_name__
    )     ,    (
        __magic_name__
    )     ,    (
        __magic_name__
    )     ,    (
        __magic_name__
    )     ,    (
        __magic_name__
    )     ,    
    )				     =       config_and_inputs
    __magic_name__				     =       {"""input_ids""": input_ids, """token_type_ids""": token_type_ids, """attention_mask""": input_mask}
    return config, inputs_dict







@require_torch
class        UpperCAmelCase_			( _A  ,       _A  ,       unittest.TestCase     ):


  '''simple docstring'''







  a__           =		(
      (
          AlbertModel,
          AlbertForPreTraining,
          AlbertForMaskedLM,
          AlbertForMultipleChoice,
          AlbertForSequenceClassification,
          AlbertForTokenClassification,
          AlbertForQuestionAnswering,
      )
      if is_torch_available()
      else ()
  )
  a__           =		(
      {
          """feature-extraction""": AlbertModel,
          """fill-mask""": AlbertForMaskedLM,
          """question-answering""": AlbertForQuestionAnswering,
          """text-classification""": AlbertForSequenceClassification,
          """token-classification""": AlbertForTokenClassification,
          """zero-shot""": AlbertForSequenceClassification,
      }
      if is_torch_available()
      else {}
  )
  a__           =		True
  def 							_lowercase							( self			: str			,							UpperCamelCase__			: Any			,							UpperCamelCase__			: Dict			,							UpperCamelCase__			: Union[str, Any]=False    )			->	Union[str, Any]:







    """simple docstring"""






    __magic_name__				     =       super()._prepare_for_class(UpperCamelCase__			,							UpperCamelCase__			,							return_labels=UpperCamelCase__    )

    if return_labels:
      if model_class in get_values(UpperCamelCase__    ):
        __magic_name__				     =       torch.zeros(
            (self.model_tester.batch_size, self.model_tester.seq_length)			,							dtype=torch.long			,							device=UpperCamelCase__    )
        __magic_name__				     =       torch.zeros(
            self.model_tester.batch_size			,							dtype=torch.long			,							device=UpperCamelCase__    )
    return inputs_dict
  def 							_lowercase							( self			: int    )			->	int:







    """simple docstring"""






    __magic_name__				     =       AlbertModelTester(self    )
    __magic_name__				     =       ConfigTester(self			,							config_class=UpperCamelCase__			,							hidden_size=37    )
  def 							_lowercase							( self			: Optional[int]    )			->	Optional[Any]:







    """simple docstring"""






    self.config_tester.run_common_tests()
  def 							_lowercase							( self			: Dict    )			->	Dict:







    """simple docstring"""






    __magic_name__				     =       self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_model(*UpperCamelCase__    )
  def 							_lowercase							( self			: int    )			->	List[str]:







    """simple docstring"""






    __magic_name__				     =       self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_for_pretraining(*UpperCamelCase__    )
  def 							_lowercase							( self			: List[Any]    )			->	Any:







    """simple docstring"""






    __magic_name__				     =       self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_for_masked_lm(*UpperCamelCase__    )
  def 							_lowercase							( self			: Dict    )			->	Tuple:







    """simple docstring"""






    __magic_name__				     =       self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_for_multiple_choice(*UpperCamelCase__    )
  def 							_lowercase							( self			: Dict    )			->	List[Any]:







    """simple docstring"""






    __magic_name__				     =       self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_for_question_answering(*UpperCamelCase__    )
  def 							_lowercase							( self			: Union[str, Any]    )			->	Any:







    """simple docstring"""






    __magic_name__				     =       self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_for_sequence_classification(*UpperCamelCase__    )
  def 							_lowercase							( self			: Tuple    )			->	Optional[Any]:







    """simple docstring"""






    __magic_name__				     =       self.model_tester.prepare_config_and_inputs()
    for type in ["absolute", "relative_key", "relative_key_query"]:
      __magic_name__				     =       type
      self.model_tester.create_and_check_model(*UpperCamelCase__    )





  @slow
  def 							_lowercase							( self			: Optional[int]    )			->	Optional[int]:







    """simple docstring"""






    for model_name in ALBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
      __magic_name__				     =       AlbertModel.from_pretrained(UpperCamelCase__    )
      self.assertIsNotNone(UpperCamelCase__    )







@require_torch
class        UpperCAmelCase_			( unittest.TestCase     ):


  '''simple docstring'''







  @slow
  def 							_lowercase							( self			: Dict    )			->	Union[str, Any]:







    """simple docstring"""






    __magic_name__				     =       AlbertModel.from_pretrained("""albert-base-v2"""    )
    __magic_name__				     =       torch.tensor([[0, 345, 232, 328, 740, 140, 1695, 69, 6078, 1588, 2]]    )
    __magic_name__				     =       torch.tensor([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]    )
    with torch.no_grad():
      __magic_name__				     =       model(UpperCamelCase__			,							attention_mask=UpperCamelCase__    )[0]
    __magic_name__				     =       torch.Size((1, 11, 768)    )
    self.assertEqual(output.shape			,							UpperCamelCase__    )
    __magic_name__				     =       torch.tensor(
        [[[-0.6513, 1.5035, -0.2766], [-0.6515, 1.5046, -0.2780], [-0.6512, 1.5049, -0.2784]]]    )

    self.assertTrue(torch.allclose(output[:, 1:4, 1:4]			,							UpperCamelCase__			,							atol=1E-4    )    )

