


"""simple docstring"""


import argparse
import json
import os

import evaluate
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


__lowerCamelCase      :Optional[int]	    =		16
__lowerCamelCase      :Tuple	    =		32




def   snake_case		(     UpperCamelCase__       :						Accelerator			,				UpperCamelCase__       :						int = 16			,				UpperCamelCase__       :						str = "bert-base-cased"    )   ->      Dict:
      lowerCamelCase					:					Tuple        =	AutoTokenizer.from_pretrained(UpperCamelCase__    )
      lowerCamelCase					:					Dict        =	load_dataset("""glue"""			,				"""mrpc"""    )

      def tokenize_function(UpperCamelCase__       :						int    ):
            # max_length=None => use the model max length (it's actually the default)
            lowerCamelCase					:					Tuple        =	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
      lowerCamelCase					:					List[Any]        =	datasets.map(
          UpperCamelCase__			,				batched=UpperCamelCase__			,				remove_columns=["""idx""", """sentence1""", """sentence2"""]			,				load_from_cache_file=UpperCamelCase__    )

      # 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"""    )

      def collate_fn(UpperCamelCase__       :						Dict    ):
            # 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(UpperCamelCase__			,				padding="""max_length"""			,				max_length=128			,				return_tensors="""pt"""    )
            return tokenizer.pad(UpperCamelCase__			,				padding="""longest"""			,				return_tensors="""pt"""    )

      # Instantiate dataloaders.
      lowerCamelCase					:					List[str]        =	DataLoader(
          tokenized_datasets["""train"""]			,				shuffle=UpperCamelCase__			,				collate_fn=UpperCamelCase__			,				batch_size=UpperCamelCase__    )
      lowerCamelCase					:					List[Any]        =	DataLoader(
          tokenized_datasets["""validation"""]			,				shuffle=UpperCamelCase__			,				collate_fn=UpperCamelCase__			,				batch_size=UpperCamelCase__    )

      return train_dataloader, eval_dataloader




def   snake_case		(     UpperCamelCase__       :						Dict			,				UpperCamelCase__       :						Any			,				UpperCamelCase__       :						Optional[int]			,				UpperCamelCase__       :						int    )   ->      int:
      model.eval()
      lowerCamelCase					:					Union[str, Any]        =	0
      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					:					int        =	model(**UpperCamelCase__    )
            lowerCamelCase					:					List[Any]        =	outputs.logits.argmax(dim=-1    )
            # It is slightly faster to call this once, than multiple times
            lowerCamelCase     ,			lowerCamelCase					:					List[str]        =	accelerator.gather(
                (predictions, batch["""labels"""])    )  # If we are in a multiprocess environment, the last batch has duplicates
            if accelerator.use_distributed:
                  if step == len(UpperCamelCase__    ) - 1:
                        lowerCamelCase					:					Tuple        =	predictions[: len(eval_dataloader.dataset    ) - samples_seen]
                        lowerCamelCase					:					str        =	references[: len(eval_dataloader.dataset    ) - samples_seen]
                  else:
                        samples_seen += references.shape[0]
            metric.add_batch(
                predictions=UpperCamelCase__			,				references=UpperCamelCase__			,				)

      lowerCamelCase					:					Tuple        =	metric.compute()
      return eval_metric["accuracy"]




