
import argparse
import gc
import os
import threading

import evaluate
import psutil
import torch
from datasets import load_dataset
from torch.distributed.fsdp.fully_sharded_data_parallel import FullOptimStateDictConfig, FullStateDictConfig
from torch.utils.data import DataLoader
from transformers import (
    AutoModelForSequenceClassification,
    AutoTokenizer,
    get_linear_schedule_with_warmup,
    set_seed,
)

from accelerate import Accelerator, DistributedType, FullyShardedDataParallelPlugin


########################################################################
# This is a fully working simple example to use Accelerate
#
# This example trains a Bert base model on GLUE MRPC
# in any of the following settings (with the same script):
#   - single CPU or single GPU
#   - multi GPUS (using PyTorch distributed mode)
#   - (multi) TPUs
#   - fp16 (mixed-precision) or fp32 (normal precision)
#   - FSDP
#
# This example also demonstrates the checkpointing and sharding capabilities
#
# To run it in each of these various modes, follow the instructions
# in the readme for examples:
# https://github.com/huggingface/accelerate/tree/main/examples
#
########################################################################


A__       :   List[Any]   						=					1_6
A__       :   int   						=					3_2



def      _a     (   __UpperCamelCase       :  List[Any]    ):
			return int(x / 2**20    )





class 						lowercase       :
					def __enter__(		self    ):
								"""simple docstring"""







								gc.collect()
								torch.cuda.empty_cache()
								torch.cuda.reset_max_memory_allocated()  # reset the peak gauge to zero
								lowerCAmelCase__ :    Optional[Any]				      =			torch.cuda.memory_allocated()
								lowerCAmelCase__ :    int				      =			psutil.Process()

								lowerCAmelCase__ :    List[str]				      =			self.cpu_mem_used()
								lowerCAmelCase__ :    Dict				      =			True
								lowerCAmelCase__ :    Optional[Any]				      =			threading.Thread(target=self.peak_monitor_func    )
								lowerCAmelCase__ :    Dict				      =			True
								peak_monitor_thread.start()
								return self
					def lowercase_			(		self    ):
								"""simple docstring"""







								return self.process.memory_info().rss
					def lowercase_			(		self    ):
								"""simple docstring"""







								lowerCAmelCase__ :    Union[str, Any]				      =			-1

								while True:
											lowerCAmelCase__ :    str				      =			max(self.cpu_mem_used() ,	self.cpu_peak    )

											# can't sleep or will not catch the peak right (this comment is here on purpose)
											# time.sleep(0.001) # 1msec

											if not self.peak_monitoring:
														break
					def __exit__(		self ,	*SCREAMING_SNAKE_CASE__    ):
								"""simple docstring"""







								lowerCAmelCase__ :    Tuple				      =			False

								gc.collect()
								torch.cuda.empty_cache()
								lowerCAmelCase__ :    Union[str, Any]				      =			torch.cuda.memory_allocated()
								lowerCAmelCase__ :    List[Any]				      =			torch.cuda.max_memory_allocated()
								lowerCAmelCase__ :    Tuple				      =			bamb(self.end - self.begin    )
								lowerCAmelCase__ :    Optional[int]				      =			bamb(self.peak - self.begin    )

								lowerCAmelCase__ :    List[Any]				      =			self.cpu_mem_used()
								lowerCAmelCase__ :    Dict				      =			bamb(self.cpu_end - self.cpu_begin    )
								lowerCAmelCase__ :    Optional[Any]				      =			bamb(self.cpu_peak - self.cpu_begin    )
								# print(f"delta used/peak {self.used:4d}/{self.peaked:4d}")


# For testing only
if os.environ.get("""TESTING_MOCKED_DATALOADERS""", None) == "1":
							from accelerate.test_utils.training import mocked_dataloaders

							A__       :   int   						=					mocked_dataloaders  # noqa: F811



