"""simple docstring"""




from manim import *
class 						__A							( SCREAMING_SNAKE_CASE_		):






     def     __A  (		self  ):
       _lowerCAmelCase						:       str  			=     Rectangle(height=0.5				,     width=0.5  )
       _lowerCAmelCase						:       List[Any]  			=     Rectangle(height=0.4_6				,     width=0.4_6  ).set_stroke(width=0  )

       _lowerCAmelCase						:       Tuple  			=     Rectangle(height=0.2_5				,     width=0.2_5  )

       _lowerCAmelCase						:       Optional[int]  			=     [mem.copy() for i in range(6  )]
       _lowerCAmelCase						:       Optional[Any]  			=     [mem.copy() for i in range(6  )]
       _lowerCAmelCase						:       List[str]  			=     VGroup(*a__  ).arrange(a__				,     buff=0  )
       _lowerCAmelCase						:       Dict  			=     VGroup(*a__  ).arrange(a__				,     buff=0  )
       _lowerCAmelCase						:       str  			=     VGroup(a__				,     a__  ).arrange(a__				,     buff=0  )
       _lowerCAmelCase						:       str  			=     Text("""CPU"""				,     font_size=24  )
       _lowerCAmelCase						:       str  			=     Group(a__				,     a__  ).arrange(a__				,     buff=0.5				,     aligned_edge=a__  )
       cpu.move_to([-2.5, -0.5, 0]  )
       self.add(a__  )

       _lowerCAmelCase						:       Union[str, Any]  			=     [mem.copy() for i in range(4  )]
       _lowerCAmelCase						:       str  			=     VGroup(*a__  ).arrange(a__				,     buff=0  )
       _lowerCAmelCase						:       str  			=     Text("""GPU"""				,     font_size=24  )
       _lowerCAmelCase						:       str  			=     Group(a__				,     a__  ).arrange(a__				,     buff=0.5				,     aligned_edge=a__  )
       gpu.move_to([-1, -1, 0]  )
       self.add(a__  )

       _lowerCAmelCase						:       Optional[Any]  			=     [mem.copy() for i in range(6  )]
       _lowerCAmelCase						:       Optional[Any]  			=     VGroup(*a__  ).arrange(a__				,     buff=0  )

       _lowerCAmelCase						:       int  			=     Text("""Model"""				,     font_size=24  )
       _lowerCAmelCase						:       int  			=     Group(a__				,     a__  ).arrange(a__				,     buff=0.5				,     aligned_edge=a__  )
       model.move_to([3, -1.0, 0]  )
       self.add(a__  )

       _lowerCAmelCase						:       Optional[Any]  			=     []
       _lowerCAmelCase						:       str  			=     []

       for i, rect in enumerate(a__  ):
         _lowerCAmelCase						:       int  			=     fill.copy().set_fill(a__				,     opacity=0.8  )
         target.move_to(a__  )
         model_arr.append(a__  )

         _lowerCAmelCase						:       Dict  			=     Rectangle(height=0.4_6				,     width=0.4_6  ).set_stroke(width=0.0  ).set_fill(a__				,     opacity=0.8  )
         cpu_target.move_to(cpu_left_col_base[i]  )
         model_cpu_arr.append(a__  )

       self.add(*a__				,     *a__  )

       _lowerCAmelCase						:       str  			=     [meta_mem.copy() for i in range(6  )]
       _lowerCAmelCase						:       Dict  			=     [meta_mem.copy() for i in range(6  )]
       _lowerCAmelCase						:       Optional[int]  			=     VGroup(*a__  ).arrange(a__				,     buff=0  )
       _lowerCAmelCase						:       Optional[Any]  			=     VGroup(*a__  ).arrange(a__				,     buff=0  )
       _lowerCAmelCase						:       int  			=     VGroup(a__				,     a__  ).arrange(a__				,     buff=0  )
       _lowerCAmelCase						:       Dict  			=     Text("""Disk"""				,     font_size=24  )
       _lowerCAmelCase						:       Optional[int]  			=     Group(a__				,     a__  ).arrange(a__				,     buff=0.5				,     aligned_edge=a__  )
       disk.move_to([-4, -1.2_5, 0]  )
       self.add(a__				,     a__  )

       _lowerCAmelCase						:       str  			=     Square(side_length=2.2  )
       key.move_to([-5, 2, 0]  )

       _lowerCAmelCase						:       Dict  			=     MarkupText(
           F"<b>Key:</b>\n\n<span fgcolor='{YELLOW}'>●</span> Empty Model"				,     font_size=18				,     )

       key_text.move_to([-5, 2.4, 0]  )

       self.add(a__				,     a__  )

       _lowerCAmelCase						:       List[str]  			=     MarkupText(
           F"<span fgcolor='{BLUE}'>●</span> Checkpoint"				,     font_size=18				,     )

       blue_text.next_to(a__				,     DOWN * 2.4				,     aligned_edge=key_text.get_left()  )
       self.add(a__  )

       _lowerCAmelCase						:       List[str]  			=     MarkupText(
           F"Now watch as an input is passed through the model\nand how the memory is utilized and handled."				,     font_size=24				,     )
       step_a.move_to([2, 2, 0]  )

       self.play(Write(a__  )  )

       _lowerCAmelCase						:       Union[str, Any]  			=     Square(0.3  )
       input.set_fill(a__				,     opacity=1.0  )
       input.set_stroke(width=0.0  )
       input.next_to(model_base[0]				,     a__				,     buff=0.5  )

       self.play(Write(a__  )  )

       input.generate_target()
       input.target.next_to(model_arr[0]				,     direction=a__				,     buff=0.0_2  )
       self.play(MoveToTarget(a__  )  )

       self.play(FadeOut(a__  )  )

       _lowerCAmelCase						:       Dict  			=     Arrow(start=a__				,     end=a__				,     color=a__				,     buff=0.5  )
       a.next_to(model_arr[0].get_left()				,     a__				,     buff=0.2  )

       model_cpu_arr[0].generate_target()
       model_cpu_arr[0].target.move_to(gpu_rect[0]  )

       _lowerCAmelCase						:       Optional[Any]  			=     MarkupText(
           F"As the input reaches a layer, the hook triggers\nand weights are moved from the CPU\nto the GPU and back."				,     font_size=24				,     )
       step_a.move_to([2, 2, 0]  )

       self.play(Write(a__				,     run_time=3  )  )

       _lowerCAmelCase						:       Optional[int]  			=     {"""run_time""": 1, """fade_in""": True, """fade_out""": True, """buff""": 0.0_2}

       self.play(
           Write(a__  )				,     Circumscribe(model_arr[0]				,     color=a__				,     **a__  )				,     Circumscribe(model_cpu_arr[0]				,     color=a__				,     **a__  )				,     Circumscribe(gpu_rect[0]				,     color=a__				,     **a__  )				,     )
       self.play(MoveToTarget(model_cpu_arr[0]  )  )

       _lowerCAmelCase						:       Any  			=     a.copy()
       for i in range(6  ):
         a_c.next_to(model_arr[i].get_right() + 0.0_2				,     a__				,     buff=0.2  )

         input.generate_target()
         input.target.move_to(model_arr[i].get_right() + 0.0_2  )

         _lowerCAmelCase						:       Union[str, Any]  			=     AnimationGroup(
             FadeOut(a__				,     run_time=0.5  )				,     MoveToTarget(a__				,     run_time=0.5  )				,     FadeIn(a__				,     run_time=0.5  )				,     lag_ratio=0.2  )

         self.play(a__  )

         model_cpu_arr[i].generate_target()
         model_cpu_arr[i].target.move_to(cpu_left_col_base[i]  )

         if i < 5:
           model_cpu_arr[i + 1].generate_target()
           model_cpu_arr[i + 1].target.move_to(gpu_rect[0]  )
           if i >= 1:
             _lowerCAmelCase						:       int  			=     0.7

           self.play(
               Circumscribe(model_arr[i]				,     **a__  )				,     Circumscribe(cpu_left_col_base[i]				,     **a__  )				,     Circumscribe(cpu_left_col_base[i + 1]				,     color=a__				,     **a__  )				,     Circumscribe(gpu_rect[0]				,     color=a__				,     **a__  )				,     Circumscribe(model_arr[i + 1]				,     color=a__				,     **a__  )				,     )
           if i < 1:
             self.play(
                 MoveToTarget(model_cpu_arr[i]  )				,     MoveToTarget(model_cpu_arr[i + 1]  )				,     )
           else:
             self.play(
                 MoveToTarget(model_cpu_arr[i]				,     run_time=0.7  )				,     MoveToTarget(model_cpu_arr[i + 1]				,     run_time=0.7  )				,     )
         else:
           model_cpu_arr[i].generate_target()
           model_cpu_arr[i].target.move_to(cpu_left_col_base[-1]  )
           input.generate_target()
           input.target.next_to(model_arr[-1].get_right()				,     RIGHT + 0.0_2				,     buff=0.2  )

           self.play(
               Circumscribe(model_arr[-1]				,     color=a__				,     **a__  )				,     Circumscribe(cpu_left_col_base[-1]				,     color=a__				,     **a__  )				,     Circumscribe(gpu_rect[0]				,     color=a__				,     **a__  )				,     )

           self.play(MoveToTarget(model_cpu_arr[i]  )  )

         _lowerCAmelCase						:       Any  			=     a_c
         _lowerCAmelCase						:       Any  			=     a_c.copy()

       input.generate_target()
       input.target.next_to(model_base[-1]				,     RIGHT + 0.0_2				,     buff=0.5  )
       self.play(
           FadeOut(a__  )				,     FadeOut(a__				,     run_time=0.5  )				,     )

       _lowerCAmelCase						:       List[str]  			=     MarkupText(F"Inference on a model too large for GPU memory\nis successfully completed."				,     font_size=24  )
       step_a.move_to([2, 2, 0]  )

       self.play(Write(a__				,     run_time=3  )				,     MoveToTarget(a__  )  )

       self.wait()





