




def 		lowerCAmelCase__    (					UpperCamelCase_				:       int ,       UpperCamelCase_				:       int	)->  int:
    return int((input_a, input_a).count(0	) != 0	)



def 		lowerCAmelCase__    (					)->  None:
    assert nand_gate(0 ,       0	) == 1
    assert nand_gate(0 ,       1	) == 1
    assert nand_gate(1 ,       0	) == 1
    assert nand_gate(1 ,       1	) == 0


if __name__ == "__main__":
   print(nand_gate(0, 0))
   print(nand_gate(0, 1))
   print(nand_gate(1, 0))
   print(nand_gate(1, 1))





import argparse
import os

# New Code #
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 import find_executable_batch_size


########################################################################
# This is a fully working simple example to use Accelerate,
# specifically showcasing how to ensure out-of-memory errors never
# interrupt training, and builds off the `nlp_example.py` script.
#
# 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)
#
# New additions from the base script can be found quickly by
# looking for the # New Code # tags
#
# 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
#
########################################################################


_lowercase						  =		16
_lowercase						  =		32



def 		lowerCAmelCase__    (					UpperCamelCase_				:       Accelerator ,       UpperCamelCase_				:       int = 1_6	)->  List[str]:
    A__		 =					AutoTokenizer.from_pretrained('''bert-base-cased'''	)
    A__		 =					load_dataset('''glue''' ,       '''mrpc'''	)

    def tokenize_function(UpperCamelCase_				:       Any	):
        # max_length=None => use the model max length (it's actually the default)
        A__		 =					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():
        A__		 =					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
    A__		 =					tokenized_datasets.rename_column('''label''' ,       '''labels'''	)

    def collate_fn(UpperCamelCase_				:       str	):
        # On TPU it's best to pad everything to the same length or training will be very slow.
        A__		 =					1_2_8 if accelerator.distributed_type == DistributedType.TPU else None
        # When using mixed precision we want round multiples of 8/16
        if accelerator.mixed_precision == "fp8":
            A__		 =					1_6
        elif accelerator.mixed_precision != "no":
            A__		 =					8
        else:
            A__		 =					None

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

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

    return train_dataloader, eval_dataloader


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

   _lowercase						  =		mocked_dataloaders  # noqa: F811



def 		lowerCAmelCase__    (					UpperCamelCase_				:       Optional[Any] ,       UpperCamelCase_				:       Tuple	)->  Union[str, Any]:
    # For testing only
    if os.environ.get('''TESTING_MOCKED_DATALOADERS''' ,       UpperCamelCase_	) == "1":
        A__		 =					2
    # Initialize accelerator
    A__		 =					Accelerator(cpu=args.cpu ,       mixed_precision=args.mixed_precision	)
    # Sample hyper-parameters for learning rate, batch size, seed and a few other HPs
    A__		 =					config['''lr''']
    A__		 =					int(config['''num_epochs''']	)
    A__		 =					int(config['''seed''']	)
    A__		 =					int(config['''batch_size''']	)

    A__		 =					evaluate.load('''glue''' ,       '''mrpc'''	)

    # New Code #
    # We now can define an inner training loop function. It should take a batch size as the only parameter,
    # and build the dataloaders in there.
    # It also gets our decorator
    @find_executable_batch_size(starting_batch_size=UpperCamelCase_	)
    def inner_training_loop(UpperCamelCase_				:       Optional[int]	):
        # And now just move everything below under this function
        # We need to bring in the Accelerator object from earlier
        nonlocal accelerator
        # And reset all of its attributes that could hold onto any memory:
        accelerator.free_memory()

        # Then we can declare the model, optimizer, and everything else:
        set_seed(UpperCamelCase_	)

        # Instantiate the model (we build the model here so that the seed also control new weights initialization)
        A__		 =					AutoModelForSequenceClassification.from_pretrained('''bert-base-cased''' ,       return_dict=UpperCamelCase_	)

        # We could avoid this line since the accelerator is set with `device_placement=True` (default value).
        # Note that if you are placing tensors on devices manually, this line absolutely needs to be before the optimizer
        # creation otherwise training will not work on TPU (`accelerate` will kindly throw an error to make us aware of that).
        A__		 =					model.to(accelerator.device	)

        # Instantiate optimizer
        A__		 =					AdamW(params=model.parameters() ,       lr=UpperCamelCase_	)
        A__ ,	A__		 =					get_dataloaders(UpperCamelCase_ ,       UpperCamelCase_	)

        # Instantiate scheduler
        A__		 =					get_linear_schedule_with_warmup(
            optimizer=UpperCamelCase_ ,       num_warmup_steps=1_0_0 ,       num_training_steps=(len(UpperCamelCase_	) * num_epochs) ,       )

        # 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.
        A__ ,	A__ ,	A__ ,	A__ ,	A__		 =					accelerator.prepare(
            UpperCamelCase_ ,       UpperCamelCase_ ,       UpperCamelCase_ ,       UpperCamelCase_ ,       UpperCamelCase_	)

        # Now we train the model
        for epoch in range(UpperCamelCase_	):
            model.train()
            for step, batch in enumerate(UpperCamelCase_	):
                # We could avoid this line since we set the accelerator with `device_placement=True`.
                batch.to(accelerator.device	)
                A__		 =					model(**UpperCamelCase_	)
                A__		 =					outputs.loss
                accelerator.backward(UpperCamelCase_	)
                optimizer.step()
                lr_scheduler.step()
                optimizer.zero_grad()

            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():
                    A__		 =					model(**UpperCamelCase_	)
                A__		 =					outputs.logits.argmax(dim=-1	)
                A__ ,	A__		 =					accelerator.gather_for_metrics((predictions, batch['''labels'''])	)
                metric.add_batch(
                    predictions=UpperCamelCase_ ,       references=UpperCamelCase_ ,       )

            A__		 =					metric.compute()
            # Use accelerator.print to print only on the main process.
            accelerator.print(f"epoch {epoch}:" ,       UpperCamelCase_	)

    # New Code #
    # And call it at the end with no arguments
    # Note: You could also refactor this outside of your training loop function
    inner_training_loop()



def 		lowerCAmelCase__    (					)->  Optional[Any]:
    A__		 =					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.'''	)
    A__		 =					parser.parse_args()
    A__		 =					{'''lr''': 2E-5, '''num_epochs''': 3, '''seed''': 4_2, '''batch_size''': 1_6}
    training_function(UpperCamelCase_ ,       UpperCamelCase_	)


if __name__ == "__main__":
   main()
