Buckets:

hf-doc-build
/

doc

Files
xet
hf-doc-build/doc / diffusers /main /ru /api /pipelines /mochi.md
mishig
3 days ago
preview code
download
raw
30.9 kB
#
# Лицензия Apache License, Version 2.0 («Лицензия»);
# вы можете использовать этот файл только в соответствии с Лицензией.
# Вы можете получить копию Лицензии по адресу
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Если это не требуется применимым законодательством или не оговорено письменно, программное
# распространяется по Лицензии на условиях «КАК ЕСТЬ»,
# БЕЗ КАКИХ-ЛИБО ГАРАНТИЙ ИЛИ УСЛОВИЙ, прямо указанных или подразумеваемых.
# См. Лицензию для получения конкретных условий, регулирующих разрешения и
# ограничениями, предусмотренными Лицензией.
-->

# Mochi 1 Preview

  

> [!TIP]
> В настоящее время доступна только исследовательская версия весов модели.

[Mochi 1](https://huggingface.co/genmo/mochi-1-preview) — это модель генерации видео от Genmo, в которой делается сильный упор на соответствие промпту и качество движения. Модель использует архитектуру Asmmetric Diffusion Transformer (AsymmDiT) с 10 млрд параметров и применяет несимметричные слои проекции QKV и выходных данных для снижения требований к памяти при инференсе. Для кодирования промптов используется одна модель T5-XXL.

*Mochi 1 preview — это открытая модель генерации видео, демонстрирующая передовые результаты: высокую точность движения и строгое следование промпту в предварительной оценке. Эта модель значительно сокращает разрыв между закрытыми и открытыми системами генерации видео. Модель распространяется по свободной лицензии Apache 2.0.*

> [!TIP]
> Обязательно ознакомьтесь с [руководством по планировщикам](../../using-diffusers/schedulers), чтобы узнать, как исследовать баланс между скоростью и качеством планировщика, а также с разделом [повторное использование компонентов в разных конвейерах](../../using-diffusers/loading#reusing-models-in-multiple-pipelines), чтобы узнать, как эффективно загружать одни и те же компоненты в несколько конвейеров.

## Квантование

Квантование помогает снизить требования к памяти для очень больших моделей, храня веса модели в формате данных с меньшей точностью. Однако влияние квантования на качество видео может различаться в зависимости от используемой модели видео.

См. обзор [Quantization](../../quantization/overview), чтобы узнать больше о поддерживаемых бэкендах квантования и о том, как выбрать бэкенд, подходящий для вашей задачи. Пример ниже показывает, как загрузить квантованный [MochiPipeline](/docs/diffusers/main/ru/api/pipelines/mochi#diffusers.MochiPipeline) для инференса с помощью bitsandbytes.

```py
import torch
from diffusers import BitsAndBytesConfig as DiffusersBitsAndBytesConfig, MochiTransformer3DModel, MochiPipeline
from diffusers.utils import export_to_video
from transformers import BitsAndBytesConfig as BitsAndBytesConfig, T5EncoderModel
quant_config = BitsAndBytesConfig(load_in_8bit=True)
text_encoder_8bit = T5EncoderModel.from_pretrained(
    "genmo/mochi-1-preview",
    subfolder="text_encoder",
    quantization_config=quant_config,
    dtype=torch.float16,
)
quant_config = DiffusersBitsAndBytesConfig(load_in_8bit=True)
transformer_8bit = MochiTransformer3DModel.from_pretrained(
    "genmo/mochi-1-preview",
    subfolder="transformer",
    quantization_config=quant_config,
    dtype=torch.float16,
)
pipeline = MochiPipeline.from_pretrained(
    "genmo/mochi-1-preview",
    text_encoder=text_encoder_8bit,
    transformer=transformer_8bit,
    dtype=torch.float16,
    device_map="balanced",
)
video = pipeline(
  "Close-up of a cats eye, with the galaxy reflected in the cats eye. Ultra high resolution 4k.",
  num_inference_steps=28,
  guidance_scale=3.5
).frames[0]
export_to_video(video, "cat.mp4")
```

## Генерация видео с помощью Mochi-1 Preview

В следующем примере будут загружены веса `mochi-1-preview` с полной точностью, что обеспечит наивысшее качество результатов, но потребует как минимум 42 ГБ видеопамяти для запуска.

```python
import torch
from diffusers import MochiPipeline
from diffusers.utils import export_to_video
pipe = MochiPipeline.from_pretrained("genmo/mochi-1-preview")
# Enable memory savings
pipe.enable_model_cpu_offload()
pipe.vae.enable_tiling()
prompt = "Close-up of a chameleon's eye, with its scaly skin changing color. Ultra high resolution 4k."
with torch.autocast("cuda", torch.bfloat16, cache_enabled=False):
      frames = pipe(prompt, num_frames=85).frames[0]
export_to_video(frames, "mochi.mp4", fps=30)
```

## Использование варианта с меньшей точностью для экономии памяти

В следующем примере используется вариант модели `bfloat16`, для запуска которого требуется 22 ГБ видеопамяти. В результате наблюдается незначительное снижение качества генерируемого видео.

```python
import torch
from diffusers import MochiPipeline
from diffusers.utils import export_to_video
pipe = MochiPipeline.from_pretrained("genmo/mochi-1-preview", variant="bf16", dtype=torch.bfloat16)
# Enable memory savings
pipe.enable_model_cpu_offload()
pipe.vae.enable_tiling()
prompt = "Close-up of a chameleon's eye, with its scaly skin changing color. Ultra high resolution 4k."
frames = pipe(prompt, num_frames=85).frames[0]
export_to_video(frames, "mochi.mp4", fps=30)
```

## Воспроизведение результатов из репозитория Genmo Mochi

Реализация [Genmo Mochi](https://github.com/genmoai/mochi/tree/main) использует разные значения точности для каждого этапа процесса вывода. Текстовый энкодер и VAE используют `torch.float32`, а DiT — `torch.bfloat16` с ядром внимания [attention kernel](https://pytorch.org/docs/stable/generated/torch.nn.attention.sdpa_kernel.html#torch.nn.attention.sdpa_kernel), установленным в `EFFICIENT_ATTENTION`. Пайплайны Diffusers в настоящее время не поддерживают установку разных `dtypes` для разных этапов пайплайна. Чтобы выполнить вывод так же, как в исходной реализации, обратитесь к следующему примеру.

> [!TIP]
> В исходной реализации Mochi пустые промпты обнуляются. Однако включение этого параметра и размещение всего конвейера под autocast может привести к численным переполнениям в текстовом энкодере T5.
>
> При включении `force_zeros_for_empty_prompt` рекомендуется выполнять этап кодирования текста вне контекста autocast с полной точностью.

> [!TIP]
> Декодирование латентов в полной точности требует значительного объёма памяти. Для генерации 163 кадров в этом примере потребуется как минимум 70 ГБ видеопамяти. Чтобы снизить потребление памяти, уменьшите количество кадров или выполните шаг декодирования в `torch.bfloat16`.

```python
import torch
from torch.nn.attention import SDPBackend, sdpa_kernel
from diffusers import MochiPipeline
from diffusers.utils import export_to_video
from diffusers.video_processor import VideoProcessor
pipe = MochiPipeline.from_pretrained("genmo/mochi-1-preview", force_zeros_for_empty_prompt=True)
pipe.vae.enable_tiling()
pipe.enable_model_cpu_offload()
prompt =  "An aerial shot of a parade of elephants walking across the African savannah. The camera showcases the herd and the surrounding landscape."
with torch.no_grad():
    prompt_embeds, prompt_attention_mask, negative_prompt_embeds, negative_prompt_attention_mask = (
        pipe.encode_prompt(prompt=prompt)
    )
with torch.autocast("cuda", torch.bfloat16):
    with sdpa_kernel(SDPBackend.EFFICIENT_ATTENTION):
        frames = pipe(
            prompt_embeds=prompt_embeds,
            prompt_attention_mask=prompt_attention_mask,
            negative_prompt_embeds=negative_prompt_embeds,
            negative_prompt_attention_mask=negative_prompt_attention_mask,
            guidance_scale=4.5,
            num_inference_steps=64,
            height=480,
            width=848,
            num_frames=163,
            generator=torch.Generator("cuda").manual_seed(0),
            output_type="latent",
            return_dict=False,
        )[0]
video_processor = VideoProcessor(vae_scale_factor=8)
has_latents_mean = hasattr(pipe.vae.config, "latents_mean") and pipe.vae.config.latents_mean is not None
has_latents_std = hasattr(pipe.vae.config, "latents_std") and pipe.vae.config.latents_std is not None
if has_latents_mean and has_latents_std:
    latents_mean = (
        torch.tensor(pipe.vae.config.latents_mean).view(1, 12, 1, 1, 1).to(frames.device, frames.dtype)
    )
    latents_std = (
        torch.tensor(pipe.vae.config.latents_std).view(1, 12, 1, 1, 1).to(frames.device, frames.dtype)
    )
    frames = frames * latents_std / pipe.vae.config.scaling_factor + latents_mean
else:
    frames = frames / pipe.vae.config.scaling_factor
with torch.no_grad():
    video = pipe.vae.decode(frames.to(pipe.vae.dtype), return_dict=False)[0]
video = video_processor.postprocess_video(video)[0]
export_to_video(video, "mochi.mp4", fps=30)
```

## Запуск инференса на нескольких GPU

Большую трансформерную модель Mochi можно распределить по нескольким GPU с помощью опций `device_map` и `max_memory` в `from_pretrained`. В примере ниже модель распределяется по двум GPU, каждый из которых имеет 24 ГБ видеопамяти.

```python
import torch
from diffusers import MochiPipeline, MochiTransformer3DModel
from diffusers.utils import export_to_video
model_id = "genmo/mochi-1-preview"
transformer = MochiTransformer3DModel.from_pretrained(
    model_id,
    subfolder="transformer",
    device_map="auto",
    max_memory={0: "24GB", 1: "24GB"}
)
pipe = MochiPipeline.from_pretrained(model_id,  transformer=transformer)
pipe.enable_model_cpu_offload()
pipe.vae.enable_tiling()
with torch.autocast(device_type="cuda", dtype=torch.bfloat16, cache_enabled=False):
    frames = pipe(
        prompt="Close-up of a chameleon's eye, with its scaly skin changing color. Ultra high resolution 4k.",
        negative_prompt="",
        height=480,
        width=848,
        num_frames=85,
        num_inference_steps=50,
        guidance_scale=4.5,
        num_videos_per_prompt=1,
        generator=torch.Generator(device="cuda").manual_seed(0),  # or "mps", "xpu", "cpu"
        max_sequence_length=256,
        output_type="pil",
    ).frames[0]
export_to_video(frames, "output.mp4", fps=30)
```

## Использование загрузки из одного файла с трансформером Mochi

Вы можете использовать `from_single_file` для загрузки трансформера Mochi в его исходном формате.

> [!TIP]
> Diffusers в настоящее время не поддерживает использование FP8-версий контрольных точек Mochi в формате одного файла.

```python
import torch
from diffusers import MochiPipeline, MochiTransformer3DModel
from diffusers.utils import export_to_video
model_id = "genmo/mochi-1-preview"
ckpt_path = "https://huggingface.co/Comfy-Org/mochi_preview_repackaged/blob/main/split_files/diffusion_models/mochi_preview_bf16.safetensors"
transformer = MochiTransformer3DModel.from_pretrained(ckpt_path, dtype=torch.bfloat16)
pipe = MochiPipeline.from_pretrained(model_id,  transformer=transformer)
pipe.enable_model_cpu_offload()
pipe.vae.enable_tiling()
with torch.autocast(device_type="cuda", dtype=torch.bfloat16, cache_enabled=False):
    frames = pipe(
        prompt="Close-up of a chameleon's eye, with its scaly skin changing color. Ultra high resolution 4k.",
        negative_prompt="",
        height=480,
        width=848,
        num_frames=85,
        num_inference_steps=50,
        guidance_scale=4.5,
        num_videos_per_prompt=1,
        generator=torch.Generator(device="cuda").manual_seed(0),  # or "mps", "xpu", "cpu"
        max_sequence_length=256,
        output_type="pil",
    ).frames[0]
export_to_video(frames, "output.mp4", fps=30)
```

## MochiPipeline[[diffusers.MochiPipeline]]

#### diffusers.MochiPipeline[[diffusers.MochiPipeline]]

```python
diffusers.MochiPipeline(scheduler: FlowMatchEulerDiscreteScheduler, vae: AutoencoderKLMochi, text_encoder: T5EncoderModel, tokenizer: T5Tokenizer, transformer: MochiTransformer3DModel, force_zeros_for_empty_prompt: bool = False)
```

[Источник](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/mochi/pipeline_mochi.py#L138)

**Параметры:**

transformer ([MochiTransformer3DModel](/docs/diffusers/main/ru/api/models/mochi_transformer3d#diffusers.MochiTransformer3DModel)) : Условная архитектура Transformer для удаления шума из закодированных латентов видео.

scheduler ([FlowMatchEulerDiscreteScheduler](/docs/diffusers/main/ru/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler)) : планировщик, используемый в связке с `transformer` для удаления шума из закодированных латентов изображения.

vae ([AutoencoderKLMochi](/docs/diffusers/main/ru/api/models/autoencoderkl_mochi#diffusers.AutoencoderKLMochi)) : Модель вариационного автоэнкодера (VAE) для кодирования и декодирования видео в латентные представления и обратно.

text_encoder (`T5EncoderModel`) : [T5](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5EncoderModel), а именно вариант [google/t5-v1_1-xxl](https://huggingface.co/google/t5-v1_1-xxl).
tokenizer (`CLIPTokenizer`) : Токенизатор класса [CLIPTokenizer](https://huggingface.co/docs/transformers/en/model_doc/clip#transformers.CLIPTokenizer).
tokenizer (`T5TokenizerFast`) : Второй токенизатор класса [T5TokenizerFast](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5TokenizerFast).
Конвейер mochi для генерации видео по тексту.
Справочник: https://github.com/genmoai/models
#### __call__[[diffusers.MochiPipeline.__call__]]
```python
__call__(prompt: str | list[str] = None, negative_prompt: str | list[str] | None = None, height: int | None = None, width: int | None = None, num_frames: int = 19, num_inference_steps: int = 64, timesteps: list[int] = None, guidance_scale: float = 4.5, num_videos_per_prompt: int | None = 1, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, prompt_embeds: typing.Optional[torch.Tensor] = None, prompt_attention_mask: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_attention_mask: typing.Optional[torch.Tensor] = None, output_type: str | None = 'pil', return_dict: bool = True, attention_kwargs: dict[str, typing.Any] | None = None, callback_on_step_end: typing.Optional[typing.Callable[[int, int], NoneType]] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], max_sequence_length: int = 256)
```
[Источник](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/mochi/pipeline_mochi.py#L444)
**Параметры:**
prompt (`str` или `list[str]`, *необязательный*) : Промпт или промпты для управления генерацией изображения. Если не задан, необходимо передать `prompt_embeds` вместо него.
negative_prompt (`str` или `list[str]`, *необязательный*) : Промпт или промпты, которые не должны направлять генерацию изображения. Если не задан, необходимо передать `negative_prompt_embeds`. Игнорируется, если не используется направляющее влияние (`guidance_scale < 1`).
height (`int`, *необязательный*, по умолчанию `self.default_height`) : Высота генерируемого изображения в пикселях. По умолчанию установлено значение 480 для достижения наилучших результатов.
width (`int`, *optional*, по умолчанию `self.default_width`) : Ширина генерируемого изображения в пикселях. По умолчанию установлено значение 848 для достижения наилучших результатов.
num_frames (`int`, по умолчанию `19`) : количество кадров видео для генерации
num_inference_steps (`int`, *optional*, по умолчанию 50) : Количество шагов денойзинга. Как правило, большее число шагов денойзинга приводит к изображению более высокого качества, но за счёт более медленного вывода.
timesteps (`list[int]`, *optional*) : Пользовательские шаги для процесса денойзинга с планировщиками, поддерживающими аргумент `timesteps` в их методе `set_timesteps`. Если не определено, будет использоваться поведение по умолчанию при передаче `num_inference_steps`. Должны быть в порядке убывания.
guidance_scale (`float`, по умолчанию `4.5`) : Масштаб руководства, определенный в [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598). `guidance_scale` определяется как `w` из уравнения 2 в [Imagen Paper](https://huggingface.co/papers/2205.11487). Масштаб руководства активируется при установке `guidance_scale > 1`. Более высокое значение масштаба руководства способствует генерации изображений, тесно связанных с текстовым `prompt`, обычно за счет снижения качества изображения.
num_videos_per_prompt (`int`, *необязательный*, по умолчанию 1) : Количество видео, генерируемых на один промпт.
generator (`torch.Generator` или `list[torch.Generator]`, *необязательный*) : Один или список [генераторов torch](https://pytorch.org/docs/stable/generated/torch.Generator.html) для обеспечения детерминированности генерации.
latents (`torch.Tensor`, *необязательный*) : Предварительно сгенерированные зашумленные латенты, выбранные из гауссова распределения, которые используются в качестве входных данных для генерации изображений. Можно использовать, чтобы скорректировать одну и ту же генерацию с разными промптами. Если не предоставлены, тензор латентов будет сгенерирован путём выборки с использованием переданного случайного `generator`.
prompt_embeds (`torch.Tensor`, *необязательный*) : Предварительно сгенерированные текстовые эмбеддинги. Можно использовать для простой настройки текстовых входных данных, *например* для взвешивания промпта. Если не предоставлены, текстовые эмбеддинги будут сгенерированы из входного аргумента `prompt`.
prompt_attention_mask (`torch.Tensor`, *необязательный*) : Предварительно сгенерированная маска внимания для текстовых эмбеддингов.
negative_prompt_embeds (`torch.FloatTensor`, *необязательный*) : Предварительно сгенерированные отрицательные текстовые эмбеддинги. Для PixArt-Sigma этот отрицательный промпт должен быть "". Если не указан, negative_prompt_embeds будет сгенерирован из аргумента `negative_prompt`.
negative_prompt_attention_mask (`torch.FloatTensor`, *необязательный*) : Предварительно сгенерированная маска внимания для отрицательных текстовых эмбеддингов.
output_type (`str`, *необязательный*, по умолчанию `"pil"`) : Формат вывода для генерируемого изображения. Выберите между [PIL](https://pillow.readthedocs.io/en/stable/): `PIL.Image.Image` или `np.array`.
return_dict (`bool`, *необязательный*, по умолчанию `True`) : Возвращать ли `~pipelines.mochi.MochiPipelineOutput` вместо обычного кортежа.
attention_kwargs (`dict`, *необязательный*) : Словарь kwargs, который при указании передается в `AttentionProcessor`, определенный в `self.processor` в [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py).
callback_on_step_end (`Callable`, *необязательный*) : функция, вызываемая в конце каждого шага денойзинга во время инференса. Функция вызывается со следующими аргументами: `callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)`. `callback_kwargs` будет содержать список всех тензоров, как указано в `callback_on_step_end_tensor_inputs`.
callback_on_step_end_tensor_inputs (`list`, *optional*) : Список тензорных входных данных для функции `callback_on_step_end`. Тензоры, указанные в списке, будут переданы в качестве аргумента `callback_kwargs`. Вы сможете включать только переменные, перечисленные в атрибуте `._callback_tensor_inputs` вашего класса pipeline.
max_sequence_length (`int` по умолчанию `256`) : Максимальная длина последовательности для использования с `prompt`.
**Возвращает:** `~pipelines.mochi.MochiPipelineOutput` или `tuple`
Если `return_dict` равно `True`, возвращается `~pipelines.mochi.MochiPipelineOutput`, иначе возвращается `tuple`, где первый элемент — это список с сгенерированными изображениями.
Функция, вызываемая при обращении к конвейеру для генерации.
Примеры:
```py
>>> import torch
>>> from diffusers import MochiPipeline
>>> from diffusers.utils import export_to_video

>>> pipe = MochiPipeline.from_pretrained("genmo/mochi-1-preview", torch_dtype=torch.bfloat16)
>>> pipe.enable_model_cpu_offload()
>>> pipe.vae.enable_tiling()
>>> prompt = "Close-up of a chameleon's eye, with its scaly skin changing color. Ultra high resolution 4k."
>>> frames = pipe(prompt, num_inference_steps=28, guidance_scale=3.5).frames[0]
>>> export_to_video(frames, "mochi.mp4")
```
#### encode_prompt[[diffusers.MochiPipeline.encode_prompt]]
```python
encode_prompt(prompt: str | list[str], negative_prompt: str | list[str] | None = None, do_classifier_free_guidance: bool = True, num_videos_per_prompt: int = 1, prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, prompt_attention_mask: typing.Optional[torch.Tensor] = None, negative_prompt_attention_mask: typing.Optional[torch.Tensor] = None, max_sequence_length: int = 256, device: typing.Optional[torch.device] = None, dtype: typing.Optional[torch.dtype] = None)
```
[Источник](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/mochi/pipeline_mochi.py#L254)
**Параметры:**
prompt (`str` или `list[str]`, *необязательный*) : промпт для кодирования
negative_prompt (`str` или `list[str]`, *необязательный*) : Промпт или промпты, которые не должны направлять генерацию изображения. Если не задан, необходимо передать `negative_prompt_embeds`. Игнорируется, если не используется направляющее влияние (то есть игнорируется, если `guidance_scale` меньше `1`).

do_classifier_free_guidance (`bool`, *необязательный*, по умолчанию `True`) : Использовать ли classifier free guidance.
num_videos_per_prompt (`int`, *optional*, по умолчанию 1) : Количество видео, которые должны быть сгенерированы для каждого промпта. Устройство torch, на котором должны размещаться результирующие эмбеддинги

prompt_embeds (`torch.Tensor`, *необязательный*) : Предварительно сгенерированные текстовые эмбеддинги. Можно использовать для простой настройки текстовых входных данных, *например* для взвешивания промпта. Если не предоставлены, текстовые эмбеддинги будут сгенерированы из входного аргумента `prompt`.
negative_prompt_embeds (`torch.Tensor`, *необязательный*) : Предварительно сгенерированные отрицательные текстовые эмбеддинги. Можно использовать для простой настройки текстовых входных данных, *например* для взвешивания промпта. Если не предоставлены, negative_prompt_embeds будут сгенерированы из входного аргумента `negative_prompt`.

device : (`torch.device`, *необязательный*): устройство torch

dtype : (`torch.dtype`, *необязательный*): torch dtype

Кодирует промпт в скрытые состояния текстового энкодера.

## MochiPipelineOutput[[diffusers.pipelines.mochi.pipeline_output.MochiPipelineOutput]]
#### diffusers.pipelines.mochi.pipeline_output.MochiPipelineOutput[[diffusers.pipelines.mochi.pipeline_output.MochiPipelineOutput]]
```python
diffusers.pipelines.mochi.pipeline_output.MochiPipelineOutput(frames: Tensor)
```
[Источник](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/mochi/pipeline_output.py#L9)
**Параметры:**
frames (`torch.Tensor`, `np.ndarray` или list[list[PIL.Image.Image]]) : список видеовыходов — может представлять собой вложенный список длины `batch_size,` где каждый подсписок содержит последовательности денойзированных изображений PIL длины `num_frames.` Также может быть массивом NumPy или тензором Torch формы `(batch_size, num_frames, channels, height, width)`.
Класс вывода для пайплайнов Mochi.
Xet Storage Details

Size:: 30.9 kB
Xet hash:: 604aaf4c1cc4917ceb154a807d88e8dd0a72f4aeda131f65c2561f9953200b9e
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.