code: 
  
  
  from manim import *
  
  
  
  
  
  
  
  class   lowerCAmelCase__ (       a):
  
  
  
  
       '''simple docstring'''
  
  
       def 				_lowerCamelCase				(		self)    ->       Tuple:
              _A   : Tuple       					=				Rectangle(height=0.5				,		width=0.5)
              _A   : Dict       					=				Rectangle(height=0.4_6				,		width=0.4_6).set_stroke(width=0)
              _A   : str       					=				Rectangle(height=0.2_5				,		width=0.2_5)
  
              _A   : Union[str, Any]       					=				[mem.copy() for i in range(6)]
              _A   : int       					=				[mem.copy() for i in range(6)]
              _A   : List[str]       					=				VGroup(*__lowerCamelCase).arrange(__lowerCamelCase				,		buff=0)
              _A   : Union[str, Any]       					=				VGroup(*__lowerCamelCase).arrange(__lowerCamelCase				,		buff=0)
              _A   : Union[str, Any]       					=				VGroup(__lowerCamelCase				,		__lowerCamelCase).arrange(__lowerCamelCase				,		buff=0)
              _A   : List[Any]       					=				Text("CPU"				,		font_size=2_4)
              _A   : List[str]       					=				Group(__lowerCamelCase				,		__lowerCamelCase).arrange(__lowerCamelCase				,		buff=0.5				,		aligned_edge=__lowerCamelCase)
              cpu.move_to([-2.5, -0.5, 0])
              self.add(__lowerCamelCase)
  
              _A   : Optional[int]       					=				[mem.copy() for i in range(4)]
              _A   : Dict       					=				VGroup(*__lowerCamelCase).arrange(__lowerCamelCase				,		buff=0)
              _A   : Optional[int]       					=				Text("GPU"				,		font_size=2_4)
              _A   : Optional[Any]       					=				Group(__lowerCamelCase				,		__lowerCamelCase).arrange(__lowerCamelCase				,		buff=0.5				,		aligned_edge=__lowerCamelCase)
              gpu.move_to([-1, -1, 0])
              self.add(__lowerCamelCase)
  
              _A   : int       					=				[mem.copy() for i in range(6)]
              _A   : Any       					=				VGroup(*__lowerCamelCase).arrange(__lowerCamelCase				,		buff=0)
  
              _A   : int       					=				Text("Model"				,		font_size=2_4)
              _A   : str       					=				Group(__lowerCamelCase				,		__lowerCamelCase).arrange(__lowerCamelCase				,		buff=0.5				,		aligned_edge=__lowerCamelCase)
              model.move_to([3, -1.0, 0])
              self.add(__lowerCamelCase)
  
              _A   : Tuple       					=				[]
              _A   : Any       					=				[]
  
              for i, rect in enumerate(__lowerCamelCase):
                     rect.set_stroke(__lowerCamelCase)
  
                     _A   : Any       					=				Rectangle(height=0.4_6 / 4				,		width=0.4_6 / 3).set_stroke(width=0.0).set_fill(__lowerCamelCase				,		opacity=0.7)
  
                     if i == 0:
                            cpu_target.next_to(cpu_left_col_base[0].get_corner(DOWN + LEFT)				,		buff=0.0_2				,		direction=__lowerCamelCase)
                            cpu_target.set_x(cpu_target.get_x() + 0.1)
                     elif i == 3:
                            cpu_target.next_to(model_cpu_arr[0]				,		direction=__lowerCamelCase				,		buff=0.0)
                     else:
                            cpu_target.next_to(model_cpu_arr[i - 1]				,		direction=__lowerCamelCase				,		buff=0.0)
                     self.add(__lowerCamelCase)
                     model_cpu_arr.append(__lowerCamelCase)
  
              self.add(*__lowerCamelCase				,		*__lowerCamelCase)
  
              _A   : List[Any]       					=				[meta_mem.copy() for i in range(6)]
              _A   : int       					=				[meta_mem.copy() for i in range(6)]
              _A   : int       					=				VGroup(*__lowerCamelCase).arrange(__lowerCamelCase				,		buff=0)
              _A   : Optional[int]       					=				VGroup(*__lowerCamelCase).arrange(__lowerCamelCase				,		buff=0)
              _A   : Optional[int]       					=				VGroup(__lowerCamelCase				,		__lowerCamelCase).arrange(__lowerCamelCase				,		buff=0)
              _A   : Dict       					=				Text("Disk"				,		font_size=2_4)
              _A   : Optional[Any]       					=				Group(__lowerCamelCase				,		__lowerCamelCase).arrange(__lowerCamelCase				,		buff=0.5				,		aligned_edge=__lowerCamelCase)
              disk.move_to([-4.0, -1.2_5, 0])
              self.add(__lowerCamelCase				,		__lowerCamelCase)
  
              _A   : Union[str, Any]       					=				[]
  
              for i in range(6):
                     _A   : Optional[int]       					=				fill.copy().set_fill(__lowerCamelCase				,		opacity=0.8)
                     target.move_to(disk_left_col_base[i]).scale(0.5)
                     cpu_disk_arr.append(__lowerCamelCase)
  
              self.add(*__lowerCamelCase)
  
              _A   : Dict       					=				Square(side_length=2.2)
              key.move_to([-5, 2, 0])
  
              _A   : Optional[int]       					=				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(__lowerCamelCase				,		__lowerCamelCase)
  
              _A   : Tuple       					=				MarkupText(
                  F"<span fgcolor='{BLUE}'>●</span> Checkpoint"				,		font_size=1_8				,		)
  
              blue_text.next_to(__lowerCamelCase				,		DOWN * 2.4				,		aligned_edge=key_text.get_left())
              self.add(__lowerCamelCase)
  
              _A   : int       					=				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(__lowerCamelCase				,		run_time=3))
  
              for i in range(6):
                     _A   : str       					=				cpu_disk_arr[i]
                     _A   : Dict       					=				rect.copy().set_fill(__lowerCamelCase				,		opacity=0.8).scale(2.0)
                     cpa.generate_target()
                     cpa.target.move_to(model_base[i])
  
                     if i == 0:
                            rect.set_fill(__lowerCamelCase				,		opacity=0.8)
                            rect.generate_target()
                            rect.target.move_to(cpu_left_col_base[0]).scale(2.0)
  
                            self.remove(
                                *__lowerCamelCase				,		*__lowerCamelCase				,		)
  
                     else:
                            rect.generate_target()
                            rect.target.move_to(cpu_left_col_base[i]).scale(2.0)
                     self.play(MoveToTarget(__lowerCamelCase)				,		MoveToTarget(__lowerCamelCase)				,		model_base[i].animate.set_stroke(__lowerCamelCase))
              self.play(FadeOut(__lowerCamelCase))
  
              _A   : Any       					=				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(__lowerCamelCase				,		run_time=3))
  
              _A   : Any       					=				[]
              _A   : str       					=				[]
              for i in range(6):
                     _A   : Optional[Any]       					=				Arrow(start=__lowerCamelCase				,		end=__lowerCamelCase				,		color=__lowerCamelCase				,		buff=0.5)
                     a.next_to(model_base[i].get_left()				,		__lowerCamelCase				,		buff=0.2)
                     arrows.append(__lowerCamelCase)
                     animations.append(Write(__lowerCamelCase))
              self.play(*__lowerCamelCase)
              self.wait()
  
