Operaciones de Álgebra Lineal con NumPy en Python

Clase 10 de 32 • Curso de Python para Ciencia de Datos

Resumen

¿Cómo realizar operaciones básicas de álgebra lineal con NumPy?

El álgebra lineal es esencial para áreas como ciencia de datos y Machine Learning debido a su capacidad para manejar grandes volúmenes de datos de manera eficiente. Con NumPy, una biblioteca clave de Python, estas operaciones se optimizan, facilitando así el cálculo de sumas, restas, multiplicaciones y más en matrices. Aquí aprenderás cómo llevar a cabo estas operaciones utilizando NumPy.

¿Cómo crear matrices en NumPy?

Para empezar, es crucial entender cómo crear matrices en NumPy. Esto se logra mediante la función array, la cual te permite definir y manipular matrices fácilmente. Vamos a ver cómo se hace:

import numpy as np

A = np.array([[1, 2], [3, 4]])
B = np.array([[5, 6], [7, 8]])

En este ejemplo, A y B son matrices de 2x2, listas para ser utilizadas en operaciones matemáticas.

¿Cómo se realiza la suma y resta de matrices?

La suma y la resta de matrices con NumPy es directa. Basta con utilizar los operadores + para adición y - para sustracción, respectivamente.

# Suma de matrices
sum = A + B
print(sum)

# Resta de matrices
resta = A - B
print(resta)

Cada elemento del arreglo resultante es la suma o diferencia de los elementos correspondientes en las matrices originales.

¿Cómo realizar una multiplicación matricial?

La multiplicación entre matrices, también conocida como producto matricial, se realiza con la función dot de NumPy:

# Producto matricial
producto = np.dot(A, B)
print(producto)

Este método considera las reglas de multiplicación de matrices, no confundir con la multiplicación de elementos individuales.

¿Cómo calcular el determinante y la inversa de una matriz?

NumPy también ofrece funciones para calcular el determinante e inversa de una matriz, elementos fundamentales en álgebra lineal.

Determinante

# Determinante
determinante = np.linalg.det(A)
print(determinante)

El determinante es un número único que puede proporcionar información sobre las propiedades de la matriz, como si es invertible o no.

Inversa

# Inversa
inversa = np.linalg.inv(A)
print(inversa)

La inversa es una matriz tal que, cuando se multiplica por la matriz original, produce la matriz identidad.

¿Cómo resolver un sistema de ecuaciones lineales con matrices?

NumPy facilita la resolución de sistemas de ecuaciones lineales de la forma (A \times X = B), donde necesitas encontrar (X).

# Resolver sistema de ecuaciones lineales
B = np.array([9, 11])
X = np.linalg.solve(A, B)
print(X)

Este cálculo devuelve el vector (X) que satisface el sistema de ecuaciones.

Estas operaciones son la base para el manejo de datos en grandes volúmenes, y pueden ser extendidas a situaciones más complejas dependiendo del tipo de problema que enfrentes. Explorar y practicar con estas herramientas te ayudará a fortalecer tus habilidades en ciencia de datos y Machine Learning. ¡Sigue explorando y dominando el fascinante mundo del álgebra lineal y NumPy!

Andres Fandiño

student•

matrices, que tiempos en la carrera de ingeniería buen lápiz y papel gaste haciendo matrices.

Antonio Jesús Dominguez

student•

En multiplicación de matrices debemos tener en cuenta que las columnas del primer Matriz( nxm) y filas de segundo Matriz( mxp) deben ser iguales , finalmente el resultado del producto de Matrices tiene la forma de P(nxp) .

Andrés Sotelo Durán

student•

Ojala explicaran mejor el tema de multiplicacion de Matrices. Y no lo pasaran asi tan encima

Esteban Diaz Diez

student•

La cuestión es que es un curso de Numpy y Pandas, no de álgebra lineal. A mi me tocó ir a youtube y buscar clases de matrices para entender mejor ese concepto.

Sergio Adrian Coronado Eid

student•

Existe el curso para eso: https://platzi.com/cursos/algebra-lineal/

Gabriel Obregón

student•

1. SUMA DE MATRICES

Descripción: La suma de matrices en Numpy permite la adición elemento a elemento de dos matrices de la misma forma. Es una operación básica en cálculos numéricos.

Ejemplos:

Código: A = np.array([[1, 2], [3, 4]])

B = np.array([[5, 6], [7, 8]])

sum = A + B

print(A)

print(B)

print(sum)

Resultado: A:

[[1 2]

[3 4]]

[[5 6]

[7 8]]

sum:

[[ 6 8]

[10 12]]

