



import argparse
import random

import joblib
import numpy as np
import torch
from igf.igf import (
    SecondaryLearner,
    collect_objective_set,
    compute_perplexity,
    generate_datasets,
    load_gpta,
    recopy_gpta,
    set_seed,
    train_secondary_learner,
)
from torch.utils.data import DataLoader, RandomSampler

from transformers import GPTaLMHeadModel







def snake_case__	(      __SCREAMING_SNAKE_CASE=32      ,  __SCREAMING_SNAKE_CASE=10      ,  __SCREAMING_SNAKE_CASE=100      ,  __SCREAMING_SNAKE_CASE=1026      ,  __SCREAMING_SNAKE_CASE=True      ,  __SCREAMING_SNAKE_CASE="data/tokenized_stories_train_wikitext103.jbl"      ,  __SCREAMING_SNAKE_CASE="igf_context_pairs.jbl"      ,  )		->				str:
		set_seed(3			)
		# generate train_data and objective_set
		UpperCAmelCase_       ,    UpperCAmelCase_						       =					generate_datasets(
		    __SCREAMING_SNAKE_CASE      ,  __SCREAMING_SNAKE_CASE      ,  number=__SCREAMING_SNAKE_CASE      ,  min_len=1026      ,  trim=__SCREAMING_SNAKE_CASE			)
		# keeps model same across runs
		set_seed(4			)
		# model, lm_optimizer, lm_scheduler = recopy_gpt2(model, device, max_steps) # store original model weights
		# can we train on GPU?
		UpperCAmelCase_						       =					torch.device("cuda:0" if torch.cuda.is_available() else "cpu"			)

		# load pretrained model
		UpperCAmelCase_						       =					load_gpta("gpt2"			).to(__SCREAMING_SNAKE_CASE			)
		print("computing perplexity on objective set"			)
		UpperCAmelCase_						       =					compute_perplexity(__SCREAMING_SNAKE_CASE      ,  __SCREAMING_SNAKE_CASE      ,  __SCREAMING_SNAKE_CASE			).item()
		print("perplexity on objective set:"      ,  __SCREAMING_SNAKE_CASE			)

		# collect igf pairs and save to file demo.jbl
		collect_objective_set(__SCREAMING_SNAKE_CASE      ,  __SCREAMING_SNAKE_CASE      ,  __SCREAMING_SNAKE_CASE      ,  __SCREAMING_SNAKE_CASE      ,  __SCREAMING_SNAKE_CASE      ,  __SCREAMING_SNAKE_CASE      ,  __SCREAMING_SNAKE_CASE      ,  __SCREAMING_SNAKE_CASE			)

		# clean up, delete model and data we don't need anymore
		del model, train_data, objective_set
		torch.cuda.empty_cache()







def snake_case__	(      __SCREAMING_SNAKE_CASE      ,  __SCREAMING_SNAKE_CASE=15      ,  __SCREAMING_SNAKE_CASE=128      ,  __SCREAMING_SNAKE_CASE=100      ,  __SCREAMING_SNAKE_CASE="igf_model.pt"      ,  )		->				Optional[int]:
		set_seed(42			)

		# Load pre-trained model
		UpperCAmelCase_						       =					GPTaLMHeadModel.from_pretrained("gpt2"			)

		# Initialize secondary learner to use embedding weights of model
		UpperCAmelCase_						       =					SecondaryLearner(__SCREAMING_SNAKE_CASE			)

		# Train secondary learner
		UpperCAmelCase_						       =					train_secondary_learner(
		    __SCREAMING_SNAKE_CASE      ,  __SCREAMING_SNAKE_CASE      ,  max_epochs=__SCREAMING_SNAKE_CASE      ,  batch_size=__SCREAMING_SNAKE_CASE      ,  eval_freq=100      ,  igf_model_path=__SCREAMING_SNAKE_CASE      ,  )

		del model, secondary_learner_train_data
		torch.cuda.empty_cache()

		return secondary_learner







