1.Tensorflow基础

1.Tensorflow基础

关于Tensorflow

TensorFlow™ 是一个采用数据流图（data flow graphs），用于数值计算的开源软件库。节点（Nodes）在图中表示数学操作，图中的线（edges）则表示在节点间相互联系的多维数据数组，即张量（tensor）。它灵活的架构让你可以在多种平台上展开计算，例如台式计算机中的一个或多个CPU（或GPU），服务器，移动设备等等。

数据流图

数据流图用“结点”（nodes）和“线”(edges)的有向图来描述数学计算。“节点” 一般用来表示施加的数学操作，但也可以表示数据输入（feed in）的起点/输出（push out）的终点，或者是读取/写入持久变量（persistent variable）的终点。“线”表示“节点”之间的输入/输出关系。这些数据“线”可以输运“size可动态调整”的多维数据数组，即“张量”（tensor）。张量从图中流过的直观图像是这个工具取名为“Tensorflow”的原因。一旦输入端的所有张量准备好，节点将被分配到各种计算设备完成异步并行地执行运算。

介绍

list 可支持一维的各种数据类型
np.array 可支持多维同类型的数据，但是没有GPU的支持，也不支持自动求导等数学问题。
tf.Tensor 连续数据

Tensor

scalar(标量)：1.2 一个标准的标量
vector(向量)：[1.1]，[1,2,3,4]
matrix(矩阵)：[ [1,2,3],[4,5,6] ]

tensor：原先值 rank(等级) >2，现指所有的数据类型

Tensorflow(科学计算库)基本数据类型

int，float，double，bool，string，tf.constant(1.1) 创建一个常量

Tensor属性

a.devce返回变量a所在设备的名称(字符串类型)，即是在GUP还是CPU上
aa=a.gpu() 将a所在的设备转换成GPU上
bb=b.cpu() 将b所在的设备装换成CPU上
在计算数据时，变量所在的设备要一致，不然会报错

a.dtype 返回数据的类型
a.shape 返回数据的形状
a.ndim 返回数据的维度

tf.rank(a) 返回Tensorflow张量a的秩

判读是不是tensor类型的方法

isinstance(a, tf.Tensor) #多数情况下可用
tf.is_tensor(a) #推荐使用

转换

a.dtype == tf.float32 判断a的类型是不是float类型
1，tf.convert_to_tensor(value,dtyoe=None)；转换换成tensor类型
可以转换各种python类型对象，numpy数组，python列表参数，

In [3]: import tensorflow as tf
In [8]: import numpy as np
In [4]: import os
In [11]: os.environ['TF_CPP_LOG_MIN_LEVEL']='2'  #禁止警告提示

In [9]: a=np.array(5)
In [10]: aa =tf.convert_to_tensor(a)
In [12]: bb=tf.convert_to_tensor(a,dtype=tf.float32)  #支持类型的转换

In [13]: aa
Out[13]: <tf.Tensor: id=0, shape=(), dtype=int32, numpy=5>

In [14]: bb
Out[14]: <tf.Tensor: id=1, shape=(), dtype=float32, numpy=5.0>

2，tf.cast(value,dtype)：数据格式的转换

In [16]: tf.cast(aa,dtype=tf.float32)
Out[16]: <tf.Tensor: id=2, shape=(), dtype=float32, numpy=5.0>

In [17]: tf.cast(aa,dtype=tf.double)
Out[17]: <tf.Tensor: id=3, shape=(), dtype=float64, numpy=5.0>

# 整形转换成bool类型
In [18]: b=tf.constant([0,1])

In [22]: bb=tf.cast(b,dtype=tf.bool)
In [23]: bb
Out[23]: <tf.Tensor: id=7, shape=(2,), dtype=bool, numpy=array([False,  True])>
In [25]: tf.cast(bb,dtype=tf.int32)  #bool转int
Out[25]: <tf.Tensor: id=8, shape=(2,), dtype=int32, numpy=array([0, 1])>

3，tf.Variable 包装变量，使其具有一些特性(专门为神经网络所设)可对变量进行算术，如可求导
就像任何Tensor（张量）一样，使用Variable（）创建的变量可以用作图中其他操作的输入

In [26]: a=tf.range(5)  #创建

In [27]: a
Out[27]: <tf.Tensor: id=12, shape=(5,), dtype=int32, numpy=array([0, 1, 2, 3, 4])>

In [28]: b=tf.Variable(a,name='input_data')   #包装，可以添加name 

In [29]: b.name 
Out[29]: 'input_data:0'

In [30]: b.trainable      #表示是否可训练
Out[30]: True

# 被包装后
In [31]: isinstance(b,tf.Variable)     
Out[31]: True

