机器学习与深度学习

置顶

1. 不知道为什么，就是不想学机器学习。。。但为了完成作业，还是得了解一下。

2. 之前用过sklearn，也学习过机器学习的知识，现在有点忘了，再整理一下。

---

一、机器学习概述

1. 机器学习算法分类

1. 监督学习

• 定义

  • 输入特征值和目标值，输出连续的值(回归)或离散值(分类)

• 分类算法

  • k-近邻算法，贝叶斯分类，决策树和随机森林，逻辑回归，SVM

• 回归算法

  • 线性回归，岭回归

2. 无监督学习

• 定义

  • 输入特征值，无标签

• 算法

  • 聚类k-means

2. 机器学习开发流程

1. 获取数据

2. 数据处理(清洗)(可以用pandas)

3. 特征工程

4. 机器学习算法训练模型(可以用sklearn)

5. 模型评估，若不好回到2-4，好的话继续

6. 应用

3. 一般的算法工程师的工作

1. 分析数据

2. 分析业务

3. 应用常见的算法

4. 特征工程，调参，优化

4. 框架

1. 机器学习

   • scikit learn(sklearn)

2. 深度学习

   • tensorflow(最火)

   • pytorch/caffe2等

5. 没有免费的午餐

• 某个算法在某个问题中效果好，在另一个问题中可能效果就不好

二、特征工程

1. 获取数据集

2. 数据集划分

• 划分为训练集和测试集，比例通常为7:3左右

3. 特征抽取

• 将任何数据(如文本和图像)转换成可用于机器学习的数字特征

  • 字典特征处理(特征离散化)

  • 文本特征处理

  • 图像特征处理

4. 特征预处理

• 数值型数据的无量纲化

  1. 归一化

     • 即让数据归一到0~1区间

     • 受异常值(特别大的值和特别小的值)影响较大

     • 适用于传统精确小数据场景

  2. 标准化

     • x'=(x-mean)/a，a为标准差

     • 适用于现代嘈杂大数据场景

5. 特征降维

• 定义：降低特征个数，得到一组"不箱管"主变量的过程

  • 例如：相关特征：相对湿度和降雨量，二者数据冗余，若冗余过多，降低处理速度

三、分类算法

1. KNN/K-近邻算法

1. 原理

   • 如果一个样本在特征空间中的k个最相似（即特征空间中最邻近）的样本中的大多数属于某一个类别，则该样本也属于这个类别

2. 问题

   • k值取得过小，会受异常点影响

   • k值取得过大，样本不均衡会影响

3. 优点

   • 简单易理解，易于实现，无需训练

4. 缺点

   • k值选择不当则分类精度不能保证

   • 懒惰算法，对测试样本分类时的计算量大，内存开销大

5. 使用场景

   • 小数据场景，千级别的数据

2. 朴素贝叶斯算法(常用与文本分类)

1. 定义

   • 朴素：假设特征与特征之间是相互独立的

   • 贝叶斯：贝叶斯公式

   • 分类完后样本属于各个类别有不同的概率值，取概率值大的为预测类别

2. 优点

   • 朴素贝叶斯模型发源于古典数学理论，有稳定的分类效率

   • 对缺失数据不太敏感，算法也较简单，常用于文本分类

   • 分类准确度高，速度快

3. 缺点

   • 由于使用了样本属性独立性的假说，所以如果特征属性有关联时效果不好

3. 决策树

1. 思想与原理

   • if-else，特征有优先级

   • 原理：信息熵，信息增益等，需要信息论知识

2. 信息论基础 (1) 信息 - 香农：消除随即不定性的东西 - 例子：小明：“我今年18岁了”，可以得到一条信息。小华再说：“小明明年19岁”。这句话就不是信息了，是确定的东西，信息熵为0 (2) 信息的衡量(消除不确定性) - 信息量 - 信息熵 (3) 信息增益 - 决策树的划分依据之一，值越大，特征优先级越高，还有其他划分依据：信息增益比，基尼系数等

