
"""simple docstring"""





from manim import *






class    _UpperCAmelCase(   lowerCamelCase     ):



		def 						UpperCAmelCase							( self)	->	Any:






							'''simple docstring'''
							_UpperCamelCase										=  Rectangle(height=0.5    ,		width=0.5)
							_UpperCamelCase										=  Rectangle(height=0.46    ,		width=0.46).set_stroke(width=0)

							_UpperCamelCase										=  Rectangle(height=0.25    ,		width=0.25)

							_UpperCamelCase										=  [mem.copy() for i in range(6)]
							_UpperCamelCase										=  [mem.copy() for i in range(6)]
							_UpperCamelCase										=  VGroup(*__a).arrange(__a    ,		buff=0)
							_UpperCamelCase										=  VGroup(*__a).arrange(__a    ,		buff=0)
							_UpperCamelCase										=  VGroup(__a    ,		__a).arrange(__a    ,		buff=0)
							_UpperCamelCase										=  Text('''CPU'''    ,		font_size=24)
							_UpperCamelCase										=  Group(__a    ,		__a).arrange(__a    ,		buff=0.5    ,		aligned_edge=__a)
							cpu.move_to([-2.5, -0.5, 0])
							self.add(__a)

							_UpperCamelCase										=  [mem.copy() for i in range(4)]
							_UpperCamelCase										=  VGroup(*__a).arrange(__a    ,		buff=0)
							_UpperCamelCase										=  Text('''GPU'''    ,		font_size=24)
							_UpperCamelCase										=  Group(__a    ,		__a).arrange(__a    ,		buff=0.5    ,		aligned_edge=__a)
							gpu.move_to([-1, -1, 0])
							self.add(__a)

							_UpperCamelCase										=  [mem.copy() for i in range(6)]
							_UpperCamelCase										=  VGroup(*__a).arrange(__a    ,		buff=0)

							_UpperCamelCase										=  Text('''Model'''    ,		font_size=24)
							_UpperCamelCase										=  Group(__a    ,		__a).arrange(__a    ,		buff=0.5    ,		aligned_edge=__a)
							model.move_to([3, -1.0, 0])
							self.add(__a)

							_UpperCamelCase										=  []
							_UpperCamelCase										=  []

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

												_UpperCamelCase										=  Rectangle(height=0.46    ,		width=0.46).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)

							_UpperCamelCase										=  [meta_mem.copy() for i in range(6)]
							_UpperCamelCase										=  [meta_mem.copy() for i in range(6)]
							_UpperCamelCase										=  VGroup(*__a).arrange(__a    ,		buff=0)
							_UpperCamelCase										=  VGroup(*__a).arrange(__a    ,		buff=0)
							_UpperCamelCase										=  VGroup(__a    ,		__a).arrange(__a    ,		buff=0)
							_UpperCamelCase										=  Text('''Disk'''    ,		font_size=24)
							_UpperCamelCase										=  Group(__a    ,		__a).arrange(__a    ,		buff=0.5    ,		aligned_edge=__a)
							disk.move_to([-4, -1.25, 0])
							self.add(__a    ,		__a)

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

							_UpperCamelCase										=  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)

							_UpperCamelCase										=  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)

							_UpperCamelCase										=  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))

							_UpperCamelCase										=  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.02)
							self.play(MoveToTarget(__a))

							self.play(FadeOut(__a))

							_UpperCamelCase										=  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])

							_UpperCamelCase										=  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))

							_UpperCamelCase										=  {'''run_time''': 1, '''fade_in''': True, '''fade_out''': True, '''buff''': 0.02}

							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]))

							_UpperCamelCase										=  a.copy()
							for i in range(6):
												a_c.next_to(model_arr[i].get_right() + 0.02    ,		__a    ,		buff=0.2)

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

												_UpperCamelCase										=  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:
																						_UpperCamelCase										=  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.02    ,		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]))

												_UpperCamelCase										=  a_c
												_UpperCamelCase										=  a_c.copy()

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

							_UpperCamelCase										=  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"""





# 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

import torch

from ..models.auto import AutoModelForVisualQuestionAnswering, AutoProcessor
from ..utils import requires_backends
from .base import PipelineTool


if TYPE_CHECKING:
				from PIL import Image






class    _UpperCAmelCase(   lowerCamelCase     ):
		lowercase__      =				'dandelin/vilt-b32-finetuned-vqa'
		lowercase__      =				(
		    'This is a tool that answers a question about an image. It takes an input named `image` which should be the '
		    'image containing the information, as well as a `question` which should be the question in English. It '
		    'returns a text that is the answer to the question.'
		)
		lowercase__      =				'image_qa'
		lowercase__      =				AutoProcessor
		lowercase__      =				AutoModelForVisualQuestionAnswering

		lowercase__      =				['image', 'text']
		lowercase__      =				['text']



		def __init__( self    ,		*__a    ,		**__a)	->	int:






							'''simple docstring'''
							requires_backends(self    ,		['''vision'''])
							super().__init__(*__a    ,		**__a)



		def 						UpperCAmelCase							( self    ,		__a    ,		__a)	->	Dict:






							'''simple docstring'''
							return self.pre_processor(__a    ,		__a    ,		return_tensors='''pt''')



		def 						UpperCAmelCase							( self    ,		__a)	->	Tuple:






							'''simple docstring'''
							with torch.no_grad():
												return self.model(**__a).logits




		def 						UpperCAmelCase							( self    ,		__a)	->	Optional[Any]:






							'''simple docstring'''
							_UpperCamelCase										=  outputs.argmax(-1).item()
							return self.model.config.idalabel[idx]






