Jupyter: Una introducción

Julio Waissman Vilanova

julio.waissman@unison.mx

¿Que es Jupyter?

1. Un entrono de computación interactiva atractivo

2. Un entrono de literate programming en python

3. Un entrono para investigación reproducible

4. Una forma de generar tutoriales y material de autoaprendizaje amigables

Historia

1. Primera versión en diciembre 2011 como un método de libretas para Ipython.

2. Inició como una versión para python de las libretas de Mathematica

3. La arquitectura desarrollada permitió su uso más allá de python

4. En 2014 se separan como proyecto independiente bajo el nombre de Jupyter

Estructura de una libreta

1. Se basa en el concepto de celdas

2. Las celdas pueden ser de código o texto

3. Las celdas de texto se realiza en Markdown

   1. Markdown con sabor de Github

   2. Incluye MathJax

4. Las celdas de código se ejecutan en el orden solicitado en forma asíncrona

5. El sistema guarda memoria de lo ejecutado

Arquitectura del sistema

1. Aplicación cliente-servidor

2. El cliente interactúa a través de un navegador

3. El servidor se compone de Kernel y dashboard

   1. El Kernel ejecuta el codigo de las celdas

   2. El dashboard se encarga de la visualización y las celdas de texto.

¿Que se requiere para poder utilizar Jupyter?

1. Python instalado (i.e. la distribucion Anaconda)

   1. Se requieren varias bibliotecas especializadas
   2. Se basa en Ipython y tornado principalmente

2. Al menos un kernel instalado (i.e. Ipython)

   1. Python, R y/o Julia como nativos y con soporte oficial

   2. Kernel para muchos lenguajes desarrollados por la comunidad

Comenzamos con Python

Empezamos por cargar algunas librerías básicas

%matplotlib inline
import numpy as np
import matplotlib.pyplot as plt

plt.rcParams['figure.figsize'] = (20,8)
plt.style.use('ggplot')

Probemos con un código sencillo

x = np.linspace(-np.pi, np.pi, 100)
y1 = np.sin(x)
y2 = np.cos(x)

Todo se queda en memoria

mientras no se reinicie el kernel

plt.plot(x, y1, label='sen(x)')
plt.plot(x, y2, label='cos(x)')
plt.title('Funciones de ejemplo')
plt.xlabel('x')
plt.ylabel('f(x)')
plt.legend()
plt.show()

Vamos por partes

1. ¿Qué puedo agregar en las celdas de texto?

2. ¿Qué puedo agregar en la celdas de código (aparte de código, por supuesto)?

3. ¿Cómo puedo cambiar el Kernel para usar otro lenguaje de programación?

Celdas de texto

1. Todo es Markdown

2. Una buena referencia rápida la puedes consultar aquí

Insertar imágenes

• Lo más fácil es:

  ![texto](imagenes/jupyter.png)

• Pero muchas veces es más conveniente

  <img src="imagenes/jupyter.png" width="70">

Cuadros

• Debe haber al menos trés lineas para marcar una separación
• Los delimitadores externos son opcionales

| Col 1         | Col 2         | Col 3  |
| ------------- |:-------------:| ------:|
| Esta          | Esta          | \$1600 |
| columna       | se encuentra  |   \$12 |
| a la derecha  | centrada      |    \$1 |


Markdown | bien | feo
---|---|---
*No se ve muy bien* | ~el código~ | **pero genera un cuadro decente**
1 | 2 | 3

Col 1	Col 2	Col 3
Esta	Esta	\$1600
columna	se encuentra	\$12
a la derecha	centrada	\$1

Markdown	bien	feo
No se ve muy bien	~el código~	pero genera un cuadro decente
1	2	3

Notación matemática

1. Jupyter usa por default mathjax

2. Las ecuaciones en linea van entre signos \$ ecuación \$

3. Las ecuaciones en propia linea van entre \$\$ ecuación \$\$

4. Utiliza la notación estandard de $\LaTeX$

