Scipy PDF

Curso Python Cientı́fico: Scipy
Módulo 3
Cesar Husillos Rodrı́guez

IAA-CSIC
Septiembre de 2014
Cesar Husillos Rodrı́guez (IAA-CSIC) Curso Python Cientı́fico: Scipy Septiembre de 2014 1 / 130
Índice
1 Introducción
2 Búsqueda de mı́nimos
3 Búsqueda de raı́ces
4 Ajuste de curvas
5 Interpolación
6 Integración
7 Estadı́stica y Distribuciones
8 Álgebra lineal
9 Procesamiento de señales
10 Agrupamiento
11 Magnitudes Fı́sicas
Introducción
Índice
1 Introducción
4 Ajuste de curvas
5 Interpolación
6 Integración
8 Álgebra lineal
10 Agrupamiento
Introducción
¿Qué es SCIPY?
Paquete que extiende la funcionalidad de NUMPY.

SCIPY implementa módulos que realizan tareas de
optimización, integración , agrupamientos, álgebra
lineal... y que dan acceso a funciones especiales,
distribuciones de probabilidad y constantes
cientı́ficas, entre otros.
NOTA: Los ejemplos y ejercicios que se proponen han sido
probados en versiones iguales o superiores a la 0.12 (Mayo 2013 ).
Introducción
subpaquetes SCIPY
Subpaquete Descripción
cluster Algoritmos de clustering
constants Constantes fı́sicas y matemáticas
fftpack Rutinas de Transformadas Rápidas de Fourier
integrate Para integrar y resolver ecuaciones diferenciales ordinarias
interpolate Rutinas de interpolación.
io Entrada y salida (Input/Output)
linalg Álgebra Lineal
maxentropy Métodos de Máxima Entropı́a
ndimage Procesado de imágenes n-dimensionales
odr Ajustes a distancias ortogonales (Orthogonal Distance Regression)
optimize Procedimientos de optimización y búsqueda de ceros en funciones
signal Procesado de señal
sparse Matrices dispersas y rutinas asociadas
spatial Datos con estructura espacial y algorimos
special Funciones especiales
stats Distribuciones estadı́sticas y funciones
weave Integración con C/C++
Introducción
¿Qué vamos a aprender?
1 Determinar los valores mı́nimos de funciones.

2 Localizar las raı́ces de una función.
3 Interpolación n-dimensional.
4 Ajuste de curvas.
5 Integración de funciones multivariables.
6 Estadı́stica descriptiva.
7 Manejar distribuciones estadı́sticas. Verificar qué parámetros de una distribucción se
ajustan a una muestra experimental.
8 Realizar operaciones sobre matrices.
9 Resolver sistemas de ecuaciones lineales.
10 Clasificación de datos.
11 Acceder a información de constantes fı́sicas.
Búsqueda de mı́nimos
Índice
1 Introducción
4 Ajuste de curvas
5 Interpolación
6 Integración
8 Álgebra lineal
10 Agrupamiento
scipy.optimize
Dentro del subpaquete scipy.optimize, la función

minimize(fun, x0[, args=(), method=’BFGS’,
jac=None, hess=None, hessp=None, bounds=None,
constraints=(), tol=None, callback=None,
options=None])
Proporciona una interfaz común para todos los
algoritmos de minimización que se apliquen sobre
funciones escalares multivariables.
Parámetros
minimize
Parámetro Tipo Descripción
fun Función El nombre de una función.
x0 ndarray Punto inicial al partir del se busca el mı́nimo.
args tupla (Opcional) Parámetros extra si los necesitan la fun y sus
derivadas.
method string (Opcional) Método de búsqueda de mı́nimo. Posibles:
’Nelder-Mead’, ’Powell’, ’CG’, ’BFGS’, ’Newton-CG’, ’Anneal’,
’L-BFGS-B’, ’TNC’,’COBYLA’ y ’SLSQP’.
jac Booleano o (Opcional) Si es True se supone que fun devuelve el valor del
función Jacobiano junto al de la función. Si es False, jac se estima
numéricamente. Puede ser una función, en cuyo caso recibe
los mismos parámetros que fun.
hess Función (Opcional) Hessiano de fun. (Sólo para Newton-CG.)
bounds secuencia (Opcional) (Sólo para L-BFGS-B, TNC, COBYLA y SLSQP)
Lı́mites para las variables. Un par
(min|"min"|None, max|"max"|None)
por cada variable de fun.
tol float (Opcional) Tolerancia por debajo de la cual se detienen las
iteraciones.
options dict (Opcional) Las opciones aceptadas por todos los métodos son:
maxiter (int); disp (bool) Si True, info de convergencia.
Ejemplo 1
Minimización
Ejemplo
# Funcion a m i n i m i z a r
def parabola ( x ):
return x ** 2 + 1
# j a c o b i a n o de la funcion
def p a r a b o l a _ d er iv a d a ( x ):
return 2 * x
Método SIMPLEX (Nelder-Mead)

Ejemplo 1
Es la forma más simple de determinar el mı́nimo de una función.

Sólo necesita de una función a evaluar. Es lento.
>>> res = minimize ( parabola , 202.34 , method = ’ nelder - mead ’ , \

options ={ ’ xtol ’: 1e -8 , ’ disp ’: True })
Optimization terminated successfully .
Current function value : 1.000000
Iterations : 38
Function evaluations : 76
>>> res
status : 0
nfev : 76
success : True
fun : 1.0
x : array ([ -9.09494702 e -13])
message : ’ Optimization terminated successfully . ’
nit : 38
Método
Broyden-Fletcher-Goldfarb-Shanno
Ejemplo 1
Converge más rápidamente porque usa el gradiente de la función. Si

no es dado, se estima.
Algoritmo de BFGS
>>> res = minimize ( parabola , 202.34 , method = ’ BFGS ’ , \
options ={ ’ disp ’: True })
Iterations : 4
Gradient evaluations : 5
Método Newton del gradiente conjugado

Ejemplo 1
Algoritmo de Newton-CG
>>> res = minimize ( parabola , 202.34 , method = ’ Newton - CG ’ , \
jac = parabola_derivada , options ={ ’ xtol ’: 1e -8 , ’ disp ’: True })
Iterations : 3
Gradient evaluations : 7
Hessian evaluations : 0
Más rápido aún. Posibilidad de insertar el Hessiano de la

función.
Minimización
scipy.optimize
¿Qué sucede si hay mı́nimos locales?
Minimización
scipy.optimize
Coseno amortiguado
−x
f (x) = cos(x) · e π
Derivada primera (jacobiano)

0 −x 1
f (x) = −e π cos(x) − sin(x)
π
Derivada segunda (hessiano)

00 −x 2sin(x) 1
f (x) = e π + − 1 cos(x)
π π2
Minimización
scipy.optimize. Minimos locales
Coseno amortiguado y dos primeras derivadas

