Super-squash branch 'main' using huggingface_hub

.gitattributes

@@ -0,0 +1,62 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.avro filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.lz4 filter=lfs diff=lfs merge=lfs -text
+*.mds filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+# Audio files - uncompressed
+*.pcm filter=lfs diff=lfs merge=lfs -text
+*.sam filter=lfs diff=lfs merge=lfs -text
+*.raw filter=lfs diff=lfs merge=lfs -text
+# Audio files - compressed
+*.aac filter=lfs diff=lfs merge=lfs -text
+*.flac filter=lfs diff=lfs merge=lfs -text
+*.mp3 filter=lfs diff=lfs merge=lfs -text
+*.ogg filter=lfs diff=lfs merge=lfs -text
+*.wav filter=lfs diff=lfs merge=lfs -text
+# Image files - uncompressed
+*.bmp filter=lfs diff=lfs merge=lfs -text
+*.gif filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text
+*.tiff filter=lfs diff=lfs merge=lfs -text
+# Image files - compressed
+*.jpg filter=lfs diff=lfs merge=lfs -text
+*.jpeg filter=lfs diff=lfs merge=lfs -text
+*.webp filter=lfs diff=lfs merge=lfs -text
+# Video files - compressed
+*.mp4 filter=lfs diff=lfs merge=lfs -text
+*.webm filter=lfs diff=lfs merge=lfs -text
+nsfw_aio_v2/loss_log.db filter=lfs diff=lfs merge=lfs -text
+nsfw_aio_v2/loss_log.db-wal filter=lfs diff=lfs merge=lfs -text

BaseSDTrainProcess.py

