AI_Program3 のバックアップ(No.10) - PukiWiki

[ トップ ] [ 一覧 | 検索 | 履歴 | ログイン ]

私的AI研究会 > AI_Program3

生成 AI プログラミング３ == 編集中 == †

　これまで検証してきた結果をもとに、Python で生成 AI プログラムを書く

▲　目　次

生成 AI プログラミング３ == 編集中 ==
参考資料

※ 最終更新:2025/06/24　

diffusersではじめめる Stable Diffusion （実践編） †

　画像生成のプログラムを書く

動作環境 †

このプロジェクトは以下の Anaconda 仮想環境とプロジェクト・フォルダで動作する
```
(base) PS > conda activate sd_test
(sd_test) PS > cd workspace_3/sd_test
```

Step 40：テキストから画像を生成する †

　「Stable Diffusion」txt2img 機能を使う最低限の基本サンプル・コード

「sd_040.py」

## sd_040.py【SD1.5】　テキストから画像生成（txt2img）サンプル・ソースコード
##      Ver. 1.00   2025/06/16

import torch
from diffusers import StableDiffusionPipeline, logging
from translate import Translator

logging.set_verbosity_error()

# モデルのフォルダーのパス
model_path = "/StabilityMatrix/Data/Models/StableDiffusion/SD1.5/v1-5-pruned-emaonly.safetensors"        # モデル

# GPUを使う場合は"cuda" 使わない場合は"cpu"
device = 'cuda'

# seed 値
seed = 12345678

# パイプラインを作成
pipeline = StableDiffusionPipeline.from_single_file(model_path).to(device)

# プロンプト
trans = Translator('en','ja').translate
prompt_jp = '満開の蘭'                                                                                   # プロンプト
prompt = trans(prompt_jp)

# Generatorオブジェクト作成
generator = torch.Generator(device).manual_seed(seed)

print(f'Seed: {seed}, Model: {model_path}')
print(f'prompt : {prompt_jp} → {prompt}')

# 画像を生成
image = pipeline(
                    prompt=prompt,
                    num_inference_steps = 30,
                    guidance_scale = 7.5,
                    width = 512,
                    height = 512,
                    generator = generator,
                    ).images[0]
image.save("results/sd_040.png")                                                                     # 生成画像

プログラムを実行する（実行時間：約 3秒 RTX 4070 Ti 12GB）

(sd_test) PS > python sd_040.py

Fetching 11 files: 100%|████████████████████| 11/11 [00:00<00:00, 11048.21it/s]
Loading pipeline components...: 100%|████████████| 6/6 [00:00<00:00,  8.85it/s]
Seed: 12345678, Model: /StabilityMatrix/Data/Models/StableDiffusion/SD1.5/v1-5-pruned-emaonly.safetensors
prompt : 満開の蘭 → Orchid in full bloom
100%|██████████████████████████████████████████| 30/30 [00:03<00:00,  8.31it/s]

画像ファイル「sd_040.png」が生成される

Step 41：　～コマンドラインからパラメータ入力～ †

主な機能
・コマンドラインから「diffusers」の各種パラメータにアクセスできる
・パラメータを付けない場合は初期値で動作する（すべてつけない場合は sd_040.py と同じ結果）
・SD1.5 と SDXL のモデルに対応する（SD1.5 モデルは「SD1.5/」ディレクトリ名のフォルダに配置されていることを前提にする）
・日本語/英語のプロンプト入力に対応（日本語の場合は自動翻訳で対応）
・以後のプログラムからアクセスできることを意識してできるだけ API 関数とした

出力ファイルの保存場所とファイル名（--result_image ' デフォールト指定の時）
・「./sd_results」フォルダに保存される（無ければ作られる）
・ファイル名「sd_5桁の連番_シード値.png」

コマンドオプション一覧

コマンドオプション	引数	初期値	意味
--result_image	str	'./sd_results/sd.png'	保存するファイルパスとヘッダ名の指定
--cpu	bool	False	cpu mode.
--log	int	3	Log level(-1/0/1/2/3/4/5)
--model_dir	str	'/StabilityMatrix/Data/Models/StableDiffusion'	モデルフォルダのパス
--model_path	str	'SD1.5/v1-5-pruned-emaonly.safetensors'	モデルファイル
--prompt	str	満開の蘭	画像生成のためのプロンプト（日本語/英語）
--seed	int	-1	シード値（-1の時はランダムに生成）
--width	int	512	生成画像サイズの幅
--height	int	512	生成画像サイズの高さ
--step	int	30	生成ステップ数
--scale	float	7.5	ガイダンススケール値

コマンド実行例

(sd_test) PS > python sd_041.py

Stable Diffusion with diffusers(041)  Ver 0.01: Starting application...

   - result_image            :  ./sd_results/sd.png
   - cpu                     :  False
   - log                     :  3

   - model_path              :  /StabilityMatrix/Data/Models/StableDiffusion/SD1.5/v1-5-pruned-emaonly.safetensors
   - prompt                  :  満開の蘭
   - seed                    :  -1
   - width                   :  512
   - height                  :  512
   - step                    :  30
   - scale                   :  7.5

prompt: Orchid in full bloom
size: 512, 512
seed: 2008793823
Fetching 11 files: 100%|███████████████████████████████| 11/11 [00:00<?, ?it/s]
Loading pipeline components...: 100%|████████████| 6/6 [00:00<00:00,  9.50it/s]
100%|██████████████████████████████████████████| 30/30 [00:03<00:00,  8.17it/s]
result_file: ./sd_results/sd_00010_2272584812.png