def snake_case__	(      __SCREAMING_SNAKE_CASE      ,  __SCREAMING_SNAKE_CASE      ,  __SCREAMING_SNAKE_CASE      ,  __SCREAMING_SNAKE_CASE=32      ,  __SCREAMING_SNAKE_CASE=1000      ,  __SCREAMING_SNAKE_CASE=16      ,  __SCREAMING_SNAKE_CASE=1.0      ,  __SCREAMING_SNAKE_CASE=recopy_gpta      ,  __SCREAMING_SNAKE_CASE=None      ,  __SCREAMING_SNAKE_CASE=10      ,  __SCREAMING_SNAKE_CASE="gpt2_finetuned.pt"      ,  )		->				List[Any]:
		UpperCAmelCase_						       =					torch.device("cuda:0" if torch.cuda.is_available() else "cpu"			)
		UpperCAmelCase_						       =					RandomSampler(__SCREAMING_SNAKE_CASE			)
		UpperCAmelCase_						       =					DataLoader(__SCREAMING_SNAKE_CASE      ,  sampler=__SCREAMING_SNAKE_CASE			)

		UpperCAmelCase_						       =					max_steps // (len(__SCREAMING_SNAKE_CASE			)) + 1
		UpperCAmelCase_						       =					0
		UpperCAmelCase_						       =					torch.zeros((1, context_len)      ,  dtype=torch.long      ,  device=__SCREAMING_SNAKE_CASE			)
		UpperCAmelCase_       ,    UpperCAmelCase_       ,    UpperCAmelCase_						       =					recopy_model(__SCREAMING_SNAKE_CASE      ,  __SCREAMING_SNAKE_CASE      ,  __SCREAMING_SNAKE_CASE			)

		model.train()
		if secondary_learner is not None:
				secondary_learner.to(__SCREAMING_SNAKE_CASE			)
				secondary_learner.eval()
		UpperCAmelCase_						       =					[]
		UpperCAmelCase_						       =					0

		UpperCAmelCase_						       =					[]
		UpperCAmelCase_						       =					[]

		# Compute the performance of the transformer model at the beginning
		UpperCAmelCase_						       =					compute_perplexity(__SCREAMING_SNAKE_CASE      ,  __SCREAMING_SNAKE_CASE      ,  __SCREAMING_SNAKE_CASE			)
		test_perps.append(__SCREAMING_SNAKE_CASE			)
		print("Test perplexity, step"      ,  __SCREAMING_SNAKE_CASE      ,  ":"      ,  __SCREAMING_SNAKE_CASE			)
		for epoch in range(int(__SCREAMING_SNAKE_CASE			)			):
				for step, example in enumerate(__SCREAMING_SNAKE_CASE			):
						torch.cuda.empty_cache()
						UpperCAmelCase_						       =					random.randint(0      ,  example.size(2			) - context_len - 1			)
						UpperCAmelCase_						       =					example[0, 0, start : start + context_len]
						lm_optimizer.zero_grad()
						UpperCAmelCase_						       =					model(__SCREAMING_SNAKE_CASE      ,  labels=__SCREAMING_SNAKE_CASE			)
						UpperCAmelCase_						       =					True

						if secondary_learner is not None:
								UpperCAmelCase_						       =					secondary_learner.forward(
								    torch.tensor(__SCREAMING_SNAKE_CASE      ,  dtype=torch.long      ,  device=__SCREAMING_SNAKE_CASE			).unsqueeze(0			)			)[0].item()
								observed_qs.append(float(__SCREAMING_SNAKE_CASE			)			)

								# Here we implement the simple non-constant threshold for the predicted IG(X) value
								# We will decay the selectivity of our secondary learner filter from
								# 1 standard deviation above average to 1 below average after 10 batches.

								if global_step == 10:
										UpperCAmelCase_						       =					-1
								if predicted_q < threshold:
										UpperCAmelCase_						       =					False

            # If we passed the filter, add the context to the batch!
						if do_backprop:
								contexts.append(np.array(context.cpu()			)			)
								UpperCAmelCase_						       =					outputs[0]
								lm_loss.backward()
								examples += 1

						del outputs

						# Once the batch is filled with enough contexts, backprop on the batch.
						if examples == batch_size:
								torch.cuda.empty_cache()
								UpperCAmelCase_						       =					0
								# Do LM backprop
								torch.nn.utils.clip_grad_norm_(model.parameters()      ,  3.0			)
								lm_optimizer.step()
								lm_scheduler.step()  # Update learning rate schedule
								global_step += 1
								# Compute the performance of the transformer model at this batch
								if global_step % eval_interval == 0:
										UpperCAmelCase_						       =					compute_perplexity(__SCREAMING_SNAKE_CASE      ,  __SCREAMING_SNAKE_CASE      ,  __SCREAMING_SNAKE_CASE			)
										test_perps.append(__SCREAMING_SNAKE_CASE			)

										print("Test perplexity, step"      ,  __SCREAMING_SNAKE_CASE      ,  ":"      ,  __SCREAMING_SNAKE_CASE			)
            # Break out of the loop after 60 batches
						if max_steps > 0 and global_step > 60:
								break
				if max_steps > 0 and global_step > 60:
						break

    # save finetuned transformer model
		torch.save(model.state_dict()      ,  __SCREAMING_SNAKE_CASE			)
		torch.cuda.empty_cache()
		# Do some cleaning up so we can reinitialize for the next run of this function
		del lm_optimizer
		del lm_scheduler
		return model







