|
|
import torch.nn as nn |
|
|
|
|
|
from torchvision import models |
|
|
from lib.common import normalize_imagenet |
|
|
|
|
|
|
|
|
class Resnet18(nn.Module): |
|
|
r''' ResNet-18 encoder network for image input. |
|
|
Args: |
|
|
c_dim (int): output dimension of the latent embedding |
|
|
normalize (bool): whether the input images should be normalized |
|
|
use_linear (bool): whether a final linear layer should be used |
|
|
''' |
|
|
|
|
|
def __init__(self, c_dim, normalize=True, use_linear=True): |
|
|
super().__init__() |
|
|
self.normalize = normalize |
|
|
self.use_linear = use_linear |
|
|
self.features = models.resnet18(pretrained=True) |
|
|
self.features.fc = nn.Sequential() |
|
|
if use_linear: |
|
|
self.fc = nn.Linear(512, c_dim) |
|
|
elif c_dim == 512: |
|
|
self.fc = nn.Sequential() |
|
|
else: |
|
|
raise ValueError('c_dim must be 512 if use_linear is False') |
|
|
|
|
|
def forward(self, x): |
|
|
if self.normalize: |
|
|
x = normalize_imagenet(x) |
|
|
net = self.features(x) |
|
|
out = self.fc(net) |
|
|
return out |
|
|
|
|
|
|
|
|
class ConvEncoder3D(nn.Module): |
|
|
r''' Simple convolutional conditioning network. |
|
|
|
|
|
It consists of 6 convolutional layers, each downsampling the input by a |
|
|
factor of 2, and a final fully-connected layer projecting the output to |
|
|
c_dim dimensions. |
|
|
''' |
|
|
|
|
|
def __init__(self, c_dim=128, hidden_dim=32, **kwargs): |
|
|
r''' Initialisation. |
|
|
|
|
|
Args: |
|
|
c_dim (int): output dimension of the latent embedding |
|
|
''' |
|
|
super().__init__() |
|
|
self.conv0 = nn.Conv3d(3, hidden_dim, 3, stride=(1, 2, 2), padding=1) |
|
|
self.conv1 = nn.Conv3d(hidden_dim, hidden_dim*2, |
|
|
3, stride=(2, 2, 2), padding=1) |
|
|
self.conv2 = nn.Conv3d(hidden_dim*2, hidden_dim*4, |
|
|
3, stride=(1, 2, 2), padding=1) |
|
|
self.conv3 = nn.Conv3d(hidden_dim*4, hidden_dim*8, |
|
|
3, stride=(2, 2, 2), padding=1) |
|
|
self.conv4 = nn.Conv3d(hidden_dim*8, hidden_dim*16, |
|
|
3, stride=(2, 2, 2), padding=1) |
|
|
self.conv5 = nn.Conv3d(hidden_dim*16, hidden_dim*16, |
|
|
3, stride=(2, 2, 2), padding=1) |
|
|
self.fc_out = nn.Linear(hidden_dim*16, c_dim) |
|
|
self.actvn = nn.ReLU() |
|
|
|
|
|
def forward(self, x): |
|
|
x = x.transpose(1, 2) |
|
|
batch_size = x.size(0) |
|
|
net = self.conv0(x) |
|
|
net = self.conv1(self.actvn(net)) |
|
|
net = self.conv2(self.actvn(net)) |
|
|
net = self.conv3(self.actvn(net)) |
|
|
net = self.conv4(self.actvn(net)) |
|
|
net = self.conv5(self.actvn(net)) |
|
|
|
|
|
final_dim = net.shape[1] |
|
|
net = net.view(batch_size, final_dim, -1).mean(2) |
|
|
out = self.fc_out(self.actvn(net)) |
|
|
|
|
|
return out |
|
|
|
