《实战》基于tensorflow搭建逻辑回归模型

基于tensorflow搭建逻辑回归模型

• 1. 用Mnist数据集进行逻辑回归任务
• 2. 逻辑回归任务
• • 2.1 模型
  • 2.2 迭代

1. 用Mnist数据集进行逻辑回归任务

本次实战，主要要学习完成，通过tesorflow搭建一个逻辑回归模型，通过逻辑回归模型，来完成Mnist数据集的分类任务。

Mnist数据集，在tensorflow中就有，需要将其下载下来，导入相应的包。

import numpy as np
import tensorflow as tf
import matplotlib.pyplot as plt
from tensorflow.examples.tutorials.mnist import input_data

调用相应的命令来执行下载任务,将其下载到一个data文件夹中，其中编码格式要设置为一个onehot的类型。这样下载下来的label标签就是对应的位置为1，其他位置为0，代表当前的类型。

print('下载中')
mnist = input_data.read_data_sets('data/',one_hot=True)

下载中
Successfully downloaded train-images-idx3-ubyte.gz 9912422 bytes.
Extracting data/train-images-idx3-ubyte.gz
Successfully downloaded train-labels-idx1-ubyte.gz 28881 bytes.
Extracting data/train-labels-idx1-ubyte.gz
Successfully downloaded t10k-images-idx3-ubyte.gz 1648877 bytes.
Extracting data/t10k-images-idx3-ubyte.gz
Successfully downloaded t10k-labels-idx1-ubyte.gz 4542 bytes.
Extracting data/t10k-labels-idx1-ubyte.gz

下载下来的数据集，可以先看看数据集的数据的类型

由于的官方自己的数据集，所以以及分好了训练集和测试集。调用相应的方法就可以查看相应的数据集。

print('类型：',type(mnist))
print('训练数据：',mnist.train.num_examples)
print('测试数据：',mnist.test.num_examples)

类型：
训练数据： 55000
测试数据： 10000

可以看出来数据集的训练集为55000，测试集为10000条

下载好了数据集，我们可以将相应的数据集进行划分，查看相应的格式，和标签。

trainimg = mnist.train.images
trainlabel = mnist.train.labels

testimg = mnist.test.images
testlabel = mnist.test.labels

print (" 数据类型 is %s"    % (type(trainimg)))
print (" 标签类型 %s"  % (type(trainlabel)))
#---------------------------------------------
print (" 训练集的shape %s"   % (trainimg.shape,))
print (" 训练集的标签的shape %s" % (trainlabel.shape,))
print (" 测试集的shape' is %s"    % (testimg.shape,))
print (" 测试集的标签的shape %s"  % (testlabel.shape,))

数据类型 is
标签类型
训练集的shape (55000, 784)
训练集的标签的shape (55000, 10)
测试集的shape’ is (10000, 784)
测试集的标签的shape (10000, 10)

数据的类型还是ndarray构成的，其中维度是784维度，因为Mnist数据集是28*28的一个1维小型图的格式

我们可以里面的数值是什么样子的

随机取得几条样板数据，通过np.random.randint()得到，将得到的样本数据进行reshape将原本一行的数据转成28*28的数据。
再就用plt.matshow将获取的数据展现出来，其中cmap选择灰色模式

nsample = 5
randidx = np.random.randint(trainimg.shape[0], size=nsample)
print(trainimg.shape)
print(randidx)

(55000, 784)
[33766 22778 22161 37185 46809]

for i in randidx:
    curr_img = np.reshape(trainimg[i,:],(28,28))
    curr_label = np.argmax(trainlabel[i,:])
    plt.matshow(curr_img,cmap=plt.get_cmap('gray'))
    print('标签是：',curr_label)
    plt.show()

其中Mnist数据集，自带方法train.next_batch实现对数据的批量

# 设置batch的数据
batch_size = 100 #一次带100个数据进行训练

batch_xs,batch_ys = mnist.train.next_batch(batch_size)

print('Batch数据：',type(batch_xs))
print('Batch标签:',batch_ys[:2])
print('Batch数据的shape:',batch_xs.shape)
print('Batch标签的shape:',batch_ys.shape)