@@ -0,0 +1,2561 @@
+import copy
+import glob
+import inspect
+import json
+import random
+import shutil
+from collections import OrderedDict
+import os
+import re
+import traceback
+from typing import Union, List, Optional
+
+import numpy as np
+import yaml
+from diffusers import T2IAdapter, ControlNetModel
+from diffusers.training_utils import compute_density_for_timestep_sampling
+from safetensors.torch import save_file, load_file
+# from lycoris.config import PRESET
+from torch.utils.data import DataLoader
+import torch
+import torch.backends.cuda
+from huggingface_hub import HfApi, interpreter_login
+from toolkit.memory_management import MemoryManager
+
+from toolkit.basic import value_map
+from toolkit.clip_vision_adapter import ClipVisionAdapter
+from toolkit.custom_adapter import CustomAdapter
+from toolkit.data_loader import get_dataloader_from_datasets, trigger_dataloader_setup_epoch
+from toolkit.data_transfer_object.data_loader import FileItemDTO, DataLoaderBatchDTO
+from toolkit.ema import ExponentialMovingAverage
+from toolkit.embedding import Embedding
+from toolkit.image_utils import show_tensors, show_latents, reduce_contrast
+from toolkit.ip_adapter import IPAdapter
+from toolkit.lora_special import LoRASpecialNetwork
+from toolkit.lorm import convert_diffusers_unet_to_lorm, count_parameters, print_lorm_extract_details, \
+	lorm_ignore_if_contains, lorm_parameter_threshold, LORM_TARGET_REPLACE_MODULE
+from toolkit.lycoris_special import LycorisSpecialNetwork
+from toolkit.models.decorator import Decorator
+from toolkit.network_mixins import Network
+from toolkit.optimizer import get_optimizer
+from toolkit.paths import CONFIG_ROOT
+from toolkit.progress_bar import ToolkitProgressBar
+from toolkit.reference_adapter import ReferenceAdapter
+from toolkit.sampler import get_sampler
+from toolkit.saving import save_t2i_from_diffusers, load_t2i_model, save_ip_adapter_from_diffusers, \
+	load_ip_adapter_model, load_custom_adapter_model
+
+from toolkit.scheduler import get_lr_scheduler
+from toolkit.sd_device_states_presets import get_train_sd_device_state_preset
+from toolkit.stable_diffusion_model import StableDiffusion
+
+from jobs.process import BaseTrainProcess
+from toolkit.metadata import get_meta_for_safetensors, load_metadata_from_safetensors, add_base_model_info_to_meta, \
+	parse_metadata_from_safetensors
+from toolkit.train_tools import get_torch_dtype, LearnableSNRGamma, apply_learnable_snr_gos, apply_snr_weight
+import gc
+
+from tqdm import tqdm
+
+from toolkit.config_modules import SaveConfig, LoggingConfig, SampleConfig, NetworkConfig, TrainConfig, ModelConfig, \
+	GenerateImageConfig, EmbeddingConfig, DatasetConfig, preprocess_dataset_raw_config, AdapterConfig, GuidanceConfig, validate_configs, \
+	DecoratorConfig
+from toolkit.logging_aitk import create_logger
+from diffusers import FluxTransformer2DModel
+from toolkit.accelerator import get_accelerator, unwrap_model
+from toolkit.print import print_acc
+from accelerate import Accelerator
+import transformers
+import diffusers
+import hashlib
+
+from toolkit.util.blended_blur_noise import get_blended_blur_noise
+from toolkit.util.get_model import get_model_class
+from toolkit.basic import flush
+
+
+class BaseSDTrainProcess(BaseTrainProcess):
+
+	def __init__(self, process_id: int, job, config: OrderedDict, custom_pipeline=None):
+		super().__init__(process_id, job, config)
+		self.accelerator: Accelerator = get_accelerator()
+		if self.accelerator.is_local_main_process:
+			transformers.utils.logging.set_verbosity_warning()
+			diffusers.utils.logging.set_verbosity_error()
+		else:
+			transformers.utils.logging.set_verbosity_error()
+			diffusers.utils.logging.set_verbosity_error()
+		
+		self.sd: StableDiffusion
+		self.embedding: Union[Embedding, None] = None
+
+		self.custom_pipeline = custom_pipeline
+		self.step_num = 0
+		self.start_step = 0
+		self.epoch_num = 0
+		self.last_save_step = 0
+		# start at 1 so we can do a sample at the start
+		self.grad_accumulation_step = 1
+		# if true, then we do not do an optimizer step. We are accumulating gradients
+		self.is_grad_accumulation_step = False
+		self.device = str(self.accelerator.device)
+		self.device_torch = self.accelerator.device
+		network_config = self.get_conf('network', None)
+		if network_config is not None:
+			self.network_config = NetworkConfig(**network_config)
+		else:
+			self.network_config = None
+		self.train_config = TrainConfig(**self.get_conf('train', {}))
+		model_config = self.get_conf('model', {})
+		self.modules_being_trained: List[torch.nn.Module] = []
+
+		# update modelconfig dtype to match train
+		model_config['dtype'] = self.train_config.dtype
+		self.model_config = ModelConfig(**model_config)
+
+		self.save_config = SaveConfig(**self.get_conf('save', {}))
+		self.sample_config = SampleConfig(**self.get_conf('sample', {}))
+		first_sample_config = self.get_conf('first_sample', None)
+		if first_sample_config is not None:
+			self.has_first_sample_requested = True
+			self.first_sample_config = SampleConfig(**first_sample_config)
+		else:
+			self.has_first_sample_requested = False
+			self.first_sample_config = self.sample_config
+		self.logging_config = LoggingConfig(**self.get_conf('logging', {}))
+		self.logger = create_logger(self.logging_config, config, self.save_root)
+		self.optimizer: torch.optim.Optimizer = None
+		self.lr_scheduler = None
+		self.data_loader: Union[DataLoader, None] = None
+		self.data_loader_reg: Union[DataLoader, None] = None
+		self.trigger_word = self.get_conf('trigger_word', None)
+
+		self.guidance_config: Union[GuidanceConfig, None] = None
+		guidance_config_raw = self.get_conf('guidance', None)
+		if guidance_config_raw is not None:
+			self.guidance_config = GuidanceConfig(**guidance_config_raw)
+
+		# store is all are cached. Allows us to not load vae if we don't need to
+		self.is_latents_cached = True
+		raw_datasets = self.get_conf('datasets', None)
+		if raw_datasets is not None and len(raw_datasets) > 0:
+			raw_datasets = preprocess_dataset_raw_config(raw_datasets)
+		self.datasets = None
+		self.datasets_reg = None
+		self.dataset_configs: List[DatasetConfig] = []
+		self.params = []
+		
+		# add dataset text embedding cache to their config
+		if self.train_config.cache_text_embeddings:
+			for raw_dataset in raw_datasets:
+				raw_dataset['cache_text_embeddings'] = True
+		
+		if raw_datasets is not None and len(raw_datasets) > 0:
+			for raw_dataset in raw_datasets:
+				dataset = DatasetConfig(**raw_dataset)
+				# handle trigger word per dataset
+				if dataset.trigger_word is None and self.trigger_word is not None:
+					dataset.trigger_word = self.trigger_word
+				is_caching = dataset.cache_latents or dataset.cache_latents_to_disk
+				if not is_caching:
+					self.is_latents_cached = False
+				if dataset.is_reg:
+					if self.datasets_reg is None:
+						self.datasets_reg = []
+					self.datasets_reg.append(dataset)
+				else:
+					if self.datasets is None:
+						self.datasets = []
+					self.datasets.append(dataset)
+				self.dataset_configs.append(dataset)
+		
+		self.is_caching_text_embeddings = any(
+			dataset.cache_text_embeddings for dataset in self.dataset_configs
+		)
+
+		self.embed_config = None
+		embedding_raw = self.get_conf('embedding', None)
+		if embedding_raw is not None:
+			self.embed_config = EmbeddingConfig(**embedding_raw)
+		
+		self.decorator_config: DecoratorConfig = None
+		decorator_raw = self.get_conf('decorator', None)
+		if decorator_raw is not None:
+			if not self.model_config.is_flux:
+				raise ValueError("Decorators are only supported for Flux models currently")
+			self.decorator_config = DecoratorConfig(**decorator_raw)
+
+		# t2i adapter
+		self.adapter_config = None
+		adapter_raw = self.get_conf('adapter', None)
+		if adapter_raw is not None:
+			self.adapter_config = AdapterConfig(**adapter_raw)
+			# sdxl adapters end in _xl. Only full_adapter_xl for now
+			if self.model_config.is_xl and not self.adapter_config.adapter_type.endswith('_xl'):
+				self.adapter_config.adapter_type += '_xl'
+
+		# to hold network if there is one
+		self.network: Union[Network, None] = None
+		self.adapter: Union[T2IAdapter, IPAdapter, ClipVisionAdapter, ReferenceAdapter, CustomAdapter, ControlNetModel, None] = None
+		self.embedding: Union[Embedding, None] = None
+		self.decorator: Union[Decorator, None] = None
+
+		is_training_adapter = self.adapter_config is not None and self.adapter_config.train
+
+		self.do_lorm = self.get_conf('do_lorm', False)
+		self.lorm_extract_mode = self.get_conf('lorm_extract_mode', 'ratio')
+		self.lorm_extract_mode_param = self.get_conf('lorm_extract_mode_param', 0.25)
+		# 'ratio', 0.25)
+
+		# get the device state preset based on what we are training
+		self.train_device_state_preset = get_train_sd_device_state_preset(
+			device=self.device_torch,
+			train_unet=self.train_config.train_unet,
+			train_text_encoder=self.train_config.train_text_encoder,
+			cached_latents=self.is_latents_cached,
+			train_lora=self.network_config is not None,
+			train_adapter=is_training_adapter,
+			train_embedding=self.embed_config is not None,
+			train_decorator=self.decorator_config is not None,
+			train_refiner=self.train_config.train_refiner,
+			unload_text_encoder=self.train_config.unload_text_encoder or self.is_caching_text_embeddings,
+			require_grads=False  # we ensure them later
+		)
+		
+		self.get_params_device_state_preset = get_train_sd_device_state_preset(
+			device=self.device_torch,
+			train_unet=self.train_config.train_unet,
+			train_text_encoder=self.train_config.train_text_encoder,
+			cached_latents=self.is_latents_cached,
+			train_lora=self.network_config is not None,
+			train_adapter=is_training_adapter,
+			train_embedding=self.embed_config is not None,
+			train_decorator=self.decorator_config is not None,
+			train_refiner=self.train_config.train_refiner,
+			unload_text_encoder=self.train_config.unload_text_encoder or self.is_caching_text_embeddings,
+			require_grads=True  # We check for grads when getting params
+		)
+
+		# fine_tuning here is for training actual SD network, not LoRA, embeddings, etc. it is (Dreambooth, etc)
+		self.is_fine_tuning = True
+		if self.network_config is not None or is_training_adapter or self.embed_config is not None or self.decorator_config is not None:
+			self.is_fine_tuning = False
+
+		self.named_lora = False
+		if self.embed_config is not None or is_training_adapter:
+			self.named_lora = True
+		self.snr_gos: Union[LearnableSNRGamma, None] = None
+		self.ema: ExponentialMovingAverage = None
+		
+		validate_configs(self.train_config, self.model_config, self.save_config, self.dataset_configs)
+		
+		do_profiler = self.get_conf('torch_profiler', False)
+		self.torch_profiler = None if not do_profiler else torch.profiler.profile(
+			activities=[
+				torch.profiler.ProfilerActivity.CPU,
+				torch.profiler.ProfilerActivity.CUDA,
+			],
+		)
+		
+		self.current_boundary_index = 0
+		self.steps_this_boundary = 0
+		self.num_consecutive_oom = 0
+
+	def post_process_generate_image_config_list(self, generate_image_config_list: List[GenerateImageConfig]):
+		# override in subclass
+		return generate_image_config_list
+
+	def sample(self, step=None, is_first=False):
+		if not self.accelerator.is_main_process:
+			return
+		flush()
+		sample_folder = os.path.join(self.save_root, 'samples')
+		gen_img_config_list = []
+
+		sample_config = self.first_sample_config if is_first else self.sample_config
+		start_seed = sample_config.seed
+		current_seed = start_seed
+
+		test_image_paths = []
+		if self.adapter_config is not None and self.adapter_config.test_img_path is not None:
+			test_image_path_list = self.adapter_config.test_img_path
+			# divide up images so they are evenly distributed across prompts
+			for i in range(len(sample_config.prompts)):
+				test_image_paths.append(test_image_path_list[i % len(test_image_path_list)])
+
+		for i in range(len(sample_config.prompts)):
+			if sample_config.walk_seed:
+				current_seed = start_seed + i
+
+			step_num = ''
+			if step is not None:
+				# zero-pad 9 digits
+				step_num = f"_{str(step).zfill(9)}"
+
+			filename = f"[time]_{step_num}_[count].{self.sample_config.ext}"
+
+			output_path = os.path.join(sample_folder, filename)
+
+			prompt = sample_config.prompts[i]
+
+			# add embedding if there is one
+			# note: diffusers will automatically expand the trigger to the number of added tokens
+			# ie test123 will become test123 test123_1 test123_2 etc. Do not add this yourself here
+			if self.embedding is not None:
+				prompt = self.embedding.inject_embedding_to_prompt(
+					prompt, expand_token=True, add_if_not_present=False
+				)
+			if self.adapter is not None and isinstance(self.adapter, ClipVisionAdapter):
+				prompt = self.adapter.inject_trigger_into_prompt(
+					prompt, expand_token=True, add_if_not_present=False
+				)
+			if self.trigger_word is not None:
+				prompt = self.sd.inject_trigger_into_prompt(
+					prompt, self.trigger_word, add_if_not_present=False
+				)
+
+			extra_args = {}
+			if self.adapter_config is not None and self.adapter_config.test_img_path is not None:
+				extra_args['adapter_image_path'] = test_image_paths[i]
+			
+			sample_item = sample_config.samples[i]
+			if sample_item.seed is not None:
+				current_seed = sample_item.seed
+
+			gen_img_config_list.append(GenerateImageConfig(
+				prompt=prompt,  # it will autoparse the prompt
+				width=sample_item.width,
+				height=sample_item.height,
+				negative_prompt=sample_item.neg,
+				seed=current_seed,
+				guidance_scale=sample_item.guidance_scale,
+				guidance_rescale=sample_config.guidance_rescale,
+				num_inference_steps=sample_item.sample_steps,
+				network_multiplier=sample_item.network_multiplier,
+				output_path=output_path,
+				output_ext=sample_config.ext,
+				adapter_conditioning_scale=sample_config.adapter_conditioning_scale,
+				refiner_start_at=sample_config.refiner_start_at,
+				extra_values=sample_config.extra_values,
+				logger=self.logger,
+				num_frames=sample_item.num_frames,
+				fps=sample_item.fps,
+				ctrl_img=sample_item.ctrl_img,
+				ctrl_idx=sample_item.ctrl_idx,
+				ctrl_img_1=sample_item.ctrl_img_1,
+				ctrl_img_2=sample_item.ctrl_img_2,
+				ctrl_img_3=sample_item.ctrl_img_3,
+				do_cfg_norm=sample_config.do_cfg_norm,
+				**extra_args
+			))
+
+		# post process
+		gen_img_config_list = self.post_process_generate_image_config_list(gen_img_config_list)
+
+		# if we have an ema, set it to validation mode
+		if self.ema is not None:
+			self.ema.eval()
+
+		# let adapter know we are sampling
+		if self.adapter is not None and isinstance(self.adapter, CustomAdapter):
+			self.adapter.is_sampling = True
+		
+		# send to be generated
+		self.sd.generate_images(gen_img_config_list, sampler=sample_config.sampler)
+
+		
+		if self.adapter is not None and isinstance(self.adapter, CustomAdapter):
+			self.adapter.is_sampling = False
+
+		if self.ema is not None:
+			self.ema.train()
+
+	def update_training_metadata(self):
+		o_dict = OrderedDict({
+			"training_info": self.get_training_info()
+		})
+		o_dict['ss_base_model_version'] = self.sd.get_base_model_version()
+
+		# o_dict = add_base_model_info_to_meta(
+		#     o_dict,
+		#     is_v2=self.model_config.is_v2,
+		#     is_xl=self.model_config.is_xl,
+		# )
+		o_dict['ss_output_name'] = self.job.name
+
+		if self.trigger_word is not None:
+			# just so auto1111 will pick it up
+			o_dict['ss_tag_frequency'] = {
+				f"1_{self.trigger_word}": {
+					f"{self.trigger_word}": 1
+				}
+			}
+
+		self.add_meta(o_dict)
+
+	def get_training_info(self):
+		info = OrderedDict({
+			'step': self.step_num,
+			'epoch': self.epoch_num,
+		})
+		return info
+
+	def clean_up_saves(self):
+		if not self.accelerator.is_main_process:
+			return
+		# remove old saves
+		# get latest saved step
+		latest_item = None
+		if os.path.exists(self.save_root):
+			# pattern is {job_name}_{zero_filled_step} for both files and directories
+			pattern = f"{self.job.name}_*"
+			items = glob.glob(os.path.join(self.save_root, pattern))
+			# Separate files and directories
+			safetensors_files = [f for f in items if f.endswith('.safetensors')]
+			pt_files = [f for f in items if f.endswith('.pt')]
+			directories = [d for d in items if os.path.isdir(d) and not d.endswith('.safetensors')]
+			embed_files = []
+			# do embedding files
+			if self.embed_config is not None:
+				embed_pattern = f"{self.embed_config.trigger}_*"
+				embed_items = glob.glob(os.path.join(self.save_root, embed_pattern))
+				# will end in safetensors or pt
+				embed_files = [f for f in embed_items if f.endswith('.safetensors') or f.endswith('.pt')]
+
+			# check for critic files
+			critic_pattern = f"CRITIC_{self.job.name}_*"
+			critic_items = glob.glob(os.path.join(self.save_root, critic_pattern))
+
+			# Sort the lists by creation time if they are not empty
+			if safetensors_files:
+				safetensors_files.sort(key=os.path.getctime)
+			if pt_files:
+				pt_files.sort(key=os.path.getctime)
+			if directories:
+				directories.sort(key=os.path.getctime)
+			if embed_files:
+				embed_files.sort(key=os.path.getctime)
+			if critic_items:
+				critic_items.sort(key=os.path.getctime)
+
+			# Combine and sort the lists
+			combined_items = safetensors_files + directories + pt_files
+			combined_items.sort(key=os.path.getctime)
+			
+			num_saves_to_keep = self.save_config.max_step_saves_to_keep
+			
+			if hasattr(self.sd, 'max_step_saves_to_keep_multiplier'):
+				num_saves_to_keep *= self.sd.max_step_saves_to_keep_multiplier
+
+			# Use slicing with a check to avoid 'NoneType' error
+			safetensors_to_remove = safetensors_files[
+									:-num_saves_to_keep] if safetensors_files else []
+			pt_files_to_remove = pt_files[:-num_saves_to_keep] if pt_files else []
+			directories_to_remove = directories[:-num_saves_to_keep] if directories else []
+			embeddings_to_remove = embed_files[:-num_saves_to_keep] if embed_files else []
+			critic_to_remove = critic_items[:-num_saves_to_keep] if critic_items else []
+
+			items_to_remove = safetensors_to_remove + pt_files_to_remove + directories_to_remove + embeddings_to_remove + critic_to_remove
+
+			# remove all but the latest max_step_saves_to_keep
+			# items_to_remove = combined_items[:-num_saves_to_keep]
+
+			# remove duplicates
+			items_to_remove = list(dict.fromkeys(items_to_remove))
+
+			for item in items_to_remove:
+				print_acc(f"Removing old save: {item}")
+				if os.path.isdir(item):
+					shutil.rmtree(item)
+				else:
+					os.remove(item)
+				# see if a yaml file with same name exists
+				yaml_file = os.path.splitext(item)[0] + ".yaml"
+				if os.path.exists(yaml_file):
+					os.remove(yaml_file)
+			if combined_items:
+				latest_item = combined_items[-1]
+		return latest_item
+
+	def post_save_hook(self, save_path):
+		# override in subclass
+		pass
+	
+	def done_hook(self):
+		pass
+	
+	def end_step_hook(self):
+		pass
+
+	def save(self, step=None):
+		if not self.accelerator.is_main_process:
+			return
+		flush()
+		if self.ema is not None:
+			# always save params as ema
+			self.ema.eval()
+
+		if not os.path.exists(self.save_root):
+			os.makedirs(self.save_root, exist_ok=True)
+
+		step_num = ''
+		if step is not None:
+			self.last_save_step = step
+			# zeropad 9 digits
+			step_num = f"_{str(step).zfill(9)}"
+
+		self.update_training_metadata()
+		filename = f'{self.job.name}{step_num}.safetensors'
+		file_path = os.path.join(self.save_root, filename)
+
+		save_meta = copy.deepcopy(self.meta)
+		# get extra meta
+		if self.adapter is not None and isinstance(self.adapter, CustomAdapter):
+			additional_save_meta = self.adapter.get_additional_save_metadata()
+			if additional_save_meta is not None:
+				for key, value in additional_save_meta.items():
+					save_meta[key] = value
+
+		# prepare meta
+		save_meta = get_meta_for_safetensors(save_meta, self.job.name)
+		if not self.is_fine_tuning and not self.train_config.merge_network_on_save:
+			if self.network is not None:
+				lora_name = self.job.name
+				if self.named_lora:
+					# add _lora to name
+					lora_name += '_LoRA'
+
+				filename = f'{lora_name}{step_num}.safetensors'
+				file_path = os.path.join(self.save_root, filename)
+				prev_multiplier = self.network.multiplier
+				self.network.multiplier = 1.0
+
+				# if we are doing embedding training as well, add that
+				embedding_dict = self.embedding.state_dict() if self.embedding else None
+				self.network.save_weights(
+					file_path,
+					dtype=get_torch_dtype(self.save_config.dtype),
+					metadata=save_meta,
+					extra_state_dict=embedding_dict
+				)
+				self.network.multiplier = prev_multiplier
+				# if we have an embedding as well, pair it with the network
+
+			# even if added to lora, still save the trigger version
+			if self.embedding is not None:
+				emb_filename = f'{self.embed_config.trigger}{step_num}.safetensors'
+				emb_file_path = os.path.join(self.save_root, emb_filename)
+				# for combo, above will get it
+				# set current step
+				self.embedding.step = self.step_num
+				# change filename to pt if that is set
+				if self.embed_config.save_format == "pt":
+					# replace extension
+					emb_file_path = os.path.splitext(emb_file_path)[0] + ".pt"
+				self.embedding.save(emb_file_path)
+			
+			if self.decorator is not None:
+				dec_filename = f'{self.job.name}{step_num}.safetensors'
+				dec_file_path = os.path.join(self.save_root, dec_filename)
+				decorator_state_dict = self.decorator.state_dict()
+				for key, value in decorator_state_dict.items():
+					if isinstance(value, torch.Tensor):
+						decorator_state_dict[key] = value.clone().to('cpu', dtype=get_torch_dtype(self.save_config.dtype))
+				save_file(
+					decorator_state_dict,
+					dec_file_path,
+					metadata=save_meta,
+				)
+
+			if self.adapter is not None and self.adapter_config.train:
+				adapter_name = self.job.name
+				if self.network_config is not None or self.embedding is not None:
+					# add _lora to name
+					if self.adapter_config.type == 't2i':
+						adapter_name += '_t2i'
+					elif self.adapter_config.type == 'control_net':
+						adapter_name += '_cn'
+					elif self.adapter_config.type == 'clip':
+						adapter_name += '_clip'
+					elif self.adapter_config.type.startswith('ip'):
+						adapter_name += '_ip'
+					else:
+						adapter_name += '_adapter'
+
+				filename = f'{adapter_name}{step_num}.safetensors'
+				file_path = os.path.join(self.save_root, filename)
+				# save adapter
+				state_dict = self.adapter.state_dict()
+				if self.adapter_config.type == 't2i':
+					save_t2i_from_diffusers(
+						state_dict,
+						output_file=file_path,
+						meta=save_meta,
+						dtype=get_torch_dtype(self.save_config.dtype)
+					)
+				elif self.adapter_config.type == 'control_net':
+					# save in diffusers format
+					name_or_path = file_path.replace('.safetensors', '')
+					# move it to the new dtype and cpu
+					orig_device = self.adapter.device
+					orig_dtype = self.adapter.dtype
+					self.adapter = self.adapter.to(torch.device('cpu'), dtype=get_torch_dtype(self.save_config.dtype))
+					self.adapter.save_pretrained(
+						name_or_path,
+						dtype=get_torch_dtype(self.save_config.dtype),
+						safe_serialization=True
+					)
+					meta_path = os.path.join(name_or_path, 'aitk_meta.yaml')
+					with open(meta_path, 'w') as f:
+						yaml.dump(self.meta, f)
+					# move it back
+					self.adapter = self.adapter.to(orig_device, dtype=orig_dtype)
+				else:
+					direct_save = False
+					if self.adapter_config.train_only_image_encoder:
+						direct_save = True
+					elif isinstance(self.adapter, CustomAdapter):
+						direct_save = self.adapter.do_direct_save
+					save_ip_adapter_from_diffusers(
+						state_dict,
+						output_file=file_path,
+						meta=save_meta,
+						dtype=get_torch_dtype(self.save_config.dtype),
+						direct_save=direct_save
+					)
+		else:
+			if self.network is not None and self.train_config.merge_network_on_save:
+				# merge the network weights into a full model and save that
+				if not self.network.can_merge_in:
+					raise ValueError("Network cannot merge in weights. Cannot save full model.")
+				
+				print_acc("Merging network weights into full model for saving...")
+				
+				self.network.merge_in(merge_weight=self.train_config.merge_network_on_save_strength)
+				# reset weights to zero
+				self.network.reset_weights()
+				self.network.is_merged_in = False
+				
+				print_acc("Done merging network weights.")
+				
+			if self.save_config.save_format == "diffusers":
+				# saving as a folder path
+				file_path = file_path.replace('.safetensors', '')
+				# convert it back to normal object
+				save_meta = parse_metadata_from_safetensors(save_meta)
+
+			if self.sd.refiner_unet and self.train_config.train_refiner:
+				# save refiner
+				refiner_name = self.job.name + '_refiner'
+				filename = f'{refiner_name}{step_num}.safetensors'
+				file_path = os.path.join(self.save_root, filename)
+				self.sd.save_refiner(
+					file_path,
+					save_meta,
+					get_torch_dtype(self.save_config.dtype)
+				)
+			if self.train_config.train_unet or self.train_config.train_text_encoder:
+				self.sd.save(
+					file_path,
+					save_meta,
+					get_torch_dtype(self.save_config.dtype)
+				)
+
+		# save learnable params as json if we have thim
+		if self.snr_gos:
+			json_data = {
+				'offset_1': self.snr_gos.offset_1.item(),
+				'offset_2': self.snr_gos.offset_2.item(),
+				'scale': self.snr_gos.scale.item(),
+				'gamma': self.snr_gos.gamma.item(),
+			}
+			path_to_save = file_path = os.path.join(self.save_root, 'learnable_snr.json')
+			with open(path_to_save, 'w') as f:
+				json.dump(json_data, f, indent=4)
+		
+		print_acc(f"Saved checkpoint to {file_path}")
+
+		# save optimizer
+		if self.optimizer is not None:
+			try:
+				filename = f'optimizer.pt'
+				file_path = os.path.join(self.save_root, filename)
+				try:
+					state_dict = unwrap_model(self.optimizer).state_dict()
+				except Exception as e:
+					state_dict = self.optimizer.state_dict()
+				torch.save(state_dict, file_path)
+				print_acc(f"Saved optimizer to {file_path}")
+			except Exception as e:
+				print_acc(e)
+				print_acc("Could not save optimizer")
+
+		self.clean_up_saves()
+		self.post_save_hook(file_path)
+
+		if self.ema is not None:
+			self.ema.train()
+		flush()
+
+	# Called before the model is loaded
+	def hook_before_model_load(self):
+		# override in subclass
+		pass
+
+	def hook_after_model_load(self):
+		# override in subclass
+		pass
+
+	def hook_add_extra_train_params(self, params):
+		# override in subclass
+		return params
+
+	def hook_before_train_loop(self):
+		if self.accelerator.is_main_process:
+			self.logger.start()
+		self.prepare_accelerator()
+		
+	def sample_step_hook(self, img_num, total_imgs):
+		pass
+	
+	def prepare_accelerator(self):
+		# set some config
+		self.accelerator.even_batches=False
+		
+		# # prepare all the models stuff for accelerator (hopefully we dont miss any)
+		self.sd.vae = self.accelerator.prepare(self.sd.vae)
+		if self.sd.unet is not None:
+			self.sd.unet = self.accelerator.prepare(self.sd.unet)
+			# todo always tdo it?
+			self.modules_being_trained.append(self.sd.unet)
+		if self.sd.text_encoder is not None and self.train_config.train_text_encoder:
+			if isinstance(self.sd.text_encoder, list):
+				self.sd.text_encoder = [self.accelerator.prepare(model) for model in self.sd.text_encoder]
+				self.modules_being_trained.extend(self.sd.text_encoder)
+			else:
+				self.sd.text_encoder = self.accelerator.prepare(self.sd.text_encoder)
+				self.modules_being_trained.append(self.sd.text_encoder)
+		if self.sd.refiner_unet is not None and self.train_config.train_refiner:
+			self.sd.refiner_unet = self.accelerator.prepare(self.sd.refiner_unet)
+			self.modules_being_trained.append(self.sd.refiner_unet)
+		# todo, do we need to do the network or will "unet" get it?
+		if self.sd.network is not None:
+			self.sd.network = self.accelerator.prepare(self.sd.network)
+			self.modules_being_trained.append(self.sd.network)
+		if self.adapter is not None and self.adapter_config.train:
+			# todo adapters may not be a module. need to check
+			self.adapter = self.accelerator.prepare(self.adapter)
+			self.modules_being_trained.append(self.adapter)
+		
+		# prepare other things
+		self.optimizer = self.accelerator.prepare(self.optimizer)
+		if self.lr_scheduler is not None:
+			self.lr_scheduler = self.accelerator.prepare(self.lr_scheduler)
+		# self.data_loader = self.accelerator.prepare(self.data_loader)
+		# if self.data_loader_reg is not None:
+		#     self.data_loader_reg = self.accelerator.prepare(self.data_loader_reg)
+			
+
+	def ensure_params_requires_grad(self, force=False):
+		if self.train_config.do_paramiter_swapping and not force:
+			# the optimizer will handle this if we are not forcing
+			return
+		for group in self.params:
+			for param in group['params']:
+				if isinstance(param, torch.nn.Parameter):  # Ensure it's a proper parameter
+					param.requires_grad_(True)
+
+	def setup_ema(self):
+		if self.train_config.ema_config.use_ema:
+			# our params are in groups. We need them as a single iterable
+			params = []
+			for group in self.optimizer.param_groups:
+				for param in group['params']:
+					params.append(param)
+			self.ema = ExponentialMovingAverage(
+				params,
+				decay=self.train_config.ema_config.ema_decay,
+				use_feedback=self.train_config.ema_config.use_feedback,
+				param_multiplier=self.train_config.ema_config.param_multiplier,
+			)
+
+	def before_dataset_load(self):
+		pass
+
+	def get_params(self):
+		# you can extend this in subclass to get params
+		# otherwise params will be gathered through normal means
+		return None
+
+	def hook_train_loop(self, batch):
+		# return loss
+		return 0.0
+	
+	def hook_after_sd_init_before_load(self):
+		pass
+
+	def get_latest_save_path(self, name=None, post=''):
+		if name == None:
+			name = self.job.name
+		# get latest saved step
+		latest_path = None
+		if os.path.exists(self.save_root):
+			# Define patterns for both files and directories
+			patterns = [
+				f"{name}*{post}.safetensors",
+				f"{name}*{post}.pt",
+				f"{name}*{post}"
+			]
+			# Search for both files and directories
+			paths = []
+			for pattern in patterns:
+				paths.extend(glob.glob(os.path.join(self.save_root, pattern)))
+
+			# Filter out non-existent paths and sort by creation time
+			if paths:
+				paths = [p for p in paths if os.path.exists(p)]
+				# remove false positives
+				if '_LoRA' not in name:
+					paths = [p for p in paths if '_LoRA' not in p]
+				if '_refiner' not in name:
+					paths = [p for p in paths if '_refiner' not in p]
+				if '_t2i' not in name:
+					paths = [p for p in paths if '_t2i' not in p]
+				if '_cn' not in name:
+					paths = [p for p in paths if '_cn' not in p]
+
+				if len(paths) > 0:
+					latest_path = max(paths, key=os.path.getctime)
+		
+		if latest_path is None and self.network_config is not None and self.network_config.pretrained_lora_path is not None:
+			# set pretrained lora path as load path if we do not have a checkpoint to resume from
+			if os.path.exists(self.network_config.pretrained_lora_path):
+				latest_path = self.network_config.pretrained_lora_path
+				print_acc(f"Using pretrained lora path from config: {latest_path}")
+			else:
+				# no pretrained lora found
+				print_acc(f"Pretrained lora path from config does not exist: {self.network_config.pretrained_lora_path}")
+
+		return latest_path
+
+	def load_training_state_from_metadata(self, path):
+		if not self.accelerator.is_main_process:
+			return
+		if path is not None and self.network_config is not None and path == self.network_config.pretrained_lora_path:
+			# dont load metadata from pretrained lora
+			return
+		meta = None
+		# if path is folder, then it is diffusers
+		if os.path.isdir(path):
+			meta_path = os.path.join(path, 'aitk_meta.yaml')
+			# load it
+			if os.path.exists(meta_path):
+				with open(meta_path, 'r') as f:
+					meta = yaml.load(f, Loader=yaml.FullLoader)
+		else:
+			meta = load_metadata_from_safetensors(path)
+		# if 'training_info' in Orderdict keys
+		if meta is not None and 'training_info' in meta and 'step' in meta['training_info'] and self.train_config.start_step is None:
+			self.step_num = meta['training_info']['step']
+			if 'epoch' in meta['training_info']:
+				self.epoch_num = meta['training_info']['epoch']
+			self.start_step = self.step_num
+			print_acc(f"Found step {self.step_num} in metadata, starting from there")
+
+	def load_weights(self, path):
+		if self.network is not None:
+			extra_weights = self.network.load_weights(path)
+			self.load_training_state_from_metadata(path)
+			return extra_weights
+		else:
+			print_acc("load_weights not implemented for non-network models")
+			return None
+
+	def apply_snr(self, seperated_loss, timesteps):
+		if self.train_config.learnable_snr_gos:
+			# add snr_gamma
+			seperated_loss = apply_learnable_snr_gos(seperated_loss, timesteps, self.snr_gos)
+		elif self.train_config.snr_gamma is not None and self.train_config.snr_gamma > 0.000001:
+			# add snr_gamma
+			seperated_loss = apply_snr_weight(seperated_loss, timesteps, self.sd.noise_scheduler, self.train_config.snr_gamma, fixed=True)
+		elif self.train_config.min_snr_gamma is not None and self.train_config.min_snr_gamma > 0.000001:
+			# add min_snr_gamma
+			seperated_loss = apply_snr_weight(seperated_loss, timesteps, self.sd.noise_scheduler, self.train_config.min_snr_gamma)
+
+		return seperated_loss
+
+	def load_lorm(self):
+		latest_save_path = self.get_latest_save_path()
+		if latest_save_path is not None:
+			# hacky way to reload weights for now
+			# todo, do this
+			state_dict = load_file(latest_save_path, device=self.device)
+			self.sd.unet.load_state_dict(state_dict)
+
+			meta = load_metadata_from_safetensors(latest_save_path)
+			# if 'training_info' in Orderdict keys
+			if 'training_info' in meta and 'step' in meta['training_info']:
+				self.step_num = meta['training_info']['step']
+				if 'epoch' in meta['training_info']:
+					self.epoch_num = meta['training_info']['epoch']
+				self.start_step = self.step_num
+				print_acc(f"Found step {self.step_num} in metadata, starting from there")
+
+	# def get_sigmas(self, timesteps, n_dim=4, dtype=torch.float32):
+	#     self.sd.noise_scheduler.set_timesteps(1000, device=self.device_torch)
+	#     sigmas = self.sd.noise_scheduler.sigmas.to(device=self.device_torch, dtype=dtype)
+	#     schedule_timesteps = self.sd.noise_scheduler.timesteps.to(self.device_torch, )
+	#     timesteps = timesteps.to(self.device_torch, )
+	#
+	#     # step_indices = [(schedule_timesteps == t).nonzero().item() for t in timesteps]
+	#     step_indices = [t for t in timesteps]
+	#
+	#     sigma = sigmas[step_indices].flatten()
+	#     while len(sigma.shape) < n_dim:
+	#         sigma = sigma.unsqueeze(-1)
+	#     return sigma
+
+	def load_additional_training_modules(self, params):
+		# override in subclass
+		return params
+
+	def get_sigmas(self, timesteps, n_dim=4, dtype=torch.float32):
+		sigmas = self.sd.noise_scheduler.sigmas.to(device=self.device, dtype=dtype)
+		schedule_timesteps = self.sd.noise_scheduler.timesteps.to(self.device)
+		timesteps = timesteps.to(self.device)
+
+		step_indices = [(schedule_timesteps == t).nonzero().item() for t in timesteps]
+
+		sigma = sigmas[step_indices].flatten()
+		while len(sigma.shape) < n_dim:
+			sigma = sigma.unsqueeze(-1)
+		return sigma
+	
+	def get_optimal_noise(self, latents, dtype=torch.float32):
+		batch_num = latents.shape[0]
+		chunks = torch.chunk(latents, batch_num, dim=0)
+		noise_chunks = []
+		for chunk in chunks:
+			noise_samples = [torch.randn_like(chunk, device=chunk.device, dtype=dtype) for _ in range(self.train_config.optimal_noise_pairing_samples)]
+			# find the one most similar to the chunk
+			lowest_loss = 999999999999
+			best_noise = None
+			for noise in noise_samples:
+				loss = torch.nn.functional.mse_loss(chunk, noise)
+				if loss < lowest_loss:
+					lowest_loss = loss
+					best_noise = noise
+			noise_chunks.append(best_noise)
+		noise = torch.cat(noise_chunks, dim=0)
+		return noise
+	
+	def get_consistent_noise(self, latents, batch: 'DataLoaderBatchDTO', dtype=torch.float32):
+		batch_num = latents.shape[0]
+		chunks = torch.chunk(latents, batch_num, dim=0)
+		noise_chunks = []
+		for idx, chunk in enumerate(chunks):
+			# get seed from path
+			file_item = batch.file_items[idx]
+			img_path = file_item.path
+			# add augmentors
+			if file_item.flip_x:
+				img_path += '_fx'
+			if file_item.flip_y:
+				img_path += '_fy'
+			seed = int(hashlib.md5(img_path.encode()).hexdigest(), 16) & 0xffffffff
+			generator = torch.Generator("cpu").manual_seed(seed)
+			noise_chunk = torch.randn(chunk.shape, generator=generator).to(chunk.device, dtype=dtype)
+			noise_chunks.append(noise_chunk)
+		noise = torch.cat(noise_chunks, dim=0).to(dtype=dtype)
+		return noise
+			
+
+	def get_noise(
+		self, 
+		latents, 
+		batch_size, 
+		dtype=torch.float32, 
+		batch: 'DataLoaderBatchDTO' = None,
+		timestep=None,
+	):
+		if self.train_config.optimal_noise_pairing_samples > 1:
+			noise = self.get_optimal_noise(latents, dtype=dtype)
+		elif self.train_config.force_consistent_noise:
+			if batch is None:
+				raise ValueError("Batch must be provided for consistent noise")
+			noise = self.get_consistent_noise(latents, batch, dtype=dtype)
+		else:
+			if hasattr(self.sd, 'get_latent_noise_from_latents'):
+				noise = self.sd.get_latent_noise_from_latents(
+					latents,
+					noise_offset=self.train_config.noise_offset
+				).to(self.device_torch, dtype=dtype)
+			else:
+				# get noise
+				noise = self.sd.get_latent_noise(
+					height=latents.shape[2],
+					width=latents.shape[3],
+					num_channels=latents.shape[1],
+					batch_size=batch_size,
+					noise_offset=self.train_config.noise_offset,
+				).to(self.device_torch, dtype=dtype)
+		
+		if self.train_config.blended_blur_noise:
+			noise = get_blended_blur_noise(
+				latents, noise, timestep
+			)
+
+		return noise
+
+	def process_general_training_batch(self, batch: 'DataLoaderBatchDTO'):
+		with torch.no_grad():
+			with self.timer('prepare_prompt'):
+				prompts = batch.get_caption_list()
+				is_reg_list = batch.get_is_reg_list()
+
+				is_any_reg = any([is_reg for is_reg in is_reg_list])
+
+				do_double = self.train_config.short_and_long_captions and not is_any_reg
+
+				if self.train_config.short_and_long_captions and do_double:
+					# dont do this with regs. No point
+
+					# double batch and add short captions to the end
+					prompts = prompts + batch.get_caption_short_list()
+					is_reg_list = is_reg_list + is_reg_list
+				if self.model_config.refiner_name_or_path is not None and self.train_config.train_unet:
+					prompts = prompts + prompts
+					is_reg_list = is_reg_list + is_reg_list
+
+				conditioned_prompts = []
+
+				for prompt, is_reg in zip(prompts, is_reg_list):
+
+					# make sure the embedding is in the prompts
+					if self.embedding is not None:
+						prompt = self.embedding.inject_embedding_to_prompt(
+							prompt,
+							expand_token=True,
+							add_if_not_present=not is_reg,
+						)
+
+					if self.adapter and isinstance(self.adapter, ClipVisionAdapter):
+						prompt = self.adapter.inject_trigger_into_prompt(
+							prompt,
+							expand_token=True,
+							add_if_not_present=not is_reg,
+						)
+
+					# make sure trigger is in the prompts if not a regularization run
+					if self.trigger_word is not None:
+						prompt = self.sd.inject_trigger_into_prompt(
+							prompt,
+							trigger=self.trigger_word,
+							add_if_not_present=not is_reg,
+						)
+
+					if not is_reg and self.train_config.prompt_saturation_chance > 0.0:
+						# do random prompt saturation by expanding the prompt to hit at least 77 tokens
+						if random.random() < self.train_config.prompt_saturation_chance:
+							est_num_tokens = len(prompt.split(' '))
+							if est_num_tokens < 77:
+								num_repeats = int(77 / est_num_tokens) + 1
+								prompt = ', '.join([prompt] * num_repeats)
+
+
+					conditioned_prompts.append(prompt)
+
+			with self.timer('prepare_latents'):
+				dtype = get_torch_dtype(self.train_config.dtype)
+				imgs = None
+				is_reg = any(batch.get_is_reg_list())
+				if batch.tensor is not None:
+					imgs = batch.tensor
+					imgs = imgs.to(self.device_torch, dtype=dtype)
+					# dont adjust for regs.
+					if self.train_config.img_multiplier is not None and not is_reg:
+						# do it ad contrast
+						imgs = reduce_contrast(imgs, self.train_config.img_multiplier)
+				if batch.latents is not None:
+					latents = batch.latents.to(self.device_torch, dtype=dtype)
+					batch.latents = latents
+				else:
+					# normalize to
+					if self.train_config.standardize_images:
+						if self.sd.is_xl or self.sd.is_vega or self.sd.is_ssd:
+							target_mean_list = [0.0002, -0.1034, -0.1879]
+							target_std_list = [0.5436, 0.5116, 0.5033]
+						else:
+							target_mean_list = [-0.0739, -0.1597, -0.2380]
+							target_std_list = [0.5623, 0.5295, 0.5347]
+						# Mean: tensor([-0.0739, -0.1597, -0.2380])
+						# Standard Deviation: tensor([0.5623, 0.5295, 0.5347])
+						imgs_channel_mean = imgs.mean(dim=(2, 3), keepdim=True)
+						imgs_channel_std = imgs.std(dim=(2, 3), keepdim=True)
+						imgs = (imgs - imgs_channel_mean) / imgs_channel_std
+						target_mean = torch.tensor(target_mean_list, device=self.device_torch, dtype=dtype)
+						target_std = torch.tensor(target_std_list, device=self.device_torch, dtype=dtype)
+						# expand them to match dim
+						target_mean = target_mean.unsqueeze(0).unsqueeze(2).unsqueeze(3)
+						target_std = target_std.unsqueeze(0).unsqueeze(2).unsqueeze(3)
+
+						imgs = imgs * target_std + target_mean
+						batch.tensor = imgs
+
+						# show_tensors(imgs, 'imgs')
+
+					latents = self.sd.encode_images(imgs)
+					batch.latents = latents
+
+				if self.train_config.standardize_latents:
+					if self.sd.is_xl or self.sd.is_vega or self.sd.is_ssd:
+						target_mean_list = [-0.1075, 0.0231, -0.0135, 0.2164]
+						target_std_list = [0.8979, 0.7505, 0.9150, 0.7451]
+					else:
+						target_mean_list = [0.2949, -0.3188, 0.0807, 0.1929]
+						target_std_list = [0.8560, 0.9629, 0.7778, 0.6719]
+
+					latents_channel_mean = latents.mean(dim=(2, 3), keepdim=True)
+					latents_channel_std = latents.std(dim=(2, 3), keepdim=True)
+					latents = (latents - latents_channel_mean) / latents_channel_std
+					target_mean = torch.tensor(target_mean_list, device=self.device_torch, dtype=dtype)
+					target_std = torch.tensor(target_std_list, device=self.device_torch, dtype=dtype)
+					# expand them to match dim
+					target_mean = target_mean.unsqueeze(0).unsqueeze(2).unsqueeze(3)
+					target_std = target_std.unsqueeze(0).unsqueeze(2).unsqueeze(3)
+
+					latents = latents * target_std + target_mean
+					batch.latents = latents
+
+					# show_latents(latents, self.sd.vae, 'latents')
+
+
+				if batch.unconditional_tensor is not None and batch.unconditional_latents is None:
+					unconditional_imgs = batch.unconditional_tensor
+					unconditional_imgs = unconditional_imgs.to(self.device_torch, dtype=dtype)
+					unconditional_latents = self.sd.encode_images(unconditional_imgs)
+					batch.unconditional_latents = unconditional_latents * self.train_config.latent_multiplier
+
+				unaugmented_latents = None
+				if self.train_config.loss_target == 'differential_noise':
+					# we determine noise from the differential of the latents
+					unaugmented_latents = self.sd.encode_images(batch.unaugmented_tensor)
+
+			with self.timer('prepare_scheduler'):
+				
+				batch_size = len(batch.file_items)
+				min_noise_steps = self.train_config.min_denoising_steps
+				max_noise_steps = self.train_config.max_denoising_steps
+				if self.model_config.refiner_name_or_path is not None:
+					# if we are not training the unet, then we are only doing refiner and do not need to double up
+					if self.train_config.train_unet:
+						max_noise_steps = round(self.train_config.max_denoising_steps * self.model_config.refiner_start_at)
+						do_double = True
+					else:
+						min_noise_steps = round(self.train_config.max_denoising_steps * self.model_config.refiner_start_at)
+						do_double = False
+
+				num_train_timesteps = self.train_config.num_train_timesteps
+
+				if self.train_config.noise_scheduler in ['custom_lcm']:
+					# we store this value on our custom one
+					self.sd.noise_scheduler.set_timesteps(
+						self.sd.noise_scheduler.train_timesteps, device=self.device_torch
+					)
+				elif self.train_config.noise_scheduler in ['lcm']:
+					self.sd.noise_scheduler.set_timesteps(
+						num_train_timesteps, device=self.device_torch, original_inference_steps=num_train_timesteps
+					)
+				elif self.train_config.noise_scheduler == 'flowmatch':
+					linear_timesteps = any([
+						self.train_config.linear_timesteps,
+						self.train_config.linear_timesteps2,
+						self.train_config.timestep_type == 'linear',
+						self.train_config.timestep_type == 'one_step',
+					])
+					
+					timestep_type = 'linear' if linear_timesteps else None
+					if timestep_type is None:
+						timestep_type = self.train_config.timestep_type
+					
+					if self.train_config.timestep_type == 'next_sample':
+						# simulate a sample
+						num_train_timesteps = self.train_config.next_sample_timesteps
+						timestep_type = 'shift'
+					
+					patch_size = 1
+					if self.sd.is_flux or 'flex' in self.sd.arch:
+						# flux is a patch size of 1, but latents are divided by 2, so we need to double it
+						patch_size = 2
+					elif hasattr(self.sd.unet, 'config') and hasattr(self.sd.unet.config, 'patch_size'):
+						patch_size = self.sd.unet.config.patch_size
+					
+					self.sd.noise_scheduler.set_train_timesteps(
+						num_train_timesteps,
+						device=self.device_torch,
+						timestep_type=timestep_type,
+						latents=latents,
+						patch_size=patch_size,
+					)
+				else:
+					self.sd.noise_scheduler.set_timesteps(
+						num_train_timesteps, device=self.device_torch
+					)
+			if self.sd.is_multistage:
+				with self.timer('adjust_multistage_timesteps'):
+					# get our current sample range
+					boundaries = [1] + self.sd.multistage_boundaries
+					boundary_max, boundary_min = boundaries[self.current_boundary_index], boundaries[self.current_boundary_index + 1]
+					asc_timesteps = torch.flip(self.sd.noise_scheduler.timesteps, dims=[0])
+					lo = len(asc_timesteps) - torch.searchsorted(asc_timesteps, torch.tensor(boundary_max * 1000, device=asc_timesteps.device), right=False)
+					hi = len(asc_timesteps) - torch.searchsorted(asc_timesteps, torch.tensor(boundary_min * 1000, device=asc_timesteps.device), right=True)
+					first_idx = (lo - 1).item() if hi > lo else 0
+					last_idx  = (hi - 1).item() if hi > lo else 999
+					min_noise_steps = first_idx
+					max_noise_steps = last_idx
+
+			# clip min max indicies
+			min_noise_steps = max(min_noise_steps, 0)
+			max_noise_steps = min(max_noise_steps, num_train_timesteps - 1)
+			
+					
+			with self.timer('prepare_timesteps_indices'):
+
+				content_or_style = self.train_config.content_or_style
+				if is_reg:
+					content_or_style = self.train_config.content_or_style_reg
+
+				# if self.train_config.timestep_sampling == 'style' or self.train_config.timestep_sampling == 'content':
+				if self.train_config.timestep_type == 'next_sample':
+					timestep_indices = torch.randint(
+							0,
+							num_train_timesteps - 2, # -1 for 0 idx, -1 so we can step
+							(batch_size,),
+							device=self.device_torch
+						)
+					timestep_indices = timestep_indices.long()
+				elif self.train_config.timestep_type == 'one_step':
+					timestep_indices = torch.zeros((batch_size,), device=self.device_torch, dtype=torch.long)
+				elif content_or_style in ['style', 'content']:
+					# this is from diffusers training code
+					# Cubic sampling for favoring later or earlier timesteps
+					# For more details about why cubic sampling is used for content / structure,
+					# refer to section 3.4 of https://arxiv.org/abs/2302.08453
+
+					# for content / structure, it is best to favor earlier timesteps
+					# for style, it is best to favor later timesteps
+
+					orig_timesteps = torch.rand((batch_size,), device=latents.device)
+
+					if content_or_style == 'content':
+						timestep_indices = orig_timesteps ** 3 * self.train_config.num_train_timesteps
+					elif content_or_style == 'style':
+						timestep_indices = (1 - orig_timesteps ** 3) * self.train_config.num_train_timesteps
+
+					timestep_indices = value_map(
+						timestep_indices,
+						0,
+						self.train_config.num_train_timesteps - 1,
+						min_noise_steps,
+						max_noise_steps
+					)
+					timestep_indices = timestep_indices.long().clamp(
+						min_noise_steps,
+						max_noise_steps
+					)
+					
+				elif content_or_style == 'balanced':
+					if min_noise_steps == max_noise_steps:
+						timestep_indices = torch.ones((batch_size,), device=self.device_torch) * min_noise_steps
+					else:
+						# todo, some schedulers use indices, otheres use timesteps. Not sure what to do here
+						min_idx = min_noise_steps + 1
+						max_idx = max_noise_steps - 1
+						if self.train_config.noise_scheduler == 'flowmatch':
+							# flowmatch uses indices, so we need to use indices
+							min_idx = min_noise_steps
+							max_idx = max_noise_steps
+						timestep_indices = torch.randint(
+							min_idx,
+							max_idx,
+							(batch_size,),
+							device=self.device_torch
+						)
+					timestep_indices = timestep_indices.long()
+				else:
+					raise ValueError(f"Unknown content_or_style {content_or_style}")
+			with self.timer('convert_timestep_indices_to_timesteps'):
+				# convert the timestep_indices to a timestep
+				timesteps = self.sd.noise_scheduler.timesteps[timestep_indices.long()]
+				
+			with self.timer('prepare_noise'):
+				# get noise
+				noise = self.get_noise(latents, batch_size, dtype=dtype, batch=batch, timestep=timesteps)
+
+				# add dynamic noise offset. Dynamic noise is offsetting the noise to the same channelwise mean as the latents
+				# this will negate any noise offsets
+				if self.train_config.dynamic_noise_offset and not is_reg:
+					latents_channel_mean = latents.mean(dim=(2, 3), keepdim=True) / 2
+					# subtract channel mean to that we compensate for the mean of the latents on the noise offset per channel
+					noise = noise + latents_channel_mean
+
+				if self.train_config.loss_target == 'differential_noise':
+					differential = latents - unaugmented_latents
+					# add noise to differential
+					# noise = noise + differential
+					noise = noise + (differential * 0.5)
+					# noise = value_map(differential, 0, torch.abs(differential).max(), 0, torch.abs(noise).max())
+					latents = unaugmented_latents
+
+				noise_multiplier = self.train_config.noise_multiplier
+				
+				s = (noise.shape[0], noise.shape[1], 1, 1)
+				if len(noise.shape) == 5:
+					# if we have a 5d tensor, then we need to do it on a per batch item, per channel basis, per frame
+					s = (noise.shape[0], noise.shape[1], noise.shape[2], 1, 1)
+				
+				noise = noise * noise_multiplier
+				
+				if self.train_config.do_signal_correction_noise:
+					batch_noise = latents.clone().to(noise.device, dtype=noise.dtype)
+					scn_scale = torch.randn(
+						batch_noise.shape[0], batch_noise.shape[1], 1, 1,
+						device=batch_noise.device, 
+						dtype=batch_noise.dtype
+					) * self.train_config.signal_correction_noise_scale
+					batch_noise = batch_noise * scn_scale
+					noise = noise + batch_noise 
+				
+				if self.train_config.do_batch_noise_correction:
+					if latents.shape[0] == 1:
+						# if we only have a batch size of 1, then we cant do batch noise correction, so we skip it
+						print_acc("Skipping batch noise correction because batch size is 1, increase batch size and num_repeats to use this feature")
+					else:
+						# shuffle tensors ensuring that no tensor is in the same position as before
+						batch_noise = latents.clone().roll(shifts=torch.randint(1, latents.shape[0], (1,)).item(), dims=0).to(noise.device, dtype=noise.dtype)
+						batch_noise_scale = torch.randn(
+							batch_noise.shape[0], batch_noise.shape[1], 1, 1,
+							device=batch_noise.device,
+							dtype=batch_noise.dtype
+						) * self.train_config.batch_noise_correction_scale
+						batch_noise = batch_noise * batch_noise_scale
+						noise = noise + batch_noise
+				
+				if self.train_config.random_noise_shift > 0.0:
+					# get random noise -1 to 1
+					noise_shift = torch.randn(
+						batch_size, latents.shape[1], 1, 1,
+						device=noise.device,
+						dtype=noise.dtype
+					) * self.train_config.random_noise_shift
+					# add to noise
+					noise += noise_shift
+				
+				if self.train_config.random_noise_multiplier > 0.0:
+					sigma = self.train_config.random_noise_multiplier
+					noise_multiplier = torch.exp(torch.randn(s, device=noise.device, dtype=noise.dtype) * sigma)
+					noise = noise * noise_multiplier
+			with self.timer('make_noisy_latents'):
+
+				latent_multiplier = self.train_config.latent_multiplier
+
+				# handle adaptive scaling mased on std
+				if self.train_config.adaptive_scaling_factor:
+					std = latents.std(dim=(2, 3), keepdim=True)
+					normalizer = 1 / (std + 1e-6)
+					latent_multiplier = normalizer
+
+				latents = latents * latent_multiplier
+				
+				if self.train_config.do_blank_stabilization:
+					# zero out latents with blank prompts
+					blank_latent = torch.zeros_like(latents)
+					for i, prompt in enumerate(conditioned_prompts):
+						if prompt.strip() == '':
+							latents[i] = blank_latent[i]
+				
+				batch.latents = latents
+
+				# normalize latents to a mean of 0 and an std of 1
+				# mean_zero_latents = latents - latents.mean()
+				# latents = mean_zero_latents / mean_zero_latents.std()
+
+				if batch.unconditional_latents is not None:
+					batch.unconditional_latents = batch.unconditional_latents * self.train_config.latent_multiplier
+
+
+				noisy_latents = self.sd.add_noise(latents, noise, timesteps)
+
+				# determine scaled noise
+				# todo do we need to scale this or does it always predict full intensity
+				# noise = noisy_latents - latents
+
+				# https://github.com/huggingface/diffusers/blob/324d18fba23f6c9d7475b0ff7c777685f7128d40/examples/t2i_adapter/train_t2i_adapter_sdxl.py#L1170C17-L1171C77
+				if self.train_config.loss_target == 'source' or self.train_config.loss_target == 'unaugmented':
+					sigmas = self.get_sigmas(timesteps, len(noisy_latents.shape), noisy_latents.dtype)
+					# add it to the batch
+					batch.sigmas = sigmas
+					# todo is this for sdxl? find out where this came from originally
+					# noisy_latents = noisy_latents / ((sigmas ** 2 + 1) ** 0.5)
+
+			def double_up_tensor(tensor: torch.Tensor):
+				if tensor is None:
+					return None
+				return torch.cat([tensor, tensor], dim=0)
+
+			if do_double:
+				if self.model_config.refiner_name_or_path:
+					# apply refiner double up
+					refiner_timesteps = torch.randint(
+						max_noise_steps,
+						self.train_config.max_denoising_steps,
+						(batch_size,),
+						device=self.device_torch
+					)
+					refiner_timesteps = refiner_timesteps.long()
+					# add our new timesteps on to end
+					timesteps = torch.cat([timesteps, refiner_timesteps], dim=0)
+
+					refiner_noisy_latents = self.sd.noise_scheduler.add_noise(latents, noise, refiner_timesteps)
+					noisy_latents = torch.cat([noisy_latents, refiner_noisy_latents], dim=0)
+
+				else:
+					# just double it
+					noisy_latents = double_up_tensor(noisy_latents)
+					timesteps = double_up_tensor(timesteps)
+
+				noise = double_up_tensor(noise)
+				# prompts are already updated above
+				imgs = double_up_tensor(imgs)
+				batch.mask_tensor = double_up_tensor(batch.mask_tensor)
+				batch.control_tensor = double_up_tensor(batch.control_tensor)
+
+			noisy_latent_multiplier = self.train_config.noisy_latent_multiplier
+
+			if noisy_latent_multiplier != 1.0:
+				noisy_latents = noisy_latents * noisy_latent_multiplier
+
+			# remove grads for these
+			noisy_latents.requires_grad = False
+			noisy_latents = noisy_latents.detach()
+			noise.requires_grad = False
+			noise = noise.detach()
+
+		return noisy_latents, noise, timesteps, conditioned_prompts, imgs
+
+	def setup_adapter(self):
+		# t2i adapter
+		is_t2i = self.adapter_config.type == 't2i'
+		is_control_net = self.adapter_config.type == 'control_net'
+		if self.adapter_config.type == 't2i':
+			suffix = 't2i'
+		elif self.adapter_config.type == 'control_net':
+			suffix = 'cn'
+		elif self.adapter_config.type == 'clip':
+			suffix = 'clip'
+		elif self.adapter_config.type == 'reference':
+			suffix = 'ref'
+		elif self.adapter_config.type.startswith('ip'):
+			suffix = 'ip'
+		else:
+			suffix = 'adapter'
+		adapter_name = self.name
+		if self.network_config is not None:
+			adapter_name = f"{adapter_name}_{suffix}"
+		latest_save_path = self.get_latest_save_path(adapter_name)
+		
+		if latest_save_path is not None and not self.adapter_config.train:
+			# the save path is for something else since we are not training
+			latest_save_path = self.adapter_config.name_or_path
+
+		dtype = get_torch_dtype(self.train_config.dtype)
+		if is_t2i:
+			# if we do not have a last save path and we have a name_or_path,
+			# load from that
+			if latest_save_path is None and self.adapter_config.name_or_path is not None:
+				self.adapter = T2IAdapter.from_pretrained(
+					self.adapter_config.name_or_path,
+					torch_dtype=get_torch_dtype(self.train_config.dtype),
+					varient="fp16",
+					# use_safetensors=True,
+				)
+			else:
+				self.adapter = T2IAdapter(
+					in_channels=self.adapter_config.in_channels,
+					channels=self.adapter_config.channels,
+					num_res_blocks=self.adapter_config.num_res_blocks,
+					downscale_factor=self.adapter_config.downscale_factor,
+					adapter_type=self.adapter_config.adapter_type,
+				)
+		elif is_control_net:
+			if self.adapter_config.name_or_path is None:
+				raise ValueError("ControlNet requires a name_or_path to load from currently")
+			load_from_path = self.adapter_config.name_or_path
+			if latest_save_path is not None:
+				load_from_path = latest_save_path
+			self.adapter = ControlNetModel.from_pretrained(
+				load_from_path,
+				torch_dtype=get_torch_dtype(self.train_config.dtype),
+			)
+		elif self.adapter_config.type == 'clip':
+			self.adapter = ClipVisionAdapter(
+				sd=self.sd,
+				adapter_config=self.adapter_config,
+			)
+		elif self.adapter_config.type == 'reference':
+			self.adapter = ReferenceAdapter(
+				sd=self.sd,
+				adapter_config=self.adapter_config,
+			)
+		elif self.adapter_config.type.startswith('ip'):
+			self.adapter = IPAdapter(
+				sd=self.sd,
+				adapter_config=self.adapter_config,
+			)
+			if self.train_config.gradient_checkpointing:
+				self.adapter.enable_gradient_checkpointing()
+		else:
+			self.adapter = CustomAdapter(
+				sd=self.sd,
+				adapter_config=self.adapter_config,
+				train_config=self.train_config,
+			)
+		self.adapter.to(self.device_torch, dtype=dtype)
+		if latest_save_path is not None and not is_control_net:
+			# load adapter from path
+			print_acc(f"Loading adapter from {latest_save_path}")
+			if is_t2i:
+				loaded_state_dict = load_t2i_model(
+					latest_save_path,
+					self.device,
+					dtype=dtype
+				)
+				self.adapter.load_state_dict(loaded_state_dict)
+			elif self.adapter_config.type.startswith('ip'):
+				# ip adapter
+				loaded_state_dict = load_ip_adapter_model(
+					latest_save_path,
+					self.device,
+					dtype=dtype,
+					direct_load=self.adapter_config.train_only_image_encoder
+				)
+				self.adapter.load_state_dict(loaded_state_dict)
+			else:
+				# custom adapter
+				loaded_state_dict = load_custom_adapter_model(
+					latest_save_path,
+					self.device,
+					dtype=dtype
+				)
+				self.adapter.load_state_dict(loaded_state_dict)
+		if latest_save_path is not None and self.adapter_config.train:
+			self.load_training_state_from_metadata(latest_save_path)
+		# set trainable params
+		self.sd.adapter = self.adapter
+
+	def run(self):
+		# torch.autograd.set_detect_anomaly(True)
+		# run base process run
+		BaseTrainProcess.run(self)
+		params = []
+
+		### HOOK ###
+		self.hook_before_model_load()
+		model_config_to_load = copy.deepcopy(self.model_config)
+
+		if self.is_fine_tuning or self.train_config.merge_network_on_save:
+			# get the latest checkpoint
+			# check to see if we have a latest save
+			latest_save_path = self.get_latest_save_path()
+
+			if latest_save_path is not None:
+				print_acc(f"#### IMPORTANT RESUMING FROM {latest_save_path} ####")
+				model_config_to_load.name_or_path = latest_save_path
+				self.load_training_state_from_metadata(latest_save_path)
+
+		ModelClass = get_model_class(self.model_config)
+		# if the model class has get_train_scheduler static method
+		if hasattr(ModelClass, 'get_train_scheduler'):
+			sampler = ModelClass.get_train_scheduler()
+		else:
+			# get the noise scheduler
+			arch = 'sd'
+			if self.model_config.is_pixart:
+				arch = 'pixart'
+			if self.model_config.is_flux:
+				arch = 'flux'
+			if self.model_config.is_lumina2:
+				arch = 'lumina2'
+			sampler = get_sampler(
+				self.train_config.noise_scheduler,
+				{
+					"prediction_type": "v_prediction" if self.model_config.is_v_pred else "epsilon",
+				},
+				arch=arch,
+			)
+
+		if self.train_config.train_refiner and self.model_config.refiner_name_or_path is not None and self.network_config is None:
+			previous_refiner_save = self.get_latest_save_path(self.job.name + '_refiner')
+			if previous_refiner_save is not None:
+				model_config_to_load.refiner_name_or_path = previous_refiner_save
+				self.load_training_state_from_metadata(previous_refiner_save)
+
+		self.sd = ModelClass(
+			# todo handle single gpu and multi gpu here
+			# device=self.device,
+			device=self.accelerator.device,
+			model_config=model_config_to_load,
+			dtype=self.train_config.dtype,
+			custom_pipeline=self.custom_pipeline,
+			noise_scheduler=sampler,
+		)
+		
+		self.hook_after_sd_init_before_load()
+		# run base sd process run
+		self.sd.load_model()
+		
+		self.sd.add_after_sample_image_hook(self.sample_step_hook)
+
+		dtype = get_torch_dtype(self.train_config.dtype)
+
+		# model is loaded from BaseSDProcess
+		unet = self.sd.unet
+		vae = self.sd.vae
+		tokenizer = self.sd.tokenizer
+		text_encoder = self.sd.text_encoder
+		noise_scheduler = self.sd.noise_scheduler
+
+		if self.train_config.xformers:
+			vae.enable_xformers_memory_efficient_attention()
+			unet.enable_xformers_memory_efficient_attention()
+			if isinstance(text_encoder, list):
+				for te in text_encoder:
+					# if it has it
+					if hasattr(te, 'enable_xformers_memory_efficient_attention'):
+						te.enable_xformers_memory_efficient_attention()
+		
+		if self.train_config.attention_backend != 'native':
+			if hasattr(vae, 'set_attention_backend'):
+				vae.set_attention_backend(self.train_config.attention_backend)
+			if hasattr(unet, 'set_attention_backend'):
+				unet.set_attention_backend(self.train_config.attention_backend)
+			if isinstance(text_encoder, list):
+				for te in text_encoder:
+					if hasattr(te, 'set_attention_backend'):
+						te.set_attention_backend(self.train_config.attention_backend)
+			else:
+				if hasattr(text_encoder, 'set_attention_backend'):
+					text_encoder.set_attention_backend(self.train_config.attention_backend)
+		if self.train_config.sdp:
+			torch.backends.cuda.enable_math_sdp(True)
+			torch.backends.cuda.enable_flash_sdp(True)
+			torch.backends.cuda.enable_mem_efficient_sdp(True)
+		
+		# # check if we have sage and is flux
+		# if self.sd.is_flux:
+		#     # try_to_activate_sage_attn()
+		#     try:
+		#         from sageattention import sageattn
+		#         from toolkit.models.flux_sage_attn import FluxSageAttnProcessor2_0
+		#         model: FluxTransformer2DModel = self.sd.unet
+		#         # enable sage attention on each block
+		#         for block in model.transformer_blocks:
+		#             processor = FluxSageAttnProcessor2_0()
+		#             block.attn.set_processor(processor)
+		#         for block in model.single_transformer_blocks:
+		#             processor = FluxSageAttnProcessor2_0()
+		#             block.attn.set_processor(processor)
+					
+		#     except ImportError:
+		#         print_acc("sage attention is not installed. Using SDP instead")
+
+		if self.train_config.gradient_checkpointing:
+			# if has method enable_gradient_checkpointing
+			if hasattr(unet, 'enable_gradient_checkpointing'):
+				unet.enable_gradient_checkpointing()
+			elif hasattr(unet, 'gradient_checkpointing'):
+				unet.gradient_checkpointing = True
+			else:
+				print("Gradient checkpointing not supported on this model")
+			if isinstance(text_encoder, list):
+				for te in text_encoder:
+					if hasattr(te, 'enable_gradient_checkpointing'):
+						te.enable_gradient_checkpointing()
+					if hasattr(te, "gradient_checkpointing_enable"):
+						te.gradient_checkpointing_enable()
+			else:
+				if hasattr(text_encoder, 'enable_gradient_checkpointing'):
+					text_encoder.enable_gradient_checkpointing()
+				if hasattr(text_encoder, "gradient_checkpointing_enable"):
+					text_encoder.gradient_checkpointing_enable()
+
+		if self.sd.refiner_unet is not None:
+			self.sd.refiner_unet.to(self.device_torch, dtype=dtype)
+			self.sd.refiner_unet.requires_grad_(False)
+			self.sd.refiner_unet.eval()
+			if self.train_config.xformers:
+				self.sd.refiner_unet.enable_xformers_memory_efficient_attention()
+			if self.train_config.gradient_checkpointing:
+				self.sd.refiner_unet.enable_gradient_checkpointing()
+
+		if isinstance(text_encoder, list):
+			for te in text_encoder:
+				te.requires_grad_(False)
+				te.eval()
+		else:
+			text_encoder.requires_grad_(False)
+			text_encoder.eval()
+		unet.to(self.device_torch, dtype=dtype)
+		unet.requires_grad_(False)
+		unet.eval()
+		vae = vae.to(torch.device('cpu'), dtype=dtype)
+		vae.requires_grad_(False)
+		vae.eval()
+		if self.train_config.learnable_snr_gos:
+			self.snr_gos = LearnableSNRGamma(
+				self.sd.noise_scheduler, device=self.device_torch
+			)
+			# check to see if previous settings exist
+			path_to_load = os.path.join(self.save_root, 'learnable_snr.json')
+			if os.path.exists(path_to_load):
+				with open(path_to_load, 'r') as f:
+					json_data = json.load(f)
+					if 'offset' in json_data:
+						# legacy
+						self.snr_gos.offset_2.data = torch.tensor(json_data['offset'], device=self.device_torch)
+					else:
+						self.snr_gos.offset_1.data = torch.tensor(json_data['offset_1'], device=self.device_torch)
+						self.snr_gos.offset_2.data = torch.tensor(json_data['offset_2'], device=self.device_torch)
+					self.snr_gos.scale.data = torch.tensor(json_data['scale'], device=self.device_torch)
+					self.snr_gos.gamma.data = torch.tensor(json_data['gamma'], device=self.device_torch)
+
+		self.hook_after_model_load()
+		flush()
+		if not self.is_fine_tuning:
+			if self.network_config is not None:
+				# TODO should we completely switch to LycorisSpecialNetwork?
+				network_kwargs = self.network_config.network_kwargs
+				is_lycoris = False
+				is_lorm = self.network_config.type.lower() == 'lorm'
+				# default to LoCON if there are any conv layers or if it is named
+				NetworkClass = LoRASpecialNetwork
+				if self.network_config.type.lower() == 'locon' or self.network_config.type.lower() == 'lycoris':
+					NetworkClass = LycorisSpecialNetwork
+					is_lycoris = True
+
+				if is_lorm:
+					network_kwargs['ignore_if_contains'] = lorm_ignore_if_contains
+					network_kwargs['parameter_threshold'] = lorm_parameter_threshold
+					network_kwargs['target_lin_modules'] = LORM_TARGET_REPLACE_MODULE
+
+				# if is_lycoris:
+				#     preset = PRESET['full']
+				# NetworkClass.apply_preset(preset)
+				
+				if hasattr(self.sd, 'target_lora_modules'):
+					network_kwargs['target_lin_modules'] = self.sd.target_lora_modules
+
+				self.network = NetworkClass(
+					text_encoder=text_encoder,
+					unet=self.sd.get_model_to_train(),
+					lora_dim=self.network_config.linear,
+					multiplier=1.0,
+					alpha=self.network_config.linear_alpha,
+					train_unet=self.train_config.train_unet,
+					train_text_encoder=self.train_config.train_text_encoder,
+					conv_lora_dim=self.network_config.conv,
+					conv_alpha=self.network_config.conv_alpha,
+					is_sdxl=self.model_config.is_xl or self.model_config.is_ssd,
+					is_v2=self.model_config.is_v2,
+					is_v3=self.model_config.is_v3,
+					is_pixart=self.model_config.is_pixart,
+					is_auraflow=self.model_config.is_auraflow,
+					is_flux=self.model_config.is_flux,
+					is_lumina2=self.model_config.is_lumina2,
+					is_ssd=self.model_config.is_ssd,
+					is_vega=self.model_config.is_vega,
+					dropout=self.network_config.dropout,
+					use_text_encoder_1=self.model_config.use_text_encoder_1,
+					use_text_encoder_2=self.model_config.use_text_encoder_2,
+					use_bias=is_lorm,
+					is_lorm=is_lorm,
+					network_config=self.network_config,
+					network_type=self.network_config.type,
+					transformer_only=self.network_config.transformer_only,
+					is_transformer=self.sd.is_transformer,
+					base_model=self.sd,
+					**network_kwargs
+				)
+
+
+				# todo switch everything to proper mixed precision like this
+				self.network.force_to(self.device_torch, dtype=torch.float32)
+				# give network to sd so it can use it
+				self.sd.network = self.network
+				self.network._update_torch_multiplier()
+
+				self.network.apply_to(
+					text_encoder,
+					unet,
+					self.train_config.train_text_encoder,
+					self.train_config.train_unet
+				)
+
+				# we cannot merge in if quantized
+				if self.model_config.quantize or self.model_config.layer_offloading:
+					# todo find a way around this
+					self.network.can_merge_in = False
+
+				if is_lorm:
+					self.network.is_lorm = True
+					# make sure it is on the right device
+					self.sd.unet.to(self.sd.device, dtype=dtype)
+					original_unet_param_count = count_parameters(self.sd.unet)
+					self.network.setup_lorm()
+					new_unet_param_count = original_unet_param_count - self.network.calculate_lorem_parameter_reduction()
+
+					print_lorm_extract_details(
+						start_num_params=original_unet_param_count,
+						end_num_params=new_unet_param_count,
+						num_replaced=len(self.network.get_all_modules()),
+					)
+
+				self.network.prepare_grad_etc(text_encoder, unet)
+				flush()
+
+				# LyCORIS doesnt have default_lr
+				config = {
+					'text_encoder_lr': self.train_config.lr,
+					'unet_lr': self.train_config.lr,
+				}
+				sig = inspect.signature(self.network.prepare_optimizer_params)
+				if 'default_lr' in sig.parameters:
+					config['default_lr'] = self.train_config.lr
+				if 'learning_rate' in sig.parameters:
+					config['learning_rate'] = self.train_config.lr
+				params_net = self.network.prepare_optimizer_params(
+					**config
+				)
+
+				params += params_net
+
+				if self.train_config.gradient_checkpointing:
+					self.network.enable_gradient_checkpointing()
+
+				lora_name = self.name
+				# need to adapt name so they are not mixed up
+				if self.named_lora:
+					lora_name = f"{lora_name}_LoRA"
+
+				latest_save_path = self.get_latest_save_path(lora_name)
+				extra_weights = None
+				if latest_save_path is not None and not self.train_config.merge_network_on_save:
+					print_acc(f"#### IMPORTANT RESUMING FROM {latest_save_path} ####")
+					print_acc(f"Loading from {latest_save_path}")
+					extra_weights = self.load_weights(latest_save_path)
+					self.network.multiplier = 1.0
+				
+				if self.network_config.layer_offloading:
+					MemoryManager.attach(
+						self.network,
+						self.device_torch
+					)
+
+			if self.embed_config is not None:
+				# we are doing embedding training as well
+				self.embedding = Embedding(
+					sd=self.sd,
+					embed_config=self.embed_config
+				)
+				latest_save_path = self.get_latest_save_path(self.embed_config.trigger)
+				# load last saved weights
+				if latest_save_path is not None:
+					self.embedding.load_embedding_from_file(latest_save_path, self.device_torch)
+					if self.embedding.step > 1:
+						self.step_num = self.embedding.step
+						self.start_step = self.step_num
+
+				# self.step_num = self.embedding.step
+				# self.start_step = self.step_num
+				params.append({
+					'params': list(self.embedding.get_trainable_params()),
+					'lr': self.train_config.embedding_lr
+				})
+
+				flush()
+			
+			if self.decorator_config is not None:
+				self.decorator = Decorator(
+					num_tokens=self.decorator_config.num_tokens,
+					token_size=4096 # t5xxl hidden size for flux
+				)
+				latest_save_path = self.get_latest_save_path()
+				# load last saved weights
+				if latest_save_path is not None:
+					state_dict = load_file(latest_save_path)
+					self.decorator.load_state_dict(state_dict)
+					self.load_training_state_from_metadata(latest_save_path)
+					
+				params.append({
+					'params': list(self.decorator.parameters()),
+					'lr': self.train_config.lr
+				})
+				
+				# give it to the sd network
+				self.sd.decorator = self.decorator
+				self.decorator.to(self.device_torch, dtype=torch.float32)
+				self.decorator.train()
+
+				flush()
+
+			if self.adapter_config is not None:
+				self.setup_adapter()
+				if self.adapter_config.train:
+
+					if isinstance(self.adapter, IPAdapter):
+						# we have custom LR groups for IPAdapter
+						adapter_param_groups = self.adapter.get_parameter_groups(self.train_config.adapter_lr)
+						for group in adapter_param_groups:
+							params.append(group)
+					else:
+						# set trainable params
+						params.append({
+							'params': list(self.adapter.parameters()),
+							'lr': self.train_config.adapter_lr
+						})
+
+				if self.train_config.gradient_checkpointing:
+					self.adapter.enable_gradient_checkpointing()
+				flush()
+
+			params = self.load_additional_training_modules(params)
+
+		else:  # no network, embedding or adapter
+			# set the device state preset before getting params
+			self.sd.set_device_state(self.get_params_device_state_preset)
+
+			# params = self.get_params()
+			if len(params) == 0:
+				# will only return savable weights and ones with grad
+				params = self.sd.prepare_optimizer_params(
+					unet=self.train_config.train_unet,
+					text_encoder=self.train_config.train_text_encoder,
+					text_encoder_lr=self.train_config.lr,
+					unet_lr=self.train_config.lr,
+					default_lr=self.train_config.lr,
+					refiner=self.train_config.train_refiner and self.sd.refiner_unet is not None,
+					refiner_lr=self.train_config.refiner_lr,
+				)
+			# we may be using it for prompt injections
+			if self.adapter_config is not None and self.adapter is None:
+				self.setup_adapter()
+		flush()
+
+		### HOOK ###
+		params = self.hook_add_extra_train_params(params)
+		self.params = params
+		# self.params = []
+
+		# for param in params:
+		#     if isinstance(param, dict):
+		#         self.params += param['params']
+		#     else:
+		#         self.params.append(param)
+
+		if self.train_config.start_step is not None:
+			self.step_num = self.train_config.start_step
+			self.start_step = self.step_num
+
+		optimizer_type = self.train_config.optimizer.lower()
+		
+		# esure params require grad
+		self.ensure_params_requires_grad(force=True)
+		optimizer = get_optimizer(self.params, optimizer_type, learning_rate=self.train_config.lr,
+								  optimizer_params=self.train_config.optimizer_params)
+		self.optimizer = optimizer
+		
+		# set it to do paramiter swapping
+		if self.train_config.do_paramiter_swapping:
+			# only works for adafactor, but it should have thrown an error prior to this otherwise
+			self.optimizer.enable_paramiter_swapping(self.train_config.paramiter_swapping_factor)
+
+		# check if it exists
+		optimizer_state_filename = f'optimizer.pt'
+		optimizer_state_file_path = os.path.join(self.save_root, optimizer_state_filename)
+		if os.path.exists(optimizer_state_file_path):
+			# try to load
+			# previous param groups
+			# previous_params = copy.deepcopy(optimizer.param_groups)
+			previous_lrs = []
+			for group in optimizer.param_groups:
+				previous_lrs.append(group['lr'])
+
+			load_optimizer = True
+			if self.network is not None:
+				if self.network.did_change_weights:
+					# do not load optimizer if the network changed, it will result in
+					# a double state that will oom.
+					load_optimizer = False
+
+			if load_optimizer:
+				try:
+					print_acc(f"Loading optimizer state from {optimizer_state_file_path}")
+					optimizer_state_dict = torch.load(optimizer_state_file_path, weights_only=False)
+					optimizer.load_state_dict(optimizer_state_dict)
+					del optimizer_state_dict
+					flush()
+				except Exception as e:
+					print_acc(f"Failed to load optimizer state from {optimizer_state_file_path}")
+					print_acc(e)
+
+			# update the optimizer LR from the params
+			print_acc(f"Updating optimizer LR from params")
+			if len(previous_lrs) > 0:
+				for i, group in enumerate(optimizer.param_groups):
+					group['lr'] = previous_lrs[i]
+					group['initial_lr'] = previous_lrs[i]
+
+			# Update the learning rates if they changed
+			# optimizer.param_groups = previous_params
+
+		lr_scheduler_params = self.train_config.lr_scheduler_params
+
+		# make sure it had bare minimum
+		if 'max_iterations' not in lr_scheduler_params:
+			lr_scheduler_params['total_iters'] = self.train_config.steps
+
+		lr_scheduler = get_lr_scheduler(
+			self.train_config.lr_scheduler,
+			optimizer,
+			**lr_scheduler_params
+		)
+		self.lr_scheduler = lr_scheduler
+
+		### HOOk ###
+		self.before_dataset_load()
+		# load datasets if passed in the root process
+		if self.datasets is not None:
+			self.data_loader = get_dataloader_from_datasets(self.datasets, self.train_config.batch_size, self.sd)
+		if self.datasets_reg is not None:
+			self.data_loader_reg = get_dataloader_from_datasets(self.datasets_reg, self.train_config.batch_size,
+																self.sd)
+
+		flush()
+		self.last_save_step = self.step_num
+		### HOOK ###
+		self.hook_before_train_loop()
+
+		# compile the model if needed (must be after LoRA/adapter injection AND accelerator.prepare)
+		if self.model_config.compile:
+			try:
+				# make sure it is on the gpu
+				self.sd.unet.to(self.device_torch)
+				print_acc("Compiling model with torch.compile. The first forward will hang for a while using this. This is normal.")
+				self.sd.unet = torch.compile(self.sd.unet)
+			except Exception as e:
+				print_acc(f"Failed to compile model: {e}")
+				print_acc("Continuing without compilation")
+
+		if self.has_first_sample_requested and self.step_num <= 1 and not self.train_config.disable_sampling:
+			print_acc("Generating first sample from first sample config")
+			self.sample(0, is_first=True)
+
+		# sample first
+		if self.train_config.skip_first_sample or self.train_config.disable_sampling:
+			print_acc("Skipping first sample due to config setting")
+		elif self.step_num <= 1 or self.train_config.force_first_sample:
+			print_acc("Generating baseline samples before training")
+			self.sample(self.step_num)
+		
+		if self.accelerator.is_local_main_process:
+			self.progress_bar = ToolkitProgressBar(
+				total=self.train_config.steps,
+				desc=self.job.name,
+				leave=True,
+				initial=self.step_num,
+				iterable=range(0, self.train_config.steps),
+			)
+			self.progress_bar.pause()
+		else:
+			self.progress_bar = None
+
+		if self.data_loader is not None:
+			dataloader = self.data_loader
+			dataloader_iterator = iter(dataloader)
+		else:
+			dataloader = None
+			dataloader_iterator = None
+
+		if self.data_loader_reg is not None:
+			dataloader_reg = self.data_loader_reg
+			dataloader_iterator_reg = iter(dataloader_reg)
+		else:
+			dataloader_reg = None
+			dataloader_iterator_reg = None
+
+		# zero any gradients
+		optimizer.zero_grad()
+
+		self.lr_scheduler.step(self.step_num)
+
+		self.sd.set_device_state(self.train_device_state_preset)
+		flush()
+		# self.step_num = 0
+
+		# print_acc(f"Compiling Model")
+		# torch.compile(self.sd.unet, dynamic=True)
+
+		# make sure all params require grad
+		self.ensure_params_requires_grad(force=True)
+
+
+		###################################################################
+		# TRAIN LOOP
+		###################################################################
+
+
+		start_step_num = self.step_num
+		did_first_flush = False
+		flush_next = False
+		for step in range(start_step_num, self.train_config.steps):
+			if self.train_config.do_paramiter_swapping:
+				self.optimizer.optimizer.swap_paramiters()
+			self.timer.start('train_loop')
+			if flush_next:
+				flush()
+				flush_next = False
+			if self.train_config.do_random_cfg:
+				self.train_config.do_cfg = True
+				self.train_config.cfg_scale = value_map(random.random(), 0, 1, 1.0, self.train_config.max_cfg_scale)
+			self.step_num = step
+			# default to true so various things can turn it off
+			self.is_grad_accumulation_step = True
+			if self.train_config.free_u:
+				self.sd.pipeline.enable_freeu(s1=0.9, s2=0.2, b1=1.1, b2=1.2)
+			if self.progress_bar is not None:
+				self.progress_bar.unpause()
+			with torch.no_grad():
+				# if is even step and we have a reg dataset, use that
+				# todo improve this logic to send one of each through if we can buckets and batch size might be an issue
+				is_reg_step = False
+				is_save_step = self.save_config.save_every and self.step_num % self.save_config.save_every == 0
+				is_sample_step = self.sample_config.sample_every and self.step_num % self.sample_config.sample_every == 0
+				if self.train_config.disable_sampling:
+					is_sample_step = False
+
+				batch_list = []
+
+				for b in range(self.train_config.gradient_accumulation):
+					# keep track to alternate on an accumulation step for reg   
+					batch_step = step
+					# don't do a reg step on sample or save steps as we dont want to normalize on those
+					if batch_step % 2 == 0 and dataloader_reg is not None and not is_save_step and not is_sample_step:
+						try:
+							with self.timer('get_batch:reg'):
+								batch = next(dataloader_iterator_reg)
+						except StopIteration:
+							with self.timer('reset_batch:reg'):
+								# hit the end of an epoch, reset
+								if self.progress_bar is not None:
+									self.progress_bar.pause()
+								dataloader_iterator_reg = iter(dataloader_reg)
+								trigger_dataloader_setup_epoch(dataloader_reg)
+
+							with self.timer('get_batch:reg'):
+								batch = next(dataloader_iterator_reg)
+							if self.progress_bar is not None:
+								self.progress_bar.unpause()
+						is_reg_step = True
+					elif dataloader is not None:
+						try:
+							with self.timer('get_batch'):
+								batch = next(dataloader_iterator)
+						except StopIteration:
+							with self.timer('reset_batch'):
+								# hit the end of an epoch, reset
+								if self.progress_bar is not None:
+									self.progress_bar.pause()
+								dataloader_iterator = iter(dataloader)
+								trigger_dataloader_setup_epoch(dataloader)
+								self.epoch_num += 1
+								if self.train_config.gradient_accumulation_steps == -1:
+									# if we are accumulating for an entire epoch, trigger a step
+									self.is_grad_accumulation_step = False
+									self.grad_accumulation_step = 0
+							with self.timer('get_batch'):
+								batch = next(dataloader_iterator)
+							if self.progress_bar is not None:
+								self.progress_bar.unpause()
+					else:
+						batch = None
+					batch_list.append(batch)
+					batch_step += 1
+
+				# setup accumulation
+				if self.train_config.gradient_accumulation_steps == -1:
+					# epoch is handling the accumulation, dont touch it
+					pass
+				else:
+					# determine if we are accumulating or not
+					# since optimizer step happens in the loop, we trigger it a step early
+					# since we cannot reprocess it before them
+					optimizer_step_at = self.train_config.gradient_accumulation_steps
+					is_optimizer_step = self.grad_accumulation_step >= optimizer_step_at
+					self.is_grad_accumulation_step = not is_optimizer_step
+					if is_optimizer_step:
+						self.grad_accumulation_step = 0
+
+			# flush()
+			### HOOK ###
+			if self.torch_profiler is not None:
+				self.torch_profiler.start()
+			did_oom = False
+			loss_dict = None
+			try:
+				with self.accelerator.accumulate(self.modules_being_trained):
+					loss_dict = self.hook_train_loop(batch_list)
+			except torch.cuda.OutOfMemoryError:
+				did_oom = True
+			except RuntimeError as e:
+				if "CUDA out of memory" in str(e):
+					did_oom = True
+				else:
+					raise  # not an OOM; surface real errors
+			if did_oom:
+				self.num_consecutive_oom += 1
+				if self.num_consecutive_oom > 3:
+					raise RuntimeError("OOM during training step 3 times in a row, aborting training")
+				optimizer.zero_grad(set_to_none=True)
+				flush()
+				torch.cuda.ipc_collect()
+				# skip this step and keep going
+				print_acc("")
+				print_acc("################################################")
+				print_acc(f"# OOM during training step, skipping batch {self.num_consecutive_oom}/3 #")
+				print_acc("################################################")
+				print_acc("")
+			else:
+				self.num_consecutive_oom = 0
+			if self.torch_profiler is not None:
+				torch.cuda.synchronize()  # Make sure all CUDA ops are done
+				self.torch_profiler.stop()
+				
+				print("\n==== Profile Results ====")
+				print(self.torch_profiler.key_averages().table(sort_by="cpu_time_total", row_limit=1000))
+			self.timer.stop('train_loop')
+			if not did_first_flush:
+				flush()
+				did_first_flush = True
+			# flush()
+			# setup the networks to gradient checkpointing and everything works
+			if self.adapter is not None and isinstance(self.adapter, ReferenceAdapter):
+				self.adapter.clear_memory()
+
+			with torch.no_grad():
+				# torch.cuda.empty_cache()
+				# if optimizer has get_lrs method, then use it
+				learning_rate = 0.0
+				if not did_oom and loss_dict is not None:
+					if hasattr(optimizer, 'get_avg_learning_rate'):
+						learning_rate = optimizer.get_avg_learning_rate()
+					elif hasattr(optimizer, 'get_learning_rates'):
+						learning_rate = optimizer.get_learning_rates()[0]
+					elif self.train_config.optimizer.lower().startswith('dadaptation') or \
+							self.train_config.optimizer.lower().startswith('prodigy'):
+						learning_rate = (
+								optimizer.param_groups[0]["d"] *
+								optimizer.param_groups[0]["lr"]
+						)
+					else:
+						learning_rate = optimizer.param_groups[0]['lr']
+
+					prog_bar_string = f"lr: {learning_rate:.1e}"
+					for key, value in loss_dict.items():
+						prog_bar_string += f" {key}: {value:.3e}"
+
+					if self.progress_bar is not None:
+						self.progress_bar.set_postfix_str(prog_bar_string)
+
+				# if the batch is a DataLoaderBatchDTO, then we need to clean it up
+				if isinstance(batch, DataLoaderBatchDTO):
+					with self.timer('batch_cleanup'):
+						batch.cleanup()
+
+				# don't do on first step
+				if self.step_num != self.start_step:
+					if is_sample_step or is_save_step:
+						self.accelerator.wait_for_everyone()
+						
+					if is_save_step:
+						self.accelerator
+						# print above the progress bar
+						if self.progress_bar is not None:
+							self.progress_bar.pause()
+						print_acc(f"\nSaving at step {self.step_num}")
+						self.save(self.step_num)
+						self.ensure_params_requires_grad()
+						# clear any grads
+						optimizer.zero_grad()
+						flush()
+						flush_next = True
+						if self.progress_bar is not None:
+							self.progress_bar.unpause()
+							
+					if is_sample_step:
+						if self.progress_bar is not None:
+							self.progress_bar.pause()
+						flush()
+						# print above the progress bar
+						if self.train_config.free_u:
+							self.sd.pipeline.disable_freeu()
+						self.sample(self.step_num)
+						if self.train_config.unload_text_encoder:
+							# make sure the text encoder is unloaded
+							self.sd.text_encoder_to('cpu')
+						flush()
+
+						self.ensure_params_requires_grad()
+						if self.progress_bar is not None:
+							self.progress_bar.unpause()
+
+					if self.logging_config.log_every and self.step_num % self.logging_config.log_every == 0:
+						if self.progress_bar is not None:
+							self.progress_bar.pause()
+						with self.timer('log_to_tensorboard'):
+							# log to tensorboard
+							if self.accelerator.is_main_process:
+								if self.writer is not None:
+									if loss_dict is not None:
+										for key, value in loss_dict.items():
+											self.writer.add_scalar(f"{key}", value, self.step_num)
+										self.writer.add_scalar(f"lr", learning_rate, self.step_num)
+								if self.progress_bar is not None:
+									self.progress_bar.unpause()
+						
+						if self.accelerator.is_main_process:
+							# log to logger
+							self.logger.log({
+								'learning_rate': learning_rate,
+							})
+							if loss_dict is not None:
+								for key, value in loss_dict.items():
+									self.logger.log({
+										f'loss/{key}': value,
+									})
+					elif self.logging_config.log_every is None:
+						if self.accelerator.is_main_process:
+							# log every step
+							self.logger.log({
+								'learning_rate': learning_rate,
+							})
+							for key, value in loss_dict.items():
+								self.logger.log({
+									f'loss/{key}': value,
+								})
+
+
+					if self.performance_log_every > 0 and self.step_num % self.performance_log_every == 0:
+						if self.progress_bar is not None:
+							self.progress_bar.pause()
+						# print the timers and clear them
+						self.timer.print()
+						self.timer.reset()
+						if self.progress_bar is not None:
+							self.progress_bar.unpause()
+				
+				# commit log
+				if self.accelerator.is_main_process:
+					with self.timer('commit_logger'):
+						self.logger.commit(step=self.step_num)
+
+				# sets progress bar to match out step
+				if self.progress_bar is not None:
+					self.progress_bar.update(step - self.progress_bar.n)
+
+				#############################
+				# End of step
+				#############################
+
+				# update various steps
+				self.step_num = step + 1
+				self.grad_accumulation_step += 1
+				self.end_step_hook()
+
+
+		###################################################################
+		##  END TRAIN LOOP
+		###################################################################
+		self.accelerator.wait_for_everyone()
+		if self.progress_bar is not None:
+			self.progress_bar.close()
+		if self.train_config.free_u:
+			self.sd.pipeline.disable_freeu()
+		if not self.train_config.disable_sampling:
+			self.sample(self.step_num)
+			self.logger.commit(step=self.step_num)
+		print_acc("")
+		if self.accelerator.is_main_process:
+			self.save()
+			self.logger.finish()
+		self.accelerator.end_training()
+
+		if self.accelerator.is_main_process:
+			# push to hub
+			if self.save_config.push_to_hub:
+				if("HF_TOKEN" not in os.environ):
+					interpreter_login(new_session=False, write_permission=True)
+				self.push_to_hub(
+					repo_id=self.save_config.hf_repo_id,
+					private=self.save_config.hf_private
+				)
+		del (
+			self.sd,
+			unet,
+			noise_scheduler,
+			optimizer,
+			self.network,
+			tokenizer,
+			text_encoder,
+		)
+
+		flush()
+		self.done_hook()
+
+	def push_to_hub(
+	self,
+	repo_id: str,
+	private: bool = False,
+	):  
+		if not self.accelerator.is_main_process:
+			return
+		readme_content = self._generate_readme(repo_id)
+		readme_path = os.path.join(self.save_root, "README.md")
+		with open(readme_path, "w", encoding="utf-8") as f:
+			f.write(readme_content)
+		
+		api = HfApi()
+
+		api.create_repo(
+			repo_id,
+			private=private,
+			exist_ok=True
+		)
+
+		api.upload_folder(
+			repo_id=repo_id,
+			folder_path=self.save_root,
+			ignore_patterns=["*.yaml", "*.pt"],
+			repo_type="model",
+		)
+
+
+	def _generate_readme(self, repo_id: str) -> str:
+		"""Generates the content of the README.md file."""
+
+		# Gather model info
+		base_model = self.model_config.name_or_path
+		instance_prompt = self.trigger_word if hasattr(self, "trigger_word") else None
+		if base_model == "black-forest-labs/FLUX.1-schnell":
+			license = "apache-2.0"
+		elif base_model == "black-forest-labs/FLUX.1-dev":
+			license = "other"
+			license_name = "flux-1-dev-non-commercial-license"
+			license_link = "https://huggingface.co/black-forest-labs/FLUX.1-dev/blob/main/LICENSE.md"
+		else:
+			license = "creativeml-openrail-m"
+		tags = [
+			"text-to-image",
+		]
+		if self.model_config.is_xl:
+			tags.append("stable-diffusion-xl")
+		if self.model_config.is_flux:
+			tags.append("flux")
+		if self.model_config.is_lumina2:
+			tags.append("lumina2")
+		if self.model_config.is_v3:
+			tags.append("sd3")
+		if self.network_config:
+			tags.extend(
+				[
+					"lora",
+					"diffusers",
+					"template:sd-lora",
+					"ai-toolkit",
+				]
+			)
+
+		# Generate the widget section
+		widgets = []
+		sample_image_paths = []
+		samples_dir = os.path.join(self.save_root, "samples")
+		if os.path.isdir(samples_dir):
+			for filename in os.listdir(samples_dir):
+				#The filenames are structured as 1724085406830__00000500_0.jpg
+				#So here we capture the 2nd part (steps) and 3rd (index the matches the prompt)
+				match = re.search(r"__(\d+)_(\d+)\.jpg$", filename)
+				if match:
+					steps, index = int(match.group(1)), int(match.group(2))
+					#Here we only care about uploading the latest samples, the match with the # of steps
+					if steps == self.train_config.steps:
+						sample_image_paths.append((index, f"samples/{filename}"))
+
+			# Sort by numeric index
+			sample_image_paths.sort(key=lambda x: x[0])
+
+			# Create widgets matching prompt with the index 
+			for i, prompt in enumerate(self.sample_config.prompts):
+				if i < len(sample_image_paths):
+					# Associate prompts with sample image paths based on the extracted index
+					_, image_path = sample_image_paths[i]
+					widgets.append(
+						{
+							"text": prompt,
+							"output": {
+								"url": image_path
+							},
+						}
+					)
+		dtype = "torch.bfloat16" if self.model_config.is_flux else "torch.float16"
+		# Construct the README content
+		readme_content = f"""---
+tags:
+{yaml.dump(tags, indent=4).strip()}
+{"widget:" if os.path.isdir(samples_dir) else ""}
+{yaml.dump(widgets, indent=4).strip() if widgets else ""}
+base_model: {base_model}
+{"instance_prompt: " + instance_prompt if instance_prompt else ""}
+license: {license}
+{'license_name: ' + license_name if license == "other" else ""}
+{'license_link: ' + license_link if license == "other" else ""}
+---
+
+# {self.job.name}
+Model trained with [AI Toolkit by Ostris](https://github.com/ostris/ai-toolkit)
+<Gallery />
+
+## Trigger words
+
+{"You should use `" + instance_prompt + "` to trigger the image generation." if instance_prompt else "No trigger words defined."}
+
+## Download model and use it with ComfyUI, AUTOMATIC1111, SD.Next, Invoke AI, etc.
+
+Weights for this model are available in Safetensors format.
+
+[Download](/{repo_id}/tree/main) them in the Files & versions tab.
+
+## Use it with the [🧨 diffusers library](https://github.com/huggingface/diffusers)
+
+```py
+from diffusers import AutoPipelineForText2Image
+import torch
+
+pipeline = AutoPipelineForText2Image.from_pretrained('{base_model}', torch_dtype={dtype}).to('cuda')
+pipeline.load_lora_weights('{repo_id}', weight_name='{self.job.name}.safetensors')
+image = pipeline('{instance_prompt if not widgets else self.sample_config.prompts[0]}').images[0]
+image.save("my_image.png")
+```
+
+For more details, including weighting, merging and fusing LoRAs, check the [documentation on loading LoRAs in diffusers](https://huggingface.co/docs/diffusers/main/en/using-diffusers/loading_adapters)
+
+"""
+		return readme_content

