




"""simple docstring"""



import contextlib
import csv
import json
import os
import sqlitea
import tarfile
import textwrap
import zipfile

import pyarrow as pa
import pyarrow.parquet as pq
import pytest

import datasets
import datasets.config



@pytest.fixture(scope="session"							)
def 					_lowerCamelCase(					):
       __a     				=  1_0
       __a     				=  datasets.Features(
           {
               "tokens": datasets.Sequence(datasets.Value("string"							)							),
               "labels": datasets.Sequence(datasets.ClassLabel(names=["negative", "positive"]							)							),
               "answers": datasets.Sequence(
                   {
                       "text": datasets.Value("string"							),
                       "answer_start": datasets.Value("int32"							),
                   }							),
               "id": datasets.Value("int64"							),
           }							)
       __a     				=  datasets.Dataset.from_dict(
           {
               "tokens": [["foo"] * 5] * n,
               "labels": [[1] * 5] * n,
               "answers": [{"answer_start": [9_7], "text": ["1976"]}] * 1_0,
               "id": list(range(_a							)							),
           } ,  features=_a ,  )
       return dataset



@pytest.fixture(scope="session"							)
def 					_lowerCamelCase(					a ,  a							):
       __a     				=  str(tmp_path_factory.mktemp("data"							) / "file.arrow"							)
       dataset.map(cache_file_name=_a							)
       return filename


# FILE_CONTENT + files


SCREAMING_SNAKE_CASE__:List[str]			=	"""\
    Text data.
    Second line of data."""



@pytest.fixture(scope="session"							)
def 					_lowerCamelCase(					a							):
       __a     				=  tmp_path_factory.mktemp("data"							) / """file.txt"""
       __a     				=  FILE_CONTENT
       with open(_a ,  "w"							) as f:
              f.write(_a							)
       return filename



@pytest.fixture(scope="session"							)
def 					_lowerCamelCase(					a							):
       import bza

       __a     				=  tmp_path_factory.mktemp("data"							) / """file.txt.bz2"""
       __a     				=  bytes(_a ,  "utf-8"							)
       with bza.open(_a ,  "wb"							) as f:
              f.write(_a							)
       return path



@pytest.fixture(scope="session"							)
def 					_lowerCamelCase(					a							):
       import gzip

       __a     				=  str(tmp_path_factory.mktemp("data"							) / "file.txt.gz"							)
       __a     				=  bytes(_a ,  "utf-8"							)
       with gzip.open(_a ,  "wb"							) as f:
              f.write(_a							)
       return path



@pytest.fixture(scope="session"							)
def 					_lowerCamelCase(					a							):




       if datasets.config.LZ4_AVAILABLE:
              import lza.frame

              __a     				=  tmp_path_factory.mktemp("data"							) / """file.txt.lz4"""
              __a     				=  bytes(_a ,  "utf-8"							)
              with lza.frame.open(_a ,  "wb"							) as f:
                     f.write(_a							)
              return path



@pytest.fixture(scope="session"							)
def 					_lowerCamelCase(					a ,  a							):




       if datasets.config.PY7ZR_AVAILABLE:
              import pyazr

              __a     				=  tmp_path_factory.mktemp("data"							) / """file.txt.7z"""
              with pyazr.SevenZipFile(_a ,  "w"							) as archive:
                     archive.write(_a ,  arcname=os.path.basename(_a							)							)
              return path



@pytest.fixture(scope="session"							)
def 					_lowerCamelCase(					a ,  a							):
       import tarfile

       __a     				=  tmp_path_factory.mktemp("data"							) / """file.txt.tar"""
       with tarfile.TarFile(_a ,  "w"							) as f:
              f.add(_a ,  arcname=os.path.basename(_a							)							)
       return path



@pytest.fixture(scope="session"							)
def 					_lowerCamelCase(					a							):
       import lzma

       __a     				=  tmp_path_factory.mktemp("data"							) / """file.txt.xz"""
       __a     				=  bytes(_a ,  "utf-8"							)
       with lzma.open(_a ,  "wb"							) as f:
              f.write(_a							)
       return path



