
import argparse
import json
import os

import fairseq
import torch
from fairseq.data import Dictionary

from transformers import (
    WavaVecaConformerConfig,
    WavaVecaConformerForCTC,
    WavaVecaConformerForPreTraining,
    WavaVecaCTCTokenizer,
    WavaVecaFeatureExtractor,
    WavaVecaProcessor,
    logging,
)


logging.set_verbosity_info()
__A							=logging.get_logger(__name__)

__A							={
    '''post_extract_proj''': '''feature_projection.projection''',
    '''encoder.pos_conv.0''': '''encoder.pos_conv_embed.conv''',
    '''self_attn.linear_k''': '''encoder.layers.*.self_attn.linear_k''',
    '''self_attn.linear_v''': '''encoder.layers.*.self_attn.linear_v''',
    '''self_attn.linear_q''': '''encoder.layers.*.self_attn.linear_q''',
    '''self_attn.pos_bias_u''': '''encoder.layers.*.self_attn.pos_bias_u''',
    '''self_attn.pos_bias_v''': '''encoder.layers.*.self_attn.pos_bias_v''',
    '''self_attn.linear_out''': '''encoder.layers.*.self_attn.linear_out''',
    '''self_attn.linear_pos''': '''encoder.layers.*.self_attn.linear_pos''',
    '''self_attn.rotary_emb''': '''encoder.embed_positions''',
    '''self_attn_layer_norm''': '''encoder.layers.*.self_attn_layer_norm''',
    '''conv_module.pointwise_conv1''': '''encoder.layers.*.conv_module.pointwise_conv1''',
    '''conv_module.pointwise_conv2''': '''encoder.layers.*.conv_module.pointwise_conv2''',
    '''conv_module.depthwise_conv''': '''encoder.layers.*.conv_module.depthwise_conv''',
    '''conv_module.batch_norm''': '''encoder.layers.*.conv_module.batch_norm''',
    '''conv_module.layer_norm''': '''encoder.layers.*.conv_module.layer_norm''',
    '''ffn1.w_1''': '''encoder.layers.*.ffn1.intermediate_dense''',
    '''ffn1.w_2''': '''encoder.layers.*.ffn1.output_dense''',
    '''ffn1.layer_norm''': '''encoder.layers.*.ffn1_layer_norm''',
    '''ffn2.w_1''': '''encoder.layers.*.ffn2.intermediate_dense''',
    '''ffn2.w_2''': '''encoder.layers.*.ffn2.output_dense''',
    '''ffn2.layer_norm''': '''encoder.layers.*.ffn2_layer_norm''',
    '''final_layer_norm''': '''encoder.layers.*.final_layer_norm''',
    '''encoder.layer_norm''': '''encoder.layer_norm''',
    '''w2v_model.layer_norm''': '''feature_projection.layer_norm''',
    '''quantizer.weight_proj''': '''quantizer.weight_proj''',
    '''quantizer.vars''': '''quantizer.codevectors''',
    '''project_q''': '''project_q''',
    '''final_proj''': '''project_hid''',
    '''w2v_encoder.proj''': '''lm_head''',
    '''mask_emb''': '''masked_spec_embed''',
}
__A							=[
    '''lm_head''',
    '''quantizer.weight_proj''',
    '''quantizer.codevectors''',
    '''project_q''',
    '''project_hid''',
]





def      lowerCamelCase_					(							lowerCamelCase__      ,					lowerCamelCase__      ,					lowerCamelCase__      ,					lowerCamelCase__      ,					lowerCamelCase__       ):
				for attribute in key.split("."       ):
								lowerCamelCase_         =     getattr(lowerCamelCase__      ,					lowerCamelCase__       )

				if weight_type is not None:
								lowerCamelCase_         =     getattr(lowerCamelCase__      ,					lowerCamelCase__       ).shape
				else:
								lowerCamelCase_         =     hf_pointer.shape

				if hf_shape != value.shape:
								raise ValueError(
								    F'Shape of hf {key + "." + weight_type if weight_type is not None else ""} is {hf_shape}, but should be'
								    F' {value.shape} for {full_name}'       )

				if weight_type == "weight":
								lowerCamelCase_         =     value
				elif weight_type == "weight_g":
								lowerCamelCase_         =     value
				elif weight_type == "weight_v":
								lowerCamelCase_         =     value
				elif weight_type == "bias":
								lowerCamelCase_         =     value
				elif weight_type == "running_mean":
								lowerCamelCase_         =     value
				elif weight_type == "running_var":
								lowerCamelCase_         =     value
				elif weight_type == "num_batches_tracked":
								lowerCamelCase_         =     value
				elif weight_type == "inv_freq":
								lowerCamelCase_         =     value
				else:
								lowerCamelCase_         =     value

				logger.info(F'{key + "." + weight_type if weight_type is not None else ""} was initialized from {full_name}.'       )





