from manim import *




class    _UpperCamelCase      (						_UpperCAmelCase ):


			"""simple docstring"""






			def        _SCREAMING_SNAKE_CASE			(   self						)     ->					Union[str, Any]:

							'''simple docstring'''


							__lowercase 			=							Rectangle(height=0.5      ,   width=0.5						)
							__lowercase 			=							Rectangle(height=0.46      ,   width=0.46						).set_stroke(width=0						)

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

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

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

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

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

							__lowercase 			=							[]
							__lowercase 			=							[]

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

											__lowercase 			=							Rectangle(height=0.46      ,   width=0.46						).set_stroke(width=0.0						).set_fill(lowerCAmelCase__      ,   opacity=0.8						)
											cpu_target.move_to(cpu_left_col_base[i]						)
											model_cpu_arr.append(lowerCAmelCase__						)

							self.add(*lowerCAmelCase__      ,   *lowerCAmelCase__						)

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

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

							__lowercase 			=							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(lowerCAmelCase__      ,   lowerCAmelCase__						)

							__lowercase 			=							MarkupText(
							    F"<span fgcolor='{BLUE}'>●</span> Checkpoint"      ,   font_size=18      ,   )

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

							__lowercase 			=							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(lowerCAmelCase__						)						)

							__lowercase 			=							Square(0.3						)
							input.set_fill(lowerCAmelCase__      ,   opacity=1.0						)
							input.set_stroke(width=0.0						)
							input.next_to(model_base[0]      ,   lowerCAmelCase__      ,   buff=0.5						)

							self.play(Write(lowerCAmelCase__						)						)

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

							self.play(FadeOut(lowerCAmelCase__						)						)

							__lowercase 			=							Arrow(start=lowerCAmelCase__      ,   end=lowerCAmelCase__      ,   color=lowerCAmelCase__      ,   buff=0.5						)
							a.next_to(model_arr[0].get_left()      ,   lowerCAmelCase__      ,   buff=0.2						)

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

							__lowercase 			=							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(lowerCAmelCase__      ,   run_time=3						)						)

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

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

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

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

											__lowercase 			=							AnimationGroup(
											    FadeOut(lowerCAmelCase__      ,   run_time=0.5						)      ,   MoveToTarget(lowerCAmelCase__      ,   run_time=0.5						)      ,   FadeIn(lowerCAmelCase__      ,   run_time=0.5						)      ,   lag_ratio=0.2						)

											self.play(lowerCAmelCase__						)

											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:
																			__lowercase 			=							0.7

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

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

											__lowercase 			=							a_c
											__lowercase 			=							a_c.copy()

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

							__lowercase 			=							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(lowerCAmelCase__      ,   run_time=3						)      ,   MoveToTarget(lowerCAmelCase__						)						)

							self.wait()
from typing import List, Optional, TypeVar

from .arrow_dataset import Dataset, _concatenate_map_style_datasets, _interleave_map_style_datasets
from .dataset_dict import DatasetDict, IterableDatasetDict
from .info import DatasetInfo
from .iterable_dataset import IterableDataset, _concatenate_iterable_datasets, _interleave_iterable_datasets
from .splits import NamedSplit
from .utils import logging
from .utils.py_utils import Literal


__a  :     Optional[Any]       =  logging.get_logger(__name__)


__a  :     List[str]       =  TypeVar("""DatasetType""", Dataset, IterableDataset)





def 				UpperCAmelCase						(    lowercase							,			lowercase = None							,			lowercase = None							,			lowercase = None							,			lowercase = None							,			lowercase = "first_exhausted"							,			):







				"""simple docstring"""



				from .arrow_dataset import Dataset
				from .iterable_dataset import IterableDataset

				if not datasets:
								raise ValueError('''Unable to interleave an empty list of datasets.'''							)
				for i, dataset in enumerate(lowercase							):
								if not isinstance(lowercase							,			(Dataset, IterableDataset)							):
												if isinstance(lowercase							,			(DatasetDict, IterableDatasetDict)							):
																if not dataset:
																				raise ValueError(
																				    F"Expected a list of Dataset objects or a list of IterableDataset objects, but element at position {i} "
																				    '''is an empty dataset dictionary.'''							)
																raise ValueError(
																    F"Dataset at position {i} has at least one split: {list(lowercase							)}\n"
																    F"Please pick one to interleave with the other datasets, for example: dataset['{next(iter(lowercase							)							)}']"							)
												raise ValueError(
												    F"Expected a list of Dataset objects or a list of IterableDataset objects, but element at position {i} is a {type(lowercase							).__name__}."							)
								if i == 0:
												__lowercase			,     __lowercase 			=							(
												    (Dataset, IterableDataset) if isinstance(lowercase							,			lowercase							) else (IterableDataset, Dataset)
												)
								elif not isinstance(lowercase							,			lowercase							):
												raise ValueError(
												    F"Unable to interleave a {dataset_type.__name__} (at position 0) with a {other_type.__name__} (at position {i}). Expected a list of Dataset objects or a list of IterableDataset objects."							)
				if stopping_strategy not in ["first_exhausted", "all_exhausted"]:
								raise ValueError(F"{stopping_strategy} is not supported. Please enter a valid stopping_strategy."							)
				if dataset_type is Dataset:
								return _interleave_map_style_datasets(
								    lowercase							,			lowercase							,			lowercase							,			info=lowercase							,			split=lowercase							,			stopping_strategy=lowercase							)
				else:
								return _interleave_iterable_datasets(
								    lowercase							,			lowercase							,			lowercase							,			info=lowercase							,			split=lowercase							,			stopping_strategy=lowercase							)





def 				UpperCAmelCase						(    lowercase							,			lowercase = None							,			lowercase = None							,			lowercase = 0							,			):







				"""simple docstring"""



				if not dsets:
								raise ValueError('''Unable to concatenate an empty list of datasets.'''							)
				for i, dataset in enumerate(lowercase							):
								if not isinstance(lowercase							,			(Dataset, IterableDataset)							):
												if isinstance(lowercase							,			(DatasetDict, IterableDatasetDict)							):
																if not dataset:
																				raise ValueError(
																				    F"Expected a list of Dataset objects or a list of IterableDataset objects, but element at position {i} "
																				    '''is an empty dataset dictionary.'''							)
																raise ValueError(
																    F"Dataset at position {i} has at least one split: {list(lowercase							)}\n"
																    F"Please pick one to interleave with the other datasets, for example: dataset['{next(iter(lowercase							)							)}']"							)
												raise ValueError(
												    F"Expected a list of Dataset objects or a list of IterableDataset objects, but element at position {i} is a {type(lowercase							).__name__}."							)
								if i == 0:
												__lowercase			,     __lowercase 			=							(
												    (Dataset, IterableDataset) if isinstance(lowercase							,			lowercase							) else (IterableDataset, Dataset)
												)
								elif not isinstance(lowercase							,			lowercase							):
												raise ValueError(
												    F"Unable to interleave a {dataset_type.__name__} (at position 0) with a {other_type.__name__} (at position {i}). Expected a list of Dataset objects or a list of IterableDataset objects."							)
				if dataset_type is Dataset:
								return _concatenate_map_style_datasets(lowercase							,			info=lowercase							,			split=lowercase							,			axis=lowercase							)
				else:
								return _concatenate_iterable_datasets(lowercase							,			info=lowercase							,			split=lowercase							,			axis=lowercase							)