






import unittest
from typing import Dict, List, Optional, Union

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 BridgeTowerImageProcessor




class 							_lowerCAmelCase(			unittest.TestCase   ):





       """simple docstring"""







       def __init__(   self    ,     _lowerCamelCase    ,     _lowerCamelCase = True    ,     _lowerCamelCase = None    ,     _lowerCamelCase = 3_2    ,     _lowerCamelCase = True    ,     _lowerCamelCase = 1 / 2_5_5    ,     _lowerCamelCase = True    ,     _lowerCamelCase = True    ,     _lowerCamelCase = [0.4_8_1_4_5_4_6_6, 0.4_5_7_8_2_7_5, 0.4_0_8_2_1_0_7_3]    ,     _lowerCamelCase = [0.2_6_8_6_2_9_5_4, 0.2_6_1_3_0_2_5_8, 0.2_7_5_7_7_7_1_1]    ,     _lowerCamelCase = True    ,     _lowerCamelCase=7    ,     _lowerCamelCase=3_0    ,     _lowerCamelCase=4_0_0    ,     _lowerCamelCase=3    ,     ):
         UpperCamelCase_:   str        =							parent
         UpperCamelCase_:   List[str]        =							do_resize
         UpperCamelCase_:   Optional[int]        =							size if size is not None else {'shortest_edge': 2_8_8}
         UpperCamelCase_:   Optional[Any]        =							size_divisor
         UpperCamelCase_:   List[str]        =							do_rescale
         UpperCamelCase_:   List[str]        =							rescale_factor
         UpperCamelCase_:   Optional[int]        =							do_normalize
         UpperCamelCase_:   str        =							do_center_crop
         UpperCamelCase_:   str        =							image_mean
         UpperCamelCase_:   str        =							image_std
         UpperCamelCase_:   Any        =							do_pad
         UpperCamelCase_:   Any        =							batch_size
         UpperCamelCase_:   List[str]        =							num_channels
         UpperCamelCase_:   Tuple        =							min_resolution
         UpperCamelCase_:   Optional[Any]        =							max_resolution





       def      _a       (   self				):
         return {
             "image_mean": self.image_mean,
             "image_std": self.image_std,
             "do_normalize": self.do_normalize,
             "do_resize": self.do_resize,
             "size": self.size,
             "size_divisor": self.size_divisor,
         }





       def      _a       (   self    ,     _lowerCamelCase    ,     _lowerCamelCase=False				):
         if not batched:
           UpperCamelCase_:   Tuple        =							self.size['shortest_edge']
           UpperCamelCase_:   Dict        =							image_inputs[0]
           if isinstance(_lowerCamelCase    ,     Image.Image				):
             UpperCamelCase_ ,UpperCamelCase_:   List[Any]        =							image.size
           else:
             UpperCamelCase_ ,UpperCamelCase_:   int        =							image.shape[1], image.shape[2]
           UpperCamelCase_:   List[str]        =							size / min(_lowerCamelCase    ,     _lowerCamelCase				)
           if h < w:
             UpperCamelCase_ ,UpperCamelCase_:   str        =							size, scale * w
           else:
             UpperCamelCase_ ,UpperCamelCase_:   str        =							scale * h, size

           UpperCamelCase_:   Dict        =							int((1_3_3_3 / 8_0_0) * size				)
           if max(_lowerCamelCase    ,     _lowerCamelCase				) > max_size:
             UpperCamelCase_:   int        =							max_size / max(_lowerCamelCase    ,     _lowerCamelCase				)
             UpperCamelCase_:   Optional[int]        =							newh * scale
             UpperCamelCase_:   Optional[int]        =							neww * scale

           UpperCamelCase_ ,UpperCamelCase_:   Dict        =							int(newh + 0.5				), int(neww + 0.5				)
           UpperCamelCase_ ,UpperCamelCase_:   int        =							(
               newh // self.size_divisor * self.size_divisor,
               neww // self.size_divisor * self.size_divisor,
           )

         else:
           UpperCamelCase_:   int        =							[]
           for image in image_inputs:
             UpperCamelCase_ ,UpperCamelCase_:   Union[str, Any]        =							self.get_expected_values([image]				)
             expected_values.append((expected_height, expected_width)				)
           UpperCamelCase_:   Optional[int]        =							max(_lowerCamelCase    ,     key=lambda _lowerCamelCase				: item[0]				)[0]
           UpperCamelCase_:   Optional[Any]        =							max(_lowerCamelCase    ,     key=lambda _lowerCamelCase				: item[1]				)[1]

         return expected_height, expected_width







