




"""simple docstring"""

import itertools




def       snake_case__	(       lowerCAmelCase   :		int = 1_000_000		):
					__snake_case          =	[1]

					for i in itertools.count(len(lowerCAmelCase		)		):
										__snake_case          =	0
										for j in itertools.count(1		):
															__snake_case          =	-1 if j % 2 == 0 else +1
															__snake_case          =	(j * j * 3 - j) // 2
															if index > i:
																				break
															item += partitions[i - index] * sign
															item %= number
															index += j
															if index > i:
																				break
															item += partitions[i - index] * sign
															item %= number

										if item == 0:
															return i
										partitions.append(lowerCAmelCase		)

					return 0


if __name__ == "__main__":
		import doctest

		doctest.testmod()

		print(f'{solution() = }')








"""simple docstring"""

import timeit
from typing import Callable, Optional

from ..configuration_utils import PretrainedConfig
from ..models.auto.modeling_auto import MODEL_MAPPING, MODEL_WITH_LM_HEAD_MAPPING
from ..utils import is_pyanvml_available, is_torch_available, logging
from .benchmark_utils import (
    Benchmark,
    Memory,
    MemorySummary,
    measure_peak_memory_cpu,
    start_memory_tracing,
    stop_memory_tracing,
)


if is_torch_available():
		import torch

		from .benchmark_args import PyTorchBenchmarkArguments


if is_pyanvml_available():
		import pyanvml.pyanvml as nvml


