フリーティアのGoogle Colabで🧨ディフューザーを使用してIFを実行中

Running IF using a diffuser in Google Colab on FreeTier.

要約：Google Colabの無料ティア上で最も強力なオープンソースのテキストから画像への変換モデルIFを実行する方法を紹介します。

また、Hugging Face Spaceでモデルの機能を直接探索することもできます。

公式のIF GitHubリポジトリから圧縮された画像。

はじめに

IFは、ピクセルベースのテキストから画像への生成モデルで、DeepFloydによって2023年4月下旬にリリースされました。モデルのアーキテクチャは、GoogleのクローズドソースのImagenに強く影響を受けています。

IFは、Stable Diffusionなどの既存のテキストから画像へのモデルと比較して、次の2つの利点があります：

モデルは、レイテントスペースではなく「ピクセルスペース」（つまり、非圧縮画像上で）で直接動作し、Stable Diffusionのようなノイズ除去プロセスを実行しません。
モデルは、Stable Diffusionでテキストエンコーダとして使用されるCLIPよりも強力なテキストエンコーダであるT5-XXLの出力で訓練されます。

その結果、IFは高周波の詳細（例：人の顔や手など）を持つ画像を生成する能力に優れており、信頼性のあるテキスト付き画像を生成できる最初のオープンソースの画像生成モデルです。

ピクセルスペースで動作し、より強力なテキストエンコーダを使用することのデメリットは、IFが大幅に多くのパラメータを持っていることです。T5、IFのテキストから画像へのUNet、IFのアップスケーラUNetは、それぞれ4.5B、4.3B、1.2Bのパラメータを持っています。それに対して、Stable Diffusion 2.1のテキストエンコーダとUNetは、それぞれ400Mと900Mのパラメータしか持っていません。

しかし、メモリ使用量を低減させるためにモデルを最適化すれば、一般のハードウェア上でもIFを実行することができます。このブログ記事では、🧨ディフューザを使用してその方法を紹介します。

1.）では、テキストから画像への生成にIFを使用する方法を説明し、2.）と3.）では、IFの画像バリエーションと画像インペインティングの機能について説明します。

💡 注意：メモリの利得と引き換えに速度の利得を得るために、IFを無料ティアのGoogle Colab上で実行できるようにしています。A100などの高性能なGPUにアクセスできる場合は、公式のIFデモのようにすべてのモデルコンポーネントをGPU上に残して、最大の速度で実行することをお勧めします。

💡 注意：ブログの形式でより速く読み込むために、一部の大きな画像は圧縮されています。公式のモデルを使用する場合は、さらに高い品質になります！

さあ、始めましょう 🚀！

IFのテキスト生成能力

ライセンスの承諾

IFを使用する前に、その使用条件を承諾する必要があります。以下の手順に従ってください：

1. Hugging Faceアカウントを作成し、ログインしていることを確認します
1. DeepFloyd/IF-I-XL-v1.0のモデルカードでライセンスを承諾します。ステージIのモデルカードでライセンスを承諾すると、他のIFモデルにも自動的に適用されます。
1. ローカルでログインしていることを確認します。 huggingface_hubをインストールします

pip install huggingface_hub --upgrade

Pythonシェルでログイン関数を実行します

from huggingface_hub import login

login()

そして、Hugging Face Hubのアクセストークンを入力します。

メモリ制約のあるハードウェア上でのIFの最適化

最新の機械学習は、エリートな一部の人々の手にだけあるべきではありません。機械学習の民主化とは、モデルを最新かつ最高のハードウェアに限定せずに実行できるようにすることを意味します。

ディープラーニングコミュニティは、リソースを多く必要とするモデルを一般のハードウェア上で実行するための世界クラスのツールを作成しました：

🤗 accelerateは、大規模なモデルを扱うためのユーティリティを提供します。
bitsandbytesは、8ビット量子化をすべてのPyTorchモデルで利用できるようにします。
🤗 safetensorsは、セーブコードが実行されるだけでなく、大規模なモデルの読み込み時間を大幅に高速化します。

Diffusersは、上記のライブラリをシームレスに統合し、大規模なモデルの最適化時に簡単なAPIを提供します。

無料のGoogle Colabは、CPU RAMが制約されています（13 GB RAM）、またGPU VRAMも制約されています（T4の場合は15 GB RAM）。そのため、10B IFモデル全体を実行することは困難です！

IFのモデルのコンポーネントのサイズを完全なfloat32精度でマッピングしましょう：

