TensorFlow Lite 入门

一、利用tensorflow输出hello world

import tensorflow as tf
def main():
    opertion_me = tf.constant("Hello world")
    with tf.Session() as sess:
        print(sess.run(opertion_me).decode())
if __name__=="__main__":
   main()

注释：（1）import tensorflow as tf：导入 TensorFlow 库，接下来的操作可以引用tensorflow数据库中的函数、操作等
（2）tf.constant：调用tf.constant函数来打印需要打印的常量信息
（3）tf.Session()：为了执行计算图，利用 with 语句定义 Session，并使用 run 来运行

二、利用tensorflow进行两个常量相加操作

import tensorflow as tf
def main():
    const_1 = tf.constant([1,2,3,4])
    const_2 = tf.constant([1,2,3,4])
    op_add = tf.add(const_1, const_2, name=None)
    with tf.Session() as sess:
        print(sess.run(op_add))

首先通过将程序分为两个独立的部分，构建任何拟创建神经网络的蓝图，包括计算图的定义及其执行。计算图：是包含节点和边的网络。本节定义所有要使用的数据，也就是张量（tensor）对象（常量、变量和占位符），同时定义要执行的所有计算，即运算操作对象（Operation Object，简称 OP）。为了构建计算图，需要定义所有要执行的常量、变量和运算操作。
说明：（1）以with 格式打开session可以在运行结束时隐式关闭会话。
（2）如果你正在使用 Jupyter Notebook 或者 Python shell 进行编程，使用 tf.InteractiveSession 将比 tf.Session 更方便。InteractiveSession 使自己成为默认会话，因此你可以使用 eval（) 直接调用运行张量对象而不用显式调用会话。例子如下：

def main():
    sess = tf.InteractiveSession()
    const_1 = tf.constant([1,2,3,4])
    const_2 = tf.constant([1,2,3,4])
    op_add = tf.add(const_1, const_2, name=None)
    print(op_add.eval（))
    sess.close()

三、tf中的常量、变量和占位符操作

TensorFlow 支持以下三种类型的张量：

（1）常量：常量是其值不能改变的张量。

（2）变量：当一个量在会话中的值需要更新时，使用变量来表示。例如，在神经网络中，权重需要在训练期间更新，可以通过将权重声明为变量来实现。变量在使用前需要被显示初始化。另外需要注意的是，常量存储在计算图的定义中，每次加载图时都会加载相关变量。换句话说，它们是占用内存的。

（3）占位符：用于将值输入 TensorFlow 图中。它们可以和 feed_dict 一起使用来输入数据。在训练神经网络时，它们通常用于提供新的训练样本。在会话中运行计算图时，可以为占位符赋值。这样在构建一个计算图时不需要真正地输入数据。需要注意的是，占位符不包含任何数据，因此不需要初始化它们。

1.常量

t_1 = tf.constant(4)   ##定义一个标量常量
t_2 = tf.constant([4,3,8])  ##定义一个维度[1,3]的向量，值为[4,3,8]
tf.zeros([M,N],tf.dtype)   ##创建一个形如 [M，N] 的零元素矩阵，dtype可以是 int32、float32等
tf.ones([M,N],tf,dtype)  ##建一个形如 [M，N]、元素均为 1 的矩阵
tf.linspace(start,stop,num)   ##生成一个从初值到终值等差排布的序列
tf.range(start,limit,delta)   ##生成一个数字序列，增量为 delta（默认值=1），直到终值

创建具有不同分布的随机张量

##均值为1（默认值=0.0）和标准差为2（默认值=1.0）、形状为 [M，N] 的正态分布随机数组
tf.random_normal([3,6],mean=1,stddev=2) 
 ##均值为1（默认值=0.0）和标准差为2（默认值=1.0）、形状为 [M，N] 的截尾正态分布随机数组
 tf.truncated_normal([2,3],mean=2,stddev=4)
 ##在种子的 [minval（default=0），maxval] 范围内创建形状为 [M，N] 的给定伽马分布随机数组
 tf.random_uniform([3,6],maxval=10)
 ##随机重新排序张量
 tf.random_shuffle9(m1)

2、变量
（1）使用变量类来创建。变量的定义还包括应该初始化的常量/随机值。下面的代码中创建了两个不同的张量变量 op1和 op2。两者将被初始化为形状为 [3，6] 的随机均匀分布，最小值=1，最大值=10：

op_t = tf.random_uniform([3,6],minval=1, maxval=10)
    op1 = tf.Variable(op_t)
    op2 = tf.Variable(op_t)

（2）在前面的例子中，是利用一些常量来初始化变量，也可以指定一个变量来初始化另一个变量：

op_add = tf.random_uniform([3,6],maxval=10)
    op1 = tf.Variable(op_add)
    op2 = tf.Variable(op_add)  
    op3 = tf.Variable(op1.initialized_value(), name="op3")

变量的定义将指定变量如何被初始化，但是必须显式初始化所有的声明变量。在计算图的定义中通过声明初始化操作对象来实现：

intial_op = tf.global_variables_initializer()

（3）每个变量也可以在运行图中单独使用 tf.Variable.initializer 来初始化：

op_1 = tf.random_uniform([3,6],maxval=10)
with tf.Session() as sess:
     print(sess.run(op_1.initializer))

（4）变量保存
使用 Saver 类来保存变量，定义一个 Saver 操作对象：

saver = tf.train.Saver()

3、占位符
占位符：用于将数据提供给计算图。可以使用以下方法定义一个占位符：

tf.placeholder(dtype,shape=None,name=None)

dtype 定占位符的数据类型，并且必须在声明占位符时指定。在这里，为 x 定义一个占位符并计算 y=x*3，使用 feed_dict 输入一个随机的 6×3 矩阵：

x = tf.placeholder("float")
    y = x*3
    data = tf.random_uniform([6,3],10)
    with tf.Session() as sess:
        x_data = sess.run(data)
        print(sess.run(y,feed_dict={x:x_data}))

注：需要注意的是，所有常量、变量和占位符将在代码的计算图部分中定义。如果在定义部分使用 print 语句，只会得到有关张量类型的信息，而不是它的值。

四、矩阵操作
1.常见的相乘、相加等操作
tf.eye(n)：返回n*n单位矩阵
tf.matmul(A, B)：将A、B两个矩阵相乘，生成两个矩阵的乘积
tf.cast(x, dtype)：将x的数据格式转化成dtype
tf.add(A, B)：将A和B的矩阵进行相加

sess = tf.InteractiveSession()
    A= tf.Variable(tf.eye(10))
    A.initializer.run()
    print(A.eval（))

    C= tf.Variable(tf.zeros([10,10]))
    C.initializer.run()
    C_new = tf.cast(C,dtype=float)
    print(C.eval（))
    print(C_new.eval（))

    B = tf.Variable(tf.random_uniform([10,6]))
    B.initializer.run()
    
    product = tf.matmul(A,B)
    print("product", product.eval（))
    op_add = tf.add(A, C_new)
    print("op_add",op_add.eval（))

2.一些其他有用的矩阵操作，如按元素相乘、乘以一个标量、按元素相除、按元素余数等
tf.scalar_mul(2, A)：乘以一个标量
tf.div(a, b)：按元素相除
tf.mod(a, b)：按元素余数

A = tf.Variable(tf.random_normal([3,6],mean=1,stddev=3))
    B = tf.Variable(tf.random_normal([3,6],mean=2,stddev=4))

    mult_op =A*B
    C = tf.scalar_mul(3,mult_op)
    D = tf.div(A,B)
    E = tf.mod(A,B)

    init_op = tf.global_variables_initializer()
    with tf.Session() as sess:
        sess.run(init_op)
        mult_op, C, D, E = sess.run([mult_op, C, D, E])
        print("mult_op, C, D, E",mult_op, C, D, E)