Manejo de matrices con TensorFlow
Posted on dom 04 febrero 2018 in Tutorial de Python • 6 min read
Los artículos anteriores sobre TensorFlow son:
En este artículo se explica algunas operaciones con matrices, y funciones que se pueden utilizar con matrices, en el siguiente enlace se encuentra la documentación de funciones con matrices en TensorFlow.
A continuación se muestran los ejemplos usando jupyter notebook:
In [1]:
# Se importa numpy y tensorflow
import numpy as np
import tensorflow as tf
In [2]:
#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)])
In [3]:
#Se imprime la matriz
print(tensor_2d)
[[ 4 3 2 1]
[ 4 5 6 7]
[11 10 9 8]
[12 13 14 15]]
In [4]:
#Se muestra el elemento 3,3 de la matriz
tensor_2d[3][3]
Out[4]:
15
In [5]:
#Se muestra una sub matriz
tensor_2d[0:2,0:2]
Out[5]:
array([[4, 3],
[4, 5]])
In [6]:
#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')
In [7]:
#Se muestra la matriz 1
print ("Matriz 1-> \n{}".format(matriz1))
Matriz 1->
[[2 2 2]
[2 2 2]
[2 2 2]]
In [8]:
#Se muestra la matriz 2
print ("Matriz 2-> \n{}".format(matriz2))
Matriz 2->
[[1 1 1]
[1 1 1]
[1 1 1]]
In [9]:
#Se define las 2 matrices como objeto tensorflow
matriz1 = tf.constant(matriz1)
matriz2 = tf.constant(matriz2)
In [10]:
# Se calcula el producto y la suma de dos matrices
matriz_prod = tf.matmul(matriz1, matriz2)
matriz_suma = tf.add(matriz1,matriz2)
In [11]:
#Se crea una matriz 3x3
matriz3 = np.array([(2,7,2),(1,4,2),(9,0,2)],dtype='float32')
In [12]:
#Se imprime la matriz3
print ("Matriz 3-> \n{}".format(matriz3))
Matriz 3->
[[ 2. 7. 2.]
[ 1. 4. 2.]
[ 9. 0. 2.]]
In [13]:
#Se calcula la matriz determinante
matriz_det = tf.matrix_determinant(matriz3)
In [14]:
#Se crea la sesión y se ejecuta las matrices calculadas
with tf.Session() as sess:
res1 = sess.run(matriz_prod)
res2 = sess.run(matriz_suma)
res3 = sess.run(matriz_det)
In [15]:
#Se imprime el producto de las matrices
print ("matriz1*matriz2-> \n{}".format(res1))
matriz1*matriz2->
[[6 6 6]
[6 6 6]
[6 6 6]]
In [16]:
##Se imprime la suma de las matrices
print ("matriz1+matriz2-> \n{}".format(res2))
matriz1+matriz2->
[[3 3 3]
[3 3 3]
[3 3 3]]
In [17]:
# Se imprime el determinante de la matriz 3
print ("det(matriz3)-> {}".format(res3))
det(matriz3)-> 56.00001907348633
In [18]:
#Se muestra la dimensión de la matriz1
matriz1.shape
Out[18]:
TensorShape([Dimension(3), Dimension(3)])
In [19]:
#Se crea un arreglo
a = np.array([[1,2,3],[4,5,6],[7,8,9]])
In [20]:
#Se muestra el arreglo
a
Out[20]:
array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])
In [21]:
#Se muestra el elemento [0,1]
a[0,1]
Out[21]:
2
In [22]:
#Se muestra el elemento a[0][1], 2 que es igual a a[0,1]
a[0][1]
Out[22]:
2
In [23]:
#Se crea el objeto tensorflow del arreglo a
a1 = tf.constant(a)
In [24]:
#Se muestra el objeto tensorflow
a1
Out[24]:
<tf.Tensor 'Const_2:0' shape=(3, 3) dtype=int64>
In [25]:
#Se muestra los valores del arreglo
with tf.Session() as sess:
print(sess.run(a1))
[[1 2 3]
[4 5 6]
[7 8 9]]
In [26]:
#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]])
with tf.Session() as sess:
print(sess.run(tf.constant(input)))
[[1 0 0 0]
[0 2 0 0]
[0 0 3 0]
[0 0 0 4]]
In [27]:
#Se calcula la matriz diagonal
diag = tf.diag_part(input)
In [28]:
#Se muestra la matriz diagonal
with tf.Session() as sess:
print(sess.run(diag))
[1 2 3 4]
In [29]:
#Se muestra la suma de la matriz diagonal
with tf.Session() as sess:
print(sess.run(tf.trace(input)))
10
In [30]:
#Se crea un arreglo y se calcula la traspuesta
b = np.array([[1,2,3],[4,5,6]])
with tf.Session() as sess:
print(sess.run(tf.transpose(b)))
[[1 4]
[2 5]
[3 6]]
In [31]:
#Matriz identidad
i = tf.eye(3)
with tf.Session() as sess:
print(sess.run(i))
[[ 1. 0. 0.]
[ 0. 1. 0.]
[ 0. 0. 1.]]
In [32]:
#Se crea una matriz
diagonal = np.array([[1, 2, 3, 4], [5, 6, 7, 8]])
In [33]:
#Se muestra las dimensiones de la matriz
diagonal.shape
Out[33]:
(2, 4)
In [34]:
#Se muestra la matriz diagonal
with tf.Session() as sess:
print(sess.run(tf.matrix_diag(diagonal)))
[[[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]]]
In [35]:
#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]]])
In [36]:
#Se muestra las dimensiones de la matriz input
input.shape
Out[36]:
(2, 4, 4)
In [37]:
#Se muestra la matriz diagonal y sus dimensiones
with tf.Session() as sess:
res = sess.run(tf.matrix_diag_part(input))
print(res)
print(res.shape)
[[1 2 3 4]
[5 6 7 8]]
(2, 4)
In [38]:
#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
Out[38]:
<tf.Tensor 'Const_4:0' shape=(3, 3) dtype=int32>
In [39]:
#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
Out[39]:
<tf.Tensor 'Const_5:0' shape=(3, 3) dtype=int32>
In [40]:
#Se realiza la multiplicación de las matrices a y b
c = tf.matmul(a, b)
In [41]:
#Se muestra el resultado de la multiplicación y las dimensiones de la nueva matriz
with tf.Session() as sess:
res = sess.run(c)
print(res)
print(res.shape)
[[ 30 24 18]
[ 84 69 54]
[138 114 90]]
(3, 3)
In [42]:
#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")
In [43]:
#Se calcula la matriz inversa de la matriz anterior
inverse = tf.matrix_inverse(input)
In [44]:
#Se muestra el objeto tensorflow de la matriz inversa.
inverse
Out[44]:
<tf.Tensor 'MatrixInverse:0' shape=(3, 3) dtype=float32>
In [45]:
#Se muestra los elementos de la matriz inversa calculada de la matriz input
with tf.Session() as sess:
print(sess.run(inverse))
[[ 1. 0. 0.]
[ 2. 2. -3.]
[-1. -1. 2.]]
In [46]:
#Se crea una matriz 4x4 con puros números 10.
fill_mat = tf.fill((4,4),10)
In [47]:
#Se muestra la matriz
with tf.Session() as sess:
print(sess.run(fill_mat))
[[10 10 10 10]
[10 10 10 10]
[10 10 10 10]
[10 10 10 10]]
In [48]:
#Se crea una matriz 4x4 de ceros
ceros_mat = tf.zeros((4,4))
In [49]:
#Se muestra la matriz
with tf.Session() as sess:
print(sess.run(ceros_mat))
[[ 0. 0. 0. 0.]
[ 0. 0. 0. 0.]
[ 0. 0. 0. 0.]
[ 0. 0. 0. 0.]]
In [50]:
#Se crea una matriz 4x4 de puros 1s.
unos_mat = tf.ones((4,4))
In [51]:
#Se muestra la matriz
with tf.Session() as sess:
print(sess.run(unos_mat))
[[ 1. 1. 1. 1.]
[ 1. 1. 1. 1.]
[ 1. 1. 1. 1.]
[ 1. 1. 1. 1.]]
In [52]:
#Se crea una matriz 4x4 de números aleatorios
random = tf.random_normal((4,4),mean=0,stddev=1.0)
In [53]:
#Se muestra la matriz
with tf.Session() as sess:
print(sess.run(random))
[[ 0.48763195 -0.30092272 0.19232044 0.31226188]
[-0.41430238 0.42101797 1.77855754 0.07280751]
[-1.41810405 -0.58018923 -0.43785188 -0.41393659]
[ 1.32442439 -0.78680986 -0.47751999 0.87710148]]
In [54]:
#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)
In [55]:
#Se muestra la matriz
with tf.Session() as sess:
print(sess.run(ramdonu))
[[ 0.89437163 0.44275856 0.09911788 0.81197321]
[ 0.60750782 0.93167293 0.31275058 0.85452628]
[ 0.36725163 0.51979959 0.61648357 0.43575656]
[ 0.26617634 0.65706372 0.2386142 0.88543487]]
In [56]:
#Se crea una lista de los objetos tensorflow.
operaciones = [fill_mat,ceros_mat,unos_mat,random,ramdonu]
In [57]:
#Se crea una sesión interactiva, se usa normalmente con jupyter.
sess = tf.InteractiveSession()
In [58]:
#Se muestra las matrices
for op in operaciones:
print(sess.run(op))
print("\n")
[[10 10 10 10]
[10 10 10 10]
[10 10 10 10]
[10 10 10 10]]
[[ 0. 0. 0. 0.]
[ 0. 0. 0. 0.]
[ 0. 0. 0. 0.]
[ 0. 0. 0. 0.]]
[[ 1. 1. 1. 1.]
[ 1. 1. 1. 1.]
[ 1. 1. 1. 1.]
[ 1. 1. 1. 1.]]
[[-0.58866209 0.9165706 0.80280447 0.49312767]
[ 1.59473944 0.52477682 2.11727142 1.67061532]
[ 0.02045015 -0.41936889 -0.86903268 -0.41808063]
[ 0.68307805 1.5401181 -0.66720027 -0.79585057]]
[[ 0.17621791 0.11907017 0.93286264 0.74120772]
[ 0.11641097 0.11936057 0.59562981 0.13035727]
[ 0.87772381 0.30514657 0.91652596 0.08015275]
[ 0.41316867 0.63185382 0.94313562 0.97722518]]
In [59]:
#Se muestra las matrices usando eval
for op in operaciones:
print(op.eval())
print("\n")
[[10 10 10 10]
[10 10 10 10]
[10 10 10 10]
[10 10 10 10]]
[[ 0. 0. 0. 0.]
[ 0. 0. 0. 0.]
[ 0. 0. 0. 0.]
[ 0. 0. 0. 0.]]
[[ 1. 1. 1. 1.]
[ 1. 1. 1. 1.]
[ 1. 1. 1. 1.]
[ 1. 1. 1. 1.]]
[[-1.56096065 -0.07210996 -0.25554755 0.4873071 ]
[-1.46382582 1.37537384 -0.5594331 -0.14968663]
[-0.38434446 1.24772871 0.90822452 -0.72924012]
[ 0.85642397 0.3183746 -0.10567457 -1.39979196]]
[[ 0.57379103 0.7317698 0.02952981 0.26845372]
[ 0.95550442 0.10524487 0.68452525 0.94136262]
[ 0.17415774 0.6024276 0.51809859 0.86097646]
[ 0.0080744 0.9969902 0.47532237 0.76927459]]
Continuaré con la serie de artículos sobre TensorFlow.
¡Haz tu donativo! Si te gustó el artículo puedes realizar un donativo con Bitcoin (BTC) usando la billetera digital de tu preferencia a la siguiente dirección: 17MtNybhdkA9GV3UNS6BTwPcuhjXoPrSzV
O Escaneando el código QR desde la billetera:
