





import argparse
import json
from pathlib import Path

import requests
import torch
from huggingface_hub import cached_download, hf_hub_download, hf_hub_url
from PIL import Image

from transformers import DetaConfig, DetaForObjectDetection, DetaImageProcessor
from transformers.utils import logging


logging.set_verbosity_info()
SCREAMING_SNAKE_CASE_      :			Dict		  =      logging.get_logger(__name__)



def    SCREAMING_SNAKE_CASE							(			)		->						List[str]:
					__lowercase					=    DetaConfig(
					    num_queries=900	,      encoder_ffn_dim=2_048	,      decoder_ffn_dim=2_048	,      num_feature_levels=5	,      assign_first_stage=snake_case__	,      with_box_refine=snake_case__	,      two_stage=snake_case__	,      )

					# set labels
					__lowercase					=    91
					__lowercase					=    'huggingface/label-files'
					__lowercase					=    'coco-detection-id2label.json'
					__lowercase					=    json.load(open(cached_download(hf_hub_url(snake_case__	,      snake_case__	,      repo_type='dataset'       )       )	,      'r'       )       )
					__lowercase					=    {int(snake_case__       ): v for k, v in idalabel.items()}
					__lowercase					=    idalabel
					__lowercase					=    {v: k for k, v in idalabel.items()}

					return config



def    SCREAMING_SNAKE_CASE							(			snake_case       )		->						Dict:
					__lowercase					=    []

					# stem
					# fmt: off
					rename_keys.append(('backbone.0.body.conv1.weight', 'model.backbone.model.embedder.embedder.convolution.weight')       )
					rename_keys.append(('backbone.0.body.bn1.weight', 'model.backbone.model.embedder.embedder.normalization.weight')       )
					rename_keys.append(('backbone.0.body.bn1.bias', 'model.backbone.model.embedder.embedder.normalization.bias')       )
					rename_keys.append(('backbone.0.body.bn1.running_mean', 'model.backbone.model.embedder.embedder.normalization.running_mean')       )
					rename_keys.append(('backbone.0.body.bn1.running_var', 'model.backbone.model.embedder.embedder.normalization.running_var')       )
					# stages
					for stage_idx in range(len(config.backbone_config.depths       )       ):
										for layer_idx in range(config.backbone_config.depths[stage_idx]       ):
															# shortcut
															if layer_idx == 0:
																				rename_keys.append(
																				    (
																				        F"backbone.0.body.layer{stage_idx + 1}.{layer_idx}.downsample.0.weight",
																				        F"model.backbone.model.encoder.stages.{stage_idx}.layers.{layer_idx}.shortcut.convolution.weight",
																				    )       )
																				rename_keys.append(
																				    (
																				        F"backbone.0.body.layer{stage_idx + 1}.{layer_idx}.downsample.1.weight",
																				        F"model.backbone.model.encoder.stages.{stage_idx}.layers.{layer_idx}.shortcut.normalization.weight",
																				    )       )
																				rename_keys.append(
																				    (
																				        F"backbone.0.body.layer{stage_idx + 1}.{layer_idx}.downsample.1.bias",
																				        F"model.backbone.model.encoder.stages.{stage_idx}.layers.{layer_idx}.shortcut.normalization.bias",
																				    )       )
																				rename_keys.append(
																				    (
																				        F"backbone.0.body.layer{stage_idx + 1}.{layer_idx}.downsample.1.running_mean",
																				        F"model.backbone.model.encoder.stages.{stage_idx}.layers.{layer_idx}.shortcut.normalization.running_mean",
																				    )       )
																				rename_keys.append(
																				    (
																				        F"backbone.0.body.layer{stage_idx + 1}.{layer_idx}.downsample.1.running_var",
																				        F"model.backbone.model.encoder.stages.{stage_idx}.layers.{layer_idx}.shortcut.normalization.running_var",
																				    )       )
															# 3 convs
															for i in range(3       ):
																				rename_keys.append(
																				    (
																				        F"backbone.0.body.layer{stage_idx + 1}.{layer_idx}.conv{i+1}.weight",
																				        F"model.backbone.model.encoder.stages.{stage_idx}.layers.{layer_idx}.layer.{i}.convolution.weight",
																				    )       )
																				rename_keys.append(
																				    (
																				        F"backbone.0.body.layer{stage_idx + 1}.{layer_idx}.bn{i+1}.weight",
																				        F"model.backbone.model.encoder.stages.{stage_idx}.layers.{layer_idx}.layer.{i}.normalization.weight",
																				    )       )
																				rename_keys.append(
																				    (
																				        F"backbone.0.body.layer{stage_idx + 1}.{layer_idx}.bn{i+1}.bias",
																				        F"model.backbone.model.encoder.stages.{stage_idx}.layers.{layer_idx}.layer.{i}.normalization.bias",
																				    )       )
																				rename_keys.append(
																				    (
																				        F"backbone.0.body.layer{stage_idx + 1}.{layer_idx}.bn{i+1}.running_mean",
																				        F"model.backbone.model.encoder.stages.{stage_idx}.layers.{layer_idx}.layer.{i}.normalization.running_mean",
																				    )       )
																				rename_keys.append(
																				    (
																				        F"backbone.0.body.layer{stage_idx + 1}.{layer_idx}.bn{i+1}.running_var",
																				        F"model.backbone.model.encoder.stages.{stage_idx}.layers.{layer_idx}.layer.{i}.normalization.running_var",
																				    )       )
    # transformer encoder
					for i in range(config.encoder_layers       ):
										rename_keys.append((F"transformer.encoder.layers.{i}.self_attn.sampling_offsets.weight", F"model.encoder.layers.{i}.self_attn.sampling_offsets.weight")       )
										rename_keys.append((F"transformer.encoder.layers.{i}.self_attn.sampling_offsets.bias", F"model.encoder.layers.{i}.self_attn.sampling_offsets.bias")       )
										rename_keys.append((F"transformer.encoder.layers.{i}.self_attn.attention_weights.weight", F"model.encoder.layers.{i}.self_attn.attention_weights.weight")       )
										rename_keys.append((F"transformer.encoder.layers.{i}.self_attn.attention_weights.bias", F"model.encoder.layers.{i}.self_attn.attention_weights.bias")       )
										rename_keys.append((F"transformer.encoder.layers.{i}.self_attn.value_proj.weight", F"model.encoder.layers.{i}.self_attn.value_proj.weight")       )
										rename_keys.append((F"transformer.encoder.layers.{i}.self_attn.value_proj.bias", F"model.encoder.layers.{i}.self_attn.value_proj.bias")       )
										rename_keys.append((F"transformer.encoder.layers.{i}.self_attn.output_proj.weight", F"model.encoder.layers.{i}.self_attn.output_proj.weight")       )
										rename_keys.append((F"transformer.encoder.layers.{i}.self_attn.output_proj.bias", F"model.encoder.layers.{i}.self_attn.output_proj.bias")       )
										rename_keys.append((F"transformer.encoder.layers.{i}.norm1.weight", F"model.encoder.layers.{i}.self_attn_layer_norm.weight")       )
										rename_keys.append((F"transformer.encoder.layers.{i}.norm1.bias", F"model.encoder.layers.{i}.self_attn_layer_norm.bias")       )
										rename_keys.append((F"transformer.encoder.layers.{i}.linear1.weight", F"model.encoder.layers.{i}.fc1.weight")       )
										rename_keys.append((F"transformer.encoder.layers.{i}.linear1.bias", F"model.encoder.layers.{i}.fc1.bias")       )
										rename_keys.append((F"transformer.encoder.layers.{i}.linear2.weight", F"model.encoder.layers.{i}.fc2.weight")       )
										rename_keys.append((F"transformer.encoder.layers.{i}.linear2.bias", F"model.encoder.layers.{i}.fc2.bias")       )
										rename_keys.append((F"transformer.encoder.layers.{i}.norm2.weight", F"model.encoder.layers.{i}.final_layer_norm.weight")       )
										rename_keys.append((F"transformer.encoder.layers.{i}.norm2.bias", F"model.encoder.layers.{i}.final_layer_norm.bias")       )

					# transformer decoder
					for i in range(config.decoder_layers       ):
										rename_keys.append((F"transformer.decoder.layers.{i}.cross_attn.sampling_offsets.weight", F"model.decoder.layers.{i}.encoder_attn.sampling_offsets.weight")       )
										rename_keys.append((F"transformer.decoder.layers.{i}.cross_attn.sampling_offsets.bias", F"model.decoder.layers.{i}.encoder_attn.sampling_offsets.bias")       )
										rename_keys.append((F"transformer.decoder.layers.{i}.cross_attn.attention_weights.weight", F"model.decoder.layers.{i}.encoder_attn.attention_weights.weight")       )
										rename_keys.append((F"transformer.decoder.layers.{i}.cross_attn.attention_weights.bias", F"model.decoder.layers.{i}.encoder_attn.attention_weights.bias")       )
										rename_keys.append((F"transformer.decoder.layers.{i}.cross_attn.value_proj.weight", F"model.decoder.layers.{i}.encoder_attn.value_proj.weight")       )
										rename_keys.append((F"transformer.decoder.layers.{i}.cross_attn.value_proj.bias", F"model.decoder.layers.{i}.encoder_attn.value_proj.bias")       )
										rename_keys.append((F"transformer.decoder.layers.{i}.cross_attn.output_proj.weight", F"model.decoder.layers.{i}.encoder_attn.output_proj.weight")       )
										rename_keys.append((F"transformer.decoder.layers.{i}.cross_attn.output_proj.bias", F"model.decoder.layers.{i}.encoder_attn.output_proj.bias")       )
										rename_keys.append((F"transformer.decoder.layers.{i}.norm1.weight", F"model.decoder.layers.{i}.encoder_attn_layer_norm.weight")       )
										rename_keys.append((F"transformer.decoder.layers.{i}.norm1.bias", F"model.decoder.layers.{i}.encoder_attn_layer_norm.bias")       )
										rename_keys.append((F"transformer.decoder.layers.{i}.self_attn.out_proj.weight", F"model.decoder.layers.{i}.self_attn.out_proj.weight")       )
										rename_keys.append((F"transformer.decoder.layers.{i}.self_attn.out_proj.bias", F"model.decoder.layers.{i}.self_attn.out_proj.bias")       )
										rename_keys.append((F"transformer.decoder.layers.{i}.norm2.weight", F"model.decoder.layers.{i}.self_attn_layer_norm.weight")       )
										rename_keys.append((F"transformer.decoder.layers.{i}.norm2.bias", F"model.decoder.layers.{i}.self_attn_layer_norm.bias")       )
										rename_keys.append((F"transformer.decoder.layers.{i}.linear1.weight", F"model.decoder.layers.{i}.fc1.weight")       )
										rename_keys.append((F"transformer.decoder.layers.{i}.linear1.bias", F"model.decoder.layers.{i}.fc1.bias")       )
										rename_keys.append((F"transformer.decoder.layers.{i}.linear2.weight", F"model.decoder.layers.{i}.fc2.weight")       )
										rename_keys.append((F"transformer.decoder.layers.{i}.linear2.bias", F"model.decoder.layers.{i}.fc2.bias")       )
										rename_keys.append((F"transformer.decoder.layers.{i}.norm3.weight", F"model.decoder.layers.{i}.final_layer_norm.weight")       )
										rename_keys.append((F"transformer.decoder.layers.{i}.norm3.bias", F"model.decoder.layers.{i}.final_layer_norm.bias")       )

					# fmt: on

					return rename_keys



