


import argparse
import os
import re

import numpy as np
import PIL
import torch
from timm import create_model
from torch.optim.lr_scheduler import OneCycleLR
from torch.utils.data import DataLoader, Dataset
from torchvision.transforms import Compose, RandomResizedCrop, Resize, ToTensor

from accelerate import Accelerator



def     __lowerCAmelCase						(							snake_case	:    Optional[int] )       ->							str:
   __lowerCamelCase:				List[str]     =	fname.split(os.path.sep )[-1]
   return re.search(r"""^(.*)_\d+\.jpg$"""						,      snake_case ).groups()[0]



class        a					(			_UpperCAmelCase   ):





     def __init__(    self					:				Any    ,	SCREAMING_SNAKE_CASE_					:				Union[str, Any]    ,	SCREAMING_SNAKE_CASE_					:				Optional[Any]=None    ,	SCREAMING_SNAKE_CASE_					:				Dict=None							):
        __lowerCamelCase:				Union[str, Any]     =	file_names
        __lowerCamelCase:				Tuple     =	image_transform
        __lowerCamelCase:				int     =	label_to_id





     def __len__(    self					:				Union[str, Any]							):
        return len(self.file_names							)







     def __getitem__(    self					:				Optional[int]    ,	SCREAMING_SNAKE_CASE_					:				Union[str, Any]							):
        __lowerCamelCase:				Dict     =	self.file_names[idx]
        __lowerCamelCase:				str     =	PIL.Image.open(SCREAMING_SNAKE_CASE_							)
        __lowerCamelCase:				Tuple     =	raw_image.convert("""RGB"""							)
        if self.image_transform is not None:
           __lowerCamelCase:				Optional[int]     =	self.image_transform(SCREAMING_SNAKE_CASE_							)
        __lowerCamelCase:				Dict     =	extract_label(SCREAMING_SNAKE_CASE_							)
        if self.label_to_id is not None:
           __lowerCamelCase:				int     =	self.label_to_id[label]
        return {"image": image, "label": label}



