


import json
import os
import pickle
import shutil
import tempfile
from unittest import TestCase
from unittest.mock import patch

import numpy as np
from datasets import Dataset

from transformers import is_faiss_available
from transformers.models.bart.configuration_bart import BartConfig
from transformers.models.bart.tokenization_bart import BartTokenizer
from transformers.models.bert.tokenization_bert import VOCAB_FILES_NAMES as DPR_VOCAB_FILES_NAMES
from transformers.models.dpr.configuration_dpr import DPRConfig
from transformers.models.dpr.tokenization_dpr import DPRContextEncoderTokenizer, DPRQuestionEncoderTokenizer
from transformers.models.rag.configuration_rag import RagConfig
from transformers.models.rag.retrieval_rag import CustomHFIndex, RagRetriever
from transformers.models.roberta.tokenization_roberta import VOCAB_FILES_NAMES as BART_VOCAB_FILES_NAMES
from transformers.testing_utils import require_faiss, require_sentencepiece, require_tokenizers, require_torch


if is_faiss_available():
						import faiss


@require_faiss
class 	_a							(      __SCREAMING_SNAKE_CASE      ):

							def 				lowerCamelCase_			(							self:     int							)      ->       Any:





									"""simple docstring"""







									lowercase__						=				tempfile.mkdtemp()
									lowercase__						=				8

									# DPR tok
									lowercase__						=				[
									    """[UNK]""",
									    """[CLS]""",
									    """[SEP]""",
									    """[PAD]""",
									    """[MASK]""",
									    """want""",
									    """##want""",
									    """##ed""",
									    """wa""",
									    """un""",
									    """runn""",
									    """##ing""",
									    """,""",
									    """low""",
									    """lowest""",
									]
									lowercase__						=				os.path.join(self.tmpdirname   ,						'''dpr_tokenizer'''							)
									os.makedirs(__UpperCAmelCase   ,						exist_ok=__UpperCAmelCase							)
									lowercase__						=				os.path.join(__UpperCAmelCase   ,						DPR_VOCAB_FILES_NAMES['''vocab_file''']							)
									with open(self.vocab_file   ,						'''w'''   ,						encoding='''utf-8'''							) as vocab_writer:
											vocab_writer.write(''''''.join([x + '''\n''' for x in vocab_tokens]							)							)

									# BART tok
									lowercase__						=				[
									    """l""",
									    """o""",
									    """w""",
									    """e""",
									    """r""",
									    """s""",
									    """t""",
									    """i""",
									    """d""",
									    """n""",
									    """\u0120""",
									    """\u0120l""",
									    """\u0120n""",
									    """\u0120lo""",
									    """\u0120low""",
									    """er""",
									    """\u0120lowest""",
									    """\u0120newer""",
									    """\u0120wider""",
									    """<unk>""",
									]
									lowercase__						=				dict(zip(__UpperCAmelCase   ,						range(len(__UpperCAmelCase							)							)							)							)
									lowercase__						=				["""#version: 0.2""", """\u0120 l""", """\u0120l o""", """\u0120lo w""", """e r""", """"""]
									lowercase__						=				{"""unk_token""": """<unk>"""}

									lowercase__						=				os.path.join(self.tmpdirname   ,						'''bart_tokenizer'''							)
									os.makedirs(__UpperCAmelCase   ,						exist_ok=__UpperCAmelCase							)
									lowercase__						=				os.path.join(__UpperCAmelCase   ,						BART_VOCAB_FILES_NAMES['''vocab_file''']							)
									lowercase__						=				os.path.join(__UpperCAmelCase   ,						BART_VOCAB_FILES_NAMES['''merges_file''']							)
									with open(self.vocab_file   ,						'''w'''   ,						encoding='''utf-8'''							) as fp:
											fp.write(json.dumps(__UpperCAmelCase							) + '''\n'''							)
									with open(self.merges_file   ,						'''w'''   ,						encoding='''utf-8'''							) as fp:
											fp.write('''\n'''.join(__UpperCAmelCase							)							)

							def 				lowerCamelCase_			(							self:     Union[str, Any]							)      ->       DPRQuestionEncoderTokenizer:





									"""simple docstring"""







									return DPRQuestionEncoderTokenizer.from_pretrained(os.path.join(self.tmpdirname   ,						'''dpr_tokenizer'''							)							)

							def 				lowerCamelCase_			(							self:     Any							)      ->       DPRContextEncoderTokenizer:





									"""simple docstring"""







									return DPRContextEncoderTokenizer.from_pretrained(os.path.join(self.tmpdirname   ,						'''dpr_tokenizer'''							)							)

							def 				lowerCamelCase_			(							self:     str							)      ->       BartTokenizer:





									"""simple docstring"""







									return BartTokenizer.from_pretrained(os.path.join(self.tmpdirname   ,						'''bart_tokenizer'''							)							)

							def 				lowerCamelCase_			(							self:     int							)      ->       Tuple:





									"""simple docstring"""







									shutil.rmtree(self.tmpdirname							)

							def 				lowerCamelCase_			(							self:     str							)      ->       int:





									"""simple docstring"""







									lowercase__						=				Dataset.from_dict(
									    {
									        '''id''': ['''0''', '''1'''],
									        '''text''': ['''foo''', '''bar'''],
									        '''title''': ['''Foo''', '''Bar'''],
									        '''embeddings''': [np.ones(self.retrieval_vector_size							), 2 * np.ones(self.retrieval_vector_size							)],
									    }							)
									dataset.add_faiss_index('''embeddings'''   ,						string_factory='''Flat'''   ,						metric_type=faiss.METRIC_INNER_PRODUCT							)
									return dataset

							def 				lowerCamelCase_			(							self:     Union[str, Any]							)      ->       str:





									"""simple docstring"""







									lowercase__						=				self.get_dummy_dataset()
									lowercase__						=				RagConfig(
									    retrieval_vector_size=self.retrieval_vector_size   ,						question_encoder=DPRConfig().to_dict()   ,						generator=BartConfig().to_dict()   ,						)
									with patch('''transformers.models.rag.retrieval_rag.load_dataset'''							) as mock_load_dataset:
											lowercase__						=				dataset
											lowercase__						=				RagRetriever(
											    __UpperCAmelCase   ,						question_encoder_tokenizer=self.get_dpr_tokenizer()   ,						generator_tokenizer=self.get_bart_tokenizer()   ,						)
									return retriever

							def 				lowerCamelCase_			(							self:     Optional[int]   ,						UpperCamelCase_:     int							)      ->       Optional[Any]:





									"""simple docstring"""







									lowercase__						=				self.get_dummy_dataset()
									lowercase__						=				RagConfig(
									    retrieval_vector_size=self.retrieval_vector_size   ,						question_encoder=DPRConfig().to_dict()   ,						generator=BartConfig().to_dict()   ,						index_name='''custom'''   ,						)
									if from_disk:
											lowercase__						=				os.path.join(self.tmpdirname   ,						'''dataset'''							)
											lowercase__						=				os.path.join(self.tmpdirname   ,						'''index.faiss'''							)
											dataset.get_index('''embeddings'''							).save(os.path.join(self.tmpdirname   ,						'''index.faiss'''							)							)
											dataset.drop_index('''embeddings'''							)
											dataset.save_to_disk(os.path.join(self.tmpdirname   ,						'''dataset'''							)							)
											del dataset
											lowercase__						=				RagRetriever(
											    __UpperCAmelCase   ,						question_encoder_tokenizer=self.get_dpr_tokenizer()   ,						generator_tokenizer=self.get_bart_tokenizer()   ,						)
									else:
											lowercase__						=				RagRetriever(
											    __UpperCAmelCase   ,						question_encoder_tokenizer=self.get_dpr_tokenizer()   ,						generator_tokenizer=self.get_bart_tokenizer()   ,						index=CustomHFIndex(config.retrieval_vector_size   ,						__UpperCAmelCase							)   ,						)
									return retriever

							def 				lowerCamelCase_			(							self:     Union[str, Any]							)      ->       int:





									"""simple docstring"""







									lowercase__						=				Dataset.from_dict(
									    {
									        '''id''': ['''0''', '''1'''],
									        '''text''': ['''foo''', '''bar'''],
									        '''title''': ['''Foo''', '''Bar'''],
									        '''embeddings''': [np.ones(self.retrieval_vector_size + 1							), 2 * np.ones(self.retrieval_vector_size + 1							)],
									    }							)
									dataset.add_faiss_index('''embeddings'''   ,						string_factory='''Flat'''   ,						metric_type=faiss.METRIC_INNER_PRODUCT							)

									lowercase__						=				os.path.join(self.tmpdirname   ,						'''hf_bert_base.hnswSQ8_correct_phi_128.c_index'''							)
									dataset.save_faiss_index('''embeddings'''   ,						index_file_name + '''.index.dpr'''							)
									pickle.dump(dataset['''id''']   ,						open(index_file_name + '''.index_meta.dpr'''   ,						'''wb'''							)							)

									lowercase__						=				os.path.join(self.tmpdirname   ,						'''psgs_w100.tsv.pkl'''							)
									lowercase__						=				{sample["""id"""]: [sample["""text"""], sample["""title"""]] for sample in dataset}
									pickle.dump(__UpperCAmelCase   ,						open(__UpperCAmelCase   ,						'''wb'''							)							)

									lowercase__						=				RagConfig(
									    retrieval_vector_size=self.retrieval_vector_size   ,						question_encoder=DPRConfig().to_dict()   ,						generator=BartConfig().to_dict()   ,						index_name='''legacy'''   ,						index_path=self.tmpdirname   ,						)
									lowercase__						=				RagRetriever(
									    __UpperCAmelCase   ,						question_encoder_tokenizer=self.get_dpr_tokenizer()   ,						generator_tokenizer=self.get_bart_tokenizer()							)
									return retriever

							def 				lowerCamelCase_			(							self:     Tuple							)      ->       List[Any]:





									"""simple docstring"""







									lowercase__						=				1
									lowercase__						=				self.get_dummy_canonical_hf_index_retriever()
									lowercase__						=				np.array(
									    [np.ones(self.retrieval_vector_size							), -np.ones(self.retrieval_vector_size							)]   ,						dtype=np.floataa							)
									lowercase__						=				retriever.retrieve(__UpperCAmelCase   ,						n_docs=__UpperCAmelCase							)
									self.assertEqual(retrieved_doc_embeds.shape   ,						(2, n_docs, self.retrieval_vector_size)							)
									self.assertEqual(len(__UpperCAmelCase							)   ,						2							)
									self.assertEqual(sorted(doc_dicts[0]							)   ,						['''embeddings''', '''id''', '''text''', '''title''']							)
									self.assertEqual(len(doc_dicts[0]['''id''']							)   ,						__UpperCAmelCase							)
									self.assertEqual(doc_dicts[0]['''id'''][0]   ,						'''1'''							)  # max inner product is reached with second doc
									self.assertEqual(doc_dicts[1]['''id'''][0]   ,						'''0'''							)  # max inner product is reached with first doc
									self.assertListEqual(doc_ids.tolist()   ,						[[1], [0]]							)

							def 				lowerCamelCase_			(							self:     List[Any]							)      ->       Optional[int]:





									"""simple docstring"""







									lowercase__						=				self.get_dummy_canonical_hf_index_retriever()
									with tempfile.TemporaryDirectory() as tmp_dirname:
											with patch('''transformers.models.rag.retrieval_rag.load_dataset'''							) as mock_load_dataset:
													lowercase__						=				self.get_dummy_dataset()
													retriever.save_pretrained(__UpperCAmelCase							)
													lowercase__						=				RagRetriever.from_pretrained(__UpperCAmelCase							)
													self.assertIsInstance(__UpperCAmelCase   ,						__UpperCAmelCase							)
													lowercase__						=				np.array(
													    [np.ones(self.retrieval_vector_size							), -np.ones(self.retrieval_vector_size							)]   ,						dtype=np.floataa							)
													lowercase__						=				retriever.retrieve(__UpperCAmelCase   ,						n_docs=1							)
													self.assertTrue(out is not None							)

							def 				lowerCamelCase_			(							self:     Optional[int]							)      ->       Tuple:





									"""simple docstring"""







									lowercase__						=				1
									lowercase__						=				self.get_dummy_custom_hf_index_retriever(from_disk=__UpperCAmelCase							)
									lowercase__						=				np.array(
									    [np.ones(self.retrieval_vector_size							), -np.ones(self.retrieval_vector_size							)]   ,						dtype=np.floataa							)
									lowercase__						=				retriever.retrieve(__UpperCAmelCase   ,						n_docs=__UpperCAmelCase							)
									self.assertEqual(retrieved_doc_embeds.shape   ,						(2, n_docs, self.retrieval_vector_size)							)
									self.assertEqual(len(__UpperCAmelCase							)   ,						2							)
									self.assertEqual(sorted(doc_dicts[0]							)   ,						['''embeddings''', '''id''', '''text''', '''title''']							)
									self.assertEqual(len(doc_dicts[0]['''id''']							)   ,						__UpperCAmelCase							)
									self.assertEqual(doc_dicts[0]['''id'''][0]   ,						'''1'''							)  # max inner product is reached with second doc
									self.assertEqual(doc_dicts[1]['''id'''][0]   ,						'''0'''							)  # max inner product is reached with first doc
									self.assertListEqual(doc_ids.tolist()   ,						[[1], [0]]							)

							def 				lowerCamelCase_			(							self:     Tuple							)      ->       str:





									"""simple docstring"""







									lowercase__						=				self.get_dummy_custom_hf_index_retriever(from_disk=__UpperCAmelCase							)
									with tempfile.TemporaryDirectory() as tmp_dirname:
											retriever.save_pretrained(__UpperCAmelCase							)
											lowercase__						=				RagRetriever.from_pretrained(__UpperCAmelCase							)
											self.assertIsInstance(__UpperCAmelCase   ,						__UpperCAmelCase							)
											lowercase__						=				np.array(
											    [np.ones(self.retrieval_vector_size							), -np.ones(self.retrieval_vector_size							)]   ,						dtype=np.floataa							)
											lowercase__						=				retriever.retrieve(__UpperCAmelCase   ,						n_docs=1							)
											self.assertTrue(out is not None							)

							def 				lowerCamelCase_			(							self:     List[Any]							)      ->       Tuple:





									"""simple docstring"""







									lowercase__						=				1
									lowercase__						=				self.get_dummy_custom_hf_index_retriever(from_disk=__UpperCAmelCase							)
									lowercase__						=				np.array(
									    [np.ones(self.retrieval_vector_size							), -np.ones(self.retrieval_vector_size							)]   ,						dtype=np.floataa							)
									lowercase__						=				retriever.retrieve(__UpperCAmelCase   ,						n_docs=__UpperCAmelCase							)
									self.assertEqual(retrieved_doc_embeds.shape   ,						(2, n_docs, self.retrieval_vector_size)							)
									self.assertEqual(len(__UpperCAmelCase							)   ,						2							)
									self.assertEqual(sorted(doc_dicts[0]							)   ,						['''embeddings''', '''id''', '''text''', '''title''']							)
									self.assertEqual(len(doc_dicts[0]['''id''']							)   ,						__UpperCAmelCase							)
									self.assertEqual(doc_dicts[0]['''id'''][0]   ,						'''1'''							)  # max inner product is reached with second doc
									self.assertEqual(doc_dicts[1]['''id'''][0]   ,						'''0'''							)  # max inner product is reached with first doc
									self.assertListEqual(doc_ids.tolist()   ,						[[1], [0]]							)

							def 				lowerCamelCase_			(							self:     Union[str, Any]							)      ->       Union[str, Any]:





									"""simple docstring"""







									lowercase__						=				self.get_dummy_custom_hf_index_retriever(from_disk=__UpperCAmelCase							)
									with tempfile.TemporaryDirectory() as tmp_dirname:
											retriever.save_pretrained(__UpperCAmelCase							)
											lowercase__						=				RagRetriever.from_pretrained(__UpperCAmelCase							)
											self.assertIsInstance(__UpperCAmelCase   ,						__UpperCAmelCase							)
											lowercase__						=				np.array(
											    [np.ones(self.retrieval_vector_size							), -np.ones(self.retrieval_vector_size							)]   ,						dtype=np.floataa							)
											lowercase__						=				retriever.retrieve(__UpperCAmelCase   ,						n_docs=1							)
											self.assertTrue(out is not None							)

							def 				lowerCamelCase_			(							self:     int							)      ->       Optional[Any]:





									"""simple docstring"""







									lowercase__						=				1
									lowercase__						=				self.get_dummy_legacy_index_retriever()
									lowercase__						=				np.array(
									    [np.ones(self.retrieval_vector_size							), -np.ones(self.retrieval_vector_size							)]   ,						dtype=np.floataa							)
									lowercase__						=				retriever.retrieve(__UpperCAmelCase   ,						n_docs=__UpperCAmelCase							)
									self.assertEqual(retrieved_doc_embeds.shape   ,						(2, n_docs, self.retrieval_vector_size)							)
									self.assertEqual(len(__UpperCAmelCase							)   ,						2							)
									self.assertEqual(sorted(doc_dicts[0]							)   ,						['''text''', '''title''']							)
									self.assertEqual(len(doc_dicts[0]['''text''']							)   ,						__UpperCAmelCase							)
									self.assertEqual(doc_dicts[0]['''text'''][0]   ,						'''bar'''							)  # max inner product is reached with second doc
									self.assertEqual(doc_dicts[1]['''text'''][0]   ,						'''foo'''							)  # max inner product is reached with first doc
									self.assertListEqual(doc_ids.tolist()   ,						[[1], [0]]							)

							def 				lowerCamelCase_			(							self:     Any							)      ->       int:





									"""simple docstring"""







									lowercase__						=				self.get_dummy_legacy_index_retriever()
									with tempfile.TemporaryDirectory() as tmp_dirname:
											retriever.save_pretrained(__UpperCAmelCase							)
											lowercase__						=				RagRetriever.from_pretrained(__UpperCAmelCase							)
											self.assertIsInstance(__UpperCAmelCase   ,						__UpperCAmelCase							)
											lowercase__						=				np.array(
											    [np.ones(self.retrieval_vector_size							), -np.ones(self.retrieval_vector_size							)]   ,						dtype=np.floataa							)
											lowercase__						=				retriever.retrieve(__UpperCAmelCase   ,						n_docs=1							)
											self.assertTrue(out is not None							)

							@require_torch
							@require_tokenizers
							@require_sentencepiece
							def 				lowerCamelCase_			(							self:     Union[str, Any]							)      ->       Union[str, Any]:





									"""simple docstring"""







									import torch

									lowercase__						=				1
									lowercase__						=				self.get_dummy_canonical_hf_index_retriever()
									lowercase__						=				[[5, 7], [10, 11]]
									lowercase__						=				np.array(
									    [np.ones(self.retrieval_vector_size							), -np.ones(self.retrieval_vector_size							)]   ,						dtype=np.floataa							)
									lowercase__						=				retriever(__UpperCAmelCase   ,						__UpperCAmelCase   ,						prefix=retriever.config.generator.prefix   ,						n_docs=__UpperCAmelCase							)
									lowercase__						=				(
									    out["""context_input_ids"""],
									    out["""context_attention_mask"""],
									    out["""retrieved_doc_embeds"""],
									)
									self.assertEqual(retrieved_doc_embeds.shape   ,						(2, n_docs, self.retrieval_vector_size)							)
									self.assertIsInstance(__UpperCAmelCase   ,						__UpperCAmelCase							)
									self.assertIsInstance(__UpperCAmelCase   ,						__UpperCAmelCase							)
									self.assertIsInstance(__UpperCAmelCase   ,						np.ndarray							)

									lowercase__						=				retriever(
									    __UpperCAmelCase   ,						__UpperCAmelCase   ,						prefix=retriever.config.generator.prefix   ,						n_docs=__UpperCAmelCase   ,						return_tensors='''pt'''   ,						)
									lowercase__						=				(  # noqa: F841
									    out["""context_input_ids"""],
									    out["""context_attention_mask"""],
									    out["""retrieved_doc_embeds"""],
									    out["""doc_ids"""],
									)
									self.assertEqual(retrieved_doc_embeds.shape   ,						(2, n_docs, self.retrieval_vector_size)							)
									self.assertIsInstance(__UpperCAmelCase   ,						torch.Tensor							)
									self.assertIsInstance(__UpperCAmelCase   ,						torch.Tensor							)
									self.assertIsInstance(__UpperCAmelCase   ,						torch.Tensor							)


							@require_torch
							@require_tokenizers
							@require_sentencepiece
							def 				lowerCamelCase_			(							self:     Union[str, Any]							)      ->       List[Any]:





									"""simple docstring"""







									lowercase__						=				self.get_dpr_ctx_encoder_tokenizer()
									lowercase__						=				1
									lowercase__						=				self.get_dummy_custom_hf_index_retriever(from_disk=__UpperCAmelCase							)
									retriever.set_ctx_encoder_tokenizer(__UpperCAmelCase							)

									lowercase__						=				[[5, 7], [10, 11]]
									lowercase__						=				np.array(
									    [np.ones(self.retrieval_vector_size							), -np.ones(self.retrieval_vector_size							)]   ,						dtype=np.floataa							)
									lowercase__						=				retriever(__UpperCAmelCase   ,						__UpperCAmelCase   ,						prefix=retriever.config.generator.prefix   ,						n_docs=__UpperCAmelCase							)

									self.assertEqual(
									    len(__UpperCAmelCase							)   ,						6							)  # check whether the retriever output consist of 6 attributes including tokenized docs
									self.assertEqual(
									    all(k in out for k in ('''tokenized_doc_ids''', '''tokenized_doc_attention_mask''')							)   ,						__UpperCAmelCase							)  # check for doc token related keys in dictionary.






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