@pytest.fixture(scope="session"							)
def 					_lowerCamelCase(					a ,  a							):
       import zipfile

       __a     				=  tmp_path_factory.mktemp("data"							) / """file.txt.zip"""
       with zipfile.ZipFile(_a ,  "w"							) as f:
              f.write(_a ,  arcname=os.path.basename(_a							)							)
       return path



@pytest.fixture(scope="session"							)
def 					_lowerCamelCase(					a							):




       if datasets.config.ZSTANDARD_AVAILABLE:
              import zstandard as zstd

              __a     				=  tmp_path_factory.mktemp("data"							) / """file.txt.zst"""
              __a     				=  bytes(_a ,  "utf-8"							)
              with zstd.open(_a ,  "wb"							) as f:
                     f.write(_a							)
              return path



@pytest.fixture(scope="session"							)
def 					_lowerCamelCase(					a							):
       __a     				=  tmp_path_factory.mktemp("data"							) / """file.xml"""
       __a     				=  textwrap.dedent(
           "\\n    <?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n    <tmx version=\"1.4\">\n      <header segtype=\"sentence\" srclang=\"ca\" />\n      <body>\n        <tu>\n          <tuv xml:lang=\"ca\"><seg>Contingut 1</seg></tuv>\n          <tuv xml:lang=\"en\"><seg>Content 1</seg></tuv>\n        </tu>\n        <tu>\n          <tuv xml:lang=\"ca\"><seg>Contingut 2</seg></tuv>\n          <tuv xml:lang=\"en\"><seg>Content 2</seg></tuv>\n        </tu>\n        <tu>\n          <tuv xml:lang=\"ca\"><seg>Contingut 3</seg></tuv>\n          <tuv xml:lang=\"en\"><seg>Content 3</seg></tuv>\n        </tu>\n        <tu>\n          <tuv xml:lang=\"ca\"><seg>Contingut 4</seg></tuv>\n          <tuv xml:lang=\"en\"><seg>Content 4</seg></tuv>\n        </tu>\n        <tu>\n          <tuv xml:lang=\"ca\"><seg>Contingut 5</seg></tuv>\n          <tuv xml:lang=\"en\"><seg>Content 5</seg></tuv>\n        </tu>\n      </body>\n    </tmx>"							)
       with open(_a ,  "w"							) as f:
              f.write(_a							)
       return filename


SCREAMING_SNAKE_CASE__:List[str]			=	[
    {"""col_1""": """0""", """col_2""": 0, """col_3""": 0.0},
    {"""col_1""": """1""", """col_2""": 1, """col_3""": 1.0},
    {"""col_1""": """2""", """col_2""": 2, """col_3""": 2.0},
    {"""col_1""": """3""", """col_2""": 3, """col_3""": 3.0},
]
SCREAMING_SNAKE_CASE__:Any			=	[
    {"""col_1""": """4""", """col_2""": 4, """col_3""": 4.0},
    {"""col_1""": """5""", """col_2""": 5, """col_3""": 5.0},
]
SCREAMING_SNAKE_CASE__:Dict			=	{
    """col_1""": ["""0""", """1""", """2""", """3"""],
    """col_2""": [0, 1, 2, 3],
    """col_3""": [0.0, 1.0, 2.0, 3.0],
}

SCREAMING_SNAKE_CASE__:Union[str, Any]			=	[
    {"""col_3""": 0.0, """col_1""": """0""", """col_2""": 0},
    {"""col_3""": 1.0, """col_1""": """1""", """col_2""": 1},
]

SCREAMING_SNAKE_CASE__:Optional[Any]			=	[
    {"""col_1""": """s0""", """col_2""": 0, """col_3""": 0.0},
    {"""col_1""": """s1""", """col_2""": 1, """col_3""": 1.0},
    {"""col_1""": """s2""", """col_2""": 2, """col_3""": 2.0},
    {"""col_1""": """s3""", """col_2""": 3, """col_3""": 3.0},
]