@require_torch
@require_vision
class 							_lowerCAmelCase(			UpperCAmelCase_				,      unittest.TestCase   ):





       """simple docstring"""







       a							:						Dict										=BridgeTowerImageProcessor if is_vision_available() else None





       def      _a       (   self				):
         UpperCamelCase_:   int        =							BridgeTowerImageProcessingTester(self				)





       @property
       def      _a       (   self				):
         return self.image_processor_tester.prepare_image_processor_dict()





       def      _a       (   self				):
         UpperCamelCase_:   Optional[int]        =							self.image_processing_class(**self.image_processor_dict				)
         self.assertTrue(hasattr(_lowerCamelCase    ,     'image_mean'				)				)
         self.assertTrue(hasattr(_lowerCamelCase    ,     'image_std'				)				)
         self.assertTrue(hasattr(_lowerCamelCase    ,     'do_normalize'				)				)
         self.assertTrue(hasattr(_lowerCamelCase    ,     'do_resize'				)				)
         self.assertTrue(hasattr(_lowerCamelCase    ,     'size'				)				)
         self.assertTrue(hasattr(_lowerCamelCase    ,     'size_divisor'				)				)





       def      _a       (   self				):
         pass





       def      _a       (   self				):
         # Initialize image processor
         UpperCamelCase_:   int        =							self.image_processing_class(**self.image_processor_dict				)
         # create random PIL images
         UpperCamelCase_:   List[str]        =							prepare_image_inputs(self.image_processor_tester    ,     equal_resolution=_lowerCamelCase				)
         for image in image_inputs:
           self.assertIsInstance(_lowerCamelCase    ,     Image.Image				)

         # Test not batched input
         UpperCamelCase_:   List[Any]        =							image_processing(image_inputs[0]    ,     return_tensors='pt'				).pixel_values

         UpperCamelCase_ ,UpperCamelCase_:   Dict        =							self.image_processor_tester.get_expected_values(_lowerCamelCase				)
         self.assertEqual(
             encoded_images.shape    ,     (1, self.image_processor_tester.num_channels, expected_height, expected_width)    ,     )

         # Test batched
         UpperCamelCase_:   Optional[Any]        =							image_processing(_lowerCamelCase    ,     return_tensors='pt'				).pixel_values

         UpperCamelCase_ ,UpperCamelCase_:   str        =							self.image_processor_tester.get_expected_values(_lowerCamelCase    ,     batched=_lowerCamelCase				)
         self.assertEqual(
             encoded_images.shape    ,     (
                 self.image_processor_tester.batch_size,
                 self.image_processor_tester.num_channels,
                 expected_height,
                 expected_width,
             )    ,     )





       def      _a       (   self				):
         # Initialize image processor
         UpperCamelCase_:   Union[str, Any]        =							self.image_processing_class(**self.image_processor_dict				)
         # create random numpy tensors
         UpperCamelCase_:   List[Any]        =							prepare_image_inputs(self.image_processor_tester    ,     equal_resolution=_lowerCamelCase    ,     numpify=_lowerCamelCase				)
         for image in image_inputs:
           self.assertIsInstance(_lowerCamelCase    ,     np.ndarray				)

         # Test not batched input
         UpperCamelCase_:   int        =							image_processing(image_inputs[0]    ,     return_tensors='pt'				).pixel_values

         UpperCamelCase_ ,UpperCamelCase_:   Union[str, Any]        =							self.image_processor_tester.get_expected_values(_lowerCamelCase				)
         self.assertEqual(
             encoded_images.shape    ,     (1, self.image_processor_tester.num_channels, expected_height, expected_width)    ,     )

         # Test batched
         UpperCamelCase_:   Optional[int]        =							image_processing(_lowerCamelCase    ,     return_tensors='pt'				).pixel_values

         UpperCamelCase_ ,UpperCamelCase_:   Optional[int]        =							self.image_processor_tester.get_expected_values(_lowerCamelCase    ,     batched=_lowerCamelCase				)
         self.assertEqual(
             encoded_images.shape    ,     (
                 self.image_processor_tester.batch_size,
                 self.image_processor_tester.num_channels,
                 expected_height,
                 expected_width,
             )    ,     )





       def      _a       (   self				):
         # Initialize image processor
         UpperCamelCase_:   Dict        =							self.image_processing_class(**self.image_processor_dict				)
         # create random PyTorch tensors
         UpperCamelCase_:   str        =							prepare_image_inputs(self.image_processor_tester    ,     equal_resolution=_lowerCamelCase    ,     torchify=_lowerCamelCase				)
         for image in image_inputs:
           self.assertIsInstance(_lowerCamelCase    ,     torch.Tensor				)

         # Test not batched input
         UpperCamelCase_:   List[Any]        =							image_processing(image_inputs[0]    ,     return_tensors='pt'				).pixel_values

         UpperCamelCase_ ,UpperCamelCase_:   Union[str, Any]        =							self.image_processor_tester.get_expected_values(_lowerCamelCase				)
         self.assertEqual(
             encoded_images.shape    ,     (1, self.image_processor_tester.num_channels, expected_height, expected_width)    ,     )

         # Test batched
         UpperCamelCase_:   Optional[int]        =							image_processing(_lowerCamelCase    ,     return_tensors='pt'				).pixel_values

         UpperCamelCase_ ,UpperCamelCase_:   List[str]        =							self.image_processor_tester.get_expected_values(_lowerCamelCase    ,     batched=_lowerCamelCase				)
         self.assertEqual(
             encoded_images.shape    ,     (
                 self.image_processor_tester.batch_size,
                 self.image_processor_tester.num_channels,
                 expected_height,
                 expected_width,
             )    ,     )

