When I want to run the DSGAN/train.py with python train.py have the top question,who can help me solve this problem,thank you.
And I have try the ways in some blogs said ,set the relu and leakyrelu the inplace is False,but the problem doesn't solved~
This is the code of model:
`from torch import nn
import torch
class Generator(nn.Module):
def init(self, n_res_blocks=8):
super(Generator, self).init()
self.block_input = nn.Sequential(
nn.Conv2d(3, 64, kernel_size=3, padding=1),
nn.PReLU()
)
self.res_blocks = nn.ModuleList([ResidualBlock(64) for _ in range(n_res_blocks)])
self.block_output = nn.Conv2d(64, 3, kernel_size=3, padding=1)
def forward(self, x):
block = self.block_input(x)
for res_block in self.res_blocks:
block = res_block(block)
block = self.block_output(block)
return torch.sigmoid(block)
class Discriminator(nn.Module):
def init(self, recursions=1, stride=1, kernel_size=5, gaussian=False, wgan=False, highpass=True):
super(Discriminator, self).init()
if highpass:
self.filter = FilterHigh(recursions=recursions, stride=stride, kernel_size=kernel_size, include_pad=False,
gaussian=gaussian)
else:
self.filter = None
self.net = DiscriminatorBasic(n_input_channels=3)
self.wgan = wgan
def forward(self, x, y=None):
if self.filter is not None:
x = self.filter(x)
x = self.net(x)
if y is not None:
x -= self.net(self.filter(y)).mean(0, keepdim=True)
if not self.wgan:
x = torch.sigmoid(x)
return x
class DiscriminatorBasic(nn.Module):
def init(self, n_input_channels=3):
super(DiscriminatorBasic, self).init()
self.net = nn.Sequential(
nn.Conv2d(n_input_channels, 64, kernel_size=5, padding=2),
nn.LeakyReLU(0.2,inplace=False),
nn.Conv2d(64, 128, kernel_size=5, padding=2),
nn.BatchNorm2d(128),
nn.LeakyReLU(0.2,inplace=False),
nn.Conv2d(128, 256, kernel_size=5, padding=2),
nn.BatchNorm2d(256),
nn.LeakyReLU(0.2,inplace=False),
nn.Conv2d(256, 1, kernel_size=1)
)
def forward(self, x):
return self.net(x)
class ResidualBlock(nn.Module):
def init(self, channels):
super(ResidualBlock, self).init()
self.conv1 = nn.Conv2d(channels, channels, kernel_size=3, padding=1)
self.prelu = nn.PReLU()
self.conv2 = nn.Conv2d(channels, channels, kernel_size=3, padding=1)
def forward(self, x):
residual = self.conv1(x)
residual = self.prelu(residual)
residual = self.conv2(residual)
return x + residual
class GaussianFilter(nn.Module):
def init(self, kernel_size=5, stride=1, padding=4):
super(GaussianFilter, self).init()
# initialize guassian kernel
mean = (kernel_size - 1) / 2.0
variance = (kernel_size / 6.0) ** 2.0
# Create a x, y coordinate grid of shape (kernel_size, kernel_size, 2)
x_coord = torch.arange(kernel_size)
x_grid = x_coord.repeat(kernel_size).view(kernel_size, kernel_size)
y_grid = x_grid.t()
xy_grid = torch.stack([x_grid, y_grid], dim=-1).float()
# Calculate the 2-dimensional gaussian kernel
gaussian_kernel = torch.exp(-torch.sum((xy_grid - mean) ** 2., dim=-1) / (2 * variance))
# Make sure sum of values in gaussian kernel equals 1.
gaussian_kernel = gaussian_kernel / torch.sum(gaussian_kernel)
# Reshape to 2d depthwise convolutional weight
gaussian_kernel = gaussian_kernel.view(1, 1, kernel_size, kernel_size)
gaussian_kernel = gaussian_kernel.repeat(3, 1, 1, 1)
# create gaussian filter as convolutional layer
self.gaussian_filter = nn.Conv2d(3, 3, kernel_size, stride=stride, padding=padding, groups=3, bias=False)
self.gaussian_filter.weight.data = gaussian_kernel
self.gaussian_filter.weight.requires_grad = False
def forward(self, x):
return self.gaussian_filter(x)
class FilterLow(nn.Module):
def init(self, recursions=1, kernel_size=5, stride=1, padding=True, include_pad=True, gaussian=False):
super(FilterLow, self).init()
if padding:
pad = int((kernel_size - 1) / 2)
else:
pad = 0
if gaussian:
self.filter = GaussianFilter(kernel_size=kernel_size, stride=stride, padding=pad)
else:
self.filter = nn.AvgPool2d(kernel_size=kernel_size, stride=stride, padding=pad, count_include_pad=include_pad)
self.recursions = recursions
def forward(self, img):
for i in range(self.recursions):
img = self.filter(img)
return img
class FilterHigh(nn.Module):
def init(self, recursions=1, kernel_size=5, stride=1, include_pad=True, normalize=True, gaussian=False):
super(FilterHigh, self).init()
self.filter_low = FilterLow(recursions=1, kernel_size=kernel_size, stride=stride, include_pad=include_pad,
gaussian=gaussian)
self.recursions = recursions
self.normalize = normalize
def forward(self, img):
if self.recursions > 1:
for i in range(self.recursions - 1):
img = self.filter_low(img)
img = img - self.filter_low(img)
if self.normalize:
return 0.5 + img * 0.5
else:
return img
`