





'''simple docstring'''





import json
import os
from typing import Optional, Tuple

import regex as re

from ...tokenization_utils import PreTrainedTokenizer
from ...utils import logging


UpperCamelCase__      =logging.get_logger(__name__)

UpperCamelCase__      ={
    'vocab_file': 'vocab.json',
    'merges_file': 'merges.txt',
}

UpperCamelCase__      ={
    'vocab_file': {'ctrl': 'https://raw.githubusercontent.com/salesforce/ctrl/master/ctrl-vocab.json'},
    'merges_file': {'ctrl': 'https://raw.githubusercontent.com/salesforce/ctrl/master/ctrl-merges.txt'},
}

UpperCamelCase__      ={
    'ctrl': 256,
}

UpperCamelCase__      ={
    'Pregnancy': 16_8629,
    'Christianity': 7675,
    'Explain': 10_6423,
    'Fitness': 6_3440,
    'Saving': 6_3163,
    'Ask': 2_7171,
    'Ass': 9_5985,
    'Joke': 16_3509,
    'Questions': 4_5622,
    'Thoughts': 4_9605,
    'Retail': 5_2342,
    'Feminism': 16_4338,
    'Writing': 1_1992,
    'Atheism': 19_2263,
    'Netflix': 4_8616,
    'Computing': 3_9639,
    'Opinion': 4_3213,
    'Alone': 4_4967,
    'Funny': 5_8917,
    'Gaming': 4_0358,
    'Human': 4088,
    'India': 1331,
    'Joker': 7_7138,
    'Diet': 3_6206,
    'Legal': 1_1859,
    'Norman': 4939,
    'Tip': 7_2689,
    'Weight': 5_2343,
    'Movies': 4_6273,
    'Running': 2_3425,
    'Science': 2090,
    'Horror': 3_7793,
    'Confession': 6_0572,
    'Finance': 1_2250,
    'Politics': 1_6360,
    'Scary': 19_1985,
    'Support': 1_2654,
    'Technologies': 3_2516,
    'Teenage': 6_6160,
    'Event': 3_2769,
    'Learned': 6_7460,
    'Notion': 18_2770,
    'Wikipedia': 3_7583,
    'Books': 6665,
    'Extract': 7_6050,
    'Confessions': 10_2701,
    'Conspiracy': 7_5932,
    'Links': 6_3674,
    'Narcissus': 15_0425,
    'Relationship': 5_4766,
    'Relationships': 13_4796,
    'Reviews': 4_1671,
    'News': 4256,
    'Translation': 2_6820,
    'multilingual': 12_8406,
}






def     lowerCamelCase__			(__lowerCamelCase	):
     _SCREAMING_SNAKE_CASE       :	Tuple						    =							set()
     _SCREAMING_SNAKE_CASE       :	Dict						    =							word[0]
     for char in word[1:]:
          pairs.add((prev_char, char)	)
          _SCREAMING_SNAKE_CASE       :	Tuple						    =							char

     _SCREAMING_SNAKE_CASE       :	Dict						    =							set(_snake_case	)
     return pairs