def    SCREAMING_SNAKE_CASE							(			snake_case	,      snake_case	,      snake_case       )		->						List[Any]:
					__lowercase					=    dct.pop(snake_case__       )
					__lowercase					=    val



def    SCREAMING_SNAKE_CASE							(			snake_case	,      snake_case       )		->						Any:
					# transformer decoder self-attention layers
					__lowercase					=    config.d_model
					for i in range(config.decoder_layers       ):
										# read in weights + bias of input projection layer of self-attention
										__lowercase					=    state_dict.pop(F"transformer.decoder.layers.{i}.self_attn.in_proj_weight"       )
										__lowercase					=    state_dict.pop(F"transformer.decoder.layers.{i}.self_attn.in_proj_bias"       )
										# next, add query, keys and values (in that order) to the state dict
										__lowercase					=    in_proj_weight[:hidden_size, :]
										__lowercase					=    in_proj_bias[:hidden_size]
										__lowercase					=    in_proj_weight[
										    hidden_size : hidden_size * 2, :
										]
										__lowercase					=    in_proj_bias[hidden_size : hidden_size * 2]
										__lowercase					=    in_proj_weight[-hidden_size:, :]
										__lowercase					=    in_proj_bias[-hidden_size:]



def    SCREAMING_SNAKE_CASE							(			)		->						List[Any]:
					__lowercase					=    'http://images.cocodataset.org/val2017/000000039769.jpg'
					__lowercase					=    Image.open(requests.get(snake_case__	,      stream=snake_case__       ).raw       )

					return im



