内容提要

线性回归逻辑回归KNN其它机器学习算法

一、线性回归

1、什么是线性回归

线性回归是利用数理统计中的回归分析来确定两种或两种以上变量间相互依赖定量关系的一种统计分析方法，其运用领域十分广泛。

简单来说，线性回归就是要完成一个函数，该函数有输入和输出，当输入一些参数时，该函数就能得到一个结果作为输出，这个输出就是对输入的预测，且这个预测的结果是连续的。

线性回归是在N维的空间找到一条直线、一个平面或者一个超平面，使其能够拟合提供的数据，从而可以预测新的数据。在线性回归中，公式为y=Wx+b，W是权重，b是偏置。

2、线性回归案例

随机生成一些数据x作为时间投入，y作为考试成绩，找到一条直线，让这条直线尽可能地拟合图中的数据点，复习过程中时间投入与考试成绩的图像如图1所示。

在这个回归任务中，需要找到“最佳拟合线”使得误差最小化。拟合后的线如图2所示。

希望拟合后的线上每一个y和 的差距都尽可能小，即这条线上所有样本点x(p)对应的真值和预测值之差的和是最小的，真值与预测值的差距反映在二维空间上，表现为两者距离的长短，从而将求最优化的拟合线问题转换为求最短距离问题。

计算距离常用的方法有L1距离和L2距离等。

L1距离公式为

，（x1，y1）是起点的坐标，（x2，y2）是终点的坐标。

L2距离公式为

，（x1，y1）是起点的坐标，（x2，y2）是终点的坐标。

提示：在寻找复习时间和考试成绩最佳拟合曲线时，也可以用L1距离或者L2距离来做，这里使用L2距离完成拟合。

此时目标就确立了，即所有的样本点x(p)对应的拟合线上预测值 与真实值y的距离之和要尽可能小，也就是说

要尽可能小，结合

，使得

尽可能小，由于x和y是已知的，所以需要找到k和b。

在机器学习中，斜率k一般称为权重W，截距b称为偏置b，y(p)是真值，

是预测值。这个过程就是使用最小二乘法解决问题的思路。

在机器学习中，需要通过分析问题确定问题的损失函数，通过最优化损失函数获得机器学习的模型。在本问题中，选择

为损失函数，由于x和y都是已知的，所以需要找到参数k和b，使得损失函数的值最小。

3、数学方法解决线性回归问题

案例见上，步骤如下：

先导入必要的库。

希望拟合后的线上每一个y和 的差距都尽可能小，即这条线上所有样本点x(p)对应的真值和预测值之差的和是最小的，真值与预测值的差距反映在二维空间上，表现为两者距离的长短，从而将求最优化的拟合线问题转换为求最短距离问题。

计算距离常用的方法有L1距离和L2距离等。

二、逻辑回归

1、什么是逻辑回归

在线性回归中，输入和输出呈一定的关系且输出为连续的，即 y=f(x)。如果输出的y不表示为一个值，而是一个概率p，则公式更改为p=f(x)，从线性回归输出一个具体的值到输出概率的过程需要一个中间公式，这个中间公式为

。当没有中间公式的转换时，就是一个回归问题；加了中间公式之后，就是一个分类问题。

线性回归中有公式

，在逻辑回归中，x可以为任意数（或多维数组），但是输出的概率值域为[0,1]。将线性回归的公式更改为

，将 作为新的特征可得到概率， 往往使用sigmoid()函数，称为激活函数，sigmoid()函数的形式为

，sigmoid()函数图像如图所示。

将sigmoid()函数在坐标轴上绘制出来后，拥有坐标轴的sigmoid()函数图像如图所示。

2、逻辑回归案例

银行基于一个人的信用度决定是否为其发放信用卡，这里假设横坐标x是信用度，纵坐标y是工作稳定性。设置一些点，三角形代表银行不发给他信用卡，五角星代表银行发给他信用卡，如图所示。

3、数学方法解决逻辑回归问题

在线性回归中，结果是线性的，期望y和 的差距尽可能小，可以使用距离求解。

但是在逻辑回归中，得到的结果是概率，没办法直接求距离，这时候需要做一些处理，使用损失函数 ，其中x是逻辑回归的结果。

对于该公式

，损失函数的图像如图所示。

说明：

损失函数是两个函数，在编程的时候会造成困难，所以将其合并为一个函数：

当y=1时，

当y=0时，

这里有一个样本，当有n个样本时，损失函数为

其中

按照解决线性回归问题的思路，应该算出它的数学公式解，

但是这个式子是没有数学公式解的，所以这里使用梯度下降的方法解决该逻辑回归问题。

4、利用TensorFlow解决逻辑回归问题

使用梯度下降法实现逻辑回归，绘制一条线将是否发给用户信用卡两类数据分开，在machine_learning项目下新建Logistic_regression.py。

（1）导入必要的库

<code>import matplotlib.pyplot as plt

import tensorflow as tf

import numpy as np

（2）训练逻辑回归

# 创造数据