anime_style_flux2k_9b_000000024.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:68cb16a3cd0c5f57bd0ca3caa883beb584546e5517715c54bdfc2ae286538cba
+size 82866720

anime_style_flux2k_9b_000000048.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0b038a43c6d94c17788f7917587ab23b76d10750b6c272976292d36dd162dec5
+size 82866720

anime_style_flux2k_9b_000000072.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:877c46ae9e1bc6eac122f3d730edf61a0cbf5f3ee618cea1ea79d2783908f208
+size 82866720

anime_style_flux2k_9b_000000096.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:01990e2a557b624cde36fcea66e74990b0e7c62da87d91b082d76219639f2750
+size 82866720

anime_style_flux2k_9b_000000120.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:374670449e2c9d47eeae0a8d07ce1776725aba78404fef82c06e63005c48d2c7
+size 82866720

anime_style_flux2k_9b_000000144.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:647b17f3fa67596b1ca2a2d58cb0d3974c3640e81f6cda34bf1b73d7361665f9
+size 82866720

anime_style_flux2k_9b_000000168.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f2d1baa73b5d99f12b84e02d78524e4251d3b5eba4d079e1e791c09d2f704beb
+size 82866720

anime_style_flux2k_9b_000000192.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2f39c1b41baf2f0d85f006057ea08be494900fa97ea7c76e78fd7516dd662c60
+size 82866720