5. Un buen lugar de consulta está aquí

Algunas ecuaciones

Podemos escribr cosas tanto en linea como $\forall x \in X, \quad \exists y \leq \epsilon$ que es muy práctico para calculo 1. Igualmente, se pueden escribir cosas como $\cos (2\theta) = \cos^2 \theta - \sin^2 \theta$ que es útil en trigonometría. O tambien podemos escribir
$$
\frac{n!}{k!(n-k)!} = \binom{n}{k},
$$

$$
P\left(A=2\middle|\frac{A^2}{B}>4\right) = \int_0^\infty \mathrm{e}^{-x}\,\mathrm{d}x
$$

Podemos escribr cosas tanto en linea como $\forall x \in X, \quad \exists y \leq \epsilon$ que es muy práctico para calculo 1. Igualmente se pueden escribir cosas como $\cos (2\theta) = \cos^2 \theta - \sin^2 \theta$ que es útil en trigonometría. O tambien podemos escribir $$ \frac{n!}{k!(n-k)!} = \binom{n}{k}, $$

$$ P\left(A=2\middle|\frac{A^2}{B}>4\right) = \int_0^\infty \mathrm{e}^{-x}\,\mathrm{d}x $$

Ingresando código de ejemplo en el texto

```python
def fibo(n):
    def fibo_r(x, y, acc):
        return y if acc < 2 else fibo_r(y, x + y, acc - 1)
    return fibo_r(1, 1, n)
`` `

lo que queda como

def fibo(n):
    def fibo_r(x, y, acc):
        return y if acc < 2 else fibo_r(y, x + y, acc - 1)
    return fibo_r(1, 1, n)

Celdas de código

1. Comandos mágicos de Jupyter

2. Código ejecutado por el Kernel

Comandos mágicos

1. Jupyter tiene una serie de comandos mágicos,

2. Todos empiezan con '%'.

3. Todos son específicos a Python

Para probar, ejecuta en una casilla lo siguiente

%quickref
%lsmagic

%lsmagic

Available line magics:
%alias  %alias_magic  %autocall  %automagic  %autosave  %bookmark  %cat  %cd  %clear  %colors  %config  %connect_info  %cp  %debug  %dhist  %dirs  %doctest_mode  %ed  %edit  %env  %gui  %hist  %history  %killbgscripts  %ldir  %less  %lf  %lk  %ll  %load  %load_ext  %loadpy  %logoff  %logon  %logstart  %logstate  %logstop  %ls  %lsmagic  %lx  %macro  %magic  %man  %matplotlib  %mkdir  %more  %mv  %notebook  %page  %pastebin  %pdb  %pdef  %pdoc  %pfile  %pinfo  %pinfo2  %popd  %pprint  %precision  %profile  %prun  %psearch  %psource  %pushd  %pwd  %pycat  %pylab  %qtconsole  %quickref  %recall  %rehashx  %reload_ext  %rep  %rerun  %reset  %reset_selective  %rm  %rmdir  %run  %save  %sc  %set_env  %store  %sx  %system  %tb  %time  %timeit  %unalias  %unload_ext  %who  %who_ls  %whos  %xdel  %xmode

Available cell magics:
%%!  %%HTML  %%SVG  %%bash  %%capture  %%debug  %%file  %%html  %%javascript  %%js  %%latex  %%markdown  %%perl  %%prun  %%pypy  %%python  %%python2  %%python3  %%ruby  %%script  %%sh  %%svg  %%sx  %%system  %%time  %%timeit  %%writefile

Automagic is ON, % prefix IS NOT needed for line magics.

def fibo(n):
    def fibo_r(x, y, acc):
        
        return y if acc < 2 else fibo_r(y, x + y, acc - 1)
    return fibo_r(1, 1, n)

display(fibo(4))
display(fibo(20))
%timeit fibo(20)

# ¿Y que pasa si ejecutas %prun fibo(200)?

5

10946

4.34 µs ± 96.7 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