def c o s e n o _ a m o r t i g u a d o ( x ):
return scipy . cos ( x ) * scipy . exp ( - x / scipy . pi )
def c o s _ a m o r t _ d e r i v a d a ( x ):
return -1 * scipy . exp ( - x / scipy . pi ) * \
( scipy . sin ( x ) + scipy . cos ( x ) / scipy . pi )
def c o s _ a m o r t _ d e r i v a d a 2 ( x ):
return scipy . exp ( - x / scipy . pi ) * \
(2 * scipy . sin ( x ) / scipy . pi + \
(( scipy . pi ** -2 - 1) * scipy . cos ( x )))
Minimización
Mı́nimos locales
>>> res = scipy . optimize . minimize ( coseno_amortiguado , \

... scipy . pi / 2 , method = ’ Newton - CG ’ , \
... jac = cos_amort_derivada , hess = cos_amort_derivada2 , \
... options ={ ’ xtol ’: 1e -8 , ’ disp ’: True })
>>> print res [ ’x ’] , res [ ’ fun ’]
[ 2.83342358] [ -0.38667837]
>>>
>>> res1 = scipy . optimize . minimize ( coseno_amortiguado , \
... 3.22 * scipy . pi , method = ’ Newton - CG ’ , \
... jac = cos_amort_derivada , hess = cos_amort_derivada2 , \
... options ={ ’ xtol ’: 1e -8 , ’ disp ’: True })
>>> print res1 [ ’x ’] , res1 [ ’ fun ’]
[ 9.11660888] [ -0.05233123]
Minimización
Mı́nimos locales
¿Qué sucede si hay mı́nimos locales?

El mı́nimo obtenido depende del punto inicial para la
evaluación de la función.
Minimización
Rango restringido de búsqueda
Cuando interesa obtener el valor mı́nimo de una función

en un rango concreto, lo hacemos explı́cito a través del
parámetro bounds de la función minimize.
Válido para métodos: L-BFGS-B, TNC, COBYLA y SLSQP.
bounds es una tupla (de tuplas).
La longitud de la tupla es la misma que el número de variables de la función.
Para cada variable independiente, los lı́mites se dan como una tupla de valores (min,
max).
Como ejemplo, para la función
f (x, y , z) = x 2 + xy + 3z
bounds serı́a algo ası́ como
((1, 5), (None, 4), (None, None))
donde x ∈ [1, 5], y ∈ (−∞, 4) y z puede tomar cualquer valor.

Minimización
Rango restringido para búsqueda de minimos. Ejemplo
>>> import scipy

>>> import scipy . optimize
>>> from matplotlib import pyplot
>>> res = scipy . optimize . minimize ( lambda x : x ** 2 + 1 , 2 , \
... method = ’L - BFGS - B ’ , bounds =((1 , None ) ,))
>>> print res
status : 0
success : True
nfev : 2
fun : array ([ 2.])
x : array ([ 1.])
message : ’ CONVERGENCE : NORM_OF_PROJECTED_GRADIENT_ <= _PGTOL ’
jac : array ([ 1.99999999])
nit : 1
>>> x = scipy . linspace (0 , 3 , 40)
>>> y = x ** 2 + 1
>>> pyplot . plot (x , y )
>>> pyplot . plot ( res [ ’x ’] , res [ ’ fun ’] , ’ ro ’)
>>> pyplot . axvline (1 , color = ’g ’)
>>> pyplot . title ( ’ Constrained bounds in minimization ’)
>>>Husillos
Cesar pyplot . show
Rodrı́guez ()
(IAA-CSIC) Curso Python Cientı́fico: Scipy Septiembre de 2014 20 / 130
Minimización
Rango restringido para búsqueda de minimos. Ejemplo
Ejercicios
Ejercicios 1 y 2
http://www.iaa.es/python/cientifico/ejercicios/scipy
Búsqueda de raı́ces
Índice
1 Introducción
4 Ajuste de curvas
5 Interpolación
6 Integración
8 Álgebra lineal
10 Agrupamiento
(scipy.optimize)
1 Para una funcion escalar.

Se trata de buscar las coordenadas para las cuales la función
toma valores nulos.
2 Para un conjunto de ecuaciones.
En este caso, se trata de encontrar los puntos de corte de las
funciones definidas por las ecuaciones.
(scipy.optimize)
Dentro del subpaquete scipy.optimize, la función

scipy.optimize.root(fun, x0, args=())
Permite resolver ecuaciones escalares y sistemas de
ecuaciones (lineales o no).
fun Función El nombre de una función.
x0 ndarray Punto inicial al partir del se busca la raı́z.
args tupla Parámetros extra si los necesitan la fun y sus derivadas.
Ecuación escalar
Trabajamos con una función sobradamente conocida: sin(x). Se

trata de resolver la ecuación
sin(x) = 0
Ecuación escalar
Siempre que hay un punto de evaluacion inicial, el resultado

dependerá de esa eleccion.
Podemos obviar esa dificultad evaluando en múltiples puntos
del dominio de la función considerado en la forma:
>>> import scipy

>>> res = scipy . optimize . root ( scipy . sin , [ -1 , 0 , 1])
donde, como hemos visto, res es un diccionario. Sus claves son:
>>> res . keys ()

... [ ’ status ’ , ’ success ’ , ’ qtf ’ , ’ nfev ’ , ’r ’ , ’ fun ’ , ’x ’ ,
... ’ message ’ , ’ fjac ’]
Ecuación escalar
De las claves del diccionario res interesan

fun, que da el resultado de la función evaluada en las raı́ces.
(Los valores obtenidos serán 0 o muy cercanos a 0.)
x, que da las coordenadas de las raices de la funcion.
En nuestro caso...
>>> res [ ’x ’]
... array ([ -3.14159265 , 0. , 3.14159265])
>>> res [ ’ fun ’]
... array ([ 2.42794333 e -13 , 0.00000000 e +00 , 2.43483352 e -13])
Ecuación escalar
Grafico las raı́ces obtenidas
Sistema de ecuaciones
Resolver un sistema de ecuaciones implica obtener los valores de x e

y que cumplen de forma simultánea todas las ecuaciones del
conjunto.
Tomemos como ejemplo, el siguiente sistema
y = sin(x)
y = 0,1 · x + 0,3
en el intervalo de x ∈ [−5, 5].
>>> import scipy

>>> x = scipy . linspace ( -5 , 5 , 100)
>>> y = scipy . sin ( x )
>>> y2 = 0.1* x +0.3
>>> pyplot . plot (x , y , ’r - ’ , x , y2 , ’b - ’)
>>> pyplot . title ( ’ Sistema de ecuaciones ’)
>>> pyplot . grid ( True )
>>> pyplot . show ()
Problema: obtener los puntos de corte
Dado el sistema
y = sin(x)
y = 0,1 · x + 0,3
tengo que localizar las raı́ces de la ecuación
sin(x) − 0,1 · x − 0,3 = 0
y eso, sabemos hacerlo :-)
>>> import scipy

>>> def func ( x ):
... return scipy . sin ( x ) - 0.1 * x - 0.3
...
>>> x0s = scipy . linspace ( -5 , 5 , 5)
>>> sol = scipy . optimize . root ( func , x0s )
>>> print sol [ ’x ’]
... [ -14.0099837 , -3.13130629 , 0.34024025 , 2.55290884 ,
14.03909441]
>>> abool = ( -5 <= sol [ ’x ’ ]) & ( sol [ ’x ’] <= 5) # filtro en i n t e r v a l o
>>> nx = scipy . compress ( abool , sol [ ’x ’ ])
>>> ny = scipy . sin ( nx )
>>> # Grafico
>>> pyplot . plot (x , y , ’r - ’)
>>> pyplot . plot (x , y2 , ’b - ’)
>>> pyplot . plot ( nx , ny , ’ go ’)
>>> pyplot . grid ( True )
>>> pyplot . legend ([ ’ sin ( x ) ’ , ’ 0.1* x +0.3 ’ , ’ raices ’ ])
Ecuación escalar
Solución al sistema de ecuaciones
Ejercicios
Ejercicio 3
Ajuste de curvas
Índice
1 Introducción
4 Ajuste de curvas
5 Interpolación
6 Integración
8 Álgebra lineal
10 Agrupamiento
Ajuste de curvas
Ajuste de curvas
scipy.optimize.curve fit
De nuevo dentro del subpaquete scipy.optimize, la función