@torch.no_grad()
def    SCREAMING_SNAKE_CASE							(			snake_case	,      snake_case	,      snake_case       )		->						Tuple:
					__lowercase					=    get_deta_config()

					# load original state dict
					if model_name == "deta-resnet-50":
										__lowercase					=    'adet_checkpoint0011.pth'
					elif model_name == "deta-resnet-50-24-epochs":
										__lowercase					=    'adet_2x_checkpoint0023.pth'
					else:
										raise ValueError(F"Model name {model_name} not supported"       )
					__lowercase					=    hf_hub_download(repo_id='nielsr/deta-checkpoints'	,      filename=snake_case__       )
					__lowercase					=    torch.load(snake_case__	,      map_location='cpu'       )['model']

					# rename keys
					__lowercase					=    create_rename_keys(snake_case__       )
					for src, dest in rename_keys:
										rename_key(snake_case__	,      snake_case__	,      snake_case__       )
					read_in_decoder_q_k_v(snake_case__	,      snake_case__       )

					# fix some prefixes
					for key in state_dict.copy().keys():
										if "transformer.decoder.class_embed" in key or "transformer.decoder.bbox_embed" in key:
															__lowercase					=    state_dict.pop(snake_case__       )
															__lowercase					=    val
										if "input_proj" in key:
															__lowercase					=    state_dict.pop(snake_case__       )
															__lowercase					=    val
										if "level_embed" in key or "pos_trans" in key or "pix_trans" in key or "enc_output" in key:
															__lowercase					=    state_dict.pop(snake_case__       )
															__lowercase					=    val

    # finally, create HuggingFace model and load state dict
					__lowercase					=    DetaForObjectDetection(snake_case__       )
					model.load_state_dict(snake_case__       )
					model.eval()

					__lowercase					=    'cuda' if torch.cuda.is_available() else 'cpu'
					model.to(snake_case__       )

					# load image processor
					__lowercase					=    DetaImageProcessor(format='coco_detection'       )

					# verify our conversion on image
					__lowercase					=    prepare_img()
					__lowercase					=    processor(images=snake_case__	,      return_tensors='pt'       )
					__lowercase					=    encoding['pixel_values']
					__lowercase					=    model(pixel_values.to(snake_case__       )       )

					# verify logits
					if model_name == "deta-resnet-50":
										__lowercase					=    torch.tensor(
										    [[-7.3978, -2.5406, -4.1668], [-8.2684, -3.9933, -3.8096], [-7.0515, -3.7973, -5.8516]]       )
										__lowercase					=    torch.tensor([[0.5043, 0.4973, 0.9998], [0.2542, 0.5489, 0.4748], [0.5490, 0.2765, 0.0570]]       )
					elif model_name == "deta-resnet-50-24-epochs":
										__lowercase					=    torch.tensor(
										    [[-7.1688, -2.4857, -4.8669], [-7.8630, -3.8154, -4.2674], [-7.2730, -4.1865, -5.5323]]       )
										__lowercase					=    torch.tensor([[0.5021, 0.4971, 0.9994], [0.2546, 0.5486, 0.4731], [0.1686, 0.1986, 0.2142]]       )

					assert torch.allclose(outputs.logits[0, :3, :3]	,      expected_logits.to(snake_case__       )	,      atol=1E-4       )
					assert torch.allclose(outputs.pred_boxes[0, :3, :3]	,      expected_boxes.to(snake_case__       )	,      atol=1E-4       )
					print('Everything ok!'       )

					if pytorch_dump_folder_path:
										# Save model and processor
										logger.info(F"Saving PyTorch model and processor to {pytorch_dump_folder_path}..."       )
										Path(snake_case__       ).mkdir(exist_ok=snake_case__       )
										model.save_pretrained(snake_case__       )
										processor.save_pretrained(snake_case__       )

					# Push to hub
					if push_to_hub:
										print('Pushing model and processor to hub...'       )
										model.push_to_hub(F"jozhang97/{model_name}"       )
										processor.push_to_hub(F"jozhang97/{model_name}"       )


