Jupyter Notebooks

Ya he acabado los 4 primeros cursos de Python de Datacamp, así que estoy pensando en hacer algún pequeño proyectillo para poner en prácctica algunos conceptos. Me gustaría usar Jupyter Notebooks e ir viendo de manera interactiva si va funcionando todo, así que me he puesto con este tutorial de Jupyter Notebooks.

Instalación

Mi primer intento ha sido instalarlo directamente a través de «pip» pero, como no podía ser de otra manera, me ha dado un error y cuando quiero abrirlo, no se abre.

Segundo intento: Anaconda. Ya había usado los Jupyter notebooks instalándolo a través de Anaconda antes, así que espero que no haya problema esta vez.

(Tarda un ratillo la instalación así que me pongo con el curso de Fundamentos de NLP con Python.)

¡Funciona! Lanzo el Jupyter notebooks con Anaconda Navigator.

Revisando la aplicación

Una vez abierta, la aplicación cuenta con tres pestañas: files, running y clusters.

En la pestaña files podemos crear un notebook nuevo en Python 3 (en nuestro caso) o un documento de texto, una carpeta o una terminal.

Si en la opción terminal escribimos «IPython» tendremos la terminal interactiva, no conocía esta opción. 😀

Creando un notebook

Lo más recomendable es empezar importando las librerías que vamos a necesitar.

Podemos añadir, eliminar o modificar las celdas como queramos. Es muy importante poner títulos y subtítulos que explique bien qué hace nuestro código. ¡Las cosas claritas!

Otra cosa que acabo de aprender: ¡Se puede añadir código LaTex a nuestra parte de texto!

Comandos mágicos de Jupyter Notebooks

Creo que esta parte me la voy a saltar por ahora, pero pufff da mucho juego!

Añadir widgets

Podemos añadir widgets como botones, campos para introducir texto, etc.

Compartir nuestros notebooks

Los documentos que se crean con nuestros notebooks son .json, pero no siempre vas a a quererlos en ese formato. Por eso, los puedes guardar y descargar como HTML, PDF, Markdown o reStructuredText, o como un script de Python or simplemente un Notebook.

Para convertir nuestro Notebook a otro formato usaremos el comando nbconvert (que tendremos que importar antes!)

Incluso podemos guardarlo como una presentación: nbpresent o RISE .

Otras cosillas

  • Muy importante para los proyectos que quiero realizar. Se pueden mostrar los gráficos en el propio notebook. Usaremos %matplotlib inline
  • Si al final tenemos un código muy largo, también podemos «esconder» algunas celdas.
  • Ejemplos chulis:

Deberes:

  • Investigar qué son los Docker containers. Lo único que sé hasta ahora es que es muy usado en el desarrollo de software y que es de software libre :S ¿Es algo así como una máquina virtual?

Nuevos proyectos y Python Toolbox 1

Hace ya unas semanas que no escribo nada y no me gusta. Este blog me permite poner en orden mis ideas y nuevos conocimientos y, la verdad, creo que me resultaba super útil, así que voy a intentar volver a escribir con regularidad. La razón por la que he dejado de escribir estas últimas semanas ha sido que en el trabajo me han asignado un nuevo proyecto y estaba a tope.

Nuevo proyecto: creación de datasets

En este nuevo proyecto que me han asignado estoy creando automáticamente datasets para lueg entrenar un sistema de extracción de intenciones. El objetivo es saber qué está pidiendo el usuario. En concreto, me centro en intenciones en el dominio de soporte informático (IT). Por ejemplo: ¿Quiere que le cambien el portátil? ¿No puede conectarse a internet? ¿Tiene un problema con su teclado?

Pero, antes de entrenar, lo que estamos haciendo es crear un dataset de posibles preguntas que puede hacer el usuario para pedir/preguntar todas esas cosas. Para crearlo estoy usando Chatito, una herramienta de código abierto, que genera conjuntos de datos (datasets) que luego podremos usar para entrenar el sistema.

El input de Chatito son nuestros posibles patrones, es decir, las posibles frases que el usuario puede usar para plantear esos problemas/peticiones al servicio técnico. El output son una serie de documentos JSON que pueden estar en formato RASA NLU, Flair, LUIS o snips NLU. En nuestro caso, vamos a trabajar con RASA NLU, así que cacharrear con este framework está ya entre mis deberes.

