code: 
  
  
  from typing import Dict, List, Optional, Union
  
  import numpy as np
  
  from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
  from ...image_transforms import normalize, rescale, resize, to_channel_dimension_format
  from ...image_utils import (
      IMAGENET_STANDARD_MEAN,
      IMAGENET_STANDARD_STD,
      ChannelDimension,
      ImageInput,
      PILImageResampling,
      make_list_of_images,
      to_numpy_array,
      valid_images,
  )
  from ...utils import TensorType, logging
  
  
  _SCREAMING_SNAKE_CASE    :				Union[str, Any]       =					logging.get_logger(__name__)
  
  class 						A__      (					snake_case__			):
  
  
  
  
  
  
  
      """simple docstring"""
  
      __magic_name__    						=	['pixel_values']
      def __init__( self    ,      __snake_case = True    ,      __snake_case = None    ,      __snake_case = PILImageResampling.BILINEAR    ,      __snake_case = True    ,      __snake_case = 1 / 2_5_5    ,      __snake_case = True    ,      __snake_case = None    ,      __snake_case = None    ,      **__snake_case    ,      ):
           super().__init__(**__snake_case					)
           snake_case					=       size if size is not None else {'''height''': 2_2_4, '''width''': 2_2_4}
           snake_case					=       get_size_dict(__snake_case					)
           snake_case					=       do_resize
           snake_case					=       do_rescale
           snake_case					=       do_normalize
           snake_case					=       size
           snake_case					=       resample
           snake_case					=       rescale_factor
           snake_case					=       image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN
           snake_case					=       image_std if image_std is not None else IMAGENET_STANDARD_STD
      def 	a_    ( self    ,      __snake_case    ,      __snake_case    ,      __snake_case = PILImageResampling.BILINEAR    ,      __snake_case = None    ,      **__snake_case    ,      ):
           snake_case					=       get_size_dict(__snake_case					)
           if "height" not in size or "width" not in size:
                raise ValueError(F'''The `size` dictionary must contain the keys `height` and `width`. Got {size.keys()}'''					)
           return resize(
               __snake_case    ,      size=(size['''height'''], size['''width'''])    ,      resample=__snake_case    ,      data_format=__snake_case    ,      **__snake_case					)
      def 	a_    ( self    ,      __snake_case    ,      __snake_case    ,      __snake_case = None    ,      **__snake_case					):
           return rescale(__snake_case    ,      scale=__snake_case    ,      data_format=__snake_case    ,      **__snake_case					)
      def 	a_    ( self    ,      __snake_case    ,      __snake_case    ,      __snake_case    ,      __snake_case = None    ,      **__snake_case    ,      ):
           return normalize(__snake_case    ,      mean=__snake_case    ,      std=__snake_case    ,      data_format=__snake_case    ,      **__snake_case					)
  
  
  
  
      def 	a_    ( self    ,      __snake_case    ,      __snake_case = None    ,      __snake_case = None    ,      __snake_case = None    ,      __snake_case = None    ,      __snake_case = None    ,      __snake_case = None    ,      __snake_case = None    ,      __snake_case = None    ,      __snake_case = None    ,      __snake_case = ChannelDimension.FIRST    ,      **__snake_case    ,      ):
           snake_case					=       do_resize if do_resize is not None else self.do_resize
           snake_case					=       do_rescale if do_rescale is not None else self.do_rescale
           snake_case					=       do_normalize if do_normalize is not None else self.do_normalize
           snake_case					=       resample if resample is not None else self.resample
           snake_case					=       rescale_factor if rescale_factor is not None else self.rescale_factor
           snake_case					=       image_mean if image_mean is not None else self.image_mean
           snake_case					=       image_std if image_std is not None else self.image_std
  
           snake_case					=       size if size is not None else self.size
           snake_case					=       get_size_dict(__snake_case					)
  
           snake_case					=       make_list_of_images(__snake_case					)
  
           if not valid_images(__snake_case					):
                raise ValueError(
                    '''Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, '''
                    '''torch.Tensor, tf.Tensor or jax.ndarray.'''					)
  
           if do_resize and size is None:
                raise ValueError('''Size must be specified if do_resize is True.'''					)
  
           if do_rescale and rescale_factor is None:
                raise ValueError('''Rescale factor must be specified if do_rescale is True.'''					)
  
           # All transformations expect numpy arrays.
           snake_case					=       [to_numpy_array(__snake_case					) for image in images]
  
           if do_resize:
                snake_case					=       [self.resize(image=__snake_case    ,      size=__snake_case    ,      resample=__snake_case					) for image in images]
  
           if do_rescale:
                snake_case					=       [self.rescale(image=__snake_case    ,      scale=__snake_case					) for image in images]
  
           if do_normalize:
                snake_case					=       [self.normalize(image=__snake_case    ,      mean=__snake_case    ,      std=__snake_case					) for image in images]
  
           snake_case					=       [to_channel_dimension_format(__snake_case    ,      __snake_case					) for image in images]
  
           snake_case					=       {'''pixel_values''': images}
           return BatchFeature(data=__snake_case    ,      tensor_type=__snake_case					)
  
  
  
  
  
  
  