In [32]: isinstance(b,tf.Tensor)     #出现问题
Out[32]: False

In [33]: tf.is_tensor(b)   #正确，判断是否为Tensor尽量用tf.is_tensor()
Out[33]: True

创建Tensor

1，from Numpy，List

In [35]: tf.convert_to_tensor(np.ones([2,3]))
Out[35]:
<tf.Tensor: id=20, shape=(2, 3), dtype=float64, numpy=
array([[1., 1., 1.],
       [1., 1., 1.]])>

In [36]: tf.convert_to_tensor(np.zeros([2,3]))
Out[36]:
<tf.Tensor: id=21, shape=(2, 3), dtype=float64, numpy=
array([[0., 0., 0.],
       [0., 0., 0.]])>
       
In [38]: tf.convert_to_tensor([1,2])    #列表
Out[38]: <tf.Tensor: id=22, shape=(2,), dtype=int32, numpy=array([1, 2])>

In [39]: tf.convert_to_tensor([1,2.])     #自动变成浮点型
Out[39]: <tf.Tensor: id=23, shape=(2,), dtype=float32, numpy=array([1., 2.], dtype=float32)>

In [40]: tf.convert_to_tensor([[1,2.],[1,2]])
Out[40]:
<tf.Tensor: id=24, shape=(2, 2), dtype=float32, numpy=
array([[1., 2.],
       [1., 2.]], dtype=float32)>

2，tf.zeros(shape,dtype=tf.float32,name=None)创建一个类型为dtype的张量，形状为shape，所有的元素都为零，
tensorflow的dtype类型：tf.int32, tf.float32, tf.float64, tf.bool, tf.string

In [41]: tf.zeros([])
Out[41]: <tf.Tensor: id=25, shape=(), dtype=float32, numpy=0.0>

In [42]: tf.zeros([1])
Out[42]: <tf.Tensor: id=28, shape=(1,), dtype=float32, numpy=array([0.], dtype=float32)>

In [43]: tf.zeros([2,3])
Out[43]:
<tf.Tensor: id=31, shape=(2, 3), dtype=float32, numpy=
array([[0., 0., 0.],
       [0., 0., 0.]], dtype=float32)>

In [45]: tf.zeros([3,2,2])
Out[45]:
<tf.Tensor: id=37, shape=(3, 2, 2), dtype=float32, numpy=
array([[[0., 0.],
        [0., 0.]],
        
       [[0., 0.],
        [0., 0.]],

       [[0., 0.],
        [0., 0.]]], dtype=float32)>

In [46]: tf.zeros([2,3],dtype=tf.int32)
Out[46]:
<tf.Tensor: id=40, shape=(2, 3), dtype=int32, numpy=
array([[0, 0, 0],
       [0, 0, 0]])>

3，tf.zeros_like(tensor,dtype=None) 创建一个所有元素都设置为零的张量
给定一个张量(tensor)，该操作返回与所有元素设置为零的tensor具有相同类型和形状的张量，或者，也可使用dtype指定返回张量的新类型

In [47]: a=tf.zeros([2,3,4])

In [48]: tf.zeros_like(a)   #等同于tf.zeros(a.shape)
Out[48]:
<tf.Tensor: id=44, shape=(2, 3, 4), dtype=float32, numpy=
array([[[0., 0., 0., 0.],
        [0., 0., 0., 0.],
        [0., 0., 0., 0.]],

       [[0., 0., 0., 0.],
        [0., 0., 0., 0.],
        [0., 0., 0., 0.]]], dtype=float32)>
        
In [50]: tf.zeros_like(a,dtype=tf.int32)
Out[50]:
<tf.Tensor: id=47, shape=(2, 3, 4), dtype=int32, numpy=
array([[[0, 0, 0, 0],
        [0, 0, 0, 0],
        [0, 0, 0, 0]],

       [[0, 0, 0, 0],
        [0, 0, 0, 0],
        [0, 0, 0, 0]]])>

4，tf.ones(shape,dtype=tf.float32)创建一个将所有元素都设置为1的张量
这个操作返回一个dtype类型的张量，并且形状为shape，所以元素都被设置为1

In [52]: tf.ones([])    #标量
Out[52]: <tf.Tensor: id=48, shape=(), dtype=float32, numpy=1.0>

In [53]: tf.ones([1])
Out[53]: <tf.Tensor: id=51, shape=(1,), dtype=float32, numpy=array([1.], dtype=float32)>

In [54]:

In [54]: tf.ones([2,2])
Out[54]:
<tf.Tensor: id=54, shape=(2, 2), dtype=float32, numpy=
array([[1., 1.],
       [1., 1.]], dtype=float32)>

tf.ones_like(tensor,dtype=None) 与tf.zeros_like类似
创建一个将所有元素都设置为1的张量