processing start >>      2025/06/17 15:21:30
processing end >>        2025/06/17 15:21:39
processing time >>       0:00:09.063929

Finished.

モジュール・ソースコード

▼「sd_041.py」

# -*- coding: utf-8 -*-
##--------------------------------------------------
##  Stable Diffusion with diffusers(041)   Ver 0.01
##
##               2025.06.17 Masahiro Izutsu
##--------------------------------------------------
## sd_041.py
##  Ver 0.01    2025.06.17  SD1.5/SDXL 対応版

import warnings
warnings.simplefilter('ignore')

# Color Escape Code
GREEN = '\033[1;32m'
RED = '\033[1;31m'
NOCOLOR = '\033[0m'
YELLOW = '\033[1;33m'
CYAN = '\033[1;36m'
BLUE = '\033[1;34m'

# インポート＆初期設定
import os
import argparse
import glob
import re
import random
import torch
from diffusers import StableDiffusionPipeline, logging          # SD1.5
from diffusers import StableDiffusionXLPipeline, logging        # SDXL
from translate import Translator

import my_logging

logging.set_verbosity_error()                                   # 不要なエラー出力の抑制

# 定数定義
DEF_RESULT_IMAGE = './sd_results/sd.png'
DEF_MODEL_DIR = '/StabilityMatrix/Data/Models/StableDiffusion'
DEF_MODEL_PATH = 'SD1.5/v1-5-pruned-emaonly.safetensors'
#DEF_MODEL_PATH = '/StabilityMatrix/Data/Models/StableDiffusion/sd_xl_base_1.0.safetensors'
DEF_SEED = -1
DEF_PROMPT = '満開の蘭'
DEF_STEP = 30
DEF_SCALE = 7.5
DEF_WIDTH = 512
DEF_HEIGHT = 512

# タイトル
title = 'Stable Diffusion with diffusers(041)  Ver 0.01'

# Parses arguments for the application
def parse_args():
    parser = argparse.ArgumentParser()
    parser.add_argument("--result_image", default = DEF_RESULT_IMAGE, help = "path to output image file")
    parser.add_argument("--cpu", dest = "cpu", action = "store_true", help = "cpu mode.")
    parser.add_argument('--log', metavar = 'LOG', default = '3', help = 'Log level(-1/0/1/2/3/4/5) Default value is \'3\'')

    parser.add_argument("--model_dir", default = DEF_MODEL_DIR, help = "Model directory")
    parser.add_argument("--model_path", default = DEF_MODEL_PATH, help = "Model Path")
    parser.add_argument("--prompt", default = DEF_PROMPT, help = "Prompt text")
    parser.add_argument("--seed", default = DEF_SEED, help = "Seed parameter (-1 = rundom")
    parser.add_argument("--width", default = DEF_WIDTH, help = "image size width")
    parser.add_argument("--height", default = DEF_HEIGHT, help = "image size height")
    parser.add_argument("--step", default = DEF_STEP, help = "infer step")
    parser.add_argument("--scale", default = DEF_SCALE, help = "gaidanse scale")
    return parser

# 基本情報の表示
def display_info(opt, title):
    print('\n' + GREEN + title + ': Starting application...' + NOCOLOR)
    print('\n   - ' + YELLOW + 'result_image            : ' + NOCOLOR, opt.result_image)
    print('   - ' + YELLOW + 'cpu                     : ' + NOCOLOR, opt.cpu)
    print('   - ' + YELLOW + 'log                     : ' + NOCOLOR, opt.log)

    print('\n   - ' + YELLOW + 'model_dir               : ' + NOCOLOR, opt.model_dir)
    print('   - ' + YELLOW + 'model_path              : ' + NOCOLOR, opt.model_path)
    print('   - ' + YELLOW + 'prompt                  : ' + NOCOLOR, opt.prompt)
    print('   - ' + YELLOW + 'seed                    : ' + NOCOLOR, opt.seed)
    print('   - ' + YELLOW + 'width                   : ' + NOCOLOR, opt.width)
    print('   - ' + YELLOW + 'height                  : ' + NOCOLOR, opt.height)
    print('   - ' + YELLOW + 'step                    : ' + NOCOLOR, opt.step)
    print('   - ' + YELLOW + 'scale                   : ' + NOCOLOR, opt.scale)
    print(' ')


# フォルダ内で連番のファイル名を得る（ヘッダ + 連番 で検索）
#   in:     filename    ヘッダー名.拡張子
#           seq_digit   連番桁数
#           ex          追加文字列
#   out:    新しいファイル名

def make_filename_by_seq(dirname, filename, seq_digit = 3, ex = ''):
    filename_without_ext, ext = os.path.splitext(filename)
    pattern = f"{filename_without_ext｝_([0-9]*){ext｝"
    prog = re.compile(pattern)
    files = glob.glob(
        os.path.join(dirname, f"{filename_without_ext｝_[0-9]*{ext｝")
    )

    max_seq = -1
    kn = len(filename_without_ext) + seq_digit + 1                  # ヘッダ + 連番桁数 + 1 (_)
    for f in files:
        fn0, _ = os.path.splitext(os.path.basename(f))
        fn1 = fn0[: min(len(fn0), kn)] + ext
        m = prog.match(os.path.basename(fn1))                       # ファイル名 kn まで比較
        if m:
            max_seq = max(max_seq, int(m.group(1)))

    new_filename = f"{filename_without_ext｝_{max_seq+1:0{seq_digit｝｝_{ex｝{ext｝"
    
    return new_filename