@pytest.fixture(scope="session"							)
def 					_lowerCamelCase(					):
       return DATA_DICT_OF_LISTS



@pytest.fixture(scope="session"							)
def 					_lowerCamelCase(					a							):
       __a     				=  datasets.Dataset.from_dict(_a							)
       __a     				=  str(tmp_path_factory.mktemp("data"							) / "dataset.arrow"							)
       dataset.map(cache_file_name=_a							)
       return path



@pytest.fixture(scope="session"							)
def 					_lowerCamelCase(					a							):
       __a     				=  str(tmp_path_factory.mktemp("data"							) / "dataset.sqlite"							)
       with contextlib.closing(sqlitea.connect(_a							)							) as con:
              __a     				=  con.cursor()
              cur.execute("CREATE TABLE dataset(col_1 text, col_2 int, col_3 real)"							)
              for item in DATA:
                     cur.execute("INSERT INTO dataset(col_1, col_2, col_3) VALUES (?, ?, ?)" ,  tuple(item.values()							)							)
              con.commit()
       return path



@pytest.fixture(scope="session"							)
def 					_lowerCamelCase(					a							):
       __a     				=  str(tmp_path_factory.mktemp("data"							) / "dataset.csv"							)
       with open(_a ,  "w" ,  newline=""							) as f:
              __a     				=  csv.DictWriter(_a ,  fieldnames=["col_1", "col_2", "col_3"]							)
              writer.writeheader()
              for item in DATA:
                     writer.writerow(_a							)
       return path



@pytest.fixture(scope="session"							)
def 					_lowerCamelCase(					a							):
       __a     				=  str(tmp_path_factory.mktemp("data"							) / "dataset2.csv"							)
       with open(_a ,  "w" ,  newline=""							) as f:
              __a     				=  csv.DictWriter(_a ,  fieldnames=["col_1", "col_2", "col_3"]							)
              writer.writeheader()
              for item in DATA:
                     writer.writerow(_a							)
       return path



@pytest.fixture(scope="session"							)
def 					_lowerCamelCase(					a ,  a							):
       import bza

       __a     				=  tmp_path_factory.mktemp("data"							) / """dataset.csv.bz2"""
       with open(_a ,  "rb"							) as f:
              __a     				=  f.read()
       # data = bytes(FILE_CONTENT, "utf-8")
       with bza.open(_a ,  "wb"							) as f:
              f.write(_a							)
       return path



@pytest.fixture(scope="session"							)
def 					_lowerCamelCase(					a ,  a ,  a							):
       __a     				=  tmp_path_factory.mktemp("data"							) / """dataset.csv.zip"""
       with zipfile.ZipFile(_a ,  "w"							) as f:
              f.write(_a ,  arcname=os.path.basename(_a							)							)
              f.write(_a ,  arcname=os.path.basename(_a							)							)
       return path



@pytest.fixture(scope="session"							)
def 					_lowerCamelCase(					a ,  a ,  a							):
       __a     				=  tmp_path_factory.mktemp("data"							) / """dataset.csv.zip"""
       with zipfile.ZipFile(_a ,  "w"							) as f:
              f.write(_a ,  arcname=os.path.basename(csv_path.replace(".csv" ,  ".CSV"							)							)							)
              f.write(_a ,  arcname=os.path.basename(csva_path.replace(".csv" ,  ".CSV"							)							)							)
       return path



@pytest.fixture(scope="session"							)
def 					_lowerCamelCase(					a ,  a ,  a							):
       __a     				=  tmp_path_factory.mktemp("data"							) / """dataset_with_dir.csv.zip"""
       with zipfile.ZipFile(_a ,  "w"							) as f:
              f.write(_a ,  arcname=os.path.join("main_dir" ,  os.path.basename(_a							)							)							)
              f.write(_a ,  arcname=os.path.join("main_dir" ,  os.path.basename(_a							)							)							)
       return path