def      lowerCamelCase_					(							lowerCamelCase__      ,					lowerCamelCase__      ,					lowerCamelCase__       ):
				lowerCamelCase_         =     []
				lowerCamelCase_         =     fairseq_model.state_dict()

				lowerCamelCase_         =     hf_model.wavaveca_conformer.feature_extractor

				for name, value in fairseq_dict.items():
								lowerCamelCase_         =     False
								if "conv_layers" in name:
												load_conv_layer(
												    lowerCamelCase__      ,					lowerCamelCase__      ,					lowerCamelCase__      ,					lowerCamelCase__      ,					hf_model.config.feat_extract_norm == "group"      ,					)
												lowerCamelCase_         =     True
								else:
												for key, mapped_key in MAPPING.items():
																lowerCamelCase_         =     "wav2vec2_conformer." + mapped_key if mapped_key not in TOP_LEVEL_KEYS else mapped_key
																if key in name or key.split("w2v_model."       )[-1] == name.split("."       )[0]:
																				lowerCamelCase_         =     True
																				if "*" in mapped_key:
																								lowerCamelCase_         =     name.split(lowerCamelCase__       )[0].split("."       )[-2]
																								lowerCamelCase_         =     mapped_key.replace("*"      ,					lowerCamelCase__       )
																				if "pos_bias_u" in name:
																								lowerCamelCase_         =     None
																				elif "pos_bias_v" in name:
																								lowerCamelCase_         =     None
																				elif "weight_g" in name:
																								lowerCamelCase_         =     "weight_g"
																				elif "weight_v" in name:
																								lowerCamelCase_         =     "weight_v"
																				elif "bias" in name:
																								lowerCamelCase_         =     "bias"
																				elif "weight" in name:
																								# TODO: don't match quantizer.weight_proj
																								lowerCamelCase_         =     "weight"
																				elif "running_mean" in name:
																								lowerCamelCase_         =     "running_mean"
																				elif "inv_freq" in name:
																								lowerCamelCase_         =     "inv_freq"
																				elif "running_var" in name:
																								lowerCamelCase_         =     "running_var"
																				elif "num_batches_tracked" in name:
																								lowerCamelCase_         =     "num_batches_tracked"
																				else:
																								lowerCamelCase_         =     None
																				set_recursively(lowerCamelCase__      ,					lowerCamelCase__      ,					lowerCamelCase__      ,					lowerCamelCase__      ,					lowerCamelCase__       )
																continue
								if not is_used:
												unused_weights.append(lowerCamelCase__       )

				logger.warning(F'Unused weights: {unused_weights}'       )





def      lowerCamelCase_					(							lowerCamelCase__      ,					lowerCamelCase__      ,					lowerCamelCase__      ,					lowerCamelCase__      ,					lowerCamelCase__       ):
				lowerCamelCase_         =     full_name.split("conv_layers."       )[-1]
				lowerCamelCase_         =     name.split("."       )
				lowerCamelCase_         =     int(items[0]       )
				lowerCamelCase_         =     int(items[1]       )

				if type_id == 0:
								if "bias" in name:
												if value.shape != feature_extractor.conv_layers[layer_id].conv.bias.data.shape:
																raise ValueError(
																    F'{full_name} has size {value.shape}, but'
																    F' {feature_extractor.conv_layers[layer_id].conv.bias.data.shape} was found.'       )
												lowerCamelCase_         =     value
												logger.info(F'Feat extract conv layer {layer_id} was initialized from {full_name}.'       )
								elif "weight" in name:
												if value.shape != feature_extractor.conv_layers[layer_id].conv.weight.data.shape:
																raise ValueError(
																    F'{full_name} has size {value.shape}, but'
																    F' {feature_extractor.conv_layers[layer_id].conv.weight.data.shape} was found.'       )
												lowerCamelCase_         =     value
												logger.info(F'Feat extract conv layer {layer_id} was initialized from {full_name}.'       )
				elif (type_id == 2 and not use_group_norm) or (type_id == 2 and layer_id == 0 and use_group_norm):
								if "bias" in name:
												if value.shape != feature_extractor.conv_layers[layer_id].layer_norm.bias.data.shape:
																raise ValueError(
																    F'{full_name} has size {value.shape}, but'
																    F' {feature_extractor.conv_layers[layer_id].layer_norm.bias.data.shape} was found.'       )
												lowerCamelCase_         =     value
												logger.info(F'Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}.'       )
								elif "weight" in name:
												if value.shape != feature_extractor.conv_layers[layer_id].layer_norm.weight.data.shape:
																raise ValueError(
																    F'{full_name} has size {value.shape}, but'
																    F' {feature_extractor.conv_layers[layer_id].layer_norm.weight.data.shape} was found.'       )
												lowerCamelCase_         =     value
												logger.info(F'Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}.'       )
				else:
								unused_weights.append(lowerCamelCase__       )