# モデルを調べる（SD1.5 モデルは SD1.5/フォルダ内にある前提）
#   in:     model       モデル名
#   out:    bool        True = SD1.5, False = SDXL
def is_sd15(model):
    return ('SD1.5' in model)

# 画像生成
def image_generation(model, prompt, seed, num_inference_steps = 50, guidance_scale = 7.0, width = 512, height = 512, device = 'cpu'):
    # パイプラインを作成
    if is_sd15(model):
        pipeline = StableDiffusionPipeline.from_single_file(model).to(device)
    else:
        pipeline = StableDiffusionXLPipeline.from_single_file(model, torch_dtype = torch.float16).to(device)

    # Generatorオブジェクト作成
    generator = torch.Generator(device).manual_seed(seed)

    # 画像を生成
    img = pipeline(
                    prompt = prompt,
                    num_inference_steps = num_inference_steps,
                    guidance_scale = guidance_scale,
                    width = width,
                    height = height,
                    generator = generator
                    ).images[0]
    return img

# メモリー開放
def device_empty_cache(device):
    if device == 'cuda':
        torch.cuda.empty_cache()
    elif device == 'mps':
        torch.mps.empty_cache()

## === ↓↓↓ diffusers parameter ↓↓↓ ===

# log 出力
def log_debug(msg, logger):
    if logger is not None:
        logger.debug(msg)

def log_info(msg, logger):
    if logger is not None:
        logger.info(msg)

# -- device --
def _get_device(opt, logger = None):
    gpu_d = torch.cuda.is_available()                           # GPU 確認
    if not opt.cpu and not gpu_d:
        opt.cpu = True
    device = 'cpu' if opt.cpu else 'cuda'
    log_debug(f'device: {device｝', logger)
    return device

# -- result_path --
def _get_result_path(opt, logger = None):
    result_path = os.path.dirname(opt.result_image)
    log_debug(f'result_path: {result_path｝', logger)
    return result_path

# -- result_file --
def _get_result_file(opt, logger = None):
    result_file = os.path.basename(opt.result_image)
    log_debug(f'result_file: {result_file｝', logger)
    return result_file

# -- prompt --
def _get_prompt(opt, logger = None):
    prompt = _get_prompt2(opt.prompt)
    log_info(f'prompt: {prompt｝', logger)
    return prompt

def _get_prompt2(str):
    if len(str) != len(str.encode('utf-8')):
        trans = Translator('en','ja').translate
        prompt = trans(str)                                     # 日本語→英語
    else:
        prompt = str
    return prompt

# -- model_path --
def _get_model_path(opt, logger = None):
    model_path = opt.model_dir + '/' + opt.model_path
    log_debug(f'model_path: {model_path｝', logger)
    return model_path

# -- height, width --
def _get_image_size(opt, logger = None):
    width = int(opt.width)
    height = int(opt.height)
    if not is_sd15(opt.model_path) and (width < 1024 or height < 1024):
        width = width * 2
        height = height * 2
    log_info(f'size: {width｝, {height｝', logger)
    return height, width

# -- seed --
def _get_seed_value(opt, logger = None):
    seed = _get_seed_value2(opt.seed)
    log_info(f'seed: {seed｝', logger)
    return seed

def _get_seed_value2(n):
    seed = int(n)
    if seed == -1:                                            # ランダムなシード値を決める
        seed = random.randint(0, 2**32-1)
    return seed

# -- num_inference_steps --
def _get_inference_steps(opt, logger = None):
    num_inference_steps = int(opt.step)
    log_debug(f'step: {num_inference_steps｝', logger)
    return num_inference_steps

# -- guidance_scale --
def _get_guidance_scale(opt, logger = None):
    guidance_scale = float(opt.scale)
    log_debug(f'scale: {guidance_scale｝', logger)
    return guidance_scale

## === ↑↑↑ diffusers parameter ↑↑↑ ===


# ** main関数 **
def main(opt):
    # パラメータ設定
    device = _get_device(opt, logger)
    result_path = _get_result_path(opt, logger)
    result_file = _get_result_file(opt, logger)
    prompt = _get_prompt(opt, logger)
    model_path = _get_model_path(opt, logger)
    height, width = _get_image_size(opt, logger)
    seed = _get_seed_value(opt, logger)
    num_inference_steps = _get_inference_steps(opt, logger)
    guidance_scale = _get_guidance_scale(opt, logger)

    # 出力フォルダ
    os.makedirs(result_path, exist_ok = True)

    # 画像生成
    image = image_generation(model_path, prompt, seed, num_inference_steps, guidance_scale, width, height, device)
    filename = result_path + '/' + make_filename_by_seq(result_path, result_file, seq_digit = 5, ex = seed)
    image.save(filename)
    logger.info(f'result_file: {filename｝')