anime_style_flux2k_9b_000000216.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e294a707d6cc4cb8dbb0dadcd2b6c6c5ceb40fb37f5f5052dae2fe617c345d59
+size 82866720

anime_style_flux2k_9b_000000240.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2e2afddf58a47097527e26960b90bac05f14a9ae30e12d79bfdeb812033a88e6
+size 82866720

anime_style_flux2k_9b_000000264.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:85bfd0b6d216c7d369f8c790c143148c98aba4e2e59afb242bc76c19a9a97426
+size 82866720

anime_style_flux2k_9b_000000288.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a593293208e48bda07a4d10f61c2705a9b59d5c89a35ab06962bac5514b68d8a
+size 82866720

anime_style_flux2k_9b_000000312.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:38ba8926b16fecced8e3efc9b710903cb80816670bea7c0560948412b8eab58e
+size 82866720

anime_style_flux2k_9b_000000336.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3cd95fe4943de51c7a78ecac6849128acfcf0cd314902be2c51abb744353dbb6
+size 82866720

anime_style_flux2k_9b_000000360.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:188d1ec06425ea54eeea05ab667db1d4abec460d2d022e9c1a69e3cdd9fc3afc
+size 82866720

anime_style_flux2k_9b_000000384.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1383a463e3fcd1bc22770b69ce95085a668583eaf56fd55cc2d67e3e23babc6b
+size 82866720