T5-XXL テキストエンコーダー：20GB
ステージ1 UNet：17.2 GB
ステージ2 スーパーレゾリューションUNet：2.5 GB
ステージ3 スーパーレゾリューションモデル：3.4 GB

CPU RAMよりもT5とステージ1 UNetのウェイトが大きいため、float32でモデルを実行することはできません。

float16では、T5、ステージ1、ステージ2 UNetのコンポーネントサイズはそれぞれ11GB、8.6GB、1.25GBであり、GPUでは実行可能ですが、T5の読み込み時にはCPUメモリオーバーフローエラーが発生します（他のプロセスがCPUを占有しているため）。

したがって、bitsandbytesの8ビット量子化を使用してT5の精度をさらに下げることで、T5のチェックポイントを8 GBで保存できるようにします。

各コンポーネントがCPUとGPUメモリに個別に収まるようになったので、必要なときにコンポーネントがCPUとGPUメモリをすべて使えるようにする必要があります。

Diffusersは、個々のコンポーネントをモジュール化してロードすることをサポートしています。つまり、UNetをロードせずにテキストエンコーダーのみをロードすることができます。このモジュール化されたロードにより、パイプラインの特定のステップで必要なコンポーネントのみをロードし、利用可能なCPU RAMとGPU VRAMを消耗しないようにします。

試してみましょう 🚀

利用可能なリソース

無料のGoogle Colabには、約13 GBのCPU RAMが付属しています：

!grep MemTotal /proc/meminfo

MemTotal:       13297192 kB

NVIDIA T4には15 GBのVRAMがあります：

!nvidia-smi

Sun Apr 23 23:14:19 2023       
+-----------------------------------------------------------------------------+
| NVIDIA-SMI 525.85.12    Driver Version: 525.85.12    CUDA Version: 12.0     |
|-------------------------------+----------------------+----------------------+
| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |
| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |
|                               |                      |               MIG M. |
|===============================+======================+======================|
|   0  Tesla T4            Off  | 00000000:00:04.0 Off |                    0 |
| N/A   72C    P0    32W /  70W |   1335MiB / 15360MiB |      0%      Default |
|                               |                      |                  N/A |
+-------------------------------+----------------------+----------------------+
                                                                                
+-----------------------------------------------------------------------------+
| Processes:                                                                  |
|  GPU   GI   CI        PID   Type   Process name                  GPU Memory |
|        ID   ID                                                   Usage      |
|=============================================================================|
+-----------------------------------------------------------------------------+

依存関係のインストール

最適化には、依存関係の最新バージョンが必要な場合があります。問題が発生した場合は、バージョンを確認してアップグレードしてください。

! pip install --upgrade \
  diffusers~=0.16 \
  transformers~=4.28 \
  safetensors~=0.3 \
  sentencepiece~=0.1 \
  accelerate~=0.18 \
  bitsandbytes~=0.38 \
  torch~=2.0 -q

1. テキストから画像生成

IFを使用したDiffusersを使用して、ステップバイステップでテキストから画像生成を行います。APIと最適化の説明は簡単に行いますが、詳細な説明はDiffusers、Transformers、Accelerate、bitsandbytesの公式ドキュメンテーションで見つけることができます。

1.1 テキストエンコーダの読み込み

8bit量子化を使用してT5をロードします。Transformersは、load_in_8bitフラグを介してbitsandbytesを直接サポートしています。

variant="8bit"フラグは、事前に量子化されたウェイトをダウンロードします。

また、device_mapフラグを使用して、transformersがモデルレイヤーをCPUまたはディスクにオフロードできるようにします。Transformersのビッグモデリングは任意のデバイスマップをサポートしており、利用可能なデバイスにモデルパラメータを別々にロードするために使用できます。"auto"を渡すと、自動的にデバイスマップが作成されます。詳細については、transformersのドキュメントを参照してください。

from transformers import T5EncoderModel

text_encoder = T5EncoderModel.from_pretrained(
    "DeepFloyd/IF-I-XL-v1.0",
    subfolder="text_encoder", 
    device_map="auto", 
    load_in_8bit=True, 
    variant="8bit"
)

1.2 テキスト埋め込みの作成

拡散モデルにアクセスするためのDiffusersのAPIはDiffusionPipelineクラスとそのサブクラスです。各DiffusionPipelineのインスタンスは、拡散ネットワークを実行するためのメソッドとモデルの完全なセットです。from_pretrainedにキーワード引数として代替インスタンスを渡すことで、使用するモデルを上書きすることができます。