# main関数エントリーポイント(実行開始)
if __name__ == "__main__":
    import datetime

    parser = parse_args()
    opt = parser.parse_args()
    display_info(opt, title)

    # アプリケーション・ログ設定
    module = os.path.basename(__file__)
    module_name = os.path.splitext(module)[0]
    logger = my_logging.get_module_logger_sel(module_name, int(opt.log))

    start_time = datetime.datetime.now()        # 時間計測開始

    main(opt)

    # 経過時間
    end_time = datetime.datetime.now()
    print(start_time.strftime('\nprocessing start >>\t %Y/%m/%d %H:%M:%S'))
    print(end_time.strftime('processing end >>\t %Y/%m/%d %H:%M:%S'))
    print('processing time >>\t', end_time - start_time)

    logger.info('\nFinished.\n')

　※ 上記ソースコードは表示の都合上、半角コード '}' が全角 '｝'になっていることに注意

Step 42：　～ GUI プログラム～【制作途中】 †

主な機能

コマンド実行例

(sd_test) PS > python sd_042.py

Stable Diffusion with diffusers(042)  Ver 0.01: Starting application...

   - result_image            :  ./sd_results/sd.png
   - cpu                     :  False
   - log                     :  3

   - model_dir               :  /StabilityMatrix/Data/Models/StableDiffusion
   - model_path              :  SD1.5/v1-5-pruned-emaonly.safetensors
   - prompt                  :  満開の蘭
   - seed                    :  -1
   - width                   :  512
   - height                  :  512
   - step                    :  30
   - scale                   :  7.5

prompt: Orchid in full bloom
size: 512, 512
** Start 1 **
Fetching 11 files: 100%|███████████████████████████████| 11/11 [00:00<?, ?it/s]
Loading pipeline components...: 100%|████████████| 6/6 [00:00<00:00, 20.38it/s]
100%|██████████████████████████████████████████| 30/30 [00:03<00:00,  8.51it/s]
result_file: ./sd_results/sd_00023_3411634370.png
** Complete ** 00:00:11

processing start >>      2025/06/23 17:22:04
processing end >>        2025/06/23 19:42:13
processing time >>       2:20:09.159391

Finished.

モジュール・ソースコード

▼「sd_042.py」

# -*- coding: utf-8 -*-
##--------------------------------------------------
##  Stable Diffusion with diffusers(042)   Ver 0.01
##      GUI interface
##               2025.06.17 Masahiro Izutsu
##--------------------------------------------------
## sd_042.py
##  Ver 0.00    2025.06.17  GUI 対応版
##  Ver 0.01    2025.06.20  Loop count

import warnings
warnings.simplefilter('ignore')

# Color Escape Code
GREEN = '\033[1;32m'
RED = '\033[1;31m'
NOCOLOR = '\033[0m'
YELLOW = '\033[1;33m'
CYAN = '\033[1;36m'
BLUE = '\033[1;34m'

# インポート＆初期設定
import os
import numpy as np
import random
import time
import csv
import cv2
import PySimpleGUI as sg
import sd_041 as sd
import my_logging
import my_csv
import my_thumbnail

# 定数定義
DEF_THEME = 'BlueMono'
CANVAS_SIZE = 512
KEY_CANCEL = '-Cancel-'

KEY_IMAGE = '-Image-'
KEY_OUTPATH = '-Output-'
KEY_MODEL = '-Model-'
KEY_MODELSEL = '-Model_sel-'
KEY_PROMPT_JP = '-PromptJP-'
KEY_PROMPT = '-Prompt-'
KEY_WIDTH = '-Width-'
KEY_HEIGHT = '-Height-'
KEY_SEED_INPUT = '-Seed_input-'
KEY_SEED = '-Seed-'
KEY_STEP = '-Step-'
KEY_SCALE = '-Scale-'
KEY_CPU = '-CPU-'
KEY_GPU = '-GPU-'
KEY_DEVICE = '-Device-'
KEY_EXIT = '-Exit-'
KEY_GENERATE = '-Generate-'
KEY_LOOP = '-Loop-'

SKEY_RESULT_PATH = '-result_path-'
SKEY_RESULT_FILE = '-result_file-'
SKEY_MODEL_DIR = '-model_dir-'
SKEY_DEF_OUTPATH = '-default_image-'

KEY_TIME = '-Time-'

DEF_IMAGE = './sd_results/sd_00000_12345678.png'
CSV_LOG_FILE = 'result.csv'

# タイトル
title = 'Stable Diffusion with diffusers(042)  Ver 0.01'

# ウィジェットのデータの取得（1回目）
def get_paramlist(window, values, param):
    param[KEY_MODEL] = window[KEY_MODEL].DisplayText
    param[KEY_WIDTH] = int(values[KEY_WIDTH])
    param[KEY_HEIGHT] = int(values[KEY_HEIGHT])
    param[KEY_SEED] = sd._get_seed_value2(values[KEY_SEED_INPUT])
    param[KEY_STEP] = int(values[KEY_STEP])
    param[KEY_SCALE] = float(values[KEY_SCALE])
    param[KEY_DEVICE] = 'cpu' if values[KEY_CPU] == True else 'cuda'
    param[KEY_PROMPT_JP] = values[KEY_PROMPT_JP]
    param[KEY_PROMPT] = sd._get_prompt2(param[KEY_PROMPT_JP])

    param[KEY_LOOP] = int(values[KEY_LOOP])
    if param[KEY_LOOP] < 1:
        param[KEY_LOOP] = 1
    if param[KEY_LOOP] > 50:
        param[KEY_LOOP] = 50

# ウィジェットのデータの取得（2回目以降）
def get_paramlist2(window, values, param):
    if int(values[KEY_SEED_INPUT]) > 0:
        param[KEY_SEED] = param[KEY_SEED] + 1
    else:
        param[KEY_SEED] = sd._get_seed_value2(values[KEY_SEED_INPUT])