3. 优点

   • 理解简单，树木可视化

4. 缺点

   • 决策树学习者可以创建不能很好地推广数据的过于复杂的树，这被称为过拟合

5. 改进

   • 剪枝cart算法

   • 随即森林

6. 应用

   • 企业重要决策

4. 随即森林

1. 集成学习方法

   • 通过建立几个模型组合的来解决单一预测问题

   • 生成多个分类器/模型，各自独立的学习和做出预测。这些预测最后组合城组合预测，因此优于任何一个单分类的预测

2. 随即森林

   • 包含多个决策树的分类器，属于集成学习方法之一

3. 随即

   • 训练集随机，从原有N个样本中随即有放回的抽样N个

     • 为什么随即抽样？为了让各个树不一样

     • 问什么有放回？若不放回，各个树没有交集，每棵树都是“有偏的”“片面的”，各个树训练出来的差异大

   • 特征随即，从M个特征中随即抽取m个特征，M>>m,降维

4. 优点

   • 在当前算法中，具有较好的准确率

   • 能有效运行在大数据集上，处理具有高纬度特征的样本，而且不需要降维

   • 能评估各个特征在分类问题上的重要性

四、回归与聚类算法

1. 线性回归

1. 定义：目标值是连续的数据

2. 通用公式：h(w)=w1x1+w2x2+...+b=Wx+b

3. 线性模型

   • 线性关系：x的次数都为1

   • 非线性关系：x的次数不定，如x+x^2+x^3

4. 线性回归的损失和优化原理

   • 目标：求模型参数

   • 损失函数/cost/成本函数/目标函数

     • 最小二乘法

   • 优化算法

     • 正规方程：直接求W,当特征值过多过复杂时，求解速度过慢且得不到正确结果，不能解决过拟合的问题

     • 梯度下降：不断试错改进，需要手动指定学习速率(超参数)

2. 欠拟合与过拟合

1. 过拟合

   • 训练集效果好，测试集效果不好

2. 欠拟合

   • 学习特征过少

3. 解决方案

   • L1正则化：使一些w直接为0，删除影响，又名LASSO回归

   • L2正则化：更常用，使得其中一些w很小，接近0，削弱某个特征的影响，又名岭回归。损失函数+惩罚项

3. 岭回归

• 就是用了L2正则化的线性回归

4. 分类算法--逻辑回归与二分类

1. 应用场景

   • 如是否是垃圾邮件，是否患病等

2. 原理

   • 输入：逻辑回归的输入就是线性回归的输出结果，h(w)=w1x1+w2x2+...+b=Wx+b

   • 激活函数：sigmoid函数

   • 分析：将回归的结果输入到sigmoid函数中，输出结果为[0,1]间的一个概率值，默认为0.5为阈值，大于这个阈值属于一个类别，小于阈值属于另一个类别

3. 损失函数

   • 其值越小越好

   • 因为实际分类为1或0,最小二乘法适用于连续数据，在这里不适用，要用对数似然损失

4. 优化损失

   • 梯度下降

5. 分类的评估方法

真实结果\预测结果	正例	假例
正例	真正例TP	伪反例FN
假例	伪正例FP	真反例TN

1. 精确率

   • 预测结果为正例样本中，真正为正例的比例

   • TP/(TP+FP)

2. 召回率

   • 真实为正例的样本中预测结果为正例的比例（对正样本的区分能力，常用）

   • TP/(TP+FN)

3. F1-score

   • 反应模型的文件稳健性

6. ROC曲线与AUC指标--衡量样本不均衡下的评估

1. ROC曲线

   • TPR为纵轴，TPR是召回率

   • FPR为横轴，TPR是在所有真实类别为假的样本中，预测为假的比例

2. AUC指标

   • 就是ROC曲线下方的面积

   • 范围[0.5,1],若是0.5,相当于瞎猜

   • AUC只能用来评价二分类

   • AUC非常适合评价样本不均衡中的分类器性能