この場合、unet引数にNoneを渡すことで、UNetはロードされません。これにより、メモリにUNetを読み込まずに拡散プロセスのテキスト埋め込み部分を実行することができます。

from diffusers import DiffusionPipeline

pipe = DiffusionPipeline.from_pretrained(
    "DeepFloyd/IF-I-XL-v1.0", 
    text_encoder=text_encoder, # 以前にインスタンス化された8bitテキストエンコーダを渡す
    unet=None, 
    device_map="auto"
)

IFにはスーパーリゾリューションパイプラインも付属しています。プロンプトの埋め込みを保存して、後でスーパーリゾリューションパイプラインに直接渡すことができます。これにより、テキストエンコーダなしでスーパーリゾリューションパイプラインをロードすることができます。

ただし、「宇宙でのPixel」というサインを手渡すことにしましょう。

適切なプロンプトを定義しましょう:

prompt = "宇宙飛行士が馬に乗ってサインを持っている写真"

そして、8bit量子化されたT5モデルを実行します:

prompt_embeds, negative_embeds = pipe.encode_prompt(prompt)

1.3 メモリの解放

プロンプトの埋め込みが作成されたら、もはやテキストエンコーダは必要ありません。ただし、まだGPU上のメモリに残っています。UNetをロードできるようにするために、それを削除する必要があります。

PyTorchのメモリを解放するのは非自明です。GPU上に割り当てられた実際のメモリを指すPythonオブジェクトをガベージコレクションする必要があります。

まず、Pythonのキーワードdelを使用して、割り当てられたGPUメモリを参照するすべてのPythonオブジェクトを削除します。

del text_encoder
del pipe

Pythonオブジェクトを削除するだけではGPUメモリを解放するのに十分ではありません。ガベージコレクションは、実際のGPUメモリが解放されるときです。

さらに、torch.cuda.empty_cache()を呼び出します。このメソッドは必須ではありませんが、キャッシュされたcudaメモリはすぐに他の割り当てに使用できるようになります。キャッシュを空にすることで、ColabのUIでメモリが利用可能かを確認できます。

メモリをフラッシュするためにflush()というヘルパー関数を使用します。

import gc
import torch

def flush():
    gc.collect()
    torch.cuda.empty_cache()

それを実行します

flush()

1.4 ステージ1: メイン拡散プロセス

現在利用可能なGPUメモリを使用して、DiffusionPipelineを再読み込みし、メインの拡散プロセスを実行することができます。

variantとtorch_dtypeフラグは、Diffusersが16ビット浮動小数点形式で重みをダウンロードおよびロードするために使用されます。

pipe = DiffusionPipeline.from_pretrained(
    "DeepFloyd/IF-I-XL-v1.0", 
    text_encoder=None, 
    variant="fp16", 
    torch_dtype=torch.float16, 
    device_map="auto"
)

通常、テキストプロンプトを直接DiffusionPipeline.__call__に渡します。しかし、以前にテキスト埋め込みを計算しているため、代わりにそれを渡すことができます。

IFにはスーパーレゾリューション拡散プロセスも付属しています。 output_type="pt"を設定すると、PILイメージではなく生のPyTorchテンソルが返されます。これにより、PyTorchテンソルをGPU上に保持し、それらを直接ステージ2のスーパーレゾリューションパイプラインに渡すことができます。

ランダムジェネレータを定義し、ステージ1の拡散プロセスを実行しましょう。

generator = torch.Generator().manual_seed(1)
image = pipe(
    prompt_embeds=prompt_embeds,
    negative_prompt_embeds=negative_embeds, 
    output_type="pt",
    generator=generator,
).images

生のテンソルをPILに手動で変換し、最終結果を覗いてみましょう。ステージ1の出力は64×64のイメージです。

from diffusers.utils import pt_to_pil

pil_image = pt_to_pil(image)
pipe.watermarker.apply_watermark(pil_image, pipe.unet.config.sample_size)

pil_image[0]

そして再び、Pythonのポインタを削除し、CPUとGPUのメモリを解放します。

del pipe
flush()

1.5 ステージ2：64×64から256×256のスーパーレゾリューション

IFには拡大のための別々の拡散プロセスも付属しています。

各拡散プロセスを別々のパイプラインで実行します。

スーパーレゾリューションパイプラインは、必要に応じてテキストエンコーダを読み込むことができます。ただし、通常は最初のIFパイプラインから事前に計算されたテキスト埋め込みを持っているでしょう。その場合は、テキストエンコーダなしでパイプラインをロードします。

