def write_env(self, env, policy=None, step=None, fps=None, speed=1.0): """ Writes GIF (output from `env` for single episode by following `policy` greedily) to TensorBoard. Important: given `env` state/observation, `policy` must return tensor in shape [n, a, 1] where n=batch_size, a=env.action_space.n. Args: env (Gym Env): OpenAI Gym environment. policy (function, optional): Policy to be followed. Defaults to random policy. step (int, optional): Current step/epoch number in the training loop. Defaults to `self.step`. fps (int, optional): Frames per second of the resulting GIF. Defaults to `env.metadata['video.frames_per_second']`. speed (float, optional): Speed of the rendered GIF (e.g. speed=2.0 will increase the speed twice). Defaults to 1.0. """ state = env.reset() steps, rewards = [], [] while True: steps.append(env.render('rgb_array')) try: action = policy(np.expand_dims(state, axis=0))[0] action = np.argmax(action) except: action = env.action_space.sample() state, reward, done, _ = env.step(action) rewards.append(reward) if done: break if fps is None: try: fps = env.metadata['video.frames_per_second'] except: fps = 24 fps = int(fps * speed) # from https://github.com/tensorflow/tensorboard/issues/39#issuecomment-568917607 thwc = env.render('rgb_array').shape im_summ = tf.compat.v1.Summary.Image() im_summ.height, im_summ.width = thwc[0], thwc[1] im_summ.colorspace = 3 # fix to 3 for RGB with tempfile.NamedTemporaryFile() as f: fname = f.name + '.gif' clip = ImageSequenceClip(steps, fps=fps) clip.write_gif(fname, verbose=False, logger=None) with open(fname, 'rb') as f: enc_gif = f.read() os.remove(fname) im_summ.encoded_image_string = enc_gif # create a serialized summary obj: gif = tf.compat.v1.Summary() env_name = env.unwrapped.spec.id gif.value.add(image=im_summ, tag=f'{env_name}/ Rewards: {sum(rewards)}') if step is None: step = self.step with self.writer.as_default(): tf.summary.experimental.write_raw_pb(gif.SerializeToString(), step=step) env.close()
def make_gif(policy, env, step_count, state_filter, maxsteps=1000): envname = env.spec.id gif_name = '_'.join([envname, str(step_count)]) state = env.reset() done = False steps = [] rewards = [] t = 0 while (not done) & (t < maxsteps): s = env.render('rgb_array') steps.append(s) action = policy.get_action(state, state_filter=state_filter, deterministic=True) action = np.clip(action, env.action_space.low[0], env.action_space.high[0]) action = action.reshape(len(action), ) state, reward, done, _ = env.step(action) rewards.append(reward) t += 1 print('Final reward :', np.sum(rewards)) clip = ImageSequenceClip(steps, fps=30) if not os.path.isdir('gifs'): os.makedirs('gifs') clip.write_gif('gifs/{}.gif'.format(gif_name), fps=30)
def CreateGif(filename, array, fps=5, scale=1., fmt='gif'): ''' Create and save a gif or video from array of images. Parameters: * filename (string): name of the saved video * array (list or string): array of images name already in order, if string it supposed to be the first part of the images name (before iteration integer) * fps = 5 (integer): frame per seconds (limit human eye ~ 15) * scale = 1. (float): ratio factor to scale image hight and width * fmt (string): file extention of the gif/video (e.g: 'gif', 'mp4' or 'avi') Return: * moviepy clip object ''' if (isinstance(array, str)): arrsize = len(gb.glob(array + '*.png')) array = [array + str(i) + '.png' for i in range(arrsize)] else: pass from moviepy.editor import ImageSequenceClip filename += '.' + fmt clip = ImageSequenceClip(list(array), fps=fps).resize(scale) if (fmt == 'gif'): clip.write_gif(filename, fps=fps) elif (fmt == 'mp4'): clip.write_videofile(filename, fps=fps, codec='mpeg4') elif (fmt == 'avi'): clip.write_videofile(filename, fps=fps, codec='png') else: print('Error! Wrong File extension.') sys.exit() command = os.popen('du -sh %s' % filename) print(command.read()) return clip
def export_action(self): #get the folder containing the images using a file dialog dlg = QFileDialog() dlg.setFileMode(QFileDialog.Directory) folderLocs = QStringList( ) #create a QstringList to hold the location data if dlg.exec_(): folderLocs = dlg.selectedFiles() for folderLoc in folderLocs: #Export the recorder images as video using ffmpeg print("Grabbing images from: ", str(folderLoc)) folderName = str( folderLoc )[-8:] #get the folder name (the last 8 characters) from the directory name try: clip = ImageSequenceClip(str(folderLoc), fps=int(self.writeFPS)) print("Writing file...") if self.writeMethod == 0: clip.write_videofile(self.localDir + "/exported/" + folderName + "_" + str(self.writeName) + ".avi", codec=str(self.writeCodec)) elif self.writeMethod == 1: clip.write_gif(self.localDir + "/exported/" + folderName + "_" + str(self.writeName) + ".gif", program=str(self.writeProgram)) except Exception as e: print("Writing exception check settings.\nException:" + str(e)) errorBox("Writing exception check settings.\nException:" + str(e))
def make_gif_of_traj(filename, output_filename, raw=True, fps=5): file = dd.io.load(filename) traj_len = len(file) print(f'trajectory length is {traj_len}') traj_images = [] a = attrdict.AttrDict({'mean': 0, 'scale': 1}) for i in range(1, traj_len): data = file[i] act = obs_to_action(data, file[i - 1], a) sorted_act = sorted(act, key=np.abs) if np.abs(sorted_act[0]) == 0 and sorted_act[1] == 0: print('alert alert') print(act) fig, axs = plot_images(data, raw=raw) fig.canvas.draw() image = np.frombuffer(fig.canvas.tostring_rgb(), dtype='uint8') image = image.reshape(fig.canvas.get_width_height()[::-1] + (3, )) traj_images.append(image) clip = ImageSequenceClip(traj_images, fps=fps) print(f'Writing out to {output_filename}.mp4') clip.write_videofile(f'{output_filename}.mp4', fps=fps) print(f'Writing out to {output_filename}.gif') clip.write_gif(f'{output_filename}.gif', fps=fps, program='imageio', opt='wu')
def play(self, env, directory, mode): """ Returns the total reward for an episode of the game.""" steps = [] state = env.reset() done = False tot_reward = 0 actions = [0] * self.actions while not done: if mode != "Train": s = env.render("rgb_array") steps.append(s) action = self.predict_action(state) actions[action] += 1 state, reward, done, _ = env.step(action) tot_reward += reward self.cur_reward = tot_reward if mode != "Train" and tot_reward > self.max_reward: print("New high reward: ", tot_reward) clip = ImageSequenceClip(steps, fps=30) clip.write_gif("~/breakout.gif", fps=30) self.max_reward = tot_reward print("ACTIONS TAKEN", actions) return tot_reward
def reset(self): # clear all local memory self.seen_observations = [] # state of the environment self.seen_values = [ ] # corresponding estimated values (given by network) self.seen_policies = [] # policies predicted by the network self.seen_states = [] # state of the model self.seen_actions = [] # actions taken self.seen_rewards = [] # rewards given # reset n-step reward calculation self.n_step_reward = 0 # reward for n consecutive steps # reset environment self.observation = self.env.reset() self.observation = self.brain.preprocess(self.observation) self.seen_observations = [self.observation] # reset model self.state = self.brain.get_initial_state() self.seen_states = [self.state] self.total_reward = 0 if self.vis: if len(self.frames) > 0: clip = ImageSequenceClip(self.frames, fps=self.vis_fps) if os.path.exists(params.VIDEO_OUT_DIR): clip.write_gif(params.VIDEO_OUT_DIR + "/" + str(self.num_episodes) + ".gif") else: print("video export directory not found") self.frames = []
def main(args): model = ImageGPT.load_from_checkpoint(args.checkpoint).gpt.cuda() model.eval() context = torch.zeros(0, dtype=torch.long).cuda() frames = generate(model, context, 28 * 28, num_samples=args.rows * args.cols) pad_frames = [] for frame in frames: pad = ((0, 0), (0, 28 * 28 - frame.shape[1])) pad_frames.append(np.pad(frame, pad_width=pad)) pad_frames = np.stack(pad_frames) f, n, _ = pad_frames.shape pad_frames = pad_frames.reshape(f, args.rows, args.cols, 28, 28) pad_frames = pad_frames.swapaxes(2, 3).reshape(f, 28 * args.rows, 28 * args.cols) pad_frames = pad_frames[..., np.newaxis] * np.ones(3) * 17 pad_frames = pad_frames.astype(np.uint8) clip = ImageSequenceClip(list(pad_frames)[::args.downsample], fps=args.fps).resize(args.scale) clip.write_gif("out.gif", fps=args.fps)
def gif(filename, array, fps=10, scale=1.0): """Creates a gif given a stack of images using moviepy Notes ----- works with current Github version of moviepy (not the pip version) https://github.com/Zulko/moviepy/commit/d4c9c37bc88261d8ed8b5d9b7c317d13b2cdf62e Usage ----- >>> X = randn(100, 64, 64) >>> gif('test.gif', X) Parameters ---------- filename : string The filename of the gif to write to array : array_like A numpy array that contains a sequence of images fps : int frames per second (default: 10) scale : float how much to rescale each image by (default: 1.0) """ # ensure that the file has the .gif extension fname, _ = os.path.splitext(filename) filename = fname + '.gif' # copy into the color dimension if the images are black and white if array.ndim == 3: array = array[..., np.newaxis] * np.ones(3) # make the moviepy clip clip = ImageSequenceClip(list(array), fps=fps).resize(scale) clip.write_gif(filename, fps=fps) clip.write_videofile(fname + ".mp4", fps=fps) return clip
def play(self, env, directory, mode): """ Returns the total reward for an episode of the game.""" steps = [] state = env.reset() done = False tot_reward = 0 actions = [0] * self.actions while not done: if mode != "Train": s = env.render("rgb_array") steps.append(s) action = self.predict_action(state) actions[action] += 1 state, reward, done, _ = env.step(action) tot_reward += reward self.cur_reward = tot_reward if mode != "Train" and tot_reward > self.max_reward: print("New high reward: ", tot_reward) clip = ImageSequenceClip(steps, fps=30) clip.write_gif("~/breakout.gif", fps=30) self.max_reward = tot_reward print("ACTIONS TAKEN", actions) return tot_reward
def save_gif(stack, filename): fps = 8 scale = 1.0 assert len(stack.shape) == 3 stack = stack[..., np.newaxis] * np.ones(3) # RGB clip = ImageSequenceClip(list(stack), fps=fps).resize(scale) clip.write_gif(filename, fps=fps, verbose=False)
def get_output(video_path, out_filename, label, fps=30, font_size=20, font_color='white', resize_algorithm='bicubic', use_frames=False): """Get demo output using ``moviepy``. This function will generate video file or gif file from raw video or frames, by using ``moviepy``. For more information of some parameters, you can refer to: https://github.com/Zulko/moviepy. Args: video_path (str): The video file path or the rawframes directory path. If ``use_frames`` is set to True, it should be rawframes directory path. Otherwise, it should be video file path. out_filename (str): Output filename for the generated file. label (str): Predicted label of the generated file. fps (int): Number of picture frames to read per second. Default: 30. font_size (int): Font size of the label. Default: 20. font_color (str): Font color of the label. Default: 'white'. resize_algorithm (str): The algorithm used for resizing. Default: 'bicubic'. For more information, see https://ffmpeg.org/ffmpeg-scaler.html. use_frames: Determine Whether to use rawframes as input. Default:False. """ try: from moviepy.editor import (ImageSequenceClip, TextClip, VideoFileClip, CompositeVideoClip) except ImportError: raise ImportError('Please install moviepy to enable output file.') if use_frames: frame_list = sorted( [osp.join(video_path, x) for x in os.listdir(video_path)]) video_clips = ImageSequenceClip(frame_list, fps=fps) else: video_clips = VideoFileClip( video_path, resize_algorithm=resize_algorithm) duration_video_clip = video_clips.duration text_clips = TextClip(label, fontsize=font_size, color=font_color) text_clips = ( text_clips.set_position( ('right', 'bottom'), relative=True).set_duration(duration_video_clip)) video_clips = CompositeVideoClip([video_clips, text_clips]) out_type = osp.splitext(out_filename)[1][1:] if out_type == 'gif': video_clips.write_gif(out_filename) else: video_clips.write_videofile(out_filename, remove_temp=True)
def _make_gif(agent, name, epsilon, n_seconds): fps = 15 total_frames = n_seconds * fps frames = [] for _ in range(total_frames): frames.append(agent.env.render(mode='rgb_array')) agent.step(epsilon) # the agent resets itself and the environment when done g = ImageSequenceClip(frames, fps=fps) g.write_gif(os.path.join('gifs', f'{name}.gif'), fps=fps)
def make_gif(frames, out_fn): """ :param frames: list of .png files representing frames in the animation :param out_fn: name of the output folder - create this folder inside the output folder :return: .gif file showing the simulated path as an animation """ ofn = 'outputs/' + out_fn + '/' clip = ImageSequenceClip(frames, fps=4) clip.write_gif(ofn + out_fn + '.gif') clip.close()
def create_movie(file_path_list, movie_name_list, movie_path, file_type='png', fps=1, movie_type='mp4', codec='mpeg4'): """ creates the movie. can support any type supported by ffmpeg some examples: movie type / codec .avi / rawvideo, png .mp4 / libx264, mpeg4 avi/rawvideo supported by libreoffice mp4 supported by windows media player Parameters ---------- file_path_list : list of str List of folders where to find the images for the movies movie_name_list : list of str List of movies to create_movie movie_path : str path where to store the movies file_type : str the individual images file type fps : int the frames per second movie_type : str the type of movie file codec : str the codec used for the movie Returns ------- Nothing """ for movie_name, file_path in zip(movie_name_list, file_path_list): file_list = sorted(glob.glob(file_path + '*.' + file_type)) print(file_list) # Generate clip clip = ImageSequenceClip(file_list, fps=fps) # Write out clip if not os.path.isdir(movie_path): os.makedirs(movie_path) clip.write_videofile(movie_path + movie_name + '.' + movie_type, codec=codec) clip.write_gif(movie_path + movie_name + '.gif') print('Created movie ' + movie_path + movie_name)
def _close(self): if len(self._snapshots) == 0: return filename = 'render_' + str(self._episode) + '.gif' clip = ImageSequenceClip(self._snapshots, fps=30) source_folder = "/tmp/" local_filename = source_folder+filename print("writing file to:"+local_filename) clip.write_gif(local_filename, fps=30, logger=None) print("uploading file") self._uploader.upload(source_folder, filename)
def make_spread_gif(): """ Creates and saves gif from images generated by make_spread(). """ # read images images = [imread('../figs/spread/' + file) for file in sorted(os.listdir(path='../figs/spread/')) if file != '.gitkeep'] # make clip and save clip = ImageSequenceClip(images, fps=5) clip.write_gif('../spread.gif')
def generador(lista_estados, cf, cc): imagenes = [] for md in lista_estados: mi = np.zeros([cf, cc, 3], dtype=np.uint8) for i in range(cf): for j in range(cc): mi[i, j] = [255, 128, 0] if (md[i, j] == True) else [0, 0, 255] imagenes.append(mi) clip = ImageSequenceClip(imagenes, fps=1) # fps = 1 indica un cuadro por segundo clip.write_gif('automata.gif') clip.close() return
def to_gif(filename, array, fps=12, scale=1.0): fname, _ = os.path.splitext(filename) filename = fname + '.gif' # copy into the color dimension if the images are black and white if array.ndim == 3: array = array[..., np.newaxis] * np.ones(3) # make the moviepy clip clip = ImageSequenceClip(list(array), fps=fps) clip.resize(scale) clip.write_gif(filename, fps=fps) return clip
def main(): parser = argparse.ArgumentParser(description='Create driving video.') parser.add_argument( 'image_folder', type=str, default='', help= 'Path to image folder. The video will be created from these images.') parser.add_argument('--fps', type=int, default=60, help='FPS (Frames per second) setting for the video.') parser.add_argument('--ext', type=str, default='mp4', help='Video format : mp4 or gif') parser.add_argument( '--cleanup', help='if present, then remove the images folder after video conversion' ) args = parser.parse_args() # convert file folder into list firltered for image file types image_list = sorted([ os.path.join(args.image_folder, image_file) for image_file in os.listdir(args.image_folder) ]) image_list = [ image_file for image_file in image_list if os.path.splitext(image_file)[1][1:].lower() in IMAGE_EXT ] print("Creating video {}, FPS={}".format(args.image_folder, args.fps)) if args.ext == 'mp4': clip = ImageSequenceClip(image_list, fps=args.fps) clip.write_videofile(args.image_folder + '.mp4') else: clip = ImageSequenceClip(image_list[::3], fps=args.fps) # keep gif file small clip = clip.resize(width=320) clip.write_gif(args.image_folder + '.gif', program='ffmpeg', fps=clip.fps) if args.cleanup: [ os.remove(f'{args.image_folder}/{f}') for f in os.listdir(args.image_folder) if f.endswith('.jpg') ]
def generate_gif(self, filename=defaults.filename): state = self.env.reset() frames = [] for _ in range(200): action = self.act(state, False) frame = self.env.render("rgb_array") next_state, reward, done, _ = self.env.step(action) frames.append(frame) if done: break else: state = next_state gif = ImageSequenceClip(frames, fps=30) gif.write_gif("gifs/{}.gif".format(filename), program="imageio")
def random_agent(): all_states = [] for i in range(1): env = gym.make("Tag-v0") env.set_config(my_config) for j in range(360): obs, rew, _, _ = env.step(3) all_states.append(obs) print(rew) clip = ImageSequenceClip(all_states, fps=60) clip.write_gif(action_name[i] + str(my_config["map"]) + ".gif", fps=60) all_states = []
def main(): parser = argparse.ArgumentParser() parser.add_argument("--cfg-path", type=str, default="conf/ant.yaml") parser.add_argument("--ckpt-path", type=str) parser.add_argument("--save-gif", action="store_true") args = parser.parse_args() with open(args.cfg_path) as f: config = yaml.load(f, Loader=yaml.FullLoader) f.close() env = builder.build_env(config["env"]) agent_ids = env.get_agent_ids() if args.save_gif: run_num = args.ckpt_path.split("/")[-3] save_dir = f"test_gif/{run_num}/" os.makedirs(save_dir) network = builder.build_network(config["network"]) network.load_state_dict(torch.load(args.ckpt_path)) for i in range(100): models = {} for agent_id in agent_ids: models[agent_id] = deepcopy(network) models[agent_id].eval() models[agent_id].reset() obs = env.reset() done = False episode_reward = 0 ep_step = 0 ep_render_lst = [] while not done: actions = {} for k, model in models.items(): s = obs[k]["state"][np.newaxis, ...] actions[k] = model(s) obs, r, done, _ = env.step(actions) rgb_array = env.render() if args.save_gif: ep_render_lst.append(rgb_array) episode_reward += r ep_step += 1 print("reward: ", episode_reward, "ep_step: ", ep_step) if args.save_gif: clip = ImageSequenceClip(ep_render_lst, fps=30) clip.write_gif(save_dir + f"ep_{i}.gif", fps=30) del ep_render_lst
def main(args): images_dir = args[1] imgs_count = int(args[2]) fps = int(args[3]) format = args[4] images = gen_filenames(images_dir, imgs_count) crop_images(images) clip = ImageSequenceClip(images, fps=fps) if format == "gif": clip.write_gif('giffer' + '.gif') else: clip.write_videofile('giffer_mov' + '.mp4')
def make_canvas_gif(): """ Creates and saves gif from images generated by make_canvas(). """ # read images images = [imread('../figs/canvas/' + file) for file in sorted(os.listdir(path='../figs/canvas/')) if file != '.gitkeep'] # durations of frames in log time durations = list(np.diff(np.log(4 + np.arange(len(images))))) # make clip and save as gif clip = ImageSequenceClip(images, durations=durations) clip.fps = 25 clip.write_gif('../canvas.gif')
def gen_gif(imgs_path, save_path, fps): ''' 把一串连续的图片保存为gif动图 :param imgs_path: 图片路径 ,比如"G:\\UCLA\\png" :param save_path: 保存的gif路径(包括文件名.gif) ,比如"G:\\UCLA\\ucla.gif" :param fps: 以多少副图片保存一帧 :return: 一个gif图片,在save_path文件夹下 ''' image_list = [] for im in os.listdir(imgs_path): image_list.append(os.path.join(imgs_path, im)) clip = ImageSequenceClip(image_list, fps=fps) clip.write_gif(save_path, fps=fps) # ------------------------------------------------------------------------------------------------
def create_gif(filename, array, fps=10, scale=1.0): """ Source: https://gist.github.com/nirum/d4224ad3cd0d71bfef6eba8f3d6ffd59 """ # ensure that the file has the .gif extension fname, _ = os.path.splitext(filename) filename = fname + '.gif' # copy into the color dimension if the images are black and white if array.ndim == 3: array = array[..., np.newaxis] * np.ones(3) # make the moviepy clip clip = ImageSequenceClip(list(array), fps=fps).resize(scale) clip.write_gif(filename, fps=fps) return clip
def gif(filename, array, fps=10, scale=1.0): # ensure that the file has the .gif extension fname, _ = os.path.splitext(filename) filename = fname + '.gif' filename_v = fname + '.mp4' # copy into the color dimension if the images are black and white if array.ndim == 3: array = array[..., np.newaxis] * np.ones(3) # make the moviepy clip clip = ImageSequenceClip(list(array), fps=fps).resize(scale) clip.write_gif(filename, fps=fps) clip.write_videofile(filename_v, fps=fps) return clip
def visualize_all_activations_3d(model, destination_path): """ Get all activations of all Conv3D layers for each filter Saving 3D activations in destination_path as .gif files in separate folders for each convolutional layer during the process :param model: keras sequential model with Conv3D layers :param destination_path: path where to save gifs :return: all activations from all layers """ # getting indices of all convolutional layers conv_layer_indices = [] number_of_layers = len(model.layers) for i in range(number_of_layers): if type(model.layers[i]) is keras.layers.convolutional.Conv3D: conv_layer_indices.append(i) # getting number of convolutional layers number_of_conv_layers = len(conv_layer_indices) # getting number of filters for each convolutional layer number_of_filters = [] for i in conv_layer_indices: number_of_filters.append(get_num_filters(model.layers[i])) # getting activations for each convolutional layer all_activations = [] for l in range(number_of_conv_layers): gif_folder = destination_path + "/" + model.layers[ conv_layer_indices[l]].name + "/" #created directory for each convolutional layer if not os.path.exists(gif_folder): os.makedirs(gif_folder) activations = [] for f in number_of_filters[l]: # getting activation activation = visualize_activation( model, layer_idx=conv_layer_indices[l], filter_indices=f) activations.append(activation) # saving activation clip = ImageSequenceClip(list(activation), fps=10).resize(1.0) gif_name = model.layers[conv_layer_indices[ l]].name + "_" + "activation" + str(f) + ".gif" clip.write_gif(gif_folder + gif_name, fps=10) all_activations.append(activations) return all_activations
async def save_gif(gif_frames, dest, fps=10): """生成 gif 将输入的帧数据合并成视频并输出为 gif 参数 gif_frames: list<numpy.ndarray> 为每一帧的数据 dest: str 为输出路径 fps: int, float 为输出 gif 每秒显示的帧数 返回 None 但是会输出一个符合参数的 gif """ clip = ImageSequenceClip(gif_frames, fps=fps) clip.write_gif(dest) # 使用 imageio clip.close()
def save_vol_gif(self, filename, array, fps=10, scale=1.0): """Creates a gif given a stack of images using moviepy Notes ----- works with current Github version of moviepy (not the pip version) https://github.com/Zulko/moviepy/commit/d4c9c37bc88261d8ed8b5d9b7c317d13b2cdf62e Usage ----- >>> X = randn(100, 64, 64) >>> gif('test.gif', X) Parameters ---------- filename : string The filename of the gif to write to array : array_like A numpy array that contains a sequence of images fps : int frames per second (default: 10) scale : float how much to rescale each image by (default: 1.0) """ # ensure that the file has the .gif extension fname, _ = os.path.splitext(filename) filename = fname + '.gif' # Normalize the volume into 0-255 range for .gif file volume_norm = np.zeros_like(array, dtype=np.uint8) for z in range(array.shape[0]): volume_norm[z] = cv2.normalize(array[z], dst=volume_norm[z], alpha=0, beta=255, norm_type=cv2.NORM_MINMAX) volume_norm, array = array, volume_norm del volume_norm # copy into the color dimension if the images are black and white if array.ndim == 3: array = array[..., np.newaxis] * np.ones(3) # make the moviepy clip clip = ImageSequenceClip(list(array), fps=fps).resize(scale) clip.write_gif(filename, fps=fps) return clip
def make_gif(): files = [] for (dirpath, dirnames, filenames) in walk("input"): files.extend(["input/" + x for x in filenames if ".jpg" in x]) image_names = ["output/frame_{}.jpg".format(x) for x in range(len(files))] for i in range(len(files)): im = Image.open(files[i]) im.thumbnail(pic_size, Image.ANTIALIAS) print image_names[i] im.save(image_names[i], quality=100) newName = "result.gif" clip = ImageSequenceClip(image_names, fps=4) clip.write_gif(newName, fuzz=False) for f in image_names: remove(f) print ""
def run(outdir, train_mode): # Build network. initializer = tf.keras.initializers.VarianceScaling() X = tf.placeholder(tf.float32, shape=[None, n_inputs]) hidden = tf.layers.dense( X, N_HIDDEN, activation=tf.nn.elu, kernel_initializer=initializer) logits = tf.layers.dense(hidden, n_outputs) outputs = tf.nn.sigmoid(logits) # probability of action 0 (left) p_left_and_right = tf.concat(axis=1, values=[outputs, 1 - outputs]) action = tf.multinomial(tf.log(p_left_and_right), num_samples=1) # Optimizer, gradients. y = 1. - tf.to_float(action) cross_entropy = tf.nn.sigmoid_cross_entropy_with_logits( labels=y, logits=logits) optimizer = tf.train.AdamOptimizer(LEARNING_RATE) grads_and_vars = optimizer.compute_gradients(cross_entropy) gradients = [grad for grad, variable in grads_and_vars] gradient_placeholders = [] grads_and_vars_feed = [] for grad, variable in grads_and_vars: gradient_placeholder = tf.placeholder(tf.float32, shape=grad.get_shape()) gradient_placeholders.append(gradient_placeholder) grads_and_vars_feed.append((gradient_placeholder, variable)) training_op = optimizer.apply_gradients(grads_and_vars_feed) # For TensorBoard. episode_reward = tf.placeholder(dtype=tf.float32, shape=[]) tf.summary.scalar('reward', episode_reward) init = tf.global_variables_initializer() saver = tf.train.Saver() if train_mode: hp_save_dir = hp_directory(outdir) with tf.Session() as sess: init.run() # For TensorBoard. print('hp_save_dir') train_writer = tf.summary.FileWriter(hp_save_dir, sess.graph) for iteration in range(n_iterations): all_rewards = [] all_gradients = [] for game in range(N_GAMES_PER_UPDATE): current_rewards = [] current_gradients = [] obs = env.reset() for step in range(n_max_steps): action_val, gradients_val = sess.run( [action, gradients], feed_dict={X: obs.reshape(1, n_inputs)}) obs, reward, done, info = env.step(action_val[0][0]) current_rewards.append(reward) current_gradients.append(gradients_val) if done: break all_rewards.append(current_rewards) all_gradients.append(current_gradients) avg_reward = np.mean(([np.sum(r) for r in all_rewards])) print('\rIteration: {}, Reward: {}'.format( iteration, avg_reward, end='')) all_rewards = discount_and_normalize_rewards( all_rewards, discount_rate=DISCOUNT_RATE) feed_dict = {} for var_index, gradient_placeholder in enumerate(gradient_placeholders): mean_gradients = np.mean([ reward * all_gradients[game_index][step][var_index] for game_index, rewards in enumerate(all_rewards) for step, reward in enumerate(rewards) ], axis=0) feed_dict[gradient_placeholder] = mean_gradients sess.run(training_op, feed_dict=feed_dict) if iteration % save_iterations == 0: print('Saving model to ', hp_save_dir) model_file = '{}/my_policy_net_pg.ckpt'.format(hp_save_dir) saver.save(sess, model_file) # Also save event files for TB. merge = tf.summary.merge_all() summary = sess.run(merge, feed_dict={episode_reward: avg_reward}) train_writer.add_summary(summary, iteration) obs = env.reset() steps = [] done = False else: # Make a gif. from moviepy.editor import ImageSequenceClip model_file = '{}/my_policy_net_pg.ckpt'.format(outdir) with tf.Session() as sess: sess.run(tf.global_variables_initializer()) saver.restore(sess, save_path=model_file) # Run model. obs = env.reset() done = False steps = [] rewards = [] while not done: s = env.render('rgb_array') steps.append(s) action_val = sess.run(action, feed_dict={X: obs.reshape(1, n_inputs)}) obs, reward, done, info = env.step(action_val[0][0]) rewards.append(reward) print('Final reward :', np.mean(rewards)) clip = ImageSequenceClip(steps, fps=30) clip.write_gif('cartpole.gif', fps=30)
print pol.shape (timestamps, x_pos, y_pos, pol) = dvsproc.clean_up_events(timestamps, x_pos, y_pos, pol, window=1000) frames, fs, _ = dvsproc.gen_dvs_frames(timestamps, x_pos, y_pos, pol, num_frames, fs=3) print "Length of produced frames: ", len(frames) new_frames = [] for frame in frames: tmp_frame = (((frame+fs)/float(2*fs))*255).astype(np.uint8) new_frames.append(tmp_frame) clip = ImageSequenceClip(new_frames, fps=20) clip.write_gif(seq_save_path, fps=30) print "Sequence %s is saved at %s" % (img_name, seq_save_path) elif option == "caltech256-ps": caltech_fn = "INI_Caltech256_10fps_20160424.hdf5" caltech_path = os.path.join(data_path, caltech_fn) caltech_db = h5py.File(caltech_path, mode="r") caltech_stats_path = os.path.join(stats_path, "caltech256_stats.pkl") caltech_save_path = os.path.join(data_path, "caltech256_ps.eps") img_num = 60 f = file(caltech_stats_path, mode="r") caltech_stats = pickle.load(f) f.close() caltech_list = caltech_stats["caltech256_list"]
video_save_path = join(data_path, "retina-simulation", "horse-riding.gif") parvo_save_path = join(data_path, "retina-simulation", "horse-riding-parvo.gif") magno_save_path = join(data_path, "retina-simulation", "horse-riding-magno.gif") parvo_frames = [] magno_frames = [] origin_frames = [] for frame in frames: retina.run(frame) origin_frames.append(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)) parvo_frame = retina.getParvo() parvo_frame = cv2.cvtColor(parvo_frame, cv2.COLOR_BGR2RGB) parvo_frames.append(parvo_frame) magno_frames.append(retina.getMagno()) clip = ImageSequenceClip(parvo_frames, fps=30) clip.write_gif(parvo_save_path, fps=30) print "[MESSAGE] Parvo frames is saved at: %s" % (parvo_save_path) clip = ImageSequenceClip(magno_frames, fps=30) clip.write_gif(magno_save_path, fps=30) print "[MESSAGE] Magno frames is saved at: %s" % (magno_save_path) clip = ImageSequenceClip(origin_frames, fps=30) clip.write_gif(video_save_path, fps=30) print "[MESSAGE] Original frames is saved at: %s" % (video_save_path)