WindowsでLaMa-RegularをONNXにexportしたり、追加学習したりする！

WindowsアプリでONNX推論してINPAINTしたい！

物体検出をして、塗りつぶすというWindowsアプリを作成しています。
現在はOpenCVのINPAINTを利用していますが、

• OpenCVのINPAINTはマスク周辺から延長して欠損部分を埋めるので見た目がそこまで良くない（マスクが小さいと気にならない）
• アルゴリズムが単純なためINPAINTとしては高速な部類ではあるもの、単純塗りつぶしやブラーと比べると処理が遅い

もしかすると、ONNXでGPU推論すればINPAINTも今より速く、しかも綺麗になるんじゃないか？
そんな感じで始めた物語です。

Inpaint（インペイント）とは、画像の一部をマスク（塗りつぶし）で指定し、その部分だけを再生成・修正・削除する技術です。
不要な背景や人物の除去、服装や表情の変更、画像の一部描き直しに利用されます。
簡単に言えば消しゴムマジック的なものです。

この記事ですること・しないこと

すること（したこと）

• LaMa-RegularがWindowsネイティブ環境で動作するよう環境の整備
• LaMa-RegularのWindowsでのONNXエクスポート、DirectML推論の確認
• LaMa-RegularのWindowsでのファインチューニング

しないこと

• LaMa-FourierのONNXエクスポート、ファインチューニング
  FFCを利用しており私のニーズには合致しないため
• Detectron2のセットアップ
  大変そうなので諦めました。
  LAMA実行時にDetectron2がないと警告がでます。また回避のためコードにパッチをしています。

当方のWindowsアプリで使えそうなINPAINTモデルの調査

アプリではONNX-DirectML、TensorRT-RTXを利用しています。
モデルの選定ではONNXへの変換可否や、DirectML、TensorRT-RTXで利用できそうかということを重視しました。

DeepFILLV2

高品質なINPAINT推論モデル。
この物語もQiitaのDeepFILLV2の記事を偶然拝見したことがきっかけ（感謝！）。
記事で公開されているリポジトリのコードで事前学習済みモデルのONNXエクスポートができ、そのONNXでDirectML推論もできました。
学習はQiita記事の元となっているリポジトリのコードで実施可能。
事前学習済モデルは入出力が1x3x320x320になっていたので、ゼロから学習したら入出力サイズを変えられるかな？と思いましたが、モデル内部に320x320を前提にした内容がある模様。修正して対応できないかとも考えましたが私の理解度では難しかったので諦めました。
またcontextual attentionの処理が重く、DirectMLやTensorRTでも推論速度が伸びないそうです。

LaMa（LaMa-Regular、LaMa-Dilated）

高品質で大きなマスクに対しても違和感なく自然な形で生成できるのが特徴。
FFC（Fast Fourier Convolution）というオペレータが採用されており、これにより広い範囲から文脈を読み取ることができるそうです。
また256x256で学習したモデルを512x512など学習時よりも高解像度の入力をしても破綻が少ないという特徴もあるそうです。
しかしFFCはDirectML、TensorRTではサポートされておらず、LaMa標準モデルは当方では利用できません。（CUDAなら大丈夫らしい？）
LaMaにはFFCを使わずにResNetで再現しているLaMa-Regularと呼ばれるResNet版LaMaもあります。
ResNetは通常の畳み込み処理のため、DirectML、TensorRTでもサポートされており、処理速度も期待できる模様。
またLaMa-DilatedにおいてもFFCを使わずDilated Convで再現しているらしく、LaMa-Regularと比較して少し広い範囲から文脈理解を進めるそうです。同じくDirectMLでもサポートされているようです。

調査したINPAINTまとめ

	LaMa-Dilated	LaMa-Regular	DeepFILLV2	OpenCV(参考)
学習可否	〇？	〇？	〇	ー
DML/TRT対応	〇？	〇？	〇	（CPU処理）
補間品質	〇？	〇？	〇 ～ △	△
処理速度	〇？	〇？	△？	◎
入出力解像度	動的対応可	動的対応可	320x320固定	制限なし
事前学習済モデル	あり	あり	あり	ー

