2、相关概念

1、张量(tensor)

    TensorFlow 中的核心数据单位是张量（tensor）。一个张量由一组形成阵列（任意维数）的原始值组成。张量的阶(rank)是它的维数，而它的形状(shape)是一个整数元组，指定了阵列每个维度的长度。以下是张量值的一些示例：

3.    # a rank 0 tensor; a scalar with shape [],

[1., 2., 3.] # a rank 1 tensor; a vector with shape [3]

[[1., 2., 3.], [4., 5., 6.]] # a rank 2 tensor; a matrix with shape [2, 3]

[[[1., 2., 3.]], [[7., 8., 9.]]] # a rank 3 tensor with shape [2, 1, 3]

     TensorFlow 使用numpy数组来表示张量值。

     tf.Tensor 具有以下属性：

数据类型（例如float32、int32 或string）

形状

     张量中的每个元素都具有相同的数据类型，且该数据类型一定是已知的。形状，即张量的维数和每个维度的大小，可能只有部分已知。如果其输入的形状也完全已知，则大多数操作会生成形状完全已知的张量，但在某些情况下，只能在执行图时获得张量的形状。

(1)、阶(rank)和形状(shape)

     tf.Tensor 对象的阶是它本身的维数。阶的同义词包括：秩、等级或n 维。请注意，TensorFlow 中的阶与数学中矩阵的阶并不是同一个概念。如下表所示，TensorFlow 中的每个阶都对应一个不同的数学实例：

    张量的形状是每个维度中元素的数量。TensorFlow 在图的构建过程中自动推理形状。这些推理的形状可能具有已知或未知的阶。如果阶已知，则每个维度的大小可能已知或未知。TensorFlow 文件编制中通过三种符号约定来描述张量维度：阶，形状和维数。下表阐述了三者如何相互关联：

TensorFlow的使用方法

TF学习：Tensorflow基础案例、经典案例集合——基于python编程代码的实现

1、基础函数

sess.run()  

#当我们构建完图后，需要在一个会话中启动图，启动的第一步是创建一个Session对象。  为了取回（Fetch）操作的输出内容, 可以在使用 Session 对象的 run()调用执行图时，传入一些 tensor, 这些 tensor 会帮助你取回结果。那么调用sess.run()的时候，ensorflow并没有计算整个图，只是计算了与想要fetch 的值相关的部分。

占位符和 feed_dict  ：占位符并没有初始值，它只会分配必要的内存。在会话中，占位符可以使用 feed_dict 馈送数据。  feed_dict 是一个字典，在字典中需要给出每一个用到的占位符的取值。在训练神经网络时需要每次提供一个批量的训练样本，如果每次迭代选取的数据要通过常量表示，那么 TensorFlow 的计算图会非常大。因为每增加一个常量，TensorFlow 都会在计算图中增加一个结点。所以说拥有几百万次迭代的神经网络会拥有极其庞大的计算图，而占位符却可以解决这一点，它只会拥有占位符这一个结点。

2、输出tensorflow的版本号

import tensorflow as tf

print('输出tensorflow的版本：',tf.__version__)

案例应用

DL框架之Tensorflow：Tensorflow中常用函数的简介、使用方法之详细攻略

1、使用常量和占位符进行计算

#使用常量和占位符进行计算：其中 y_1 的计算过程使用占位符，而 y_2 的计算过程使用常量

w1=tf. Variable (tf.random_normal([ 1 , 2 ],stddev= 1 ,seed= 1 ))  #因为需要重复输入x，而每建一个x就会生成一个结点，计算图的效率会低。所以使用占位符

x=tf.placeholder(tf.float32,shape=( 1 , 2 ))

x1=tf.constant([[ 0.7 , 0.9 ]])

a=x+w1

b=x1+w1

sess=tf. Session ()

sess.run(tf.global_variables_initializer())  #运行y时将占位符填上，feed_dict为字典，变量名不可变

y_1=sess.run(a,feed_dict={x:[[ 0.7 , 0.9 ]]})

y_2=sess.run(b)

print (y_1)

print (y_2)

sess.close

2、输出w、b和计算两个数值相乘

import tensorflow as tf

import numpy as np

W = tf.Variable(np.arange(6).reshape((2, 3)), dtype=tf.float32, name="weights")

b = tf.Variable(np.arange(3).reshape((1, 3)), dtype=tf.float32, name="biases")

 

saver = tf.train.Saver()

with tf.Session() as sess:

   saver.restore(sess, "niu/save_net.ckpt")

   print("weights:", sess.run(W))

   print("biases:", sess.run(b))

import tensorflow as tf

#构建一个计算图

a=tf.constant([1.0, 2.0])

b=tf.constant([3.0, 4.0])

c=a*b  

#T1、传统的方法，先构建再释放

sess=tf.Session()   #构建一个Session

print(sess.run(c))  #把计算图放到session里，并运行得到结果

sess.close()        #关闭session释放资源

#T2、with语句的方法，先构建再释放

with tf.Session() as sess:

   print(sess.run(c))  #把计算图放到session里，并运行得到结果

3、ML之LoR：利用LoR算法(tensorflow)对mnist数据集实现手写数字识别

import tensorflow as tf

import numpy as np

from tensorflow.examples.tutorials.mnist import input_data

#1、定义数据集：mnist

mnist = input_data.read_data_sets('MNIST_data', one_hot=True)

trainimg       =  mnist.train.images

trainimg_label =  mnist.train.labels

testimg        =  mnist.test.images

testimg_label  =  mnist.test.labels

print(trainimg_label[0]) #输出第一行label值

#2、定义x、y、w、b：tf.placeholder占位符、tf.Variable变量

x = tf.placeholder("float",[None,784])  # [None,784]样本的个数（无限大），每个样本的特征（784个像素点）

y = tf.placeholder("float",[None,10])   #样本的类别（10个）

W = tf.Variable(tf.zeros([784,10]))     #每个特征（784个像素点）对应输出10个分类值

b = tf.Variable(tf.zeros([10]))

#3、模型预测：LoR(softmax多分类)

#3.1、定义计算损失：actv、cost

actv = tf.nn.softmax(tf.matmul(x,W)+b)                                     #计算属于正确类别的概率值

cost = tf.reduce_mean(-tf.reduce_sum(y*tf.log(actv),reduction_indices=1))  #计算损失值（预测值与真实值间的均方差）

#3.2、定义模型训练：learning_rate、optm：

#(1)、采用GD优化参数w、b，最小化损失值

learning_rate=0.01                    

optm = tf.train.GradientDescentOptimizer(learning_rate).minimize(cost) #学习率为0.01

# optimizer = tf.train.GradientDescentOptimizer(0.01)                    #学习率为0.01

# optm = optimizer.minimize(cost)                                        #最小化损失值

#3.3、定义模型的pred、accr

pred =    tf.equal(tf.argmax(actv,1),tf.argmax(y,1))  #预测值：equal返回的值是布尔类型，argmax返回矩阵中最大元素的索引，0，代表列方向；1代表行方向        

accr =    tf.reduce_mean(tf.cast(pred,"float"))       #准确率，cast进行类型转化 （true为1，false为0）                

#3.4、定义模型训练参数init_op、train_epochs、batch_size、display_step

init_op = tf.global_variables_initializer()       #初始化所有variables 的op

train_epochs = 50   #将所有样本迭代50次

batch_size = 100       #每次迭代选择样本的个数                

display_step =5        #每进行5个epoch进行一次展示              

#3.5、运行模型tf.Session()

with tf.Session() as sess:             #在session中启动graph

   sess.run(init_op)                      #启动运行使用variables的op

   for epoch in range(train_epochs):

       

       #(1)、定义avg_cost、num_batch

       avg_cost =0.0  #初始化损失值

       num_batch = int(mnist.train.num_examples/batch_size)

       

       #(2)、for循环实现num_batch批量训练

       for i in range(num_batch):

           batch_xs, batch_ys = mnist.train.next_batch(batch_size)  #以batch为单位逐次进行

           sess.run(optm,feed_dict={x: batch_xs,y: batch_ys})       #给x，y赋值

           feeds={x: batch_xs,y: batch_ys}  

           avg_cost +=sess.run(cost,feed_dict= feeds)/num_batch

           

      #(3)、if判断实现每轮结果输出：输出每轮(5个epoch)的cost、trian_acc、test_acc

       if epoch %  display_step == 0:

           feeds_train = {x: batch_xs,y: batch_ys}        

           feeds_test  = {x:mnist.test.images,y: mnist.test.labels}

           train_acc   =  sess.run(accr,feed_dict= feeds_train)

           test_acc    =  sess.run(accr,feed_dict= feeds_test)        

           print("Epoch: %03d/%03d cost:%.9f trian_acc: %.3f test_acc: %.3f"

                % (epoch,train_epochs,avg_cost,train_acc,test_acc))        

print("Done")