style_context: 
  
  
  from manim import *
  
  class 						A__      (					snake_case__			):
  
  
  
  
  
  
  
      """simple docstring"""
  
      def 	a_    ( self					):
           snake_case					=       Rectangle(height=0.5    ,      width=0.5					)
           snake_case					=       Rectangle(height=0.46    ,      width=0.46					).set_stroke(width=0					)
           snake_case					=       Rectangle(height=0.25    ,      width=0.25					)
  
           snake_case					=       [mem.copy() for i in range(6					)]
           snake_case					=       [mem.copy() for i in range(6					)]
           snake_case					=       VGroup(*__snake_case					).arrange(__snake_case    ,      buff=0					)
           snake_case					=       VGroup(*__snake_case					).arrange(__snake_case    ,      buff=0					)
           snake_case					=       VGroup(__snake_case    ,      __snake_case					).arrange(__snake_case    ,      buff=0					)
           snake_case					=       Text('''CPU'''    ,      font_size=2_4					)
           snake_case					=       Group(__snake_case    ,      __snake_case					).arrange(__snake_case    ,      buff=0.5    ,      aligned_edge=__snake_case					)
           cpu.move_to([-2.5, -0.5, 0]					)
           self.add(__snake_case					)
  
           snake_case					=       [mem.copy() for i in range(4					)]
           snake_case					=       VGroup(*__snake_case					).arrange(__snake_case    ,      buff=0					)
           snake_case					=       Text('''GPU'''    ,      font_size=2_4					)
           snake_case					=       Group(__snake_case    ,      __snake_case					).arrange(__snake_case    ,      buff=0.5    ,      aligned_edge=__snake_case					)
           gpu.move_to([-1, -1, 0]					)
           self.add(__snake_case					)
  
           snake_case					=       [mem.copy() for i in range(6					)]
           snake_case					=       VGroup(*__snake_case					).arrange(__snake_case    ,      buff=0					)
  
           snake_case					=       Text('''Model'''    ,      font_size=2_4					)
           snake_case					=       Group(__snake_case    ,      __snake_case					).arrange(__snake_case    ,      buff=0.5    ,      aligned_edge=__snake_case					)
           model.move_to([3, -1.0, 0]					)
           self.add(__snake_case					)
  
           snake_case					=       []
           snake_case					=       []
  
           for i, rect in enumerate(__snake_case					):
                rect.set_stroke(__snake_case					)
  
                snake_case					=       Rectangle(height=0.46 / 4    ,      width=0.46 / 3					).set_stroke(width=0.0					).set_fill(__snake_case    ,      opacity=0.7					)
  
                if i == 0:
                     cpu_target.next_to(cpu_left_col_base[0].get_corner(DOWN + LEFT					)    ,      buff=0.02    ,      direction=__snake_case					)
                     cpu_target.set_x(cpu_target.get_x() + 0.1					)
                elif i == 3:
                     cpu_target.next_to(model_cpu_arr[0]    ,      direction=__snake_case    ,      buff=0.0					)
                else:
                     cpu_target.next_to(model_cpu_arr[i - 1]    ,      direction=__snake_case    ,      buff=0.0					)
                self.add(__snake_case					)
                model_cpu_arr.append(__snake_case					)
  
           self.add(*__snake_case    ,      *__snake_case					)
  
           snake_case					=       [meta_mem.copy() for i in range(6					)]
           snake_case					=       [meta_mem.copy() for i in range(6					)]
           snake_case					=       VGroup(*__snake_case					).arrange(__snake_case    ,      buff=0					)
           snake_case					=       VGroup(*__snake_case					).arrange(__snake_case    ,      buff=0					)
           snake_case					=       VGroup(__snake_case    ,      __snake_case					).arrange(__snake_case    ,      buff=0					)
           snake_case					=       Text('''Disk'''    ,      font_size=2_4					)
           snake_case					=       Group(__snake_case    ,      __snake_case					).arrange(__snake_case    ,      buff=0.5    ,      aligned_edge=__snake_case					)
           disk.move_to([-4.0, -1.25, 0]					)
           self.add(__snake_case    ,      __snake_case					)
  
           snake_case					=       []
  
           for i in range(6					):
                snake_case					=       fill.copy().set_fill(__snake_case    ,      opacity=0.8					)
                target.move_to(disk_left_col_base[i]					).scale(0.5					)
                cpu_disk_arr.append(__snake_case					)
  
           self.add(*__snake_case					)
  
           snake_case					=       Square(side_length=2.2					)
           key.move_to([-5, 2, 0]					)
  
           snake_case					=       MarkupText(
               F'''<b>Key:</b>\n\n<span fgcolor=\'{YELLOW}\'>●</span> Empty Model'''    ,      font_size=1_8    ,      )
  
           key_text.move_to([-5, 2.4, 0]					)
  
           self.add(__snake_case    ,      __snake_case					)
  
           snake_case					=       MarkupText(
               F'''<span fgcolor=\'{BLUE}\'>●</span> Checkpoint'''    ,      font_size=1_8    ,      )
  
           blue_text.next_to(__snake_case    ,      DOWN * 2.4    ,      aligned_edge=key_text.get_left()					)
           self.add(__snake_case					)
  
           snake_case					=       MarkupText(F'''The offloaded weights are all sent to the CPU.'''    ,      font_size=2_4					)
           step_a.move_to([2, 2, 0]					)
  
           self.play(Write(__snake_case    ,      run_time=3					)					)
  
           for i in range(6					):
                snake_case					=       cpu_disk_arr[i]
                snake_case					=       rect.copy().set_fill(__snake_case    ,      opacity=0.8					).scale(2.0					)
                cpa.generate_target()
                cpa.target.move_to(model_base[i]					)
  
                if i == 0:
                     rect.set_fill(__snake_case    ,      opacity=0.8					)
                     rect.generate_target()
                     rect.target.move_to(cpu_left_col_base[0]					).scale(2.0					)
  
                     self.remove(
                         *__snake_case    ,      *__snake_case    ,      )
  
                else:
                     rect.generate_target()
                     rect.target.move_to(cpu_left_col_base[i]					).scale(2.0					)
                self.play(MoveToTarget(__snake_case					)    ,      MoveToTarget(__snake_case					)    ,      model_base[i].animate.set_stroke(__snake_case					)					)
           self.play(FadeOut(__snake_case					)					)
  
           snake_case					=       MarkupText(
               F'''Finally, hooks are added to each weight in the model\nto transfer the weights from CPU to GPU\n\t\tand back when needed.'''    ,      font_size=2_4    ,      )
           step_a.move_to([2, 2, 0]					)
  
           self.play(Write(__snake_case    ,      run_time=3					)					)
  
           snake_case					=       []
           snake_case					=       []
           for i in range(6					):
                snake_case					=       Arrow(start=__snake_case    ,      end=__snake_case    ,      color=__snake_case    ,      buff=0.5					)
                a.next_to(model_base[i].get_left()    ,      __snake_case    ,      buff=0.2					)
                arrows.append(__snake_case					)
                animations.append(Write(__snake_case					)					)
           self.play(*__snake_case					)
           self.wait()
  
  
  
  
  