From 8772eece9c35f3525a262092899d3b44573622bf Mon Sep 17 00:00:00 2001 From: Xinze Li Date: Tue, 10 Dec 2024 15:33:11 +0800 Subject: [PATCH 01/14] Add examples and plugins --- src/diffusers/group_coordinator.py | 515 +++++++ src/diffusers/nccl_parallel_context.py | 503 +++++++ src/diffusers/parallel_state.py | 209 +++ .../pipeline_stable_diffusion_3_pp.py | 1241 +++++++++++++++++ src/diffusers/postal_service.py | 514 +++++++ src/diffusers/runtime_state.py | 184 +++ src/diffusers/torch_parallel_context.py | 353 +++++ src/examples/run.sh | 68 + src/examples/sd3_example.py | 222 +++ .../SD3_result_ulysses1_ring1_pp1_rank0.png | Bin 0 -> 1696050 bytes 10 files changed, 3809 insertions(+) create mode 100644 src/diffusers/group_coordinator.py create mode 100644 src/diffusers/nccl_parallel_context.py create mode 100644 src/diffusers/parallel_state.py create mode 100644 src/diffusers/pipelines/stable_diffusion_3/pipeline_stable_diffusion_3_pp.py create mode 100644 src/diffusers/postal_service.py create mode 100644 src/diffusers/runtime_state.py create mode 100644 src/diffusers/torch_parallel_context.py create mode 100644 src/examples/run.sh create mode 100644 src/examples/sd3_example.py create mode 100644 src/results/SD3_result_ulysses1_ring1_pp1_rank0.png diff --git a/src/diffusers/group_coordinator.py b/src/diffusers/group_coordinator.py new file mode 100644 index 000000000000..f97c3638b484 --- /dev/null +++ b/src/diffusers/group_coordinator.py @@ -0,0 +1,515 @@ +import torch +import torch.distributed +from torch.distributed import Backend, ProcessGroup +from typing import Any, Dict, List, Optional, Tuple, Union + +class GroupCoordinator: + """ + PyTorch ProcessGroup wrapper for a group of processes. + PyTorch ProcessGroup is bound to one specific communication backend, + e.g. NCCL, Gloo, MPI, etc. + GroupCoordinator takes charge of all the communication operations among + the processes in the group. It can route the communication to + a specific implementation (e.g. switch allreduce implementation + based on the tensor size and cuda graph mode). + """ + + # available attributes: + rank: int # global rank + ranks: List[int] # global ranks in the group + world_size: int # size of the group + # difference between `local_rank` and `rank_in_group`: + # if we have a group of size 4 across two nodes: + # Process | Node | Rank | Local Rank | Rank in Group + # 0 | 0 | 0 | 0 | 0 + # 1 | 0 | 1 | 1 | 1 + # 2 | 1 | 2 | 0 | 2 + # 3 | 1 | 3 | 1 | 3 + local_rank: int # local rank used to assign devices + rank_in_group: int # rank inside the group + cpu_group: ProcessGroup # group for CPU communication + device_group: ProcessGroup # group for device communication + + def __init__( + self, + group_ranks: List[List[int]], + local_rank: int, + torch_distributed_backend: Union[str, Backend], + ): + + self.rank = torch.distributed.get_rank() + self.local_rank = local_rank + self.device_group = None + self.cpu_group = None + + for ranks in group_ranks: + device_group = torch.distributed.new_group( + ranks, backend=torch_distributed_backend + ) + # a group with `gloo` backend, to allow direct coordination between + # processes through the CPU. + cpu_group = torch.distributed.new_group(ranks, backend="gloo") + if self.rank in ranks: + self.ranks = ranks + self.world_size = len(ranks) + self.rank_in_group = ranks.index(self.rank) + self.device_group = device_group + self.cpu_group = cpu_group + + assert self.cpu_group is not None + assert self.device_group is not None + + if torch.cuda.is_available(): + self.device = torch.device(f"cuda:{local_rank}") + else: + self.device = torch.device("cpu") + + def all_gather(# xinze: this is just adapted torch.all_gather_into_tensor and then reshape + self, input_: torch.Tensor, dim: int = 0, separate_tensors: bool = False + ) -> Union[torch.Tensor, List[torch.Tensor]]: + world_size = self.world_size + if world_size == 1: + return input_ + if dim <0: + dim += input_.dim() + input_size = input_.size() + output_tensor = torch.empty( + (world_size,) + input_size, dtype=input_.dtype, device=input_.device #xinze: (world_size, ) is a tuple. + ) + # All-gather + torch.distributed.all_gather_into_tensor( + output_tensor, input_, group=self.device_group + ) + if dim != 0: + output_tensor = output_tensor.movedim(0, dim) + + if separate_tensors: + tensor_list = [ + output_tensor.view(-1) + .narrow(0, input_.numel() * i, input_.numel()) + .view_as(input_) + for i in range(world_size) + ] + return tensor_list + else: + input_size = list(input_.size()) + input_size[dim] = input_size[dim] * world_size + output_tensor = output_tensor.reshape(input_size) + return output_tensor + + @property + def prev_rank(self): + rank_in_group = self.rank_in_group + world_size = self.world_size + return self.ranks[(rank_in_group - 1) % world_size] + + @property + def first_rank(self): + """Return the global rank of the first process in the group""" + return self.ranks[0] + + @property + def last_rank(self): + """Return the global rank of the last process in the group""" + return self.ranks[-1] + + @property + def is_first_rank(self): + """Return whether the caller is the first process in the group""" + return self.rank == self.first_rank + + @property + def is_last_rank(self): + """Return whether the caller is the last process in the group""" + return self.rank == self.last_rank + + @property + def next_rank(self): + """Return the global rank of the process that follows the caller""" + rank_in_group = self.rank_in_group + world_size = self.world_size + return self.ranks[(rank_in_group + 1) % world_size] + + @property + def group_next_rank(self): + """Return the group rank of the process that follows the caller""" + rank_in_group = self.rank_in_group + world_size = self.world_size + return (rank_in_group + 1) % world_size + + @property + def group_prev_rank(self): + """Return the group rank of the process that precedes the caller""" + rank_in_group = self.rank_in_group + world_size = self.world_size + return (rank_in_group - 1) % world_size + + @property + def skip_rank(self): + """Return the global rank of the process that skip connects with the caller""" + rank_in_group = self.rank_in_group + world_size = self.world_size + return self.ranks[(world_size - rank_in_group - 1) % world_size] + + @property + def group_skip_rank(self): + """Return the group rank of the process that skip connects with the caller""" + rank_in_group = self.rank_in_group + world_size = self.world_size + return (world_size - rank_in_group - 1) % world_size + +class SequenceParallelGroupCoordinator(GroupCoordinator): + def __init__( + self, + group_ranks: List[List[int]], + local_rank: int, + torch_distributed_backend: Union[str, Backend], + **kwargs, + ): + super().__init__( + group_ranks=group_ranks, + local_rank=local_rank, + torch_distributed_backend=torch_distributed_backend, + ) + + ulysses_group = kwargs.get("ulysses_group", None) + ring_group = kwargs.get("ring_group", None) + if ulysses_group is None: + raise RuntimeError( + f"Please pass argument 'ulysses_group' when calling init func of SequenceParallelGroupCoordinator" + ) + if ring_group is None: + raise RuntimeError( + f"Please pass argument 'ring_group' when calling init func of SequenceParallelGroupCoordinator" + ) + self.ulysses_group = ulysses_group + self.ring_group = ring_group + + self.ulysses_world_size = torch.distributed.get_world_size( + self.ulysses_group + ) + self.ulysses_rank = torch.distributed.get_rank(self.ulysses_group) + self.ring_world_size = torch.distributed.get_world_size(self.ring_group) + self.ring_rank = torch.distributed.get_rank(self.ring_group) + +class PipelineParallelGroupCoordinator(GroupCoordinator): + def __init__( + self, + group_ranks: List[List[int]], + local_rank: int, + torch_distributed_backend: Union[str, Backend], + **kwargs, + ): + self.rank = torch.distributed.get_rank() + self.local_rank = local_rank + self.device_group = None + self.cpu_group = None + self.cpu_groups = [] + self.device_groups = [] + if len(group_ranks[0]) > 2 or len(group_ranks[0]) == 1: + for ranks in group_ranks: + device_group = torch.distributed.new_group( + ranks, backend=torch_distributed_backend + ) + # a group with `gloo` backend, to allow direct coordination between + # processes through the CPU. + cpu_group = torch.distributed.new_group(ranks, backend="gloo") + if self.rank in ranks: + self.ranks = ranks + self.world_size = len(ranks) + self.rank_in_group = ranks.index(self.rank) + self.device_group = device_group + self.cpu_group = cpu_group + # when pipeline parallelism is 2, we need to create two groups to avoid + # communication stall. + # *_group_0_1 represents the group for communication from device 0 to + # device 1. + # *_group_1_0 represents the group for communication from device 1 to + # device 0. + elif len(group_ranks[0]) == 2: + for ranks in group_ranks: + device_group_0_1 = torch.distributed.new_group( + ranks, backend=torch_distributed_backend + ) + device_group_1_0 = torch.distributed.new_group( + ranks, backend=torch_distributed_backend + ) + # a group with `gloo` backend, to allow direct coordination between + # processes through the CPU. + cpu_group_0_1 = torch.distributed.new_group(ranks, backend="gloo") + cpu_group_1_0 = torch.distributed.new_group(ranks, backend="gloo") + if self.rank in ranks: + self.ranks = ranks + self.world_size = len(ranks) + self.rank_in_group = ranks.index(self.rank) + self.device_groups = [device_group_0_1, device_group_1_0] + self.cpu_groups = [cpu_group_0_1, cpu_group_1_0] + self.device_group = device_group_0_1 + self.cpu_group = cpu_group_0_1 + + assert self.cpu_group is not None + assert self.device_group is not None + + if torch.cuda.is_available(): + self.device = torch.device(f"cuda:{local_rank}") + else: + self.device = torch.device("cpu") + + self.recv_buffer_set: bool = False + self.recv_tasks_queue: List[Tuple[str, int]] = [] + self.receiving_tasks: List[Tuple[torch.distributed.Work, str, int]] = [] + self.dtype: Optional[torch.dtype] = None + self.num_pipefusion_patches: Optional[int] = None + + self.recv_shape: Dict[str, Dict[int, torch.Size]] = {} + self.send_shape: Dict[str, Dict[int, torch.Size]] = {} + self.recv_buffer: Dict[str, Dict[int, torch.Size]] = {} + + self.skip_tensor_recv_buffer_set: bool = False + self.recv_skip_tasks_queue: List[Union[int, Tuple[str, int]]] = [] + self.receiving_skip_tasks: List[Tuple[torch.distributed.Work, str, int]] = [] + self.skip_tensor_recv_buffer: Optional[ + Union[List[torch.Tensor], torch.Tensor] + ] = None + self.skip_device_group = None + for ranks in group_ranks: + skip_device_group = torch.distributed.new_group( + ranks, backend=torch_distributed_backend + ) + if self.rank in ranks: + self.skip_device_group = skip_device_group + assert self.skip_device_group is not None + + def reset_buffer(self): + self.recv_tasks_queue = [] + self.receiving_tasks = [] + self.recv_shape = {} + self.send_shape = {} + self.recv_buffer = {} + + self.recv_skip_tasks_queue = [] + self.receiving_skip_tasks = [] + self.skip_tensor_recv_buffer = {} + + def recv_next(self): + if len(self.recv_tasks_queue) == 0: + raise ValueError("No more tasks to receive") + elif len(self.recv_tasks_queue) > 0: + name, idx = self.recv_tasks_queue.pop(0) + self._check_shape_and_buffer(recv_prev=True, name=name, segment_idx=idx) + self.receiving_tasks.append( + (self._pipeline_irecv(self.recv_buffer[name][idx]), name, idx) + ) + + def _pipeline_irecv(self, tensor: torch.tensor): + return torch.distributed.irecv( + tensor, + src=self.prev_rank, + group=( + self.device_groups[(self.rank_in_group + 1) % 2] + if self.world_size == 2 + else self.device_group + ), + ) + + def get_pipeline_recv_data( + self, idx: int = -1, name: str = "latent" + ) -> torch.Tensor: + receiving_task = self.receiving_tasks.pop(0) + receiving_task[0].wait() + return self.recv_buffer[name][idx] + + def _check_shape_and_buffer( + self, + tensor_send_to_next=None, + recv_prev=False, + name: Optional[str] = None, + segment_idx: int = 0, + ): + pass + +def generate_masked_orthogonal_rank_groups( + world_size: int, parallel_size: List[int], mask: List[bool] +) -> List[List[int]]: + """Generate orthogonal parallel groups based on the parallel size and mask. + + Arguments: + world_size (int): world size + + parallel_size (List[int]): + The parallel size of each orthogonal parallel type. For example, if + tensor_parallel_size = 2, pipeline_model_parallel_group = 3, data_parallel_size = 4, + and the parallel mapping order is tp-pp-dp, then the parallel_size = [2, 3, 4]. + + mask (List[bool]): + The mask controls which parallel methods the generated groups represent. If mask[i] is + True, it means the generated group contains the i-th parallelism method. For example, + if parallel_size = [tp_size, pp_size, dp_size], and mask = [True, False , True], then + the generated group is the `tp-dp` group, if the mask = [False, True, False], then the + generated group is the `pp` group. + + Algorithm: + For orthogonal parallelism, such as tp/dp/pp/cp, the global_rank and + local_rank satisfy the following equation: + global_rank = tp_rank + dp_rank * tp_size + pp_rank * tp_size * dp_size (1) + tp_rank \in [0, tp_size) + dp_rank \in [0, dp_size) + pp_rank \in [0, pp_size) + + If we want to get the `dp_group` (tp_size * pp_size groups of dp_size ranks each. + For example, if the gpu size is 8 and order is 'tp-pp-dp', size is '2-2-2', and the + dp_group here is [[0, 4], [1, 5], [2, 6], [3, 7]].) + The tp_rank and pp_rank will be combined to form the `dp_group_index`. + dp_group_index = tp_rank + pp_rank * tp_size (2) + + So, Given that tp_rank and pp_rank satisfy equation (2), and dp_rank in + range(0, dp_size), the ranks in dp_group[dp_group_index] satisfies the + equation (1). + + This function solve this math problem. + + For example, if the parallel_size = [tp_size, dp_size, pp_size] = [2, 3, 4], + and the mask = [False, True, False]. Then, + dp_group_index(0) = tp_rank(0) + pp_rank(0) * 2 + dp_group_index(1) = tp_rank(1) + pp_rank(0) * 2 + ... + dp_group_index(7) = tp_rank(1) + pp_rank(3) * 2 + + dp_group[0] = 0 + range(0, 3) * 2 + 0 = [0, 2, 4] + dp_group[1] = 1 + range(0, 3) * 2 + 0 = [1, 3, 5] + ... + dp_group[7] = 1 + range(0, 3) * 2 + 3 * 2 * 3 = [19, 21, 23] + """ + + def prefix_product(a: List[int], init=1) -> List[int]: + r = [init] + for v in a: + init = init * v + r.append(init) + return r + + def inner_product(a: List[int], b: List[int]) -> int: + return sum([x * y for x, y in zip(a, b)]) + + def decompose(index, shape, stride=None): + """ + This function solve the math problem below: + There is an equation: + index = sum(idx[i] * stride[i]) + And given the value of index, stride. + Return the idx. + This function will used to get the pp/dp/pp_rank + from group_index and rank_in_group. + """ + if stride is None: + stride = prefix_product(shape) + idx = [(index // d) % s for s, d in zip(shape, stride)] + # stride is a prefix_product result. And the value of stride[-1] + # is not used. + assert ( + sum([x * y for x, y in zip(idx, stride[:-1])]) == index + ), "idx {} with shape {} mismatch the return idx {}".format(index, shape, idx) + return idx + + masked_shape = [s for s, m in zip(parallel_size, mask) if m] + unmasked_shape = [s for s, m in zip(parallel_size, mask) if not m] + + global_stride = prefix_product(parallel_size) + masked_stride = [d for d, m in zip(global_stride, mask) if m] + unmasked_stride = [d for d, m in zip(global_stride, mask) if not m] + + group_size = prefix_product(masked_shape)[-1] + num_of_group = world_size // group_size + + ranks = [] + for group_index in range(num_of_group): + # get indices from unmaksed for group_index. + decomposed_group_idx = decompose(group_index, unmasked_shape) + rank = [] + for rank_in_group in range(group_size): + # get indices from masked for rank_in_group. + decomposed_rank_idx = decompose(rank_in_group, masked_shape) + rank.append( + inner_product(decomposed_rank_idx, masked_stride) + + inner_product(decomposed_group_idx, unmasked_stride) + ) + ranks.append(rank) + return ranks + + +class RankGenerator(object): + def __init__( + self, + # tp: int, + sp: int, + pp: int, + cfg: int, + # dp: int, + order: str, + rank_offset: int = 0, + ) -> None: + # self.tp = tp + self.sp = sp + self.pp = pp + self.cfg = cfg + # self.dp = dp + self.rank_offset = rank_offset + self.world_size = sp * pp * cfg + + self.name_to_size = { + # "tp": self.tp, + "sp": self.sp, + "pp": self.pp, + "cfg": self.cfg, + # "dp": self.dp, + } + order = order.lower() + + for name in self.name_to_size.keys(): + if name not in order and self.name_to_size[name] != 1: + raise RuntimeError( + f"The size of ({name}) is ({self.name_to_size[name]}), but you haven't specified the order ({self.order})." + ) + elif name not in order: + order = order + "-" + name + + self.order = order + self.ordered_size = [] + + for token in order.split("-"): + self.ordered_size.append(self.name_to_size[token]) + + def get_mask(self, order: str, token: str): + ordered_token = order.split("-") + token = token.split("-") + mask = [False] * len(ordered_token) + for t in token: + mask[ordered_token.index(t)] = True + return mask + + def get_ranks(self, token): + """Get rank group by input token. + + Arguments: + token (str): + Specify the ranks type that want to get. If we want + to obtain multiple parallel types, we can use a hyphen + '-' to separate them. For example, if we want to obtain + the TP_DP group, the token should be 'tp-dp'. + + independent_ep (bool: True): + This flag controls whether we treat EP and DP independently. + EP shares ranks with DP, if we want to get ranks related to + EP, we should set the flag. For example, get_ranks('dp', True) + will get DP modulo EP group, and get_ranks('dp', False) will + get full DP group. + """ + mask = self.get_mask(self.order, token) + ranks = generate_masked_orthogonal_rank_groups( + self.world_size, self.ordered_size, mask + ) + if self.rank_offset > 0: + for rank_group in ranks: + for i in range(len(rank_group)): + rank_group[i] += self.rank_offset + return ranks diff --git a/src/diffusers/nccl_parallel_context.py b/src/diffusers/nccl_parallel_context.py new file mode 100644 index 000000000000..f7b91c791b6c --- /dev/null +++ b/src/diffusers/nccl_parallel_context.py @@ -0,0 +1,503 @@ +import os +from typing import Optional, Union, Tuple, Sequence +from datetime import timedelta +from loguru import logger +from collections.abc import Coroutine + +import asyncio +import torch + +import crossing_accelerator_cuda_extension +from parallel_context import ( + ParallelContext, + AsyncModeContext, + AsyncMode, +) + +# types +Shape = Sequence[int] +Stream = torch.cuda.Stream +ProcessGroup = torch.distributed.ProcessGroup +Communicator = "torch.cuda.nccl.Communicator" + +if int(os.getenv("CROSSING_ENABLE_MSCCLPP_ALLRECUDE", "0")) == 1: + try: + from crossing.accelerators.mscclpp_allreduce import MscclppAllReduce + + MSCCLPP_ALLRECUDE_ENABLED = True + except: + MSCCLPP_ALLRECUDE_ENABLED = False +else: + MSCCLPP_ALLRECUDE_ENABLED = False + +from contextlib import closing +import socket + + +def _find_free_port(): + with closing(socket.socket(socket.AF_INET, socket.SOCK_STREAM)) as s: + s.bind(("", 0)) + s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) + return s.getsockname()[1] + + +MSCCLPP_MAX_SIZE_BYTES = 128 * 1024 + + +class OverlapAsyncModeContext(AsyncModeContext): + def __init__(self, parallel_ctx: "NcclParallelContext"): + self.parallel_ctx = parallel_ctx + + def __enter__(self): + self._coroutine_switch_condition = asyncio.Condition() + self._comm_stream = self.parallel_ctx._tensor_parallel_comm_stream + if self._comm_stream is None: + self._comm_stream = torch.cuda.Stream() + self.parallel_ctx._tensor_parallel_comm_stream = self._comm_stream + self._old_async_mode = self.parallel_ctx._async_mode + self.parallel_ctx._async_mode = self + return self + + def __exit__(self, exc_type, exc_value, traceback): + self.parallel_ctx._async_mode = self._old_async_mode + if exc_type is not None: + logger.error( + f"An exception occurred in OverlapAsyncModeContext context scope: {exc_value}" + ) + return False + + async def gather(self, task1, task2) -> Tuple: + if isinstance(task1, Coroutine): + task1 = asyncio.create_task(task1) + if isinstance(task2, Coroutine): + task2 = asyncio.create_task(task2) + + assert isinstance( + task1, asyncio.Task + ), f"task1 should be a asyncio.Task, but got {task1}" + assert isinstance( + task2, asyncio.Task + ), f"task2 should be a asyncio.Task, but got {task2}" + + result1 = None + result2 = None + task1_completed = False + task2_completed = False + + while not task1_completed or not task2_completed: + done, pending = await asyncio.wait( + [task1, task2], return_when=asyncio.FIRST_COMPLETED + ) + for task in done: + if task is task1: + # notify task2 + async with self._coroutine_switch_condition: + self._coroutine_switch_condition.notify() + result1 = task.result() + task1_completed = True + else: + assert task1_completed + # task_2 done + result2 = task.result() + task2_completed = True + + return result1, result2 + + async def async_allreduce(self, tensor): + comp_stream = torch.cuda.current_stream() + # sync from comp to comm + cuda_event_comp = torch.cuda.Event() + cuda_event_comp.record(stream=comp_stream) + self._comm_stream.wait_event(cuda_event_comp) + + # allreduce on comm stream + with torch.cuda.stream(self._comm_stream): + self.parallel_ctx.allreduce_in_tensor_parallel_group(tensor) + + # sync from comm to comp + cuda_event_comm = torch.cuda.Event() + cuda_event_comm.record(stream=self._comm_stream) + # switch to another coroutine + async with self._coroutine_switch_condition: + self._coroutine_switch_condition.notify() + await self._coroutine_switch_condition.wait() + comp_stream.wait_event(cuda_event_comm) + + +def _init_torch_distributed(timeout=timedelta(hours=24)): + assert torch.cuda.is_available() + assert torch.distributed.is_available() + + env_rank = int(os.getenv("RANK", "0")) + env_world_size = int(os.getenv("WORLD_SIZE", "1")) + if env_world_size == 1: + return + + if torch.distributed.is_initialized(): + assert env_world_size == torch.distributed.get_world_size() + assert env_rank == torch.distributed.get_rank() + return + + backend = "nccl" + options = torch.distributed.ProcessGroupNCCL.Options() + options.is_high_priority_stream = True + + torch.distributed.init_process_group( + backend=backend, + world_size=env_world_size, + rank=env_rank, + timeout=timeout, + pg_options=options, + ) + + +def _check_send_recv_tensors(tensors: Union[torch.Tensor, Sequence[torch.Tensor]]): + if isinstance(tensors, torch.Tensor): + tensors = [tensors] + else: + if not isinstance(tensors, (list, tuple)): + raise ValueError( + f"send_tensors must be a list of tensors, but got type {type(tensors)}" + ) + + for i, tensor in enumerate(tensors): + if not isinstance(tensor, torch.Tensor): + raise ValueError( + "send_tensors must be a list of tensors, " + f"but got {i} th element type {type(tensor)}" + ) + + return tensors + + +class NcclParallelContext(ParallelContext): + def __init__( + self, + *, + ranks: Sequence[int] = None, + tensor_parallel_size: int = 1, + pipeline_parallel_size: int = 1, + device_index: int = 0, + ): + _init_torch_distributed() + + self._ranks = ranks + self._tensor_parallel_size = tensor_parallel_size + self._pipeline_parallel_size = pipeline_parallel_size + self._device_index = device_index + self._torch_device = torch.device(f"cuda:{self._device_index}") + self._parallel_size = tensor_parallel_size * pipeline_parallel_size + + if not isinstance(ranks, (list, tuple)) or not all( + isinstance(rank, int) for rank in ranks + ): + raise ValueError(f"`ranks` should be a list of int") + if len(ranks) != self._parallel_size: + raise ValueError(f"`ranks` should has the same length as parallel_ctx.size") + self._ranks = ranks + + if self._parallel_size > 1: + self._main_group = torch.distributed.new_group(self._ranks, backend="nccl") + else: + self._main_group = None + + # for grouping + self._process_mesh = torch.tensor(self._ranks) + + self._rank = ( + torch.distributed.get_rank() if torch.distributed.is_initialized() else 0 + ) + + # TODO: remove when tests don't rely on set_device in parallel_ctx + if self._rank in self._ranks: + torch.cuda.set_device(self._device_index) + + # tensor parallel property + self._tensor_parallel_group: Optional[ProcessGroup] = None + self._tensor_parallel_group_root: int = 0 + self._tensor_parallel_main_comm: Optional[Communicator] = None + self._tensor_parallel_comm_stream: Optional[Stream] = None + # async mode + self._async_mode: Optional[AsyncModeContext] = None + + # pipeline parallel property + self._pipeline_parallel_group: Optional[ProcessGroup] = None + self._pipeline_stage_id: int = 0 + self._pipeline_parallel_group_prev_rank = 0 + self._pipeline_parallel_group_next_rank = 0 + + with torch.cuda.device(self._device_index): + self._init_pipeline_parallel_group() + self._init_tensor_parallel_group() + + if self.tensor_parallel_size > 1 and MSCCLPP_ALLRECUDE_ENABLED: + if self.tensor_parallel_rank == 0: + port = _find_free_port() + port_tensor = torch.tensor( + [port], dtype=torch.int32, device=self._torch_device + ) + else: + port_tensor = torch.empty( + (1,), dtype=torch.int32, device=self._torch_device + ) + self.broadcast_in_tensor_parallel_group(port_tensor) + port = port_tensor.item() + self._mscclpp_allreduce = MscclppAllReduce( + rank=self.tensor_parallel_rank, + parallel_size=self.tensor_parallel_size, + max_size_bytes=MSCCLPP_MAX_SIZE_BYTES, + port=port, + device=self._torch_device, + ) + else: + self._mscclpp_allreduce = None + + def _init_pipeline_parallel_group(self): + if self.size > 1: + self._pipeline_parallel_group = self._new_group( + self._pipeline_parallel_size + ) + if self._pipeline_parallel_group is not None: + # set pipeline property + group_ranks = torch.distributed.get_process_group_ranks( + self._pipeline_parallel_group + ) + self._pipeline_stage_id = group_ranks.index(self._rank) + self._pipeline_parallel_group_prev_rank = group_ranks[ + (self._pipeline_stage_id - 1) % self._pipeline_parallel_size + ] + self._pipeline_parallel_group_next_rank = group_ranks[ + (self._pipeline_stage_id + 1) % self._pipeline_parallel_size + ] + + def _init_tensor_parallel_group(self): + if self.size > 1: + self._tensor_parallel_group = self._new_group(self._tensor_parallel_size) + if self._tensor_parallel_group is not None: + group_ranks = torch.distributed.get_process_group_ranks( + self._tensor_parallel_group + ) + self._tensor_parallel_group_root = group_ranks[0] + self._tensor_parallel_main_comm = self._create_communicator( + self._tensor_parallel_group + ) + + def _new_group( + self, parallel_size: int + ) -> Optional[torch.distributed.ProcessGroup]: + remain_num_groups = self._process_mesh.size(-1) + if remain_num_groups % parallel_size != 0: + raise ValueError( + f"The process mesh {self._process_mesh} cannot be divided further by parallel_size {parallel_size}" + ) + + num_groups = remain_num_groups // parallel_size + self._process_mesh = self._process_mesh.view( + *self._process_mesh.shape[:-1], parallel_size, num_groups + ) + + ret_group = None + global_rank = torch.distributed.get_rank() + # (past_num_groups, parallel_size, new_num_groups) + process_mesh = self._process_mesh.view(-1, parallel_size, num_groups) + for group_i in range(process_mesh.size(0)): + for group_j in range(process_mesh.size(-1)): + global_ranks = process_mesh[group_i, :, group_j].tolist() + group = torch.distributed.new_group(global_ranks, backend="nccl") + if global_rank in global_ranks: + ret_group = group + + return ret_group + + def _create_communicator(self, group: torch.distributed.ProcessGroup): + backend = torch.distributed.get_backend(group) + assert backend == "nccl" + group_ranks = torch.distributed.get_process_group_ranks(group) + if self._rank in group_ranks: + group_rank = group_ranks.index(self._rank) + unique_id = torch.cuda.nccl.unique_id() + unique_id_tensor = torch.ByteTensor(list(unique_id)).cuda() + torch.distributed.broadcast( + unique_id_tensor, src=group_ranks[0], group=group + ) + unique_id = unique_id_tensor.cpu().numpy().tobytes() + comm = crossing_accelerator_cuda_extension._nccl_comm_init_rank( + nranks=len(group_ranks), commId=unique_id, rank=group_rank + ) + return comm + return None + + def device_index(self) -> int: + return self._device_index + + def torch_device(self) -> torch.device: + return self._torch_device + + def allreduce(self, tensor: torch.Tensor, red_op: torch.distributed.ReduceOp): + if self.size > 1: + torch.distributed.all_reduce(tensor, op=red_op, group=self._main_group) + + @property + def tensor_parallel_group(self): + return self._tensor_parallel_group + + @property + def size(self) -> int: + return self._parallel_size + + @property + def tensor_parallel_size(self): + return self._tensor_parallel_size + + @property + def tensor_parallel_rank(self) -> int: + if self._tensor_parallel_group is None: + return 0 + return self._tensor_parallel_group.rank() + + def broadcast_in_tensor_parallel_group(self, tensor: torch.Tensor): + if self.tensor_parallel_size > 1: + torch.distributed.broadcast( + tensor, + src=self._tensor_parallel_group_root, + group=self._tensor_parallel_group, + ) + + def allreduce_in_tensor_parallel_group(self, tensor: torch.Tensor): + if self.tensor_parallel_size > 1: + tensor_size = tensor.numel() * tensor.element_size() + if ( + self._mscclpp_allreduce + and tensor_size <= MSCCLPP_MAX_SIZE_BYTES + and tensor.dtype == torch.float16 + and tensor.is_contiguous() + ): + self._mscclpp_allreduce(tensor) + else: + crossing_accelerator_cuda_extension._nccl_all_reduce( + input=tensor, + output=tensor, + op=0, # ncclRedOp_t::ncclSum + comm=self._tensor_parallel_main_comm, + ) + + def allgather_in_tensor_parallel_group( + self, input: torch.Tensor, output: torch.Tensor + ): + if self.tensor_parallel_size > 1: + crossing_accelerator_cuda_extension._nccl_all_gather( + input=input, + output=output, + comm=self._tensor_parallel_main_comm, + ) + + def async_mode(self, async_mode_type: AsyncMode) -> AsyncModeContext: + if async_mode_type == AsyncMode.OVERLAPPING: + return OverlapAsyncModeContext(self) + + raise NotImplementedError + + async def async_allreduce_in_tensor_parallel_group(self, tensor: torch.Tensor): + if self.tensor_parallel_size == 1: + return + + if self._async_mode is None: + return self.allreduce_in_tensor_parallel_group(tensor) + + return await self._async_mode.async_allreduce(tensor) + + @property + def pipeline_parallel_group(self): + return self._pipeline_parallel_group + + @property + def pipeline_parallel_size(self) -> int: + return self._pipeline_parallel_size + + @property + def pipeline_stage_id(self) -> int: + return self._pipeline_stage_id + + def recv_from_prev_stage( + self, recv_tensors: Union[torch.Tensor, Sequence[torch.Tensor]] + ): + """Receive tensor from previous stage in pipeline (forward receive).""" + assert ( + self.pipeline_parallel_group is not None + ), "pipeline_parallel_group is not initialized, pipeline_parallel_size need to be set greater than 1" + + recv_tensors = _check_send_recv_tensors(recv_tensors) + p2p_ops = [] + for recv_tensor in recv_tensors: + recv_op = torch.distributed.P2POp( + torch.distributed.irecv, + recv_tensor, + self._pipeline_parallel_group_prev_rank, + group=self.pipeline_parallel_group, + ) + p2p_ops.append(recv_op) + + if len(p2p_ops) > 0: + reqs = torch.distributed.batch_isend_irecv(p2p_ops) + for req in reqs: + req.wait() + + def send_to_next_stage( + self, send_tensors: Union[torch.Tensor, Sequence[torch.Tensor]] + ): + """Send tensor to next stage in pipeline (forward send).""" + assert ( + self.pipeline_parallel_group is not None + ), "pipeline_parallel_group is not initialized, pipeline_parallel_size need to be set greater than 1" + + send_tensors = _check_send_recv_tensors(send_tensors) + p2p_ops = [] + for tensor in send_tensors: + send_op = torch.distributed.P2POp( + torch.distributed.isend, + tensor, + self._pipeline_parallel_group_next_rank, + group=self.pipeline_parallel_group, + ) + p2p_ops.append(send_op) + + if len(p2p_ops) > 0: + reqs = torch.distributed.batch_isend_irecv(p2p_ops) + for req in reqs: + req.wait() + + def send_and_recv_between_neighborhoods( + self, + recv_tensors: Union[torch.Tensor, Sequence[torch.Tensor]], + send_tensors: Union[torch.Tensor, Sequence[torch.Tensor]], + ): + assert ( + self.pipeline_parallel_group is not None + ), "pipeline_parallel_group is not initialized, pipeline_parallel_size need to be set greater than 1" + + recv_tensors = _check_send_recv_tensors(recv_tensors) + send_tensors = _check_send_recv_tensors(send_tensors) + p2p_ops = [] + + for recv_tensor in recv_tensors: + recv_op = torch.distributed.P2POp( + torch.distributed.irecv, + recv_tensor, + self._pipeline_parallel_group_prev_rank, + group=self.pipeline_parallel_group, + ) + p2p_ops.append(recv_op) + + for send_tensor in send_tensors: + send_op = torch.distributed.P2POp( + torch.distributed.isend, + send_tensor, + self._pipeline_parallel_group_next_rank, + group=self.pipeline_parallel_group, + ) + p2p_ops.append(send_op) + + if len(p2p_ops) > 0: + reqs = torch.distributed.batch_isend_irecv(p2p_ops) + for req in reqs: + req.wait() \ No newline at end of file diff --git a/src/diffusers/parallel_state.py b/src/diffusers/parallel_state.py new file mode 100644 index 000000000000..591bad5bfc71 --- /dev/null +++ b/src/diffusers/parallel_state.py @@ -0,0 +1,209 @@ +from typing import List, Optional +import torch +import torch.distributed +from diffusers.group_coordinator import ( + GroupCoordinator, + PipelineParallelGroupCoordinator, + SequenceParallelGroupCoordinator, + RankGenerator, + generate_masked_orthogonal_rank_groups +) +import os +from yunchang import set_seq_parallel_pg +from yunchang.globals import PROCESS_GROUP + +_WORLD: Optional[GroupCoordinator] = None +_SP: Optional[SequenceParallelGroupCoordinator] = None +_PP: Optional[PipelineParallelGroupCoordinator] = None +_CFG: Optional[GroupCoordinator] = None + +def get_world_group() -> GroupCoordinator: + return _WORLD + +# SP +def get_sp_group() -> SequenceParallelGroupCoordinator: + return _SP + +def get_sequence_parallel_world_size(): + """Return world size for the sequence parallel group.""" + return get_sp_group().world_size + + +def get_sequence_parallel_rank(): + """Return my rank for the sequence parallel group.""" + return get_sp_group().rank_in_group + + +def get_ulysses_parallel_world_size(): + return get_sp_group().ulysses_world_size + + +def get_ulysses_parallel_rank(): + return get_sp_group().ulysses_rank + + +def get_ring_parallel_world_size(): + return get_sp_group().ring_world_size + +def get_ring_parallel_rank(): + return get_sp_group().ring_rank + +# CFG +def get_cfg_group() -> GroupCoordinator: + return _CFG + +def get_classifier_free_guidance_world_size(): + """Return world size for the classifier_free_guidance parallel group.""" + return get_cfg_group().world_size + + +def get_classifier_free_guidance_rank(): + """Return my rank for the classifier_free_guidance parallel group.""" + return get_cfg_group().rank_in_group + + + +# PP +def get_pp_group() -> GroupCoordinator: + return _PP + + +def get_pipeline_parallel_world_size(): + """Return world size for the pipeline model parallel group.""" + return get_pp_group().world_size + + +def get_pipeline_parallel_rank(): + """Return my rank for the pipeline model parallel group.""" + return get_pp_group().rank_in_group + + +def is_pipeline_first_stage(): + """Return True if in the first pipeline model parallel stage, False otherwise.""" + return get_pipeline_parallel_rank() == 0 + + +def is_pipeline_last_stage(): + """Return True if in the last pipeline model parallel stage, False otherwise.""" + return get_pipeline_parallel_rank() == (get_pipeline_parallel_world_size() - 1) + + +def init_world_group( + ranks: List[int], local_rank: int, backend: str +) -> GroupCoordinator: + return GroupCoordinator( + group_ranks=[ranks], + local_rank=local_rank, + torch_distributed_backend=backend, + ) + +def init_model_parallel_group( + group_ranks: List[List[int]], + local_rank: int, + backend: "nccl", + parallel_mode: str, + **kwargs, +) -> GroupCoordinator: + assert parallel_mode in [ + "data", + "pipeline", + "tensor", + "sequence", + "classifier_free_guidance", + ], f"parallel_mode {parallel_mode} is not supported" + if parallel_mode == "pipeline": + return PipelineParallelGroupCoordinator( + group_ranks=group_ranks, + local_rank=local_rank, + torch_distributed_backend=backend, + ) + elif parallel_mode == "sequence": + return SequenceParallelGroupCoordinator( + group_ranks=group_ranks, + local_rank=local_rank, + torch_distributed_backend=backend, + **kwargs, + ) + else: + return GroupCoordinator( + group_ranks=group_ranks, + local_rank=local_rank, + torch_distributed_backend=backend, + ) + + +def initialize_model_parallel( + classifier_free_guidance_degree: int = 1, + # sequence_parallel_degree: int = 1, + ulysses_degree: int = 1, + ring_degree: int = 1, + # tensor_parallel_degree: int = 1, + pipeline_parallel_degree: int = 1, +) -> None: + sequence_parallel_degree = ulysses_degree * ring_degree + rank_generator: RankGenerator = RankGenerator( + # tensor_parallel_degree, + sequence_parallel_degree, + pipeline_parallel_degree, + classifier_free_guidance_degree, + # data_parallel_degree, + "sp-pp-cfg", + ) + global _CFG + global _PP + global _SP + backend = "nccl" + _CFG = init_model_parallel_group( + group_ranks=rank_generator.get_ranks("cfg"), + local_rank=get_world_group().local_rank, + backend=backend, + parallel_mode="classifier_free_guidance", + ) + grouprankcfg = rank_generator.get_ranks("cfg") + grouprankpp = rank_generator.get_ranks("pp") + groupranksp = rank_generator.get_ranks("sp") + print(f"cfg group ranks is {grouprankcfg}, pp group ranks is {grouprankpp}, sp group rank is {groupranksp}") + + _PP = init_model_parallel_group( + group_ranks=rank_generator.get_ranks("pp"), + local_rank=get_world_group().local_rank, + backend=backend, + parallel_mode="pipeline", + ) + + set_seq_parallel_pg( + sp_ulysses_degree=ulysses_degree, + sp_ring_degree=ring_degree, + rank=get_world_group().rank_in_group, + world_size=get_world_group().world_size, + ) + _SP = init_model_parallel_group( + group_ranks=rank_generator.get_ranks("sp"), + local_rank=get_world_group().local_rank, + backend=backend, + parallel_mode="sequence", + ulysses_group=PROCESS_GROUP.ULYSSES_PG, + ring_group=PROCESS_GROUP.RING_PG, + ) + print(f"ulysses group is {PROCESS_GROUP.ULYSSES_PG}, ring group is {PROCESS_GROUP.RING_PG}") + print(f"ulysses world size is {_SP.ulysses_world_size}, ring group is {_SP.ring_world_size}") + + +def init_distributed_environment( + world_size: int = -1, + rank: int = -1, + distributed_init_method: str = "env://", + local_rank: int = -1, + backend: str = "nccl", +): + local_rank= int(os.environ.get("LOCAL_RANK", "0")) + torch.distributed.init_process_group( + backend="nccl", + init_method="env://", + world_size=-1, + rank=-1, + ) + torch.cuda.set_device(local_rank) + global _WORLD + ranks = list(range(torch.distributed.get_world_size())) + _WORLD = init_world_group(ranks, local_rank, backend="nccl") \ No newline at end of file diff --git a/src/diffusers/pipelines/stable_diffusion_3/pipeline_stable_diffusion_3_pp.py b/src/diffusers/pipelines/stable_diffusion_3/pipeline_stable_diffusion_3_pp.py new file mode 100644 index 000000000000..675f05c010b8 --- /dev/null +++ b/src/diffusers/pipelines/stable_diffusion_3/pipeline_stable_diffusion_3_pp.py @@ -0,0 +1,1241 @@ +# Copyright 2024 Stability AI and The HuggingFace Team. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import inspect +from typing import Any, Callable, Dict, List, Optional, Union + +import torch +from transformers import ( + CLIPTextModelWithProjection, + CLIPTokenizer, + T5EncoderModel, + T5TokenizerFast, +) +import torch.distributed as dist +from yfusers.image_processor import VaeImageProcessor +from yfusers.loaders import FromSingleFileMixin, SD3LoraLoaderMixin +# from diffusers.models.autoencoders import AutoencoderKL +from yfusers.models.autoencoders.autoencoder_kl import AutoencoderKL +from yfusers.models.transformers.transformer_sd3 import SD3Transformer2DModel +from yfusers.schedulers import FlowMatchEulerDiscreteScheduler +from yfusers.utils import ( + USE_PEFT_BACKEND, + is_torch_xla_available, + logging, + replace_example_docstring, + scale_lora_layers, + unscale_lora_layers, +) +from diffusers.utils.torch_utils import randn_tensor +from yfusers.pipelines.pipeline_utils import DiffusionPipeline +from .pipeline_output import StableDiffusion3PipelineOutput + +from yfusers.torch_parallel_context import TorchBasedParallelContext +from yfusers.postal_service import ( + Shipment, + PostalService, +) +from yfusers.parallel_state import ( + get_cfg_group, + get_classifier_free_guidance_rank, + get_classifier_free_guidance_world_size, + get_pipeline_parallel_rank, + get_pipeline_parallel_world_size, + get_pp_group, + get_ring_parallel_rank, + get_ring_parallel_world_size, + get_sequence_parallel_rank, + get_sequence_parallel_world_size, + get_sp_group, + get_ulysses_parallel_rank, + get_ulysses_parallel_world_size, + get_world_group, + generate_masked_orthogonal_rank_groups, + is_pipeline_first_stage, + is_pipeline_last_stage, +) +from yfusers.runtime_state import( + get_runtime_state, +) + +if is_torch_xla_available(): + import torch_xla.core.xla_model as xm + + XLA_AVAILABLE = True +else: + XLA_AVAILABLE = False + + +logger = logging.get_logger(__name__) # pylint: disable=invalid-name + +EXAMPLE_DOC_STRING = """ + Examples: + ```py + >>> import torch + >>> from diffusers import StableDiffusion3Pipeline + + >>> pipe = StableDiffusion3Pipeline.from_pretrained( + ... "stabilityai/stable-diffusion-3-medium-diffusers", torch_dtype=torch.float16 + ... ) + >>> pipe.to("cuda") + >>> prompt = "A cat holding a sign that says hello world" + >>> image = pipe(prompt).images[0] + >>> image.save("sd3.png") + ``` +""" + + +# Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.retrieve_timesteps +def retrieve_timesteps( + scheduler, + num_inference_steps: Optional[int] = None, + device: Optional[Union[str, torch.device]] = None, + timesteps: Optional[List[int]] = None, + sigmas: Optional[List[float]] = None, + **kwargs, +): + r""" + Calls the scheduler's `set_timesteps` method and retrieves timesteps from the scheduler after the call. Handles + custom timesteps. Any kwargs will be supplied to `scheduler.set_timesteps`. + + Args: + scheduler (`SchedulerMixin`): + The scheduler to get timesteps from. + num_inference_steps (`int`): + The number of diffusion steps used when generating samples with a pre-trained model. If used, `timesteps` + must be `None`. + device (`str` or `torch.device`, *optional*): + The device to which the timesteps should be moved to. If `None`, the timesteps are not moved. + timesteps (`List[int]`, *optional*): + Custom timesteps used to override the timestep spacing strategy of the scheduler. If `timesteps` is passed, + `num_inference_steps` and `sigmas` must be `None`. + sigmas (`List[float]`, *optional*): + Custom sigmas used to override the timestep spacing strategy of the scheduler. If `sigmas` is passed, + `num_inference_steps` and `timesteps` must be `None`. + + Returns: + `Tuple[torch.Tensor, int]`: A tuple where the first element is the timestep schedule from the scheduler and the + second element is the number of inference steps. + """ + if timesteps is not None and sigmas is not None: + raise ValueError("Only one of `timesteps` or `sigmas` can be passed. Please choose one to set custom values") + if timesteps is not None: + accepts_timesteps = "timesteps" in set(inspect.signature(scheduler.set_timesteps).parameters.keys()) + if not accepts_timesteps: + raise ValueError( + f"The current scheduler class {scheduler.__class__}'s `set_timesteps` does not support custom" + f" timestep schedules. Please check whether you are using the correct scheduler." + ) + scheduler.set_timesteps(timesteps=timesteps, device=device, **kwargs) + timesteps = scheduler.timesteps + num_inference_steps = len(timesteps) + elif sigmas is not None: + accept_sigmas = "sigmas" in set(inspect.signature(scheduler.set_timesteps).parameters.keys()) + if not accept_sigmas: + raise ValueError( + f"The current scheduler class {scheduler.__class__}'s `set_timesteps` does not support custom" + f" sigmas schedules. Please check whether you are using the correct scheduler." + ) + scheduler.set_timesteps(sigmas=sigmas, device=device, **kwargs) + timesteps = scheduler.timesteps + num_inference_steps = len(timesteps) + else: + scheduler.set_timesteps(num_inference_steps, device=device, **kwargs) + timesteps = scheduler.timesteps + return timesteps, num_inference_steps + + +class StableDiffusion3Pipeline(DiffusionPipeline, SD3LoraLoaderMixin, FromSingleFileMixin): + r""" + Args: + transformer ([`SD3Transformer2DModel`]): + Conditional Transformer (MMDiT) architecture to denoise the encoded image latents. + scheduler ([`FlowMatchEulerDiscreteScheduler`]): + A scheduler to be used in combination with `transformer` to denoise the encoded image latents. + vae ([`AutoencoderKL`]): + Variational Auto-Encoder (VAE) Model to encode and decode images to and from latent representations. + text_encoder ([`CLIPTextModelWithProjection`]): + [CLIP](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModelWithProjection), + specifically the [clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14) variant, + with an additional added projection layer that is initialized with a diagonal matrix with the `hidden_size` + as its dimension. + text_encoder_2 ([`CLIPTextModelWithProjection`]): + [CLIP](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModelWithProjection), + specifically the + [laion/CLIP-ViT-bigG-14-laion2B-39B-b160k](https://huggingface.co/laion/CLIP-ViT-bigG-14-laion2B-39B-b160k) + variant. + text_encoder_3 ([`T5EncoderModel`]): + Frozen text-encoder. Stable Diffusion 3 uses + [T5](https://huggingface.co/docs/transformers/model_doc/t5#transformers.T5EncoderModel), specifically the + [t5-v1_1-xxl](https://huggingface.co/google/t5-v1_1-xxl) variant. + tokenizer (`CLIPTokenizer`): + Tokenizer of class + [CLIPTokenizer](https://huggingface.co/docs/transformers/v4.21.0/en/model_doc/clip#transformers.CLIPTokenizer). + tokenizer_2 (`CLIPTokenizer`): + Second Tokenizer of class + [CLIPTokenizer](https://huggingface.co/docs/transformers/v4.21.0/en/model_doc/clip#transformers.CLIPTokenizer). + tokenizer_3 (`T5TokenizerFast`): + Tokenizer of class + [T5Tokenizer](https://huggingface.co/docs/transformers/model_doc/t5#transformers.T5Tokenizer). + """ + + model_cpu_offload_seq = "text_encoder->text_encoder_2->text_encoder_3->transformer->vae" + _optional_components = [] + _callback_tensor_inputs = ["latents", "prompt_embeds", "negative_prompt_embeds", "negative_pooled_prompt_embeds"] + + def __init__( + self, + transformer: SD3Transformer2DModel, + scheduler: FlowMatchEulerDiscreteScheduler, + vae: AutoencoderKL, + text_encoder: CLIPTextModelWithProjection, + tokenizer: CLIPTokenizer, + text_encoder_2: CLIPTextModelWithProjection, + tokenizer_2: CLIPTokenizer, + text_encoder_3: T5EncoderModel, + tokenizer_3: T5TokenizerFast, + ): + super().__init__() + self.world_size = get_pp_group().world_size + self.local_rank = get_pp_group().local_rank + + self.parallel_ctx = TorchBasedParallelContext( + ranks=list(range(self.world_size)), + pipeline_parallel_size=self.world_size, + device_index=self.local_rank, + ) + self.post_office = PostalService(self.parallel_ctx) + self.shipment = Shipment(self.parallel_ctx.torch_device()) + # xinze: every time updates a dict + + self.register_modules( + vae=vae, + text_encoder=text_encoder, + text_encoder_2=text_encoder_2, + text_encoder_3=text_encoder_3, + tokenizer=tokenizer, + tokenizer_2=tokenizer_2, + tokenizer_3=tokenizer_3, + transformer=SD3Transformer2DModel, + scheduler=scheduler, + ) + self.vae_scale_factor = ( + 2 ** (len(self.vae.config.block_out_channels) - 1) if hasattr(self, "vae") and self.vae is not None else 8 + ) + self.image_processor = VaeImageProcessor(vae_scale_factor=self.vae_scale_factor) + self.tokenizer_max_length = ( + self.tokenizer.model_max_length if hasattr(self, "tokenizer") and self.tokenizer is not None else 77 + ) + # self.default_sample_size = ( + # self.transformer.config.sample_size + # if hasattr(self, "transformer") and self.transformer is not None + # else 128 + # ) + self.default_sample_size = 128 + print(f"the config is {self.transformer.config}") + # self.patch_size = ( + # self.transformer.config.patch_size if hasattr(self, "transformer") and self.transformer is not None else 2 + # ) + self.patch_size = 2 + + def _get_t5_prompt_embeds( + self, + prompt: Union[str, List[str]] = None, + num_images_per_prompt: int = 1, + max_sequence_length: int = 256, + device: Optional[torch.device] = None, + dtype: Optional[torch.dtype] = None, + ): + device = device or self._execution_device + dtype = dtype or self.text_encoder.dtype + + prompt = [prompt] if isinstance(prompt, str) else prompt + batch_size = len(prompt) + + if self.text_encoder_3 is None: + return torch.zeros( + ( + batch_size * num_images_per_prompt, + self.tokenizer_max_length, + self.transformer.config.joint_attention_dim, + ), + device=device, + dtype=dtype, + ) + + text_inputs = self.tokenizer_3( + prompt, + padding="max_length", + max_length=max_sequence_length, + truncation=True, + add_special_tokens=True, + return_tensors="pt", + ) + text_input_ids = text_inputs.input_ids + untruncated_ids = self.tokenizer_3(prompt, padding="longest", return_tensors="pt").input_ids + + if untruncated_ids.shape[-1] >= text_input_ids.shape[-1] and not torch.equal(text_input_ids, untruncated_ids): + removed_text = self.tokenizer_3.batch_decode(untruncated_ids[:, self.tokenizer_max_length - 1 : -1]) + logger.warning( + "The following part of your input was truncated because `max_sequence_length` is set to " + f" {max_sequence_length} tokens: {removed_text}" + ) + + prompt_embeds = self.text_encoder_3(text_input_ids.to(device))[0] + + dtype = self.text_encoder_3.dtype + prompt_embeds = prompt_embeds.to(dtype=dtype, device=device) + + _, seq_len, _ = prompt_embeds.shape + + # duplicate text embeddings and attention mask for each generation per prompt, using mps friendly method + prompt_embeds = prompt_embeds.repeat(1, num_images_per_prompt, 1) + prompt_embeds = prompt_embeds.view(batch_size * num_images_per_prompt, seq_len, -1) + + return prompt_embeds + + def _get_clip_prompt_embeds( + self, + prompt: Union[str, List[str]], + num_images_per_prompt: int = 1, + device: Optional[torch.device] = None, + clip_skip: Optional[int] = None, + clip_model_index: int = 0, + ): + device = device or self._execution_device + + clip_tokenizers = [self.tokenizer, self.tokenizer_2] + clip_text_encoders = [self.text_encoder, self.text_encoder_2] + + tokenizer = clip_tokenizers[clip_model_index] + text_encoder = clip_text_encoders[clip_model_index] + + prompt = [prompt] if isinstance(prompt, str) else prompt + batch_size = len(prompt) + + text_inputs = tokenizer( + prompt, + padding="max_length", + max_length=self.tokenizer_max_length, + truncation=True, + return_tensors="pt", + ) + + text_input_ids = text_inputs.input_ids + untruncated_ids = tokenizer(prompt, padding="longest", return_tensors="pt").input_ids + if untruncated_ids.shape[-1] >= text_input_ids.shape[-1] and not torch.equal(text_input_ids, untruncated_ids): + removed_text = tokenizer.batch_decode(untruncated_ids[:, self.tokenizer_max_length - 1 : -1]) + logger.warning( + "The following part of your input was truncated because CLIP can only handle sequences up to" + f" {self.tokenizer_max_length} tokens: {removed_text}" + ) + prompt_embeds = text_encoder(text_input_ids.to(device), output_hidden_states=True) + pooled_prompt_embeds = prompt_embeds[0] + + if clip_skip is None: + prompt_embeds = prompt_embeds.hidden_states[-2] + else: + prompt_embeds = prompt_embeds.hidden_states[-(clip_skip + 2)] + + prompt_embeds = prompt_embeds.to(dtype=self.text_encoder.dtype, device=device) + + _, seq_len, _ = prompt_embeds.shape + # duplicate text embeddings for each generation per prompt, using mps friendly method + prompt_embeds = prompt_embeds.repeat(1, num_images_per_prompt, 1) + prompt_embeds = prompt_embeds.view(batch_size * num_images_per_prompt, seq_len, -1) + + pooled_prompt_embeds = pooled_prompt_embeds.repeat(1, num_images_per_prompt, 1) + pooled_prompt_embeds = pooled_prompt_embeds.view(batch_size * num_images_per_prompt, -1) + + return prompt_embeds, pooled_prompt_embeds + + def encode_prompt( + self, + prompt: Union[str, List[str]], + prompt_2: Union[str, List[str]], + prompt_3: Union[str, List[str]], + device: Optional[torch.device] = None, + num_images_per_prompt: int = 1, + do_classifier_free_guidance: bool = True, + negative_prompt: Optional[Union[str, List[str]]] = None, + negative_prompt_2: Optional[Union[str, List[str]]] = None, + negative_prompt_3: Optional[Union[str, List[str]]] = None, + prompt_embeds: Optional[torch.FloatTensor] = None, + negative_prompt_embeds: Optional[torch.FloatTensor] = None, + pooled_prompt_embeds: Optional[torch.FloatTensor] = None, + negative_pooled_prompt_embeds: Optional[torch.FloatTensor] = None, + clip_skip: Optional[int] = None, + max_sequence_length: int = 256, + lora_scale: Optional[float] = None, + ): + r""" + + Args: + prompt (`str` or `List[str]`, *optional*): + prompt to be encoded + prompt_2 (`str` or `List[str]`, *optional*): + The prompt or prompts to be sent to the `tokenizer_2` and `text_encoder_2`. If not defined, `prompt` is + used in all text-encoders + prompt_3 (`str` or `List[str]`, *optional*): + The prompt or prompts to be sent to the `tokenizer_3` and `text_encoder_3`. If not defined, `prompt` is + used in all text-encoders + device: (`torch.device`): + torch device + num_images_per_prompt (`int`): + number of images that should be generated per prompt + do_classifier_free_guidance (`bool`): + whether to use classifier free guidance or not + negative_prompt (`str` or `List[str]`, *optional*): + The prompt or prompts not to guide the image generation. If not defined, one has to pass + `negative_prompt_embeds` instead. Ignored when not using guidance (i.e., ignored if `guidance_scale` is + less than `1`). + negative_prompt_2 (`str` or `List[str]`, *optional*): + The prompt or prompts not to guide the image generation to be sent to `tokenizer_2` and + `text_encoder_2`. If not defined, `negative_prompt` is used in all the text-encoders. + negative_prompt_2 (`str` or `List[str]`, *optional*): + The prompt or prompts not to guide the image generation to be sent to `tokenizer_3` and + `text_encoder_3`. If not defined, `negative_prompt` is used in both text-encoders + prompt_embeds (`torch.FloatTensor`, *optional*): + Pre-generated text embeddings. Can be used to easily tweak text inputs, *e.g.* prompt weighting. If not + provided, text embeddings will be generated from `prompt` input argument. + negative_prompt_embeds (`torch.FloatTensor`, *optional*): + Pre-generated negative text embeddings. Can be used to easily tweak text inputs, *e.g.* prompt + weighting. If not provided, negative_prompt_embeds will be generated from `negative_prompt` input + argument. + pooled_prompt_embeds (`torch.FloatTensor`, *optional*): + Pre-generated pooled text embeddings. Can be used to easily tweak text inputs, *e.g.* prompt weighting. + If not provided, pooled text embeddings will be generated from `prompt` input argument. + negative_pooled_prompt_embeds (`torch.FloatTensor`, *optional*): + Pre-generated negative pooled text embeddings. Can be used to easily tweak text inputs, *e.g.* prompt + weighting. If not provided, pooled negative_prompt_embeds will be generated from `negative_prompt` + input argument. + clip_skip (`int`, *optional*): + Number of layers to be skipped from CLIP while computing the prompt embeddings. A value of 1 means that + the output of the pre-final layer will be used for computing the prompt embeddings. + lora_scale (`float`, *optional*): + A lora scale that will be applied to all LoRA layers of the text encoder if LoRA layers are loaded. + """ + device = device or self._execution_device + + # set lora scale so that monkey patched LoRA + # function of text encoder can correctly access it + if lora_scale is not None and isinstance(self, SD3LoraLoaderMixin): + self._lora_scale = lora_scale + + # dynamically adjust the LoRA scale + if self.text_encoder is not None and USE_PEFT_BACKEND: + scale_lora_layers(self.text_encoder, lora_scale) + if self.text_encoder_2 is not None and USE_PEFT_BACKEND: + scale_lora_layers(self.text_encoder_2, lora_scale) + + prompt = [prompt] if isinstance(prompt, str) else prompt + if prompt is not None: + batch_size = len(prompt) + else: + batch_size = prompt_embeds.shape[0] + + if prompt_embeds is None: + prompt_2 = prompt_2 or prompt + prompt_2 = [prompt_2] if isinstance(prompt_2, str) else prompt_2 + + prompt_3 = prompt_3 or prompt + prompt_3 = [prompt_3] if isinstance(prompt_3, str) else prompt_3 + + prompt_embed, pooled_prompt_embed = self._get_clip_prompt_embeds( + prompt=prompt, + device=device, + num_images_per_prompt=num_images_per_prompt, + clip_skip=clip_skip, + clip_model_index=0, + ) + prompt_2_embed, pooled_prompt_2_embed = self._get_clip_prompt_embeds( + prompt=prompt_2, + device=device, + num_images_per_prompt=num_images_per_prompt, + clip_skip=clip_skip, + clip_model_index=1, + ) + clip_prompt_embeds = torch.cat([prompt_embed, prompt_2_embed], dim=-1) + + t5_prompt_embed = self._get_t5_prompt_embeds( + prompt=prompt_3, + num_images_per_prompt=num_images_per_prompt, + max_sequence_length=max_sequence_length, + device=device, + ) + + clip_prompt_embeds = torch.nn.functional.pad( + clip_prompt_embeds, (0, t5_prompt_embed.shape[-1] - clip_prompt_embeds.shape[-1]) + ) + + prompt_embeds = torch.cat([clip_prompt_embeds, t5_prompt_embed], dim=-2) + pooled_prompt_embeds = torch.cat([pooled_prompt_embed, pooled_prompt_2_embed], dim=-1) + + if do_classifier_free_guidance and negative_prompt_embeds is None: + negative_prompt = negative_prompt or "" + negative_prompt_2 = negative_prompt_2 or negative_prompt + negative_prompt_3 = negative_prompt_3 or negative_prompt + + # normalize str to list + negative_prompt = batch_size * [negative_prompt] if isinstance(negative_prompt, str) else negative_prompt + negative_prompt_2 = ( + batch_size * [negative_prompt_2] if isinstance(negative_prompt_2, str) else negative_prompt_2 + ) + negative_prompt_3 = ( + batch_size * [negative_prompt_3] if isinstance(negative_prompt_3, str) else negative_prompt_3 + ) + + if prompt is not None and type(prompt) is not type(negative_prompt): + raise TypeError( + f"`negative_prompt` should be the same type to `prompt`, but got {type(negative_prompt)} !=" + f" {type(prompt)}." + ) + elif batch_size != len(negative_prompt): + raise ValueError( + f"`negative_prompt`: {negative_prompt} has batch size {len(negative_prompt)}, but `prompt`:" + f" {prompt} has batch size {batch_size}. Please make sure that passed `negative_prompt` matches" + " the batch size of `prompt`." + ) + + negative_prompt_embed, negative_pooled_prompt_embed = self._get_clip_prompt_embeds( + negative_prompt, + device=device, + num_images_per_prompt=num_images_per_prompt, + clip_skip=None, + clip_model_index=0, + ) + negative_prompt_2_embed, negative_pooled_prompt_2_embed = self._get_clip_prompt_embeds( + negative_prompt_2, + device=device, + num_images_per_prompt=num_images_per_prompt, + clip_skip=None, + clip_model_index=1, + ) + negative_clip_prompt_embeds = torch.cat([negative_prompt_embed, negative_prompt_2_embed], dim=-1) + + t5_negative_prompt_embed = self._get_t5_prompt_embeds( + prompt=negative_prompt_3, + num_images_per_prompt=num_images_per_prompt, + max_sequence_length=max_sequence_length, + device=device, + ) + + negative_clip_prompt_embeds = torch.nn.functional.pad( + negative_clip_prompt_embeds, + (0, t5_negative_prompt_embed.shape[-1] - negative_clip_prompt_embeds.shape[-1]), + ) + + negative_prompt_embeds = torch.cat([negative_clip_prompt_embeds, t5_negative_prompt_embed], dim=-2) + negative_pooled_prompt_embeds = torch.cat( + [negative_pooled_prompt_embed, negative_pooled_prompt_2_embed], dim=-1 + ) + + if self.text_encoder is not None: + if isinstance(self, SD3LoraLoaderMixin) and USE_PEFT_BACKEND: + # Retrieve the original scale by scaling back the LoRA layers + unscale_lora_layers(self.text_encoder, lora_scale) + + if self.text_encoder_2 is not None: + if isinstance(self, SD3LoraLoaderMixin) and USE_PEFT_BACKEND: + # Retrieve the original scale by scaling back the LoRA layers + unscale_lora_layers(self.text_encoder_2, lora_scale) + + return prompt_embeds, negative_prompt_embeds, pooled_prompt_embeds, negative_pooled_prompt_embeds + + def check_inputs( + self, + prompt, + prompt_2, + prompt_3, + height, + width, + negative_prompt=None, + negative_prompt_2=None, + negative_prompt_3=None, + prompt_embeds=None, + negative_prompt_embeds=None, + pooled_prompt_embeds=None, + negative_pooled_prompt_embeds=None, + callback_on_step_end_tensor_inputs=None, + max_sequence_length=None, + ): + if ( + height % (self.vae_scale_factor * self.patch_size) != 0 + or width % (self.vae_scale_factor * self.patch_size) != 0 + ): + raise ValueError( + f"`height` and `width` have to be divisible by {self.vae_scale_factor * self.patch_size} but are {height} and {width}." + f"You can use height {height - height % (self.vae_scale_factor * self.patch_size)} and width {width - width % (self.vae_scale_factor * self.patch_size)}." + ) + + if callback_on_step_end_tensor_inputs is not None and not all( + k in self._callback_tensor_inputs for k in callback_on_step_end_tensor_inputs + ): + raise ValueError( + f"`callback_on_step_end_tensor_inputs` has to be in {self._callback_tensor_inputs}, but found {[k for k in callback_on_step_end_tensor_inputs if k not in self._callback_tensor_inputs]}" + ) + + if prompt is not None and prompt_embeds is not None: + raise ValueError( + f"Cannot forward both `prompt`: {prompt} and `prompt_embeds`: {prompt_embeds}. Please make sure to" + " only forward one of the two." + ) + elif prompt_2 is not None and prompt_embeds is not None: + raise ValueError( + f"Cannot forward both `prompt_2`: {prompt_2} and `prompt_embeds`: {prompt_embeds}. Please make sure to" + " only forward one of the two." + ) + elif prompt_3 is not None and prompt_embeds is not None: + raise ValueError( + f"Cannot forward both `prompt_3`: {prompt_2} and `prompt_embeds`: {prompt_embeds}. Please make sure to" + " only forward one of the two." + ) + elif prompt is None and prompt_embeds is None: + raise ValueError( + "Provide either `prompt` or `prompt_embeds`. Cannot leave both `prompt` and `prompt_embeds` undefined." + ) + elif prompt is not None and (not isinstance(prompt, str) and not isinstance(prompt, list)): + raise ValueError(f"`prompt` has to be of type `str` or `list` but is {type(prompt)}") + elif prompt_2 is not None and (not isinstance(prompt_2, str) and not isinstance(prompt_2, list)): + raise ValueError(f"`prompt_2` has to be of type `str` or `list` but is {type(prompt_2)}") + elif prompt_3 is not None and (not isinstance(prompt_3, str) and not isinstance(prompt_3, list)): + raise ValueError(f"`prompt_3` has to be of type `str` or `list` but is {type(prompt_3)}") + + if negative_prompt is not None and negative_prompt_embeds is not None: + raise ValueError( + f"Cannot forward both `negative_prompt`: {negative_prompt} and `negative_prompt_embeds`:" + f" {negative_prompt_embeds}. Please make sure to only forward one of the two." + ) + elif negative_prompt_2 is not None and negative_prompt_embeds is not None: + raise ValueError( + f"Cannot forward both `negative_prompt_2`: {negative_prompt_2} and `negative_prompt_embeds`:" + f" {negative_prompt_embeds}. Please make sure to only forward one of the two." + ) + elif negative_prompt_3 is not None and negative_prompt_embeds is not None: + raise ValueError( + f"Cannot forward both `negative_prompt_3`: {negative_prompt_3} and `negative_prompt_embeds`:" + f" {negative_prompt_embeds}. Please make sure to only forward one of the two." + ) + + if prompt_embeds is not None and negative_prompt_embeds is not None: + if prompt_embeds.shape != negative_prompt_embeds.shape: + raise ValueError( + "`prompt_embeds` and `negative_prompt_embeds` must have the same shape when passed directly, but" + f" got: `prompt_embeds` {prompt_embeds.shape} != `negative_prompt_embeds`" + f" {negative_prompt_embeds.shape}." + ) + + if prompt_embeds is not None and pooled_prompt_embeds is None: + raise ValueError( + "If `prompt_embeds` are provided, `pooled_prompt_embeds` also have to be passed. Make sure to generate `pooled_prompt_embeds` from the same text encoder that was used to generate `prompt_embeds`." + ) + + if negative_prompt_embeds is not None and negative_pooled_prompt_embeds is None: + raise ValueError( + "If `negative_prompt_embeds` are provided, `negative_pooled_prompt_embeds` also have to be passed. Make sure to generate `negative_pooled_prompt_embeds` from the same text encoder that was used to generate `negative_prompt_embeds`." + ) + + if max_sequence_length is not None and max_sequence_length > 512: + raise ValueError(f"`max_sequence_length` cannot be greater than 512 but is {max_sequence_length}") + + def prepare_latents( + self, + batch_size, + num_channels_latents, + height, + width, + dtype, + device, + generator, + latents=None, + ): + if latents is not None: + return latents.to(device=device, dtype=dtype) + + shape = ( + batch_size, + num_channels_latents, + int(height) // self.vae_scale_factor, + int(width) // self.vae_scale_factor, + ) + + if isinstance(generator, list) and len(generator) != batch_size: + raise ValueError( + f"You have passed a list of generators of length {len(generator)}, but requested an effective batch" + f" size of {batch_size}. Make sure the batch size matches the length of the generators." + ) + + latents = randn_tensor(shape, generator=generator, device=device, dtype=dtype) + + return latents + + @property + def guidance_scale(self): + return self._guidance_scale + + @property + def clip_skip(self): + return self._clip_skip + + # here `guidance_scale` is defined analog to the guidance weight `w` of equation (2) + # of the Imagen paper: https://arxiv.org/pdf/2205.11487.pdf . `guidance_scale = 1` + # corresponds to doing no classifier free guidance. + @property + def do_classifier_free_guidance(self): + return self._guidance_scale > 1 + + @property + def joint_attention_kwargs(self): + return self._joint_attention_kwargs + + @property + def num_timesteps(self): + return self._num_timesteps + + @property + def interrupt(self): + return self._interrupt + + def _process_cfg_split_batch( + self, + concat_group_0_negative: torch.Tensor, + concat_group_0: torch.Tensor, + concat_group_1_negative: torch.Tensor, + concat_group_1: torch.Tensor, + ): + r""" + if not using cfg parallel, then the function return as previously commented version. + if use cfg parallel, this function assign rank 0 device with negative prompt (namely null prompty “”), + and assign rank1 device with positive prompt. + """ + if get_classifier_free_guidance_world_size() == 1: + concat_group_0 = torch.cat([concat_group_0_negative, concat_group_0], dim=0) + concat_group_1 = torch.cat([concat_group_1_negative, concat_group_1], dim=0) + elif get_classifier_free_guidance_rank() == 0: + concat_group_0 = concat_group_0_negative + concat_group_1 = concat_group_1_negative + elif get_classifier_free_guidance_rank() == 1: + concat_group_0 = concat_group_0 + concat_group_1 = concat_group_1 + else: + raise ValueError("Invalid classifier free guidance rank") + return concat_group_0, concat_group_1 + + def _init_pipeline(self, latents: torch.Tensor): + return latents + + @torch.no_grad() + @replace_example_docstring(EXAMPLE_DOC_STRING) + def __call__( + self, + prompt: Union[str, List[str]] = None, + prompt_2: Optional[Union[str, List[str]]] = None, + prompt_3: Optional[Union[str, List[str]]] = None, + height: Optional[int] = None, + width: Optional[int] = None, + num_inference_steps: int = 28, + timesteps: List[int] = None, + guidance_scale: float = 7.0, + negative_prompt: Optional[Union[str, List[str]]] = None, + negative_prompt_2: Optional[Union[str, List[str]]] = None, + negative_prompt_3: Optional[Union[str, List[str]]] = None, + num_images_per_prompt: Optional[int] = 1, + generator: Optional[Union[torch.Generator, List[torch.Generator]]] = None, + latents: Optional[torch.FloatTensor] = None, + prompt_embeds: Optional[torch.FloatTensor] = None, + negative_prompt_embeds: Optional[torch.FloatTensor] = None, + pooled_prompt_embeds: Optional[torch.FloatTensor] = None, + negative_pooled_prompt_embeds: Optional[torch.FloatTensor] = None, + output_type: Optional[str] = "pil", + return_dict: bool = True, + joint_attention_kwargs: Optional[Dict[str, Any]] = None, + clip_skip: Optional[int] = None, + callback_on_step_end: Optional[Callable[[int, int, Dict], None]] = None, + callback_on_step_end_tensor_inputs: List[str] = ["latents"], + max_sequence_length: int = 256, + ): + r""" + Function invoked when calling the pipeline for generation. + + Args: + prompt (`str` or `List[str]`, *optional*): + The prompt or prompts to guide the image generation. If not defined, one has to pass `prompt_embeds`. + instead. + prompt_2 (`str` or `List[str]`, *optional*): + The prompt or prompts to be sent to `tokenizer_2` and `text_encoder_2`. If not defined, `prompt` is + will be used instead + prompt_3 (`str` or `List[str]`, *optional*): + The prompt or prompts to be sent to `tokenizer_3` and `text_encoder_3`. If not defined, `prompt` is + will be used instead + height (`int`, *optional*, defaults to self.unet.config.sample_size * self.vae_scale_factor): + The height in pixels of the generated image. This is set to 1024 by default for the best results. + width (`int`, *optional*, defaults to self.unet.config.sample_size * self.vae_scale_factor): + The width in pixels of the generated image. This is set to 1024 by default for the best results. + num_inference_steps (`int`, *optional*, defaults to 50): + The number of denoising steps. More denoising steps usually lead to a higher quality image at the + expense of slower inference. + timesteps (`List[int]`, *optional*): + Custom timesteps to use for the denoising process with schedulers which support a `timesteps` argument + in their `set_timesteps` method. If not defined, the default behavior when `num_inference_steps` is + passed will be used. Must be in descending order. + guidance_scale (`float`, *optional*, defaults to 7.0): + Guidance scale as defined in [Classifier-Free Diffusion Guidance](https://arxiv.org/abs/2207.12598). + `guidance_scale` is defined as `w` of equation 2. of [Imagen + Paper](https://arxiv.org/pdf/2205.11487.pdf). Guidance scale is enabled by setting `guidance_scale > + 1`. Higher guidance scale encourages to generate images that are closely linked to the text `prompt`, + usually at the expense of lower image quality. + negative_prompt (`str` or `List[str]`, *optional*): + The prompt or prompts not to guide the image generation. If not defined, one has to pass + `negative_prompt_embeds` instead. Ignored when not using guidance (i.e., ignored if `guidance_scale` is + less than `1`). + negative_prompt_2 (`str` or `List[str]`, *optional*): + The prompt or prompts not to guide the image generation to be sent to `tokenizer_2` and + `text_encoder_2`. If not defined, `negative_prompt` is used instead + negative_prompt_3 (`str` or `List[str]`, *optional*): + The prompt or prompts not to guide the image generation to be sent to `tokenizer_3` and + `text_encoder_3`. If not defined, `negative_prompt` is used instead + num_images_per_prompt (`int`, *optional*, defaults to 1): + The number of images to generate per prompt. + generator (`torch.Generator` or `List[torch.Generator]`, *optional*): + One or a list of [torch generator(s)](https://pytorch.org/docs/stable/generated/torch.Generator.html) + to make generation deterministic. + latents (`torch.FloatTensor`, *optional*): + Pre-generated noisy latents, sampled from a Gaussian distribution, to be used as inputs for image + generation. Can be used to tweak the same generation with different prompts. If not provided, a latents + tensor will ge generated by sampling using the supplied random `generator`. + prompt_embeds (`torch.FloatTensor`, *optional*): + Pre-generated text embeddings. Can be used to easily tweak text inputs, *e.g.* prompt weighting. If not + provided, text embeddings will be generated from `prompt` input argument. + negative_prompt_embeds (`torch.FloatTensor`, *optional*): + Pre-generated negative text embeddings. Can be used to easily tweak text inputs, *e.g.* prompt + weighting. If not provided, negative_prompt_embeds will be generated from `negative_prompt` input + argument. + pooled_prompt_embeds (`torch.FloatTensor`, *optional*): + Pre-generated pooled text embeddings. Can be used to easily tweak text inputs, *e.g.* prompt weighting. + If not provided, pooled text embeddings will be generated from `prompt` input argument. + negative_pooled_prompt_embeds (`torch.FloatTensor`, *optional*): + Pre-generated negative pooled text embeddings. Can be used to easily tweak text inputs, *e.g.* prompt + weighting. If not provided, pooled negative_prompt_embeds will be generated from `negative_prompt` + input argument. + output_type (`str`, *optional*, defaults to `"pil"`): + The output format of the generate image. Choose between + [PIL](https://pillow.readthedocs.io/en/stable/): `PIL.Image.Image` or `np.array`. + return_dict (`bool`, *optional*, defaults to `True`): + Whether or not to return a [`~pipelines.stable_diffusion_xl.StableDiffusionXLPipelineOutput`] instead + of a plain tuple. + joint_attention_kwargs (`dict`, *optional*): + A kwargs dictionary that if specified is passed along to the `AttentionProcessor` as defined under + `self.processor` in + [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py). + callback_on_step_end (`Callable`, *optional*): + A function that calls at the end of each denoising steps during the inference. The function is called + with the following arguments: `callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, + callback_kwargs: Dict)`. `callback_kwargs` will include a list of all tensors as specified by + `callback_on_step_end_tensor_inputs`. + callback_on_step_end_tensor_inputs (`List`, *optional*): + The list of tensor inputs for the `callback_on_step_end` function. The tensors specified in the list + will be passed as `callback_kwargs` argument. You will only be able to include variables listed in the + `._callback_tensor_inputs` attribute of your pipeline class. + max_sequence_length (`int` defaults to 256): Maximum sequence length to use with the `prompt`. + + Examples: + + Returns: + [`~pipelines.stable_diffusion_3.StableDiffusion3PipelineOutput`] or `tuple`: + [`~pipelines.stable_diffusion_3.StableDiffusion3PipelineOutput`] if `return_dict` is True, otherwise a + `tuple`. When returning a tuple, the first element is a list with the generated images. + """ + + height = height or self.default_sample_size * self.vae_scale_factor + width = width or self.default_sample_size * self.vae_scale_factor + + # 1. Check inputs. Raise error if not correct + self.check_inputs( + prompt, + prompt_2, + prompt_3, + height, + width, + negative_prompt=negative_prompt, + negative_prompt_2=negative_prompt_2, + negative_prompt_3=negative_prompt_3, + prompt_embeds=prompt_embeds, + negative_prompt_embeds=negative_prompt_embeds, + pooled_prompt_embeds=pooled_prompt_embeds, + negative_pooled_prompt_embeds=negative_pooled_prompt_embeds, + callback_on_step_end_tensor_inputs=callback_on_step_end_tensor_inputs, + max_sequence_length=max_sequence_length, + ) + + self._guidance_scale = guidance_scale + self._clip_skip = clip_skip + self._joint_attention_kwargs = joint_attention_kwargs + self._interrupt = False + + # 2. Define call parameters + if prompt is not None and isinstance(prompt, str): + batch_size = 1 + elif prompt is not None and isinstance(prompt, list): + batch_size = len(prompt) + else: + batch_size = prompt_embeds.shape[0] + + device = self._execution_device + + lora_scale = ( + self.joint_attention_kwargs.get("scale", None) if self.joint_attention_kwargs is not None else None + ) + ( + prompt_embeds, + negative_prompt_embeds, + pooled_prompt_embeds, + negative_pooled_prompt_embeds, + ) = self.encode_prompt( + prompt=prompt, + prompt_2=prompt_2, + prompt_3=prompt_3, + negative_prompt=negative_prompt, + negative_prompt_2=negative_prompt_2, + negative_prompt_3=negative_prompt_3, + do_classifier_free_guidance=self.do_classifier_free_guidance, + prompt_embeds=prompt_embeds, + negative_prompt_embeds=negative_prompt_embeds, + pooled_prompt_embeds=pooled_prompt_embeds, + negative_pooled_prompt_embeds=negative_pooled_prompt_embeds, + device=device, + clip_skip=self.clip_skip, + num_images_per_prompt=num_images_per_prompt, + max_sequence_length=max_sequence_length, + lora_scale=lora_scale, + ) + # xinze: here need to change! + # print(f"the shape of embed prompt is {prompt_embeds.shape}, the shape of pooled_prompt_embeds is {pooled_prompt_embeds.shape}") + if self.do_classifier_free_guidance: + # prompt_embeds = torch.cat([negative_prompt_embeds, prompt_embeds], dim=0) + # pooled_prompt_embeds = torch.cat([negative_pooled_prompt_embeds, pooled_prompt_embeds], dim=0) + ( + prompt_embeds, + pooled_prompt_embeds, + ) = self._process_cfg_split_batch( + negative_prompt_embeds, + prompt_embeds, + negative_pooled_prompt_embeds, + pooled_prompt_embeds, + ) + # print(f"after split batch, the shape of embed prompt is {prompt_embeds.shape}, the shape of pooled_prompt_embeds is {pooled_prompt_embeds.shape}") + + # 4. Prepare timesteps + timesteps, num_inference_steps = retrieve_timesteps(self.scheduler, num_inference_steps, device, timesteps) + num_warmup_steps = max(len(timesteps) - num_inference_steps * self.scheduler.order, 0) + self._num_timesteps = len(timesteps) + # print(f"the timesteps is {timesteps}") + # 5. Prepare latent variables + # num_channels_latents = self.transformer.config.in_channels + num_channels_latents = 16 + latents = self.prepare_latents( + batch_size * num_images_per_prompt, + num_channels_latents, + height, + width, + prompt_embeds.dtype, + device, + generator, + latents, + ) + + # 6. Denoising loop + num_pipeline_warmup_steps = 1 + with self.progress_bar(total=num_inference_steps) as progress_bar: + if get_pipeline_parallel_world_size == 1: + latents = self._sync_pipeline( + latents=latents, + prompt_embeds=prompt_embeds, + pooled_prompt_embeds=pooled_prompt_embeds, + timesteps=timesteps, + num_warmup_steps=num_warmup_steps, + progress_bar=progress_bar, + callback_on_step_end=callback_on_step_end, + callback_on_step_end_tensor_inputs=callback_on_step_end_tensor_inputs, + sync_only=True, + ) + else: + latents = self._sync_pipeline( + latents=latents, + prompt_embeds=prompt_embeds, + pooled_prompt_embeds=pooled_prompt_embeds, + timesteps=timesteps[:num_pipeline_warmup_steps], + num_warmup_steps=num_warmup_steps, + progress_bar=progress_bar, + callback_on_step_end=callback_on_step_end, + callback_on_step_end_tensor_inputs=callback_on_step_end_tensor_inputs, + ) + # * pipefusion stage + latents = self._async_pipeline( + latents=latents, + prompt_embeds=prompt_embeds, + pooled_prompt_embeds=pooled_prompt_embeds, + timesteps=timesteps[num_pipeline_warmup_steps:], + num_warmup_steps=num_warmup_steps, + progress_bar=progress_bar, + callback_on_step_end=callback_on_step_end, + callback_on_step_end_tensor_inputs=callback_on_step_end_tensor_inputs, + num_pipeline_warmup_steps=num_pipeline_warmup_steps, + ) + + + + + if output_type == "latent": + image = latents + + else: + latents = (latents / self.vae.config.scaling_factor) + self.vae.config.shift_factor + + image = self.vae.decode(latents, return_dict=False)[0] + image = self.image_processor.postprocess(image, output_type=output_type) + + # Offload all models + self.maybe_free_model_hooks() + + if not return_dict: + return (image,) + + return StableDiffusion3PipelineOutput(images=image) + + + def _sync_pipeline( + self, + latents: torch.Tensor, + prompt_embeds: torch.Tensor, + pooled_prompt_embeds: torch.Tensor, + timesteps: List[int], + num_warmup_steps: int, + progress_bar, + callback_on_step_end, + callback_on_step_end_tensor_inputs, + sync_only: bool = False, + ): + for i, t in enumerate(timesteps): + # if is_pipeline_last_stage(): + # last_timestep_latents = latents + if is_pipeline_last_stage(): + last_timestep_latents = latents + + if not is_pipeline_first_stage(): + latents = self.post_office.recv_shipment().content["hidden_states"] + encoder_hidden_states = self.post_office.recv_shipment().content["encoder_hidden_states"] + elif not i == 0: + latents = self.post_office.recv_shipment().content["hidden_states"] + # for the first timestep of the first stage, need not recv anything. + + latents, encoder_hidden_states = self._backbone_forward( + latents=latents, + encoder_hidden_states=( + prompt_embeds + if is_pipeline_first_stage() + else encoder_hidden_states + ), + pooled_prompt_embeds=pooled_prompt_embeds, + t=t, + ) + print(f"the shape of latents is {latents.shape}, encoder hidden states is {encoder_hidden_states.shape}") + # compute the previous noisy sample x_t -> x_t-1 + if is_pipeline_last_stage(): + latents_dtype = latents.dtype + latents = self.scheduler.step(latents, t, last_timestep_latents, return_dict=False)[0] + + if latents.dtype != latents_dtype: + if torch.backends.mps.is_available(): + # some platforms (eg. apple mps) misbehave due to a pytorch bug: https://github.com/pytorch/pytorch/pull/99272 + latents = latents.to(latents_dtype) + + if callback_on_step_end is not None: + callback_kwargs = {} + for k in callback_on_step_end_tensor_inputs: + callback_kwargs[k] = locals()[k] + callback_outputs = callback_on_step_end(self, i, t, callback_kwargs) + + latents = callback_outputs.pop("latents", latents) + prompt_embeds = callback_outputs.pop("prompt_embeds", prompt_embeds) + negative_prompt_embeds = callback_outputs.pop("negative_prompt_embeds", negative_prompt_embeds) + negative_pooled_prompt_embeds = callback_outputs.pop( + "negative_pooled_prompt_embeds", negative_pooled_prompt_embeds + ) + + # call the callback, if provided + if i == len(timesteps) - 1 or ((i + 1) > num_warmup_steps and (i + 1) % self.scheduler.order == 0): + progress_bar.update() + + if XLA_AVAILABLE: + xm.mark_step() + + if is_pipeline_last_stage(): + self.shipment.update({"hidden_states": latents}) + self.post_office.send_shipment(self.shipment) + else: + self.shipment.update({"hidden_states": latents}) + self.shipment.update({"encoder_hidden_states": encoder_hidden_states}) + self.post_office.send_shipment(self.shipment) + + return latents + + def _init_async_pipeline( + self, + latents: torch.Tensor, + ): + if is_pipeline_first_stage(): + latents = self.post_office.recv_shipment().content["hidden_states"] + patch_latents = list(latents.split(get_runtime_state().pp_patches_height, dim=2)) + elif is_pipeline_last_stage(): + patch_latents = list(latents.split(get_runtime_state().pp_patches_height, dim=2)) + else: + patch_latents = [None for _ in range(get_runtime_state().num_pipeline_patch)] + + return patch_latents + + + def _async_pipeline( + self, + latents: torch.Tensor, + prompt_embeds: torch.Tensor, + pooled_prompt_embeds: torch.Tensor, + timesteps: List[int], + num_warmup_steps: int, + progress_bar, + callback_on_step_end: Optional[Callable[[int, int, Dict], None]] = None, + callback_on_step_end_tensor_inputs: List[str] = ["latents"], + num_pipeline_warmup_steps=1, + ): + patch_latents = self._init_async_pipeline(latents=latents) # xinze: ensure each pipe stage has the right data + num_pipeline_patch = get_pp_group().world_size + last_patch_latents = [None for _ in range(num_pipeline_patch)] # xinze: we need it to step. + for i, t in enumerate(timesteps): + for patch_idx in range(num_pipeline_patch): + if is_pipeline_last_stage(): + last_patch_latents[patch_idx] = patch_latents[patch_idx] + + if not is_pipeline_first_stage() and patch_idx == 0: + last_encoder_hidden_states = self.post_office.recv_shipment().content["encoder_hidden_states"] + + if is_pipeline_first_stage() and i == 0: + pass + else: + patch_latents[patch_idx] = self.post_office.recv_shipment().content["hidden_states"] + + patch_latents[patch_idx], next_encoder_hidden_states = ( + self._backbone_forward( + latents=patch_latents[patch_idx], + encoder_hidden_states=( + prompt_embeds + if is_pipeline_first_stage() + else last_encoder_hidden_states + ), + pooled_prompt_embeds=pooled_prompt_embeds, + t=t, + ) + ) + + if is_pipeline_last_stage(): + latents_dtype = patch_latents[patch_idx].dtype + patch_latents[patch_idx] = self.scheduler.step(patch_latents[patch_idx], \ + t, last_patch_latents[patch_idx], return_dict=False)[0] + + if latents.dtype != latents_dtype: + if torch.backends.mps.is_available(): + # some platforms (eg. apple mps) misbehave due to a pytorch bug: https://github.com/pytorch/pytorch/pull/99272 + latents = latents.to(latents_dtype) + + if callback_on_step_end is not None: + callback_kwargs = {} + for k in callback_on_step_end_tensor_inputs: + callback_kwargs[k] = locals()[k] + callback_outputs = callback_on_step_end( + self, i, t, callback_kwargs + ) + + latents = callback_outputs.pop("latents", latents) + prompt_embeds = callback_outputs.pop( + "prompt_embeds", prompt_embeds + ) + negative_prompt_embeds = callback_outputs.pop( + "negative_prompt_embeds", negative_prompt_embeds + ) + negative_pooled_prompt_embeds = callback_outputs.pop( + "negative_pooled_prompt_embeds", + negative_pooled_prompt_embeds, + ) + + if not is_pipeline_last_stage() and patch_idx == 0: + self.shipment.update({"encoder_hidden_states": next_encoder_hidden_states}) + self.post_office.send_shipment(self.shipment) + if not is_pipeline_last_stage() or i != len(timesteps) - 1: + self.shipment.update({"hidden_states": patch_latents[patch_idx]}) + self.post_office.send_shipment(self.shipment) + self.shipment.clear() + + get_runtime_state().next_patch() + + if i == len(timesteps) - 1 or ( + (i + num_pipeline_warmup_steps + 1) > num_warmup_steps + and (i + num_pipeline_warmup_steps + 1) % self.scheduler.order == 0 + ): + progress_bar.update() + + + if XLA_AVAILABLE and is_pipeline_last_stage(): + xm.mark_step() + + latents = torch.cat(patch_latents, dim=2) + return latents + + def _backbone_forward( + self, + latents: torch.Tensor, + encoder_hidden_states: torch.Tensor, + pooled_prompt_embeds: torch.Tensor, + t: Union[float, torch.Tensor], + ): + if is_pipeline_first_stage(): + latents = torch.cat( + [latents] * (2 // get_classifier_free_guidance_world_size()) + ) + + # broadcast to batch dimension in a way that's compatible with ONNX/Core ML + timestep = t.expand(latents.shape[0]) + + noise_pred, encoder_hidden_states = self.transformer( + hidden_states=latents, + timestep=timestep, + encoder_hidden_states=encoder_hidden_states, + pooled_projections=pooled_prompt_embeds, + joint_attention_kwargs=self.joint_attention_kwargs, + return_dict=False, + )[0] + + # classifier free guidance + if is_pipeline_last_stage(): + # xinze: pp last stage means a time step is about to end + if get_classifier_free_guidance_world_size() == 1: + noise_pred_uncond, noise_pred_text = noise_pred.chunk(2) + elif get_classifier_free_guidance_world_size() == 2: + noise_pred_uncond, noise_pred_text = get_cfg_group().all_gather( + noise_pred, separate_tensors=True + ) + latents = noise_pred_uncond + self.guidance_scale * ( + noise_pred_text - noise_pred_uncond + ) + else: + latents = noise_pred + + return latents, encoder_hidden_states \ No newline at end of file diff --git a/src/diffusers/postal_service.py b/src/diffusers/postal_service.py new file mode 100644 index 000000000000..217f133fc318 --- /dev/null +++ b/src/diffusers/postal_service.py @@ -0,0 +1,514 @@ +import torch + +from typing import List, Union, Optional +from crossing.core.parallel_context import ParallelContext + +support_type = [ + torch.float32, + torch.float64, + torch.float16, + torch.uint8, + torch.int8, + torch.int16, + torch.int32, + torch.int64, + torch.bool, + torch.complex64, + torch.complex128, + torch.bfloat16, + torch.cdouble, + torch.quint8, + torch.qint8, + torch.qint32, +] + +type2int = {} +for idx, dtype in enumerate(support_type): + type2int[dtype] = idx + +int64_type = torch.int64 +int64_byte = torch.tensor([], dtype=int64_type).element_size() +byte_type = torch.uint8 +min_copy_size = 4096 + + +def is_cpu(device_type): + return str(device_type) == "cpu" + + +def string2list(s: str): + return list(s.encode()) + + +def byte_list2string(t: List[int]): + return bytes(t).decode() + + +def patch2long_byte(p): + return (-p) % int64_byte + + +def jump2patch(p): + return p + patch2long_byte(p) + + +def patching(p, tensor_list: List[torch.Tensor], device="cpu"): + patch_size = patch2long_byte(p) + if patch_size > 0: + tensor_list.append(torch.empty(patch_size, dtype=byte_type, device=device)) + + +def sum_tensor_len(tensor_list: List[torch.Tensor]): + sum_len = 0 + for tensor in tensor_list: + sum_len += len(tensor) + return sum_len + + +class Shipment: + def __init__(self, device: torch.device, buffer_device: Optional[torch.device]=None): + # Record the device for accelerator + # `device` is the device for accelerating computing and `buffer_device` is device for buffer to be sent/received + self._device = device + self._buffer_device = buffer_device or device + # Buffer and shipment on cpu should be tensor + # Use [] to speed up + # We do not use None since len(None) would cause error + # The structure of buffer, which is related to pack and unpack. + # buffer = torch.tensor([the number of package n| package 0 | package 1 | ... | package n]) + # Each package has specific format: + # package = [len(meta) | len(cpu tensors) | len(gpu tensors) | meta | cpu tensors | gpu tensors] + # meta is the information of tensor, which has structure: + # meta = [len(name) | name | dtype | ndim | shape | device | len(tensor)] + self._buffer = [] + # Items packed in the buffer + self._packed_items = {} + # The store position on the buffer + self._pack_item2position = {} + # Not packed items + self._warehouse = {} + # Items packed but replaced by new items + self._replaced_items = {} + + # Local variable for pack + self.meta_int_list: List[int] = [] + # Local variable for look through items, or say, unpack + # The part of buffer sent from gpu to cpu + self.shipment_on_cpu = [] + # The point on gpu shipment marking the starting position of shipment on cpu + self.cpu_shipment_start = 0 + # Convert the shipment on cpu from bytes to int64 + self.shipment_in_list = [] + # The pointer in shipment in list, which is used to mark the reading position of meta information + # The data is int64, adding 1 to pointer_in_list is equal to move 8 bytes with a cpu or gpu pointer (with type bytes) + self.pointer_in_list = 0 + + # _bundling_single_int, _bundling, _pack are 3 functions related to pack + def _bundling_single_int(self, single_int: int): + self.meta_int_list.append(single_int) + + def _bundling(self, list_1d: Union[List[int], torch.Size]): + self._bundling_single_int(len(list_1d)) + self.meta_int_list.extend(list_1d) + + def _pack(self): + if len(self._replaced_items) > 0: + for key, value in self._replaced_items.items(): + data_start_end = self._pack_item2position[key] + self._buffer[data_start_end[0] : data_start_end[1]] = ( + value.view(-1).view(byte_type).to(self._buffer_device) + ) + + self._replaced_items.clear() + + # No new items + if len(self._warehouse) == 0: + return + + # Update total pacakge number + if len(self._buffer) > 0: + self._buffer[0:int64_byte].view(int64_type)[0] += 1 + + # Convert self._warehouse to byte tensors + self.meta_int_list = [] + should_on_cpu2data_tensor_list = {True: [], False: []} + self._bundling_single_int(len(self._warehouse)) + new_item2position = {} + storage_start_position = 0 + # Go through all the cpu tensors before dealing with any gpu tensors + for should_on_cpu in [True, False]: + for key, value in self._warehouse.items(): + if is_cpu(value.device.type) == should_on_cpu: + # name + self._bundling(string2list(key)) + # data type + self._bundling_single_int(type2int[value.dtype]) + # shape + self._bundling(value.size()) + # device + self._bundling_single_int(int(should_on_cpu)) + # the length of value viewed as byte tensor + value_view_as_1d_byte_data = ( + value.contiguous().view(-1).view(byte_type) + ) + value_view_as_1d_byte_data_size = len(value_view_as_1d_byte_data) + self._bundling_single_int(value_view_as_1d_byte_data_size) + # data + should_on_cpu2data_tensor_list[should_on_cpu].append( + value_view_as_1d_byte_data + ) + # storage pointers of start and end + storage_end_position = ( + storage_start_position + value_view_as_1d_byte_data_size + ) + new_item2position[key] = [ + storage_start_position, + storage_end_position, + ] + storage_start_position = jump2patch(storage_end_position) + # An empty tensor patch, to make the offset divisible by int64_byte + patching( + value_view_as_1d_byte_data_size, + should_on_cpu2data_tensor_list[should_on_cpu], + value.device, + ) + + # Calculate tensor length + total_package_len = [ + len(self.meta_int_list) * int64_byte, + sum_tensor_len(should_on_cpu2data_tensor_list[True]), + sum_tensor_len(should_on_cpu2data_tensor_list[False]), + ] + self.meta_int_list = total_package_len + self.meta_int_list + # Concatenate cpu tensors first + if len(self._buffer) == 0: + self.meta_int_list.insert(0, 1) + cpu_data_tensor_list = should_on_cpu2data_tensor_list[True] + if len(cpu_data_tensor_list) == 0: + concat_cpu_tensor = torch.tensor( + self.meta_int_list, dtype=int64_type, device=self._buffer_device + ).view(byte_type) + # Place the meta information before cpu and gpu tensors, move the offset correspondingly + offset = len(concat_cpu_tensor) + else: + cpu_data_tensor_list.insert( + 0, torch.tensor(self.meta_int_list, dtype=int64_type).view(byte_type) + ) + offset = len(cpu_data_tensor_list[0]) + concat_cpu_tensor = torch.cat(cpu_data_tensor_list).to(self._buffer_device) + # Concatenate gpu tensors + gpu_data_tensor_list = should_on_cpu2data_tensor_list[False] + if is_cpu(self._buffer_device) and len(gpu_data_tensor_list) > 0: + gpu_data_tensor_list = [torch.cat(gpu_data_tensor_list).to(self._buffer_device)] + gpu_data_tensor_list.insert(0, concat_cpu_tensor) + if len(self._buffer) > 0: + gpu_data_tensor_list.insert(0, self._buffer) + # Place the last package before this package, move the offset correspondingly + offset += len(self._buffer) + self._buffer = torch.cat(gpu_data_tensor_list) + self.meta_int_list.clear() + # Move the items from warehouse to the shipment + self._packed_items.update(self._warehouse) + self._warehouse.clear() + # Maintain the packed item storage pointers + for key, pointers in new_item2position.items(): + self._pack_item2position[key] = [pointers[0] + offset, pointers[1] + offset] + + # _unbundling_single_int, _unbunding, _deliver_to_host, _unpack are 4 functions related to unpack + def _unbundling_single_int(self) -> int: + single_int = self.shipment_in_list[self.pointer_in_list] + self.pointer_in_list += 1 + return single_int + + def _unbundling(self): + tensor_len = self._unbundling_single_int() + p_start = self.pointer_in_list + # Not using p_end would cause error: + self.pointer_in_list += tensor_len + item = self.shipment_in_list[p_start : self.pointer_in_list] + return item + + def _deliver_to_host(self, size=min_copy_size): + if size < min_copy_size: + size = min_copy_size + self.cpu_shipment_start += self.pointer_in_list * int64_byte + p_end = min(self.cpu_shipment_start + size, len(self._buffer)) + self.shipment_on_cpu = self._buffer[self.cpu_shipment_start : p_end].to("cpu") + self.shipment_in_list = self.shipment_on_cpu.view(int64_type).tolist() + self.pointer_in_list = 0 + + def _look_through_items(self, do_something): + self.pointer_in_list = 0 + self.cpu_shipment_start = 0 + self._deliver_to_host() + # Total pacakge number + total_package_num = self._unbundling_single_int() + for package_id in range(total_package_num): + # Get length of meta, cpu tensors, gpu tensors + total_meta_len = self._unbundling_single_int() + total_cpu_tensor_len = self._unbundling_single_int() + total_gpu_tensor_len = self._unbundling_single_int() + # At least deliver this whole package to host + if ( + len(self.shipment_on_cpu) - self.pointer_in_list * int64_byte + < total_meta_len + total_cpu_tensor_len + ): + self._deliver_to_host(total_meta_len + total_cpu_tensor_len) + # Assign pointers, which is related to the position of shipment copy + # The pointer on shipment_on_cpu, marking the reading position of cpu tensors + p_cpu = self.pointer_in_list * int64_byte + total_meta_len + # The pointer on shipment on gpu, marking the reading position of gpu tensors + p_gpu = self.cpu_shipment_start + p_cpu + total_cpu_tensor_len + # The end of this package + # total_gpu_tensor_len % 8 == 0, we do not need to use jump2patch + p_end = p_gpu + total_gpu_tensor_len + # The end position of meta information, which is also the start position of the cpu tensors + p_meta_end = p_cpu + # look into the shipment + total_item_num = self._unbundling_single_int() + for item_id in range(total_item_num): + # name + name_list = self._unbundling() + name = byte_list2string(name_list) + # data type + dtype_id = self._unbundling_single_int() + value_dtype = support_type[dtype_id] + # shape + # It supports scalar. + # For example: torch.tensor([42]).view([]) == torch.tensor(42) + shape = self._unbundling() + # device + on_cpu = self._unbundling_single_int() + # data length + data_len = self._unbundling_single_int() + # p_gpu_end = p_gpu + data_len + # data + if on_cpu: + # on cpu + p_cpu_end = p_cpu + data_len + data = ( + self.shipment_on_cpu[p_cpu:p_cpu_end] + .view(value_dtype) + .view(shape) + ) + data_memory_start = self.cpu_shipment_start + p_cpu + data_memory_end = self.cpu_shipment_start + p_cpu_end + # Move the cpu pointer to the next cpu tensor + p_cpu = jump2patch(p_cpu_end) + else: + # on cuda + p_gpu_end = p_gpu + data_len + data = self._buffer[p_gpu:p_gpu_end].view(value_dtype).view(shape).to(self._device) + data_memory_start = p_gpu + data_memory_end = p_gpu_end + # Move the gpu pointer to the next gpu tensor + p_gpu = jump2patch(p_gpu_end) + # do something + # Return False means keep going through the rest of the shipment + # Return True means stopping looking for the item + if do_something(name, data, data_memory_start, data_memory_end): + return + + assert ( + self.pointer_in_list * int64_byte == p_meta_end + ), "expect self.pointer_in_list({}) * int64_byte({}) == p_meta_end({})".format( + self.pointer_in_list, int64_byte, p_meta_end + ) + assert p_gpu == p_end, "p_gpu ({}) must be equal to p_end ({})".format( + p_gpu, p_end + ) + # Move the meta pointer to the start of the next package + self.pointer_in_list = (p_end - self.cpu_shipment_start) // int64_byte + # Have not finish the package + # and still need to take 3 integers from the cpu shipment + if package_id < total_package_num - 1 and self.pointer_in_list + 3 > len( + self.shipment_in_list + ): + self._deliver_to_host() + + def _unpack(self): + def take_item_out(name, data, p_gpu, p_gpu_end): + self._packed_items[name] = data + self._pack_item2position[name] = [p_gpu, p_gpu_end] + # Return False means keep going through the rest of the shipment + return False + + self._look_through_items(take_item_out) + + # Make sure the item is packed before using this function + def _remove_packed_item(self, item_name): + self._warehouse.update(self._packed_items) + self._warehouse.update(self._replaced_items) + del self._warehouse[item_name] + self._buffer = [] + self._packed_items.clear() + self._replaced_items.clear() + self._pack_item2position.clear() + + @staticmethod + def from_buffer(buffer: torch.ByteTensor, device: torch.device=None): + device = device or buffer.device + shipment = Shipment(device, buffer_device=buffer.device) + shipment._buffer = buffer + shipment._unpack() + return shipment + + def remove(self, item_name): + if item_name in self._warehouse: + del self._warehouse[item_name] + else: + assert ( + item_name in self._packed_items or item_name in self._replaced_items + ), f"{item_name} not in shipment" + self._remove_packed_item(item_name) + + def update(self, new_items: dict): + if len(new_items) == 0: + return + for key, value in new_items.items(): + assert isinstance( + value, torch.Tensor + ), "parameter of {} must be a Tensor, but got a {}".format(key, type(value)) + assert ( + is_cpu(value.device.type) or value.device == self._device + ), f"This shipment only accept tensors on cpu or {self._device} but gets {value.device}" + + not_found_item_with_same_meta = True + # Packed or replaced + for package in [self._packed_items, self._replaced_items]: + if key in package: + old_value = package[key] + if ( + old_value.dtype == value.dtype + and old_value.size() == value.size() + and old_value.device == value.device + ): + # Replace the item no matter value changed or not + # Different item with the same dtype, shape, device + if package == self._replaced_items: + # Found in the replaced items, directly replace + package[key] = value + else: + # Found in the packed items, move and replace it + del package[key] + self._replaced_items[key] = value + + not_found_item_with_same_meta = False + else: + # Different item with same name, remove the old item first, add the new item later + self._remove_packed_item(key) + + break + + if not_found_item_with_same_meta: + # Add the new item + self._warehouse[key] = value + + @property + def buffer(self): + self._pack() + return self._buffer + + @property + def content(self): + return dict(self._packed_items, **self._warehouse, **self._replaced_items) + + def clear(self): + self._warehouse.clear() + self._buffer = [] + self._packed_items.clear() + self._pack_item2position.clear() + + def is_empty(self) -> bool: + return ( + len(self._warehouse) == 0 + and len(self._packed_items) == 0 + and len(self._replaced_items) == 0 + ) + + +class PostalService: + def __init__(self, parallel_ctx: ParallelContext): + self.parallel_ctx = parallel_ctx + self.send_recv_comm_device = self.parallel_ctx.send_recv_comm_device() + + def send_shipment(self, shipment: Shipment): + # Pack items before shipping + self.parallel_ctx.send_to_next_stage( + torch.tensor( + [len(shipment.buffer)], device=self.send_recv_comm_device + ) + ) + self.parallel_ctx.send_to_next_stage(shipment.buffer) + + def recv_shipment(self) -> Shipment: + shipment_volume = torch.empty( + [1], + dtype=torch.int64, + device=self.send_recv_comm_device, + requires_grad=False, + ) + print(f"the shipment volume is {shipment_volume}") + self.parallel_ctx.recv_from_prev_stage(shipment_volume) + buffer = torch.empty( + shipment_volume.tolist(), + dtype=byte_type, + device=self.send_recv_comm_device, + requires_grad=False, + ) + self.parallel_ctx.recv_from_prev_stage(buffer) + return Shipment.from_buffer(buffer, self.parallel_ctx.torch_device()) + + def exchange_shipment(self, shipment: Shipment) -> Shipment: + # Send and recv the length of shipment simultaneously + recv_shipment_volume = torch.empty( + [1], + dtype=torch.int64, + device=self.send_recv_comm_device, + requires_grad=False, + ) + send_shipment_volume = torch.tensor( + [len(shipment.buffer)], + dtype=torch.int64, + device=self.send_recv_comm_device, + requires_grad=False, + ) + self.parallel_ctx.send_and_recv_between_neighborhoods( + recv_shipment_volume, send_shipment_volume + ) + # Send and recv shipment simultaneously + recv_buffer = torch.empty( + recv_shipment_volume.tolist(), + dtype=byte_type, + device=self.send_recv_comm_device, + requires_grad=False, + ) + send_buffer = shipment.buffer + self.parallel_ctx.send_and_recv_between_neighborhoods(recv_buffer, send_buffer) + return Shipment.from_buffer(recv_buffer, self.parallel_ctx.torch_device()) + + def broadcast_shipment(self, shipment: Shipment) -> Shipment: + if self.parallel_ctx.tensor_parallel_size == 1: + return shipment + + # broadcast shipment volume + shipment_volume = torch.tensor(len(shipment.buffer)).to( + self.parallel_ctx.torch_device() + ) + self.parallel_ctx.broadcast_in_tensor_parallel_group(shipment_volume) + # broadcast shipment buffer + if self.parallel_ctx.tensor_parallel_rank == 0: + shipment_buffer = shipment.buffer + else: + shipment_buffer = torch.empty( + shipment_volume, + device=self.parallel_ctx.torch_device(), + dtype=byte_type, + requires_grad=False, + ) + self.parallel_ctx.broadcast_in_tensor_parallel_group(shipment_buffer) + + if self.parallel_ctx.tensor_parallel_rank == 0: + return shipment + else: + return Shipment.from_buffer(shipment_buffer) diff --git a/src/diffusers/runtime_state.py b/src/diffusers/runtime_state.py new file mode 100644 index 000000000000..85a26e7775aa --- /dev/null +++ b/src/diffusers/runtime_state.py @@ -0,0 +1,184 @@ +import torch.distributed +import random +from typing import List, Optional, Tuple +from abc import ABCMeta +from argparse import Namespace + +import numpy as np +import torch +from diffusers.pipelines.pipeline_utils import DiffusionPipeline + +from diffusers.parallel_state import ( + get_pp_group, + get_sp_group, + get_sequence_parallel_rank, + get_sequence_parallel_world_size, +) + +class RuntimeState(metaclass=ABCMeta): + config: Namespace + num_pipeline_patch: int + + def __init__(self, config): + self.config = config + self.num_pipeline_patch = config.pipefusion_parallel_degree + self.warmup_steps = 1 + +class DiTRuntimeState(RuntimeState): + patch_mode: bool + pipeline_patch_idx: int + vae_scale_factor: int + backbone_patch_size: int + pp_patches_height: Optional[List[int]] + pp_patches_start_idx_local: Optional[List[int]] + pp_patches_start_end_idx_global: Optional[List[List[int]]] + pp_patches_token_start_idx_local: Optional[List[int]] + pp_patches_token_start_end_idx_global: Optional[List[List[int]]] + pp_patches_token_num: Optional[List[int]] + max_condition_sequence_length: int + + def __init__(self, pipeline: DiffusionPipeline, config): + super().__init__(config) + self.patch_mode = False + self.pipeline_patch_idx = 0 + self._set_model_parameters( + vae_scale_factor=pipeline.vae_scale_factor, + # backbone_patch_size=pipeline.transformer.config.patch_size, + # backbone_in_channel=pipeline.transformer.config.in_channels, + # backbone_inner_dim=pipeline.transformer.config.num_attention_heads + # * pipeline.transformer.config.attention_head_dim, + backbone_patch_size=2, + backbone_in_channel=16, + backbone_inner_dim=24 * 64 + ) + + def next_patch(self): + if self.patch_mode: + self.pipeline_patch_idx += 1 + if self.pipeline_patch_idx == self.num_pipeline_patch: + self.pipeline_patch_idx = 0 + else: + self.pipeline_patch_idx = 0 + + def set_patch_mode(self, patch_mode: bool): + self.patch_mode = patch_mode + self.pipeline_patch_idx = 0 + + def _set_model_parameters( + self, + vae_scale_factor:int, + backbone_patch_size:int, + backbone_inner_dim:int, + backbone_in_channel:int, + ): + self.vae_scale_factor = vae_scale_factor + self.backbone_patch_size = backbone_patch_size + self.backbone_inner_dim = backbone_inner_dim + self.backbone_in_channel = backbone_in_channel + + def _input_size_change( + self, + height: Optional[int] = None, + width: Optional[int] = None, + ): + self.config.height = height or self.config.height + self.config.width = width or self.config.width + self._calc_patches_metadata() + self._reset_recv_buffer() + + def _calc_patches_metadata(self): + num_sp_patches = get_sequence_parallel_world_size() + sp_patch_idx = get_sequence_parallel_rank() + patch_size = self.backbone_patch_size + vae_scale_factor = self.vae_scale_factor + latents_height = self.config.height // vae_scale_factor + latents_width = self.config.width // vae_scale_factor # xinze: for 1024 width and 8 vae factor, latents width is 128 + + pipeline_patches_height = ( + latents_height + self.num_pipeline_patch - 1 + ) // self.num_pipeline_patch + + num_pipeline_patch = ( + latents_height + pipeline_patches_height - 1 + ) // pipeline_patches_height + + pipeline_patches_height_list = [ + pipeline_patches_height for _ in range(num_pipeline_patch) - 1 + ] + + the_last_pp_patch_height = latents_height - pipeline_patches_height * ( + num_pipeline_patch - 1 + ) + pipeline_patches_height.append(the_last_pp_patch_height) + + flatten_patches_height = [ + pp_patch_height // num_sp_patches + for _ in range(num_sp_patches) + for pp_patch_height in pipeline_patches_height_list + ]# xinze: if using sp, then patch will be deeper patched. + flatten_patches_start_idx = [0] + [ + sum(flatten_patches_height[:i]) + for i in range(1, len(flatten_patches_height) + 1) + ]# xinze: for height 1024, pp=sp=2, it is [0, 32 ,64, 96, 128] + pp_sp_patches_height = [ + flatten_patches_height[ + pp_patch_idx * num_sp_patches : (pp_patch_idx + 1) * num_sp_patches + ] + for pp_patch_idx in range(num_pipeline_patch) + ]# xinze: for height 1024, pp=sp=2, it is [[32, 32], [32, 32]] + pp_sp_patches_start_idx = [ + flatten_patches_start_idx[ + pp_patch_idx * num_sp_patches : (pp_patch_idx + 1) * num_sp_patches + 1 + ] + for pp_patch_idx in range(num_pipeline_patch) + ]# xinze: for height 1024, pp=sp=2, it is [[0, 32, 64], [64, 96, 128]] + pp_patches_height = [ + sp_patches_height[sp_patch_idx] + for sp_patches_height in pp_sp_patches_height + ]# xinze: for height 1024, pp=sp=2, it is [32, 32] + pp_patches_start_idx_local = [0] + [ + sum(pp_patches_height[:i]) for i in range(1, len(pp_patches_height) + 1) + ]# xinze: for height 1024, pp=sp=2, it is [0, 32, 64] + pp_patches_start_end_idx_global = [ + sp_patches_start_idx[sp_patch_idx : sp_patch_idx + 2] + for sp_patches_start_idx in pp_sp_patches_start_idx + ]# xinze: for height 1024, pp=sp=2, it is [[0, 32], [64, 96]] for rank 0 and [[32, 64], [96, 128]] for rank 1 + + pp_patches_token_start_end_idx_global = [ + [ + (latents_width // patch_size) * (start_idx // patch_size), + (latents_width // patch_size) * (end_idx // patch_size), + ] + for start_idx, end_idx in pp_patches_start_end_idx_global + ]# xinze: it is [[0, 1024], [2048, 3072]] for rank 0 and [[1024, 2048], [3072, 4096]] for rank 1 + + pp_patches_token_num = [ + end - start for start, end in pp_patches_token_start_end_idx_global + ]# xinze: it is [1024, 1024] + pp_patches_token_start_idx_local = [ + sum(pp_patches_token_num[:i]) for i in range(len(pp_patches_token_num) + 1) + ]# xinze: it is [0, 1024, 2048] + self.num_pipeline_patch = num_pipeline_patch + self.pp_patches_height = pp_patches_height + self.pp_patches_start_idx_local = pp_patches_start_idx_local + self.pp_patches_start_end_idx_global = pp_patches_start_end_idx_global + self.pp_patches_token_start_idx_local = pp_patches_token_start_idx_local + self.pp_patches_start_end_idx_global = ( + pp_patches_token_start_end_idx_global + ) + + self.pp_patches_token_num = pp_patches_token_num + + + def _reset_recv_buffer(self): + get_pp_group().reset_buffer() + get_pp_group.set_config(self, dtype=torch.float16) + +def initialize_runtime_state(pipeline: DiffusionPipeline, engine_config): + global _RUNTIME + if hasattr(pipeline, "transformer"): + _RUNTIME = DiTRuntimeState(pipeline=pipeline, config=engine_config) + +def get_runtime_state(): + assert _RUNTIME is not None, "Runtime state has not been initialized." + return _RUNTIME \ No newline at end of file diff --git a/src/diffusers/torch_parallel_context.py b/src/diffusers/torch_parallel_context.py new file mode 100644 index 000000000000..c1b526744a6e --- /dev/null +++ b/src/diffusers/torch_parallel_context.py @@ -0,0 +1,353 @@ +from typing import Optional, Union, Sequence, ContextManager +from datetime import timedelta +from contextlib import nullcontext + +import torch +import os + +from yfusers.parallel_context import ( + AsyncMode, + AsyncModeContext, + ParallelContext, +) + +# types +Shape = Sequence[int] +Stream = torch.cuda.Stream +ProcessGroup = torch.distributed.ProcessGroup + + +def _check_send_recv_tensors(tensors: Union[torch.Tensor, Sequence[torch.Tensor]]): + if isinstance(tensors, torch.Tensor): + tensors = [tensors] + else: + if not isinstance(tensors, (list, tuple)): + raise ValueError( + f"send_tensors must be a list of tensors, but got type {type(tensors)}" + ) + + for i, tensor in enumerate(tensors): + if not isinstance(tensor, torch.Tensor): + raise ValueError( + "send_tensors must be a list of tensors, " + f"but got {i} th element type {type(tensor)}" + ) + + return tensors + + +class TorchBasedParallelContext(ParallelContext): + def __init__( + self, + *, + ranks: Sequence[int] = None, + tensor_parallel_size: int = 1, + pipeline_parallel_size: int = 1, + device_index: int = 0, + backend: str = "nccl", + ): + self._init_torch_distributed() + self._backend = backend + + self._ranks = ranks + self._tensor_parallel_size = tensor_parallel_size + self._pipeline_parallel_size = pipeline_parallel_size + self._device_index = device_index + self._torch_device = torch.device(f"cuda:{self._device_index}") + self._parallel_size = tensor_parallel_size * pipeline_parallel_size + + if not isinstance(ranks, (list, tuple)) or not all( + isinstance(rank, int) for rank in ranks + ): + raise ValueError(f"`ranks` should be a list of int") + if len(ranks) != self._parallel_size: + raise ValueError(f"`ranks` should has the same length as parallel_ctx.size") + self._ranks = ranks + + if self._parallel_size > 1: + self._main_group = torch.distributed.new_group( + self._ranks, backend=self._backend + ) + else: + self._main_group = None + + # for grouping + self._process_mesh = torch.tensor(self._ranks) + + self._rank = ( + torch.distributed.get_rank() if torch.distributed.is_initialized() else 0 + ) + + # TODO: remove when tests don't rely on set_device in parallel_ctx + if self._rank in self._ranks: + torch.cuda.set_device(self._device_index) + + # tensor parallel property + self._tensor_parallel_group: Optional[ProcessGroup] = None + self._tensor_parallel_group_root: int = 0 + self._tensor_parallel_main_comm: Optional[Communicator] = None + self._tensor_parallel_comm_stream: Optional[Stream] = None + # async mode + self._async_mode: Optional[AsyncModeContext] = None + + # pipeline parallel property + self._pipeline_parallel_group: Optional[ProcessGroup] = None + self._pipeline_stage_id: int = 0 + self._pipeline_parallel_group_prev_rank = 0 + self._pipeline_parallel_group_next_rank = 0 + + with torch.cuda.device(self._device_index): + self._init_pipeline_parallel_group() + self._init_tensor_parallel_group() + + def _init_torch_distributed(self, timeout=timedelta(hours=24)): + assert torch.cuda.is_available() + assert torch.distributed.is_available() + + env_rank = int(os.getenv("RANK", "0")) + env_world_size = int(os.getenv("WORLD_SIZE", "1")) + if env_world_size == 1: + return + + if torch.distributed.is_initialized(): + assert env_world_size == torch.distributed.get_world_size() + assert env_rank == torch.distributed.get_rank() + return + + backend = "nccl" + options = torch.distributed.ProcessGroupNCCL.Options() + options.is_high_priority_stream = True + + torch.distributed.init_process_group( + backend=backend, + world_size=env_world_size, + rank=env_rank, + timeout=timeout, + pg_options=options, + ) + + def backend(self) -> str: + return self._backend + + def send_recv_comm_device(self) -> Union[str, torch.device]: + # communication device for send/recv + return self._torch_device + + def _init_pipeline_parallel_group(self): + if self.size > 1: + self._pipeline_parallel_group = self._new_group( + self._pipeline_parallel_size + ) + if self._pipeline_parallel_group is not None: + # set pipeline property + group_ranks = torch.distributed.get_process_group_ranks( + self._pipeline_parallel_group + ) + self._pipeline_stage_id = group_ranks.index(self._rank) + self._pipeline_parallel_group_prev_rank = group_ranks[ + (self._pipeline_stage_id - 1) % self._pipeline_parallel_size + ] + self._pipeline_parallel_group_next_rank = group_ranks[ + (self._pipeline_stage_id + 1) % self._pipeline_parallel_size + ] + + def _init_tensor_parallel_group(self): + if self.size > 1: + self._tensor_parallel_group = self._new_group(self._tensor_parallel_size) + if self._tensor_parallel_group is not None: + group_ranks = torch.distributed.get_process_group_ranks( + self._tensor_parallel_group + ) + self._tensor_parallel_group_root = group_ranks[0] + + def _new_group( + self, parallel_size: int + ) -> Optional[torch.distributed.ProcessGroup]: + remain_num_groups = self._process_mesh.size(-1) + if remain_num_groups % parallel_size != 0: + raise ValueError( + f"The process mesh {self._process_mesh} cannot be divided further by parallel_size {parallel_size}" + ) + + num_groups = remain_num_groups // parallel_size + self._process_mesh = self._process_mesh.view( + *self._process_mesh.shape[:-1], parallel_size, num_groups + ) + + ret_group = None + global_rank = torch.distributed.get_rank() + # (past_num_groups, parallel_size, new_num_groups) + process_mesh = self._process_mesh.view(-1, parallel_size, num_groups) + for group_i in range(process_mesh.size(0)): + for group_j in range(process_mesh.size(-1)): + global_ranks = process_mesh[group_i, :, group_j].tolist() + group = torch.distributed.new_group(global_ranks, backend=self._backend) + if global_rank in global_ranks: + ret_group = group + + return ret_group + + def device_index(self) -> int: + return self._device_index + + def torch_device(self) -> torch.device: + return self._torch_device + + def allreduce(self, tensor: torch.Tensor, red_op: torch.distributed.ReduceOp): + if self.size > 1: + torch.distributed.all_reduce(tensor, op=red_op, group=self._main_group) + + @property + def tensor_parallel_group(self): + return self._tensor_parallel_group + + @property + def size(self) -> int: + return self._parallel_size + + @property + def tensor_parallel_size(self): + return self._tensor_parallel_size + + @property + def tensor_parallel_rank(self) -> int: + if self._tensor_parallel_group is None: + return 0 + return self._tensor_parallel_group.rank() + + def broadcast_in_tensor_parallel_group(self, tensor: torch.Tensor): + if self.tensor_parallel_size > 1: + torch.distributed.broadcast( + tensor, + src=self._tensor_parallel_group_root, + group=self._tensor_parallel_group, + ) + + def allreduce_in_tensor_parallel_group(self, tensor: torch.Tensor): + if self.tensor_parallel_size > 1: + torch.distributed.all_reduce( + tensor, + op=torch.distributed.ReduceOp.SUM, + group=self._tensor_parallel_group, + ) + + def allgather_in_tensor_parallel_group( + self, input: torch.Tensor, output: torch.Tensor + ): + if self.tensor_parallel_size > 1: + output1d = output.view(-1) + local_elems = output1d.size(0) // self._tensor_parallel_size + tensor_list = [ + output1d[i * local_elems : (i + 1) * local_elems] + for i in range(self._tensor_parallel_size) + ] + torch.distributed.all_gather( + tensor_list, + input.view(-1), + group=self._tensor_parallel_group, + ) + + @property + def pipeline_parallel_group(self): + return self._pipeline_parallel_group + + @property + def pipeline_parallel_size(self) -> int: + return self._pipeline_parallel_size + + @property + def pipeline_stage_id(self) -> int: + return self._pipeline_stage_id + + def recv_from_prev_stage( + self, recv_tensors: Union[torch.Tensor, Sequence[torch.Tensor]] + ): + """Receive tensor from previous stage in pipeline (forward receive).""" + assert ( + self.pipeline_parallel_group is not None + ), "pipeline_parallel_group is not initialized, pipeline_parallel_size need to be set greater than 1" + + recv_tensors = _check_send_recv_tensors(recv_tensors) + p2p_ops = [] + for recv_tensor in recv_tensors: + recv_op = torch.distributed.P2POp( + torch.distributed.irecv, + recv_tensor, + self._pipeline_parallel_group_prev_rank, + group=self.pipeline_parallel_group, + ) + p2p_ops.append(recv_op) + + if len(p2p_ops) > 0: + reqs = torch.distributed.batch_isend_irecv(p2p_ops) + for req in reqs: + req.wait() + + def send_to_next_stage( + self, send_tensors: Union[torch.Tensor, Sequence[torch.Tensor]] + ): + """Send tensor to next stage in pipeline (forward send).""" + assert ( + self.pipeline_parallel_group is not None + ), "pipeline_parallel_group is not initialized, pipeline_parallel_size need to be set greater than 1" + + send_tensors = _check_send_recv_tensors(send_tensors) + p2p_ops = [] + for tensor in send_tensors: + send_op = torch.distributed.P2POp( + torch.distributed.isend, + tensor, + self._pipeline_parallel_group_next_rank, + group=self.pipeline_parallel_group, + ) + p2p_ops.append(send_op) + + if len(p2p_ops) > 0: + reqs = torch.distributed.batch_isend_irecv(p2p_ops) + for req in reqs: + req.wait() + + def send_and_recv_between_neighborhoods( + self, + recv_tensors: Union[torch.Tensor, Sequence[torch.Tensor]], + send_tensors: Union[torch.Tensor, Sequence[torch.Tensor]], + ): + assert ( + self.pipeline_parallel_group is not None + ), "pipeline_parallel_group is not initialized, pipeline_parallel_size need to be set greater than 1" + + recv_tensors = _check_send_recv_tensors(recv_tensors) + send_tensors = _check_send_recv_tensors(send_tensors) + p2p_ops = [] + + for recv_tensor in recv_tensors: + recv_op = torch.distributed.P2POp( + torch.distributed.irecv, + recv_tensor, + self._pipeline_parallel_group_prev_rank, + group=self.pipeline_parallel_group, + ) + p2p_ops.append(recv_op) + + for send_tensor in send_tensors: + send_op = torch.distributed.P2POp( + torch.distributed.isend, + send_tensor, + self._pipeline_parallel_group_next_rank, + group=self.pipeline_parallel_group, + ) + p2p_ops.append(send_op) + + if len(p2p_ops) > 0: + reqs = torch.distributed.batch_isend_irecv(p2p_ops) + for req in reqs: + req.wait() + + def tensor_parallel_reduce_context(self) -> ContextManager[None]: + return nullcontext() + + def async_mode(self, async_mode_type: AsyncMode) -> AsyncModeContext: + raise NotImplementedError + + async def async_allreduce_in_tensor_parallel_group(self, tensor: torch.Tensor): + raise NotImplementedError diff --git a/src/examples/run.sh b/src/examples/run.sh new file mode 100644 index 000000000000..93140cb1f21d --- /dev/null +++ b/src/examples/run.sh @@ -0,0 +1,68 @@ +set -x + +export PYTHONPATH=$PWD:$PYTHONPATH +export CUDA_VISIBLE_DEVICES=4,7 +# export CUDA_VISIBLE_DEVICES=0,1,2,3,4,5,6,7 + +# # Select the model type +export MODEL_TYPE="Sd3" +# # Configuration for different model types +# # script, model_id, inference_step +declare -A MODEL_CONFIGS=( + ["Pixart-alpha"]="pixartalpha_example.py /cfs/dit/PixArt-XL-2-1024-MS 20" + ["Pixart-sigma"]="pixartsigma_example.py /cfs/dit/PixArt-Sigma-XL-2-2K-MS 20" + ["Sd3"]="sd3_example.py /maasjfs/hf_models/stable-diffusion-3.5-fp8/stable-diffusion-3-medium-diffusers 20" + ["Flux"]="flux_example.py /cfs/dit/FLUX.1-dev 28" + ["HunyuanDiT"]="hunyuandit_example.py /cfs/dit/HunyuanDiT-v1.2-Diffusers 50" +) + +if [[ -v MODEL_CONFIGS[$MODEL_TYPE] ]]; then + IFS=' ' read -r SCRIPT MODEL_ID INFERENCE_STEP <<< "${MODEL_CONFIGS[$MODEL_TYPE]}" + export SCRIPT MODEL_ID INFERENCE_STEP +else + echo "Invalid MODEL_TYPE: $MODEL_TYPE" + exit 1 +fi + +mkdir -p ./results + +# task args +TASK_ARGS="--height 1024 --width 1024" + + +# On 8 gpus, pp=2, ulysses=2, ring=1, cfg_parallel=2 (split batch) +N_GPUS=1 +PARALLEL_ARGS="--pipefusion_parallel_degree 1 --ulysses_degree 1 --ring_degree 1" + +# CFG_ARGS="--use_cfg_parallel" + +# By default, num_pipeline_patch = pipefusion_degree, and you can tune this parameter to achieve optimal performance. +# xinze: patch number is not necessarily equal to pp degree. +# PIPEFUSION_ARGS="--num_pipeline_patch 8 " + +# For high-resolution images, we use the latent output type to avoid runing the vae module. Used for measuring speed. +# OUTPUT_ARGS="--output_type latent" + +# PARALLLEL_VAE="--use_parallel_vae" + +# Another compile option is `--use_onediff` which will use onediff's compiler. +# COMPILE_FLAG="--use_torch_compile" + +# $CFG_ARGS \" + +# export CUDA_VISIBLE_DEVICES=4,5,6,7 + +torchrun --nproc_per_node=$N_GPUS ./examples/$SCRIPT \ +--model $MODEL_ID \ +$PARALLEL_ARGS \ +$TASK_ARGS \ +$PIPEFUSION_ARGS \ +$OUTPUT_ARGS \ +--num_inference_steps $INFERENCE_STEP \ +--prompt "a female character with long, flowing hair that appears to be made of ethereal, swirling patterns resembling the Northern Lights or Aurora Borealis. The background is dominated by deep blues and purples, creating a mysterious and dramatic atmosphere. The character's face is serene, with pale skin and striking features. She wears a dark-colored outfit with subtle patterns. The overall style of the artwork is reminiscent of fantasy or supernatural genres." \ +$PARALLLEL_VAE \ +$CFG_ARGS + +# --warmup_steps 1 \ + +# $COMPILE_FLAG diff --git a/src/examples/sd3_example.py b/src/examples/sd3_example.py new file mode 100644 index 000000000000..10fdba1b5208 --- /dev/null +++ b/src/examples/sd3_example.py @@ -0,0 +1,222 @@ +import time +import os +import torch +import torch.distributed +from diffusers.pipelines.stable_diffusion_3.pipeline_stable_diffusion_3 import StableDiffusion3Pipeline +import argparse +from diffusers.models.autoencoders.autoencoder_kl import AutoencoderKL +# from distvae.modules.adapters.vae.decoder_adapters import DecoderAdapter +from diffusers.group_coordinator import ( + GroupCoordinator, + RankGenerator, + SequenceParallelGroupCoordinator, + PipelineParallelGroupCoordinator, +) +from diffusers.runtime_state import initialize_runtime_state +from typing import Any, Dict, List, Optional, Tuple, Union +from diffusers.parallel_state import ( + init_model_parallel_group, + init_world_group, + initialize_model_parallel, + init_distributed_environment, + get_world_group, + get_pipeline_parallel_rank, + get_pipeline_parallel_world_size, +) +import torch.nn as nn + + + + +def convert_transformer( + transformer: nn.Module, + blocks_name: List[str] = ['transformer_blocks'], + ) -> nn.Module: + pp_rank = get_pipeline_parallel_rank() + pp_world_size = get_pipeline_parallel_world_size() + blocks_list = { + block_name: getattr(transformer, block_name) for block_name in blocks_name + } + num_blocks_list = [len(blocks) for blocks in blocks_list.values()] + blocks_idx = { + name: [sum(num_blocks_list[:i]), sum(num_blocks_list[: i + 1])] + for i, name in enumerate(blocks_name) + } + + num_blocks_per_stage = ( + sum(num_blocks_list) + pp_world_size - 1 + ) // pp_world_size + stage_block_start_idx = pp_rank * num_blocks_per_stage + stage_block_end_idx = min( + (pp_rank + 1) * num_blocks_per_stage, + sum(num_blocks_list), + ) + for name, [blocks_start, blocks_end] in zip( + blocks_idx.keys(), blocks_idx.values() + ): + if ( + blocks_end <= stage_block_start_idx + or stage_block_end_idx <= blocks_start + ): + setattr(transformer, name, nn.ModuleList([])) + elif stage_block_start_idx <= blocks_start: + if blocks_end <= stage_block_end_idx: + pass + else: + setattr( + transformer, + name, + blocks_list[name][: -(blocks_end - stage_block_end_idx)], + ) + # self.stage_info.after_flags[name] = False + elif blocks_start < stage_block_start_idx: + if blocks_end <= stage_block_end_idx: + setattr( + transformer, + name, + blocks_list[name][stage_block_start_idx - blocks_start :], + ) + # self.stage_info.after_flags[name] = True + else: # blocks_end > stage_layer_end_idx + setattr( + transformer, + name, + blocks_list[name][ + stage_block_start_idx + - blocks_start : stage_block_end_idx + - blocks_end + ], + ) + # self.stage_info.after_flags[name] = False + + return transformer + + +def main(): + parser = argparse.ArgumentParser(description="parallel diffuser arguments") + model_group = parser.add_argument_group("Model Options") + model_group.add_argument( + "--model", + type=str, + default="/maasjfs/hf_models/stable-diffusion-3.5-fp8/stable-diffusion-3-medium-diffusers", + help="Name or path of the huggingface model to use." + ) + model_group.add_argument( + "--ulysses_degree", + type=int, + default=None, + help="Ulysses SP degree. Used in attention layer" + ) + model_group.add_argument( + "--ring_degree", + type=int, + default=None, + help="Ring SP degree. Used in attention layer" + ) + model_group.add_argument( + "--pipefusion_parallel_degree", + type=int, + default=1, + help="Pipefusion parallel degree." + ) + model_group.add_argument( + "--prompt", + type=str, + nargs="*", + default="", + help="prompt." + ) + model_group.add_argument( + "--use_parallel_vae", + action="store_true", + help="use distvae to parallel vae" + ) + model_group.add_argument( + "--num_inference_steps", + type=int, + default=20, + help="number of inference steps." + ) + model_group.add_argument( + "--use_cfg_parallel", + action="store_true", + help="Use split batch in classifier_free_guidance. cfg_degree will be 2 if set", + ) + model_group.add_argument( + "--height", + type=int, + default=1024, + ) + model_group.add_argument( + "--width", + type=int, + default=1024, + ) + args = parser.parse_args() + use_parallel_vae = args.use_parallel_vae + ulysses_degree = args.ulysses_degree + ring_degree = args.ring_degree + PP_degree = args.pipefusion_parallel_degree + if args.use_cfg_parallel: + cfg_degree = 2 + else: + cfg_degree = 1 + + init_distributed_environment() + + + + # raise Exception(f"use_parallel_Vae is {use_parallel_vae}") + + # torch.cuda.synchronize(device=local_rank) + # print(f"the world size is {torch.distributed.get_world_size()}") + # print(f"Ulysses degree is {ulysses_degree}, ring degree is {ring_degree}, PP degree is {PP_degree}") + # print(f"the local rank is {local_rank}") + + initialize_model_parallel( + classifier_free_guidance_degree=cfg_degree, + ulysses_degree=ulysses_degree, + ring_degree=ring_degree, + pipeline_parallel_degree=PP_degree, + ) + local_rank= int(os.environ.get("LOCAL_RANK", "0")) + pipe = StableDiffusion3Pipeline.from_pretrained( + pretrained_model_name_or_path=args.model, + # engine_config=engine_config, + torch_dtype=torch.float16, + use_parallel_vae=use_parallel_vae, + PP_degree=PP_degree, + ulysses_degree=ulysses_degree, + ring_degree=ring_degree, + ).to(f"cuda:{local_rank}") + initialize_runtime_state(pipeline=pipe, engine_config=args) + + + if pipe.transformer is not None and PP_degree > 1: + pipe.transformer = convert_transformer(pipe.transformer) + start_time = time.time() + # pipe.prepare_run(input_config) + output = pipe( + height=1024, + width=1024, + prompt=args.prompt, + num_inference_steps=args.num_inference_steps, + # output_type=args.output_type, + generator=torch.Generator(device="cuda").manual_seed(42), + ) + end_time = time.time() + parallel_info = ( + # f"dp{args.data_parallel_degree}_cfg{engine_config.parallel_config.cfg_degree}_" + f"ulysses{args.ulysses_degree}_ring{args.ring_degree}_" + f"pp{args.pipefusion_parallel_degree}" + ) + image=output.images[0] + if not os.path.exists("results"): + os.mkdir("results") + image.save(f"./results/SD3_result_{parallel_info}_rank{local_rank}.png") + print(f"image saved to ./results/SD3_result_{parallel_info}_rank{local_rank}.png") + if get_world_group().rank == get_world_group().world_size - 1: + print(f"used time: {end_time-start_time:.2f} seconds") + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/src/results/SD3_result_ulysses1_ring1_pp1_rank0.png b/src/results/SD3_result_ulysses1_ring1_pp1_rank0.png new file mode 100644 index 0000000000000000000000000000000000000000..58db0ccd7c951bf1763e9cc2e2a3f9d0dbe9ae3d GIT binary patch literal 1696050 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%0DOB}X?T*4~*1dJWWdkYWf3 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
    Hq(|ydL=43cAdTiA zXvmZ<)jVAMhIj${6JwaW4^=$?z8l`hqs@1i1A>`z&V)le_b$`;QrwTW0UtjyT-0r2 zhj39HT~5+F+rsE=MvB2O0V9Qnne)4T1rY&75?>kyb8BEqmpV&gw8DtPY_6_qod_jK zAesk^+YSU#AUfaxi^Zk+8Y-W-BroHoO9{Jp7%t+f5$6Gyt;)z=z|k3*jfjJRwF(v) zuNGk*o^mnsfatxMSp-hIz3g`LexG+U%W%^gA)8ur@yIRu={5IX3o)rQdAiqo}l zYuo+#Aw|5OWlvGpZAbC6Bx%rIZT-bveeuJL!K~(fIDEVnW}aVM+i4{HD(^)AS0V9i{zBe zoRAn91Jret+U{y@tyk54k(mKWp29Iak|d8XkKJza(6w&becLLbGQ*qK-+lS*Ke*S3 z+VouV6$T5FyTAATC%fqiY#{UN+Ru(-F$aA!ZM@rGmk9)0^kWv?wyjmgAP9BPd4C85 z!PL|h92{K9+`Flo4J8o{w~1@cdEOmbT}zqf!#)6+SU3l=dbnef34#NdITOo;9K`?- z77)NG?_H5e5XF21SG&6Q-Xa`@NrX8AkwutCN;7fE<&evvTd1<+1Itd0)REIX?Qd9S z05O9kQ@C&2$|#9S?-4P0-KofwL{uwrxGA_#WzQ_a*&K+{lxF4vz$DZ4&3nw*1Df{M zU1VmQL}rhv;o;Mt{P}0U_*LHTyBjAiIawGX?sM8tnTXZF0+Mja9B$^_-NG$2CZ03p z?ytr3jhzZQBGXrNk^|otg74M*;`6))J#?&BE4gRexwr zy{E*}RBDgYscP45R$I+ky6b7(2niV^vlK})mpQRSuqpd${h_zjy#X|fwY9N3-MTvX zpc)wB(zH8P!iTPRy=?|WrMn+%Tdk8&$w@K?7?Gz;H#gHf(e98~oRfF&-OUg=F{jk3 z5wc(qLRZxQ1w?|Jn224`y0uNu56vnuOyKO@b<@5XG>7H|DAa6izGyT!uI|0u4eb-x!O6Bdc%{TL3{7--V#Vv#k`Omc>GlsN>^ZitA-h2L`H5VpMXdbP$l9F&TjVbR_+SS^^y<1mn!emM1J#GIK7(Ow4 KCB_)+J3-+iH>Y^vQc|vmx0J^C_2-W#n>*NblWD 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

    u3sOQtEnRL#NIWq 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

    oj6KIpA49nXilpZ7e0(Zjo=e`b&zoDf$ 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