4.1: Representaciones matriciales de vectores, matrices y tensores

Hasta ahora, hemos discutido matrices simples “unidimensionales” (1D), que son secuencias lineales de números. En términos de álgebra lineal, las matrices 1D representan vectores. La longitud de la matriz corresponde a la “dimensión vectorial” (por ejemplo, una matriz 1D de longitud 3 corresponde a un vector 3). De acuerdo con la terminología de Scipy, utilizaremos la obra “dimension” para referirnos a la dimensionalidad de la matriz (llamada el rango en álgebra lineal), y no a la dimensión vectorial.

Probablemente esté familiarizado con el hecho de que los vectores se pueden representar usando notación de índice, que es bastante similar a la notación de Python para abordar matrices 1D. Considere un\(d\) vector de longitud

\[\vec{x} = \begin{bmatrix}x_0\\x_1\\\vdots\\x_{d-1}\end{bmatrix}.\]

El elemento\(j\) th se puede escribir como

\[x_j \quad \leftrightarrow\quad \texttt{x[j]},\]

donde\(j=0,1,\dots,d-1\). La notación de la izquierda es notación de índice matemático, y la notación de la derecha es la notación de matriz de Python. Tenga en cuenta que estamos usando indexación\(0\) basada, de modo que el primer elemento tiene índice\(0\) y el último elemento tiene índice\(d-1\).

Una matriz es una colección de números organizados usando dos índices, en lugar de un solo índice como un vector. Bajo indexación\(0\) basada, los elementos de una\(m\times n\) matriz son:

\[\mathbf{M} = \begin{bmatrix}M_{00} & M_{01} & \cdots & M_{0,n-1} \\ M_{10} & M_{11}& \cdots & M_{1,n-1} \\ \vdots & \vdots &\ddots&\vdots \\ M_{m-1,0} & M_{m-1,1} & \cdots & M_{m-1,n-1} \end{bmatrix}.\]

De manera más general, los números que se organizan usando múltiples índices se denominan colectivamente tensores. Los tensores pueden tener más de dos índices. Por ejemplo, los productos de cruce vectorial se calculan utilizando el tensor Levi-Civita\(\varepsilon\), que tiene tres índices:

\[\left(\vec{A} \times \vec{B}\right)_i = \sum_{jk} \varepsilon_{ijk} A_j B_k.\]

4.1.1 Matrices multidimensionales

En Python, los tensores están representados por matrices multidimensionales, que son similares a las matrices 1D excepto que se abordan usando más de un índice. Por ejemplo, las matrices están representadas por matrices 2D, y el componente\((i,j)\) th de una\(m\times n\) matriz se escribe en notación Python de la siguiente manera:

\[M_{ij} \quad \leftrightarrow\quad \texttt{M[i,j]} \quad\quad \mathrm{for} \;\;i=0,\dots,m-1, \;\;j=0,\dots,n-1.\]

Figura\(\PageIndex{1}\): Modelo de memoria de una matriz 2D.

La forma en que se disponen las matrices multidimensionales en la memoria es muy similar a la disposición de la memoria de las matrices 1D. Hay un bloque de contabilidad, que está asociado con el nombre de la matriz, y que almacena información sobre el tamaño de la matriz (incluyendo el número de índices y el tamaño de cada índice), así como la ubicación de la memoria del contenido de la matriz. Los elementos se encuentran en una secuencia de bloques de almacenamiento, en un orden específico (dependiendo del tamaño de la matriz). Esta disposición se muestra esquemáticamente en la Fig. \(\PageIndex{1}\).

Cuando Python necesita acceder a cualquier elemento de una matriz multidimensional, sabe exactamente en qué ubicación de memoria está almacenado el elemento. La ubicación se puede calcular a partir del tamaño de la matriz multidimensional y la ubicación de la memoria del primer elemento. En la Fig. \(\PageIndex{1}\), por ejemplo, M es una\(2\times 3\) matriz, que contiene bloques de\(6\) almacenamiento dispuestos en una secuencia específica. Si necesitamos acceder a M [1,1], Python sabe que necesita saltar al bloque de almacenamiento cuatro cuadras abajo del\((0,0)\) bloque. Por lo tanto, la lectura/escritura de los elementos de una matriz multidimensional es una\(O(1)\) operación, al igual que para las matrices 1D.