DeepFILLV2でDirectML推論や学習もさせることができたので、物語の当初の目的であった"INPAINTをONNX推論する"はクリアできそうではありました。
ただ処理後の見た目が少しモヤがかかったような感じであまり納得できなかったこと、入力画像が1x3x320x320固定で適用方法に条件があることは少し不満でした。
また処理速度が出ない可能性もあるらしいのも気になりました。
それだったらOpenCVのままでも良くない？みたいな。

DeepFILLV2以外でONNX-DirectMLやTensorRTに向いたINPAINTモデルがないですかね？とWindows Copilot、Gemini、Grokに問い合わせると、口を揃えてLaMaを勧めてくるので、FFCのないLaMa-RegularのONNXエクスポートからのONNX-DirectML推論や、ファインチューニングに取り組んでみることにしました。

LaMa-Regularを使うためにPython環境を整える

公式リポジトリはLinux環境を想定しているのに、Windowsネイティブで環境構築するやついる？いねぇよなぁ！？
（書きたかっただけ）

LaMaが動作しようとする公式リポジトリに近い環境構築は結構大変でした。古いので。
公式リポジトリにはDockerファイルがあったので、WSL＋Dockerで一発や！と思いましたが、想定されているUbuntuもまた古く、私がWSLやDocker、
Linuxに対する解像度が低いので、Windowsで環境構築をしています。

なおDeepFILLV2では何の苦労もなく普段使いのPython3.11で学習まわせました。さすが実績多いだけある。

１．公式リポジトリからGit clone

git clone https://github.com/advimman/lama.git
cd lama

２．Python3.9のインストール

ONNXへのエクスポートだけなら入れなくてもいいかもしれません（未確認）
当初、いつも利用しているPython3.11で進めていたのですが、何かのパッケージをインストールできませんでした。
それを回避するためにPython3.9をインストールします。
https://www.python.org/downloads/release/python-390/
私はWindows x86-64 executable installerでインストールしました。
パスを通してしまうと普段使いのぐちゃぐちゃ環境がさらにグチャグチャになるので、通さないように。

３．Python仮想環境VENV

私は未だVENVですが、ナウなヤングはUVなりを使ってください。
Python3.9へのパスが通っていないので、EXEへのフルパスで作成する必要があります。

C:\Users\（ユーザ名）\AppData\Local\Programs\Python\Python39\python.exe -m venv venv
.\venv\Scripts\activate

４．pipなどを基本パッケージ更新

python -m pip install --upgrade pip wheel

５．pipでパッケージを導入

もしかすると最新版のパッケージでも動作するのかもしれませんが、ここではできるだけリポジトリのrequirements.txtに近いものを導入するようにします。
requirements.txtでバージョン指示ないものもバージョン指定しないとうまくインストールできません。
私は試行錯誤しながらひとつひとつpipしました。
下記はそれをまとめて書いてますが、最終形がこうだったなので、一度に綺麗に入るかは未確認です。

setuptoolsは、バージョン指定しないと後の依存関係を解決できなかったので指定しています。
tensorflowは、使わないので入れません（入れたらPython3.9 の typing モジュールと衝突して動かない）
ONNXへのエクスポートだけなら全部入れなくてもいいかもしれません。

requirements.txt

pip install setuptools==59.5.0
pip install torch==2.1.2+cu121 torchvision==0.16.2+cu121 --extra-index-url https://download.pytorch.org/whl/cu121
pip install numpy==1.23.5
pip install easydict==1.9.0
pip install scikit-image==0.19.3
pip install scikit-learn==0.24.2
pip install tensorboard==2.14.0
pip install albumentations==0.5.2
pip install hydra-core==1.1.1
pip install pytorch-lightning==1.2.9
pip install omegaconf==2.1.1
pip install pandas==1.5.3
pip install kornia==0.5.0
pip install onnx==1.14.1
pip install protobuf==3.20.3
# 以下は特に指定なし。コメントは入ったバージョン
pip install pyyaml #6.0.3
pip install tqdm #4.67.3
pip install opencv-python # 4.13.0.92
pip install joblib #1.5.3
pip install matplotlib #3.9.4
pip install tabulate #0.9.0
pip install webdataset #0.2.100
pip install packaging #26.0
pip install wldhx.yadisk-direct #0.0.6

