





from manim import *


class 						lowerCamelCase       (__lowerCamelCase      ):







							"""simple docstring"""




							def  A_     ( self     :					str						)				->			int:





														"""simple docstring"""
														SCREAMING_SNAKE_CASE__       :      Union[str, Any]     =						Rectangle(height=0.5,			width=0.5						)
														SCREAMING_SNAKE_CASE__       :      List[str]     =						Rectangle(height=0.46,			width=0.46						).set_stroke(width=0						)

														SCREAMING_SNAKE_CASE__       :      Tuple     =						Rectangle(height=0.25,			width=0.25						)

														SCREAMING_SNAKE_CASE__       :      Optional[Any]     =						[mem.copy() for i in range(6						)]
														SCREAMING_SNAKE_CASE__       :      Any     =						[mem.copy() for i in range(6						)]
														SCREAMING_SNAKE_CASE__       :      Any     =						VGroup(*_UpperCAmelCase						).arrange(_UpperCAmelCase,			buff=0						)
														SCREAMING_SNAKE_CASE__       :      List[str]     =						VGroup(*_UpperCAmelCase						).arrange(_UpperCAmelCase,			buff=0						)
														SCREAMING_SNAKE_CASE__       :      Union[str, Any]     =						VGroup(_UpperCAmelCase,			_UpperCAmelCase						).arrange(_UpperCAmelCase,			buff=0						)
														SCREAMING_SNAKE_CASE__       :      int     =						Text("CPU",			font_size=2_4						)
														SCREAMING_SNAKE_CASE__       :      Union[str, Any]     =						Group(_UpperCAmelCase,			_UpperCAmelCase						).arrange(_UpperCAmelCase,			buff=0.5,			aligned_edge=_UpperCAmelCase						)
														cpu.move_to([-2.5, -0.5, 0]						)
														self.add(_UpperCAmelCase						)

														SCREAMING_SNAKE_CASE__       :      Optional[Any]     =						[mem.copy() for i in range(4						)]
														SCREAMING_SNAKE_CASE__       :      Optional[int]     =						VGroup(*_UpperCAmelCase						).arrange(_UpperCAmelCase,			buff=0						)
														SCREAMING_SNAKE_CASE__       :      Optional[int]     =						Text("GPU",			font_size=2_4						)
														SCREAMING_SNAKE_CASE__       :      Union[str, Any]     =						Group(_UpperCAmelCase,			_UpperCAmelCase						).arrange(_UpperCAmelCase,			buff=0.5,			aligned_edge=_UpperCAmelCase						)
														gpu.move_to([-1, -1, 0]						)
														self.add(_UpperCAmelCase						)

														SCREAMING_SNAKE_CASE__       :      List[Any]     =						[mem.copy() for i in range(6						)]
														SCREAMING_SNAKE_CASE__       :      Tuple     =						VGroup(*_UpperCAmelCase						).arrange(_UpperCAmelCase,			buff=0						)

														SCREAMING_SNAKE_CASE__       :      Union[str, Any]     =						Text("Model",			font_size=2_4						)
														SCREAMING_SNAKE_CASE__       :      Tuple     =						Group(_UpperCAmelCase,			_UpperCAmelCase						).arrange(_UpperCAmelCase,			buff=0.5,			aligned_edge=_UpperCAmelCase						)
														model.move_to([3, -1.0, 0]						)
														self.add(_UpperCAmelCase						)

														SCREAMING_SNAKE_CASE__       :      List[str]     =						[]
														SCREAMING_SNAKE_CASE__       :      Any     =						[]

														for i, rect in enumerate(_UpperCAmelCase						):
																					SCREAMING_SNAKE_CASE__       :      Optional[int]     =						fill.copy().set_fill(_UpperCAmelCase,			opacity=0.8						)
																					target.move_to(_UpperCAmelCase						)
																					model_arr.append(_UpperCAmelCase						)

																					SCREAMING_SNAKE_CASE__       :      Dict     =						Rectangle(height=0.46,			width=0.46						).set_stroke(width=0.0						).set_fill(_UpperCAmelCase,			opacity=0.8						)
																					cpu_target.move_to(cpu_left_col_base[i]						)
																					model_cpu_arr.append(_UpperCAmelCase						)

														self.add(*_UpperCAmelCase,			*_UpperCAmelCase						)

														SCREAMING_SNAKE_CASE__       :      int     =						[meta_mem.copy() for i in range(6						)]
														SCREAMING_SNAKE_CASE__       :      Any     =						[meta_mem.copy() for i in range(6						)]
														SCREAMING_SNAKE_CASE__       :      Any     =						VGroup(*_UpperCAmelCase						).arrange(_UpperCAmelCase,			buff=0						)
														SCREAMING_SNAKE_CASE__       :      Tuple     =						VGroup(*_UpperCAmelCase						).arrange(_UpperCAmelCase,			buff=0						)
														SCREAMING_SNAKE_CASE__       :      str     =						VGroup(_UpperCAmelCase,			_UpperCAmelCase						).arrange(_UpperCAmelCase,			buff=0						)
														SCREAMING_SNAKE_CASE__       :      int     =						Text("Disk",			font_size=2_4						)
														SCREAMING_SNAKE_CASE__       :      List[Any]     =						Group(_UpperCAmelCase,			_UpperCAmelCase						).arrange(_UpperCAmelCase,			buff=0.5,			aligned_edge=_UpperCAmelCase						)
														disk.move_to([-4, -1.25, 0]						)
														self.add(_UpperCAmelCase,			_UpperCAmelCase						)

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

														SCREAMING_SNAKE_CASE__       :      Dict     =						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(_UpperCAmelCase,			_UpperCAmelCase						)

														SCREAMING_SNAKE_CASE__       :      str     =						MarkupText(
														    F'''<span fgcolor=\'{BLUE}\'>●</span> Checkpoint''',			font_size=1_8,			)

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

														SCREAMING_SNAKE_CASE__       :      Optional[Any]     =						MarkupText(
														    F'''Now watch as an input is passed through the model\nand how the memory is utilized and handled.''',			font_size=2_4,			)
														step_a.move_to([2, 2, 0]						)

														self.play(Write(_UpperCAmelCase						)						)

														SCREAMING_SNAKE_CASE__       :      str     =						Square(0.3						)
														input.set_fill(_UpperCAmelCase,			opacity=1.0						)
														input.set_stroke(width=0.0						)
														input.next_to(model_base[0],			_UpperCAmelCase,			buff=0.5						)

														self.play(Write(_UpperCAmelCase						)						)

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

														self.play(FadeOut(_UpperCAmelCase						)						)

														SCREAMING_SNAKE_CASE__       :      Optional[int]     =						Arrow(start=_UpperCAmelCase,			end=_UpperCAmelCase,			color=_UpperCAmelCase,			buff=0.5						)
														a.next_to(model_arr[0].get_left(),			_UpperCAmelCase,			buff=0.2						)

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

														SCREAMING_SNAKE_CASE__       :      int     =						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=2_4,			)
														step_a.move_to([2, 2, 0]						)

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

														SCREAMING_SNAKE_CASE__       :      List[str]     =						{"run_time": 1, "fade_in": True, "fade_out": True, "buff": 0.02}

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

														SCREAMING_SNAKE_CASE__       :      Union[str, Any]     =						a.copy()
														for i in range(6						):
																					a_c.next_to(model_arr[i].get_right() + 0.02,			_UpperCAmelCase,			buff=0.2						)

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

																					SCREAMING_SNAKE_CASE__       :      int     =						AnimationGroup(
																					    FadeOut(_UpperCAmelCase,			run_time=0.5						),			MoveToTarget(_UpperCAmelCase,			run_time=0.5						),			FadeIn(_UpperCAmelCase,			run_time=0.5						),			lag_ratio=0.2						)

																					self.play(_UpperCAmelCase						)

																					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:
																																			SCREAMING_SNAKE_CASE__       :      Tuple     =						0.7

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

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

																					SCREAMING_SNAKE_CASE__       :      Tuple     =						a_c
																					SCREAMING_SNAKE_CASE__       :      Dict     =						a_c.copy()

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

														SCREAMING_SNAKE_CASE__       :      Dict     =						MarkupText(F'''Inference on a model too large for GPU memory\nis successfully completed.''',			font_size=2_4						)
														step_a.move_to([2, 2, 0]						)

														self.play(Write(_UpperCAmelCase,			run_time=3						),			MoveToTarget(_UpperCAmelCase						)						)

														self.wait()