@pytest.fixture(scope="session"							)
def 					_lowerCamelCase(					a							):
       __a     				=  str(tmp_path_factory.mktemp("data"							) / "dataset.parquet"							)
       __a     				=  pa.schema(
           {
               "col_1": pa.string(),
               "col_2": pa.intaa(),
               "col_3": pa.floataa(),
           }							)
       with open(_a ,  "wb"							) as f:
              __a     				=  pq.ParquetWriter(_a ,  schema=_a							)
              __a     				=  pa.Table.from_pydict({k: [DATA[i][k] for i in range(len(_a							)							)] for k in DATA[0]} ,  schema=_a							)
              writer.write_table(_a							)
              writer.close()
       return path



@pytest.fixture(scope="session"							)
def 					_lowerCamelCase(					a							):
       __a     				=  str(tmp_path_factory.mktemp("data"							) / "dataset.json"							)
       __a     				=  {"""data""": DATA}
       with open(_a ,  "w"							) as f:
              json.dump(_a ,  _a							)
       return path



@pytest.fixture(scope="session"							)
def 					_lowerCamelCase(					a							):
       __a     				=  str(tmp_path_factory.mktemp("data"							) / "dataset.json"							)
       __a     				=  {"""data""": DATA_DICT_OF_LISTS}
       with open(_a ,  "w"							) as f:
              json.dump(_a ,  _a							)
       return path



@pytest.fixture(scope="session"							)
def 					_lowerCamelCase(					a							):
       __a     				=  str(tmp_path_factory.mktemp("data"							) / "dataset.jsonl"							)
       with open(_a ,  "w"							) as f:
              for item in DATA:
                     f.write(json.dumps(_a							) + "\n"							)
       return path



@pytest.fixture(scope="session"							)
def 					_lowerCamelCase(					a							):
       __a     				=  str(tmp_path_factory.mktemp("data"							) / "dataset2.jsonl"							)
       with open(_a ,  "w"							) as f:
              for item in DATA:
                     f.write(json.dumps(_a							) + "\n"							)
       return path



@pytest.fixture(scope="session"							)
def 					_lowerCamelCase(					a							):
       __a     				=  str(tmp_path_factory.mktemp("data"							) / "dataset_312.jsonl"							)
       with open(_a ,  "w"							) as f:
              for item in DATA_312:
                     f.write(json.dumps(_a							) + "\n"							)
       return path



@pytest.fixture(scope="session"							)
def 					_lowerCamelCase(					a							):
       __a     				=  str(tmp_path_factory.mktemp("data"							) / "dataset-str.jsonl"							)
       with open(_a ,  "w"							) as f:
              for item in DATA_STR:
                     f.write(json.dumps(_a							) + "\n"							)
       return path



@pytest.fixture(scope="session"							)
def 					_lowerCamelCase(					a ,  a							):
       import gzip

       __a     				=  str(tmp_path_factory.mktemp("data"							) / "dataset.txt.gz"							)
       with open(_a ,  "rb"							) as orig_file:
              with gzip.open(_a ,  "wb"							) as zipped_file:
                     zipped_file.writelines(_a							)
       return path



@pytest.fixture(scope="session"							)
def 					_lowerCamelCase(					a ,  a							):
       import gzip

       __a     				=  str(tmp_path_factory.mktemp("data"							) / "dataset.jsonl.gz"							)
       with open(_a ,  "rb"							) as orig_file:
              with gzip.open(_a ,  "wb"							) as zipped_file:
                     zipped_file.writelines(_a							)
       return path



@pytest.fixture(scope="session"							)
def 					_lowerCamelCase(					a ,  a ,  a							):
       __a     				=  tmp_path_factory.mktemp("data"							) / """dataset.jsonl.zip"""
       with zipfile.ZipFile(_a ,  "w"							) as f:
              f.write(_a ,  arcname=os.path.basename(_a							)							)
              f.write(_a ,  arcname=os.path.basename(_a							)							)
       return path