# 生成画像のファイル名からシード値を得る
def path2seed(filepath):
    s = os.path.splitext(os.path.basename(filepath))[0]
    n = s.rfind('_')
    return int(s[n + 1:])

# 経過時間(秒)を hh:mm:ssフォーマットに変換
def elapsed_time_str(seconds):
    seconds = int(seconds + 0.5)                                # 秒数を四捨五入
    h = seconds // 3600                                         # 時の取得
    m = (seconds - h * 3600) // 60                              # 分の取得
    s = seconds - h * 3600 - m * 60                             # 秒の取得
    return f"{h:02｝:{m:02｝:{s:02｝"                              # hh:mm:ss形式の文字列で返す

# 結果を CSV ファイルに残す
def result_csv(csvfile, param, logger):
    my_csv_treatment = my_csv.CSVtreatment(csvfile, 'utf_8_sig')
    s = my_csv_treatment.read_csv()
    if len(s) ==0:
        data = []
        data.append(KEY_OUTPATH)
        data.append(KEY_SEED)
        data.append(KEY_PROMPT_JP)
        data.append(KEY_PROMPT)
        data.append(KEY_WIDTH)
        data.append(KEY_HEIGHT)
        data.append(KEY_STEP)
        data.append(KEY_SCALE)
        data.append(SKEY_MODEL_DIR)
        data.append(KEY_MODEL)
        data.append(KEY_DEVICE)
        data.append(KEY_TIME)
        data.append(KEY_LOOP)
        my_csv_treatment.write_csv(data)
        logger.debug(data)

    data = []
    data.append(param[KEY_OUTPATH])
    data.append(str(param[KEY_SEED]))
    data.append(param[KEY_PROMPT_JP])
    data.append(param[KEY_PROMPT])
    data.append(str(param[KEY_WIDTH]))
    data.append(str(param[KEY_HEIGHT]))
    data.append(str(param[KEY_STEP]))
    data.append(str(param[KEY_SCALE]))
    data.append(param[SKEY_MODEL_DIR])
    data.append(param[KEY_MODEL])
    data.append(param[KEY_DEVICE])
    data.append(param[KEY_TIME])
    data.append(param[KEY_LOOP])
    my_csv_treatment.append_csv(data)
    logger.debug(data)

# 結果ログからパラメータを取得
def read_result_csv(csvfile, param, logger, imgfile = '0' ):
    bf = False

    try:
        with open(csvfile, 'r', encoding = 'utf_8_sig') as f:
            reader = csv.DictReader(f)
            if imgfile == '0':                                  # 最初の行
                for dd in reader:
                    bf = True
                    break

            elif imgfile == '1':                                # 最後の行
                for dd in reader:
                    bf = True
                    continue

            else:                                               # 出力ファイルの行
                for dd in reader:
                    if dd[KEY_OUTPATH] == imgfile:
                        bf = True
                        break

    except FileNotFoundError as e:
        logger.error(e)
    except csv.Error as e:
        logger.debug(e)

    if bf:
        param[KEY_OUTPATH] = dd[KEY_OUTPATH]
        param[KEY_SEED_INPUT] = int(dd[KEY_SEED])               # シード値を固定
        param[KEY_PROMPT_JP] = dd[KEY_PROMPT_JP]
        param[KEY_PROMPT] = dd[KEY_PROMPT]
        param[KEY_WIDTH] = int(dd[KEY_WIDTH])
        param[KEY_HEIGHT] = int(dd[KEY_HEIGHT])
        param[KEY_STEP] = int(dd[KEY_STEP])
        param[KEY_SCALE] = float(dd[KEY_SCALE])
        param[SKEY_MODEL_DIR] = dd[SKEY_MODEL_DIR]
        param[KEY_MODEL] = dd[KEY_MODEL]
        param[KEY_DEVICE] = dd[KEY_DEVICE]
        logout_data(dd, logger)
    return bf

# 動的パラメータの出力
def logout_data(dd, logger):
    logger.debug('---------------------------------------------')
    logger.debug(dd[KEY_OUTPATH])
    logger.debug(int(dd[KEY_SEED]))
    logger.debug(dd[KEY_PROMPT_JP])
    logger.debug(dd[KEY_PROMPT])
    logger.debug(int(dd[KEY_WIDTH]))
    logger.debug(int(dd[KEY_HEIGHT]))
    logger.debug(int(dd[KEY_STEP]))
    logger.debug(float(dd[KEY_SCALE]))
    logger.debug(dd[SKEY_MODEL_DIR])
    logger.debug(dd[KEY_MODEL])
    logger.debug(dd[KEY_DEVICE])
    logger.debug('---------------------------------------------')