def   snake_case		(     UpperCamelCase__       :						Optional[int]			,				UpperCamelCase__       :						Union[str, Any]    )   ->      Union[str, Any]:
      # Initialize accelerator
      lowerCamelCase					:					str        =	Accelerator()

      # Sample hyper-parameters for learning rate, batch size, seed and a few other HPs
      lowerCamelCase					:					str        =	config["""lr"""]
      lowerCamelCase					:					Any        =	int(config["""num_epochs"""]    )
      lowerCamelCase					:					int        =	int(config["""seed"""]    )
      lowerCamelCase					:					Optional[Any]        =	int(config["""batch_size"""]    )
      lowerCamelCase					:					Tuple        =	args.model_name_or_path

      set_seed(UpperCamelCase__    )
      lowerCamelCase     ,			lowerCamelCase					:					List[Any]        =	get_dataloaders(UpperCamelCase__			,				UpperCamelCase__			,				UpperCamelCase__    )

      # Instantiate the model (we build the model here so that the seed also control new weights initialization)
      lowerCamelCase					:					Union[str, Any]        =	AutoModelForSequenceClassification.from_pretrained(UpperCamelCase__			,				return_dict=UpperCamelCase__    )

      # Instantiate optimizer
      lowerCamelCase					:					Optional[int]        =	(
          AdamW
          if accelerator.state.deepspeed_plugin is None
          or """optimizer""" not in accelerator.state.deepspeed_plugin.deepspeed_config
          else DummyOptim
      )
      lowerCamelCase					:					Dict        =	optimizer_cls(params=model.parameters()			,				lr=UpperCamelCase__    )

      if accelerator.state.deepspeed_plugin is not None:
            lowerCamelCase					:					Tuple        =	accelerator.state.deepspeed_plugin.deepspeed_config[
                """gradient_accumulation_steps"""
            ]
      else:
            lowerCamelCase					:					Any        =	1
      lowerCamelCase					:					List[str]        =	(len(UpperCamelCase__    ) * num_epochs) // gradient_accumulation_steps

      # Instantiate scheduler
      if (
          accelerator.state.deepspeed_plugin is None
          or "scheduler" not in accelerator.state.deepspeed_plugin.deepspeed_config
      ):
            lowerCamelCase					:					Optional[Any]        =	get_linear_schedule_with_warmup(
                optimizer=UpperCamelCase__			,				num_warmup_steps=0			,				num_training_steps=UpperCamelCase__			,				)
      else:
            lowerCamelCase					:					str        =	DummyScheduler(UpperCamelCase__			,				total_num_steps=UpperCamelCase__			,				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.
      lowerCamelCase     ,			lowerCamelCase     ,			lowerCamelCase     ,			lowerCamelCase     ,			lowerCamelCase					:					Tuple        =	accelerator.prepare(
          UpperCamelCase__			,				UpperCamelCase__			,				UpperCamelCase__			,				UpperCamelCase__			,				UpperCamelCase__    )

      # We need to keep track of how many total steps we have iterated over
      lowerCamelCase					:					Optional[int]        =	0
      # We also need to keep track of the stating epoch so files are named properly
      lowerCamelCase					:					int        =	0
      lowerCamelCase					:					int        =	evaluate.load("""glue"""			,				"""mrpc"""    )
      lowerCamelCase					:					int        =	num_epochs

      if args.partial_train_epoch is not None:
            lowerCamelCase					:					Dict        =	args.partial_train_epoch

      if args.resume_from_checkpoint:
            accelerator.load_state(args.resume_from_checkpoint    )
            lowerCamelCase					:					str        =	args.resume_from_checkpoint.split("""epoch_"""    )[1]
            lowerCamelCase					:					Optional[int]        =	""""""
            for char in epoch_string:
                  if char.isdigit():
                        state_epoch_num += char
                  else:
                        break
            lowerCamelCase					:					List[str]        =	int(UpperCamelCase__    ) + 1
            lowerCamelCase					:					Any        =	evaluation_loop(UpperCamelCase__			,				UpperCamelCase__			,				UpperCamelCase__			,				UpperCamelCase__    )
            accelerator.print("""resumed checkpoint performance:"""			,				UpperCamelCase__    )
            accelerator.print("""resumed checkpoint's scheduler's lr:"""			,				lr_scheduler.get_lr()[0]    )
            accelerator.print("""resumed optimizers's lr:"""			,				optimizer.param_groups[0]["""lr"""]    )
            with open(os.path.join(args.output_dir			,				F'state_{starting_epoch-1}.json'    )			,				"""r"""    ) as f:
                  lowerCamelCase					:					Dict        =	json.load(UpperCamelCase__    )
                  assert resumed_state["accuracy"] == accuracy, "Accuracy mismatch, loading from checkpoint failed"
                  assert (
                      resumed_state["lr"] == lr_scheduler.get_lr()[0]
                  ), "Scheduler learning rate mismatch, loading from checkpoint failed"
                  assert (
                      resumed_state["optimizer_lr"] == optimizer.param_groups[0]["lr"]
                  ), "Optimizer learning rate mismatch, loading from checkpoint failed"
                  assert resumed_state["epoch"] == starting_epoch - 1, "Epoch mismatch, loading from checkpoint failed"
                  return

    # Now we train the model
      lowerCamelCase					:					int        =	{}
      for epoch in range(UpperCamelCase__			,				UpperCamelCase__    ):
            model.train()
            for step, batch in enumerate(UpperCamelCase__    ):
                  lowerCamelCase					:					Tuple        =	model(**UpperCamelCase__    )
                  lowerCamelCase					:					List[str]        =	outputs.loss
                  lowerCamelCase					:					List[str]        =	loss / gradient_accumulation_steps
                  accelerator.backward(UpperCamelCase__    )
                  if step % gradient_accumulation_steps == 0:
                        optimizer.step()
                        lr_scheduler.step()
                        optimizer.zero_grad()

                  overall_step += 1
            lowerCamelCase					:					List[Any]        =	F'epoch_{epoch}'
            lowerCamelCase					:					Dict        =	os.path.join(args.output_dir			,				UpperCamelCase__    )
            accelerator.save_state(UpperCamelCase__    )
            lowerCamelCase					:					List[Any]        =	evaluation_loop(UpperCamelCase__			,				UpperCamelCase__			,				UpperCamelCase__			,				UpperCamelCase__    )
            lowerCamelCase					:					Any        =	accuracy
            lowerCamelCase					:					Optional[Any]        =	lr_scheduler.get_lr()[0]
            lowerCamelCase					:					Union[str, Any]        =	optimizer.param_groups[0]["""lr"""]
            lowerCamelCase					:					Tuple        =	epoch
            lowerCamelCase					:					Optional[Any]        =	overall_step
            accelerator.print(F'epoch {epoch}:'			,				UpperCamelCase__    )

            accelerator.wait_for_everyone()
            if accelerator.is_main_process:
                  with open(os.path.join(args.output_dir			,				F'state_{epoch}.json'    )			,				"""w"""    ) as f:
                        json.dump(UpperCamelCase__			,				UpperCamelCase__    )




def   snake_case		(     )   ->      Any:
      lowerCamelCase					:					str        =	argparse.ArgumentParser(description="""Simple example of training script tracking peak GPU memory usage."""    )
      parser.add_argument(
          """--model_name_or_path"""			,				type=UpperCamelCase__			,				default="""bert-base-cased"""			,				help="""Path to pretrained model or model identifier from huggingface.co/models."""			,				required=UpperCamelCase__			,				)
      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(
          """--resume_from_checkpoint"""			,				type=UpperCamelCase__			,				default=UpperCamelCase__			,				help="""If the training should continue from a checkpoint folder."""			,				)
      parser.add_argument(
          """--partial_train_epoch"""			,				type=UpperCamelCase__			,				default=UpperCamelCase__			,				help="""If passed, the training will stop after this number of epochs."""			,				)
      parser.add_argument(
          """--num_epochs"""			,				type=UpperCamelCase__			,				default=2			,				help="""Number of train epochs."""			,				)
      lowerCamelCase					:					Optional[int]        =	parser.parse_args()
      lowerCamelCase					:					str        =	{"""lr""": 2E-5, """num_epochs""": args.num_epochs, """seed""": 42, """batch_size""": 16}

      training_function(UpperCamelCase__			,				UpperCamelCase__    )


if __name__ == "__main__":
    main()








"""simple docstring"""


import os




def   snake_case		(     )   ->      Optional[Any]:
      with open(os.path.dirname(UpperCamelCase__    ) + """/grid.txt"""    ) as f:
            lowerCamelCase					:					int        =	[]  # noqa: E741
            for _ in range(20    ):
                  l.append([int(UpperCamelCase__    ) for x in f.readline().split()]    )

            lowerCamelCase					:					Union[str, Any]        =	0

            # right
            for i in range(20    ):
                  for j in range(17    ):
                        lowerCamelCase					:					Dict        =	l[i][j] * l[i][j + 1] * l[i][j + 2] * l[i][j + 3]
                        if temp > maximum:
                              lowerCamelCase					:					Tuple        =	temp

        # down
            for i in range(17    ):
                  for j in range(20    ):
                        lowerCamelCase					:					Any        =	l[i][j] * l[i + 1][j] * l[i + 2][j] * l[i + 3][j]
                        if temp > maximum:
                              lowerCamelCase					:					Optional[Any]        =	temp

        # diagonal 1
            for i in range(17    ):
                  for j in range(17    ):
                        lowerCamelCase					:					List[Any]        =	l[i][j] * l[i + 1][j + 1] * l[i + 2][j + 2] * l[i + 3][j + 3]
                        if temp > maximum:
                              lowerCamelCase					:					List[str]        =	temp

        # diagonal 2
            for i in range(17    ):
                  for j in range(3			,				20    ):
                        lowerCamelCase					:					List[str]        =	l[i][j] * l[i + 1][j - 1] * l[i + 2][j - 2] * l[i + 3][j - 3]
                        if temp > maximum:
                              lowerCamelCase					:					List[Any]        =	temp
            return maximum


if __name__ == "__main__":
    print(solution())