def      _a     (   __UpperCamelCase       :  Any	,__UpperCamelCase       :  str    ):






			if os.environ.get('''TESTING_MOCKED_DATALOADERS'''	,_UpperCAmelCase    ) == "1":
						lowerCAmelCase__ :    Optional[int]				      =			2

			# New Code #
			# Pass the advanced FSDP settings not part of the accelerate config by creating fsdp_plugin
			lowerCAmelCase__ :    List[str]				      =			FullyShardedDataParallelPlugin(
			    state_dict_config=FullStateDictConfig(offload_to_cpu=_UpperCAmelCase	,ranka_only=_UpperCAmelCase    )	,optim_state_dict_config=FullOptimStateDictConfig(offload_to_cpu=_UpperCAmelCase	,ranka_only=_UpperCAmelCase    )	,)

			# Initialize accelerator
			if args.with_tracking:
						lowerCAmelCase__ :    Any				      =			Accelerator(
						    cpu=args.cpu	,mixed_precision=args.mixed_precision	,log_with='''wandb'''	,project_dir=args.logging_dir	,fsdp_plugin=_UpperCAmelCase	,)
			else:
						lowerCAmelCase__ :    Optional[int]				      =			Accelerator(fsdp_plugin=_UpperCAmelCase    )
			accelerator.print(accelerator.distributed_type    )

			if hasattr(args.checkpointing_steps	,'''isdigit'''    ):
						if args.checkpointing_steps == "epoch":
									lowerCAmelCase__ :    List[Any]				      =			args.checkpointing_steps
						elif args.checkpointing_steps.isdigit():
									lowerCAmelCase__ :    Optional[int]				      =			int(args.checkpointing_steps    )
						else:
									raise ValueError(
									    f'''Argument `checkpointing_steps` must be either a number or `epoch`. `{args.checkpointing_steps}` passed.'''    )
			else:
						lowerCAmelCase__ :    List[Any]				      =			None
			# Sample hyper-parameters for learning rate, batch size, seed and a few other HPs
			lowerCAmelCase__ :    Union[str, Any]				      =			config['lr']
			lowerCAmelCase__ :    Union[str, Any]				      =			int(config['''num_epochs''']    )
			lowerCAmelCase__ :    Tuple				      =			int(config['''seed''']    )
			lowerCAmelCase__ :    Any				      =			int(config['''batch_size''']    )

			# We need to initialize the trackers we use, and also store our configuration
			if args.with_tracking:
						lowerCAmelCase__ :    Dict				      =			vars(_UpperCAmelCase    )
						accelerator.init_trackers('''fsdp_glue_no_trainer'''	,_UpperCAmelCase    )

			lowerCAmelCase__ :    List[str]				      =			AutoTokenizer.from_pretrained(args.model_name_or_path    )
			lowerCAmelCase__ :    Any				      =			load_dataset('''glue'''	,'''mrpc'''    )
			lowerCAmelCase__ :    Any				      =			evaluate.load('''glue'''	,'''mrpc'''    )

			def tokenize_function(__UpperCamelCase       :  List[str]    ):
						# max_length=None => use the model max length (it's actually the default)
						lowerCAmelCase__ :    int				      =			tokenizer(examples['''sentence1''']	,examples['''sentence2''']	,truncation=_UpperCAmelCase	,max_length=_UpperCAmelCase    )
						return outputs

			# Apply the method we just defined to all the examples in all the splits of the dataset
			# starting with the main process first:
			with accelerator.main_process_first():
						lowerCAmelCase__ :    Union[str, Any]				      =			datasets.map(
						    _UpperCAmelCase	,batched=_UpperCAmelCase	,remove_columns=['''idx''', '''sentence1''', '''sentence2''']	,)

			# We also rename the 'label' column to 'labels' which is the expected name for labels by the models of the
			# transformers library
			lowerCAmelCase__ :    Union[str, Any]				      =			tokenized_datasets.rename_column('''label'''	,'''labels'''    )

			# If the batch size is too big we use gradient accumulation
			lowerCAmelCase__ :    Optional[Any]				      =			1
			if batch_size > MAX_GPU_BATCH_SIZE and accelerator.distributed_type != DistributedType.TPU:
						lowerCAmelCase__ :    str				      =			batch_size // MAX_GPU_BATCH_SIZE
						lowerCAmelCase__ :    Optional[int]				      =			MAX_GPU_BATCH_SIZE

			def collate_fn(__UpperCamelCase       :  List[str]    ):
						# On TPU it's best to pad everything to the same length or training will be very slow.
						lowerCAmelCase__ :    List[str]				      =			128 if accelerator.distributed_type == DistributedType.TPU else None
						# When using mixed precision we want round multiples of 8/16
						if accelerator.mixed_precision == "fp8":
									lowerCAmelCase__ :    Tuple				      =			16
						elif accelerator.mixed_precision != "no":
									lowerCAmelCase__ :    List[Any]				      =			8
						else:
									lowerCAmelCase__ :    Union[str, Any]				      =			None

						return tokenizer.pad(
						    _UpperCAmelCase	,padding='''longest'''	,max_length=_UpperCAmelCase	,pad_to_multiple_of=_UpperCAmelCase	,return_tensors='''pt'''	,)

			# Instantiate dataloaders.
			lowerCAmelCase__ :    int				      =			DataLoader(
			    tokenized_datasets['''train''']	,shuffle=_UpperCAmelCase	,collate_fn=_UpperCAmelCase	,batch_size=_UpperCAmelCase    )
			lowerCAmelCase__ :    int				      =			DataLoader(
			    tokenized_datasets['''validation''']	,shuffle=_UpperCAmelCase	,collate_fn=_UpperCAmelCase	,batch_size=_UpperCAmelCase    )

			set_seed(_UpperCAmelCase    )

			# Instantiate the model (we build the model here so that the seed also control new weights initialization)
			lowerCAmelCase__ :    Optional[int]				      =			AutoModelForSequenceClassification.from_pretrained(
			    args.model_name_or_path	,return_dict=_UpperCAmelCase	,low_cpu_mem_usage=_UpperCAmelCase    )

			# New Code #
			# For FSDP feature, it is highly recommended and efficient to prepare the model before creating optimizer
			lowerCAmelCase__ :    int				      =			accelerator.prepare(_UpperCAmelCase    )
			accelerator.print(_UpperCAmelCase    )

			# Instantiate optimizer
			# New Code #
			# For FSDP feature, at present it doesn't support multiple parameter groups,
			# so we need to create a single parameter group for the whole model
			lowerCAmelCase__ :    str				      =			torch.optim.AdamW(params=model.parameters()	,lr=_UpperCAmelCase	,weight_decay=2e-4    )

			# Instantiate scheduler
			lowerCAmelCase__ :    Optional[Any]				      =			get_linear_schedule_with_warmup(
			    optimizer=_UpperCAmelCase	,num_warmup_steps=10	,num_training_steps=(len(_UpperCAmelCase    ) * num_epochs) // gradient_accumulation_steps	,)

			# New Code #
			# For FSDP feature, prepare everything except the model as we have already prepared the model
			# before creating the optimizer
			# There is no specific order to remember, we just need to unpack the objects in the same order we gave them to the
			# prepare method.
			lowerCAmelCase__ :    Any				      =			accelerator.prepare(
			    _UpperCAmelCase	,_UpperCAmelCase	,_UpperCAmelCase	,_UpperCAmelCase    )

			lowerCAmelCase__ :    Optional[Any]				      =			0

			# Potentially load in the weights and states from a previous save
			if args.resume_from_checkpoint:
						if args.resume_from_checkpoint is not None or args.resume_from_checkpoint != "":
									accelerator.print(f'''Resumed from checkpoint: {args.resume_from_checkpoint}'''    )
									accelerator.load_state(args.resume_from_checkpoint    )
									lowerCAmelCase__ :    Optional[Any]				      =			os.path.basename(args.resume_from_checkpoint    )
						else:
									# Get the most recent checkpoint
									lowerCAmelCase__ :    Tuple				      =			[f.name for f in os.scandir(os.getcwd()    ) if f.is_dir()]
									dirs.sort(key=os.path.getctime    )
									lowerCAmelCase__ :    Optional[int]				      =			dirs[-1]  # Sorts folders by date modified, most recent checkpoint is the last
						# Extract `epoch_{i}` or `step_{i}`
						lowerCAmelCase__ :    str				      =			os.path.splitext(_UpperCAmelCase    )[0]

						if "epoch" in training_difference:
									num_epochs -= int(training_difference.replace('''epoch_'''	,''''''    )    )
									lowerCAmelCase__ :    str				      =			None
						else:
									lowerCAmelCase__ :    Optional[int]				      =			int(training_difference.replace('''step_'''	,''''''    )    )
									num_epochs -= resume_step // len(_UpperCAmelCase    )
									# If resuming by step, we also need to know exactly how far into the DataLoader we went
									lowerCAmelCase__ :    str				      =			(num_epochs * len(_UpperCAmelCase    )) - resume_step

    # Now we train the model
			for epoch in range(_UpperCAmelCase    ):
						# New Code #
						# context manager to track the peak memory usage during the training epoch
						with TorchTracemalloc() as tracemalloc:
									model.train()
									if args.with_tracking:
												lowerCAmelCase__ :    Optional[Any]				      =			0
									for step, batch in enumerate(_UpperCAmelCase    ):
												# We need to skip steps until we reach the resumed step
												if args.resume_from_checkpoint and epoch == 0:
															if resume_step is not None and step < resume_step:
																		pass
                # We could avoid this line since we set the accelerator with `device_placement=True`.
												batch.to(accelerator.device    )
												lowerCAmelCase__ :    List[Any]				      =			model(**_UpperCAmelCase    )
												lowerCAmelCase__ :    str				      =			outputs.loss
												lowerCAmelCase__ :    List[Any]				      =			loss / gradient_accumulation_steps
												# We keep track of the loss at each epoch
												if args.with_tracking:
															total_loss += loss.detach().float()
												accelerator.backward(_UpperCAmelCase    )
												if step % gradient_accumulation_steps == 0:
															optimizer.step()
															lr_scheduler.step()
															optimizer.zero_grad()
															# accelerator.print(lr_scheduler.get_lr())

												overall_step += 1

												if isinstance(_UpperCAmelCase	,_UpperCAmelCase    ):
															lowerCAmelCase__ :    Optional[int]				      =			f'''step_{overall_step}'''
															if overall_step % checkpointing_steps == 0:
																		if args.output_dir is not None:
																					lowerCAmelCase__ :    List[str]				      =			os.path.join(args.output_dir	,_UpperCAmelCase    )
																		accelerator.save_state(_UpperCAmelCase    )
        # New Code #
        # Printing the GPU memory usage details such as allocated memory, peak memory, and total memory usage
						accelerator.print('''Memory before entering the train : {}'''.format(bamb(tracemalloc.begin    )    )    )
						accelerator.print('''Memory consumed at the end of the train (end-begin): {}'''.format(tracemalloc.used    )    )
						accelerator.print('''Peak Memory consumed during the train (max-begin): {}'''.format(tracemalloc.peaked    )    )
						accelerator.print(
						    '''Total Peak Memory consumed during the train (max): {}'''.format(
						        tracemalloc.peaked + bamb(tracemalloc.begin    )    )    )
						# Logging the peak memory usage of the GPU to the tracker
						if args.with_tracking:
									accelerator.log(
									    {
									        '''train_total_peak_memory''': tracemalloc.peaked + bamb(tracemalloc.begin    ),
									    }	,step=_UpperCAmelCase	,)

						# New Code #
						# context manager to track the peak memory usage during the evaluation
						with TorchTracemalloc() as tracemalloc:
									model.eval()
									for step, batch in enumerate(_UpperCAmelCase    ):
												# We could avoid this line since we set the accelerator with `device_placement=True`.
												batch.to(accelerator.device    )
												with torch.no_grad():
															lowerCAmelCase__ :    List[Any]				      =			model(**_UpperCAmelCase    )
												lowerCAmelCase__ :    Optional[Any]				      =			outputs.logits.argmax(dim=-1    )
												lowerCAmelCase__ :    Union[str, Any]				      =			accelerator.gather_for_metrics((predictions, batch['''labels'''])    )
												metric.add_batch(
												    predictions=_UpperCAmelCase	,references=_UpperCAmelCase	,)

									lowerCAmelCase__ :    Dict				      =			metric.compute()
									# Use accelerator.print to print only on the main process.
									accelerator.print(f'''epoch {epoch}:'''	,_UpperCAmelCase    )
									if args.with_tracking:
												accelerator.log(
												    {
												        '''accuracy''': eval_metric['''accuracy'''],
												        '''f1''': eval_metric['''f1'''],
												        '''train_loss''': total_loss.item() / len(_UpperCAmelCase    ),
												    }	,step=_UpperCAmelCase	,)

									if checkpointing_steps == "epoch":
												lowerCAmelCase__ :    str				      =			f'''epoch_{epoch}'''
												if args.output_dir is not None:
															lowerCAmelCase__ :    List[str]				      =			os.path.join(args.output_dir	,_UpperCAmelCase    )
												accelerator.save_state(_UpperCAmelCase    )
        # New Code #
        # Printing the GPU memory usage details such as allocated memory, peak memory, and total memory usage
						accelerator.print('''Memory before entering the eval : {}'''.format(bamb(tracemalloc.begin    )    )    )
						accelerator.print('''Memory consumed at the end of the eval (end-begin): {}'''.format(tracemalloc.used    )    )
						accelerator.print('''Peak Memory consumed during the eval (max-begin): {}'''.format(tracemalloc.peaked    )    )
						accelerator.print(
						    '''Total Peak Memory consumed during the eval (max): {}'''.format(tracemalloc.peaked + bamb(tracemalloc.begin    )    )    )
						# Logging the peak memory usage of the GPU to the tracker
						if args.with_tracking:
									accelerator.log(
									    {
									        '''eval_total_peak_memory''': tracemalloc.peaked + bamb(tracemalloc.begin    ),
									    }	,step=_UpperCAmelCase	,)

			if args.with_tracking:
						accelerator.end_training()



def      _a     (   ):
			lowerCAmelCase__ :    Dict				      =			argparse.ArgumentParser(description='''Simple example of training script.'''    )
			parser.add_argument(
			    '''--mixed_precision'''	,type=_UpperCAmelCase	,default=_UpperCAmelCase	,choices=['''no''', '''fp16''', '''bf16''', '''fp8''']	,help='''Whether to use mixed precision. Choose'''
			    '''between fp16 and bf16 (bfloat16). Bf16 requires PyTorch >= 1.10.'''
			    '''and an Nvidia Ampere GPU.'''	,)
			parser.add_argument('''--cpu'''	,action='''store_true'''	,help='''If passed, will train on the CPU.'''    )
			parser.add_argument(
			    '''--checkpointing_steps'''	,type=_UpperCAmelCase	,default=_UpperCAmelCase	,help='''Whether the various states should be saved at the end of every n steps, or \'epoch\' for each epoch.'''	,)
			parser.add_argument(
			    '''--resume_from_checkpoint'''	,type=_UpperCAmelCase	,default=_UpperCAmelCase	,help='''If the training should continue from a checkpoint folder.'''	,)
			parser.add_argument(
			    '''--with_tracking'''	,action='''store_true'''	,help='''Whether to load in all available experiment trackers from the environment and use them for logging.'''	,)
			parser.add_argument(
			    '''--output_dir'''	,type=_UpperCAmelCase	,default='''.'''	,help='''Optional save directory where all checkpoint folders will be stored. Default is the current working directory.'''	,)
			parser.add_argument(
			    '''--logging_dir'''	,type=_UpperCAmelCase	,default='''logs'''	,help='''Location on where to store experiment tracking logs`'''	,)
			parser.add_argument(
			    '''--model_name_or_path'''	,type=_UpperCAmelCase	,help='''Path to pretrained model or model identifier from huggingface.co/models.'''	,required=_UpperCAmelCase	,)
			lowerCAmelCase__ :    Union[str, Any]				      =			parser.parse_args()
			lowerCAmelCase__ :    Any				      =			{'lr': 2e-5, 'num_epochs': 3, 'seed': 42, 'batch_size': 16}
			training_function(_UpperCAmelCase	,_UpperCAmelCase    )


if __name__ == "__main__":
							main()





import collections
import inspect
import unittest

from transformers import DonutSwinConfig
from transformers.testing_utils import require_torch, slow, torch_device
from transformers.utils import is_torch_available

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


if is_torch_available():
							import torch
							from torch import nn

							from transformers import DonutSwinModel
							from transformers.models.donut.modeling_donut_swin import DONUT_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST





class 						lowercase       :
					def __init__(		self ,	SCREAMING_SNAKE_CASE__ ,	SCREAMING_SNAKE_CASE__=13 ,	SCREAMING_SNAKE_CASE__=32 ,	SCREAMING_SNAKE_CASE__=2 ,	SCREAMING_SNAKE_CASE__=3 ,	SCREAMING_SNAKE_CASE__=16 ,	SCREAMING_SNAKE_CASE__=[1, 2, 1] ,	SCREAMING_SNAKE_CASE__=[2, 2, 4] ,	SCREAMING_SNAKE_CASE__=2 ,	SCREAMING_SNAKE_CASE__=2.0 ,	SCREAMING_SNAKE_CASE__=True ,	SCREAMING_SNAKE_CASE__=0.0 ,	SCREAMING_SNAKE_CASE__=0.0 ,	SCREAMING_SNAKE_CASE__=0.1 ,	SCREAMING_SNAKE_CASE__="gelu" ,	SCREAMING_SNAKE_CASE__=False ,	SCREAMING_SNAKE_CASE__=True ,	SCREAMING_SNAKE_CASE__=0.02 ,	SCREAMING_SNAKE_CASE__=1E-5 ,	SCREAMING_SNAKE_CASE__=True ,	SCREAMING_SNAKE_CASE__=None ,	SCREAMING_SNAKE_CASE__=True ,	SCREAMING_SNAKE_CASE__=10 ,	SCREAMING_SNAKE_CASE__=8 ,	):
								"""simple docstring"""







								lowerCAmelCase__ :    Any				      =			parent
								lowerCAmelCase__ :    str				      =			batch_size
								lowerCAmelCase__ :    Tuple				      =			image_size
								lowerCAmelCase__ :    Union[str, Any]				      =			patch_size
								lowerCAmelCase__ :    int				      =			num_channels
								lowerCAmelCase__ :    Tuple				      =			embed_dim
								lowerCAmelCase__ :    Optional[int]				      =			depths
								lowerCAmelCase__ :    Tuple				      =			num_heads
								lowerCAmelCase__ :    Tuple				      =			window_size
								lowerCAmelCase__ :    Dict				      =			mlp_ratio
								lowerCAmelCase__ :    int				      =			qkv_bias
								lowerCAmelCase__ :    Dict				      =			hidden_dropout_prob
								lowerCAmelCase__ :    Dict				      =			attention_probs_dropout_prob
								lowerCAmelCase__ :    Tuple				      =			drop_path_rate
								lowerCAmelCase__ :    int				      =			hidden_act
								lowerCAmelCase__ :    Union[str, Any]				      =			use_absolute_embeddings
								lowerCAmelCase__ :    Dict				      =			patch_norm
								lowerCAmelCase__ :    Any				      =			layer_norm_eps
								lowerCAmelCase__ :    Tuple				      =			initializer_range
								lowerCAmelCase__ :    Optional[Any]				      =			is_training
								lowerCAmelCase__ :    str				      =			scope
								lowerCAmelCase__ :    List[str]				      =			use_labels
								lowerCAmelCase__ :    Optional[Any]				      =			type_sequence_label_size
								lowerCAmelCase__ :    int				      =			encoder_stride
					def lowercase_			(		self    ):
								"""simple docstring"""







								lowerCAmelCase__ :    List[str]				      =			floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]    )

								lowerCAmelCase__ :    Tuple				      =			None
								if self.use_labels:
											lowerCAmelCase__ :    Tuple				      =			ids_tensor([self.batch_size] ,	self.type_sequence_label_size    )

								lowerCAmelCase__ :    Tuple				      =			self.get_config()

								return config, pixel_values, labels
					def lowercase_			(		self    ):
								"""simple docstring"""







								return DonutSwinConfig(
								    image_size=self.image_size ,	patch_size=self.patch_size ,	num_channels=self.num_channels ,	embed_dim=self.embed_dim ,	depths=self.depths ,	num_heads=self.num_heads ,	window_size=self.window_size ,	mlp_ratio=self.mlp_ratio ,	qkv_bias=self.qkv_bias ,	hidden_dropout_prob=self.hidden_dropout_prob ,	attention_probs_dropout_prob=self.attention_probs_dropout_prob ,	drop_path_rate=self.drop_path_rate ,	hidden_act=self.hidden_act ,	use_absolute_embeddings=self.use_absolute_embeddings ,	path_norm=self.patch_norm ,	layer_norm_eps=self.layer_norm_eps ,	initializer_range=self.initializer_range ,	encoder_stride=self.encoder_stride ,	)
					def lowercase_			(		self ,	SCREAMING_SNAKE_CASE__ ,	SCREAMING_SNAKE_CASE__ ,	SCREAMING_SNAKE_CASE__    ):
								"""simple docstring"""







								lowerCAmelCase__ :    Optional[Any]				      =			DonutSwinModel(config=SCREAMING_SNAKE_CASE__    )
								model.to(SCREAMING_SNAKE_CASE__    )
								model.eval()
								lowerCAmelCase__ :    Optional[Any]				      =			model(SCREAMING_SNAKE_CASE__    )

								lowerCAmelCase__ :    str				      =			((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths    ) - 1))
								lowerCAmelCase__ :    int				      =			int(config.embed_dim * 2 ** (len(config.depths    ) - 1)    )

								self.parent.assertEqual(result.last_hidden_state.shape ,	(self.batch_size, expected_seq_len, expected_dim)    )
					def lowercase_			(		self    ):
								"""simple docstring"""







								lowerCAmelCase__ :    int				      =			self.prepare_config_and_inputs()
								(
								    (
								    lowerCAmelCase__
								)      ,				(
								    lowerCAmelCase__
								)      ,				(
								    lowerCAmelCase__
								)      ,				
								) :    Optional[Any]				      =			config_and_inputs
								lowerCAmelCase__ :    Union[str, Any]				      =			{'''pixel_values''': pixel_values}
								return config, inputs_dict