LaMa-RegularをONNXエクスポートする

１．事前学習済みモデルをダウンロードする

まず公式リポジトリのreadmeに記載のダウンロード先から

LaMa_models.zipをダウンロードして解凍。

いろいろありますが、LaMa_models\lama-places\lama-regular\models\best.ckptがLaMa-Regularの事前学習済みモデルです。

２．LAMAフォルダにパスを通す、環境変数を設定する（毎回起動時）

このままではLAMA以下のPythonコードにアクセスできないので、パスを通します。
setup.pyもpyproject.tomlも存在しないためpip install -e .が使えないためです。
環境変数 USER TORCH_HOMEも設定します。Linuxにありますが、Windowsにはないためです。
デフォルトではNCCLを使って分散学習しようとしますがWindowsではサポートされていないため、代わりにPL_TORCH_DISTRIBUTED_BACKENDでglooを指定しておきます。

$env:PYTHONPATH="D:\lama"
$env:TORCH_HOME ="D:\lama\torch_home"
$env:USER =$env:USERNAME
$env:PL_TORCH_DISTRIBUTED_BACKEND="gloo"

毎回設定するのも面倒なので、
D:\lama\venv\Scripts\Activate.ps1の# Add the venv to the PATH以下に追加しておくと楽です。

３．ADE20K の重みをダウンロードして TORCH_HOME に置く

まず公式リポジトリのreadmeに記載のダウンロード先から

LaMa_perceptual_loss_models.zipをダウンロードして解凍。

TORCH_HOMEに置く。

D:\lama\torch_home\ade20k\ade20k-resnet50dilated-ppm_deepsup\encoder_epoch_20.pth
D:\lama\torch_home\ade20k\ade20k-resnet50dilated-ppm_deepsup\decoder_epoch_20.pth

４．ONNXエクスポートする

Grokに作ってもらいました。
LaMa-Regularで記載していますが、LaMa-Dilatedの事前学習済モデルでも同様にエクスポートできることを確認しています。

export_onnx.py

import torch
import torch.nn as nn
from omegaconf import OmegaConf
from saicinpainting.training.trainers.default import DefaultInpaintingTrainingModule

# カスタムエクスポート用ラッパークラス（マスキングロジックを追加してトレースエラー回避）
class ExportLama(nn.Module):
    def __init__(self, base_model, concat_mask=True):  # config.model.concat_maskに基づく
        super(ExportLama, self).__init__()
        self.base_model = base_model
        self.concat_mask = concat_mask

    def forward(self, image: torch.Tensor, mask: torch.Tensor):
        # マスキング処理（LaMaの内部ロジックを再現）
        masked_img = image * (1 - mask)
        if self.concat_mask:
            masked_img = torch.cat([masked_img, mask], dim=1)
        # generator呼び出し
        predicted_image = self.base_model(masked_img)
        # 出力合成
        inpainted = mask * predicted_image + (1 - mask) * image
        # クランプ（出力範囲調整）
        return torch.clamp(inpainted, min=0, max=1)  # 入力が[0,1]前提なのでclamp [0,1]

# Configとチェックポイントのパスを指定
config_path = "d:\\ダウンロード\\LaMa_models\\LaMa_models\\lama-places\\lama-regular\\config.yaml"
checkpoint_path = "d:\\ダウンロード\\LaMa_models\\LaMa_models\\lama-places\\lama-regular\\models\\best.ckpt"

# Configロード
config = OmegaConf.load(config_path)

# Config調整（エクスポート時のエラー回避）
if 'generator' in config and 'resnet_conv_kwargs' in config.generator:
    config.generator.resnet_conv_kwargs.use_jit = True  # FourierUnitのJIT有効化（Dilated版必須）