raw_data_X = [[1.85, 1.05],[1.57, 2.63], [2.28, 1.42],

[2.28, 3.64], [1.94, 3.68],[2.09, 2.66], [1.49, 3.66],

[0.12, 1.12], [0.25, 1.04],[0.23, 0.54], [0.83, 1.49],

[0.95, 0.09], [0.46, 1.63], [0.26, 1.03], ]

raw_data_Y = [0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1];

data = np.array(raw_data_X)

label = np.array(raw_data_Y)

data = np.hstack(data).reshape(-1,2)

label = np.hstack(label).reshape(-1,1)

label1 = label.reshape(1,-1)[0]

plt.scatter(data[label1 == 0, 0], data[label1 == 0, 1], marker="*")code>

plt.scatter(data[label1 == 1, 0], data[label1 == 1, 1], marker="^")code>

plt.show()

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

y_ = tf.placeholder(tf.float32,shape=(None,1))

# tf.random_normal()函数用于从服从指定正态分布的数值中取出指定个数的值

# tf.random_normal(shape, mean=0.0, stddev=1.0, dtype=tf.float32, seed=None, name=None)

weight = tf.Variable(tf.random_normal([2,1]), dtype=tf.float32)

bias = tf.Variable(tf.constant(0.1, shape=[1]))

# tf.nn.sigmoid()是激活函数

y_hat = tf.nn.sigmoid(tf.matmul(x, weight) + bias)

# 不适用该损失函数

# cost = tf.reduce_sum(tf.square(y_ - y_hat))

# 损失函数

cost = - tf.reduce_mean(y_ * tf.log(tf.clip_by_value(y_hat, 1e-10, 1.0)) + (1 - y_) * tf.log(tf.clip_by_value((1 - y_hat), 1e-10, 1.0)))

# 梯度下降

optimizer = tf.train.AdamOptimizer(0.001)

train = optimizer.minimize(cost)

#开始训练

with tf.Session() as sess:

sess.run(tf.global_variables_initializer())

plt.ion()

for i in range(8000):

sess.run(train,feed_dict={x:data,y_:label})

#画出训练后的分割函数

#mgrid()函数产生两个300×400的数组：0～3每隔0.1取一个数，共300×400个

xx, yy = np.mgrid[0:3:.1,0:4:.1]

if (i % 20) == 0:

# np.c_用于合并两个数组

# ravel()函数将多维数组降为一维，仍返回array数组，元素以列排列

grid = np.c_[xx.ravel(), yy.ravel()]

probs = sess.run(y_hat, feed_dict={x:grid})

# print(probs)

效果如图：

三、KNN

<code>def train(X, y):

Xtr = X

Ytr = y

return Xtr, Ytr

（7）创建预测函数

def predict_math (X, xtrain, ytrain):

# 求L2距离

distances = [sqrt(np.sum((X_train - X) ** 2)) for X_train in xtrain]

# 对数组进行排序，返回的是值的索引值

nearest = np.argsort(distances)

# 取出前3个离得最近的点的标签

k = 3

topK_y = [ytrain[i] for i in nearest[:k]]

# 计数，取到键值对。键：标签；值：个数

votes = Counter(topK_y)

# 在键值对中值最多的键

print(votes.most_common(1)[0][0])

（8）调用训练函数与预测函数，完成预测

xtrain, ytrain = train(x_train, y_train)

predict_math (x_test, xtrain, ytrain)

（9）修改预测函数

def predict_math(X, xtrain, ytrain):

# 求L2距离

distances = [sqrt(np.sum((X_train - X) ** 2)) for X_train in xtrain]

# 对数组进行排序，返回的是值的索引值

nearest = np.argsort(distances)

# 取出前3个离得最近的点的标签

k = 3

topK_y = [ytrain[i] for i in nearest[:k]]

# 计数，取到键值对。键：标签；值：个数

votes = Counter(topK_y)

# 在键值对中值最多的键

print(votes.most_common(1)[0][0])

# 得到最接近的3个点的索引值

k = 3

topK_X = nearest[:k]

for i in range(3):

# 绘制预测点与最接近的3个点连成的直线

plt.plot([X[0], xtrain[topK_X[i]][0]], [X[1], xtrain[topK_X[i]][1]])

# 绘制预测点与最接近的3个点之间的长度

plt.annotate("%s"%round(distances[topK_X[i]], 2), xy=((X[0] + xtrain[topK_X[i]][0]) / 2,(X[1] + xtrain[topK_X[i]][1]) / 2))

plt.xlabel('x轴')

plt.ylabel('y轴')

plt.scatter(x_train[y_train == 0, 0], x_train[y_train == 0, 1], marker="*")code>

plt.scatter(x_train[y_train == 1, 0], x_train[y_train == 1, 1], marker="^")code>

plt.scatter(x_train[y_train == 2, 0], x_train[y_train == 2, 1], marker="s")code>

plt.scatter(x_test[0], x_test[1], marker="o")code>

plt.show()

k=3时认为测试点属于第0个类别，即五角星的类别。此时直接输出不是非常直观，如图所示。

4、利用TensorFllow解决KNN问题