五、无监督学习--K-means算法

1. 什么是无监督学习

• 没有目标值

2. 无监督学习算法

• 聚类：K-means(K均值聚类)

• 降维：PCA

3. K-means原理

1. 随即设置K个特征空间内的点作为初始的聚类中心

2. 对于其他每个点计算到K个中心的距离，未知的点选择最近的一个聚类中心点作为标记类别

3. 接着对着标记的聚类中心后，重新计算出每个聚类的新中心点（平均值）

4. 如果计算的新中心点与原中心点一致，结束。否则重复2

4. 优点

• 采用迭代式算法，直观易懂且实用

5. 缺点

• 容易收敛到局部最优解。解决办法：多次聚类

6. 应用场景

• 一开始没有目标值，可以先聚类获得目标值，再分类

---

六、深度学习介绍

1. 深度学习与机器学习的区别

1. 特征提取方面

   • 机器学习：特征工程步骤手动完成，需要大量领域专业知识

   • 深度学习：通常由多个层组成。它们通常将更简单的模型组合在一起，将数据从一层传递到另一层来构建更复杂的模型。通过训练大量数据自动得出模型，不需要人工特征提取环节。

     • 深度学习适合用在难提取特征的图像，语音，自然语言处理领域

2. 数据量和计算性能要求

   • 深度学习需要大量的训练数据

   • 训练深度神经网络需要大量的算力

     • 所有深度学习通常需要强大的GPU服务器来计算

     • 需要全面管理的分布式训练与预测服务——如谷歌Tensorflow云机器学习平台

3. 算法代表

   • 机器学习：朴素贝叶斯，决策树等

   • 深度学习：神经网络

2. 深度学习应用场景

1. 图像识别

   • 物体识别，场景识别，车型识别，人脸检测跟踪，人脸关键点定位，人脸身份认证

2. 自然语言处理

   • 机器翻译，文本识别，聊天对话

3. 语言技术

   • 语音识别

GPU/CPU

1. CPU

   • 核心数量少，但每一个核心的速度更快，性能更强

   • 更适用于处理连续性任务(sequential)

2. GPU

   • 核心数量多,但每一个核心的速度慢

   • 更适用于处理并行任务(parallel)

七、Tensorflow框架

1. Tensorflow结构

1. 构建阶段：数据（张量）与操作（节点）的执行步骤描述成一个图

2. 执行阶段：使用会话执行构建好的图中的操作。session

3. 数据流图

   • Tensor——数据——张量

   • Flow——操作——节点

2. 会话

1. 创建会话，常用tf.session

2. 会话初始化参数

3. 会话的执行——run(op,feed_dict=None)

   • op：单一的operation操作

   • feed_dict：传入的数据，与tf.placeholder()搭配

3. 张量

1. 定义

   • 就是数据的定义

   • n维数组

2. 创建张量

   • tf.zeros(),全0

   • tf.ones()，全1

   • tf.constrant(),常量

   • tf.random_normal()，随即

   • tf.Varinable()，变量

   • tf.placeholder(),占位符

3. 张量变化

   • 类型改变

   • 形状改变

   • 张量的数学运算

4. 变量op(操作)

1. 创建变量

   • tf.Variable()

   • 变量需要显式初始化，才能运行值,如下：

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

5. 模型保存与加载

• 用时再搜

6. 数据IO

1. 三种获取数据到Tensorflow程序的方式

- QueueRunner:基于队列的输入管道从Tensorflow图形开头的文件中读取数据（最高效）
- Feeding：运行每一步时，Python代码提供数据，和placeholder()结合使用
- 预加载数据：Tensorflow图中的张量包含所有数据(对于小数据集)

2. 文件读取流程

1. 构建文件名队列

   • tf.train.string_input_producer(string_tensor,shuffle=True)

   • string_tensor为列表

2. 读取

   • tf.TextLineReader,读csv格式文件

   • tf.WholeFileReader,读取图片文件

   • tf.TFRecordReader,读取TFRecords文件

   • 用时再查