if 'losses' in config.training_model and 'resnet_pl' in config.training_model.losses:
    config.training_model.losses.resnet_pl.weight = 0  # 不要なlossを無効化

# トレーニングモジュールのkwargs準備
kwargs = dict(config.training_model)
kwargs.pop("kind", None)
kwargs["use_ddp"] = False  # エクスポート時はDDP不要

# チェックポイントロード
state = torch.load(checkpoint_path, map_location='cpu', weights_only=False)

# トレーニングモジュールインスタンス化とロード
training_module = DefaultInpaintingTrainingModule(config, **kwargs)
training_module.load_state_dict(state['state_dict'], strict=False)
training_module.on_load_checkpoint(state)  # 追加: チェックポイントの後処理（重要）

# generator抽出
base_model = training_module.generator
base_model.eval()
base_model.to('cpu')

# concat_maskを確認（config.modelから、lama-regularは通常True）
concat_mask = config.training_model.get('concat_mask', True)

# ラッパーモデル作成
model = ExportLama(base_model, concat_mask)

# ダミー入力（[0,1]範囲に正規化、randでOK）
height, width = 512, 512  # lama-regularの標準解像度
dummy_image = torch.rand(1, 3, height, width)  # [0,1]
dummy_mask = torch.rand(1, 1, height, width)  # [0,1]
inputs = (dummy_image, dummy_mask)

# ONNXエクスポート
torch.onnx.export(
    model,
    inputs,
    "d:\\ダウンロード\\LaMa_models\\LaMa_models\\lama-places\\lama-regular\\models\\best.onnx",
    export_params=True,
    opset_version=17,
    do_constant_folding=True,
    input_names=['image', 'mask'],
    output_names=['output'],
    dynamic_axes={
        'image': {0: 'batch_size'},
        'mask': {0: 'batch_size'},
        'output': {0: 'batch_size'}
    },
    verbose=False  # 詳細ログ抑制
)

print("Export completed!")

５．ONNXRUNTIME-DirectMLで推論してinpaintしてみる

出力したONNX DirectMLで推論してinpaintできるかを確認しました。
特にエラーや警告もなく実行できているので、良さそうです。

lama-regular onnx-directmlテストコード（Windows Copilot作成）

lama_test.py

import onnxruntime as ort
import numpy as np
from PIL import Image
import cv2

# ======== 設定 ========
# onnx_path = "lama.onnx"
onnx_path = "d:\\ダウンロード\\LaMa_models\\LaMa_models\\lama-places\\lama-regular\\models\\best.onnx"
# input_image_path = "input.png"
input_image_path = "D:\\ダウンロード\\lukasz-szmigiel-jFCViYFYcus-unsplash.jpg"
# mask_image_path = "mask.png"
mask_image_path = "D:\\lama\\my_data\\val\\masks\\vlcsnap-2024-09-02-18h05m32s103_crop000_mask000.png"
output_compare_path = "compare.png"

# ======== セッション作成（CPU or DirectML） ========
# CPU
# sess = ort.InferenceSession(onnx_path, providers=["CPUExecutionProvider"])

# DirectML (GPU)
sess = ort.InferenceSession(onnx_path, providers=["DmlExecutionProvider"])

# ======== 画像読み込み ========
def load_rgb(path):
    img = Image.open(path).convert("RGB").resize((512, 512))
    arr = np.array(img).astype(np.float32) / 255.0
    arr = arr.transpose(2, 0, 1)  # HWC → CHW
    return arr

def load_mask(path):
    img = Image.open(path).convert("L").resize((512, 512))
    arr = np.array(img).astype(np.float32) / 255.0
    arr = np.expand_dims(arr, axis=0)  # (1, H, W)
    return arr

image = load_rgb(input_image_path)
mask = load_mask(mask_image_path)

# バッチ次元追加
image_batch = np.expand_dims(image, axis=0)
mask_batch = np.expand_dims(mask, axis=0)

