about transforms.Normalize

[crapthings]

is this same thing when training?

transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
transforms.Normalize([0.5], [0.5])
transforms.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5])

[bghira]

yes, to normalise to -1,1

[crapthings]

is this for grayscale
transforms.Normalize([0.5], [0.5])

and this for rgb?
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))

because i see different trainer use different value [0.5], [0.5, 0.5, 0.5]

Does this affect the color of the image?
Does this affect specify task like controlnet like inpainting(preserve color)?

[crapthings]

trainer

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import Dataset, DataLoader
from torchvision import transforms
from PIL import Image
import os
import random
import numpy as np
import matplotlib.pyplot as plt
from tqdm import tqdm

# 固定随机种子
def set_seed(seed):
    random.seed(seed)
    np.random.seed(seed)
    torch.manual_seed(seed)
    torch.cuda.manual_seed_all(seed)
    torch.backends.cudnn.deterministic = True

# 简单的自编码器模型
class SimpleAutoencoder(nn.Module):
    def __init__(self):
        super(SimpleAutoencoder, self).__init__()
        # Encoder
        self.encoder = nn.Sequential(
            nn.Conv2d(3, 16, 3, padding=1),
            nn.ReLU(),
            nn.MaxPool2d(2, 2),
            nn.Conv2d(16, 32, 3, padding=1),
            nn.ReLU(),
            nn.MaxPool2d(2, 2)
        )
        # Decoder
        self.decoder = nn.Sequential(
            nn.ConvTranspose2d(32, 16, 2, stride=2),
            nn.ReLU(),
            nn.ConvTranspose2d(16, 3, 2, stride=2),
            nn.Tanh()
        )

    def forward(self, x):
        x = self.encoder(x)
        x = self.decoder(x)
        return x

# 自定义数据集
class ImageFolder(Dataset):
    def __init__(self, root_dir, transform=None):
        self.root_dir = root_dir
        self.transform = transform
        self.image_files = [f for f in os.listdir(root_dir) if f.endswith(('.jpg', '.png', '.jpeg'))]

    def __len__(self):
        return len(self.image_files)

    def __getitem__(self, idx):
        img_path = os.path.join(self.root_dir, self.image_files[idx])
        image = Image.open(img_path).convert('RGB')
        if self.transform:
            image = self.transform(image)
        return image

# 训练函数
def train_model(model, train_loader, optimizer, criterion, device, epoch):
    model.train()
    running_loss = 0.0
    pbar = tqdm(train_loader, desc=f'Epoch {epoch}')

    for images in pbar:
        images = images.to(device)
        optimizer.zero_grad()
        outputs = model(images)
        loss = criterion(outputs, images)
        loss.backward()
        optimizer.step()

        running_loss += loss.item()
        pbar.set_postfix({'loss': loss.item()})

    return running_loss / len(train_loader)

