持续更新和补充中…多多交流！
参考:
图像评价指标PNSR和SSIM
函数 structural_similarity
图片相似度计算方法总结
MSE和PSNR
MSE:
M S E = 1 m n ∑ i = 0 m − 1 ∑ j = 0 n − 1 [ I ( i , j ) − K ( i , j ) ] 2 MSE=\frac{1}{mn}\sum_{i=0}^{m-1}\sum_{j=0}^{n-1}[I(i,j)-K(i,j)]^2 MSE=mn1i=0∑m−1j=0∑n−1[I(i,j)−K(i,j)]2
- M S E MSE MSE：均方误差（Mean Squared Error），用于衡量两幅图像之间的差异，MSE越小表示两幅图像越相似。
- m m m：图像的行数或高度。
- n n n：图像的列数或宽度。
- I ( i , j ) I(i,j) I(i,j)：原始图像的像素值，表示在位置 ( i , j ) (i,j) (i,j)处的像素值。
- K ( i , j ) K(i,j) K(i,j)：处理后的图像的像素值，表示在位置 ( i , j ) (i,j) (i,j)处的像素值。
import torch
def calculate_mse(original_img, enhanced_img):
# 将图像转换为 PyTorch 的 Tensor
original_img_tensor = torch.tensor(original_img, dtype=torch.float32)
enhanced_img_tensor = torch.tensor(enhanced_img, dtype=torch.float32)
# 计算像素值之差的平方
diff = original_img_tensor - enhanced_img_tensor
squared_diff = torch.square(diff)
# 计算均方误差
mse = torch.mean(squared_diff)
return mse.item() # 返回均方误差的值
# 示例用法
original_img = [0.1, 0.2, 0.3, 0.4] # 原始图像像素值
enhanced_img = [0.15, 0.25, 0.35, 0.45] # 处理后图像像素值
mse_value = calculate_mse(original_img, enhanced_img)
print("MSE 值为:", mse_value)
PSNR基于MSE进行计算:
P S N R = 10 ⋅ l o g 10 ( M A X I 2 M S E ) \begin{aligned} PSNR=10\cdot log_{10}(\frac{MAX_{I}^{2}}{MSE}) \end{aligned} PSNR=10⋅log10(MSEMAXI2)
- MAX表示像素灰度级的最大值，如果一个像素值由B位来表示，则 M A X I = 2 B − 1 MAX_I=2^B-1 MAXI=2B−1.
- MSE表示均方误差
- 如果是彩色图像，一般有三种方法
- 分别计算 RGB 三个通道的 PSNR，然后取平均值。
- 计算 RGB 三通道的 MSE ，然后再除以 3。
- 将图片转化为 YCbCr 格式，然后只计算 Y分量也就是亮度分量的 PSNR。
import numpy as np
def calculate_mse(original_img, enhanced_img):
mse = np.mean((original_img - enhanced_img) ** 2)
return mse
MAX = 255 # 最大灰度级
original_img = np.array([[1, 2, 3], [4, 5, 6]]) # 原始图像
enhanced_img = np.array([[3, 4, 5], [6, 7, 8]]) # 处理后的图像
mse = calculate_mse(original_img, enhanced_img)
psnr = 10 * np.log10(MAX**2 / mse)
print("MSE:", mse)
print("PSNR:", psnr)
SSIM-结构相似性
SSIM（structural similarity）结构相似性，也是一种全参考的图像质量评价指标，它分别从亮度、对比度、结构三方面度量图像相似性。
S
S
I
M
(
x
,
y
)
=
[
l
(
x
,
y
)
α
⋅
c
(
x
,
y
)
β
⋅
s
(
x
,
y
)
γ
]
SSIM(x,y)=[l(x,y)^\alpha\cdot c(x,y)^\beta\cdot s(x,y)^\gamma]
SSIM(x,y)=[l(x,y)α⋅c(x,y)β⋅s(x,y)γ]
-
l ( x , y ) = 2 μ x μ y + C 1 μ x 2 + μ y 2 + C 1 l(x, y) = \frac{2\mu_x\mu_y + C_1}{\mu_x^2 + \mu_y^2 + C_1} l(x,y)=μx2+μy2+C12μxμy+C1是亮度相似度，
- μ x \mu_x μx和 μ y \mu_y μy分别是图像 x x x和 y y y的均值
- C 1 = ( K 1 L ) 2 C_1=(K_1L)^2 C1=(K1L)2 是平滑度常数,k1=0.01为默认值
-
c ( x , y ) = 2 σ x σ y + C 2 σ x 2 + σ y 2 + C 2 c(x, y) = \frac{2\sigma_x\sigma_y + C_2}{\sigma_x^2 + \sigma_y^2 + C_2} c(x,y)=σx2+σy2+C22σxσy+C2是对比度相似度
- σ x \sigma_x σx 和 σ y \sigma_y σy分别是图像 x x x和 y y y 的标准差
- C 2 ( K 2 L ) 2 C_2(K_2L)^2 C2(K2L)2 是对比度常数,k2=0.03为默认值
-
s ( x , y ) = σ x y + C 3 σ x σ y + C 3 s(x, y) = \frac{\sigma_{xy} + C_3}{\sigma_x\sigma_y + C_3} s(x,y)=σxσy+C3σxy+C3是结构相似度，
- σ x y \sigma_{xy} σxy是 x x x和 y y y的协方差
- C 3 C_3 C3是结构常数,常取 C 2 / 2 C_2/2 C2/2
公式中的 α ， β ， γ \alpha， \beta， \gamma α，β，γ是权重参数，用于控制每个相似度项的影响力。通常情况下，它们的值是 α = β = γ = 1 \alpha = \beta = \gamma = 1 α=β=γ=1。
代码: https://github.com/jorge-pessoa/pytorch-msssim
#针对𝛼，𝛽，𝛾都为1的情况
import torch
import torch.nn.functional as F
from math import exp
import numpy as np
# 计算一维的高斯分布向量
def gaussian(window_size, sigma):
gauss = torch.Tensor([exp(-(x - window_size//2)**2/float(2*sigma**2)) for x in range(window_size)])
return gauss/gauss.sum()
# 创建高斯核，通过两个一维高斯分布向量进行矩阵乘法得到
# 可以设定channel参数拓展为3通道
def create_window(window_size, channel=1):
_1D_window = gaussian(window_size, 1.5).unsqueeze(1)
_2D_window = _1D_window.mm(_1D_window.t()).float().unsqueeze(0).unsqueeze(0)
window = _2D_window.expand(channel, 1, window_size, window_size).contiguous()
return window
# 计算SSIM
# 直接使用SSIM的公式，但是在计算均值时，不是直接求像素平均值，而是采用归一化的高斯核卷积来代替。
# 在计算方差和协方差时用到了公式Var(X)=E[X^2]-E[X]^2, cov(X,Y)=E[XY]-E[X]E[Y].
# 正如前面提到的，上面求期望的操作采用高斯核卷积代替。
def ssim(img1, img2, window_size=11, window=None, size_average=True, full=False, val_range=None):
# Value range can be different from 255. Other common ranges are 1 (sigmoid) and 2 (tanh).
if val_range is None:
if torch.max(img1) > 128:
max_val = 255
else:
max_val = 1
if torch.min(img1) < -0.5:
min_val = -1
else:
min_val = 0
L = max_val - min_val
else:
L = val_range
padd = 0
(_, channel, height, width) = img1.size()
if window is None:
real_size = min(window_size, height, width)
window = create_window(real_size, channel=channel).to(img1.device)
mu1 = F.conv2d(img1, window, padding=padd, groups=channel)
mu2 = F.conv2d(img2, window, padding=padd, groups=channel)
mu1_sq = mu1.pow(2)
mu2_sq = mu2.pow(2)
mu1_mu2 = mu1 * mu2
sigma1_sq = F.conv2d(img1 * img1, window, padding=padd, groups=channel) - mu1_sq
sigma2_sq = F.conv2d(img2 * img2, window, padding=padd, groups=channel) - mu2_sq
sigma12 = F.conv2d(img1 * img2, window, padding=padd, groups=channel) - mu1_mu2
C1 = (0.01 * L) ** 2
C2 = (0.03 * L) ** 2
v1 = 2.0 * sigma12 + C2
v2 = sigma1_sq + sigma2_sq + C2
cs = torch.mean(v1 / v2) # contrast sensitivity
ssim_map = ((2 * mu1_mu2 + C1) * v1) / ((mu1_sq + mu2_sq + C1) * v2)
if size_average:
ret = ssim_map.mean()
else:
ret = ssim_map.mean(1).mean(1).mean(1)
if full:
return ret, cs
return ret
# Classes to re-use window
class SSIM(torch.nn.Module):
def __init__(self, window_size=11, size_average=True, val_range=None):
super(SSIM, self).__init__()
self.window_size = window_size
self.size_average = size_average
self.val_range = val_range
# Assume 1 channel for SSIM
self.channel = 1
self.window = create_window(window_size)
def forward(self, img1, img2):
(_, channel, _, _) = img1.size()
if channel == self.channel and self.window.dtype == img1.dtype:
window = self.window
else:
window = create_window(self.window_size, channel).to(img1.device).type(img1.dtype)
self.window = window
self.channel = channel
return ssim(img1, img2, window=window, window_size=self.window_size, size_average=self.size_average)
还可以利用函数 structural_similarity
from skimage.metrics import structural_similarity as ssim
import numpy as np
# 创建两个示例图像
im1 = np.random.rand(256, 256)
im2 = np.random.rand(256, 256)
# 计算 SSIM，并使用一些可选参数
ssim_index, ssim_image = ssim(im1, im2,
win_size=11,
gradient=True,
data_range=1.0,
multichannel=False,
gaussian_weights=True,
full=True)
print(f"SSIM Index: {ssim_index}")
print(f"SSIM Image: \n{ssim_image}")
'''
def structural_similarity(*, im1, im2,
win_size=None, gradient=False, data_range=None,
multichannel=False, gaussian_weights=False,
full=False, **kwargs)
'''
| 参数名 | 类型及说明 |
|---|---|
im1, im2 | Ndarray，输入图像 |
win_size | int or none, optional，滑动窗口的边长，必须为奇数，默认值为7。当 gaussian_weights=True 时，滑动窗口的大小取决于 sigma |
gradient | bool, optional，若为 True，返回相对于 im2 的梯度 |
data_range | float, optional，图像灰度级数，图像灰度的最小值和最大可能值，默认情况下根据图像的数据类型进行估计 |
multichannel | bool, optional，值为 True 时将 img.shape[-1] 视为图像通道数，对每个通道单独计算，取平均值作为相似度 |
gaussian_weights | bool, optional，高斯权重，值为 True 时，平均值和方差在空间上的权重为归一化高斯核，宽度 sigma=1.5 |
use_sample_covariance | bool若为True，则通过N-1归一化协方差，N是滑动窗口内的像素数 |
| 其它参数 | 说明 |
|---|---|
K1,K2 | loat, 算法参数，默认值K1=0.01，K2=0.03 |
sigma | float，当gaussian_weights=True时，决定滑动窗口大小 |
full | bool, optional，值为 true 时，返回完整的结构相似性图像 |
| 返回值 | 说明 |
|---|---|
mssim | 平均结构相似度 |
grad | 结构相似性梯度 (gradient=True) |
S | 结构相似性图像(full=True) |
FIDFrechlet Inception Distance（FID）
FID是基于Inception-V3模型（预训练好的图像分类模型）的feature vectors来计算真实图片与生成图片之间的距离，用高斯分布来表示，FID就是计算两个分布之间的Wasserstein-2距离。将真实图片和预测图片分别经过Inception模型中，得到2048维度（特征的维度）的embedding vector。把生成和真实的图片同时放入Inception-V3中，然后将feature vectors取出来用于比较。
d
2
=
∣
∣
μ
1
−
μ
2
∣
∣
2
+
T
r
(
C
1
+
C
2
−
2
∗
(
C
1
∗
C
2
)
)
d^2 = ||\mu_1 -\mu_2||^2 + Tr(C_1 + C_2 - 2*\sqrt{(C_1 *C_2)})
d2=∣∣μ1−μ2∣∣2+Tr(C1+C2−2∗(C1∗C2))
- μ 1 ， μ 2 μ_1，μ_2 μ1，μ2为均值， C 1 , C 2 C_1,C_2 C1,C2为协方差， T r Tr Tr为矩阵的迹
- FID越低，说明预测分布越接近于真实的分布
- 可以评估类内多样性，例如每个类别只产生一张一模一样的照片，FID会比较高，也就意味着评估效果比较差
import numpy as np
from scipy.linalg import sqrtm
def calculate_fid(act1, act2):
# 计算均值和协方差统计量
mu1, sigma1 = act1.mean(axis=0), np.cov(act1, rowvar=False)
mu2, sigma2 = act2.mean(axis=0), np.cov(act2, rowvar=False)
# 计算均值之间的平方差之和
ssdiff = np.sum((mu1 - mu2)**2.0)
# 计算协方差之积的平方根
covmean = sqrtm(sigma1.dot(sigma2))
# 检查从sqrtm中移除的复数部分
if np.iscomplexobj(covmean):
covmean = covmean.real
# 计算 FID 分数
fid = ssdiff + np.trace(sigma1 + sigma2 - 2.0 * covmean)
return fid
# 示例用法
act1 = np.random.rand(100, 10) # 隐变量 act1
act2 = np.random.rand(100, 10) # 隐变量 act2
fid_score = calculate_fid(act1, act2)
print("FID 分数为:", fid_score)
Inception score
Inception Score基于Inception-V3模型的分类概率来评估生成照片的质量，通过使用预训练的卷积神经网络（通常是Inception网络）来评估生成图像的质量和多样性。
K
L
d
i
v
e
r
g
e
n
c
e
=
p
(
y
∣
x
)
∗
(
l
o
g
(
p
(
y
∣
x
)
)
−
l
o
g
(
p
(
y
)
)
)
\mathrm{KL~divergence=p(y|x)*(log(p(y|x))-log(p(y)))}
KL divergence=p(y∣x)∗(log(p(y∣x))−log(p(y)))
- p （ y ∣ x ） p（y|x） p（y∣x）:表示在给定条件 𝑥下，观测到的概率 𝑦
- p ( y ) p(y) p(y) 表示概率 𝑦的边际概率
- 对KL散度对所有类别求和再取平均值，并且取一个e指数，即可得到Inception Score。一般生成5000张照片S的值在0~1000范围内。
- 希望 p ( y ∣ x ) p(y|x) p(y∣x)应该具有低熵(即越真实），p(y)应该具有高熵即越多样，因此，IS值越大越好
- 缺点:缺乏跟真实照片之间的比较;缺乏类内多样性，例如每个类别只产生一张一模一样的照片，IS一样很高
import numpy as np
def calculate_inception_score(p_yx, eps=1E-16):
# 计算 p(y)：所有样本的平均值
p_y = np.expand_dims(p_yx.mean(axis=0), 0)
# 计算每个图像的 KL 散度
kl_d = p_yx * (np.log(p_yx + eps) - np.log(p_y + eps))
# 对类别求和
sum_kl_d = kl_d.sum(axis=1)
# 对所有图像的 KL 散度取平均值
avg_kl_d = np.mean(sum_kl_d)
# 撤销对数运算
is_score = np.exp(avg_kl_d)
return is_score
# 示例用法
p_yx = np.random.rand(100, 10) # 概率分布 p(y|x)
is_score = calculate_inception_score(p_yx)
print("Inception Score 值为:", is_score)
LPIPS
论文:
The Unreasonable Effectiveness of Deep Features as a Perceptual Metric
代码:
LPIPS代码实现-Pytorch
LPIPS:学习感知图像块相似度(Learned Perceptual Image Patch Similarity, LPIPS)也称为“感知损失”(perceptual loss)，用于度量两张图像之间的差别，LPIPS 测量风格化图像和相应内容图像之间的内容保真度。它通过比较图像块的深层特征来工作，这些特征能够捕捉到人类视觉系统中对图像质量的感知。LPIPS的值越低表示两张图像越相似，反之，则差异越大。
步骤:从 l l l层提取特征堆(feature stack)并在通道维度中进行单位规格化(unit-normalize)。利用向量 W l W_l Wl来放缩激活通道数,最终计算 L 2 L_2 L2距离。 最后在空间上平均，在通道上求和。 d ( x , x 0 ) = ∑ l 1 H l W l ∑ h , w ∣ ∣ w l ⊙ ( y ^ h w l − y ^ 0 h w l ) ∣ ∣ 2 2 d(x,x_0)=\sum_l\frac1{H_lW_l}\sum_{h,w}||w_l\odot(\hat{y}_{hw}^l-\hat{y}_{0hw}^l)||_2^2 d(x,x0)=l∑HlWl1h,w∑∣∣wl⊙(y^hwl−y^0hwl)∣∣22
-
d ( x , x 0 ) d(x, x_0) d(x,x0)：表示图像块 x x x 和 x 0 x_0 x0 之间的感知距离，即它们在感知上的差异度量。
-
l l l：表示特征堆中的层（layer）索引，用于指代不同的深度特征表示。
-
H l ， W l H_l，W_l Hl，Wl：表示特征堆中第 l l l 层的高度（height）和宽度（width）。
-
h , w h, w h,w：分别表示特征堆中第 l l l 层的高度和宽度索引，用于遍历特征图中的每个位置。
-
w l w_l wl：表示用于缩放特征通道的权重向量，对应于特征堆中第 l l l 层的通道数。
-
y ^ h w l \hat{y}_{hw}^l y^hwl：表示特征堆中第 l l l 层的特征表示的一个元素，对应于在位置 ( h , w ) (h, w) (h,w) 处的特征向量。
-
y ^ 0 h w l \hat{y}_{0hw}^l y^0hwl：表示特征堆中第 l l l 层的参考特征表示的一个元素，对应于在位置 ( h , w ) (h, w) (h,w) 处的参考特征向量。
import torch
import lpips
use_gpu = False
spatial = True #返回感知距离的空间地图
# 创建线性校准的 LPIPS 模型
loss_fn = lpips.LPIPS(net='alex', spatial=spatial) # 使用 AlexNet 架构创建 LPIPS 模型
# loss_fn = lpips.LPIPS(net='alex', spatial=spatial, lpips=False) # 使用不同网络配置的 LPIPS 模型
if use_gpu:
loss_fn.cuda() # 如果 use_gpu 为 True，则将 LPIPS 模型移动到 GPU 上
# 示例中使用虚拟张量
root_path = r'D:\Project\results\faces' # 存储图像的根路径
img0_path_list = [] # 存储文件名中包含 '_generated' 的图像路径列表
img1_path_list = [] # 存储文件名中包含 '_real' 的图像路径列表
# 循环遍历图像路径（代码已注释，不会执行）
for root, _, fnames in sorted(os.walk(root_path, followlinks=True)):
for fname in fnames:
path = os.path.join(root, fname)
if '_generated' in fname:
img0_path_list.append(path)
elif '_real' in fname:
img1_path_list.append(path)
distances = [] # 存储计算得到的图像对之间的感知距离
for i in range(len(img0_path_list)):
dummy_img0 = lpips.im2tensor(lpips.load_image(img0_path_list[i])) # 加载并将图像转换为张量
dummy_img1 = lpips.im2tensor(lpips.load_image(img1_path_list[i])) # 加载并将图像转换为张量
if use_gpu:
dummy_img0 = dummy_img0.cuda() # 将图像张量移动到 GPU
dummy_img1 = dummy_img1.cuda() # 将图像张量移动到 GPU
dist = loss_fn.forward(dummy_img0, dummy_img1) # 计算图像对之间的感知距离
distances.append(dist.mean().item()) # 将平均距离添加到 distances 列表中
print('Average Distances: %.3f' % (sum(distances) / len(img0_path_list))) # 打印平均感知距离
CSFD
代码：https://github.com/jiwoogit/StyleID
论文：https://jiwoogit.github.io/StyleID_site/
Content Feature Structural Distance-CFSD内容特征结构距离。在风格迁移评估中，内容保真度通常依赖于LPIPS距离，该指标使用了在ImageNet数据集上预训练的AlexNet模型的特征空间，这使得LPIPS对纹理有偏见。图像的风格信息可能会影响LPIPS分数，因为它偏向于纹理特征。为了减少风格信息对评估的影响，作者引入了CFSD，这是一种只考虑图像块之间空间相关性的新距离度量。
CFSD的计算步骤：
- 获取特征图：对于给定图像 I I I，首先获取特征图 F ∈ R h × w × c F \in \mathbb{R}^{h \times w \times c} F∈Rh×w×c，这是VGG19网络中conv3层的输出特征。
- 计算相似性矩阵：计算特征图 F F F中每对特征之间的相似性，得到相似性矩阵 M = F × F T M = F \times F^T M=F×FT，其中 M ∈ R h × w × h × w M \in \mathbb{R}^{h \times w \times h \times w} M∈Rh×w×h×w。
- 应用softmax操作：对相似性矩阵 M M M 的每个元素应用softmax操作，将其建模为概率分布，得到相关性矩阵 S = [ softmax ( M i ) ] h × w i = 1 S = [\text{softmax}(M_i)]_{h \times w}^{i=1} S=[softmax(Mi)]h×wi=1，其中 M i ∈ R 1 × h × w M_i \in \mathbb{R}^{1 \times h \times w} Mi∈R1×h×w 是第 i i i 个图像块与其他块的相似性。
- 计算KL散度：CFSD定义为两个相关性矩阵之间的Kullback-Leibler散度（KL-divergence）。
CFSD公式：
C F S D = 1 h w ∑ i = 1 h w D K L ( S i c ∣ ∣ S i c s ) , \mathrm{CFSD}=\frac{1}{hw}\sum_{i=1}^{hw}D_{\mathrm{KL}}(S_{i}^{c}||S_{i}^{cs}), CFSD=hw1i=1∑hwDKL(Sic∣∣Sics),
- S i c S_{i}^{c} Sic:内容图像对应的相关性矩阵的第i个元素，这些矩阵是通过计算图像特征图（例如，VGG19网络的conv3层输出）中每对特征之间的相似性得到的。
- S i c s S_{i}^{cs} Sics:风格图像对应的相关性矩阵的第i个元素
- D K L D_{KL} DKL:KL散度
#StyleID\evaluation\eval_artfid.py
def compute_patch_simi(path_to_stylized, path_to_content, batch_size, device, num_workers=1):
"""Computes the distance for the given paths.
Args:
path_to_stylized (str): Path to the stylized images.
path_to_style (str): Path to the style images. [注：这里应该为 path_to_content，修正为 path_to_content]
batch_size (int): Batch size for computing activations.
content_metric (str): Metric to use for content distance. Choices: 'lpips', 'vgg', 'alexnet' [注：缺少 content_metric 参数]
device (str): Device for computing activations.
num_workers (int): Number of threads for data loading.
Returns:
(float) FID value. [注：文档中写的是 FID value，但函数名为 compute_patch_simi，可能存在混淆，需要核对和确认]
"""
device = torch.device('cuda') if device == 'cuda' and torch.cuda.is_available() else torch.device('cpu')
# 根据路径获取图像路径并排序以匹配样式化图像与对应的内容图像
stylized_image_paths = get_image_paths(path_to_stylized, sort=True)
content_image_paths = get_image_paths(path_to_content, sort=True)
# 确保样式化图像和内容图像数量相等
assert len(stylized_image_paths) == len(content_image_paths), 'Number of stylized images and number of content images must be equal.'
# 定义图像转换方法
style_transforms = ToTensor()
# 创建样式化图像的数据集和数据加载器
dataset_stylized = ImagePathDataset(stylized_image_paths, transforms=style_transforms)
dataloader_stylized = torch.utils.data.DataLoader(dataset_stylized,
batch_size=batch_size,
shuffle=False,
drop_last=False,
num_workers=num_workers)
# 创建内容图像的数据集和数据加载器
dataset_content = ImagePathDataset(content_image_paths, transforms=style_transforms)
dataloader_content = torch.utils.data.DataLoader(dataset_content,
batch_size=batch_size,
shuffle=False,
drop_last=False,
num_workers=num_workers)
# 初始化用于计算距离的度量类
metric = image_metrics.PatchSimi(device=device).to(device)
dist_sum = 0.0
N = 0
pbar = tqdm(total=len(stylized_image_paths))
# 遍历样式化图像和内容图像的批次
for batch_stylized, batch_content in zip(dataloader_stylized, dataloader_content):
# 在不计算梯度的上下文中进行操作，节省内存和计算资源
with torch.no_grad():
# 计算当前批次的距离
batch_dist = metric(batch_stylized.to(device), batch_content.to(device))
N += batch_stylized.shape[0]
dist_sum += torch.sum(batch_dist)
pbar.update(batch_stylized.shape[0])
pbar.close()
return dist_sum / N
def compute_cfsd(path_to_stylized, path_to_content, batch_size, device, num_workers=1):
"""Computes CFSD for the given paths.
Args:
path_to_stylized (str): Path to the stylized images.
path_to_content (str): Path to the content images.
batch_size (int): Batch size for computing activations.
device (str): Device for computing activations.
num_workers (int): Number of threads for data loading.
Returns:
(float) CFSD value.
"""
print('Compute CFSD value...')
# 计算 Patch Similarity，该函数返回样式化图像和内容图像的距离值
simi_val = compute_patch_simi(path_to_stylized, path_to_content, 1, device, num_workers)
# 将距离值保留四位小数
simi_dist = f'{simi_val.item():.4f}'
return simi_dist
#evaluation\image_metrics.py
class PatchSimi(nn.Module):
def __init__(self, device=None):
# 初始化函数
super(PatchSimi, self).__init__()
# 加载预训练的 VGG19 模型，并移到指定设备上进行评估
self.model = models.vgg19(pretrained=True).features.to(device).eval()
# 指定层名称和替换名称的映射
self.layers = {"11": "conv3"}
# 图像归一化的均值和标准差
self.norm_mean = (0.485, 0.456, 0.406)
self.norm_std = (0.229, 0.224, 0.225)
# KL 散度损失函数
self.kld = torch.nn.KLDivLoss(reduction='batchmean')
self.device = device
def get_feats(self, img):
features = []
# 遍历 VGG19 模型的各层并提取特征
for name, layer in self.model._modules.items():
img = layer(img)
if name in self.layers:
features.append(img)
return features
def normalize(self, input):
# 图像归一化处理
return transforms.functional.normalize(input, self.norm_mean, self.norm_std)
def patch_simi_cnt(self, input):
b, c, h, w = input.size()
# 转置和重塑特征
input = torch.transpose(input, 1, 3)
features = input.reshape(b, h*w, c).div(c)
feature_t = torch.transpose(features, 1, 2)
# 计算内容图像的特征相似度
patch_simi = F.log_softmax(torch.bmm(features, feature_t), dim=-1)
return patch_simi.reshape(b, -1)
def patch_simi_out(self, input):
b, c, h, w = input.size()
# 转置和重塑特征
input = torch.transpose(input, 1, 3)
features = input.reshape(b, h*w, c).div(c)
feature_t = torch.transpose(features, 1, 2)
# 计算样式化图像的特征相似度
patch_simi = F.softmax(torch.bmm(features, feature_t), dim=-1)
return patch_simi.reshape(b, -1)
def forward(self, input, target):
src_feats = self.get_feats(self.normalize(input))
target_feats = self.get_feats(self.normalize(target))
init_loss = 0.
# 计算各层的 KL 散度并求和作为初始损失值
for idx in range(len(src_feats)):
init_loss += F.kl_div(self.patch_simi_cnt(src_feats[idx]), self.patch_simi_out(target_feats[idx]), reduction='batchmean')
余弦相似度
cos ( θ ) = ∑ i = 1 n ( x i × y i ) ∑ i = 1 n ( x i ) 2 × ∑ i = 1 n ( y i ) 2 = a ∙ b ∣ ∣ a ∣ ∣ × ∣ ∣ b ∣ ∣ \begin{aligned} \begin{array}{c}\\{\cos( \theta )}\\\end{array} =\quad\frac{\sum_{i = 1}^{n} ( x_{i} \times y_{i} )}{\sqrt{\sum_{i = 1}^{n} ( x_{i} )^{2}} \times \sqrt{\sum_{i = 1}^{n} ( y_{i} )^{2}}} = \frac{\mathrm{a} \bullet \mathrm{b}}{| | \mathrm{a} | | \times | | \mathrm{b} | |} \end{aligned} cos(θ)=∑i=1n(xi)2×∑i=1n(yi)2∑i=1n(xi×yi)=∣∣a∣∣×∣∣b∣∣a∙b
# -*- coding: utf-8 -*-
# !/usr/bin/env python
# 余弦相似度计算
from PIL import Image
from numpy import average, dot, linalg
# 对图片进行统一化处理
def get_thum(image, size=(64, 64), greyscale=False):
# 利用image对图像大小重新设置, Image.ANTIALIAS为高质量的
image = image.resize(size, Image.ANTIALIAS)
if greyscale:
# 将图片转换为L模式，其为灰度图，其每个像素用8个bit表示
image = image.convert('L')
return image
# 计算图片的余弦距离
def image_similarity_vectors_via_numpy(image1, image2):
image1 = get_thum(image1)
image2 = get_thum(image2)
images = [image1, image2]
vectors = []
norms = []
for image in images:
vector = []
for pixel_tuple in image.getdata():
vector.append(average(pixel_tuple))
vectors.append(vector)
# linalg=linear（线性）+algebra（代数），norm则表示范数
# 求图片的范数
norms.append(linalg.norm(vector, 2))
a, b = vectors
a_norm, b_norm = norms
# dot返回的是点积，对二维数组（矩阵）进行计算
res = dot(a / a_norm, b / b_norm)
return res
image1 = Image.open('010.jpg')
image2 = Image.open('011.jpg')
cosin = image_similarity_vectors_via_numpy(image1, image2)
print('图片余弦相似度', cosin)