# ======== 推論 ========
inputs = {
    "image": image_batch,
    "mask": mask_batch
}

output = sess.run(None, inputs)[0]  # (1, 3, H, W)
output = output[0].transpose(1, 2, 0)  # CHW → HWC
output = np.clip(output, 0, 1)

# ======== 合成（inpaint） ========
# mask=1 の部分を output で置き換える
mask_3ch = np.repeat(mask.transpose(1, 2, 0), 3, axis=2)
composited = image.transpose(1, 2, 0) * (1 - mask_3ch) + output * mask_3ch

# ======== 比較画像を作成 ========
def to_uint8(img):
    return (img * 255).astype(np.uint8)

input_vis = to_uint8(image.transpose(1, 2, 0))
mask_vis = to_uint8(mask.transpose(1, 2, 0))
mask_vis = cv2.cvtColor(mask_vis, cv2.COLOR_GRAY2RGB)
output_vis = to_uint8(output)
comp_vis = to_uint8(composited)

# 横に並べる
compare = np.hstack([input_vis, mask_vis, output_vis, comp_vis])
compare_bgr = cv2.cvtColor(compare, cv2.COLOR_RGB2BGR)
cv2.imwrite(output_compare_path, compare_bgr)

# # 保存
# cv2.imwrite(output_compare_path, compare)

print("比較画像を保存しました:", output_compare_path)

処理結果は次のような感じでした。
左からオリジナル、マスク、ONNX-DirectML推論、入出力合成の画像になります。
そこまで大きなマスクではありませんが、大きな違和感なく埋められているように見えます。

なおLaMa-Dilatedでも問題なく推論できinpaintできました。
ただなぜかLaMa-Regularの方がなぜか良さそうに見えました。（学習データの差？）

LaMa-Regularを学習する

１．フォルダを準備する。

事前学習済みモデルや学習データを置くフォルダを準備します。

LAMA
├─ pretrained_model
└─ my_dataset
   ├─ eval
   ├─ train
   ├─ val
   └─ visual_test

２．事前学習済みモデルをpretrained_modelにコピーする

チェックポイントのbest.ckptとコンフィグのconfig.yamlをフォルダに保存します。
（パスに日本語が入るとHydraがエラーになりました）

３．学習データを準備する。

学習データ準備のポイントは2つです。

1. 明確に消したいものがある場合には、それが映っていない画像を準備する
   LAMAはGANなので、明確に消したい対象がわかっている場合には、その対象が映っていない画像を準備する方がいいと思われます。
2. valデータは、画像とマスクのセットで準備する
   trainフォルダの画像は、その都度マスクを生成して学習を行いますが、valについては画像とマスクを固定した状態で評価が行われます。
   LAMAにはval画像を生成するスクリプトが準備されており、bin\gen_mask_dataset.pyがそれです。
   マスク生成の設定、入力フォルダ、出力フォルダ、対象画像ファイルのサフィックスという感じで指定します。
   マスク生成設定はconfigs\data_gen\にいくつかあります。

python bin\gen_mask_dataset.py configs\data_gen\random_medium_512.yaml D:\lama\my_data\val\images D:\lama\my_data\val\masks --ext jpg

実行すると出力フォルダには、例えば下記のように画像とマスクが対になって出力されます。
このセットでvalに保存します。

image_crop000.png
image_crop000_mask000.png

４．YAMLファイルを新規に追加

configs\training\location\my_dataset.yaml
configs\training\my_regular.yaml
を新規に作成します。

configs\training\my_regular.yamlについては、まだちょっと綺麗ではないと思ってます。不要な指示がたくさんありそう

configs\training\location\my_dataset.yaml

data_root_dir: D:/lama/my_dataset  # 絶対パス
out_root_dir: D:/lama/experiments
tb_dir: D:/lama/tb_logs

configs\training\my_regular.yaml

defaults:  # 警告解決のため追加
  - _self_  # これでデフォルト順序を明示
  - location: my_dataset  # データセットをdefaultsに含めて +location不要に（オプション）
  - optimizers: default_optimizers
  
