4 feb. 2018

Manejo de matrices con TensorFlow

Los artículos anteriores sobre TensorFlow son:

  1. Hola mundo desde TensorFlow
  2. Matemáticas básicas con TensorFlow
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 muestra 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.

Publicar un comentario