
"""simple docstring"""






import numpy as np

from transformers import BatchFeature
from transformers.testing_utils import require_tf, require_torch

from .test_feature_extraction_common import FeatureExtractionSavingTestMixin





class 				snake_case    (			SCREAMING_SNAKE_CASE_						):
   # to overwrite at feature extractactor specific tests
   a_ :						int			 =			None
   a_ :						Tuple			 =			None







   @property
   def 					UpperCAmelCase__     (      self)					->str:
      return self.feat_extract_tester.prepare_feat_extract_dict()







   def 					UpperCAmelCase__     (      self)					->Union[str, Any]:
      a_							=			self.feature_extraction_class(**self.feat_extract_dict)
      self.assertTrue(hasattr(__UpperCAmelCase    ,				"feature_size"))
      self.assertTrue(hasattr(__UpperCAmelCase    ,				"sampling_rate"))
      self.assertTrue(hasattr(__UpperCAmelCase    ,				"padding_value"))







   def 					UpperCAmelCase__     (      self)					->Dict:
      a_							=			self.feat_extract_tester.prepare_inputs_for_common()
      a_							=			self.feature_extraction_class(**self.feat_extract_dict)
      a_							=			feat_extract.model_input_names[0]

      a_							=			BatchFeature({input_name: speech_inputs})

      self.assertTrue(all(len(__UpperCAmelCase) == len(__UpperCAmelCase) for x, y in zip(__UpperCAmelCase    ,				processed_features[input_name])))

      a_							=			self.feat_extract_tester.prepare_inputs_for_common(equal_length=__UpperCAmelCase)
      a_							=			BatchFeature({input_name: speech_inputs}    ,				tensor_type="np")

      a_							=			processed_features[input_name]

      if len(batch_features_input.shape) < 3:
         a_							=			batch_features_input[:, :, None]

      self.assertTrue(
          batch_features_input.shape
          == (self.feat_extract_tester.batch_size, len(speech_inputs[0]), self.feat_extract_tester.feature_size))







   @require_torch
   def 					UpperCAmelCase__     (      self)					->Dict:
      a_							=			self.feat_extract_tester.prepare_inputs_for_common(equal_length=__UpperCAmelCase)
      a_							=			self.feature_extraction_class(**self.feat_extract_dict)
      a_							=			feat_extract.model_input_names[0]

      a_							=			BatchFeature({input_name: speech_inputs}    ,				tensor_type="pt")

      a_							=			processed_features[input_name]

      if len(batch_features_input.shape) < 3:
         a_							=			batch_features_input[:, :, None]

      self.assertTrue(
          batch_features_input.shape
          == (self.feat_extract_tester.batch_size, len(speech_inputs[0]), self.feat_extract_tester.feature_size))







   @require_tf
   def 					UpperCAmelCase__     (      self)					->Any:
      a_							=			self.feat_extract_tester.prepare_inputs_for_common(equal_length=__UpperCAmelCase)
      a_							=			self.feature_extraction_class(**self.feat_extract_dict)
      a_							=			feat_extract.model_input_names[0]

      a_							=			BatchFeature({input_name: speech_inputs}    ,				tensor_type="tf")

      a_							=			processed_features[input_name]

      if len(batch_features_input.shape) < 3:
         a_							=			batch_features_input[:, :, None]

      self.assertTrue(
          batch_features_input.shape
          == (self.feat_extract_tester.batch_size, len(speech_inputs[0]), self.feat_extract_tester.feature_size))







   def 					UpperCAmelCase__     (      self    ,				__UpperCAmelCase=False)					->Tuple:







      def _inputs_have_equal_length(__UpperCAmelCase):
         a_							=			len(input[0])
         for input_slice in input[1:]:
            if len(__UpperCAmelCase) != length:
               return False
         return True

      def _inputs_are_equal(__UpperCAmelCase    ,				__UpperCAmelCase):
         if len(__UpperCAmelCase) != len(__UpperCAmelCase):
            return False

         for input_slice_a, input_slice_a in zip(__UpperCAmelCase    ,				__UpperCAmelCase):
            if not np.allclose(np.asarray(__UpperCAmelCase)    ,				np.asarray(__UpperCAmelCase)    ,				atol=1E-3):
               return False
         return True

      a_							=			self.feature_extraction_class(**self.feat_extract_dict)
      a_							=			self.feat_extract_tester.prepare_inputs_for_common(numpify=__UpperCAmelCase)
      a_							=			feat_extract.model_input_names[0]

      a_							=			BatchFeature({input_name: speech_inputs})

      a_							=			self.feat_extract_tester.seq_length_diff
      a_							=			self.feat_extract_tester.max_seq_length + pad_diff
      a_							=			self.feat_extract_tester.min_seq_length
      a_							=			self.feat_extract_tester.batch_size
      a_							=			self.feat_extract_tester.feature_size

      # test padding for List[int] + numpy
      a_							=			feat_extract.pad(__UpperCAmelCase    ,				padding=__UpperCAmelCase)
      a_							=			input_a[input_name]

      a_							=			feat_extract.pad(__UpperCAmelCase    ,				padding="longest")
      a_							=			input_a[input_name]

      a_							=			feat_extract.pad(__UpperCAmelCase    ,				padding="max_length"    ,				max_length=len(speech_inputs[-1]))
      a_							=			input_a[input_name]

      a_							=			feat_extract.pad(__UpperCAmelCase    ,				padding="longest"    ,				return_tensors="np")
      a_							=			input_a[input_name]

      # max_length parameter has to be provided when setting `padding="max_length"`
      with self.assertRaises(__UpperCAmelCase):
         feat_extract.pad(__UpperCAmelCase    ,				padding="max_length")[input_name]

      a_							=			feat_extract.pad(
          __UpperCAmelCase    ,				padding="max_length"    ,				max_length=__UpperCAmelCase    ,				return_tensors="np")
      a_							=			input_a[input_name]

      self.assertFalse(_inputs_have_equal_length(__UpperCAmelCase))
      self.assertTrue(_inputs_have_equal_length(__UpperCAmelCase))
      self.assertTrue(_inputs_have_equal_length(__UpperCAmelCase))
      self.assertTrue(_inputs_are_equal(__UpperCAmelCase    ,				__UpperCAmelCase))
      self.assertTrue(len(input_a[0]) == pad_min_length)
      self.assertTrue(len(input_a[1]) == pad_min_length + pad_diff)
      self.assertTrue(input_a.shape[:2] == (batch_size, len(input_a[0])))
      self.assertTrue(input_a.shape[:2] == (batch_size, pad_max_length))

      if feature_size > 1:
         self.assertTrue(input_a.shape[2] == input_a.shape[2] == feature_size)

      # test padding for `pad_to_multiple_of` for List[int] + numpy
      a_							=			feat_extract.pad(__UpperCAmelCase    ,				pad_to_multiple_of=10)
      a_							=			input_a[input_name]

      a_							=			feat_extract.pad(__UpperCAmelCase    ,				padding="longest"    ,				pad_to_multiple_of=10)
      a_							=			input_a[input_name]

      a_							=			feat_extract.pad(
          __UpperCAmelCase    ,				padding="max_length"    ,				pad_to_multiple_of=10    ,				max_length=__UpperCAmelCase)
      a_							=			input_a[input_name]

      a_							=			feat_extract.pad(
          __UpperCAmelCase    ,				padding="max_length"    ,				pad_to_multiple_of=10    ,				max_length=__UpperCAmelCase    ,				return_tensors="np"    ,				)
      a_							=			input_a[input_name]

      self.assertTrue(all(len(__UpperCAmelCase) % 10 == 0 for x in input_a))
      self.assertTrue(_inputs_are_equal(__UpperCAmelCase    ,				__UpperCAmelCase))

      a_							=			pad_max_length if pad_max_length % 10 == 0 else (pad_max_length // 10 + 1) * 10
      self.assertTrue(all(len(__UpperCAmelCase) == expected_mult_pad_length for x in input_a))
      self.assertEqual(input_a.shape[:2]    ,				(batch_size, expected_mult_pad_length))

      if feature_size > 1:
         self.assertTrue(input_a.shape[2] == feature_size)

      # Check padding value is correct
      a_							=			(np.ones(self.feat_extract_tester.feature_size) * feat_extract.padding_value).sum()
      self.assertTrue(
          abs(np.asarray(input_a[0])[pad_min_length:].sum() - padding_vector_sum * (pad_max_length - pad_min_length))
          < 1E-3)
      self.assertTrue(
          abs(
              np.asarray(input_a[1])[pad_min_length + pad_diff :].sum()
              - padding_vector_sum * (pad_max_length - pad_min_length - pad_diff))
          < 1E-3)
      self.assertTrue(
          abs(
              np.asarray(input_a[2])[pad_min_length + 2 * pad_diff :].sum()
              - padding_vector_sum * (pad_max_length - pad_min_length - 2 * pad_diff))
          < 1E-3)
      self.assertTrue(
          abs(input_a[0, pad_min_length:].sum() - padding_vector_sum * (pad_max_length - pad_min_length)) < 1E-3)
      self.assertTrue(
          abs(input_a[0, pad_min_length:].sum() - padding_vector_sum * (expected_mult_pad_length - pad_min_length))
          < 1E-3)







   def 					UpperCAmelCase__     (      self    ,				__UpperCAmelCase=False)					->List[Any]:







      def _inputs_have_equal_length(__UpperCAmelCase):
         a_							=			len(input[0])
         for input_slice in input[1:]:
            if len(__UpperCAmelCase) != length:
               return False
         return True

      def _inputs_are_equal(__UpperCAmelCase    ,				__UpperCAmelCase):
         if len(__UpperCAmelCase) != len(__UpperCAmelCase):
            return False

         for input_slice_a, input_slice_a in zip(__UpperCAmelCase    ,				__UpperCAmelCase):
            if not np.allclose(np.asarray(__UpperCAmelCase)    ,				np.asarray(__UpperCAmelCase)    ,				atol=1E-3):
               return False
         return True

      a_							=			self.feature_extraction_class(**self.feat_extract_dict)
      a_							=			self.feat_extract_tester.prepare_inputs_for_common(numpify=__UpperCAmelCase)
      a_							=			feat_extract.model_input_names[0]

      a_							=			BatchFeature({input_name: speech_inputs})

      # truncate to smallest
      a_							=			feat_extract.pad(
          __UpperCAmelCase    ,				padding="max_length"    ,				max_length=len(speech_inputs[0])    ,				truncation=__UpperCAmelCase)
      a_							=			input_a[input_name]

      a_							=			feat_extract.pad(__UpperCAmelCase    ,				padding="max_length"    ,				max_length=len(speech_inputs[0]))
      a_							=			input_a[input_name]

      self.assertTrue(_inputs_have_equal_length(__UpperCAmelCase))
      self.assertFalse(_inputs_have_equal_length(__UpperCAmelCase))

      # truncate to smallest with np
      a_							=			feat_extract.pad(
          __UpperCAmelCase    ,				padding="max_length"    ,				max_length=len(speech_inputs[0])    ,				return_tensors="np"    ,				truncation=__UpperCAmelCase    ,				)
      a_							=			input_a[input_name]

      a_							=			feat_extract.pad(
          __UpperCAmelCase    ,				padding="max_length"    ,				max_length=len(speech_inputs[0])    ,				return_tensors="np")
      a_							=			input_a[input_name]

      self.assertTrue(_inputs_have_equal_length(__UpperCAmelCase))
      self.assertTrue(input_a.shape[1] == len(speech_inputs[0]))

      # since truncation forces padding to be smaller than longest input
      # function can't return `np.ndarray`, but has to return list
      self.assertFalse(_inputs_have_equal_length(__UpperCAmelCase))

      # truncate to middle
      a_							=			feat_extract.pad(
          __UpperCAmelCase    ,				padding="max_length"    ,				max_length=len(speech_inputs[1])    ,				truncation=__UpperCAmelCase    ,				return_tensors="np"    ,				)
      a_							=			input_a[input_name]

      a_							=			feat_extract.pad(
          __UpperCAmelCase    ,				padding="max_length"    ,				max_length=len(speech_inputs[1])    ,				truncation=__UpperCAmelCase)
      a_							=			input_a[input_name]

      a_							=			feat_extract.pad(
          __UpperCAmelCase    ,				padding="max_length"    ,				max_length=len(speech_inputs[1])    ,				return_tensors="np")
      a_							=			input_a[input_name]

      self.assertTrue(input_a.shape[1] == len(speech_inputs[1]))
      self.assertTrue(_inputs_have_equal_length(__UpperCAmelCase))
      self.assertTrue(_inputs_have_equal_length(__UpperCAmelCase))
      self.assertTrue(_inputs_are_equal(__UpperCAmelCase    ,				__UpperCAmelCase))

      # since truncation forces padding to be smaller than longest input
      # function can't return `np.ndarray`, but has to return list
      self.assertFalse(_inputs_have_equal_length(__UpperCAmelCase))
      self.assertTrue(len(input_a[-1]) == len(speech_inputs[-1]))

      # padding has to be max_length when setting `truncation=True`
      with self.assertRaises(__UpperCAmelCase):
         feat_extract.pad(__UpperCAmelCase    ,				truncation=__UpperCAmelCase)[input_name]

      # padding has to be max_length when setting `truncation=True`
      with self.assertRaises(__UpperCAmelCase):
         feat_extract.pad(__UpperCAmelCase    ,				padding="longest"    ,				truncation=__UpperCAmelCase)[input_name]

      # padding has to be max_length when setting `truncation=True`
      with self.assertRaises(__UpperCAmelCase):
         feat_extract.pad(__UpperCAmelCase    ,				padding="longest"    ,				truncation=__UpperCAmelCase)[input_name]

      # max_length parameter has to be provided when setting `truncation=True` and padding="max_length"
      with self.assertRaises(__UpperCAmelCase):
         feat_extract.pad(__UpperCAmelCase    ,				padding="max_length"    ,				truncation=__UpperCAmelCase)[input_name]

      # test truncation for `pad_to_multiple_of` for List[int] + numpy
      a_							=			12
      a_							=			feat_extract.pad(
          __UpperCAmelCase    ,				padding="max_length"    ,				max_length=len(speech_inputs[0])    ,				pad_to_multiple_of=__UpperCAmelCase    ,				truncation=__UpperCAmelCase    ,				)
      a_							=			input_a[input_name]

      a_							=			feat_extract.pad(
          __UpperCAmelCase    ,				padding="max_length"    ,				max_length=len(speech_inputs[0])    ,				pad_to_multiple_of=__UpperCAmelCase    ,				)
      a_							=			input_a[input_name]

      # retrieve expected_length as multiple of pad_to_multiple_of
      a_							=			len(speech_inputs[0])
      if expected_length % pad_to_multiple_of != 0:
         a_							=			((len(speech_inputs[0]) // pad_to_multiple_of) + 1) * pad_to_multiple_of

      self.assertTrue(len(input_a[0]) == expected_length)
      self.assertTrue(_inputs_have_equal_length(__UpperCAmelCase))
      self.assertFalse(_inputs_have_equal_length(__UpperCAmelCase))







   def 					UpperCAmelCase__     (      self)					->Tuple:
      self._check_padding(numpify=__UpperCAmelCase)







   def 					UpperCAmelCase__     (      self)					->Any:
      self._check_padding(numpify=__UpperCAmelCase)







   def 					UpperCAmelCase__     (      self)					->str:
      self._check_truncation(numpify=__UpperCAmelCase)







   def 					UpperCAmelCase__     (      self)					->int:
      self._check_truncation(numpify=__UpperCAmelCase)







   @require_torch
   def 					UpperCAmelCase__     (      self)					->List[Any]:
      a_							=			self.feature_extraction_class(**self.feat_extract_dict)
      a_							=			self.feat_extract_tester.prepare_inputs_for_common()
      a_							=			feat_extract.model_input_names[0]

      a_							=			BatchFeature({input_name: speech_inputs})

      a_							=			feat_extract.pad(__UpperCAmelCase    ,				padding="longest"    ,				return_tensors="np")[input_name]
      a_							=			feat_extract.pad(__UpperCAmelCase    ,				padding="longest"    ,				return_tensors="pt")[input_name]

      self.assertTrue(abs(input_np.astype(np.floataa).sum() - input_pt.numpy().astype(np.floataa).sum()) < 1E-2)







   @require_tf
   def 					UpperCAmelCase__     (      self)					->Dict:
      a_							=			self.feature_extraction_class(**self.feat_extract_dict)
      a_							=			self.feat_extract_tester.prepare_inputs_for_common()
      a_							=			feat_extract.model_input_names[0]

      a_							=			BatchFeature({input_name: speech_inputs})

      a_							=			feat_extract.pad(__UpperCAmelCase    ,				padding="longest"    ,				return_tensors="np")[input_name]
      a_							=			feat_extract.pad(__UpperCAmelCase    ,				padding="longest"    ,				return_tensors="tf")[input_name]

      self.assertTrue(abs(input_np.astype(np.floataa).sum() - input_tf.numpy().astype(np.floataa).sum()) < 1E-2)







   def 					UpperCAmelCase__     (      self)					->str:
      a_							=			self.feat_extract_dict
      a_							=			True
      a_							=			self.feature_extraction_class(**__UpperCAmelCase)
      a_							=			self.feat_extract_tester.prepare_inputs_for_common()
      a_							=			[len(__UpperCAmelCase) for x in speech_inputs]
      a_							=			feat_extract.model_input_names[0]

      a_							=			BatchFeature({input_name: speech_inputs})

      a_							=			feat_extract.pad(__UpperCAmelCase    ,				padding="longest"    ,				return_tensors="np")
      self.assertIn("attention_mask"    ,				__UpperCAmelCase)
      self.assertListEqual(list(processed.attention_mask.shape)    ,				list(processed[input_name].shape[:2]))
      self.assertListEqual(processed.attention_mask.sum(-1).tolist()    ,				__UpperCAmelCase)







   def 					UpperCAmelCase__     (      self)					->List[Any]:
      a_							=			self.feat_extract_dict
      a_							=			True
      a_							=			self.feature_extraction_class(**__UpperCAmelCase)
      a_							=			self.feat_extract_tester.prepare_inputs_for_common()
      a_							=			[len(__UpperCAmelCase) for x in speech_inputs]
      a_							=			feat_extract.model_input_names[0]

      a_							=			BatchFeature({input_name: speech_inputs})
      a_							=			min(__UpperCAmelCase)

      a_							=			feat_extract.pad(
          __UpperCAmelCase    ,				padding="max_length"    ,				max_length=__UpperCAmelCase    ,				truncation=__UpperCAmelCase    ,				return_tensors="np")
      self.assertIn("attention_mask"    ,				__UpperCAmelCase)
      self.assertListEqual(
          list(processed_pad.attention_mask.shape)    ,				[processed_pad[input_name].shape[0], max_length])
      self.assertListEqual(
          processed_pad.attention_mask[:, :max_length].sum(-1).tolist()    ,				[max_length for x in speech_inputs])

import argparse
import re
from typing import Dict

import torch
from datasets import Audio, Dataset, load_dataset, load_metric

from transformers import AutoFeatureExtractor, pipeline
def  lowerCAmelCase__			(  SCREAMING_SNAKE_CASE_       ,							SCREAMING_SNAKE_CASE_     )				->		List[str]:
			lowerCAmelCase__      :      Optional[Any]         =		args.log_outputs
			lowerCAmelCase__      :      Union[str, Any]         =		'_'.join(args.dataset.split('/'     ) + [args.config, args.split]     )

			# load metric
			lowerCAmelCase__      :      Dict         =		load_metric('wer'     )
			lowerCAmelCase__      :      Tuple         =		load_metric('cer'     )

			# compute metrics
			lowerCAmelCase__      :      Dict         =		wer.compute(references=result['target']       ,							predictions=result['prediction']     )
			lowerCAmelCase__      :      int         =		cer.compute(references=result['target']       ,							predictions=result['prediction']     )

			# print & log results
			lowerCAmelCase__      :      Optional[int]         =		F'''WER: {wer_result}\nCER: {cer_result}'''
			print(SCREAMING_SNAKE_CASE_     )

			with open(F'''{dataset_id}_eval_results.txt'''       ,							'w'     ) as f:
						f.write(SCREAMING_SNAKE_CASE_     )

			# log all results in text file. Possibly interesting for analysis
			if log_outputs is not None:
						lowerCAmelCase__      :      List[str]         =		F'''log_{dataset_id}_predictions.txt'''
						lowerCAmelCase__      :      Union[str, Any]         =		F'''log_{dataset_id}_targets.txt'''

						with open(SCREAMING_SNAKE_CASE_       ,							'w'     ) as p, open(SCREAMING_SNAKE_CASE_       ,							'w'     ) as t:
									# mapping function to write output
									def write_to_file(SCREAMING_SNAKE_CASE_       ,							SCREAMING_SNAKE_CASE_     ):
												p.write(F'''{i}''' + '\n'     )
												p.write(batch['prediction'] + '\n'     )
												t.write(F'''{i}''' + '\n'     )
												t.write(batch['target'] + '\n'     )

									result.map(SCREAMING_SNAKE_CASE_       ,							with_indices=SCREAMING_SNAKE_CASE_     )
def  lowerCAmelCase__			(  SCREAMING_SNAKE_CASE_     )				->		str:
			lowerCAmelCase__      :      List[str]         =		'[,?.!\-\;\:"“%‘”�—’…–]'  # noqa: W605 IMPORTANT: this should correspond to the chars that were ignored during training

			lowerCAmelCase__      :      Union[str, Any]         =		re.sub(SCREAMING_SNAKE_CASE_       ,							''       ,							text.lower()     )

			# In addition, we can normalize the target text, e.g. removing new lines characters etc...
			# note that order is important here!
			lowerCAmelCase__      :      List[Any]         =		['\n\n', '\n', '   ', '  ']

			for t in token_sequences_to_ignore:
						lowerCAmelCase__      :      Optional[int]         =		' '.join(text.split(SCREAMING_SNAKE_CASE_     )     )

			return text
def  lowerCAmelCase__			(  SCREAMING_SNAKE_CASE_     )				->		List[Any]:
			# load dataset
			lowerCAmelCase__      :      Tuple         =		load_dataset(args.dataset       ,							args.config       ,							split=args.split       ,							use_auth_token=SCREAMING_SNAKE_CASE_     )

			# for testing: only process the first two examples as a test
			# dataset = dataset.select(range(10))

			# load processor
			lowerCAmelCase__      :      List[Any]         =		AutoFeatureExtractor.from_pretrained(args.model_id     )
			lowerCAmelCase__      :      Union[str, Any]         =		feature_extractor.sampling_rate

			# resample audio
			lowerCAmelCase__      :      Union[str, Any]         =		dataset.cast_column('audio'       ,							Audio(sampling_rate=SCREAMING_SNAKE_CASE_     )     )

			# load eval pipeline
			if args.device is None:
						lowerCAmelCase__      :      List[Any]         =		0 if torch.cuda.is_available() else -1
			lowerCAmelCase__      :      List[Any]         =		pipeline('automatic-speech-recognition'       ,							model=args.model_id       ,							device=args.device     )

			# map function to decode audio
			def map_to_pred(SCREAMING_SNAKE_CASE_     ):
						lowerCAmelCase__      :      Optional[int]         =		asr(
						    batch['audio']['array']       ,							chunk_length_s=args.chunk_length_s       ,							stride_length_s=args.stride_length_s     )

						lowerCAmelCase__      :      int         =		prediction['text']
						lowerCAmelCase__      :      Optional[int]         =		normalize_text(batch['sentence']     )
						return batch

			# run inference on all examples
			lowerCAmelCase__      :      Dict         =		dataset.map(SCREAMING_SNAKE_CASE_       ,							remove_columns=dataset.column_names     )

			# compute and log_results
			# do not change function below
			log_results(SCREAMING_SNAKE_CASE_       ,							SCREAMING_SNAKE_CASE_     )


if __name__ == "__main__":
					lowerCamelCase__          =		argparse.ArgumentParser()

					parser.add_argument(
					    """--model_id""", type=str, required=True, help="""Model identifier. Should be loadable with 🤗 Transformers"""
					)
					parser.add_argument(
					    """--dataset""",
					    type=str,
					    required=True,
					    help="""Dataset name to evaluate the `model_id`. Should be loadable with 🤗 Datasets""",
					)
					parser.add_argument(
					    """--config""", type=str, required=True, help="""Config of the dataset. *E.g.* `'en'`  for Common Voice"""
					)
					parser.add_argument("""--split""", type=str, required=True, help="""Split of the dataset. *E.g.* `'test'`""")
					parser.add_argument(
					    """--chunk_length_s""", type=float, default=None, help="""Chunk length in seconds. Defaults to 5 seconds."""
					)
					parser.add_argument(
					    """--stride_length_s""", type=float, default=None, help="""Stride of the audio chunks. Defaults to 1 second."""
					)
					parser.add_argument(
					    """--log_outputs""", action="""store_true""", help="""If defined, write outputs to log file for analysis."""
					)
					parser.add_argument(
					    """--device""",
					    type=int,
					    default=None,
					    help="""The device to run the pipeline on. -1 for CPU (default), 0 for the first GPU and so on.""",
					)
					lowerCamelCase__          =		parser.parse_args()

					main(args)