From a884f59c4d1561895a3565f71d20fd59d8c8c928 Mon Sep 17 00:00:00 2001 From: Snailpong Date: Sun, 22 Jan 2023 00:00:47 +0900 Subject: [PATCH 01/12] feat) optimization kr translation --- docs/source/ko/optimization/fp16.mdx | 342 ++++++++++++++++++++++ docs/source/ko/optimization/habana.mdx | 71 +++++ docs/source/ko/optimization/mps.mdx | 64 ++++ docs/source/ko/optimization/onnx.mdx | 42 +++ docs/source/ko/optimization/open_vino.mdx | 15 + docs/source/ko/optimization/xformers.mdx | 26 ++ 6 files changed, 560 insertions(+) create mode 100644 docs/source/ko/optimization/fp16.mdx create mode 100644 docs/source/ko/optimization/habana.mdx create mode 100644 docs/source/ko/optimization/mps.mdx create mode 100644 docs/source/ko/optimization/onnx.mdx create mode 100644 docs/source/ko/optimization/open_vino.mdx create mode 100644 docs/source/ko/optimization/xformers.mdx diff --git a/docs/source/ko/optimization/fp16.mdx b/docs/source/ko/optimization/fp16.mdx new file mode 100644 index 000000000000..10fda087b8c8 --- /dev/null +++ b/docs/source/ko/optimization/fp16.mdx @@ -0,0 +1,342 @@ + + +# 메모리와 속도 + +메모리 또는 속도에 대해 🤗 Diffusers _추론_을 최적화하기 위한 몇 가지 기술과 아이디어를 제시합니다. 일반적으로, 메모리 효율적인 어텐션을 위해 [xFormers](https://github.com/facebookresearch/xformers) 사용을 추천하기 때문에, 추천하는 [설치 방법](xformers)을 보세요. + +다음 설정이 성능과 메모리에 미치는 영향에 대해 설명합니다. + +| | 지연시간 | 속도 향상 | +| ---------------- | ------- | ------- | +| 별도 설정 없음 | 9.50s | x1 | +| cuDNN auto-tuner | 9.37s | x1.01 | +| fp16 | 3.61s | x2.63 | +| 채널 마지막 형식 | 3.30s | x2.88 | +| 추적을 수행한 UNet | 3.21s | x2.96 | +| 메모리 효율적인 어텐션 | 2.63s | x3.61 | + + + NVIDIA TITAN RTX에서 50 DDIM 단계의 "a photo of an astronaut riding a horse on mars" 프롬프트로 512x512 크기의 단일 이미지를 생성하였습니다. + + +## cuDNN auto-tuner 활성화하기 + +[NVIDIA cuDNN](https://developer.nvidia.com/cudnn)은 컨벌루션을 계산하는 많은 알고리즘을 지원합니다. Autotuner는 짧은 벤wd치마크를 실행하고 주어진 입력 크기에 대해 주어진 하드웨어에서 최고의 성능을 가진 커널을 선택합니다. + +**컨볼루션 네트워크**를 활용하고 있기 때문에 (다른 유형들은 현재 지원되지 않음), 다음 설정을 통해 추론을 시작하기 전에 cuDNN autotuner를 활성화할 수 있습니다: + +```python +import torch + +torch.backends.cudnn.benchmark = True +``` + +### fp32 대신 tf32 사용하기 (Ampere 및 이후 CUDA 장치들에서) + +Ampere 및 이후 CUDA 장치에서 행렬 곱셈 및 컨볼루션은 TensorFloat32(TF32) 모드를 사용하여 더 빠르지만 약간 덜 정확할 수 있습니다. 기본적으로 PyTorch는 컨볼루션에 대해 TF32 모드를 활성화하지만 행렬 곱셈은 활성화하지 않습니다. 네트워크에 완전한 float32 정밀도가 필요한 경우가 아니면 행렬 곱셈에 대해서도 이 설정을 활성화하는 것이 좋습니다. 이는 일반적으로 무시할 수 있는 수치의 정확도 손실로 계산 속도를 크게 높일 수 있습니다. 그것에 대해 [여기](https://huggingface.co/docs/transformers/v4.18.0/en/performance#tf32)서 더 읽을 수 있습니다. 추론하기 전에 다음을 추가하기만 하면 됩니다: + +```python +import torch + +torch.backends.cuda.matmul.allow_tf32 = True +``` + +## 반정밀도 가중치 + +더 많은 GPU 메모리를 절약하고 더 빠른 속도를 얻기 위해 모델 가중치를 반정밀도로 직접 로드하고 실행할 수 있습니다. 여기에는 `fp16`이라는 브랜치에 저장된 float16 버전의 가중치를 로드하고, 로드할 때 `float16` 유형을 사용하도록 PyTorch에 지시하는 작업이 포함됩니다. + +```Python +pipe = StableDiffusionPipeline.from_pretrained( + "runwayml/stable-diffusion-v1-5", + + torch_dtype=torch.float16, +) +pipe = pipe.to("cuda") + +prompt = "a photo of an astronaut riding a horse on mars" +image = pipe(prompt).images[0] +``` + + + 어떤 파이프라인에서도 [`torch.autocast`](https://pytorch.org/docs/stable/amp.html#torch.autocast)를 사용하는 것은 검은색 이미지로 이어질 수 있고, 순수한 float16 정밀도를 사용하는 것보다 항상 느리기 때문에 사용하지 않는 것이 좋습니다. + + +## 추가 메모리 절약을 위한 슬라이스 어텐션 + +추가 메모리 절약을 위해, 한 번에 모두 계산하는 대신 단계적으로 계산을 수행하는 슬라이스 버전의 어텐션을 사용할 수 있습니다. + + + 어텐션 슬라이싱은 모델이 하나 이상의 어텐션 헤드를 사용하는 한 배치 크기가 1인 경우에도 유용합니다. 하나 이상의 어텐션 헤드가 있는 경우 *QK^T* 어텐션 매트릭스는 상당한 양의 메모리를 절약할 수 있는 각 헤드에 대해 순차적으로 계산될 수 있습니다. + + +각 헤드에 대해 순차적으로 어텐션 계산을 수행하려면, 다음과 같이 추론 전에 파이프라인에서 [`~StableDiffusionPipeline.enable_attention_slicing`]를 호출하면 됩니다: + +```Python +import torch +from diffusers import StableDiffusionPipeline + +pipe = StableDiffusionPipeline.from_pretrained( + "runwayml/stable-diffusion-v1-5", + + torch_dtype=torch.float16, +) +pipe = pipe.to("cuda") + +prompt = "a photo of an astronaut riding a horse on mars" +pipe.enable_attention_slicing() +image = pipe(prompt).images[0] +``` + +There's a small performance penalty of about 10% slower inference times, but this method allows you to use Stable Diffusion in as little as 3.2 GB of VRAM! +추론 시간이 약 10% 느려지는 약간의 성능 저하가 있지만 이 방법을 사용하면 3.2GB 정도의 작은 VRAM으로도 Stable Diffusion을 사용할 수 있습니다! + + +## 더 큰 배치를 위한 슬라이스 VAE 디코드 + +제한된 VRAM에서 대규모 이미지 배치를 디코딩하거나 32개 이상의 이미지가 포함된 배치를 활성화하기 위해, 배치 잠재 이미지를 한 번에 하나씩 디코딩하는 슬라이스 VAE 디코드를 사용할 수 있습니다. + +이를 [`~StableDiffusionPipeline.enable_attention_slicing`] 또는 [`~StableDiffusionPipeline.enable_xformers_memory_efficient_attention`]과 결합하여 메모리 사용을 추가로 최소화할 수 있습니다. + +VAE 디코드를 한 번에 하나씩 수행하려면 추론 전에 파이프라인에서 [`~StableDiffusionPipeline.enable_vae_slicing`]을 호출합니다. 예를 들어: + +```Python +import torch +from diffusers import StableDiffusionPipeline + +pipe = StableDiffusionPipeline.from_pretrained( + "runwayml/stable-diffusion-v1-5", + + torch_dtype=torch.float16, +) +pipe = pipe.to("cuda") + +prompt = "a photo of an astronaut riding a horse on mars" +pipe.enable_vae_slicing() +images = pipe([prompt] * 32).images +``` + +다중 이미지 배치에서 VAE 디코드가 약간의 성능 향상을 볼 수 있습니다. 단일 이미지 배치에서는 성능 영향이 없어야 합니다. + + +## 메모리 절약을 위해 가속 기능을 사용하여 CPU로 오프로드 + +추가 메모리 절약을 위해 가중치를 CPU로 오프로드하고 순방향 전달을 수행할 때만 GPU로 로드할 수 있습니다. + +CPU 오프로딩을 수행하려면 [`~StableDiffusionPipeline.enable_sequential_cpu_offload`]를 호출하기만 하면 됩니다: + +```Python +import torch +from diffusers import StableDiffusionPipeline + +pipe = StableDiffusionPipeline.from_pretrained( + "runwayml/stable-diffusion-v1-5", + + torch_dtype=torch.float16, +) + +prompt = "a photo of an astronaut riding a horse on mars" +pipe.enable_sequential_cpu_offload() +image = pipe(prompt).images[0] +``` + +그러면 메모리 소비를 3GB 미만으로 줄일 수 있습니다. + +최소한의 메모리 소비(< 2GB)를 위해 어텐션 슬라이싱을 같이 사용하는 것도 가능합니다. + +```Python +import torch +from diffusers import StableDiffusionPipeline + +pipe = StableDiffusionPipeline.from_pretrained( + "runwayml/stable-diffusion-v1-5", + + torch_dtype=torch.float16, +) + +prompt = "a photo of an astronaut riding a horse on mars" +pipe.enable_sequential_cpu_offload() +pipe.enable_attention_slicing(1) + +image = pipe(prompt).images[0] +``` + +**참고**: 'enable_sequential_cpu_offload()'를 사용할 때, 미리 파이프라인을 CUDA로 이동하지 **않는** 것이 중요합니다. 그렇지 않으면 메모리 소비의 이득이 최소화됩니다. 더 많은 정보를 위해 [이 이슈](https://github.com/huggingface/diffusers/issues/1934)를 보세요. + +## 채널 마지막 메모리 형식 사용하기 + +채널 마지막 메모리 형식은 차원 순서를 보존하는 메모리에서 NCHW 텐서 배열을 대체하는 방법입니다. 채널 마지막 텐서는 채널이 가장 조밀한 차원이 되는 방식으로 정렬됩니다(일명 픽셀당 이미지를 저장). 현재 모든 연산자 채널 마지막 형식을 지원하는 것은 아니라 성능이 저하될 수 있으므로, 사용해보고 모델에 잘 작동하는지 확인하는 것이 좋습니다. + + +예를 들어 파이프라인의 UNet 모델이 채널 마지막 형식을 사용하도록 설정하려면 다음을 사용할 수 있습니다: + +```python +print(pipe.unet.conv_out.state_dict()["weight"].stride()) # (2880, 9, 3, 1) +pipe.unet.to(memory_format=torch.channels_last) # in-place 연산 +print( + pipe.unet.conv_out.state_dict()["weight"].stride() +) # 2번째 차원에서 스트라이드 1을 가지는 (2880, 1, 960, 320)로 작동함을 증명합니다. +``` + +## 추적 + +추적은 모델을 통해 예제 입력 텐서를 통해 실행되는데, 해당 입력이 모델의 레이어를 통과할 때 호출되는 작업을 캡처하여 실행 파일 또는 'ScriptFunction'이 반환되도록 하고, 이는 적시 컴파일을 사용하여 최적화됩니다. + +UNet 모델을 추적하기 위해 다음을 사용할 수 있습니다: + +```python +import time +import torch +from diffusers import StableDiffusionPipeline +import functools + +# torch 기울기 비활성화 +torch.set_grad_enabled(False) + +# 변수 설정 +n_experiments = 2 +unet_runs_per_experiment = 50 + +# 입력 불러오기 +def generate_inputs(): + sample = torch.randn(2, 4, 64, 64).half().cuda() + timestep = torch.rand(1).half().cuda() * 999 + encoder_hidden_states = torch.randn(2, 77, 768).half().cuda() + return sample, timestep, encoder_hidden_states + + +pipe = StableDiffusionPipeline.from_pretrained( + "runwayml/stable-diffusion-v1-5", + torch_dtype=torch.float16, +).to("cuda") +unet = pipe.unet +unet.eval() +unet.to(memory_format=torch.channels_last) # 채널 마지막 메모리 형식 사용 +unet.forward = functools.partial(unet.forward, return_dict=False) # return_dict=False을 기본값으로 설정 + +# 워밍업 +for _ in range(3): + with torch.inference_mode(): + inputs = generate_inputs() + orig_output = unet(*inputs) + +# 추적 +print("tracing..") +unet_traced = torch.jit.trace(unet, inputs) +unet_traced.eval() +print("done tracing") + + +# 워밍업 및 그래프 최적화 +for _ in range(5): + with torch.inference_mode(): + inputs = generate_inputs() + orig_output = unet_traced(*inputs) + + +# 벤치마킹 +with torch.inference_mode(): + for _ in range(n_experiments): + torch.cuda.synchronize() + start_time = time.time() + for _ in range(unet_runs_per_experiment): + orig_output = unet_traced(*inputs) + torch.cuda.synchronize() + print(f"unet traced inference took {time.time() - start_time:.2f} seconds") + for _ in range(n_experiments): + torch.cuda.synchronize() + start_time = time.time() + for _ in range(unet_runs_per_experiment): + orig_output = unet(*inputs) + torch.cuda.synchronize() + print(f"unet inference took {time.time() - start_time:.2f} seconds") + +# 모델 저장 +unet_traced.save("unet_traced.pt") +``` + +그 다음, 파이프라인의 `unet` 특성을 다음과 같이 추적된 모델로 바꿀 수 있습니다. + +```python +from diffusers import StableDiffusionPipeline +import torch +from dataclasses import dataclass + + +@dataclass +class UNet2DConditionOutput: + sample: torch.FloatTensor + + +pipe = StableDiffusionPipeline.from_pretrained( + "runwayml/stable-diffusion-v1-5", + torch_dtype=torch.float16, +).to("cuda") + +# jitted unet 사용 +unet_traced = torch.jit.load("unet_traced.pt") +# pipe.unet 삭제 +class TracedUNet(torch.nn.Module): + def __init__(self): + super().__init__() + self.in_channels = pipe.unet.in_channels + self.device = pipe.unet.device + + def forward(self, latent_model_input, t, encoder_hidden_states): + sample = unet_traced(latent_model_input, t, encoder_hidden_states)[0] + return UNet2DConditionOutput(sample=sample) + + +pipe.unet = TracedUNet() + +with torch.inference_mode(): + image = pipe([prompt] * 1, num_inference_steps=50).images[0] +``` + + +## 메모리 효율적인 어텐션 + +어텐션 블록의 대역폭을 최적화하는 최근 작업으로 GPU 메모리 사용량이 크게 향상되고 향상되었습니다. @tridao의 가장 최근의 플래시 어텐션: [code](https://github.com/HazyResearch/flash-attention), [paper](https://arxiv.org/pdf/2205.14135.pdf). + +배치 크기 1(프롬프트 1개)로 512x512 크기로 추론을 실행할 때 몇 가지 Nvidia GPU에서 얻은 속도 향상은 다음과 같습니다: + +| GPU | 기준 어텐션 FP16 | 메모리 효율적인 어텐션 FP16 | +|------------------ |--------------------- |--------------------------------- | +| NVIDIA Tesla T4 | 3.5it/s | 5.5it/s | +| NVIDIA 3060 RTX | 4.6it/s | 7.8it/s | +| NVIDIA A10G | 8.88it/s | 15.6it/s | +| NVIDIA RTX A6000 | 11.7it/s | 21.09it/s | +| NVIDIA TITAN RTX | 12.51it/s | 18.22it/s | +| A100-SXM4-40GB | 18.6it/s | 29.it/s | +| A100-SXM-80GB | 18.7it/s | 29.5it/s | + +이를 활용하려면 다음을 만족해야 합니다: + - PyTorch > 1.12 + - Cuda 사용 가능 + - [xformers 라이브러리를 설치함](xformers). +```python +from diffusers import StableDiffusionPipeline +import torch + +pipe = StableDiffusionPipeline.from_pretrained( + "runwayml/stable-diffusion-v1-5", + torch_dtype=torch.float16, +).to("cuda") + +pipe.enable_xformers_memory_efficient_attention() + +with torch.inference_mode(): + sample = pipe("a small cat") + +# 선택: 이를 비활성화 하기 위해 다음을 사용할 수 있습니다. +# pipe.disable_xformers_memory_efficient_attention() +``` diff --git a/docs/source/ko/optimization/habana.mdx b/docs/source/ko/optimization/habana.mdx new file mode 100644 index 000000000000..8beecdef6e08 --- /dev/null +++ b/docs/source/ko/optimization/habana.mdx @@ -0,0 +1,71 @@ + + +# Habana Gaudi에서 Stable Diffusion을 사용하는 방법 + +🤗 Diffusers는 🤗 [Optimum Habana](https://huggingface.co/docs/optimum/habana/usage_guides/stable_diffusion)를 통해서 Habana Gaudi와 호환됩니다. + +## 요구 사항 + +- Optimum Habana 1.3 또는 이후, [여기](https://huggingface.co/docs/optimum/habana/installation)에 설치하는 방법이 있습니다. +- SynapseAI 1.7. + + +## 추론 파이프라인 + +Gaudi에서 Stable Diffusion 1 및 2로 이미지를 생성하려면 두 인스턴스를 인스턴스화해야 합니다: +- [`GaudiStableDiffusionPipeline`](https://huggingface.co/docs/optimum/habana/package_reference/stable_diffusion_pipeline)이 포함된 파이프라인. 이 파이프라인은 *텍스트-이미지 생성*을 지원합니다. +- [`GaudiDDIMScheduler`](https://huggingface.co/docs/optimum/habana/package_reference/stable_diffusion_pipeline#optimum.habana.diffusers.GaudiDDIMScheduler)이 포함된 스케줄러. 이 스케줄러는 Habana Gaudi에 최적화되어 있습니다. + +파이프라인을 초기화할 때, HPU에 배포하기 위해 `use_habana=True`를 지정해야 합니다. +또한 가능한 가장 빠른 생성을 위해 `use_hpu_graphs=True`로 **HPU 그래프**를 활성화해야 합니다. +마지막으로, [Hugging Face Hub](https://huggingface.co/Habana)에서 다운로드할 수 있는 [Gaudi configuration](https://huggingface.co/docs/optimum/habana/package_reference/gaudi_config)을 지정해야 합니다. + +```python +from optimum.habana import GaudiConfig +from optimum.habana.diffusers import GaudiDDIMScheduler, GaudiStableDiffusionPipeline + +model_name = "stabilityai/stable-diffusion-2-base" +scheduler = GaudiDDIMScheduler.from_pretrained(model_name, subfolder="scheduler") +pipeline = GaudiStableDiffusionPipeline.from_pretrained( + model_name, + scheduler=scheduler, + use_habana=True, + use_hpu_graphs=True, + gaudi_config="Habana/stable-diffusion", +) +``` + +파이프라인을 호출하여 하나 이상의 프롬프트에서 배치별로 이미지를 생성할 수 있습니다. + +```python +outputs = pipeline( + prompt=[ + "High quality photo of an astronaut riding a horse in space", + "Face of a yellow cat, high resolution, sitting on a park bench", + ], + num_images_per_prompt=10, + batch_size=4, +) +``` + +더 많은 정보를 얻기 위해, Optimum Habana의 [문서](https://huggingface.co/docs/optimum/habana/usage_guides/stable_diffusion)와 공식 Github 저장소에 제공된 [예시](https://github.com/huggingface/optimum-habana/tree/main/examples/stable-diffusion)를 확인하세요. + + +## 벤치마크 + +다음은 [Habana/stable-diffusion](https://huggingface.co/Habana/stable-diffusion) Gaudi 구성(혼합 정밀도 bf16/fp32)을 사용하는 Habana Gaudi 1 및 Gaudi 2의 지연 시간입니다: + +| | Latency | Batch size | +| ------- |:-------:|:----------:| +| Gaudi 1 | 4.37s | 4/8 | +| Gaudi 2 | 1.19s | 4/8 | diff --git a/docs/source/ko/optimization/mps.mdx b/docs/source/ko/optimization/mps.mdx new file mode 100644 index 000000000000..ae6e0fb8beab --- /dev/null +++ b/docs/source/ko/optimization/mps.mdx @@ -0,0 +1,64 @@ + + +# Apple Silicon (M1/M2)에서 Stable Diffusion을 사용하는 방법 + +Diffusers는 Stable Diffusion 추론을 위해 PyTorch `mps` 장치를 사용해 Apple 실리콘과 호환됩니다. 다음은 Stable Diffusion이 있는 M1 또는 M2 컴퓨터를 사용하기 위해 따라야 하는 단계입니다. + +## 요구 사항 + +- Apple silicon (M1/M2) 하드웨어의 Mac 컴퓨터. +- macOS 12.6 또는 이후 (13.0 또는 이후 추천). +- Python arm64 버전 +- PyTorch 1.13. Yhttps://pytorch.org/get-started/locally/의 지침에 따라 `pip` 또는 `conda`로 설치할 수 있습니다. + + +## 추론 파이프라인 + +아래 코도는 익숙한 `to()` 인터페이스를 사용하여 `mps` 백엔드로 Stable Diffusion 파이프라인을 M1 또는 M2 장치로 이동하는 방법을 보여줍니다. + +추가 일회성 전달을 사용하여 파이프라인을 "프라이밍"하는 것이 좋습니다. 이것은 우리가 발견한 이상한 문제에 대한 임시 해결 방법입니다. 첫 번째 추론 전달은 후속 전달와 약간 다른 결과를 생성합니다. 이 전달은 한 번만 수행하면 되며 추론 단계를 한 번만 사용하고 결과를 폐기해도 됩니다. + +```python +# `huggingface-cli login`에 로그인되어 있음을 확인 +from diffusers import StableDiffusionPipeline + +pipe = StableDiffusionPipeline.from_pretrained("runwayml/stable-diffusion-v1-5") +pipe = pipe.to("mps") + +# 컴퓨터가 64 GB 이하의 RAM 램일 때 추천 +pipe.enable_attention_slicing() + +prompt = "a photo of an astronaut riding a horse on mars" + +# 처음 "워밍업" 전달 (위 설명을 보세요) +_ = pipe(prompt, num_inference_steps=1) + +# 결과는 워밍업 전달 후의 CPU 장치의 결과와 일치합니다. +image = pipe(prompt).images[0] +``` + +## 성능 추천 + +M1/M2 성능은 메모리 압력에 매우 민감합니다. 시스템은 필요한 경우 자동으로 스왑되지만 스왑할 때 성능이 크게 저하됩니다. + + +특히 컴퓨터의 시스템 RAM이 64GB 미만이거나 512 × 512픽셀보다 큰 비표준 해상도에서 이미지를 생성하는 경우, 추론 중에 메모리 압력을 줄이고 스와핑을 방지하기 위해 _어텐션 슬라이싱_을 사용하는 것이 좋습니다. 어텐션 슬라이싱은 비용이 많이 드는 어텐션 작업을 한 번에 모두 수행하는 대신 여러 단계로 수행합니다. 일반적으로 범용 메모리가 없는 컴퓨터에서 ~20%의 성능 영향을 미치지만 64GB 이상이 아닌 경우 대부분의 Apple Silicon 컴퓨터에서 _더 나은 성능_이 관찰되었습니다. + +```python +pipeline.enable_attention_slicing() +``` + +## Known Issues + +- 위에서 언급한 대로, [첫번째 추론 이슈](https://github.com/huggingface/diffusers/issues/372)를 조사하고 있습니다. +- 여러 프롬프트를 배치로 생성하는 것은 [충돌이 발생하거나 안정적으로 작동하지 않습니다](https://github.com/huggingface/diffusers/issues/363). 우리는 이것이 [PyTorch의 `mps` 백엔드](https://github.com/pytorch/pytorch/issues/84039)와 관련이 있다고 생각합니다. 이 문제는 해결되고 있지만 지금은 배치 대신 반복 방법을 사용하는 것이 좋습니다. \ No newline at end of file diff --git a/docs/source/ko/optimization/onnx.mdx b/docs/source/ko/optimization/onnx.mdx new file mode 100644 index 000000000000..fed00208cd15 --- /dev/null +++ b/docs/source/ko/optimization/onnx.mdx @@ -0,0 +1,42 @@ + + + +# 추론을 위해 ONNX 런타임을 사용하는 방법 + +🤗 Diffusers는 ONNX Runtime과 호환되는 Stable Diffusion 파이프라인을 제공합니다. 이를 통해 ONNX(CPU 포함)를 지원하고 PyTorch의 가속 버전을 사용할 수 없는 모든 하드웨어에서 Stable Diffusion을 실행할 수 있습니다. + +## 설치 + +- TODO + +## Stable Diffusion 추론 + +아래 코드는 ONNX 런타임을 사용하는 방법을 보여줍니다. `StableDiffusionPipeline` 대신 `StableDiffusionOnnxPipeline`을 사용해야 합니다. 또한 리포지토리의 'onnx' 분기에서 가중치를 다운로드하고 사용하려는 런타임 공급자를 지정해야 합니다. + +```python +# `huggingface-cli login`에 로그인되어 있음을 확인 +from diffusers import StableDiffusionOnnxPipeline + +pipe = StableDiffusionOnnxPipeline.from_pretrained( + "runwayml/stable-diffusion-v1-5", + revision="onnx", + provider="CUDAExecutionProvider", +) + +prompt = "a photo of an astronaut riding a horse on mars" +image = pipe(prompt).images[0] +``` + +## 알려진 이슈들 + +- 여러 프롬프트를 배치로 생성하면 너무 많은 메모리가 사용되는 것 같습니다. 이를 조사하는 동안, 배치 대신 반복 방법이 필요할 수도 있습니다. diff --git a/docs/source/ko/optimization/open_vino.mdx b/docs/source/ko/optimization/open_vino.mdx new file mode 100644 index 000000000000..4aa602a9d0b3 --- /dev/null +++ b/docs/source/ko/optimization/open_vino.mdx @@ -0,0 +1,15 @@ + + +# OpenVINO + +작업중 🚧 diff --git a/docs/source/ko/optimization/xformers.mdx b/docs/source/ko/optimization/xformers.mdx new file mode 100644 index 000000000000..81aeb819734e --- /dev/null +++ b/docs/source/ko/optimization/xformers.mdx @@ -0,0 +1,26 @@ + + +# xFormers 설치하기 + +추론과 학습 모두에 [xFormers](https://github.com/facebookresearch/xformers)를 사용하는 것이 좋습니다. 우리의 테스트에서, 어텐션 블록에서 수행된 최적화는 더 빠른 속도와 감소된 메모리 소비를 허용합니다. + +xFormers 설치는 역사적으로 바이너리 배포판이 항상 최신 상태가 아니었기 때문에 다소 복잡했습니다. 다행스럽게도, 이 프로젝트는 [매우 최근에](https://github.com/facebookresearch/xformers/pull/591) 프로젝트의 지속적인 통합의 일환으로 pip wheels을 구축하는 프로세스를 통합했고, xFormers 버전 0.0.16부터 많은 개선이 필요합니다. + +xFormers 0.0.16이 배포될 때까지 [`TestPyPI`](https://test.pypi.org/project/formers/)를 사용하여 pip wheel을 설치할 수 있습니다. 다음은 Linux 컴퓨터에서 xFormers 버전 0.0.15를 설치하는 단계입니다: + +```bash +pip install pyre-extensions==0.0.23 +pip install -i https://test.pypi.org/simple/ formers==0.0.15.dev376 +``` + +wheel이 공식 PyPI 저장소에 게시되면 이 지침을 업데이트할 것입니다. From 1fe07bbc3e2600e29698b317e1a206688a2fc000 Mon Sep 17 00:00:00 2001 From: Snailpong Date: Sun, 22 Jan 2023 00:06:32 +0900 Subject: [PATCH 02/12] fix) typo, italic setting --- docs/source/ko/optimization/fp16.mdx | 8 ++++---- docs/source/ko/optimization/mps.mdx | 2 +- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/docs/source/ko/optimization/fp16.mdx b/docs/source/ko/optimization/fp16.mdx index 10fda087b8c8..a8b43ff2d77b 100644 --- a/docs/source/ko/optimization/fp16.mdx +++ b/docs/source/ko/optimization/fp16.mdx @@ -12,7 +12,7 @@ specific language governing permissions and limitations under the License. # 메모리와 속도 -메모리 또는 속도에 대해 🤗 Diffusers _추론_을 최적화하기 위한 몇 가지 기술과 아이디어를 제시합니다. 일반적으로, 메모리 효율적인 어텐션을 위해 [xFormers](https://github.com/facebookresearch/xformers) 사용을 추천하기 때문에, 추천하는 [설치 방법](xformers)을 보세요. +메모리 또는 속도에 대해 🤗 Diffusers *추론*을 최적화하기 위한 몇 가지 기술과 아이디어를 제시합니다. 일반적으로, 메모리 효율적인 어텐션을 위해 [xFormers](https://github.com/facebookresearch/xformers) 사용을 추천하기 때문에, 추천하는 [설치 방법](xformers)을 보세요. 다음 설정이 성능과 메모리에 미치는 영향에 대해 설명합니다. @@ -31,7 +31,7 @@ specific language governing permissions and limitations under the License. ## cuDNN auto-tuner 활성화하기 -[NVIDIA cuDNN](https://developer.nvidia.com/cudnn)은 컨벌루션을 계산하는 많은 알고리즘을 지원합니다. Autotuner는 짧은 벤wd치마크를 실행하고 주어진 입력 크기에 대해 주어진 하드웨어에서 최고의 성능을 가진 커널을 선택합니다. +[NVIDIA cuDNN](https://developer.nvidia.com/cudnn)은 컨벌루션을 계산하는 많은 알고리즘을 지원합니다. Autotuner는 짧은 벤치마크를 실행하고 주어진 입력 크기에 대해 주어진 하드웨어에서 최고의 성능을 가진 커널을 선택합니다. **컨볼루션 네트워크**를 활용하고 있기 때문에 (다른 유형들은 현재 지원되지 않음), 다음 설정을 통해 추론을 시작하기 전에 cuDNN autotuner를 활성화할 수 있습니다: @@ -68,7 +68,7 @@ image = pipe(prompt).images[0] ``` - 어떤 파이프라인에서도 [`torch.autocast`](https://pytorch.org/docs/stable/amp.html#torch.autocast)를 사용하는 것은 검은색 이미지로 이어질 수 있고, 순수한 float16 정밀도를 사용하는 것보다 항상 느리기 때문에 사용하지 않는 것이 좋습니다. + 어떤 파이프라인에서도 [`torch.autocast`](https://pytorch.org/docs/stable/amp.html#torch.autocast) 를 사용하는 것은 검은색 이미지로 이어질 수 있고, 순수한 float16 정밀도를 사용하는 것보다 항상 느리기 때문에 사용하지 않는 것이 좋습니다. ## 추가 메모리 절약을 위한 슬라이스 어텐션 @@ -322,7 +322,7 @@ with torch.inference_mode(): 이를 활용하려면 다음을 만족해야 합니다: - PyTorch > 1.12 - Cuda 사용 가능 - - [xformers 라이브러리를 설치함](xformers). + - [xformers 라이브러리를 설치함](xformers) ```python from diffusers import StableDiffusionPipeline import torch diff --git a/docs/source/ko/optimization/mps.mdx b/docs/source/ko/optimization/mps.mdx index ae6e0fb8beab..f18241608926 100644 --- a/docs/source/ko/optimization/mps.mdx +++ b/docs/source/ko/optimization/mps.mdx @@ -52,7 +52,7 @@ image = pipe(prompt).images[0] M1/M2 성능은 메모리 압력에 매우 민감합니다. 시스템은 필요한 경우 자동으로 스왑되지만 스왑할 때 성능이 크게 저하됩니다. -특히 컴퓨터의 시스템 RAM이 64GB 미만이거나 512 × 512픽셀보다 큰 비표준 해상도에서 이미지를 생성하는 경우, 추론 중에 메모리 압력을 줄이고 스와핑을 방지하기 위해 _어텐션 슬라이싱_을 사용하는 것이 좋습니다. 어텐션 슬라이싱은 비용이 많이 드는 어텐션 작업을 한 번에 모두 수행하는 대신 여러 단계로 수행합니다. 일반적으로 범용 메모리가 없는 컴퓨터에서 ~20%의 성능 영향을 미치지만 64GB 이상이 아닌 경우 대부분의 Apple Silicon 컴퓨터에서 _더 나은 성능_이 관찰되었습니다. +특히 컴퓨터의 시스템 RAM이 64GB 미만이거나 512 × 512픽셀보다 큰 비표준 해상도에서 이미지를 생성하는 경우, 추론 중에 메모리 압력을 줄이고 스와핑을 방지하기 위해 *어텐션 슬라이싱*을 사용하는 것이 좋습니다. 어텐션 슬라이싱은 비용이 많이 드는 어텐션 작업을 한 번에 모두 수행하는 대신 여러 단계로 수행합니다. 일반적으로 범용 메모리가 없는 컴퓨터에서 ~20%의 성능 영향을 미치지만 64GB 이상이 아닌 경우 대부분의 Apple Silicon 컴퓨터에서 *더 나은 성능*이 관찰되었습니다. ```python pipeline.enable_attention_slicing() From 5d980f7ec88282b89fc721c6418f37a21b4034cc Mon Sep 17 00:00:00 2001 From: Snailpong Date: Thu, 2 Feb 2023 23:07:13 +0900 Subject: [PATCH 03/12] feat) dreambooth, text2image kr --- docs/source/ko/training/dreambooth.mdx | 282 +++++++++++++++++++++++++ docs/source/ko/training/text2image.mdx | 136 ++++++++++++ 2 files changed, 418 insertions(+) create mode 100644 docs/source/ko/training/dreambooth.mdx create mode 100644 docs/source/ko/training/text2image.mdx diff --git a/docs/source/ko/training/dreambooth.mdx b/docs/source/ko/training/dreambooth.mdx new file mode 100644 index 000000000000..79ae56909487 --- /dev/null +++ b/docs/source/ko/training/dreambooth.mdx @@ -0,0 +1,282 @@ + + +# DreamBooth 미세 조정 예시 + +[DreamBooth](https://arxiv.org/abs/2208.12242)는 한 주제에 대한 적은 이미지(3~5개)만으로도 stable diffusion과 같이 text-to-image 모델을 개인화하는 방법입니다. + +![프로젝트 블로그로부터의 DreamBooth 예시](https://dreambooth.github.io/DreamBooth_files/teaser_static.jpg) +_[프로젝트 블로그](https://dreambooth.github.io)로부터의 DreamBooth 예시._ + +[Dreambooth 학습 스크립트](https://github.com/huggingface/diffusers/tree/main/examples/dreambooth)는 사전 학습된 Stable Diffusion 모델에서 학습 순서를 구현하는 방법을 보여줍니다. + + + +Dreambooth 미세 조정은 하이퍼파라미터에 매우 민감하고 과적합되기 쉽습니다. 다양한 주제에 대한 권장 설정이 포함된 [심층 분석](https://huggingface.co/blog/dreambooth)을 살펴보고 거기서에서 시작하는 것이 좋습니다. + + + +## 로컬에서 학습하기 + +### dependency 설치하기 + +스크립트를 실행하기 전에, 라이브러리의 학습 dependency들을 설치해야 합니다. 또한 `main` github 브랜치에서 `diffusers`를 설치하는 것이 좋습니다. + + +```bash +pip install git+https://github.com/huggingface/diffusers +pip install -U -r diffusers/examples/dreambooth/requirements.txt +``` + +xFormers는 학습 요구 사항의 일부는 아니지만 [가능하면 설치하는 것이 좋습니다](../optimization/xformers). 이는 훈련 속도를 높이고 메모리 집약도를 낮출 수 있습니다. + +모든 dependency가 세팅되었으면, 다음으로 [🤗 가속](https://github.com/huggingface/accelerate/) 환경을 구성할 수 있습니다: + +```bash +accelerate config +``` + +이 예시에서는 모델 버전 `v1-4`를 사용하므로, [이 링크](https://huggingface.co/CompVis/stable-diffusion-v1-4)를 방문하여 라이선스를 주의 깊게 읽어본 후 진행하시기 바랍니다. + +아래 명령은 모델의 허브 id `CompVis/stable-diffusion-v1-4`를 사용하기 때문에 허브에서 모델 가중치를 다운로드하고 캐시합니다. 리포지토리를 로컬로 복제하고 체크아웃이 저장된 시스템의 로컬 경로를 사용할 수도 있습니다. + +### 간단한 개 예시 + +이 예시에서는 [이 이미지들](https://drive.google.com/drive/folders/1BO_dyz-p65qhBRRMRA4TbZ8qW4rB99JZ)를 사용하여 Dreambooth 프로세스를 사용하여 Stable Diffusion에 새로운 개념을 추가합니다. 그것들은 우리의 훈련 데이터가 될 것입니다. 다운로드하여 시스템 어딘가에 배치하십시오. + +그런 다음 다음을 사용하여 학습 스크립트를 시작할 수 있습니다: + +```bash +export MODEL_NAME="CompVis/stable-diffusion-v1-4" +export INSTANCE_DIR="path_to_training_images" +export OUTPUT_DIR="path_to_saved_model" + +accelerate launch train_dreambooth.py \ + --pretrained_model_name_or_path=$MODEL_NAME \ + --instance_data_dir=$INSTANCE_DIR \ + --output_dir=$OUTPUT_DIR \ + --instance_prompt="a photo of sks dog" \ + --resolution=512 \ + --train_batch_size=1 \ + --gradient_accumulation_steps=1 \ + --learning_rate=5e-6 \ + --lr_scheduler="constant" \ + --lr_warmup_steps=0 \ + --max_train_steps=400 +``` + +### 사전 보존 손실을 사용한 학습 + +과적합과 language drift를 방지하기 위해 사전 보존이 사용됩니다. 관심이 있는 경우 자세한 내용은 논문를 참조하십시오. 사전 보존을 위해 동일한 클래스의 다른 이미지를 교육 프로세스의 일부로 사용합니다. 좋은 점은 Stable Diffusion 모델 자체를 사용하여 이러한 이미지를 생성할 수 있다는 것입니다! 학습 스크립트는 생성된 이미지를 우리가 지정한 로컬 경로에 저장합니다. + +논문에 따르면, 사전 보존을 위해 `num_epochs * num_samples`개의 이미지를 생성하는 것이 좋습니다. 200-300개에서 대부분 잘 작동합니다. + +```bash +export MODEL_NAME="CompVis/stable-diffusion-v1-4" +export INSTANCE_DIR="path_to_training_images" +export CLASS_DIR="path_to_class_images" +export OUTPUT_DIR="path_to_saved_model" + +accelerate launch train_dreambooth.py \ + --pretrained_model_name_or_path=$MODEL_NAME \ + --instance_data_dir=$INSTANCE_DIR \ + --class_data_dir=$CLASS_DIR \ + --output_dir=$OUTPUT_DIR \ + --with_prior_preservation --prior_loss_weight=1.0 \ + --instance_prompt="a photo of sks dog" \ + --class_prompt="a photo of dog" \ + --resolution=512 \ + --train_batch_size=1 \ + --gradient_accumulation_steps=1 \ + --learning_rate=5e-6 \ + --lr_scheduler="constant" \ + --lr_warmup_steps=0 \ + --num_class_images=200 \ + --max_train_steps=800 +``` + +### 학습 중 체크포인트 저장하기 + +Dreambooth로 훈련하는 동안 과적합하기 쉬우므로, 때때로 프로세스 중에 정기적인 체크포인트를 저장하는 것이 유용합니다. 중간 체크포인트 중 하나가 최종 모델보다 더 잘 작동할 수 있습니다! 이 기능을 사용하려면 학습 스크립트에 다음 인수를 전달해야 합니다: + +```bash + --checkpointing_steps=500 +``` + +이렇게 하면 `output_dir`의 하위 폴더에 전체 학습 상태가 저장됩니다. 하위 폴더 이름은 접두사 `checkpoint-`로 시작하고 지금까지 수행된 step 수입니다. 예: `checkpoint-1500`은 1500 학습 step 후에 저장된 체크포인트입니다. + +#### 저장된 체크포인트에서 훈련 재개하기 + +저장된 체크포인트에서 훈련을 재개하려면, `--resume_from_checkpoint` 인수를 전달한 다음 사용할 체크포인트의 이름을 지정하면 됩니다. 특수 문자열 `"latest"`를 사용하여 저장된 마지막 체크포인트(즉, step 수가 가장 많은 체크포인트)에서 재개할 수도 있습니다. 예를 들어 다음은 1500 step 후에 저장된 체크포인트에서부터 학습을 재개합니다: + +```bash + --resume_from_checkpoint="checkpoint-1500" +``` + +원하는 경우 일부 하이퍼파라미터를 조정할 수 있는 좋은 기회일 수 있습니다. + +#### 저장된 체크포인트를 사용하여 추론 수행하기 + +저장된 체크포인트는 훈련 재개에 적합한 형식으로 저장됩니다. 여기에는 모델 가중치뿐만 아니라 옵티마이저, 데이터 로더 및 학습률의 상태도 포함됩니다. + +추론을 위해 체크포인트를 사용할 수 있지만, 먼저 이를 추론 파이프라인으로 변환해야 합니다. 이는 다음과 같이 할 수 있습니다: + +```python +from accelerate import Accelerator +from diffusers import DiffusionPipeline + +# 학습에 사용된 것과 동일한 인수(모델, 개정)로 파이프라인을 로드합니다. +model_id = "CompVis/stable-diffusion-v1-4" +pipeline = DiffusionPipeline.from_pretrained(model_id) + +accelerator = Accelerator() + +# 초기 학습에 `--train_text_encoder`가 사용된 경우 text_encoder를 사용합니다. +unet, text_encoder = accelerator.prepare(pipeline.unet, pipeline.text_encoder) + +# 체크포인트 경로로부터 상태를 복원합니다. 여기서는 절대 경로를 사용해야 합니다. +accelerator.load_state("/sddata/dreambooth/daruma-v2-1/checkpoint-100") + +# unwrapped 모델로 파이프라인을 다시 빌드합니다.(.unet and .text_encoder로의 할당도 작동해야 합니다) +pipeline = DiffusionPipeline.from_pretrained( + model_id, + unet=accelerator.unwrap_model(unet), + text_encoder=accelerator.unwrap_model(text_encoder), +) + +# 추론을 수행하거나 저장하거나, 허브에 푸시합니다. +pipeline.save_pretrained("dreambooth-pipeline") +``` + +### 16GB GPU에서 훈련하기 + +Gradient checkpointing과 [bitsandbytes](https://github.com/TimDettmers/bitsandbytes)의 8비트 옵티마이저의 도움으로, 16GB GPU에서 dreambooth를 훈련할 수 있습니다. + +```bash +pip install bitsandbytes +``` + +그 다음, 학습 스크립트에 `--use_8bit_adam` 옵션을 명시합니다. + +```bash +export MODEL_NAME="CompVis/stable-diffusion-v1-4" +export INSTANCE_DIR="path_to_training_images" +export CLASS_DIR="path_to_class_images" +export OUTPUT_DIR="path_to_saved_model" + +accelerate launch train_dreambooth.py \ + --pretrained_model_name_or_path=$MODEL_NAME \ + --instance_data_dir=$INSTANCE_DIR \ + --class_data_dir=$CLASS_DIR \ + --output_dir=$OUTPUT_DIR \ + --with_prior_preservation --prior_loss_weight=1.0 \ + --instance_prompt="a photo of sks dog" \ + --class_prompt="a photo of dog" \ + --resolution=512 \ + --train_batch_size=1 \ + --gradient_accumulation_steps=2 --gradient_checkpointing \ + --use_8bit_adam \ + --learning_rate=5e-6 \ + --lr_scheduler="constant" \ + --lr_warmup_steps=0 \ + --num_class_images=200 \ + --max_train_steps=800 +``` + +### UNet뿐만 아니라 텍스트 인코더 미세 조정 + +이 스크립트는 또한 `unet`과 함께 `text_encoder`를 미세 조정할 수 있습니다. 이것은 특히 얼굴에서 훨씬 더 나은 결과를 제공한다는 것이 실험적으로 관찰되었습니다. 자세한 내용은 [블로그](https://huggingface.co/blog/dreambooth)를 참조하세요. + +이 옵션을 활성화하려면, 학습 스크립트에 `--train_text_encoder` 인수를 전달하세요. + + +텍스트 인코더를 학습하려면 추가 메모리가 필요하므로, 학습에 16GB GPU에 적합하지 않습니다. 이 옵션을 사용하려면 최소 24GB VRAM이 필요합니다. + + +```bash +export MODEL_NAME="CompVis/stable-diffusion-v1-4" +export INSTANCE_DIR="path_to_training_images" +export CLASS_DIR="path_to_class_images" +export OUTPUT_DIR="path_to_saved_model" + +accelerate launch train_dreambooth.py \ + --pretrained_model_name_or_path=$MODEL_NAME \ + --train_text_encoder \ + --instance_data_dir=$INSTANCE_DIR \ + --class_data_dir=$CLASS_DIR \ + --output_dir=$OUTPUT_DIR \ + --with_prior_preservation --prior_loss_weight=1.0 \ + --instance_prompt="a photo of sks dog" \ + --class_prompt="a photo of dog" \ + --resolution=512 \ + --train_batch_size=1 \ + --use_8bit_adam + --gradient_checkpointing \ + --learning_rate=2e-6 \ + --lr_scheduler="constant" \ + --lr_warmup_steps=0 \ + --num_class_images=200 \ + --max_train_steps=800 +``` + +### 8GB GPU에서 학습하기 + +[DeepSpeed](https://www.deepspeed.ai/)를 사용하면 일부 텐서를 VRAM에서 CPU 또는 NVME로 오프로드하여 더 적은 GPU 메모리로 학습할 수도 있습니다. + +DeepSpeed는 `accelerate config`로 활성화할 수 있습니다. 구성하는 동안, "DeepSpeed를 사용하시겠습니까?"에 예라고 대답하세요. DeepSpeed 2단계, fp16 혼합 정밀도를 결합하고 모델 매개변수와 옵티마이저 상태를 모두 CPU로 오프로드하면 8GB VRAM 미만에서 학습할 수 있습니다. 단점은 더 많은 시스템 RAM(약 25GB)이 필요하다는 것입니다. 추가 구성 옵션은 [DeepSpeed 문서](https://huggingface.co/docs/accelerate/usage_guides/deepspeed)를 참조하세요. + +기본 Adam 옵티마이저를 DeepSpeed의 특수 버전인 Adam `deepspeed.ops.adam.DeepSpeedCPUAdam`으로 변경하면 속도가 상당히 향상되지만, 활성화하려면 시스템의 CUDA 도구 체인 버전이 PyTorch로 설치된 것과 동일해야 합니다. 8비트 옵티마이저는 현재 DeepSpeed와 호환되지 않는 것 같습니다. + +```bash +export MODEL_NAME="CompVis/stable-diffusion-v1-4" +export INSTANCE_DIR="path_to_training_images" +export CLASS_DIR="path_to_class_images" +export OUTPUT_DIR="path_to_saved_model" + +accelerate launch train_dreambooth.py \ + --pretrained_model_name_or_path=$MODEL_NAME \ + --instance_data_dir=$INSTANCE_DIR \ + --class_data_dir=$CLASS_DIR \ + --output_dir=$OUTPUT_DIR \ + --with_prior_preservation --prior_loss_weight=1.0 \ + --instance_prompt="a photo of sks dog" \ + --class_prompt="a photo of dog" \ + --resolution=512 \ + --train_batch_size=1 \ + --sample_batch_size=1 \ + --gradient_accumulation_steps=1 --gradient_checkpointing \ + --learning_rate=5e-6 \ + --lr_scheduler="constant" \ + --lr_warmup_steps=0 \ + --num_class_images=200 \ + --max_train_steps=800 \ + --mixed_precision=fp16 +``` + +## 추론 + +모델을 학습한 후에는, 모델이 저장된 경로를 표시하기만 하면 `StableDiffusionPipeline`을 사용하여 추론을 수행할 수 있습니다. 프롬프트에 학습에 사용된 특수 `식별자`(이전 예시의 `sks`)가 포함되어 있는지 확인하세요. + +```python +from diffusers import StableDiffusionPipeline +import torch + +model_id = "path_to_saved_model" +pipe = StableDiffusionPipeline.from_pretrained(model_id, torch_dtype=torch.float16).to("cuda") + +prompt = "A photo of sks dog in a bucket" +image = pipe(prompt, num_inference_steps=50, guidance_scale=7.5).images[0] + +image.save("dog-bucket.png") +``` + +[저장된 학습 체크포인트](#performing-inference-using-a-saved-checkpoint)에서도 추론을 실행할 수도 있습니다. \ No newline at end of file diff --git a/docs/source/ko/training/text2image.mdx b/docs/source/ko/training/text2image.mdx new file mode 100644 index 000000000000..c2185ca1f647 --- /dev/null +++ b/docs/source/ko/training/text2image.mdx @@ -0,0 +1,136 @@ + + + +# Stable Diffusion text-to-image 미세 조정 + +[`train_text_to_image.py`](https://github.com/huggingface/diffusers/tree/main/examples/text_to_image) 스크립트는 자체 데이터셋에서 stable diffusion 모델을 미세 조정하는 방법을 보여줍니다. + + + +text-to-image 미세 조정 스크립트는 실험적입니다. 과적합하기 쉽고 치명적인 망각과 같은 문제에 부딪히기 쉽습니다. 자체 데이터셋에서 최상의 결과를 얻으려면 다양한 하이퍼파라미터를 탐색하는 것이 좋습니다. + + + +## 로컬에서 실행하기 + +### dependency 설치하기 + +스크립트를 실행하기 전에, 라이브러리의 학습 dependency들을 설치해야 합니다: + +```bash +pip install git+https://github.com/huggingface/diffusers.git +pip install -U -r requirements.txt +``` + +그리고 [🤗가속](https://github.com/huggingface/accelerate/) 환경을 초기화합니다: + +```bash +accelerate config +``` + +가중치를 다운로드하거나 사용하기 전에 모델 라이선스에 동의해야 합니다. 이 예시에서는 모델 버전 `v1-4`를 사용하므로, [이 링크](https://huggingface.co/CompVis/stable-diffusion-v1-4)를 방문하여 라이선스를 읽고 동의하면 확인란을 선택하십시오. + +🤗 Hugging Face Hub에 등록된 사용자여야 하며, 코드를 작동하기 위해 액세스 토큰도 사용해야 합니다. 액세스 토큰에 대한 자세한 내용은 [문서의 이 섹션](https://huggingface.co/docs/hub/security-tokens)을 참조하세요. + +다음 명령을 실행하여 토큰을 인증합니다. + +```bash +huggingface-cli login +``` + +리포지토리를 이미 복제한 경우, 이 단계를 수행할 필요가 없습니다. 대신, 로컬 체크아웃 경로를 학습 스크립트에 명시할 수 있으며 거기에서 로드됩니다. + +### 미세 조정을 위한 하드웨어 요구 사항 + +`gradient_checkpointing` 및 `mixed_precision`을 사용하면 단일 24GB GPU에서 모델을 미세 조정할 수 있습니다. 더 높은 `batch_size`와 더 빠른 훈련을 위해서는 GPU 메모리가 30GB 이상인 GPU를 사용하는 것이 좋습니다. TPU 또는 GPU에서 미세 조정을 위해 JAX나 Flax를 사용할 수도 있습니다. 자세한 내용은 [아래](#flax-jax-finetuning)를 참조하세요. + +### 미세 조정 예시 + +다음 스크립트는 Hugging Face Hub에서 사용할 수 있는 [Justin Pinkneys이 캡션한 Pokemon 데이터셋](https://huggingface.co/datasets/lambdalabs/pokemon-blip-captions)를 사용하여 미세 조정 실행을 시작합니다. + +```bash +export MODEL_NAME="CompVis/stable-diffusion-v1-4" +export dataset_name="lambdalabs/pokemon-blip-captions" + +accelerate launch train_text_to_image.py \ + --pretrained_model_name_or_path=$MODEL_NAME \ + --dataset_name=$dataset_name \ + --use_ema \ + --resolution=512 --center_crop --random_flip \ + --train_batch_size=1 \ + --gradient_accumulation_steps=4 \ + --gradient_checkpointing \ + --mixed_precision="fp16" \ + --max_train_steps=15000 \ + --learning_rate=1e-05 \ + --max_grad_norm=1 \ + --lr_scheduler="constant" --lr_warmup_steps=0 \ + --output_dir="sd-pokemon-model" +``` + +자체 학습 파일에서 실행하려면 `datasets`에 필요한 형식에 따라 데이터셋을 준비해야 합니다. 데이터셋을 허브에 업로드하거나 파일이 있는 로컬 폴더를 준비할 수 있습니다. [이 문서](https://huggingface.co/docs/datasets/v2.4.0/en/image_load#imagefolder-with-metadata)에서 이를 수행하는 방법을 설명합니다. + +커스텀 로딩 로직을 사용하려면 스크립트를 수정해야 합니다. 코드의 적절한 위치에 포인터를 남겼습니다 :) + +```bash +export MODEL_NAME="CompVis/stable-diffusion-v1-4" +export TRAIN_DIR="path_to_your_dataset" +export OUTPUT_DIR="path_to_save_model" + +accelerate launch train_text_to_image.py \ + --pretrained_model_name_or_path=$MODEL_NAME \ + --train_data_dir=$TRAIN_DIR \ + --use_ema \ + --resolution=512 --center_crop --random_flip \ + --train_batch_size=1 \ + --gradient_accumulation_steps=4 \ + --gradient_checkpointing \ + --mixed_precision="fp16" \ + --max_train_steps=15000 \ + --learning_rate=1e-05 \ + --max_grad_norm=1 \ + --lr_scheduler="constant" --lr_warmup_steps=0 \ + --output_dir=${OUTPUT_DIR} +``` + +학습이 완료되면 모델은 명령에 지정된 `OUTPUT_DIR`에 저장됩니다. 추론을 위해 미세 조정된 모델을 로드하려면, 해당 경로를 `StableDiffusionPipeline`으로 전달하기만 하면 됩니다: + +```python +from diffusers import StableDiffusionPipeline + +model_path = "path_to_saved_model" +pipe = StableDiffusionPipeline.from_pretrained(model_path, torch_dtype=torch.float16) +pipe.to("cuda") + +image = pipe(prompt="yoda").images[0] +image.save("yoda-pokemon.png") +``` + +### Flax / JAX 미세 조정 + +[@duongna211](https://github.com/duongna21) 덕분에 Flax를 사용하여 Stable Diffusion을 미세 조정할 수 있습니다! 이는 TPU 하드웨어에서 매우 효율적이지만 GPU에서도 훌륭하게 작동합니다. 다음과 같이 [Flax 학습 스크립트](https://github.com/huggingface/diffusers/blob/main/examples/text_to_image/train_text_to_image_flax.py)를 사용할 수 있습니다: + +```Python +export MODEL_NAME="runwayml/stable-diffusion-v1-5" +export dataset_name="lambdalabs/pokemon-blip-captions" + +python train_text_to_image_flax.py \ + --pretrained_model_name_or_path=$MODEL_NAME \ + --dataset_name=$dataset_name \ + --resolution=512 --center_crop --random_flip \ + --train_batch_size=1 \ + --max_train_steps=15000 \ + --learning_rate=1e-05 \ + --max_grad_norm=1 \ + --output_dir="sd-pokemon-model" +``` From 8991ae22ef069362be26aa8c65fe10d48a72f62d Mon Sep 17 00:00:00 2001 From: Snailpong Date: Sat, 18 Feb 2023 11:17:58 +0900 Subject: [PATCH 04/12] feat) lora kr --- docs/source/ko/training/lora.mdx | 164 +++++++++++++++++++++++++++++++ 1 file changed, 164 insertions(+) create mode 100644 docs/source/ko/training/lora.mdx diff --git a/docs/source/ko/training/lora.mdx b/docs/source/ko/training/lora.mdx new file mode 100644 index 000000000000..d65eac4b22a1 --- /dev/null +++ b/docs/source/ko/training/lora.mdx @@ -0,0 +1,164 @@ + + +# Diffusers에서의 LoRa 지원 + +Diffusers는 Stable Diffusion의 더 빠른 미세 조정을 위해 LoRA를 지원하여 더 큰 메모리 효율성과 더 쉬운 휴대성을 가지게 해줍니다. + +Large Language Models의 Low-Rank Adaption는 Microsoft에 의해 *Edward J. Hu, Yelong Shen, Phillip Wallis, Zeyuan Allen-Zhu, Yuanzhi Li, Shean Wang, Lu Wang, Weizhu Chen*에 의한[LoRA: Low-Rank Adaptation of Large Language Models](https://arxiv.org/abs/2106.09685)에서 소개되었습니다. + +간단히 말해서, LoRA는 기존 가중치에 순위 분해 가중치 행렬 쌍(**업데이트 행렬**이라고 함)을 추가하고 새로 추가된 가중치**만** 훈련함으로써 사전 훈련된 모델을 적용할 수 있습니다. 여기에는 몇 가지 장점이 있습니다. + +- 이전에 사전 훈련된 가중치는 고정된 상태로 유지되어 모델이 [치명적 망각](https://www.pnas.org/doi/10.1073/pnas.1611835114) 경향이 없습니다. +- 순위 분해 행렬은 원래 모델보다 파라메터 수가 훨씬 적으므로 훈련된 LoRA 가중치를 쉽게 이식할 수 있습니다. +- LoRA 행렬들은 일반적으로 원본 모델의 주의 레이어에 추가되며 `scale` 매개변수를 통해 모델이 새로운 학습 이미지에 적용되는 정도를 제어합니다. + +**__LoRA의 사용이 어텐션 레이어에만 국한되지 않는 점을 참고하세요. 원래 LoRA 작업에서는, 저자들은 언어 모델의 어텐션 레이어를 수정하는 것만으로도 매우 효율적으로 우수한 다운스트림 성능을 얻기에 충분하다는 것을 알아냈습니다. 이것이 LoRA 가중치를 모델의 어텐션 레이어에 추가하는 것이 일반적인 이유입니다.__** + +[cloneofsimo](https://github.com/cloneofsimo)가 인기 있는 [lora](https://github.com/cloneofsimo/lora) GitHub 리포지토리에서, Stable Diffusion에 대해 LoRA 학습을 최초로 시도했습니다. + + + +LoRA를 사용하면 사전 훈련된 가중치가 고정되고 LoRA 가중치만 학습되므로 Tesla T4, RTX 3080 또는 심지어 RTX 2080 Ti와 같은 소비자 GPU에서 미세 조정을 실행할 수 있으므로 더 큰 메모리 효율성을 달성할 수 있습니다! Kaggle Kernels 및 Google Colab Notebooks의 무료 등급에서 T4와 같은 GPU에 액세스할 수 있습니다. + + + +## 미세 조정을 위해 LoRA 시작하기 + +Stable Diffusion은 다양한 방법으로 미세 조정할 수 있습니다: + +* [Textual inversion](https://huggingface.co/docs/diffusers/main/kr/training/text_inversion) +* [DreamBooth](https://huggingface.co/docs/diffusers/main/kr/training/dreambooth) +* [Text2Image 미세 조정](https://huggingface.co/docs/diffusers/main/kr/training/text2image) + +LoRA로 미세 조정을 실행하는 방법을 보여주는 두 가지 종단 간 예시를 제공합니다: + +* [DreamBooth](https://github.com/huggingface/diffusers/tree/main/examples/dreambooth#training-with-low-rank-adaptation-of-large-language-models-lora) +* [Text2Image](https://github.com/huggingface/diffusers/tree/main/examples/text_to_image#training-with-lora) + +예를 들어 LoRA로 DreamBooth 학습을 수행하려면 다음을 실행합니다: + +```bash +export MODEL_NAME="runwayml/stable-diffusion-v1-5" +export INSTANCE_DIR="path-to-instance-images" +export OUTPUT_DIR="path-to-save-model" + +accelerate launch train_dreambooth_lora.py \ + --pretrained_model_name_or_path=$MODEL_NAME \ + --instance_data_dir=$INSTANCE_DIR \ + --output_dir=$OUTPUT_DIR \ + --instance_prompt="a photo of sks dog" \ + --resolution=512 \ + --train_batch_size=1 \ + --gradient_accumulation_steps=1 \ + --checkpointing_steps=100 \ + --learning_rate=1e-4 \ + --report_to="wandb" \ + --lr_scheduler="constant" \ + --lr_warmup_steps=0 \ + --max_train_steps=500 \ + --validation_prompt="A photo of sks dog in a bucket" \ + --validation_epochs=50 \ + --seed="0" \ + --push_to_hub +``` + +`examples/text_to_image/train_text_to_image_lora.py` 스크립트를 사용하여 커스텀 데이터셋에서 Stable Diffusion을 완전히 미세 조정하기 위해 유사한 프로세스를 따를 수 있습니다. + +자세한 내용은 위에 링크된 각 예시를 참조하십시오. + + + +LoRA를 사용할 때 LoRA가 아닌 Dreambooth 미세 조정에 비해 훨씬 더 높은 학습률(일반적으로 ~1e-6이 아닌 1e-4)을 사용할 수 있습니다. + + + +그러나 공짜 점심은 없습니다. 주어진 데이터셋과 예상되는 생성 품질에 대해 여전히 다른 하이퍼파라미터로 실험해야 합니다. 다음은 몇 가지 중요한 사항입니다: + +* 학습 시간 + * 학습률 + * 학습 step 수 +* 추론 시간 + * steps 수 + * 스케줄러 종류 + +또한 Stable Diffusion의 DreamBooth 학습을 수행하기 위한 실험 결과 문서를 [이 블로그](https://huggingface.co/blog/dreambooth)로 팔로우할 수 있습니다. + +미세 조정 시, LoRA 업데이트 행렬은 어텐션 레이어들에만 추가됩니다. 이를 활성하시키기 위해, 새로운 가중치 로딩 기능을 추가했습니다. 자세한 내용은 [여기](https://huggingface.co/docs/diffusers/main/en/api/loaders)에서 확인할 수 있습니다. + +## 추론 + +[Pokemon 데이터셋](https://huggingface.co/datasets/lambdalabs/pokemon-blip-captions)으로 Stable Diffusion을 미세 조정하기 위해 `examples/text_to_image/train_text_to_image_lora.py`를 사용할 때, 다음과 같은 추론을 수행할 수 있습니다: + +```py +from diffusers import StableDiffusionPipeline +import torch + +model_path = "sayakpaul/sd-model-finetuned-lora-t4" +pipe = StableDiffusionPipeline.from_pretrained("CompVis/stable-diffusion-v1-4", torch_dtype=torch.float16) +pipe.unet.load_attn_procs(model_path) +pipe.to("cuda") + +prompt = "A pokemon with blue eyes." +image = pipe(prompt, num_inference_steps=30, guidance_scale=7.5).images[0] +image.save("pokemon.png") +``` + +다음은 기대되는 몇 가지 예시 이미지입니다. + + + +[`sayakpaul/sd-model-finetuned-lora-t4`](https://huggingface.co/sayakpaul/sd-model-finetuned-lora-t4)에는 [LoRA 미세 조정 업데이트 행렬](https:// huggingface.co/sayakpaul/sd-model-finetuned-lora-t4/blob/main/pytorch_lora_weights.bin)을 포함하며, 이 크기는 3MB에 불과합니다. +추론하는 동안, 사전 훈련된 Stable Diffusion 체크포인트는 이러한 업데이트 행렬과 함께 로드된 다음 결합되어 추론을 실행합니다. + +[`sayakpaul/sd-model-finetuned-lora-t4`](https://huggingface.co/sayakpaul/sd-model-finetuned-lora-t4)을 차지 위해 [`huggingface_hub`](https://github.com/huggingface/huggingface_hub) 라이브러리를 다음과 같이 사용할 수 있습니다: + +```py +from huggingface_hub.repocard import RepoCard + +card = RepoCard.load("sayakpaul/sd-model-finetuned-lora-t4") +base_model = card.data.to_dict()["base_model"] +# 'CompVis/stable-diffusion-v1-4' +``` + +그리고 `pipe = StableDiffusionPipeline.from_pretrained(base_model, torch_dtype=torch.float16)`로 사용할 수 있습니다. + +이는 `StableDiffusionPipeline`을 초기화하는 동안 기본 모델 식별자를 하드코딩하지 않으려는 경우에 특히 유용합니다. + +DreamBooth 학습 결과에 대한 추론은 동일합니다. [이 섹션](https://github.com/huggingface/diffusers/tree/main/examples/dreambooth#inference-1)에서 자세한 내용을 확인하세요. + +### 원본 모델과 LoRA 합치기 + +추론을 수행할 때, 훈련된 LoRA 가중치를 고정된 사전 훈련된 모델 가중치와 병합하여 원래 모델의 추론 결과(미세 조정이 발생하지 않은 것처럼)와 완전히 미세 조정된 버전에 대해 보간할 수 있습니다. + +논문에서는 α(알파), 구현된 코드에서는 `scale`이라는 매개변수를 사용하여 병합 비율을 조정할 수 있습니다. 파이프라인 호출에서 `scale`을 `cross_attention_kwargs`로 전달하는 방식으로 코드를 작성할 수 있습니다. + +```py +from diffusers import StableDiffusionPipeline +import torch + +model_path = "sayakpaul/sd-model-finetuned-lora-t4" +pipe = StableDiffusionPipeline.from_pretrained("CompVis/stable-diffusion-v1-4", torch_dtype=torch.float16) +pipe.unet.load_attn_procs(model_path) +pipe.to("cuda") + +prompt = "A pokemon with blue eyes." +image = pipe(prompt, num_inference_steps=30, guidance_scale=7.5, cross_attention_kwargs={"scale": 0.5}).images[0] +image.save("pokemon.png") +``` + +`0`은 LoRA 가중치를 사용하지 _않는_ 것과 같고 `1`은 LoRA 미세 조정된 가중치만 사용함을 의미합니다. 0과 1 사이의 값은 두 결과들 사이로 보간됩니다. + + +## 알려진 제한들 + +* 현재 [`UNet2DConditionModel`](https://huggingface.co/docs/diffusers/main/en/api/models#diffusers.UNet2DConditionModel)의 어텐션 레이어에 대해서만 LoRA를 지원합니다. \ No newline at end of file From 20522937575178aa442de8e59870f2ab368fbdd3 Mon Sep 17 00:00:00 2001 From: Snailpong Date: Tue, 21 Mar 2023 19:40:45 +0900 Subject: [PATCH 05/12] fix) LoRA --- docs/source/ko/training/lora.mdx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/source/ko/training/lora.mdx b/docs/source/ko/training/lora.mdx index d65eac4b22a1..826635132c5c 100644 --- a/docs/source/ko/training/lora.mdx +++ b/docs/source/ko/training/lora.mdx @@ -10,7 +10,7 @@ an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express o specific language governing permissions and limitations under the License. --> -# Diffusers에서의 LoRa 지원 +# Diffusers에서의 LoRA 지원 Diffusers는 Stable Diffusion의 더 빠른 미세 조정을 위해 LoRA를 지원하여 더 큰 메모리 효율성과 더 쉬운 휴대성을 가지게 해줍니다. From c7c059e4d360caef231881831d0b191d31d602a5 Mon Sep 17 00:00:00 2001 From: Snailpong Date: Thu, 23 Mar 2023 20:43:02 +0900 Subject: [PATCH 06/12] fix) fp16 fix --- docs/source/ko/optimization/fp16.mdx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/source/ko/optimization/fp16.mdx b/docs/source/ko/optimization/fp16.mdx index a8b43ff2d77b..0e6bc9117ebe 100644 --- a/docs/source/ko/optimization/fp16.mdx +++ b/docs/source/ko/optimization/fp16.mdx @@ -22,7 +22,7 @@ specific language governing permissions and limitations under the License. | cuDNN auto-tuner | 9.37s | x1.01 | | fp16 | 3.61s | x2.63 | | 채널 마지막 형식 | 3.30s | x2.88 | -| 추적을 수행한 UNet | 3.21s | x2.96 | +| traced UNet | 3.21s | x2.96 | | 메모리 효율적인 어텐션 | 2.63s | x3.61 | From 5b447f8fb83210367ec6e1b252c6392f938a472c Mon Sep 17 00:00:00 2001 From: Snailpong Date: Thu, 23 Mar 2023 21:25:39 +0900 Subject: [PATCH 07/12] fix) doc-builder style --- docs/source/ko/optimization/fp16.mdx | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/docs/source/ko/optimization/fp16.mdx b/docs/source/ko/optimization/fp16.mdx index 0e6bc9117ebe..09697e189262 100644 --- a/docs/source/ko/optimization/fp16.mdx +++ b/docs/source/ko/optimization/fp16.mdx @@ -182,9 +182,7 @@ image = pipe(prompt).images[0] ```python print(pipe.unet.conv_out.state_dict()["weight"].stride()) # (2880, 9, 3, 1) pipe.unet.to(memory_format=torch.channels_last) # in-place 연산 -print( - pipe.unet.conv_out.state_dict()["weight"].stride() -) # 2번째 차원에서 스트라이드 1을 가지는 (2880, 1, 960, 320)로 작동함을 증명합니다. +print(pipe.unet.conv_out.state_dict()["weight"].stride()) # 2번째 차원에서 스트라이드 1을 가지는 (2880, 1, 960, 320)로 작동함을 증명합니다. ``` ## 추적 From 2cc2f411ca77c432eb5c5eaab1207b7519ec2f4b Mon Sep 17 00:00:00 2001 From: Snailpong Date: Fri, 24 Mar 2023 21:28:34 +0900 Subject: [PATCH 08/12] =?UTF-8?q?fix)=20fp16=20=EC=9D=BC=EB=B6=80=20?= =?UTF-8?q?=EB=8B=A8=EC=96=B4=20=EC=88=98=EC=A0=95?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- docs/source/ko/optimization/fp16.mdx | 126 +++++++++++++++++++++------ 1 file changed, 97 insertions(+), 29 deletions(-) diff --git a/docs/source/ko/optimization/fp16.mdx b/docs/source/ko/optimization/fp16.mdx index 09697e189262..7f1220192444 100644 --- a/docs/source/ko/optimization/fp16.mdx +++ b/docs/source/ko/optimization/fp16.mdx @@ -1,4 +1,4 @@ - -# OpenVINO +# 추론을 위한 OpenVINO 사용 방법 -작업중 🚧 +🤗 [Optimum](https://github.com/huggingface/optimum-intel)은 OpenVINO와 호환되는 Stable Diffusion 파이프라인을 제공합니다. +이제 다양한 Intel 프로세서에서 OpenVINO Runtime으로 쉽게 추론을 수행할 수 있습니다. ([여기](https://docs.openvino.ai/latest/openvino_docs_OV_UG_supported_plugins_Supported_Devices.html)서 지원되는 전 기기 목록을 확인하세요). + +## 설치 + +다음 명령어로 🤗 Optimum을 설치합니다: + +``` +pip install optimum["openvino"] +``` + +## Stable Diffusion 추론 + +OpenVINO 모델을 불러오고 OpenVINO 런타임으로 추론을 실행하려면 `StableDiffusionPipeline`을 `OVStableDiffusionPipeline`으로 교체해야 합니다. PyTorch 모델을 불러오고 즉시 OpenVINO 형식으로 변환하려는 경우 `export=True`로 설정합니다. + +```python +from optimum.intel.openvino import OVStableDiffusionPipeline + +model_id = "runwayml/stable-diffusion-v1-5" +pipe = OVStableDiffusionPipeline.from_pretrained(model_id, export=True) +prompt = "a photo of an astronaut riding a horse on mars" +images = pipe(prompt).images[0] +``` + +[Optimum 문서](https://huggingface.co/docs/optimum/intel/inference#export-and-inference-of-stable-diffusion-models)에서 (정적 reshaping과 모델 컴파일 등의) 더 많은 예시들을 찾을 수 있습니다. diff --git a/docs/source/ko/optimization/xformers.mdx b/docs/source/ko/optimization/xformers.mdx index 81aeb819734e..a8b9408fbe50 100644 --- a/docs/source/ko/optimization/xformers.mdx +++ b/docs/source/ko/optimization/xformers.mdx @@ -1,4 +1,4 @@ - -# DreamBooth 미세 조정 예시 +# DreamBooth -[DreamBooth](https://arxiv.org/abs/2208.12242)는 한 주제에 대한 적은 이미지(3~5개)만으로도 stable diffusion과 같이 text-to-image 모델을 개인화하는 방법입니다. +[DreamBooth](https://arxiv.org/abs/2208.12242)는 한 주제에 대한 적은 이미지(3~5개)만으로도 stable diffusion과 같이 text-to-image 모델을 개인화할 수 있는 방법입니다. 이를 통해 모델은 다양한 장면, 포즈 및 장면(뷰)에서 피사체에 대해 맥락화(contextualized)된 이미지를 생성할 수 있습니다. -![프로젝트 블로그로부터의 DreamBooth 예시](https://dreambooth.github.io/DreamBooth_files/teaser_static.jpg) -_[프로젝트 블로그](https://dreambooth.github.io)로부터의 DreamBooth 예시._ +![프로젝트 블로그에서의 DreamBooth 예시](https://dreambooth.github.io/DreamBooth_files/teaser_static.jpg) +project's blog. +프로젝트 블로그에서의 Dreambooth 예시 -[Dreambooth 학습 스크립트](https://github.com/huggingface/diffusers/tree/main/examples/dreambooth)는 사전 학습된 Stable Diffusion 모델에서 학습 순서를 구현하는 방법을 보여줍니다. - +이 가이드는 다양한 GPU, Flax 사양에 대해 [`CompVis/stable-diffusion-v1-4`](https://huggingface.co/CompVis/stable-diffusion-v1-4) 모델로 DreamBooth를 파인튜닝하는 방법을 보여줍니다. 더 깊이 파고들어 작동 방식을 확인하는 데 관심이 있는 경우, 이 가이드에 사용된 DreamBooth의 모든 학습 스크립트를 [여기](https://github.com/huggingface/diffusers/tree/main/examples/dreambooth)에서 찾을 수 있습니다. -Dreambooth 미세 조정은 하이퍼파라미터에 매우 민감하고 과적합되기 쉽습니다. 다양한 주제에 대한 권장 설정이 포함된 [심층 분석](https://huggingface.co/blog/dreambooth)을 살펴보고 거기서에서 시작하는 것이 좋습니다. +스크립트를 실행하기 전에 라이브러리의 학습에 필요한 dependencies를 설치해야 합니다. 또한 `main` GitHub 브랜치에서 🧨 Diffusers를 설치하는 것이 좋습니다. - +```bash +pip install git+https://github.com/huggingface/diffusers +pip install -U -r diffusers/examples/dreambooth/requirements.txt +``` -## 로컬에서 학습하기 +xFormers는 학습에 필요한 요구 사항은 아니지만, 가능하면 [설치](../optimization/xformers)하는 것이 좋습니다. 학습 속도를 높이고 메모리 사용량을 줄일 수 있기 때문입니다. -### dependency 설치하기 +모든 dependencies을 설정한 후 다음을 사용하여 [🤗 Accelerate](https://github.com/huggingface/accelerate/) 환경을 다음과 같이 초기화합니다: -스크립트를 실행하기 전에, 라이브러리의 학습 dependency들을 설치해야 합니다. 또한 `main` github 브랜치에서 `diffusers`를 설치하는 것이 좋습니다. +```bash +accelerate config +``` +별도 설정 없이 기본 🤗 Accelerate 환경을 설치하려면 다음을 실행합니다: ```bash -pip install git+https://github.com/huggingface/diffusers -pip install -U -r diffusers/examples/dreambooth/requirements.txt +accelerate config default ``` -xFormers는 학습 요구 사항의 일부는 아니지만 [가능하면 설치하는 것이 좋습니다](../optimization/xformers). 이는 훈련 속도를 높이고 메모리 집약도를 낮출 수 있습니다. +또는 현재 환경이 노트북과 같은 대화형 셸을 지원하지 않는 경우 다음을 사용할 수 있습니다: -모든 dependency가 세팅되었으면, 다음으로 [🤗 가속](https://github.com/huggingface/accelerate/) 환경을 구성할 수 있습니다: +```py +from accelerate.utils import write_basic_config -```bash -accelerate config +write_basic_config() ``` -이 예시에서는 모델 버전 `v1-4`를 사용하므로, [이 링크](https://huggingface.co/CompVis/stable-diffusion-v1-4)를 방문하여 라이선스를 주의 깊게 읽어본 후 진행하시기 바랍니다. +## 파인튜닝 -아래 명령은 모델의 허브 id `CompVis/stable-diffusion-v1-4`를 사용하기 때문에 허브에서 모델 가중치를 다운로드하고 캐시합니다. 리포지토리를 로컬로 복제하고 체크아웃이 저장된 시스템의 로컬 경로를 사용할 수도 있습니다. + -### 간단한 개 예시 +DreamBooth 파인튜닝은 하이퍼파라미터에 매우 민감하고 과적합되기 쉽습니다. 적절한 하이퍼파라미터를 선택하는 데 도움이 되도록 다양한 권장 설정이 포함된 [심층 분석](https://huggingface.co/blog/dreambooth)을 살펴보는 것이 좋습니다. -이 예시에서는 [이 이미지들](https://drive.google.com/drive/folders/1BO_dyz-p65qhBRRMRA4TbZ8qW4rB99JZ)를 사용하여 Dreambooth 프로세스를 사용하여 Stable Diffusion에 새로운 개념을 추가합니다. 그것들은 우리의 훈련 데이터가 될 것입니다. 다운로드하여 시스템 어딘가에 배치하십시오. + + + + +[몇 장의 강아지 이미지들](https://drive.google.com/drive/folders/1BO_dyz-p65qhBRRMRA4TbZ8qW4rB99JZ)로 DreamBooth를 시도해봅시다. +이를 다운로드해 디렉터리에 저장한 다음 `INSTANCE_DIR` 환경 변수를 해당 경로로 설정합니다: -그런 다음 다음을 사용하여 학습 스크립트를 시작할 수 있습니다: ```bash export MODEL_NAME="CompVis/stable-diffusion-v1-4" export INSTANCE_DIR="path_to_training_images" export OUTPUT_DIR="path_to_saved_model" +``` +그런 다음, 다음 명령을 사용하여 학습 스크립트를 실행할 수 있습니다 (전체 학습 스크립트는 [여기](https://github.com/huggingface/diffusers/blob/main/examples/dreambooth/train_dreambooth.py)에서 찾을 수 있습니다): + +```bash accelerate launch train_dreambooth.py \ --pretrained_model_name_or_path=$MODEL_NAME \ --instance_data_dir=$INSTANCE_DIR \ @@ -73,13 +86,45 @@ accelerate launch train_dreambooth.py \ --lr_warmup_steps=0 \ --max_train_steps=400 ``` + + -### 사전 보존 손실을 사용한 학습 +TPU에 액세스할 수 있거나 더 빠르게 훈련하고 싶다면 [Flax 학습 스크립트](https://github.com/huggingface/diffusers/blob/main/examples/dreambooth/train_dreambooth_flax.py)를 사용해 볼 수 있습니다. Flax 학습 스크립트는 gradient checkpointing 또는 gradient accumulation을 지원하지 않으므로, 메모리가 30GB 이상인 GPU가 필요합니다. -과적합과 language drift를 방지하기 위해 사전 보존이 사용됩니다. 관심이 있는 경우 자세한 내용은 논문를 참조하십시오. 사전 보존을 위해 동일한 클래스의 다른 이미지를 교육 프로세스의 일부로 사용합니다. 좋은 점은 Stable Diffusion 모델 자체를 사용하여 이러한 이미지를 생성할 수 있다는 것입니다! 학습 스크립트는 생성된 이미지를 우리가 지정한 로컬 경로에 저장합니다. +스크립트를 실행하기 전에 요구 사항이 설치되어 있는지 확인하십시오. -논문에 따르면, 사전 보존을 위해 `num_epochs * num_samples`개의 이미지를 생성하는 것이 좋습니다. 200-300개에서 대부분 잘 작동합니다. +```bash +pip install -U -r requirements.txt +``` + +그러면 다음 명령어로 학습 스크립트를 실행시킬 수 있습니다: +```bash +export MODEL_NAME="duongna/stable-diffusion-v1-4-flax" +export INSTANCE_DIR="path-to-instance-images" +export OUTPUT_DIR="path-to-save-model" + +python train_dreambooth_flax.py \ + --pretrained_model_name_or_path=$MODEL_NAME \ + --instance_data_dir=$INSTANCE_DIR \ + --output_dir=$OUTPUT_DIR \ + --instance_prompt="a photo of sks dog" \ + --resolution=512 \ + --train_batch_size=1 \ + --learning_rate=5e-6 \ + --max_train_steps=400 +``` + + + +### Prior-preserving(사전 보존) loss를 사용한 파인튜닝 + +과적합과 language drift를 방지하기 위해 사전 보존이 사용됩니다(관심이 있는 경우 [논문](https://arxiv.org/abs/2208.12242)을 참조하세요). 사전 보존을 위해 동일한 클래스의 다른 이미지를 학습 프로세스의 일부로 사용합니다. 좋은 점은 Stable Diffusion 모델 자체를 사용하여 이러한 이미지를 생성할 수 있다는 것입니다! 학습 스크립트는 생성된 이미지를 우리가 지정한 로컬 경로에 저장합니다. + +저자들에 따르면 사전 보존을 위해 `num_epochs * num_samples`개의 이미지를 생성하는 것이 좋습니다. 200-300개에서 대부분 잘 작동합니다. + + + ```bash export MODEL_NAME="CompVis/stable-diffusion-v1-4" export INSTANCE_DIR="path_to_training_images" @@ -103,16 +148,109 @@ accelerate launch train_dreambooth.py \ --num_class_images=200 \ --max_train_steps=800 ``` + + +```bash +export MODEL_NAME="duongna/stable-diffusion-v1-4-flax" +export INSTANCE_DIR="path-to-instance-images" +export CLASS_DIR="path-to-class-images" +export OUTPUT_DIR="path-to-save-model" + +python train_dreambooth_flax.py \ + --pretrained_model_name_or_path=$MODEL_NAME \ + --instance_data_dir=$INSTANCE_DIR \ + --class_data_dir=$CLASS_DIR \ + --output_dir=$OUTPUT_DIR \ + --with_prior_preservation --prior_loss_weight=1.0 \ + --instance_prompt="a photo of sks dog" \ + --class_prompt="a photo of dog" \ + --resolution=512 \ + --train_batch_size=1 \ + --learning_rate=5e-6 \ + --num_class_images=200 \ + --max_train_steps=800 +``` + + + +## 텍스트 인코더와 and UNet로 파인튜닝하기 + +해당 스크립트를 사용하면 `unet`과 함께 `text_encoder`를 파인튜닝할 수 있습니다. 실험에서(자세한 내용은 [🧨 Diffusers를 사용해 DreamBooth로 Stable Diffusion 학습하기](https://huggingface.co/blog/dreambooth) 게시물을 확인하세요), 특히 얼굴 이미지를 생성할 때 훨씬 더 나은 결과를 얻을 수 있습니다. + + + +텍스트 인코더를 학습시키려면 추가 메모리가 필요해 16GB GPU로는 동작하지 않습니다. 이 옵션을 사용하려면 최소 24GB VRAM이 필요합니다. + + + +`--train_text_encoder` 인수를 학습 스크립트에 전달하여 `text_encoder` 및 `unet`을 파인튜닝할 수 있습니다: + + + +```bash +export MODEL_NAME="CompVis/stable-diffusion-v1-4" +export INSTANCE_DIR="path_to_training_images" +export CLASS_DIR="path_to_class_images" +export OUTPUT_DIR="path_to_saved_model" + +accelerate launch train_dreambooth.py \ + --pretrained_model_name_or_path=$MODEL_NAME \ + --train_text_encoder \ + --instance_data_dir=$INSTANCE_DIR \ + --class_data_dir=$CLASS_DIR \ + --output_dir=$OUTPUT_DIR \ + --with_prior_preservation --prior_loss_weight=1.0 \ + --instance_prompt="a photo of sks dog" \ + --class_prompt="a photo of dog" \ + --resolution=512 \ + --train_batch_size=1 \ + --use_8bit_adam + --gradient_checkpointing \ + --learning_rate=2e-6 \ + --lr_scheduler="constant" \ + --lr_warmup_steps=0 \ + --num_class_images=200 \ + --max_train_steps=800 +``` + + +```bash +export MODEL_NAME="duongna/stable-diffusion-v1-4-flax" +export INSTANCE_DIR="path-to-instance-images" +export CLASS_DIR="path-to-class-images" +export OUTPUT_DIR="path-to-save-model" + +python train_dreambooth_flax.py \ + --pretrained_model_name_or_path=$MODEL_NAME \ + --train_text_encoder \ + --instance_data_dir=$INSTANCE_DIR \ + --class_data_dir=$CLASS_DIR \ + --output_dir=$OUTPUT_DIR \ + --with_prior_preservation --prior_loss_weight=1.0 \ + --instance_prompt="a photo of sks dog" \ + --class_prompt="a photo of dog" \ + --resolution=512 \ + --train_batch_size=1 \ + --learning_rate=2e-6 \ + --num_class_images=200 \ + --max_train_steps=800 +``` + + + +## LoRA로 파인튜닝하기 + +DreamBooth에서 대규모 모델의 학습을 가속화하기 위한 파인튜닝 기술인 LoRA(Low-Rank Adaptation of Large Language Models)를 사용할 수 있습니다. 자세한 내용은 [LoRA 학습](training/lora#dreambooth) 가이드를 참조하세요. ### 학습 중 체크포인트 저장하기 -Dreambooth로 훈련하는 동안 과적합하기 쉬우므로, 때때로 프로세스 중에 정기적인 체크포인트를 저장하는 것이 유용합니다. 중간 체크포인트 중 하나가 최종 모델보다 더 잘 작동할 수 있습니다! 이 기능을 사용하려면 학습 스크립트에 다음 인수를 전달해야 합니다: +Dreambooth로 훈련하는 동안 과적합하기 쉬우므로, 때때로 학습 중에 정기적인 체크포인트를 저장하는 것이 유용합니다. 중간 체크포인트 중 하나가 최종 모델보다 더 잘 작동할 수 있습니다! 체크포인트 저장 기능을 활성화하려면 학습 스크립트에 다음 인수를 전달해야 합니다: ```bash --checkpointing_steps=500 ``` -이렇게 하면 `output_dir`의 하위 폴더에 전체 학습 상태가 저장됩니다. 하위 폴더 이름은 접두사 `checkpoint-`로 시작하고 지금까지 수행된 step 수입니다. 예: `checkpoint-1500`은 1500 학습 step 후에 저장된 체크포인트입니다. +이렇게 하면 `output_dir`의 하위 폴더에 전체 학습 상태가 저장됩니다. 하위 폴더 이름은 접두사 `checkpoint-`로 시작하고 지금까지 수행된 step 수입니다. 예시로 `checkpoint-1500`은 1500 학습 step 후에 저장된 체크포인트입니다. #### 저장된 체크포인트에서 훈련 재개하기 @@ -122,19 +260,41 @@ Dreambooth로 훈련하는 동안 과적합하기 쉬우므로, 때때로 프로 --resume_from_checkpoint="checkpoint-1500" ``` -원하는 경우 일부 하이퍼파라미터를 조정할 수 있는 좋은 기회일 수 있습니다. +원하는 경우 일부 하이퍼파라미터를 조정할 수 있습니다. #### 저장된 체크포인트를 사용하여 추론 수행하기 저장된 체크포인트는 훈련 재개에 적합한 형식으로 저장됩니다. 여기에는 모델 가중치뿐만 아니라 옵티마이저, 데이터 로더 및 학습률의 상태도 포함됩니다. -추론을 위해 체크포인트를 사용할 수 있지만, 먼저 이를 추론 파이프라인으로 변환해야 합니다. 이는 다음과 같이 할 수 있습니다: +**`"accelerate>=0.16.0"`**이 설치된 경우 다음 코드를 사용하여 중간 체크포인트에서 추론을 실행합니다. + +```python +from diffusers import DiffusionPipeline, UNet2DConditionModel +from transformers import CLIPTextModel +import torch + +# 학습에 사용된 것과 동일한 인수(model, revision)로 파이프라인을 로드합니다. +model_id = "CompVis/stable-diffusion-v1-4" + +unet = UNet2DConditionModel.from_pretrained("/sddata/dreambooth/daruma-v2-1/checkpoint-100/unet") + +# `args.train_text_encoder`로 학습한 경우면 텍스트 인코더를 꼭 불러오세요 +text_encoder = CLIPTextModel.from_pretrained("/sddata/dreambooth/daruma-v2-1/checkpoint-100/text_encoder") + +pipeline = DiffusionPipeline.from_pretrained(model_id, unet=unet, text_encoder=text_encoder, dtype=torch.float16) +pipeline.to("cuda") + +# 추론을 수행하거나 저장하거나, 허브에 푸시합니다. +pipeline.save_pretrained("dreambooth-pipeline") +``` + +If you have **`"accelerate<0.16.0"`** installed, you need to convert it to an inference pipeline first: ```python from accelerate import Accelerator from diffusers import DiffusionPipeline -# 학습에 사용된 것과 동일한 인수(모델, 개정)로 파이프라인을 로드합니다. +# 학습에 사용된 것과 동일한 인수(model, revision)로 파이프라인을 로드합니다. model_id = "CompVis/stable-diffusion-v1-4" pipeline = DiffusionPipeline.from_pretrained(model_id) @@ -157,15 +317,37 @@ pipeline = DiffusionPipeline.from_pretrained( pipeline.save_pretrained("dreambooth-pipeline") ``` -### 16GB GPU에서 훈련하기 +## 각 GPU 용량에서의 최적화 -Gradient checkpointing과 [bitsandbytes](https://github.com/TimDettmers/bitsandbytes)의 8비트 옵티마이저의 도움으로, 16GB GPU에서 dreambooth를 훈련할 수 있습니다. +하드웨어에 따라 16GB에서 8GB까지 GPU에서 DreamBooth를 최적화하는 몇 가지 방법이 있습니다! + +### xFormers + +[xFormers](https://github.com/facebookresearch/xformers)는 Transformers를 최적화하기 위한 toolbox이며, 🧨 Diffusers에서 사용되는[memory-efficient attention](https://facebookresearch.github.io/xformers/components/ops.html#module-xformers.ops) 메커니즘을 포함하고 있습니다. [xFormers를 설치](./optimization/xformers)한 다음 학습 스크립트에 다음 인수를 추가합니다: + +```bash + --enable_xformers_memory_efficient_attention +``` + +xFormers는 Flax에서 사용할 수 없습니다. + +### 그래디언트 없음으로 설정 + +메모리 사용량을 줄일 수 있는 또 다른 방법은 [기울기 설정](https://pytorch.org/docs/stable/generated/torch.optim.Optimizer.zero_grad.html)을 0 대신 `None`으로 하는 것입니다. 그러나 이로 인해 특정 동작이 변경될 수 있으므로 문제가 발생하면 이 인수를 제거해 보십시오. 학습 스크립트에 다음 인수를 추가하여 그래디언트를 `None`으로 설정합니다. + +```bash + --set_grads_to_none +``` + +### 16GB GPU + +Gradient checkpointing과 [bitsandbytes](https://github.com/TimDettmers/bitsandbytes)의 8비트 옵티마이저의 도움으로, 16GB GPU에서 dreambooth를 훈련할 수 있습니다. bitsandbytes가 설치되어 있는지 확인하세요: ```bash pip install bitsandbytes ``` -그 다음, 학습 스크립트에 `--use_8bit_adam` 옵션을 명시합니다. +그 다음, 학습 스크립트에 `--use_8bit_adam` 옵션을 명시합니다: ```bash export MODEL_NAME="CompVis/stable-diffusion-v1-4" @@ -192,25 +374,18 @@ accelerate launch train_dreambooth.py \ --max_train_steps=800 ``` -### UNet뿐만 아니라 텍스트 인코더 미세 조정 - -이 스크립트는 또한 `unet`과 함께 `text_encoder`를 미세 조정할 수 있습니다. 이것은 특히 얼굴에서 훨씬 더 나은 결과를 제공한다는 것이 실험적으로 관찰되었습니다. 자세한 내용은 [블로그](https://huggingface.co/blog/dreambooth)를 참조하세요. +### 12GB GPU -이 옵션을 활성화하려면, 학습 스크립트에 `--train_text_encoder` 인수를 전달하세요. - - -텍스트 인코더를 학습하려면 추가 메모리가 필요하므로, 학습에 16GB GPU에 적합하지 않습니다. 이 옵션을 사용하려면 최소 24GB VRAM이 필요합니다. - +12GB GPU에서 DreamBooth를 실행하려면 gradient checkpointing, 8비트 옵티마이저, xFormers를 활성화하고 그래디언트를 `None`으로 설정해야 합니다. ```bash export MODEL_NAME="CompVis/stable-diffusion-v1-4" -export INSTANCE_DIR="path_to_training_images" -export CLASS_DIR="path_to_class_images" -export OUTPUT_DIR="path_to_saved_model" +export INSTANCE_DIR="path-to-instance-images" +export CLASS_DIR="path-to-class-images" +export OUTPUT_DIR="path-to-save-model" accelerate launch train_dreambooth.py \ --pretrained_model_name_or_path=$MODEL_NAME \ - --train_text_encoder \ --instance_data_dir=$INSTANCE_DIR \ --class_data_dir=$CLASS_DIR \ --output_dir=$OUTPUT_DIR \ @@ -219,8 +394,10 @@ accelerate launch train_dreambooth.py \ --class_prompt="a photo of dog" \ --resolution=512 \ --train_batch_size=1 \ - --use_8bit_adam - --gradient_checkpointing \ + --gradient_accumulation_steps=1 --gradient_checkpointing \ + --use_8bit_adam \ + --enable_xformers_memory_efficient_attention \ + --set_grads_to_none \ --learning_rate=2e-6 \ --lr_scheduler="constant" \ --lr_warmup_steps=0 \ @@ -230,11 +407,25 @@ accelerate launch train_dreambooth.py \ ### 8GB GPU에서 학습하기 -[DeepSpeed](https://www.deepspeed.ai/)를 사용하면 일부 텐서를 VRAM에서 CPU 또는 NVME로 오프로드하여 더 적은 GPU 메모리로 학습할 수도 있습니다. +8GB GPU에 대해서는 [DeepSpeed](https://www.deepspeed.ai/)를 사용해 일부 텐서를 VRAM에서 CPU 또는 NVME로 오프로드하여 더 적은 GPU 메모리로 학습할 수도 있습니다. + +🤗 Accelerate 환경을 구성하려면 다음 명령을 실행하세요: -DeepSpeed는 `accelerate config`로 활성화할 수 있습니다. 구성하는 동안, "DeepSpeed를 사용하시겠습니까?"에 예라고 대답하세요. DeepSpeed 2단계, fp16 혼합 정밀도를 결합하고 모델 매개변수와 옵티마이저 상태를 모두 CPU로 오프로드하면 8GB VRAM 미만에서 학습할 수 있습니다. 단점은 더 많은 시스템 RAM(약 25GB)이 필요하다는 것입니다. 추가 구성 옵션은 [DeepSpeed 문서](https://huggingface.co/docs/accelerate/usage_guides/deepspeed)를 참조하세요. +```bash +accelerate config +``` -기본 Adam 옵티마이저를 DeepSpeed의 특수 버전인 Adam `deepspeed.ops.adam.DeepSpeedCPUAdam`으로 변경하면 속도가 상당히 향상되지만, 활성화하려면 시스템의 CUDA 도구 체인 버전이 PyTorch로 설치된 것과 동일해야 합니다. 8비트 옵티마이저는 현재 DeepSpeed와 호환되지 않는 것 같습니다. +환경 구성 중에 DeepSpeed를 사용할 것을 확인하세요. +그러면 DeepSpeed stage 2, fp16 혼합 정밀도를 결합하고 모델 매개변수와 옵티마이저 상태를 모두 CPU로 오프로드하면 8GB VRAM 미만에서 학습할 수 있습니다. +단점은 더 많은 시스템 RAM(약 25GB)이 필요하다는 것입니다. 추가 구성 옵션은 [DeepSpeed 문서](https://huggingface.co/docs/accelerate/usage_guides/deepspeed)를 참조하세요. + +또한 기본 Adam 옵티마이저를 DeepSpeed의 최적화된 Adam 버전으로 변경해야 합니다. +이는 상당한 속도 향상을 위한 Adam인 [`deepspeed.ops.adam.DeepSpeedCPUAdam`](https://deepspeed.readthedocs.io/en/latest/optimizers.html#adam-cpu)입니다. +`DeepSpeedCPUAdam`을 활성화하려면 시스템의 CUDA toolchain 버전이 PyTorch와 함께 설치된 것과 동일해야 합니다. + +8비트 옵티마이저는 현재 DeepSpeed와 호환되지 않는 것 같습니다. + +다음 명령으로 학습을 시작합니다: ```bash export MODEL_NAME="CompVis/stable-diffusion-v1-4" @@ -264,7 +455,9 @@ accelerate launch train_dreambooth.py \ ## 추론 -모델을 학습한 후에는, 모델이 저장된 경로를 표시하기만 하면 `StableDiffusionPipeline`을 사용하여 추론을 수행할 수 있습니다. 프롬프트에 학습에 사용된 특수 `식별자`(이전 예시의 `sks`)가 포함되어 있는지 확인하세요. +모델을 학습한 후에는, 모델이 저장된 경로를 지정해 [`StableDiffusionPipeline`]로 추론을 수행할 수 있습니다. 프롬프트에 학습에 사용된 특수 `식별자`(이전 예시의 `sks`)가 포함되어 있는지 확인하세요. + +**`"accelerate>=0.16.0"`**이 설치되어 있는 경우 다음 코드를 사용하여 중간 체크포인트에서 추론을 실행할 수 있습니다: ```python from diffusers import StableDiffusionPipeline @@ -279,4 +472,4 @@ image = pipe(prompt, num_inference_steps=50, guidance_scale=7.5).images[0] image.save("dog-bucket.png") ``` -[저장된 학습 체크포인트](#performing-inference-using-a-saved-checkpoint)에서도 추론을 실행할 수도 있습니다. \ No newline at end of file +[저장된 학습 체크포인트](#inference-from-a-saved-checkpoint)에서도 추론을 실행할 수도 있습니다. \ No newline at end of file diff --git a/docs/source/ko/training/lora.mdx b/docs/source/ko/training/lora.mdx index 826635132c5c..9aebb0fa3109 100644 --- a/docs/source/ko/training/lora.mdx +++ b/docs/source/ko/training/lora.mdx @@ -10,48 +10,65 @@ an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express o specific language governing permissions and limitations under the License. --> -# Diffusers에서의 LoRA 지원 +# Low-Rank Adaptation of Large Language Models (LoRA) -Diffusers는 Stable Diffusion의 더 빠른 미세 조정을 위해 LoRA를 지원하여 더 큰 메모리 효율성과 더 쉬운 휴대성을 가지게 해줍니다. +[[open-in-colab]] -Large Language Models의 Low-Rank Adaption는 Microsoft에 의해 *Edward J. Hu, Yelong Shen, Phillip Wallis, Zeyuan Allen-Zhu, Yuanzhi Li, Shean Wang, Lu Wang, Weizhu Chen*에 의한[LoRA: Low-Rank Adaptation of Large Language Models](https://arxiv.org/abs/2106.09685)에서 소개되었습니다. + -간단히 말해서, LoRA는 기존 가중치에 순위 분해 가중치 행렬 쌍(**업데이트 행렬**이라고 함)을 추가하고 새로 추가된 가중치**만** 훈련함으로써 사전 훈련된 모델을 적용할 수 있습니다. 여기에는 몇 가지 장점이 있습니다. +현재 LoRA는 [`UNet2DConditionalModel`]의 어텐션 레이어에서만 지원됩니다. -- 이전에 사전 훈련된 가중치는 고정된 상태로 유지되어 모델이 [치명적 망각](https://www.pnas.org/doi/10.1073/pnas.1611835114) 경향이 없습니다. -- 순위 분해 행렬은 원래 모델보다 파라메터 수가 훨씬 적으므로 훈련된 LoRA 가중치를 쉽게 이식할 수 있습니다. -- LoRA 행렬들은 일반적으로 원본 모델의 주의 레이어에 추가되며 `scale` 매개변수를 통해 모델이 새로운 학습 이미지에 적용되는 정도를 제어합니다. + + +[LoRA(Low-Rank Adaptation of Large Language Models)](https://arxiv.org/abs/2106.09685)는 메모리를 적게 사용하면서 대규모 모델의 학습을 가속화하는 학습 방법입니다. 이는 rank-decomposition weight 행렬 쌍(**업데이트 행렬**이라고 함)을 추가하고 새로 추가된 가중치**만** 학습합니다. 여기에는 몇 가지 장점이 있습니다. -**__LoRA의 사용이 어텐션 레이어에만 국한되지 않는 점을 참고하세요. 원래 LoRA 작업에서는, 저자들은 언어 모델의 어텐션 레이어를 수정하는 것만으로도 매우 효율적으로 우수한 다운스트림 성능을 얻기에 충분하다는 것을 알아냈습니다. 이것이 LoRA 가중치를 모델의 어텐션 레이어에 추가하는 것이 일반적인 이유입니다.__** +- 이전에 미리 학습된 가중치는 고정된 상태로 유지되므로 모델이 [치명적인 망각](https://www.pnas.org/doi/10.1073/pnas.1611835114) 경향이 없습니다. +- Rank-decomposition 행렬은 원래 모델보다 파라메터 수가 훨씬 적으므로 학습된 LoRA 가중치를 쉽게 끼워넣을 수 있습니다. +- LoRA 매트릭스는 일반적으로 원본 모델의 어텐션 레이어에 추가됩니다. 🧨 Diffusers는 [`~diffusers.loaders.UNet2DConditionLoadersMixin.load_attn_procs`] 메서드를 제공하여 LoRA 가중치를 모델의 어텐션 레이어로 불러옵니다. `scale` 매개변수를 통해 모델이 새로운 학습 이미지에 맞게 조정되는 범위를 제어할 수 있습니다. +- 메모리 효율성이 향상되어 Tesla T4, RTX 3080 또는 RTX 2080 Ti와 같은 소비자용 GPU에서 파인튜닝을 실행할 수 있습니다! T4와 같은 GPU는 무료이며 Kaggle 또는 Google Colab 노트북에서 쉽게 액세스할 수 있습니다. -[cloneofsimo](https://github.com/cloneofsimo)가 인기 있는 [lora](https://github.com/cloneofsimo/lora) GitHub 리포지토리에서, Stable Diffusion에 대해 LoRA 학습을 최초로 시도했습니다. -LoRA를 사용하면 사전 훈련된 가중치가 고정되고 LoRA 가중치만 학습되므로 Tesla T4, RTX 3080 또는 심지어 RTX 2080 Ti와 같은 소비자 GPU에서 미세 조정을 실행할 수 있으므로 더 큰 메모리 효율성을 달성할 수 있습니다! Kaggle Kernels 및 Google Colab Notebooks의 무료 등급에서 T4와 같은 GPU에 액세스할 수 있습니다. +💡 LoRA는 어텐션 레이어에만 한정되지는 않습니다. 저자는 언어 모델의 어텐션 레이어를 수정하는 것이 매우 효율적으로 죻은 성능을 얻기에 충분하다는 것을 발견했습니다. 이것이 LoRA 가중치를 모델의 어텐션 레이어에 추가하는 것이 일반적인 이유입니다. LoRA 작동 방식에 대한 자세한 내용은 [Using LoRA for effective Stable Diffusion fine-tuning](https://huggingface.co/blog/lora) 블로그를 확인하세요! -## 미세 조정을 위해 LoRA 시작하기 +[cloneofsimo](https://github.com/cloneofsimo)는 인기 있는 [lora](https://github.com/cloneofsimo/lora) GitHub 리포지토리에서 Stable Diffusion을 위한 LoRA 학습을 최초로 시도했습니다. 🧨 Diffusers는 [text-to-image 생성](https://github.com/huggingface/diffusers/tree/main/examples/text_to_image#training-with-lora) 및 [DreamBooth](https://github.com/huggingface/diffusers/tree/main/examples/dreambooth#training-with-low-rank-adaptation-of-large-language-models-lora)을 지원합니다. 이 가이드는 두 가지를 모두 수행하는 방법을 보여줍니다. + +모델을 저장하거나 커뮤니티와 공유하려면 Hugging Face 계정에 로그인하세요(아직 계정이 없는 경우 [생성](hf.co/join)하세요): + +```bash +huggingface-cli login +``` -Stable Diffusion은 다양한 방법으로 미세 조정할 수 있습니다: +## Text-to-image -* [Textual inversion](https://huggingface.co/docs/diffusers/main/kr/training/text_inversion) -* [DreamBooth](https://huggingface.co/docs/diffusers/main/kr/training/dreambooth) -* [Text2Image 미세 조정](https://huggingface.co/docs/diffusers/main/kr/training/text2image) +수십억 개의 파라메터들이 있는 Stable Diffusion과 같은 모델을 파인튜닝하는 것은 느리고 어려울 수 있습니다. LoRA를 사용하면 diffusion 모델을 파인튜닝하는 것이 훨씬 쉽고 빠릅니다. 8비트 옵티마이저와 같은 트릭에 의존하지 않고도 11GB의 GPU RAM으로 하드웨어에서 실행할 수 있습니다. -LoRA로 미세 조정을 실행하는 방법을 보여주는 두 가지 종단 간 예시를 제공합니다: -* [DreamBooth](https://github.com/huggingface/diffusers/tree/main/examples/dreambooth#training-with-low-rank-adaptation-of-large-language-models-lora) -* [Text2Image](https://github.com/huggingface/diffusers/tree/main/examples/text_to_image#training-with-lora) +### 학습 [[text-to-image 학습]] -예를 들어 LoRA로 DreamBooth 학습을 수행하려면 다음을 실행합니다: +[Pokémon BLIP 캡션](https://huggingface.co/datasets/lambdalabs/pokemon-blip-captions) 데이터셋으로 [`stable-diffusion-v1-5`](https://huggingface.co/runwayml/stable-diffusion-v1-5)를 파인튜닝해 나만의 포켓몬을 생성해 보겠습니다. + +시작하려면 `MODEL_NAME` 및 `DATASET_NAME` 환경 변수가 설정되어 있는지 확인하십시오. `OUTPUT_DIR` 및 `HUB_MODEL_ID` 변수는 선택 사항이며 허브에서 모델을 저장할 위치를 지정합니다. ```bash export MODEL_NAME="runwayml/stable-diffusion-v1-5" -export INSTANCE_DIR="path-to-instance-images" -export OUTPUT_DIR="path-to-save-model" +export OUTPUT_DIR="/sddata/finetune/lora/pokemon" +export HUB_MODEL_ID="pokemon-lora" +export DATASET_NAME="lambdalabs/pokemon-blip-captions" +``` + +학습을 시작하기 전에 알아야 할 몇 가지 플래그가 있습니다. + +* `--push_to_hub`를 명시하면 학습된 LoRA 임베딩을 허브에 저장합니다. +* `--report_to=wandb`는 학습 결과를 가중치 및 편향 대시보드에 보고하고 기록합니다(예를 들어, 이 [보고서](https://wandb.ai/pcuenq/text2image-fine-tune/run/b4k1w0tn?workspace=user-pcuenq)를 참조하세요). +* `--learning_rate=1e-04`, 일반적으로 LoRA에서 사용하는 것보다 더 높은 학습률을 사용할 수 있습니다. + +이제 학습을 시작할 준비가 되었습니다 (전체 학습 스크립트는 [여기](https://github.com/huggingface/diffusers/blob/main/examples/text_to_image/train_text_to_image_lora.py)에서 찾을 수 있습니다). +```bash accelerate launch train_dreambooth_lora.py \ --pretrained_model_name_or_path=$MODEL_NAME \ --instance_data_dir=$INSTANCE_DIR \ @@ -72,93 +89,40 @@ accelerate launch train_dreambooth_lora.py \ --push_to_hub ``` -`examples/text_to_image/train_text_to_image_lora.py` 스크립트를 사용하여 커스텀 데이터셋에서 Stable Diffusion을 완전히 미세 조정하기 위해 유사한 프로세스를 따를 수 있습니다. - -자세한 내용은 위에 링크된 각 예시를 참조하십시오. - - - -LoRA를 사용할 때 LoRA가 아닌 Dreambooth 미세 조정에 비해 훨씬 더 높은 학습률(일반적으로 ~1e-6이 아닌 1e-4)을 사용할 수 있습니다. - - - -그러나 공짜 점심은 없습니다. 주어진 데이터셋과 예상되는 생성 품질에 대해 여전히 다른 하이퍼파라미터로 실험해야 합니다. 다음은 몇 가지 중요한 사항입니다: - -* 학습 시간 - * 학습률 - * 학습 step 수 -* 추론 시간 - * steps 수 - * 스케줄러 종류 - -또한 Stable Diffusion의 DreamBooth 학습을 수행하기 위한 실험 결과 문서를 [이 블로그](https://huggingface.co/blog/dreambooth)로 팔로우할 수 있습니다. +### 추론 [[dreambooth 추론]] -미세 조정 시, LoRA 업데이트 행렬은 어텐션 레이어들에만 추가됩니다. 이를 활성하시키기 위해, 새로운 가중치 로딩 기능을 추가했습니다. 자세한 내용은 [여기](https://huggingface.co/docs/diffusers/main/en/api/loaders)에서 확인할 수 있습니다. +이제 [`StableDiffusionPipeline`]에서 기본 모델을 불러와 추론을 위해 모델을 사용할 수 있습니다: -## 추론 - -[Pokemon 데이터셋](https://huggingface.co/datasets/lambdalabs/pokemon-blip-captions)으로 Stable Diffusion을 미세 조정하기 위해 `examples/text_to_image/train_text_to_image_lora.py`를 사용할 때, 다음과 같은 추론을 수행할 수 있습니다: - -```py -from diffusers import StableDiffusionPipeline -import torch +```py +>>> import torch +>>> from diffusers import StableDiffusionPipeline -model_path = "sayakpaul/sd-model-finetuned-lora-t4" -pipe = StableDiffusionPipeline.from_pretrained("CompVis/stable-diffusion-v1-4", torch_dtype=torch.float16) -pipe.unet.load_attn_procs(model_path) -pipe.to("cuda") +>>> model_base = "runwayml/stable-diffusion-v1-5" -prompt = "A pokemon with blue eyes." -image = pipe(prompt, num_inference_steps=30, guidance_scale=7.5).images[0] -image.save("pokemon.png") +>>> pipe = StableDiffusionPipeline.from_pretrained(model_base, torch_dtype=torch.float16) ``` -다음은 기대되는 몇 가지 예시 이미지입니다. +*기본 모델의 가중치 위에* 파인튜닝된 DreamBooth 모델에서 LoRA 가중치를 로드한 다음, 더 빠른 추론을 위해 파이프라인을 GPU로 이동합니다. LoRA 가중치를 프리징된 사전 훈련된 모델 가중치와 병합할 때, 선택적으로 'scale' 매개변수로 어느 정도의 가중치를 병합할 지 조절할 수 있습니다: - + -[`sayakpaul/sd-model-finetuned-lora-t4`](https://huggingface.co/sayakpaul/sd-model-finetuned-lora-t4)에는 [LoRA 미세 조정 업데이트 행렬](https:// huggingface.co/sayakpaul/sd-model-finetuned-lora-t4/blob/main/pytorch_lora_weights.bin)을 포함하며, 이 크기는 3MB에 불과합니다. -추론하는 동안, 사전 훈련된 Stable Diffusion 체크포인트는 이러한 업데이트 행렬과 함께 로드된 다음 결합되어 추론을 실행합니다. +💡 `0`의 `scale` 값은 LoRA 가중치를 사용하지 않아 원래 모델의 가중치만 사용한 것과 같고, `1`의 `scale` 값은 파인튜닝된 LoRA 가중치만 사용함을 의미합니다. 0과 1 사이의 값들은 두 결과들 사이로 보간됩니다. -[`sayakpaul/sd-model-finetuned-lora-t4`](https://huggingface.co/sayakpaul/sd-model-finetuned-lora-t4)을 차지 위해 [`huggingface_hub`](https://github.com/huggingface/huggingface_hub) 라이브러리를 다음과 같이 사용할 수 있습니다: + ```py -from huggingface_hub.repocard import RepoCard - -card = RepoCard.load("sayakpaul/sd-model-finetuned-lora-t4") -base_model = card.data.to_dict()["base_model"] -# 'CompVis/stable-diffusion-v1-4' -``` - -그리고 `pipe = StableDiffusionPipeline.from_pretrained(base_model, torch_dtype=torch.float16)`로 사용할 수 있습니다. - -이는 `StableDiffusionPipeline`을 초기화하는 동안 기본 모델 식별자를 하드코딩하지 않으려는 경우에 특히 유용합니다. - -DreamBooth 학습 결과에 대한 추론은 동일합니다. [이 섹션](https://github.com/huggingface/diffusers/tree/main/examples/dreambooth#inference-1)에서 자세한 내용을 확인하세요. - -### 원본 모델과 LoRA 합치기 - -추론을 수행할 때, 훈련된 LoRA 가중치를 고정된 사전 훈련된 모델 가중치와 병합하여 원래 모델의 추론 결과(미세 조정이 발생하지 않은 것처럼)와 완전히 미세 조정된 버전에 대해 보간할 수 있습니다. - -논문에서는 α(알파), 구현된 코드에서는 `scale`이라는 매개변수를 사용하여 병합 비율을 조정할 수 있습니다. 파이프라인 호출에서 `scale`을 `cross_attention_kwargs`로 전달하는 방식으로 코드를 작성할 수 있습니다. - -```py -from diffusers import StableDiffusionPipeline -import torch - -model_path = "sayakpaul/sd-model-finetuned-lora-t4" -pipe = StableDiffusionPipeline.from_pretrained("CompVis/stable-diffusion-v1-4", torch_dtype=torch.float16) -pipe.unet.load_attn_procs(model_path) -pipe.to("cuda") - -prompt = "A pokemon with blue eyes." -image = pipe(prompt, num_inference_steps=30, guidance_scale=7.5, cross_attention_kwargs={"scale": 0.5}).images[0] -image.save("pokemon.png") -``` - -`0`은 LoRA 가중치를 사용하지 _않는_ 것과 같고 `1`은 LoRA 미세 조정된 가중치만 사용함을 의미합니다. 0과 1 사이의 값은 두 결과들 사이로 보간됩니다. - - -## 알려진 제한들 - -* 현재 [`UNet2DConditionModel`](https://huggingface.co/docs/diffusers/main/en/api/models#diffusers.UNet2DConditionModel)의 어텐션 레이어에 대해서만 LoRA를 지원합니다. \ No newline at end of file +>>> pipe.unet.load_attn_procs(model_path) +>>> pipe.to("cuda") +# LoRA 파인튜닝된 모델의 가중치 절반과 기본 모델의 가중치 절반 사용 + +>>> image = pipe( +... "A picture of a sks dog in a bucket.", +... num_inference_steps=25, +... guidance_scale=7.5, +... cross_attention_kwargs={"scale": 0.5}, +... ).images[0] +# 완전히 파인튜닝된 LoRA 모델의 가중치 사용 + +>>> image = pipe("A picture of a sks dog in a bucket.", num_inference_steps=25, guidance_scale=7.5).images[0] +>>> image.save("bucket-dog.png") +``` \ No newline at end of file diff --git a/docs/source/ko/training/text2image.mdx b/docs/source/ko/training/text2image.mdx index c2185ca1f647..069388603124 100644 --- a/docs/source/ko/training/text2image.mdx +++ b/docs/source/ko/training/text2image.mdx @@ -1,4 +1,4 @@ - -# Stable Diffusion text-to-image 미세 조정 - -[`train_text_to_image.py`](https://github.com/huggingface/diffusers/tree/main/examples/text_to_image) 스크립트는 자체 데이터셋에서 stable diffusion 모델을 미세 조정하는 방법을 보여줍니다. +# Text-to-image -text-to-image 미세 조정 스크립트는 실험적입니다. 과적합하기 쉽고 치명적인 망각과 같은 문제에 부딪히기 쉽습니다. 자체 데이터셋에서 최상의 결과를 얻으려면 다양한 하이퍼파라미터를 탐색하는 것이 좋습니다. - - +text-to-image 파인튜닝 스크립트는 experimental 상태입니다. 과적합하기 쉽고 치명적인 망각과 같은 문제에 부딪히기 쉽습니다. 자체 데이터셋에서 최상의 결과를 얻으려면 다양한 하이퍼파라미터를 탐색하는 것이 좋습니다. -## 로컬에서 실행하기 + -### dependency 설치하기 +Stable Diffusion과 같은 text-to-image 모델은 텍스트 프롬프트에서 이미지를 생성합니다. 이 가이드는 PyTorch 및 Flax를 사용하여 자체 데이터셋에서 [`CompVis/stable-diffusion-v1-4`](https://huggingface.co/CompVis/stable-diffusion-v1-4) 모델로 파인튜닝하는 방법을 보여줍니다. 이 가이드에 사용된 text-to-image 파인튜닝을 위한 모든 학습 스크립트에 관심이 있는 경우 이 [리포지토리](https://github.com/huggingface/diffusers/tree/main/examples/text_to_image)에서 자세히 찾을 수 있습니다. 스크립트를 실행하기 전에, 라이브러리의 학습 dependency들을 설치해야 합니다: @@ -32,31 +28,53 @@ pip install git+https://github.com/huggingface/diffusers.git pip install -U -r requirements.txt ``` -그리고 [🤗가속](https://github.com/huggingface/accelerate/) 환경을 초기화합니다: +그리고 [🤗Accelerate](https://github.com/huggingface/accelerate/) 환경을 초기화합니다: ```bash accelerate config ``` -가중치를 다운로드하거나 사용하기 전에 모델 라이선스에 동의해야 합니다. 이 예시에서는 모델 버전 `v1-4`를 사용하므로, [이 링크](https://huggingface.co/CompVis/stable-diffusion-v1-4)를 방문하여 라이선스를 읽고 동의하면 확인란을 선택하십시오. +리포지토리를 이미 복제한 경우, 이 단계를 수행할 필요가 없습니다. 대신, 로컬 체크아웃 경로를 학습 스크립트에 명시할 수 있으며 거기에서 로드됩니다. + +### 하드웨어 요구 사항 + +`gradient_checkpointing` 및 `mixed_precision`을 사용하면 단일 24GB GPU에서 모델을 파인튜닝할 수 있습니다. 더 높은 `batch_size`와 더 빠른 훈련을 위해서는 GPU 메모리가 30GB 이상인 GPU를 사용하는 것이 좋습니다. TPU 또는 GPU에서 파인튜닝을 위해 JAX나 Flax를 사용할 수도 있습니다. 자세한 내용은 [아래](#flax-jax-finetuning)를 참조하세요. + +xFormers로 memory efficient attention을 활성화하여 메모리 사용량 훨씬 더 줄일 수 있습니다. [xFormers가 설치](./optimization/xformers)되어 있는지 확인하고 `--enable_xformers_memory_efficient_attention`를 학습 스크립트에 명시합니다. + +xFormers는 Flax에 사용할 수 없습니다. + +## Hub에 모델 업로드하기 + +학습 스크립트에 다음 인수를 추가하여 모델을 허브에 저장합니다: + +```bash + --push_to_hub +``` + -🤗 Hugging Face Hub에 등록된 사용자여야 하며, 코드를 작동하기 위해 액세스 토큰도 사용해야 합니다. 액세스 토큰에 대한 자세한 내용은 [문서의 이 섹션](https://huggingface.co/docs/hub/security-tokens)을 참조하세요. +## 체크포인트 저장 및 불러오기 -다음 명령을 실행하여 토큰을 인증합니다. +학습 중 발생할 수 있는 일에 대비하여 정기적으로 체크포인트를 저장해 두는 것이 좋습니다. 체크포인트를 저장하려면 학습 스크립트에 다음 인수를 명시합니다. ```bash -huggingface-cli login + --checkpointing_steps=500 ``` -리포지토리를 이미 복제한 경우, 이 단계를 수행할 필요가 없습니다. 대신, 로컬 체크아웃 경로를 학습 스크립트에 명시할 수 있으며 거기에서 로드됩니다. +500스텝마다 전체 학습 state가 'output_dir'의 하위 폴더에 저장됩니다. 체크포인트는 'checkpoint-'에 지금까지 학습된 step 수입니다. 예를 들어 'checkpoint-1500'은 1500 학습 step 후에 저장된 체크포인트입니다. -### 미세 조정을 위한 하드웨어 요구 사항 +학습을 재개하기 위해 체크포인트를 불러오려면 '--resume_from_checkpoint' 인수를 학습 스크립트에 명시하고 재개할 체크포인트를 지정하십시오. 예를 들어 다음 인수는 1500개의 학습 step 후에 저장된 체크포인트에서부터 훈련을 재개합니다. + +```bash + --resume_from_checkpoint="checkpoint-1500" +``` -`gradient_checkpointing` 및 `mixed_precision`을 사용하면 단일 24GB GPU에서 모델을 미세 조정할 수 있습니다. 더 높은 `batch_size`와 더 빠른 훈련을 위해서는 GPU 메모리가 30GB 이상인 GPU를 사용하는 것이 좋습니다. TPU 또는 GPU에서 미세 조정을 위해 JAX나 Flax를 사용할 수도 있습니다. 자세한 내용은 [아래](#flax-jax-finetuning)를 참조하세요. +## 파인튜닝 -### 미세 조정 예시 + + +다음과 같이 [Pokémon BLIP 캡션](https://huggingface.co/datasets/lambdalabs/pokemon-blip-captions) 데이터셋에서 파인튜닝 실행을 위해 [PyTorch 학습 스크립트](https://github.com/huggingface/diffusers/blob/main/examples/text_to_image/train_text_to_image.py)를 실행합니다: -다음 스크립트는 Hugging Face Hub에서 사용할 수 있는 [Justin Pinkneys이 캡션한 Pokemon 데이터셋](https://huggingface.co/datasets/lambdalabs/pokemon-blip-captions)를 사용하여 미세 조정 실행을 시작합니다. ```bash export MODEL_NAME="CompVis/stable-diffusion-v1-4" @@ -78,9 +96,10 @@ accelerate launch train_text_to_image.py \ --output_dir="sd-pokemon-model" ``` -자체 학습 파일에서 실행하려면 `datasets`에 필요한 형식에 따라 데이터셋을 준비해야 합니다. 데이터셋을 허브에 업로드하거나 파일이 있는 로컬 폴더를 준비할 수 있습니다. [이 문서](https://huggingface.co/docs/datasets/v2.4.0/en/image_load#imagefolder-with-metadata)에서 이를 수행하는 방법을 설명합니다. +자체 데이터셋으로 파인튜닝하려면 🤗 [Datasets](https://huggingface.co/docs/datasets/index)에서 요구하는 형식에 따라 데이터셋을 준비하세요. [데이터셋을 허브에 업로드](https://huggingface.co/docs/datasets/image_dataset#upload-dataset-to-the-hub)하거나 [파일들이 있는 로컬 폴더를 준비](https ://huggingface.co/docs/datasets/image_dataset#imagefolder)할 수 있습니다. + +사용자 커스텀 loading logic을 사용하려면 스크립트를 수정하십시오. 도움이 되도록 코드의 적절한 위치에 포인터를 남겼습니다. 🤗 아래 예제 스크립트는 `TRAIN_DIR`의 로컬 데이터셋으로를 파인튜닝하는 방법과 `OUTPUT_DIR`에서 모델을 저장할 위치를 보여줍니다: -커스텀 로딩 로직을 사용하려면 스크립트를 수정해야 합니다. 코드의 적절한 위치에 포인터를 남겼습니다 :) ```bash export MODEL_NAME="CompVis/stable-diffusion-v1-4" @@ -103,24 +122,19 @@ accelerate launch train_text_to_image.py \ --output_dir=${OUTPUT_DIR} ``` -학습이 완료되면 모델은 명령에 지정된 `OUTPUT_DIR`에 저장됩니다. 추론을 위해 미세 조정된 모델을 로드하려면, 해당 경로를 `StableDiffusionPipeline`으로 전달하기만 하면 됩니다: + + +[@duongna211](https://github.com/duongna21)의 기여로, Flax를 사용해 TPU 및 GPU에서 Stable Diffusion 모델을 더 빠르게 학습할 수 있습니다. 이는 TPU 하드웨어에서 매우 효율적이지만 GPU에서도 훌륭하게 작동합니다. Flax 학습 스크립트는 gradient checkpointing나 gradient accumulation과 같은 기능을 아직 지원하지 않으므로 메모리가 30GB 이상인 GPU 또는 TPU v3가 필요합니다. -```python -from diffusers import StableDiffusionPipeline +스크립트를 실행하기 전에 요구 사항이 설치되어 있는지 확인하십시오: -model_path = "path_to_saved_model" -pipe = StableDiffusionPipeline.from_pretrained(model_path, torch_dtype=torch.float16) -pipe.to("cuda") - -image = pipe(prompt="yoda").images[0] -image.save("yoda-pokemon.png") +```bash +pip install -U -r requirements_flax.txt ``` -### Flax / JAX 미세 조정 - -[@duongna211](https://github.com/duongna21) 덕분에 Flax를 사용하여 Stable Diffusion을 미세 조정할 수 있습니다! 이는 TPU 하드웨어에서 매우 효율적이지만 GPU에서도 훌륭하게 작동합니다. 다음과 같이 [Flax 학습 스크립트](https://github.com/huggingface/diffusers/blob/main/examples/text_to_image/train_text_to_image_flax.py)를 사용할 수 있습니다: +그러면 다음과 같이 [Flax 학습 스크립트](https://github.com/huggingface/diffusers/blob/main/examples/text_to_image/train_text_to_image_flax.py)를 실행할 수 있습니다. -```Python +```bash export MODEL_NAME="runwayml/stable-diffusion-v1-5" export dataset_name="lambdalabs/pokemon-blip-captions" @@ -134,3 +148,77 @@ python train_text_to_image_flax.py \ --max_grad_norm=1 \ --output_dir="sd-pokemon-model" ``` + +자체 데이터셋으로 파인튜닝하려면 🤗 [Datasets](https://huggingface.co/docs/datasets/index)에서 요구하는 형식에 따라 데이터셋을 준비하세요. [데이터셋을 허브에 업로드](https://huggingface.co/docs/datasets/image_dataset#upload-dataset-to-the-hub)하거나 [파일들이 있는 로컬 폴더를 준비](https ://huggingface.co/docs/datasets/image_dataset#imagefolder)할 수 있습니다. + +사용자 커스텀 loading logic을 사용하려면 스크립트를 수정하십시오. 도움이 되도록 코드의 적절한 위치에 포인터를 남겼습니다. 🤗 아래 예제 스크립트는 `TRAIN_DIR`의 로컬 데이터셋으로를 파인튜닝하는 방법을 보여줍니다: + +```bash +export MODEL_NAME="duongna/stable-diffusion-v1-4-flax" +export TRAIN_DIR="path_to_your_dataset" + +python train_text_to_image_flax.py \ + --pretrained_model_name_or_path=$MODEL_NAME \ + --train_data_dir=$TRAIN_DIR \ + --resolution=512 --center_crop --random_flip \ + --train_batch_size=1 \ + --mixed_precision="fp16" \ + --max_train_steps=15000 \ + --learning_rate=1e-05 \ + --max_grad_norm=1 \ + --output_dir="sd-pokemon-model" +``` + + + +## LoRA + +Text-to-image 모델 파인튜닝을 위해, 대규모 모델 학습을 가속화하기 위한 파인튜닝 기술인 LoRA(Low-Rank Adaptation of Large Language Models)를 사용할 수 있습니다. 자세한 내용은 [LoRA 학습](lora#text-to-image) 가이드를 참조하세요. + +## 추론 + +허브의 모델 경로 또는 모델 이름을 [`StableDiffusionPipeline`]에 전달하여 추론을 위해 파인 튜닝된 모델을 불러올 수 있습니다: + + + +```python +from diffusers import StableDiffusionPipeline + +model_path = "path_to_saved_model" +pipe = StableDiffusionPipeline.from_pretrained(model_path, torch_dtype=torch.float16) +pipe.to("cuda") + +image = pipe(prompt="yoda").images[0] +image.save("yoda-pokemon.png") +``` + + +```python +import jax +import numpy as np +from flax.jax_utils import replicate +from flax.training.common_utils import shard +from diffusers import FlaxStableDiffusionPipeline + +model_path = "path_to_saved_model" +pipe, params = FlaxStableDiffusionPipeline.from_pretrained(model_path, dtype=jax.numpy.bfloat16) + +prompt = "yoda pokemon" +prng_seed = jax.random.PRNGKey(0) +num_inference_steps = 50 + +num_samples = jax.device_count() +prompt = num_samples * [prompt] +prompt_ids = pipeline.prepare_inputs(prompt) + +# shard inputs and rng +params = replicate(params) +prng_seed = jax.random.split(prng_seed, jax.device_count()) +prompt_ids = shard(prompt_ids) + +images = pipeline(prompt_ids, params, prng_seed, num_inference_steps, jit=True).images +images = pipeline.numpy_to_pil(np.asarray(images.reshape((num_samples,) + images.shape[-3:]))) +image.save("yoda-pokemon.png") +``` + + \ No newline at end of file From 829bc99868e98babcedd8e09c7a3d3df6354cb5c Mon Sep 17 00:00:00 2001 From: Snailpong Date: Fri, 19 May 2023 19:34:34 +0900 Subject: [PATCH 11/12] feat) toctree update --- docs/source/ko/_toctree.yml | 209 ++++++------------------------------ 1 file changed, 32 insertions(+), 177 deletions(-) diff --git a/docs/source/ko/_toctree.yml b/docs/source/ko/_toctree.yml index a1c0c690eb94..efa2bf89944d 100644 --- a/docs/source/ko/_toctree.yml +++ b/docs/source/ko/_toctree.yml @@ -3,191 +3,46 @@ title: "🧨 Diffusers" - local: quicktour title: "훑어보기" + - local: in_translation + title: Stable Diffusion - local: installation title: "설치" title: "시작하기" + - sections: - sections: - local: in_translation - title: "Loading Pipelines, Models, and Schedulers" - - local: in_translation - title: "Using different Schedulers" - - local: in_translation - title: "Configuring Pipelines, Models, and Schedulers" - - local: in_translation - title: "Loading and Adding Custom Pipelines" - title: "불러오기 & 허브 (번역 예정)" - - sections: - - local: in_translation - title: "Unconditional Image Generation" - - local: in_translation - title: "Text-to-Image Generation" - - local: in_translation - title: "Text-Guided Image-to-Image" - - local: in_translation - title: "Text-Guided Image-Inpainting" - - local: in_translation - title: "Text-Guided Depth-to-Image" + title: 개요 - local: in_translation - title: "Reusing seeds for deterministic generation" + title: Unconditional 이미지 생성 - local: in_translation - title: "Community Pipelines" + title: Textual Inversion + - local: training/dreambooth + title: DreamBooth + - local: training/text2image + title: Text-to-image + - local: training/lora + title: Low-Rank Adaptation of Large Language Models (LoRA) - local: in_translation - title: "How to contribute a Pipeline" - title: "추론을 위한 파이프라인 (번역 예정)" - - sections: - - local: in_translation - title: "Reinforcement Learning" - - local: in_translation - title: "Audio" + title: ControlNet - local: in_translation - title: "Other Modalities" - title: "Taking Diffusers Beyond Images" - title: "Diffusers 사용법 (번역 예정)" -- sections: - - local: in_translation - title: "Memory and Speed" - - local: in_translation - title: "xFormers" - - local: in_translation - title: "ONNX" - - local: in_translation - title: "OpenVINO" - - local: in_translation - title: "MPS" - - local: in_translation - title: "Habana Gaudi" - title: "최적화/특수 하드웨어 (번역 예정)" + title: InstructPix2Pix 학습 + title: 학습 - sections: - - local: in_translation - title: "Overview" - - local: in_translation - title: "Unconditional Image Generation" - - local: in_translation - title: "Textual Inversion" - - local: in_translation - title: "Dreambooth" - - local: in_translation - title: "Text-to-image fine-tuning" - title: "학습 (번역 예정)" -- sections: - - local: in_translation - title: "Stable Diffusion" - - local: in_translation - title: "Philosophy" - - local: in_translation - title: "How to contribute?" - title: "개념 설명 (번역 예정)" -- sections: - - sections: - - local: in_translation - title: "Models" - - local: in_translation - title: "Diffusion Pipeline" - - local: in_translation - title: "Logging" - - local: in_translation - title: "Configuration" - - local: in_translation - title: "Outputs" - title: "Main Classes" - - - sections: - - local: in_translation - title: "Overview" - - local: in_translation - title: "AltDiffusion" - - local: in_translation - title: "Cycle Diffusion" - - local: in_translation - title: "DDIM" - - local: in_translation - title: "DDPM" - - local: in_translation - title: "Latent Diffusion" - - local: in_translation - title: "Unconditional Latent Diffusion" - - local: in_translation - title: "PaintByExample" - - local: in_translation - title: "PNDM" - - local: in_translation - title: "Score SDE VE" - - sections: - - local: in_translation - title: "Overview" - - local: in_translation - title: "Text-to-Image" - - local: in_translation - title: "Image-to-Image" - - local: in_translation - title: "Inpaint" - - local: in_translation - title: "Depth-to-Image" - - local: in_translation - title: "Image-Variation" - - local: in_translation - title: "Super-Resolution" - title: "Stable Diffusion" - - local: in_translation - title: "Stable Diffusion 2" - - local: in_translation - title: "Safe Stable Diffusion" - - local: in_translation - title: "Stochastic Karras VE" - - local: in_translation - title: "Dance Diffusion" - - local: in_translation - title: "UnCLIP" - - local: in_translation - title: "Versatile Diffusion" - - local: in_translation - title: "VQ Diffusion" - - local: in_translation - title: "RePaint" - - local: in_translation - title: "Audio Diffusion" - title: "파이프라인 (번역 예정)" - - sections: - - local: in_translation - title: "Overview" - - local: in_translation - title: "DDIM" - - local: in_translation - title: "DDPM" - - local: in_translation - title: "Singlestep DPM-Solver" - - local: in_translation - title: "Multistep DPM-Solver" - - local: in_translation - title: "Heun Scheduler" - - local: in_translation - title: "DPM Discrete Scheduler" - - local: in_translation - title: "DPM Discrete Scheduler with ancestral sampling" - - local: in_translation - title: "Stochastic Kerras VE" - - local: in_translation - title: "Linear Multistep" - - local: in_translation - title: "PNDM" - - local: in_translation - title: "VE-SDE" - - local: in_translation - title: "IPNDM" - - local: in_translation - title: "VP-SDE" - - local: in_translation - title: "Euler scheduler" - - local: in_translation - title: "Euler Ancestral Scheduler" - - local: in_translation - title: "VQDiffusionScheduler" - - local: in_translation - title: "RePaint Scheduler" - title: "스케줄러 (번역 예정)" - - sections: - - local: in_translation - title: "RL Planning" - title: "Experimental Features" - title: "API (번역 예정)" + - local: optimization/opt_overview + title: 개요 + - local: optimization/fp16 + title: 메모리와 속도 + - local: in_translation + title: Torch2.0 지원 + - local: optimization/xformers + title: xFormers + - local: optimization/onnx + title: ONNX + - local: optimization/open_vino + title: OpenVINO + - local: optimization/mps + title: MPS + - local: optimization/habana + title: Habana Gaudi + title: 최적화/특수 하드웨어 \ No newline at end of file From 0b857853effe9c724cc7e8eaba94344ebae6797b Mon Sep 17 00:00:00 2001 From: Snailpong Date: Fri, 19 May 2023 19:35:21 +0900 Subject: [PATCH 12/12] feat) toctree update --- docs/source/ko/_toctree.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/source/ko/_toctree.yml b/docs/source/ko/_toctree.yml index efa2bf89944d..2fec3af66525 100644 --- a/docs/source/ko/_toctree.yml +++ b/docs/source/ko/_toctree.yml @@ -29,7 +29,7 @@ title: InstructPix2Pix 학습 title: 학습 - sections: - - local: optimization/opt_overview + - local: in_translation title: 개요 - local: optimization/fp16 title: 메모리와 속도