def animate(self, zs, time_range=[None], max_frames=75, image_width=7, fps=15, filename=None): print("Rendering animation ...", file=sys.stderr) fig, space_step, Q, P, T, scatter_scale = self.plot(0, zs, image_width=image_width, show_plot=False) if not hasattr(zs, "__iter__"): zs = [zs] time_slice = slice(*time_range) data = self.datas[time_slice] time_step = (len(data) + max_frames - 1 ) // max_frames if max_frames > 0 else 1 data = data[::time_step] times = self.times[time_slice][::time_step] steps = len(data) with progressbar.ProgressBar(max_value=steps) as bar: def do_steps(i): for j, z in enumerate(zs): mx, my, mz = data[i][:,::space_step,::space_step,z] Q[j].set_UVC(mx, my) P[j].set_array(mz.reshape(-1)) P[j].set_sizes(mz.reshape(-1) ** 2 * scatter_scale) T[j].set_text(r"$z = {:3.2e}$ m, $t={:3.2e} $s".format(z * self.lengths[2] / self.dims[2], times[i])) bar.update(i + 1) return Q, anim = animation.FuncAnimation(fig, do_steps, range(steps), interval=1000/fps) if not filename is None: anim.save(filename, fps=fps) plt.close() display(Video(filename)) else: plt.close() display(anim)
def notebook_video(video): """Display IPython Video object in the notebook :param video: path to the video file """ if video: display(Video(video))
def create_video(self, genome, config, fout="./out.mp4", fps=30, quality=7, render=False, i_seed=0): net = self.make_net(genome, config) env = gym.make(self._env_name) if i_seed is not None: env.seed(self._seed[i_seed]) state = env.reset() done = False imgs = [] while not done: if render: env.render() action = self.activate_net(net, state) state, _, done, _ = env.step(action) imgs.append(state) env.close() with warnings.catch_warnings(): warnings.simplefilter("ignore") imageio.mimwrite(fout, imgs, fps=fps, quality=quality) return Video(fout)
def show_simple_run(x0, ca, num_steps=20, batch=0, only_alive_cells=False, white_background=False): x = x0 with VideoWriter("_autoplay.mp4") as vid: for i in range(num_steps): x = ca(x) if only_alive_cells: res = utils.zoom( (x[batch, :, :, 3].numpy() > 0.1).astype(np.float32)) vid.add(res) else: vid.add( utils.zoom( rgba_to_rgb(ca.classify(x)[batch], white_background=white_background))) run = Video("./_autoplay.mp4", width=320, height=220, html_attributes="autoplay controls", embed=True) return run
def _repr_html_(self): """TODO: codec""" from IPython.display import Video embed = True if urlparse(self.uri).scheme.lower().startswith("http"): embed = False return Video(self.uri, embed=embed, width=480, height=320)._repr_html_()
def make_training_video(folder_dir): files = sorted([ os.path.join(folder_dir, f) for f in os.listdir(folder_dir) if f.endswith('.png') ]) frames = [mpy.ImageClip(f).set_duration(1) for f in files] clip = mpy.concatenate_videoclips(frames, method="compose") clip.write_videofile("movie.mp4", fps=15) return Video("movie.mp4")
def save_video(video_frames, video_preds, fps, output_path): ani = animated_landmarks(video_frames, video_preds, fps=fps) Writer = animation.writers['ffmpeg'] writer = Writer(fps=fps, metadata=dict(artist='StanfordFacialNerveCenter')) print(f'output video: {output_path}') ani.save(output_path, writer=writer) return Video(output_path)
def displayCanvas(self, canvas, filename=None, width="100%", loop=True, autoplay=True, controls=True, center=False): """ displayCanvas """ if canvas is None: return None if self.animation == 'none': # # Just create a frame from the last state and display it # AnimationDisabledError = "Note: Canvas animation has been disabled - showing final frame" im = canvas.getLastFrame(AnimationDisabledError) display(im) return if self.animation == 'spacetime': # # Get the spacetime diagrams # print("Spacetime") for image in canvas.getLastFrame(): display(image) return if filename is None: basename = Path(self._random_string(10) + ".mp4") filename = self.tmpdir / basename posix_filename = filename.as_posix() canvas.saveMovie(posix_filename) # TBD: Actually pay attention to width and centering final_width = "" if width is None else " width=\"{0}\"".format(width) final_center = "" if not center else " style=\"display:block; margin: 0 auto;\"" final_loop = "" if not loop else " loop" final_autoplay = "" if not autoplay else " autoplay" final_controls = "" if not controls else " controls" final_attributes = f"{final_loop}{final_autoplay}{final_controls}" video = Video(f"./{posix_filename}", html_attributes=final_attributes, width=800) display(video)
def show(self): try: if os.path.splitext(self.uri)[-1].lower() == ".gif": from IPython.display import Image display(Image(self.uri)) else: from IPython.display import Video display(Video(self.uri, html_attributes="loop autoplay muted controls")) except: pass
def animation_scan_mcp(self, scan_num, v_range, fig_size, font_size, show = 1, clean = 1): ''' Generate animations with specified MCP scan_num. v_range = [v_min, v_max] v_max = -1: use highest count as vmax ''' start_time = time.time() # read data (imgs_data, positions_data) = self.img_data_scan_mcp(scan_num) [v_min, v_max] = v_range if v_max == -1: # use highest count as vmax v_max = np.amax(imgs_data) # prepare directory DIR = './' + self.PROJECT_NAME + '/Data/MCP_images/scan_' + str(scan_num).zfill(3) if not os.path.exists(DIR): os.makedirs(DIR) DIR_movie = './' + self.PROJECT_NAME + '/Data/MCP_images/movie_scan_' + str(scan_num).zfill(3) + '.mp4' # plotting print("Start generating images...") for snap_no in range(len(imgs_data)): fig = plt.figure(figsize=fig_size) plt.rcParams.update({'font.size': font_size}) ax = fig.add_subplot(111) ax.set_title('snap ' + str(snap_no)) img = plt.imshow(imgs_data[snap_no], vmin=v_min, vmax=v_max) divider = make_axes_locatable(ax) cax = divider.append_axes("right", size="5%", pad=0.1) plt.colorbar(img, cax) fig.tight_layout() plt.savefig(DIR + '/snap_' + str(snap_no).zfill(2) + '.png', dpi = 150, format = 'png') plt.close() print("Done.") # generate animation using ffmpeg print("Start generating animation...") os.system("ffmpeg -r 5 -i " + DIR + "/snap_%02d.png" + " -vcodec mpeg4 -y " + DIR_movie) print("Done.") # delete all figures if clean == 1: shutil.rmtree(DIR) print("All images are deleted.") elapsed_time = time.time() - start_time print("Time consuming: {0:.3f}s.".format(elapsed_time)) if show == 1: return Video(DIR_movie, width=600, height=600) return
def show_dataset(data): ''' Shows dataset in a video (time is the slice dimension) ''' if len(data.shape) == 4: _data = combine_channels(data) elif len(data.shape) == 3: _data = data else: return None _data = (np.abs(_data) * 255).astype(np.uint8) imageio.mimwrite('_.mp4', _data, fps=30); return Video('_.mp4', width=_data.shape[2], height=_data.shape[1])
def play(self, player = None, **kwargs): from IPython.display import Video, HTML if player: subprocess.call([player+ " "+self.vid_file], shell=True) return try: # if in notebook, this loop runs and Video object is returned get_ipython return Video(self.vid_file, embed=True) # If running from terminal, `get_ipython` will raise error # and `globalVariable.video_player` will be called except: subprocess.call([globalVariables.video_player+ " "+self.vid_file], shell=True)
def load_video(video_path, output_size=(270, 480)): cap = cv2.VideoCapture(video_path) frames_list = [] while True: success, frame = cap.read() if not success: break frame = cv2.cvtColor(cv2.resize(frame, output_size), cv2.COLOR_BGR2RGB) frames_list.append(frame) print( f'Video {video_path} loaded: {len(frames_list)} frames with shape {np.shape(frames_list[0])}' ) fps = cap.get(cv2.CAP_PROP_FPS) return frames_list, fps, Video(video_path, width=output_size[0])
def display_video(selection): from IPython.display import Video from pathlib import Path # TODO: Handle when selection is an abs-path try: # selection is an absolute path and Video expects # a relative path rel_path = str(Path.cwd().relative_to(selection)) except ValueError as e: # a relative path was given rel_path = selection display(f'Displaying "{rel_path}"') return Video(rel_path)
def display(self, width: int = None, height: int = None, **kwargs): """ Customize visualization in jupyter notebook Parameters ---------- width: int, default None Width in pixels. Defaults to the original video width height: int, default None Height in pixels. Defaults to the original video height kwargs: dict See :py:class:`IPython.display.Video` doc for other kwargs Returns ------- v: IPython.display.Video """ from IPython.display import Video return Video(self.uri, width=width, height=height, **kwargs)
def animate_decision_regions(X, Y, predict_history, *, Xhistory=None, ax=None, filename=None, interval=50): ''' make_predict: function that takes parameters ''' import matplotlib.pyplot as plt if ax is None: f, ax = plt.subplots() f = ax.figure # HACK HACK comment this if Xhistory is None: Xhistory = [X] * len(predict_history) kw = dict(force_matplotlib_output_png_hack=False) plot_decision_regions(predict_history[0], Xhistory[0], Y, ax=ax, **kw) def update(t): for a in ax.lines + ax.collections: a.remove() plot_decision_regions(predict_history[t], Xhistory[t], Y, ax=ax, **kw) return [] a = animation.FuncAnimation( f, update, frames=len(predict_history), interval=interval, blit=True, repeat=False) plt.close() if filename is not None: assert filename.endswith('.gif') or filename.endswith('.mp4'), 'Only supports exporting to .gif or .mp4' if filename.endswith('.mp4'): Writer = animation.writers['ffmpeg'] writer = Writer(fps=1000./interval, bitrate=1800) a.save(filename, writer=writer) from IPython.display import Video return Video(filename) else: a.save(filename, writer='imagemagick') from IPython.display import Image return Image(filename) from IPython.display import HTML return HTML(a.to_jshtml())
def show(file, width=640, height=480, mode='windowed', title='Untitled'): """ Helper function which actually does the "showing". Args: file (str): Path to the file. width (int, optional): The width of the window. Defaults to 640. height (int, optional): The height of the window. Defaults to 480. mode (str, optional): 'windowed' will use ffplay (in a separate window), while 'notebook' will use Image or Video from IPython.display. Defaults to 'windowed'. title (str, optional): The title of the window. Defaults to 'Untitled'. """ if mode.lower() == 'windowed': cmd = f'ffplay "{file}" -x {width} -y {height} -window_title "{title}"' # os.system(cmd) show_async(cmd) elif mode.lower() == 'notebook': video_formats = ['.avi', '.mp4', '.mov', '.mkv', '.mpg', '.mpeg', '.webm', '.ogg', '.ts', '.wmv', '.3gp'] image_formats = ['.jpg', '.png', '.jpeg', '.tiff', '.gif', '.bmp'] file_extension = os.path.splitext(file)[1].lower() if file_extension in video_formats: file_type = 'video' elif file_extension in image_formats: file_type = 'image' if file_type == 'image': display(Image(file)) elif file_type == 'video': if file_extension not in ['.mp4', '.webm', '.ogg']: from musicalgestures._utils import convert_to_mp4 print( 'Only mp4, webm and ogg videos are supported in notebook mode.') video_to_display = convert_to_mp4(file) else: video_to_display = file display(Video(video_to_display, width=800)) else: print( f'Unrecognized mode: "{mode}". Try "windowed" or "notebook".')
def show_data(self, interactive): self.get_data_path() #Extract path to video clip if (interactive): display(Video(self.data_path, embed=True)) else: # Create a VideoCapture object and read from input file cap = cv2.VideoCapture(self.data_path) # Check if video is correctly open assert cap.isOpened(), "Not able to open video" # Read until video is completed while (cap.isOpened()): ret, frame = cap.read() if ret == True: # Display the resulting frame cv2.imshow('Frame', frame) if cv2.waitKey(25) & 0xFF == ord('q'): break else: break cap.release() cv2.destroyAllWindows()
def manim(self, line, cell=None, local_ns=None): r"""Render Manim scenes contained in IPython cells. Works as a line or cell magic. .. note:: This line and cell magic works best when used in a JupyterLab environment: while all of the functionality is available for classic Jupyter notebooks as well, it is possible that videos sometimes don't update on repeated execution of the same cell if the scene name stays the same. This problem does not occur when using JupyterLab. Please refer to `<https://jupyter.org/>`_ for more information about JupyterLab and Jupyter notebooks. Usage in line mode:: %manim MyAwesomeScene [CLI options] Usage in cell mode:: %%manim MyAwesomeScene [CLI options] class MyAweseomeScene(Scene): def construct(self): ... Run ``%manim -h`` for possible command line interface options. """ if cell: exec(cell, local_ns) args = line.split() if not len( args ) or "-h" in args or "--help" in args or "--version" in args: main(args, standalone_mode=False, prog_name="manim") return modified_args = ["--jupyter"] + args[:-1] + [""] + [args[-1]] args = main(modified_args, standalone_mode=False, prog_name="manim") with tempconfig(local_ns.get("config", {})): config.digest_args(args) exec(f"{config['scene_names'][0]}().render()", local_ns) local_path = Path(config["output_file"]).relative_to( Path.cwd()) tmpfile = (Path(config["media_dir"]) / "jupyter" / f"{_video_hash(local_path)}{local_path.suffix}") if local_path in self.rendered_files: self.rendered_files[local_path].unlink() self.rendered_files[local_path] = tmpfile os.makedirs(tmpfile.parent, exist_ok=True) shutil.copy(local_path, tmpfile) file_type = mimetypes.guess_type(config["output_file"])[0] if file_type.startswith("image"): display(Image(filename=config["output_file"])) return # videos need to be embedded when running in google colab video_embed = "google.colab" in str(get_ipython()) display( Video( tmpfile, html_attributes= f'controls autoplay loop style="max-width: {config["media_width"]};"', embed=video_embed, ))
point_conv.set_data(frame+1, current_ratio[frame]) return ln_in, ln_out, line_conv, point_conv ani = animation.FuncAnimation(fig, update, frames=n_samples, interval=150, init_func=init, blit=True) Writer = animation.writers['ffmpeg'] writer = Writer(fps=15, metadata=dict(artist='Me'), bitrate=1800) ani.save('pi.mp4', writer=writer) plt.show() # %% from IPython.display import Video Video("pi.mp4") # Need ffmpeg installed on your machine # %% # Reminder: orange area is: np.pi/4 # %% @jit(nopython=True) def monte_carlo_pi(n_samples=1000): acc = 0
def run(self, mode=None, directory=None): env = self.make_env(mode=mode, directory=directory) self.reset_data() self.model.model.reset_states() state = env.reset() resting = 0 x_pos = 0 prev_state = state done = False last_x_pos = 24 prev_action = self.take_action() for step in range(self.max_steps): if step % self.fps == 0: action = self.take_action() next_state, reward, done, info = env.step(action) reward += self.button_penalty * list_dist(prev_action, action) prev_action = action #advancing check if info['x_pos'] > x_pos: x_pos = info['x_pos'] resting = 0 #sub-area entry check if abs(last_x_pos - info['x_pos']) > 10: resting = 0 x_pos = info['x_pos'] last_x_pos = info['x_pos'] resting += 1 if info['life'] < 2: break if resting > self.patience * 60: break self.gather_data(step, state, reward, done, info, next_state) prev_state = state state = next_state if mode == 'render': env.render() if done: break if mode == 'monitor': file_name = directory + 'openaigym.video.%s.video000000.mp4' % env.file_infix mp4 = Video(file_name, width=400, height=300) self.video = mp4 else: env.close()
def addVideo(self,path,width=None): self.addmd(Video(path)._repr_html_(),width=width)
sim.run(until=200) eps_data = sim.get_array(center=mp.Vector3(), size=cell, component=mp.Dielectric) plt.figure(dpi=100) sim.plot2D() #plt.show() plt.savefig('PLM-Box.png') ez_data = sim.get_array(center=mp.Vector3(), size=cell, component=mp.Ez) plt.figure(dpi=100) sim.plot2D(fields=mp.Ez) #plt.show() plt.savefig('EzComponent.png') #sim.reset_meep() f = plt.figure(dpi=100) Animate = mp.Animate2D(sim, fields=mp.Ez, f=f, realtime=False, normalize=True) plt.close() sim.run(mp.at_every(1, Animate), until=100) plt.close() filename = "straight_waveguide.mp4" Animate.to_mp4(20, filename) from IPython.display import Video Video(filename)
def manim( self, line: str, cell: str = None, local_ns: dict[str, Any] = None, ) -> None: r"""Render Manim scenes contained in IPython cells. Works as a line or cell magic. .. hint:: This line and cell magic works best when used in a JupyterLab environment: while all of the functionality is available for classic Jupyter notebooks as well, it is possible that videos sometimes don't update on repeated execution of the same cell if the scene name stays the same. This problem does not occur when using JupyterLab. Please refer to `<https://jupyter.org/>`_ for more information about JupyterLab and Jupyter notebooks. Usage in line mode:: %manim [CLI options] MyAwesomeScene Usage in cell mode:: %%manim [CLI options] MyAwesomeScene class MyAweseomeScene(Scene): def construct(self): ... Run ``%manim --help`` and ``%manim render --help`` for possible command line interface options. .. note:: The maximal width of the rendered videos that are displayed in the notebook can be configured via the ``media_width`` configuration option. The default is set to ``25vw``, which is 25% of your current viewport width. To allow the output to become as large as possible, set ``config.media_width = "100%"``. Examples -------- First make sure to put ``import manim``, or even ``from manim import *`` in a cell and evaluate it. Then, a typical Jupyter notebook cell for Manim could look as follows:: %%manim -v WARNING --disable_caching -qm BannerExample config.media_width = "75%" class BannerExample(Scene): def construct(self): self.camera.background_color = "#ece6e2" banner_large = ManimBanner(dark_theme=False).scale(0.7) self.play(banner_large.create()) self.play(banner_large.expand()) Evaluating this cell will render and display the ``BannerExample`` scene defined in the body of the cell. .. note:: In case you want to hide the red box containing the output progress bar, the ``progress_bar`` config option should be set to ``None``. This can also be done by passing ``--progress_bar None`` as a CLI flag. """ if cell: exec(cell, local_ns) args = line.split() if not len(args) or "-h" in args or "--help" in args or "--version" in args: main(args, standalone_mode=False, prog_name="manim") return modified_args = self.add_additional_args(args) args = main(modified_args, standalone_mode=False, prog_name="manim") with tempconfig(local_ns.get("config", {})): config.digest_args(args) renderer = None if config.renderer == "opengl": # Check if the imported mobjects extend the OpenGLMobject class # meaning ConvertToOpenGL did its job if "OpenGLMobject" in map(lambda cls: cls.__name__, Group.mro()): from manim.renderer.opengl_renderer import OpenGLRenderer renderer = OpenGLRenderer() else: logger.warning( "Renderer must be set to OpenGL in the configuration file " "before importing Manim! Using cairo renderer instead.", ) config.renderer = "cairo" try: SceneClass = local_ns[config["scene_names"][0]] scene = SceneClass(renderer=renderer) scene.render() finally: # Shader cache becomes invalid as the context is destroyed shader_program_cache.clear() # Close OpenGL window here instead of waiting for the main thread to # finish causing the window to stay open and freeze if renderer is not None and renderer.window is not None: renderer.window.close() if config["output_file"] is None: logger.info("No output file produced") return local_path = Path(config["output_file"]).relative_to(Path.cwd()) tmpfile = ( Path(config["media_dir"]) / "jupyter" / f"{_generate_file_name()}{local_path.suffix}" ) if local_path in self.rendered_files: self.rendered_files[local_path].unlink() self.rendered_files[local_path] = tmpfile os.makedirs(tmpfile.parent, exist_ok=True) shutil.copy(local_path, tmpfile) file_type = mimetypes.guess_type(config["output_file"])[0] if file_type.startswith("image"): display(Image(filename=config["output_file"])) return # videos need to be embedded when running in google colab video_embed = "google.colab" in str(get_ipython()) display( Video( tmpfile, html_attributes=f'controls autoplay loop style="max-width: {config["media_width"]};"', embed=video_embed, ), )
image_prediction.query("input == @image_to_plot").plot_detections() # # Detecting FEX from videos # Detecting facial expressions in videos is also easy by using the `detect_video()` method. This sample video is by [Wolfgang Langer](https://www.pexels.com/@wolfgang-langer-1415383?utm_content=attributionCopyText&utm_medium=referral&utm_source=pexels) from [Pexels](https://www.pexels.com/video/a-woman-exhibits-different-emotions-through-facial-expressions-3063838/). # In[21]: # Find the file you want to process. from feat.tests.utils import get_test_data_path import os, glob test_data_dir = get_test_data_path() test_video = os.path.join(test_data_dir, "WolfgangLanger_Pexels.mp4") # Show video from IPython.display import Video Video(test_video, embed=True) # Let's predict facial expressions from the video using the `detect_video()` method. # In[22]: video_prediction = detector.detect_video(test_video, skip_frames=24) video_prediction.head() # You can also plot the detection results from a video. The frames are not extracted from the video (that will result in thousands of images) so the visualization only shows the detected face without the underlying image. # # The video has 24 fps and the actress show sadness around the 0:02, and happiness at 0:14 seconds. # In[23]: video_prediction.loc[[48]].plot_detections()
pickled_puzzle = pickle.load(f) pickled_puzzle.show() # これで生成済みのパズルデータをオープンすることができました。 # --- # ## (番外編)解の軌跡をアニメーション化 # 解の軌跡をアニメーション化してみましょう。 # パズルの巻き戻し・早送り機能を使って、作業履歴を最初から順番に画像化し、 # 外部ファイルを用いてそれを動画化します(このセルの実行には数分かかる場合があります)。 for p in glob.glob("fig/animation/*.png"): if os.path.isfile(p): os.remove(p) # jump to top of the frame tmpPuzzle = pickled_puzzle.jump(0) tmpPuzzle.saveAnswerImage(f"fig/animation/0000.png") # save all history as image file for histNum in range(len(tmpPuzzle.baseHistory)): tmpPuzzle = tmpPuzzle.getNext() tmpPuzzle.saveAnswerImage(f"fig/animation/{str(histNum+1).zfill(4)}.png") # 動画化にはmovie_maker.pyを用います。コマンドライン引数で画像が入ったディレクトリとFPSを指定します。 # !python ../python/script/movie_maker.py "fig/animation/" -o "fig/animation/out.mp4" -f 10 -c mp4v # これで、fig/animation内にout.mp4という動画ファイルが作成されました。 # 再生してみましょう。 Video("fig/animation/out.mp4", width=960, height=480)
def convert_jpg_video(video_root, start_frame, dst_path, n_frames=-1, fps=60, insert_pause=-1, show_vid=False, frame_number_display=False, ignore_if_exist=True, store_frames=[]): ''' Helper for Epic and SynthEpic visualization. ignore_if_exist: If True, don't write any files if the .mp4 already exists. Set False if store_frames changed. ''' if not (os.path.exists(dst_path)) or not (ignore_if_exist): if not (os.path.exists(Path(dst_path).parent)): os.makedirs(Path(dst_path).parent) if n_frames <= 0: n_frames = len(os.listdir(video_root)) if store_frames != []: dst_frame_path = 'single_video_frames/' + str( video_root.split('/')[-1]) + '/' + str(start_frame) if not (os.path.exists(dst_frame_path)): os.makedirs(dst_frame_path) # Write all frames writer = FFmpegWriter(dst_path, inputdict={'-r': str(fps)}) for i in range(n_frames): cur_frame = start_frame + i file_name = 'frame_{:010d}.jpg'.format(cur_frame + 1) video_path = os.path.join(video_root, file_name) if not (os.path.exists(video_path)): break # n_frames could be overestimated due to extra files frame = plt.imread(video_path) if cur_frame in store_frames: frame_still = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB) cv2.imwrite(os.path.join(dst_frame_path, file_name), frame_still) if frame_number_display: font = cv2.FONT_HERSHEY_SIMPLEX bottomLeftCornerOfText = (250, 250) fontScale = 1 fontColor = (255, 255, 255) lineType = 2 frame_annotated = cv2.putText(frame, str(start_frame + i), bottomLeftCornerOfText, font, fontScale, fontColor, lineType) frame_annotated = frame_annotated.copy() writer.writeFrame(frame_annotated) else: frame = frame.copy() writer.writeFrame(frame) # Insert pause (with orange borders) just as predictions start to happen if insert_pause >= 0 and i == insert_pause: alert_frame = frame.copy() alert_frame[:20, :] = [255, 128, 0] alert_frame[-20:, :] = [255, 128, 0] alert_frame[:, :20] = [255, 128, 0] alert_frame[:, -20:] = [255, 128, 0] for j in range(60): writer.writeFrame(alert_frame) writer.close() if show_vid: # For use in jupyter notebook display(Video(dst_path, embed=True, width=480, height=320))
fig, ax = plt.subplots(1,1, figsize=(15, 15)) sns.heatmap(ML.corr().iloc[0:10,10:], cmap=sns.color_palette("coolwarm"), center=0,square=True, linewidths=.5, cbar_kws={"shrink": .5}) plt.show() q19_cnt = multiple_choice['Q19'].value_counts()[:-1] fig = go.Figure([go.Bar(x=q19_cnt.index, y=q19_cnt, marker_color='crimson')]) fig.update_layout(title="Programming Language Ranking") fig.show() q18_df, q18_sub = q_list('Q18') q18_df.drop(0, axis=0, inplace=True) q18_convert = {b:a for a, b in zip(q18_sub.values, q18_df.columns)} q18_df.rename(columns=q18_convert, inplace=True) msno.matrix(q18_df, color=(0.37, 0.29, 0.48)) from IPython.display import Video Video("https://thumbs.gfycat.com/UnderstatedAnotherAntelope-mobile.mp4") data = multiple_choice[['Q19', 'Q23']] data.drop(0, axis=0, inplace=True) career = data['Q23'].value_counts() fig = go.Figure([go.Bar(x=career.index, y=career, marker_color='#F6CD8B')]) fig.update_layout(title="Distribution of ML Career") fig.show() data.groupby('Q23')['Q19'].value_counts().unstack().fillna(0).T[[ '< 1 years', '1-2 years', '2-3 years', '3-4 years', '4-5 years', '5-10 years', '10-15 years', '20+ years']].drop(['None','Other'], axis=0) fig = px.histogram(data.dropna(), x='Q23', y='Q23', color='Q19', template='ggplot2') fig.update_layout() fig.show() data = multiple_choice[['Q19', 'Q15']] data.drop(0, axis=0, inplace=True)
def play(video, filepath="tmp.mp4"): from IPython.display import Video video = img_as_ubyte(clip(img_as_float32(np.asarray(video)))) imageio.mimwrite(filepath, video, fps=24, macro_block_size=None) display(Video(filepath, width=800, height=400))
Z = Z1 #%% N = np.zeros(Z.shape, dtype=int) N[1:-1, 1:-1] += (Z[:-2, :-2] + Z[:-2, 1:-1] + Z[:-2, 2:] + Z[1:-1, :-2] + Z[1:-1, 2:] + Z[2:, :-2] + Z[2:, 1:-1] + Z[2:, 2:]) # 当前细胞为存活状态时,当周围有2个或3个存活细胞时, 该细胞保持原样。 birth = (N == 3)[1:-1, 1:-1] & (Z[1:-1, 1:-1] == 0) # 当前细胞为死亡状态时,当周围有3个存活细胞时,该细胞变成存活状态。 (模拟繁殖) survive = ((N == 2) | (N == 3))[1:-1, 1:-1] & (Z[1:-1, 1:-1] == 1) Z[...] = 0 Z[1:-1, 1:-1][birth | survive] = 1 #%% Video("game-of-life.mp4") #%% #%% [markdown] # # 参考 # # 1. [Numerical Python: A Practical Techniques Approach for Industry](https://www.amazon.com/Numerical-Python-Practical-Techniques-Approach/dp/1484205545) # 1. [Guide to NumPy, by the creator of Numpy](http://web.mit.edu/dvp/Public/numpybook.pdf) # 1. [Scipy Lecture Notes](http://www.scipy-lectures.org/intro/numpy/) # 1. [From Python to Numpy](http://www.labri.fr/perso/nrougier/from-python-to-numpy) #%% #%%