# Comandos mágicos que mandan llamar al shell 
!which python

%ls

%pwd

/Users/juliowaissman/anaconda/bin/python
LICENSE                     jupyter_basico.ipynb
README.md                   jupyter_basico.slides.html
imagenes/                   publish.sh*
index.html                  reveal.js/

'/Users/juliowaissman/Documents/cursos/Capacitacion/jupyter-intro'

Tambien existe la biblioteca de Ipython

from IPython.display import YouTubeVideo
# a talk about IPython at Sage Days at U. Washington, Seattle.
# Video credit: William Stein.
YouTubeVideo('1j_HxD4iLn8')

¿Y el código?

• Depende de lo que quieras hacer.

• Se puede hacer uso intensivo del autocompletado

• Igualmente, se tiene la documentación de todas las funciones

• Prácticamente todo lo que se hace en python funciona en Jupyter, sin embargo, se usa principalmente con:

  • numpy y matplotlib

  • pandas

¿Y si quiero ejecutar y guardar mis libretas en linea?

Dos opciones:

1. Colab. Libre, pero de Google (se usa desde drive)

   • Ejemplo de introducción a pandas

2. Binder. Libre pero en etapa Beta y algo tardado (se usa desde github). No siepre funciona con las bibliotecas que se consideran de base.

Agregando otros Kernels a Jupyter

1. El nombre viene de Julia, python y R.

2. Instalar R, y desde R en la terminal:

   install.packages(c('repr', 'IRdisplay', 'evaluate', 'crayon', 
                      'pbdZMQ', 'devtools', 'uuid', 'digest'))
   devtools::install_github('IRkernel/IRkernel')
   IRkernel::installspec()
   

3. Instalar Julia, y luego ejecutar dentro del repl de Julia

   Pkg.add("IJulia")
   

¿Y si quiero agregar un interprete de C++?

1. Necesito tener instalado Jupyter a través de la distribución Anaconda

2. Usar el interprete (basado en python) Xeus-cling

Para instalar, desde la consola:

$ conda create -n cling
$ source activate cling
$ conda install xeus-cling notebook -c QuantStack -c conda-forge
$ source deactivate

Para probar

$ source activate cling
$ jupyter notebook

¿Y si quiero hacer una presentación en Jupyter?

1. Habilitar la edición de diapositivas en el menú (View -> Cell Toolbar -> Slideshow)

2. Seleccionar el tipo de diapositiva:

   1. Slide Transparencia a la derecha

   2. Subslide Transparencia hacia abajo

   3. Fragment Para completar la transparencia paso a paso

   4. - Para continuar con la transparencia

3. CGenerar la presentación en html usando reveal.js

¿Y como se genera la presentación?

Para generar una presentación que se pueda ver como página de Github es necesario usar la version de reveal.js en linea, y con ella transformar la libreta en una presentación en html. La conversion (y luego cambiar su nombre por index.html se hace con el siguiente código (asumiendo que la libreta se llama toto.ipynb).

$ jupyter-nbconvert --to slides toto.ipynb --reveal-prefix="https://cdnjs.cloudflare.com/ajax/libs/reveal.js/3.1.0"
$ mv toto.slides.html index.html

1. Tanto reveal.js como mathjax se encuentran en linea, por lo que la presentación no puede ser utilizada sin conexión a internet.

2. Para publicarlo en github, es necesario hacerlo desde la rama gh-pages

Pequeño script para actualizar la presentación

# Convierte la libreta a slides y le cambia el nombre a index.html
jupyter-nbconvert --to slides libreta.ipynb --reveal prefix="https://cdnjs.cloudflare.com/ajax/libs/reveal.js/3.1.0"
mv libreta.slides.html index.html

# Actualiza la rama master
git add -A .
git commit -m "Actualiza"
git push origin master

# Actualiza la rama gh-pages
git checkout gh-pages
git rebase master
git push origin gh-pages
git checkout master

Y esto es todo por el momento...

Muchas gracias por su atención