anime_style_flux2k_9b_000000408.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:661922b210be2281b6e17cc32da4168913306984d010ef006c8802655c017b5b
+size 82866720

anime_style_flux2k_9b_000000432.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1465704dea374c3a9f91d19c512a07d2fb66ebfc16477c073e7cbc1253d5fc9e
+size 82866720

anime_style_flux2k_9b_000000456.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e545990bc42ce240657adec32707f02004edc8f1e77da82548623434fb4a1ed0
+size 82866720

anime_style_flux2k_9b_000000480.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1723c3d4956c054cafbc7c5327c9466747f131e2ceb4665d6c468f071902a18b
+size 82866720

anime_style_flux2k_9b_000000504.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a0b06bc1c842323377e8971c0076b5a6c269e1f0a0a7aa397e8bc029cbbf4749
+size 165704464

anime_style_flux2k_9b_000000528.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6a73343bd78d6641378c185f6f00551af4ed99570f3c89424a6635ac859a6dff
+size 165704464

anime_style_flux2k_9b_000000552.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0fb6e43d13526bbf4877413a4af3da6063112e78c67d275605506691973d1e3f
+size 165704464

anime_style_flux2k_9b_000000576.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:72e050be25380b3c7c6d31424731d07ed2093fcfa0df9e2c679ac7dec48748dd
+size 165704464