@require_torch
class 						lowercase       (  __UpperCamelCase	,		__UpperCamelCase	,		unittest.TestCase					):
					__a					=    (DonutSwinModel,) if is_torch_available() else ()
					__a					=    {"""feature-extraction""": DonutSwinModel} if is_torch_available() else {}
					__a					=    True

					__a					=    False
					__a					=    False
					__a					=    False
					def lowercase_			(		self    ):
								"""simple docstring"""







								lowerCAmelCase__ :    List[str]				      =			DonutSwinModelTester(self    )
								lowerCAmelCase__ :    Union[str, Any]				      =			ConfigTester(self ,	config_class=SCREAMING_SNAKE_CASE__ ,	embed_dim=37    )
					def lowercase_			(		self    ):
								"""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 lowercase_			(		self    ):
								"""simple docstring"""







								return
					def lowercase_			(		self    ):
								"""simple docstring"""







								lowerCAmelCase__ :    int				      =			self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_model(*SCREAMING_SNAKE_CASE__    )
					def lowercase_			(		self    ):
								"""simple docstring"""







								pass
					def lowercase_			(		self    ):
								"""simple docstring"""







								lowerCAmelCase__      ,				lowerCAmelCase__ :    Optional[Any]				      =			self.model_tester.prepare_config_and_inputs_for_common()

								for model_class in self.all_model_classes:
											lowerCAmelCase__ :    List[str]				      =			model_class(SCREAMING_SNAKE_CASE__    )
											self.assertIsInstance(model.get_input_embeddings() ,	(nn.Module)    )
											lowerCAmelCase__ :    Dict				      =			model.get_output_embeddings()
											self.assertTrue(x is None or isinstance(SCREAMING_SNAKE_CASE__ ,	nn.Linear    )    )
					def lowercase_			(		self    ):
								"""simple docstring"""







								lowerCAmelCase__      ,				lowerCAmelCase__ :    Tuple				      =			self.model_tester.prepare_config_and_inputs_for_common()

								for model_class in self.all_model_classes:
											lowerCAmelCase__ :    Union[str, Any]				      =			model_class(SCREAMING_SNAKE_CASE__    )
											lowerCAmelCase__ :    Optional[Any]				      =			inspect.signature(model.forward    )
											# signature.parameters is an OrderedDict => so arg_names order is deterministic
											lowerCAmelCase__ :    Tuple				      =			[*signature.parameters.keys()]

											lowerCAmelCase__ :    List[str]				      =			['''pixel_values''']
											self.assertListEqual(arg_names[:1] ,	SCREAMING_SNAKE_CASE__    )
					def lowercase_			(		self    ):
								"""simple docstring"""







								lowerCAmelCase__      ,				lowerCAmelCase__ :    str				      =			self.model_tester.prepare_config_and_inputs_for_common()
								lowerCAmelCase__ :    List[Any]				      =			True

								for model_class in self.all_model_classes:
											lowerCAmelCase__ :    int				      =			True
											lowerCAmelCase__ :    Union[str, Any]				      =			False
											lowerCAmelCase__ :    Tuple				      =			True
											lowerCAmelCase__ :    str				      =			model_class(SCREAMING_SNAKE_CASE__    )
											model.to(SCREAMING_SNAKE_CASE__    )
											model.eval()
											with torch.no_grad():
														lowerCAmelCase__ :    Dict				      =			model(**self._prepare_for_class(SCREAMING_SNAKE_CASE__ ,	SCREAMING_SNAKE_CASE__    )    )
											lowerCAmelCase__ :    List[Any]				      =			outputs.attentions
											lowerCAmelCase__ :    str				      =			len(self.model_tester.depths    )
											self.assertEqual(len(SCREAMING_SNAKE_CASE__    ) ,	SCREAMING_SNAKE_CASE__    )

											# check that output_attentions also work using config
											del inputs_dict["output_attentions"]
											lowerCAmelCase__ :    Dict				      =			True
											lowerCAmelCase__ :    Optional[Any]				      =			config.window_size**2
											lowerCAmelCase__ :    Tuple				      =			model_class(SCREAMING_SNAKE_CASE__    )
											model.to(SCREAMING_SNAKE_CASE__    )
											model.eval()
											with torch.no_grad():
														lowerCAmelCase__ :    Tuple				      =			model(**self._prepare_for_class(SCREAMING_SNAKE_CASE__ ,	SCREAMING_SNAKE_CASE__    )    )
											lowerCAmelCase__ :    List[Any]				      =			outputs.attentions
											self.assertEqual(len(SCREAMING_SNAKE_CASE__    ) ,	SCREAMING_SNAKE_CASE__    )

											self.assertListEqual(
											    list(attentions[0].shape[-3:]    ) ,	[self.model_tester.num_heads[0], window_size_squared, window_size_squared] ,	)
											lowerCAmelCase__ :    Optional[int]				      =			len(SCREAMING_SNAKE_CASE__    )

											# Check attention is always last and order is fine
											lowerCAmelCase__ :    Any				      =			True
											lowerCAmelCase__ :    List[Any]				      =			True
											lowerCAmelCase__ :    Tuple				      =			model_class(SCREAMING_SNAKE_CASE__    )
											model.to(SCREAMING_SNAKE_CASE__    )
											model.eval()
											with torch.no_grad():
														lowerCAmelCase__ :    Any				      =			model(**self._prepare_for_class(SCREAMING_SNAKE_CASE__ ,	SCREAMING_SNAKE_CASE__    )    )

											if hasattr(self.model_tester ,	'''num_hidden_states_types'''    ):
														lowerCAmelCase__ :    Tuple				      =			self.model_tester.num_hidden_states_types
											else:
														# also another +1 for reshaped_hidden_states
														lowerCAmelCase__ :    str				      =			2
											self.assertEqual(out_len + added_hidden_states ,	len(SCREAMING_SNAKE_CASE__    )    )

											lowerCAmelCase__ :    List[str]				      =			outputs.attentions

											self.assertEqual(len(SCREAMING_SNAKE_CASE__    ) ,	SCREAMING_SNAKE_CASE__    )

											self.assertListEqual(
											    list(self_attentions[0].shape[-3:]    ) ,	[self.model_tester.num_heads[0], window_size_squared, window_size_squared] ,	)
					def lowercase_			(		self ,	SCREAMING_SNAKE_CASE__ ,	SCREAMING_SNAKE_CASE__ ,	SCREAMING_SNAKE_CASE__ ,	SCREAMING_SNAKE_CASE__    ):
								"""simple docstring"""







								lowerCAmelCase__ :    Tuple				      =			model_class(SCREAMING_SNAKE_CASE__    )
								model.to(SCREAMING_SNAKE_CASE__    )
								model.eval()

								with torch.no_grad():
											lowerCAmelCase__ :    List[str]				      =			model(**self._prepare_for_class(SCREAMING_SNAKE_CASE__ ,	SCREAMING_SNAKE_CASE__    )    )

								lowerCAmelCase__ :    List[str]				      =			outputs.hidden_states

								lowerCAmelCase__ :    Optional[Any]				      =			getattr(
								    self.model_tester ,	'''expected_num_hidden_layers''' ,	len(self.model_tester.depths    ) + 1    )
								self.assertEqual(len(SCREAMING_SNAKE_CASE__    ) ,	SCREAMING_SNAKE_CASE__    )

								# DonutSwin has a different seq_length
								lowerCAmelCase__ :    int				      =			(
								    config.patch_size
								    if isinstance(config.patch_size ,	collections.abc.Iterable    )
								    else (config.patch_size, config.patch_size)
								)

								lowerCAmelCase__ :    Dict				      =			(image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])

								self.assertListEqual(
								    list(hidden_states[0].shape[-2:]    ) ,	[num_patches, self.model_tester.embed_dim] ,	)

								lowerCAmelCase__ :    List[str]				      =			outputs.reshaped_hidden_states
								self.assertEqual(len(SCREAMING_SNAKE_CASE__    ) ,	SCREAMING_SNAKE_CASE__    )

								lowerCAmelCase__      ,				lowerCAmelCase__      ,				lowerCAmelCase__      ,				lowerCAmelCase__ :    List[str]				      =			reshaped_hidden_states[0].shape
								lowerCAmelCase__ :    Dict				      =			(
								    reshaped_hidden_states[0].view(SCREAMING_SNAKE_CASE__ ,	SCREAMING_SNAKE_CASE__ ,	height * width    ).permute(0 ,	2 ,	1    )
								)
								self.assertListEqual(
								    list(reshaped_hidden_states.shape[-2:]    ) ,	[num_patches, self.model_tester.embed_dim] ,	)
					def lowercase_			(		self    ):
								"""simple docstring"""







								lowerCAmelCase__      ,				lowerCAmelCase__ :    List[str]				      =			self.model_tester.prepare_config_and_inputs_for_common()

								lowerCAmelCase__ :    Optional[int]				      =			(
								    self.model_tester.image_size
								    if isinstance(self.model_tester.image_size ,	collections.abc.Iterable    )
								    else (self.model_tester.image_size, self.model_tester.image_size)
								)

								for model_class in self.all_model_classes:
											lowerCAmelCase__ :    Any				      =			True
											self.check_hidden_states_output(SCREAMING_SNAKE_CASE__ ,	SCREAMING_SNAKE_CASE__ ,	SCREAMING_SNAKE_CASE__ ,	SCREAMING_SNAKE_CASE__    )

											# check that output_hidden_states also work using config
											del inputs_dict["output_hidden_states"]
											lowerCAmelCase__ :    Union[str, Any]				      =			True

											self.check_hidden_states_output(SCREAMING_SNAKE_CASE__ ,	SCREAMING_SNAKE_CASE__ ,	SCREAMING_SNAKE_CASE__ ,	SCREAMING_SNAKE_CASE__    )
					def lowercase_			(		self    ):
								"""simple docstring"""







								lowerCAmelCase__      ,				lowerCAmelCase__ :    Dict				      =			self.model_tester.prepare_config_and_inputs_for_common()
								lowerCAmelCase__ :    Union[str, Any]				      =			3

								lowerCAmelCase__ :    int				      =			(
								    self.model_tester.image_size
								    if isinstance(self.model_tester.image_size ,	collections.abc.Iterable    )
								    else (self.model_tester.image_size, self.model_tester.image_size)
								)
								lowerCAmelCase__ :    str				      =			(
								    config.patch_size
								    if isinstance(config.patch_size ,	collections.abc.Iterable    )
								    else (config.patch_size, config.patch_size)
								)

								lowerCAmelCase__ :    Optional[int]				      =			image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
								lowerCAmelCase__ :    Any				      =			image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

								for model_class in self.all_model_classes:
											lowerCAmelCase__ :    Tuple				      =			True
											self.check_hidden_states_output(SCREAMING_SNAKE_CASE__ ,	SCREAMING_SNAKE_CASE__ ,	SCREAMING_SNAKE_CASE__ ,	(padded_height, padded_width)    )

											# check that output_hidden_states also work using config
											del inputs_dict["output_hidden_states"]
											lowerCAmelCase__ :    Dict				      =			True
											self.check_hidden_states_output(SCREAMING_SNAKE_CASE__ ,	SCREAMING_SNAKE_CASE__ ,	SCREAMING_SNAKE_CASE__ ,	(padded_height, padded_width)    )
					@slow
					def lowercase_			(		self    ):
								"""simple docstring"""







								for model_name in DONUT_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
											lowerCAmelCase__ :    Optional[Any]				      =			DonutSwinModel.from_pretrained(SCREAMING_SNAKE_CASE__    )
											self.assertIsNotNone(SCREAMING_SNAKE_CASE__    )
					def lowercase_			(		self    ):
								"""simple docstring"""







								lowerCAmelCase__      ,				lowerCAmelCase__ :    Any				      =			self.model_tester.prepare_config_and_inputs_for_common()

								lowerCAmelCase__ :    Union[str, Any]				      =			_config_zero_init(SCREAMING_SNAKE_CASE__    )
								for model_class in self.all_model_classes:
											lowerCAmelCase__ :    Union[str, Any]				      =			model_class(config=SCREAMING_SNAKE_CASE__    )
											for name, param in model.named_parameters():
														if "embeddings" not in name and param.requires_grad:
																	self.assertIn(
																	    ((param.data.mean() * 1E9).round() / 1E9).item() ,	[0.0, 1.0] ,	msg=f'''Parameter {name} of model {model_class} seems not properly initialized''' ,	)