def     __lowerCAmelCase						(							snake_case	:    Optional[Any]						,      snake_case	:    Union[str, Any] )       ->							Optional[int]:
   # Initialize accelerator
   if args.with_tracking:
      __lowerCamelCase:				Dict     =	Accelerator(
          cpu=args.cpu						,      mixed_precision=args.mixed_precision						,      log_with="""all"""						,      project_dir=args.project_dir )
   else:
      __lowerCamelCase:				Optional[int]     =	Accelerator(cpu=args.cpu						,      mixed_precision=args.mixed_precision )

   # Sample hyper-parameters for learning rate, batch size, seed and a few other HPs
   __lowerCamelCase:				List[Any]     =	config["""lr"""]
   __lowerCamelCase:				Union[str, Any]     =	int(config["""num_epochs"""] )
   __lowerCamelCase:				Optional[Any]     =	int(config["""seed"""] )
   __lowerCamelCase:				List[Any]     =	int(config["""batch_size"""] )
   __lowerCamelCase:				Dict     =	config["""image_size"""]
   if not isinstance(snake_case						,      (list, tuple) ):
      __lowerCamelCase:				Any     =	(image_size, image_size)

   # Parse out whether we are saving every epoch or after a certain number of batches
   if hasattr(args.checkpointing_steps						,      """isdigit""" ):
      if args.checkpointing_steps == "epoch":
         __lowerCamelCase:				Dict     =	args.checkpointing_steps
      elif args.checkpointing_steps.isdigit():
         __lowerCamelCase:				Dict     =	int(args.checkpointing_steps )
      else:
         raise ValueError(
             f'Argument `checkpointing_steps` must be either a number or `epoch`. `{args.checkpointing_steps}` passed.' )
   else:
      __lowerCamelCase:				Tuple     =	None

   # We need to initialize the trackers we use, and also store our configuration
   if args.with_tracking:
      __lowerCamelCase:				List[str]     =	os.path.split(snake_case )[-1].split(""".""" )[0]
      accelerator.init_trackers(snake_case						,      snake_case )

   # Grab all the image filenames
   __lowerCamelCase:				str     =	[os.path.join(args.data_dir						,      snake_case ) for fname in os.listdir(args.data_dir ) if fname.endswith(""".jpg""" )]

   # Build the label correspondences
   __lowerCamelCase:				List[Any]     =	[extract_label(snake_case ) for fname in file_names]
   __lowerCamelCase:				Tuple     =	list(set(snake_case ) )
   id_to_label.sort()
   __lowerCamelCase:				int     =	{lbl: i for i, lbl in enumerate(snake_case )}

   # Set the seed before splitting the data.
   np.random.seed(snake_case )
   torch.manual_seed(snake_case )
   torch.cuda.manual_seed_all(snake_case )

   # Split our filenames between train and validation
   __lowerCamelCase:				Tuple     =	np.random.permutation(len(snake_case ) )
   __lowerCamelCase:				Tuple     =	int(0.8 * len(snake_case ) )
   __lowerCamelCase:				Optional[int]     =	random_perm[:cut]
   __lowerCamelCase:				List[str]     =	random_perm[cut:]

   # For training we use a simple RandomResizedCrop
   __lowerCamelCase:				Union[str, Any]     =	Compose([RandomResizedCrop(snake_case						,      scale=(0.5, 1.0) ), ToTensor()] )
   __lowerCamelCase:				Tuple     =	PetsDataset(
       [file_names[i] for i in train_split]						,      image_transform=snake_case						,      label_to_id=snake_case )

   # For evaluation, we use a deterministic Resize
   __lowerCamelCase:				int     =	Compose([Resize(snake_case ), ToTensor()] )
   __lowerCamelCase:				int     =	PetsDataset([file_names[i] for i in eval_split]						,      image_transform=snake_case						,      label_to_id=snake_case )

   # Instantiate dataloaders.
   __lowerCamelCase:				Optional[int]     =	DataLoader(snake_case						,      shuffle=snake_case						,      batch_size=snake_case						,      num_workers=4 )
   __lowerCamelCase:				Union[str, Any]     =	DataLoader(snake_case						,      shuffle=snake_case						,      batch_size=snake_case						,      num_workers=4 )

   # Instantiate the model (we build the model here so that the seed also control new weights initialization)
   __lowerCamelCase:				Tuple     =	create_model("""resnet50d"""						,      pretrained=snake_case						,      num_classes=len(snake_case ) )

   # We could avoid this line since the accelerator is set with `device_placement=True` (default value).
   # Note that if you are placing tensors on devices manually, this line absolutely needs to be before the optimizer
   # creation otherwise training will not work on TPU (`accelerate` will kindly throw an error to make us aware of that).
   __lowerCamelCase:				Union[str, Any]     =	model.to(accelerator.device )

   # Freezing the base model
   for param in model.parameters():
      __lowerCamelCase:				Tuple     =	False
   for param in model.get_classifier().parameters():
      __lowerCamelCase:				Optional[int]     =	True

   # We normalize the batches of images to be a bit faster.
   __lowerCamelCase:				str     =	torch.tensor(model.default_cfg["""mean"""] )[None, :, None, None].to(accelerator.device )
   __lowerCamelCase:				Optional[Any]     =	torch.tensor(model.default_cfg["""std"""] )[None, :, None, None].to(accelerator.device )

   # Instantiate optimizer
   __lowerCamelCase:				str     =	torch.optim.Adam(params=model.parameters()						,      lr=lr / 25 )

   # Instantiate learning rate scheduler
   __lowerCamelCase:				Optional[Any]     =	OneCycleLR(optimizer=snake_case						,      max_lr=snake_case						,      epochs=snake_case						,      steps_per_epoch=len(snake_case ) )

   # Prepare everything
   # There is no specific order to remember, we just need to unpack the objects in the same order we gave them to the
   # prepare method.
   __lowerCamelCase   ,     __lowerCamelCase   ,     __lowerCamelCase   ,     __lowerCamelCase   ,     __lowerCamelCase:				Dict     =	accelerator.prepare(
       snake_case						,      snake_case						,      snake_case						,      snake_case						,      snake_case )
   # We need to keep track of how many total steps we have iterated over
   __lowerCamelCase:				List[Any]     =	0
   # We also need to keep track of the starting epoch so files are named properly
   __lowerCamelCase:				Dict     =	0

   # Potentially load in the weights and states from a previous save
   if args.resume_from_checkpoint:
      if args.resume_from_checkpoint is not None or args.resume_from_checkpoint != "":
         accelerator.print(f'Resumed from checkpoint: {args.resume_from_checkpoint}' )
         accelerator.load_state(args.resume_from_checkpoint )
         __lowerCamelCase:				Dict     =	os.path.basename(args.resume_from_checkpoint )
      else:
         # Get the most recent checkpoint
         __lowerCamelCase:				Union[str, Any]     =	[f.name for f in os.scandir(os.getcwd() ) if f.is_dir()]
         dirs.sort(key=os.path.getctime )
         __lowerCamelCase:				List[str]     =	dirs[-1]  # Sorts folders by date modified, most recent checkpoint is the last
      # Extract `epoch_{i}` or `step_{i}`
      __lowerCamelCase:				Optional[Any]     =	os.path.splitext(snake_case )[0]

      if "epoch" in training_difference:
         __lowerCamelCase:				List[str]     =	int(training_difference.replace("""epoch_"""						,      """""" ) ) + 1
         __lowerCamelCase:				Optional[int]     =	None
      else:
         __lowerCamelCase:				Optional[int]     =	int(training_difference.replace("""step_"""						,      """""" ) )
         __lowerCamelCase:				Any     =	resume_step // len(snake_case )
         resume_step -= starting_epoch * len(snake_case )

    # Now we train the model
   for epoch in range(snake_case						,      snake_case ):
      model.train()
      if args.with_tracking:
         __lowerCamelCase:				List[str]     =	0
      if args.resume_from_checkpoint and epoch == starting_epoch and resume_step is not None:
         # We need to skip steps until we reach the resumed step
         __lowerCamelCase:				int     =	accelerator.skip_first_batches(snake_case						,      snake_case )
         overall_step += resume_step
      else:
         # After the first iteration though, we need to go back to the original dataloader
         __lowerCamelCase:				str     =	train_dataloader
      for batch in active_dataloader:
         # We could avoid this line since we set the accelerator with `device_placement=True`.
         __lowerCamelCase:				Any     =	{k: v.to(accelerator.device ) for k, v in batch.items()}
         __lowerCamelCase:				Union[str, Any]     =	(batch["""image"""] - mean) / std
         __lowerCamelCase:				List[Any]     =	model(snake_case )
         __lowerCamelCase:				List[Any]     =	torch.nn.functional.cross_entropy(snake_case						,      batch["""label"""] )
         # We keep track of the loss at each epoch
         if args.with_tracking:
            total_loss += loss.detach().float()
         accelerator.backward(snake_case )
         optimizer.step()
         lr_scheduler.step()
         optimizer.zero_grad()
         overall_step += 1
         if isinstance(snake_case						,      snake_case ):
            __lowerCamelCase:				List[str]     =	f'step_{overall_step}'
            if overall_step % checkpointing_steps == 0:
               if args.output_dir is not None:
                  __lowerCamelCase:				List[str]     =	os.path.join(args.output_dir						,      snake_case )
               accelerator.save_state(snake_case )
      model.eval()
      __lowerCamelCase:				Optional[int]     =	0
      __lowerCamelCase:				Optional[int]     =	0
      for step, batch in enumerate(snake_case ):
         # We could avoid this line since we set the accelerator with `device_placement=True`.
         __lowerCamelCase:				List[str]     =	{k: v.to(accelerator.device ) for k, v in batch.items()}
         __lowerCamelCase:				List[str]     =	(batch["""image"""] - mean) / std
         with torch.no_grad():
            __lowerCamelCase:				Dict     =	model(snake_case )
         __lowerCamelCase:				List[str]     =	outputs.argmax(dim=-1 )
         __lowerCamelCase   ,     __lowerCamelCase:				List[str]     =	accelerator.gather_for_metrics((predictions, batch["""label"""]) )
         __lowerCamelCase:				Any     =	predictions == references
         num_elems += accurate_preds.shape[0]
         accurate += accurate_preds.long().sum()

      __lowerCamelCase:				Dict     =	accurate.item() / num_elems
      # Use accelerator.print to print only on the main process.
      accelerator.print(f'epoch {epoch}: {100 * eval_metric:.2f}' )
      if args.with_tracking:
         accelerator.log(
             {
                 """accuracy""": 100 * eval_metric,
                 """train_loss""": total_loss.item() / len(snake_case ),
                 """epoch""": epoch,
             }						,      step=snake_case						,      )
      if checkpointing_steps == "epoch":
         __lowerCamelCase:				str     =	f'epoch_{epoch}'
         if args.output_dir is not None:
            __lowerCamelCase:				int     =	os.path.join(args.output_dir						,      snake_case )
         accelerator.save_state(snake_case )

   if args.with_tracking:
      accelerator.end_training()



