


import unittest

import numpy as np

from transformers.testing_utils import require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available

from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs


if is_torch_available():
       import torch

if is_vision_available():
       from PIL import Image

       from transformers import ViTImageProcessor


class   a__	(						unittest.TestCase    ):

       def __init__(   self      :     Any      ,							lowerCamelCase_      :     Any      ,							lowerCamelCase_      :     str=1_3      ,							lowerCamelCase_      :     List[str]=3      ,							lowerCamelCase_      :     str=2_2_4      ,							lowerCamelCase_      :     List[Any]=3_0      ,							lowerCamelCase_      :     List[str]=4_0_0      ,							lowerCamelCase_      :     Optional[Any]=True      ,							lowerCamelCase_      :     List[str]=None      ,							lowerCamelCase_      :     str=True      ,							lowerCamelCase_      :     str=[0.5, 0.5, 0.5]      ,							lowerCamelCase_      :     Union[str, Any]=[0.5, 0.5, 0.5]      ,							):
              a_    :     int										=    size if size is not None else {"""height""": 1_8, """width""": 1_8}
              a_    :     Any										=    parent
              a_    :     Dict										=    batch_size
              a_    :     Any										=    num_channels
              a_    :     Dict										=    image_size
              a_    :     Union[str, Any]										=    min_resolution
              a_    :     List[str]										=    max_resolution
              a_    :     List[Any]										=    do_resize
              a_    :     Dict										=    size
              a_    :     Union[str, Any]										=    do_normalize
              a_    :     Optional[Any]										=    image_mean
              a_    :     int										=    image_std

       def 						UpperCAmelCase(   self      :     List[Any]    ):
              return {
                  "image_mean": self.image_mean,
                  "image_std": self.image_std,
                  "do_normalize": self.do_normalize,
                  "do_resize": self.do_resize,
                  "size": self.size,
              }