scipy.optimize.curve fit(func, xdata, ydata, p0=None)
emplea un ajuste por mı́nimos cuadrados no lineales para establecer
los parámetros de la función func que mejor se ajustan a los datos
(xdata, ydata).
El parámetro p0 es una tupla que representa los valores iniciales
para los parámetros de func.
Devuelve una tupla de 2 elementos:
el primer elemento es un array con los parámetros de la
función que minimizan la suma cuadrática de los errores.
la matriz de covarianza de la solución. La diagonal corresponde
a las varianzas de cada uno de los parámetros.
Ajuste de curvas
Ajuste de curvas
Ajuste la función con ruido normal gausiano escalado por 0.5 a la

función y = 3 · e −x + 2 · x.
>>> def func_fit (x , a , b ):

... return a * scipy . exp ( - x ) + b * x
...
>>> x = scipy . linspace (0 , 10 , 100)
>>> y = 3 * scipy . exp ( - x ) + 2 * x
>>> noise = scipy . randn (100) * 0.5
>>> y += noise
>>> res = scipy . optimize . curve_fit ( func_fit , x , y )
>>> print res
( array ([ 2.97253275 , 1.99997092]) , array ([[ 3.61334133 e -02 ,
-1.06635306 e -04] ,
[ -1.06635306 e -04 , 5.89627071 e -05]]))
Ajuste de curvas
Ajuste de curvas
Ajuste de curvas
Ejercicios
Ejercicio 4
Interpolación
Índice
1 Introducción
4 Ajuste de curvas
5 Interpolación
6 Integración
8 Álgebra lineal
10 Agrupamiento
Interpolación
Interpolación
scipy.interpolate
Definiciones
“En el subcampo matemático del análisis
numérico, se denomina interpolación a la obtención
de nuevos puntos partiendo del conocimiento de un
conjunto discreto de puntos.”
“En ingenierı́a y algunas ciencias es frecuente
disponer de un cierto número de puntos obtenidos
por muestreo o a partir de un experimento y
pretender construir una función que los ajuste.”
Obtenidas de la Wikipedia (http://es.wikipedia.org/wiki/Interpolación)
Interpolación
Interpolación
scipy.interpolate
Hay dos formas básicas de interpolación:

1 Ajustar todo el conjunto de datos a una función.
2 Ajustar diferentes subconjuntos a distintas
funciones.
El tipo 2 se denomina interpolación con splines. Se
emplea sobre todo cuando la forma funcional de los
datos es compleja.
Veremos ejemplos de todos estos tipos.
Interpolación
Interpolación
Splines
Una función spline está formada por varios polinomios,

cada uno definido sobre un subintervalo, que se unen
entre sı́ obedeciendo a ciertas condiciones de continuidad.
Supongamos que disponemos de n + 1 puntos, a los que
denominaremos nudos, tales que t0 < t1 < ... < tn . Supongamos
además que se ha fijado un entero k > 0. Decimos entonces que una
función spline de grado k con nudos en t0 , t1 , ..., tn es una función
S que satisface las condiciones:
1 en cada intervalo (ti−1 , ti ), S es un polinomio de grado menor
o igual a k.
2 S tiene una derivada de orden (k − 1) continua en [t0 , tn ].
Interpolación
Interpolación-1D: sobre muestra completa

scipy.interpolate.interp1d
Para interpolar todos los datos de una función unidimensional

usaremos
scipy.interpolate.interp1d(x, y, kind=’linear’)
x array Array de números ordenados de forma monótona creciente.
y array Array o matrı́z de valores reales. El tamaño de y a lo largo
del eje de interpolación debe ser el mismo que el de x.
kind string o Si es string puede tomar valores entre: ‘linear’,’nearest’,
entero ‘zero’, ‘slinear’, ‘quadratic’ o ‘cubic’. Si es entero
especifica el orden del spline usado para interpolar.
axis entero Especifica el eje del array N-dimensional y a usar.
Devuelve una función. Cuando se la llama (pasándole nuevas

coordenadas), devuelve los valores interpolados.
Interpolación
Ejemplo 1
Código del ejemplo

>>> from scipy . interpolate import interp1d
>>> x = scipy . array ([ -1 , 0 , 1 , 2])
>>> y = scipy . exp ( x )
>>> flin = interp1d (x , y )
>>> fqua = interp1d (x , y , kind = ’ quadratic ’)
>>> fcub = interp1d (x , y , kind = ’ cubic ’)
>>> fnea = interp1d (x , y , kind = ’ nearest ’)
>>> newx = scipy . arange ( -1 , 2 , 0.2)
>>> newylin = flin ( newx )
>>> newyqua = fqua ( newx )
>>> newycub = fcub ( newx )
>>> newynea = fnea ( newx )
Interpolación
Ejemplo 1
Interpolación
Interpolación-1D: uso de splines

scipy.interpolate.UnivariateSpline
scipy.interpolate.UnivariateSpline(x, y, w=None,
bbox=[None, None], k=3, s=None)
x array Array 1D, ordenados de forma monótona creciente.
y array Array 1D de valores de la variable dependiente. Mismo número de
w array Array 1D de pesos para el ajuste con splines.
Si toma valor None (por defecto), todos los pesos son iguales.
bbox (tupla, (Opcional) Especifica los lı́mites del intervalo a
lista o array) interpolar. Si vale None (por defecto), bbox=[x[0], x[-1]]
k entero (Opcional) Grado de suavizado del spline (≤ 5).
s float (Opcional) Factor de suavizado empleado para elegir el número de
nodos. Dicho número aumenta hasta que la condición de
suavizado se alcanza:
sum((w[i]*(y[i]-s(x[i])))**2,axis=0) <= s
Si vale None (por defecto) s = len(w )
Devuelve una función. Cuando se la llama (pasándole nuevas

coordenadas), devuelve los valores interpolados.
Interpolación
Ejemplo 2

>>> import scipy
>>> import scipy . interpolate
>>> x = scipy . linspace (0 , 10 , 10) # muestra inicial
>>> y = x ** 3 * scipy . sin (2 * x ) - 9 * x ** 2 - 2.
>>> # interpolate
>>> sp1d = scipy . interpolate . U n i v a r i a t e S p l i n e (x , y )
>>> nx = scipy . linspace (0 , 10 , 100) # nueva muestra
>>> ny = sp1d ( nx )
>>> pyplot . plot (x , y , ’r . - ’)
>>> pyplot . plot ( nx , ny , ’b - ’)
>>> pyplot . title ( ’ Spline 1 D interpolation ’)
>>> pyplot . legend ([ ’ original ’ , ’ interpolated ’] , numpoints =1)
Interpolación
Ejemplo2
Interpolación
Interpolación
Splines con datos ruidosos
¿Podemos interpolar datos con ruido usando splines?

Sı́, haciendo uso del factor de suavizado (parámetro s) de la función
UnivariateSpline.
scipy.interpolate.UnivariateSpline(x, y, w=None,
bbox=[None, None], k=3, s=None)
Interpolación
Ejemplo 3
Interpolación-1D: uso de splines con datos ruidosos

>>> x = scipy . linspace (0 , 10 , 20)
>>> y = scipy . cos ( x ) * scipy . exp ( - x ) + 1
>>> y += scipy . rand (20) * 2 # noise data
>>> sp1d = scipy . interpolate . U n i v a r i a t e S p l i n e (x , y )
>>> sp1d_s1 = scipy . interpolate . U n i v a ri a t e S p l i n e (x , y , s =1)
>>> sp1d_s2 = scipy . interpolate . U n i v a ri a t e S p l i n e (x , y , s =2)
>>> # nuevas m u e s t r a s
>>> nx = scipy . linspace (0 , 10 , 100)
>>> ny = sp1d ( nx )
>>> ny_s1 = sp1d_s1 ( nx )
>>> ny_s2 = sp1d_s2 ( nx )
>>> pyplot . plot (x , y , ’r . - ’ , lw =2 , alpha =0.5)
>>> pyplot . plot ( nx , ny , ’b - ’)
>>> pyplot . plot ( nx , ny_s1 , ’g - ’)
>>> pyplot . plot ( nx , ny_s2 , ’m - ’)
>>> pyplot . title ( ’ Spline 1 D interpolation ’)
>>> pyplot . legend ([ ’ original ’ , ’s = None ’ , ’s =1 ’ , ’s =2 ’] , numpoints =1)
Interpolación
Ejemplo3
Interpolación-1D: uso de splines con datos ruidosos
Interpolación
Interpolación-2D
scipy.interpolate.griddata
scipy.interpolate.griddata(points, values,
xi, method=’linear’, fill value=nan)
points array Coordenadas. Array de forma (n, D), o una tupla de ndim arrays.
values array Valores asignados a las coordenadas dadas por points. Dimensión (n, ).
xi array Forma (M, D). Puntos en los que interpolar.
method string (Opcional). Método de interpolación. Valores posibles: nearest, linear o
cubic.
fill value float (Opcional) Valor usado para la región fuera de la zona de interpolación
definida por points.
Si no se da, se toma nan. No tiene efecto para el método nearest.
Devuelve el conjunto de datos interpolados en xi.
Interpolación
Ejemplo4
Interpolación-2D
import scipy
from scipy . interpolate import griddata
def func (x , y ): # funcion a i n t e r p o l a r

return ( scipy . sin ( x ) + scipy . cos ( y )) * 10
intvx = scipy . linspace (0 , 10 , 100)

intvy = scipy . linspace (0 , 10 , 200)
grid_x , grid_y = scipy . meshgrid ( intvx , intvy )
points = scipy . random . rand (1000 , 2) * 10
values = func ( points [: , 0] , points [: , 1])
grid_z0 = griddata ( points , values , ( grid_x , grid_y ) , \
method = ’ nearest ’)
method = ’ linear ’)
method = ’ cubic ’)
Interpolación
Ejemplo4
Interpolación-2D (Continuación)
# plotting
pyplot . subplot (221)
pyplot . imshow ( func ( grid_x , grid_y ). T , extent =(0 , 10 , 0 , 10) , \
origin = ’ lower ’)
pyplot . plot ( points [: , 0] , points [: , 1] , ’k . ’ , ms =1)
pyplot . title ( ’ Original ’)
pyplot . imshow ( grid_z0 .T , extent =(0 , 10 , 0 , 10) , origin = ’ lower ’)
pyplot . title ( ’ Nearest ’)
pyplot . title ( ’ Linear ’)
pyplot . title ( ’ Cubic ’)
pyplot . gcf (). s et _ si ze _i n ch es (6 , 6)
pyplot . show ()
Interpolación
Ejemplo4
Interpolación-2D (Continuación)
Interpolación
Interpolación-2D
scipy.interpolate.SmoothBivariateSpline
scipy.interpolate.SmoothBivariateSpline(x, y,
z, w=None, bbox=[None, None, None, None],
kx=3, ky=3, s=None)
x array Coordenadas en x.
y array Coordenadas en y.
z array Coordenadas en z.
w array (Opcional). Secuencia de pesos. Misma dimensión que x, y y z.
bbox float (Opcional) Secuencia de tamaño 4, con los valores que limitan el dominio
de x e y. Valores por defecto:
bbox=[min(x),max(x), min(y),max(y)]
kx entero (Opcional) Grado del spline en x. Por defecto 3.
ky entero (Opcional) Grado del spline en y. Por defecto 3.
s float (Opcional) Valor positivo para el factor de suavizado.
Devuelve la función de interpolación.
Interpolación
Ejemplo5
Interpolación-2D con splines
import scipy
from scipy . interpolate import S m o o t h B i v a r i a t e S p l i n e
def func (x , y ):
return ( scipy . sin ( x ) + scipy . cos ( y )) * 10
intvx = scipy . linspace (0 , 10 , 100) # dominio de la grafica
intvy = scipy . linspace (0 , 10 , 200)
points = scipy . random . rand (1000 , 2) * 10 # puntos para i n t e r p o l a r
z = func ( points [: , 0] , points [: , 1])
spline2d = S m o o t h B i v a r i a t e S p l i n e ( points [: , 0] , points [: , 1] , z , \
s =0.01 , kx =4 , ky =4)
Interpolación
Ejemplo5
Interpolación-2D con splines (Continuación)
# plotting
pyplot . imshow ( func ( grid_x , grid_y ). T , extent =(0 , 10 , 0 , 10) , \
pyplot . plot ( points [: , 0] , points [: , 1] , ’k . ’ , ms =1)
pyplot . title ( ’ Original ’)
pyplot . imshow ( spline2d ( intvx , intvy ) , extent =(0 , 10 , 0 , 10) , \
pyplot . title ( ’ spline 2 D ’)
pyplot . gcf (). s et _ si ze _i n ch es (6 , 3)
pyplot . show ()
Interpolación
Ejemplo5
Interpolación-2D con splines (Continuación)
Interpolación
Ejercicios
Ejercicios 5 y 6
Integración
Índice
1 Introducción
4 Ajuste de curvas
5 Interpolación
6 Integración
8 Álgebra lineal
10 Agrupamiento
Integración
Integración
scipy.integrate
El subpaquete scipy.integrate proporciona

rutinas para integrar funciones de una o varias
variables.
También para integrar ecuaciones diferenciales
ordinarias.
Integración
Integración en una variable

scipy.integrate.quad
La función
quad(func, a, b, args=())
sirve para integrar la función func de una variable entre
dos puntos (a y b). args es una tupla con parámetros
adicionales para func.
Los lı́mites de integración pueden ser scipy.inf para
indicar los lı́mites infinitos.
Retorna una tupla:
(valor de la integral, estimación del error absoluto
en el resultado)
Integración
Integración en una variable

scipy.integrate.quad
>>> def const ( x ):

... return 1
...
>>> import scipy . integrate
>>> # Funcion constante , de valor 1, en [0 , 1]
>>> # Es un CUADRADO
>>> res = scipy . integrate . quad ( const , 0 , 1)
>>> print res
(1.0 , 1.1102230246251565 e -14)
Integración
Integración
scipy.integrate
Hemos integrado una función analı́tica. Lo normal en

investigación cientı́fica es obtener medidas en función de
uno o varios parámetros. Para obtener la integral en
estos casos, se emplea la función
scipy.integrate.trapz(y, x=None, dx=1.0)
y array Conjunto de puntos a integrar.
x array (Opcional) Si es None es espacio entre puntos es dx.
dx escalar Si x=None, dx es el espacio entre puntos. Por defecto se asume 1.0.
Devuelve el valor de la integral obtenida por el método
de la regla trapezoidal.
Integración
Integración analı́tica vs. numérica

scipy.integrate.quad vs. scipy.integrate.trapz
>>> import scipy

>>> from scipy . integrate import quad , trapz
x = scipy . sort ( scipy . randn (1000) * 5). clip (1 , 4)
>>> def func2 ( x ):
... return scipy . absolute ( scipy . exp ( - x ) * scipy . cos ( x * 3))
>>> an_sol = quad ( func2 , 1 , 4)[0]
>>> nu_sol = trapz ( func2 ( x ) , x = x )
>>> print ’ Soluciones ( analitica , numerica ) = ( %7.6 f , %7.6 f ) ’ % \
( an_sol , nu_sol )
>>> nx = scipy . linspace (0 , 5 , 200)
>>> pyplot . plot ( nx , func2 ( nx ))
>>> pyplot . fill_between ( nx , 0 , func2 ( nx ) , where =( nx >=1)&( nx <=4))
Salida por pantalla:

Soluciones (analitica, numerica) = (0.231357, 0.231502)
Integración
Ejemplo5
Integración analı́tica vs. numérica (Continuación)
Integración
Integración doble
scipy.integrate.dblquad
La función
dblquad(func, a, b, gfun, hfun, args=())
sirve para integrar una función func de dos variables:
func, es la función a integrar (dependiente de 2 variables)
a y b, son los lı́mites de integración en x (a < b)
gfun, es una función de y , que depende sólo de una variable
(x), que funciona como lı́mite inferior de integración para y .
hfun, es la función que determina el lı́mite superior de
integración para y (de nuevo, como función sólo de x).
args, es una tupla con los parámetros adicionales de la
función func.
Integración
Integración doble
Volumen un cubo de lado parametrizable)

>>> import scipy
>>> import scipy . integrate
>>> def cubo (y , x , lado ):
... return lado
...
>>> for lado in range (1 , 4):
... res = scipy . integrate . dblquad ( cubo , 0 , lado , \
... lambda x : 0 , lambda x : lado , args =( lado ,))
... print ’ Cubo de lado = %d --> Volumen = ’ % lado , res
Salida:
Cubo de lado = 1 --> Volumen = (1.0 , 1 . 1 1 0 2 2 3 0 2 4 6 2 5 1 5 6 5 e -14)
Cubo de lado = 2 --> Volumen = (8.0 , 8 . 8 8 1 7 8 4 1 9 70 0 1 2 5 2 e -14)
Cubo de lado = 3 --> Volumen = (27.0 , 2 . 9 9 7 6 0 2 1 6 6 4 8 7 9 2 2 7 e -13)
Integración
Integración doble
Reto
¿Se atreve a obtener el volumen de una esfera?
Integración
Integración triple
scipy.integrate.tplquad
La función
scipy.integrate.tplquad(func, a, b, gfun,
hfun, qfun, rfun, args=())
sirve para realizar integrales triples en funciones func de
tres variables (x, y , z):
func, es la función a integrar (dependiente de 3 variables).
a y b, son los lı́mites de integración en x e y (a < b).
gfun, es una función de y , dependiente de x, que funciona como lı́mite inferior de
integración para y .
hfun, lı́mite superior de integración para y .
qfun, superficie(x, y) que funciona como lı́mite inferior para la variable z.
rfun, mismas caracterı́sticas que qfun, pero con funciones de lı́mite superior para la
variable z.
Retorna una tupla: (integral, estimación del error

absoluto del resultado)
Integración
Integración triple
scipy.integrate.tplquad
f (x, y , z) = y · sin(x) + z · cos(x) en la región 0 ≤ x ≤ π,

0 ≤ y ≤ 1, −1 ≤ z ≤ 1
from scipy . integrate import tplquad
import numpy as np
def integrand (z , y , x ):
return y * np . sin ( x ) + z * np . cos ( x )
ans , err = tplquad ( integrand , \

... 0 , np . pi , # x limits
... lambda x : 0 , lambda x : 1 , # y limits
... lambda x , y : -1 , lambda x , y : 1) # z limits
print ans
Salida
2.0
Integración
Ejercicios
Ejercicios 7, 8 y 9
Estadı́stica y Distribuciones
Índice
1 Introducción
4 Ajuste de curvas
5 Interpolación
6 Integración
8 Álgebra lineal
10 Agrupamiento
Estadı́stica descriptiva
Valores centrales y medidas de dispersión
SCIPY se basa en NUMPY adoptando las funciones de las que éste

dispone para caracterizar medidas de valores centrales y dispersión
de un array cualquiera.
Función Descripción
scipy.average(a, axis=None, Devuelve un escalar o array con la media “pesada” del
weights=None) array a por los valores “weights” en el eje “axis”
seleccionado.
scipy.mean(a, axis=None) Devuelve un escalar o array con la media aritmética
del array sobre el “axis” dado.
scipy.median(a, axis=None) Devuelve un escalar o array con la mediana del array para
el eje seleccionado.
scipy.std(a, axis=None) Devuelve un escalar o array con la desviación estándar
en el “axis”.
scipy.var(a, axis=None) Devuelve un escalar o array con la varianza de los
elementos en “axis” eje seleccionado.
Distribuciones de probabilidad
scipy.stats
SCIPY dispone de un número enorme de distribuciones de

probabilidad, tanto discretas (12 distribuciones) como contı́nuas
(unas 84).
(Consultar documentación)
Entre las posibilidades más atractivas están
1 Capacidad de generar muestras aleatorias de cualquiera de
esas casi 100 disponibles.
2 Dada una muestra aleatoria obtenida experimentalmente,
determinar los parámetros de una determinada distribución que
mejor ajustan.
scipy.stats
scipy.stats
De los métodos disponibles de las distribuciones, los que más nos

interesan son:
Método Descripción
rvs(loc=0, scale=1, size=1) Genera una muestra aleatoria de esta distribución.
El tamaño viene dado size.
pdf(x, loc=0, scale=1) Función Densidad de Probabilidad.
cdf(x, loc=0, scale=1) Función de distribución acumulativa.
ppf(q, loc=0, scale=1) Percentil.
stats(loc=0, scale=1, Devuelve la media, varianza, sesgo (de Fisher) o kurtosis
moments=’mv’) (de Fisher), según el valor de moments:
media(‘m’), varianza(‘v’), sesgo(‘s’), y kurtosis(‘k’)
fit(data, loc=0, scale=1) Estima parámetros de la distribución a partir de data.
scipy.stats
>>> import scipy . stats

>>> print scipy . stats . norm . cdf ( scipy . array ([ -2 , 0 , 2]))
[ 0.02275013 0.5 0.97724987]
>>> print scipy . stats . norm . stats ( moments = " mvsk " )
( array (0.0) , array (1.0) , array (0.0) , array (0.0))
>>> print scipy . stats . norm . ppf (0.5) # mediana = p e r c e n t i l 50
0.0
>>> print scipy . stats . norm . rvs ( size =3) # muestra de 3 e l e m e n t o s
[ 1.37629104 0.24356188 -1.7217918 ]
>>> sample = scipy . stats . norm . rvs ( loc =3 , scale =2 , size =3)
>>> print sample
[ 4.79340559 3.46683487 4.74428621]
>>> print sample . mean () , sample . std () , sample . var ()
4.33484222524 0.6141 01380386 0. 37712050 5392
>>> a = scipy . stats . norm . rvs ( loc =4 , scale =0.5 , size =1000)
>>> print scipy . stats . norm . fit ( a )
(4.0141137335638515 , 0 . 4 9 4 6 1 5 2 0 1 0 1 0 1 4 1 5 6 )
scipy.stats. Funciones Útiles
Obtener la media, varianza y desviación estándar con

errores de estimación.
scipy.stats.bayes mvs(data, alpha=0.9)
data array Muestra. Si es multidimensional, lo pasa a 1D.
Necesita de 2 puntos como mı́nimo.
alpha float (Opcional) Probabilidad de que el intervalo de confianza contenga
el valor verdadero.
Retorna una tupla: (mean cntr, var cntr, std cntr)
donde cada elemento es una tupla con el siguiente formato:
(valor dentral, (mı́nimo, máximo) de intervalo de
confianza)
scipy.stats. Funciones Útiles
Se puede eliminar outliers de la muestra mediante

sigmaclipping.
scipy.stats.sigmaclip(a, low=4.0, high=4.0)
El array de salida contiene los elementos que verifican
mean(a) − std(a) ∗ low < a < mean(a) + std(a) ∗ high
a array Muestra.
low float (Opcional) Factor de escala inferior para el clipping.
high float (Opcional) Factor de escala superior para el clipping.
Retorna una tupla:
(array filtrado, lı́mite inferior de filtrado, limite
superior de filtrado)
scipy.stats. Funciones Útiles (continuación)
Se puede truncar la muestra a un lı́mite inferior o

superior (o ambos).
scipy.stats.threshold(a, threshmin=None,
threshmax=None, newval=0)
a array Muestra.
threshmin float, int, None (Opcional) Valor mı́nimo de la muestra.
threshmax float, int, None (Opcional) Valor máximo de la muestra
newval float, int (Opcional) Reemplazo para valores fuera de los limites.
Retorna el array de la misma longitud que el de entrada.
Los valores fuera de los lı́mites son sustituı́dos por
newval.
Ejercicios
Ejercicios 10 y 11
Álgebra lineal
Índice
1 Introducción
4 Ajuste de curvas
5 Interpolación
6 Integración
8 Álgebra lineal
10 Agrupamiento
Álgebra lineal
Álgebra lineal
scipy.linalg
scipy.linalg contiene y amplı́a las

funcionalidades de numpy.linalg.
las rutinas están construidas sobre las librerı́as
optimizadas ATLAS, LAPACK y BLAS, lo cual
garantiza el resultado y un rendimiento en
operaciones espectacular.
Álgebra lineal
Producto escalar de matrices

scipy.dot
scipy.dot(array1, array2)
Las dimensiones han de ser compatibles.
>>> from scipy import linalg
>>> A = scipy . arange (1 , 7). reshape ((2 ,3))
>>> A . shape
(2 , 3)
>>> b = scipy . ones (3)
>>> b . shape
(3 ,)
>>> b = scipy . array ([ b ])
>>> b . shape
(1 , 3)
>>> prod = scipy . dot (A , b . transpose ())
>>> print prod . T
[[ 6. 15.]]
>>> print prod . shape
(2 , 1)
Álgebra lineal
Inversa de una matriz

scipy.linalg.inv
scipy.linalg.inv(ndarray)

>>> A
array ([[1 , 2] ,
[3 , 4]])
>>> B = linalg . inv ( A )
>>> B
array ([[ -2. , 1. ] ,
[ 1.5 , -0.5]])
>>> A . dot ( B ) # v e r i f i c a c i o n
array ([[ 1. , 0.] ,
[ 0. , 1.]])
Álgebra lineal
Determinante de una matriz

scipy.linalg.det
scipy.linalg.det(ndarray)

>>> A
array ([[1 , 2] ,
[3 , 4]])
>>> linalg . det ( A )
-2.0
Álgebra lineal
Resolución de sistemas lineales

scipy.linalg.solve
scipy.linalg.solve(a, b)
a array Dimensiones (M, M).
b array Dimensiones (M, ) o (M, N)
Corresponde a la matriz de la ecuación matricial a · x = b.
Devuelve un array de dimensiones (M, ) o (M, N) que

resuelve el sistema matricial
a·x =b
Tiene, por tanto, la misma forma (shape) que b.

Álgebra lineal
Resolución de sistemas lineales

Dado el sistema lineal
3x + 2y + z = 1
5x + 3y + 4z = 2
x +y −z =1
Se toma por matriz A los coeficientes de x, y y z, y por vector b el

de los términos independientes.
>>> import scipy

>>> import scipy . linalg
>>> A = scipy . array ([[3 , 2 , 1] , [5 , 3 , 4] , [1 , 1 , -1]])
>>> b = scipy . array ([[1 , 2 , 1]])
>>> solucion = scipy . linalg . solve (A , scipy . transpose ( b ))
>>> print solucion . T
[[ -4. 6. 1.]]
Álgebra lineal
Autovalores y autovectores
scipy.linalg.
La función
scipy.linalg.eig(A)
realiza la descomposición del array (N x N) dimensional A.
Devuelve una tupla con dos elementos:
(valores propios, vectores propios)
Álgebra lineal
Autovalores y autovectores
scipy.linalg.
>>> import scipy . linalg

>>> A = scipy . array ([[2 , 4] , [1 , 3]])
>>> eigval , eigvect = scipy . linalg . eig ( A )
>>> eigval [0] , eigval [1]
( ( 0 . 4 3 8 4 4 7 1 8 7 1 9 1 1 6 9 7 1 + 0 j ) , ( 4 . 5 6 1 5 5 2 8 1 2 8 0 8 8 3 0 7 + 0 j ))
>>> eigvect [: ,0] # e i g e n v e c t o r e s en c o l u m n a s
array ([ -0.93153209 , 0.36365914])
>>> eigvect [: ,1]
array ([ -0.84212294 , -0.5392856 ])
>>> mod_eigvect1 = scipy . dot ( eigvect [: ,0] , eigvect [: ,0]. T )
>>> mod_eigvect1 # modulo del vector propio 1
1.0
>>> mod_eigvect2 = scipy . dot ( eigvect [: ,1] , eigvect [: ,1]. T )
>>> mod_eigvect2 # modulo del vector propio 2
0.99999999999999978
Álgebra lineal
Ejercicios
Ejercicio 12
Procesamiento de señales
Índice
1 Introducción
4 Ajuste de curvas
5 Interpolación
6 Integración
8 Álgebra lineal
10 Agrupamiento
Suavizado de señal ruidosa

scipy.signal
Un caso muy comun en ciencia
Suavizado de señal ruidosa

scipy.signal
Para suavizar, podemos emplear

1 filtros.
2 ventanas.
Dependiendo de si se trabaja sobre imágenes o señales
unidimensionales, existen multitud de filtros y ventanas
predefinidos en los paquetes scipy.ndimage y
scipy.signal.
Filtros
scipy.signal.wiener
scipy.signal.wiener(im, mysize=None,
noise=None)
Aplica el filtro de wiener a una señal N-dimensional.
im array Array N-dimensional.
mysize entero o array (Opcional) Escalar o array N-dimensional que indica el tamaño
de la ventana del filtro en cada dimensión. El número
de elementos de mysize debe ser impar.
noise float (Opcional) La potencia del ruido a emplear (nois-power. Si no
se da (None), se estima como el promedio de la varianza local
de la señal de entrada (im).
Retorna un array de la misma que el de entrada (im)
sobre el que se ha realizado el filtrado.
Filtros
scipy.signal.medfilt
scipy.signal.medfilt(volume,
kernel size=None)
Aplica el filtro
de mediana a una señal N-dimensional (dada por un array).
volume array Array N-dimensional.
kernel size entero o array (Opcional) Escalar o array N-dimensional que indica el
tamaño de la ventana del filtro en cada dimensión. El número
de elementos de kernel size debe ser impar.
Por defecto vale 3.
Retorna un array de la misma que el de entrada (im)
sobre el que se ha realizado el filtrado.
Filtros
scipy.signal
Comparamos el trabajo de ambos filtros sobre una señal
que es la superposición de varios armónicos
f (t) = cos(π · t) + 0,5 · sin(2 · π · t + 0,3) + 0,3 · cos(10 · π · t + 0,2) + 0,2 · sin(30 · π · t + 0,7)
Filtros
scipy.signal. Comparando filtros
Filtros
scipy.signal. Comparando filtros:código
>>> import scipy

>>> import scipy . signal
>>> def signal ( t ):
... return scipy . cos ( scipy . pi * t ) + \
... 0.5 * scipy . sin (2 * scipy . pi * t + 0.3) + \
... 0.3 * scipy . cos (10 * scipy . pi * t + 0.2) + \
... 0.2 * scipy . sin (30 * scipy . pi * t + 0.7)
...
>>> t = scipy . linspace (0 , 4 , 400)
>>> pyplot . plot (t , signal ( t ))
>>> pyplot . title ( ’ Filtering signal ’)
>>> pyplot . plot (t , scipy . signal . wiener ( signal ( t ) , mysize =41) , lw =2)
>>> pyplot . plot (t , scipy . signal . medfilt ( signal ( t ) , \
... kernel_size =41) , lw =2)
>>> pyplot . legend ([ ’ original ’ , ’ wiener ’ , ’ median ’ ])
Ventanas
scipy.signal
Otra forma de suavizado de datos consiste en la

convolución de una señal de entrada con una ventana.
Una ventana es una función matemática que tiene
valores nulos fuera de un dominio dado.
En el proceso de convolución
1 se relaciona el valor de cada medida con las que
tiene a su alrededor.
2 Se tienen en cuenta más vecinos cuando mayor sea
la anchura de la ventana.
3 La ”forma” de dicha ventana influye crı́ticamente en
el resultado final.
Ventanas
scipy.signal. Ventanas de convolución para suavizado.
SCIPY en su paquete signal (scipy.signal) permite

usar ventanas estándar en el procesado de señal.
Ventanas
scipy.signal. Ventanas de convolución para suavizado: código

>>> windows = [ ’ gaussian ’ , ’ hamming ’ , ’ nuttall ’ , ’ hanning ’ , ’ boxcar ’ ,
>>> # windows width = 10
>>> for w in windows :
>>> if w == ’ gaussian ’:
... eval ( ’ pyplot . plot ( scipy . signal . %s (21 , 1)) ’ % w )
... else :
... eval ( ’ pyplot . plot ( scipy . signal . %s (21)) ’ % w )
... pyplot . ylim ([ -0.5 , 2])
... pyplot . xlim ([ -1 , 32])
... pyplot . legend ( windows )
Ventanas
scipy.signal
El resultado de aplicar la operación de convolución con

algunas de estas ventanas sobre la señal ruidosa es
Ventanas
scipy.signal. Ejemplo de código de suavizado

>>> x = scipy . linspace ( -4 * scipy . pi , 4 * scipy . pi , 200)
>>> signal = scipy . sin ( x )
>>> noise = scipy . random . randn ( signal . size ) * 0.2
>>> noise_signal = signal + noise # g e n e r a c i o n de sennal y ruido
>>> # sennal e x t e n d i d a para su c o r r e c t o m u e s t r e o
>>> e_ noise_si gnal = scipy . concatenate ([ noise_signal [10:0: -1] , \
... noise_signal , noise_signal [ -1: -15: -1]])
>>> # Smoothing
>>> pyplot . plot ( e_noise_signal , alpha =0.3)
>>> windows2 = [ ’ gaussian ’ , ’ hamming ’ , ’ nuttall ’ , ’ triang ’]
>>> for w in windows2 :
... if w == ’ gaussian ’:
... window = eval ( ’ scipy . signal . %s (21 , 1) ’ % w )
... else :
... window = eval ( ’ scipy . signal . %s (21) ’ % w )
>>> output = scipy . convolve ( window / window . sum () , noise_signal )
>>> pyplot . plot ( output , lw =1.5)
>>> pyplot . legend ([ ’ original ’] + windows )
Ejercicios
Ejercicios 13 y 14
Agrupamiento
Índice
1 Introducción
4 Ajuste de curvas
5 Interpolación
6 Integración
8 Álgebra lineal
10 Agrupamiento
Agrupamiento
Agrupamiento
Caso práctico
Tengo el siguiente conjunto conjunto de datos
¿Cómo agrupo las observaciones en 2 o

más grupos?
Agrupamiento
Agrupamiento
scipy.clustering
Dos paquetes realizan este tipo de tareas:

1 scipy.clustering.vq
Soporta técnicas de vector quantization y algoritmo
k-means.
2 scipy.clustering.hierarchy
Agrupamiento por aglomeración y jerárquico.
Agrupamiento
Agrupamiento k-means
scipy.clustering.vq
En el algoritmo k-means se necesitan dos parámetros de entrada:

1 el conjunto de datos a agrupar.
2 el número de grupos a generar.
Los datos son normalmente arrays-2D de dimensión M x N, donde M
es el número de objetos y N es el número de datos del que se
dispone para cada objetos
Dado el número de grupos, el algoritmo trabaja asignando unas
coordenadas al centro de cada uno de los grupos y asignando el
identificador a cada objeto en función del grupo cuyo centro
esté más próximo. Esto es lo que se denomina cuantificar vectores
(vector quantization)
Agrupamiento
k-means
scipy.clustering.vq.kmeans
scipy.cluster.vq.kmeans(obs, k or guess, iter=20,

thresh=1e-05)
obs array de dimensión M x N (M observaciones con N datos cada una).
k or guess entero o array Si es entero, es el número de grupos. Los centros se inicializan
aleatoriamente entre las observaciones. Si es un array, se
inicializan los centros a esas k posiciones (k x N).
iter entero Número de iteracciones
thresh entero Termina las iteraciones si la distorsión (suma de las distancias
al cuadrado entre cada observación y su centroide dominante)
cambia menos que este valor.
Retorna
codebook array Array k x N, con las coordenadas de los centroides que minimizan la
distorsión
distorsion float Suma de las distancias al cuadrado entre cada observación y su
centroide dominante
Agrupamiento
Vector quantization
scipy.clustering.vq.vq
scipy.cluster.vq.vq(obs, code book))

obs array de dimensión M x N (M observaciones con N datos cada una).
code book array Array k x N, con las coordenadas de los centroides que minimizan la
distorsión
Retorna
code array Array de longitud N, con el código del centroide dominante para cada
observación
dist array Array de longitud N, con la distanca de cada observación al centroide
dominante.
Agrupamiento
Ejemplo 1
Agrupamiento por k-means
>>> # genero la muestra

>>> x = scipy . concatenate (( random . normal (2 , 3 , 100) , \
random . normal (5 , 1 , 100)))
>>> y = scipy . concatenate (( random . normal (4 , 1 , 100) , \
random . normal (3 , 2 , 100)))
>>> data = scipy . concatenate (( x , y ))
>>> data = data . reshape ((200 ,2))
>>> Agrupo
>>> codebook , distorsion = cluster . vq . kmeans ( data , 2)
>>> code , dist = cluster . vq . vq ( data , codebook )
>>> # puntos de un grupo
>>> pyplot . plot ( data [: ,0]. compress ( code ==0) , \
data [: ,1]. compress ( code ==0) , ’ bo ’ , alpha =0.3)
>>> # puntos del otro grupo
>>> pyplot . plot ( data [: ,0]. compress ( code ==1) , \
data [: ,1]. compress ( code ==1) , ’ ro ’ , alpha =0.3)
>>> # c e n t r o i d e s
>>> pyplot . plot ( codebook [: ,0] , codebook [: ,1] , ’ go ’)
Agrupamiento
Ejemplo 1
Agrupamiento por k-means
Agrupamiento
Ejercicios
Ejercicio 15
Magnitudes Fı́sicas
Índice
1 Introducción
4 Ajuste de curvas
5 Interpolación
6 Integración
8 Álgebra lineal
10 Agrupamiento
Constantes SCIPY
scipy.constants
Este módulo contiene sobre constantes matemáticas y

fı́sicas.
Incluye un diccionario
“scipy.constants.physical constants” en el que
cada clave es el nombre de una constante fı́sica, y
el valor es una tupla que incluye (valor de la
constante, unidades, precisión).
Se dispone de 399 constantes fı́sicas.
Constantes SCIPY
scipy.constants
El siguiente fragmento de código muestra diez de ellas:
>>> import scipy . constants

>>> keys = scipy . constants . p h y s i c a l _ c o n s t a n t s . keys ()
>>> print len ( keys )
399
>>> for j in range (10):
... print keys [ j ]
...
joule - electron volt relationship
conductance quantum
standard acceleration of gravity
electron volt - hertz relationship
shielded helion to proton mag . mom . ratio
lattice parameter of silicon
neutron mag . mom . to nuclear magneton ratio
deuteron mass in u
kelvin - joule relationship
shielded helion magn . moment
Constantes SCIPY
scipy.constants
Cada constante lleva asociados tres valores, almacenados en forma

de tupla en el diccionario scipy.constants.physical constants
>>> scipy . constants . p h y s i c a l _ c o n s t a n t s [ ’ joule - electron volt relations

(6.24150965 e +18 , ’ eV ’ , 16 0 00 00 00 0 00 .0 )
# ( VALOR , UNIDADES , P R E C I S I O N )
Constantes SCIPY
scipy.constants
Existen 3 funciones que permiten obtener esos valores por separado

para una constante dada:
scipy.constants.value(nombre constante),
scipy.constants.unit(nombre constante),
scipy.constants.precision(nombre constante).
>>> scipy . constants . value ( ’ electron mass ’)

9.10938291 e -31
>>> scipy . constants . unit ( ’ electron mass ’)
’ kg ’
>>> scipy . constants . precision ( ’ electron mass ’)
4.3 91 07 6 80 45 64 8 e -08
Constantes SCIPY
scipy.constants
¿Tengo que leer todas las claves para saber si una

constante existe y cuál es su nombre?
No es necesario. Podemos hacer una búsqueda aproximada mediante

el uso de la función
scipy.constants.find(regexp)
>>> scipy . constants . find ( ’ light ’)

[ ’ speed of light in vacuum ’]
Prefijos de unidades
scipy.constants
Disponemos de órdenes para prefijos de unidades fı́sicas.
>>> scipy . constants . yotta

1 e +24
>>> scipy . constants . exa
1 e +18
>>> scipy . constants . mega
1000000.0
>>> scipy . constants . kilo
1000.0
>>> scipy . constants . hecto
100.0
>>> scipy . constants . micro
1e -06
>>> scipy . constants . femto
1e -15
Unidades de información binaria

scipy.constants
También para unidades de información en sistema binario.
>>> scipy . constants . kibi

1024
>>> scipy . constants . gibi
1073741824
>>> scipy . constants . tebi
1099511627776
Funciones de conversión
scipy.constants
Existen funciones de conversión especı́ficas para determinadas

magnitudes.
>>> scipy . constants . lambda2nu (3000)

99930.819333333333
>>> # E q u i v a l e n t e a ...
>>> scipy . constants . find ( ’ light ’)
[ ’ speed of light in vacuum ’]
>>> scipy . constants . value ( ’ speed of light in vacuum ’ )/3000
99 9 3 0 . 8 1 9 3 3 3 3 3 3 3 3
Ejercicios
Ejercicio 16
FIN

Scipy PDF

Cargado por

Información del documentohacer clic para expandir la información del documento

Copyright:

Formatos disponibles

Scipy PDF

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Scipy PDF

Cargado por

Copyright:

Formatos disponibles

Curso Python Cientı́fico: Scipy

Cesar Husillos Rodrı́guez

Paquete que extiende la funcionalidad de NUMPY.

¿Qué vamos a aprender?

1 Determinar los valores mı́nimos de funciones.

Dentro del subpaquete scipy.optimize, la función

Método SIMPLEX (Nelder-Mead)

Es la forma más simple de determinar el mı́nimo de una función.

>>> res = minimize ( parabola , 202.34 , method = ’ nelder - mead ’ , \

Converge más rápidamente porque usa el gradiente de la función. Si

Método Newton del gradiente conjugado

Más rápido aún. Posibilidad de insertar el Hessiano de la

¿Qué sucede si hay mı́nimos locales?

Derivada primera (jacobiano)

Derivada segunda (hessiano)

Coseno amortiguado y dos primeras derivadas

>>> res = scipy . optimize . minimize ( coseno_amortiguado , \

¿Qué sucede si hay mı́nimos locales?

Cuando interesa obtener el valor mı́nimo de una función

bounds serı́a algo ası́ como

((1, 5), (None, 4), (None, None))

donde x ∈ [1, 5], y ∈ (−∞, 4) y z puede tomar cualquer valor.

>>> import scipy

1 Para una funcion escalar.

Dentro del subpaquete scipy.optimize, la función

Trabajamos con una función sobradamente conocida: sin(x). Se

Siempre que hay un punto de evaluacion inicial, el resultado

>>> import scipy

donde, como hemos visto, res es un diccionario. Sus claves son:

>>> res . keys ()

De las claves del diccionario res interesan

Grafico las raı́ces obtenidas

Resolver un sistema de ecuaciones implica obtener los valores de x e

en el intervalo de x ∈ [−5, 5].

>>> import scipy

Problema: obtener los puntos de corte

tengo que localizar las raı́ces de la ecuación

sin(x) − 0,1 · x − 0,3 = 0

y eso, sabemos hacerlo :-)

>>> import scipy

Solución al sistema de ecuaciones

De nuevo dentro del subpaquete scipy.optimize, la función

Ajuste la función con ruido normal gausiano escalado por 0.5 a la

>>> def func_fit (x , a , b ):

Hay dos formas básicas de interpolación:

Una función spline está formada por varios polinomios,

Interpolación-1D: sobre muestra completa

Para interpolar todos los datos de una función unidimensional

Devuelve una función. Cuando se la llama (pasándole nuevas

Código del ejemplo

Interpolación-1D: uso de splines

Devuelve una función. Cuando se la llama (pasándole nuevas

Código del ejemplo

¿Podemos interpolar datos con ruido usando splines?

Código del ejemplo

def func (x , y ): # funcion a i n t e r p o l a r

intvx = scipy . linspace (0 , 10 , 100)

El subpaquete scipy.integrate proporciona