anime_style_flux2k_9b_000000600.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:814c6543bb03b43345100585af40d617bfc8df4fb2dd61a1622ae3fed85e87f5
+size 165704464

anime_style_flux2k_9b_000000624.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2691efe6fb2b3192b470bb03dea946ea43797d1a963da7984c0593ffa7e8c487
+size 165704464

anime_style_flux2k_9b_000000648.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a1e876433bcc28aeffff9ea2dcb25c8a03622478399a8f29b7ac768c3c01fe3e
+size 82866720

anime_style_flux2k_9b_000000672.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3f3b62d976234d03d3488a5805a660c347d55538b6d8be567ce3aaa137b00f4a
+size 82866720

anime_style_flux2k_9b_000000696.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:97b93eaf36680d0856cc3f0ed49fc1b94d5806b5328e26876b535c0176ac8d14
+size 82866720

anime_style_flux2k_9b_000000720.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9d4fca1a405332efb5a3905dbe040255f21bd941817703ff9843f14123cf5634
+size 82866720

anime_style_flux2k_9b_000000744.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ebbbdde3a89db1944eb18c993e4ee979d5e23f7851a2fc7ad4bfecc09a65c2cf
+size 82866720

anime_style_flux2k_9b_000000768.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:661744599b2e8fac372d0e2cac40c9fd0fc6362cb8d74a61b9b4e897ae2e5683
+size 82866720

