Transposición y Suma de Matrices en Python
Contenido del curso
Julián Andrés Santos Méndez
Oyarzabal Ivan
Julián Andrés Santos Méndez
Andres López
Daniel Andrés Peñuela González
Uriel Alfonso Velandia Donado
Josue Noha Valdivia
Cesar Arturo Castanon Acuna
Julián Cárdenas
Mauricio Gomez
Juan R. Vergara M.
Mario Andrés Castro Martínez
Rodrigo Lopez Rosales
Julián Cárdenas
Felix Manuel Figueroa Araujo
Santiago Velásquez Serna
Jeinfferson Bernal G
Carlos Daniel Pimentel Díaz
Erik Ucenik
Diego Jurado
Guillermo Dario Acosta Cabrera
Angello Villanueva Menichetti
Cristian Ruben Pereyra
Sebastián Andrade
jhonatan larico
Sebastián Andrade
Juan Diego Bonifacio Briceño
Sebastian Sosa
Profesor
Alfonso Andres Zapata Guzman
Nicolas Vargas
Mayra Lopez
Carlos Antonio Martínez Martínez
Santiago Ruiz
Jhon Freddy Tavera Blandon
Carlos Daniel Pimentel Díaz
Emmanuel Lopez
Alfonso Neil Jiménez Casallas
Numpy facilita mucho el trabajo, eso es un hecho, sin embargo considero que estos temas básicos se deben enseñar de la manera tradicional, por ejemplo, para sumar dos matrices, hay que sumar escalar por escalar, de la manera tradicional, como se hace en C/C++ o a mano. Hacer esto desarrolla la lógica algorítmica.
Aca les presento el primer ejemplo de suma del video pero escalar por escalar:
#inicializacion de arrays, uso Numpy solo para iniciarlizar a = np.array([[1,2],[3,4],[5,6]]) b = np.array([[6,5],[4,3],[2,1]]) c = np.array([[0,0],[0,0],[0,0]]) #suma escalar por escalar con bucles while anidados i = 0 while (i<3): j = 0 while (j<2): c[i][j] = a[i][j] + b[i][j] j = j + 1 i = i + 1 print(a) print(b) print(c)``` Los invito a hacer los ejercicios de esta manera, les desarrollara mucha lógica.
Yo creo que si llegaste a este curso, deberias de tener toda esa logica jajaja al final del dia las librerias siempre van a ser mas utiles, porque no hay ser humano en la tierra que pueda aprender todo desde 0 en algo tan complicado y extenso como es la programacion y la tecnologia.
No hay ser humano que pueda hacerlo, es cierto, por eso usamos sckit-learn o TensorFlow, por ejemplo, sin embargo para el nivel básico es muy importante comprender cómo funciona esta álgebra matricial en código, ya que desarrolla el pensamiento algorítmico. Con las librerías y con el pensamiento algorítmico es que se hacen grandes cosas, librerías sin algoritmia... no sirven de nada.
Les comparto el código del escalar, el vector, la matriz y el tensor para que no tengan que escribirlo desde 0
scalar = 5.679 vector = np.array([3,4,5,6]) matriz = np.array([[1,2],[3,4],[5,6]]) tensor = np.array([ [[1,2,3,30], [4,5,6,31], [7,8,9,32]], [[11,12,13,33], [14,15,16,34], [17,18,19,35]], [[21,22,23,36], [24,25,26,37], [27,28,29,38]] ])
Qué buena!
Thanks Bro!
Trasposición:
Nota:
Suma de matrices Está definida para matrices de las mismas dimensiones y será una matriz cuyos elementos serán la sumas de los elementos que se encuentran en la misma posición de las matrices a sumar
Nota:
Josue, thanks for your summary. ⚡ . Here is my activity. :D .
Que buen resumen compañero, gracias por el aporte!
print(matrix, " + ", matrix_t, " = ", final, sep = "\n\n") [[7 3 4 9 1] [0 3 2 9 2] [8 2 4 1 0] [5 2 3 8 7] [1 3 2 4 5]] + [[7 0 8 5 1] [3 3 2 2 3] [4 2 4 3 2] [9 9 1 8 4] [1 2 0 7 5]] = [[14 3 12 14 2] [ 3 6 4 11 5] [12 4 8 4 2] [14 11 4 16 11] [ 2 5 2 11 10]]
Gran aporte amigo 👍
Hola para quienes sean curiosos como yo, aquí les dejo la manera "a pie" de hacer la transposición de matrices, con una List Comprehension:
list comprehensions!
Buen aporte, yo del todo no entiendo esa lógica matemática de la programación :/
Hola a todos, les comparto un listado de funciones en NumPy para trabajar con una array:
import numpy as np a = np.array([ [1, 3, 4, 5], [4, 7, 9, 1], [7, 8, 8, 2] ]) #========Function Basics=============== # print(np.sqrt(a)) # print(np.log(a)) # print(np.exp(a)) # print(np.sin(a)) # print(np.cos(a)) # print(np.tan(a)) # print(np.sum(a)) # ====================================== # print(np.min(a)) # print(np.max(a)) # ====================================== # print(np.mean(a)) # print(np.median(a)) # print(np.std(a)) # ====================================== # b = a.reshape(2,2,3) # print(b) # ===================================== # print(a.flatten()) #====================================== # print(a.flat[7]) #====================================== # for x in a.flat: # print(x) #====================================== # print(a.transpose())
Solo para aclarar, las propiedades y operaciones de los tipos de arreglos(escalares, matrices, etc) solo funcionan en python cuando estamos trabajando un objeto tipo array. Es decir, la propiedad .shape, ndim y en general las operaciones con matrices, solo son posibles si hemos convertido los datos a arrays. la transpuesta de el escalar no le funciona porque no la convirtio previamente
escalar=np.array(5) print(escalar.T)
Esto da como resultado 5 y es obvio si solo tenemos una fila y una columna.
Muy interesante acotacion! Gracias
Hola compañeros les presento un código que hice para sumar dos matrices con el método "clásico" (sin usar NumPy) de complejidad O(n^2), con la función suma_matrices. Es muy fácil de entender. Espero les sirva.
def suma_matrices(matrixA, matrixB): # Inicializamos una matriz para mantener los resultados matrizSuma = [] # Ciclo For para iterar a través de las filas de las matrices. for i in range(len(matrixA)): # Matriz fila para ir agregando la suma de cada elemento. fila = [] # Ciclo For para iterar a través de las columnas de las matrices. for j in range(len(matrixA[0])): suma_ij = matrixA[i][j] + matrixB[i][j] fila.append(suma_ij) matrizSuma.append(fila) return matrizSuma A = [[2, 5, 1], [6, 9, 7.4], [2, 1, 1], [8, 5, 3], [2, 1, 6], [5, 3, 1]] B = [[7, 19, 5.1], [6.5, 9.2, 7.4], [2.8, 1.5, 12], [8, 5, 3], [2, 1, 6], [2, 33, 1]] print(suma_matrices(A, B))
Cualquier duda o complemento me lo hacen saber. Gracias.
Si tenemos una matriz:
| a b c | | d e f | | g h i |
su transpuesta será:
| a d g | | b e h | | c f i |
Como las diagonales son iguales, al sumarlas se duplicarán
| 2*a ? ? | | ? 2*e ? | | ? ? 2*i |
Si tomamos de referencia b, este ocupa el lugar de d en la transpuesta.
Por lo que al sumarlas, en una casilla quedará d + b y en la otra quedará b + d, que son iguales. Pasará lo mismo en el resto de pares que se intercambian la posición.
Al sumar una matriz con su transpuesta, se duplica la diagonal y nos queda una matriz perfectamente simétrica.
Muy avanzados dos los compañeros en sus comentarios
Por si a alguno le llamo la atención o no entendió lo que menciona en el minuto 5 aproximadamente el profesor , que la transpuesta nos ayuda a resolver sistemas de ecuaciones, y también en forma de pregunta si es posible dividir por una matriz como cuando resolvemos cuentas. Todo esto es de lo mas importante del curso y empieza desde el vídeo 11 en adelante. Todo lo visto hasta ahora y en un par de vídeos mas es preparatorio a dicho tema.
Transponer es cambiar las filas por columnas y se realiza con la función .T
La transpuesta de una matriz transpuesta dará lugar a la primera matriz
La suma de matrices tienen las mismas dimensiones
Solo por curiosidad, al usar el metodo reshape de numpy pense que me retornaria la matriz transpuesta pero no fue asi ¿entonces como funciona el metodo reshape?
reshape modifica el tamaño de tu matriz
Si, eso lo tengo entendido pero mi pregunta es ¿como hace matematicamente esta operacion la libreria?
a partir del min 3:32 hasta el min 4.00 cuando imprime el tensor le sale 3 matrices de 3x4(3 flias y 4 columnas) cuando imprime el tensor_t le sale 4 matrices de 3x3 ¿No debería salir el tensor_t 3 matrices de 4x3? y si no es así ¿por qué pasa esto?
Transponer un tensor es una generalización de transponer una matriz, pero no es lo mismo, nosotros no veremos aquí la definición.
Esta estrechamente relacionado con el concepto de simetría y en que orden queremos intercambiar los ejes. Lamentablemente excede al alcance de este curso ver porque el resultado no es el que esperas.
Usar tensor.T es lo mismo que usar la función transpose() sin especificar el orden en el cual queremos realizar la transposición/cambio de los ejes.
tensor_t = tensor.transpose() print(tensor_t)
También es lo mismo que usar el orden (2,1,0)
tensor_t = tensor.transpose((2,1,0)) print(tensor_t) print(tensor_t.shape)
Aquí el uso de tensor.T
tensor_t = tensor.T print(tensor_t)
Por otro lado si definimos el orden de la transposición como el (0,1,2), entonces no estamos haciendo nada y obtenemos nuestro tensor original.
tensor_t = tensor.transpose((0,1,2)) print(tensor_t) print(tensor_t.shape)
Mientras que al utilizar el orden (1,2,0) obtenemos 3 matrices de 4x3
tensor_t = tensor.transpose((1,2,0)) print(tensor_t) print(tensor_t.shape)
[[[ 1 11 21] [ 2 12 22] [ 3 13 23] [30 33 36]]
[[ 4 14 24] [ 5 15 25] [ 6 16 26] [31 34 37]]
[[ 7 17 27] [ 8 18 28] [ 9 19 29] [32 35 38]]] (3, 4, 3)
Yo tengo una pregunta, como hace para al escribir codigo en jupyter y colocar: [] o () y que automaticamente se coloquen ambas con presionar una sola tecla, ya que todo el curso estuve tratando de ver si escuchaba el tecleo doble de primero [ y luego ] para cerrarlo, pero siempre suena es una sola tecla, me imagine que quizas era porque usaba un hotkeys configurado personalmente para hacerlo pero luego vi que tambien lo hacia con (), comparta esto porque optimizaria aunque sea un poco la escritura de codigo, ya que lo que hecho mas de falta en jupyter es que no se autocompletan los parentesis y siempre hay que cerrarlos, es mejor tener que borrar el parentesis en caso de que no se requiera a tener que estarlo tecleando cada vez
en mis matricez puedo tener numero iguales, por ejemplo [1,2], [2,3] [2,1]? O algo por el estilo?
Si, sin problema
Claro que si, recuerda que las matrices solo son un arreglo de un sistema de ecuaciones lineales, los coeficientes son los que se toman para escribir la matriz, por lo cual no hay ningún problema en que se repitan :)
Reto superado, adjunto el código
Matriz_A = np.array([[1,2,3,4,5],[6,7,8,9,10],[11,12,13,14,15],[16,17,18,19,20],[21,22,23,24,25]]) Matriz_B = Matriz_A.T Matriz_C = Matriz_A + Matriz_B print(Matriz_A) print(Matriz_B) print(Matriz_C)
Transposición de una matriz:
import numpy as np # Matriz original A = np.array([[1, 2], [3, 4], [5, 6]]) # Transposición de la matriz A A_transpuesta = A.T print(A) # resultado: [[1 2] # [3 4] # [5 6]] print(A_transpuesta) # resultado: [[1 3 5] # [2 4 6]]
Suma de matrices y escalares:
import numpy as np # Suma de matrices A = np.array([[1, 2], [3, 4]]) B = np.array([[5, 6], [7, 8]]) C = A + B print(C) # resultado: [[ 6 8] # [10 12]] # Suma de un escalar y una matriz D = 2 * A + 3 print(D) # resultado: [[ 5 7] # [ 9 11]]
Reto
d = np.array([[20,21,22],[23,24,25],[26,27,28]]) e = np.array([[29,30,31],[32,33,34],[35,36,37]]) f = d+e print(f)
Comparto con ustedes otro código que realicé para calcular la transpuesta de una matriz de forma "clásica" sin usar NumPy. Espero les sirva.
# Función que extrae la columna de una matriz según la columna deseada. def obtener_columna(matriz, numero_columna): # Inicializamos una matriz para mantener los resultados. columna = [] # Ciclo For que recorre cada elemento de la columna. for i in range(len(matriz)): n = matriz[i][numero_columna] columna.append(n) return columna # Función que calcula la transpuesta de una matriz. def transpuesta(matriz): numero_columnas = len(matriz[0]) # Inicializamos una matriz para mantener los resultados. matriz_transpuesta = [] # Ciclo For que recorre cada columna y la devuelve como una fila. for i in range(numero_columnas): columna_Matriz = obtener_columna(matriz, i) # print(columna_Matriz) matriz_transpuesta.append(columna_Matriz) return matriz_transpuesta m = [[5, 9, 11, 2], [3, 2, 99, 3], [7, 1, 8, 2]] print(transpuesta(m))
matriz2 = np.array([[1,2,3,4,5],[3,4,6,7,8],[5,6,7,8,9,],[9,8,7,6,5],[11,12,13,14,15]]) print(matriz2) [[ 1 2 3 4 5] [ 3 4 6 7 8] [ 5 6 7 8 9] [ 9 8 7 6 5] [11 12 13 14 15]] matriz2_t = matriz2.T print(matriz2_t) [[ 1 3 5 9 11] [ 2 4 6 8 12] [ 3 6 7 7 13] [ 4 7 8 6 14] [ 5 8 9 5 15]] reto = matriz2 + matriz2_t print(reto) [[ 2 5 8 13 16] [ 5 8 12 15 20] [ 8 12 14 15 22] [13 15 15 12 19] [16 20 22 19 30]]