model:
  kind: pix2pixhd_global
location:
  data_root_dir: my_dataset
  out_root_dir: experiments
  tb_dir: tb_logs
data:
  train:
    indir: ${location.data_root_dir}/train  # トレーニング画像のディレクトリ
    mask_generator_kind: mixed  # マスク生成方法 mixed,outpainting,dumb
  val:
    indir: ${location.data_root_dir}/val  # validation画像とマスクのディレクトリ
    img_suffix: .png  # 画像の拡張子（通常.png）
  visual_test:
    indir: ${location.data_root_dir}/visual_test
    img_suffix: .png  # 画像の拡張子（通常.png）
  eval:
    indir: ${location.data_root_dir}/eval
    img_suffix: .png  # 画像の拡張子（通常.png）
  batch_size: 4  # 調整
  num_workers: 0  # ← Windows必須！（>0でエラー多発）
  
trainer:
  kwargs:
    gpus: 1  # 使用するGPU数（1で単一GPU、-1で全GPU）
    # accelerator: ddp  # GPUが使えない場合、またはテスト用に 'cpu' を指定。GPU使用時は 'ddp' など
    max_epochs: 50  # トレーニングのエポック数
    # limit_train_batches: 10  # トレーニングバッチを制限（デバッグ用）
    val_check_interval: 1  # 検証間隔
    limit_val_batches: 1.0
    num_sanity_val_steps: 0  # サニティチェックをスキップ
    precision: 32  # 精度（16で混合精度）
  checkpoint_kwargs:
    verbose: True
    save_top_k: 1  # ベストモデルを1つ保存
    save_last: True  # 最後のモデルを保存
    monitor: train_gen_l1  # 監視メトリクス（適宜変更）
    mode: min  # min で損失を最小化

visualizer:
  kind: noop  # 'noop' でビジュアライズ無効。有効にしたい時は'directory'
  outdir: visualizations  # 出力ディレクトリ（train.pyで使用）

training_model:  
  kind: default  # LaMaの標準トレーニングモード
  visualize_each_iters: 100  # 視覚化間隔（テスト時は小さく）
  concat_mask: true  # マスクを入力に連結
  store_discr_outputs_for_vis: true  # 識別器出力の保存（ビジュアライズ用）

generator:
  kind: pix2pixhd_global
  input_nc: 4
  output_nc: 3
  ngf: 64
  n_downsampling: 3
  n_blocks: 9
  conv_kind: default
  add_out_act: sigmoid

discriminator:
  kind: pix2pixhd_nlayer
  input_nc: 3
  ndf: 64
  n_layers: 4

evaluator:
  kind: default
  inpainted_key: inpainted
  integral_kind: ssim_fid100_f1

losses:  # 損失関数定義（finetuning時は調整）
  l1:  # L1損失
    weight_missing: 1  # マスク部（欠損）の重み（regular版で大マスク対応強化なら増やす）
    weight_known: 0  # 非マスク部の重み
  perceptual:  # 知覚損失
    weight: 1
  adversarial:  # GAN損失（オプションだが推奨）
    kind: r1
    weight: 0.01
    gp_coef: 10
    mask_as_fake_target: true
    allow_scale_mask: true
  feature_matching:  # 特徴マッチング
    weight: 10
  resnet_pl:  # ResNetベースの知覚損失
    weight: 10
    weights_path: ${env:TORCH_HOME}  # pretrained重みのベースパス（環境変数）

run_title: my_lama_regular_ft_win

４．コードを一部修正する。

Windowsで動作させるため、
bin\train.py
saicinpainting\training\data\masks.py
のコードを修正をします。

bin\train.py

Windows OSでは、Pythonのmultiprocessingがデフォルトで'spawn'メソッドを使うよう設計されていますが、PyTorchの分散トレーニング（例: Distributed Data Parallel, DDP）やCUDA/GPUを活用したマルチプロセス処理の場合、明示的に'spawn'を設定しないとエラーが発生しやすいです。
主な問題点は：