En las siguientes subsecciones, describiremos cómo se pueden crear y manipular matrices multidimensionales en código Python.

Nota

También hay una clase especial Scipy llamada matrix que se puede usar para representar matrices. No uses esto. Es una capa encima de las instalaciones de arreglos multidimensionales de Scipy, principalmente pensada como una muleta para los programadores que hacen la transición de Matlab. Las matrices son mejores para usar, y más consistentes con el resto de Scipy.

4.1.2 Creación de matrices multidimensionales

Puede crear una matriz 2D con elementos específicos usando el comando array, con una entrada que consiste en una lista de listas:

>>> x = array([[1., 2., 3.], [4., 5., 6.]])
>>> x
array([[ 1.,  2.,  3.],
       [ 4.,  5.,  6.]])

El código anterior crea una matriz 2D (es decir, una matriz) llamada x. Se trata de una\(2\times 3\) matriz, que contiene los elementos\(x_{00}=1\)\(x_{01}=2\),\(x_{02}=3\),, etc. Del mismo modo, se puede crear una matriz 3D suministrando una entrada que consiste en una lista de listas de listas; y así sucesivamente.

Es más común, sin embargo, crear matrices multidimensionales usando unos o ceros. Estas funciones devuelven matrices cuyos elementos son inicializados a\(0.0\) y\(1.0\), respectivamente. (A continuación, puede asignar valores a los elementos según lo desee). Para ello, en lugar de especificar un número como entrada (lo que crearía una matriz 1D de ese tamaño), se debe especificar una tupla como entrada. Por ejemplo,

>>> x = zeros((2,3))
>>> x
array([[ 0.,  0.,  0.],
       [ 0.,  0.,  0.]])
>>>
>>> y = ones((3,2))
>>> y
array([[ 1.,  1.],
       [ 1.,  1.],
       [ 1.,  1.]])

Hay muchas más formas de crear matrices multidimensionales, que discutiremos cuando sea necesario.

4.1.3 Operaciones básicas de arreglos

Para verificar la dimensión de una matriz, consulte su ranura ndim:

>>> x = zeros((5,4))
>>> x.ndim
2

Para determinar la forma exacta de la matriz, use la ranura de forma (la forma se almacena en forma de tupla):

>>> x.shape
(3, 5)

Para acceder a los elementos de una matriz multidimensional, use notación de corchetes cuadrados: M [2,3], T [0,4,2], etc. Solo recuerde que cada componente está indexado a cero.

Las matrices multidimensionales se pueden rebanar, de manera similar a las matrices 1D. Hay una característica importante del corte multidimensional: si especifica un solo valor como uno de los índices, el corte da como resultado una matriz de dimensionalidad más pequeña. Por ejemplo:

>>> x = array([[1., 2., 3.], [4., 5., 6.]])
>>> x[:,0]
array([ 1.,  4.])

En el código anterior, x es una matriz 2D de tamaño\(2\times 3\). El sector\(x[:,0]\) especifica el valor\(0\) para index\(1\), por lo que el resultado es una matriz 1D que contiene los elementos\([x_{00}, x_{10}]\).

Si no especifica todos los índices de una matriz multidimensional, los índices omitidos se incluyen implícitamente y se ejecutan en todo su rango. Por ejemplo, para la matriz x anterior,

>>> x[1]
array([ 4.,  5.,  6.])

Esto también equivale a x [1,:].

4.1.4 Operaciones Aritméticas

Todas las operaciones aritméticas básicas se pueden realizar en matrices multidimensionales y actuar sobre las matrices elemento por elemento. Por ejemplo,

>>> x = ones((2,3))
>>> y = ones((2,3))
>>> z = x + y
>>> z
array([[ 2.,  2.,  2.],
       [ 2.,  2.,  2.]])

Se puede pensar en esto en términos de notación de índice:

\[z_{ij} = x_{ij} + y_{ij}.\]