Batch数据：
Batch标签: [[ 1. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
[ 0. 0. 0. 1. 0. 0. 0. 0. 0. 0.]]
Batch数据的shape: (100, 784)
Batch标签的shape: (100, 10)

后面的分析就通过这个方法实现数据的批量处理

2. 逻辑回归任务

先定义需要的模型的参数模型,类别数，特征数，迭代次数，batchSize

numClasses = 10
inputSize = 784 #输入的特征数
trainingIterations = 50000
batchSize = 64  #一次迭代多少个

指定完事基本的参数后，我们就需要指定传入模型的参数，X，y。
其中X表示输入数据的，y为标签。一般来说，x和y的第一个值是传入的样本数量的值。

X = tf.placeholder(tf.float32,shape = [None,inputSize])   #每个数据是784个，None就是代表输入的数据量可以是任意的
y = tf.placeholder(tf.float32,shape = [None,numClasses]) #

输入是 64* 784

中间是 784 * 10

最后是 64 * 10

最后的一个b ，最后的b应该和最后输出的维度的一致的，才能相加。

2.1 模型

构建出来了输入的x和y，接下来就要构建逻辑回归模型的w和b的值

其中W就是前面的中间的维度，而b是加在之后，所以b的维度应该和最后的类别的数量是一致的

一开始的值设置为随机数就可以

W1 = tf.Variable(tf.random_normal([inputSize, numClasses], stddev=0.1))
B1 = tf.Variable(tf.constant(0.1), [numClasses])

构建出预测的逻辑回归模型，逻辑回归模型就是在完成线性回归模型的基础上，再将结果映射到Sigmoid函数上，得到最后的结果。

y_pred = tf.nn.softmax(tf.matmul(X,W1) + B1)

完成模式构建之后，就可以计算损失函数的值，计算损失函数的方法有很多，本次分类任务的是通过计算平方差的均值。

loss = tf.reduce_mean(tf.square(y-y_pred)) 

构建出损失函数后，就需要去构建优化器，不断的优化模型的参数，本次选择梯度下降的方式完成参数的优化。

opt = tf.train.GradientDescentOptimizer(learning_rate= 0.05).minimize(loss)

可以计算得到模型每次预测的准确率，主要通过tf.argmax()找到对应位置的最大值，返回位置，判断预测最终结果与实际结果的差距。

correct_prediction = tf.equal(tf.argmax(y_pred,1),tf.argmax(y,1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction,'float'))

2.2 迭代

基本都完成了模型的构建流程，后面就是将构建出来的向量的进行初始化，进行迭代计算。打印出来相应的准确度信息。

sess = tf.Session()
init = tf.global_variables_initializer()
sess.run(init)

for i in range(trainingIterations):
    batch = mnist.train.next_batch(batchSize)
    bachInput = batch[0]
    bachLabel = batch[1]
    _,trainingLoss = sess.run([opt,loss],feed_dict={X:bachInput,y:bachLabel})
    if i % 1000 == 0 :
        train_accuray = accuracy.eval(session =sess,feed_dict={X:bachInput,y:bachLabel})
        print('第',i,'次迭代','准确度为：',train_accuray)

第 0 次迭代 准确度为： 0.0625
第 1000 次迭代 准确度为： 0.59375
第 2000 次迭代 准确度为： 0.65625
第 3000 次迭代 准确度为： 0.84375
第 4000 次迭代 准确度为： 0.78125
第 5000 次迭代 准确度为： 0.765625
第 6000 次迭代 准确度为： 0.8125
第 7000 次迭代 准确度为： 0.765625
第 8000 次迭代 准确度为： 0.75
第 9000 次迭代 准确度为： 0.828125
第 10000 次迭代 准确度为： 0.84375
第 11000 次迭代 准确度为： 0.859375
第 12000 次迭代 准确度为： 0.890625
第 13000 次迭代 准确度为： 0.90625
第 14000 次迭代 准确度为： 0.875
第 15000 次迭代 准确度为： 0.90625
第 16000 次迭代 准确度为： 0.9375
第 17000 次迭代 准确度为： 0.875
第 18000 次迭代 准确度为： 0.90625
第 19000 次迭代 准确度为： 0.875
第 20000 次迭代 准确度为： 0.921875
第 21000 次迭代 准确度为： 0.890625
第 22000 次迭代 准确度为： 0.90625
第 23000 次迭代 准确度为： 0.90625
第 24000 次迭代 准确度为： 0.921875
第 25000 次迭代 准确度为： 0.890625
第 26000 次迭代 准确度为： 0.921875
第 27000 次迭代 准确度为： 0.921875
第 28000 次迭代 准确度为： 0.90625
第 29000 次迭代 准确度为： 0.859375
第 30000 次迭代 准确度为： 0.9375
第 31000 次迭代 准确度为： 0.953125
第 32000 次迭代 准确度为： 0.890625
第 33000 次迭代 准确度为： 0.84375
第 34000 次迭代 准确度为： 0.921875
第 35000 次迭代 准确度为： 0.875
第 36000 次迭代 准确度为： 0.921875
第 37000 次迭代 准确度为： 0.875
第 38000 次迭代 准确度为： 0.953125
第 39000 次迭代 准确度为： 0.859375
第 40000 次迭代 准确度为： 0.953125
第 41000 次迭代 准确度为： 0.875
第 42000 次迭代 准确度为： 0.890625
第 43000 次迭代 准确度为： 0.859375
第 44000 次迭代 准确度为： 0.921875
第 45000 次迭代 准确度为： 0.953125
第 46000 次迭代 准确度为： 0.859375
第 47000 次迭代 准确度为： 0.890625
第 48000 次迭代 准确度为： 0.90625
第 49000 次迭代 准确度为： 0.921875

可以看出在多次迭代计算后，模型的准确度，已经逐步的提高。初步完成了tensorflow完成逻辑回归模型的分类。