Raul E.

Lopez Briega
([Link]
Matemáticas, análisis de datos y python
Atom (/[Link])

Search 

About (/pages/[Link])
Home Page (/[Link])
Archives (/[Link])
Mi otro Blog ([Link]
IAAR Book ([Link]
2048 (/2048/)
Contacto (/pages/[Link])

Algebra Lineal con Python

dom 14 junio 2015

Introducción
Una de las herramientas matemáticas más utilizadas en machine learning ([Link] y data
mining ([Link] es el Álgebra lineal
([Link] por tanto, si queremos incursionar en el fascinante mundo del aprendizaje
automático y el análisis de datos es importante reforzar los conceptos que forman parte de sus cimientos.

El Álgebra lineal ([Link] es una rama de las matemáticas

([Link] que es sumamente utilizada en el estudio de una gran variedad de ciencias,
como ser, ingeniería, finanzas, investigación operativa, entre otras. Es una extensión del álgebra
([Link] que aprendemos en la escuela secundaria, hacia un mayor número de dimensiones;
en lugar de trabajar con incógnitas a nivel de escalares ([Link] comenzamos a
trabajar con matrices ([Link] y vectores ([Link]
El estudio del Álgebra lineal ([Link] implica trabajar con varios objetos matemáticos,
como ser:

Los Escalares ([Link] Un escalar es un solo número, en

contraste con la mayoría de los otros objetos estudiados en Álgebra lineal
([Link] que son generalmente una colección de múltiples números.
Los Vectores ([Link] vector es una serie de números. Los números tienen una orden
preestablecido, y podemos identificar cada número individual por su índice en ese orden. Podemos pensar en los vectores
como la identificación de puntos en el espacio, con cada elemento que da la coordenada a lo largo de un eje diferente.
Existen dos tipos de vectores, los vectores de fila y los vectores de columna. Podemos representarlos de la siguiente
manera, dónde f es un vector de fila y c es un vector de columna:

0
⎡ ⎤
f = [0 1 −1 ] ; c = ⎢ 1 ⎥
⎣ ⎦
−1

Las Matrices ([Link] Una matriz es un arreglo bidimensional de

números (llamados entradas de la matriz) ordenados en filas (o renglones) y columnas, donde una fila es cada una de las
líneas horizontales de la matriz y una columna es cada una de las líneas verticales. En una matriz cada elemento puede
ser identificado utilizando dos índices, uno para la fila y otro para la columna en que se encuentra. Las podemos
representar de la siguiente manera, A es una matriz de 3x2.

0 1
⎡ ⎤
A = ⎢ −1 2 ⎥
⎣ ⎦
−2 3

Los Tensores ([Link] algunos casos necesitaremos una matriz

con más de dos ejes. En general, una serie de números dispuestos en una cuadrícula regular con un número variable de
ejes es conocido como un tensor.

Sobre estos objetos podemos realizar las operaciones matemáticas básicas, como ser adición
([Link] multiplicación ([Link] sustracción
([Link] y división ([Link]
es decir que vamos a poder sumar vectores ([Link] con matrices
([Link] multiplicar escalares
([Link] a vectores ([Link] y demás.

Librerías de Python para álgebra lineal

Los principales módulos que Python ([Link] nos ofrece para realizar operaciones de Álgebra lineal
([Link] son los siguientes:

Numpy ([Link] El popular paquete matemático de Python ([Link] nos va a permitir

crear vectores ([Link] matrices
([Link] y tensores
([Link] con suma facilidad.
[Link] ([Link] Este es un submodulo dentro de
Numpy ([Link] con un gran número de funciones para resolver ecuaciones de Álgebra lineal
([Link]
[Link] ([Link] Este submodulo del paquete científico
Scipy ([Link] es muy similar al anterior, pero con algunas más funciones
y optimaciones.
 Sympy ([Link] Esta librería nos permite trabajar con matemática simbólica, convierte a Python
([Link] en un sistema algebraico computacional
([Link] Nos va a permitir trabajar con ecuaciones y fórmulas
simbólicamente, en lugar de numéricamente.
CVXOPT ([Link] Este módulo nos permite resolver problemas de optimizaciones de programación lineal
([Link]
PuLP ([Link] Esta librería nos permite crear modelos de programación lineal
([Link] en forma muy sencilla con Python ([Link]

Operaciones básicas

Vectores
Un vector ([Link] de largo n es una secuencia (o array, o tupla) de n números. La solemos escribir
como x = (x1, . . . , xn) o x = [x1, . . . , xn]

En Python ([Link] un vector ([Link] puede ser representado con una simple lista, o con
un array de Numpy ([Link] siendo preferible utilizar esta última opción.

In [1]: # Vector como lista de Python

v1 = [2, 4, 6]

v1

Out[1]: [2, 4, 6]

In [2]: # Vectores con numpy

import numpy as np

v2 = [Link](3) # vector de solo unos.

v2

Out[2]: array([1., 1., 1.])

In [3]: v3 = [Link]([1, 3, 5]) # pasando una lista a las arrays de numpy

v3

Out[3]: array([1, 3, 5])

In [4]: v4 = [Link](1, 8) # utilizando la funcion arange de numpy

v4

Out[4]: array([1, 2, 3, 4, 5, 6, 7])

Representación gráfica
Tradicionalmente, los vectores ([Link] son representados visualmente como flechas que parten
desde el origen hacia un punto.

Por ejemplo, si quisiéramos representar graficamente a los vectores v1 = [2, 4] , v2 = [−3, 3] y v3 = [−4, −3.5] , podríamos
hacerlo de la siguiente manera.

In [ ]: import [Link] as plt

from warnings import filterwarnings

%matplotlib inline

filterwarnings('ignore') # Ignorar warnings

 In [ ]: def move_spines():

"""Crea la figura de pyplot y los ejes. Mueve las lineas de la izquierda y de abajo

para que se intersecten con el origen. Elimina las lineas de la derecha y la de arriba.
Devuelve los ejes."""

fix, ax = [Link]()

for spine in ["left", "bottom"]:

[Link][spine].set_position("zero")

for spine in ["right", "top"]:

[Link][spine].set_color("none")

return ax

def vect_fig():

"""Genera el grafico de los vectores en el plano"""

ax = move_spines()

ax.set_xlim(-5, 5)

ax.set_ylim(-5, 5)

[Link]()

vecs = [[2, 4], [-3, 3], [-4, -3.5]] # lista de vectores

for v in vecs:

[Link](" ", xy=v, xytext=[0, 0],

arrowprops=dict(facecolor="blue",

shrink=0,

alpha=0.7,

width=0.5))

[Link](1.1 * v[0], 1.1 * v[1], v)

In [ ]: vect_fig() # crea el gráfico

Operaciones con vectores

Las operaciones más comunes que utilizamos cuando trabajamos con vectores ([Link] son la suma,
la resta y la multiplicación por escalares ([Link]

Cuando sumamos dos vectores ([Link] vamos sumando elemento por elemento de cada
vector
([Link]

x1 y1 x1 + y1
⎡ ⎤ ⎡ ⎤ ⎡ ⎤

⎢ x2 ⎥ ⎢ y2 ⎥ ⎢ x2 + y2 ⎥
x+y = ⎢ ⎥+⎢ ⎥ := ⎢ ⎥
⎢ ⎥ ⎢ ⎥ ⎢ ⎥
⎢ ⋮ ⎥ ⎢ ⋮ ⎥ ⎢ ⋮ ⎥

⎣ ⎦ ⎣ ⎦ ⎣ ⎦
xn yn xn + yn

De forma similar funciona la operación de resta.

x1 y1 x1 − y1
⎡ ⎤ ⎡ ⎤ ⎡ ⎤

⎢ x2 ⎥ ⎢ y2 ⎥ ⎢ x2 − y2 ⎥
x−y = ⎢ ⎥−⎢ ⎥ := ⎢ ⎥
⎢ ⎥ ⎢ ⎥ ⎢ ⎥
⎢ ⋮ ⎥ ⎢ ⋮ ⎥ ⎢ ⋮ ⎥

⎣ ⎦ ⎣ ⎦ ⎣ ⎦
xn yn xn − yn

La multiplicación por escalares ([Link] es una operación que toma a un

número γ , y a un vector ([Link] x y produce un nuevo vector ([Link]
donde cada elemento del vector x es multiplicado por el número γ .
 γx1
⎡ ⎤

⎢ γx2 ⎥
γx := ⎢ ⎥
⎢ ⎥
⎢ ⋮ ⎥

⎣ ⎦
γxn

En Python ([Link] podríamos realizar estas operaciones en forma muy sencilla:

In [8]: # Ejemplo en Python

x = [Link](1, 5)

y = [Link]([2, 4, 6, 8])

x, y

Out[8]: (array([1, 2, 3, 4]), array([2, 4, 6, 8]))

In [9]: # sumando dos vectores numpy

x + y

Out[9]: array([ 3, 6, 9, 12])

In [10]: # restando dos vectores

x - y

Out[10]: array([-1, -2, -3, -4])

In [11]: # multiplicando por un escalar

x * 2

Out[11]: array([2, 4, 6, 8])

In [12]: y * 3

Out[12]: array([ 6, 12, 18, 24])

Producto escalar o interior

El producto escalar ([Link] de dos vectores ([Link] se

define como la suma de los productos de sus elementos, suele representarse matemáticamente como < x, y > o x'y, donde x e y
son dos vectores.
n

< x, y >:= ∑ xi yi

i=1

Dos vectores ([Link] son ortogonales

([Link] o perpendiculares cuando forman ángulo recto entre sí. Si el
producto escalar de dos vectores es cero, ambos vectores son ortogonales
([Link]

Adicionalmente, todo producto escalar ([Link] induce una norma

([Link] sobre el espacio en el que está definido, de la siguiente manera:

1/2
n

−−−− −−− 2
∥x∥ := √< x, x > := (∑ x )
i

i=1

En Python ([Link] lo podemos calcular de la siguiente forma:

In [13]: # Calculando el producto escalar de los vectores x e y

x @ y

Out[13]: 60
 In [14]: # o lo que es lo mismo, que:

sum(x * y), [Link](x, y)

Out[14]: (60, 60)

In [15]: # Calculando la norma del vector X

[Link](x)

Out[15]: 5.477225575051661

In [16]: # otra forma de calcular la norma de x

[Link](x @ x)

Out[16]: 5.477225575051661

In [17]: # vectores ortogonales

v1 = [Link]([3, 4])

v2 = [Link]([4, -3])

v1 @ v2

Out[17]: 0

Matrices
Las matrices ([Link] son una forma clara y sencilla de organizar los datos
para su uso en operaciones lineales.

Una matriz ([Link] n × k es una agrupación rectangular de números con n

filas y k columnas; se representa de la siguiente forma:

a11 a12 ⋯ a1k

⎡ ⎤

⎢ a21 a22 ⋯ a2k ⎥

⎢ ⎥
A =
⎢ ⎥
⎢ ⋮ ⋮ ⋮ ⎥
⎣ ⎦
an1 an2 ⋯ ank

En la matriz ([Link] A, el símbolo ank representa el elemento n-ésimo de la

fila en la k-ésima columna. La matriz ([Link] A también puede ser llamada
un vector ([Link] si cualquiera de n o k son iguales a 1. En el caso de n=1, A se llama un vector
([Link] fila, mientras que en el caso de k=1 se denomina un vector
([Link] columna.

Las matrices ([Link] se utilizan para múltiples aplicaciones y sirven, en

particular, para representar los coeficientes de los sistemas de ecuaciones lineales o para representar transformaciones lineales
dada una base. Pueden sumarse, multiplicarse y descomponerse de varias formas.

Operaciones con matrices

Al igual que con los vectores ([Link] que no son más que un caso particular, las matrices
([Link] se pueden sumar, restar y la multiplicar por escalares
([Link]

Multiplicacion por escalares:

a11 ⋯ a1k γa11 ⋯ γa1k

⎡ ⎤ ⎡ ⎤

γA ⎢ ⎥ := ⎢ ⎥
⎢ ⋮ ⋮ ⋮ ⎥ ⎢ ⋮ ⋮ ⋮ ⎥

⎣ ⎦ ⎣ ⎦
an1 ⋯ ank γan1 ⋯ γank
Suma de matrices:

a11 ⋯ a1k b11 ⋯ b1k a11 + b11 ⋯ a1k + b1k

⎡ ⎤ ⎡ ⎤ ⎡ ⎤

A+B = ⎢ ⎥+⎢ ⎥ := ⎢ ⎥
⎢ ⋮ ⋮ ⋮ ⎥ ⎢ ⋮ ⋮ ⋮ ⎥ ⎢ ⋮ ⋮ ⋮ ⎥
⎣ ⎦ ⎣ ⎦ ⎣ ⎦
an1 ⋯ ank bn1 ⋯ bnk an1 + bn1 ⋯ ank + bnk

Resta de matrices:

a11 ⋯ a1k b11 ⋯ b1k a11 − b11 ⋯ a1k − b1k

⎡ ⎤ ⎡ ⎤ ⎡ ⎤

A−B = ⎢ ⎥−⎢ ⎥ := ⎢ ⎥
⎢ ⋮ ⋮ ⋮ ⎥ ⎢ ⋮ ⋮ ⋮ ⎥ ⎢ ⋮ ⋮ ⋮ ⎥
⎣ ⎦ ⎣ ⎦ ⎣ ⎦
an1 ⋯ ank bn1 ⋯ bnk an1 − bn1 ⋯ ank − bnk

Para los casos de suma y resta, hay que tener en cuenta que solo se pueden sumar o restar matrices
([Link] que tengan las mismas dimensiones, es decir que si tengo una
matriz ([Link] A de dimensión 3x2 (3 filas y 2 columnas) solo voy a poder
sumar o restar la matriz ([Link] B si esta también tiene 3 filas y 2 columnas.

In [18]: # Ejemplo en Python

A = [Link]([[1, 3, 2],

[1, 0, 0],

[1, 2, 2]])

B = [Link]([[1, 0, 5],

[7, 5, 0],

[2, 1, 1]])

In [19]: # suma de las matrices A y B

A + B

Out[19]: array([[2, 3, 7],

[8, 5, 0],

[3, 3, 3]])

In [20]: # resta de matrices

A - B

Out[20]: array([[ 0, 3, -3],

[-6, -5, 0],

[-1, 1, 1]])

In [21]: # multiplicando matrices por escalares

A * 2

Out[21]: array([[2, 6, 4],

[2, 0, 0],

[2, 4, 4]])

In [22]: B * 3

Out[22]: array([[ 3, 0, 15],

[21, 15, 0],

[ 6, 3, 3]])

In [23]: # ver la dimension de una matriz

[Link]

Out[23]: (3, 3)
 In [24]: # ver cantidad de elementos de una matriz

[Link]

Out[24]: 9

Multiplicacion o Producto de matrices

La regla para la multiplicación de matrices ([Link] generaliza la idea

del producto interior ([Link] que vimos con los vectores
([Link] y esta diseñada para facilitar las operaciones lineales básicas.
Cuando multiplicamos
matrices ([Link] el número de columnas de la primera matriz
([Link] debe ser igual al número de filas de la segunda matriz
([Link] y el resultado de esta multiplicación va a tener el mismo número de
filas que la primer matriz ([Link] y el número de la columnas de la segunda
matriz ([Link] Es decir, que si yo tengo una matriz
([Link] A de dimensión 3x4 y la multiplico por una matriz
([Link] B de dimensión 4x2, el resultado va a ser una matriz
([Link] C de dimensión 3x2.

Algo a tener en cuenta a la hora de multiplicar matrices ([Link] es que

la propiedad connmutativa ([Link] no se cumple. AxB no es lo mismo que BxA.

Veamos los ejemplos en Python ([Link]

In [25]: # Ejemplo multiplicación de matrices

A = [Link](1, 13).reshape(3, 4) #matriz de dimension 3x4

Out[25]: array([[ 1, 2, 3, 4],

[ 5, 6, 7, 8],

[ 9, 10, 11, 12]])

In [26]: B = [Link](8).reshape(4,2) #matriz de dimension 4x2

Out[26]: array([[0, 1],

[2, 3],

[4, 5],

[6, 7]])

In [27]: # Multiplicando A x B

A @ B #resulta en una matriz de dimension 3x2

Out[27]: array([[ 40, 50],

[ 88, 114],

[136, 178]])

In [28]: # Multiplicando B x A

B @ A

---------------------------------------------------------------------------

ValueError Traceback (most recent call last)

<ipython-input-28-b55e34ad9c31> in <module>()

1 # Multiplicando B x A

----> 2 B @ A

ValueError: shapes (4,2) and (3,4) not aligned: 2 (dim 1) != 3 (dim 0)

Este ultimo ejemplo vemos que la propiedad conmutativa no se cumple, es más, Python ([Link] nos arroja un error,
ya que el número de columnas de B no coincide con el número de filas de A, por lo que ni siquiera se puede realizar la
multiplicación de B x A.

Para una explicación más detallada del proceso de multiplicación de matrices

([Link] pueden consultar el siguiente tutorial
([Link]

La matriz identidad, la matriz inversa, la matriz transpuesta y el determinante

La matriz identidad ([Link] es el elemento neutro en la multiplicación de matrices

([Link] es el equivalente al número 1. Cualquier matriz multiplicada
por la matriz identidad ([Link] nos da como resultado la misma matriz. La matriz identidad
([Link] es una matriz cuadrada ([Link] (tiene
siempre el mismo número de filas que de columnas); y su diagonal principal se compone de todos elementos 1 y el resto de los
elementos se completan con 0. Suele representase con la letra I

Por ejemplo la matriz identidad de 3x3 sería la siguiente:

1 0 0
⎡ ⎤
I = ⎢0 1 0 ⎥
⎣ ⎦
0 0 1

Ahora que conocemos el concepto de la matriz identidad ([Link] podemos llegar al

concepto de la matriz inversa ([Link] Si tenemos una matriz A, la matriz inversa
([Link] de A, que se representa como A−1 es aquella matriz cuadrada
([Link] que hace que la multiplicación AxA−1 sea igual a la matriz identidad
([Link] I. Es decir que es la matriz
([Link] recíproca de A.
−1 −1
A×A = A ×A = I

Tener en cuenta que esta matriz inversa ([Link] en muchos casos puede no [Link] este
caso se dice que la matriz es singular o degenerada. Una matriz es singular si y solo si su determinante
([Link] es nulo.

El determinante ([Link] es un número especial que puede calcularse

sobre las matrices cuadradas ([Link] Se calcula como la suma de los productos de las
diagonales de la matriz en una dirección menos la suma de los productos de las diagonales en la otra dirección. Se represente
con el símbolo |A|.

a11 a12 a13

⎡ ⎤
A = ⎢ a21 a22 a23 ⎥
⎣ ⎦
a31 a32 a33

|A| = (a11 a22 a33 + a12 a23 a31 + a13 a21 a32 ) − (a31 a22 a13 + a32 a23 a11 + a33 a21 a12 )

Por último, la matriz transpuesta ([Link] es aquella en que las filas se transforman en
columnas y las columnas en filas. Se representa con el símbolo A⊺

T
a b
⎡ ⎤
a c e
⎢c d ⎥ := [ ]
⎣ ⎦ b d f
e f

Ejemplos en Python ([Link]

 In [29]: # Creando una matriz identidad de 2x2

I = [Link](2)

Out[29]: array([[1., 0.],

[0., 1.]])

In [30]: # Multiplicar una matriz por la identidad nos da la misma matriz

A = [Link]([[4, 7],

[2, 6]])

Out[30]: array([[4, 7],

[2, 6]])

In [31]: A @ I # AxI = A

Out[31]: array([[4., 7.],

[2., 6.]])

In [32]: # Calculando el determinante de la matriz A

[Link](A)

Out[32]: 10.000000000000002

In [33]: # Calculando la inversa de A.

A_inv = [Link](A)

A_inv

Out[33]: array([[ 0.6, -0.7],

[-0.2, 0.4]])

In [34]: # A x A_inv nos da como resultado I.

A @ A_inv

Out[34]: array([[1., 0.],

[0., 1.]])

In [35]: # Trasponiendo una matriz

A = [Link](6).reshape(3, 2)

Out[35]: array([[0, 1],

[2, 3],

[4, 5]])

In [36]: [Link](A)

Out[36]: array([[0, 2, 4],

[1, 3, 5]])

Sistemas de ecuaciones lineales

Una de las principales aplicaciones del Álgebra lineal ([Link] consiste en resolver
problemas de sistemas de ecuaciones lineales.

Una ecuación lineal ([Link] es una ecuación que solo involucra sumas
y restas de una variable o mas variables a la primera potencia. Es la ecuación de la línea [Link] nuestro problema esta
representado por más de una ecuación lineal ([Link] hablamos de un
sistema de ecuaciones lineales ([Link] Por ejemplo, podríamos tener un
sistema de dos ecuaciones con dos incógnitas como el siguiente:
x − 2y = 1

3x + 2y = 11

La idea es encontrar el valor de x e y que resuelva ambas ecuaciones. Una forma en que podemos hacer esto, puede ser
representando graficamente ambas rectas y buscar los puntos en que las rectas se cruzan.

En Python ([Link] esto se puede hacer en forma muy sencilla con la ayuda de matplotlib ([Link]

In [37]: # graficando el sistema de ecuaciones.

x_vals = [Link](0, 5, 50) # crea 50 valores entre 0 y 5

[Link](x_vals, (1 - x_vals)/-2) # grafica x - 2y = 1

[Link](x_vals, (11 - (3*x_vals))/2) # grafica 3x + 2y = 11

[Link](ymin = 0)

Out[37]: (-0.25, 5.25, 0, 5.875)

Luego de haber graficado las funciones, podemos ver que ambas rectas se cruzan en el punto (3, 1), es decir que la solución de
nuestro sistema sería x = 3 e y = 1 . En este caso, al tratarse de un sistema simple y con solo dos incógnitas, la solución
gráfica puede ser de utilidad, pero para sistemas más complicados se necesita una solución numérica, es aquí donde entran a
jugar las matrices ([Link]

Ese mismo sistema se podría representar como una ecuación matricial de la siguiente forma:

1 −2 x 1
[ ][ ] = [ ]
3 2 y 11

Lo que es lo mismo que decir que la matriz ([Link] A por la matriz

([Link] x nos da como resultado el vector
([Link] b.

Ax = b

En este caso, ya sabemos el resultado de x, por lo que podemos comprobar que nuestra solución es correcta realizando la
multiplicación de matrices ([Link]

In [38]: # Comprobando la solucion con la multiplicación de matrices.

A = [Link]([[1., -2.],

[3., 2.]])

x = [Link]([[3.],[1.]])

A @ x

Out[38]: array([[ 1.],

[11.]])
Para resolver en forma numérica los sistema de ecuaciones ([Link]
existen varios métodos:

El método de sustitución: El cual consiste en despejar en una de las ecuaciones cualquier incógnita, preferiblemente
la que tenga menor coeficiente y a continuación sustituirla en otra ecuación por su valor.
El método de igualacion: El cual se puede entender como un caso particular del método de sustitución en el que se
despeja la misma incógnita en dos ecuaciones y a continuación se igualan entre sí la parte derecha de ambas
ecuaciones.
El método de reduccion: El procedimiento de este método consiste en transformar una de las ecuaciones
(generalmente, mediante productos), de manera que obtengamos dos ecuaciones en la que una misma incógnita
aparezca con el mismo coeficiente y distinto signo. A continuación, se suman ambas ecuaciones produciéndose así la
reducción o cancelación de dicha incógnita, obteniendo una ecuación con una sola incógnita, donde el método de
resolución es simple.
El método gráfico: Que consiste en construir el gráfica de cada una de las ecuaciones del sistema. Este método
(manualmente aplicado) solo resulta eficiente en el plano cartesiano (solo dos incógnitas).
El método de Gauss: El método de eliminación de Gauss o simplemente método de Gauss consiste en convertir un
sistema lineal de n ecuaciones con n incógnitas, en uno escalonado, en el que la primera ecuación tiene n incógnitas, la
segunda ecuación tiene n - 1 incógnitas, ..., hasta la última ecuación, que tiene 1 incógnita. De esta forma, será fácil
partir de la última ecuación e ir subiendo para calcular el valor de las demás incógnitas.
El método de Eliminación de Gauss-Jordan: El cual es una variante del método anterior, y consistente en triangular la
matriz aumentada del sistema mediante transformaciones elementales, hasta obtener ecuaciones de una sola incógnita.
El método de Cramer: El cual consiste en aplicar la regla de Cramer ([Link]
para resolver el sistema. Este método solo se puede aplicar cuando la matriz de coeficientes del sistema es cuadrada y
de determinante no nulo.

La idea no es explicar cada uno de estos métodos, sino saber que existen y que Python ([Link] nos hacer la vida
mucho más fácil, ya que para resolver un sistema de ecuaciones ([Link]
simplemente debemos llamar a la función solve().

Por ejemplo, para resolver este sistema de 3 ecuaciones y 3 incógnitas.

x + 2y + 3z = 6

2x + 5y + 2z = 4

6x − 3y + z = 2

Primero armamos la matriz ([Link] A de coeficientes y la matriz

([Link] b de resultados y luego utilizamos solve() para resolverla.

In [39]: # Creando matriz de coeficientes

A = [Link]([[1, 2, 3],

[2, 5, 2],

[6, -3, 1]])

Out[39]: array([[ 1, 2, 3],

[ 2, 5, 2],

[ 6, -3, 1]])

In [40]: # Creando matriz de resultados

b = [Link]([6, 4, 2])

Out[40]: array([6, 4, 2])

 In [41]: # Resolviendo sistema de ecuaciones

x = [Link](A, b)

Out[41]: array([0., 0., 2.])

In [42]: # Comprobando la solucion

A @ x == b

Out[42]: array([ True, True, True])

Programación lineal
La programación lineal ([Link] estudia las situaciones en las que se exige
maximizar o minimizar funciones que se encuentran sujetas a determinadas restricciones.

Consiste en optimizar (minimizar o maximizar) una función lineal, denominada función objetivo, de tal forma que las variables de
dicha función estén sujetas a una serie de restricciones que expresamos mediante un sistema de inecuaciones lineales
([Link]

Para resolver un problema de programación lineal, debemos seguir los siguientes pasos:

1. Elegir las incógnitas.

2. Escribir la función objetivo en función de los datos del problema.
3. Escribir las restricciones en forma de sistema de inecuaciones.
4. Averiguar el conjunto de soluciones factibles representando gráficamente las restricciones.
5. Calcular las coordenadas de los vértices del recinto de soluciones factibles (si son pocos).
6. Calcular el valor de la función objetivo en cada uno de los vértices para ver en cuál de ellos presenta el valor máximo o
mínimo según nos pida el problema (hay que tener en cuenta aquí la posible no existencia de solución).

Veamos un ejemplo y como Python ([Link] nos ayuda a resolverlo en forma sencilla.

Supongamos que tenemos la siguiente función objetivo:

f(x1 , x2 ) = 50x1 + 40x2

y las siguientes restricciones:

x1 + 1.5x2 ≤ 750

2x1 + x2 ≤ 1000

x1 ≥ 0

x2 ≥ 0

Podemos resolverlo utilizando PuLP ([Link] CVXOPT ([Link] o graficamente (con

matplotlib ([Link] de la siguiente forma.
In [43]: # Resolviendo la optimizacion con pulp

from pulp import *

# declarando las variables

x1 = LpVariable("x1", 0, 800) # 0<= x1 <= 40

x2 = LpVariable("x2", 0, 1000) # 0<= x2 <= 1000

# definiendo el problema

prob = LpProblem("problem", LpMaximize)

# definiendo las restricciones

prob += x1+1.5*x2 <= 750

prob += 2*x1+x2 <= 1000

prob += x1>=0

prob += x2>=0

# definiendo la funcion objetivo a maximizar

prob += 50*x1+40*x2

# resolviendo el problema

status = [Link](GLPK(msg=0))

LpStatus[status]

# imprimiendo los resultados

(value(x1), value(x2))

Out[43]: (375.0, 250.0)

In [44]: # Resolviendo el problema con cvxopt

from cvxopt import matrix, solvers

A = matrix([[-1., -2., 1., 0.], # columna de x1

[-1.5, -1., 0., 1.]]) # columna de x2

b = matrix([750., 1000., 0., 0.]) # resultados

c = matrix([50., 40.]) # funcion objetivo

# resolviendo el problema

sol=[Link](c,A,b)

pcost dcost gap pres dres k/t

0: -2.5472e+04 -3.6797e+04 5e+03 0e+00 3e-01 1e+00

1: -2.8720e+04 -2.9111e+04 1e+02 2e-16 9e-03 2e+01

2: -2.8750e+04 -2.8754e+04 1e+00 8e-17 9e-05 2e-01

3: -2.8750e+04 -2.8750e+04 1e-02 4e-16 9e-07 2e-03

4: -2.8750e+04 -2.8750e+04 1e-04 9e-17 9e-09 2e-05

Optimal solution found.

In [45]: # imprimiendo la solucion.

print('{0:.2f}, {1:.2f}'.format(sol['x'][0]*-1, sol['x'][1]*-1))

375.00, 250.00

 In [46]: # Resolviendo la optimizacion graficamente.

x_vals = [Link](0, 800, 10) # 10 valores entre 0 y 800

[Link](x_vals, ((750 - x_vals)/1.5)) # grafica x1 + 1.5x2 = 750

[Link](x_vals, (1000 - 2*x_vals)) # grafica 2x1 + x2 = 1000

[Link](ymin = 0)

[Link]()

Como podemos ver en el gráfico, ambas rectas se cruzan en la solución óptima, x1=375 y x2=250.

Con esto termino esta introducción al Álgebra lineal ([Link] con Python
([Link]

Espero que hayan disfurtado de este tutorial tanto como yo disfrute escribirlo!

Saludos!

Este post fue escrito utilizando IPython notebook. Pueden descargar este notebook
([Link] o ver su version
estática en nbviewer
([Link]

Este articulo fue escrito utilizando Jupyter notebook

([Link]
Presionar aquí para la versión
interactiva:
launch binder ([Link]
filepath=content/notebooks/[Link])

Posted by Raul E. Lopez Briega

dom 14 junio 2015 python ([Link]
algebra
([Link]
programacion ([Link]
Tweet

Comments
 ALSO ON RELOPEZBRIEGA_GITHUB

Visualizaciones de Ecuaciones Ecuaciones en Machine Learn

datos con Python Diferenciales con … derivadas … con Python - …
5 years ago • 4 comments 6 years ago • 14 comments 6 years ago • 12 comments 6 years ago • 3 commen

Visualización de datos con Ecuaciones diferenciales con Derivadas parciales con Sobreajuste en mach
python. Análisis de datos, python. Qué es una ecuación Python. Qué es una ecuación learning. Cómo reco
cómo elegir la … diferencial, clasificación, … en derivadas parciales, … sobreajuste, sobreaju

7 Comments relopezbriega_github 🔒 Disqus' Privacy Policy 

1 Login

 Favorite 4 t Tweet f Share Sort by Best

Join the discussion…

LOG IN WITH
OR SIGN UP WITH DISQUS ?

Name

Santiago reyes • 2 months ago

Muchas gracias, me ha sido bastante útil tu blog.
△ ▽ • Reply • Share ›

David Duque David • 2 years ago • edited

Muchas gracias por generar el post, fue bastante productivo volver a recordar este tipo de temas que si hoy
vuelvo a leer, es porque en su momento no quedaron tan claros o se olvidaron.

feliz tarde
△ ▽ • Reply • Share ›

Lourdis Zanahoria • 4 years ago

Muy buenas, ¿pyhton tiene forma de resolver determinantes con más de 2 vectores? El código
[Link](z) creo que solo se puede para matrices cuadradas. Necesito calcular un determinante con tres
vectores y me da fallo con ese comando.

¡Gracias de antemano!
△ ▽ • Reply • Share ›

hernández guillén • 4 years ago

Que buen blog, justo lo que andaba buscando.
△ ▽ • Reply • Share ›

Raul Lopez Briega Mod > hernández guillén • 4 years ago

 Muchas gracias por visitar el blog, me alegra que te haya sido de utilidad. Saludos
1△ ▽ • Reply • Share ›

AlfaInk • 5 years ago • edited

No sabes lo bien que vienen estas introducciones, clarísimas y sin fisuras. Ojala hagas mas artículos, no a
todo el mundo se le da bien. Un saludo.
△ ▽ • Reply • Share ›

Raul Lopez Briega Mod > AlfaInk • 5 years ago

Muchas gracias! Saludos!

△ ▽ • Reply • Share ›

✉ Subscribe d Add Disqus to your siteAdd DisqusAdd ⚠ Do Not Sell My Data

Most Popular
Probabilidad y Estadística con Python ([Link]
Ecuaciones Diferenciales con Python ([Link]
Algebra lineal con Python ([Link]
Expresiones regulares con Python ([Link]
Machine Learning con Python ([Link]

Subscribe to my mailing list

email address

Subscribe

Recent Posts
Modelos basados en Agentes con Python ([Link]
python/)
Introducción al pensamiento lógico con Python ([Link]
logico-con-python/)
Sistemas dinámicos, Complejidad y Caos con Python ([Link]
complejidad-y-caos-con-python/)
Fractales con Python ([Link]
Jugando la Copa América con Python ([Link]

Categories
Algebra ([Link]
Analisis de datos ([Link]
Calculo ([Link]
Finanzas ([Link]
IA ([Link]
 Machine Learning ([Link]
Matematica ([Link]
Pobabilidad y Estadistica ([Link]
Programacion ([Link]
Redes Neuronales ([Link]

Tags
python ([Link] incertidumbre ([Link]
matematica ([Link] pensamiento ([Link]
inteligencia ([Link] modelos ([Link] ABM
([Link] Mesa ([Link] falacias
([Link] logica ([Link] sistemas dinamicos
([Link] caos ([Link] fractales
([Link] programacion ([Link] futbol
([Link] copa america ([Link] Machine
Learning ([Link] binario ([Link] numeros
([Link] decimales ([Link] multiplicar
([Link] sumar ([Link] restar
([Link] dividir ([Link] informacion
([Link] entropia ([Link] bit
([Link] redundancia ([Link] shannon
([Link] estadistica ([Link] probabilidad
([Link] boosting ([Link] xgboost
([Link] adaboost ([Link] gradientboost
([Link] analisis de datos ([Link]
Inteligencia Artificial ([Link] TensorFlow
([Link] Redes Neuronales ([Link]
distribuciones ([Link] Monte-Carlo ([Link]
[Link]), MCMC ([Link] Metropolis ([Link]
Bayes ([Link] inferencia ([Link] optimizacion
([Link] scipy ([Link] cvxopt
([Link] pulp ([Link] visualizaciones
([Link] series de tiempo ([Link]
finanzas ([Link] bokeh ([Link] folium
([Link] seaborn ([Link] matplotlib
([Link] algebra ([Link] matrices
([Link] recomendaciones ([Link]
Sobreajuste ([Link] calculo ([Link] ecuaciones
diferenciales ([Link] vectores
([Link] derivada ([Link] integral
([Link] derivadas parciales ([Link]
logaritmo ([Link] limite ([Link] infinito
([Link] complejos ([Link] conjuntos
([Link] batman ([Link] regex
([Link] funcional ([Link] pi
([Link] map-reduce ([Link]

Social
Atom (/[Link])
twitter ([Link]
linkedin ([Link]
github ([Link]
Blogroll
Mi otro blog ([Link]
IAAR Book ([Link]
Pelican ([Link]
[Link] ([Link]
Jinja2 ([Link]

Follow @relopezbriega 322 followers

Copyright © 2018 - Raul E. Lopez Briega -

Powered by Pelican ([Link]