

from manim import *







class 			lowercase    (	lowercase_      ):




				def    a							( self	):
											snake_case_          =   Rectangle(height=0.5				,       width=0.5	)
											snake_case_          =   Rectangle(height=0.25				,       width=0.25	)
											snake_case_          =   Rectangle(height=0.46				,       width=0.46	).set_stroke(width=0	)

											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=24	)
											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=24	)
											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=24	)
											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_          =   []
											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	)

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

											snake_case_          =   Text('Loaded Checkpoint'				,       font_size=24	)
											snake_case_          =   Group(snake_case				,       snake_case	).arrange(snake_case				,       buff=0.5				,       aligned_edge=snake_case	)
											checkpoint.move_to([3, 0.5, 0]	)

											self.add(snake_case	)

											snake_case_          =   []
											snake_case_          =   []

											for i, rect in enumerate(snake_case	):
																		snake_case_          =   fill.copy().set_fill(snake_case				,       opacity=0.7	)
																		target.move_to(snake_case	)
																		ckpt_arr.append(snake_case	)

																		snake_case_          =   target.copy()
																		if i < 5:
																									cpu_target.move_to(cpu_left_col_base[i + 1]	)
																		else:
																									cpu_target.move_to(cpu_right_col_base[i - 5]	)
																		ckpt_cpu_arr.append(snake_case	)
											self.add(*snake_case				,       *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=18				,       )

											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=18				,       )

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

											snake_case_          =   MarkupText(
											    F'''Based on the passed in configuration, weights are stored in\na variety of np.memmaps on disk or to a particular device.'''				,       font_size=24				,       )
											step_a.move_to([2, 2, 0]	)

											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=24	)
											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.play(Write(snake_case				,       run_time=3	)				,       Write(snake_case				,       run_time=1	)				,       Create(snake_case				,       run_time=1	)	)

											snake_case_          =   []
											for i, rect in enumerate(snake_case	):
																		snake_case_          =   rect.copy()
																		target.generate_target()
																		target.target.move_to(disk_left_col_base[i]	).scale(0.5	)
																		animations.append(MoveToTarget(snake_case				,       run_time=1.5	)	)
											self.play(*snake_case	)

											self.play(FadeOut(snake_case	)	)

											snake_case_          =   MarkupText(F'''Then, the checkpoint is removed from memory\nthrough garbage collection.'''				,       font_size=24	)
											step_a.move_to([2, 2, 0]	)

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

											self.play(
											    FadeOut(snake_case				,       snake_case				,       *snake_case				,       *snake_case	)				,       )

											self.wait()







import unittest

from transformers import is_torch_available, is_vision_available
from transformers.testing_utils import require_torch, require_vision, slow, torch_device


if is_torch_available():
					import torch

					from transformers import AutoModelForImageClassification

if is_vision_available():
					from transformers import AutoImageProcessor







@require_torch
@require_vision
class 			lowercase    (	unittest.TestCase      ):




				@slow
				def    a							( self	):
											snake_case_          =   AutoImageProcessor.from_pretrained('microsoft/dit-base-finetuned-rvlcdip'	)
											snake_case_          =   AutoModelForImageClassification.from_pretrained('microsoft/dit-base-finetuned-rvlcdip'	)
											model.to(snake_case	)

											from datasets import load_dataset

											snake_case_          =   load_dataset('nielsr/rvlcdip-demo'	)

											snake_case_          =   dataset['train'][0]['image'].convert('RGB'	)

											snake_case_          =   image_processor(snake_case				,       return_tensors='pt'	).to(snake_case	)

											# forward pass
											with torch.no_grad():
																		snake_case_          =   model(**snake_case	)
																		snake_case_          =   outputs.logits

											snake_case_          =   torch.Size((1, 16)	)
											self.assertEqual(logits.shape				,       snake_case	)

											snake_case_          =   torch.tensor(
											    [-0.41_58, -0.40_92, -0.43_47]				,       device=snake_case				,       dtype=torch.float				,       )
											self.assertTrue(torch.allclose(logits[0, :3]				,       snake_case				,       atol=1e-4	)	)