• Unix系OS（Linuxなど）ではデフォルトの'fork'メソッドが使えますが、Windowsは'fork'をサポートしていません。
• 'fork'を使うと、CUDAコンテキストの再初期化に失敗し、RuntimeError: Cannot re-initialize CUDA in forked subprocess などのエラーが出ることがあります。

'spawn'メソッドは、各子プロセスを新しいPythonインタープリタで起動するため、親プロセスの状態を継承せずクリーンに初期化されます。これにより、GPUメモリの競合やCUDA関連の不具合を回避できます。特にmulti-GPUやデータローダーのnum_workersを増やした場合に有効です

bin\train.py

import logging
import os
import sys
import traceback

+ import torch.multiprocessing as mp
+ if __name__ == '__main__':
+     mp.set_start_method('spawn', force=True)

os.environ['OMP_NUM_THREADS'] = '1'
os.environ['OPENBLAS_NUM_THREADS'] = '1'
os.environ['MKL_NUM_THREADS'] = '1'
os.environ['VECLIB_MAXIMUM_THREADS'] = '1'
os.environ['NUMEXPR_NUM_THREADS'] = '1'

saicinpainting\training\data\masks.py

Detectron2をセットアップしていないため、物体セグメント検出を無効にします。

saicinpainting\training\data\masks.py

class MixedMaskGenerator:
    def __init__(self, irregular_proba=1/3, irregular_kwargs=None,
                 box_proba=1/3, box_kwargs=None,
-                #  segm_proba=1/3, segm_kwargs=None,
+                segm_proba=0, segm_kwargs=None, # Detectron2 なし対応
                 squares_proba=0, squares_kwargs=None,
                 superres_proba=0, superres_kwargs=None,
                 outpainting_proba=0, outpainting_kwargs=None,
                 invert_proba=0):
        self.probas = []
        self.gens = []

train.pyを実行する

python bin/train.py -cn my_regular +location.checkpoint_dir=D:\lama\pretrained_model data.batch_size=8

動いた！

本番の学習データでないにせよ、この評価値だったらファインチューニングいらｎ

動かしてみての感想（LAMAとはあまり関係がありません）

• 論文は2021年？コードは2022年？
  現在からまだ5年ほど前のことですが、Pythonパッケージの依存関係や関数などの廃止で、動き出す環境づくりに苦労しました。
  Pythonの仕組み上の問題もあるとは思いますが、現在の開発や発展のスピードに改めて驚きました。
  リポジトリは、あまり更新はされていないようですが、枯れた技術で私が動かせたように現在でも動かせている人が多く、もしくはこれとは別の手段で対応できている、ということなのだと思います。
• 技術力なし生成AI無課金勢による環境構築や設定
  LAMAをWindowsネイティブで動作させたという情報は少なめで、公式のISSUEで目にする程度でした。
  私の能力では依存関係を回避する環境づくり、実行時のエラー回避は無理だった思います。
  今回は、GrokとWindows Copilotにとても助けられました。
  Grokはインターネット情報検索とその情報のまとめにとても長けており、LAMAを動かし始めるYAML設定や環境変数、最小限のコードへのパッチなどで力を発揮してくれました。コードの生成はあまり試していませんが、MCPやエージェント含めてかなり良いモデルなんですかね？
  Windows Copilotは、この世に存在しない?LaMa-LITEが最適と言ったり、"LaMa-LITE"として動かすためにすぐにコードにパッチをして回避しようとするなど、なかなか苦労しました（一度リセットしてやり直した）。ただPythonのパッケージ依存関係回避にはとても役に立ちました。
  ローカルLLM含めいろんなAIモデルが百花繚乱ですが、それぞれに得手不得手があり、感触を確かめながら今後もうまく付き合っていきたいと思います。
• 最後に
  このLLM・Agent全盛の時代に画像処理ですかとも思いますが、誰かの参考になれば幸いです。
  （そんなやついるー？いねぇよなー？）