@require_torch
@require_vision
class   a__	(						lowerCAmelCase_						,       unittest.TestCase    ):
       lowerCamelCase__:     Dict							    =     ViTImageProcessor if is_vision_available() else None

       def 						UpperCAmelCase(   self      :     int    ):
              a_    :     Optional[int]										=    EfficientFormerImageProcessorTester(self    )

       @property
       def 						UpperCAmelCase(   self      :     Optional[int]    ):
              return self.image_proc_tester.prepare_image_processor_dict()

       def 						UpperCAmelCase(   self      :     List[Any]    ):
              a_    :     int										=    self.image_processing_class(**self.image_processor_dict    )
              self.assertTrue(hasattr(__a      ,							"""image_mean"""    )    )
              self.assertTrue(hasattr(__a      ,							"""image_std"""    )    )
              self.assertTrue(hasattr(__a      ,							"""do_normalize"""    )    )
              self.assertTrue(hasattr(__a      ,							"""do_resize"""    )    )
              self.assertTrue(hasattr(__a      ,							"""size"""    )    )

       def 						UpperCAmelCase(   self      :     List[str]    ):
              pass

       def 						UpperCAmelCase(   self      :     str    ):
              a_    :     Optional[int]										=    self.image_processing_class(**self.image_processor_dict    )
              # create random PIL images
              a_    :     str										=    prepare_image_inputs(self.image_proc_tester      ,							equal_resolution=__a    )
              for image in image_inputs:
                     self.assertIsInstance(__a      ,							Image.Image    )

              # Test not batched input
              a_    :     Union[str, Any]										=    image_processor(image_inputs[0]      ,							return_tensors="""pt"""    ).pixel_values
              self.assertEqual(
                  encoded_images.shape      ,							(
                      1,
                      self.image_proc_tester.num_channels,
                      self.image_proc_tester.size["""height"""],
                      self.image_proc_tester.size["""width"""],
                  )      ,							)

              # Test batched
              a_    :     int										=    image_processor(__a      ,							return_tensors="""pt"""    ).pixel_values
              self.assertEqual(
                  encoded_images.shape      ,							(
                      self.image_proc_tester.batch_size,
                      self.image_proc_tester.num_channels,
                      self.image_proc_tester.size["""height"""],
                      self.image_proc_tester.size["""width"""],
                  )      ,							)

       def 						UpperCAmelCase(   self      :     List[Any]    ):
              a_    :     List[str]										=    self.image_processing_class(**self.image_processor_dict    )
              # create random numpy tensors
              a_    :     int										=    prepare_image_inputs(self.image_proc_tester      ,							equal_resolution=__a      ,							numpify=__a    )
              for image in image_inputs:
                     self.assertIsInstance(__a      ,							np.ndarray    )

              # Test not batched input
              a_    :     Optional[Any]										=    image_processor(image_inputs[0]      ,							return_tensors="""pt"""    ).pixel_values
              self.assertEqual(
                  encoded_images.shape      ,							(
                      1,
                      self.image_proc_tester.num_channels,
                      self.image_proc_tester.size["""height"""],
                      self.image_proc_tester.size["""width"""],
                  )      ,							)

              # Test batched
              a_    :     Dict										=    image_processor(__a      ,							return_tensors="""pt"""    ).pixel_values
              self.assertEqual(
                  encoded_images.shape      ,							(
                      self.image_proc_tester.batch_size,
                      self.image_proc_tester.num_channels,
                      self.image_proc_tester.size["""height"""],
                      self.image_proc_tester.size["""width"""],
                  )      ,							)

       def 						UpperCAmelCase(   self      :     Optional[int]    ):
              a_    :     Tuple										=    self.image_processing_class(**self.image_processor_dict    )
              # create random PyTorch tensors
              a_    :     str										=    prepare_image_inputs(self.image_proc_tester      ,							equal_resolution=__a      ,							torchify=__a    )
              for image in image_inputs:
                     self.assertIsInstance(__a      ,							torch.Tensor    )

              # Test not batched input
              a_    :     List[Any]										=    image_processor(image_inputs[0]      ,							return_tensors="""pt"""    ).pixel_values
              self.assertEqual(
                  encoded_images.shape      ,							(
                      1,
                      self.image_proc_tester.num_channels,
                      self.image_proc_tester.size["""height"""],
                      self.image_proc_tester.size["""width"""],
                  )      ,							)

              # Test batched
              a_    :     List[Any]										=    image_processor(__a      ,							return_tensors="""pt"""    ).pixel_values
              self.assertEqual(
                  encoded_images.shape      ,							(
                      self.image_proc_tester.batch_size,
                      self.image_proc_tester.num_channels,
                      self.image_proc_tester.size["""height"""],
                      self.image_proc_tester.size["""width"""],
                  )      ,							)







import os
from argparse import ArgumentParser, Namespace

from ..data import SingleSentenceClassificationProcessor as Processor
from ..pipelines import TextClassificationPipeline
from ..utils import is_tf_available, is_torch_available, logging
from . import BaseTransformersCLICommand


if not is_tf_available() and not is_torch_available():
       raise RuntimeError('''At least one of PyTorch or TensorFlow 2.0+ should be installed to use CLI training''')

# TF training parameters
__lowerCamelCase        =     False
__lowerCamelCase        =     False



def  _a			(						__UpperCamelCase ):
     return TrainCommand(__UpperCamelCase )


