Tensorflow-逻辑斯蒂回归

1.交叉熵

逻辑斯蒂回归这个模型采用的是交叉熵，通俗点理解交叉熵

推荐一篇文章讲的很清楚：

https://www.zhihu.com/question/41252833

因此，交叉熵越低，这个策略就越好，最低的交叉熵也就是使用了真实分布所计算出来的信息熵，因为此时  ，交叉熵 = 信息熵。这也是为什么在机器学习中的分类算法中，我们总是最小化交叉熵，因为交叉熵越低，就证明由算法所产生的策略最接近最优策略，也间接证明我们算法所算出的非真实分布越接近真实分布

2.代码解释

import warnings
warnings.filterwarnings('ignore')
import numpy as np
import tensorflow as tf
# 样本集
from tensorflow.examples.tutorials.mnist import input_data

# 加载数据，目标值变成概率的形式，ont-hot
mnist = input_data.read_data_sets('./',one_hot=True)
# 训练数据 (55000, 784)
mnist.train.images.shape
# 测试数据 (10000, 784)
mnist.test.images.shape
# 目标值 ont-hot形式
mnist.train.labels[:10]

# 构建方程
X = tf.placeholder(dtype=tf.float64,shape = (None,784),name = 'data')
y = tf.placeholder(dtype=tf.float64,shape = (None,10),name = 'target')
W = tf.Variable(initial_value=tf.zeros(shape =(784,10),dtype = tf.float64))
b = tf.Variable(initial_value=tf.zeros(shape = (10),dtype = tf.float64))
y_pred = tf.matmul(X,W) + b

# 构建损失函数
# y 和 y_pred对比
# y表示是概率 [0., 0., 0., 0., 0., 0., 0., 1., 0., 0.]
# y_pred,矩阵运算求解的目标值
# 要将y_pred转化成概率，softmax
y_ = tf.nn.softmax(y_pred)
# 此时y和y_表示概率
# y和y_越接近，说明预测函数越准确
# 此时分类问题，交叉熵，表示损失函数
# 熵：表示的系统混乱程度
# 损失函数，越小越好
# 平均交叉熵------->可以比较大小的数
loss = tf.reduce_mean(tf.reduce_sum(tf.multiply(y,tf.log(1/y_)),axis = -1))

# 最优化
opt = tf.train.GradientDescentOptimizer(0.01).minimize(loss)

# 训练
# 训练次数
epoches = 100
# 保存
saver = tf.train.Saver()
with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    for i in range(epoches):
        c = 0
        for j in range(100):
#      一次取550个，分100次取完数据 next_batch方法
            X_train,y_train = mnist.train.next_batch(550)
            opt_,cost = sess.run([opt,loss],feed_dict = {X:X_train,y:y_train})
            c += cost/100
#         计算准确率
        X_test,y_test = mnist.test.next_batch(2000)      
        y_predict = sess.run(y_,feed_dict={X:X_test})      
        y_test = np.argmax(y_test,axis = -1)
        y_predict = np.argmax(y_predict,axis = 1)      
        accuracy = (y_test == y_predict).mean()
        print('执行次数：%d。损失函数是：%0.4f。准确率是：%0.4f'%(i+1,c,accuracy))       
        if accuracy > 0.91:
            saver.save(sess,'./model/estimator',global_step=i)
            print('---------------------------模型保存成功----------------------------')

保存了模型，在上一次的基础上继续进行学习，这样的话可以直接从上次的准确率开始

# 其实代码是一样的，只是加了个saver.restore还原
with tf.Session() as sess:
#     还原到sess会话中
    saver.restore(sess,'./model/estimator-99')
    
    for i in range(100,200):
        c = 0
        for j in range(100):
            X_train,y_train = mnist.train.next_batch(550)
            opt_,cost = sess.run([opt,loss],feed_dict = {X:X_train,y:y_train})
            c += cost/100
        
#         计算准确率
        X_test,y_test = mnist.test.next_batch(2000)
        
        y_predict = sess.run(y_,feed_dict={X:X_test})
        
        y_test = np.argmax(y_test,axis = -1)
        y_predict = np.argmax(y_predict,axis = 1)
        
        accuracy = (y_test == y_predict).mean()
        print('执行次数：%d。损失函数是：%0.4f。准确率是：%0.4f'%(i+1,c,accuracy))
        
        if accuracy > 0.91:
            saver.save(sess,'./model/estimator',global_step=i)
            print('---------------------------模型保存成功----------------------------')