def trainGAN(is_dummy=False, checkpoint=None): weights = initialiseWeights() z_vector = tf.placeholder(shape=[batch_size,z_size],dtype=tf.float32) x_vector = tf.placeholder(shape=[batch_size,cube_len,cube_len,cube_len,1],dtype=tf.float32) net_g_train = generator(z_vector, phase_train=True, reuse=False) d_output_x, d_no_sigmoid_output_x = discriminator(x_vector, phase_train=True, reuse=False) d_output_x = tf.maximum(tf.minimum(d_output_x, 0.99), 0.01) summary_d_x_hist = tf.summary.histogram("d_prob_x", d_output_x) d_output_z, d_no_sigmoid_output_z = discriminator(net_g_train, phase_train=True, reuse=True) d_output_z = tf.maximum(tf.minimum(d_output_z, 0.99), 0.01) summary_d_z_hist = tf.summary.histogram("d_prob_z", d_output_z) # Compute the discriminator accuracy n_p_x = tf.reduce_sum(tf.cast(d_output_x > 0.5, tf.int32)) n_p_z = tf.reduce_sum(tf.cast(d_output_z < 0.5, tf.int32)) d_acc = tf.divide(n_p_x + n_p_z, 2 * batch_size) # Compute the discriminator and generator loss # d_loss = -tf.reduce_mean(tf.log(d_output_x) + tf.log(1-d_output_z)) # g_loss = -tf.reduce_mean(tf.log(d_output_z)) d_loss = tf.nn.sigmoid_cross_entropy_with_logits(logits=d_no_sigmoid_output_x, labels=tf.ones_like(d_output_x)) d_loss += tf.nn.sigmoid_cross_entropy_with_logits(logits=d_no_sigmoid_output_z, labels=tf.zeros_like(d_output_z)) g_loss = tf.nn.sigmoid_cross_entropy_with_logits(logits=d_no_sigmoid_output_z, labels=tf.ones_like(d_output_z)) d_loss = tf.reduce_mean(d_loss) g_loss = tf.reduce_mean(g_loss) summary_d_loss = tf.summary.scalar("d_loss", d_loss) summary_g_loss = tf.summary.scalar("g_loss", g_loss) summary_n_p_z = tf.summary.scalar("n_p_z", n_p_z) summary_n_p_x = tf.summary.scalar("n_p_x", n_p_x) summary_d_acc = tf.summary.scalar("d_acc", d_acc) net_g_test = generator(z_vector, phase_train=False, reuse=True) para_g = [var for var in tf.trainable_variables() if any(x in var.name for x in ['wg', 'bg', 'gen'])] para_d = [var for var in tf.trainable_variables() if any(x in var.name for x in ['wd', 'bd', 'dis'])] # only update the weights for the discriminator network optimizer_op_d = tf.train.AdamOptimizer(learning_rate=d_lr,beta1=beta).minimize(d_loss,var_list=para_d) # only update the weights for the generator network optimizer_op_g = tf.train.AdamOptimizer(learning_rate=g_lr,beta1=beta).minimize(g_loss,var_list=para_g) saver = tf.train.Saver() vis = visdom.Visdom() with tf.Session() as sess: sess.run(tf.global_variables_initializer()) if checkpoint is not None: saver.restore(sess, checkpoint) if is_dummy: volumes = np.random.randint(0,2,(batch_size,cube_len,cube_len,cube_len)) print('Using Dummy Data') else: volumes = d.getAll(obj=obj, train=True, is_local=is_local, obj_ratio=obj_ratio) print('Using ' + obj + ' Data') volumes = volumes[...,np.newaxis].astype(np.float) # volumes *= 2.0 # volumes -= 1.0 for epoch in range(n_epochs): idx = np.random.randint(len(volumes), size=batch_size) x = volumes[idx] z_sample = np.random.normal(0, 0.33, size=[batch_size, z_size]).astype(np.float32) z = np.random.normal(0, 0.33, size=[batch_size, z_size]).astype(np.float32) # z = np.random.uniform(0, 1, size=[batch_size, z_size]).astype(np.float32) # Update the discriminator and generator d_summary_merge = tf.summary.merge([summary_d_loss, summary_d_x_hist, summary_d_z_hist, summary_n_p_x, summary_n_p_z, summary_d_acc]) summary_d, discriminator_loss = sess.run([d_summary_merge,d_loss],feed_dict={z_vector:z, x_vector:x}) summary_g, generator_loss = sess.run([summary_g_loss,g_loss],feed_dict={z_vector:z}) d_accuracy, n_x, n_z, d_x,d_z = sess.run([d_acc, n_p_x, n_p_z,d_output_x,d_output_z],feed_dict={z_vector:z, x_vector:x}) #print("nx_nz:",n_x, n_z, "\nd_x:",d_x.reshape(batch_size), "d_z:",d_z.reshape(batch_size)) print ("nx",n_x,"nz",n_z) if d_accuracy < d_thresh: sess.run([optimizer_op_d],feed_dict={z_vector:z, x_vector:x}) print('Discriminator Training ', "epoch: ",epoch,', d_loss:',discriminator_loss,'g_loss:',generator_loss, "d_acc: ", d_accuracy) sess.run([optimizer_op_g],feed_dict={z_vector:z}) print('Generator Training ', "epoch: ",epoch,', d_loss:',discriminator_loss,'g_loss:',generator_loss, "d_acc: ", d_accuracy) # output generated chairs if epoch % 100 == 0: g_objects = sess.run(net_g_test,feed_dict={z_vector:z_sample}) if not os.path.exists(train_sample_directory): os.makedirs(train_sample_directory) g_objects.dump(train_sample_directory+'/biasfree_'+str(epoch)) id_ch = np.random.randint(0, batch_size, 4) for i in range(4): print(g_objects[id_ch[i]].max()) if g_objects[id_ch[i]].max() > 0.5: d.plotVoxelVisdom(np.squeeze(g_objects[id_ch[i]]>0.5), vis, '_'.join(map(str,[epoch,i]))) if epoch % 200 == 0: if not os.path.exists(model_directory): os.makedirs(model_directory) saver.save(sess, save_path = model_directory + '/biasfree_' + str(epoch) + '.cptk')
def trainGAN(is_dummy=False): weights = initialiseWeights() biases = initialiseBiases() z_vector = tf.placeholder(shape=[batch_size,z_size],dtype=tf.float32) x_vector = tf.placeholder(shape=[batch_size,cube_len,cube_len,cube_len,1],dtype=tf.float32) net_g_train = generator(z_vector, phase_train=True, reuse=False) d_output_x, d_no_sigmoid_output_x, flat_feature_x = discriminator(x_vector, phase_train=True, reuse=False) d_output_x = tf.maximum(tf.minimum(d_output_x, 0.99), 0.01) summary_d_x_hist = tf.summary.histogram("d_prob_x", d_output_x) d_output_z, d_no_sigmoid_output_z, flat_feature_z = discriminator(net_g_train, phase_train=True, reuse=True) d_output_z = tf.maximum(tf.minimum(d_output_z, 0.99), 0.01) summary_d_z_hist = tf.summary.histogram("d_prob_z", d_output_z) # Compute the discriminator accuracy n_p_x = tf.reduce_sum(tf.cast(d_output_x > 0.5, tf.int32)) n_p_z = tf.reduce_sum(tf.cast(d_output_z < 0.5, tf.int32)) d_acc = tf.divide(n_p_x + n_p_z, 2 * batch_size) # Compute the discriminator and generator loss # d_loss = -tf.reduce_mean(tf.log(d_output_x) + tf.log(1-d_output_z)) # g_loss = -tf.reduce_mean(tf.log(d_output_z)) d_loss = tf.nn.sigmoid_cross_entropy_with_logits(logits=d_no_sigmoid_output_x, labels=tf.ones_like(d_output_x)) + tf.nn.sigmoid_cross_entropy_with_logits(logits=d_no_sigmoid_output_z, labels=tf.zeros_like(d_output_z)) g_loss = tf.nn.sigmoid_cross_entropy_with_logits(logits=d_no_sigmoid_output_z, labels=tf.ones_like(d_output_z)) d_loss = tf.reduce_mean(d_loss) g_loss = tf.reduce_mean(g_loss) # Feature Matching loss feature_loss = tf.reduce_mean(abs(tf.reduce_mean(flat_feature_z, 0) - tf.reduce_mean(flat_feature_x, 0))) g_loss = (1-feat_loss) * g_loss + feat_loss * feature_loss summary_d_loss = tf.summary.scalar("d_loss", d_loss) summary_g_loss = tf.summary.scalar("g_loss", g_loss) summary_n_p_z = tf.summary.scalar("n_p_z", n_p_z) summary_n_p_x = tf.summary.scalar("n_p_x", n_p_x) summary_d_acc = tf.summary.scalar("d_acc", d_acc) net_g_test = generator(z_vector, phase_train=False, reuse=True) para_g = [var for var in tf.trainable_variables() if any(x in var.name for x in ['wg', 'bg', 'gen'])] para_d = [var for var in tf.trainable_variables() if any(x in var.name for x in ['wd', 'bd', 'dis'])] # only update the weights for the discriminator network optimizer_op_d = tf.train.AdamOptimizer(learning_rate=d_lr,beta1=beta).minimize(d_loss,var_list=para_d) # only update the weights for the generator network optimizer_op_g = tf.train.AdamOptimizer(learning_rate=g_lr,beta1=beta).minimize(g_loss,var_list=para_g) saver = tf.train.Saver(max_to_keep=50) with tf.Session() as sess: sess.run(tf.global_variables_initializer()) z_sample = np.random.normal(0, 0.33, size=[batch_size, z_size]).astype(np.float32) if is_dummy: volumes = np.random.randint(0,2,(batch_size,cube_len,cube_len,cube_len)) print 'Using Dummy Data' else: volumes = d.getAll(obj=obj, train=True, is_local=is_local, obj_ratio=obj_ratio) print 'Using ' + obj + ' Data' volumes = volumes[...,np.newaxis].astype(np.float) # volumes *= 2.0 # volumes -= 1.0 for epoch in range(n_epochs): idx = np.random.randint(len(volumes), size=batch_size) x = volumes[idx] # z = np.random.normal(0, 1, size=[batch_size, z_size]).astype(np.float32) z = np.random.uniform(0, 1, size=[batch_size, z_size]).astype(np.float32) # Update the discriminator and generator d_summary_merge = tf.summary.merge([summary_d_loss, summary_d_x_hist, summary_d_z_hist, summary_n_p_x, summary_n_p_z, summary_d_acc]) summary_d, discriminator_loss = sess.run([d_summary_merge,d_loss],feed_dict={z_vector:z, x_vector:x}) summary_g, generator_loss = sess.run([summary_g_loss,g_loss],feed_dict={z_vector:z, x_vector:x}) d_accuracy, n_x, n_z = sess.run([d_acc, n_p_x, n_p_z],feed_dict={z_vector:z, x_vector:x}) print n_x, n_z if d_accuracy < d_thresh: sess.run([optimizer_op_d],feed_dict={z_vector:z, x_vector:x}) print 'Discriminator Training ', "epoch: ",epoch,', d_loss:',discriminator_loss,'g_loss:',generator_loss, "d_acc: ", d_accuracy sess.run([optimizer_op_g],feed_dict={z_vector:z, x_vector:x}) print 'Generator Training ', "epoch: ",epoch,', d_loss:',discriminator_loss,'g_loss:',generator_loss, "d_acc: ", d_accuracy # output generated chairs if epoch % 50 == 10: g_chairs = sess.run(net_g_test,feed_dict={z_vector:z_sample}) if not os.path.exists(train_sample_directory): os.makedirs(train_sample_directory) g_chairs.dump(train_sample_directory+'/biasfree_'+str(epoch)) if epoch % 50 == 10: if not os.path.exists(model_directory): os.makedirs(model_directory) saver.save(sess, save_path = model_directory + '/biasfree_' + str(epoch) + '.cptk')
def trainGAN(is_dummy=False, checkpoint=None): weights = initialiseWeights() z_vector = tf.placeholder(shape=[batch_size, z_size, z_size, 3], dtype=tf.float32) #z_vector = tf.placeholder(shape=[batch_size, 32,32,1], dtype=tf.float32) y_vector = tf.placeholder(dtype=tf.float32, shape=[batch_size, y_dim]) x_vector = tf.placeholder( shape=[batch_size, cube_len, cube_len, cube_len, 1], dtype=tf.float32) #rat_vector = tf.placeholder(dtype = tf.float32, shape=[1, y_dim]) net_g_train = generator(z_vector, y_vector, phase_train=True, reuse=False) y_mask = tf.placeholder(tf.float32, shape=[batch_size, 64, 64, 64, 1]) d_output_x, d_no_sigmoid_output_x = discriminator(x_vector, y_mask, phase_train=True, reuse=False) d_output_x = tf.maximum(tf.minimum(d_output_x, 0.99), 0.01) summary_d_x_hist = tf.summary.histogram("d_prob_x", d_output_x) d_output_z, d_no_sigmoid_output_z = discriminator(net_g_train, y_mask, phase_train=True, reuse=True) d_output_z = tf.maximum(tf.minimum(d_output_z, 0.99), 0.01) summary_d_z_hist = tf.summary.histogram("d_prob_z", d_output_z) # Compute the discriminator accuracy n_p_x = tf.reduce_sum(tf.cast(d_output_x > 0.5, tf.int32)) n_p_z = tf.reduce_sum(tf.cast(d_output_z < 0.5, tf.int32)) d_acc = tf.divide(n_p_x + n_p_z, 2 * batch_size) d_loss = tf.nn.sigmoid_cross_entropy_with_logits( logits=d_no_sigmoid_output_x, labels=tf.ones_like( d_output_x)) + tf.nn.sigmoid_cross_entropy_with_logits( logits=d_no_sigmoid_output_z, labels=tf.zeros_like(d_output_z)) g_loss = tf.nn.sigmoid_cross_entropy_with_logits( logits=d_no_sigmoid_output_z, labels=tf.ones_like(d_output_z)) d_loss = tf.reduce_mean(d_loss) gen_loss_L1 = tf.reduce_mean(tf.abs(x_vector - net_g_train)) g_loss = tf.reduce_mean(g_loss) * 0.1 + gen_loss_L1 * 0.9 summary_d_loss = tf.summary.scalar("d_loss", d_loss) summary_g_loss = tf.summary.scalar("g_loss", g_loss) summary_n_p_z = tf.summary.scalar("n_p_z", n_p_z) summary_n_p_x = tf.summary.scalar("n_p_x", n_p_x) summary_d_acc = tf.summary.scalar("d_acc", d_acc) para_g = [ var for var in tf.trainable_variables() if any(x in var.name for x in ['encoder_h', 'encoder_b', 'wg', 'bg', 'gen']) ] para_d = [ var for var in tf.trainable_variables() if any(x in var.name for x in ['encoder_h', 'encoder_b', 'wd', 'bd', 'dis']) ] # only update the weights for the discriminator network optimizer_op_d = tf.train.AdamOptimizer().minimize(d_loss, var_list=para_d) optimizer_op_g = tf.train.AdamOptimizer().minimize(g_loss, var_list=para_g) saver = tf.train.Saver() # vis = visdom.Visdom() count = 0 loss_all = 0 with tf.Session() as sess: sess.run(tf.global_variables_initializer()) if is_dummy: volumes = np.random.randint( 0, 2, (batch_size, cube_len, cube_len, cube_len)) print('Using Dummy Data') else: volumes = d.getAll(obj=obj, train=True, is_local=is_local, obj_ratio=obj_ratio) print('Using ' + obj + ' Data') volumes = volumes[..., np.newaxis].astype(np.float) for epoch in range(n_epochs): idx = np.random.randint(len(volumes) - 1, size=batch_size) x = volumes[idx] y = np.random.normal(0, 0.33, size=[batch_size, y_dim]).astype(np.float32) #z = z_load[idx] z = np.array([], dtype=float) for m in range(batch_size): idy = random.randint(0, 7) id = idx[m] z1 = np.array([], float) if id < 200: #0-199 z1 = z_load1[id][idy] if id >= 200 and id < 400: #200-399 z1 = z_load2[id - 200][idy] if id >= 400 and id < 600: #400-599 z1 = z_load3[id - 400][idy] if id >= 600: #600-end z1 = z_load4[id - 600][idy] z = np.append(z, z1) z = z.reshape([m + 1, 128, 128, 3]) y_mask_array = mask_load[idx] d_summary_merge = tf.summary.merge([ summary_d_loss, summary_d_x_hist, summary_d_z_hist, summary_n_p_x, summary_n_p_z, summary_d_acc ]) count = count + 1 summary_d, discriminator_loss = sess.run([d_summary_merge, d_loss], feed_dict={ z_vector: z, x_vector: x, y_vector: y, y_mask: y_mask_array }) summary_g, generator_loss, generator_loss_L1 = sess.run( [summary_g_loss, g_loss, gen_loss_L1], feed_dict={ z_vector: z, x_vector: x, y_vector: y, y_mask: y_mask_array }) d_accuracy, n_x, n_z = sess.run([d_acc, n_p_x, n_p_z], feed_dict={ z_vector: z, x_vector: x, y_vector: y, y_mask: y_mask_array }) loss_all = loss_all + generator_loss_L1 loss_avg = loss_all / count print(loss_avg) if d_accuracy < d_thresh: sess.run([optimizer_op_d], feed_dict={ z_vector: z, x_vector: x, y_vector: y, y_mask: y_mask_array }) # write_Excle.saveValue('D', epoch, discriminator_loss.item(), generator_loss.item(), d_accuracy) print('Discriminator Training ', "epoch: ", epoch, ', d_loss:', discriminator_loss, 'g_loss:', generator_loss, "d_acc: ", d_accuracy) list.append( dict(netType='D', epoch=epoch, d_loss=discriminator_loss.item(), g_loss=generator_loss.item(), d_acc=d_accuracy)) if d_accuracy > 0.5: sess.run([optimizer_op_g], feed_dict={ z_vector: z, x_vector: x, y_vector: y, y_mask: y_mask_array }) # write_Excle.saveValue('G', epoch, discriminator_loss.item(), generator_loss.item(), d_accuracy) list.append( dict(netType='G', epoch=epoch, d_loss=discriminator_loss.item(), g_loss=generator_loss.item(), d_acc=d_accuracy)) print('Generator Training ', "epoch: ", epoch, ', d_loss:', discriminator_loss, 'g_loss:', generator_loss, "d_acc: ", d_accuracy) if epoch % 400 == 10: if not os.path.exists(model_directory): os.makedirs(model_directory) saver.save(sess, save_path=model_directory + '/Larry_2_5_' + str(epoch) + '.cptk') loss_all = 0 count = 0
def ganGetOneResult(trained_model_path): global IsInit global Istrue global number if IsInit == False: initialiseWeights() IsInit = False z_vector = tf.placeholder(shape=[batch_size, z_size, z_size, 3], dtype=tf.float32) y_vector = tf.placeholder(tf.float32, [batch_size, y_dim]) net_g_test = generator(z_vector, y_vector, phase_train=True) saver = tf.train.Saver() with tf.variable_scope(tf.get_variable_scope(), reuse=None): config = tf.ConfigProto() config.gpu_options.allow_growth = True with tf.Session(config=config) as sess: sess.run(tf.global_variables_initializer()) saver.restore(sess, trained_model_path) while True: if Istrue: x = [] Istrue = False volumes = d.getAll(obj=obj, train=True, is_local=is_local, obj_ratio=obj_ratio) volumes = volumes.reshape((99, 64, 64, 64)) g_objects = volumes[num] for i in range(0, 5): x.append(g_objects) g_objects = np.array(x) id_ch = np.random.randint(0, batch_size, 4) i = 0 print(g_objects[id_ch[i]].max(), g_objects[id_ch[i]].min(), g_objects[id_ch[i]].shape) if g_objects[id_ch[i]].max() > 0.5: result = np.squeeze(g_objects[id_ch[i]] > 0.5) yield result else: data_path = glob.glob(r'D:\Paper\image\test\Ball\*.png') onepath = choice(data_path) print(onepath) img = Image.open(onepath) img.save('output.png', quality=100) def matrixpic(img): matrixpic = np.asarray(img) (h, w) = matrixpic.shape[:2] for i in range(h): for j in range(w): if matrixpic[i][j] == 255: matrixpic[i][j] = 255 else: matrixpic[i][j] = 0 return matrixpic # 绿色转白色 def convertcolor(img): img = np.asarray(img) (h, w) = img.shape[:2] for i in range(h): for j in range(w): if img[i][j][1] > 180 and img[i][j][ 0] < 20 and img[i][j][2] < 20: img[i][j] = 255 return img # 生成二值测试图像 img = cv2.imread('output.png') img = cv2.resize(img, (128, 128)) one_array = np.asarray(img) / 255 # img1 = np.ones(img.shape[:2]) # converted = convertcolor(img) # gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) # thresh = matrixpic(gray) # # # # # 检测所有图形的轮廓 # contours = measure.find_contours(thresh, 0.5) # x = 0 # y = 0 # for n, contour in enumerate(contours): # if contour.size > x: # x = contour.size # y = contour # y[:, [0, 1]] = y[:, [1, 0]] # _contours = [] # _contours.append(np.around(np.expand_dims(y, 1)).astype(np.int)) # cv2.drawContours(img1, _contours, -1, (0, 0, 0), -1) # # img1 = cv2.resize(img1, (64, 64), interpolation=cv2.INTER_CUBIC) # # # img_np_1d = img1 * 255 # # one_array = np.zeros((64, 64), float) # for i in range(64): # for j in range(64): # if img_np_1d[i][j] < 155: # one_array[i][j] = 255 # else: # one_array[i][j] = 0 # # one_array = Image.fromarray(one_array) # one_array = one_array.rotate(-90) # if one_array.mode != 'RGB': # one_array = one_array.convert('RGB') # one_array.save('1234.png') # one_array = cv2.imread('1234.png', 0) # left = up = down = right = 0 # for j in range(32): # for i in range(64): # if one_array[i][j] != 0: # left = j # if left != 0: # break # # for i in range(32): # for j in range(64): # if one_array[i][j] == 255: # up = i # if up != 0: # break # for i in range(32): # for j in range(64): # if one_array[63 - i][j] == 255: # down = 63 - i # if down != 0: # break # right = down - up + 24 # box = (left, up, right, down) # img = Image.open('1234.png') # roi = img.crop(box) # dst = roi.resize((64, 64), Image.ANTIALIAS) # dst.save('123456.png', quality=100) # num = onepath[-8:-5] # num = int(num) - 901 # # #one_array = cv2.imread('123456.png', 0) # for i in range(64): # for j in range(64): # if one_array[i][j] > 125: # one_array[i][j] = 1 # else: # one_array[i][j] = 0 # Istrue = True x = np.array([], float) for i in range(0, 5): x = np.append(x, one_array) x = x.reshape([i + 1, z_size, z_size, 3]) # x = np.array(x) # z_sample = np.array(x) # z_sample = z_sample.reshape([-1, z_size, z_size, 3]) y = np.random.normal(0, 0.33, size=[batch_size, y_dim]).astype(np.float32) g_objects = sess.run(net_g_test, feed_dict={ z_vector: x, y_vector: y }) id_ch = np.random.randint(0, batch_size, 4) i = 0 print(g_objects[id_ch[i]].max(), g_objects[id_ch[i]].min(), g_objects[id_ch[i]].shape) if g_objects[id_ch[i]].max() > 0.5: result = np.squeeze(g_objects[id_ch[i]] > 0.5) yield result yield None
def trainGAN(): weights, biases = initialiseWeights(), initialiseBiases() z_vector = tf.placeholder(shape=[batch_size, z_size], dtype=tf.float32) x_vector = tf.placeholder(shape=[batch_size, 32, 32, 32, 1], dtype=tf.float32) net_g_train = generator(z_vector, phase_train=True, reuse=False) d_output_x = discriminator(x_vector, phase_train=True, reuse=False) d_output_x = tf.maximum(tf.minimum(d_output_x, 0.99), 0.01) summary_d_x_hist = tf.summary.histogram("d_prob_x", d_output_x) d_output_z = discriminator(net_g_train, phase_train=True, reuse=True) d_output_z = tf.maximum(tf.minimum(d_output_z, 0.99), 0.01) summary_d_z_hist = tf.summary.histogram("d_prob_z", d_output_z) d_loss = -tf.reduce_mean(tf.log(d_output_x) + tf.log(1 - d_output_z)) summary_d_loss = tf.summary.scalar("d_loss", d_loss) g_loss = -tf.reduce_mean(tf.log(d_output_z)) summary_g_loss = tf.summary.scalar("g_loss", g_loss) net_g_test = generator(z_vector, phase_train=True, reuse=True) para_g = list( np.array(tf.trainable_variables())[[0, 1, 4, 5, 8, 9, 12, 13]]) para_d = list( np.array(tf.trainable_variables())[[14, 15, 16, 17, 20, 21, 24, 25]]) #,28,29]]) # only update the weights for the discriminator network optimizer_op_d = tf.train.AdamOptimizer( learning_rate=alpha_d, beta1=beta).minimize(d_loss, var_list=para_d) # only update the weights for the generator network optimizer_op_g = tf.train.AdamOptimizer( learning_rate=alpha_g, beta1=beta).minimize(g_loss, var_list=para_g) saver = tf.train.Saver(max_to_keep=50) with tf.Session() as sess: sess.run(tf.global_variables_initializer()) z_sample = np.random.normal(0, 0.33, size=[batch_size, z_size]).astype(np.float32) volumes = d.getAll(obj=obj, train=True, is_local=True) volumes = volumes[..., np.newaxis].astype(np.float) for epoch in tqdm(range(n_epochs)): idx = np.random.randint(len(volumes), size=batch_size) x = volumes[idx] z = np.random.normal(0, 0.33, size=[batch_size, z_size]).astype(np.float32) # Update the discriminator and generator d_summary_merge = tf.summary.merge( [summary_d_loss, summary_d_x_hist, summary_d_z_hist]) summary_d, discriminator_loss = sess.run([d_summary_merge, d_loss], feed_dict={ z_vector: z, x_vector: x }) summary_g, generator_loss = sess.run([summary_g_loss, g_loss], feed_dict={z_vector: z}) if discriminator_loss <= 4.6 * 0.1: sess.run([optimizer_op_g], feed_dict={z_vector: z}) elif generator_loss <= 4.6 * 0.1: sess.run([optimizer_op_d], feed_dict={ z_vector: z, x_vector: x }) else: sess.run([optimizer_op_d], feed_dict={ z_vector: z, x_vector: x }) sess.run([optimizer_op_g], feed_dict={z_vector: z}) print("epoch: ", epoch, ', d_loss:', discriminator_loss, 'g_loss:', generator_loss) # output generated chairs if epoch % 500 == 10: g_chairs = sess.run(net_g_test, feed_dict={z_vector: z_sample}) if not os.path.exists(train_sample_directory): os.makedirs(train_sample_directory) g_chairs.dump(train_sample_directory + '/' + str(epoch)) if epoch % 500 == 10: if not os.path.exists(model_directory): os.makedirs(model_directory) saver.save(sess, save_path=model_directory + '/' + str(epoch) + '.cptk')
gen_loader = tf.train.Saver(generator_vars) gen_loader.restore(sess, tf.train.latest_checkpoint(gan_save_directory)) vox_loader = tf.train.Saver( tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, scope='vox')) vox_loader.restore(sess, voxnet_save_path) # load from checkpoint # all_saver.restore(sess, tf.train.latest_checkpoint(model_directory)) # In[11]: volumes = d.getAll(obj=obj, train=True, is_local=False, obj_ratio=obj_ratio, cube_len=32) print('Using ' + obj + ' Data') volumes = volumes[..., np.newaxis].astype(np.float) num_samples = len(volumes) num_batches = num_samples // batch_size sess.run(tf.global_variables_initializer()) # In[ ]: volumes_test = d.getAll(obj=obj, train=False,
def trainGAN(is_dummy=False, exp_id=None): weights, biases = initialiseWeights(), initialiseBiases() x_vector = tf.placeholder(shape=[batch_size,cube_len,cube_len,cube_len,1],dtype=tf.float32) z_vector = tf.placeholder(shape=[batch_size,z_size],dtype=tf.float32) # Weights for autoencoder pretraining xavier_init = tf.contrib.layers.xavier_initializer() zero_init = tf.zeros_initializer() weights['wae_d'] = tf.get_variable("wae_d", shape=[4, 4, 4, 512, 200], initializer=xavier_init) biases['bae_d'] = tf.get_variable("bae_d", shape=[200], initializer=zero_init) encoded = encoder(x_vector, phase_train=True, reuse=False) encoded = tf.maximum(tf.minimum(encoded, 0.99), 0.01) decoded = generator(encoded, phase_train=True, reuse=False) decoded_test = generator(tf.maximum(tf.minimum(encoder(x_vector, phase_train=False, reuse=False), 0.99), 0.01), phase_train=False, reuse=False) # Round decoder output decoded = threshold(decoded) # Compute MSE Loss and L2 Loss mse_loss = tf.reduce_mean(tf.pow(x_vector - decoded, 2)) para_ae = [var for var in tf.trainable_variables() if any(x in var.name for x in ['wg', 'wd', 'wae'])] for var in tf.trainable_variables(): if 'wd5' in var.name: last_layer_dis = var para_ae.remove(last_layer_dis) # l2_loss = tf.add_n([tf.nn.l2_loss(v) for v in para_ae]) # ae_loss = mse_loss + reg_l2 * l2_loss ae_loss = mse_loss optimizer_ae = tf.train.AdamOptimizer(learning_rate=ae_lr,beta1=beta, name="Adam_AE").minimize(ae_loss) # optimizer_ae = tf.train.RMSPropOptimizer(learning_rate=ae_lr, name="RMS_AE").minimize(ae_loss) net_g_train = generator(z_vector, phase_train=True, reuse=False) d_output_x = discriminator(x_vector, phase_train=True, reuse=False) d_output_x = tf.maximum(tf.minimum(d_output_x, 0.99), 0.01) summary_d_x_hist = tf.summary.histogram("d_prob_x", d_output_x) d_output_z = discriminator(net_g_train, phase_train=True, reuse=True) d_output_z = tf.maximum(tf.minimum(d_output_z, 0.99), 0.01) summary_d_z_hist = tf.summary.histogram("d_prob_z", d_output_z) # Compute the discriminator accuracy n_p_x = tf.reduce_sum(tf.cast(d_output_x > 0.5, tf.int32)) n_p_z = tf.reduce_sum(tf.cast(d_output_z <= 0.5, tf.int32)) d_acc = tf.divide(n_p_x + n_p_z, 2 * batch_size) # Compute the discriminator and generator loss d_loss = -tf.reduce_mean(tf.log(d_output_x) + tf.log(1-d_output_z)) g_loss = -tf.reduce_mean(tf.log(d_output_z)) summary_d_loss = tf.summary.scalar("d_loss", d_loss) summary_g_loss = tf.summary.scalar("g_loss", g_loss) summary_n_p_z = tf.summary.scalar("n_p_z", n_p_z) summary_n_p_x = tf.summary.scalar("n_p_x", n_p_x) summary_d_acc = tf.summary.scalar("d_acc", d_acc) net_g_test = generator(z_vector, phase_train=False, reuse=True) para_g = [var for var in tf.trainable_variables() if any(x in var.name for x in ['wg', 'bg', 'gen'])] para_d = [var for var in tf.trainable_variables() if any(x in var.name for x in ['wd', 'bd', 'dis'])] # only update the weights for the discriminator network optimizer_op_d = tf.train.AdamOptimizer(learning_rate=d_lr,beta1=beta).minimize(d_loss,var_list=para_d) # only update the weights for the generator network optimizer_op_g = tf.train.AdamOptimizer(learning_rate=g_lr,beta1=beta).minimize(g_loss,var_list=para_g) saver = tf.train.Saver(max_to_keep=50) with tf.Session() as sess: sess.run(tf.global_variables_initializer()) z_sample = np.random.normal(0, 0.33, size=[batch_size, z_size]).astype(np.float32) if is_dummy: volumes = np.random.randint(0,2,(batch_size,cube_len,cube_len,cube_len)) print 'Using Dummy Data' else: volumes = d.getAll(obj=obj, train=True, is_local=is_local, obj_ratio=obj_ratio) print 'Using ' + obj + ' Data' volumes = volumes[...,np.newaxis].astype(np.float) for epoch in range(n_ae_epochs): idx = np.random.randint(len(volumes), size=batch_size) x = volumes[idx] # Autoencoder pretraining # ae_l, mse_l, l2_l, _ = sess.run([ae_loss, mse_loss, l2_loss, optimizer_ae],feed_dict={x_vector:x}) # print 'Autoencoder Training ', "epoch: ",epoch, 'ae_loss:', ae_l, 'mse_loss:', mse_l, 'l2_loss:', l2_l ae_l, mse_l, _ = sess.run([ae_loss, mse_loss, optimizer_ae],feed_dict={x_vector:x}) print 'Autoencoder Training ', "epoch: ",epoch, 'ae_loss:', ae_l, 'mse_loss:', mse_l # output generated chairs if epoch % ae_inter == 10: idx = np.random.randint(len(volumes), size=batch_size) x = volumes[idx] decoded_chairs = sess.run(decoded_test, feed_dict={x_vector:x}) if not os.path.exists(train_sample_directory): os.makedirs(train_sample_directory) decoded_chairs.dump(train_sample_directory+'/ae_' + exp_id +str(epoch)) for epoch in range(n_epochs): idx = np.random.randint(len(volumes), size=batch_size) x = volumes[idx] z = np.random.normal(0, 0.33, size=[batch_size, z_size]).astype(np.float32) # Update the discriminator and generator d_summary_merge = tf.summary.merge([summary_d_loss, summary_d_x_hist, summary_d_z_hist, summary_n_p_x, summary_n_p_z, summary_d_acc]) summary_d, discriminator_loss = sess.run([d_summary_merge,d_loss],feed_dict={z_vector:z, x_vector:x}) summary_g, generator_loss = sess.run([summary_g_loss,g_loss],feed_dict={z_vector:z}) d_accuracy, n_x, n_z = sess.run([d_acc, n_p_x, n_p_z],feed_dict={z_vector:z, x_vector:x}) print n_x, n_z if d_accuracy < d_thresh: sess.run([optimizer_op_d],feed_dict={z_vector:z, x_vector:x}) print 'Discriminator Training ', "epoch: ",epoch,', d_loss:',discriminator_loss,'g_loss:',generator_loss, "d_acc: ", d_accuracy sess.run([optimizer_op_g],feed_dict={z_vector:z}) print 'Generator Training ', "epoch: ",epoch,', d_loss:',discriminator_loss,'g_loss:',generator_loss, "d_acc: ", d_accuracy # output generated chairs if epoch % gan_inter == 10: g_chairs = sess.run(net_g_test,feed_dict={z_vector:z_sample}) if not os.path.exists(train_sample_directory): os.makedirs(train_sample_directory) g_chairs.dump(train_sample_directory+'/'+str(epoch)) if epoch % gan_inter == 10: if not os.path.exists(model_directory): os.makedirs(model_directory) saver.save(sess, save_path = model_directory + '/' + str(epoch) + '.cptk')
def trainGAN(is_dummy=False, exp_id=None): weights, biases = initialiseWeights(), initialiseBiases() x_vector = tf.placeholder( shape=[batch_size, cube_len, cube_len, cube_len, 1], dtype=tf.float32) z_vector = tf.placeholder(shape=[batch_size, z_size], dtype=tf.float32) # Weights for autoencoder pretraining xavier_init = tf.contrib.layers.xavier_initializer() zero_init = tf.zeros_initializer() weights['wae_d'] = tf.get_variable("wae_d", shape=[4, 4, 4, 512, 200], initializer=xavier_init) biases['bae_d'] = tf.get_variable("bae_d", shape=[200], initializer=zero_init) encoded = encoder(x_vector, phase_train=True, reuse=False) encoded = tf.maximum(tf.minimum(encoded, 0.99), 0.01) decoded = generator(encoded, phase_train=True, reuse=False) decoded_test = generator(tf.maximum( tf.minimum(encoder(x_vector, phase_train=False, reuse=False), 0.99), 0.01), phase_train=False, reuse=False) # Round decoder output decoded = threshold(decoded) # Compute MSE Loss and L2 Loss mse_loss = tf.reduce_mean(tf.pow(x_vector - decoded, 2)) para_ae = [ var for var in tf.trainable_variables() if any(x in var.name for x in ['wg', 'wd', 'wae']) ] for var in tf.trainable_variables(): if 'wd5' in var.name: last_layer_dis = var para_ae.remove(last_layer_dis) # l2_loss = tf.add_n([tf.nn.l2_loss(v) for v in para_ae]) # ae_loss = mse_loss + reg_l2 * l2_loss ae_loss = mse_loss optimizer_ae = tf.train.AdamOptimizer(learning_rate=ae_lr, beta1=beta, name="Adam_AE").minimize(ae_loss) # optimizer_ae = tf.train.RMSPropOptimizer(learning_rate=ae_lr, name="RMS_AE").minimize(ae_loss) net_g_train = generator(z_vector, phase_train=True, reuse=False) d_output_x = discriminator(x_vector, phase_train=True, reuse=False) d_output_x = tf.maximum(tf.minimum(d_output_x, 0.99), 0.01) summary_d_x_hist = tf.summary.histogram("d_prob_x", d_output_x) d_output_z = discriminator(net_g_train, phase_train=True, reuse=True) d_output_z = tf.maximum(tf.minimum(d_output_z, 0.99), 0.01) summary_d_z_hist = tf.summary.histogram("d_prob_z", d_output_z) # Compute the discriminator accuracy n_p_x = tf.reduce_sum(tf.cast(d_output_x > 0.5, tf.int32)) n_p_z = tf.reduce_sum(tf.cast(d_output_z <= 0.5, tf.int32)) d_acc = tf.divide(n_p_x + n_p_z, 2 * batch_size) # Compute the discriminator and generator loss d_loss = -tf.reduce_mean(tf.log(d_output_x) + tf.log(1 - d_output_z)) g_loss = -tf.reduce_mean(tf.log(d_output_z)) summary_d_loss = tf.summary.scalar("d_loss", d_loss) summary_g_loss = tf.summary.scalar("g_loss", g_loss) summary_n_p_z = tf.summary.scalar("n_p_z", n_p_z) summary_n_p_x = tf.summary.scalar("n_p_x", n_p_x) summary_d_acc = tf.summary.scalar("d_acc", d_acc) net_g_test = generator(z_vector, phase_train=False, reuse=True) para_g = [ var for var in tf.trainable_variables() if any(x in var.name for x in ['wg', 'bg', 'gen']) ] para_d = [ var for var in tf.trainable_variables() if any(x in var.name for x in ['wd', 'bd', 'dis']) ] # only update the weights for the discriminator network optimizer_op_d = tf.train.AdamOptimizer( learning_rate=d_lr, beta1=beta).minimize(d_loss, var_list=para_d) # only update the weights for the generator network optimizer_op_g = tf.train.AdamOptimizer( learning_rate=g_lr, beta1=beta).minimize(g_loss, var_list=para_g) saver = tf.train.Saver(max_to_keep=50) with tf.Session() as sess: sess.run(tf.global_variables_initializer()) z_sample = np.random.normal(0, 0.33, size=[batch_size, z_size]).astype(np.float32) if is_dummy: volumes = np.random.randint( 0, 2, (batch_size, cube_len, cube_len, cube_len)) print('Using Dummy Data') else: volumes = d.getAll(obj=obj, train=True, is_local=is_local, obj_ratio=obj_ratio) print('Using ' + obj + ' Data') volumes = volumes[..., np.newaxis].astype(np.float) for epoch in range(n_ae_epochs): idx = np.random.randint(len(volumes), size=batch_size) x = volumes[idx] # Autoencoder pretraining # ae_l, mse_l, l2_l, _ = sess.run([ae_loss, mse_loss, l2_loss, optimizer_ae],feed_dict={x_vector:x}) # print ('Autoencoder Training ', "epoch: ",epoch, 'ae_loss:', ae_l, 'mse_loss:', mse_l, 'l2_loss:', l2_l) ae_l, mse_l, _ = sess.run([ae_loss, mse_loss, optimizer_ae], feed_dict={x_vector: x}) print('Autoencoder Training ', "epoch: ", epoch, 'ae_loss:', ae_l, 'mse_loss:', mse_l) # output generated chairs if epoch % ae_inter == 10: idx = np.random.randint(len(volumes), size=batch_size) x = volumes[idx] decoded_chairs = sess.run(decoded_test, feed_dict={x_vector: x}) if not os.path.exists(train_sample_directory): os.makedirs(train_sample_directory) decoded_chairs.dump(train_sample_directory + '/ae_' + exp_id + str(epoch)) for epoch in range(n_epochs): idx = np.random.randint(len(volumes), size=batch_size) x = volumes[idx] z = np.random.normal(0, 0.33, size=[batch_size, z_size]).astype(np.float32) # Update the discriminator and generator d_summary_merge = tf.summary.merge([ summary_d_loss, summary_d_x_hist, summary_d_z_hist, summary_n_p_x, summary_n_p_z, summary_d_acc ]) summary_d, discriminator_loss = sess.run([d_summary_merge, d_loss], feed_dict={ z_vector: z, x_vector: x }) summary_g, generator_loss = sess.run([summary_g_loss, g_loss], feed_dict={z_vector: z}) d_accuracy, n_x, n_z = sess.run([d_acc, n_p_x, n_p_z], feed_dict={ z_vector: z, x_vector: x }) print(n_x, n_z) if d_accuracy < d_thresh: sess.run([optimizer_op_d], feed_dict={ z_vector: z, x_vector: x }) print('Discriminator Training ', "epoch: ", epoch, ', d_loss:', discriminator_loss, 'g_loss:', generator_loss, "d_acc: ", d_accuracy) sess.run([optimizer_op_g], feed_dict={z_vector: z}) print('Generator Training ', "epoch: ", epoch, ', d_loss:', discriminator_loss, 'g_loss:', generator_loss, "d_acc: ", d_accuracy) # output generated chairs if epoch % gan_inter == 10: g_chairs = sess.run(net_g_test, feed_dict={z_vector: z_sample}) if not os.path.exists(train_sample_directory): os.makedirs(train_sample_directory) g_chairs.dump(train_sample_directory + '/' + str(epoch)) if epoch % gan_inter == 10: if not os.path.exists(model_directory): os.makedirs(model_directory) saver.save(sess, save_path=model_directory + '/' + str(epoch) + '.cptk') export_model(saver, sess, ["gen/init"], "gen/tanh")
def trainGAN(is_dummy=False): weights, biases = initialiseWeights(), initialiseBiases() z_vector = tf.placeholder(shape=[batch_size, z_size], dtype=tf.float32) x_vector = tf.placeholder( shape=[batch_size, cube_len, cube_len, cube_len, 1], dtype=tf.float32) net_g_train = generator(z_vector, phase_train=True, reuse=False) d_output_x = discriminator(x_vector, phase_train=True, reuse=False) d_output_x = tf.maximum(tf.minimum(d_output_x, 0.99), 0.01) summary_d_x_hist = tf.summary.histogram("d_prob_x", d_output_x) d_output_z = discriminator(net_g_train, phase_train=True, reuse=True) d_output_z = tf.maximum(tf.minimum(d_output_z, 0.99), 0.01) summary_d_z_hist = tf.summary.histogram("d_prob_z", d_output_z) # Compute the discriminator accuracy n_p_x = tf.reduce_sum(tf.cast(d_output_x > 0.5, tf.int32)) n_p_z = tf.reduce_sum(tf.cast(d_output_z <= 0.5, tf.int32)) d_acc = tf.divide(n_p_x + n_p_z, 2 * batch_size) # Compute the discriminator and generator loss d_loss = -tf.reduce_mean(tf.log(d_output_x) + tf.log(1 - d_output_z)) g_loss = -tf.reduce_mean(tf.log(d_output_z)) summary_d_loss = tf.summary.scalar("d_loss", d_loss) summary_g_loss = tf.summary.scalar("g_loss", g_loss) summary_n_p_z = tf.summary.scalar("n_p_z", n_p_z) summary_n_p_x = tf.summary.scalar("n_p_x", n_p_x) summary_d_acc = tf.summary.scalar("d_acc", d_acc) net_g_test = generator(z_vector, phase_train=False, reuse=True) para_g = [ var for var in tf.trainable_variables() if any(x in var.name for x in ['wg', 'bg', 'gen']) ] para_d = [ var for var in tf.trainable_variables() if any(x in var.name for x in ['wd', 'bd', 'dis']) ] # only update the weights for the discriminator network optimizer_op_d = tf.train.AdamOptimizer( learning_rate=d_lr, beta1=beta).minimize(d_loss, var_list=para_d) # only update the weights for the generator network optimizer_op_g = tf.train.AdamOptimizer( learning_rate=g_lr, beta1=beta).minimize(g_loss, var_list=para_g) saver = tf.train.Saver(max_to_keep=50) with tf.Session() as sess: sess.run(tf.global_variables_initializer()) z_sample = np.random.normal(0, 0.33, size=[batch_size, z_size]).astype(np.float32) if is_dummy: volumes = np.random.randint( 0, 2, (batch_size, cube_len, cube_len, cube_len)) print 'Using Dummy Data' else: volumes = d.getAll(obj=obj, train=True, is_local=is_local, obj_ratio=obj_ratio) print 'Using ' + obj + ' Data' volumes = volumes[..., np.newaxis].astype(np.float) for epoch in range(n_epochs): idx = np.random.randint(len(volumes), size=batch_size) x = volumes[idx] z = np.random.normal(0, 0.33, size=[batch_size, z_size]).astype(np.float32) # Update the discriminator and generator d_summary_merge = tf.summary.merge([ summary_d_loss, summary_d_x_hist, summary_d_z_hist, summary_n_p_x, summary_n_p_z, summary_d_acc ]) summary_d, discriminator_loss = sess.run([d_summary_merge, d_loss], feed_dict={ z_vector: z, x_vector: x }) summary_g, generator_loss = sess.run([summary_g_loss, g_loss], feed_dict={z_vector: z}) d_accuracy, n_x, n_z = sess.run([d_acc, n_p_x, n_p_z], feed_dict={ z_vector: z, x_vector: x }) print n_x, n_z if d_accuracy < d_thresh: sess.run([optimizer_op_d], feed_dict={ z_vector: z, x_vector: x }) print 'Discriminator Training ', "epoch: ", epoch, ', d_loss:', discriminator_loss, 'g_loss:', generator_loss, "d_acc: ", d_accuracy sess.run([optimizer_op_g], feed_dict={z_vector: z}) print 'Generator Training ', "epoch: ", epoch, ', d_loss:', discriminator_loss, 'g_loss:', generator_loss, "d_acc: ", d_accuracy # output generated chairs if epoch % 500 == 10: g_chairs = sess.run(net_g_test, feed_dict={z_vector: z_sample}) if not os.path.exists(train_sample_directory): os.makedirs(train_sample_directory) g_chairs.dump(train_sample_directory + '/' + str(epoch)) if epoch % 500 == 10: if not os.path.exists(model_directory): os.makedirs(model_directory) saver.save(sess, save_path=model_directory + '/' + str(epoch) + '.cptk')
def save_checkpoint(state, curr_epoch): torch.save(state, './models/netG_e%d.pth.tar' % (curr_epoch)) # initialize Generator & Discriminator netG = Generator().to(device) weights_init(netG) print(netG) netD = Discriminator().to(device) weights_init(netD) print(netD) # load ".off" files volumes = d.getAll(obj=obj, train=True, is_local=is_local, obj_ratio=obj_ratio) print('Using ' + obj + ' Data') volumes = volumes[..., np.newaxis].astype(np.float) data = torch.from_numpy(volumes) data = data.permute(0, 4, 1, 2, 3) data = data.type(torch.FloatTensor) # choose loss function criterion = nn.BCELoss() criterion2 = nn.MSELoss() # fake/real labels real_label = 1 fake_label = 0
def trainGAN(is_dummy=False, checkpoint=None): weights = initialiseWeights() # z_vector = tf.placeholder(shape=[batch_size, z_size], dtype=tf.float32) #z_vector = tf.placeholder(shape=[batch_size, 32,32,1], dtype=tf.float32) #y_vector = tf.placeholder(tf.float32, [batch_size, y_dim]) x_vector = tf.placeholder(shape=[batch_size, cube_len, cube_len, cube_len, 1], dtype=tf.float32) mask_vector = tf.placeholder(shape=[batch_size, cube_len, cube_len, cube_len, 1], dtype=tf.float32) net_g_train = generator(mask_vector, phase_train=True, reuse=False) #y_mask = tf.placeholder(tf.float32, shape=[batch_size, 64, 64, 64, 1]) d_output_x, d_no_sigmoid_output_x = discriminator(x_vector, phase_train=True, reuse=False) d_output_x = tf.maximum(tf.minimum(d_output_x, 0.99), 0.01) summary_d_x_hist = tf.summary.histogram("d_prob_x", d_output_x) d_output_z, d_no_sigmoid_output_z = discriminator(net_g_train, phase_train=True, reuse=True) d_output_z = tf.maximum(tf.minimum(d_output_z, 0.99), 0.01) summary_d_z_hist = tf.summary.histogram("d_prob_z", d_output_z) # Compute the discriminator accuracy n_p_x = tf.reduce_sum(tf.cast(d_output_x > 0.5, tf.int32)) n_p_z = tf.reduce_sum(tf.cast(d_output_z < 0.5, tf.int32)) d_acc = tf.divide(n_p_x + n_p_z, 2 * batch_size) # Compute the discriminator and generator loss # d_loss = -tf.reduce_mean(tf.log(d_output_x) + tf.log(1-d_output_z)) # g_loss = -tf.reduce_mean(tf.log(d_output_z)) d_loss = tf.nn.sigmoid_cross_entropy_with_logits(logits=d_no_sigmoid_output_x, labels=tf.ones_like( d_output_x)) + tf.nn.sigmoid_cross_entropy_with_logits(logits=d_no_sigmoid_output_z, labels=tf.zeros_like(d_output_z)) gen_loss_L1 = tf.reduce_mean(tf.abs(x_vector - net_g_train)) g_loss = tf.nn.sigmoid_cross_entropy_with_logits(logits=d_no_sigmoid_output_z, labels=tf.ones_like(d_output_z)) d_loss = tf.reduce_mean(d_loss) g_loss = tf.reduce_mean(g_loss) * 0.01 + gen_loss_L1*0.99 summary_d_loss = tf.summary.scalar("d_loss", d_loss) summary_g_loss = tf.summary.scalar("g_loss", g_loss) summary_n_p_z = tf.summary.scalar("n_p_z", n_p_z) summary_n_p_x = tf.summary.scalar("n_p_x", n_p_x) summary_d_acc = tf.summary.scalar("d_acc", d_acc) #net_g_test = generator(z_vector, y_vector, phase_train=False, reuse=True) para_g = [var for var in tf.trainable_variables() if any(x in var.name for x in ['wg', 'bg', 'gen'])] para_d = [var for var in tf.trainable_variables() if any(x in var.name for x in ['wd', 'bd', 'dis'])] # only update the weights for the discriminator network optimizer_op_d = tf.train.AdamOptimizer(learning_rate=d_lr, beta1=beta).minimize(d_loss, var_list=para_d)#Larry #optimizer_op_d = tf.train.AdamOptimizer(learning_rate=d_lr, beta1=beta).minimize(d_loss) # Larry #optimizer_op_g = tf.train.AdamOptimizer(learning_rate=g_lr, beta1=beta).minimize(g_loss) # Larry # only update the weights for the generator network optimizer_op_g = tf.train.AdamOptimizer(learning_rate=g_lr, beta1=beta).minimize(g_loss, var_list=para_g)#Larry parameter_count = tf.reduce_sum([tf.reduce_prod(tf.shape(v)) for v in tf.trainable_variables()]) saver = tf.train.Saver() # vis = visdom.Visdom() with tf.Session() as sess: print("parameter_count =", sess.run(parameter_count)) sess.run(tf.global_variables_initializer()) # if checkpoint is not None: # saver.restore(sess, checkpoint) if is_dummy: volumes = np.random.randint(0, 2, (batch_size, cube_len, cube_len, cube_len)) print('Using Dummy Data') else: volumes = d.getAll(obj=obj, train=True, is_local=is_local, obj_ratio=obj_ratio) print('Using ' + obj + ' Data') volumes = volumes[..., np.newaxis].astype(np.float) # volumes *= 2.0 # volumes -= 1.0 # bound_list, mask_list = d.getBounds() #test_bound = np.array([22, 22, 0, 42, 42, 62], dtype=float) #test_bound = np.array([22, 22, 0, 42, 42, 62], dtype=int) #test_bound_list = np.tile(test_bound, bound_list.shape[0]) #test_bound_list = test_bound_list.reshape((bound_list.shape[0], bound_list.shape[1])) # test_mask_list=d.get_mask_list_by_bound(test_bound_list) #mask_list = d.getMask() for epoch in range(n_epochs): idx = np.random.randint(len(volumes), size=batch_size) x = volumes[idx] # y = bound_list[idx]/64 #z = z_load[idx] #y = y_load[idx] y_mask_array = mask_load[idx]#Larry y_mask_array=y_mask_array.reshape([-1,64,64,64,1]) # Larry Begin #z_sample = np.random.normal(0, 0.33, size=[batch_size, z_size]).astype(np.float32)###Larry #z_sample #z = np.random.normal(0, 0.33, size=[batch_size, z_size]).astype(np.float32) z = np.random.uniform(0, 0.33, size=[batch_size, z_size]).astype(np.float32) # Larry End # Update the discriminator and generator d_summary_merge = tf.summary.merge([summary_d_loss, summary_d_x_hist, summary_d_z_hist, summary_n_p_x, summary_n_p_z, summary_d_acc]) summary_d, discriminator_loss = sess.run([d_summary_merge, d_loss], feed_dict={ x_vector: x,mask_vector: y_mask_array}) summary_g, generator_loss = sess.run([summary_g_loss, g_loss], feed_dict={ mask_vector: y_mask_array}) d_accuracy, n_x, n_z = sess.run([d_acc, n_p_x, n_p_z], feed_dict={ x_vector: x,mask_vector: y_mask_array}) print(n_x, n_z) if d_accuracy < d_thresh: sess.run([optimizer_op_d], feed_dict={x_vector: x,mask_vector: y_mask_array}) write_Excle.saveValue('D', epoch, discriminator_loss.item(), generator_loss.item(), d_accuracy) print('Discriminator Training ', "epoch: ", epoch, ', d_loss:', discriminator_loss, 'g_loss:', generator_loss, "d_acc: ", d_accuracy) list.append(dict(netType='D', epoch=epoch, d_loss=discriminator_loss.item(), g_loss=generator_loss.item(), d_acc=d_accuracy)) if d_accuracy > 0.5: sess.run([optimizer_op_g], feed_dict={mask_vector: y_mask_array}) write_Excle.saveValue('G', epoch, discriminator_loss.item(), generator_loss.item(), d_accuracy) list.append(dict(netType='G', epoch=epoch, d_loss=discriminator_loss.item(), g_loss=generator_loss.item(), d_acc=d_accuracy)) print('Generator Training ', "epoch: ", epoch, ', d_loss:', discriminator_loss, 'g_loss:', generator_loss, "d_acc: ", d_accuracy) # output generated chairs # if epoch % 10000 == 0: # #use fixed bound and mask # y = test_bound_list[idx] / 64 # y_mask_array = test_mask_list[idx] # # g_objects = sess.run(net_g_test, feed_dict={z_vector: z_sample, y_vector: y,y_mask: y_mask_array}) # if not os.path.exists(train_sample_directory): # os.makedirs(train_sample_directory) # g_objects.dump(train_sample_directory + '/biasfree_' + str(epoch)) # id_ch = np.random.randint(0, batch_size, 4) # for i in range(4): # if g_objects[id_ch[i]].max() > 0.5: # d.plotVoxelVisdom(np.squeeze(g_objects[id_ch[i]] > 0.5), '_'.join(map(str, [epoch, i]))) if epoch % 200 == 10: if not os.path.exists(model_directory): os.makedirs(model_directory) saver.save(sess, save_path=model_directory + '/Larry_5_' + str(epoch) + '.cptk')
def train(): discriminator = disc_model() generator = gen_model() discriminator_on_generator = generator_containing_discriminator( generator, discriminator) g_optim = Adam(lr=g_lr, beta_1=beta) generator.compile(loss='binary_crossentropy', optimizer="SGD") d_optim = Adam(lr=d_lr, beta_1=0.9) discriminator_on_generator.compile(loss='binary_crossentropy', optimizer=g_optim) discriminator.trainable = True discriminator.compile(loss='binary_crossentropy', optimizer=d_optim) z_sample = np.random.normal(0, 0.33, size=[batch_size, 1, 1, 1, z_size]).astype(np.float32) volumes = d.getAll(obj=obj, train=True, is_local=is_local, obj_ratio=obj_ratio) print 'Data loaded .......' volumes = volumes[..., np.newaxis].astype(np.float) if not os.path.exists(train_sample_directory): os.makedirs(train_sample_directory) if not os.path.exists(model_directory): os.makedirs(model_directory) for epoch in range(n_epochs): print("Epoch is", epoch) idx = np.random.randint(len(volumes), size=batch_size) x = volumes[idx] z = np.random.normal(0, 0.33, size=[batch_size, 1, 1, 1, z_size]).astype(np.float32) generated_volumes = generator.predict(z, verbose=0) X = np.concatenate((x, generated_volumes)) Y = np.reshape([1] * batch_size + [0] * batch_size, (-1, 1, 1, 1, 1)) d_loss = discriminator.train_on_batch(X, Y) print("d_loss : %f" % (d_loss)) z = np.random.normal(0, 0.33, size=[batch_size, 1, 1, 1, z_size]).astype(np.float32) discriminator.trainable = False g_loss = discriminator_on_generator.train_on_batch( z, np.reshape([1] * batch_size, (-1, 1, 1, 1, 1))) discriminator.trainable = True print("g_loss : %f" % (g_loss)) if epoch % 1000 == 10: generator.save_weights(model_directory + 'generator_' + str(epoch), True) discriminator.save_weights( model_directory + 'discriminator_' + str(epoch), True) if epoch % 500 == 10: generated_volumes = generator.predict(z_sample, verbose=0) generated_volumes.dump(train_sample_directory + '/' + str(epoch))
def ganGetOneResult(trained_model_path): global IsInit global Istrue global number if IsInit == False: initialiseWeights() IsInit = True z_vector = tf.placeholder(shape=[batch_size, z_size, z_size, 1], dtype=tf.float32) y_vector = tf.placeholder(tf.float32, [batch_size, y_dim]) net_g_test = generator(z_vector, y_vector, phase_train=True) saver = tf.train.Saver() with tf.variable_scope(tf.get_variable_scope(), reuse=None): config = tf.ConfigProto() config.gpu_options.allow_growth = True with tf.Session(config=config) as sess: sess.run(tf.global_variables_initializer()) saver.restore(sess, trained_model_path) while True: if Istrue: x = [] Istrue = False volumes = d.getAll(obj=obj, train=True, is_local=is_local, obj_ratio=obj_ratio) volumes = volumes.reshape((99, 64, 64, 64)) g_objects = volumes[num] for i in range(0, 5): x.append(g_objects) g_objects = np.array(x) id_ch = np.random.randint(0, batch_size, 4) i = 0 print(g_objects[id_ch[i]].max(), g_objects[id_ch[i]].min(), g_objects[id_ch[i]].shape) if g_objects[id_ch[i]].max() > 0.5: result = np.squeeze(g_objects[id_ch[i]] > 0.5) yield result else: data_path = glob.glob(r'D:\Paper\image\test\A\*.png') onepath = choice(data_path) print(onepath) img = Image.open(onepath) img.save('output.png', quality=100) def matrixpic(img): matrixpic = np.asarray(img) (h, w) = matrixpic.shape[:2] for i in range(h): for j in range(w): if matrixpic[i][j] == 255: matrixpic[i][j] = 255 else: matrixpic[i][j] = 0 return matrixpic # 绿色转白色 def convertcolor(img): img = np.asarray(img) (h, w) = img.shape[:2] for i in range(h): for j in range(w): if img[i][j][1] > 180 and img[i][j][ 0] < 20 and img[i][j][2] < 20: img[i][j] = 255 return img # 生成二值测试图像 img = cv2.imread('output.png') img1 = np.ones(img.shape[:2]) converted = convertcolor(img) gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) thresh = matrixpic(gray) # # 检测所有图形的轮廓 contours = measure.find_contours(thresh, 0.5) x = 0 y = 0 for n, contour in enumerate(contours): if contour.size > x: x = contour.size y = contour y[:, [0, 1]] = y[:, [1, 0]] _contours = [] _contours.append( np.around(np.expand_dims(y, 1)).astype(np.int)) cv2.drawContours(img1, _contours, -1, (0, 0, 0), -1) img1 = cv2.resize(img1, (64, 64), interpolation=cv2.INTER_CUBIC) img_np_1d = img1 * 255 one_array = np.zeros((64, 64), float) for i in range(64): for j in range(64): if img_np_1d[i][j] < 155: one_array[i][j] = 255 else: one_array[i][j] = 0 one_array = Image.fromarray(one_array) one_array = one_array.rotate(-90) if one_array.mode != 'RGB': one_array = one_array.convert('RGB') one_array.save('1234.png') one_array = cv2.imread('1234.png', 0) left = up = down = right = 0 for j in range(32): for i in range(64): if one_array[i][j] != 0: left = j if left != 0: break for i in range(32): for j in range(64): if one_array[i][j] == 255: up = i if up != 0: break for i in range(32): for j in range(64): if one_array[63 - i][j] == 255: down = 63 - i if down != 0: break right = down - up + 24 box = (left, up, right, down) img = Image.open('1234.png') roi = img.crop(box) dst = roi.resize((64, 64), Image.ANTIALIAS) dst.save('123456.png', quality=100) num = onepath[-8:-5] num = int(num) - 901 # one_array = cv2.imread('123456.png', 0) for i in range(64): for j in range(64): if one_array[i][j] > 125: one_array[i][j] = 1 else: one_array[i][j] = 0 Istrue = True x = [] for i in range(0, 5): x.append(one_array) x = np.array(x) z_sample = np.array(x) z_sample = z_sample.reshape([-1, z_size, z_size, 1]) y = np.random.normal(0, 0.33, size=[batch_size, y_dim]).astype(np.float32) g_objects = sess.run(net_g_test, feed_dict={ z_vector: z_sample, y_vector: y }) id_ch = np.random.randint(0, batch_size, 4) i = 0 print(g_objects[id_ch[i]].max(), g_objects[id_ch[i]].min(), g_objects[id_ch[i]].shape) if g_objects[id_ch[i]].max() > 0.5: result = np.squeeze(g_objects[id_ch[i]] > 0.5) volumes = d.getAll(obj=obj, train=True, is_local=is_local, obj_ratio=obj_ratio) volumes = volumes.reshape((99, 64, 64, 64)) g_objects = volumes[num] x = [] for i in range(0, 5): x.append(g_objects) g_objects = np.array(x) id_ch = np.random.randint(0, batch_size, 4) i = 0 print(g_objects[id_ch[i]].max(), g_objects[id_ch[i]].min(), g_objects[id_ch[i]].shape) result2 = [] result3 = [] result4 = [] if g_objects[id_ch[i]].max() > 0.5: result2 = np.squeeze(g_objects[id_ch[i]] > 0.5) pre1 = np.sum(np.logical_xor(result, result2)) pre2 = np.sum(np.logical_and(result, result2)) pre3 = np.sum(np.logical_or(result, result2)) print("xor=", pre1, " and=", pre2, " or=", pre3) acc = pre2 / pre3 print("Acc=", acc) # result2=result2.reshape(64 * 64 * 64) # result =result.reshape(64 * 64 * 64) # result3 = result&result2 # result4 = result | result2 # result3=result3.reshape((64,64,64)) yield result yield None
def trainGAN(is_dummy=False, checkpoint=None): weights = initialiseWeights() # z_size = 200 cube_len = 64 z_vector = tf.placeholder(shape=[batch_size, z_size], dtype=tf.float32) x_vector = tf.placeholder( shape=[batch_size, cube_len, cube_len, cube_len, 1], dtype=tf.float32) net_g_train = generator(z_vector, phase_train=True, reuse=False) # x_vector is the input of discriminator original 3D object d_output_x, d_no_sigmoid_output_x = discriminator(x_vector, phase_train=True, reuse=False) d_output_x = tf.maximum(tf.minimum(d_output_x, 0.99), 0.01) # d_output_x is between 0.01 and 0.99 # tf.summary.histogram is concerning to tensorboard summary_d_x_hist = tf.summary.histogram("d_prob_x", d_output_x) # generating 3d OBJECT d_output_z, d_no_sigmoid_output_z = discriminator(net_g_train, phase_train=True, reuse=True) d_output_z = tf.maximum(tf.minimum(d_output_z, 0.99), 0.01) summary_d_z_hist = tf.summary.histogram("d_prob_z", d_output_z) # Compute the discriminator accuracy n_p_x = tf.reduce_sum(tf.cast(d_output_x > 0.5, tf.int32)) n_p_z = tf.reduce_sum(tf.cast(d_output_z < 0.5, tf.int32)) d_acc = tf.divide(n_p_x + n_p_z, 2 * batch_size) # Compute the discriminator and generator loss # d_loss = -tf.reduce_mean(tf.log(d_output_x) + tf.log(1-d_output_z)) # g_loss = -tf.reduce_mean(tf.log(d_output_z)) d_loss = tf.nn.sigmoid_cross_entropy_with_logits( logits=d_no_sigmoid_output_x, labels=tf.ones_like( d_output_x)) + tf.nn.sigmoid_cross_entropy_with_logits( logits=d_no_sigmoid_output_z, labels=tf.zeros_like(d_output_z)) g_loss = tf.nn.sigmoid_cross_entropy_with_logits( logits=d_no_sigmoid_output_z, labels=tf.ones_like(d_output_z)) d_loss = tf.reduce_mean(d_loss) g_loss = tf.reduce_mean(g_loss) # concerning to tensorboard summary_d_loss = tf.summary.scalar("d_loss", d_loss) summary_g_loss = tf.summary.scalar("g_loss", g_loss) summary_n_p_z = tf.summary.scalar("n_p_z", n_p_z) summary_n_p_x = tf.summary.scalar("n_p_x", n_p_x) summary_d_acc = tf.summary.scalar("d_acc", d_acc) net_g_test = generator(z_vector, phase_train=False, reuse=True) # tf.trainable_variables() return a list which need training para_g = [ var for var in tf.trainable_variables() if any(x in var.name for x in ['wg', 'bg', 'gen']) ] para_d = [ var for var in tf.trainable_variables() if any(x in var.name for x in ['wd', 'bd', 'dis']) ] # only update the weights for the discriminator network optimizer_op_d = tf.train.AdamOptimizer( learning_rate=d_lr, beta1=beta).minimize(d_loss, var_list=para_d) # only update the weights for the generator network optimizer_op_g = tf.train.AdamOptimizer( learning_rate=g_lr, beta1=beta).minimize(g_loss, var_list=para_g) saver = tf.train.Saver() # data visidize vis = visdom.Visdom() with tf.Session() as sess: sess.run(tf.global_variables_initializer()) if checkpoint is not None: saver.restore(sess, checkpoint) # is_dummy = false if is_dummy: # is_dummy = true # batch_size = 32 cube_len = 64 volumes = np.random.randint( 0, 2, (batch_size, cube_len, cube_len, cube_len)) print 'Using Dummy Data' else: # is_dummy = false is_local = false volumes is a list of npy voxList = d.getAll(obj=obj, train=True, is_local=is_local, obj_ratio=obj_ratio) print 'Using ' + obj + ' Data' # volumes *= 2.0 # volumes -= 1.0 for epoch in range(n_epochs): for batch_count in range(len(voxList) / batch_size): volumes = np.zeros([batch_size, cube_len, cube_len, cube_len], dtype=np.bool) # each batch get two npy for index in range(batch_count * batch_size, (batch_count + 1) * batch_size): # each npy load a array vox_arr = np.load(voxList[index]) volumes[index % batch_size] = vox_arr # increase a axis to stand a place x = volumes[..., np.newaxis].astype(np.float) # Gaussian Distribution z_sample = np.random.normal(0, 0.33, size=[batch_size, z_size]).astype(np.float32) z = np.random.normal(0, 0.33, size=[batch_size, z_size]).astype(np.float32) # z = np.random.uniform(0, 1, size=[batch_size, z_size]).astype(np.float32) # Update the discriminator and generator # manage summary d_summary_merge = tf.summary.merge([ summary_d_loss, summary_d_x_hist, summary_d_z_hist, summary_n_p_x, summary_n_p_z, summary_d_acc ]) #writer = tf.summary.FileWriter('logs' , sess.graph) #summary_d, discriminator_loss = sess.run([d_summary_merge,d_loss],feed_dict={z_vector:z, x_vector:x}) discriminator_loss = sess.run(d_loss, feed_dict={ z_vector: z, x_vector: x }) #writer.add_summary(summary_d, batch_count) generator_loss = sess.run(g_loss, feed_dict={z_vector: z}) #writer.add_summary(summary_g, batch_count) d_accuracy, n_x, n_z = sess.run([d_acc, n_p_x, n_p_z], feed_dict={ z_vector: z, x_vector: x }) print n_x, n_z # when discriminator's d_accuracy < 0.8, optimize if d_accuracy < d_thresh: sess.run([optimizer_op_d], feed_dict={ z_vector: z, x_vector: x }) print 'Discriminator Training ', "Iteration: ", batch_count, ', d_loss:', discriminator_loss, 'g_loss:', generator_loss, "d_acc: ", d_accuracy sess.run([optimizer_op_g], feed_dict={z_vector: z}) print 'Generator Training ', "Iteration: ", batch_count, ', d_loss:', discriminator_loss, 'g_loss:', generator_loss, "d_acc: ", d_accuracy # output generated chairs if epoch % 2 == 0: g_objects = sess.run(net_g_test, feed_dict={z_vector: z_sample}) if not os.path.exists(train_sample_directory): os.makedirs(train_sample_directory) g_objects.dump(train_sample_directory + '/biasfree_' + str(epoch)) id_ch = np.random.randint(0, batch_size, 4) for i in range(4): if g_objects[id_ch[i]].max() > 0.5: d.plotVoxelVisdom( np.squeeze(g_objects[id_ch[i]] > 0.5), vis, '_'.join(map(str, [epoch, i]))) if epoch % 50 == 10: if not os.path.exists(model_directory): os.makedirs(model_directory) saver.save(sess, save_path=model_directory + '/biasfree_' + str(epoch) + '.cptk')
def trainGAN(): weights, biases = initialiseWeights(), initialiseBiases() z_vector = tf.placeholder(shape=[batch_size,z_size],dtype=tf.float32) x_vector = tf.placeholder(shape=[batch_size,32,32,32,1],dtype=tf.float32) net_g_train = generator(z_vector, phase_train=True, reuse=False) d_output_x = discriminator(x_vector, phase_train=True, reuse=False) d_output_x = tf.maximum(tf.minimum(d_output_x, 0.99), 0.01) summary_d_x_hist = tf.summary.histogram("d_prob_x", d_output_x) d_output_z = discriminator(net_g_train, phase_train=True, reuse=True) d_output_z = tf.maximum(tf.minimum(d_output_z, 0.99), 0.01) summary_d_z_hist = tf.summary.histogram("d_prob_z", d_output_z) d_loss = -tf.reduce_mean(tf.log(d_output_x) + tf.log(1-d_output_z)) summary_d_loss = tf.summary.scalar("d_loss", d_loss) g_loss = -tf.reduce_mean(tf.log(d_output_z)) summary_g_loss = tf.summary.scalar("g_loss", g_loss) net_g_test = generator(z_vector, phase_train=True, reuse=True) para_g=list(np.array(tf.trainable_variables())[[0,1,4,5,8,9,12,13]]) para_d=list(np.array(tf.trainable_variables())[[14,15,16,17,20,21,24,25]])#,28,29]]) # only update the weights for the discriminator network optimizer_op_d = tf.train.AdamOptimizer(learning_rate=alpha_d,beta1=beta).minimize(d_loss,var_list=para_d) # only update the weights for the generator network optimizer_op_g = tf.train.AdamOptimizer(learning_rate=alpha_g,beta1=beta).minimize(g_loss,var_list=para_g) saver = tf.train.Saver(max_to_keep=50) with tf.Session() as sess: sess.run(tf.global_variables_initializer()) z_sample = np.random.normal(0, 0.33, size=[batch_size, z_size]).astype(np.float32) volumes = d.getAll(obj=obj, train=True, is_local=True) volumes = volumes[...,np.newaxis].astype(np.float) for epoch in tqdm(range(n_epochs)): idx = np.random.randint(len(volumes), size=batch_size) x = volumes[idx] z = np.random.normal(0, 0.33, size=[batch_size, z_size]).astype(np.float32) # Update the discriminator and generator d_summary_merge = tf.summary.merge([summary_d_loss, summary_d_x_hist,summary_d_z_hist]) summary_d, discriminator_loss = sess.run([d_summary_merge,d_loss],feed_dict={z_vector:z, x_vector:x}) summary_g, generator_loss = sess.run([summary_g_loss,g_loss],feed_dict={z_vector:z}) if discriminator_loss <= 4.6*0.1: sess.run([optimizer_op_g],feed_dict={z_vector:z}) elif generator_loss <= 4.6*0.1: sess.run([optimizer_op_d],feed_dict={z_vector:z, x_vector:x}) else: sess.run([optimizer_op_d],feed_dict={z_vector:z, x_vector:x}) sess.run([optimizer_op_g],feed_dict={z_vector:z}) print "epoch: ",epoch,', d_loss:',discriminator_loss,'g_loss:',generator_loss # output generated chairs if epoch % 500 == 10: g_chairs = sess.run(net_g_test,feed_dict={z_vector:z_sample}) if not os.path.exists(train_sample_directory): os.makedirs(train_sample_directory) g_chairs.dump(train_sample_directory+'/'+str(epoch)) if epoch % 500 == 10: if not os.path.exists(model_directory): os.makedirs(model_directory) saver.save(sess, save_path = model_directory + '/' + str(epoch) + '.cptk')