3. 解码

   • 读取不同类型的文件，要进行相应的解码操作，解码成统一的Tensor格式

   • tf.decode_csv,解码csv文本文件

   • tf.image.decode_jpeg(contents),将JPEG编码的图像解码为uint8张量

   • tf.image.decode_png(contents),将PNG编码的图像解码为uint8张量

   • tf.decode_raw:解码二进制文件内容

4. 批处理

   • 解码后只获得默认的一个样本内容，若想获取多个样本，需要加入到新的队列进行批处理

   • tf.train.batch

   • tf.train.shuffle_batch

7. TensorBoard可视化

1. 图结构

   • 数据+操作

2. 图相关操作

   • 默认图

     • 查看默认图：tf.get_default_graph()

     • 查看属性：sess.graph

   • 创建图

     new_g=tf.Graph()
     with new_g.as_default():
         定义数据和操作

3. 可视化

   • 数据序列化为events文件

       tf.summary.FileWriter(path="写入路径",graph=sess.graph) # 第二个为图的名字

   • 查看图

       //在命令行输入
       tensorboard --logdir="图的目录"
       //在浏览器输入
       127.0.0.1:6006

3. 图片数据

1. 用张量表示一张图片

   • 张量形状：Tensor(指令名称，shape,dtype)

   • 对于shape

     • 一张图片：shape=(height,width,channels通道数)

     • 多张图片：shape=(batch,...如上)，batch表示一个批次的张量数量

2. 图片特征值处理

   • 若图片大小不一，要进行统一的缩放处理，保持特征数量相同

   • 方法：tf.image.resize_images(images,size)

   • 数据格式：

     • 存储：uint8

     • 矩阵计算：float32

八、神经网络

1. 人工神经网络(Artificial Neural Network,ANN)

1. 简称神经网络(NN)，经典NN结构包含三个层次的神经网络，分别为输入层，隐藏层，输出层。

2. 感知机

   • 一种最基础的分类模型，类似于逻辑回归

   • 和逻辑回归激活函数不同，逻辑回归是sigmoid，感知机是sign

   • 感知机只能解决简单的与或问题

2. 神经网络原理

1. 神经网络的主要用途在于分类，分类的原理要围绕损失，优化两块

2. softmax回归

   • 将神经网络输出转换成概率结果。类似与逻辑回归中的sigmoid函数，sigmoid输出的是某个类别的概率

   • logits+softmax能解决多分类问题

3. 交叉熵损失(损失函数)

   • 真实值要用one-hot形式[0,0,0,0,1,0,0,0],这样才能算离真实值的距离

   • 损失大小

     • 总损失——求平均

     • 最小二乘法——衡量线性回归的损失——均方误差

   • 优化损失函数

3. 手写数字识别例子

1. 准备数据

2. 构建模型

3. 构造损失函数

4. 优化损失

4. 卷积神经网络(CNN)

1. CNN和NN的区别

1. NN

   • 只有输入层，隐藏层，输出层。

   • 隐藏层的层数根据需要而定，没有明确说多少层合适

2. CNN

   • 在原多层网络的基础上，加入了更有效的特征学习部分，具体操作如下

     • 在原来的全连接层前加入了卷积层和池化层

   • 卷积神经网络出现，使得神经网络层数得以加深，“深度”学习由此而来

   • 2012年被重视

3. 深度学习

   • 一般指的是这些CNN等新的结构以及一些新的方法(比如一些新的激活函数Relu等)，解决了传统多层神经网络的一些难以解决的问题。

2. 卷积层

1. 通过在原始图像上平移来提取特征

2. 卷积核（Filter过滤器）四大要素

   • 卷积核个数

   • 大小，3*3,5*5

   • 步长

   • 零填充大小

3. 卷积运算的目的是提取特征

4. 每层卷积层由若干卷积单元(卷积核)组成

