def validate(self, dataloader, graph): self.model.eval() hrs, ndcgs = [], [] with torch.no_grad(): tqdm_dataloader = tqdm(dataloader) for iteration, batch in enumerate(tqdm_dataloader, start=1): user_idx, item_idx = batch rep, user_pool = self.model(graph) user = rep[user_idx] + user_pool[user_idx] item = rep[self.model.n_user + item_idx] preds = self.model.predict(user, item) preds_hrs, preds_ndcgs = self.calc_hr_and_ndcg(preds, self.args.topk) hrs += preds_hrs ndcgs += preds_ndcgs return np.mean(hrs), np.mean(ndcgs)
时间: 2024-02-14 15:31:36 浏览: 179
这是一个 `validate` 方法的定义，它接受两个参数 `dataloader` 和 `graph`。这个方法用于在模型训练过程中对验证集进行评估。
首先，将模型设置为评估模式，即 `self.model.eval()`。
然后，定义了两个空列表 `hrs` 和 `ndcgs`，用于存储每个样本的评估结果。
接下来，通过一个循环遍历 `dataloader`，每次迭代时从 `dataloader` 中获取一个批次的数据，其中 `user_idx` 和 `item_idx` 是从批次中获取的用户索引和物品索引。
使用模型 `self.model` 和图数据 `graph` 调用 `self.model` 的方法，得到用户和物品的表示，并计算预测结果 `preds`。
再调用 `self.calc_hr_and_ndcg()` 方法，根据预测结果和 `self.args.topk` 计算命中率和NDCG（归一化折损累计增益）。
将计算得到的命中率和NDCG分别添加到 `hrs` 和 `ndcgs` 列表中。
最后，在循环结束后，计算 `hrs` 和 `ndcgs` 的平均值，并返回这两个平均值作为评估结果。
注意，在整个验证过程中，没有进行模型参数更新，因此使用了 `torch.no_grad()` 上下文管理器来禁用梯度计算，以提高效率。
相关问题
unet和attention unet 只保留两层 其他的不动 把代码完整的复制给我 我直接运行
为了满足您的要求，我将 `UNet` 和 `AttentionUNet` 类中的编码器和解码器层数减少到两层，并保持其他部分不变。以下是修改后的完整代码：
```python
import torch
import torch.nn as nn
import torch.optim as optim
import torch.nn.functional as F
from torch.utils.data import Dataset, DataLoader
from torchvision import transforms
from PIL import Image
import os
import argparse
import glob
import matplotlib.pyplot as plt
from tqdm import tqdm
import numpy as np
class UNet(nn.Module):
def __init__(self):
super(UNet, self).__init__()
self.encoder = nn.Sequential(
nn.Conv2d(3, 64, kernel_size=3, stride=1, padding=1),
nn.ReLU(),
nn.MaxPool2d(kernel_size=2, stride=2),
nn.Conv2d(64, 128, kernel_size=3, padding=1),
nn.ReLU(),
nn.MaxPool2d(2),
)
self.decoder = nn.Sequential(
nn.ConvTranspose2d(128, 64, kernel_size=2, stride=2),
nn.ReLU(),
nn.ConvTranspose2d(64, 3, kernel_size=2, stride=2),
nn.Sigmoid(),
)
def forward(self, x):
x = self.encoder(x)
x = self.decoder(x)
return x
class AttentionBlock(nn.Module):
def __init__(self, F_g, F_l, F_int):
super(AttentionBlock, self).__init__()
self.W_g = nn.Sequential(
nn.Conv2d(F_g, F_int, kernel_size=1, stride=1, padding=0, bias=True),
nn.BatchNorm2d(F_int)
)
self.W_x = nn.Sequential(
nn.Conv2d(F_l, F_int, kernel_size=1, stride=1, padding=0, bias=True),
nn.BatchNorm2d(F_int)
)
self.psi = nn.Sequential(
nn.Conv2d(F_int, 1, kernel_size=1, stride=1, padding=0, bias=True),
nn.BatchNorm2d(1),
nn.Sigmoid()
)
self.relu = nn.ReLU(inplace=True)
def forward(self, g, x):
g1 = self.W_g(g)
x1 = self.W_x(x)
psi = self.relu(g1 + x1)
psi = self.psi(psi)
return x * psi
class AttentionUNet(nn.Module):
def __init__(self):
super(AttentionUNet, self).__init__()
self.encoder1 = self.conv_block(3, 64)
self.encoder2 = self.conv_block(64, 128)
self.bottleneck = self.conv_block(128, 256)
self.upconv2 = nn.ConvTranspose2d(256, 128, kernel_size=2, stride=2)
self.att2 = AttentionBlock(F_g=128, F_l=128, F_int=64)
self.decoder2 = self.conv_block(256, 128)
self.upconv1 = nn.ConvTranspose2d(128, 64, kernel_size=2, stride=2)
self.att1 = AttentionBlock(F_g=64, F_l=64, F_int=32)
self.decoder1 = self.conv_block(128, 64)
self.final_conv = nn.Conv2d(64, 3, kernel_size=1, stride=1, padding=0)
self.sigmoid = nn.Sigmoid()
def conv_block(self, in_channels, out_channels):
return nn.Sequential(
nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=1, padding=1),
nn.BatchNorm2d(out_channels),
nn.ReLU(inplace=True),
nn.Conv2d(out_channels, out_channels, kernel_size=3, stride=1, padding=1),
nn.BatchNorm2d(out_channels),
nn.ReLU(inplace=True)
)
def forward(self, x):
e1 = self.encoder1(x)
e2 = self.encoder2(F.max_pool2d(e1, 2))
b = self.bottleneck(F.max_pool2d(e2, 2))
d2 = self.upconv2(b)
e2 = self.att2(g=d2, x=e2)
d2 = torch.cat((e2, d2), dim=1)
d2 = self.decoder2(d2)
d1 = self.upconv1(d2)
e1 = self.att1(g=d1, x=e1)
d1 = torch.cat((e1, d1), dim=1)
d1 = self.decoder1(d1)
out = self.final_conv(d1)
out = self.sigmoid(out)
return out
class ColorblindDataset(Dataset):
def __init__(self, image_dir, mode='train', transform=None):
self.image_dir = image_dir
self.mode = mode
self.transform = transform
self.normal_images = glob.glob(image_dir + '/' + mode + '/' + 'origin_image' + '/*')
self.recolor_images = glob.glob(image_dir + '/' + mode + '/' + 'recolor_image' + '/' + '*Protanopia*')
self.correct_images = glob.glob(image_dir + '/' + mode + '/' + 'correct_image' + '/*')
self.normal_images.sort()
self.recolor_images.sort()
self.correct_images.sort()
self.image_pair = []
for index, image in enumerate(self.normal_images):
self.image_pair.append([self.recolor_images[index], self.normal_images[index]])
def __len__(self):
return len(self.image_pair)
def __getitem__(self, idx):
recolor_path, normal_path = self.image_pair[idx]
recolor_image = Image.open(recolor_path).convert('RGB')
normal_image = Image.open(normal_path).convert('RGB')
if self.transform:
recolor_image = self.transform(recolor_image)
normal_image = self.transform(normal_image)
return recolor_image, normal_image
class Generator(nn.Module):
def __init__(self):
super(Generator, self).__init__()
self.encoder1 = self.conv_block(3, 64)
self.encoder2 = self.conv_block(64, 128)
self.bottleneck = self.conv_block(128, 256)
self.upconv2 = nn.ConvTranspose2d(256, 128, kernel_size=2, stride=2)
self.att2 = AttentionBlock(F_g=128, F_l=128, F_int=64)
self.decoder2 = self.conv_block(256, 128)
self.upconv1 = nn.ConvTranspose2d(128, 64, kernel_size=2, stride=2)
self.att1 = AttentionBlock(F_g=64, F_l=64, F_int=32)
self.decoder1 = self.conv_block(128, 64)
self.final_conv = nn.Conv2d(64, 3, kernel_size=1, stride=1, padding=0)
self.sigmoid = nn.Sigmoid()
def conv_block(self, in_channels, out_channels):
return nn.Sequential(
nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=1, padding=1),
nn.BatchNorm2d(out_channels),
nn.ReLU(inplace=True),
nn.Conv2d(out_channels, out_channels, kernel_size=3, stride=1, padding=1),
nn.BatchNorm2d(out_channels),
nn.ReLU(inplace=True)
)
def forward(self, x):
e1 = self.encoder1(x)
e2 = self.encoder2(F.max_pool2d(e1, 2))
b = self.bottleneck(F.max_pool2d(e2, 2))
d2 = self.upconv2(b)
e2 = self.att2(g=d2, x=e2)
d2 = torch.cat((e2, d2), dim=1)
d2 = self.decoder2(d2)
d1 = self.upconv1(d2)
e1 = self.att1(g=d1, x=e1)
d1 = torch.cat((e1, d1), dim=1)
d1 = self.decoder1(d1)
out = self.final_conv(d1)
out = self.sigmoid(out)
return out
class Discriminator(nn.Module):
def __init__(self):
super(Discriminator, self).__init__()
self.main = nn.Sequential(
nn.Conv2d(3, 64, kernel_size=4, stride=2, padding=1),
nn.LeakyReLU(0.2, inplace=True),
nn.Conv2d(64, 128, kernel_size=4, stride=2, padding=1),
nn.BatchNorm2d(128),
nn.LeakyReLU(0.2, inplace=True),
nn.Conv2d(128, 256, kernel_size=4, stride=2, padding=1),
nn.BatchNorm2d(256),
nn.LeakyReLU(0.2, inplace=True),
nn.Conv2d(256, 512, kernel_size=4, stride=2, padding=1),
nn.BatchNorm2d(512),
nn.LeakyReLU(0.2, inplace=True),
nn.Conv2d(512, 1, kernel_size=16),
)
def forward(self, x):
return self.main(x).view(-1)
def compute_iou(outputs, targets, threshold=0.5):
outputs = (outputs > threshold).float()
targets = (targets > threshold).float()
intersection = (outputs * targets).sum(dim=(1, 2, 3))
union = outputs.sum(dim=(1, 2, 3)) + targets.sum(dim=(1, 2, 3)) - intersection
iou = (intersection + 1e-6) / (union + 1e-6)
return iou.mean().item()
from skimage.metrics import peak_signal_noise_ratio as psnr_metric
from skimage.metrics import structural_similarity as ssim_metric
def compute_psnr(outputs, targets):
outputs = outputs.cpu().detach().numpy()
targets = targets.cpu().detach().numpy()
psnr = 0
for i in range(outputs.shape[0]):
psnr += psnr_metric(targets[i], outputs[i], data_range=1.0)
return psnr / outputs.shape[0]
def compute_ssim(outputs, targets):
outputs = outputs.cpu().detach().numpy()
targets = targets.cpu().detach().numpy()
ssim = 0
for i in range(outputs.shape[0]):
output_img = outputs[i].transpose(1, 2, 0)
target_img = targets[i].transpose(1, 2, 0)
H, W, _ = output_img.shape
min_dim = min(H, W)
win_size = min(7, min_dim if min_dim % 2 == 1 else min_dim - 1)
win_size = max(win_size, 3)
ssim += ssim_metric(
target_img, output_img, data_range=1.0, channel_axis=-1, win_size=win_size
)
return ssim / outputs.shape[0]
def wasserstein_loss(pred, target):
return torch.mean(pred * target)
from torch.autograd import grad
def compute_gradient_penalty(discriminator, real_samples, fake_samples, device):
alpha = torch.rand(real_samples.size(0), 1, 1, 1, device=device)
interpolates = (alpha * real_samples + ((1 - alpha) * fake_samples)).requires_grad_(True)
d_interpolates = discriminator(interpolates)
fake = torch.ones(real_samples.size(0), device=device)
gradients = grad(
outputs=d_interpolates,
inputs=interpolates,
grad_outputs=fake,
create_graph=True,
retain_graph=True,
only_inputs=True,
)[0]
gradients = gradients.view(gradients.size(0), -1)
gradient_penalty = ((gradients.norm(2, dim=1) - 1) ** 2).mean()
return gradient_penalty
def train_correction_model(generator, discriminator, dataloader, optimizer_G, optimizer_D, device, lambda_gp, lambda_pixel, n_critic):
generator.train()
discriminator.train()
running_g_loss = 0.0
running_d_loss = 0.0
running_iou = 0.0
running_psnr = 0.0
running_ssim = 0.0
for batch_idx, (inputs, targets) in enumerate(tqdm(dataloader, desc="Training")):
inputs = inputs.to(device)
targets = targets.to(device)
# -------
# 训练判别器
# ---------------------
optimizer_D.zero_grad()
corrected_images = generator(inputs)
real_validity = discriminator(targets)
fake_validity = discriminator(corrected_images.detach())
gp = compute_gradient_penalty(discriminator, targets.data, corrected_images.data, device)
d_loss = -torch.mean(real_validity) + torch.mean(fake_validity) + lambda_gp * gp
d_loss.backward()
optimizer_D.step()
# -----------------
# 训练生成器
# -----------------
if batch_idx % n_critic == 0:
optimizer_G.zero_grad()
corrected_images = generator(inputs)
fake_validity = discriminator(corrected_images)
g_adv_loss = -torch.mean(fake_validity)
pixelwise_loss = nn.L1Loss()
g_pixel_loss = pixelwise_loss(corrected_images, targets)
g_loss = g_adv_loss + lambda_pixel * g_pixel_loss
g_loss.backward()
optimizer_G.step()
else:
g_loss = torch.tensor(0.0)
running_g_loss += g_loss.item()
running_d_loss += d_loss.item()
iou = compute_iou(corrected_images, targets)
psnr = compute_psnr(corrected_images, targets)
ssim = compute_ssim(corrected_images, targets)
running_iou += iou
running_psnr += psnr
running_ssim += ssim
epoch_g_loss = running_g_loss / len(dataloader)
epoch_d_loss = running_d_loss / len(dataloader)
epoch_iou = running_iou / len(dataloader)
epoch_psnr = running_psnr / len(dataloader)
epoch_ssim = running_ssim / len(dataloader)
return epoch_g_loss, epoch_d_loss, epoch_iou, epoch_psnr, epoch_ssim
def validate_correction_model(generator, discriminator, dataloader, device, lambda_gp):
generator.eval()
discriminator.eval()
running_g_loss = 0.0
running_d_loss = 0.0
running_iou = 0.0
running_psnr = 0.0
running_ssim = 0.0
with torch.no_grad():
for inputs, targets in tqdm(dataloader, desc="Validation"):
inputs = inputs.to(device)
targets = targets.to(device)
corrected_images = generator(inputs)
real_validity = discriminator(targets)
fake_validity = discriminator(corrected_images)
d_loss = -torch.mean(real_validity) + torch.mean(fake_validity)
g_adv_loss = -torch.mean(fake_validity)
g_loss = g_adv_loss
running_g_loss += g_loss.item()
running_d_loss += d_loss.item()
iou = compute_iou(corrected_images, targets)
psnr = compute_psnr(corrected_images, targets)
ssim = compute_ssim(corrected_images, targets)
running_iou += iou
running_psnr += psnr
running_ssim += ssim
epoch_g_loss = running_g_loss / len(dataloader)
epoch_d_loss = running_d_loss / len(dataloader)
epoch_iou = running_iou / len(dataloader)
epoch_psnr = running_psnr / len(dataloader)
epoch_ssim = running_ssim / len(dataloader)
return epoch_g_loss,
去掉注意力机制后 把完整代码给我 我复制粘贴直接运行
好的，以下是去掉了注意力机制后的完整代码。你可以直接复制并运行：
```python
import torch
import torch.nn as nn
import torch.optim as optim
import torch.nn.functional as F
from torch.utils.data import Dataset, DataLoader
from torchvision import transforms
from PIL import Image
import os
import argparse
import glob
import matplotlib.pyplot as plt
from tqdm import tqdm
import numpy as np
class UNet(nn.Module):
def __init__(self):
super(UNet, self).__init__()
self.encoder = nn.Sequential(
nn.Conv2d(3, 64, kernel_size=3, stride=1, padding=1),
nn.ReLU(),
nn.MaxPool2d(kernel_size=2, stride=2),
nn.Conv2d(64, 128, kernel_size=3, padding=1),
nn.ReLU(),
nn.MaxPool2d(2),
)
self.decoder = nn.Sequential(
nn.ConvTranspose2d(128, 64, kernel_size=2, stride=2),
nn.ReLU(),
nn.ConvTranspose2d(64, 3, kernel_size=2, stride=2),
nn.Sigmoid(),
)
def forward(self, x):
x = self.encoder(x)
x = self.decoder(x)
return x
class ColorblindDataset(Dataset):
def __init__(self, image_dir, mode='train', transform=None):
self.image_dir = image_dir
self.mode = mode
self.transform = transform
self.normal_images = glob.glob(image_dir + '/' + mode + '/' + 'origin_image' + '/*')
self.recolor_images = glob.glob(image_dir + '/' + mode + '/' + 'recolor_image' + '/' + '*Protanopia*')
self.correct_images = glob.glob(image_dir + '/' + mode + '/' + 'correct_image' + '/*')
self.normal_images.sort()
self.recolor_images.sort()
self.correct_images.sort()
self.image_pair = []
for index, image in enumerate(self.normal_images):
self.image_pair.append([self.recolor_images[index], self.normal_images[index]])
def __len__(self):
return len(self.image_pair)
def __getitem__(self, idx):
recolor_path, normal_path = self.image_pair[idx]
recolor_image = Image.open(recolor_path).convert('RGB')
normal_image = Image.open(normal_path).convert('RGB')
if self.transform:
recolor_image = self.transform(recolor_image)
normal_image = self.transform(normal_image)
return recolor_image, normal_image
class Generator(nn.Module):
def __init__(self):
super(Generator, self).__init__()
self.encoder1 = self.conv_block(3, 64)
self.encoder2 = self.conv_block(64, 128)
self.encoder3 = self.conv_block(128, 256)
self.encoder4 = self.conv_block(256, 512)
self.bottleneck = self.conv_block(512, 1024)
self.upconv4 = nn.ConvTranspose2d(1024, 512, kernel_size=2, stride=2)
self.decoder4 = self.conv_block(1024, 512)
self.upconv3 = nn.ConvTranspose2d(512, 256, kernel_size=2, stride=2)
self.decoder3 = self.conv_block(512, 256)
self.upconv2 = nn.ConvTranspose2d(256, 128, kernel_size=2, stride=2)
self.decoder2 = self.conv_block(256, 128)
self.upconv1 = nn.ConvTranspose2d(128, 64, kernel_size=2, stride=2)
self.decoder1 = self.conv_block(128, 64)
self.final_conv = nn.Conv2d(64, 3, kernel_size=1, stride=1, padding=0)
self.sigmoid = nn.Sigmoid()
def conv_block(self, in_channels, out_channels):
return nn.Sequential(
nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=1, padding=1),
nn.BatchNorm2d(out_channels),
nn.ReLU(inplace=True),
nn.Conv2d(out_channels, out_channels, kernel_size=3, stride=1, padding=1),
nn.BatchNorm2d(out_channels),
nn.ReLU(inplace=True)
)
def forward(self, x):
e1 = self.encoder1(x)
e2 = self.encoder2(F.max_pool2d(e1, 2))
e3 = self.encoder3(F.max_pool2d(e2, 2))
e4 = self.encoder4(F.max_pool2d(e3, 2))
b = self.bottleneck(F.max_pool2d(e4, 2))
d4 = self.upconv4(b)
d4 = torch.cat((e4, d4), dim=1)
d4 = self.decoder4(d4)
d3 = self.upconv3(d4)
d3 = torch.cat((e3, d3), dim=1)
d3 = self.decoder3(d3)
d2 = self.upconv2(d3)
d2 = torch.cat((e2, d2), dim=1)
d2 = self.decoder2(d2)
d1 = self.upconv1(d2)
d1 = torch.cat((e1, d1), dim=1)
d1 = self.decoder1(d1)
out = self.final_conv(d1)
out = self.sigmoid(out)
return out
class Discriminator(nn.Module):
def __init__(self):
super(Discriminator, self).__init__()
self.main = nn.Sequential(
nn.Conv2d(3, 64, kernel_size=4, stride=2, padding=1),
nn.LeakyReLU(0.2, inplace=True),
nn.Conv2d(64, 128, kernel_size=4, stride=2, padding=1),
nn.BatchNorm2d(128),
nn.LeakyReLU(0.2, inplace=True),
nn.Conv2d(128, 256, kernel_size=4, stride=2, padding=1),
nn.BatchNorm2d(256),
nn.LeakyReLU(0.2, inplace=True),
nn.Conv2d(256, 512, kernel_size=4, stride=2, padding=1),
nn.BatchNorm2d(512),
nn.LeakyReLU(0.2, inplace=True),
nn.Conv2d(512, 1, kernel_size=16),
)
def forward(self, x):
return self.main(x).view(-1)
def compute_iou(outputs, targets, threshold=0.5):
outputs = (outputs > threshold).float()
targets = (targets > threshold).float()
intersection = (outputs * targets).sum(dim=(1, 2, 3))
union = outputs.sum(dim=(1, 2, 3)) + targets.sum(dim=(1, 2, 3)) - intersection
iou = (intersection + 1e-6) / (union + 1e-6)
return iou.mean().item()
from skimage.metrics import peak_signal_noise_ratio as psnr_metric
from skimage.metrics import structural_similarity as ssim_metric
def compute_psnr(outputs, targets):
outputs = outputs.cpu().detach().numpy()
targets = targets.cpu().detach().numpy()
psnr = 0
for i in range(outputs.shape[0]):
psnr += psnr_metric(targets[i], outputs[i], data_range=1.0)
return psnr / outputs.shape[0]
def compute_ssim(outputs, targets):
outputs = outputs.cpu().detach().numpy()
targets = targets.cpu().detach().numpy()
ssim = 0
for i in range(outputs.shape[0]):
output_img = outputs[i].transpose(1, 2, 0)
target_img = targets[i].transpose(1, 2, 0)
H, W, _ = output_img.shape
min_dim = min(H, W)
win_size = min(7, min_dim if min_dim % 2 == 1 else min_dim - 1)
win_size = max(win_size, 3)
ssim += ssim_metric(target_img, output_img, data_range=1.0, channel_axis=-1, win_size=win_size)
return ssim / outputs.shape[0]
def wasserstein_loss(pred, target):
return torch.mean(pred * target)
from torch.autograd import grad
def compute_gradient_penalty(discriminator, real_samples, fake_samples, device):
alpha = torch.rand(real_samples.size(0), 1, 1, 1, device=device)
interpolates = (alpha * real_samples + ((1 - alpha) * fake_samples)).requires_grad_(True)
d_interpolates = discriminator(interpolates)
fake = torch.ones(real_samples.size(0), device=device)
gradients = grad(
outputs=d_interpolates,
inputs=interpolates,
grad_outputs=fake,
create_graph=True,
retain_graph=True,
only_inputs=True,
)[0]
gradients = gradients.view(gradients.size(0), -1)
gradient_penalty = ((gradients.norm(2, dim=1) - 1) ** 2).mean()
return gradient_penalty
def train_correction_model(generator, discriminator, dataloader, optimizer_G, optimizer_D, device, lambda_gp, lambda_pixel, n_critic):
generator.train()
discriminator.train()
running_g_loss = 0.0
running_d_loss = 0.0
running_iou = 0.0
running_psnr = 0.0
running_ssim = 0.0
for batch_idx, (inputs, targets) in enumerate(tqdm(dataloader, desc="Training")):
inputs = inputs.to(device)
targets = targets.to(device)
# Train Discriminator
optimizer_D.zero_grad()
corrected_images = generator(inputs)
real_validity = discriminator(targets)
fake_validity = discriminator(corrected_images.detach())
gp = compute_gradient_penalty(discriminator, targets.data, corrected_images.data, device)
d_loss = -torch.mean(real_validity) + torch.mean(fake_validity) + lambda_gp * gp
d_loss.backward()
optimizer_D.step()
# Train Generator
if batch_idx % n_critic == 0:
optimizer_G.zero_grad()
corrected_images = generator(inputs)
fake_validity = discriminator(corrected_images)
g_adv_loss = -torch.mean(fake_validity)
pixelwise_loss = nn.L1Loss()
g_pixel_loss = pixelwise_loss(corrected_images, targets)
g_loss = g_adv_loss + lambda_pixel * g_pixel_loss
g_loss.backward()
optimizer_G.step()
else:
g_loss = torch.tensor(0.0)
running_g_loss += g_loss.item()
running_d_loss += d_loss.item()
iou = compute_iou(corrected_images, targets)
psnr = compute_psnr(corrected_images, targets)
ssim = compute_ssim(corrected_images, targets)
running_iou += iou
running_psnr += psnr
running_ssim += ssim
epoch_g_loss = running_g_loss / len(dataloader)
epoch_d_loss = running_d_loss / len(dataloader)
epoch_iou = running_iou / len(dataloader)
epoch_psnr = running_psnr / len(dataloader)
epoch_ssim = running_ssim / len(dataloader)
return epoch_g_loss, epoch_d_loss, epoch_iou, epoch_psnr, epoch_ssim
def validate_correction_model(generator, discriminator, dataloader, device, lambda_gp):
generator.eval()
discriminator.eval()
running_g_loss = 0.0
running_d_loss = 0.0
running_iou = 0.0
running_psnr = 0.0
running_ssim = 0.0
with torch.no_grad():
for inputs, targets in tqdm(dataloader, desc="Validation"):
inputs = inputs.to(device)
targets = targets.to(device)
corrected_images = generator(inputs)
real_validity = discriminator(targets)
fake_validity = discriminator(corrected_images)
d_loss = -torch.mean(real_validity) + torch.mean(fake_validity)
g_adv_loss = -torch.mean(fake_validity)
g_loss = g_adv_loss
running_g_loss += g_loss.item()
running_d_loss += d_loss.item()
iou = compute_iou(corrected_images, targets)
psnr = compute_psnr(corrected_images, targets)
ssim = compute_ssim(corrected_images, targets)
running_iou += iou
running_psnr += psnr
running_ssim += ssim
epoch_g_loss = running_g_loss / len(dataloader)
epoch_d_loss = running_d_loss / len(dataloader)
epoch_iou = running_iou / len(dataloader)
epoch_psnr = running_psnr / len(dataloader)
epoch_ssim = running_ssim / len(dataloader)
return epoch_g_loss, epoch_d_loss, epoch_iou, epoch_psnr, epoch_ssim
def visualize_results(generator, dataloader, device, num_images=10, save_path='./results'):
generator.eval()
inputs, targets = next(iter(dataloader))
inputs = inputs.to(device)
targets = targets.to(device)
with torch.no_grad():
corrected_images = generator(inputs)
inputs = inputs.cpu().numpy()
targets = targets.cpu().numpy()
corrected_images = corrected_images.cpu().numpy()
if not os.path.exists(save_path):
os.makedirs(save_path)
plt.figure(figsize=(20, 10))
for i in range(num_images):
plt.subplot(3, num_images, i + 1)
plt.imshow(targets[i].transpose(1, 2, 0))
plt.title("Original")
plt.axis('off')
plt.subplot(3, num_images, i + 1 + num_images)
plt.imshow(inputs[i].transpose(1, 2, 0))
plt.title("Simulated Colorblind")
plt.axis('off')
plt.subplot(3, num_images, i + 1 + 2 * num_images)
plt.imshow(corrected_images[i].transpose(1, 2, 0))
plt.title("Corrected")
plt.axis('off')
plt.tight_layout()
plt.savefig(f'{save_path}_visualization.png')
plt.show()
def plot_and_save_metrics(train_metrics, val_metrics, epoch, path='./metrics_plots'):
if not os.path.exists(path):
os.makedirs(path)
epochs = np.arange(1, epoch + 1)
train_g_losses, train_d_losses, train_ious, train_psnrs, train_ssims = zip(*train_metrics)
val_g_losses, val_d_losses, val_ious, val_psnrs, val_ssims = zip(*val_metrics)
plt.figure()
plt.plot(epochs, train_g_losses, label='Training Generator Loss')
plt.plot(epochs, val_g_losses, label='Validation Generator Loss')
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.title('Generator Loss over Epochs')
plt.legend()
plt.savefig(f'{path}/generator_loss.png')
plt.close()
plt.figure()
plt.plot(epochs, train_d_losses, label='Training Discriminator Loss')
plt.plot(epochs, val_d_losses, label='Validation Discriminator Loss')
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.title('Discriminator Loss over Epochs')
plt.
阅读全文
相关推荐
大家在看
dhtmlxGantt_v4.0.0
甘特图（dhtmlxgantt）的资源文件，具体代码请访问https://blog.csdn.net/qq_27339781/article/details/79869584
AUTOSAR_MCAL_WDG.zip
This User Manual describes NXP Semiconductors AUTOSAR Watchdog ( Wdg ) for S32K14X .
AUTOSAR Wdg driver configuration parameters and deviations from the specification are described in Wdg Driver chapter of this document. AUTOSAR Wdg driver requirements and APIs are described in the AUTOSAR Wdg driver software specification document.
虚幻引擎3D角色动画工作流
当3D建模师或动画师在Maya/3ds MAX/Blender等软件（下述将这些软件简称为DCC，Digital Content Creation）中制作3D模型或动画时应该遵循怎样的制作规范？
在模型或动画制作完成后应该怎样将其导入到虚幻引擎中？通常我们会在DCC工具中将制作好的资源导出成FBX文件，然后在虚幻引擎中导入FBX文件，FBX文件是如此重要以至于我们需要深刻的认识它。当然现在也有一些工作流插件可以直接将DCC工具中制作的模型或动画直接传递给虚幻引擎，在这个过程中我们将不会再看到FBX文件。
模型或动画被导入到虚幻引擎后，在虚幻引擎中应该怎样使用这些资源？
如果多个角色的骨骼相同或非常相似，应该怎样复用动画资源而不是让动画师重复的制作这些动画？
在虚幻引擎中驱动动画（在什么时候该播什么动画）的玩意叫动画蓝图，动画蓝图是与骨骼严格绑定的，当游戏中不同骨骼的角色拥有相同的动画播放逻辑，此时应该怎样避免对每种骨骼都创建相同逻辑的动画蓝图，换句话说应该怎样复用动画蓝图？
在本课程中我们将解决上述问题。
注意：本课程并不涉及如何制作漂亮的角色和帅气的动画，本课程重点讲的是
verilog实现SDI音频内嵌bt1120
verilog实现SDI音频内嵌bt1120；符合标准SDI 辅助数据协议。数据包括：Y/C两路，分别为控制链路和数据链路。通过SDI分析仪可以分析协议正确性。
《操作系统教程》（第六版）习题答案
教材：《操作系统教程》（第六版）骆斌，葛季栋，费翔林编著
内容为该教材的习题答案（仅供参考，不确保是否有遗漏）
最新推荐
redis常用命令入门教程.md
redis常用命令入门教程.md
课程设计-jsp2159(CS)交通信号灯oracle-qlkrp.zip
课程设计 源代码数据库配套报告教程
Java算法：二叉树的前中后序遍历实现
在深入探讨如何用Java实现二叉树及其三种基本遍历（前序遍历、中序遍历和后序遍历）之前，我们需要了解一些基础知识。
首先，二叉树是一种被广泛使用的数据结构，它具有以下特性：
1. 每个节点最多有两个子节点，分别是左子节点和右子节点。
2. 左子树和右子树都是二叉树。
3. 每个节点都包含三个部分：值、左子节点的引用和右子节点的引用。
4. 二叉树的遍历通常用于访问树中的每个节点，且访问的顺序可以是前序、中序和后序。
接下来，我们将详细介绍如何用Java来构建这样一个树结构，并实现这些遍历方式。
### Java实现二叉树结构
要实现二叉树结构，我们首先需要一个节点类（Node.java），该类将包含节点值以及指向左右子节点的引用。其次，我们需要一个树类（Tree.java），它将包含根节点，并提供方法来构建树以及执行不同的遍历。
#### Node.java
```java
public class Node {
int value;
Node left;
Node right;
public Node(int value) {
this.value = value;
left = null;
right = null;
}
}
```
#### Tree.java
```java
import java.util.Stack;
public class Tree {
private Node root;
public Tree() {
root = null;
}
// 这里可以添加插入、删除等方法
// ...
// 前序遍历
public void preOrderTraversal(Node node) {
if (node != null) {
System.out.print(node.value + " ");
preOrderTraversal(node.left);
preOrderTraversal(node.right);
}
}
// 中序遍历
public void inOrderTraversal(Node node) {
if (node != null) {
inOrderTraversal(node.left);
System.out.print(node.value + " ");
inOrderTraversal(node.right);
}
}
// 后序遍历
public void postOrderTraversal(Node node) {
if (node != null) {
postOrderTraversal(node.left);
postOrderTraversal(node.right);
System.out.print(node.value + " ");
}
}
// 迭代形式的前序遍历
public void preOrderTraversalIterative() {
Stack<Node> stack = new Stack<>();
stack.push(root);
while (!stack.isEmpty()) {
Node node = stack.pop();
System.out.print(node.value + " ");
if (node.right != null) {
stack.push(node.right);
}
if (node.left != null) {
stack.push(node.left);
}
}
System.out.println();
}
// 迭代形式的中序遍历
public void inOrderTraversalIterative() {
Stack<Node> stack = new Stack<>();
Node current = root;
while (current != null || !stack.isEmpty()) {
while (current != null) {
stack.push(current);
current = current.left;
}
current = stack.pop();
System.out.print(current.value + " ");
current = current.right;
}
System.out.println();
}
// 迭代形式的后序遍历
public void postOrderTraversalIterative() {
Stack<Node> stack = new Stack<>();
Stack<Node> output = new Stack<>();
stack.push(root);
while (!stack.isEmpty()) {
Node node = stack.pop();
output.push(node);
if (node.left != null) {
stack.push(node.left);
}
if (node.right != null) {
stack.push(node.right);
}
}
while (!output.isEmpty()) {
System.out.print(output.pop().value + " ");
}
System.out.println();
}
}
```
### Java实现的二叉树遍历详细解析
#### 前序遍历（Pre-order Traversal）
前序遍历是先访问根节点，然后递归地前序遍历左子树，接着递归地前序遍历右子树。遍历的顺序是：根 -> 左 -> 右。
#### 中序遍历（In-order Traversal）
中序遍历是先递归地中序遍历左子树，然后访问根节点，最后递归地中序遍历右子树。对于二叉搜索树来说，中序遍历可以按从小到大的顺序访问所有节点。遍历的顺序是：左 -> 根 -> 右。
#### 后序遍历（Post-order Traversal）
后序遍历是先递归地后序遍历左子树，然后递归地后序遍历右子树，最后访问根节点。遍历的顺序是：左 -> 右 -> 根。
### 迭代形式的遍历
在上述`Tree.java`类中，我们还实现了迭代形式的遍历，通过使用栈来模拟递归过程。这种方法在处理大型树结构时，可以避免递归导致的栈溢出问题，并且可以提高效率。
### 总结
通过上述代码和解释，我们可以看到，使用Java实现二叉树及其遍历方法相对直接。核心在于理解二叉树节点的结构和递归逻辑，以及如何使用栈来模拟递归过程。在实践中，了解并掌握这些基本算法对于解决复杂问题是非常有用的。此外，理解这些基本概念后，可以进一步探索更高级的二叉树算法，如平衡二叉树（AVL树）、红黑树等。
【性能测试基准】：为RK3588选择合适的NVMe性能测试工具指南
# 1. NVMe性能测试基础
## 1.1 NVMe协议简介
NVMe，全称为Non-Volatile Memory Express，是专为固态驱动器设计的逻辑设备接口规范。与传统的SATA接口相比，NVMe通过使用PCI Express（PCIe）总线，大大提高了存储设备的数据吞吐量和IOPS（每秒输入输出操作次数），特别适合于高速的固态存储设备。
grant usage on ** to bcc@*%
<think>我们正在处理一个关于MySQL权限授予的问题。用户的具体需求是：为数据库用户'bcc'@'%'授予对所有数据库的使用权限(USAGE)。根据引用[1]和引用[4]，我们知道在MySQL中，使用GRANT语句来授予权限。注意：USAGE权限实际上是一个“无权限”的权限，它仅仅表示用户存在，但没有任何实际权限（除了连接数据库）。如果用户只想允许用户连接数据库而不做任何操作，那么授予USAGE是合适的。但是，用户要求的是“使用权限”，我们需要确认用户是否真的只需要USAGE权限，还是需要其他权限？根据问题描述，用户明确说“使用权限”，并且指定了USAGE（在问题中提到了grantusa
Nokia手机通用密码计算器：解锁神器
根据给定的文件信息，我们可以了解到一个关于诺基亚（Nokia）手机解锁密码生成工具的知识点。在这个场景中，文件标题“Nokia手机密码计算器”表明了这是一个专门用于生成Nokia手机解锁密码的应用程序。描述中提到的“输入手机串号，就可得到10位通用密码，用于解锁手机”说明了该工具的使用方法和功能。
知识点详解如下：
1. Nokia手机串号的含义：
串号（Serial Number），也称为序列号，是每部手机独一无二的标识，通常印在手机的电池槽内或者在手机的设置信息中可以查看。它对于手机的售后维修、技术支持以及身份识别等方面具有重要意义。串号通常由15位数字组成，能够提供制造商、型号、生产日期和制造地点等相关信息。
2. Nokia手机密码计算器的工作原理：
Nokia手机密码计算器通过特定的算法将手机的串号转换成一个10位的数字密码。这个密码是为了帮助用户在忘记手机的PIN码（个人识别码）、PUK码（PIN解锁码）或者某些情况下手机被锁定时，能够解锁手机。
3. 通用密码与安全性：
这种“通用密码”是基于一定算法生成的，不是随机的。它通常适用于老型号的Nokia手机，因为这些手机在设计时通常会采用固定的算法来生成密码。然而，随着科技的发展和安全需求的提高，现代手机通常不会提供此类算法生成的通用密码，以防止未经授权的解锁尝试。
4. Nokia手机的安全机制：
老型号的Nokia手机在设计时，通常会考虑到用户可能忘记密码的情况。为了保证用户在这种情况下的手机依然能够被解锁使用，制造商设置了一套安全机制，即通用密码系统。但这同时也带来了潜在的安全风险，因为如果算法被破解，那么任何知道串号的人都可能解锁这部手机。
5. MasterCode.exe文件的作用：
文件列表中的“MasterCode.exe”很可能就是上述“Nokia手机密码计算器”的可执行文件。用户需要运行这个程序，并按照程序的指示输入手机的串号，程序便会根据内部的算法计算出用于解锁的密码。
6. 注意事项和法律风险：
尽管此类工具在技术上帮助了用户，但必须强调的是，使用此类解锁工具或破解手机可能会违反相关的法律法规，特别是如果手机并非属于解锁者本人。在大多数国家，未经授权解锁手机都是违法的，尤其是在手机是通过运营商签订合约购买的情况下。因此，用户在尝试使用通用密码解锁手机前，应确保了解当地的法律法规，并且只在合法和合理的范围内使用此类工具。
7. 替代解锁方法：
对于现代智能手机，如果用户忘记了解锁密码，通常需要通过官方的客户服务来解决，例如联系手机制造商的客服或到指定的维修点进行解锁。一些手机还提供了账号解锁的功能，比如Apple的“查找我的iPhone”功能，以及Google的账号解锁选项。
总结来说，Nokia手机密码计算器是一个基于特定算法的实用工具，可帮助用户在忘记密码时解锁其Nokia手机。然而，用户在使用此类工具时应谨慎，并且必须遵守当地的法律法规。
【固态硬盘寿命延长】：RK3588平台NVMe维护技巧大公开
# 1. 固态硬盘寿命延长的基础知识
## 1.1 固态硬盘的基本概念
固态硬盘（SSD）是现代计算设备中不可或缺的存储设备之一。与传统的机械硬盘（HDD）相比，SSD拥有更快的读写速度、更小的体积和更低的功耗。但是，SSD也有其生命周期限制，主要受限于NAND闪存的写入次数。
## 1.2 SSD的写入次数和寿命
每块SSD中的NAND闪存单元都有有限的写入次数。这意味着，随着时间的推移，SSD的
缺省参数是什么
<think>首先，用户的问题是：“我想理解编程中缺省参数的概念和使用方法请问编程语言中缺省参数的定义及示例”。用户想了解缺省参数在编程中的概念和使用方法。我有系统级指令：-所有行内数学表达式必须使用$...$格式。-独立公式必须使用$$...$$格式并单独成段。-LaTeX语法正确。-使用中文回答。-生成相关问题。-回答中引用的段落末尾自然地添加引用标识，例如[^1]。用户可见层指令：-回答结构清晰，帮助用户逐步解决问题。-尽量保证回答真实可靠。参考站内引用：-引用[1]:缺省参数是声明或定义函数时为函数的参数指定的一个默认值。在调用该函数时，如果没有指定实参则采用该默认值，否则使用指定的实
jxl API实现Excel文件的读写操作
### 知识点一：jxl API概述
jxl API是针对Java语言的开源库，用于操作Microsoft Excel文件。它允许开发者通过Java程序创建、读取、修改和写入Excel文件（特别是XLS格式的文件）。jxl API是纯Java实现的，因此它独立于操作系统的Excel处理能力，具有良好的跨平台性。
### 知识点二：jxl API的安装和配置
要使用jxl API，首先需要将其安装到Java项目中。可以通过Maven或直接下载jar文件的方式进行安装。如果是使用Maven项目，可以在pom.xml文件中添加依赖。如果直接使用jar文件，则需要将其添加到项目的类路径中。
### 知识点三：jxl API的主要功能
jxl API支持Excel文件的创建、读写等操作，具体包括：
1. 创建新的Excel工作簿。
2. 读取已存在的Excel文件。
3. 向工作簿中添加和修改单元格数据。
4. 设置单元格样式，如字体、颜色、边框等。
5. 对工作表进行操作，比如插入、删除、复制工作表。
6. 写入和读取公式。
7. 处理图表和图片。
8. 数据筛选、排序功能。
### 知识点四：jxl API的基本操作示例
#### 创建Excel文件
```java
// 导入jxl API的类
import jxl.Workbook;
import jxl.write.WritableWorkbook;
import jxl.write.WritableSheet;
// 创建一个新的Excel工作簿
WritableWorkbook workbook = Workbook.createWorkbook(new File("example.xls"));
WritableSheet sheet = workbook.createSheet("Sheet1", 0); // 创建工作表
// 其他操作...
// 关闭工作簿
workbook.write();
workbook.close();
```
#### 读取Excel文件
```java
// 导入jxl API的类
import jxl.Workbook;
import jxl.read.biff.BiffException;
// 打开一个现有的Excel文件
Workbook workbook = Workbook.getWorkbook(new File("example.xls"));
// 读取工作表
Sheet sheet = workbook.getSheet(0);
// 读取单元格数据
String value = sheet.getCell(0, 0).getContents();
// 关闭工作簿
workbook.close();
```
### 知识点五：jxl API的高级操作
除了基础操作之外，jxl API还支持一些高级功能，如：
- **设置单元格格式**：为单元格设置字体大小、颜色、对齐方式等。
- **批量修改**：一次性修改大量单元格的数据。
- **数据透视表**：创建和操作数据透视表。
- **图表**：在工作表中插入图表，并进行修改。
### 知识点六：错误处理
使用jxl API时，可能会遇到一些错误，例如：
- `BiffException`：当打开一个损坏的Excel文件时会抛出此异常。
- `WriteException`：在写入Excel文件时出现问题会抛出此异常。
正确处理这些异常对于确保程序的健壮性至关重要。
### 知识点七：兼容性问题
由于jxl API主要处理XLS格式的Excel文件，它可能与新版本的Excel（如Excel 2007及以上版本的XLSX格式）不完全兼容。如果需要操作XLSX格式的文件，可能需要寻找其他的库，如Apache POI。
### 知识点八：最佳实践
当使用jxl API进行读写操作时，应该遵循一些最佳实践：
- 尽量在读取或写入少量数据时打开和关闭工作簿，以节省资源。
- 对于需要大量数据操作的场景，建议使用jxl API的批量写入和批量读取功能。
- 注意线程安全问题。jxl API不是线程安全的，因此在多线程环境下操作Excel文件时需要特别注意。
- 在处理大量数据时，可能需要考虑性能优化，例如缓存读取的数据或使用更高效的文件操作方法。
以上就是jxl API在读写Excel文件时的详细知识点，涵盖了jxl API的基本概念、安装配置、主要功能、操作示例、高级操作、错误处理、兼容性问题以及最佳实践。掌握这些知识点将有助于开发者高效、稳定地处理Excel文件。
【故障恢复策略】：RK3588与NVMe固态硬盘的容灾方案指南
# 1. RK3588处理器与NVMe固态硬盘的概述
## 1.1 RK3588处理器简介
RK3588是Rockchip推出的一款高端处理器，具备强大的性能和多样的功能，集成了八核CPU和六核GPU，以及专用的AI处理单元，主要用于高端移动设备、边缘计算和