Python toolbox 1

Aparte del proyecto que comento, hoy continúo mi proceso de aprendizaje con DataCamp, con el curso de Python toolbox 1. Mi objetivo es completar los 4 cursos de Python que eran requisito del curso Natural Language Processing Fundamentals with Python, también de esta misma plataforma.

Este curso está compuesto de 3 módulos. El primero está dedicado a escribir tus propias funciones. Como antes, en algunos de los módulos de los cursos anteriores, ya sé cómo se hace, pero siempre aprendo algo nuevo y más dirigido a la ciencia de datos, no en general como en otros cursos que hice en el pasado.

Qué he aprendido hoy
  • Definir una función propia con un parámetro y devolver (return) un valor (vídeo 1)
def square(value) # function header with a parameter "value". Signature of the function
    new_value = value ** 2    
    return(new_value)

valor = square(4)  ## así llamamos a la función, usando un argumento concreto, en este caso 4.
print(valor)
  • Definir una función propia con más de un parámetro (vídeo 2)
def square(value1, value2)
    new_value = value1 ** value2
    return(new_value)

valor = square(4, 2)
print(valor)
  • Primeras nociones de tuplas: Son similares a las listas ya que pueden contener distintos valores, pero son inmutables, es decir, una vez creadas no podremos cambiar sus valores. Las tuplas se construyen con los paréntesis. (Recuerdo: los diccionarios los creábamos con {} y las listas con [] )
numeros_pares = (2, 4, 6) ## creamos una tupla

a, b, c = numeros_pares ## empaquetamos cada elemento en una variable

numeros_pares[1]  ## accede al segundo elemento de la tupla
print(numeros_pares) ## los imprimirá todos en pantalla

Y, hasta aquí llegamos por hoy (50% del primer módulo hecho), que tengo que volver al proyecto!

Acabando Python intermedio

Pues, tal y como digo en el título, hoy voy a intentar acabar por fin el curso intermedio de Python para Ciencia de Datos de DataCamp. Sólo me queda el último módulo: Hacker Statistics! 😀

Random Generators