Explicación: Cada elemento de A se suma al elemento correspondiente de B, resultando en la matriz sumada.

2. MULTIPLICACIÓN DE MATRICES

Descripción: La multiplicación de matrices en Numpy se puede realizar utilizando la función np.dot(). Esta calcula el producto escalar entre dos matrices o arreglos.

Ejemplos:

Código: A = np.array([[1, 2], [3, 4]])

B = np.array([[5, 6], [7, 8]])

product = np.dot(A, B)

print(product)

Resultado: product:

[[19 22]

[43 50]]

Explicación: Las filas de A se multiplican con las columnas de B utilizando la fórmula del producto escalar.

3. DETERMINANTE E INVERSA

Descripción:

Determinante: El determinante de una matriz cuadrada es un valor escalar calculado a partir de sus elementos. Indica si una matriz es invertible.
Inversa: La inversa de una matriz es una matriz que, al multiplicarse con la original, resulta en la matriz identidad.

Ejemplos:

Código: A = np.array([[1, 2], [3, 4]])

det_A = np.linalg.det(A)

inv_A = np.linalg.inv(A)

print(A)

print(det_A)

print(inv_A)

Resultado: A:

[[1 2]

[3 4]]

det_A: -2.0000000000000004

inv_A:

[[-2. 1. ]

[ 1.5 -0.5]]

Explicación:
- El determinante se calcula con np.linalg.det(), mostrando que la matriz es invertible (determinante distinto de cero).
- La inversa se calcula con np.linalg.inv(), resultando en una matriz que satisface A⋅A−1=IA \cdot A^{-1} = I.

4. ECUACIONES LINEALES

Descripción: La función np.linalg.solve resuelve ecuaciones lineales de la forma Ax=bAx = b, donde AA es la matriz de coeficientes y bb es el vector constante.

Ejemplos:

Código: A = np.array([[1, 2], [3, 4]])

b = np.array([9, 11])

x = np.linalg.solve(A, b)

print(x)

Resultado: x: [-7. 8.]

Explicación: El vector solución xx satisface la ecuación Ax=bAx = b, calculado usando np.linalg.solve().

waek vexotiq youtube

student•

gracias

Andrés Sotelo Durán

student•

Igual con el tema de las determinantes y las inversas. Muy por encima y mediocre esa explicación. Aunque sea la profesora si sabe para que se usa una determinante o una inversa?

Carli Code

teacher•

Hola Andrés, este curso no se enfoca en conceptos de álgebra lineal, solo me enfoco en el código y su uso ;)

Diego Ernesto Cuaycal Tirira

student•

Las matrices y su maravilla

Ricardo David Cárdenas Vázquez

student•

Un ejemplo interesante es el método np.linalg.lstsq, que permite encontrar la solución por mínimos cuadrados de un sistema de la forma Ax=y. Esto es importante para realizar una regresión lineal simple.

El primer paso es tener dos vectores de datos a los cuales queremos realizarles una regresión lineal simple. Como queremos una ecuación vectorial de la forma y=mx+c, podemos pasarlo a una forma matricial con np.stack. Finalmente usamos np.linalg.lstsq , y conseguimos una regresión lineal simple!

x = np.array([0,1,2,3])
y = np.array([-1,0.2,0.9,2.1])
, 
A = np.stack([x, np.ones(len(x))], axis=1)
print(A)
m, c = np.linalg.lstsq(A, y, rcond=None)[0]
print(m,c)
print(m*x+c)

Antonio Demarco Bonino

student•

Me puse a hacer pruebas y me encantó:

A = np.array([[1, 2, 3], [4, 5, 6]]) B = np.array([[7, 8, 9], [10, 11, 12]]) print("Matriz A:\n", A)print("Matriz B:\n", B) suma = A + Bprint("Suma de A y B:\n", suma) resta = A - Bprint("Resta de A y B:\n", resta) multiplicacion_elemento = A * Bprint("Multiplicación elemento por elemento de A y B:\n", multiplicacion_elemento) division = A / Bprint("División elemento por elemento de A y B:\n", division) multiplicacion_matrices = np.dot(A, B.T) print("Multiplicación matricial (producto punto) de A y B:\n", multiplicacion_matrices)

Mario Alexander Vargas Celis

student•

Los cálculos matriciales en NumPy son esenciales para realizar operaciones matemáticas eficientes con matrices y arreglos. Aquí te explico algunos de los conceptos clave y operaciones que puedes realizar:

### 1. **Creación de Matrices**

- **Matriz a partir de listas anidadas:**

```python

import numpy as np

A = np.array([[1, 2], [3, 4]])

```