5. 每个卷积单元的参数是通过反向传播算法以最佳化得到的

3. 激活层

1. 使用激活函数，增加非线性分割能力

2. sigmoid不能满足，效果不好，计算量大，且反向传播时，容易出现梯度消失

3. Relu

   • 解决梯度消失问题

   • 计算速度快

   • 对图像没有负的像素值

4. 池化层pooling

1. 主要作用是特征提取。通过去掉Feature Map中不重要的样本，进一步减少参数数量，降低网络的复杂度，防止过拟合。

5. 全连接层

1. 前面的卷积和池化相当于做特征工程

2. 最后的全连接层在整个CNN中起到“分类器”的作用，最后的输出层，进行损失计算

5. 网络设计

1. 一个简单的网络结构

• 卷积|激活|池化--->卷积|激活|池化--->全连接

2. 具体参数

1. 第一层：

   • 卷积：

     • 输入图像(None,28,28,1)

     • 32个filter,5*5,strides=1(步长)，padding=SAME

     • 输出形状(None,28,28,32)

   • 激活：Relu

   • 池化：大小2*2，步长2

     • 输入图像(None,28,28,32)

     • 2*2,strides=2(步长)

     • 输出形状(None,14,14,32)

2. 第二层：

   • 卷积：

     • 输入图像(None,14,14，32)

     • 64个filter,5*5,strides=1(步长)，padding=SAME

     • 输出形状(None,14,14,64)

   • 激活：Relu

   • 池化：大小2*2，步长2

     • 输入图像(None,14,14,64)

     • 2*2,strides=2(步长)

     • 输出形状(None,7,7,64)

3. 全连接层

   • [None,7,7,64]-->[None,7*7*64]

   • [None,7*7*64]*[7*7*64,10]=[None,10]

   • [None,1024]*[1024,10]=[None,10]

   • y_predict=tf.matmul(pool2,weights)+bias

3. 调参提高准确率

1. 改变学习率，梯度下降的学习率

2. 随即初始化的权重，偏置的值

3. 选择好的优化器，梯度下降用的

4. CNN几种经典模型

1. AlexNet

2. ResNet

3. GoogleNet

6. MNIST例子

import tensorflow as tf
import os
from tensorflow.python.framework import graph_util
from tensorflow.python.saved_model import builder as saved_model_builder
from tensorflow.python.saved_model import (signature_constants, signature_def_utils, tag_constants, utils)

""" 
0 表示训练并存成ckpt和pb
1 表示读取ckpt测试
2 表示存成pb文件
3 表示读取pb测试
"""
choise=0

# 加载数据，没有的话会自动下载
from tensorflow.examples.tutorials.mnist import input_data
mnist=input_data.read_data_sets("MNIST_data",one_hot=True)

##################### build net model ##########################

########## define conv process ##########
# 2维卷积
def conv2d(name,x,W,b,strides=1, padding='SAME'):
	x=tf.nn.conv2d(x,W,strides=[1,strides,strides,1],padding=padding)
	x=tf.nn.bias_add(x,b)
	return tf.nn.relu(x,name=name)

########## define pool process ##########
# 池化
def maxpool2d(name, x, k=3, s=2, padding='SAME'):
	return tf.nn.max_pool(x,ksize=[1,k,k,1],strides=[1,s,s,1],padding=padding,name=name)

########## set net parameters ##########
def weight_var2(shape):
	return tf.Variable(initial_value=tf.random_normal(shape=shape))	# 正态分布随机数初始化
	
def weight_var(shape):
	initial = tf.truncated_normal(shape, stddev=0.1)
	return tf.Variable(initial)
def bias_var(shape):
	initial = tf.constant(0.1, shape=shape)
	return tf.Variable(initial)