¿Cuál es el tiempo de ejecución para realizar tales operaciones aritméticas en matrices multidimensionales? Con un poco de pensamiento, podemos convencernos de que el tiempo de ejecución escala linealmente con el número de elementos en la matriz multidimensional, porque la operación aritmética se realiza en cada índice individual. Por ejemplo, el tiempo de ejecución para agregar un par de\(M\times N\) matrices escalas como\((O(MN)\).

Nota

El operador de multiplicación* también actúa elemento por elemento. ¡No se refiere a la multiplicación matricial!

Por ejemplo,

>>> x = ones((2,3))
>>> y = ones((2,3))
>>> z = x * y
>>> z
array([[ 1.,  1.,  1.],
       [ 1.,  1.,  1.]])

En notación de índice, podemos pensar en el operador * como haciendo esto:

\[z_{ij} = x_{ij} y_{ij}.\]

Por el contrario, la multiplicación matricial es\(z_{ij} = \sum_k x_{ik} y_{kj}\). Veremos cómo se logra esto en la siguiente subsección.

4.1.5 La Operación Dot

La función más utilizada para la multiplicación de matrices es la función punto, que toma dos entradas de matriz x e y y devuelve su “producto punto”. Construye un producto sumando sobre el último índice de la matriz x, y sobre el índice siguiente al último de la matriz y (o sobre su último índice, si y es una matriz 1D). Esto puede sonar como una regla complicada, pero deberías poder convencerte de que corresponde al tipo apropiado de operación de multiplicación para los casos más comunes que se encuentran en álgebra lineal:

• Si x e y son ambas matrices 1D (vectores), entonces punto corresponde al producto punto habitual entre dos vectores:
  \[\texttt{z} = \texttt{dot(x,y)} \;\;\; \leftrightarrow \;\;\; z = \sum_{k} x_k\, y_k \]
• Si x es una matriz 2D e y es una matriz 1D, entonces punto corresponde a multiplicar a la derecha una matriz por un vector:
  \[\texttt{z} = \texttt{dot(x,y)} \;\;\; \leftrightarrow \;\;\; z_i = \sum_{k} x_{ik}\, y_k \]
• Si x es una matriz 1D e y es una matriz 2D, entonces el punto corresponde a la multiplicación izquierda:
  \[\texttt{z} = \texttt{dot(x,y)} \;\;\; \leftrightarrow \;\;\; z_i = \sum_{k} x_{k} \,y_{ki} \]
• Si x e y son ambas matrices 2D, el punto corresponde a la multiplicación de matriz:
  \[\texttt{z} = \texttt{dot(x,y)} \;\;\; \leftrightarrow \;\;\; z_{ij} = \sum_{k} x_{ik}\, y_{kj} \]
• La regla también se aplica a matrices de dimensiones superiores. Por ejemplo, dos tensores de rango 3 se multiplican juntos de esta manera:
  \[\texttt{z} = \texttt{dot(x,y)} \;\;\; \leftrightarrow \;\;\; z_{ijpq} = \sum_{k} x_{ijk} \,y_{pkq} \]

Si necesita realizar productos más generales que los que proporciona la función punto, puede usar la función tensordot. Esto toma dos entradas de matriz, x e y, y una tupla de dos enteros que especifican qué componentes de x e y sumar. Por ejemplo, si x e y son matrices 2D,

\[\texttt{z} = \texttt{tensordot(x, y, (0,1))} \;\;\; \leftrightarrow \;\;\; z_{ij} = \sum_{k} x_{ki} \,y_{jk} \]

¿Cuál es el tiempo de ejecución para punto y tensordot? Considera un caso simple: multiplicación matricial de una\(M\times N\) matriz con una\(N\times P\) matriz. En notación de índice, esto tiene la forma

\[C_{ij} = \sum_{k=0}^{N-1} A_{ik} \, B_{kj},\quad \mathrm{for}\;i\in\{0,\dots,M-1\}, \;\;j\in\{0,\dots,P-1\}.\]

La matriz resultante tiene un total de\((M\times P)\) índices a computar. Cada uno de estos cálculos requiere una suma que involucre operaciones\(O(N)\) aritméticas. Por lo tanto, el tiempo de ejecución total se escala como\(O(MNP)\). Por razonamiento similar, podemos averiguar el escalado de tiempo de ejecución para cualquier producto tensor entre dos tensores: es el producto de los tamaños de los índices no sumados, multiplicado por el tamaño del índice sumado. Por ejemplo, para un producto tensordot entre un\(M\times N\times P\) tensor y un\(Q\times S\times P\) tensor, sumando sobre el último índice de cada tensor, el tiempo de ejecución escalaría como\(O(MNPQS)\).