if __name__ == "__main__":
		SCREAMING_SNAKE_CASE_      :			Optional[Any]		  =      argparse.ArgumentParser()

		parser.add_argument(
		    '''--model_name''',
		    type=str,
		    default='''deta-resnet-50''',
		    choices=['''deta-resnet-50''', '''deta-resnet-50-24-epochs'''],
		    help='''Name of the model you\'d like to convert.''',
		)
		parser.add_argument(
		    '''--pytorch_dump_folder_path''',
		    default=None,
		    type=str,
		    help='''Path to the folder to output PyTorch model.''',
		)
		parser.add_argument(
		    '''--push_to_hub''', action='''store_true''', help='''Whether or not to push the converted model to the 🤗 hub.'''
		)
		SCREAMING_SNAKE_CASE_      :			int		  =      parser.parse_args()
		convert_deta_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)











import shutil
import tempfile
import unittest
from pathlib import Path
from shutil import copyfile

from transformers import SpeechaTextTokenizer, is_speech_available
from transformers.models.speech_to_text.tokenization_speech_to_text import VOCAB_FILES_NAMES, save_json
from transformers.testing_utils import get_tests_dir, require_sentencepiece, require_torch, require_torchaudio
from transformers.utils import FEATURE_EXTRACTOR_NAME

from .test_feature_extraction_speech_to_text import floats_list


if is_speech_available():
		from transformers import SpeechaTextFeatureExtractor, SpeechaTextProcessor


SCREAMING_SNAKE_CASE_      :			Union[str, Any]		  =      get_tests_dir('''fixtures/test_sentencepiece.model''')