パイプラインを作成します

pipe = DiffusionPipeline.from_pretrained(
    "DeepFloyd/IF-II-L-v1.0", 
    text_encoder=None, # no use of text encoder => memory savings!
    variant="fp16", 
    torch_dtype=torch.float16, 
    device_map="auto"
)

そして実行し、事前計算されたテキスト埋め込みを再利用します

image = pipe(
    image=image, 
    prompt_embeds=prompt_embeds, 
    negative_prompt_embeds=negative_embeds, 
    output_type="pt",
    generator=generator,
).images

再び中間結果を確認することができます。

pil_image = pt_to_pil(image)
pipe.watermarker.apply_watermark(pil_image, pipe.unet.config.sample_size)

pil_image[0]

そして再び、Pythonのポインタを削除し、メモリを解放します。

del pipe
flush()

1.6 ステージ3：256×256から1024×1024のスーパーレゾリューション

IFの2番目のスーパーレゾリューションモデルは、以前にリリースされたStability AIのx4 Upscalerです。

パイプラインを作成し、device_map="auto"で直接GPUに読み込みます。

pipe = DiffusionPipeline.from_pretrained(
    "stabilityai/stable-diffusion-x4-upscaler", 
    torch_dtype=torch.float16, 
    device_map="auto"
)

🧨 diffusersは、独立して開発された拡散モデルをパイプラインとして簡単に組み合わせることができます。ここでは、前のPyTorchテンソルの出力をそのままステージ3のパイプラインに渡すだけです。image=image。

💡 注：x4のアップスケーラーはT5を使用せず、独自のテキストエンコーダーを持っています。したがって、以前に作成したプロンプト埋め込みを使用することはできず、代わりに元のプロンプトを渡す必要があります。

pil_image = pipe(prompt, generator=generator, image=image).images

IFパイプラインとは異なり、Stable Diffusion x4アップスケーラーパイプラインの出力にはデフォルトでIFウォーターマークは追加されません。

代わりに、ウォーターマークを手動で適用することができます。

from diffusers.pipelines.deepfloyd_if import IFWatermarker

watermarker = IFWatermarker.from_pretrained("DeepFloyd/IF-I-XL-v1.0", subfolder="watermarker")
watermarker.apply_watermark(pil_image, pipe.unet.config.sample_size)

出力画像を表示する

pil_image[0]

エ・ボワラ！無料のGoogle Colabで美しい1024×1024の画像を手に入れました。

🧨 diffusersがリソースの消費量が多い拡散モデルを分解してモジュール化してロードすることが簡単であることを示しました。

💡 注：上記のセットアップは本番環境ではお勧めしません。8ビットの量子化、モデルの重みの手動解放、ディスクへのオフロードはすべて、メモリを時間（推論速度）と引き換えにするトレードオフです。特に拡散パイプラインが再利用される場合、これは特に顕著になります。本番環境では、すべてのモデルコンポーネントをGPU上に残した40GBのA100を使用することをお勧めします。公式のIFデモを参照してください。

2. 画像の変動

IFチェックポイントは、テキストによる画像のバリエーションやインペイントにも使用することができます。核となる拡散プロセスは、テキストから画像の生成と同じですが、初期のノイズのある画像はバリエーションまたはインペイントする画像から作成されます。

画像のバリエーションを実行するには、IFImg2ImgPipeline.from_pretrained()とIFImg2ImgSuperResolution.from_pretrained()で同じチェックポイントをロードします。

メモリの最適化のためのAPIはすべて同じです！

前のセクションからメモリを解放しましょう。

del pipe
flush()

画像のバリエーションでは、適応したい初期画像から始めます。

このセクションでは、有名な「車の屋根をたたく」ミームを適応します。インターネットからそれをダウンロードしましょう。

import requests

url = "https://i.kym-cdn.com/entries/icons/original/000/026/561/car.jpg"
response = requests.get(url)

そして、PILイメージにロードします

from PIL import Image
from io import BytesIO

original_image = Image.open(BytesIO(response.content)).convert("RGB")
original_image = original_image.resize((768, 512))
original_image

画像のバリエーションパイプラインは、PILイメージと生のテンソルの両方を受け取ることができます。入力の期待値については、詳細なドキュメンテーションを表示してください。

2.1 テキストエンコーダー

画像のバリエーションはテキストによって導かれるため、プロンプトを定義し、T5のテキストエンコーダーでエンコードすることができます。

再び、テキストエンコーダーを8ビット精度でロードします。

from transformers import T5EncoderModel