@torch.no_grad()
def      lowerCamelCase_					(							lowerCamelCase__      ,					lowerCamelCase__      ,					lowerCamelCase__=None      ,					lowerCamelCase__=None      ,					lowerCamelCase__=True       ):
				if config_path is not None:
								lowerCamelCase_         =     WavaVecaConformerConfig.from_pretrained(lowerCamelCase__      ,					hidden_act="swish"       )
				else:
								lowerCamelCase_         =     WavaVecaConformerConfig()

				if "rope" in checkpoint_path:
								lowerCamelCase_         =     "rotary"

				if is_finetuned:
								if dict_path:
												lowerCamelCase_         =     Dictionary.load(lowerCamelCase__       )

												# important change bos & pad token id since CTC symbol is <pad> and
												# not <s> as in fairseq
												lowerCamelCase_         =     target_dict.pad_index
												lowerCamelCase_         =     target_dict.bos_index
												lowerCamelCase_         =     target_dict.eos_index
												lowerCamelCase_         =     len(target_dict.symbols       )
												lowerCamelCase_         =     os.path.join(lowerCamelCase__      ,					"vocab.json"       )
												if not os.path.isdir(lowerCamelCase__       ):
																logger.error("--pytorch_dump_folder_path ({}) should be a directory".format(lowerCamelCase__       )       )
																return
												os.makedirs(lowerCamelCase__      ,					exist_ok=lowerCamelCase__       )
												lowerCamelCase_         =     target_dict.indices

												# fairseq has the <pad> and <s> switched
												lowerCamelCase_         =     0
												lowerCamelCase_         =     1
												with open(lowerCamelCase__      ,					"w"      ,					encoding="utf-8"       ) as vocab_handle:
																json.dump(lowerCamelCase__      ,					lowerCamelCase__       )
												lowerCamelCase_         =     WavaVecaCTCTokenizer(
												    lowerCamelCase__      ,					unk_token=target_dict.unk_word      ,					pad_token=target_dict.pad_word      ,					bos_token=target_dict.bos_word      ,					eos_token=target_dict.eos_word      ,					word_delimiter_token="|"      ,					do_lower_case=lowerCamelCase__      ,					)
												lowerCamelCase_         =     True if config.feat_extract_norm == "layer" else False
												lowerCamelCase_         =     WavaVecaFeatureExtractor(
												    feature_size=1      ,					sampling_rate=1_6_0_0_0      ,					padding_value=0      ,					do_normalize=lowerCamelCase__      ,					return_attention_mask=lowerCamelCase__      ,					)
												lowerCamelCase_         =     WavaVecaProcessor(feature_extractor=lowerCamelCase__      ,					tokenizer=lowerCamelCase__       )
												processor.save_pretrained(lowerCamelCase__       )

								lowerCamelCase_         =     WavaVecaConformerForCTC(lowerCamelCase__       )
				else:
								lowerCamelCase_         =     WavaVecaConformerForPreTraining(lowerCamelCase__       )

				if is_finetuned:
								lowerCamelCase_      ,       lowerCamelCase_      ,       lowerCamelCase_         =     fairseq.checkpoint_utils.load_model_ensemble_and_task(
								    [checkpoint_path]      ,					arg_overrides={"data": "/".join(dict_path.split("/"       )[:-1]       )}       )
				else:
								lowerCamelCase_         =     argparse.Namespace(task="audio_pretraining"       )
								lowerCamelCase_         =     fairseq.tasks.setup_task(lowerCamelCase__       )

								lowerCamelCase_      ,       lowerCamelCase_      ,       lowerCamelCase_         =     fairseq.checkpoint_utils.load_model_ensemble_and_task([checkpoint_path]      ,					task=lowerCamelCase__       )

				lowerCamelCase_         =     model[0].eval()

				recursively_load_weights(lowerCamelCase__      ,					lowerCamelCase__      ,					not is_finetuned       )

				hf_wavavec.save_pretrained(lowerCamelCase__       )