@require_torch
@require_torchaudio
@require_sentencepiece
class 		snake_case_      (       unittest.TestCase	):







	'''simple docstring'''




	def       UpperCAmelCase (	self       :    List[Any]      )					->   str:

			'''simple docstring'''




			__lowercase					=    tempfile.mkdtemp()

			__lowercase					=    ['<s>', '<pad>', '</s>', '<unk>', '▁This', '▁is', '▁a', '▁t', 'est']
			__lowercase					=    dict(zip(__lowerCamelCase				,			range(len(__lowerCamelCase      )      )      )      )
			__lowercase					=    Path(self.tmpdirname      )
			save_json(__lowerCamelCase				,			save_dir / VOCAB_FILES_NAMES['vocab_file']      )
			if not (save_dir / VOCAB_FILES_NAMES["spm_file"]).exists():
					copyfile(__lowerCamelCase				,			save_dir / VOCAB_FILES_NAMES['spm_file']      )

			__lowercase					=    SpeechaTextTokenizer.from_pretrained(self.tmpdirname      )
			tokenizer.save_pretrained(self.tmpdirname      )

			__lowercase					=    {
			    'feature_size': 24,
			    'num_mel_bins': 24,
			    'padding_value': 0.0,
			    'sampling_rate': 16_000,
			    'return_attention_mask': False,
			    'do_normalize': True,
			}
			save_json(__lowerCamelCase				,			save_dir / FEATURE_EXTRACTOR_NAME      )




	def       UpperCAmelCase (	self       :    Dict				,			**__lowerCamelCase       :    Dict      )					->   Union[str, Any]:

			'''simple docstring'''




			return SpeechaTextTokenizer.from_pretrained(self.tmpdirname				,			**__lowerCamelCase      )




	def       UpperCAmelCase (	self       :    str				,			**__lowerCamelCase       :    List[str]      )					->   Tuple:

			'''simple docstring'''




			return SpeechaTextFeatureExtractor.from_pretrained(self.tmpdirname				,			**__lowerCamelCase      )




	def       UpperCAmelCase (	self       :    Optional[int]      )					->   str:

			'''simple docstring'''




			shutil.rmtree(self.tmpdirname      )




	def       UpperCAmelCase (	self       :    str      )					->   Any:

			'''simple docstring'''




			__lowercase					=    self.get_tokenizer()
			__lowercase					=    self.get_feature_extractor()

			__lowercase					=    SpeechaTextProcessor(tokenizer=__lowerCamelCase				,			feature_extractor=__lowerCamelCase      )

			processor.save_pretrained(self.tmpdirname      )
			__lowercase					=    SpeechaTextProcessor.from_pretrained(self.tmpdirname      )

			self.assertEqual(processor.tokenizer.get_vocab()				,			tokenizer.get_vocab()      )
			self.assertIsInstance(processor.tokenizer				,			__lowerCamelCase      )

			self.assertEqual(processor.feature_extractor.to_json_string()				,			feature_extractor.to_json_string()      )
			self.assertIsInstance(processor.feature_extractor				,			__lowerCamelCase      )




	def       UpperCAmelCase (	self       :    List[str]      )					->   Optional[Any]:

			'''simple docstring'''




			__lowercase					=    SpeechaTextProcessor(
			    tokenizer=self.get_tokenizer()				,			feature_extractor=self.get_feature_extractor()      )
			processor.save_pretrained(self.tmpdirname      )

			__lowercase					=    self.get_tokenizer(bos_token='(BOS)'				,			eos_token='(EOS)'      )
			__lowercase					=    self.get_feature_extractor(do_normalize=__lowerCamelCase				,			padding_value=1.0      )

			__lowercase					=    SpeechaTextProcessor.from_pretrained(
			    self.tmpdirname				,			bos_token='(BOS)'				,			eos_token='(EOS)'				,			do_normalize=__lowerCamelCase				,			padding_value=1.0      )

			self.assertEqual(processor.tokenizer.get_vocab()				,			tokenizer_add_kwargs.get_vocab()      )
			self.assertIsInstance(processor.tokenizer				,			__lowerCamelCase      )

			self.assertEqual(processor.feature_extractor.to_json_string()				,			feature_extractor_add_kwargs.to_json_string()      )
			self.assertIsInstance(processor.feature_extractor				,			__lowerCamelCase      )




	def       UpperCAmelCase (	self       :    Dict      )					->   str:

			'''simple docstring'''




			__lowercase					=    self.get_feature_extractor()
			__lowercase					=    self.get_tokenizer()

			__lowercase					=    SpeechaTextProcessor(tokenizer=__lowerCamelCase				,			feature_extractor=__lowerCamelCase      )

			__lowercase					=    floats_list((3, 1_000)      )

			__lowercase					=    feature_extractor(__lowerCamelCase				,			return_tensors='np'      )
			__lowercase					=    processor(__lowerCamelCase				,			return_tensors='np'      )

			for key in input_feat_extract.keys():
					self.assertAlmostEqual(input_feat_extract[key].sum()				,			input_processor[key].sum()				,			delta=1E-2      )




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

			'''simple docstring'''




			__lowercase					=    self.get_feature_extractor()
			__lowercase					=    self.get_tokenizer()

			__lowercase					=    SpeechaTextProcessor(tokenizer=__lowerCamelCase				,			feature_extractor=__lowerCamelCase      )

			__lowercase					=    'This is a test string'

			__lowercase					=    processor(text=__lowerCamelCase      )

			__lowercase					=    tokenizer(__lowerCamelCase      )

			for key in encoded_tok.keys():
					self.assertListEqual(encoded_tok[key]				,			encoded_processor[key]      )




	def       UpperCAmelCase (	self       :    str      )					->   str:

			'''simple docstring'''




			__lowercase					=    self.get_feature_extractor()
			__lowercase					=    self.get_tokenizer()

			__lowercase					=    SpeechaTextProcessor(tokenizer=__lowerCamelCase				,			feature_extractor=__lowerCamelCase      )

			__lowercase					=    [[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

			__lowercase					=    processor.batch_decode(__lowerCamelCase      )
			__lowercase					=    tokenizer.batch_decode(__lowerCamelCase      )

			self.assertListEqual(__lowerCamelCase				,			__lowerCamelCase      )






	def       UpperCAmelCase (	self       :    Tuple      )					->   str:

			'''simple docstring'''




			__lowercase					=    self.get_feature_extractor()
			__lowercase					=    self.get_tokenizer()

			__lowercase					=    SpeechaTextProcessor(tokenizer=__lowerCamelCase				,			feature_extractor=__lowerCamelCase      )

			self.assertListEqual(
			    processor.model_input_names				,			feature_extractor.model_input_names				,			msg='`processor` and `feature_extractor` model input names do not match'				,			)




