逻辑回归的例子

逻辑回归是经典的分类算法。为了简单，我们考虑二分类。这意味着，我们要处理识别二个分类的问题，我们的标签为 0 或 1。 我们要一个与线性回归不同的激活函数，不同的损失函数，神经元的输出略有不同。我们的目的是能构建模型能预测一个新的观察属于两个分类中的哪一个。 对于输入 x神经元应输出概率P(y = 1| x) 作为分类1.我们分类观察作为分类1,如果 P(y = 1| x) > 0.5, 或者分类 0,如果P(y = 1| x) < 0.5.

损失函数

作为损失函数，我们使用交叉熵. 对于一个观察函数为

对于多于一个观察 损 失函数是求和所有的观察

后面我们可以从头书写完整的逻辑回归，但是现在，tensorflow会为我们处理细节--微分，梯度下降，等的实现。我们只需要构建对的神经元。

激活函数

记住:我们想要神经元输出观察是分类 0或分类 1的概率。因些，我们想要激活函数输出0 到1的值。否则我们不能把它作为概率。对于逻辑回归，我们使用 sigmoid函数作为激活函数.

数据集

要构建一个有趣的模型，我们要使用修改版的 MNIST数据集。你可以在 http://yann.lecun.com/exdb/ mnist/找到相关信息。

 MNIST数据集是大的手写字数据集可以用来训练我们的模型。 MNIST数据集包含70,000张图像。 “原始的黑白图像 (bilevel)来自NIST的大小被归一化以适合 20×20像素盒子而保留它们的比例.结果图像包含灰度水平作为归一化算法使用的  anti-aliasing技术的结果。图像集中于 28×28图像，通过计算像素质心，我后转换图像使中心在28×28 区域内” (来源: http://yann. lecun.com/exdb/mnist/).

我们的特征是每个像素的灰度值，所以我们有28 × 28 = 784个特征取值为0到255 (灰度值).数据集包含10个数字，从0到9. 用下面的代码，你可以准备数据以供下一节使用。通常，我们先导入必要的库.

 #List3-46

from  sklearn.datasets  import  fetch_mldata

然后加载数据.

mnist = fetch_mldata('MNIST original') X,y  =  mnist["data"],  mnist["target"]

现在X包含输入图像且y是目标标签 (记住在机器学习里我们想要预测的值称为目标). 只要输入 X.shape就会得到 X的形状: (70000, 784). 注意 X 有70,000行 (每行是一张图像)和 784列 (每列是一个特征,或像素灰度值,本例中).我们检查一下数据集里有多少个数字.

 #List3-47

for i in range(10):

print ("digit", i, "appears", np.count_nonzero(y == i), "times")

结果如下:

定义一个函数来可视化数字是有用的.

 #List3-48

def  plot_digit(some_digit):

some_digit_image    =    some_digit.reshape(28,28)  plt.imshow(some_digit_image,    cmap    =    matplotlib.cm.binary,    interpolation

= "nearest") plt.axis("off") plt.show()

例如， 我们随机的作图 (见图 3-46).

plot_digit(X[36003])

图3-47. 从数据集随机选取的6个数字。相对的标签在括号里 (记住现在标签为0或 1).

tensorflow实现

 tensorflow实现并不难，与线性回归几乎相同。首先定义placeholders和variables.

tf.reset_default_graph()

X  =  tf.placeholder(tf.float32,  [n_dim,  None]) Y   =   tf.placeholder(tf.float32,  [1,  None])

learning_rate  =  tf.placeholder(tf.float32,  shape=())

W   =   tf.Variable(tf.zeros([1,  n_dim])) b     =     tf.Variable(tf.zeros(1))

init   =   tf.global_variables_initializer()

注意代码与上面的线性回归相同。但是我们必须定义不同的损失函数和不神经元输出 (sigmoid函数).

y_   =   tf.sigmoid(tf.matmul(W,X)+b)

cost  =  -  tf.reduce_mean(Y  *  tf.log(y_)+(1-Y)  *  tf.log(1-y_))

training_step    =    tf.train.GradientDescentOptimizer(learning_rate).minimize(cost)

我们用sigmoid函数作为神经元的输出,使用 tf.sigmoid(). 运行模型的代码与线性回归相同.我们只改变函数名称.

def   run_logistic_model(learning_r,   training_epochs,   train_obs, train_labels,  debug  =  False):

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

cost_history  =  np.empty(shape=[0],  dtype  =  float)

for epoch in range(training_epochs+1):

sess.run(training_step,  feed_dict  =  {X:  train_obs,  Y:  train_labels, learning_rate:    learning_r})

cost_ = sess.run(cost, feed_dict={ X:train_obs, Y: train_labels, learning_rate:  learning_r})

cost_history  =  np.append(cost_history,  cost_)

if (epoch %  500 == 0) &  debug:

print("Reached epoch",epoch,"cost J =", str.format('{0:.6f}', cost_))

return sess, cost_history

我们运行模型并看一下结果.我们从学习速率0.01开始.

sess,  cost_history  =  run_logistic_model(learning_r  =  0.01,

training_epochs = 5000, train_obs  =  Xtrain, train_labels   =   ytrain, debug = True)

代码的输出如下 ( 3000 epochs后停止):

Reached epoch 0 cost J = 0.678598 Reached epoch 500 cost J = 0.108655 Reached epoch 1000 cost J = 0.078912 Reached epoch 1500 cost J = 0.066786 Reached epoch 2000 cost J = 0.059914 Reached epoch 2500 cost J = 0.055372 Reached epoch 3000 cost J = nan

发生什么了? 突然，某些点，我们的损失函数取nan (不是数字).看来模型在某个点工作得不好。如果学习速率太大，或初始化权重错误，你的值

yˆ(i )  = P (y(i )  = 1|x(i ) ) 或能接按于零或1 ( sigmoid函数取值接近 0 或1 以于非常大的正或负的z值）.记住，在损失函数里，你有两个项tf.log(y_)和 tf.log(1-y_), 因为 log函数对于值零没有定义，如果 y_ 为 0或 1, 你会得到 nan, 因为代码试图评估tf.log(0).例如，我们可以运行模型使用学习速率 2.0.只要一个 epoch, 你的损失函数就得到nan值。很容易理解原因，如果你打印b在第一个训练步前后。简单的修改你的模型代码，使用下面的版本 :

def   run_logistic_model(learning_r,   training_epochs,   train_obs,   train_ labels,  debug  =  False):

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

cost_history = np.empty(shape=[0], dtype = float) for epoch in range(training_epochs+1):

print ('epoch: ', epoch)

print(sess.run(b,  feed_dict={X:train_obs,  Y:  train_labels, learning_rate:   learning_r}))

sess.run(training_step,  feed_dict  =  {X:  train_obs,  Y:  train_labels, learning_rate:    learning_r})

print(sess.run(b,  feed_dict={X:train_obs,  Y:  train_labels, learning_rate:   learning_r}))

cost_ = sess.run(cost, feed_dict={ X:train_obs, Y: train_labels, learning_rate:  learning_r})

cost_history  =  np.append(cost_history,  cost_)

if (epoch %  500 == 0) &  debug:

print("Reached epoch",epoch,"cost J =", str.format('{0:.6f}', cost_))

return sess, cost_history

你得到下面的结果 (训练一个epoch):

epoch:    0

[ 0.]

[-0.05966223]

Reached epoch 0 cost J = nan epoch:      1

[-0.05966223]

[ nan]

你看到b从0变到 -0.05966223然后再到 nan? 因此, z = wTX + b 这为 nan, 然后y = σ(z) 也变为 nan, 最后损失函数是 y的函数，结果为nan. 这是因为学习速率过大。解决方案呢? 你应该试试不同的学习速率 (更少的值).

我们试试并得到更稳定的结果，在 2500 epochs之后.我们运行模型:

sess,   cost_history   =   run_logistic_model(learning_r   =   0.005,

training_epochs = 5000, train_obs  =  Xtrain, train_labels   =   ytrain, debug = True)

correct_prediction1   =   tf.equal(tf.greater(y_,   0.5),   tf.equal(Y,1)) accuracy  =  tf.reduce_mean(tf.cast(correct_prediction1,  tf.float32)) print(sess.run(accuracy,  feed_dict={X:Xtrain,  Y:  ytrain,  learning_rate: 0.05}))

使用这个模型，我们得到准确率为 98.6%. 这对于一个神经元的网络不差。