Cell (celda) pulsando [shift] + [Enter] o presionando el botón Play en la barra de herramientas.[shift] + [tab] después de los paréntesis de apertura function(function?Manipular matrices de numpy es un parte muy importante del aprendizaje automático en Python (en realidad, de cualquier tipo de computación científica). Esto será un repaso para la mayoría. En cualquier caso, repasemos las características más importantes.
In [ ]:
import numpy as np
# Semilla de números aleatorios (para reproducibilidad)
rnd = np.random.RandomState(seed=123)
# Generar una matriz aleatoria
X = rnd.uniform(low=0.0, high=1.0, size=(3, 5)) # dimensiones 3x5
print(X)
(tener en cuenta que los arrays en numpy se indexan desde el 0, al igual que la mayoría de estructuras en Python)
In [ ]:
# Acceder a los elementos
# Obtener un único elemento
# (primera fila, primera columna)
print(X[0, 0])
# Obtener una fila
# (segunda fila)
print(X[1])
# Obtener una columna
# (segunda columna)
print(X[:, 1])
In [ ]:
# Obtener la traspuesta
print(X.T)
In [ ]:
# Crear un vector fila de números con la misma separación
# sobre un intervalo prefijado
y = np.linspace(0, 12, 5)
print(y)
In [ ]:
# Transformar el vector fila en un vector columna
print(y[:, np.newaxis])
In [ ]:
# Obtener la forma de un array y cambiarla
# Generar un array aleatorio
rnd = np.random.RandomState(seed=123)
X = rnd.uniform(low=0.0, high=1.0, size=(3, 5)) # a 3 x 5 array
print(X)
print(X.shape)
print(X.reshape(5, 3))
In [ ]:
# Indexar según un conjunto de números enteros
indices = np.array([3, 1, 0])
print(indices)
X[:, indices]
Hay mucho más que aprender, pero esto cubre algunas de las cosas fundamentales que se tratarán en este curso.
No utilizaremos demasiado las matrices dispersas, pero son muy útiles en múltiples situaciones. En algunas tareas de aprendizaje automático, especialmente en aquellas asociadas con análisis de textos, los datos son casi siempre ceros. Guardar todos estos ceros es muy poco eficiente, mientras que representar estas matrices de forma que solo almacenemos lo qué no es cero es mucho más eficiente. Podemos crear y manipular matrices dispersas de la siguiente forma:
In [ ]:
from scipy import sparse
# Crear una matriz de aleatorios entre 0 y 1
rnd = np.random.RandomState(seed=123)
X = rnd.uniform(low=0.0, high=1.0, size=(10, 5))
print(X)
In [ ]:
# Poner a cero la mayoría de elementos
X[X < 0.7] = 0
print(X)
In [ ]:
# Transformar X en una matriz CSR (Compressed-Sparse-Row)
X_csr = sparse.csr_matrix(X)
print(X_csr)
In [ ]:
# Convertir la matriz CSR de nuevo a una matriz densa
print(X_csr.toarray())
(puede que encuentres otra forma alternativa para convertir matrices dispersas a densas: numpy.todense; toarray devuelve un array numpy, mientras que todense devuelve una matriz numpy. En este tutorial trabajaremos con arrays numpy, no con matrices, ya que estas últimas no son soportadas por scikit-learn.
La representación CSR puede ser muy eficiente para hacer cómputo, pero no tanto para añadir elementos. Para ello, la representación LIL (List-In-List) es mejor:
In [ ]:
# Crear una matriz LIL vacía y añadir algunos elementos
X_lil = sparse.lil_matrix((5, 5))
for i, j in np.random.randint(0, 5, (15, 2)):
X_lil[i, j] = i + j
print(X_lil)
print(type(X_lil))
In [ ]:
X_dense = X_lil.toarray()
print(X_dense)
print(type(X_dense))
A menudo, una vez creamos la matriz LIL, es útil convertirla al formato CSR (muchos algoritmos de scikit-learn requieren formatos CSR)
In [ ]:
X_csr = X_lil.tocsr()
print(X_csr)
print(type(X_csr))
Los formatos dispersos disponibles que pueden ser útiles para distintos problemas son:
CSR (compressed sparse row).CSC (compressed sparse column).BSR (block sparse row).COO (coordinate).DIA (diagonal).DOK (dictionary of keys).LIL (list in list).El paquete scipy.sparse tienen bastantes funciones para matrices dispersas, incluyendo álgebra lineal, algoritmos de grafos y mucho más.
Otra parte muy importante del aprendizaje automático es la visualización de datos. La herramienta más habitual para esto en Python es matplotlib. Es un paquete extremadamente flexible y ahora veremos algunos elementos básicos.
Ya que estamos usando los libros (notebooks) Jupyter, vamos a usar una de las funciones mágicas que vienen incluidas en IPython, el modo "matoplotlib inline", que dibujará los plots directamente en el libro.
In [ ]:
%matplotlib inline
In [ ]:
import matplotlib.pyplot as plt
In [ ]:
# Dibujar una línea
x = np.linspace(0, 10, 100)
plt.plot(x, np.sin(x));
In [ ]:
# Dibujar un scatter
x = np.random.normal(size=500)
y = np.random.normal(size=500)
plt.scatter(x, y);
In [ ]:
# Mostrar imágenes usando imshow
# - Tener en cuenta que el origen por defecto está arriba a la izquierda
x = np.linspace(1, 12, 100)
y = x[:, np.newaxis]
im = y * np.sin(x) * np.cos(y)
print(im.shape)
plt.imshow(im);
In [ ]:
# Hacer un diagrama de curvas de nivel (contour plot)
# - El origen aquí está abajo a la izquierda
plt.contour(im);
In [ ]:
# El modo "notebook" en lugar de inline permite que los plots sean interactivos
%matplotlib notebook
# Plot en 3D
from mpl_toolkits.mplot3d import Axes3D
ax = plt.axes(projection='3d')
xgrid, ygrid = np.meshgrid(x, y.ravel())
ax.plot_surface(xgrid, ygrid, im, cmap=plt.cm.viridis, cstride=2, rstride=2, linewidth=0);
Hay muchísimos tipos de gráficos disponibles. Una forma útila de explorarlos es mirar la galería de matplotlib.
Puedes probar estos ejemplos fácilmente en el libro de notas: simplemente copia el enlace Source Code de cada página y pégalo en el libro usando el comando mágico %load.
Por ejemplo:
In [ ]:
# %load http://matplotlib.org/mpl_examples/pylab_examples/ellipse_collection.py