""" 
1. 第一层：
    - 卷积：
        - 输入图像(None,28,28,1)
        - 32个filter,5*5,strides=1(步长)，padding=SAME
        - 输出形状(None,28,28,32)
    - 激活：Relu
    - 池化：大小2*2，步长2
        - 输入图像(None,28,28,32)
        - 2*2,strides=2(步长)
        - 输出形状(None,14,14,32)
2. 第二层：
    - 卷积：
        - 输入图像(None,14,14，32)
        - 64个filter,5*5,strides=1(步长)，padding=SAME
        - 输出形状(None,14,14,64)
    - 激活：Relu
    - 池化：大小2*2，步长2
        - 输入图像(None,14,14,64)
        - 2\*2,strides=2(步长)
        - 输出形状(None,7,7,64)
3. 全连接层
    - [None,7,7,64]-->[None,7*7*64]
    - [None,7*7*64]*[7*7*64,1024]=[None,1024]
	- [None,1024]*[1024,10]=[None,10]
    - y_predict=tf.matmul(pool2,weights)+bias

 """
def my_net(x):
	""" 
	卷积神经网络
	"""
	y_pred=0
	# 第一层
	# 卷积层
	# 将x[None,784]形状修改
	# shape第一个是载入样本数量，不知道一次性载入多少，所以用-1,1为通道数
	input_x = tf.reshape(x,shape=[-1,28,28,1])
	# 定义filter和偏置
	conv1_weights = weight_var2(shape=[5,5,1,32])	# 5*5的filter,通道数为1,32个filter
	conv1_bias = weight_var2(shape=[32])
	conv1_x = tf.nn.conv2d(input=input_x,filter=conv1_weights,strides=[1,1,1,1],padding="SAME")+conv1_bias	#步长为[batch, height, width, channels]这样的shape，一般为[1,s,s,1],s表示步长
																											#padding为0填充，SAME表示输入图片大小和输出图片大小是一致的，如果是VALID则图片经过滤波器后可能会变小。
	# 激活层
	relu1_x=tf.nn.relu(conv1_x)
	# 池化层
	pool1_x = tf.nn.max_pool(value=relu1_x,ksize=[1,2,2,1],strides=[1,2,2,1],padding="SAME")	# ksize为池化窗口的大小，一般是[1, height, width, 1]，因为我们不想在batch和channels上做池化，所以这两个维度设为了1
																								
	# 第二层
	# 定义filter和偏置
	conv2_weights = weight_var2(shape=[5,5,32,64])	# 5*5的filter,通道数为1,32个filter
	conv2_bias = weight_var2(shape=[64])
	conv2_x = tf.nn.conv2d(input=pool1_x,filter=conv2_weights,strides=[1,1,1,1],padding="SAME")+conv2_bias																											
	# 激活层
	relu2_x=tf.nn.relu(conv2_x)
	# 池化层
	pool2_x = tf.nn.max_pool(value=relu2_x,ksize=[1,2,2,1],strides=[1,2,2,1],padding="SAME")

	# 全连接层
	""" 
		[None,7,7,64]-->[None,7*7*64]
    	[None,7*7*64]*[7*7*64,10]=[None,10]
	"""
	x_fc=tf.reshape(pool2_x,shape=[-1,7*7*64])
	weights_fc=weight_var(shape=[7*7*64,10])
	bias_fc=weight_var(shape=[10])
	y_pred=tf.matmul(x_fc,weights_fc)+bias_fc
	# y_pred2=tf.nn.softmax(tf.matmul(x_fc, weights_fc) + bias_fc,name="final_result")
	return y_pred