def main():
    # 设置参数
    SEED = 42
    set_seed(SEED)
    EPOCHS = 500
    BATCH_SIZE = 32
    LEARNING_RATE = 0.001
    IMAGE_SIZE = 64
    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')

    # 创建两种不同的数据转换
    transform_single_channel = transforms.Compose([
        transforms.Resize((IMAGE_SIZE, IMAGE_SIZE)),
        transforms.ToTensor(),
        transforms.Normalize([0.5], [0.5])
    ])

    transform_three_channel = transforms.Compose([
        transforms.Resize((IMAGE_SIZE, IMAGE_SIZE)),
        transforms.ToTensor(),
        transforms.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5])
    ])

    # 创建数据集和数据加载器
    dataset_single = ImageFolder('./images', transform=transform_single_channel)
    dataset_three = ImageFolder('./images', transform=transform_three_channel)

    loader_single = DataLoader(dataset_single, batch_size=BATCH_SIZE, shuffle=True)
    loader_three = DataLoader(dataset_three, batch_size=BATCH_SIZE, shuffle=True)

    # 创建两个相同的模型
    model_single = SimpleAutoencoder().to(device)
    model_three = SimpleAutoencoder().to(device)

    # 优化器和损失函数
    optimizer_single = optim.Adam(model_single.parameters(), lr=LEARNING_RATE)
    optimizer_three = optim.Adam(model_three.parameters(), lr=LEARNING_RATE)
    criterion = nn.MSELoss()

    # 记录损失
    losses_single = []
    losses_three = []

    # 训练循环
    for epoch in range(EPOCHS):
        # 训练单通道归一化模型
        loss_single = train_model(model_single, loader_single, optimizer_single,
                                criterion, device, epoch)
        losses_single.append(loss_single)

        # 训练三通道归一化模型
        loss_three = train_model(model_three, loader_three, optimizer_three,
                               criterion, device, epoch)
        losses_three.append(loss_three)

        print(f'Epoch {epoch+1}/{EPOCHS}:')
        print(f'Single channel normalization loss: {loss_single:.4f}')
        print(f'Three channel normalization loss: {loss_three:.4f}')

    # 绘制损失曲线
    plt.figure(figsize=(10, 5))
    plt.plot(losses_single, label='Single Channel Norm')
    plt.plot(losses_three, label='Three Channel Norm')
    plt.xlabel('Epoch')
    plt.ylabel('Loss')
    plt.title('Training Loss Comparison')
    plt.legend()
    plt.savefig('loss_comparison.png')
    plt.close()

    # 保存模型
    torch.save(model_single.state_dict(), 'model_single_norm.pth')
    torch.save(model_three.state_dict(), 'model_three_norm.pth')

if __name__ == '__main__':
    main()

sampler

import torch
from torchvision import transforms
from PIL import Image
import matplotlib.pyplot as plt
from new import SimpleAutoencoder
import numpy as np

def load_and_process_image(image_path, image_size=64):
    # 图像预处理
    transform = transforms.Compose([
        transforms.Resize((image_size, image_size)),
        transforms.ToTensor(),
        transforms.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5])
    ])

    # 加载并转换图像
    image = Image.open(image_path).convert('RGB')
    image_tensor = transform(image).unsqueeze(0)
    return image_tensor

def reconstruct_image(model, image_tensor):
    model.eval()
    with torch.no_grad():
        reconstructed = model(image_tensor)

    # 将输出转换回图像格式
    reconstructed = reconstructed.squeeze(0)
    # 反归一化
    reconstructed = reconstructed * 0.5 + 0.5
    reconstructed = reconstructed.clamp(0, 1)
    reconstructed = reconstructed.permute(1, 2, 0).numpy()

    return reconstructed

def show_comparison_results(original_image, single_reconstructed, three_reconstructed):
    fig, (ax1, ax2, ax3) = plt.subplots(1, 3, figsize=(15, 5))

    ax1.imshow(original_image)
    ax1.set_title('Original Image')
    ax1.axis('off')

    ax2.imshow(single_reconstructed)
    ax2.set_title('Single Channel Norm')
    ax2.axis('off')

    ax3.imshow(three_reconstructed)
    ax3.set_title('Three Channel Norm')
    ax3.axis('off')

    plt.tight_layout()
    plt.show()

def main():
    # 加载两个模型
    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')

    # 加载单通道归一化模型
    model_single = SimpleAutoencoder().to(device)
    model_single.load_state_dict(torch.load('model_single_norm.pth'))

    # 加载三通道归一化模型
    model_three = SimpleAutoencoder().to(device)
    model_three.load_state_dict(torch.load('model_three_norm.pth'))

    # 处理单张图片
    image_path = './input1.png'  # 替换为你的图片路径
    image_tensor = load_and_process_image(image_path)
    image_tensor = image_tensor.to(device)

    # 使用两个模型重建图像
    single_reconstructed = reconstruct_image(model_single, image_tensor)
    three_reconstructed = reconstruct_image(model_three, image_tensor)

    # 显示原图和两种重建图像的比较
    original_image = Image.open(image_path).convert('RGB')
    original_image = original_image.resize((64, 64))
    show_comparison_results(np.array(original_image)/255,
                          single_reconstructed,
                          three_reconstructed)

if __name__ == '__main__':
    main()

result, random image with 500 epochs