from __future__ import annotations

import math
from collections import Counter
from string import ascii_lowercase




def _a (  SCREAMING_SNAKE_CASE__      :  str       )	->    None:

							'''simple docstring'''






							SCREAMING_SNAKE_CASE__   ,SCREAMING_SNAKE_CASE__       :      Dict     =						analyze_text(SCREAMING_SNAKE_CASE__       )
							SCREAMING_SNAKE_CASE__       :      Tuple     =						list(" " + ascii_lowercase       )
							# what is our total sum of probabilities.
							SCREAMING_SNAKE_CASE__       :      str     =						sum(single_char_strings.values()       )

							# one length string
							SCREAMING_SNAKE_CASE__       :      str     =						0
							# for each alpha we go in our dict and if it is in it we calculate entropy
							for ch in my_alphas:
														if ch in single_char_strings:
																					SCREAMING_SNAKE_CASE__       :      Optional[int]     =						single_char_strings[ch]
																					SCREAMING_SNAKE_CASE__       :      Any     =						my_str / all_sum
																					my_fir_sum += prob * math.loga(SCREAMING_SNAKE_CASE__       )  # entropy formula.

    # print entropy
							print(f'''{round(-1 * my_fir_sum       ):.1f}'''       )

							# two len string
							SCREAMING_SNAKE_CASE__       :      Union[str, Any]     =						sum(two_char_strings.values()       )
							SCREAMING_SNAKE_CASE__       :      int     =						0
							# for each alpha (two in size) calculate entropy.
							for cha in my_alphas:
														for cha in my_alphas:
																					SCREAMING_SNAKE_CASE__       :      List[str]     =						cha + cha
																					if sequence in two_char_strings:
																												SCREAMING_SNAKE_CASE__       :      Optional[Any]     =						two_char_strings[sequence]
																												SCREAMING_SNAKE_CASE__       :      Tuple     =						int(SCREAMING_SNAKE_CASE__       ) / all_sum
																												my_sec_sum += prob * math.loga(SCREAMING_SNAKE_CASE__       )

    # print second entropy
							print(f'''{round(-1 * my_sec_sum       ):.1f}'''       )

							# print the difference between them
							print(f'''{round((-1 * my_sec_sum) - (-1 * my_fir_sum)       ):.1f}'''       )