class   a__	(						lowerCAmelCase_    ):

       @staticmethod
       def 						UpperCAmelCase(   lowerCamelCase_      :     ArgumentParser    ):
            a_    :     List[Any]										=    parser.add_parser("""train"""      ,							help="""CLI tool to train a model on a task."""    )

            train_parser.add_argument(
                """--train_data"""      ,							type=lowerCamelCase_      ,							required=lowerCamelCase_      ,							help="""path to train (and optionally evaluation) dataset as a csv with tab separated labels and sentences."""      ,							)
            train_parser.add_argument(
                """--column_label"""      ,							type=lowerCamelCase_      ,							default=0      ,							help="""Column of the dataset csv file with example labels."""    )
            train_parser.add_argument(
                """--column_text"""      ,							type=lowerCamelCase_      ,							default=1      ,							help="""Column of the dataset csv file with example texts."""    )
            train_parser.add_argument(
                """--column_id"""      ,							type=lowerCamelCase_      ,							default=2      ,							help="""Column of the dataset csv file with example ids."""    )
            train_parser.add_argument(
                """--skip_first_row"""      ,							action="""store_true"""      ,							help="""Skip the first row of the csv file (headers)."""    )

            train_parser.add_argument("""--validation_data"""      ,							type=lowerCamelCase_      ,							default=""""""      ,							help="""path to validation dataset."""    )
            train_parser.add_argument(
                """--validation_split"""      ,							type=lowerCamelCase_      ,							default=0.1      ,							help="""if validation dataset is not provided, fraction of train dataset to use as validation dataset."""      ,							)

            train_parser.add_argument("""--output"""      ,							type=lowerCamelCase_      ,							default="""./"""      ,							help="""path to saved the trained model."""    )

            train_parser.add_argument(
                """--task"""      ,							type=lowerCamelCase_      ,							default="""text_classification"""      ,							help="""Task to train the model on."""    )
            train_parser.add_argument(
                """--model"""      ,							type=lowerCamelCase_      ,							default="""bert-base-uncased"""      ,							help="""Model's name or path to stored model."""    )
            train_parser.add_argument("""--train_batch_size"""      ,							type=lowerCamelCase_      ,							default=3_2      ,							help="""Batch size for training."""    )
            train_parser.add_argument("""--valid_batch_size"""      ,							type=lowerCamelCase_      ,							default=6_4      ,							help="""Batch size for validation."""    )
            train_parser.add_argument("""--learning_rate"""      ,							type=lowerCamelCase_      ,							default=3E-5      ,							help="""Learning rate."""    )
            train_parser.add_argument("""--adam_epsilon"""      ,							type=lowerCamelCase_      ,							default=1E-08      ,							help="""Epsilon for Adam optimizer."""    )
            train_parser.set_defaults(func=lowerCamelCase_    )

       def __init__(   self      :     int      ,							lowerCamelCase_      :     Namespace    ):
            a_    :     Optional[int]										=    logging.get_logger("""transformers-cli/training"""    )

            a_    :     List[str]										=    """tf""" if is_tf_available() else """torch"""

            os.makedirs(args.output      ,							exist_ok=lowerCamelCase_    )
            a_    :     List[str]										=    args.output

            a_    :     Optional[int]										=    args.column_label
            a_    :     Tuple										=    args.column_text
            a_    :     Optional[int]										=    args.column_id

            self.logger.info(F'''Loading {args.task} pipeline for {args.model}'''    )
            if args.task == "text_classification":
                 a_    :     str										=    TextClassificationPipeline.from_pretrained(args.model    )
            elif args.task == "token_classification":
                 raise NotImplementedError
            elif args.task == "question_answering":
                 raise NotImplementedError

            self.logger.info(F'''Loading dataset from {args.train_data}'''    )
            a_    :     int										=    Processor.create_from_csv(
                args.train_data      ,							column_label=args.column_label      ,							column_text=args.column_text      ,							column_id=args.column_id      ,							skip_first_row=args.skip_first_row      ,							)
            a_    :     Union[str, Any]										=    None
            if args.validation_data:
                 self.logger.info(F'''Loading validation dataset from {args.validation_data}'''    )
                 a_    :     Tuple										=    Processor.create_from_csv(
                     args.validation_data      ,							column_label=args.column_label      ,							column_text=args.column_text      ,							column_id=args.column_id      ,							skip_first_row=args.skip_first_row      ,							)

            a_    :     str										=    args.validation_split
            a_    :     Tuple										=    args.train_batch_size
            a_    :     List[Any]										=    args.valid_batch_size
            a_    :     str										=    args.learning_rate
            a_    :     str										=    args.adam_epsilon

       def 						UpperCAmelCase(   self      :     List[str]    ):
            if self.framework == "tf":
                 return self.run_tf()
            return self.run_torch()

       def 						UpperCAmelCase(   self      :     Any    ):
            raise NotImplementedError

       def 						UpperCAmelCase(   self      :     List[str]    ):
            self.pipeline.fit(
                self.train_dataset      ,							validation_data=self.valid_dataset      ,							validation_split=self.validation_split      ,							learning_rate=self.learning_rate      ,							adam_epsilon=self.adam_epsilon      ,							train_batch_size=self.train_batch_size      ,							valid_batch_size=self.valid_batch_size      ,							)

            # Save trained pipeline
            self.pipeline.save_pretrained(self.output    )



