


def       lowercase_		(		_A			:    Tuple						):

      """simple docstring"""




      if length <= 0 or not isinstance(_A    ,					_A						):
            raise ValueError("Length must be a positive integer."						)
      return [n * (2 * n - 1) for n in range(_A						)]


if __name__ == "__main__":
    print(hexagonal_numbers(length=5))
    print(hexagonal_numbers(length=10))



import argparse
import gc
import json
import os

import torch
from datasets import load_dataset
from torch.optim import AdamW
from torch.utils.data import DataLoader
from transformers import AutoModelForSequenceClassification, AutoTokenizer, get_linear_schedule_with_warmup, set_seed

from accelerate import Accelerator, DistributedType
from accelerate.utils.deepspeed import DummyOptim, DummyScheduler


__a  :     str       =  1_6
__a  :     str       =  3_2





def 				UpperCAmelCase						(    lowercase							):







				"""simple docstring"""



				return int(x / 2**20							)




class    _UpperCamelCase      :


			"""simple docstring"""






			def __enter__(   self						)     ->					str:

							'''simple docstring'''


							gc.collect()
							torch.cuda.empty_cache()
							torch.cuda.reset_max_memory_allocated()  # reset the peak gauge to zero
							__lowercase 			=							torch.cuda.memory_allocated()
							return self





			def __exit__(   self      ,   *lowerCAmelCase__						)     ->					int:

							'''simple docstring'''


							gc.collect()
							torch.cuda.empty_cache()
							__lowercase 			=							torch.cuda.memory_allocated()
							__lowercase 			=							torch.cuda.max_memory_allocated()
							__lowercase 			=							bamb(self.end - self.begin						)
							__lowercase 			=							bamb(self.peak - self.begin						)
							# print(f"delta used/peak {self.used:4d}/{self.peaked:4d}")





def 				UpperCAmelCase						(    lowercase							,			lowercase = 16							,			lowercase = "bert-base-cased"							,			lowercase = 320							,			lowercase = 160							,			):







				"""simple docstring"""



				__lowercase 			=							AutoTokenizer.from_pretrained(lowercase							)
				__lowercase 			=							load_dataset(
				    '''glue'''							,			'''mrpc'''							,			split={'''train''': F"train[:{n_train}]", '''validation''': F"validation[:{n_val}]"}							)

				def tokenize_function(lowercase							):
								# max_length=None => use the model max length (it's actually the default)
								__lowercase 			=							tokenizer(examples['''sentence1''']							,			examples['''sentence2''']							,			truncation=lowercase							,			max_length=lowercase							)
								return outputs

				# Apply the method we just defined to all the examples in all the splits of the dataset
				__lowercase 			=							datasets.map(
				    lowercase							,			batched=lowercase							,			remove_columns=['''idx''', '''sentence1''', '''sentence2''']							,			load_from_cache_file=lowercase							)

				# We also rename the 'label' column to 'labels' which is the expected name for labels by the models of the
				# transformers library
				__lowercase 			=							tokenized_datasets.rename_column('''label'''							,			'''labels'''							)

				def collate_fn(lowercase							):
								# On TPU it's best to pad everything to the same length or training will be very slow.
								if accelerator.distributed_type == DistributedType.TPU:
												return tokenizer.pad(lowercase							,			padding='''max_length'''							,			max_length=128							,			return_tensors='''pt'''							)
								return tokenizer.pad(lowercase							,			padding='''longest'''							,			return_tensors='''pt'''							)

				# Instantiate dataloaders.
				__lowercase 			=							DataLoader(
				    tokenized_datasets['''train''']							,			shuffle=lowercase							,			collate_fn=lowercase							,			batch_size=lowercase							)
				__lowercase 			=							DataLoader(
				    tokenized_datasets['''validation''']							,			shuffle=lowercase							,			collate_fn=lowercase							,			batch_size=lowercase							)

				return train_dataloader, eval_dataloader





