Complementaria 2: Álgebra Lineal en Python

El objetivo de esta complementaria es aprender a definir y manejar matrices en Python. El uso de matrices aplicado a la construcción de Cadenas de Markov también será tratado a lo largo de la complementaria.

Manejo de matrices

Para crear y realizar operaciones sobre matrices en Python utilzaremos la libreria numpy que se abrevia como np.

import numpy as np

Existen diferentes formas para crear matrices en Python. Aqui hay algunos ejemplos:

Se puede crear una matriz a partir de varias listas:

matrix = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print(matrix)

[[1 2 3]
 [4 5 6]
 [7 8 9]]

Se puede crear una matriz llena de ceros (esta forma de crear la matriz será de suma utilidad cuando estemos definiendo las cadenas de Markov):

matrix2 = np.zeros((3, 3))  # Matriz 3x3 de ceros
print(matrix2)

[[0. 0. 0.]
 [0. 0. 0.]
 [0. 0. 0.]]

Crear una matriz identidad (útil para realizar análisis de tiempos)

matrix3 = np.eye(4)  # Matriz identidad 4x4
print(matrix3)

[[1. 0. 0. 0.]
 [0. 1. 0. 0.]
 [0. 0. 1. 0.]
 [0. 0. 0. 1.]]

Para acceder a un elemento de una matriz se deben utilizar los índices del respectivo elemento. Se debe tener cuidado ya que los índices en Python empiezan en 0, tal que si, por ejemplo, se quiere acceder a la fila 1 se debe utilizar el 0.

# Accede al elemento en la fila 1, columna 2
elemento = matrix[0, 1]
elemento

También se puede extraer filas o columnas de la siguiente manera:

# Extraer la primera fila de 'matrix'.
fila1 = matrix[0,:]
fila1

array([1, 2, 3])

# Extraer la tercera columna de 'matrix'.
columna2 = matrix[:,2]
columna2

array([3, 6, 9])

De igual manera se pueden agregar filas o columnas con la función append. Si se quiere aregar una nueva fila el parámetro axis de la funcion append debe ser igual a 0; si se quiere agregar una nueva columna, axis debe ser igual a 1.

# Nueva fila que se quiere agregar.
nueva_fila = np.array([10,11,12])

# Agregar la nueva fila a la matriz
matrix_con_fila = np.append(matrix, [nueva_fila], axis = 0)
matrix_con_fila

array([[ 1,  2,  3],
       [ 4,  5,  6],
       [ 7,  8,  9],
       [10, 11, 12]])

# Nueva columna que se quiere agregar.
nueva_columna = np.array([[13], [14], [15]])

# Agregar la nueva columna a la matriz
matrix_con_columna = np.append(matrix, nueva_columna, axis = 1)
matrix_con_columna

array([[ 1,  2,  3, 13],
       [ 4,  5,  6, 14],
       [ 7,  8,  9, 15]])

Operaciones matriciales

A modo de ejemplo, se crearán dos matrices llenas de números aleatorios que siguen una distribución normal generados por el comando random.normal de la libreria numpy, que tiene como parámetros la media, la desviación estandar y el tamaño de la matriz

A = np.random.normal(loc = 20, scale = 8, size = (6,6))
print(A)

[[20.61420465 18.53038505 19.34593808 16.95032865 26.01339437 15.58137537]
 [18.67789626 12.29950943 28.69895498  3.45586144 16.93549113  8.20519094]
 [ 5.87975044 12.81151521 -5.36952811 23.50255984 18.06487259 24.06553259]
 [25.72116978 17.33731284 14.12499462 18.160598   22.04139583 20.31738403]
 [10.97301135 22.29568069 17.43866771 16.95778474 23.37345701  2.07374761]
 [29.02158175 25.37778612 26.53921658 20.83154742 27.11320958 18.68228303]]

B = np.random.normal(loc = 10, scale = 3, size = (6,6))
print(B)

[[11.30162052 12.45324412  9.61247484  9.61429633 12.98599461 14.23948903]
 [13.68473238  8.16363746 11.8875856   8.2958035   8.34692499 14.14994237]
 [14.49797405  9.94927604  8.15324005  8.57684678  5.66138163  5.69651272]
 [11.29590062 13.6089437  13.24485645  9.18983709 12.37596912  9.09031647]
 [ 6.81095415 13.9334374  14.0949812  10.9870315  13.13953976  5.27301622]
 [12.26107279  9.48700596  7.06066598  8.66130514 13.67649147 10.99601617]]