class 			lowerCAmelCase__( __lowercase    ):






       '''simple docstring'''


       __snake_case 			=    VOCAB_FILES_NAMES
       __snake_case 			=    PRETRAINED_VOCAB_FILES_MAP
       __snake_case 			=    PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
       __snake_case 			=    CONTROL_CODES




       def __init__(      self    ,						__lowerCamelCase    ,						__lowerCamelCase    ,						__lowerCamelCase="<unk>"    ,						**__lowerCamelCase							)			->     Tuple:
            super().__init__(unk_token=__lowerCamelCase    ,						**__lowerCamelCase							)

            with open(__lowerCamelCase    ,						encoding="utf-8"							) as vocab_handle:
                 _SCREAMING_SNAKE_CASE       :	Union[str, Any]						    =							json.load(__lowerCamelCase							)
            _SCREAMING_SNAKE_CASE       :	int						    =							{v: k for k, v in self.encoder.items()}
            with open(__lowerCamelCase    ,						encoding="utf-8"							) as merges_handle:
                 _SCREAMING_SNAKE_CASE       :	str						    =							merges_handle.read().split("\n"							)[1:-1]
            _SCREAMING_SNAKE_CASE       :	Optional[int]						    =							[tuple(merge.split()							) for merge in merges]
            _SCREAMING_SNAKE_CASE       :	Union[str, Any]						    =							dict(zip(__lowerCamelCase    ,						range(len(__lowerCamelCase							)							)							)							)
            _SCREAMING_SNAKE_CASE       :	List[str]						    =							{}




       @property
       def     UpperCamelCase_			(      self							)			->     Optional[int]:
            return len(self.encoder							)




       def     UpperCamelCase_			(      self							)			->     List[Any]:
            return dict(self.encoder    ,						**self.added_tokens_encoder							)




       def     UpperCamelCase_			(      self    ,						__lowerCamelCase							)			->     int:
            if token in self.cache:
                 return self.cache[token]
            _SCREAMING_SNAKE_CASE       :	int						    =							tuple(__lowerCamelCase							)
            _SCREAMING_SNAKE_CASE       :	str						    =							tuple(list(word[:-1]							) + [word[-1] + "</w>"]							)
            _SCREAMING_SNAKE_CASE       :	Any						    =							get_pairs(__lowerCamelCase							)

            if not pairs:
                 return token

            while True:
                 _SCREAMING_SNAKE_CASE       :	Union[str, Any]						    =							min(__lowerCamelCase    ,						key=lambda __lowerCamelCase							: self.bpe_ranks.get(__lowerCamelCase    ,						float("inf"							)							)							)
                 if bigram not in self.bpe_ranks:
                      break
                 _SCREAMING_SNAKE_CASE    ,			_SCREAMING_SNAKE_CASE       :	Any						    =							bigram
                 _SCREAMING_SNAKE_CASE       :	Optional[int]						    =							[]
                 _SCREAMING_SNAKE_CASE       :	str						    =							0
                 while i < len(__lowerCamelCase							):
                      try:
                           _SCREAMING_SNAKE_CASE       :	List[str]						    =							word.index(__lowerCamelCase    ,						__lowerCamelCase							)
                      except ValueError:
                           new_word.extend(word[i:]							)
                           break
                      else:
                           new_word.extend(word[i:j]							)
                           _SCREAMING_SNAKE_CASE       :	Any						    =							j

                      if word[i] == first and i < len(__lowerCamelCase							) - 1 and word[i + 1] == second:
                           new_word.append(first + second							)
                           i += 2
                      else:
                           new_word.append(word[i]							)
                           i += 1
                 _SCREAMING_SNAKE_CASE       :	Union[str, Any]						    =							tuple(__lowerCamelCase							)
                 _SCREAMING_SNAKE_CASE       :	Tuple						    =							new_word
                 if len(__lowerCamelCase							) == 1:
                      break
                 else:
                      _SCREAMING_SNAKE_CASE       :	str						    =							get_pairs(__lowerCamelCase							)
            _SCREAMING_SNAKE_CASE       :	Tuple						    =							"@@ ".join(__lowerCamelCase							)
            _SCREAMING_SNAKE_CASE       :	Any						    =							word[:-4]
            _SCREAMING_SNAKE_CASE       :	int						    =							word
            return word




       def     UpperCamelCase_			(      self    ,						__lowerCamelCase							)			->     int:
            _SCREAMING_SNAKE_CASE       :	Optional[Any]						    =							[]

            _SCREAMING_SNAKE_CASE       :	List[Any]						    =							re.findall(r"\S+\n?"    ,						__lowerCamelCase							)

            for token in words:
                 split_tokens.extend(list(self.bpe(__lowerCamelCase							).split(" "							)							)							)
            return split_tokens




       def     UpperCamelCase_			(      self    ,						__lowerCamelCase							)			->     Optional[Any]:
            return self.encoder.get(__lowerCamelCase    ,						self.encoder.get(self.unk_token							)							)




       def     UpperCamelCase_			(      self    ,						__lowerCamelCase							)			->     Optional[int]:
            return self.decoder.get(__lowerCamelCase    ,						self.unk_token							)




       def     UpperCamelCase_			(      self    ,						__lowerCamelCase							)			->     Any:
            _SCREAMING_SNAKE_CASE       :	List[Any]						    =							" ".join(__lowerCamelCase							).replace("@@ "    ,						""							).strip()
            return out_string







       def     UpperCamelCase_			(      self    ,						__lowerCamelCase    ,						__lowerCamelCase = None							)			->     Any:
            if not os.path.isdir(__lowerCamelCase							):
                 logger.error(F"""Vocabulary path ({save_directory}) should be a directory"""							)
                 return
            _SCREAMING_SNAKE_CASE       :	List[str]						    =							os.path.join(
                __lowerCamelCase    ,						(filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["vocab_file"]							)
            _SCREAMING_SNAKE_CASE       :	Tuple						    =							os.path.join(
                __lowerCamelCase    ,						(filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["merges_file"]							)

            with open(__lowerCamelCase    ,						"w"    ,						encoding="utf-8"							) as f:
                 f.write(json.dumps(self.encoder    ,						indent=2    ,						sort_keys=__lowerCamelCase    ,						ensure_ascii=__lowerCamelCase							) + "\n"							)

            _SCREAMING_SNAKE_CASE       :	Tuple						    =							0
            with open(__lowerCamelCase    ,						"w"    ,						encoding="utf-8"							) as writer:
                 writer.write("#version: 0.2\n"							)
                 for bpe_tokens, token_index in sorted(self.bpe_ranks.items()    ,						key=lambda __lowerCamelCase							: kv[1]							):
                      if index != token_index:
                           logger.warning(
                               F"""Saving vocabulary to {merge_file}: BPE merge indices are not consecutive."""
                               " Please check that the tokenizer is not corrupted!"							)
                           _SCREAMING_SNAKE_CASE       :	str						    =							token_index
                      writer.write(" ".join(__lowerCamelCase							) + "\n"							)
                      index += 1

            return vocab_file, merge_file

       # def decode(self, token_ids, skip_special_tokens=False, clean_up_tokenization_spaces=True):
       #     filtered_tokens = ' '.join(self.convert_ids_to_tokens(token_ids, skip_special_tokens=skip_special_tokens))
       #     tokens_generated_so_far = re.sub('(@@ )', '', string=filtered_tokens)
       #     tokens_generated_so_far = re.sub('(@@ ?$)', '', string=tokens_generated_so_far)
       #     return ''.join(tokens_generated_so_far)






import json
import os
import shutil
import sys
import tempfile
import unittest
import unittest.mock as mock
from pathlib import Path

from huggingface_hub import HfFolder, delete_repo
from requests.exceptions import HTTPError

from transformers import AutoConfig, BertConfig, GPTaConfig
from transformers.configuration_utils import PretrainedConfig
from transformers.testing_utils import TOKEN, USER, is_staging_test


sys.path.append(str(Path(__file__).parent.parent / 'utils'))

from test_module.custom_configuration import CustomConfig  # noqa E402


UpperCamelCase__      ={
    'return_dict': False,
    'output_hidden_states': True,
    'output_attentions': True,
    'torchscript': True,
    'torch_dtype': 'float16',
    'use_bfloat16': True,
    'tf_legacy_loss': True,
    'pruned_heads': {'a': 1},
    'tie_word_embeddings': False,
    'is_decoder': True,
    'cross_attention_hidden_size': 128,
    'add_cross_attention': True,
    'tie_encoder_decoder': True,
    'max_length': 50,
    'min_length': 3,
    'do_sample': True,
    'early_stopping': True,
    'num_beams': 3,
    'num_beam_groups': 3,
    'diversity_penalty': 0.5,
    'temperature': 2.0,
    'top_k': 10,
    'top_p': 0.7,
    'typical_p': 0.2,
    'repetition_penalty': 0.8,
    'length_penalty': 0.8,
    'no_repeat_ngram_size': 5,
    'encoder_no_repeat_ngram_size': 5,
    'bad_words_ids': [1, 2, 3],
    'num_return_sequences': 3,
    'chunk_size_feed_forward': 5,
    'output_scores': True,
    'return_dict_in_generate': True,
    'forced_bos_token_id': 2,
    'forced_eos_token_id': 3,
    'remove_invalid_values': True,
    'architectures': ['BertModel'],
    'finetuning_task': 'translation',
    'id2label': {0: 'label'},
    'label2id': {'label': '0'},
    'tokenizer_class': 'BertTokenizerFast',
    'prefix': 'prefix',
    'bos_token_id': 6,
    'pad_token_id': 7,
    'eos_token_id': 8,
    'sep_token_id': 9,
    'decoder_start_token_id': 10,
    'exponential_decay_length_penalty': (5, 1.01),
    'suppress_tokens': [0, 1],
    'begin_suppress_tokens': 2,
    'task_specific_params': {'translation': 'some_params'},
    'problem_type': 'regression',
}





@is_staging_test
class 			lowerCAmelCase__( unittest.TestCase    ):






       '''simple docstring'''


       @classmethod
       def     UpperCamelCase_			(      cls							)			->     Optional[int]:
            _SCREAMING_SNAKE_CASE       :	Tuple						    =							TOKEN
            HfFolder.save_token(__lowerCamelCase							)




       @classmethod
       def     UpperCamelCase_			(      cls							)			->     List[str]:
            try:
                 delete_repo(token=cls._token    ,						repo_id="test-config"							)
            except HTTPError:
                 pass

            try:
                 delete_repo(token=cls._token    ,						repo_id="valid_org/test-config-org"							)
            except HTTPError:
                 pass

            try:
                 delete_repo(token=cls._token    ,						repo_id="test-dynamic-config"							)
            except HTTPError:
                 pass




       def     UpperCamelCase_			(      self							)			->     Any:
            _SCREAMING_SNAKE_CASE       :	Dict						    =							BertConfig(
                vocab_size=9_9    ,						hidden_size=3_2    ,						num_hidden_layers=5    ,						num_attention_heads=4    ,						intermediate_size=3_7							)
            config.push_to_hub("test-config"    ,						use_auth_token=self._token							)

            _SCREAMING_SNAKE_CASE       :	Optional[Any]						    =							BertConfig.from_pretrained(F"""{USER}/test-config"""							)
            for k, v in config.to_dict().items():
                 if k != "transformers_version":
                      self.assertEqual(__lowerCamelCase    ,						getattr(__lowerCamelCase    ,						__lowerCamelCase							)							)

        # Reset repo
            delete_repo(token=self._token    ,						repo_id="test-config"							)

            # Push to hub via save_pretrained
            with tempfile.TemporaryDirectory() as tmp_dir:
                 config.save_pretrained(__lowerCamelCase    ,						repo_id="test-config"    ,						push_to_hub=__lowerCamelCase    ,						use_auth_token=self._token							)

            _SCREAMING_SNAKE_CASE       :	Dict						    =							BertConfig.from_pretrained(F"""{USER}/test-config"""							)
            for k, v in config.to_dict().items():
                 if k != "transformers_version":
                      self.assertEqual(__lowerCamelCase    ,						getattr(__lowerCamelCase    ,						__lowerCamelCase							)							)




       def     UpperCamelCase_			(      self							)			->     List[str]:
            _SCREAMING_SNAKE_CASE       :	int						    =							BertConfig(
                vocab_size=9_9    ,						hidden_size=3_2    ,						num_hidden_layers=5    ,						num_attention_heads=4    ,						intermediate_size=3_7							)
            config.push_to_hub("valid_org/test-config-org"    ,						use_auth_token=self._token							)

            _SCREAMING_SNAKE_CASE       :	str						    =							BertConfig.from_pretrained("valid_org/test-config-org"							)
            for k, v in config.to_dict().items():
                 if k != "transformers_version":
                      self.assertEqual(__lowerCamelCase    ,						getattr(__lowerCamelCase    ,						__lowerCamelCase							)							)

        # Reset repo
            delete_repo(token=self._token    ,						repo_id="valid_org/test-config-org"							)

            # Push to hub via save_pretrained
            with tempfile.TemporaryDirectory() as tmp_dir:
                 config.save_pretrained(
                     __lowerCamelCase    ,						repo_id="valid_org/test-config-org"    ,						push_to_hub=__lowerCamelCase    ,						use_auth_token=self._token							)

            _SCREAMING_SNAKE_CASE       :	int						    =							BertConfig.from_pretrained("valid_org/test-config-org"							)
            for k, v in config.to_dict().items():
                 if k != "transformers_version":
                      self.assertEqual(__lowerCamelCase    ,						getattr(__lowerCamelCase    ,						__lowerCamelCase							)							)







       def     UpperCamelCase_			(      self							)			->     int:
            CustomConfig.register_for_auto_class()
            _SCREAMING_SNAKE_CASE       :	Dict						    =							CustomConfig(attribute=4_2							)

            config.push_to_hub("test-dynamic-config"    ,						use_auth_token=self._token							)

            # This has added the proper auto_map field to the config
            self.assertDictEqual(config.auto_map    ,						{"AutoConfig": "custom_configuration.CustomConfig"}							)

            _SCREAMING_SNAKE_CASE       :	Optional[Any]						    =							AutoConfig.from_pretrained(F"""{USER}/test-dynamic-config"""    ,						trust_remote_code=__lowerCamelCase							)
            # Can't make an isinstance check because the new_config is from the FakeConfig class of a dynamic module
            self.assertEqual(new_config.__class__.__name__    ,						"CustomConfig"							)
            self.assertEqual(new_config.attribute    ,						4_2							)





class 			lowerCAmelCase__( unittest.TestCase    ):






       '''simple docstring'''


       def     UpperCamelCase_			(      self							)			->     Union[str, Any]:
            _SCREAMING_SNAKE_CASE       :	int						    =							GPTaConfig()

            # attempt to modify each of int/float/bool/str config records and verify they were updated
            _SCREAMING_SNAKE_CASE       :	Any						    =							c.n_embd + 1  # int
            _SCREAMING_SNAKE_CASE       :	Optional[Any]						    =							c.resid_pdrop + 1.0  # float
            _SCREAMING_SNAKE_CASE       :	str						    =							not c.scale_attn_weights  # bool
            _SCREAMING_SNAKE_CASE       :	Optional[Any]						    =							c.summary_type + "foo"  # str
            c.update_from_string(
                F"""n_embd={n_embd},resid_pdrop={resid_pdrop},scale_attn_weights={scale_attn_weights},summary_type={summary_type}"""							)
            self.assertEqual(__lowerCamelCase    ,						c.n_embd    ,						"mismatch for key: n_embd"							)
            self.assertEqual(__lowerCamelCase    ,						c.resid_pdrop    ,						"mismatch for key: resid_pdrop"							)
            self.assertEqual(__lowerCamelCase    ,						c.scale_attn_weights    ,						"mismatch for key: scale_attn_weights"							)
            self.assertEqual(__lowerCamelCase    ,						c.summary_type    ,						"mismatch for key: summary_type"							)




       def     UpperCamelCase_			(      self							)			->     Dict:
            _SCREAMING_SNAKE_CASE       :	str						    =							PretrainedConfig()
            _SCREAMING_SNAKE_CASE       :	Dict						    =							[key for key in base_config.__dict__ if key not in config_common_kwargs]
            # If this part of the test fails, you have arguments to addin config_common_kwargs above.
            self.assertListEqual(
                __lowerCamelCase    ,						["is_encoder_decoder", "_name_or_path", "_commit_hash", "transformers_version"]							)
            _SCREAMING_SNAKE_CASE       :	int						    =							[key for key, value in config_common_kwargs.items() if value == getattr(__lowerCamelCase    ,						__lowerCamelCase							)]
            if len(__lowerCamelCase							) > 0:
                 raise ValueError(
                     "The following keys are set with the default values in"
                     " `test_configuration_common.config_common_kwargs` pick another value for them:"
                     F""" {', '.join(__lowerCamelCase							)}."""							)




       def     UpperCamelCase_			(      self							)			->     int:
            with self.assertRaises(__lowerCamelCase							):
                 # config is in subfolder, the following should not work without specifying the subfolder
                 _SCREAMING_SNAKE_CASE       :	Optional[Any]						    =							BertConfig.from_pretrained("hf-internal-testing/tiny-random-bert-subfolder"							)

            _SCREAMING_SNAKE_CASE       :	int						    =							BertConfig.from_pretrained("hf-internal-testing/tiny-random-bert-subfolder"    ,						subfolder="bert"							)

            self.assertIsNotNone(__lowerCamelCase							)




       def     UpperCamelCase_			(      self							)			->     str:
            # A mock response for an HTTP head request to emulate server down
            _SCREAMING_SNAKE_CASE       :	Any						    =							mock.Mock()
            _SCREAMING_SNAKE_CASE       :	Optional[int]						    =							5_0_0
            _SCREAMING_SNAKE_CASE       :	Any						    =							{}
            _SCREAMING_SNAKE_CASE       :	int						    =							HTTPError
            _SCREAMING_SNAKE_CASE       :	int						    =							{}

            # Download this model to make sure it's in the cache.
            _SCREAMING_SNAKE_CASE       :	List[Any]						    =							BertConfig.from_pretrained("hf-internal-testing/tiny-random-bert"							)

            # Under the mock environment we get a 500 error when trying to reach the model.
            with mock.patch("requests.Session.request"    ,						return_value=__lowerCamelCase							) as mock_head:
                 _SCREAMING_SNAKE_CASE       :	Optional[int]						    =							BertConfig.from_pretrained("hf-internal-testing/tiny-random-bert"							)
                 # This check we did call the fake head request
                 mock_head.assert_called()




       def     UpperCamelCase_			(      self							)			->     Optional[Any]:
            # This test is for deprecated behavior and can be removed in v5
            _SCREAMING_SNAKE_CASE       :	Optional[Any]						    =							BertConfig.from_pretrained(
                "https://huggingface.co/hf-internal-testing/tiny-random-bert/resolve/main/config.json"							)




       def     UpperCamelCase_			(      self							)			->     str:
            _SCREAMING_SNAKE_CASE       :	int						    =							AutoConfig.from_pretrained("bert-base-cased"							)
            _SCREAMING_SNAKE_CASE       :	List[str]						    =							["config.4.0.0.json"]

            with tempfile.TemporaryDirectory() as tmp_dir:
                 configuration.save_pretrained(__lowerCamelCase							)
                 _SCREAMING_SNAKE_CASE       :	Optional[Any]						    =							2
                 json.dump(configuration.to_dict()    ,						open(os.path.join(__lowerCamelCase    ,						"config.4.0.0.json"							)    ,						"w"							)							)

                 # This should pick the new configuration file as the version of Transformers is > 4.0.0
                 _SCREAMING_SNAKE_CASE       :	Optional[int]						    =							AutoConfig.from_pretrained(__lowerCamelCase							)
                 self.assertEqual(new_configuration.hidden_size    ,						2							)

                 # Will need to be adjusted if we reach v42 and this test is still here.
                 # Should pick the old configuration file as the version of Transformers is < 4.42.0
                 _SCREAMING_SNAKE_CASE       :	Dict						    =							["config.42.0.0.json"]
                 _SCREAMING_SNAKE_CASE       :	List[Any]						    =							7_6_8
                 configuration.save_pretrained(__lowerCamelCase							)
                 shutil.move(os.path.join(__lowerCamelCase    ,						"config.4.0.0.json"							)    ,						os.path.join(__lowerCamelCase    ,						"config.42.0.0.json"							)							)
                 _SCREAMING_SNAKE_CASE       :	Tuple						    =							AutoConfig.from_pretrained(__lowerCamelCase							)
                 self.assertEqual(new_configuration.hidden_size    ,						7_6_8							)







       def     UpperCamelCase_			(      self							)			->     Dict:
            # This repo has two configuration files, one for v4.0.0 and above with a different hidden size.
            _SCREAMING_SNAKE_CASE       :	Union[str, Any]						    =							"hf-internal-testing/test-two-configs"

            import transformers as new_transformers

            _SCREAMING_SNAKE_CASE       :	List[Any]						    =							"v4.0.0"
            _SCREAMING_SNAKE_CASE    ,			_SCREAMING_SNAKE_CASE       :	int						    =							new_transformers.models.auto.AutoConfig.from_pretrained(
                __lowerCamelCase    ,						return_unused_kwargs=__lowerCamelCase							)
            self.assertEqual(new_configuration.hidden_size    ,						2							)
            # This checks `_configuration_file` ia not kept in the kwargs by mistake.
            self.assertDictEqual(__lowerCamelCase    ,						{}							)

            # Testing an older version by monkey-patching the version in the module it's used.
            import transformers as old_transformers

            _SCREAMING_SNAKE_CASE       :	Dict						    =							"v3.0.0"
            _SCREAMING_SNAKE_CASE       :	List[str]						    =							old_transformers.models.auto.AutoConfig.from_pretrained(__lowerCamelCase							)
            self.assertEqual(old_configuration.hidden_size    ,						7_6_8							)