if __name__ == "__main__":
		
	########## placeholder ##########
	x=tf.placeholder("float",[None,784],name="x")
	y_true=tf.placeholder("float",[None,10],name="y_true")

	W = tf.Variable(tf.zeros([784,10]))
	b = tf.Variable(tf.zeros([10]))

	#### model ####	
	y_pred = my_net(x)

	# softmax 回归及交叉熵损失计算
	# labels 真实值
	# logits 预测值
	loss=tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=y_true,logits=y_pred))
	loss2=tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=y_true,logits=y_pred,name='final_result'))
	
	# tf.add_to_collection('output', y_conv2)
	#梯度下降损失优化
	train_step = tf.train.GradientDescentOptimizer(0.001).minimize(loss)
	# train_step = tf.train.AdamOptimizer(0.001).minimize(cross_entropy)	# 这个比梯度下降损失优化差一点
	correct_prediction = tf.equal(tf.argmax(y_pred,1), tf.argmax(y_true,1))
	accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
	########## initialize variables ##########
	init=tf.global_variables_initializer()

	saver=tf.train.Saver(max_to_keep=1)
	
	with tf.Session() as sess:
		sess.run(init)
		if(choise==0):	# 训练阶段
			max_acc=0
			for i in range(1000):
				mnist_x,mnist_y = mnist.train.next_batch(50)
				sess.run(train_step,feed_dict={x:mnist_x,y_true:mnist_y})
				val_loss,val_acc=sess.run([loss,accuracy], feed_dict={x: mnist_x, y_true: mnist_y})
				# val_loss,val_acc=sess.run([loss,accuracy], feed_dict={x: mnist.test.images, y_true: mnist.test.labels})
				if val_acc>max_acc:
					max_acc=val_acc
					saver.save(sess,'ckpt/mnist.ckpt',global_step=i+1)	#global_step是一个计数器，可以用于保存多个中间结果
				if(i%50==0):
					print("准确率为：{0}, 损失为：{1}".format(val_acc,val_loss))
			# # 保存图
			# # tensorboard --logdir="path" 再通过浏览器查看图
			# tf.summary.FileWriter("./graph/one",graph=sess.graph)
			# # 保存为pb文件
			# #将当前图设置为默认图
			# graph_def = tf.get_default_graph().as_graph_def() 
			# #将上面的变量转化成常量，保存模型为pb模型时需要,注意这里的final_result和前面的y_con2是同名，只有这样才会保存它，否则会报错，
			# # 如果需要保存其他tensor只需要让tensor的名字和这里保持一直即可
			# output_graph_def = tf.graph_util.convert_variables_to_constants(sess,  
			# 				graph_def, ['final_result'])  
			# #保存前面训练后的模型为pb文件
			# with tf.gfile.GFile("./pb_model/three/model.pb", 'wb') as f:  
			# 		f.write(output_graph_def.SerializeToString())

		elif(choise==1):	# ckpt测试阶段
			model_file=tf.train.latest_checkpoint('ckpt/')
			saver.restore(sess,model_file)
			val_loss,val_acc=sess.run([loss,accuracy], feed_dict={x: mnist.test.images, y_true: mnist.test.labels})
			print('准确率为: {0}, 损失为： {1}'.format(val_acc,val_loss))
		elif(choise==2):	# 训练保存为pb
			model_file=tf.train.latest_checkpoint('ckpt/')
			saver.restore(sess,model_file)
			constant_graph = graph_util.convert_variables_to_constants(sess, sess.graph_def, ['final_result'])			
			with tf.gfile.FastGFile("./pb_model/two/mymnist_model.pb", mode='wb') as f:
				f.write(constant_graph.SerializeToString())
		elif(choise==3):	# pb测试
			# load_pb()
			pass
		else:
			print("choise出错")
			

• 为了保存为pb文件在安卓上运行而找的代码

from tensorflow.examples.tutorials.mnist import input_data
# 保存模型需要的库
from tensorflow.python.framework.graph_util import convert_variables_to_constants 
from tensorflow.python.framework import graph_util 
# 导入其他库
import tensorflow as tf
import numpy as np 

#权重
def weight_variable(shape):
  initial = tf.truncated_normal(shape, stddev=0.1)
  return tf.Variable(initial)
#偏差
def bias_variable(shape):
  initial = tf.constant(0.1, shape=shape)
  return tf.Variable(initial)
#卷积
def conv2d(x, W):
  return tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding='SAME')