@pytest.fixture(scope="session"							)
def 					_lowerCamelCase(					a ,  a ,  a ,  a							):
       __a     				=  tmp_path_factory.mktemp("data"							) / """dataset_nested.jsonl.zip"""
       with zipfile.ZipFile(_a ,  "w"							) as f:
              f.write(_a ,  arcname=os.path.join("nested" ,  os.path.basename(_a							)							)							)
       return path



@pytest.fixture(scope="session"							)
def 					_lowerCamelCase(					a ,  a ,  a							):
       __a     				=  tmp_path_factory.mktemp("data"							) / """dataset_with_dir.jsonl.zip"""
       with zipfile.ZipFile(_a ,  "w"							) as f:
              f.write(_a ,  arcname=os.path.join("main_dir" ,  os.path.basename(_a							)							)							)
              f.write(_a ,  arcname=os.path.join("main_dir" ,  os.path.basename(_a							)							)							)
       return path



@pytest.fixture(scope="session"							)
def 					_lowerCamelCase(					a ,  a ,  a							):
       __a     				=  tmp_path_factory.mktemp("data"							) / """dataset.jsonl.tar"""
       with tarfile.TarFile(_a ,  "w"							) as f:
              f.add(_a ,  arcname=os.path.basename(_a							)							)
              f.add(_a ,  arcname=os.path.basename(_a							)							)
       return path



@pytest.fixture(scope="session"							)
def 					_lowerCamelCase(					a ,  a ,  a ,  a							):
       __a     				=  tmp_path_factory.mktemp("data"							) / """dataset_nested.jsonl.tar"""
       with tarfile.TarFile(_a ,  "w"							) as f:
              f.add(_a ,  arcname=os.path.join("nested" ,  os.path.basename(_a							)							)							)
       return path



@pytest.fixture(scope="session"							)
def 					_lowerCamelCase(					a							):
       __a     				=  ["""0""", """1""", """2""", """3"""]
       __a     				=  str(tmp_path_factory.mktemp("data"							) / "dataset.txt"							)
       with open(_a ,  "w"							) as f:
              for item in data:
                     f.write(item + "\n"							)
       return path



@pytest.fixture(scope="session"							)
def 					_lowerCamelCase(					a							):
       __a     				=  ["""0""", """1""", """2""", """3"""]
       __a     				=  str(tmp_path_factory.mktemp("data"							) / "dataset2.txt"							)
       with open(_a ,  "w"							) as f:
              for item in data:
                     f.write(item + "\n"							)
       return path



@pytest.fixture(scope="session"							)
def 					_lowerCamelCase(					a							):
       __a     				=  ["""0""", """1""", """2""", """3"""]
       __a     				=  tmp_path_factory.mktemp("data"							) / """dataset.abc"""
       with open(_a ,  "w"							) as f:
              for item in data:
                     f.write(item + "\n"							)
       return path



@pytest.fixture(scope="session"							)
def 					_lowerCamelCase(					a ,  a ,  a							):
       __a     				=  tmp_path_factory.mktemp("data"							) / """dataset.text.zip"""
       with zipfile.ZipFile(_a ,  "w"							) as f:
              f.write(_a ,  arcname=os.path.basename(_a							)							)
              f.write(_a ,  arcname=os.path.basename(_a							)							)
       return path



@pytest.fixture(scope="session"							)
def 					_lowerCamelCase(					a ,  a ,  a							):
       __a     				=  tmp_path_factory.mktemp("data"							) / """dataset_with_dir.text.zip"""
       with zipfile.ZipFile(_a ,  "w"							) as f:
              f.write(_a ,  arcname=os.path.join("main_dir" ,  os.path.basename(_a							)							)							)
              f.write(_a ,  arcname=os.path.join("main_dir" ,  os.path.basename(_a							)							)							)
       return path