def _a (  SCREAMING_SNAKE_CASE__      :  str       )	->    tuple[dict, dict]:

							'''simple docstring'''






							SCREAMING_SNAKE_CASE__       :      str     =						Counter()  # type: ignore
							SCREAMING_SNAKE_CASE__       :      Dict     =						Counter()  # type: ignore
							single_char_strings[text[-1]] += 1

							# first case when we have space at start.
							two_char_strings[" " + text[0]] += 1
							for i in range(0			,				len(SCREAMING_SNAKE_CASE__       ) - 1       ):
														single_char_strings[text[i]] += 1
														two_char_strings[text[i : i + 2]] += 1
							return single_char_strings, two_char_strings




def _a (  )	->    str:

							'''simple docstring'''






							import doctest

							doctest.testmod()
							# text = (
							#     "Had repulsive dashwoods suspicion sincerity but advantage now him. Remark "
							#     "easily garret nor nay. Civil those mrs enjoy shy fat merry. You greatest "
							#     "jointure saw horrible. He private he on be imagine suppose. Fertile "
							#     "beloved evident through no service elderly is. Blind there if every no so "
							#     "at. Own neglected you preferred way sincerity delivered his attempted. To "
							#     "of message cottage windows do besides against uncivil.  Delightful "
							#     "unreserved impossible few estimating men favourable see entreaties. She "
							#     "propriety immediate was improving. He or entrance humoured likewise "
							#     "moderate. Much nor game son say feel. Fat make met can must form into "
							#     "gate. Me we offending prevailed discovery. "
							# )

							# calculate_prob(text)


if __name__ == "__main__":
		main()






