【tensorflow1.0】基础入门01

1.1认识tensorflow

1.1.1简介

采用数据流图,用于数值计算的开源软件库.

• 节点:表示数学操作
• 线:张量,表示节点间相互联系的多维数据数组
• 数据流图:节点和线的有向图描述数学计算;

1.1.2优点

1. 高度的灵活性:可以自己写点C++代码来丰富底层的操作.
2. 可移植性:CPU、GPU、台式机、服务器、手机移动端
3. 多语言支持：python、C++
4. 性能最优化：真正得多线程，代码编译效率比较高

1.1.3计算密集型和IO密集型

计算密集型：专门在CPU或者GPU中运算的。tensorflow
IO密集型：进行的是IO操作，网页请求，磁盘操作，Django，Scarpy等。

1.1.4、关闭警告

import os
os.environ['TF_CPP_MIN_LOG_LEVEL']='2'

tensorflow开发文档

1.2下载和安装

1.2.1类型选择

选取1.1.4版本号

• CPU：直接安装：pip3.6 install tensorflow==1.1.4
• GPU：先觉条件是NVIDIA@GPU，并且需要运行性能关键型应用程序
  Linux版本下安装：
• pip install https://storage.googleapis.com/tensorflow/linux/cpu/tensorflow-1.0.1-cp27-none-linux_x86_64.whl

1.3图

使用tensor来表示数据，使用graph表示计算任务，使用会话运行图。tensorflow中发生得所有事情都是在会话中进行得。所以当你在TF中编写一个加法得时候，其实就你时设计了一个加法操作，而不是实际添加任何东西。所有的这些设计都会在图中产生，你会在图中保留这些计算操作和张量，而不是具体的值。
tensorflow程序通常被组织成一个构建阶段和一个执行阶段。在构建阶段 op的执行步骤被描述成一个图. 在执行阶段, 使用会话执行执行图中的op。我们来构建一个简单的计算图。每个节点采用零个或多个张量作为输入，并产生张量作为输出。一种类型的节点是一个常数。像所有TensorFlow常数一样，它不需要任何输入，它输出一个内部存储的值。

1.3.1默认图

当我们生成张量的时候，图默认会在默认图中创建