if __name__ == "__main__":
			__A							=argparse.ArgumentParser()
			parser.add_argument('''--pytorch_dump_folder_path''', default=None, type=str, help='''Path to the output PyTorch model.''')
			parser.add_argument('''--checkpoint_path''', default=None, type=str, help='''Path to fairseq checkpoint''')
			parser.add_argument('''--dict_path''', default=None, type=str, help='''Path to dict of fine-tuned model''')
			parser.add_argument('''--config_path''', default=None, type=str, help='''Path to hf config.json of model to convert''')
			parser.add_argument(
			    '''--not_finetuned''', action='''store_true''', help='''Whether the model to convert is a fine-tuned model or not'''
			)
			__A							=parser.parse_args()
			convert_wavaveca_conformer_checkpoint(
			    args.checkpoint_path, args.pytorch_dump_folder_path, args.config_path, args.dict_path, not args.not_finetuned
			)




import inspect
import unittest

from transformers import ConvNextConfig
from transformers.testing_utils import require_torch, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

from ...test_backbone_common import BackboneTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
			import torch

			from transformers import ConvNextBackbone, ConvNextForImageClassification, ConvNextModel
			from transformers.models.convnext.modeling_convnext import CONVNEXT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
			from PIL import Image

			from transformers import AutoImageProcessor




