


from manim import *
class _lowerCamelCase	(						lowerCamelCase__							):



		'''simple docstring'''







		def        __lowerCAmelCase		( self		:						Any      )  ->			Dict:
			__magic_name__	:   Tuple					     =					Rectangle(height=0.5  ,					width=0.5      )
			__magic_name__	:   Any					     =					Rectangle(height=0.46  ,					width=0.46      ).set_stroke(width=0      )

			__magic_name__	:   List[Any]					     =					Rectangle(height=0.25  ,					width=0.25      )

			__magic_name__	:   List[str]					     =					[mem.copy() for i in range(6      )]
			__magic_name__	:   Dict					     =					[mem.copy() for i in range(6      )]
			__magic_name__	:   Tuple					     =					VGroup(*snake_case__      ).arrange(snake_case__  ,					buff=0      )
			__magic_name__	:   str					     =					VGroup(*snake_case__      ).arrange(snake_case__  ,					buff=0      )
			__magic_name__	:   List[Any]					     =					VGroup(snake_case__  ,					snake_case__      ).arrange(snake_case__  ,					buff=0      )
			__magic_name__	:   List[Any]					     =					Text('CPU'  ,					font_size=24      )
			__magic_name__	:   str					     =					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__      )

			__magic_name__	:   Optional[Any]					     =					[mem.copy() for i in range(4      )]
			__magic_name__	:   str					     =					VGroup(*snake_case__      ).arrange(snake_case__  ,					buff=0      )
			__magic_name__	:   Optional[int]					     =					Text('GPU'  ,					font_size=24      )
			__magic_name__	:   int					     =					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__      )

			__magic_name__	:   Union[str, Any]					     =					[mem.copy() for i in range(6      )]
			__magic_name__	:   Optional[Any]					     =					VGroup(*snake_case__      ).arrange(snake_case__  ,					buff=0      )

			__magic_name__	:   Optional[int]					     =					Text('Model'  ,					font_size=24      )
			__magic_name__	:   Dict					     =					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__      )

			__magic_name__	:   Optional[int]					     =					[]
			__magic_name__	:   List[str]					     =					[]

			for i, rect in enumerate(snake_case__      ):
				__magic_name__	:   List[Any]					     =					fill.copy().set_fill(snake_case__  ,					opacity=0.8      )
				target.move_to(snake_case__      )
				model_arr.append(snake_case__      )

				__magic_name__	:   Optional[Any]					     =					Rectangle(height=0.46  ,					width=0.46      ).set_stroke(width=0.0      ).set_fill(snake_case__  ,					opacity=0.8      )
				cpu_target.move_to(cpu_left_col_base[i]      )
				model_cpu_arr.append(snake_case__      )

			self.add(*snake_case__  ,					*snake_case__      )

			__magic_name__	:   List[str]					     =					[meta_mem.copy() for i in range(6      )]
			__magic_name__	:   str					     =					[meta_mem.copy() for i in range(6      )]
			__magic_name__	:   str					     =					VGroup(*snake_case__      ).arrange(snake_case__  ,					buff=0      )
			__magic_name__	:   int					     =					VGroup(*snake_case__      ).arrange(snake_case__  ,					buff=0      )
			__magic_name__	:   int					     =					VGroup(snake_case__  ,					snake_case__      ).arrange(snake_case__  ,					buff=0      )
			__magic_name__	:   int					     =					Text('Disk'  ,					font_size=24      )
			__magic_name__	:   Dict					     =					Group(snake_case__  ,					snake_case__      ).arrange(snake_case__  ,					buff=0.5  ,					aligned_edge=snake_case__      )
			disk.move_to([-4, -1.25, 0]      )
			self.add(snake_case__  ,					snake_case__      )

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

			__magic_name__	:   Optional[Any]					     =					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(snake_case__  ,					snake_case__      )

			__magic_name__	:   Union[str, Any]					     =					MarkupText(
			    F'<span fgcolor=\'{BLUE}\'>●</span> Checkpoint'  ,					font_size=18  ,					)

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

			__magic_name__	:   Union[str, Any]					     =					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(snake_case__      )      )

			__magic_name__	:   Tuple					     =					Square(0.3      )
			input.set_fill(snake_case__  ,					opacity=1.0      )
			input.set_stroke(width=0.0      )
			input.next_to(model_base[0]  ,					snake_case__  ,					buff=0.5      )

			self.play(Write(snake_case__      )      )

			input.generate_target()
			input.target.next_to(model_arr[0]  ,					direction=snake_case__  ,					buff=0.02      )
			self.play(MoveToTarget(snake_case__      )      )

			self.play(FadeOut(snake_case__      )      )

			__magic_name__	:   str					     =					Arrow(start=snake_case__  ,					end=snake_case__  ,					color=snake_case__  ,					buff=0.5      )
			a.next_to(model_arr[0].get_left()  ,					snake_case__  ,					buff=0.2      )

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

			__magic_name__	:   str					     =					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(snake_case__  ,					run_time=3      )      )

			__magic_name__	:   List[Any]					     =					{'''run_time''': 1, '''fade_in''': True, '''fade_out''': True, '''buff''': 0.02}

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

			__magic_name__	:   List[Any]					     =					a.copy()
			for i in range(6      ):
				a_c.next_to(model_arr[i].get_right() + 0.02  ,					snake_case__  ,					buff=0.2      )

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

				__magic_name__	:   str					     =					AnimationGroup(
				    FadeOut(snake_case__  ,					run_time=0.5      )  ,					MoveToTarget(snake_case__  ,					run_time=0.5      )  ,					FadeIn(snake_case__  ,					run_time=0.5      )  ,					lag_ratio=0.2      )

				self.play(snake_case__      )

				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:
						__magic_name__	:   str					     =					0.7

					self.play(
					    Circumscribe(model_arr[i]  ,					**snake_case__      )  ,					Circumscribe(cpu_left_col_base[i]  ,					**snake_case__      )  ,					Circumscribe(cpu_left_col_base[i + 1]  ,					color=snake_case__  ,					**snake_case__      )  ,					Circumscribe(gpu_rect[0]  ,					color=snake_case__  ,					**snake_case__      )  ,					Circumscribe(model_arr[i + 1]  ,					color=snake_case__  ,					**snake_case__      )  ,					)
					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.02  ,					buff=0.2      )

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

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

				__magic_name__	:   str					     =					a_c
				__magic_name__	:   Dict					     =					a_c.copy()

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

			__magic_name__	:   Tuple					     =					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(snake_case__  ,					run_time=3      )  ,					MoveToTarget(snake_case__      )      )

			self.wait()