anime_style_flux2k_9b_000001464.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a8ee8a769a195be233e9e95fa921591bcb2c810fa302663bfd7a6f525ddf3012
+size 165704464

anime_style_flux2k_9b_000001488.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:75d5437fc1cb40d8decdfe87c9a8b4f78000cf5939467bcc07bfb67ccd04cbf4
+size 165704464

anime_style_flux2k_9b_000001512.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:aa366300ee3911d818f29c8cfbb1fac967d3b73ce817675dd26058910067b9d0
+size 165704464

anime_style_flux2k_9b_000001536.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:334784987b16dadb3504a30c666a0ea304c0e1eba87a063cc19093a8dfc6260f
+size 165704464

anime_style_flux2k_9b_000001560.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4249beb63b612ac161d9c1985889f4012ea30ee55ef5351af35af12209e27c89
+size 165704464

anime_style_flux2k_9b_000001584.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7091ddd2aea40fabb92086d322fee308fca5749ca5bb347e9578e712464d4341
+size 165704464

anime_style_flux2k_9b_000001608.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d9207ff431feb32f2e627d255f389a31147d3c40d8842312043711cfdaec4e49
+size 165704464

anime_style_flux2k_9b_000001632.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7f93947a4c42a68441d918fba271edbf3c48e17a94eb6f0c47418d0fc73f08bc
+size 165704464