class        _SCREAMING_SNAKE_CASE	:



	def __init__(       self		,    lowercase		,    lowercase=13		,    lowercase=32		,    lowercase=3		,    lowercase=4		,    lowercase=[10, 20, 30, 40]		,    lowercase=[2, 2, 3, 2]		,    lowercase=True		,    lowercase=True		,    lowercase=37		,    lowercase="gelu"		,    lowercase=10		,    lowercase=0.0_2		,    lowercase=["stage2", "stage3", "stage4"]		,    lowercase=[2, 3, 4]		,    lowercase=None		,    )							->			Any:
					lowerCamelCase_         =     parent
					lowerCamelCase_         =     batch_size
					lowerCamelCase_         =     image_size
					lowerCamelCase_         =     num_channels
					lowerCamelCase_         =     num_stages
					lowerCamelCase_         =     hidden_sizes
					lowerCamelCase_         =     depths
					lowerCamelCase_         =     is_training
					lowerCamelCase_         =     use_labels
					lowerCamelCase_         =     intermediate_size
					lowerCamelCase_         =     hidden_act
					lowerCamelCase_         =     num_labels
					lowerCamelCase_         =     initializer_range
					lowerCamelCase_         =     out_features
					lowerCamelCase_         =     out_indices
					lowerCamelCase_         =     scope



	def        SCREAMING_SNAKE_CASE_(       self					)							->			Tuple:
					lowerCamelCase_         =     floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]					)

					lowerCamelCase_         =     None
					if self.use_labels:
									lowerCamelCase_         =     ids_tensor([self.batch_size]		,    self.num_labels					)

					lowerCamelCase_         =     self.get_config()
					return config, pixel_values, labels



	def        SCREAMING_SNAKE_CASE_(       self					)							->			Dict:
					return ConvNextConfig(
					    num_channels=self.num_channels		,    hidden_sizes=self.hidden_sizes		,    depths=self.depths		,    num_stages=self.num_stages		,    hidden_act=self.hidden_act		,    is_decoder=lowercase		,    initializer_range=self.initializer_range		,    out_features=self.out_features		,    out_indices=self.out_indices		,    num_labels=self.num_labels		,    )



	def        SCREAMING_SNAKE_CASE_(       self		,    lowercase		,    lowercase		,    lowercase					)							->			Tuple:
					lowerCamelCase_         =     ConvNextModel(config=lowercase					)
					model.to(lowercase					)
					model.eval()
					lowerCamelCase_         =     model(lowercase					)
					# expected last hidden states: B, C, H // 32, W // 32
					self.parent.assertEqual(
					    result.last_hidden_state.shape		,    (self.batch_size, self.hidden_sizes[-1], self.image_size // 32, self.image_size // 32)		,    )



	def        SCREAMING_SNAKE_CASE_(       self		,    lowercase		,    lowercase		,    lowercase					)							->			str:
					lowerCamelCase_         =     ConvNextForImageClassification(lowercase					)
					model.to(lowercase					)
					model.eval()
					lowerCamelCase_         =     model(lowercase		,    labels=lowercase					)
					self.parent.assertEqual(result.logits.shape		,    (self.batch_size, self.num_labels)					)



	def        SCREAMING_SNAKE_CASE_(       self		,    lowercase		,    lowercase		,    lowercase					)							->			str:
					lowerCamelCase_         =     ConvNextBackbone(config=lowercase					)
					model.to(lowercase					)
					model.eval()
					lowerCamelCase_         =     model(lowercase					)

					# verify hidden states
					self.parent.assertEqual(len(result.feature_maps					)		,    len(config.out_features					)					)
					self.parent.assertListEqual(list(result.feature_maps[0].shape					)		,    [self.batch_size, self.hidden_sizes[1], 4, 4]					)

					# verify channels
					self.parent.assertEqual(len(model.channels					)		,    len(config.out_features					)					)
					self.parent.assertListEqual(model.channels		,    config.hidden_sizes[1:]					)

					# verify backbone works with out_features=None
					lowerCamelCase_         =     None
					lowerCamelCase_         =     ConvNextBackbone(config=lowercase					)
					model.to(lowercase					)
					model.eval()
					lowerCamelCase_         =     model(lowercase					)

					# verify feature maps
					self.parent.assertEqual(len(result.feature_maps					)		,    1					)
					self.parent.assertListEqual(list(result.feature_maps[0].shape					)		,    [self.batch_size, self.hidden_sizes[-1], 1, 1]					)

					# verify channels
					self.parent.assertEqual(len(model.channels					)		,    1					)
					self.parent.assertListEqual(model.channels		,    [config.hidden_sizes[-1]]					)



	def        SCREAMING_SNAKE_CASE_(       self					)							->			Optional[Any]:
					lowerCamelCase_         =     self.prepare_config_and_inputs()
					lowerCamelCase_      ,       lowerCamelCase_      ,       lowerCamelCase_         =     config_and_inputs
					lowerCamelCase_         =     {"pixel_values": pixel_values}
					return config, inputs_dict




@require_torch
class        _SCREAMING_SNAKE_CASE	( snake_case_     ,			snake_case_     ,			unittest.TestCase		):
	lowerCAmelCase__   =					(
	    (
	        ConvNextModel,
	        ConvNextForImageClassification,
	        ConvNextBackbone,
	    )
	    if is_torch_available()
	    else ()
	)
	lowerCAmelCase__   =					(
	    {'feature-extraction': ConvNextModel, 'image-classification': ConvNextForImageClassification}
	    if is_torch_available()
	    else {}
	)

	lowerCAmelCase__   =					True
	lowerCAmelCase__   =					False
	lowerCAmelCase__   =					False
	lowerCAmelCase__   =					False
	lowerCAmelCase__   =					False



	def        SCREAMING_SNAKE_CASE_(       self					)							->			Optional[int]:
					lowerCamelCase_         =     ConvNextModelTester(self					)
					lowerCamelCase_         =     ConfigTester(self		,    config_class=lowercase		,    has_text_modality=lowercase		,    hidden_size=37					)



	def        SCREAMING_SNAKE_CASE_(       self					)							->			Union[str, Any]:
					self.create_and_test_config_common_properties()
					self.config_tester.create_and_test_config_to_json_string()
					self.config_tester.create_and_test_config_to_json_file()
					self.config_tester.create_and_test_config_from_and_save_pretrained()
					self.config_tester.create_and_test_config_with_num_labels()
					self.config_tester.check_config_can_be_init_without_params()
					self.config_tester.check_config_arguments_init()



	def        SCREAMING_SNAKE_CASE_(       self					)							->			Optional[Any]:
					return



	@unittest.skip(reason="ConvNext does not use inputs_embeds"					)
	def        SCREAMING_SNAKE_CASE_(       self					)							->			List[str]:
					pass



	@unittest.skip(reason="ConvNext does not support input and output embeddings"					)
	def        SCREAMING_SNAKE_CASE_(       self					)							->			List[Any]:
					pass



	@unittest.skip(reason="ConvNext does not use feedforward chunking"					)
	def        SCREAMING_SNAKE_CASE_(       self					)							->			Tuple:
					pass



	def        SCREAMING_SNAKE_CASE_(       self					)							->			Union[str, Any]:
					lowerCamelCase_      ,       lowerCamelCase_         =     self.model_tester.prepare_config_and_inputs_for_common()

					for model_class in self.all_model_classes:
									lowerCamelCase_         =     model_class(lowercase					)
									lowerCamelCase_         =     inspect.signature(model.forward					)
									# signature.parameters is an OrderedDict => so arg_names order is deterministic
									lowerCamelCase_         =     [*signature.parameters.keys()]

									lowerCamelCase_         =     ["pixel_values"]
									self.assertListEqual(arg_names[:1]		,    lowercase					)



	def        SCREAMING_SNAKE_CASE_(       self					)							->			Dict:
					lowerCamelCase_         =     self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_model(*lowercase					)



	def        SCREAMING_SNAKE_CASE_(       self					)							->			Dict:
					lowerCamelCase_         =     self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_backbone(*lowercase					)



	def        SCREAMING_SNAKE_CASE_(       self					)							->			Optional[Any]:
					def check_hidden_states_output(lowercase		,    lowercase		,    lowercase					):
									lowerCamelCase_         =     model_class(lowercase					)
									model.to(lowercase					)
									model.eval()

									with torch.no_grad():
													lowerCamelCase_         =     model(**self._prepare_for_class(lowercase		,    lowercase					)					)

									lowerCamelCase_         =     outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

									lowerCamelCase_         =     self.model_tester.num_stages
									self.assertEqual(len(lowercase					)		,    expected_num_stages + 1					)

									# ConvNext's feature maps are of shape (batch_size, num_channels, height, width)
									self.assertListEqual(
									    list(hidden_states[0].shape[-2:]					)		,    [self.model_tester.image_size // 4, self.model_tester.image_size // 4]		,    )

					lowerCamelCase_      ,       lowerCamelCase_         =     self.model_tester.prepare_config_and_inputs_for_common()

					for model_class in self.all_model_classes:
									lowerCamelCase_         =     True
									check_hidden_states_output(lowercase		,    lowercase		,    lowercase					)

									# check that output_hidden_states also work using config
									del inputs_dict["output_hidden_states"]
									lowerCamelCase_         =     True

									check_hidden_states_output(lowercase		,    lowercase		,    lowercase					)



	def        SCREAMING_SNAKE_CASE_(       self					)							->			str:
					lowerCamelCase_         =     self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_for_image_classification(*lowercase					)



	@slow
	def        SCREAMING_SNAKE_CASE_(       self					)							->			Dict:
					for model_name in CONVNEXT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
									lowerCamelCase_         =     ConvNextModel.from_pretrained(lowercase					)
									self.assertIsNotNone(lowercase					)





def      lowerCamelCase_					(							):
				lowerCamelCase_         =     Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"       )
				return image




@require_torch
@require_vision
class        _SCREAMING_SNAKE_CASE	( unittest.TestCase		):



	@cached_property
	def        SCREAMING_SNAKE_CASE_(       self					)							->			List[str]:
					return AutoImageProcessor.from_pretrained("facebook/convnext-tiny-224"					) if is_vision_available() else None



	@slow
	def        SCREAMING_SNAKE_CASE_(       self					)							->			List[Any]:
					lowerCamelCase_         =     ConvNextForImageClassification.from_pretrained("facebook/convnext-tiny-224"					).to(lowercase					)

					lowerCamelCase_         =     self.default_image_processor
					lowerCamelCase_         =     prepare_img()
					lowerCamelCase_         =     image_processor(images=lowercase		,    return_tensors="pt"					).to(lowercase					)

					# forward pass
					with torch.no_grad():
									lowerCamelCase_         =     model(**lowercase					)

					# verify the logits
					lowerCamelCase_         =     torch.Size((1, 1000)					)
					self.assertEqual(outputs.logits.shape		,    lowercase					)

					lowerCamelCase_         =     torch.tensor([-0.0_2_6_0, -0.4_7_3_9, 0.1_9_1_1]					).to(lowercase					)

					self.assertTrue(torch.allclose(outputs.logits[0, :3]		,    lowercase		,    atol=1e-4					)					)




@require_torch
class        _SCREAMING_SNAKE_CASE	( unittest.TestCase     ,			snake_case_		):
	lowerCAmelCase__   =					(ConvNextBackbone,) if is_torch_available() else ()
	lowerCAmelCase__   =					ConvNextConfig

	lowerCAmelCase__   =					False



	def        SCREAMING_SNAKE_CASE_(       self					)							->			List[Any]:
					lowerCamelCase_         =     ConvNextModelTester(self					)