- **Matrices especiales:**

```python

Z = np.zeros((2, 2)) # Matriz de ceros

O = np.ones((2, 2)) # Matriz de unos

I = np.eye(2) # Matriz identidad

```

### 2. **Operaciones Básicas**

- **Suma y resta de matrices:**

```python

C = A + B

D = A - B

```

- **Multiplicación por un escalar:**

```python

E = 2 * A

```

- **Multiplicación de matrices:**

```python

F = np.dot(A, B) # Producto matricial

```

### 3. **Transposición de una Matriz**

```python

A_T = A.T

```

### 4. **Inversa de una Matriz**

```python

A_inv = np.linalg.inv(A)

```

### 5. **Determinante de una Matriz**

```python

det_A = np.linalg.det(A)

```

### 6. **Solución de Sistemas de Ecuaciones Lineales**

- Si tienes un sistema de ecuaciones \( AX = B \):

```python

X = np.linalg.solve(A, B)

```

### 7. **Valores y Vectores Propios**

```python

eigvals, eigvecs = np.linalg.eig(A)

```

### 8. **Operaciones Elemento a Elemento**

- **Multiplicación elemento a elemento:**

```python

G = A * B

```

- **División elemento a elemento:**

```python

H = A / B

```

### 9. **Reducción (Sumas, Máximos, etc.)**

- **Suma de todos los elementos:**

```python

total_sum = np.sum(A)

```

- **Máximo de todos los elementos:**

```python

max_value = np.max(A)

```

### 10. **Broadcasting**

NumPy permite realizar operaciones entre matrices de diferentes dimensiones de forma automática, ajustando las dimensiones según sea necesario.

```python

I = A + 1 # Añade 1 a todos los elementos de A

```

Estos son solo algunos ejemplos de lo que puedes hacer con NumPy para realizar cálculos matriciales. NumPy es extremadamente eficiente y es una herramienta fundamental para cualquier análisis de datos, machine learning o cálculos científicos en Python.

Jhon Freddy Tavera Blandon

student•


import numpy as np

A = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
B = np.array([[9, 8, 7], [6, 5, 4], [3, 2, 1]])
C = np.array([[1, 2], [3, 4], [5, 6]])
D = np.array([[7, 8], [9, 10]])
E = np.array([[1, 2], [3, 4]])

print("Matriz A:")
print(A)
print("\nMatriz B:")
print(B)


suma = A + B
resta = A - B
print("\nSuma de A y B:")
print(suma)
print("\nResta de A y B:")
print(resta)


multiplicacion_elemento = A * B
print("\nMultiplicación elemento a elemento de A y B:")
print(multiplicacion_elemento)


producto_punto = np.dot(C, D)
print("\nProducto punto de C y D:")
print(producto_punto)

A_transpuesta = A.T
print("\nTransposición de A:")
print(A_transpuesta)


E_inversa = np.linalg.inv(E)
determinante_E = np.linalg.det(E)
print("\nInversa de E:")
print(E_inversa)
print("\nDeterminante de E:")
print(determinante_E)


eigenvalores, eigenvectores = np.linalg.eig(E)
print("\nEigenvalores de E:")
print(eigenvalores)
print("\nEigenvectores de E:")
print(eigenvectores)


A_sys = np.array([[3, 1], [1, 2]])
b = np.array([9, 8])
x = np.linalg.solve(A_sys, b)
print("\nSolución del sistema de ecuaciones Ax = b:")
print(x)


norma_A = np.linalg.norm(A)
print("\nNorma de A:")
print(norma_A)

Diego Andrés Lopez Rodriguez

student•

Juliana Castillo Araujo

Team Platzi•

Este es mi ejemplo FAV 👩‍💻

vector = np.array([1, 2, 3])

matriz = np.array([[1, 2, 3],

[4, 5, 6],

[7, 8, 9]])

print("Vector:")

print(vector)

print("\nMatriz:")

print(matriz)

Laura Juliana Piraneque Esquivel

student•

Estas son algunas reglas que hay que tener en cuenta al realizar operaciones entre matrices:

Para sumarlas y restarlas, las matrices deben tener el mismo número de filas y columnas.
Para multiplicarlas, el número de columnas de la primera matriz debe ser igual al número de filas de la segunda matriz. El resultado será una matriz con el número de filas de la primera matriz y el número de columnas de la segunda matriz.

Esto lo aprendí en mi clase de Álgebra Lineal en la Universidad. Para quienes quieren incursionar en el mundo de la Ciencia de Datos, les recomiendo aprender sobre este tema (vectores, matrices, sistemas de ecuaciones lineales, valores y vectores propios).