"""simple docstring"""




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
a		:       Optional[Any]     						=       False
a		:       str     						=       False



def     __magic_name__		(					UpperCamelCase     :		Namespace     )     ->						Optional[int]:
    return TrainCommand(UpperCamelCase     )







class     lowercase(_lowercase       ):



     @staticmethod
     def 			lowercase__  (							__SCREAMING_SNAKE_CASE   )		->     List[Any]:







         """simple docstring"""



         a__		=			parser.add_parser('train'     ,				help='CLI tool to train a model on a task.'   )

         train_parser.add_argument(
             '--train_data'     ,				type=__SCREAMING_SNAKE_CASE     ,				required=__SCREAMING_SNAKE_CASE     ,				help='path to train (and optionally evaluation) dataset as a csv with tab separated labels and sentences.'     ,				)
         train_parser.add_argument(
             '--column_label'     ,				type=__SCREAMING_SNAKE_CASE     ,				default=0     ,				help='Column of the dataset csv file with example labels.'   )
         train_parser.add_argument(
             '--column_text'     ,				type=__SCREAMING_SNAKE_CASE     ,				default=1     ,				help='Column of the dataset csv file with example texts.'   )
         train_parser.add_argument(
             '--column_id'     ,				type=__SCREAMING_SNAKE_CASE     ,				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=__SCREAMING_SNAKE_CASE     ,				default=''     ,				help='path to validation dataset.'   )
         train_parser.add_argument(
             '--validation_split'     ,				type=__SCREAMING_SNAKE_CASE     ,				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=__SCREAMING_SNAKE_CASE     ,				default='./'     ,				help='path to saved the trained model.'   )

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



     def __init__(							self     ,				__SCREAMING_SNAKE_CASE   )		->     Union[str, Any]:







         """simple docstring"""



         a__		=			logging.get_logger('transformers-cli/training'   )

         a__		=			'tf' if is_tf_available() else 'torch'

         os.makedirs(args.output     ,				exist_ok=__SCREAMING_SNAKE_CASE   )
         a__		=			args.output

         a__		=			args.column_label
         a__		=			args.column_text
         a__		=			args.column_id

         self.logger.info(f'Loading {args.task} pipeline for {args.model}'   )
         if args.task == "text_classification":
             a__		=			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__		=			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__		=			None
         if args.validation_data:
             self.logger.info(f'Loading validation dataset from {args.validation_data}'   )
             a__		=			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__		=			args.validation_split
         a__		=			args.train_batch_size
         a__		=			args.valid_batch_size
         a__		=			args.learning_rate
         a__		=			args.adam_epsilon



     def 			lowercase__  (							self   )		->     Tuple:







         """simple docstring"""



         if self.framework == "tf":
             return self.run_tf()
         return self.run_torch()



     def 			lowercase__  (							self   )		->     Any:







         """simple docstring"""



         raise NotImplementedError




     def 			lowercase__  (							self   )		->     Dict:







         """simple docstring"""



         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   )