a=tf.constant(3.0,dtype=tf.float32)
b=tf.constant(4.0,dtype=tf.float32)
sum1=tf.add(a,b)
graph=tf.get_default_graph()  # 获取默认图
with tf.Session() as sess:
    print(a.graph)
    print(sum1.graph)
    print(sess.run(a)

他为什么不是输出结果，那是因为tensorflow中的图形节点操作必须在会话中运行.
图是整个程序的结构，当我们定义了第一个内容的时候，图就已经生成了。图就是用来展示分配的内存的。一个会话默认展示一张图(这张图是默认的)，我们也可以指定图，一张图中包含节点op和张量tensor，有了这两个东西，图才有意义。

1.3.2构建图

a=tf.constant(3.0,dtype=tf.float32)  # 定义一个常量
g=tf.Graph()  # 定义一张图
with g.as_default(): # 打开该图，写入自己想写入的op
    c=tf.constant(5.0,dtype=tf.float32,name='g')
b=tf.constant(4.0,dtype=tf.float32)  
# 指定该Session()运行图是g，打印的时候可以打印任何位置的op，
# 但是运行只能运行指定图中的op，默认情况下，创剑的op都被创建在了默认图中
with tf.Session(graph=g) as sess:  
    print(a.graph)
    print(c)
    print(sess.run(c))

我们可以打印程序中的任何张量，但是run的时候我们只能运行默认图中的张量，如果在会话中我们指定了图，那么我们就只能运行指定的在该图中声明的张量。

a=tf.constant(3.0,dtype=tf.float32)
b=tf.constant(4.0,dtype=tf.float32)
sum1=tf.add(a,b)
graph=tf.get_default_graph()  # 表示获取默认图
with graph.as_default():  # 打开默认图，在默认图中创建op
    c=tf.constant(5.0,dtype=tf.float32,name='graph')
with tf.Session(graph=graph) as sess:
    print(sess.run(sum1))
    print(sess.run(c))

无论是使用get_default_graph()获取默认图，在默认图中写入内容还是直接将op写入程序，最终都是将op写入到了默认图。

1.3.3在会话中使用图

构造阶段完成后，才能启动图。启动图的第一步是创建一个Session对象，如果无任何创建参数，会话构造器将启动默认图。
调用Session的run()方法来执行矩阵乘法op, 传入product作为该方法的参数，会话负责传递op所需的全部输入，op通常是并发执行的。

1.3.3.1会话的作用

用于运行图的结构，分配资源进行计算；会话一旦关闭，所有的操作就不能使用了；一个会话中一次只能运行一个图。举个例子：创建一个新图，在Session中指定新图后，当前会话中可以打印所有的张量但是只能运行新图中创建的张量。会话可能拥有很多资源tf.Variable.tf.QueueBase和tf.ReaderBase会话结束后需要进行资源的释放。

1.3.3.2开启会话的两种方式

sess=tf.Session()
sess.run(t1)
sess.close()

with tf.Session() as sess:
    print(sess.run(product))

1.3.2.3会话参数

a=tf.constant(3.0,dtype=tf.float32)
with tf.Session(
    target='', # 指定连接到的引擎,默认为使用进程内的引擎，在执行单机任务的时候不管用
    graph=None, # 指定需要运行的图
    config=tf.ConfigProto(log_device_placement=True)  # 指定配置参数，这里指的是设置
) as sess:
    print(sess.run(a))

1.3.2.4注意点

• 会话中的run方法与多任务中的run方法一样，都是运行启动运行资源的方法。如果不启动，无法执行Session会话；
• 一种交互式的会话，为了快速的验证，在ipython中我们不需要反复的定义会话，直接在交互式截面中输入：tf.InteractiveSession()。后期就可以不再去定义会话，直接“a.eval()”就可以了。不但再交互式界面下可以这样使用，再普通的程序中我们也可以这样使用。

1.4张量(tensor)

1.4.1基本概念

1.4.1.1基本介绍

张量：就是tensor，我们可以看成numpy中的数组，可以实现矩阵的运算
节点：就是op操作，就是用来描述张量间的运算关系。常量、变量之间的关系；
在tensorflow中最基本的单位就是常量、变量和占位符。

• 常量：定义之后值和维度不可变；存储超参数等
• 变量：定义之后值可变但是维度不可变；存储权值等
• 占位符：就是用来占据位置的。

1.4.1.2张量的属性

print(t1.name)  # 张量名
print(t1.graph)  # 图
print(tf.shape)  # 形状
print(t1.dtype)  # 类型

1.4.1.3张量的数据类型

我们可以通过函数cast()修改任何张量的数据类型

a=tf.cast(a,dtype=tf.int32,name='a')

1.4.1.4张量形状的改变

动态形状的改变，tf.reshape创建一个具有不同动态形状的新张量。和我们以前在numpy中使用的reshape一样，返回的是一个新的张量。
静态形状的改变，某个张量有一个初始的状态，但是形状是不确定的，我们可以通过get_shape获取静态形状，set_shape()更新形状的静态形状。更改的是本身。静态形状不能跨维度进行修改。

a=tf.placeholder(shape=[3,None],dtype=tf.float32)
with tf.Session() as sess:
    val=sess.run(a,feed_dict={a:np.random.randint(0,10,size=(3,8))})
    print('静态形状的改变',val)
    print('动态形状的改变',sess.run(tf.reshape(val,(2,3,4))))

1.4.2常量

1.4.3变量

1.4.4占位符

1】生成固定张量

one=tf.ones(
    shape=(4,5),
    dtype=tf.float32,
    name='zero'
)
zero_like=tf.zeros_like(
    tensor=zero,
    dtype=tf.float32,
    name='zero_like',
    optimize=True
)
scalar=tf.fill(
    dims=(2,3), value=2, name=None
)
t1=tf.constant(
    value=[1,2,3],  # 值
    dtype=tf.float32,  # 类型
    shape=(1,3), # 形状
    name='const',  # 常量的名字
    verify_shape=False, # 用来对形状进行验证
)

2】创建随机张量

nor=tf.random_normal(
    shape=(3,4),
    mean=0.0,
    stddev=1.0,
    dtype=tf.float32,
    seed=1,
    name='normal'
)

4、张量的拼接

con=tf.concat(
    values=[nor,nor],
    axis=1,
    name='concat'
)

5、张量形状的改变

五、变量

1、变量是可以持久化的，普通的张量是不能的，变量是特殊的张量
2、参数

a=tf.Variable(    initial_value，    trainable=True,  # 指定参数是否变化    collections=None,    validate_shape=True,    caching_device=None,    name=None,    dtype=None,)

3、变量初始化：变量在运行之前必须做一步显示初始化

init=tf.global_variables_initializer()
with tf.Session() as sess:
    sess.run(init)
    print(sess.run(a))

4、assign(value)函数

value=tf.Variable(5.0)
state=tf.Variable(2.0)
update=tf.assign_add(state,value)
# update=tf.assign(state,value)
init=tf.initialize_all_variables()
with tf.Session() as sess:
    sess.run(init)
    for i in range(10):
        print(sess.run(update),sess.run(state))  # 这里的state和update的值是一样的

5、placehold-占位符

A=tf.placeholder(
    dtype=tf.float32,
    shape=[None,5],
    name='A',
)
B=tf.placeholder(
    dtype=tf.float32,
    shape=[3,None],
    name='B',
)
with tf.Session() as sess:
    a=sess.run(
        fetches=A,
        feed_dict={
            A:np.random.randint(0,10,size=(3,5)),
            B:np.random.randint(0,10,size=(3,4))
        },
    )
    print(a)

6、变量作用域
语法：with tf.variable_scope(‘model’):
作用
将同一类的代码放在一块，对代码进行一个小小的封装(和函数的封装差不多)，使得在tensorboard中查看程序运行流程更加清晰。作用分明。