UpperCamelCase__ :    List[str] 					=							logging.get_logger(__name__)
class     A__      (      lowercase_     ):
	A_							:				PyTorchBenchmarkArguments
	A_							:				PretrainedConfig
	A_							:				str						     =      "PyTorch"




	@property
	def 							a_		(   self  :	Optional[Any]	)					-> Tuple:
						return torch.__version__




	def 							a_		(   self  :	int      ,    lowercase  :	str      ,    lowercase  :	int      ,    lowercase  :	int	)					-> float:
						__snake_case          =	self._prepare_inference_func(lowercase      ,    lowercase      ,    lowercase	)
						return self._measure_speed(_inference	)




	def 							a_		(   self  :	Dict      ,    lowercase  :	str      ,    lowercase  :	int      ,    lowercase  :	int	)					-> [Memory, Optional[MemorySummary]]:
						__snake_case          =	self._prepare_inference_func(lowercase      ,    lowercase      ,    lowercase	)
						return self._measure_memory(_inference	)




	def 							a_		(   self  :	str      ,    lowercase  :	str      ,    lowercase  :	int      ,    lowercase  :	int	)					-> float:
						__snake_case          =	self._prepare_train_func(lowercase      ,    lowercase      ,    lowercase	)
						return self._measure_speed(_train	)




	def 							a_		(   self  :	List[Any]      ,    lowercase  :	str      ,    lowercase  :	int      ,    lowercase  :	int	)					-> [Memory, Optional[MemorySummary]]:
						__snake_case          =	self._prepare_train_func(lowercase      ,    lowercase      ,    lowercase	)
						return self._measure_memory(_train	)




	def 							a_		(   self  :	Union[str, Any]      ,    lowercase  :	str      ,    lowercase  :	int      ,    lowercase  :	int	)					-> Callable[[], None]:
						__snake_case          =	self.config_dict[model_name]

						if self.args.torchscript:
											__snake_case          =	True

						__snake_case          =	(
						    hasattr(lowercase      ,    """architectures"""	)
						    and isinstance(config.architectures      ,    lowercase	)
						    and len(config.architectures	) > 0
						)
						if not self.args.only_pretrain_model and has_model_class_in_config:
											try:
																__snake_case          =	config.architectures[0]
																__snake_case          =	__import__("""transformers"""      ,    fromlist=[model_class]	)
																__snake_case          =	getattr(lowercase      ,    lowercase	)
																__snake_case          =	model_cls(lowercase	)
											except ImportError:
																raise ImportError(
																    f'''{model_class} does not exist. If you just want to test the pretrained model, you might want to'''
																    """ set `--only_pretrain_model` or `args.only_pretrain_model=True`."""	)
						else:
											__snake_case          =	MODEL_MAPPING[config.__class__](lowercase	)

						model.eval()
						model.to(self.args.device	)

						# encoder-decoder has vocab size saved differently
						__snake_case          =	config.vocab_size if hasattr(lowercase      ,    """vocab_size"""	) else config.encoder.vocab_size
						__snake_case          =	torch.randint(lowercase      ,    (batch_size, sequence_length)      ,    dtype=torch.long      ,    device=self.args.device	)

						if self.args.fpaa:
											logger.info("""Running training in Mixed Precision..."""	)
											if not self.args.is_gpu:
																raise ValueError("""Mixed precision is possible only for GPU."""	)
											# amp seems to have memory leaks so that memory usage
											# is measured using .half() for now https://github.com/NVIDIA/apex/issues/439
											model.half()

						if self.args.torchscript:
											with torch.no_grad():
																__snake_case          =	torch.jit.trace(lowercase      ,    lowercase	)
						else:
											__snake_case          =	model

						def encoder_decoder_forward():
											with torch.no_grad():
																__snake_case          =	inference_model(lowercase      ,    decoder_input_ids=lowercase	)
											return outputs

						def encoder_forward():
											with torch.no_grad():
																__snake_case          =	inference_model(lowercase	)
											return outputs

						__snake_case          =	encoder_decoder_forward if config.is_encoder_decoder else encoder_forward
						return _forward




	def 							a_		(   self  :	Optional[int]      ,    lowercase  :	str      ,    lowercase  :	int      ,    lowercase  :	int	)					-> Callable[[], None]:
						__snake_case          =	self.config_dict[model_name]

						__snake_case          =	(
						    hasattr(lowercase      ,    """architectures"""	)
						    and isinstance(config.architectures      ,    lowercase	)
						    and len(config.architectures	) > 0
						)
						if not self.args.only_pretrain_model and has_model_class_in_config:
											try:
																__snake_case          =	config.architectures[0]
																__snake_case          =	__import__("""transformers"""      ,    fromlist=[model_class]	)
																__snake_case          =	getattr(lowercase      ,    lowercase	)
																__snake_case          =	model_cls(lowercase	)
											except ImportError:
																raise ImportError(
																    f'''{model_class} does not exist. If you just want to test the pretrained model, you might want to'''
																    """ set `--only_pretrain_model` or `args.only_pretrain_model=True`."""	)
						else:
											__snake_case          =	MODEL_WITH_LM_HEAD_MAPPING[config.__class__](lowercase	)

						if self.args.torchscript:
											raise NotImplementedError("""Training for torchscript is currently not implemented"""	)
						else:
											__snake_case          =	model

						model.train()
						model.to(self.args.device	)

						# encoder-decoder has vocab size saved differently
						__snake_case          =	config.vocab_size if hasattr(lowercase      ,    """vocab_size"""	) else config.encoder.vocab_size
						__snake_case          =	torch.randint(lowercase      ,    (batch_size, sequence_length)      ,    dtype=torch.long      ,    device=self.args.device	)

						if self.args.fpaa:
											logger.info("""Running training in Mixed Precision..."""	)
											if not self.args.is_gpu:
																raise ValueError("""Mixed precision is possible only for GPU."""	)

											# amp seems to have memory leaks so that memory usage
											# is measured using .half() for now https://github.com/NVIDIA/apex/issues/439
											model.half()

						def compute_loss_and_backprob_encoder():
											__snake_case          =	train_model(lowercase      ,    labels=lowercase	)[0]
											loss.backward()
											return loss

						def compute_loss_and_backprob_encoder_decoder():
											__snake_case          =	train_model(lowercase      ,    decoder_input_ids=lowercase      ,    labels=lowercase	)[0]
											loss.backward()
											return loss

						__snake_case          =	(
						    compute_loss_and_backprob_encoder_decoder
						    if config.is_encoder_decoder
						    else compute_loss_and_backprob_encoder
						)
						return _train




	def 							a_		(   self  :	Tuple      ,    lowercase  :	List[Any]	)					-> float:
						try:
											if self.args.is_tpu or self.args.torchscript:
																# run additional 10 times to stabilize compilation for tpu and torchscript
																logger.info("""Do inference on TPU or torchscript. Running model 5 times to stabilize compilation"""	)
																timeit.repeat(
																    lowercase      ,    repeat=1      ,    number=5      ,    )

											# as written in https://docs.python.org/2/library/timeit.html#timeit.Timer.repeat, min should be taken rather than the average
											__snake_case          =	timeit.repeat(
											    lowercase      ,    repeat=self.args.repeat      ,    number=10      ,    )

											if self.args.is_tpu and self.args.torch_xla_tpu_print_metrics:
																import torch_xla.debug.metrics as met

																self.print_fn(met.metrics_report()	)

											return min(lowercase	) / 10.0
						except RuntimeError as e:
											self.print_fn(f'''Doesn\'t fit on GPU. {e}'''	)
											return "N/A"




	def 							a_		(   self  :	Union[str, Any]      ,    lowercase  :	Callable[[], None]	)					-> [Memory, MemorySummary]:
						try:
											if self.args.trace_memory_line_by_line:
																__snake_case          =	start_memory_tracing("""transformers"""	)

											if self.args.is_tpu:
																# tpu
																raise NotImplementedError(
																    """Memory Benchmarking is currently not implemented for TPU. Please disable memory benchmarking with"""
																    """ `--no-memory` or `args.memory=False`"""	)
											elif self.args.is_gpu:
																if not is_pyanvml_available():
																					logger.warning(
																					    """py3nvml not installed, we won't log GPU memory usage. """
																					    """Install py3nvml (pip install py3nvml) to log information about GPU."""	)
																					__snake_case          =	"""N/A"""
																else:
																					logger.info(
																					    """Measuring total GPU usage on GPU device. Make sure to not have additional processes running"""
																					    """ on the same GPU."""	)
																					# init nvml
																					nvml.nvmlInit()
																					func()
																					__snake_case          =	nvml.nvmlDeviceGetHandleByIndex(self.args.device_idx	)
																					__snake_case          =	nvml.nvmlDeviceGetMemoryInfo(lowercase	)
																					__snake_case          =	meminfo.used
																					__snake_case          =	Memory(lowercase	)
																					# shutdown nvml
																					nvml.nvmlShutdown()
											else:
																# cpu
																__snake_case          =	measure_peak_memory_cpu(lowercase	)
																__snake_case          =	Memory(lowercase	) if isinstance(lowercase      ,    lowercase	) else memory_bytes

											if self.args.trace_memory_line_by_line:
																__snake_case          =	stop_memory_tracing(lowercase	)
											else:
																__snake_case          =	None

											return memory, summary
						except RuntimeError as e:
											self.print_fn(f'''Doesn\'t fit on GPU. {e}'''	)
											return "N/A", None