#最大池化
def max_pool_2x2(x):
  return tf.nn.max_pool(x, ksize=[1, 2, 2, 1],
                        strides=[1, 2, 2, 1], padding='SAME')

#获取MINIST数据
mnist=input_data.read_data_sets("MNIST_data",one_hot=True)
# 创建会话 
sess = tf.InteractiveSession()


x = tf.placeholder("float", shape=[None, 784], name="x")
y_true = tf.placeholder("float",shape=[None, 10],  name="y_true")
W = tf.Variable(tf.zeros([784,10]),name='w')
b = tf.Variable(tf.zeros([10]),'b')


# 第一层，卷积激活池化
W_conv1 = weight_variable([5, 5, 1, 32])
b_conv1 = bias_variable([32])
x_image = tf.reshape(x, [-1,28,28,1])
h_conv1 = tf.nn.relu(conv2d(x_image, W_conv1) + b_conv1)
h_pool1 = max_pool_2x2(h_conv1)

# 第二层，卷积激活池化
W_conv2 = weight_variable([5, 5, 32, 64])
b_conv2 = bias_variable([64])
h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2) + b_conv2)
h_pool2 = max_pool_2x2(h_conv2)

# 全连接层
W_fc1 = weight_variable([7 * 7 * 64, 1024])
b_fc1 = bias_variable([1024])
h_pool2_flat = tf.reshape(h_pool2, [-1, 7*7*64])
h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, W_fc1) + b_fc1)

# dropout防止过拟合
# keep_prob = tf.placeholder("float",name='rob')
# h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)

#用于训练用的softmax函数
W_fc2 = weight_variable([1024, 10])
b_fc2 = bias_variable([10])
y_conv=tf.nn.softmax(tf.matmul(h_fc1, W_fc2) + b_fc2,name='res')
#用于训练作完后，作测试用的softmax函数
y_conv2=tf.nn.softmax(tf.matmul(h_fc1, W_fc2) + b_fc2,name="final_result")

#交叉熵的计算，返回包含了损失值的Tensor。
cross_entropy = -tf.reduce_sum(y_true*tf.log(y_conv))

#优化器，负责最小化交叉熵
train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)
#梯度下降损失优化
# train_step = tf.train.GradientDescentOptimizer(0.001).minimize(loss)
correct_prediction = tf.equal(tf.argmax(y_conv,1), tf.argmax(y_true,1))
#计算准确率
accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
#初始化所以变量
sess.run(tf.global_variables_initializer())

 # 保存输入输出，可以为之后用
# tf.add_to_collection('res', y_conv)
# tf.add_to_collection('output', y_conv2)
# tf.add_to_collection('result', res)
# tf.add_to_collection('x', x)

#训练开始
for i in range(200):
  batch = mnist.train.next_batch(50)
  if i%100 == 0:
    train_accuracy = accuracy.eval(feed_dict={
        x:batch[0], y_true: batch[1]})
    print("step {0}, training accuracy {1}".format(i, train_accuracy))
#run()可以看做输入相关值给到函数中的占位符，然后计算的出结果，这里将batch[0]，给xbatch[1]给y_
  train_step.run(feed_dict={x: batch[0], y_true: batch[1]})

#将当前图设置为默认图
graph_def = tf.get_default_graph().as_graph_def() 
#将上面的变量转化成常量，保存模型为pb模型时需要,注意这里的final_result和前面的y_con2是同名，只有这样才会保存它，否则会报错，
# 如果需要保存其他tensor只需要让tensor的名字和这里保持一直即可
output_graph_def = tf.graph_util.convert_variables_to_constants(sess,  
                graph_def, ['final_result'])  
#保存前面训练后的模型为pb文件
with tf.gfile.GFile("./model/pb/mnist.pb", 'wb') as f:  
        f.write(output_graph_def.SerializeToString())
print("保存pb成功")

#保存模型
saver = tf.train.Saver()   
saver.save(sess, "./model/ckpt/mnist.ckpt")  
print("保存ckpt成功")