def snake_case__	(      )		->				List[Any]:
		UpperCAmelCase_						       =					argparse.ArgumentParser(description="Fine-tune a transformer model with IGF on a language modeling task"			)

		# Required parameters
		parser.add_argument(
		    "--data_dir"      ,  default=__SCREAMING_SNAKE_CASE      ,  type=__SCREAMING_SNAKE_CASE      ,  required=__SCREAMING_SNAKE_CASE      ,  help="The input data dir. Should contain data files for WikiText."      ,  )
		parser.add_argument(
		    "--model_name_or_path"      ,  default=__SCREAMING_SNAKE_CASE      ,  type=__SCREAMING_SNAKE_CASE      ,  required=__SCREAMING_SNAKE_CASE      ,  help="Path to pretrained model or model identifier from huggingface.co/models"      ,  )
		parser.add_argument(
		    "--data_file"      ,  type=__SCREAMING_SNAKE_CASE      ,  default=__SCREAMING_SNAKE_CASE      ,  help=(
		        "A jbl file containing tokenized data which can be split as objective dataset, "
		        "train_dataset and test_dataset."
		    )      ,  )

		parser.add_argument(
		    "--igf_data_file"      ,  type=__SCREAMING_SNAKE_CASE      ,  default=__SCREAMING_SNAKE_CASE      ,  help="A jbl file containing the context and information gain pairs to train secondary learner."      ,  )

		parser.add_argument(
		    "--output_dir"      ,  default=__SCREAMING_SNAKE_CASE      ,  type=__SCREAMING_SNAKE_CASE      ,  required=__SCREAMING_SNAKE_CASE      ,  help="The output directory where the final fine-tuned model is stored."      ,  )

		parser.add_argument(
		    "--tokenizer_name"      ,  default=__SCREAMING_SNAKE_CASE      ,  type=__SCREAMING_SNAKE_CASE      ,  help="Pretrained tokenizer name or path if not the same as model_name"      ,  )
		parser.add_argument("--seed"      ,  type=__SCREAMING_SNAKE_CASE      ,  default=__SCREAMING_SNAKE_CASE      ,  help="A seed for reproducible training."			)

		parser.add_argument(
		    "--context_len"      ,  default=32      ,  type=__SCREAMING_SNAKE_CASE      ,  help=(
		        "The maximum total input sequence length after tokenization. Sequences longer "
		        "than this will be truncated, sequences shorter will be padded."
		    )      ,  )

		parser.add_argument(
		    "--size_objective_set"      ,  default=100      ,  type=__SCREAMING_SNAKE_CASE      ,  help="number of articles that are long enough to be used as our objective set"      ,  )
		parser.add_argument(
		    "--eval_freq"      ,  default=100      ,  type=__SCREAMING_SNAKE_CASE      ,  help="secondary model evaluation is triggered at eval_freq"			)

		parser.add_argument("--max_steps"      ,  default=1000      ,  type=__SCREAMING_SNAKE_CASE      ,  help="To calculate training epochs"			)

		parser.add_argument(
		    "--secondary_learner_batch_size"      ,  default=128      ,  type=__SCREAMING_SNAKE_CASE      ,  help="batch size of training data for secondary learner"      ,  )

		parser.add_argument(
		    "--batch_size"      ,  default=16      ,  type=__SCREAMING_SNAKE_CASE      ,  help="batch size of training data of language model(gpt2) "			)

		parser.add_argument(
		    "--eval_interval"      ,  default=10      ,  type=__SCREAMING_SNAKE_CASE      ,  help=(
		        "decay the selectivity of our secondary learner filter from"
		        "1 standard deviation above average to 1 below average after 10 batches"
		    )      ,  )

		parser.add_argument(
		    "--number"      ,  default=100      ,  type=__SCREAMING_SNAKE_CASE      ,  help="The number of examples split to be used as objective_set/test_data"			)

		parser.add_argument(
		    "--min_len"      ,  default=1026      ,  type=__SCREAMING_SNAKE_CASE      ,  help="The minimum length of the article to be used as objective set"			)

		parser.add_argument(
		    "--secondary_learner_max_epochs"      ,  default=15      ,  type=__SCREAMING_SNAKE_CASE      ,  help="number of epochs to train secondary learner"			)

		parser.add_argument("--trim"      ,  default=__SCREAMING_SNAKE_CASE      ,  type=__SCREAMING_SNAKE_CASE      ,  help="truncate the example if it exceeds context length"			)

		parser.add_argument(
		    "--threshold"      ,  default=1.0      ,  type=__SCREAMING_SNAKE_CASE      ,  help=(
		        "The threshold value used by secondary learner to filter the train_data and allow only"
		        " informative data as input to the model"
		    )      ,  )

		parser.add_argument("--finetuned_model_name"      ,  default="gpt2_finetuned.pt"      ,  type=__SCREAMING_SNAKE_CASE      ,  help="finetuned_model_name"			)

		parser.add_argument(
		    "--recopy_model"      ,  default=__SCREAMING_SNAKE_CASE      ,  type=__SCREAMING_SNAKE_CASE      ,  help="Reset the model to the original pretrained GPT-2 weights after each iteration"      ,  )

		# function calls
		# Collecting *n* pairs of context and information gain(X, IG(X)) for training the secondary learner
		generate_n_pairs(
		    context_len=32      ,  max_steps=10      ,  size_objective_set=100      ,  min_len=1026      ,  trim=__SCREAMING_SNAKE_CASE      ,  data_file="data/tokenized_stories_train_wikitext103.jbl"      ,  igf_data_file="igf_context_pairs.jbl"      ,  )

		# Load train data for secondary learner
		UpperCAmelCase_						       =					joblib.load("data/IGF_values.jbl"			)

		# Train secondary learner
		UpperCAmelCase_						       =					training_secondary_learner(
		    __SCREAMING_SNAKE_CASE      ,  secondary_learner_max_epochs=15      ,  secondary_learner_batch_size=128      ,  eval_freq=100      ,  igf_model_path="igf_model.pt"      ,  )

		# load pretrained gpt2 model
		UpperCAmelCase_						       =					GPTaLMHeadModel.from_pretrained("gpt2"			)
		set_seed(42			)

		# Generate train and test data to train and evaluate gpt2 model
		UpperCAmelCase_       ,    UpperCAmelCase_						       =					generate_datasets(
		    context_len=32      ,  file="data/tokenized_stories_train_wikitext103.jbl"      ,  number=100      ,  min_len=1026      ,  trim=__SCREAMING_SNAKE_CASE			)

		# fine-tuning of the gpt2 model using igf (Information Gain Filtration)
		finetune(
		    __SCREAMING_SNAKE_CASE      ,  __SCREAMING_SNAKE_CASE      ,  __SCREAMING_SNAKE_CASE      ,  context_len=32      ,  max_steps=1000      ,  batch_size=16      ,  threshold=1.0      ,  recopy_model=__SCREAMING_SNAKE_CASE      ,  secondary_learner=__SCREAMING_SNAKE_CASE      ,  eval_interval=10      ,  finetuned_model_name="gpt2_finetuned.pt"      ,  )