style_context: 
  
  
  import cva
  import numpy as np
  
  from digital_image_processing.filters.convolve import img_convolve
  from digital_image_processing.filters.sobel_filter import sobel_filter
  
  lowerCAmelCase__   	=				1_80
  def 							_UpperCAmelCase       (UpperCamelCase__  :						Optional[Any]       ,							UpperCamelCase__  :						Optional[Any]		):
         _A   : int       					=				k_size // 2
         _A					,    _A   : Tuple       					=				np.mgrid[0 - center : k_size - center, 0 - center : k_size - center]
         _A   : Union[str, Any]       					=				(
             1
             / (2 * np.pi * sigma)
             * np.exp(-(np.square(UpperCamelCase__		) + np.square(UpperCamelCase__		)) / (2 * np.square(UpperCamelCase__		))		)
         )
         return g
  def 							_UpperCAmelCase       (UpperCamelCase__  :						str       ,							UpperCamelCase__  :						Any       ,							UpperCamelCase__  :						Tuple		):
         _A   : Optional[int]       					=				np.zeros(UpperCamelCase__		)
  
         for row in range(1       ,							image_shape[0] - 1		):
                for col in range(1       ,							image_shape[1] - 1		):
                       _A   : Dict       					=				gradient_direction[row, col]
  
                       if (
                           0 <= direction < PI / 8
                           or 15 * PI / 8 <= direction <= 2 * PI
                           or 7 * PI / 8 <= direction <= 9 * PI / 8
                       ):
                              _A   : Dict       					=				sobel_grad[row, col - 1]
                              _A   : Any       					=				sobel_grad[row, col + 1]
                              if sobel_grad[row, col] >= w and sobel_grad[row, col] >= e:
                                     _A   : List[Any]       					=				sobel_grad[row, col]
  
                       elif (
                           PI / 8 <= direction < 3 * PI / 8
                           or 9 * PI / 8 <= direction < 11 * PI / 8
                       ):
                              _A   : List[str]       					=				sobel_grad[row + 1, col - 1]
                              _A   : str       					=				sobel_grad[row - 1, col + 1]
                              if sobel_grad[row, col] >= sw and sobel_grad[row, col] >= ne:
                                     _A   : List[Any]       					=				sobel_grad[row, col]
  
                       elif (
                           3 * PI / 8 <= direction < 5 * PI / 8
                           or 11 * PI / 8 <= direction < 13 * PI / 8
                       ):
                              _A   : Any       					=				sobel_grad[row - 1, col]
                              _A   : int       					=				sobel_grad[row + 1, col]
                              if sobel_grad[row, col] >= n and sobel_grad[row, col] >= s:
                                     _A   : Any       					=				sobel_grad[row, col]
  
                       elif (
                           5 * PI / 8 <= direction < 7 * PI / 8
                           or 13 * PI / 8 <= direction < 15 * PI / 8
                       ):
                              _A   : List[str]       					=				sobel_grad[row - 1, col - 1]
                              _A   : Optional[Any]       					=				sobel_grad[row + 1, col + 1]
                              if sobel_grad[row, col] >= nw and sobel_grad[row, col] >= se:
                                     _A   : List[Any]       					=				sobel_grad[row, col]
  
         return destination
  def 							_UpperCAmelCase       (UpperCamelCase__  :						Dict       ,							UpperCamelCase__  :						Optional[Any]       ,							UpperCamelCase__  :						str       ,							UpperCamelCase__  :						Dict       ,							UpperCamelCase__  :						Optional[Any]       ,							UpperCamelCase__  :						Any		):
         for row in range(1       ,							image_shape[0] - 1		):
                for col in range(1       ,							image_shape[1] - 1		):
                       if destination[row, col] >= threshold_high:
                              _A   : Optional[int]       					=				strong
                       elif destination[row, col] <= threshold_low:
                              _A   : Optional[int]       					=				0
                       else:
                              _A   : Union[str, Any]       					=				weak
  def 							_UpperCAmelCase       (UpperCamelCase__  :						Optional[Any]       ,							UpperCamelCase__  :						Optional[int]       ,							UpperCamelCase__  :						Any       ,							UpperCamelCase__  :						Any		):
         for row in range(1       ,							image_shape[0]		):
                for col in range(1       ,							image_shape[1]		):
                       if destination[row, col] == weak:
                              if 255 in (
                                  destination[row, col + 1],
                                  destination[row, col - 1],
                                  destination[row - 1, col],
                                  destination[row + 1, col],
                                  destination[row - 1, col - 1],
                                  destination[row + 1, col - 1],
                                  destination[row - 1, col + 1],
                                  destination[row + 1, col + 1],
                              ):
                                     _A   : str       					=				strong
                              else:
                                     _A   : Any       					=				0
  def 							_UpperCAmelCase       (UpperCamelCase__  :						Dict       ,							UpperCamelCase__  :						int=15       ,							UpperCamelCase__  :						Dict=30       ,							UpperCamelCase__  :						int=128       ,							UpperCamelCase__  :						Union[str, Any]=255		):
         # gaussian_filter
         _A   : Union[str, Any]       					=				img_convolve(UpperCamelCase__       ,							gen_gaussian_kernel(9       ,							sigma=1.4		)		)
         # get the gradient and degree by sobel_filter
         _A					,    _A   : Dict       					=				sobel_filter(UpperCamelCase__		)
         _A   : Tuple       					=				PI + np.radadeg(UpperCamelCase__		)
  
         _A   : Optional[int]       					=				suppress_non_maximum(image.shape       ,							UpperCamelCase__       ,							UpperCamelCase__		)
  
         detect_high_low_threshold(
             image.shape       ,							UpperCamelCase__       ,							UpperCamelCase__       ,							UpperCamelCase__       ,							UpperCamelCase__       ,							UpperCamelCase__		)
  
         track_edge(image.shape       ,							UpperCamelCase__       ,							UpperCamelCase__       ,							UpperCamelCase__		)
  
         return destination
  
  
  if __name__ == "__main__":
      # read original image in gray mode
      lowerCAmelCase__   	=				cva.imread(R'../image_data/lena.jpg', 0)
      # canny edge detection
      lowerCAmelCase__   	=				canny(lena)
      cva.imshow('canny', canny_destination)
      cva.waitKey(0)
  