def 				UpperCAmelCase						(    lowercase							,			lowercase							):







				"""simple docstring"""



				__lowercase 			=							Accelerator()

				# Sample hyper-parameters for learning rate, batch size, seed and a few other HPs
				__lowercase 			=							config['''lr''']
				__lowercase 			=							int(config['''num_epochs''']							)
				__lowercase 			=							int(config['''seed''']							)
				__lowercase 			=							int(config['''batch_size''']							)
				__lowercase 			=							args.model_name_or_path

				set_seed(lowercase							)
				__lowercase			,     __lowercase 			=							get_dataloaders(lowercase							,			lowercase							,			lowercase							,			args.n_train							,			args.n_val							)

				# Instantiate the model (we build the model here so that the seed also control new weights initialization)
				__lowercase 			=							AutoModelForSequenceClassification.from_pretrained(lowercase							,			return_dict=lowercase							)

				# Instantiate optimizer
				__lowercase 			=							(
				    AdamW
				    if accelerator.state.deepspeed_plugin is None
				    or '''optimizer''' not in accelerator.state.deepspeed_plugin.deepspeed_config
				    else DummyOptim
				)
				__lowercase 			=							optimizer_cls(params=model.parameters()							,			lr=lowercase							)

				if accelerator.state.deepspeed_plugin is not None:
								__lowercase 			=							accelerator.state.deepspeed_plugin.deepspeed_config[
								    '''gradient_accumulation_steps'''
								]
				else:
								__lowercase 			=							1
				__lowercase 			=							(len(lowercase							) * num_epochs) // gradient_accumulation_steps

				# Instantiate scheduler
				if (
				    accelerator.state.deepspeed_plugin is None
				    or "scheduler" not in accelerator.state.deepspeed_plugin.deepspeed_config
				):
								__lowercase 			=							get_linear_schedule_with_warmup(
								    optimizer=lowercase							,			num_warmup_steps=0							,			num_training_steps=lowercase							,			)
				else:
								__lowercase 			=							DummyScheduler(lowercase							,			total_num_steps=lowercase							,			warmup_num_steps=0							)

				# Prepare everything
				# 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.
				__lowercase			,     __lowercase			,     __lowercase			,     __lowercase			,     __lowercase 			=							accelerator.prepare(
				    lowercase							,			lowercase							,			lowercase							,			lowercase							,			lowercase							)

				# We need to keep track of how many total steps we have iterated over
				__lowercase 			=							0
				# We also need to keep track of the stating epoch so files are named properly
				__lowercase 			=							0

				# Now we train the model
				__lowercase 			=							{}
				for epoch in range(lowercase							,			lowercase							):
								with TorchTracemalloc() as tracemalloc:
												model.train()
												for step, batch in enumerate(lowercase							):
																__lowercase 			=							model(**lowercase							)
																__lowercase 			=							outputs.loss
																__lowercase 			=							loss / gradient_accumulation_steps
																accelerator.backward(lowercase							)
																if step % gradient_accumulation_steps == 0:
																				optimizer.step()
																				lr_scheduler.step()
																				optimizer.zero_grad()

																overall_step += 1

        # 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							)							)							)
								__lowercase 			=							tracemalloc.peaked + bamb(tracemalloc.begin							)
								if args.peak_memory_upper_bound is not None:
												assert (
												    train_total_peak_memory[F"epoch-{epoch}"] <= args.peak_memory_upper_bound
												), "Peak memory usage exceeded the upper bound"

				accelerator.wait_for_everyone()
				if accelerator.is_main_process:
								with open(os.path.join(args.output_dir							,			'''peak_memory_utilization.json'''							)							,			'''w'''							) as f:
												json.dump(lowercase							,			lowercase							)





def 				UpperCAmelCase						(    ):







				"""simple docstring"""



				__lowercase 			=							argparse.ArgumentParser(description='''Simple example of training script tracking peak GPU memory usage.'''							)
				parser.add_argument(
				    '''--model_name_or_path'''							,			type=lowercase							,			default='''bert-base-cased'''							,			help='''Path to pretrained model or model identifier from huggingface.co/models.'''							,			required=lowercase							,			)
				parser.add_argument(
				    '''--output_dir'''							,			type=lowercase							,			default='''.'''							,			help='''Optional save directory where all checkpoint folders will be stored. Default is the current working directory.'''							,			)
				parser.add_argument(
				    '''--peak_memory_upper_bound'''							,			type=lowercase							,			default=lowercase							,			help='''The upper bound of peak memory usage in MB. If set, the training will throw an error if the peak memory usage exceeds this value.'''							,			)
				parser.add_argument(
				    '''--n_train'''							,			type=lowercase							,			default=320							,			help='''Number of training examples to use.'''							,			)
				parser.add_argument(
				    '''--n_val'''							,			type=lowercase							,			default=160							,			help='''Number of validation examples to use.'''							,			)
				parser.add_argument(
				    '''--num_epochs'''							,			type=lowercase							,			default=1							,			help='''Number of train epochs.'''							,			)
				__lowercase 			=							parser.parse_args()
				__lowercase 			=							{'''lr''': 2E-5, '''num_epochs''': args.num_epochs, '''seed''': 42, '''batch_size''': 16}
				training_function(lowercase							,			lowercase							)


if __name__ == "__main__":
		main()