'''simple docstring'''

# Copyright 2023 The HuggingFace Inc. team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from typing import TYPE_CHECKING

from ..models.auto import AutoModelForVisionaSeq
from ..utils import requires_backends
from .base import PipelineTool


if TYPE_CHECKING:
							from PIL import Image
class _lowerCamelCase	(						lowercase__							):



		'''simple docstring'''







		A_     :      Any				   =    """Salesforce/blip-image-captioning-base"""
		A_     :      Any				   =    (
		    """This is a tool that generates a description of an image. It takes an input named `image` which should be the """
		    """image to caption, and returns a text that contains the description in English."""
		)
		A_     :      List[str]				   =    """image_captioner"""
		A_     :      Optional[Any]				   =    AutoModelForVisionaSeq

		A_     :      Any				   =    ["""image"""]
		A_     :      Union[str, Any]				   =    ["""text"""]







		def __init__( self		:						Dict  ,					*_A		:						Dict  ,					**_A		:						Any      )  ->			Dict:
			requires_backends(self  ,					['vision']      )
			super().__init__(*_A  ,					**_A      )







		def        __lowerCAmelCase		( self		:						Tuple  ,					_A		:						"Image"      )  ->			Union[str, Any]:
			return self.pre_processor(images=_A  ,					return_tensors='pt'      )







		def        __lowerCAmelCase		( self		:						Optional[Any]  ,					_A		:						str      )  ->			List[Any]:
			return self.model.generate(**_A      )







		def        __lowerCAmelCase		( self		:						int  ,					_A		:						Optional[int]      )  ->			Union[str, Any]:
			return self.pre_processor.batch_decode(_A  ,					skip_special_tokens=_A      )[0].strip()