@pytest.fixture(scope="session"							)
def 					_lowerCamelCase(					a ,  a ,  a							):
       __a     				=  tmp_path_factory.mktemp("data"							) / """dataset.ext.zip"""
       with zipfile.ZipFile(_a ,  "w"							) as f:
              f.write(_a ,  arcname=os.path.basename("unsupported.ext"							)							)
              f.write(_a ,  arcname=os.path.basename("unsupported_2.ext"							)							)
       return path



@pytest.fixture(scope="session"							)
def 					_lowerCamelCase(					a							):
       __a     				=  """\n""".join(["First", "Second\u2029with Unicode new line", "Third"]							)
       __a     				=  str(tmp_path_factory.mktemp("data"							) / "dataset_with_unicode_new_lines.txt"							)
       with open(_a ,  "w" ,  encoding="utf-8"							) as f:
              f.write(_a							)
       return path



@pytest.fixture(scope="session"							)
def 					_lowerCamelCase(					):
       return os.path.join("tests" ,  "features" ,  "data" ,  "test_image_rgb.jpg"							)



@pytest.fixture(scope="session"							)
def 					_lowerCamelCase(					):
       return os.path.join("tests" ,  "features" ,  "data" ,  "test_audio_44100.wav"							)



@pytest.fixture(scope="session"							)
def 					_lowerCamelCase(					a ,  a							):
       __a     				=  tmp_path_factory.mktemp("data"							) / """dataset.img.zip"""
       with zipfile.ZipFile(_a ,  "w"							) as f:
              f.write(_a ,  arcname=os.path.basename(_a							)							)
              f.write(_a ,  arcname=os.path.basename(_a							).replace(".jpg" ,  "2.jpg"							)							)
       return path




@pytest.fixture(scope="session"							)
def 					_lowerCamelCase(					a							):
       __a     				=  tmp_path_factory.mktemp("data_dir"							)

       (data_dir / "subdir").mkdir()
       with open(data_dir / "subdir" / "train.txt" ,  "w"							) as f:
              f.write("foo\n" * 1_0							)
       with open(data_dir / "subdir" / "test.txt" ,  "w"							) as f:
              f.write("bar\n" * 1_0							)
       # hidden file
       with open(data_dir / "subdir" / ".test.txt" ,  "w"							) as f:
              f.write("bar\n" * 1_0							)

       # hidden directory
       (data_dir / ".subdir").mkdir()
       with open(data_dir / ".subdir" / "train.txt" ,  "w"							) as f:
              f.write("foo\n" * 1_0							)
       with open(data_dir / ".subdir" / "test.txt" ,  "w"							) as f:
              f.write("bar\n" * 1_0							)

       return data_dir

"""simple docstring"""



import functools
import operator

from ...configuration_utils import PretrainedConfig
from ...utils import logging


SCREAMING_SNAKE_CASE__:Optional[Any]			=	logging.get_logger(__name__)

SCREAMING_SNAKE_CASE__:str			=	{
    """asapp/sew-d-tiny-100k""": """https://huggingface.co/asapp/sew-d-tiny-100k/resolve/main/config.json""",
    # See all SEW-D models at https://huggingface.co/models?filter=sew-d
}






