def sample_model(sess, idx, test_X, test_Y, testG, testF, testG_back, testF_back): # RUN THEM THROUGH THE MODEL x_val, y_val, y_samp, x_samp, y_cycle_samp, x_cycle_samp = sess.run( [test_X, test_Y, testG, testF, testG_back, testF_back]) # GRAB THE RETURNED RESULTS AND COLOR CORRECT / MERGE DOWN TO SINGLE IMAGE FILE EACH pretty_x = merge(utils.inverse_transform(x_samp), [1, 1]) pretty_y = merge(utils.inverse_transform(y_samp), [1, 1]) pretty_x_cycle = merge(utils.inverse_transform(x_cycle_samp), [1, 1]) pretty_y_cycle = merge(utils.inverse_transform(y_cycle_samp), [1, 1]) if not os.path.isdir(SAMPLE_DIR): os.makedirs(SAMPLE_DIR) scipy.misc.imsave(os.path.join(SAMPLE_DIR, '{}_X.jpg'.format(idx)), x_val[0]) scipy.misc.imsave(os.path.join(SAMPLE_DIR, '{}_Y.jpg'.format(idx)), y_val[0]) scipy.misc.imsave(os.path.join(SAMPLE_DIR, '{}_X_2Y.jpg'.format(idx)), y_samp[0]) scipy.misc.imsave(os.path.join(SAMPLE_DIR, '{}_Y_2X.jpg'.format(idx)), x_samp[0]) scipy.misc.imsave(os.path.join(SAMPLE_DIR, '{}_X_2Y_2X.jpg'.format(idx)), x_cycle_samp[0]) scipy.misc.imsave(os.path.join(SAMPLE_DIR, '{}_Y_2X_2Y.jpg'.format(idx)), y_cycle_samp[0])
def calculate_rmse(n_series, n_features, n_lags, X, y, scaler, model): import utils """ Función para calcular la raíz del error cuadrático medio, solo es utilizado por los algoritmos: *Random forest *Ada boost *SVM (máquinas de soporte vectorial o máquinas de soporte de vectores) Los otros algoritmos tienen su propia forma de calcular este error. Parámetros: - n_series -- Entero, el número de time steps a predecir en el futuro, en estos metodos es siempre es 1 por ahora, hasta que se implementen para varios time steps - n_features -- Entero, el número de *features* con los que se entrena el modelo, también se conocen como variables exogenas - n_lags -- Entero, el número de *lags* que se usaron para entrenar, estos *lags* también son conocidos como resagos. Intuitivamente se pueden enterder como una ventana deslizante o como cuantos tiempos atrás en el tiempo tomo en cuenta para hacer mi predicción - X -- Arreglo de numpy, los datos con los que se quier hacer la rpedicción para calcular el error - y -- Arreglo de numpy, las observaciones contra las cuales se van a comparar las predicciones para luego calcular el error - scaler -- Instancia de la clase MinMaxScaler de la libreria sklearn, sirve para escalar los datos y devolverlos a la escala original posteriormente. En esta función se utiliza para revertir el escalamiento y obtener los datos reales - model -- Modelo de sklearn, el modelo entrenado con el cual se van a realizar las predicciones Retorna: - inv_y -- Arreglo de numpy, observaciones en la escala real - inv_yhat -- Arreglo de numpy, predicciones en la escala real - rmse -- Flotante, raíz del error curadrático medio entre las observaciones y las predicciones """ yhat = model.predict(X) inv_yhat = utils.inverse_transform(yhat, scaler, n_features) inv_y = utils.inverse_transform(y, scaler, n_features) # calculate RMSE rmse = math.sqrt(mean_squared_error(inv_y, inv_yhat)) return inv_y, inv_yhat, rmse
def main(_): # Using the Winograd non-fused algorithms provides a small performance boost. os.environ['TF_ENABLE_WINOGRAD_NONFUSED'] = '1' os.environ['CUDA_VISIBLE_DEVICES'] = FLAGS.gpu_index gpu_options = tf.GPUOptions( per_process_gpu_memory_fraction=FLAGS.gpu_memory_fraction) run_config = tf.ConfigProto(allow_soft_placement=True, gpu_options=gpu_options) run_config.gpu_options.allow_growth = True sess = tf.Session(config=run_config) data_path = '../../Data/BMP_320x280/tfrecord/train.tfrecords' data_reader = reader.Reader(data_path, name='data', image_size=(320, 280, 3), batch_size=1) x_imgs_, y_imgs_, x_imgs_ori_, y_imgs_ori_, img_name = data_reader.feed() sess.run(tf.global_variables_initializer()) # threads for tfrecord coord = tf.train.Coordinator() threads = tf.train.start_queue_runners(sess=sess, coord=coord) iter_time = 0 try: while iter_time < FLAGS.iters: x_imgs, y_imgs, x_imgs_ori, y_imgs_ori = sess.run( [x_imgs_, y_imgs_, x_imgs_ori_, y_imgs_ori_]) _, h, w, c = x_imgs.shape canvas = np.zeros((h, 4 * w, c), dtype=np.uint8) x_imgs = utils.inverse_transform(x_imgs) y_imgs = utils.inverse_transform(y_imgs) x_imgs_ori = utils.inverse_transform(x_imgs_ori) y_imgs_ori = utils.inverse_transform(y_imgs_ori) y_imgs = utils.draw_minutiae(x_imgs, y_imgs) canvas[:, 0:w, :] = x_imgs[0] canvas[:, w:2 * w, :] = y_imgs canvas[:, 2 * w:3 * w, :] = x_imgs_ori[0] canvas[:, 3 * w:, :] = y_imgs_ori[0] iter_time += 1 cv2.imshow('show', canvas[:, :, ::-1]) if cv2.waitKey(0) == 27: sys.exit('Esc clicked!') except KeyboardInterrupt: coord.request_stop() except Exception as e: coord.request_stop(e) finally: # when done, ask the threads to stop coord.request_stop() coord.join(threads)
def plots(self, imgs_, iter_time, save_file): # reshape image from vector to (N, H, W, C) imgs_fake = np.reshape(imgs_[0], (self.flags.sample_batch, 64, 64, 3)) imgs = [] for img in imgs_fake: imgs.append(img) # parameters for plot size scale, margin = 0.04, 0.01 n_cols, n_rows = int(np.sqrt(len(imgs))), int(np.sqrt(len(imgs))) imgs = [utils.inverse_transform(imgs[idx]) for idx in range(len(imgs))] output = (imgs[0]).reshape(self.image_size[0], self.image_size[1], self.image_size[2]) for row_index in range(n_rows - 1): output = cv.vconcat([output, (imgs[(row_index + 1) * n_cols]).reshape(self.image_size[0], self.image_size[1], self.image_size[2])]) for col_index in range(n_cols - 1): out = (imgs[col_index + 1]).reshape(self.image_size[0], self.image_size[1], self.image_size[2]) for row_index in range(n_rows - 1): out = cv.vconcat([out, (imgs[(row_index + 1) * n_cols + col_index + 1]).reshape(self.image_size[0], self.image_size[1], self.image_size[2])]) output = cv.hconcat([output, out]) output = np.uint8(output*255.0) print(np.min(output), np.max(output)) cv.imwrite(save_file + '/sample_{}.png'.format(str(iter_time)), output)
def plots(imgs, iter_time, image_size, save_file): scale, margin = 0.02, 0.02 n_cols, n_rows = len(imgs), imgs[0].shape[0] cell_size_h, cell_size_w = imgs[0].shape[1] * scale, imgs[0].shape[ 2] * scale fig = plt.figure(figsize=(cell_size_w * n_cols, cell_size_h * n_rows)) # (column, row) gs = gridspec.GridSpec(n_rows, n_cols) # (row, column) gs.update(wspace=margin, hspace=margin) imgs = [inverse_transform(imgs[idx]) for idx in range(len(imgs))] # save more bigger image for col_index in range(n_cols): for row_index in range(n_rows): ax = plt.subplot(gs[row_index * n_cols + col_index]) plt.axis('off') ax.set_xticklabels([]) ax.set_yticklabels([]) ax.set_aspect('equal') plt.imshow((imgs[col_index][row_index]).reshape( image_size[0], image_size[1]), cmap='Greys_r') plt.savefig(save_file + f'/sample_{str(iter_time).zfill(5)}.png', bbox_inches='tight') plt.close(fig)
def slerp_interpolation(self,batch_image,batch_label,epoch,interval): # 球面差值法测试 # for _ in xrange(3):#测试三次 # print 'slerp test!!' index_select = np.random.randint(0, batch_image.shape[0], self.test_slerp_count*2*2) encode_512 = self.sess.run(self.encode_slerp, feed_dict={self.batch_data: batch_image[index_select], self.input_label: batch_label[0][index_select]}) encode_50=np.random.uniform(high=1, low=-1, size=[self.test_slerp_count*2,self.noise_z]) encode_562=np.concatenate([encode_512,encode_50],axis=1) encode_sub = np.split(encode_562,2,axis=0) decodes = [] for idx, ratio in enumerate(np.linspace(0, 1, 10)): z = np.stack([utils.slerp(ratio, r1, r2) for r1, r2 in zip(encode_sub[0], encode_sub[1])]) z = np.reshape(z, [-1,562]) z_decode = self.sess.run(self.image_syn_slerp, feed_dict={self.encode_slerp_z: z}) decodes.append(z_decode) decodes = np.stack(decodes).transpose([1, 0, 2, 3, 4]) index_sub=np.split(index_select,2,axis=0) index_sub=np.split(index_sub[0],2,axis=0) for idx, img in enumerate(decodes): img = np.concatenate([[batch_image[index_sub[0][idx]]], img, [batch_image[index_sub[1][idx]]]], 0) img = utils.inverse_transform(img)[:, :, :, ::-1] utils.save_image(img, os.path.join('./{}'.format(self.result_path), 'test{:08}_interp_G_{:01}.png'.format(epoch,interval )), nrow=10 + 2)
def save_image_to_memory(image): image = inverse_transform(image) image = merge(image, (1, 1)) image = cv2.cvtColor(image.astype('uint8'), cv2.COLOR_RGB2BGR) is_success, buffer = cv2.imencode(".jpg", image) io_buf = io.BytesIO(buffer) return io_buf
def slerp_interpolation(self, batch_image, batch_label, epoch, interval): # 球面差值法测试 # for _ in xrange(3):#测试三次 # print 'slerp test!!' index_select = np.random.randint(0, batch_image.shape[0], self.test_slerp_count * 2) encode_512 = self.sess.run(self.encode_slerp, feed_dict={ self.batch_data: batch_image[index_select], self.input_label: batch_label[0][index_select], self.input_pose: batch_label[1][index_select], self.input_light: batch_label[2][index_select] }) pose = np.asarray(batch_label[1][index_select], np.int32) light = np.asarray(batch_label[2][index_select], np.int32) b_1 = np.zeros((pose.size, self.pose_c), dtype=np.float32) b_1[np.arange(pose.size), pose] = 1. noise = np.zeros((light.size, self.light_c), dtype=np.float32) noise[np.arange(light.size), light] = 1. encode_519 = np.concatenate([np.reshape(encode_512, [-1, 512]), b_1], axis=1) encode_539 = np.concatenate([encode_519, noise], 1) encode_sub = np.split(encode_539, 2, axis=0) decodes = [] for idx, ratio in enumerate(np.linspace(0, 1, 10)): z = np.stack([ utils.slerp(ratio, r1, r2) for r1, r2 in zip(encode_sub[0], encode_sub[1]) ]) z = np.reshape(z, [-1, 1, 1, 512 + self.light_c + self.pose_c]) z_decode = self.sess.run(self.image_syn_slerp, feed_dict={ self.slerp_code: z, self.batch_data: batch_image, self.input_label: batch_label[0], self.input_pose: batch_label[1], self.input_light: batch_label[2] }) decodes.append(z_decode) decodes = np.stack(decodes).transpose([1, 0, 2, 3, 4]) index_sub = np.split(index_select, 2, axis=0) for idx, img in enumerate(decodes): img = np.concatenate([[batch_image[index_sub[0][idx]]], img, [batch_image[index_sub[1][idx]]]], 0) img = utils.inverse_transform(img)[:, :, :, ::-1] utils.save_image(img, os.path.join( './{}'.format(self.result_path), 'test{:08}_interp_G_{:01}.png'.format( epoch, interval)), nrow=10 + 2)
def sample_and_save_imgs(self, iter_time = 0, istrain = True): if istrain == True: if np.mod(iter_time, self.flags.sample_freq) == 0: imgs = self.model.sample_imgs(sample_size=self.flags.sample_batch) imgs = [utils.inverse_transform(imgs[idx]) for idx in range(len(imgs))] # [(batch_size, height, width, 3)] for i in range(imgs[0].shape[0]): # print('img shape is: ', imgs[0][i].shape) imgs[0][i] = imgs[0][i][:, :, [2, 1, 0]] # rgb to bgr file_path = self.sample_out_dir + '/sample_{}_{}.jpg'.format(str(iter_time), str(i+1)) cv2.imwrite(file_path, imgs[0][i]) else: imgs = self.model.sample_imgs(sample_size=self.flags.sample_batch) imgs = [utils.inverse_transform(imgs[idx]) for idx in range(len(imgs))] # [(batch_size, height, width, 3)] for i in range(imgs[0].shape[0]): # print('img shape is: ', imgs[0][i].shape) imgs[0][i] = imgs[0][i][:, :, [2, 1, 0]] # rgb to bgr file_path = self.test_out_dir + '/sample_{}_{}.jpg'.format(str(iter_time), str(i+1)) cv2.imwrite(file_path, imgs[0][i])
def predict_img(self, img_path): img_np = self.gan.read_img(img_path) print('[Info] img_np shape: {}'.format(img_np.shape)) img_fake = self.gan.predict_img(img_np, self.sess) img_fake = np.squeeze(img_fake, axis=0) print('[Info] img_fake shape: {}'.format(img_fake.shape)) img_fake = inverse_transform(img_fake) img_fake = img_fake.astype(np.uint8) # show_img_rgb(img_fake) return img_fake
def plots_test(self, imgs, img_name, save_file): num_imgs = len(imgs) canvas = np.zeros((self.img_size[0], num_imgs * self.img_size[1]), np.uint8) for idx in range(num_imgs): canvas[:, idx * self.img_size[1]: (idx+1) * self.img_size[1], :] = \ np.squeeze(255. * utils.inverse_transform(imgs[idx])) img_name_ = img_name.astype('U26')[0] # save imgs on test folder cv2.imwrite(os.path.join(save_file, img_name_), canvas)
def calculate(self, preds, gts): # from list to array arr_preds = np.asarray(preds).astype(np.float32) arr_gts = np.asarray(gts).astype(np.float32) # reshape to (N, image_size, image_size) arr_preds = np.reshape( arr_preds, (arr_preds.shape[0], self.image_size[0], self.image_size[1])) arr_gts = np.reshape( arr_gts, (arr_gts.shape[0], self.image_size[0], self.image_size[1])) # conver from [-1. to 1.] to [0. to 255.] arr_preds_ = utils.inverse_transform(arr_preds) * 255. arr_gts_ = utils.inverse_transform(arr_gts) * 255. mae = self.mean_absoulute_error(arr_preds_, arr_gts_) psnr = self.peak_signal_to_noise_ratio(arr_preds_, arr_gts_) return mae, psnr
def plots(self, imgs, iter_time, save_file, names=None): canvas = len(imgs) # transform [-1., 1.] to [0., 1.] imgs = [utils.inverse_transform(imgs[idx]) for idx in range(len(imgs))] # save more bigger image for canvas_idx in range(canvas): utils.plots(imgs[canvas_idx], iter_time, save_file, self.grid_cols, self.grid_rows, self.flags.sample_batch, name=names[canvas_idx])
def generate_images(dcgan, sess, predefined_mean_z=None, z_sigma=0.05): print(FLAGS.generate_name_postfix) strLog = "" generation_data = [] dir = FLAGS.generate_dir if not os.path.exists(dir): os.makedirs(dir) imgInd = 0 while (imgInd < FLAGS.generate_num): if predefined_mean_z is None: z_sample = np.random.uniform(-1, 1, size=(FLAGS.batch_size, FLAGS.z_dim)) else: z_sample = [[np.random.normal(mu, z_sigma) for mu in z_sigma] for _ in range(FLAGS.batch_size)] z_sample = np.array(z_sample) samples = sess.run(dcgan.sampler, feed_dict={dcgan.z: z_sample}) ps = sess.run(dcgan.D, feed_dict={dcgan.inputs: samples}) probs = ps[:, 0] images = inverse_transform(samples) for im, z, d_prob in zip(images, z_sample, probs): if imgInd >= FLAGS.generate_num: break if FLAGS.generate_min_D_prob is None or d_prob >= FLAGS.generate_min_D_prob: filename = 'gen_%d_dPr_%.2f.png' % (imgInd, d_prob) scipy.misc.imsave(os.path.join(dir, filename), np.squeeze(im)) strLog += filename + ',' + FLAGS.generate_name_postfix + ',' + strftime("%Y%m%d%H%M%S", gmtime()) + '\n' generation_data.append((filename, str(d_prob),','.join([str(_) for _ in z]))) imgInd += 1 if imgInd % 50 == 0: print(imgInd) f = open(dir + "/generated_list.txt", "a") f.write(strLog) f.close() with open(dir + "/generated_info.csv", 'w') as ff: ff.write('file,D_prob,' + ','.join(['z' + str(_) for _ in range(0, FLAGS.z_dim)]) + '\n') for g_d in generation_data: ff.write(','.join(g_d) + '\n') # plt.hist(probs) # plt.show() return [os.path.join(dir, gd[0]) for gd in generation_data]
def slerp_interpolation(self, input_data, batch_image, sess, savepath, test_slerp_count=1): #用了patch的方法是不能做slerp—interpolation操作的 # 球面差值法测试 index_select = np.random.randint(0, batch_image.shape[0], test_slerp_count * 2) encode_512 = sess.run( self.encode_slerp, feed_dict={input_data: batch_image[index_select]}) encode_50 = np.random.uniform( high=1, low=-1, size=[test_slerp_count * 2, self.noise_z]) encode_562 = np.concatenate([encode_512, encode_50], axis=1) encode_sub = np.split(encode_562, 2, axis=0) decodes = [] for idx, ratio in enumerate(np.linspace(0, 1, 10)): z = np.stack([ utils.slerp(ratio, r1, r2) for r1, r2 in zip(encode_sub[0], encode_sub[1]) ]) z = np.reshape(z, [-1, 562]) z_decode = sess.run(self.image_syn_slerp, feed_dict={ input_data: batch_image[index_select], self.encode_slerp_z: z }) decodes.append(z_decode) decodes = np.stack(decodes).transpose([1, 0, 2, 3, 4]) index_sub = np.split(index_select, 2, axis=0) index_sub = np.split(index_sub[0], 2, axis=0) for idx, img in enumerate(decodes): img = np.concatenate([[batch_image[index_sub[0][idx]]], img, [batch_image[index_sub[1][idx]]]], 0) img = utils.inverse_transform(img)[:, :, :, ::-1] utils.save_image( img, os.path.join('./{}'.format(savepath), 'test{:08}_interp_G.png'.format(self.model_id)), nrow=10 + 2)
def plots(self, imgs_, iter_time, save_file): imgs_fake = np.reshape(imgs_[0], (self.flags.sample_batch, *self.image_size)) imgs = [] for img in imgs_fake: imgs.append(img) scale, margin = 0.04, 0.01 n_cols, n_rows = int(np.sqrt(len(imgs))), int(np.sqrt(len(imgs))) cell_size_h, cell_size_w = imgs[0].shape[0] * scale, imgs[0].shape[ 1] * scale fig = plt.figure(figsize=(cell_size_w * n_cols, cell_size_h * n_rows)) gs = gridspec.GridSpec(n_rows, n_cols) gs.update(wspace=margin, hspace=margin) imgs = [utils.inverse_transform(imgs[idx]) for idx in range(len(imgs))] for col_index in range(n_cols): for row_index in range(n_rows): ax = plt.subplot(gs[row_index * n_cols + col_index]) plt.axis('off') ax.set_xticklabels([]) ax.set_yticklabels([]) ax.set_aspect('equal') if self.image_size[2] == 3: plt.imshow((imgs[row_index * n_cols + col_index]).reshape( self.image_size[0], self.image_size[1], self.image_size[2]), cmap='Greys_r') elif self.image_sizep[2] == 1: plt.imshow((imgs[row_index * n_cols + col_index]).reshape( self.image_size[0], self.image_size[1]), cmap='Greys_r') else: raise NotImplementedError plt.savefig(save_file + '/sample_{}.png'.format(str(iter_time)), bbox_inches='tight') plt.close(fig)
def eval_mnist_stacked_generate_images(sess, dcgan, config): # generate N images n = config.eval_mnist_stacked_examples generated = np.zeros((n, 3, 28, 28), dtype=np.float32) n_generated = 0 while True: to_be_added_count = config.batch_size if n_generated + config.batch_size > n: to_be_added_count = n - n_generated if config.z_uniform: sample_z = np.random.uniform(-1, 1, size=(config.batch_size, dcgan.z_dim)) else: sample_z = np.random.normal(0, 1, size=(config.batch_size, dcgan.z_dim)) samples = sess.run(dcgan.sampler, feed_dict={dcgan.z: sample_z}) samples = inverse_transform(samples) samples = np.transpose(samples, (0, 3, 1, 2)) generated[n_generated:n_generated + to_be_added_count] = samples[0:to_be_added_count] n_generated += to_be_added_count print n_generated if n_generated >= n: break """ # save to an nparray of shape [N, 3, 28, 28] dir_str = './' + config.main_output_dir + '/eval_stacked_mnist/' if not os.path.exists(dir_str): os.makedirs(dir_str) np.save(dir_str + "eval_mnist_stacked_gen_dataset.npy", generated)""" return generated
def list_files(directory, extension): return sorted((f for f in os.listdir(directory) if f.endswith('.' + extension))) if __name__ == '__main__': crop_size = 148 resize_sze = (64, 64) BATCH_SIZE = 32 dataset = KinectLeap(model='cvae') for i in range(len(dataset)): X, y, g, y_, y__, g_, g__ = dataset[i] X = inverse_transform(X) print(y) print(g) print(y_) print(g_) print(y__) print(g__) plt.figure() plt.imshow(X) plt.axis('off') plt.show() # Data # data transform data_transform = transforms.Compose([ transforms.CenterCrop((crop_size, crop_size)),
def predictF(image_data): img = (image_data / 127.5) - 1. res = sess.run(genF, feed_dict={real_Y: [img]}) res = utils.inverse_transform(res[0]) # scipy.misc.imsave('resultF.jpg', res) return res
out = layer(img) loss = -(out[0]**2).mean() loss.backward() g = params.grad.data g = g / g.abs().mean() params = params - learning_rate * g img = torch.irfft(params, signal_ndim=2) # Normalize image # from https://github.com/eriklindernoren/PyTorch-Deep-Dream for c in range(3): m, s = mean[c], std[c] img[0][c] = torch.clamp(img[0][c], -m / s, (1 - m) / s) # undo jitter img = torch.roll(img, shifts=(-y_jitter, -x_jitter), dims=(-2, -1)) # print(print_probs(F.softmax(net(img), dim=1)[0])) # for proc in psutil.process_iter(): # if proc.name() == "display": # proc.kill() img = img[0].cpu() img = inverse_transform(img) img.show() time.sleep(5)