Cómo resolver ecuaciones algebraicas en Python con SciPy

Introducción En este artículo vamos a utilizar las rutinas de búsqueda de raíces ya disponibles en el módulo scipy.optimize para resolver ecuaciones algebraicas con Python. Ya vimos hace tiempo cómo encontrar el mínimo de una función con SciPy, y también cómo implementar los métodos de la bisección y de Newton… Leer más »Cómo resolver ecuaciones algebraicas en Python con SciPy

Funciones definidas a trozos con arrays de NumPy

Introducción

Hoy vamos a ver cómo crear funciones definidas a trozos que manejen arrays de NumPy. Seguro que todos conocéis este tipo de funciones, pero a la hora de crearlas en NumPy me encontré con un par de obstáculos en el camino que me gustaría compartir con vosotros.
Como ya sabéis, las funciones definidas a trozos son ubicuas en matemáticas y se utilizan cuando queremos ensamblar varias funciones en una sola. Vamos a ver cómo construirlas en Python utilizando la función numpy.piecewise y vamos a revisar un par de conceptos sobre comparación de arrays e indexación avanzada utilizando valores booleanos. Esto último suena un poco a magia negra pero ya veréis cómo no es para tanto 😛
En esta entrada se ha usado python 2.7.3 y numpy 1.6.2.

Funciones definidas a trozos

La función de NumPy numpy.piecewise acepta, como mínimo, tres argumentos:

  • un array de valores en los que evaluar la función x,
  • una lista de arrays booleanos condlist que son los «trozos» en los que se divide la función, que deben tener la misma forma que x,
  • y una lista de funciones funclist que se corresponden con cada uno de los trozos.

Leer más »Funciones definidas a trozos con arrays de NumPy

Análisis de componentes principales con python

Esta entrada también se podría haber llamado:
‘Reducción de la dimensión’
‘Comprimiendo imágenes usando análisis de componentes principales y python’
Para la siguiente entrada se ha usado python 2.7.2, numpy 1.6.1, matplotlib 1.1.0 y sklearn 0.10

El análisis de componentes principales (PCA, por sus siglas en inglés, Principal Component Analysis) es una técnica que trata de reducir el número de dimensiones (número de variables) de un conjunto de datos intentando, a su vez, conservar la mayor cantidad de información. Es una técnica extremadamente útil como análisis exploratorio de datos (exploratory data analysis, pongo algunos términos en inglés porque a veces pueden resultar extraños en castellano), cuando se tiene demasiada información (muchas dimensiones, variables) y no se puede analizar correctamente la información. Se ha usado de forma exitosa para encontrar patrones, determinar ‘outliers’, compresión de imágenes,… Más adelante se explicará brevemente el proceso matemático que hay detrás.
Para el presente artículo vamos a usar el PCA para obtener imágenes comprimidas. Vamos a trabajar con una imagen monocromática extraída de la galería de AdeRussell en flickr. (con licencia cc 2.0) La imagen en cuestión es la siguiente:

Martin Luther King Memorial and the Washington Monument por AdeRussell

Martin Luther King Memorial and the Washington Monument por AdeRussell