if __name__ == "__main__":
			main()







from __future__ import annotations

import inspect
import unittest

import numpy as np

from transformers import ResNetConfig
from transformers.testing_utils import require_tf, require_vision, slow
from transformers.utils import cached_property, is_tf_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
						import tensorflow as tf

						from transformers import TFResNetForImageClassification, TFResNetModel
						from transformers.models.resnet.modeling_tf_resnet import TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
						from PIL import Image

						from transformers import AutoImageProcessor



class    lowercase_		:



						def __init__(			self	:   Optional[Any]					,							snake_case__	:   List[Any]					,							snake_case__	:   Tuple=3					,							snake_case__	:   Union[str, Any]=32					,							snake_case__	:   Union[str, Any]=3					,							snake_case__	:   str=10					,							snake_case__	:   List[Any]=[10, 20, 30, 40]					,							snake_case__	:   Optional[Any]=[1, 1, 2, 1]					,							snake_case__	:   str=True					,							snake_case__	:   str=True					,							snake_case__	:   List[str]="relu"					,							snake_case__	:   Tuple=3					,							snake_case__	:   str=None					,							):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_					      =							parent
								SCREAMING_SNAKE_CASE_					      =							batch_size
								SCREAMING_SNAKE_CASE_					      =							image_size
								SCREAMING_SNAKE_CASE_					      =							num_channels
								SCREAMING_SNAKE_CASE_					      =							embeddings_size
								SCREAMING_SNAKE_CASE_					      =							hidden_sizes
								SCREAMING_SNAKE_CASE_					      =							depths
								SCREAMING_SNAKE_CASE_					      =							is_training
								SCREAMING_SNAKE_CASE_					      =							use_labels
								SCREAMING_SNAKE_CASE_					      =							hidden_act
								SCREAMING_SNAKE_CASE_					      =							num_labels
								SCREAMING_SNAKE_CASE_					      =							scope
								SCREAMING_SNAKE_CASE_					      =							len(snake_case__  )



						def 	__a					(			self	:   Any  ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_					      =							floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]  )

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

								SCREAMING_SNAKE_CASE_					      =							self.get_config()

								return config, pixel_values, labels



						def 	__a					(			self	:   int  ):

								"""simple docstring"""

								return ResNetConfig(
								    num_channels=self.num_channels					,							embeddings_size=self.embeddings_size					,							hidden_sizes=self.hidden_sizes					,							depths=self.depths					,							hidden_act=self.hidden_act					,							num_labels=self.num_labels					,							image_size=self.image_size					,							)



						def 	__a					(			self	:   str					,							snake_case__	:   str					,							snake_case__	:   Tuple					,							snake_case__	:   Optional[Any]  ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_					      =							TFResNetModel(config=snake_case__  )
								SCREAMING_SNAKE_CASE_					      =							model(snake_case__  )
								# 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 	__a					(			self	:   int					,							snake_case__	:   Optional[Any]					,							snake_case__	:   int					,							snake_case__	:   Any  ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_					      =							self.num_labels
								SCREAMING_SNAKE_CASE_					      =							TFResNetForImageClassification(snake_case__  )
								SCREAMING_SNAKE_CASE_					      =							model(snake_case__					,							labels=snake_case__  )
								self.parent.assertEqual(result.logits.shape					,							(self.batch_size, self.num_labels)  )






						def 	__a					(			self	:   Dict  ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_					      =							self.prepare_config_and_inputs()
								SCREAMING_SNAKE_CASE_      ,				SCREAMING_SNAKE_CASE_      ,				SCREAMING_SNAKE_CASE_					      =							config_and_inputs
								SCREAMING_SNAKE_CASE_					      =							{'pixel_values': pixel_values}
								return config, inputs_dict



@require_tf
class    lowercase_		(SCREAMING_SNAKE_CASE__							,	SCREAMING_SNAKE_CASE__							,	unittest.TestCase ):
						lowerCAmelCase__			      =(TFResNetModel, TFResNetForImageClassification) if is_tf_available() else ()
						lowerCAmelCase__			      =(
						    {"feature-extraction": TFResNetModel, "image-classification": TFResNetForImageClassification}
						    if is_tf_available()
						    else {}
						)

						lowerCAmelCase__			      =False
						lowerCAmelCase__			      =False
						lowerCAmelCase__			      =False
						lowerCAmelCase__			      =False
						lowerCAmelCase__			      =False



						def 	__a					(			self	:   str  ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_					      =							TFResNetModelTester(self  )
								SCREAMING_SNAKE_CASE_					      =							ConfigTester(self					,							config_class=snake_case__					,							has_text_modality=snake_case__  )



						def 	__a					(			self	:   Optional[Any]  ):

								"""simple docstring"""

								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 	__a					(			self	:   List[Any]  ):

								"""simple docstring"""

								return



						@unittest.skip(reason='ResNet does not use inputs_embeds'  )
						def 	__a					(			self	:   Optional[Any]  ):

								"""simple docstring"""

								pass



						@unittest.skip(reason='ResNet does not support input and output embeddings'  )
						def 	__a					(			self	:   Tuple  ):

								"""simple docstring"""

								pass



						def 	__a					(			self	:   List[Any]  ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_      ,				SCREAMING_SNAKE_CASE_					      =							self.model_tester.prepare_config_and_inputs_for_common()

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

										SCREAMING_SNAKE_CASE_					      =							['pixel_values']
										self.assertListEqual(arg_names[:1]					,							snake_case__  )



						def 	__a					(			self	:   Union[str, Any]  ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_					      =							self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_model(*snake_case__  )



						def 	__a					(			self	:   int  ):

								"""simple docstring"""

								def check_hidden_states_output(snake_case__	:   Optional[int]					,							snake_case__	:   int					,							snake_case__	:   Dict  ):
										SCREAMING_SNAKE_CASE_					      =							model_class(snake_case__  )
										SCREAMING_SNAKE_CASE_					      =							model(**self._prepare_for_class(snake_case__					,							snake_case__  )  )

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

										SCREAMING_SNAKE_CASE_					      =							self.model_tester.num_stages
										self.assertEqual(len(snake_case__  )					,							expected_num_stages + 1  )

										# ResNet'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]					,							)

								SCREAMING_SNAKE_CASE_      ,				SCREAMING_SNAKE_CASE_					      =							self.model_tester.prepare_config_and_inputs_for_common()
								SCREAMING_SNAKE_CASE_					      =							['basic', 'bottleneck']
								for model_class in self.all_model_classes:
										for layer_type in layers_type:
												SCREAMING_SNAKE_CASE_					      =							layer_type
												SCREAMING_SNAKE_CASE_					      =							True
												check_hidden_states_output(snake_case__					,							snake_case__					,							snake_case__  )

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

												check_hidden_states_output(snake_case__					,							snake_case__					,							snake_case__  )



						def 	__a					(			self	:   List[Any]  ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_					      =							self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_image_classification(*snake_case__  )






						@slow
						def 	__a					(			self	:   Tuple  ):

								"""simple docstring"""

								for model_name in TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
										SCREAMING_SNAKE_CASE_					      =							TFResNetModel.from_pretrained(snake_case__  )
										self.assertIsNotNone(snake_case__  )


def 					_a							(					)->	Tuple:
		SCREAMING_SNAKE_CASE_					      =							Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png' )
		return image




@require_tf
@require_vision
class    lowercase_		(unittest.TestCase ):



						@cached_property
						def 	__a					(			self	:   List[Any]  ):

								"""simple docstring"""

								return (
								    AutoImageProcessor.from_pretrained(TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]  )
								    if is_vision_available()
								    else None
								)






						@slow
						def 	__a					(			self	:   Any  ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_					      =							TFResNetForImageClassification.from_pretrained(TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]  )

								SCREAMING_SNAKE_CASE_					      =							self.default_image_processor
								SCREAMING_SNAKE_CASE_					      =							prepare_img()
								SCREAMING_SNAKE_CASE_					      =							image_processor(images=snake_case__					,							return_tensors='tf'  )

								# forward pass
								SCREAMING_SNAKE_CASE_					      =							model(**snake_case__  )

								# verify the logits
								SCREAMING_SNAKE_CASE_					      =							tf.TensorShape((1, 10_00)  )
								self.assertEqual(outputs.logits.shape					,							snake_case__  )

								SCREAMING_SNAKE_CASE_					      =							tf.constant([-11.10_69, -9.78_77, -8.37_77]  )

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