<jupyter_start><jupyter_text>Clase Nro. 6: Álgebra Lineal > El álgebra lineal es una rama de las matemáticas que estudia conceptos tales como vectores, matrices, espacio dual, sistemas de ecuaciones lineales y en su enfoque de manera más formal, espacios vectoriales y sus transformaciones lineales np.linalg: paquete de álgebra lineal en NumPy - Funciones básicas     - vectores    - operaciones con vectores     - norma de un vector    - operaciones con matrices    - inversa de una matriz    - determinante- Resolución de sistemas _Con el manejo básico de arrays en Python con NumPy, es hora de pasar a operaciones más interesantes como son las propias del Álgebra Lineal.__Los productos escalares y las inversiones de matrices están por todas partes en los programas científicos e ingenieriles, así que vamos a estudiar cómo se realizan en Python._ Como sabemos, las operaciones del álgebra lineal aparecen con mucha frecuencia a la hora de resolver sistemas de ecuaciones en derivadas parciales y en general al linealizar problemas de todo tipo, y suele ser necesario resolver sistemas con un número enorme de ecuaciones e incógnitas. Gracias a los arrays de NumPy podemos abordar este tipo de cálculos en Python, ya que todas las funciones están escritas en C o Fortran y tenemos la opción de usar bibliotecas optimizadas al límite. El paquete de álgebra lineal en NumPy se llama `linalg`, así que importando NumPy con la convención habitual podemos acceder a él escribiendo `np.linalg`.  **Pero ¿Porqué álgebra lineal?** Si entendemos álgebra lineal podremos desarrollar una mejor intuición para el aprendizaje automático y algoritmos. Además, también seremos capaces de desarrollar algoritmos desde cero y hacer variaciones de ellos. **¿Qué es un vector?** Un vector tiene tanto magnitud como dirección. Utilizamos vectores para describir, por ejemplo, la velocidad de objetos en movimiento. Por dirección, se refiere a dónde en el espacio apunta la “flecha”, y la magnitud te dice qué tan lejos debes ir en esa dirección. Si solo tienes magnitud, pero no dirección, entonces estás hablando de escalares. Una vez que le das al escalar alguna dirección, se convierte en un vector.Un vector se representa con una letra minúscula y una flecha arriba, apuntando a la derecha ![vector](https://cdn-images-1.medium.com/max/800/1*6dAzelg6O36hbb74L7b1gQ.png) **Suma de vectores** Para sumar los vectores (x₁,y₁) y (x₂,y₂), sumamos los componentes correspondientes de cada vector: (x₁+x₂,y₁+y₂) ![suma de vectores](https://cdn-images-1.medium.com/max/800/0*9r4Qmivh-MSPFqM3.png)<jupyter_code><jupyter_output><empty_output><jupyter_text>**Multiplicar un vector por un escalar** ![](https://cdn-images-1.medium.com/max/800/0*YNlBN98aoAyV4DAL.png)<jupyter_code><jupyter_output><empty_output><jupyter_text>**Producto punto o escalar** Esto suena raro, pero no es más que la multiplicación de vectores cuyo resultado es un escalar. Para calcular el producto escalar de dos vectores, primero debemos multiplicar los elementos correspondientes y luego sumar los términos del producto. En la siguiente fórmula lo vemos mucho más fácil ![image.png](https://cdn-images-1.medium.com/max/800/0*lMEmcY_nXD4LOvHD.png)<jupyter_code><jupyter_output><empty_output><jupyter_text>**Norma vectorial** La norma es solo otro término para la magnitud de un vector y se denota con dos lineas dobles (||) en cada lado. Se define como una raíz cuadrada de la suma de cuadrados para cada componente de un vectorPasos: - Elevar al cuadrado cada componente- Suma todos los cuadrados- Toma la raíz cuadradaTrabajemos ahora con la formula: ![](https://cdn-images-1.medium.com/max/800/0*fIYtRzCI6vI8THet.png)<jupyter_code><jupyter_output><empty_output><jupyter_text>**Vector unitario** Los vectores unitarios son aquellos cuya magnitud es exactamente 1 unidad. Son muy útiles por diversas razones. Específicamente, los vectores unitarios [0,1] y [1,0] juntos pueden formar cualquier otro vector.Un vector unitario se denota con mayor frecuencia con un símbolo de sombrero (^) y se determina calculando la norma y luego dividiendo cada componente del vector con la norma.Suena complejo, pero vamos a hacer un ejercicio para poder ver que es más complejo de lo que imaginamos ![](https://cdn-images-1.medium.com/max/800/0*3Qkk3weTeyaMYthE.png)<jupyter_code><jupyter_output><empty_output><jupyter_text>Operaciones con matrices  ¿Qué es una matriz? Una matriz es simplemente un arreglo rectangular de números En data science las usamos un montón, así no nos demos cuenta. Es muy importante de diferenciar un vector de una matriz. En pocas palabras un vector es una sola columna (atributo) en su conjunto de datos y una matriz es una colección de todas las columnas<jupyter_code><jupyter_output><empty_output><jupyter_text>**Definición de matrices** $A = \begin{equation}\begin{bmatrix}1 & 2 & 3\\4 & 5 & 6\\\end{bmatrix}\end{equation}$<jupyter_code><jupyter_output><empty_output><jupyter_text>$B = \begin{equation}\begin{bmatrix}5 & 5 & 5\\5 & 5 & 5\\\end{bmatrix}\end{equation}$<jupyter_code><jupyter_output><empty_output><jupyter_text>$v = \begin{equation}\begin{bmatrix}6\\7\\8\end{bmatrix}\end{equation}$<jupyter_code><jupyter_output><empty_output><jupyter_text>**Suma de matrices** ![](https://cdn-images-1.medium.com/max/1600/0*eKgiNEikBO09MCN1.png)<jupyter_code><jupyter_output><empty_output><jupyter_text>**Resta de matrices**<jupyter_code><jupyter_output><empty_output><jupyter_text>**Multiplicación por un escalar** ![](https://cdn-images-1.medium.com/max/1600/0*RMuq3SZ_8Z4KE-48.png)<jupyter_code><jupyter_output><empty_output><jupyter_text>**Matriz transpuesta** ![](https://cdn-images-1.medium.com/max/1600/0*mrjFrMfmMcj4xsUe.png)<jupyter_code><jupyter_output><empty_output><jupyter_text>**Matriz identidad**<jupyter_code>#help(np.linalg)<jupyter_output><empty_output><jupyter_text>Recordemos que si queremos usar una función de un paquete pero no queremos escribir la "ruta" completa cada vez, podemos usar la sintaxis `from package import func`:<jupyter_code>from numpy.linalg import norm, det
norm<jupyter_output><empty_output><jupyter_text>El producto matricial usual (no el que se hace elemento a elemento, sino el del álgebra lineal) se calcula con la misma función que el producto matriz-vector y el producto escalar vector-vector: con la función `dot`, que **no** está en el paquete `linalg` sino directamente en `numpy` y no hace falta importarlo.<jupyter_code>np.dot<jupyter_output><empty_output><jupyter_text>Una consideración importante a tener en cuenta es que en NumPy no hace falta ser estricto a la hora de manejar vectores como si fueran matrices columna, siempre que la operación sea consistente. Un vector es una matriz con una sola dimensión: por eso si calculamos su traspuesta no funciona.<jupyter_code>M = np.array([
    [1, 2],
    [3, 4]
])
v = np.array([1, -1])<jupyter_output><empty_output><jupyter_text>v<jupyter_code>M.T
v.T
v.reshape(2,1).T
u = np.dot(M, v)
u<jupyter_output><empty_output><jupyter_text>**Multiplicación entre matrices**<jupyter_code># producto matricial<jupyter_output><empty_output><jupyter_text>**Determinante de una matriz**<jupyter_code># calcula el determinante de una matriz<jupyter_output><empty_output><jupyter_text>**Inversa de una matriz** Para calcular la matriz inversa en Python, use la función linalg.inv () del módulo numpy. linalg.inv(x) El parámetro x de la función es una matriz cuadrada invertible M definida con la función array() de numpy. La función genera la matriz inversa M-1 de la matriz M. > ¿Qué es la matriz inversa? La matriz inversa M-1 de una matriz cuadrada es una matriz tal que el producto M · M-1 es igual a una matriz de identidad I.  Encuentre la matriz inversa M-1 de la siguiente matriz invertible M. ![](http://how.okpedia.org/data/okpediaorg/matrix-inverse-example-python-1.gif)<jupyter_code>m=np.array([[3,4,-1],[2,0,1],[1,3,-2]])
# Calcula la matriz inversa con la función linalg.inv().<jupyter_output><empty_output><jupyter_text>La matriz de salida inversa es también un objeto array(). Se puede leer como una lista anidada. Los elementos de la matriz inversa son números reales.![](http://how.okpedia.org/data/okpediaorg/matrix-inverse-example-9.gif) Verificación. El producto de la matriz M para la matriz M-1 es una matriz de identidad.![](http://how.okpedia.org/data/okpediaorg/matrix-inverse-example-10.gif)<jupyter_code># verificación<jupyter_output><empty_output><jupyter_text>**Otro ejemplo** Encontrar el determinante y la matriz inversa de D.$ D = \begin{equation}\begin{bmatrix}1 & 2\\3 & 4\\\end{bmatrix}\end{equation}$<jupyter_code>D = np.array([[1, 2], [3, 4]])
D
# cálculo del determinante

# y el inverso<jupyter_output><empty_output><jupyter_text>**Solución de ecuaciones con matrices** 1. Resolver el siguiente sistema de ecuaciones$\begin{eqnarray}3x + y  = 9 \\x + 2y = 8 \\\end{eqnarray}$<jupyter_code><jupyter_output><empty_output><jupyter_text>Ejercicios 1- Hallar el producto de estas dos matrices y su determinante:$$\begin{pmatrix} 1 & 0 & 0 \\ 2 & 1 & 1 \\ -1 & 0 & 1 \end{pmatrix} \begin{pmatrix} 2 & 3 & -1 \\ 0 & -2 & 1 \\ 0 & 0 & 3 \end{pmatrix}$$<jupyter_code>from numpy.linalg import det<jupyter_output><empty_output><jupyter_text>3- Resuelva el siguiente sistema de ecuaciones $\begin{eqnarray}x + 2y  = 3 \\3x + 4y = 5 \\\end{eqnarray}$<jupyter_code><jupyter_output><empty_output><jupyter_text>4- Un ingeniereo escribe dos ecuaciones que describen el circuito, como sigue: $\begin{gather}300I_{1} + 500(I_{1}-I_{2})-20 = 0\\200I_{2} + 500(I_{2}-I_{1}) +10 = 0\\\end{gather}$![circuito](https://github.com/lsantiago/PythonIntermedio/blob/master/Clases/Semana6_ALGEBRA/img/problem4.png?raw=1)Coloque las dos ecuaciones en forma estándar y resuelva las dos ecuaciones:<jupyter_code><jupyter_output><empty_output><jupyter_text>5- Resolver el siguiente sistema de ecuaciones![](https://github.com/lsantiago/PythonIntermedio/blob/master/Clases/Semana6_ALGEBRA/img/problem5.png?raw=1)<jupyter_code><jupyter_output><empty_output><jupyter_text>3- Resolver el siguiente sistema:$$ \begin{pmatrix} 2 & 0 & 0 \\ -1 & 1 & 0 \\ 3 & 2 & -1 \end{pmatrix} \begin{pmatrix} 1 & 1 & 1 \\ 0 & 1 & 2 \\ 0 & 0 & 1 \end{pmatrix} \begin{pmatrix} x \\ y \\ z \end{pmatrix} = \begin{pmatrix} -1 \\ 3 \\ 0 \end{pmatrix} $$<jupyter_code><jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.10318151049221545, 'fraction_numerical': 0.02079102601295813, 'mean_word_length': 5.646529562982005, 'pattern_counts': {'":': 0, '<': 117, '<?xml version=': 0, '>': 119, 'https://': 11, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '29', 'dir': 'jupyter-structured-clean-dedup', 'id': '306565', 'license': 'MIT', 'n_tokens_mistral': 3832, 'n_tokens_neox': 3664, 'n_words': 1110, 'path': 'Clases/Semana6_ALGEBRA/algebra_lineal_apuntes.ipynb', 'repo_name': 'CarlosLedesma/PythonIntermedio', 'size': '10341'}