# Making animations work in Google Colaboratory — new home for ML prototyping

I always felt Jupyter was such an amazing platform to get up and running quickly in Machine Learning — with focus on quick results/content, minimal installation drama.

Well, that was until I found Google Colab.

Change minimal installation to zero installation drama, add some bells and whistles to the UX, add Google Docs like real-time collaboration features, and add a 1-click option to switch to GPU when needed —Google Colab is definitely a 1-up on Jupyter notebooks.

That said, as with anything new and shiny, there are gaps, and understandably so.

1 big blocker which hits soon enough is — animating your plots. The `matplotlib` animation APIs which work smoothly out of the box with Jupyter notebooks, are not that trivial to get working, on Colab.

#### Here’s the best way I have seen to get your plots animating

`from matplotlib import rcrc('animation', html='jshtml')`

#### Let’s go through step by step details

Task: plot `y= sin(x)` and animate a tangent line showing its gradient at each point

`import numpy as npimport matplotlib.pyplot as pltfrom matplotlib import animation`

get a range of `x` to plot our function `sin(x)`

`x = np.linspace(-4, 4, 100)y = np.sin(x)`

create the required plot objects

`fig, ax = plt.subplots()ax.set_xlim(( -4, 4))ax.set_ylim((-2, 2))`

create 2 line plots, 1 each for our function and its gradient line

`line1, = ax.plot([], [], lw=2)line2, = ax.plot([], [], lw=2)`

next define the `init()` function, which is responsible for the background of each frame in the animation

`def init():    line1.set_data(x, y)          return (line1,)`

now define the `animate()` function, which is called sequentially and is responsible for the change we see in each frame

`def animate(i):  at_x = x[i]    # gradient_line will have the form m*x + b  m = np.cos(at_x)  b = np.sin(at_x) - np.cos(at_x)*at_x  gradient_line = m*x + b    line2.set_data(x, gradient_line)  return (line2,)`

finally, call the `FuncAnimation()` of `matplotlib.animation` to kick off the animation

`anim = animation.FuncAnimation(fig, animate, init_func=init, frames=100, interval=100, blit=True)`

At this stage, we have our animation object `anim` — and to animate it inline, we want to set the default HTML representation of our plots as interactive javascript widget.
This is done by setting the `rc` parameter of`animation.html` to `jshtml`

`rc('animation', html='jshtml')`

Once the above is set, we can just reference our animation object `anim` to display the animated plot inline.

Here’s what the combined code block looks like:

`import numpy as npimport matplotlib.pyplot as pltfrom matplotlib import animation, rcfrom IPython.display import HTML`
`# animate over some set of x, yx = np.linspace(-4, 4, 100)y = np.sin(x)`
`# First set up the figure, the axes, and the plot elementfig, ax = plt.subplots()plt.close()ax.set_xlim(( -4, 4))ax.set_ylim((-2, 2))`
`line1, = ax.plot([], [], lw=2)line2, = ax.plot([], [], lw=2)`
`# initialization function: plot the background of each framedef init():    line1.set_data(x, y)          return (line1,)`
`# animation function: this is called sequentiallydef animate(i):  at_x = x[i]    # gradient_line will have the form m*x + b  m = np.cos(at_x)  b = np.sin(at_x) - np.cos(at_x)*at_x  gradient_line = m*x + b    line2.set_data(x, gradient_line)  return (line2,)`
`anim = animation.FuncAnimation(fig, animate, init_func=init, frames=100, interval=100, blit=True)`
`rc('animation', html='jshtml')anim`

Running the above in Google Colab will give the inline animated plot we were after.