text_encoder = T5EncoderModel.from_pretrained(
    "DeepFloyd/IF-I-XL-v1.0",
    subfolder="text_encoder", 
    device_map="auto", 
    load_in_8bit=True, 
    variant="8bit"
)

画像のバリエーションでは、IFImg2ImgPipelineでチェックポイントをロードします。 DiffusionPipeline.from_pretrained(...)を使用する場合、チェックポイントはデフォルトのパイプラインにロードされます。IFのデフォルトパイプラインは、テキストから画像への変換のIFPipelineです。非デフォルトのパイプラインでチェックポイントをロードする場合は、明示的にパイプラインを指定する必要があります。

from diffusers import IFImg2ImgPipeline

pipe = IFImg2ImgPipeline.from_pretrained(
    "DeepFloyd/IF-I-XL-v1.0", 
    text_encoder=text_encoder, 
    unet=None, 
    device_map="auto"
)

セールスマンをアニメキャラクターに変えましょう。

prompt = "アニメスタイル"

前回と同様に、T5でテキストの埋め込みを作成します。

prompt_embeds, negative_embeds = pipe.encode_prompt(prompt)

そして、GPUとCPUのメモリを解放します。

まず、Pythonのポインタを削除します。

del text_encoder
del pipe

そしてメモリを解放します。

flush()

2.2 ステージ1：メインの拡散プロセス

次に、ステージ1のUNetの重みのみをパイプラインオブジェクトにロードします。

pipe = IFImg2ImgPipeline.from_pretrained(
    "DeepFloyd/IF-I-XL-v1.0", 
    text_encoder=None, 
    variant="fp16", 
    torch_dtype=torch.float16, 
    device_map="auto"
)

画像変換パイプラインでは、元の画像とプロンプトの埋め込みが必要です。

オプションでstrength引数を使用して変動量を設定できます。strengthは直接ノイズの量を制御します。強度が高いほど、ノイズが多くなり、変動量も増えます。

generator = torch.Generator().manual_seed(0)
image = pipe(
    image=original_image,
    prompt_embeds=prompt_embeds,
    negative_prompt_embeds=negative_embeds, 
    output_type="pt",
    generator=generator,
).images

中間の64×64を再確認しましょう。

pil_image = pt_to_pil(image)
pipe.watermarker.apply_watermark(pil_image, pipe.unet.config.sample_size)

pil_image[0]

良さそうです！メモリを解放して、画像を再度拡大しましょう。

del pipe
flush()

2.3 ステージ2：スーパーレゾリューション

スーパーレゾリューションのために、IFImg2ImgSuperResolutionPipelineと前と同じチェックポイントをロードします。

from diffusers import IFImg2ImgSuperResolutionPipeline

pipe = IFImg2ImgSuperResolutionPipeline.from_pretrained(
    "DeepFloyd/IF-II-L-v1.0", 
    text_encoder=None, 
    variant="fp16", 
    torch_dtype=torch.float16, 
    device_map="auto"
)

💡 注意：画像変動スーパーレゾリューションパイプラインでは、生成された画像と元の画像の両方が必要です。

この画像にはStable Diffusion x4アップスケーラーも使用できます。セクション1.6のコードスニペットを使用して試してみてください。

image = pipe(
    image=image,
    original_image=original_image,
    prompt_embeds=prompt_embeds,
    negative_prompt_embeds=negative_embeds, 
    generator=generator,
).images[0]
image

素晴らしいです！メモリを解放して、最終的なインペインティングパイプラインを見てみましょう。

del pipe
flush()

3. インペインティング

IFインペインティングパイプラインは、画像変動と同じですが、画像の選択した領域のみがノイズ除去されます。

画像マスクでインペインティングする領域を指定します。

IFの素晴らしい「レター生成」機能を見せましょう。この看板のテキストを異なるスローガンに置き換えることができます。

まず、画像をダウンロードしましょう。

import requests

url = "https://i.imgflip.com/5j6x75.jpg"
response = requests.get(url)

そして、PILイメージに変換します。

from PIL import Image
from io import BytesIO

original_image = Image.open(BytesIO(response.content)).convert("RGB")
original_image = original_image.resize((512, 768))
original_image

サインをマスクして、テキストを置き換えることができます。

便利のために、マスクを事前に生成してHFデータセットにロードしておきました。

ダウンロードしましょう。

from huggingface_hub import hf_hub_download

mask_image = hf_hub_download("diffusers/docs-images", repo_type="dataset", filename="if/sign_man_mask.png")
mask_image = Image.open(mask_image)