'''simple docstring'''




import copy
from typing import Any, Dict, List, Optional, Union

import numpy as np

from ...audio_utils import mel_filter_bank, spectrogram, window_function
from ...feature_extraction_sequence_utils import SequenceFeatureExtractor
from ...feature_extraction_utils import BatchFeature
from ...utils import TensorType, logging


__lowercase          =  logging.get_logger(__name__)






class 				a__(					lowerCAmelCase__	):


			'''simple docstring'''






			UpperCAmelCase_			:     Union[str, Any]      =       ['''input_features''']



			def __init__(   self       ,    __lowerCAmelCase=80       ,    __lowerCAmelCase=16000       ,    __lowerCAmelCase=160       ,    __lowerCAmelCase=30       ,    __lowerCAmelCase=400       ,    __lowerCAmelCase=0.0       ,    __lowerCAmelCase=False       ,    **__lowerCAmelCase       ,    ):




					"""simple docstring"""


					super().__init__(
					    feature_size=__lowerCAmelCase       ,    sampling_rate=__lowerCAmelCase       ,    padding_value=__lowerCAmelCase       ,    return_attention_mask=__lowerCAmelCase       ,    **__lowerCAmelCase       ,    )
					lowerCAmelCase   					=  n_fft
					lowerCAmelCase   					=  hop_length
					lowerCAmelCase   					=  chunk_length
					lowerCAmelCase   					=  chunk_length * sampling_rate
					lowerCAmelCase   					=  self.n_samples // hop_length
					lowerCAmelCase   					=  sampling_rate
					lowerCAmelCase   					=  mel_filter_bank(
					    num_frequency_bins=1 + n_fft // 2       ,    num_mel_filters=__lowerCAmelCase       ,    min_frequency=0.0       ,    max_frequency=8000.0       ,    sampling_rate=__lowerCAmelCase       ,    norm="""slaney"""       ,    mel_scale="""slaney"""       ,    )



			def 							a_       (   self       ,    __lowerCAmelCase):




					"""simple docstring"""


					lowerCAmelCase   					=  spectrogram(
					    __lowerCAmelCase       ,    window_function(self.n_fft       ,    """hann""")       ,    frame_length=self.n_fft       ,    hop_length=self.hop_length       ,    power=2.0       ,    mel_filters=self.mel_filters       ,    log_mel="""log10"""       ,    )
					lowerCAmelCase   					=  log_spec[:, :-1]
					lowerCAmelCase   					=  np.maximum(__lowerCAmelCase       ,    log_spec.max() - 8.0)
					lowerCAmelCase   					=  (log_spec + 4.0) / 4.0
					return log_spec



			@staticmethod
			# Copied from transformers.models.wav2vec2.feature_extraction_wav2vec2.Wav2Vec2FeatureExtractor.zero_mean_unit_var_norm
			def 							a_       (   __lowerCAmelCase       ,    __lowerCAmelCase       ,    __lowerCAmelCase = 0.0):




					"""simple docstring"""


					if attention_mask is not None:
							lowerCAmelCase   					=  np.array(__lowerCAmelCase       ,    np.intaa)
							lowerCAmelCase   					=  []

							for vector, length in zip(__lowerCAmelCase       ,    attention_mask.sum(-1)):
									lowerCAmelCase   					=  (vector - vector[:length].mean()) / np.sqrt(vector[:length].var() + 1E-7)
									if length < normed_slice.shape[0]:
											lowerCAmelCase   					=  padding_value

									normed_input_values.append(__lowerCAmelCase)
					else:
							lowerCAmelCase   					=  [(x - x.mean()) / np.sqrt(x.var() + 1E-7) for x in input_values]

					return normed_input_values



			def __call__(   self       ,    __lowerCAmelCase       ,    __lowerCAmelCase = True       ,    __lowerCAmelCase = None       ,    __lowerCAmelCase = None       ,    __lowerCAmelCase = None       ,    __lowerCAmelCase = "max_length"       ,    __lowerCAmelCase = None       ,    __lowerCAmelCase = None       ,    __lowerCAmelCase = None       ,    **__lowerCAmelCase       ,    ):




					"""simple docstring"""


					if sampling_rate is not None:
							if sampling_rate != self.sampling_rate:
									raise ValueError(
									    f"The model corresponding to this feature extractor: {self.__class__.__name__} was trained using a"
									    f" sampling rate of {self.sampling_rate}. Please make sure that the provided `raw_speech` input"
									    f" was sampled with {self.sampling_rate} and not {sampling_rate}.")
					else:
							logger.warning(
							    """It is strongly recommended to pass the `sampling_rate` argument to this function. """
							    """Failing to do so can result in silent errors that might be hard to debug.""")

					lowerCAmelCase   					=  isinstance(__lowerCAmelCase       ,    np.ndarray) and len(raw_speech.shape) > 1
					if is_batched_numpy and len(raw_speech.shape) > 2:
							raise ValueError(f"Only mono-channel audio is supported for input to {self}")
					lowerCAmelCase   					=  is_batched_numpy or (
					    isinstance(__lowerCAmelCase       ,    (list, tuple)) and (isinstance(raw_speech[0]       ,    (np.ndarray, tuple, list)))
					)

					if is_batched:
							lowerCAmelCase   					=  [np.asarray([speech]       ,    dtype=np.floataa).T for speech in raw_speech]
					elif not is_batched and not isinstance(__lowerCAmelCase       ,    np.ndarray):
							lowerCAmelCase   					=  np.asarray(__lowerCAmelCase       ,    dtype=np.floataa)
					elif isinstance(__lowerCAmelCase       ,    np.ndarray) and raw_speech.dtype is np.dtype(np.floataa):
							lowerCAmelCase   					=  raw_speech.astype(np.floataa)

					# always return batch
					if not is_batched:
							lowerCAmelCase   					=  [np.asarray([raw_speech]).T]

					lowerCAmelCase   					=  BatchFeature({"""input_features""": raw_speech})

					# convert into correct format for padding

					lowerCAmelCase   					=  self.pad(
					    __lowerCAmelCase       ,    padding=__lowerCAmelCase       ,    max_length=max_length if max_length else self.n_samples       ,    truncation=__lowerCAmelCase       ,    pad_to_multiple_of=__lowerCAmelCase       ,    return_attention_mask=return_attention_mask or do_normalize       ,    )

					# zero-mean and unit-variance normalization
					if do_normalize:
							lowerCAmelCase   					=  self.zero_mean_unit_var_norm(
							    padded_inputs["""input_features"""]       ,    attention_mask=padded_inputs["""attention_mask"""]       ,    padding_value=self.padding_value       ,    )
							lowerCAmelCase   					=  np.stack(padded_inputs["""input_features"""]       ,    axis=0)

					# make sure list is in array format
					lowerCAmelCase   					=  padded_inputs.get("""input_features""").transpose(2       ,    0       ,    1)

					lowerCAmelCase   					=  [self._np_extract_fbank_features(__lowerCAmelCase) for waveform in input_features[0]]

					if isinstance(input_features[0]       ,    __lowerCAmelCase):
							lowerCAmelCase   					=  [np.asarray(__lowerCAmelCase       ,    dtype=np.floataa) for feature in input_features]
					else:
							lowerCAmelCase   					=  input_features

					if return_attention_mask:
							# rescale from sample (48000) to feature (3000)
							lowerCAmelCase   					=  padded_inputs["""attention_mask"""][:, :: self.hop_length]

					if return_tensors is not None:
							lowerCAmelCase   					=  padded_inputs.convert_to_tensors(__lowerCAmelCase)

					return padded_inputs







			def 							a_       (   self):




					"""simple docstring"""


					lowerCAmelCase   					=  copy.deepcopy(self.__dict__)
					lowerCAmelCase   					=  self.__class__.__name__
					if "mel_filters" in output:
							del output["mel_filters"]
					return output