A continuación, se encuentran algunos comandos de interes que nos permiten realizar operaciones matriciales en Python

Comando	Explicación
`A.T`	Transpuesta de la matriz A
`A + B`	Suma elemento a elemento de las matrices A y B
`A - B`	Resta elemento a elemento de las matrices A y B
`A @ B`	Producto matricial de A por B
`A * B`	Producto elemento a elemento de A por B
`np.linalg.det(A)`	Calcula el determinante de la matriz cuadrada A
`np.linalg.inv(A)`	Calcula la inversa de la matriz cuadrada A
`np.linalg.solve(A, b)`	Resuelve el sistema de ecuaciones lineales Ax = b
`np.linalg.eig(A)`	Calcula los valores y vectores propios de la matriz cuadrada A
`np.diag(A)`	Extrae la diagonal principal de la matriz A como un vector
`A.sum(axis = 1)`	Calcula la suma de los elementos de cada fila de la matriz A

Cadenas de Markov

El uso de matrices sirve para definir la representación de una cadena de Markov en Python. Por ejemplo, en las cadenas continuas es posible definir la matriz generadora (o de tasas de transición) Q, y en las discretas se define la matriz de probabilidades de transición a un paso P. En Python se utilizará la libreria jmarkov.

¡Ponte a prueba!. Modela la evolución del Índice de calidad del aire (ICA) como una cadena de Markov.

En primer lugar, se modela la situación como una cadena de Markov de tiempo discreto. Se define la variable de estado y el espacio de estados correspondiente.

\[ I_n = \text{Nivel del ICA en el n-ésimo día} \]

\[ S_I = \{1, 2, 3, 4, 5\} \]

Es importante considerar que, en el espacio de estados, los niveles de calidad del aire aparecen en orden creciente de empeoramiento: el estado 1 corresponde a la clase Buena y el estado 5 a Muy dañina para la salud.

Como es una cadena de Markov en tiempo discreto (CMTD) se debe definir la matriz P. Las probabilidades de transición en un paso entre estados de la cadena de Markov discreta son las siguientes:

\[\begin{split} P_{i \rightarrow j} = \begin{cases} 0.5 & \text{si } j = i + 1, i < 5 \\ 0.3 & \text{si } j = i, 1 < i < 5 \\ 0.2 & \text{si } j = i - 1, i > 1 \\ 0.5 & \text{si } j = i = 1 \\ 0.8 & \text{si } j = i = 5 \\ 0 & \text{dlc} \end{cases} \end{split}\]

Para crear matrices en Python, utilizaremos la biblioteca numpy, que se emplea para trabajar con matrices y realizar cálculos numéricos de manera eficiente. Esta biblioteca se abrevia comúnmente como np.

# Importar las librerias necesarias.

import numpy as np

A continuación, se implementa esta CMTD en Python. Se empieza creando la matriz de probabilidades de transición que se llamará matriz:

filas = 5
columnas = 5

# Crear una matriz de ceros de 5x5
matriz = np.zeros((filas, columnas), dtype = float)

Ahora, se recorren las filas y columnas de la matriz para llenarla de acuerdo a la formulación general definida previamente.

# Llenar la matriz con valores
for i in range(filas):
    for j in range(columnas):
        if j == i + 1 and i < filas - 1:
            matriz[i, j] = 0.5
        elif j == i and i > 0 and i < filas - 1:
            matriz[i, j] = 0.3
        elif j == i - 1 and i > 0:
            matriz[i, j] = 0.2
        elif i == j == 0:
            matriz[i, j] = 0.5
        elif i == j == filas - 1:
            matriz[i, j] = 0.8

print(matriz)

# Verificación de que las filas de la matriz suman 1.
matriz.sum(axis = 1)

[[0.5 0.5 0.  0.  0. ]
 [0.2 0.3 0.5 0.  0. ]
 [0.  0.2 0.3 0.5 0. ]
 [0.  0.  0.2 0.3 0.5]
 [0.  0.  0.  0.2 0.8]]

array([1., 1., 1., 1., 1.])