# 画像生成
def generate_image(param):
    model = param[SKEY_MODEL_DIR] + '/' + param[KEY_MODEL]
    prompt = param[KEY_PROMPT]
    width = param[KEY_WIDTH]
    height = param[KEY_HEIGHT]
    seed = param[KEY_SEED]
    num_inference_steps = param[KEY_STEP]
    guidance_scale = param[KEY_SCALE]
    device = param[KEY_DEVICE]
    out_path = param[SKEY_RESULT_PATH] + '/' + sd.make_filename_by_seq(param[SKEY_RESULT_PATH], param[SKEY_RESULT_FILE], seq_digit = 5, ex = seed)
    param[KEY_OUTPATH] = out_path

    logger.debug(f'model: {model｝')
    logger.debug(f'prompt: {prompt｝')
    logger.debug(f'width: {width｝')
    logger.debug(f'height: {height｝')
    logger.debug(f'seed: {seed｝')
    logger.debug(f'num_inference_steps: {num_inference_steps｝')
    logger.debug(f'guidance_scale: {guidance_scale｝')
    logger.debug(f'device: {device｝')
    logger.debug(f'loop: {param[KEY_LOOP]｝')
    logger.debug(f'out_path: {out_path｝')

    image = sd.image_generation(model, prompt, seed, num_inference_steps, guidance_scale, width, height, device)
    image.save(out_path)
    logger.info(f'result_file: {out_path｝')

    sd.device_empty_cache(device)                               # メモリー開放