class 				snake_case__     (   snake_case_   ):
 _snake_case   :			str           =		"""sew-d"""


 def __init__(				self  ,						lowerCamelCase=32  ,						lowerCamelCase=768  ,						lowerCamelCase=12  ,						lowerCamelCase=12  ,						lowerCamelCase=3072  ,						lowerCamelCase=2  ,						lowerCamelCase=512  ,						lowerCamelCase=256  ,						lowerCamelCase=True  ,						lowerCamelCase=True  ,						lowerCamelCase=("p2c", "c2p")  ,						lowerCamelCase="layer_norm"  ,						lowerCamelCase="gelu_python"  ,						lowerCamelCase=0.1  ,						lowerCamelCase=0.1  ,						lowerCamelCase=0.1  ,						lowerCamelCase=0.0  ,						lowerCamelCase=0.1  ,						lowerCamelCase=0.02  ,						lowerCamelCase=1E-7  ,						lowerCamelCase=1E-5  ,						lowerCamelCase="group"  ,						lowerCamelCase="gelu"  ,						lowerCamelCase=(64, 128, 128, 128, 128, 256, 256, 256, 256, 512, 512, 512, 512)  ,						lowerCamelCase=(5, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1)  ,						lowerCamelCase=(10, 3, 1, 3, 1, 3, 1, 3, 1, 2, 1, 2, 1)  ,						lowerCamelCase=False  ,						lowerCamelCase=128  ,						lowerCamelCase=16  ,						lowerCamelCase=True  ,						lowerCamelCase=0.05  ,						lowerCamelCase=10  ,						lowerCamelCase=2  ,						lowerCamelCase=0.0  ,						lowerCamelCase=10  ,						lowerCamelCase=0  ,						lowerCamelCase="mean"  ,						lowerCamelCase=False  ,						lowerCamelCase=False  ,						lowerCamelCase=256  ,						lowerCamelCase=0  ,						lowerCamelCase=1  ,						lowerCamelCase=2  ,						**lowerCamelCase  ,						):
        super().__init__(**lowerCamelCase  ,						pad_token_id=lowerCamelCase  ,						bos_token_id=lowerCamelCase  ,						eos_token_id=lowerCamelCase		)
        __a     				=  hidden_size
        __a     				=  feat_extract_norm
        __a     				=  feat_extract_activation
        __a     				=  list(lowerCamelCase		)
        __a     				=  list(lowerCamelCase		)
        __a     				=  list(lowerCamelCase		)
        __a     				=  conv_bias
        __a     				=  num_conv_pos_embeddings
        __a     				=  num_conv_pos_embedding_groups
        __a     				=  len(self.conv_dim		)
        __a     				=  num_hidden_layers
        __a     				=  intermediate_size
        __a     				=  squeeze_factor
        __a     				=  max_position_embeddings
        __a     				=  position_buckets
        __a     				=  share_att_key
        __a     				=  relative_attention
        __a     				=  norm_rel_ebd
        __a     				=  list(lowerCamelCase		)
        __a     				=  hidden_act
        __a     				=  num_attention_heads
        __a     				=  hidden_dropout
        __a     				=  attention_dropout
        __a     				=  activation_dropout
        __a     				=  feat_proj_dropout
        __a     				=  final_dropout
        __a     				=  layer_norm_eps
        __a     				=  feature_layer_norm_eps
        __a     				=  initializer_range
        __a     				=  vocab_size

        if (
            (len(self.conv_stride		) != self.num_feat_extract_layers)
            or (len(self.conv_kernel		) != self.num_feat_extract_layers)
            or (len(self.conv_dim		) != self.num_feat_extract_layers)
        ):
               raise ValueError(
                   "Configuration for convolutional layers is incorrect."
                   "It is required that `len(config.conv_dim)` == `len(config.conv_stride)` == `len(config.conv_kernel)`,"
                   F"but is `len(config.conv_dim) = {len(self.conv_dim		)}`, `len(config.conv_stride)"
                   F"= {len(self.conv_stride		)}`, `len(config.conv_kernel) = {len(self.conv_kernel		)}`."		)

        # fine-tuning config parameters for SpecAugment: https://arxiv.org/abs/1904.08779
        __a     				=  apply_spec_augment
        __a     				=  mask_time_prob
        __a     				=  mask_time_length
        __a     				=  mask_time_min_masks
        __a     				=  mask_feature_prob
        __a     				=  mask_feature_length
        __a     				=  mask_feature_min_masks

        # ctc loss
        __a     				=  ctc_loss_reduction
        __a     				=  ctc_zero_infinity

        # sequence classification
        __a     				=  use_weighted_layer_sum
        __a     				=  classifier_proj_size






 @property
 def 		a__ (				self		):
        return functools.reduce(operator.mul  ,						self.conv_stride  ,						1		)