5，利用标量值填充TensorFlow张量
tf.fill(dims,value) 创建一个填充了标量值的张量
该操作创建一个形状dims的张量，并将值(value)填充其中
返回张量的类型与value具有相同的类型

In [56]: tf.fill([2,3],0)   # 2*3的全0 张量
Out[56]:
<tf.Tensor: id=60, shape=(2, 3), dtype=int32, numpy=
array([[0, 0, 0],
       [0, 0, 0]])>

相当于np.full

6，Normal随机初始化
tf.random_normal(shape,mean=0.0,stddev=1.0,dtype=tf.tloat32,seed=None) 正太分布
mean:正态分布的均值，默认为0.0
stddev:正态分布的标准差，默认为1.0
seed:一个python整数，用于为分发创建一个随机种子，设置后每次生成的随机数都一样

In [57]: tf.random.normal([2,2])
Out[57]:
<tf.Tensor: id=66, shape=(2, 2), dtype=float32, numpy=
array([[-2.0627532 , -0.48125386],
       [-0.7270144 ,  0.41614422]], dtype=float32)>

In [58]: tf.random.normal([2,2],mean=1,stddev=2)
Out[58]:
<tf.Tensor: id=72, shape=(2, 2), dtype=float32, numpy=
array([[-0.42468727, -3.429366  ],
       [ 0.3059216 ,  0.3949545 ]], dtype=float32)>

tf.random.truncated_normal(shape,mean=0.0,stddev=1.0,dtype=tf.float32.seed=None)
从截断的正态分布中输出随机值
生成的值遵循具有指定均值和标准差的正态分布，不同之处在于其平均值大于2个标准差的值将被丢弃并重新选择即范围为 [ mean - 2 * stddev, mean + 2 * stddev ] 。用于提升性能，缩小范围

In [59]: tf.random.truncated_normal([2,2])
Out[59]:
<tf.Tensor: id=78, shape=(2, 2), dtype=float32, numpy=
array([[ 0.21286643,  0.1667896 ],
       [-0.29199   , -0.80637115]], dtype=float32)>

7，Uniform随机均匀分布
tf.random.unifrom(shape,minval=0,maxval=None,dtype=tf.float32,seed=None)
从均匀分布中输出随机数
生产的值在该 [ minval, maxval）范围内遵循均匀分布
对于浮点数，默认范围是 [ 0, 1 )

In [61]: tf.random.uniform([2,2])
Out[61]:
<tf.Tensor: id=85, shape=(2, 2), dtype=float32, numpy=
array([[0.53005064, 0.93355775],
       [0.8443105 , 0.3429159 ]], dtype=float32)>

In [62]: tf.random.uniform([2,2],minval=1,maxval=5)
Out[62]:
<tf.Tensor: id=92, shape=(2, 2), dtype=float32, numpy=
array([[1.0178642, 2.2819552],
       [2.2837105, 1.1925797]], dtype=float32)>

8，Random Permutation 随机打散
tf.random.shuffle(value,seed=None)
value: 将被打乱的张量
随机地将张量沿着第一维度打乱
张良沿着维度0被重新打乱，使得每个value[j]被映射到唯一一个output[i]

In [64]: idx=tf.range(10)

In [65]: tf.random.shuffle(idx)
Out[65]: <tf.Tensor: id=97, shape=(10,), dtype=int32, numpy=array([4, 5, 1, 8, 0, 6, 2, 3, 7, 9])>

In [66]: idx
Out[66]: <tf.Tensor: id=96, shape=(10,), dtype=int32, numpy=array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])>

9，tf.constant(value,dtype=None,shape=None)
创建一个常量tensor，按照给出的value来赋值，可以用shape来指定形状，value可以是一个数，也可以是一个list；
如果是一个数，那么这个常量中的所有值都是按该数来赋值
如果是list，（因为版本的原因，这里强调的比较严苛）那么len(value)的值一定等于shape的乘积个数

In [79]: tf.constant([])
Out[79]: <tf.Tensor: id=118, shape=(0,), dtype=float32, numpy=array([], dtype=float32)>

In [80]: tf.constant([1])
Out[80]: <tf.Tensor: id=119, shape=(1,), dtype=int32, numpy=array([1])>

In [81]: tf.constant([[1,2,3]])
Out[81]: <tf.Tensor: id=120, shape=(1, 3), dtype=int32, numpy=array([[1, 2, 3]])>

In [82]: tf.constant([1,2,3,4,5,6],shape=[2,3])
Out[82]:
<tf.Tensor: id=123, shape=(2, 3), dtype=int32, numpy=
array([[1, 2, 3],
       [4, 5, 6]])>