def dcwcgan_data(img_epoch_num=50, cuda=True):
'''
:param img_epoch_num:
:param cuda:
:return: imgs(.jpg) note: change the save path
'''
latent_dim = 20 # details in G_D_Module
n_class = 5 # details in G_D_Module
img_shape = (1, 32, 32) # details in G_D_Module
data_list = os.listdir('coedatas')
data = []
for path in data_list:
data.append(data_read('coedatas/' + path))
if cuda:
FloatTensor = torch.cuda.FloatTensor
LongTensor = torch.cuda.LongTensor
generator = G_D_Module.GeneratorDCWCGAN(latent_dim, n_class, img_shape)
generator.load_state_dict(torch.load('GANParameters/DCWCGAN/generator.pt'))
noise = FloatTensor(
np.random.normal(0, 1, (img_epoch_num * n_class, latent_dim)))
single_list = list(range(n_class))
label_cpu = single_list * img_epoch_num
label = LongTensor(label_cpu)
if cuda:
label.cuda()
generator.cuda()
gen_imags = generator(noise, label)
gen_imags = gen_imags.cpu()
for i in range(gen_imags.shape[0]):
plt.axis('off')
plt.contourf(gen_imags[i][0].detach().numpy())
plt.subplots_adjust(top=1,
bottom=0,
right=1,
left=0,
hspace=0,
wspace=0)
plt.savefig(save_path + 'gen/label' + str(i % 5) + '_' + str(i // 5) +
'.jpg')
plt.close()
for i in range(img_epoch_num):
for j in range(len(data)):
index = random.randint(0, data[j].shape[0] - 1)
plt.axis('off')
plt.contourf(data[j][index])
plt.subplots_adjust(top=1,
bottom=0,
right=1,
left=0,
hspace=0,
wspace=0)
plt.savefig(save_path + 'real/label' + str(j) + '_' + str(i) +
'.jpg')
plt.close()
def self_noise_data(img_epoch_num=50, cuda=True):
'''
:param img_epoch_num:
:param cuda:
:return: imgs(.jpg) note: change the save path
'''
img_shape = (1, 32, 32) # details in G_D_Module
data_list = os.listdir('coedatas')
data = []
for path in data_list:
data.append(data_read('coedatas/' + path))
FloatTensor = torch.cuda.FloatTensor if cuda else torch.FloatTensor
generator = G_D_Module.GeneratorSelfNoise(img_shape)
generator.load_state_dict(
torch.load('GANParameters/SELFNOISEGAN/generator.pt'))
if cuda:
generator.cuda()
for epoch in range(img_epoch_num):
imgs = np.empty([len(data), 1, 32, 32], dtype=float)
for i in range(len(data)):
index = random.randint(0, len(data[i]) - 20 - 1)
imgs[i][0] = data[i][index]
if cuda:
imgs_torch = FloatTensor(imgs).cuda()
gen_imags = generator(imgs_torch)
gen_imags = gen_imags.cpu()
for i in range(gen_imags.shape[0]):
plt.axis('off')
plt.contourf(gen_imags[i][0].detach().numpy())
plt.subplots_adjust(top=1,
bottom=0,
right=1,
left=0,
hspace=0,
wspace=0)
plt.savefig(save_path + 'gen/label' + str(i) + '_' + str(epoch) +
'.jpg')
plt.close()
for i in range(imgs.shape[0]):
plt.axis('off')
plt.contourf(imgs[i][0])
plt.subplots_adjust(top=1,
bottom=0,
right=1,
left=0,
hspace=0,
wspace=0)
plt.savefig(save_path + 'real/label' + str(i) + '_' + str(epoch) +
'.jpg')
plt.close()
def show_perfprmance_data():
data_list_real = os.listdir('Performance/real')
data_list_gen = os.listdir('Performance/gen')
data_real = []
for path in data_list_real:
data_real.append(data_read('Performance/real/' + path))
data_gen = []
for path in data_list_gen:
data_gen.append(data_read('Performance/gen/' + path))
# for i in data_gen[0]:
# plt.contourf(i[0])
# plt.show()
# plt.close()
imgs_gen = np.empty([len(data_gen)**2, 1, 32, 32], dtype=float)
for i in range(len(data_gen)):
for j in range(len(data_gen)):
index = random.randint(0, len(data_gen[j]) - 1)
imgs_gen[i * len(data_gen) + j][0] = data_gen[j][index]
imgs_real = np.empty([len(data_real)**2, 1, 32, 32], dtype=float)
for i in range(len(data_real)):
for j in range(len(data_real)):
index = random.randint(0, len(data_real[j]) - 1)
imgs_real[i * len(data_real) + j][0] = data_real[j][index]
for i in range(imgs_gen.shape[0]):
plt.subplot(len(data_gen), len(data_gen), i + 1)
plt.axis('off')
plt.contourf(imgs_gen[i][0])
plt.savefig('caches/gen.jpg', bbox_inches='tight', pad_inches=0.0)
# plt.show()
plt.close()
for i in range(imgs_real.shape[0]):
plt.subplot(len(data_real), len(data_real), i + 1)
plt.axis('off')
plt.contourf(imgs_real[i][0])
plt.savefig('caches/real.jpg', bbox_inches='tight', pad_inches=0.0)
# plt.show()
plt.close()
def self_noise_data_perf(img_epoch_num=50, cuda=True):
"""
:param img_epoch_num:
:param cuda:
:return: .npz in directory of gen
"""
n_class = 5 # details in G_D_Module
img_shape = (1, 32, 32) # details in G_D_Module
data_list = os.listdir('coedatas')
data = []
for path in data_list:
data.append(data_read('coedatas/' + path))
if cuda:
FloatTensor = torch.cuda.FloatTensor
LongTensor = torch.cuda.LongTensor
else:
FloatTensor = torch.FloatTensor
LongTensor = torch.LongTensor
generator = G_D_Module.GeneratorSelfNoise(img_shape)
generator.load_state_dict(
torch.load('GANParameters/SELFNOISEGAN/generator.pt'))
end_list = None
for i in range(img_epoch_num // 50):
datas_list = []
for j in range(n_class):
mid = np.empty([50, 1, 32, 32], dtype=float)
for k in range(50):
mid[k][0] = data[j][random.randint(0, data[j].shape[0] - 1)]
datas_list.append(mid)
img_list = []
for img in datas_list:
if cuda:
generator.cuda()
img = FloatTensor(img)
gen_imags = generator(img)
gen_imags = gen_imags.cpu()
img_list.append(gen_imags)
if end_list is None:
end_list = [
img_list[mid].detach().numpy() for mid in range(len(img_list))
]
else:
for count in range(len(end_list)):
end_list[count] = np.concatenate(
(end_list[count], img_list[count].detach().numpy()),
axis=0)
for i in range(len(end_list)):
np.savez(save_path + "gen/%d.npz" % i, end_list[i])
print(end_list[i].shape)
def show_self_noise_data():
data_list = os.listdir('coedatas')
data = []
for path in data_list:
data.append(data_read('coedatas/' + path))
FloatTensor = torch.cuda.FloatTensor
generator = G_D_Module.GeneratorSelfNoise((1, 32, 32))
generator.load_state_dict(
torch.load('GANParameters/SELFNOISEGAN/generator.pt'))
generator.cuda()
imgs = np.empty([len(data)**2, 1, 32, 32], dtype=float)
for i in range(len(data)):
for j in range(len(data)):
index = random.randint(0, len(data[j]) - 1)
imgs[i * len(data) + j][0] = data[j][index]
imgs_torch = FloatTensor(imgs)
gen_imags = generator(imgs_torch)
for i in range(gen_imags.size(0)):
plt.subplot(len(data), len(data), i + 1)
plt.axis('off')
plt.contourf(gen_imags[i][0].detach().cpu().numpy())
plt.savefig('caches/gen.jpg', bbox_inches='tight', pad_inches=0)
# plt.show()
plt.close()
# random
imgs = np.empty([len(data)**2, 1, 32, 32], dtype=float)
for i in range(len(data)):
for j in range(len(data)):
index = random.randint(0, len(data[j]) - 1)
imgs[i * len(data) + j][0] = data[j][index]
# r
for i in range(len(imgs)):
plt.subplot(len(data), len(data), i + 1)
plt.axis('off')
plt.contourf(imgs[i][0])
plt.savefig('caches/real.jpg', bbox_inches='tight', pad_inches=0.0)
# plt.show()
plt.close()
def dcwcgan_data_perf(img_epoch_num=50, cuda=True):
'''
:param img_epoch_num:
:param cuda:
:return:
note: generate the .npy in the Performance
'''
latent_dim = 20 # details in G_D_Module
n_class = 5 # details in G_D_Module
img_shape = (1, 32, 32) # details in G_D_Module
data_list = os.listdir('coedatas')
data = []
for path in data_list:
data.append(data_read('coedatas/' + path))
if cuda:
FloatTensor = torch.cuda.FloatTensor
LongTensor = torch.cuda.LongTensor
else:
FloatTensor = torch.FloatTensor
LongTensor = torch.LongTensor
generator = G_D_Module.GeneratorDCWCGAN(latent_dim, n_class, img_shape)
generator.load_state_dict(torch.load('GANParameters/DCWCGAN/generator.pt'))
noise = FloatTensor(
np.random.normal(0, 1, (img_epoch_num * n_class, latent_dim)))
single_list = list(range(n_class))
label_cpu = single_list * img_epoch_num
label = LongTensor(label_cpu)
if cuda:
label.cuda()
generator.cuda()
gen_imags = generator(noise, label)
gen_imags = gen_imags.cpu()
datas = []
for i in range(len(data_list)):
datas.append(np.empty((img_epoch_num, *img_shape), dtype=float))
for i in range(len(label_cpu)):
datas[label_cpu[i]][i // 5][0] = gen_imags[i][0].detach().numpy()
for i in range(len(datas)):
np.savez(save_path + "gen/%d.npz" % i, datas[i])
print(datas[i].shape)
def show_dcwcgan_data():
im_index = range(9)
latent_dim = 20
data_list = os.listdir('coedatas')
data = []
for path in data_list:
data.append(data_read('coedatas/' + path))
FloatTensor = torch.FloatTensor
LongTensor = torch.LongTensor
generator = G_D_Module.GeneratorDCWCGAN(latent_dim, 5, (1, 32, 32))
generator.load_state_dict(torch.load('GANParameters/DCWCGAN/generator.pt'))
noise = FloatTensor(np.random.normal(0, 1, (len(data)**2, latent_dim)))
single_list = list(range(len(data)))
label = LongTensor(single_list * len(data))
gen_imags = generator(noise, label)
gen_imags = gen_imags.cpu()
for i in range(gen_imags.size(0)):
plt.subplot(len(data), len(data), i + 1)
plt.axis('off')
plt.contourf(gen_imags[i][0].detach().numpy())
# plt.subplots_adjust(top=1, bottom=0, right=1, left=0, hspace=0, wspace=0)
plt.savefig('caches/gen.jpg', bbox_inches='tight', pad_inches=0)
# plt.show()
plt.close()
for i in range(len(data)):
for j in range(len(data)):
index = random.randint(0, data[j].shape[0] - 1)
plt.subplot(len(data), len(data), i * len(data) + j + 1)
plt.axis('off')
plt.contourf(data[j][index])
# plt.subplots_adjust(top=1, bottom=0, right=1, left=0, hspace=0, wspace=0)
plt.savefig('caches/real.jpg', bbox_inches='tight', pad_inches=0)
# plt.show()
plt.close()
def show_cdcgan_data():
latent_dim = 20
data_list = os.listdir('coedatas')
data = []
for path in data_list:
data.append(data_read('coedatas/' + path))
FloatTensor = torch.FloatTensor
LongTensor = torch.LongTensor
generator = G_D_Module.GeneratorCDCGAN(latent_dim, 5, (1, 32, 32))
generator.load_state_dict(torch.load('GANParameters/CDCGAN/generator.pt'))
noise = FloatTensor(np.random.normal(0, 1, (len(data)**2, latent_dim)))
single_list = list(range(len(data)))
label = LongTensor(single_list * len(data))
gen_imags = generator(noise, label)
# real
# imgs = np.empty([len(data) ** 2, 1, 32, 32], dtype=float)
# for i in range(len(data)):
# for j in range(len(data)):
# index = random.randint(0, len(data[j]) - 1)
# imgs[i * len(data) + j][0] = data[j][index]
# for i in range(imgs.shape[0]):
# plt.subplot(len(data_list), len(data_list), i + 1)
# plt.axis('off')
# plt.contourf(imgs[i][0])
# plt.savefig('caches/real.jpg', bbox_inches='tight')
# plt.close()
for i in range(gen_imags.shape[0]):
plt.subplot(len(data), len(data), i + 1)
plt.axis('off')
plt.contourf(gen_imags[i][0].detach().numpy())
plt.savefig('caches/gen.jpg', bbox_inches='tight')
plt.close()
def img_data(img_epoch_num, cuda=True):
'''
:param img_epoch_num:
:param cuda:
:return: imgs(.jpg) note: change the save path
'''
os.makedirs('Performance/imgdatas/train/gen', exist_ok=True)
os.makedirs('Performance/imgdatas/train/real', exist_ok=True)
os.makedirs('Performance/imgdatas/test', exist_ok=True)
img_shape = (1, 32, 32) # details in G_D_Module
data_list = os.listdir('coedatas')
data = []
for path in data_list:
data.append(data_read('coedatas/' + path))
FloatTensor = torch.cuda.FloatTensor if cuda else torch.FloatTensor
generator = G_D_Module.GeneratorSelfNoise(img_shape)
generator.load_state_dict(
torch.load('GANParameters/SELFNOISEGAN/generator.pt'))
if cuda:
generator.cuda()
for epoch in range(img_epoch_num):
imgs = np.empty([len(data), 1, 32, 32], dtype=float)
for i in range(len(data)):
index = random.randint(0, len(data[i]) - 20 - 1)
imgs[i][0] = data[i][index]
imgs_torch = FloatTensor(imgs)
gen_imags = generator(imgs_torch)
gen_imags = gen_imags.cpu()
for i in range(gen_imags.shape[0]):
plt.axis('off')
plt.contourf(gen_imags[i][0].detach().numpy())
plt.subplots_adjust(top=1,
bottom=0,
right=1,
left=0,
hspace=0,
wspace=0)
plt.savefig('Performance/imgdatas/train/gen/' + str(i) + '_' +
str(epoch) + '.jpg',
pad_inches=0.0)
plt.close()
# real data 300 for train 170+ for test don't commend if need
for i in range(len(data)):
for j in range(data[i].shape[0]):
if j < 300:
plt.axis('off')
plt.contourf(data[i][j])
plt.subplots_adjust(top=1,
bottom=0,
right=1,
left=0,
hspace=0,
wspace=0)
plt.savefig('Performance/imgdatas/train/real/' + str(i) + '_' +
str(j) + '.jpg',
pad_inches=0.0)
plt.close()
else:
plt.axis('off')
plt.contourf(data[i][j])
plt.subplots_adjust(top=1,
bottom=0,
right=1,
left=0,
hspace=0,
wspace=0)
plt.savefig('Performance/imgdatas/test/' + str(i) + '_' +
str(j) + '.jpg',
pad_inches=0.0)
plt.close()
def train_again_for_2D():
filename = 'coedatas/0.npz'
dataset = dataToCoe.data_read(filename)
data_loader = DataLoader(
dataset,
batch_size=opt.batch_size,
shuffle=True,
)
generator = GeneratorFor2D()
discriminator = DiscriminatorFor2D()
generator.load_state_dict(torch.load('GANParameters\\generator.pt'))
discriminator.load_state_dict(
torch.load('GANParameters\\discriminator.pt'))
loss = nn.BCELoss()
if cuda:
generator.cuda()
discriminator.cuda()
loss.cuda()
optimizer_G = torch.optim.Adam(generator.parameters(),
lr=opt.lr,
betas=(opt.b1, opt.b2))
optimizer_D = torch.optim.Adam(discriminator.parameters(),
lr=opt.lr,
betas=(opt.b1, opt.b2))
Tensor = torch.cuda.FloatTensor if cuda else torch.FloatTensor
for epoch in range(opt.n_epochs):
for i, imgs in enumerate(data_loader):
# Adversarial ground truths
valid = Variable(Tensor(imgs.shape[0], 1).fill_(1.0),
requires_grad=False)
fake = Variable(Tensor(imgs.shape[0], 1).fill_(0.0),
requires_grad=False)
# Configure input
imgs = imgs[:, np.newaxis, :, :]
real_imgs = Variable(imgs.type(Tensor))
# -----------------
# Train Generator
# -----------------
optimizer_G.zero_grad()
# Sample noise as generator input
z = Variable(
Tensor(np.random.normal(0, 1,
(imgs.shape[0], opt.latent_dim))))
# Generate a batch of images
gen_imgs = generator(z)
# Loss measures generator's ability to fool the discriminator
g_loss = loss(discriminator(gen_imgs), valid)
g_loss.backward()
optimizer_G.step()
# ---------------------
# Train Discriminator
# ---------------------
optimizer_D.zero_grad()
# Measure discriminator's ability to classify real from generated samples
real_loss = loss(discriminator(real_imgs), valid)
fake_loss = loss(discriminator(gen_imgs.detach()), fake)
d_loss = (real_loss + fake_loss) / 2
d_loss.backward()
optimizer_D.step()
print("[Epoch %d/%d] [Batch %d/%d] [D loss: %f] [G loss: %f]" %
(epoch, opt.n_epochs, i, len(data_loader), d_loss.item(),
g_loss.item()))
if epoch % 5 == 0 and i == 1:
if cuda:
gen_imgs = gen_imgs.cpu()
plt.contourf(gen_imgs[0][0].detach().numpy())
plt.axis('off')
plt.savefig("waveImages\\" + str(epoch + 200) + '.jpg')
plt.close()
torch.save(generator.state_dict(), 'GANParameters\\generator.pt')
torch.save(discriminator.state_dict(), 'GANParameters\\discriminator.pt')
