def plot_contour_ani(x, y, z, xl=r"$X$", yl=r"$Y$", steps=100, fn="test.mp4"): metadata = dict(title='Movie Test', artist='Matplotlib', comment='Movie support!') writer = FFMpegWriter(fps=15, metadata=metadata) xx, yy = np.meshgrid(x, y) fig = plt.figure() plt.xlabel(xl) plt.ylabel(yl) plt.contourf(xx, yy, z[0, :, :].T, cmap='seismic', levels=np.linspace(-1.0, 1.0, 32), extend='both') cb = plt.colorbar() cb.set_ticks([-1, -0.8, -0.6, -0.4, 0.2, 0.0, 0.2, 0.4, 0.6, 0.8, 1.0]) cb.set_label(r'$\zeta$', rotation=0) with writer.saving(fig, fn, 100): for i in range(steps): if i % 10 == 0: plt.contourf(xx, yy, z[i, :, :].T, cmap='seismic', levels=np.linspace(-1.0, 1.0, 32), extend='both') plt.title('t = {0:.1f} s'.format(i * 0.1)) print("i = ", i) writer.grab_frame() plt.close()
def save_history_as_video_file(x, n_components, history, save_video_file): fig, ax = plt.subplots(1, 1, figsize=(8, 8)) ax.set_xlim(-2.0, 2.0) ax.set_ylim(-2.0, 2.0) def animate(t): nonlocal history, ax ax.clear() colors = list(BASE_COLORS)[:n_components] plot_gmm_confidence_ellipses(ax, history[t]['mean'], history[t]['cov'], colors=colors) plot_data_samples(ax, x, history[t]['gamma'], colors=colors) ax.set_title('iteration = {:02d}, log_likelihood = {:.3f}'.format( t, history[t]['log_likelihood'])) return ax, writer = FFMpegWriter(fps=1) with writer.saving(fig, save_video_file, dpi=100): for t in range(len(history)): animate(t) writer.grab_frame()
def movie(self, variables=None, InOut=0.0, plotgroup=None, saveName='movie.mp4', resolution=10, figsize=(15, 8)): metadata = dict(title=self.meas_type, artist='Matplotlib', comment='') writer = FFMpegWriter(fps=15, metadata=metadata) fig = plt.figure(figsize=figsize) subset = self.GetDataSubset(inout=InOut, plotGroup=plotgroup) length = subset['Amp'].values.shape[1] limits = self.varlimits(variables=variables, InOut=InOut, plotgroup=plotgroup) with writer.saving(fig, saveName, 100): for k in np.arange(0, length, int(length / resolution)): # Create a new plot object self.imslice(variables=variables, sliceNum=k, InOut=InOut, plotgroup=plotgroup, limits=limits) writer.grab_frame()
def main(): power = int(sys.argv[1]) height = 2**power width = int(height**0.5) sandpile = np.zeros((width, width), dtype=np.uint32) sandpile[width // 2, width // 2] = height my_cmap = colors.ListedColormap(["white", "green", "purple", "gold"]) bounds = [-1, 0.5, 1.5, 2.5, 3.5] norm = colors.BoundaryNorm(bounds, my_cmap.N) writer = FFMpegWriter(fps=15, metadata={ "title": "Abelian Sand", "artist": "Matplotlib" }) fig, ax = plt.subplots() plt.axis("off") fig.subplots_adjust(left=0, bottom=0, right=1, top=1, wspace=None, hspace=None) im = ax.imshow(sandpile, cmap=my_cmap, norm=norm) min_height = np.max(sandpile) with writer.saving(fig, f"sand-{power}.mp4", dpi=100): for i, _ in enumerate(apply_gravity(sandpile)): im.set_data(sandpile) min_height = min(min_height, np.max(sandpile)) im.set_clim(0, 4) # min_height) writer.grab_frame() np.save(f"video/frame-{power}-{i:09d}", sandpile) np.save(f"sand-{power}", sandpile) plt.imsave(f"sand-{power}.png", sandpile, cmap=my_cmap)
def write_movie(pose_array, name='writer_test.mp4', fps=15, r_base=1000, color_shift_at=0, title=None): """ Write a movie of ground truth and predicted outputs. :param pose_array: np.array [joints, 3dpoints, time] :param name: the name for the movie. """ time = pose_array.shape[-1] metadata = dict(title='Movie Test', artist='Matplotlib', comment='Movie support!') writer = FFMpegWriter(fps=fps, metadata=metadata) fig = plt.figure() with writer.saving(fig, name, 100): ax = fig.add_subplot(111, projection='3d') gt_plotter = viz.Ax3DPose(ax, 'Human36', title=title) net_plotter = viz.Ax3DPose(ax, 'Human36', lcolor='#e88d1e', rcolor='#3ce7ae', title=title) net_plotter.axes_set = True for i in range(time): if i > color_shift_at: net_plotter.update(pose_array[:, :, i].flatten(), r_base=r_base) else: gt_plotter.update(pose_array[:, :, i].flatten(), r_base=r_base) writer.grab_frame() plt.close()
def main(): parser = ArgumentParser() parser.add_argument('--n_particles', type=int, default=50) parser.add_argument('--animation_command', type=str, default='show', choices=('show', 'save')) args = parser.parse_args() n_states = 1 transition_model = GaussianTransitionModel(np.eye(n_states), np.eye(n_states)) observation_model = GaussianObservationModel(np.eye(n_states), np.eye(n_states)) particle_filter = MonteCarloFilter(args.n_particles, n_states, transition_model, observation_model) sim = ToySimulator(particle_filter) if args.animation_command == 'show': ani = FuncAnimation(sim.fig, sim.update) plt.show() return elif args.animation_command == 'save': n_steps = 50 video_file_name = 'monte_carlo_filter_example' extensions = ['.mp4', '.h264'] for ext in extensions: writer = FFMpegWriter() with writer.saving(sim.fig, video_file_name + ext, dpi=100): for t in range(n_steps): sim.update(t) writer.grab_frame()
def start(self, saved=False, filename="visual.mp4"): fig = plt.figure() ax = fig.add_subplot(projection='3d') ax.view_init(60, 48) self.draw_func(ax, self.line_count, self.point_count) pointer, = ax.plot3D([], [], marker="8", linestyle='None', markersize=2, color='red') def init(): pointer.set_data([], []) return pointer, def update(fishes): x = np.array([fish.get("pos")[0] for fish in fishes], dtype=np.core.float64) y = np.array([fish.get("pos")[1] for fish in fishes], dtype=np.core.float64) z = np.array([fish.get("fitness_value") for fish in fishes], dtype=np.core.float64) pointer.set_data_3d(x, y, z) return pointer, if not saved: ani = FuncAnimation(fig, update, frames=self.history.get("steps"), init_func=init, blit=True, interval=self.timeout) plt.show() else: metadata = dict(title='Visualization', artist='Matplotlib', comment='') movie_writer = FFMpegWriter(fps=5, metadata=metadata) with movie_writer.saving(fig, outfile=filename, dpi=800): for step in self.history.get("steps"): update(step) movie_writer.grab_frame()
class VideoWriter(object): def __init__(self, frame_rate, bit_rate=None, dots_per_inch=200, figure=None, axes=None, axis=True, verbose=True, **kwargs): self.fps = kwargs.get('fps', None) if self.fps is None: self.fps = frame_rate kwargs['fps'] = self.fps if 'bitrate' not in kwargs: kwargs['bitrate'] = bit_rate self.grab = FFMpegWriter( **{kw: arg for kw, arg in kwargs.items() if arg is not None}) self.finally_close = False if figure is None: if axes is None: # always import pyplot as late as possible to allow for backend selection import matplotlib.pyplot as plt figure, axes = plt.subplots() self.finally_close = True else: figure = axes.get_figure() elif axes is None: axes = figure.gca() if axis in (False, 'off'): axes.set_axis_off() self.dpi = dots_per_inch self.figure = figure self.axes = axes self.verbose = verbose def saving(self, output_file): output_file = os.path.expanduser(output_file) if self.verbose and os.path.exists( output_file) and 0 < os.path.getsize(output_file): answer = input("overwrite file '{}': [N/y] ".format(output_file)) if not (answer and answer[0].lower() == 'y'): raise Aborted return self.grab.saving(self.figure, output_file, self.dpi) def range(self, N): trange = range if self.verbose: try: import tqdm except ImportError: pass else: trange = tqdm.trange return trange(int(N)) def grab_frame(self, *args, **kwargs): self.grab.grab_frame(*args, **kwargs)
def main(): parser = ArgumentParser() parser.add_argument('--n_particles', type=int, default=50) parser.add_argument('--animation_command', type=str, default='show', choices=('show', 'save')) args = parser.parse_args() n_states = 1 transition_model = GaussianTransitionModel(np.eye(n_states), np.eye(n_states)) observation_model = GaussianObservationModel(np.eye(n_states), np.eye(n_states)) particle_filter = MonteCarloFilter(args.n_particles, n_states, transition_model, observation_model) sim = ToySimulator(particle_filter) if args.animation_command == 'show': ani = FuncAnimation(sim.fig, sim.update) plt.show() return elif args.animation_command == 'save': n_steps = 50 video_file_name = 'monte_carlo_filter_example' extensions = ['.mp4', '.h264'] for ext in extensions: writer = FFMpegWriter() with writer.saving(sim.fig, video_file_name + ext, dpi=100): for t in range(n_steps): sim.update(t) writer.grab_frame()
def exportDistributionSweep(distributions, fps=30, dpi=100, path=None): """ Creates (and plays) a video of a sequence of distributions on the simplex. Parameters ---------- distributions: an iterable containing the different distributions passed to the plot function fps: framerate of the video dpi: resolution of the video path: path to the video. If 'None', a temporary file is used. """ # create temporary file if path is None: _, path = tempfile.mkstemp(suffix='.mp4') # create writer object and export frames to video writer = FFMpegWriter(fps=fps) fig = plt.figure() with writer.saving(fig, path, dpi=dpi): for param in distributions: fig.clear() plot(param) writer.grab_frame() # show video os.system('open ' + path)
def plot(self, measures_summary): os.makedirs('plots/', exist_ok=True) measures = measures_summary['measures_all_runs'] activations_summary = measures_summary['activations_summary'] self.get_specifications(measures) plt.set_cmap("hsv") fig, (ax_infoplane, ax_accuracy) = plt.subplots( 2, 1, figsize=(6, 9), gridspec_kw={'height_ratios': [2, 1]}) acc = [] val_acc = [] scatter, text = self.setup_infoplane_subplot(ax_infoplane) acc_line, val_acc_line = self.setup_accuracy_subplot(ax_accuracy) writer = FFMpegWriter(fps=7) with writer.saving(fig, self.filename, 600): for epoch_number, mi_epoch in measures.groupby(level=0): # Drop outer index level corresponding to the epoch. mi_epoch.index = mi_epoch.index.droplevel() scatter = self.fill_infoplane_subplot(scatter, mi_epoch) text.set_text(f'Epoch: {epoch_number}') acc, val_acc, acc_line, val_acc_line = self.fill_accuracy_subplot( acc_line, val_acc_line, activations_summary, epoch_number, acc, val_acc) writer.grab_frame()
def ianimate(df, autoscale=True, ax=None, axis=0, filename=None, fps=5, kind=None, n=None, rx=None, ry=None, step=1, title=None): """ ianimate. Animate plots, output to jupyter notebook. :param df: pandas dataframe :param autoscale: bool, if True will adjust the scale as data is processed, else will pre-render full scale :param ax: matplotlib ax :param axis: 0 or 1 for horizontal or vertical data :param filename: file name to save the mp4 file to :param fps: frames per second - defaults to 5 :param kind: pandas plot kind :param n: frame to render :param rx: remove x axis :param ry: remove y axis :param step: how many steps between frames :param title: optional, title for the plot :return: HTML video control widget for jupyter notebook """ if ax is None: fig, ax = plt.subplots() else: fig = ax.get_fig() if filename is None: filename = 'tmp.mp4' if n is None: n = df.shape[0] moviewriter = FFMpegWriter(fps=fps) with moviewriter.saving(fig, filename, dpi=100): for j in range(1, n, step): update_figure(df, n=j, ax=ax, axis=axis, autoscale=autoscale, kind=kind, rx=rx, ry=ry, title=title) moviewriter.grab_frame() return HTML(""" <video width="640" height="480" controls loop> <source src="{}" type="video/mp4"> </video> """.format(filename))
def make_movie(fig, plot_fn, param_list, output='output.mp4'): from matplotlib.animation import FFMpegWriter writer = FFMpegWriter(fps=60) with writer.saving(fig, output, dpi=200): for n, param in enumerate(param_list): print(f'frame {n} / {len(param_list)}') plot_fn(fig, param) writer.grab_frame() fig.clf() print(f'writing {output}')
def make_movie(fig, directories, output, plot_function, **kwargs): filename_lists = [directory_contents(d) for d in directories] writer = FFMpegWriter(fps=10) with writer.saving(fig, output, dpi=200): for filename_list in zip(*filename_lists): print(list(filename_list)) plot_function(fig, filename_list, **kwargs) writer.grab_frame() fig.clf()
def createVideo(hdf, videoIn, videoOut, minDuration, maxDuration): df = pd.read_hdf(hdf) if len(df) > minDuration - 1: scorer = df.columns.get_level_values(0)[0] bptsToPlot = [ 'proboscis1', 'proboscis2', 'head', 'thorax', 'abdomenC', 'abdomenR', 'abdomenL', 'bottom', 'rightForeLeg1', 'rightForeLeg2', 'rightForeLeg3', 'leftForeLeg1', 'leftForeLeg2', 'leftForeLeg3', 'rightMidleg1', 'rightMidleg2', 'rightMidleg3', 'leftMidleg1', 'leftMidleg2', 'leftMidleg3', 'rightHindleg1', 'rightHindleg2', 'rightHindleg3', 'leftHindleg1', 'leftHindleg2', 'leftHindleg3' ] cmap = mpl.cm.get_cmap('plasma', len(bptsToPlot) + 2) start = df.first_valid_index() stop = df.last_valid_index() if stop - start > maxDuration: stop = start + maxDuration cap = cv2.VideoCapture(videoIn) fps = cap.get(cv2.CAP_PROP_FPS) cap.set(1, start) ret, frame = cap.read() (h, w) = frame.shape[:2] dpi = 100 writer = FFMpegWriter(fps=fps, codec='h264') fig = plt.figure(frameon=False, figsize=(w / dpi, h / dpi)) plt.set_cmap('plasma') with writer.saving(fig, videoOut, dpi=dpi): for i in tqdm(range(start, stop)): cap.set(1, i) ret, frame = cap.read() plt.imshow(frame) j = 0 for ind in df.columns.get_level_values(1).unique(): for bp in bptsToPlot: plt.scatter(df[scorer, ind, bp].x[i], df[scorer, ind, bp].y[i], color=cmap(j), alpha=0.75) j += 1 plt.axis('off') plt.subplots_adjust(left=0, bottom=0, right=1, top=1, wspace=0, hspace=0) writer.grab_frame() plt.clf() plt.close(fig)
def tweening(df, filename, autoscale=True, axis=0, fps=5, kind=None, rx=None, ry=None, step=1, title=None, transitions=10): """ tweening. :param df: pandas dataframe, required :param filename: file name to save the mp4 file to, required :param autoscale: bool, if True will adjust the scale as data is processed, else will pre-render full scale :param axis: 0 or 1 for horizontal or vertical data :param fps: frames per second - defaults to 5 :param kind: pandas plot kind :param rx: remove x axis :param ry: remove y axis :param step: how many steps between frames :param title: optional, title for the plot :param transitions: how many interimary values to generate :return: HTML video control widget for jupyter notebook """ fig, ax = plt.subplots() nb_data_points = df.shape[0] moviewriter = FFMpegWriter(fps=fps) grayed = num_only(df) with moviewriter.saving(fig, filename, dpi=100): for j in range(0, nb_data_points - 1, step): dfj = df.iloc[j:] df_expanded = between_rows(dfj, n=transitions) for i in range(transitions): update_figure(df_expanded, n=i, ax=ax, axis=axis, autoscale=autoscale, grayed=grayed, j=j, kind=kind, rx=rx, ry=ry, title=title) moviewriter.grab_frame() return HTML(""" <video width="640" height="480" controls loop> <source src="{}" type="video/mp4"> </video> """.format(filename))
def slice_vid(as_, points, slicer=_slicer3, iters=7, fname="slices of 3d.mp4"): '''Generate a 3D slicing video''' writer = FFMpegWriter(fps=4) fig = plt.figure() with writer.saving(fig, fname, 144): for a in as_: slice_ = slicer(points, iters, a) plt.imshow(slice_, cmap='inferno') plt.clim(0, iters - 1) plt.title(f"$\\Re(z) = {a}$") writer.grab_frame() plt.clf() print("\a")
def make_movie(fig, plot_fn, args): from matplotlib.animation import FFMpegWriter writer = FFMpegWriter(fps=15) with writer.saving(fig, 'output.mp4', dpi=200): for filename in args.filenames: print(filename) plot_fn(fig, filename, args) writer.grab_frame() fig.clf() print('writing', 'output.mp4')
def make_movie(filename): with h5py.File(filename, "r") as f: positions_t = np.array(f["positions_t"]) theta_t = np.array(f["theta_t"]) U_t = np.array(f["U_t"]) alpha = np.array(f["alpha"]) area_n = np.array(f["area_n"])[0] nrecord = np.array(f["nrecord"])[0] dt = np.array(f["dt"])[0] fbase = os.path.splitext(filename)[0] metadata = dict(title=fbase) writer = FFMpegWriter(fps=30, metadata=metadata) fig = plt.figure(figsize=[6.4, 6.4], dpi=100) with writer.saving(fig, fbase + ".mp4", 100): for i in range(0, positions_t.shape[0]): positions = positions_t[i, :, :] thetas = theta_t[i, :] U_n = U_t[i, :] normals = np.vstack([-np.sin(thetas), np.cos(thetas)]).T plt.plot( np.sqrt(area_n / np.pi) * np.hstack([np.cos(alpha), np.cos(alpha[0])]), np.sqrt(area_n / np.pi) * np.hstack([np.sin(alpha), np.sin(alpha[0])]), color="red", ) plt.plot( np.hstack([positions[:, 0], positions[:, 0]]), np.hstack([positions[:, 1], positions[:, 1]]), color="blue", ) plt.quiver( positions[:, 0], positions[:, 1], U_n * normals[:, 0], U_n * normals[:, 1], scale=2.5, color="blue", headwidth=1.5, headlength=2.5, ) plt.xlim([-1.2, 1.2]) plt.ylim([-1.2, 1.2]) writer.grab_frame() plt.cla()
def make_movie_impl(args, plot_fn, figsize=[16, 6]): from matplotlib.animation import FFMpegWriter dpi = 200 res = 768 writer = FFMpegWriter(fps=10) fig = plt.figure(figsize=figsize) with writer.saving(fig, args.output, dpi): for filename in args.filenames: print(filename) fig = plot_fn(fig, filename, edges=args.edges, depth=args.depth, **get_ranges(args)) writer.grab_frame() fig.clf()
def writevideo(self): #print animation.writers.list() #matplotlib.rcParams['animation.ffmpeg_args'] = ['-report', '/tmp/ffmpeg.log'] #FFMpegWriter = animation.writers['ffmpeg'] metadata = dict(title='Github Data Projects', artist='0x0FFF', comment='Evolution of open source data projects') writer = FFMpegWriter(fps=30, bitrate=8000, metadata=metadata) i = 0 #self.iters = 200 with writer.saving(self.fig, "/projects/personal/writer_test.mp4", 120): while i < self.iters: self.update_animation(i) writer.grab_frame() i += 1 return
def plot_accuracy_development(history, _run): fig, ax = plt.subplots() writer = FFMpegWriter(fps=1) filename = "accuracy_movie.mp4" with writer.saving(fig, filename, 600): accuracy = history.history["accuracy"] x = list(range(1, len(accuracy) + 1)) y = accuracy ax.set(xlim=[0.9, len(accuracy) + 0.1], ylim=[0, 1], xlabel="epoch", ylabel="accuracy") [acc_line] = ax.plot(x, y, "o-") for i in range(1, len(accuracy) + 1): acc_line.set_data(x[:i], y[:i]) writer.grab_frame() _run.add_artifact(filename=filename, name="accuracy_movie")
def make_movie(args): from matplotlib.animation import FFMpegWriter figsize = [15, 8] dpi = 200 res = 768 writer = FFMpegWriter(fps=10) fig = plt.figure(figsize=figsize) with writer.saving(fig, args.output, dpi): for filename in args.filenames: print(filename) # plot_single_file(args, fig, filename) plot_radial_profile(args, fig, filename) writer.grab_frame() fig.clf()
def writevideo(self): #print animation.writers.list() #matplotlib.rcParams['animation.ffmpeg_args'] = ['-report', '/tmp/ffmpeg.log'] #FFMpegWriter = animation.writers['ffmpeg'] metadata = dict(title='Github Data Projects', artist='0x0FFF', comment='Evolution of open source data projects') writer = FFMpegWriter(fps=30, bitrate=8000, metadata=metadata ) i = 0 #self.iters = 200 with writer.saving(self.fig, "/projects/personal/writer_test.mp4", 120): while i < self.iters: self.update_animation(i) writer.grab_frame() i += 1 return
def write_frames_from_log(self, logfile): stuff = np.load(logfile) filename = str(stuff['name']) + '.mp4' self.visualizer = Visualizer(int(stuff['ego_id']), stuff['LengthWidth'][:, 0], stuff['LengthWidth'][:, 1], int(stuff['num_cars']), self.road) metadata = dict(title=str(stuff['name']), artist='Pseudo', comment='') writer = FFMpegWriter(fps=2 * int(1. / Vehicle.DEL_T), codec='libx264', metadata=metadata, extra_args=['-pix_fmt', 'yuv420p']) with writer.saving(self.visualizer.fig, filename, self.visualizer.fig.dpi): for state in stuff['State_record']: self.visualizer.update(state[:, :3]) writer.grab_frame() Scenario.flip_video(filename)
def make_video_animation(num_frames, animation_function, output_name, fps=30): """ fps: int frames per second for output video. animation_function: function that returs a frame given an index j. """ metadata = dict(title='Movie Test', artist='IA', comment='A.I. Dance Autotune') writer = FFMpegWriter(fps=fps, metadata=metadata) with writer.saving(fig, output_name + '.mp4', dpi=100): for j in tqdm(range(num_frames)): animation_function(j) writer.grab_frame() torch.cuda.empty_cache()
def main(): parser = ArgumentParser() # SVC hyper-parameters parser.add_argument('--C', type=float, default=10.0) parser.add_argument('--kernel', type=str, default='rbf', choices=('linear', 'rbf')) parser.add_argument('--gamma', type=str, default='auto') # toy data config parser.add_argument('--n_samples_per_label', type=int, default=10) parser.add_argument('--seed', type=int, default=0) # Animation config parser.add_argument('--animation_command', type=str, default='save', choices=('show', 'save')) parser.add_argument('--out_video_name', type=str, default='svc_smo.mp4') args = parser.parse_args() x, y = get_toy_data(n_features=2, n_samples_per_label=args.n_samples_per_label, seed=args.seed) clf = SVC(args.C, args.kernel, args.gamma) ani = SVCAnimator(clf, x, y) if args.animation_command == 'show': animation = FuncAnimation(ani.fig, ani.update) plt.show() return if args.animation_command == 'save': writer = FFMpegWriter() with writer.saving(ani.fig, args.out_video_name, dpi=100): t = 0 while True: t += 1 print(t) ani.update(t) writer.grab_frame() if ani.convergence: break
def animate(self, index, substance, time_idx): """create an mp4 movie for the substance for all time_idxteps (t)""" writer = FFMpegWriter(fps=15) assert (self.grids[index] != []), "No grids defined" substances = self.grids[index]['nc_file'].variables.keys() assert substance in substances, "Substance name not in: " + str( substances) lat = self.grids[index]['lat'][:] lon = self.grids[index]['lon'][:] # read variable substance from the file and get the array for depth_idx == 0 substance_arr = self.grids[index]['nc_file'].variables[substance][ time_idx, 0, :, :] img_info = self.create_image(lat, lon, substance_arr[0]) with writer.saving(img_info['fig'], "%s.mp4" % (substance, ), 100): for idx in range(len(time_idx)): img_info['pcolor'].set_array( substance_arr[idx, :-1, :-1].ravel()) writer.grab_frame()
def main(): parser = ArgumentParser() parser.add_argument('--animation_command', type=str, default='show', choices=('show', 'save')) args = parser.parse_args() gen = _data_generator(np.zeros(2), [2.2, 0.5], np.eye(2)) kf = build_kf() sim = _ToySimulator(kf, gen) if args.animation_command == 'show': ani = FuncAnimation(sim.fig, sim.update) plt.show() elif args.animation_command == 'save': n_steps = 50 video_file_name = 'kf.mp4' writer = FFMpegWriter() with writer.saving(sim.fig, video_file_name, dpi=100): for t in range(n_steps): sim.update(t) writer.grab_frame()
def main(): parser = ArgumentParser() # SVC hyper-parameters parser.add_argument('--C', type=float, default=10.0) parser.add_argument('--kernel', type=str, default='rbf', choices=('linear', 'rbf')) parser.add_argument('--gamma', type=str, default='auto') # toy data config parser.add_argument('--n_samples_per_label', type=int, default=10) parser.add_argument('--seed', type=int, default=0) # Animation config parser.add_argument('--animation_command', type=str, default='save', choices=('show', 'save')) parser.add_argument('--out_video_name', type=str, default='svc_smo.mp4') args = parser.parse_args() x, y = get_toy_data(n_features=2, n_samples_per_label=args.n_samples_per_label, seed=args.seed) clf = SVC(args.C, args.kernel, args.gamma) ani = SVCAnimator(clf, x, y) if args.animation_command == 'show': animation = FuncAnimation(ani.fig, ani.update) plt.show() return if args.animation_command == 'save': writer = FFMpegWriter() with writer.saving(ani.fig, args.out_video_name, dpi=100): t = 0 while True: t += 1 print(t) ani.update(t) writer.grab_frame() if ani.convergence: break
def run_agent(num_timesteps, record=False, title="recording_test.mp4"): done = False _ = env.reset() if record: print("recording a test run . . . ") fig = plt.figure() metadata = dict(title='Movie Test', artist='Matplotlib', comment='Movie support!') writer = FFMpegWriter(fps=15, metadata=metadata) with writer.saving(fig, title, 100): for i in range(num_timesteps): current_state = env.last_obs / 255 action = int(q_func.get_best_action(current_state)) obs, reward, done, _ = env.step(action) #next_state = obs/255 #experience_replay.put((current_state, action, reward, next_state, done)) plt.imshow(obs) writer.grab_frame() env.render(record=record) #i += 1 if done: _ = env.reset() else: for i in range(num_timesteps): current_state = env.last_obs / 255 action = int(q_func.get_best_action(current_state)) obs, reward, done, _ = env.step(action) next_state = obs / 255 try: experience_replay.put( (current_state, action, reward, next_state, done)) except queue.Full as e: import pdb pdb.set_trace() env.render(record=record) #i += 1 if done: _ = env.reset()
class TwoDPlotter: #TODO: Track real time between plots and maybe also loss? def __init__(self, x, y, saving=False): plt.ion() self.fig = plt.figure() self.real_ax = self.fig.subplots() self.real_ax.grid('both') plt.show() new_x = [i['x'] for i in x] self.real_ax.scatter(new_x,y, c='red', label='Training Data') self.points = self.real_ax.scatter([],[], c='green', label='Neural Net') self.fig.legend() self.cache = self.fig.canvas.copy_from_bbox(self.fig.bbox) self.fig.canvas.draw() self.saving = False if saving: self.writer = FFMpegWriter(fps=1) self.saving = True def __call__(self, new_x, new_y): new_x = [i['x'] for i in new_x] offsets = list(zip(new_x, new_y)) self.points.set_offsets(offsets) self.update_blit() if self.saving: self.writer.grab_frame() def update_blit(self): self.fig.canvas.restore_region(self.cache) self.real_ax.draw_artist(self.points) self.fig.canvas.blit(self.fig.bbox) def save(self, filepath): if self.saving: return self.writer.saving(self.fig, filepath, 300) else: raise ValueError("Cannot save a plotter not configured to save")
def plot(self, measures_summary): measures = measures_summary['measures_all_runs'] os.makedirs('plots/', exist_ok=True) plt.set_cmap("hsv") fig, ax = plt.subplots() if self.dataset == 'datasets.mnist' or self.dataset == 'datasets.fashion_mnist': ax.set(xlim=[0, 14], ylim=[0, 3.5]) else: ax.set(xlim=[0, 12], ylim=[0, 1]) ax.set(xlabel='I(X;M)', ylabel='I(Y;M)') scatter = ax.scatter([], [], s=20, edgecolor='none') text = ax.text(0, 1.05, "", fontsize=12) num_layers = measures.index.get_level_values(1).nunique() layers_colors = np.linspace(0, 1, num_layers) writer = FFMpegWriter(fps=10) with writer.saving(fig, self.filename, 600): for epoch_number, mi_epoch in measures.groupby(level=0): # Drop outer index level corresponding to the epoch. mi_epoch.index = mi_epoch.index.droplevel() xmvals = mi_epoch['MI_XM'] ymvals = mi_epoch['MI_YM'] points = np.array([xmvals, ymvals]).transpose() colors = layers_colors[mi_epoch.index] scatter.set_offsets(points) scatter.set_array(colors) text.set_text(f"Epoch: {epoch_number}") writer.grab_frame()
def animate_movie(db_fn: str, graph_movie_fn: str): # db_fn = r"E:\Simulations\CeramicBands\v7\pics\8X\history.db" movie_writer = ThisWriter(fps=30) sub_graph_flags = SubGraphs(force_disp=True, surface_absolute=False, surface_deviation=True, columns_strain_x=True) fig, sub_graphs = create_subplots(sub_graph_flags) # fig.tight_layout() with movie_writer.saving(fig, graph_movie_fn, dpi=DPI_FIG): with history.DB(db_fn) as hist: top_nodes = _node_of_top_line(hist) if not top_nodes: # Empty DB - get out of here. return lims = get_limits_graphs(hist, top_nodes, sub_graphs) for db_res_case in sorted(hist.get_all(history.ResultCase)): print(db_res_case) graphed_something = compose_graphs(hist, top_nodes, db_res_case.num, sub_graphs) # Set any global limits which have been assigned for ax in sub_graphs: if ax and ax in lims: x_lims, y_lims = lims[ax] ax.set_xlim(x_lims) ax.set_ylim(y_lims) fig.canvas.draw() fig.canvas.flush_events() if graphed_something: movie_writer.grab_frame()