Podemos generar números aleatorios con un submódulo del módulo Numpy (por eso lo llamamos con la notación del punto. Dentro de este subpaquete también habrá otras funciones como

  • seed()
  • rand(): por defecto, genera un número decimal aleatorio entre 0 y 1.
  • randint(): general números enteros aleatorios.
import numpy as np

np.random.rand()   # esto genera un número pseudo-aleatorio

coin = np.random.radint(0,2) # esto genera un número entero aleatorio (0 o 1). El dos no está incluido.

# simulación de un dado
dice = np.random.randint(1,7)

Concepto de Random Walk

max(): nos devuelve el mayor de dos argumentos.

np.transpose()

¡Acabado el curso!

El siguiente paso es el Python Data Science Toolbox (1). Este, junto con su segunda parte, completarán los prerequisitos exigidos para el curso de Procesamiento de Lenguaje Natural Básico con Python. ¡Qué ganas de seguir progresando, la verdad! 🙂

Python intermedio para ciencia de datos

Esta mañana he hecho una entrevista para un puesto de Data Scientist. Creo que todo ha ido bien!! 😀 Como mi sprint con RDF y Linked data era sobre todo para prepararme para la entrevista, hoy voy a continuar con el curso de Python intermedio que se me quedó a medias la semana pasada. No sé si voy a poder continuar con mi «estudio» durante las próximas semanas ya que tengo un proyecto de tres semanas en camino, así que me gustaría, al menos, acabar este curso.

Continúo pues con el módulo 3. Muy facilito: operadores de comparación, booleanos, control de flujo, etc.

Algunos apuntes/cosas nuevas:

  • Los operadores booleanos (and, or, not) no funcionan por sí solos en Numpy. Tendremos que usar np.logical_and(), np.logical_or(), np.logical_not().
if condition:
   expression
elif condition:
   expression
else:
   expression

Filtrar un DataFrame de Pandas

  1. Tendremos que encontrar la columna correcta. Aquí tendremos que seleccionar como output un Panda Series, no un Panda Dataframe, es decir, tendremos que hacerlo con corchetes simples. Por ejemplo: mi_dataframe[«columnaX»], mi_dataframe.loc[:, «columnaX»] o mi_dataframe.iloc[:, 2] (2 sería la columna 2).
  2. Establecer la comparación. Por ejemplo: mi_dataframe[«columnaX»] > 8. Esto nos devolverá la columna correspondiente como una Panda Series con booleans, es decir, True donde se cumpla y False donde no se cumpla esa condición.
  3. Filtrar. Podemos crear una nueva variable con la comparación. Ejemplo: is_huge = mi_dataframe[«columnaX»] > 8 . Si luego, filtramos (my_dataframe[is_huge]), obtendremos solo las filas de los elementos con la columnaX mayor de 8.

Como las filas de un dataframe son arrays de Numpy, si queremos usar los operadores lógicos/booleanos para filtrar, deberemos tener en cuenta las formas que comentábamos más arriba.

*** Módulo 3 acabado!!! ***

Empiezo el módulo 4, dedicado a los bucles.

while condition:
     expression
for var in seq:
     expression

# para iterar sobre un diccionario necesitamos el método items()
for key, value in my_dict.items(): 
...

# para iterar sobre un array multidimensional necesitamos esto
for val in np.enditer(my_array):
...

#iteraciones en DataFrames de Pandas
# esto nos dará los nombres de las columnas
for val in DataFrame:
    print(val)

# esto nos devolverá todos los datos de una fila
for lab, row in DataFrame.iterrows():
     print(lab)
     print(row)

Algunos apuntes/cosas nuevas:

enumerate() : nos devuelve el índice del elemento de una lista.

np.enditer(arrayname): nos devuelve los elementos del array en columna, no como una lista con corchetes.

Cuando iteramos sobre un diccionario el resultado estará desordenado ya que los diccionarios en Python no siguen un orden predeterminado.

*** Módulo 4 acabado!! **

Día 8: MatPlotLib

Ayer empecé un poquito con el curso intermedio de Python para Ciencia de Datos de DataCamp y hoy he continuado.

He acabado el primer módulo, que habla de la librería MatPlotLib. Con ella podemos crear diferentes tipos de gráficos: histogramas, scatterplot, etc. También nos enseñan cómo ponerlo bonito, cambiando los colores, los tamaños, poniendo rótulos, etc.

Continúo con el módulo dos, dedicado a los diccionarios y la librería Pandas (otra de las que están pidiendo actualmente en casi todos los puestos a los que aplico!). Básicamente, lo que hace Pandas es crear documentos tabulares con datos. Incluso podemos importarlos de un documento CSV. Creo que esto funcionará bien para hacer algunas pruebas con word2vec (creo que probaré este tutorial)

Introduction to Python (Data Science)

He acabado el curso de Introducción a Python de Data Camp, así que voy a hacer un resumen de lo que he aprendido para poner un poco en orden mis ideas.

El curso en cuestión está dividido en cuatro módulos:

  1. Python Basics
  2. Pythons Lists
  3. Functions & Packages
  4. NumPy

Python Basics

Para empezar, nos explican cómo instalar Python en nuestro equipo y que los ficheros de Python tendrán la extensión .py

Luego, pasan ya a revisar cómo instanciar las variables (case-sensitive) y nos hablan de los tipos de datos con los que podemos trabajar: float, integer, string, boolean.

Python Lists

En este módulo entramos un poco más en detalle en los tipo de datos y cómo estos se pueden usar para crear listas, que no serían otra cosa que colecciones de valores (o datos). Una lista en Python puede contener distintos tipos de datos, no es necesario que todos sus elementos sean del mismo tipo. Un ejemplo de lista:

fam = ["liz", 1.73, "emma", 1.68]

En Python también se pueden crear listas de listas, como por ejemplo:

fam = [["liz", 1.73], 
["emma", 1.68]]

Las listas son un tipo de dato en sí mismas, así que si le preguntamos a Python, nos lo dirá:

type(fam)
>> list

Los elementos de una lista están ordenados, desde el elemento 0 (el primero) hasta el último. Para acceder a los distintos elementos usaremos los corchetes:

fam[3]
>> "emma" 
# usando la primera definición de fam, no la lista de listas
fam[-1]
>> 1.68
# si usamos un número negativo empezará por detrás

También podemos partir una lista y seleccionar sólo una parte de los elementos (slicing):

fam[1:3]
>> [1.73, "emma"]
# el último elemento no se incluye
fam[:3]
>> ["liz", 1.73, "emma"]
# desde el primer elemento hasta el tercero, no incluido
fam[1:]
>> [1.73, "emma", 1.68]
# desde el elemento con índice 1 hasta el final, último elemento incluido

Las listas se pueden manipular con algunas funciones propias. Por ejemplo, podemos cambiar uno o varios datos:

fam[2] = "maria"
fam
>> ["liz", 1.73, "maria", 1.68]
fam[:2] = ["luisa", 1.56]
fam
>> ["luisa", 1.56, "maria", 1.68]

También podemos añadir o borrar elementos:

fam + ["silvia", 1.60]
fam
>> ["luisa", 1.56, "maria", 1.68, "silvia", 1.60]
# los nuevos elementos se añadirán al final
del(fam[0])
fam
>> [1.56, "maria", 1.68, "silvia", 1.60]
# hay que tener cuidado al borrar elementos, ya que luego cambiarán los índices de los elementos que estaban en la lista.

Finalmente, nos advierten del cambio de nombre de las listas, ya que podemos liarla. Veamos el siguiente código:

x = ['a', 'b', 'c']
y = x
y[1] = 'z'
y
>> ['a', 'z', 'c'] #se ha añadido la z tal y como queríamos
x
>> ['a', 'z', 'c'] # pero cuidado, x también ha cambiado!!

# para evitar esto tendremos que hacer lo siguiente

x = ['a', 'b', 'c']
y = list(x)
y = x[:]
y[1] = 'z'
y
>> ['a', 'z', 'c']
x
>> ['a', 'b', 'c']

Functions & Packages

Una función no es más que un trozo de código que podemos reusar, normalmente para resolver una tarea concreta. Los distintos tipos de datos tienen distintas funciones predefinidas en Python.

Algunos ejemplos:

  • type() es una función predefinida que nos dará el tipo de dato de lo que esté entre paréntesis.
  • max() es una función que nos decuelve el número más alto de una lista.
  • round() es una función que redondeará un número float.

Todas las funciones nos devolverán algo cuando las llamemos y les pasemos los correspondientes argumentos (lo que va entre paréntesis), que pueden ser uno o varios. Además algunos argumentos pueden ser opcionales. Podemos ver esto en la documentación de round(), por ejemplo. Aquí vemos que, el número de dígitos será un argumento opcional.

Un método no es más que una función de un objeto concreto. Cada tipo de dato es, a su vez, un objeto de Python, por lo que cada tipo de dato tendrá métodos propios. Por ejemplo:

  • El objeto/tipo de dato string tiene asociados (entre otros muchos) los métodos capitalize() (para convertirlo a mayúsculas) o replace().
  • El objeto/tipo de dato lista tiene asociados (entre otros) los métodos index() o count().

Los paquetes o librerías es un archivo o conjuntos de archivos que se pueden utilizar para hacer una determinada tarea, más compleja que la que podemos realizar con un simple método. Normalmente, cada librería está asociada a un tipo de tarea. Por ejemplo: NLTK es una librería para tareas de procesamiento del lenguaje natural, MatPotLib es una librería para tareas de visualización, etc. Existen miles de librerías o paquetes disponibles. Mejor buscar si ya existe algo disponible antes de ponernos a picar código sin sentido!

Cada script dentro de una librería se llama módulo.

Para instalar una librería o paquete simplemente podemos utilizar «pip» desde la terminal. Una vez instalado, si lo queremos usar en nuestro programa, tendremos que importarlo:

import numpy as np 
# normalmente le pondremos un nombre más corto, para eso usamos el as np

from numpy import array

# usaremos from.. import para importaciones parciales, de solo algún módulo dentro de la librería.

# ejemplos de uso
 np.array([1, 2])

NumPy

Uno de los problemas que presentan las listas es que no se pueden hacer operaciones matemáticas con sus elementos. Esto, y el tiempo de procesamiento, nos lo soluciona la librería NumPy.

En el ejemplo vemos que si definimos la altura y el peso como simples listas y queremos operar con los distintos valores, nos dará error. Esto no ocurre si creamos unos arrays de NumPy a partir de ellas. Una ve creados los arrays de NumPy, estas listas se entederán como vectores y, por tanto, será posible operar con los distintos elementos.

In [13]: height = [1.73, 1.68, 1.71, 1.89, 1.79]
In [14]: weight = [65.4, 59.2, 63.6, 88.4, 68.7]
In [15]: weight / height ** 2
TypeError: unsupported operand type(s) for **: 'list' and 'int'

In [16]: np_height = np.array(height)
In [17]: np_weight = np.array(weight)
In [18]: np_weight / np_height ** 2
Out[18]: array([ 21.852, 20.975, 21.75 , 24.747, 21.441])

Otra diferencia con respecto a las listas es que los arrays de NumPy solo pueden contener elementos de un mismo tipo. Las listas podían estar formadas por datos de distintos tipos (strings, float, boolean…).

Al igual que las listas, los arrays de NumPy pueden ser listas de listas. Para saber qué tipo de matriz tenemos podemos usar la siguiente función:

np_array.shape
>> (2, 5)
# en este caso nos dice que nuestra matriz tendrá dos file y 5 columnas. O, lo que es lo mismo, dos vectores con 5 elementos cada uno.

Para acceder a los elementos de un array de NumPy lo tendremos más fácil que con las listas.

np_2d = np.array([[1.73, 1.68, 1.71, 1.89, 1.79],
[65.4, 59.2, 63.6, 88.4, 68.7]])

np_2d[0]
>> array([ 1.73, 1.68, 1.71, 1.89, 1.79])

np_2d[0][2]
>> 1.71

np_2d[0,2] # fila 0, columna 2
>> 1.71

np_2d[:,1:3] # todas las filas, de la columna 1 a la 3
>> array([[ 1.68, 1.71],
[ 59.2 , 63.6 ]])

np_2d[1,:] # file 1, todas las columnas
>> array([ 65.4, 59.2, 63.6, 88.4, 68.7])

Algunos cálculos de estadística básica que podremos hacer con NumPy son:

  • Media: np.mean()
  • Mediana: np.median()
  • Correlación de coeficientes (?¿): np.corrcoef()
  • Desviación estándar: np.std()

Día 6: funciones, métodos y librerías en Python

Hoy voy a continuar con el módulo 3 de Introduction to Python, de DataCamp.

¿Qué he aprendido hoy?

  • Funciones: trocitos de código reusables que solucionan un problema particular. Ej.: print(), type(), max(), round(), len()…
    • sorted(lista, reverse=False): esto nos ordena los elementos de una lista. Por defecto, estarán en order normal, si los queremos al revés pondremos «reverse=True»
  • Métodos: funciones que pertenecen a un objeto (string, lista, float…).
    • métodos de strings: capitalize(), replace()…
    • métodos de floats: bit_length(), conjugate()…
    • métodos de listas: index(), count()…
fam = ['liz', 1.73, 'emma', 1.68, 'mom', 1.71, 'dad', 1.89]
fam.index('mom') # index de 'mom'
>> 4
fam.count(1.73) # cuántas veces aparece 1.73 en la lista fam
>> 1
  • Paquetes/librerías: algunas librerías útiles para Data Science son: NumPy, MatpotLib, Scikit-learn.
    • No todas las librerías están preintaladas en Python por defecto, así que tendremos que instalarlas si las queremos usar. Usaremos «pip».Una vez intalado el paquete que necesitamos, tendremos que importarlo si queremos usarlo. Ej.: import numpy / import numpy as np (simplemente para simplificar su nombre).Si solo necesitamos una función en concreto, lo explicitaremos en el código. Ej.: from numpy import array.

Hoy he tenido también una entrevista de trabajo, así que no me da tiempo a acabar los dos módulos que me quedan.

Deberes

Acabar el módulo de NumPy, que es el último, para acabar el curso de Introduction to Python.

Día 5: vuelta a los básicos

Hoy tenía muchas ganas de continuar con el siguiente módulo de «NLP fundamentals with Python«. Sin embargo, he visto que en la descripción de este curso dicen que deberías haber hecho los siguientes cursos como prerequisitos:

  • Introducción a Python
  • Python intermedio para Data Science
  • Python Data Science Toolbox 1
  • Python Data Science Toolbox 2

Vamos, que te empapes de Python y luego hagas cosas más específicas. Es cierto, que ya conozco Python (de hecho, he podido seguir bien el primer módulo), pero he decidido que esta vez voy a hacerlo bien y en orden, así que esta tarde me he puesto a hacer los cursos que son prerequisitos de este otro.

He empezado con Introduction to Python, que tiene 4 módulos:

  • Python Basics: completado. Muy muy básico, lo he hecho en unos 20 minutos. Generalidades, variables, print, tipos de datos.
  • Python Lists: completado. colecciones de valores de distintos tipos.
    • lista = [dato, dato, dato…].
    • Listas de listas.
    • Las listas en sí mismas son un tipo de dato (podemos acceder a él con type(list’s name), en concreto un compound data type.
    • Cómo acceder a los elementos de una lista: index (lista[index]) o slicing (list[start index:end index]). Ojo, el start index está incluido, pero el end index no. Si no añadimos un index de inicio, se sobreentiende que empieza desde cero. Si no añadimos el index de final, se sobreentiende que llega hasta el final (incluido).
    • Manipulación de listas (añadir, cambiar o eliminar elementos)
  • Functions and Packages
  • NumPy

La verdad es que, aunque muchas cosas ya las conocía (al menos del curso básico), está bien porque está muy orientado a Data Science, en concreto. He tardado 1 hora aprox. en completar los dos primeros módulos de Introduction to Python.

Finalmente, cotilleando un poco la web de Data Camp, he visto que en el área de community tienen también un montón de tutoriales. Además, aparte de los cursos hay también una serie de proyectos

Deberes

Acabar los módulos que me quedan de Introduction to Python para poder continuar con los otros tres también. ¡Me lo estoy pasando pipa, la verdad! 😀

Día 3: Regular Expressions & Word Tokenization

Hoy me he inscrito en Data Camp. He visto que hay algunos cursos específicos de Python con NLP. Justo lo que necesito ahora mismo. La suscripción a los cursos es de unos 33$ al mes, así que me parece razonable también.

He empezado el curso «Natural Language Processing Fundamentals with Python«. Estoy con el módulo 1, que es gratuito: Regular expressions & word tokenization. Algunas de estas cosas ya las sé, pero me ha obligado a crearme un Jupyter Notebook nuevo y empezar a trastear. Ya vale de lecturas y podcasts!

¿Qué he aprendido hoy?

REGEX con Python (siempre había trabajado con Regex en Perl)

  • El módulo de Python para expresiones regulares es «re»: import re
  • re.split: nos permite usar la expresión en REGEX como separador. Lo más común es usar el espacio como separador. Por tanto,
    • re.split(‘\s+’, ‘Split on spaces.’) => [‘Split’, ‘on’, ‘spaces.’]
  • re.findall(regex, string) => encuentra todos los casos de esa regex en el texto o string dada.
  • re.search(): el patrón que busquemos puede estar en cualquier parte del string/documento.
  • re.match(): el patrón que busquemos tiene que estar al principio del string.
    • if you need to match at the beginning of the string, or to match the entire string use match. It is faster. Otherwise use search.

TOKENIZATION con Python

  • Un módulo que podemos usar para tokenizar es NLTK.
  • Simplemente lo importamos en Python (import nltk) y dentro de él, usaremos el tokenizador: from nltk import word_tokenize
  • Lo usaremos así: word_tokenize(«Hi there!»)
  • Otros módulos de NLTK que podemos usar para tokenizar el texto:
    • sent_tokenize: separa todo el texto en frases.
    • regexp_tokenize: separa un texto o un string en base a una Regex que le indiquemos.
    • TweetTokenizer: especial para tokenizar tweets (hashtags, menciones, etc.)

Otras notas:

  • Buscar el tutorial de cómo crear un chatbot usando RASA NLU: te dice paso a paso cómo crear y entrenar tu chatbot usando Spacy así que me parece muy interesante para hacerlo como ejercicio.