source stringclasses 273
values | url stringlengths 47 172 | file_type stringclasses 1
value | chunk stringlengths 1 512 | chunk_id stringlengths 5 9 |
|---|---|---|---|---|
/Users/nielsrogge/Documents/python_projecten/diffusers/docs/source/en/quantization/bitsandbytes.md | https://huggingface.co/docs/diffusers/en/quantization/bitsandbytes/#nested-quantization | .md | Nested quantization is a technique that can save additional memory at no additional performance cost. This feature performs a second quantization of the already quantized weights to save an additional 0.4 bits/parameter.
```py
from diffusers import BitsAndBytesConfig as DiffusersBitsAndBytesConfig
from transformers i... | 43_8_0 |
/Users/nielsrogge/Documents/python_projecten/diffusers/docs/source/en/quantization/bitsandbytes.md | https://huggingface.co/docs/diffusers/en/quantization/bitsandbytes/#nested-quantization | .md | from diffusers import FluxTransformer2DModel
from transformers import T5EncoderModel
quant_config = TransformersBitsAndBytesConfig(
load_in_4bit=True,
bnb_4bit_use_double_quant=True,
)
text_encoder_2_4bit = T5EncoderModel.from_pretrained(
"black-forest-labs/FLUX.1-dev",
subfolder="text_encoder_2",
quantization_config... | 43_8_1 |
/Users/nielsrogge/Documents/python_projecten/diffusers/docs/source/en/quantization/bitsandbytes.md | https://huggingface.co/docs/diffusers/en/quantization/bitsandbytes/#nested-quantization | .md | quant_config = DiffusersBitsAndBytesConfig(
load_in_4bit=True,
bnb_4bit_use_double_quant=True,
)
transformer_4bit = FluxTransformer2DModel.from_pretrained(
"black-forest-labs/FLUX.1-dev",
subfolder="transformer",
quantization_config=quant_config,
torch_dtype=torch.float16,
)
``` | 43_8_2 |
/Users/nielsrogge/Documents/python_projecten/diffusers/docs/source/en/quantization/bitsandbytes.md | https://huggingface.co/docs/diffusers/en/quantization/bitsandbytes/#dequantizing-bitsandbytes-models | .md | Once quantized, you can dequantize a model to its original precision, but this might result in a small loss of quality. Make sure you have enough GPU RAM to fit the dequantized model.
```python
from diffusers import BitsAndBytesConfig as DiffusersBitsAndBytesConfig
from transformers import BitsAndBytesConfig as Trans... | 43_9_0 |
/Users/nielsrogge/Documents/python_projecten/diffusers/docs/source/en/quantization/bitsandbytes.md | https://huggingface.co/docs/diffusers/en/quantization/bitsandbytes/#dequantizing-bitsandbytes-models | .md | from diffusers import FluxTransformer2DModel
from transformers import T5EncoderModel
quant_config = TransformersBitsAndBytesConfig(
load_in_4bit=True,
bnb_4bit_use_double_quant=True,
)
text_encoder_2_4bit = T5EncoderModel.from_pretrained(
"black-forest-labs/FLUX.1-dev",
subfolder="text_encoder_2",
quantization_config... | 43_9_1 |
/Users/nielsrogge/Documents/python_projecten/diffusers/docs/source/en/quantization/bitsandbytes.md | https://huggingface.co/docs/diffusers/en/quantization/bitsandbytes/#dequantizing-bitsandbytes-models | .md | quant_config = DiffusersBitsAndBytesConfig(
load_in_4bit=True,
bnb_4bit_use_double_quant=True,
)
transformer_4bit = FluxTransformer2DModel.from_pretrained(
"black-forest-labs/FLUX.1-dev",
subfolder="transformer",
quantization_config=quant_config,
torch_dtype=torch.float16,
)
text_encoder_2_4bit.dequantize()
transform... | 43_9_2 |
/Users/nielsrogge/Documents/python_projecten/diffusers/docs/source/en/quantization/bitsandbytes.md | https://huggingface.co/docs/diffusers/en/quantization/bitsandbytes/#resources | .md | * [End-to-end notebook showing Flux.1 Dev inference in a free-tier Colab](https://gist.github.com/sayakpaul/c76bd845b48759e11687ac550b99d8b4)
* [Training](https://gist.github.com/sayakpaul/05afd428bc089b47af7c016e42004527) | 43_10_0 |
/Users/nielsrogge/Documents/python_projecten/diffusers/docs/source/en/quantization/torchao.md | https://huggingface.co/docs/diffusers/en/quantization/torchao/ | .md | <!-- Copyright 2024 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 ag... | 44_0_0 |
/Users/nielsrogge/Documents/python_projecten/diffusers/docs/source/en/quantization/torchao.md | https://huggingface.co/docs/diffusers/en/quantization/torchao/ | .md | 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. --> | 44_0_1 |
/Users/nielsrogge/Documents/python_projecten/diffusers/docs/source/en/quantization/torchao.md | https://huggingface.co/docs/diffusers/en/quantization/torchao/#torchao | .md | [TorchAO](https://github.com/pytorch/ao) is an architecture optimization library for PyTorch. It provides high-performance dtypes, optimization techniques, and kernels for inference and training, featuring composability with native PyTorch features like [torch.compile](https://pytorch.org/tutorials/intermediate/torch_c... | 44_1_0 |
/Users/nielsrogge/Documents/python_projecten/diffusers/docs/source/en/quantization/torchao.md | https://huggingface.co/docs/diffusers/en/quantization/torchao/#torchao | .md | Before you begin, make sure you have Pytorch 2.5+ and TorchAO installed.
```bash
pip install -U torch torchao
```
Quantize a model by passing [`TorchAoConfig`] to [`~ModelMixin.from_pretrained`] (you can also load pre-quantized models). This works for any model in any modality, as long as it supports loading with [... | 44_1_1 |
/Users/nielsrogge/Documents/python_projecten/diffusers/docs/source/en/quantization/torchao.md | https://huggingface.co/docs/diffusers/en/quantization/torchao/#torchao | .md | The example below only quantizes the weights to int8.
```python
import torch
from diffusers import FluxPipeline, FluxTransformer2DModel, TorchAoConfig | 44_1_2 |
/Users/nielsrogge/Documents/python_projecten/diffusers/docs/source/en/quantization/torchao.md | https://huggingface.co/docs/diffusers/en/quantization/torchao/#torchao | .md | model_id = "black-forest-labs/FLUX.1-dev"
dtype = torch.bfloat16
quantization_config = TorchAoConfig("int8wo")
transformer = FluxTransformer2DModel.from_pretrained(
model_id,
subfolder="transformer",
quantization_config=quantization_config,
torch_dtype=dtype,
)
pipe = FluxPipeline.from_pretrained(
model_id,
transforme... | 44_1_3 |
/Users/nielsrogge/Documents/python_projecten/diffusers/docs/source/en/quantization/torchao.md | https://huggingface.co/docs/diffusers/en/quantization/torchao/#torchao | .md | # Without quantization: ~31.447 GB
# With quantization: ~20.40 GB
print(f"Pipeline memory usage: {torch.cuda.max_memory_reserved() / 1024**3:.3f} GB") | 44_1_4 |
/Users/nielsrogge/Documents/python_projecten/diffusers/docs/source/en/quantization/torchao.md | https://huggingface.co/docs/diffusers/en/quantization/torchao/#torchao | .md | prompt = "A cat holding a sign that says hello world"
image = pipe(
prompt, num_inference_steps=50, guidance_scale=4.5, max_sequence_length=512
).images[0]
image.save("output.png")
```
TorchAO is fully compatible with [torch.compile](./optimization/torch2.0#torchcompile), setting it apart from other quantization meth... | 44_1_5 |
/Users/nielsrogge/Documents/python_projecten/diffusers/docs/source/en/quantization/torchao.md | https://huggingface.co/docs/diffusers/en/quantization/torchao/#torchao | .md | ```python
# In the above code, add the following after initializing the transformer
transformer = torch.compile(transformer, mode="max-autotune", fullgraph=True)
```
For speed and memory benchmarks on Flux and CogVideoX, please refer to the table [here](https://github.com/huggingface/diffusers/pull/10009#issue-268878... | 44_1_6 |
/Users/nielsrogge/Documents/python_projecten/diffusers/docs/source/en/quantization/torchao.md | https://huggingface.co/docs/diffusers/en/quantization/torchao/#torchao | .md | torchao also supports an automatic quantization API through [autoquant](https://github.com/pytorch/ao/blob/main/torchao/quantization/README.md#autoquantization). Autoquantization determines the best quantization strategy applicable to a model by comparing the performance of each technique on chosen input types and shap... | 44_1_7 |
/Users/nielsrogge/Documents/python_projecten/diffusers/docs/source/en/quantization/torchao.md | https://huggingface.co/docs/diffusers/en/quantization/torchao/#torchao | .md | The `TorchAoConfig` class accepts three parameters:
- `quant_type`: A string value mentioning one of the quantization types below.
- `modules_to_not_convert`: A list of module full/partial module names for which quantization should not be performed. For example, to not perform any quantization of the [`FluxTransformer2... | 44_1_8 |
/Users/nielsrogge/Documents/python_projecten/diffusers/docs/source/en/quantization/torchao.md | https://huggingface.co/docs/diffusers/en/quantization/torchao/#torchao | .md | - `kwargs`: A dict of keyword arguments to pass to the underlying quantization method which will be invoked based on `quant_type`. | 44_1_9 |
/Users/nielsrogge/Documents/python_projecten/diffusers/docs/source/en/quantization/torchao.md | https://huggingface.co/docs/diffusers/en/quantization/torchao/#supported-quantization-types | .md | torchao supports weight-only quantization and weight and dynamic-activation quantization for int8, float3-float8, and uint1-uint7.
Weight-only quantization stores the model weights in a specific low-bit data type but performs computation with a higher-precision data type, like `bfloat16`. This lowers the memory requi... | 44_2_0 |
/Users/nielsrogge/Documents/python_projecten/diffusers/docs/source/en/quantization/torchao.md | https://huggingface.co/docs/diffusers/en/quantization/torchao/#supported-quantization-types | .md | Dynamic activation quantization stores the model weights in a low-bit dtype, while also quantizing the activations on-the-fly to save additional memory. This lowers the memory requirements from model weights, while also lowering the memory overhead from activation computations. However, this may come at a quality trade... | 44_2_1 |
/Users/nielsrogge/Documents/python_projecten/diffusers/docs/source/en/quantization/torchao.md | https://huggingface.co/docs/diffusers/en/quantization/torchao/#supported-quantization-types | .md | The quantization methods supported are as follows:
| **Category** | **Full Function Names** | **Shorthands** |
|--------------|-------------------------|----------------|
| **Integer quantization** | `int4_weight_only`, `int8_dynamic_activation_int4_weight`, `int8_weight_only`, `int8_dynamic_activation_int8_weight` |... | 44_2_2 |
/Users/nielsrogge/Documents/python_projecten/diffusers/docs/source/en/quantization/torchao.md | https://huggingface.co/docs/diffusers/en/quantization/torchao/#supported-quantization-types | .md | | **Floating point 8-bit quantization** | `float8_weight_only`, `float8_dynamic_activation_float8_weight`, `float8_static_activation_float8_weight` | `float8wo`, `float8wo_e5m2`, `float8wo_e4m3`, `float8dq`, `float8dq_e4m3`, `float8_e4m3_tensor`, `float8_e4m3_row` |
| **Floating point X-bit quantization** | `fpx_weight... | 44_2_3 |
/Users/nielsrogge/Documents/python_projecten/diffusers/docs/source/en/quantization/torchao.md | https://huggingface.co/docs/diffusers/en/quantization/torchao/#supported-quantization-types | .md | | **Unsigned Integer quantization** | `uintx_weight_only` | `uint1wo`, `uint2wo`, `uint3wo`, `uint4wo`, `uint5wo`, `uint6wo`, `uint7wo` |
Some quantization methods are aliases (for example, `int8wo` is the commonly used shorthand for `int8_weight_only`). This allows using the quantization methods described in the tor... | 44_2_4 |
/Users/nielsrogge/Documents/python_projecten/diffusers/docs/source/en/quantization/torchao.md | https://huggingface.co/docs/diffusers/en/quantization/torchao/#supported-quantization-types | .md | Refer to the official torchao documentation for a better understanding of the available quantization methods and the exhaustive list of configuration options available. | 44_2_5 |
/Users/nielsrogge/Documents/python_projecten/diffusers/docs/source/en/quantization/torchao.md | https://huggingface.co/docs/diffusers/en/quantization/torchao/#serializing-and-deserializing-quantized-models | .md | To serialize a quantized model in a given dtype, first load the model with the desired quantization dtype and then save it using the [`~ModelMixin.save_pretrained`] method.
```python
import torch
from diffusers import FluxTransformer2DModel, TorchAoConfig | 44_3_0 |
/Users/nielsrogge/Documents/python_projecten/diffusers/docs/source/en/quantization/torchao.md | https://huggingface.co/docs/diffusers/en/quantization/torchao/#serializing-and-deserializing-quantized-models | .md | quantization_config = TorchAoConfig("int8wo")
transformer = FluxTransformer2DModel.from_pretrained(
"black-forest-labs/Flux.1-Dev",
subfolder="transformer",
quantization_config=quantization_config,
torch_dtype=torch.bfloat16,
)
transformer.save_pretrained("/path/to/flux_int8wo", safe_serialization=False)
```
To load ... | 44_3_1 |
/Users/nielsrogge/Documents/python_projecten/diffusers/docs/source/en/quantization/torchao.md | https://huggingface.co/docs/diffusers/en/quantization/torchao/#serializing-and-deserializing-quantized-models | .md | transformer = FluxTransformer2DModel.from_pretrained("/path/to/flux_int8wo", torch_dtype=torch.bfloat16, use_safetensors=False)
pipe = FluxPipeline.from_pretrained("black-forest-labs/Flux.1-Dev", transformer=transformer, torch_dtype=torch.bfloat16)
pipe.to("cuda") | 44_3_2 |
/Users/nielsrogge/Documents/python_projecten/diffusers/docs/source/en/quantization/torchao.md | https://huggingface.co/docs/diffusers/en/quantization/torchao/#serializing-and-deserializing-quantized-models | .md | prompt = "A cat holding a sign that says hello world"
image = pipe(prompt, num_inference_steps=30, guidance_scale=7.0).images[0]
image.save("output.png")
``` | 44_3_3 |
/Users/nielsrogge/Documents/python_projecten/diffusers/docs/source/en/quantization/torchao.md | https://huggingface.co/docs/diffusers/en/quantization/torchao/#serializing-and-deserializing-quantized-models | .md | image.save("output.png")
```
Some quantization methods, such as `uint4wo`, cannot be loaded directly and may result in an `UnpicklingError` when trying to load the models, but work as expected when saving them. In order to work around this, one can load the state dict manually into the model. Note, however, that this... | 44_3_4 |
/Users/nielsrogge/Documents/python_projecten/diffusers/docs/source/en/quantization/torchao.md | https://huggingface.co/docs/diffusers/en/quantization/torchao/#serializing-and-deserializing-quantized-models | .md | ```python
import torch
from accelerate import init_empty_weights
from diffusers import FluxPipeline, FluxTransformer2DModel, TorchAoConfig | 44_3_5 |
/Users/nielsrogge/Documents/python_projecten/diffusers/docs/source/en/quantization/torchao.md | https://huggingface.co/docs/diffusers/en/quantization/torchao/#serializing-and-deserializing-quantized-models | .md | # Serialize the model
transformer = FluxTransformer2DModel.from_pretrained(
"black-forest-labs/Flux.1-Dev",
subfolder="transformer",
quantization_config=TorchAoConfig("uint4wo"),
torch_dtype=torch.bfloat16,
)
transformer.save_pretrained("/path/to/flux_uint4wo", safe_serialization=False, max_shard_size="50GB")
# ... | 44_3_6 |
/Users/nielsrogge/Documents/python_projecten/diffusers/docs/source/en/quantization/torchao.md | https://huggingface.co/docs/diffusers/en/quantization/torchao/#serializing-and-deserializing-quantized-models | .md | # Load the model
state_dict = torch.load("/path/to/flux_uint4wo/diffusion_pytorch_model.bin", weights_only=False, map_location="cpu")
with init_empty_weights():
transformer = FluxTransformer2DModel.from_config("/path/to/flux_uint4wo/config.json")
transformer.load_state_dict(state_dict, strict=True, assign=True)
``` | 44_3_7 |
/Users/nielsrogge/Documents/python_projecten/diffusers/docs/source/en/quantization/torchao.md | https://huggingface.co/docs/diffusers/en/quantization/torchao/#resources | .md | - [TorchAO Quantization API](https://github.com/pytorch/ao/blob/main/torchao/quantization/README.md)
- [Diffusers-TorchAO examples](https://github.com/sayakpaul/diffusers-torchao) | 44_4_0 |
/Users/nielsrogge/Documents/python_projecten/diffusers/docs/source/en/quantization/overview.md | https://huggingface.co/docs/diffusers/en/quantization/overview/ | .md | <!--Copyright 2024 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 agr... | 45_0_0 |
/Users/nielsrogge/Documents/python_projecten/diffusers/docs/source/en/quantization/overview.md | https://huggingface.co/docs/diffusers/en/quantization/overview/ | .md | 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.
--> | 45_0_1 |
/Users/nielsrogge/Documents/python_projecten/diffusers/docs/source/en/quantization/overview.md | https://huggingface.co/docs/diffusers/en/quantization/overview/#quantization | .md | Quantization techniques focus on representing data with less information while also trying to not lose too much accuracy. This often means converting a data type to represent the same information with fewer bits. For example, if your model weights are stored as 32-bit floating points and they're quantized to 16-bit flo... | 45_1_0 |
/Users/nielsrogge/Documents/python_projecten/diffusers/docs/source/en/quantization/overview.md | https://huggingface.co/docs/diffusers/en/quantization/overview/#quantization | .md | store and reduces memory-usage. Lower precision can also speedup inference because it takes less time to perform calculations with fewer bits. | 45_1_1 |
/Users/nielsrogge/Documents/python_projecten/diffusers/docs/source/en/quantization/overview.md | https://huggingface.co/docs/diffusers/en/quantization/overview/#quantization | .md | <Tip>
Interested in adding a new quantization method to Diffusers? Refer to the [Contribute new quantization method guide](https://huggingface.co/docs/transformers/main/en/quantization/contribute) to learn more about adding a new quantization method.
</Tip>
<Tip>
If you are new to the quantization field, we rec... | 45_1_2 |
/Users/nielsrogge/Documents/python_projecten/diffusers/docs/source/en/quantization/overview.md | https://huggingface.co/docs/diffusers/en/quantization/overview/#quantization | .md | * [Quantization Fundamentals with Hugging Face](https://www.deeplearning.ai/short-courses/quantization-fundamentals-with-hugging-face/)
* [Quantization in Depth](https://www.deeplearning.ai/short-courses/quantization-in-depth/)
</Tip> | 45_1_3 |
/Users/nielsrogge/Documents/python_projecten/diffusers/docs/source/en/quantization/overview.md | https://huggingface.co/docs/diffusers/en/quantization/overview/#when-to-use-what | .md | Diffusers currently supports the following quantization methods.
- [BitsandBytes](./bitsandbytes)
- [TorchAO](./torchao)
- [GGUF](./gguf)
[This resource](https://huggingface.co/docs/transformers/main/en/quantization/overview#when-to-use-what) provides a good overview of the pros and cons of different quantization tec... | 45_2_0 |
/Users/nielsrogge/Documents/python_projecten/diffusers/docs/source/en/quantization/gguf.md | https://huggingface.co/docs/diffusers/en/quantization/gguf/ | .md | <!--Copyright 2024 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 agr... | 46_0_0 |
/Users/nielsrogge/Documents/python_projecten/diffusers/docs/source/en/quantization/gguf.md | https://huggingface.co/docs/diffusers/en/quantization/gguf/ | .md | 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.
--> | 46_0_1 |
/Users/nielsrogge/Documents/python_projecten/diffusers/docs/source/en/quantization/gguf.md | https://huggingface.co/docs/diffusers/en/quantization/gguf/#gguf | .md | The GGUF file format is typically used to store models for inference with [GGML](https://github.com/ggerganov/ggml) and supports a variety of block wise quantization options. Diffusers supports loading checkpoints prequantized and saved in the GGUF format via `from_single_file` loading with Model classes. Loading GGUF ... | 46_1_0 |
/Users/nielsrogge/Documents/python_projecten/diffusers/docs/source/en/quantization/gguf.md | https://huggingface.co/docs/diffusers/en/quantization/gguf/#gguf | .md | The following example will load the [FLUX.1 DEV](https://huggingface.co/black-forest-labs/FLUX.1-dev) transformer model using the GGUF Q2_K quantization variant.
Before starting please install gguf in your environment
```shell
pip install -U gguf
```
Since GGUF is a single file format, use [`~FromSingleFileMixin.... | 46_1_1 |
/Users/nielsrogge/Documents/python_projecten/diffusers/docs/source/en/quantization/gguf.md | https://huggingface.co/docs/diffusers/en/quantization/gguf/#gguf | .md | When using GGUF checkpoints, the quantized weights remain in a low memory `dtype`(typically `torch.uint8`) and are dynamically dequantized and cast to the configured `compute_dtype` during each module's forward pass through the model. The `GGUFQuantizationConfig` allows you to set the `compute_dtype`. | 46_1_2 |
/Users/nielsrogge/Documents/python_projecten/diffusers/docs/source/en/quantization/gguf.md | https://huggingface.co/docs/diffusers/en/quantization/gguf/#gguf | .md | The functions used for dynamic dequantizatation are based on the great work done by [city96](https://github.com/city96/ComfyUI-GGUF), who created the Pytorch ports of the original [`numpy`](https://github.com/ggerganov/llama.cpp/blob/master/gguf-py/gguf/quants.py) implementation by [compilade](https://github.com/compil... | 46_1_3 |
/Users/nielsrogge/Documents/python_projecten/diffusers/docs/source/en/quantization/gguf.md | https://huggingface.co/docs/diffusers/en/quantization/gguf/#gguf | .md | from diffusers import FluxPipeline, FluxTransformer2DModel, GGUFQuantizationConfig | 46_1_4 |
/Users/nielsrogge/Documents/python_projecten/diffusers/docs/source/en/quantization/gguf.md | https://huggingface.co/docs/diffusers/en/quantization/gguf/#gguf | .md | ckpt_path = (
"https://huggingface.co/city96/FLUX.1-dev-gguf/blob/main/flux1-dev-Q2_K.gguf"
)
transformer = FluxTransformer2DModel.from_single_file(
ckpt_path,
quantization_config=GGUFQuantizationConfig(compute_dtype=torch.bfloat16),
torch_dtype=torch.bfloat16,
)
pipe = FluxPipeline.from_pretrained(
"black-forest-labs/... | 46_1_5 |
/Users/nielsrogge/Documents/python_projecten/diffusers/docs/source/en/quantization/gguf.md | https://huggingface.co/docs/diffusers/en/quantization/gguf/#gguf | .md | torch_dtype=torch.bfloat16,
)
pipe.enable_model_cpu_offload()
prompt = "A cat holding a sign that says hello world"
image = pipe(prompt, generator=torch.manual_seed(0)).images[0]
image.save("flux-gguf.png")
``` | 46_1_6 |
/Users/nielsrogge/Documents/python_projecten/diffusers/docs/source/en/quantization/gguf.md | https://huggingface.co/docs/diffusers/en/quantization/gguf/#supported-quantization-types | .md | - BF16
- Q4_0
- Q4_1
- Q5_0
- Q5_1
- Q8_0
- Q2_K
- Q3_K
- Q4_K
- Q5_K
- Q6_K | 46_2_0 |
/Users/nielsrogge/Documents/python_projecten/diffusers/docs/source/en/using-diffusers/shap-e.md | https://huggingface.co/docs/diffusers/en/using-diffusers/shap-e/ | .md | <!--Copyright 2024 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 agr... | 47_0_0 |
/Users/nielsrogge/Documents/python_projecten/diffusers/docs/source/en/using-diffusers/shap-e.md | https://huggingface.co/docs/diffusers/en/using-diffusers/shap-e/ | .md | 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.
--> | 47_0_1 |
/Users/nielsrogge/Documents/python_projecten/diffusers/docs/source/en/using-diffusers/shap-e.md | https://huggingface.co/docs/diffusers/en/using-diffusers/shap-e/#shap-e | .md | [[open-in-colab]]
Shap-E is a conditional model for generating 3D assets which could be used for video game development, interior design, and architecture. It is trained on a large dataset of 3D assets, and post-processed to render more views of each object and produce 16K instead of 4K point clouds. The Shap-E model... | 47_1_0 |
/Users/nielsrogge/Documents/python_projecten/diffusers/docs/source/en/using-diffusers/shap-e.md | https://huggingface.co/docs/diffusers/en/using-diffusers/shap-e/#shap-e | .md | 2. a diffusion model is trained on the latents produced by the encoder to generate either neural radiance fields (NeRFs) or a textured 3D mesh, making it easier to render and use the 3D asset in downstream applications
This guide will show you how to use Shap-E to start generating your own 3D assets!
Before you beg... | 47_1_1 |
/Users/nielsrogge/Documents/python_projecten/diffusers/docs/source/en/using-diffusers/shap-e.md | https://huggingface.co/docs/diffusers/en/using-diffusers/shap-e/#text-to-3d | .md | To generate a gif of a 3D object, pass a text prompt to the [`ShapEPipeline`]. The pipeline generates a list of image frames which are used to create the 3D object.
```py
import torch
from diffusers import ShapEPipeline
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
pipe = ShapEPipeline.from_... | 47_2_0 |
/Users/nielsrogge/Documents/python_projecten/diffusers/docs/source/en/using-diffusers/shap-e.md | https://huggingface.co/docs/diffusers/en/using-diffusers/shap-e/#text-to-3d | .md | guidance_scale = 15.0
prompt = ["A firecracker", "A birthday cupcake"]
images = pipe(
prompt,
guidance_scale=guidance_scale,
num_inference_steps=64,
frame_size=256,
).images
```
이제 [`~utils.export_to_gif`] 함수를 사용해 이미지 프레임 리스트를 3D 오브젝트의 gif로 변환합니다.
```py
from diffusers.utils import export_to_gif | 47_2_1 |
/Users/nielsrogge/Documents/python_projecten/diffusers/docs/source/en/using-diffusers/shap-e.md | https://huggingface.co/docs/diffusers/en/using-diffusers/shap-e/#text-to-3d | .md | export_to_gif(images[0], "firecracker_3d.gif")
export_to_gif(images[1], "cake_3d.gif")
```
<div class="flex gap-4">
<div>
<img class="rounded-xl" src="https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/shap_e/firecracker_out.gif"/>
<figcaption class="mt-2 text-center text-sm text-gray-5... | 47_2_2 |
/Users/nielsrogge/Documents/python_projecten/diffusers/docs/source/en/using-diffusers/shap-e.md | https://huggingface.co/docs/diffusers/en/using-diffusers/shap-e/#text-to-3d | .md | <figcaption class="mt-2 text-center text-sm text-gray-500">prompt = "A birthday cupcake"</figcaption>
</div>
</div> | 47_2_3 |
/Users/nielsrogge/Documents/python_projecten/diffusers/docs/source/en/using-diffusers/shap-e.md | https://huggingface.co/docs/diffusers/en/using-diffusers/shap-e/#image-to-3d | .md | To generate a 3D object from another image, use the [`ShapEImg2ImgPipeline`]. You can use an existing image or generate an entirely new one. Let's use the [Kandinsky 2.1](../api/pipelines/kandinsky) model to generate a new image.
```py
from diffusers import DiffusionPipeline
import torch | 47_3_0 |
/Users/nielsrogge/Documents/python_projecten/diffusers/docs/source/en/using-diffusers/shap-e.md | https://huggingface.co/docs/diffusers/en/using-diffusers/shap-e/#image-to-3d | .md | prior_pipeline = DiffusionPipeline.from_pretrained("kandinsky-community/kandinsky-2-1-prior", torch_dtype=torch.float16, use_safetensors=True).to("cuda")
pipeline = DiffusionPipeline.from_pretrained("kandinsky-community/kandinsky-2-1", torch_dtype=torch.float16, use_safetensors=True).to("cuda")
prompt = "A cheeseburge... | 47_3_1 |
/Users/nielsrogge/Documents/python_projecten/diffusers/docs/source/en/using-diffusers/shap-e.md | https://huggingface.co/docs/diffusers/en/using-diffusers/shap-e/#image-to-3d | .md | prompt = "A cheeseburger, white background"
image_embeds, negative_image_embeds = prior_pipeline(prompt, guidance_scale=1.0).to_tuple()
image = pipeline(
prompt,
image_embeds=image_embeds,
negative_image_embeds=negative_image_embeds,
).images[0]
image.save("burger.png")
```
Pass the cheeseburger to the [`ShapEImg2I... | 47_3_2 |
/Users/nielsrogge/Documents/python_projecten/diffusers/docs/source/en/using-diffusers/shap-e.md | https://huggingface.co/docs/diffusers/en/using-diffusers/shap-e/#image-to-3d | .md | pipe = ShapEImg2ImgPipeline.from_pretrained("openai/shap-e-img2img", torch_dtype=torch.float16, variant="fp16").to("cuda")
guidance_scale = 3.0
image = Image.open("burger.png").resize((256, 256))
images = pipe(
image,
guidance_scale=guidance_scale,
num_inference_steps=64,
frame_size=256,
).images | 47_3_3 |
/Users/nielsrogge/Documents/python_projecten/diffusers/docs/source/en/using-diffusers/shap-e.md | https://huggingface.co/docs/diffusers/en/using-diffusers/shap-e/#image-to-3d | .md | gif_path = export_to_gif(images[0], "burger_3d.gif")
```
<div class="flex gap-4">
<div>
<img class="rounded-xl" src="https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/shap_e/burger_in.png"/>
<figcaption class="mt-2 text-center text-sm text-gray-500">cheeseburger</figcaption>
</div>
<di... | 47_3_4 |
/Users/nielsrogge/Documents/python_projecten/diffusers/docs/source/en/using-diffusers/shap-e.md | https://huggingface.co/docs/diffusers/en/using-diffusers/shap-e/#image-to-3d | .md | <figcaption class="mt-2 text-center text-sm text-gray-500">3D cheeseburger</figcaption>
</div>
</div> | 47_3_5 |
/Users/nielsrogge/Documents/python_projecten/diffusers/docs/source/en/using-diffusers/shap-e.md | https://huggingface.co/docs/diffusers/en/using-diffusers/shap-e/#generate-mesh | .md | Shap-E is a flexible model that can also generate textured mesh outputs to be rendered for downstream applications. In this example, you'll convert the output into a `glb` file because the 🤗 Datasets library supports mesh visualization of `glb` files which can be rendered by the [Dataset viewer](https://huggingface.co... | 47_4_0 |
/Users/nielsrogge/Documents/python_projecten/diffusers/docs/source/en/using-diffusers/shap-e.md | https://huggingface.co/docs/diffusers/en/using-diffusers/shap-e/#generate-mesh | .md | ```py
import torch
from diffusers import ShapEPipeline | 47_4_1 |
/Users/nielsrogge/Documents/python_projecten/diffusers/docs/source/en/using-diffusers/shap-e.md | https://huggingface.co/docs/diffusers/en/using-diffusers/shap-e/#generate-mesh | .md | device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
pipe = ShapEPipeline.from_pretrained("openai/shap-e", torch_dtype=torch.float16, variant="fp16")
pipe = pipe.to(device)
guidance_scale = 15.0
prompt = "A birthday cupcake" | 47_4_2 |
/Users/nielsrogge/Documents/python_projecten/diffusers/docs/source/en/using-diffusers/shap-e.md | https://huggingface.co/docs/diffusers/en/using-diffusers/shap-e/#generate-mesh | .md | images = pipe(prompt, guidance_scale=guidance_scale, num_inference_steps=64, frame_size=256, output_type="mesh").images
```
Use the [`~utils.export_to_ply`] function to save the mesh output as a `ply` file:
<Tip>
You can optionally save the mesh output as an `obj` file with the [`~utils.export_to_obj`] function. ... | 47_4_3 |
/Users/nielsrogge/Documents/python_projecten/diffusers/docs/source/en/using-diffusers/shap-e.md | https://huggingface.co/docs/diffusers/en/using-diffusers/shap-e/#generate-mesh | .md | ply_path = export_to_ply(images[0], "3d_cake.ply")
print(f"Saved to folder: {ply_path}")
```
Then you can convert the `ply` file to a `glb` file with the trimesh library:
```py
import trimesh
mesh = trimesh.load("3d_cake.ply")
mesh_export = mesh.export("3d_cake.glb", file_type="glb")
```
By default, the mesh out... | 47_4_4 |
/Users/nielsrogge/Documents/python_projecten/diffusers/docs/source/en/using-diffusers/shap-e.md | https://huggingface.co/docs/diffusers/en/using-diffusers/shap-e/#generate-mesh | .md | mesh = trimesh.load("3d_cake.ply")
rot = trimesh.transformations.rotation_matrix(-np.pi / 2, [1, 0, 0])
mesh = mesh.apply_transform(rot)
mesh_export = mesh.export("3d_cake.glb", file_type="glb")
```
Upload the mesh file to your dataset repository to visualize it with the Dataset viewer!
<div class="flex justify-cen... | 47_4_5 |
/Users/nielsrogge/Documents/python_projecten/diffusers/docs/source/en/using-diffusers/marigold_usage.md | https://huggingface.co/docs/diffusers/en/using-diffusers/marigold_usage/ | .md | <!--Copyright 2024 Marigold authors 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 ... | 48_0_0 |
/Users/nielsrogge/Documents/python_projecten/diffusers/docs/source/en/using-diffusers/marigold_usage.md | https://huggingface.co/docs/diffusers/en/using-diffusers/marigold_usage/ | .md | 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.
--> | 48_0_1 |
/Users/nielsrogge/Documents/python_projecten/diffusers/docs/source/en/using-diffusers/marigold_usage.md | https://huggingface.co/docs/diffusers/en/using-diffusers/marigold_usage/#marigold-pipelines-for-computer-vision-tasks | .md | [Marigold](../api/pipelines/marigold) is a novel diffusion-based dense prediction approach, and a set of pipelines for various computer vision tasks, such as monocular depth estimation.
This guide will show you how to use Marigold to obtain fast and high-quality predictions for images and videos.
Each pipeline supp... | 48_1_0 |
/Users/nielsrogge/Documents/python_projecten/diffusers/docs/source/en/using-diffusers/marigold_usage.md | https://huggingface.co/docs/diffusers/en/using-diffusers/marigold_usage/#marigold-pipelines-for-computer-vision-tasks | .md | Currently, the following tasks are implemented:
| Pipeline | Predicted Modalities | ... | 48_1_1 |
/Users/nielsrogge/Documents/python_projecten/diffusers/docs/source/en/using-diffusers/marigold_usage.md | https://huggingface.co/docs/diffusers/en/using-diffusers/marigold_usage/#marigold-pipelines-for-computer-vision-tasks | .md | |---------------------------------------------------------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------------------------------|:-------------------------------------------------------------... | 48_1_2 |
/Users/nielsrogge/Documents/python_projecten/diffusers/docs/source/en/using-diffusers/marigold_usage.md | https://huggingface.co/docs/diffusers/en/using-diffusers/marigold_usage/#marigold-pipelines-for-computer-vision-tasks | .md | | [MarigoldDepthPipeline](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/marigold/pipeline_marigold_depth.py) | [Depth](https://en.wikipedia.org/wiki/Depth_map), [Disparity](https://en.wikipedia.org/wiki/Binocular_disparity) | [Fast Demo (LCM)](https://huggingface.co/spaces/prs-eth/marig... | 48_1_3 |
/Users/nielsrogge/Documents/python_projecten/diffusers/docs/source/en/using-diffusers/marigold_usage.md | https://huggingface.co/docs/diffusers/en/using-diffusers/marigold_usage/#marigold-pipelines-for-computer-vision-tasks | .md | | [MarigoldNormalsPipeline](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/marigold/pipeline_marigold_normals.py) | [Surface normals](https://en.wikipedia.org/wiki/Normal_mapping) | [Fast Demo (LCM)](https://h... | 48_1_4 |
/Users/nielsrogge/Documents/python_projecten/diffusers/docs/source/en/using-diffusers/marigold_usage.md | https://huggingface.co/docs/diffusers/en/using-diffusers/marigold_usage/#marigold-pipelines-for-computer-vision-tasks | .md | The original checkpoints can be found under the [PRS-ETH](https://huggingface.co/prs-eth/) Hugging Face organization.
These checkpoints are meant to work with diffusers pipelines and the [original codebase](https://github.com/prs-eth/marigold).
The original code can also be used to train new checkpoints. | 48_1_5 |
/Users/nielsrogge/Documents/python_projecten/diffusers/docs/source/en/using-diffusers/marigold_usage.md | https://huggingface.co/docs/diffusers/en/using-diffusers/marigold_usage/#marigold-pipelines-for-computer-vision-tasks | .md | | Checkpoint | Modality | Comment | 48_1_6 |
/Users/nielsrogge/Documents/python_projecten/diffusers/docs/source/en/using-diffusers/marigold_usage.md | https://huggingface.co/docs/diffusers/en/using-diffusers/marigold_usage/#marigold-pipelines-for-computer-vision-tasks | .md | | | 48_1_7 |
/Users/nielsrogge/Documents/python_projecten/diffusers/docs/source/en/using-diffusers/marigold_usage.md | https://huggingface.co/docs/diffusers/en/using-diffusers/marigold_usage/#marigold-pipelines-for-computer-vision-tasks | .md | |-----------------------------------------------------------------------------------------------|----------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------... | 48_1_8 |
/Users/nielsrogge/Documents/python_projecten/diffusers/docs/source/en/using-diffusers/marigold_usage.md | https://huggingface.co/docs/diffusers/en/using-diffusers/marigold_usage/#marigold-pipelines-for-computer-vision-tasks | .md | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| | 48_1_9 |
/Users/nielsrogge/Documents/python_projecten/diffusers/docs/source/en/using-diffusers/marigold_usage.md | https://huggingface.co/docs/diffusers/en/using-diffusers/marigold_usage/#marigold-pipelines-for-computer-vision-tasks | .md | | [prs-eth/marigold-v1-0](https://huggingface.co/prs-eth/marigold-v1-0) | Depth | The first Marigold Depth checkpoint, which predicts *affine-invariant depth* maps. The performance of this checkpoint in benchmarks was studied in the original [paper](https://huggingface.co/papers/2312.02145). ... | 48_1_10 |
/Users/nielsrogge/Documents/python_projecten/diffusers/docs/source/en/using-diffusers/marigold_usage.md | https://huggingface.co/docs/diffusers/en/using-diffusers/marigold_usage/#marigold-pipelines-for-computer-vision-tasks | .md | requires at least 10 steps to get reliable predictions. Affine-invariant depth prediction has a range of values in each pixel between 0 (near plane) and 1 (far plane); both planes are chosen by the model as part of the inference process. See the `MarigoldImageProcessor` reference for visualization utilities. | | 48_1_11 |
/Users/nielsrogge/Documents/python_projecten/diffusers/docs/source/en/using-diffusers/marigold_usage.md | https://huggingface.co/docs/diffusers/en/using-diffusers/marigold_usage/#marigold-pipelines-for-computer-vision-tasks | .md | | [prs-eth/marigold-depth-lcm-v1-0](https://huggingface.co/prs-eth/marigold-depth-lcm-v1-0) | Depth | The fast Marigold Depth checkpoint, fine-tuned from `prs-eth/marigold-v1-0`. Designed to be used with the `LCMScheduler` at inference, it requires as little as 1 step to get reliable predictions. The prediction ... | 48_1_12 |
/Users/nielsrogge/Documents/python_projecten/diffusers/docs/source/en/using-diffusers/marigold_usage.md | https://huggingface.co/docs/diffusers/en/using-diffusers/marigold_usage/#marigold-pipelines-for-computer-vision-tasks | .md | | | 48_1_13 |
/Users/nielsrogge/Documents/python_projecten/diffusers/docs/source/en/using-diffusers/marigold_usage.md | https://huggingface.co/docs/diffusers/en/using-diffusers/marigold_usage/#marigold-pipelines-for-computer-vision-tasks | .md | | [prs-eth/marigold-normals-v0-1](https://huggingface.co/prs-eth/marigold-normals-v0-1) | Normals | A preview checkpoint for the Marigold Normals pipeline. Designed to be used with the `DDIMScheduler` at inference, it requires at least 10 steps to get reliable predictions. The surface normals predictions are u... | 48_1_14 |
/Users/nielsrogge/Documents/python_projecten/diffusers/docs/source/en/using-diffusers/marigold_usage.md | https://huggingface.co/docs/diffusers/en/using-diffusers/marigold_usage/#marigold-pipelines-for-computer-vision-tasks | .md | checkpoint will be phased out after the release of `v1-0` version.* | | 48_1_15 |
/Users/nielsrogge/Documents/python_projecten/diffusers/docs/source/en/using-diffusers/marigold_usage.md | https://huggingface.co/docs/diffusers/en/using-diffusers/marigold_usage/#marigold-pipelines-for-computer-vision-tasks | .md | | [prs-eth/marigold-normals-lcm-v0-1](https://huggingface.co/prs-eth/marigold-normals-lcm-v0-1) | Normals | The fast Marigold Normals checkpoint, fine-tuned from `prs-eth/marigold-normals-v0-1`. Designed to be used with the `LCMScheduler` at inference, it requires as little as 1 step to get reliable predictions. The p... | 48_1_16 |
/Users/nielsrogge/Documents/python_projecten/diffusers/docs/source/en/using-diffusers/marigold_usage.md | https://huggingface.co/docs/diffusers/en/using-diffusers/marigold_usage/#marigold-pipelines-for-computer-vision-tasks | .md | *This checkpoint will be phased out after the release of `v1-0` version.* | | 48_1_17 |
/Users/nielsrogge/Documents/python_projecten/diffusers/docs/source/en/using-diffusers/marigold_usage.md | https://huggingface.co/docs/diffusers/en/using-diffusers/marigold_usage/#marigold-pipelines-for-computer-vision-tasks | .md | The examples below are mostly given for depth prediction, but they can be universally applied with other supported modalities.
We showcase the predictions using the same input image of Albert Einstein generated by Midjourney.
This makes it easier to compare visualizations of the predictions across various modalities an... | 48_1_18 |
/Users/nielsrogge/Documents/python_projecten/diffusers/docs/source/en/using-diffusers/marigold_usage.md | https://huggingface.co/docs/diffusers/en/using-diffusers/marigold_usage/#marigold-pipelines-for-computer-vision-tasks | .md | <div class="flex gap-4" style="justify-content: center; width: 100%;">
<div style="flex: 1 1 50%; max-width: 50%;">
<img class="rounded-xl" src="https://marigoldmonodepth.github.io/images/einstein.jpg"/>
<figcaption class="mt-1 text-center text-sm text-gray-500">
Example input image for all Marigold pipelines
</figcapt... | 48_1_19 |
/Users/nielsrogge/Documents/python_projecten/diffusers/docs/source/en/using-diffusers/marigold_usage.md | https://huggingface.co/docs/diffusers/en/using-diffusers/marigold_usage/#depth-prediction-quick-start | .md | To get the first depth prediction, load `prs-eth/marigold-depth-lcm-v1-0` checkpoint into `MarigoldDepthPipeline` pipeline, put the image through the pipeline, and save the predictions:
```python
import diffusers
import torch
pipe = diffusers.MarigoldDepthPipeline.from_pretrained(
"prs-eth/marigold-depth-lcm-v1-0", ... | 48_2_0 |
/Users/nielsrogge/Documents/python_projecten/diffusers/docs/source/en/using-diffusers/marigold_usage.md | https://huggingface.co/docs/diffusers/en/using-diffusers/marigold_usage/#depth-prediction-quick-start | .md | image = diffusers.utils.load_image("https://marigoldmonodepth.github.io/images/einstein.jpg")
depth = pipe(image)
vis = pipe.image_processor.visualize_depth(depth.prediction)
vis[0].save("einstein_depth.png") | 48_2_1 |
/Users/nielsrogge/Documents/python_projecten/diffusers/docs/source/en/using-diffusers/marigold_usage.md | https://huggingface.co/docs/diffusers/en/using-diffusers/marigold_usage/#depth-prediction-quick-start | .md | depth_16bit = pipe.image_processor.export_depth_to_16bit_png(depth.prediction)
depth_16bit[0].save("einstein_depth_16bit.png")
```
The visualization function for depth [`~pipelines.marigold.marigold_image_processing.MarigoldImageProcessor.visualize_depth`] applies one of [matplotlib's colormaps](https://matplotlib.or... | 48_2_2 |
/Users/nielsrogge/Documents/python_projecten/diffusers/docs/source/en/using-diffusers/marigold_usage.md | https://huggingface.co/docs/diffusers/en/using-diffusers/marigold_usage/#depth-prediction-quick-start | .md | With the `Spectral` colormap, pixels with near depth are painted red, and far pixels are assigned blue color.
The 16-bit PNG file stores the single channel values mapped linearly from the `[0, 1]` range into `[0, 65535]`.
Below are the raw and the visualized predictions; as can be seen, dark areas (mustache) are easier... | 48_2_3 |
/Users/nielsrogge/Documents/python_projecten/diffusers/docs/source/en/using-diffusers/marigold_usage.md | https://huggingface.co/docs/diffusers/en/using-diffusers/marigold_usage/#depth-prediction-quick-start | .md | <div class="flex gap-4">
<div style="flex: 1 1 50%; max-width: 50%;">
<img class="rounded-xl" src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/marigold/marigold_einstein_lcm_depth_16bit.png"/>
<figcaption class="mt-1 text-center text-sm text-gray-500">
Predicted depth (16-bit PNG)
</fi... | 48_2_4 |
/Users/nielsrogge/Documents/python_projecten/diffusers/docs/source/en/using-diffusers/marigold_usage.md | https://huggingface.co/docs/diffusers/en/using-diffusers/marigold_usage/#depth-prediction-quick-start | .md | Predicted depth (16-bit PNG)
</figcaption>
</div>
<div style="flex: 1 1 50%; max-width: 50%;">
<img class="rounded-xl" src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/marigold/marigold_einstein_lcm_depth.png"/>
<figcaption class="mt-1 text-center text-sm text-gray-500">
Predicted dept... | 48_2_5 |
/Users/nielsrogge/Documents/python_projecten/diffusers/docs/source/en/using-diffusers/marigold_usage.md | https://huggingface.co/docs/diffusers/en/using-diffusers/marigold_usage/#surface-normals-prediction-quick-start | .md | Load `prs-eth/marigold-normals-lcm-v0-1` checkpoint into `MarigoldNormalsPipeline` pipeline, put the image through the pipeline, and save the predictions:
```python
import diffusers
import torch
pipe = diffusers.MarigoldNormalsPipeline.from_pretrained(
"prs-eth/marigold-normals-lcm-v0-1", variant="fp16", torch_dtype... | 48_3_0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.