anime_style_flux2k_9b_000001656.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:136a5dce2a7032d41f82ebd565ed3ee837ba7ff9d17fa9a52a3639c650ae5ba8
+size 165704464

anime_style_flux2k_9b_000001680.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:279e93d00b431262dc3336b46e11b232cfcabb0d67834820b59d3b1d7e041822
+size 165704464

anime_style_flux2k_9b_000001704.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:437f7f8b60868a32b5f7df6018341c55210dfbdb0b4e20b6ce1f7212b71bc78a
+size 165704464

anime_style_flux2k_9b_000001728.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:39fb2396996493dc2f73cd40ab5a890bfb2a21f335fd545e8d9c1924973bb91a
+size 165704464

anime_style_flux2k_9b_000001752.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8e23d1fd01ca174ab534383ee120b5a0253013121d06371d1c087cc7fe1bff5e
+size 165704464

anime_style_flux2k_9b_000001776.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:516ccca7c4892f9fc7aa0cf2bbbf42e450130e97c39ed2fa46ae82a6c1a401aa
+size 165704464

anime_style_flux2k_9b_000001800.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7bbbad9cbc511e4be1aa55aa554f2ded85d7e45225db6f95dd7b22ce2f2ec6d8
+size 165704464

anime_style_flux2k_9b_000001824.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cc6c3a567c57ad1ed02f29adc7208011bc1f32a61ff702d323d49ca403f30883
+size 165704464