def check_dc_discriminator():
"""Checks the output and number of parameters of the DCDiscriminator class.
"""
state = torch.load('/home/love_you/Documents/Study/deep_learning/a4-code/a4-code-v2-updated/checker_files/dc_discriminator.pt')
# for key, value in state.items():
# print(key)
D = DCDiscriminator(conv_dim=32)
# summary(D, input_size=(3, 32, 32))
D.load_state_dict(state['state_dict'])
images = state['input']
dc_discriminator_expected = state['output']
output = D(images)
output_np = output.data.cpu().numpy()
if np.allclose(output_np, dc_discriminator_expected):
print('DCDiscriminator output: EQUAL')
else:
print("output_np: ", output_np.shape)
print("dc_discriminator_expected: ", dc_discriminator_expected.shape)
print('DCDiscriminator output: NOT EQUAL')
num_params = count_parameters(D)
expected_params = 167872
print('DCDiscriminator #params = {}, expected #params = {}, {}'.format(
num_params, expected_params, 'EQUAL' if num_params == expected_params else 'NOT EQUAL'))
print('-' * 80)
def check_dc_discriminator():
"""Checks the output and number of parameters of the DCDiscriminator class.
"""
state = torch.load('checker_files/dc_discriminator.pt')
D = DCDiscriminator(conv_dim=32)
D.load_state_dict(state['state_dict'])
images = state['input']
dc_discriminator_expected = state['output']
output = D(images)
output_np = output.data.cpu().numpy()
if np.allclose(output_np, dc_discriminator_expected):
print('DCDiscriminator output: EQUAL')
else:
print('DCDiscriminator output: NOT EQUAL')
num_params = count_parameters(D)
expected_params = 167872
print('DCDiscriminator #params = {}, expected #params = {}, {}'.format(
num_params, expected_params,
'EQUAL' if num_params == expected_params else 'NOT EQUAL'))
print('-' * 80)
def create_model(opts):
"""Builds the generators and discriminators.
"""
G_XtoY = CycleGenerator(conv_dim=opts.g_conv_dim, init_zero_weights=opts.init_zero_weights)
G_YtoX = CycleGenerator(conv_dim=opts.g_conv_dim, init_zero_weights=opts.init_zero_weights)
D_X = DCDiscriminator(conv_dim=opts.d_conv_dim)
D_Y = DCDiscriminator(conv_dim=opts.d_conv_dim)
return G_XtoY, G_YtoX, D_X, D_Y
def create_model(opts):
"""Builds the generators and discriminators.
"""
G = DCGenerator(noise_size=opts.noise_size, conv_dim=opts.conv_dim)
D = DCDiscriminator(conv_dim=opts.conv_dim)
print_models(G, D)
if torch.cuda.is_available():
G.cuda()
D.cuda()
print('Models moved to GPU.')
return G, D
def load_checkpoint(opts):
"""Loads the generator and discriminator models from checkpoints.
"""
G_XtoY_path = os.path.join(opts.load, 'G_XtoY.pkl')
G_YtoX_path = os.path.join(opts.load, 'G_YtoX.pkl')
D_X_path = os.path.join(opts.load, 'D_X.pkl')
D_Y_path = os.path.join(opts.load, 'D_Y.pkl')
G_XtoY = CycleGenerator(conv_dim=opts.g_conv_dim,
init_zero_weights=opts.init_zero_weights)
G_YtoX = CycleGenerator(conv_dim=opts.g_conv_dim,
init_zero_weights=opts.init_zero_weights)
D_X = DCDiscriminator(conv_dim=opts.d_conv_dim)
D_Y = DCDiscriminator(conv_dim=opts.d_conv_dim)
G_XtoY.load_state_dict(
torch.load(G_XtoY_path, map_location=lambda storage, loc: storage))
G_YtoX.load_state_dict(
torch.load(G_YtoX_path, map_location=lambda storage, loc: storage))
D_X.load_state_dict(
torch.load(D_X_path, map_location=lambda storage, loc: storage))
D_Y.load_state_dict(
torch.load(D_Y_path, map_location=lambda storage, loc: storage))
# if torch.cuda.is_available():
# G_XtoY.cuda()
# G_YtoX.cuda()
# D_X.cuda()
# D_Y.cuda()
# print('Models moved to GPU.')
return G_XtoY, G_YtoX, D_X, D_Y
def create_model(opts):
"""Builds the generators and discriminators.
"""
G = DCGenerator(noise_size=opts.noise_size, conv_dim=opts.conv_dim)
D = DCDiscriminator(conv_dim=opts.conv_dim)
return G, D
def check_dc_discriminator():
"""Checks the output and number of parameters of the DCDiscriminator class.
"""
set_random_seeds(RANDOM_SEED)
D = DCDiscriminator(conv_dim=32)
dataloader_X, test_dataloader_X = get_emoji_loader(emoji_type='Apple')
images, labels = iter(dataloader_X).next()
images = Variable(images)
output = D(images)
output_np = output.data.cpu().numpy()
dc_discriminator_expected = np.load('checker_files/dc_discriminator.npy')
if np.allclose(output_np, dc_discriminator_expected):
print('DCDiscriminator output: EQUAL')
else:
print('DCDiscriminator output: NOT EQUAL')
num_params = count_parameters(D)
expected_params = 167872
print('DCDiscriminator #params = {}, expected #params = {}, {}'.format(
num_params, expected_params, 'EQUAL' if num_params == expected_params else 'NOT EQUAL'))
print('-' * 80)
def main():
args = parse_args()
# Housekeeping
torch.manual_seed(0)
device = torch.device("cuda" if args.device=="cuda" else "cpu") # change to args
train_loader_kwargs = {'num_workers': 1, 'pin_memory': True} if args.device=="cuda" else {}# change to args
# Load dataset
train_loader = torch.utils.data.DataLoader(
datasets.MNIST('../data', train=True, download=True,
transform=transforms.ToTensor()),
batch_size=args.batch_size, shuffle=True, **train_loader_kwargs
)
# Arguments for both models
n_colours = args.n_colours
n_classes = args.n_classes
input_size = args.input_size
# Generator arguments
latent_size = args.latent_size
ngf = args.n_generator_filters
# Discriminator arguments
ndf = args.n_discriminator_filters
# Define generator and discriminator
if args.model_type == "dcgan":
generator_network = DCGenerator(latent_size, ngf, n_colours)
discriminator_network = DCDiscriminator(ndf, n_colours)
elif args.model_type == "conditional":
generator_network = ConditionalGenerator(latent_size, n_classes, input_size)
discriminator_network = ConditionalDiscriminator(n_classes, input_size)
print('Generator: ', generator_network)
print('Discriminator: ', discriminator_network)
# Fixed noise that will be used to examine generator output in saved images
if args.model_type == "dcgan":
fixed_noise = torch.randn(args.batch_size, latent_size, 1, 1)
elif args.model_type == "conditional":
fixed_noise = torch.randn(args.batch_size, latent_size)
train_kwargs = {
"n_epochs": args.epochs,
"latent_size": latent_size,
"learning_rate": args.learning_rate,
"fixed_noise": fixed_noise,
"model_type": args.model_type,
"n_classes": n_classes
}
train(generator_network, discriminator_network, train_loader, **train_kwargs)
def create_model(opts):
"""Builds the generators and discriminators.
"""
G_XtoY = CycleGenerator(conv_dim=opts.g_conv_dim,
init_zero_weights=opts.init_zero_weights)
G_YtoX = CycleGenerator(conv_dim=opts.g_conv_dim,
init_zero_weights=opts.init_zero_weights)
D_X = DCDiscriminator(conv_dim=opts.d_conv_dim)
D_Y = DCDiscriminator(conv_dim=opts.d_conv_dim)
print_models(G_XtoY, G_YtoX, D_X, D_Y)
# if torch.cuda.is_available():
# G_XtoY.cuda()
# G_YtoX.cuda()
# D_X.cuda()
# D_Y.cuda()
# print('Models moved to GPU.')
return G_XtoY, G_YtoX, D_X, D_Y
def create_model(opts):
"""Builds the generators and discriminators.
"""
G_XtoY = CycleGenerator(conv_dim=opts.g_conv_dim,
init_zero_weights=opts.init_zero_weights)
G_YtoX = CycleGenerator(conv_dim=opts.g_conv_dim,
init_zero_weights=opts.init_zero_weights)
D_X = DCDiscriminator(conv_dim=opts.d_conv_dim)
D_Y = DCDiscriminator(conv_dim=opts.d_conv_dim)
if torch.cuda.is_available():
G_XtoY.cuda()
G_YtoX.cuda()
D_X.cuda()
D_Y.cuda()
return G_XtoY, G_YtoX, D_X, D_Y
def create_model(opts):
"""Builds the generators and discriminators.
"""
if opts.GAN_type == 'LSGAN':
G = DCGenerator(noise_size=opts.noise_size, conv_dim=opts.conv_dim)
D = DCDiscriminator(conv_dim=opts.conv_dim, batch_norm=not opts.disable_bn)
elif opts.GAN_type == 'WGAN':
G = WGANGenerator(noise_size=opts.noise_size, conv_dim=opts.conv_dim)
D = WGANDiscriminator(conv_dim=opts.conv_dim, batch_norm=not opts.disable_bn)
elif opts.GAN_type == 'WGANGP':
G = WGANGPGenerator(noise_size=opts.noise_size, conv_dim=opts.conv_dim)
D = WGANGPDiscriminator(conv_dim=opts.conv_dim)
#print_models(G, D)
#move to device
G.to(opts.device) # in-place
D.to(opts.device) # in-place
print_models(G, D)
print('Models are at:'+str(opts.device))
return G, D