def     __lowerCAmelCase						(							)       ->							List[str]:
   __lowerCamelCase:				List[Any]     =	argparse.ArgumentParser(description="""Simple example of training script.""" )
   parser.add_argument("""--data_dir"""						,      required=snake_case						,      help="""The data folder on disk.""" )
   parser.add_argument("""--fp16"""						,      action="""store_true"""						,      help="""If passed, will use FP16 training.""" )
   parser.add_argument(
       """--mixed_precision"""						,      type=snake_case						,      default=snake_case						,      choices=["""no""", """fp16""", """bf16""", """fp8"""]						,      help="""Whether to use mixed precision. Choose"""
       """between fp16 and bf16 (bfloat16). Bf16 requires PyTorch >= 1.10."""
       """and an Nvidia Ampere GPU."""						,      )
   parser.add_argument("""--cpu"""						,      action="""store_true"""						,      help="""If passed, will train on the CPU.""" )
   parser.add_argument(
       """--checkpointing_steps"""						,      type=snake_case						,      default=snake_case						,      help="""Whether the various states should be saved at the end of every n steps, or 'epoch' for each epoch."""						,      )
   parser.add_argument(
       """--output_dir"""						,      type=snake_case						,      default="""."""						,      help="""Optional save directory where all checkpoint folders will be stored. Default is the current working directory."""						,      )
   parser.add_argument(
       """--resume_from_checkpoint"""						,      type=snake_case						,      default=snake_case						,      help="""If the training should continue from a checkpoint folder."""						,      )
   parser.add_argument(
       """--with_tracking"""						,      action="""store_true"""						,      help="""Whether to load in all available experiment trackers from the environment and use them for logging."""						,      )
   parser.add_argument(
       """--project_dir"""						,      type=snake_case						,      default="""logs"""						,      help="""Location on where to store experiment tracking logs` and relevent project information"""						,      )
   __lowerCamelCase:				Union[str, Any]     =	parser.parse_args()
   __lowerCamelCase:				Optional[int]     =	{"""lr""": 3e-2, """num_epochs""": 3, """seed""": 42, """batch_size""": 64, """image_size""": 224}
   training_function(snake_case						,      snake_case )