Primero la guardaremos en nuestro equipo usando la biblioteca urllib2 disponible en la biblioteca estándar de vuestra instalación de python:
[sourcecode language=”python”]
import urllib2
## Leemos la imagen desde la url
url = ‘http://farm9.staticflickr.com/8312/8059125132_bed732fcc8_z.jpg’
kk = urllib2.urlopen(url).read()
## Guardamos la imagen en el directorio donde nos encontremos
## con el nombre ‘king.jpg’
imagen = open(‘king.jpg’, ‘wb’)
imagen.write(kk)
imagen.close()
[/sourcecode]
La imagen está en formato jpg, la vamos a leer usando matplotlib y vamos a guardar la información en una matriz 2D (tenemos tres canales (r,g,b) que son iguales (imagen en escala de grises) por lo que solo vamos a usar uno de ellos).
[sourcecode language=”python”]
import numpy as np
import matplotlib.pyplot as plt
## Leemos la imagen como un numpy array
kk = plt.imread(‘king.jpg’)
## Si hacemos kk.shape vemos que existen
## tres canales en la imagen (r, g, b)
## Pero como es una imagen en escala de grises
## Los tres canales tienen la misma información
## por lo que nos podemos quedar con un solo canal
plt.subplot(221)
plt.title(‘canal 1’)
plt.imshow(kk[:,:,0])
plt.subplot(222)
plt.title(‘canal 2’)
plt.imshow(kk[:,:,1])
plt.subplot(223)
plt.title(‘canal 3’)
plt.imshow(kk[:,:,2])
## Vemos que la imagen está rotada, hacemos uso de np.flipud
## http://docs.scipy.org/doc/numpy/reference/generated/numpy.flipud.html
plt.subplot(224)
plt.title(‘canal 1 rotado en BN’)
plt.imshow(np.flipud(kk[:,:,0]), cmap=plt.cm.Greys_r)
plt.show()
## Finalmente, nos quedamos con una única dimensión
## Los tres canales rgb son iguales (escala de grises)
matriz = np.flipud(kk[:,:,0])
[/sourcecode]
Bueno, ahora ya tenemos nuestra imagen como la queremos para poder empezar a trabajar con ella.
¿Cómo se obtienen las componentes principales?
Leer más »Análisis de componentes principales con python

Lanzando proyectiles (con ayuda de vpython)

La mayoría de vosotros habréis resuelto el típico problema del lanzamiento de un proyectil que describe una trayectoria parabólica. Las ecuaciones que describen el movimiento son: Vector posición Vector velocidad con con Hoy vamos a intentar resolverlo de forma gráfica con la ayuda de python y vpython. La biblioteca vpython… Leer más »Lanzando proyectiles (con ayuda de vpython)

Transformada de Fourier discreta en Python con SciPy

Introducción

En este artículo vamos a ver cómo calcular la transformada de Fourier discreta (o DFT) de una señal en Python utilizando la transformada rápida de Fourier (o FFT) implementada en SciPy. El análisis de Fourier es la herramienta fundamental en procesamiento de señales y resulta útil en otras áreas como en la resolución de ecuaciones diferenciales o en el tratamiento de imágenes.
Nota: Puedes ver el artículo en forma de notebook de IPython mediante la herramienta nbviewer.
La transformada rápida de Fourier o FFT es en realidad una familia de algoritmos muy eficientes ($latex O(n \log n)$) para calcular la DFT de una señal discreta, de los cuales el más utilizado es el algoritmo de Cooley-Tukey. Este es el que está implementado en SciPy a través de las subrutinas FFTPACK, escritas en FORTRAN 77, y es el que vamos a utilizar. También podríamos haber utilizado la biblioteca FFTW, más moderna y escrita en C, o la implementación presente en NumPy, que es una traducción a C de FFTPACK y que funciona igual que la de SciPy, pero no lo vamos a hacer.
Nótese que estos métodos no nos permiten calcular ni la serie de Fourier de una función periódica ni la transformada de Fourier de una función no periódica. Estas operaciones forman parte del cálculo simbólico y deben llevarse a cabo con otro tipo de programas, como SymPy o Sage. En Pybonacci puedes leer una introducción a SymPy y cómo calcular series con SymPy, así como una reseña sobre Sage.
En este artículo nos vamos a centrar en el caso unidimensional, aunque el código es fácilmente extrapolable al caso de dos y más dimensiones.
En esta entrada se ha usado python 2.7.3, numpy 1.6.2, scipy 0.10.1 y matplotlib 1.1.1.

Definiciones

Antes de empezar de lleno con las FFTs vamos a hacer una brevísima introducción matemática. He intentado que esto no se convierta en una larga introducción al procesamiento de señales digitales, pero si te interesa el tema y quieres más rigor puedes acudir a cualquiera de las referencias que doy más abajo además de la documentación de scipy.fftpack.
Leer más »Transformada de Fourier discreta en Python con SciPy