mask_image

💡 注意 : 自分でグレースケール画像を作成してマスクを作成することもできます。

from PIL import Image
import numpy as np

height = 64
width = 64

example_mask = np.zeros((height, width), dtype=np.int8)

# マスクされたピクセルを255に設定します
example_mask[20:30, 30:40] = 255

# 'L'というモードでイメージを作成することを忘れないでください
# これは単一チャンネルのグレースケールを意味します
example_mask = Image.fromarray(example_mask, mode='L')

example_mask

これでインペインティングを開始できます 🎨🖌

3.1. テキストエンコーダー

まず、テキストエンコーダーをロードします。

from transformers import T5EncoderModel

text_encoder = T5EncoderModel.from_pretrained(
    "DeepFloyd/IF-I-XL-v1.0",
    subfolder="text_encoder", 
    device_map="auto", 
    load_in_8bit=True, 
    variant="8bit"
)

今回は、テキストエンコーダーの重みを使用して IFInpaintingPipeline インペインティングパイプラインを初期化します。

from diffusers import IFInpaintingPipeline

pipe = IFInpaintingPipeline.from_pretrained(
    "DeepFloyd/IF-I-XL-v1.0", 
    text_encoder=text_encoder, 
    unet=None, 
    device_map="auto"
)

さて、男性の代わりにもっと多くのレイヤーを宣伝してもらいましょう。

prompt = 'the text, "just stack more layers"'

プロンプトを定義したら、プロンプトの埋め込みを作成できます。

prompt_embeds, negative_embeds = pipe.encode_prompt(prompt)

前と同様に、メモリを解放します。

del text_encoder
del pipe
flush()

3.2 ステージ1：メインディフュージョンプロセス

前と同様に、ステージ1のパイプラインをUNetのみでロードします。

pipe = IFInpaintingPipeline.from_pretrained(
    "DeepFloyd/IF-I-XL-v1.0", 
    text_encoder=None, 
    variant="fp16", 
    torch_dtype=torch.float16, 
    device_map="auto"
)

今度は、入力画像、マスク画像、およびプロンプトの埋め込みを渡す必要があります。

image = pipe(
    image=original_image,
    mask_image=mask_image,
    prompt_embeds=prompt_embeds,
    negative_prompt_embeds=negative_embeds, 
    output_type="pt",
    generator=generator,
).images

中間出力を確認しましょう。

pil_image = pt_to_pil(image)
pipe.watermarker.apply_watermark(pil_image, pipe.unet.config.sample_size)

pil_image[0]

見た目は良いです！テキストは非常に一貫しています！

メモリを解放して画像の解像度を上げることができるようにしましょう。

del pipe
flush()

3.3 ステージ2：スーパーレゾリューション

スーパーレゾリューションのために、IFInpaintingSuperResolutionPipeline チェックポイントをロードします。

from diffusers import IFInpaintingSuperResolutionPipeline

pipe = IFInpaintingSuperResolutionPipeline.from_pretrained(
    "DeepFloyd/IF-II-L-v1.0", 
    text_encoder=None, 
    variant="fp16", 
    torch_dtype=torch.float16, 
    device_map="auto"
)

インペイントスーパーレゾリューションパイプラインは、生成された画像、元の画像、マスク画像、およびプロンプト埋め込みを必要とします。

最後のデノイジングランを行いましょう。

image = pipe(
    image=image,
    original_image=original_image,
    mask_image=mask_image,
    prompt_embeds=prompt_embeds,
    negative_prompt_embeds=negative_embeds, 
    generator=generator,
).images[0]
image

素晴らしい、このモデルは一つのスペルミスもなくテキストを生成しました！

結論

32ビット浮動小数点精度のIFは、合計で40 GBの重みを使用します。オープンソースのモデルとライブラリのみを使用して、IFを無料のGoogle Colabインスタンスで実行する方法を示しました。

MLエコシステムは、オープンツールとオープンモデルの共有によって深く恩恵を受けています。このノートブック単体で、DeepFloyd、StabilityAI、Googleからモデルを使用しました。使用したライブラリであるDiffusers、Transformers、Accelerate、bitsandbytesは、異なる組織からの無数の貢献者によって恩恵を受けています。

IFの作成とオープンソース化、そして良い機械学習の民主化への貢献に対して、DeepFloydチームに大きな感謝を申し上げます 🤗。

We will continue to update VoAGI; if you have any questions or suggestions, please contact us!

Was this article helpful?

93 out of 132 found this helpful