if __name__ == "__main__":
   main()






from manim import *



class        a					(			_UpperCAmelCase   ):





     def  SCREAMING_SNAKE_CASE__       (    self					:				int							):
        __lowerCamelCase:				int     =	Rectangle(height=0.5    ,	width=0.5							)
        __lowerCamelCase:				List[str]     =	Rectangle(height=0.25    ,	width=0.25							)
        __lowerCamelCase:				Optional[int]     =	Rectangle(height=0.46    ,	width=0.46							).set_stroke(width=0							)

        __lowerCamelCase:				str     =	[mem.copy() for i in range(6							)]
        __lowerCamelCase:				Dict     =	[mem.copy() for i in range(6							)]
        __lowerCamelCase:				Union[str, Any]     =	VGroup(*SCREAMING_SNAKE_CASE_							).arrange(SCREAMING_SNAKE_CASE_    ,	buff=0							)
        __lowerCamelCase:				Tuple     =	VGroup(*SCREAMING_SNAKE_CASE_							).arrange(SCREAMING_SNAKE_CASE_    ,	buff=0							)
        __lowerCamelCase:				Optional[int]     =	VGroup(SCREAMING_SNAKE_CASE_    ,	SCREAMING_SNAKE_CASE_							).arrange(SCREAMING_SNAKE_CASE_    ,	buff=0							)
        __lowerCamelCase:				Dict     =	Text("""CPU"""    ,	font_size=24							)
        __lowerCamelCase:				Any     =	Group(SCREAMING_SNAKE_CASE_    ,	SCREAMING_SNAKE_CASE_							).arrange(SCREAMING_SNAKE_CASE_    ,	buff=0.5    ,	aligned_edge=SCREAMING_SNAKE_CASE_							)
        cpu.move_to([-2.5, -0.5, 0]							)
        self.add(SCREAMING_SNAKE_CASE_							)

        __lowerCamelCase:				Optional[int]     =	[mem.copy() for i in range(4							)]
        __lowerCamelCase:				Optional[int]     =	VGroup(*SCREAMING_SNAKE_CASE_							).arrange(SCREAMING_SNAKE_CASE_    ,	buff=0							)
        __lowerCamelCase:				Dict     =	Text("""GPU"""    ,	font_size=24							)
        __lowerCamelCase:				Dict     =	Group(SCREAMING_SNAKE_CASE_    ,	SCREAMING_SNAKE_CASE_							).arrange(SCREAMING_SNAKE_CASE_    ,	buff=0.5    ,	aligned_edge=SCREAMING_SNAKE_CASE_							)
        gpu.move_to([-1, -1, 0]							)
        self.add(SCREAMING_SNAKE_CASE_							)

        __lowerCamelCase:				Any     =	[mem.copy() for i in range(6							)]
        __lowerCamelCase:				Dict     =	VGroup(*SCREAMING_SNAKE_CASE_							).arrange(SCREAMING_SNAKE_CASE_    ,	buff=0							)

        __lowerCamelCase:				List[Any]     =	Text("""Model"""    ,	font_size=24							)
        __lowerCamelCase:				Any     =	Group(SCREAMING_SNAKE_CASE_    ,	SCREAMING_SNAKE_CASE_							).arrange(SCREAMING_SNAKE_CASE_    ,	buff=0.5    ,	aligned_edge=SCREAMING_SNAKE_CASE_							)
        model.move_to([3, -1.0, 0]							)
        self.add(SCREAMING_SNAKE_CASE_							)

        __lowerCamelCase:				Tuple     =	[]
        __lowerCamelCase:				Any     =	[]
        __lowerCamelCase:				int     =	[]

        for i, rect in enumerate(SCREAMING_SNAKE_CASE_							):
           rect.set_stroke(SCREAMING_SNAKE_CASE_							)

           __lowerCamelCase:				int     =	Rectangle(height=0.46 / 4    ,	width=0.46 / 3							).set_stroke(width=0.0							).set_fill(SCREAMING_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=SCREAMING_SNAKE_CASE_							)
              cpu_target.set_x(cpu_target.get_x() + 0.1							)
           elif i == 3:
              cpu_target.next_to(model_cpu_arr[0]    ,	direction=SCREAMING_SNAKE_CASE_    ,	buff=0.0							)
           else:
              cpu_target.next_to(model_cpu_arr[i - 1]    ,	direction=SCREAMING_SNAKE_CASE_    ,	buff=0.0							)
           self.add(SCREAMING_SNAKE_CASE_							)
           model_cpu_arr.append(SCREAMING_SNAKE_CASE_							)

        self.add(*SCREAMING_SNAKE_CASE_    ,	*SCREAMING_SNAKE_CASE_    ,	*SCREAMING_SNAKE_CASE_							)

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

        __lowerCamelCase:				Tuple     =	Text("""Loaded Checkpoint"""    ,	font_size=24							)
        __lowerCamelCase:				Tuple     =	Group(SCREAMING_SNAKE_CASE_    ,	SCREAMING_SNAKE_CASE_							).arrange(SCREAMING_SNAKE_CASE_    ,	buff=0.5    ,	aligned_edge=SCREAMING_SNAKE_CASE_							)
        checkpoint.move_to([3, 0.5, 0]							)

        self.add(SCREAMING_SNAKE_CASE_							)

        __lowerCamelCase:				List[Any]     =	[]
        __lowerCamelCase:				Optional[int]     =	[]

        for i, rect in enumerate(SCREAMING_SNAKE_CASE_							):
           __lowerCamelCase:				Optional[int]     =	fill.copy().set_fill(SCREAMING_SNAKE_CASE_    ,	opacity=0.7							)
           target.move_to(SCREAMING_SNAKE_CASE_							)
           ckpt_arr.append(SCREAMING_SNAKE_CASE_							)

           __lowerCamelCase:				List[Any]     =	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(SCREAMING_SNAKE_CASE_							)
        self.add(*SCREAMING_SNAKE_CASE_    ,	*SCREAMING_SNAKE_CASE_							)

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

        __lowerCamelCase:				Dict     =	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(SCREAMING_SNAKE_CASE_    ,	SCREAMING_SNAKE_CASE_							)

        __lowerCamelCase:				Optional[int]     =	MarkupText(
            F'<span fgcolor=\'{BLUE}\'>●</span> Checkpoint'    ,	font_size=18    ,	)

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

        __lowerCamelCase:				Tuple     =	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]							)

        __lowerCamelCase:				List[Any]     =	[meta_mem.copy() for i in range(6							)]
        __lowerCamelCase:				Optional[int]     =	[meta_mem.copy() for i in range(6							)]
        __lowerCamelCase:				str     =	VGroup(*SCREAMING_SNAKE_CASE_							).arrange(SCREAMING_SNAKE_CASE_    ,	buff=0							)
        __lowerCamelCase:				Optional[int]     =	VGroup(*SCREAMING_SNAKE_CASE_							).arrange(SCREAMING_SNAKE_CASE_    ,	buff=0							)
        __lowerCamelCase:				List[str]     =	VGroup(SCREAMING_SNAKE_CASE_    ,	SCREAMING_SNAKE_CASE_							).arrange(SCREAMING_SNAKE_CASE_    ,	buff=0							)
        __lowerCamelCase:				Dict     =	Text("""Disk"""    ,	font_size=24							)
        __lowerCamelCase:				Any     =	Group(SCREAMING_SNAKE_CASE_    ,	SCREAMING_SNAKE_CASE_							).arrange(SCREAMING_SNAKE_CASE_    ,	buff=0.5    ,	aligned_edge=SCREAMING_SNAKE_CASE_							)
        disk.move_to([-4.0, -1.25, 0]							)
        self.play(Write(SCREAMING_SNAKE_CASE_    ,	run_time=3							)    ,	Write(SCREAMING_SNAKE_CASE_    ,	run_time=1							)    ,	Create(SCREAMING_SNAKE_CASE_    ,	run_time=1							)							)

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

        self.play(FadeOut(SCREAMING_SNAKE_CASE_							)							)

        __lowerCamelCase:				List[Any]     =	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(SCREAMING_SNAKE_CASE_    ,	run_time=3							)							)

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

        self.wait()