# ** main関数 **
def main(opt, logger):
    # ------------------------------------------
    # キャンバスをクリア
    def clear_canvas(key, msg, color):
        frame = np.zeros((CANVAS_SIZE, CANVAS_SIZE, 3), np.uint8)
        frame[:,:,] = 0xf0
        return msg_out_canvas(key, frame, msg, color)

    def msg_out_canvas(key, frame, msg, color):
        x0,y0,x1,y1 = cv2_putText(img=frame, text=msg, org=(CANVAS_SIZE//2, CANVAS_SIZE//2), fontFace=font_face, fontScale=16,  color=color, mode=2,areaf=True)
        cv2.rectangle(frame,(x0-8, y0), (x1+8, y1), (0xf0,0xf0,0xf0), -1)
        img = cv2_putText(img=frame, text=msg, org=(CANVAS_SIZE//2, CANVAS_SIZE//2), fontFace=font_face, fontScale=16,  color=color, mode=2)
        img = cv2.imencode('.png', frame)[1].tobytes()
        window[key].update(img)
        return frame

    # キャンバスへ画像の表示
    def update_canvas(key, imgfile):
        if os.path.isfile(imgfile):
            frame = cv2.imread(imgfile)
            frame = cv2.resize(frame, dsize = (CANVAS_SIZE, CANVAS_SIZE))
            img = cv2.imencode('.png', frame)[1].tobytes()
            window[key].update(img)
        else:
            frame = clear_canvas(key, 'Generate Image', (0,0,0))

        return frame

    # ウイジェットの更新
    def update_widget():
        frame = update_canvas(KEY_IMAGE, param[KEY_OUTPATH])
        window[KEY_OUTPATH].update(param[KEY_OUTPATH])
        window[KEY_SEED].update('')
        window[KEY_SEED_INPUT].update(param[KEY_SEED_INPUT])
        window[KEY_PROMPT_JP].update(param[KEY_PROMPT_JP])
        window[KEY_PROMPT].update(param[KEY_PROMPT])
        window[KEY_MODEL].update(param[KEY_MODEL])
        window[KEY_WIDTH].update(param[KEY_WIDTH])
        window[KEY_HEIGHT].update(param[KEY_HEIGHT])
        window[KEY_STEP].update(param[KEY_STEP])
        window[KEY_SCALE].update(param[KEY_SCALE])
        window[KEY_CPU].update(param[KEY_DEVICE] == 'cpu')
        window[KEY_GPU].update(param[KEY_DEVICE] == 'cuda')
        return frame

    # ------------------------------------------

    # パラメータ設定
    device = sd._get_device(opt, logger)
    result_path = sd._get_result_path(opt, logger)
    result_file = sd._get_result_file(opt, logger)
    prompt = sd._get_prompt(opt, logger)
    model_path = sd._get_model_path(opt, logger)
    height, width = sd._get_image_size(opt, logger)
    seed = path2seed(DEF_IMAGE)                                 # 初期ファイル名に含まれるシード値
    num_inference_steps = sd._get_inference_steps(opt, logger)
    guidance_scale = sd._get_guidance_scale(opt, logger)

    param = {｝
    param[KEY_OUTPATH] = DEF_IMAGE
    param[KEY_PROMPT_JP] = opt.prompt
    param[KEY_PROMPT] = prompt
    param[KEY_MODEL] = opt.model_path
    param[KEY_WIDTH] = width
    param[KEY_HEIGHT] = height
    param[KEY_SEED_INPUT] = opt.seed
    param[KEY_SEED] = seed
    param[KEY_STEP] = num_inference_steps
    param[KEY_SCALE] = guidance_scale
    param[KEY_DEVICE] = device
    param[KEY_LOOP] = 1
    param[KEY_TIME] = elapsed_time_str(0)
    param[SKEY_RESULT_PATH] = result_path
    param[SKEY_RESULT_FILE] = result_file
    param[SKEY_MODEL_DIR] = opt.model_dir
    logout_data(param, logger)
    csvfile = param[SKEY_RESULT_PATH]+ '/' + CSV_LOG_FILE       # 出力画像ログファイル名

    # 出力フォルダ
    os.makedirs(result_path, exist_ok = True)

    # フォント取得
    from my_puttext import get_font, cv2_putText
    font_face = get_font()

    # ウィンドウのテーマ
    sg.theme(DEF_THEME)

    canvas_img = sg.Image(size = (CANVAS_SIZE, CANVAS_SIZE), key=KEY_IMAGE)

    # ウィンドウのレイアウト
    layout = [[sg.Text('Stable Diffusion with diffusers', size=(30, 1), justification='center', font='Helvetica 20')],
              [canvas_img],
              [sg.Text("Output File", size=(14, 1)), sg.Text(param[KEY_OUTPATH], size=(48,1), key=KEY_OUTPATH)],
              [sg.Text("Model", size=(14, 1)), sg.Text(param[KEY_MODEL], size=(38,1), text_color='#008800', background_color='LightSteelBlue1', key=KEY_MODEL),sg.Button('Model', size=(6, 1), key=KEY_MODELSEL)],
              [sg.Text("Prompt input", size=(14, 1)), sg.Multiline(param[KEY_PROMPT_JP], size=(52,4), key=KEY_PROMPT_JP)],
              [sg.Text("Prompt", size=(14, 1)), sg.Multiline(param[KEY_PROMPT], size=(52,4), text_color='#008800', background_color='LightSteelBlue1', key=KEY_PROMPT)],
              [sg.Text("Image size (pixel)", size=(14, 1)), sg.Text("Width: ", size=(4, 1)), sg.Input(param[KEY_WIDTH], size=(10,1), key=KEY_WIDTH), sg.Text("Height: ", size=(4, 1)), sg.Input(param[KEY_HEIGHT], size=(10,1), key=KEY_HEIGHT)],

              [sg.Text("Seed  (-1=Random)", size=(14, 1)), sg.Input(param[KEY_SEED_INPUT], size=(20,1), key=KEY_SEED_INPUT), sg.Text(param[KEY_SEED], size=(20,1), text_color='#008800', background_color='LightSteelBlue1', key=KEY_SEED)],
              [sg.Text("Detail (Steps)", size=(14, 1)), sg.Slider((10, 150), float(param[KEY_STEP]), 1, orientation='h', size=(42, 5), key=KEY_STEP)],
              [sg.Text("Guidance Scale", size=(14, 1)), sg.Slider((1, 50), float(param[KEY_SCALE]), 0.1, orientation='h', size=(42, 5), key=KEY_SCALE)],
              [sg.Text("Device", size=(14, 1)), sg.Radio('CPU', group_id='device', default=(device == 'cpu'), key=KEY_CPU), sg.Radio("GPU", group_id='device', default=(device == 'cuda'), key=KEY_GPU)],
              [sg.Text("Loop count (1-50)", size=(14, 1)), sg.Input(param[KEY_LOOP], size=(2,1), justification='right', key=KEY_LOOP), sg.Text("", size=(4, 1)), sg.Button('Generate', size=(10, 1), key=KEY_GENERATE), sg.Text("", size=(10, 1)), sg.Button('Exit', size=(10, 1), key=KEY_EXIT)]
    ]

    # ウィンドウオブジェクトの作成
    window = sg.Window(title, layout, finalize=True, return_keyboard_events=True)

    # ユーザーイベントの定義
    canvas_img.bind('<ButtonPress>', '_click_on')

    # キャンバス初期化
    ss = param[KEY_SEED_INPUT]                                  # 最初のシード入力値
    bf = read_result_csv(csvfile, param, logger, '1')
    if bf:
        frame = update_widget()
        param[KEY_SEED] = param[KEY_SEED_INPUT]
        param[KEY_SEED_INPUT] = ss
        window[KEY_SEED].update(param[KEY_SEED])
        window[KEY_SEED_INPUT].update(param[KEY_SEED_INPUT] )
    else:
        frame = update_canvas(KEY_IMAGE, param[KEY_OUTPATH])

    param[SKEY_DEF_OUTPATH] = param[KEY_OUTPATH]                # 現在の画像パス

    new_make_f = False
    window[KEY_PROMPT].update(disabled = True)

    cv2.imwrite('test.png', frame)


    # イベントのループ
    while True:
        event, values = window.read(timeout = 30)

        # 画像生成
        if new_make_f:
            # 処理プロセス
            logger.info(f'{CYAN｝** Start {param[KEY_LOOP]｝ **{NOCOLOR｝')
            start_time = time.time()
            generate_image(param)
            param[KEY_TIME] = elapsed_time_str(time.time() - start_time)
            result_csv(csvfile, param, logger)

            frame = update_canvas(KEY_IMAGE, param[KEY_OUTPATH])
            param[SKEY_DEF_OUTPATH] = param[KEY_OUTPATH]        # 現在の画像パス
            window[KEY_OUTPATH].update(param[KEY_OUTPATH])
            param[KEY_LOOP] = param[KEY_LOOP] - 1
            window[KEY_LOOP].update(param[KEY_LOOP])

            if param[KEY_LOOP] < 1:
                param[KEY_LOOP] = 1
                window[KEY_LOOP].update(param[KEY_LOOP], disabled = False)
                window[KEY_GENERATE].update(disabled = False)
                window[KEY_EXIT].update(disabled = False)
                new_make_f = False
            else:
                get_paramlist2(window, values, param)
                window[KEY_SEED].update(param[KEY_SEED])

            logger.info(f'{CYAN｝** Complete **{NOCOLOR｝ {param[KEY_TIME]｝')

        # 終了
        if event == KEY_EXIT or event == sg.WIN_CLOSED:
            break

        # KEY_IMAGE
        if event == KEY_IMAGE + '_click_on':
            logger.debug(f'{event｝')
            window[KEY_GENERATE].update(disabled = True)
            window[KEY_EXIT].update(disabled = True)
            def_file = param[SKEY_DEF_OUTPATH]
            if os.path.isfile(def_file):
                imgfile = my_thumbnail.image_dialog(def_file, 'Image file select', my_thumbnail.DEF_THEME, 10, 4, ret = '', logger = logger)
                if os.path.isfile(imgfile):
                    logger.debug(f'Output select: {imgfile｝')
                    bf = read_result_csv(csvfile, param, logger, imgfile)
                    if bf:
                        update_widget()
                        param[SKEY_DEF_OUTPATH] = param[KEY_OUTPATH]
            window[KEY_GENERATE].update(disabled = False)
            window[KEY_EXIT].update(disabled = False)

        # Genarate ボタン
        if event == KEY_GENERATE:
            logger.debug(f'{event｝')
            window[KEY_LOOP].update(disabled = True)
            window[KEY_GENERATE].update(disabled = True)
            window[KEY_EXIT].update(disabled = True)
            get_paramlist(window, values, param)
            frame = msg_out_canvas(KEY_IMAGE, frame, 'Generating ...', (240,0,0))
            window[KEY_OUTPATH].update('')
            window[KEY_PROMPT].update(param[KEY_PROMPT])
            window[KEY_SEED].update(param[KEY_SEED])
            new_make_f = True

    # ウィンドウ終了処理
    window.close()


# main関数エントリーポイント(実行開始)
if __name__ == "__main__":
    import datetime

    parser = sd.parse_args()
    opt = parser.parse_args()

    # アプリケーション・ログ設定
    module = os.path.basename(__file__)
    module_name = os.path.splitext(module)[0]
    logger = my_logging.get_module_logger_sel(module_name, int(opt.log))

    sd.display_info(opt, title)
    start_time = datetime.datetime.now()        # 時間計測開始

    main(opt, logger)

    # 経過時間
    end_time = datetime.datetime.now()
    print(start_time.strftime('\nprocessing start >>\t %Y/%m/%d %H:%M:%S'))
    print(end_time.strftime('processing end >>\t %Y/%m/%d %H:%M:%S'))
    print('processing time >>\t', end_time - start_time)

    logger.info('\nFinished.\n')

　※ 上記ソースコードは表示の都合上、半角コード '}' が全角 '｝'になっていることに注意

Step 50：画像から画像を生成する †

　基本のサンプル・コード

img2img 画像から画像生成

「sd_img2img.py」

## sd_img2img.py【SD1.5】　画像から画像生成（img2img）サンプル・ソースコード
##      Ver. 1.00   2025/06/16

import torch
from PIL import Image
from diffusers import StableDiffusionImg2ImgPipeline,DPMSolverMultistepScheduler, logging
from translate import Translator

logging.set_verbosity_error()

# モデルフォルダーのパス
model_path = "/StabilityMatrix/Data/Models/StableDiffusion/SD1.5/v1-5-pruned-emaonly.safetensors"       # モデル
image_path = "images/kamo.jpg"                                                                          # 元画像

# GPUを使う場合は"cuda" 使わない場合は"cpu"
device = 'cuda'

# seed 値
seed = 12345678

# パイプラインを作成
pipeline = StableDiffusionImg2ImgPipeline.from_single_file(
                    model_path,
                    torch_dtype = torch.float16,
                    ).to(device)

# スケジューラ設定
pipeline.scheduler = DPMSolverMultistepScheduler.from_config(pipeline.scheduler.config)

# プロンプト
trans = Translator('en','ja').translate
prompt_jp = '兎'                                                                                      # プロンプト
prompt = trans(prompt_jp)
src_image = Image.open(image_path)

# Generatorオブジェクト作成
generator = torch.Generator(device).manual_seed(seed)

print(f'Seed: {seed}, Model: {model_path}')
print(f'prompt : {prompt_jp} → {prompt}')

# 画像を生成
image = pipeline(
                    prompt = prompt,
                    image = src_image,
                    num_inference_steps = 30,
                    guidance_scale = 7,
                    strength = 0.6,
                    generator = generator
                    ).images[0]

image.save("results/sd_img2img.png")                                                                    # 生成画像

プログラムを実行する（実行時間：約 5秒 RTX 4070 Ti 12GB）

(sd_test) PS > python sd_img2img.py

Fetching 11 files: 100%|███████████████████████████████| 11/11 [00:00<?, ?it/s]
Loading pipeline components...: 100%|████████████| 6/6 [00:01<00:00,  3.51it/s]
Seed: 12345678, Model: /StabilityMatrix/Data/Models/StableDiffusion/SD1.5/v1-5-pruned-emaonly.safetensors
prompt : 兎 → Domestic Rabbit
100%|██████████████████████████████████████████| 18/18 [00:04<00:00,  3.78it/s]
(sd_test) PS D:\anaconda_win\workspace_3\sd_test> python sd_037.py

画像ファイル「sd_img2img.png」が生成される

Step 51：　～コマンドラインからパラメータ入力～ †

Step 52：　～ GUI プログラム～ †

Step 60：統合した『私的 AI 生成プログラム』 †

忘備録 †

更新履歴 †

2025/06/16 初版

参考資料 †

Stable Diffusion

Programming
- Pythonで既存ファイルを考慮してファイル名の連番をつける

書籍など
- 日経ソフトウエア 2025年7月号「ローカル生成AIプログラミング」
- Interface 2025年3月号「画像による異常検出＆ローカルLLM作り - 仕事のための生成AI」