lpips的python代码

以下是使用PyTorch实现的LPIPS（Learned Perceptual Image Patch Similarity）的Python代码：

import torch
import torch.nn as nn

class LPIPS(nn.Module):
    def __init__(self, net='alex', version='0.1'):
        super(LPIPS, self).__init__()
        self.version = version
        self.net = nn.Sequential(*list(self.get_net(net)))

    def get_net(self, net):
        if net == 'alex':
            net = [
                nn.Conv2d(3, 64, kernel_size=11, stride=4, padding=2),
                nn.ReLU(inplace=True),
                nn.MaxPool2d(kernel_size=3, stride=2),
                nn.Conv2d(64, 192, kernel_size=5, padding=2),
                nn.ReLU(inplace=True),
                nn.MaxPool2d(kernel_size=3, stride=2),
                nn.Conv2d(192, 384, kernel_size=3, padding=1),
                nn.ReLU(inplace=True),
                nn.Conv2d(384, 256, kernel_size=3, padding=1),
                nn.ReLU(inplace=True),
                nn.Conv2d(256, 256, kernel_size=3, padding=1),
                nn.ReLU(inplace=True),
                nn.MaxPool2d(kernel_size=3, stride=2),
                nn.AdaptiveAvgPool2d(output_size=(6, 6)),
                nn.Conv2d(256, 4096, kernel_size=6),
                nn.ReLU(inplace=True),
                nn.Conv2d(4096, 4096, kernel_size=1),
                nn.ReLU(inplace=True),
                nn.Conv2d(4096, 1, kernel_size=1)
            ]
        elif net == 'vgg':
            net = [
                nn.Conv2d(3, 64, kernel_size=3, padding=1),
                nn.ReLU(inplace=True),
                nn.Conv2d(64, 64, kernel_size=3, padding=1),
                nn.ReLU(inplace=True),
                nn.MaxPool2d(kernel_size=2, stride=2),
                nn.Conv2d(64, 128, kernel_size=3, padding=1),
                nn.ReLU(inplace=True),
                nn.Conv2d(128, 128, kernel_size=3, padding=1),
                nn.ReLU(inplace=True),
                nn.MaxPool2d(kernel_size=2, stride=2),
                nn.Conv2d(128, 256, kernel_size=3, padding=1),
                nn.ReLU(inplace=True),
                nn.Conv2d(256, 256, kernel_size=3, padding=1),
                nn.ReLU(inplace=True),
                nn.Conv2d(256, 256, kernel_size=3, padding=1),
                nn.ReLU(inplace=True),
                nn.MaxPool2d(kernel_size=2, stride=2),
                nn.Conv2d(256, 512, kernel_size=3, padding=1),
                nn.ReLU(inplace=True),
                nn.Conv2d(512, 512, kernel_size=3, padding=1),
                nn.ReLU(inplace=True),
                nn.Conv2d(512, 512, kernel_size=3, padding=1),
                nn.ReLU(inplace=True),
                nn.MaxPool2d(kernel_size=2, stride=2),
                nn.Conv2d(512, 512, kernel_size=3, padding=1),
                nn.ReLU(inplace=True),
                nn.Conv2d(512, 512, kernel_size=3, padding=1),
                nn.ReLU(inplace=True),
                nn.Conv2d(512, 512, kernel_size=3, padding=1),
                nn.ReLU(inplace=True),
                nn.MaxPool2d(kernel_size=2, stride=2),
                nn.AdaptiveAvgPool2d(output_size=(7, 7)),
                nn.Conv2d(512, 4096, kernel_size=7),
                nn.ReLU(inplace=True),
                nn.Conv2d(4096, 4096, kernel_size=1),
                nn.ReLU(inplace=True),
                nn.Conv2d(4096, 1, kernel_size=1)
            ]
        else:
            raise ValueError('Invalid network specified.')

        return net

    def forward(self, x, y):
        x = (x + 1) / 2
        y = (y + 1) / 2
        if self.version == '0.1':
            distances = []
            for i in range(x.shape[0]):
                d = 0
                for j in range(x.shape[1]):
                    d += torch.norm(x[i, j] - y[i, j], p=2)
                distances.append(d)
            distances = torch.stack(distances)
        elif self.version == '0.2':
            distances = self.net(torch.cat((x, y), dim=1)).squeeze()
        else:
            raise ValueError('Invalid version specified.')

        return distances

使用方法：

import torch
from lpips import LPIPS

model = LPIPS(net='alex', version='0.1')
x = torch.randn(1, 3, 256, 256)
y = torch.randn(1, 3, 256, 256)
distance = model(x, y)