Ernesto Crespo: Manejo de matrices con TensorFlow

# Se importa numpy y tensorflow
importnumpyasnp
importtensorflowastf

#Se crea una matriz de 4x4
tensor_2d=np.array([(4,3,2,1),(4,5,6,7),(11,10,9,8),(12,13,14,15)])

#Se imprime la matriz
print(tensor_2d)

#Se muestra el elemento 3,3 de la matriz
tensor_2d[3][3]

#Se muestra una sub matriz
tensor_2d[0:2,0:2]

#Se crean dos matrices 3x3 de tipo int32
matriz1=np.array([(2,2,2),(2,2,2),(2,2,2)],dtype='int32')
matriz2=np.array([(1,1,1),(1,1,1),(1,1,1)],dtype='int32')

#Se muestra la matriz 1
print("Matriz 1-> \n{}".format(matriz1))

#Se muestra la matriz 2
print("Matriz 2-> \n{}".format(matriz2))

#Se define las 2 matrices como objeto tensorflow
matriz1=tf.constant(matriz1)
matriz2=tf.constant(matriz2)

# Se calcula el producto y la suma de dos matrices
matriz_prod=tf.matmul(matriz1,matriz2)
matriz_suma=tf.add(matriz1,matriz2)

#Se crea una matriz 3x3
matriz3=np.array([(2,7,2),(1,4,2),(9,0,2)],dtype='float32')

#Se imprime la matriz3
print("Matriz 3-> \n{}".format(matriz3))

#Se calcula la matriz determinante
matriz_det=tf.matrix_determinant(matriz3)

#Se crea la sesión y se ejecuta las matrices calculadas
withtf.Session()assess:
res1=sess.run(matriz_prod)
res2=sess.run(matriz_suma)
res3=sess.run(matriz_det)

#Se imprime el producto de las matrices
print("matriz1*matriz2-> \n{}".format(res1))

##Se imprime la suma de las matrices
print("matriz1+matriz2-> \n{}".format(res2))

# Se imprime el determinante de la matriz 3
print("det(matriz3)-> {}".format(res3))

#Se muestra la dimensión de la matriz1
matriz1.shape

#Se crea un arreglo
a=np.array([[1,2,3],[4,5,6],[7,8,9]])

#Se muestra el arreglo
a

#Se muestra el elemento [0,1] 
a[0,1]

#Se muestra el elemento a[0][1], 2 que es igual a a[0,1]
a[0][1]

#Se crea el objeto tensorflow del arreglo a
a1=tf.constant(a)

#Se muestra el objeto tensorflow
a1

#Se muestra los valores del arreglo
withtf.Session()assess:
print(sess.run(a1))

#Se crea un arreglo input, se define como objeto tensorflow
input=np.array([[1,0,0,0],[0,2,0,0],[0,0,3,0],[0,0,0,4]])
withtf.Session()assess:
print(sess.run(tf.constant(input)))

#Se calcula la matriz diagonal
diag=tf.diag_part(input)

#Se muestra la matriz diagonal
withtf.Session()assess:
print(sess.run(diag))

#Se muestra la suma de la matriz diagonal
withtf.Session()assess:
print(sess.run(tf.trace(input)))

#Se crea un arreglo y se calcula la traspuesta
b=np.array([[1,2,3],[4,5,6]])
withtf.Session()assess:
print(sess.run(tf.transpose(b)))

#Matriz identidad
i=tf.eye(3)
withtf.Session()assess:
print(sess.run(i))

#Se crea una matriz 
diagonal=np.array([[1,2,3,4],[5,6,7,8]])

#Se muestra las dimensiones de la matriz
diagonal.shape

#Se muestra la matriz diagonal
withtf.Session()assess:
print(sess.run(tf.matrix_diag(diagonal)))

#Se crea una matriz 
input=np.array([[[1,0,0,0],[0,2,0,0],[0,0,3,0],[0,0,0,4]],
[[5,0,0,0],[0,6,0,0],[0,0,7,0],[0,0,0,8]]])

#Se muestra las dimensiones de la matriz input
input.shape

#Se muestra la matriz diagonal y sus dimensiones
withtf.Session()assess:
res=sess.run(tf.matrix_diag_part(input))
print(res)
print(res.shape)

#Se crea una matriz 3x3 y se define como tensorflow de tipo int32
a=np.array([[1,2,3],[4,5,6],[7,8,9]])
a.shape
a=tf.constant(a,shape=[3,3],dtype="int32")
a

#Se crea otra matriz 3x3
b=tf.constant(np.array([[9,8,7],[6,5,4],[3,2,1]]),shape=[3,3],dtype="int32")
b

#Se realiza la multiplicación de las matrices a y b
c=tf.matmul(a,b)

#Se muestra el resultado de la multiplicación y las dimensiones de la nueva matriz
withtf.Session()assess:
res=sess.run(c)
print(res)
print(res.shape)

#Se define la matriz 3x3 como objeto tensorflow de tipo float32
input=tf.constant(np.array([[1,0,0],[-1,2,3],[0,1,2]]),shape=[3,3],dtype="float32")

#Se calcula la matriz inversa de la matriz anterior
inverse=tf.matrix_inverse(input)

#Se muestra el objeto tensorflow de la matriz inversa.
inverse

#Se muestra los elementos de la matriz inversa calculada de la matriz input
withtf.Session()assess:
print(sess.run(inverse))

#Se crea una matriz 4x4 con puros números 10.
fill_mat=tf.fill((4,4),10)

#Se muestra la matriz
withtf.Session()assess:
print(sess.run(fill_mat))

#Se crea una matriz 4x4 de ceros
ceros_mat=tf.zeros((4,4))

#Se muestra la matriz
withtf.Session()assess:
print(sess.run(ceros_mat))

#Se crea una matriz 4x4 de puros 1s.
unos_mat=tf.ones((4,4))

#Se muestra la matriz
withtf.Session()assess:
print(sess.run(unos_mat))

#Se crea una matriz 4x4 de números aleatorios
random=tf.random_normal((4,4),mean=0,stddev=1.0)

#Se muestra la matriz
withtf.Session()assess:
print(sess.run(random))

#Se crea una matriz 4x4 de números aleatorios uniformes,con valor mínimo 0 y un valor máximo 1s. 
ramdonu=tf.random_uniform((4,4),minval=0,maxval=1)

#Se muestra la matriz
withtf.Session()assess:
print(sess.run(ramdonu))

#Se crea una lista de los objetos tensorflow.
operaciones=[fill_mat,ceros_mat,unos_mat,random,ramdonu]

#Se crea una sesión interactiva, se usa normalmente con jupyter.
sess=tf.InteractiveSession()

#Se muestra las matrices
foropinoperaciones:
print(sess.run(op))
print("\n")

#Se muestra las matrices usando eval
foropinoperaciones:
print(op.eval())
print("\n")