lowerCAmelCase	=							logging.get_logger(__name__)

lowerCAmelCase	=							{
    'unc-nlp/lxmert-base-uncased': 'https://huggingface.co/unc-nlp/lxmert-base-uncased/resolve/main/config.json',
}


class 	_a							(      UpperCamelCase__      ):
							_lowercase     :      List[Any]  				=			'''lxmert'''
							_lowercase     :      Any  				=			{}

							def __init__(							self:     Any   ,						UpperCamelCase_:     List[Any]=30_522   ,						UpperCamelCase_:     int=768   ,						UpperCamelCase_:     Optional[Any]=12   ,						UpperCamelCase_:     Dict=9_500   ,						UpperCamelCase_:     List[Any]=1_600   ,						UpperCamelCase_:     List[Any]=400   ,						UpperCamelCase_:     List[str]=3_072   ,						UpperCamelCase_:     int="gelu"   ,						UpperCamelCase_:     Any=0.1   ,						UpperCamelCase_:     int=0.1   ,						UpperCamelCase_:     List[str]=512   ,						UpperCamelCase_:     Optional[int]=2   ,						UpperCamelCase_:     Union[str, Any]=0.02   ,						UpperCamelCase_:     Dict=1E-1_2   ,						UpperCamelCase_:     List[Any]=9   ,						UpperCamelCase_:     List[Any]=5   ,						UpperCamelCase_:     Optional[Any]=5   ,						UpperCamelCase_:     str=2_048   ,						UpperCamelCase_:     Dict=4   ,						UpperCamelCase_:     Any=6.67   ,						UpperCamelCase_:     Dict=True   ,						UpperCamelCase_:     List[str]=True   ,						UpperCamelCase_:     Dict=True   ,						UpperCamelCase_:     Any=True   ,						UpperCamelCase_:     Tuple=True   ,						UpperCamelCase_:     Optional[Any]=True   ,						UpperCamelCase_:     Any=True   ,						**UpperCamelCase_:     Union[str, Any]   ,						)      ->       Union[str, Any]:





									"""simple docstring"""







									lowercase__						=				vocab_size
									lowercase__						=				hidden_size
									lowercase__						=				num_attention_heads
									lowercase__						=				hidden_act
									lowercase__						=				intermediate_size
									lowercase__						=				hidden_dropout_prob
									lowercase__						=				attention_probs_dropout_prob
									lowercase__						=				max_position_embeddings
									lowercase__						=				type_vocab_size
									lowercase__						=				initializer_range
									lowercase__						=				layer_norm_eps
									lowercase__						=				num_qa_labels
									lowercase__						=				num_object_labels
									lowercase__						=				num_attr_labels
									lowercase__						=				l_layers
									lowercase__						=				x_layers
									lowercase__						=				r_layers
									lowercase__						=				visual_feat_dim
									lowercase__						=				visual_pos_dim
									lowercase__						=				visual_loss_normalizer
									lowercase__						=				task_matched
									lowercase__						=				task_mask_lm
									lowercase__						=				task_obj_predict
									lowercase__						=				task_qa
									lowercase__						=				visual_obj_loss
									lowercase__						=				visual_attr_loss
									lowercase__						=				visual_feat_loss
									lowercase__						=				{'''vision''': r_layers, '''cross_encoder''': x_layers, '''language''': l_layers}
									super().__init__(**UpperCamelCase_							)


