机器学习入门（五）回归算法实战一

最新推荐文章于 2024-01-09 12:18:03 发布
最新推荐文章于 2024-01-09 12:18:03 发布
阅读量582 收藏 2
点赞数 1
分类专栏： 机器学习 文章标签： 机器学习 逻辑回归实战
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/rookie_wei/article/details/83479700
版权

--------韦访 20181023

1、概述

这一讲，我们来学习怎么使用逻辑回归解决实际问题。假设现在我们有100个学生两次考试成绩以及是否通过考核的历史数据，我们来建个逻辑回归的模型来对以后学生的考试成绩进行预测是否通过。

2、查看数据

示例数据的下载链接为：https://download.csdn.net/download/rookie_wei/10749893

我们先来查看原始数据文件，

数据只有3列，共100行，前两列分别代表两次考试的成绩，第三列表示是否通过考核，0表示不通过，第一行就直接是数据了，没有表头。为了更直观的观察数据，我们可以将其用坐标系画出来。代码如下，

#encoding:utf-8
import pandas as pd
import matplotlib.pyplot as plt
import numpy as np

#因为第一行就是数据了，所有，要指定header参数为None
#为了方便后续数据处理，再给数据加个表头names
lrData = pd.read_csv('LogiReg_data.csv', header=None, names=['Score1', 'Score2', 'PASS'])
print(lrData.shape)

#将通过的数据和不通过考核的数据分别提出了
passData = lrData[lrData['PASS'] == 1]
notPassData = lrData[lrData['PASS'] == 0]

#将数据画出来
xy = plt.subplot()
xy.scatter(passData['Score1'], passData['Score2'], c='r', marker='o', label='Pass')
xy.scatter(notPassData['Score1'], notPassData['Score2'], c='b', marker='x', label='Not Pass')
xy.legend()
xy.set_xlabel('Score1')
xy.set_ylabel('Score2')
plt.show()

运行结果，

 

3、模型构思

由上一讲可知，我们训练的目的，是为了求出三个θ参数（θ1、θ2、θ3）和一个阈值，根据阈值判断结果是否通过。

我们需要完成的模块如下：

Sigmoid：将值转换到概率上的函数

Model：返回预测结果

Cost：根据参数计算损失

Gradient：计算每个参数的梯度方向

Descent：更新参数

Accuracy：计算精度

4、代码实现模块

Sigmoid函数：

公式如下，

代码实现就很简单了，

def sigmoid(z):
    return 1 / (1 + np.exp(-z))

Model函数：

公式如下，

 这个代码也很简单，传入X和θ参数，再带入上面的sigmoid函数即可，代码如下，

def model(X, theta):
    return sigmoid(np.dot(theta.T, X))

损失函数：

公式如下，

为将上式转为梯度下降，引入，

 

 为了让代码更清晰明了，我们可以先求

 再求

 最后再求和，代码如下，

def cost(X, y, theta):
    left = np.multiply(y, np.log(model(X, theta)))
    right = np.multiply(1 - y, np.log(1 - model(X, theta)))
    return - np.sum(left + right) / len(X)

计算梯度：

对平均损失函数求偏导，得到式子如下，

 实现代码如下，

#计算梯度的函数
def gradient(X, y, theta):
    grad = np.zeros(theta.shape)
    error = (model(X, theta) - y).ravel()
    #求所有theta的梯度
    for i in range(len(theta.ravel())):
        term = np.multiply(error, X[:,i])
        grad[0, i] = np.sum(term) / len(X)
    return grad

洗牌函数：

什么叫洗牌函数呢？其实就是随机打乱数据，跟打牌时的洗牌动作一样，这样是为了避免我们获取（或者爬取）的数据因为某些原因而使训练结果不够好。比如，如果按成绩排名获取的数据，那么就有可能导致某些batch的成绩都非常好，某些batch的成绩很差，所以把它们洗牌（打乱）以后再训练。代码如下，

#洗牌
def shuffle(data):
    np.random.shuffle(data)
    columns = data.shape[1]
    X = data[:, 0:columns-1]
    Y = data[:, columns-1:]
    return X, Y

可以写个例子试试有没有起到“洗牌”的效果，代码如下，

data = np.array([
    [1, 2, 3],
    [11, 12, 13],
    [21, 22, 23],
    [31, 32, 33],
    [41, 42, 43],
])

x, y = shuffle(data)
print(x)
print('------')
print(y)

运行结果，

梯度下降：

上一讲中有提到过，梯度小下降法有三种，分别是：批量梯度下降法、随机梯度下降法、小批量梯度下降法。等下我们对比一下这三种梯度下降法的结果，我们总不能让训练无休止的进行下去吧？所以我们也要有相关的停止策略，一般分为三种：设定迭代次数、根据损失值停止训练、根据梯度变化停止训练。

#停止策略
#设定迭代次数
STOP_COUNT = 1
#根据损失值停止训练
STOP_LOSS = 2
#根据梯度变化停止训练
STOP_GRAD = 3
def stopTrain(type, value, threshold):
    if type == STOP_COUNT:
        return value > threshold
    elif type == STOP_LOSS:
        return abs(value[-1] - value[-2]) < threshold
    elif type == STOP_GRAD:
        return np.linalg.norm(value) < threshold
    else:
        return False

#梯度下降法
#data : 数据  theta：系数  stopType：停止策略  batchSize：batch大小
#threshold：阈值  learning_rate：步长/学习率
def gradientDescent(data, theta, stopType, batchSize, threshold, learning_rate):
    #迭代次数
    iterTime = 0
    #batch 下标
    batchIndex = 0
    #对数据洗牌
    X, y = shuffle(data)
    #损失
    errors = [cost(X, y, theta)]

    while True:
        #计算梯度
        grad = gradient(X[batchIndex:batchIndex+batchSize], y[batchIndex:batchIndex+batchSize], theta)

        #更新参数
        theta = theta - learning_rate * grad
        #调整下标
        batchIndex += batchSize
        #迭代次数加一
        iterTime += 1
        #记录下损失值
        errors.append(cost(X, y, theta))
        if batchIndex >= len(X):
            batchIndex = 0
            # 重新对数据洗牌
            X, y = shuffle(data)

        if stopType == STOP_COUNT:
            value = iterTime
        elif stopType == STOP_LOSS:
            value = errors
        elif stopType == STOP_GRAD:
            value = grad
        else:
            stopType = STOP_COUNT
            value = iterTime

        if stopTrain(stopType, value, threshold):
            break
    return theta, iterTime, errors

#开始训练
def train(data, theta, stopType, batchSize, threshold, learning_rate):
    theta, iterTime, errors = gradientDescent(data, theta, stopType, batchSize, threshold, learning_rate)
    print('theta:{}'.format(theta))
    print('iterTime:{}'.format(iterTime))
    print('last loss:{}'.format(errors[-1]))
    xy = plt.subplot()
    xy.plot(np.arange(len(errors)), errors, 'r')
    xy.set_xlabel('Iter Last Loss:{}'.format(errors[-1]))
    xy.set_ylabel('Cost')
    plt.show()

5、不同停止策略比较

主要模块都完成了，现在先来比较一下不同的停止策略之间有什么差别。为了排除不同梯度下降法的影响，我们采用相同的梯度下降法，这里采取批量梯度下降法来测试，即batch等于全部数据（batchSize=100）。

设定迭代次数：

指定迭代次数为10000，代码如下，

if __name__ == '__main__':
    #因为第一行就是数据了，所有，要指定header参数为None
    #为了方便后续数据处理，再给数据加个表头names
    lrData = pd.read_csv('LogiReg_data.csv', header=None, names=['Score1', 'Score2', 'PASS'])
    #因为theta0只是一个偏置量，所以，相当于x0=1，所以要插入一个值为1的列
    lrData.insert(0, 'Ones', 1)
    #将数据转为矩阵的格式
    lrData = lrData.as_matrix()
    #初始化theta
    theta = np.zeros([1, 3])
    #开始训练并显示出损失
    train(lrData, theta=theta, stopType=STOP_COUNT, batchSize=100, threshold=10000, learning_rate=0.001)

运行结果：

 可以看到，损失大概在0.585002。

根据损失值停止训练：

if __name__ == '__main__':
    #因为第一行就是数据了，所有，要指定header参数为None
    #为了方便后续数据处理，再给数据加个表头names
    lrData = pd.read_csv('LogiReg_data.csv', header=None, names=['Score1', 'Score2', 'PASS'])
    #因为theta0只是一个偏置量，所以，相当于x0=1，所以要插入一个值为1的列
    lrData.insert(0, 'Ones', 1)
    #将数据转为矩阵的格式
    lrData = lrData.as_matrix()
    #初始化theta
    theta = np.zeros([1, 3])
    #开始训练并显示出损失
    #设定迭代次数
    # train(lrData, theta=theta, stopType=STOP_COUNT, batchSize=100, threshold=10000, learning_rate=0.001)
    train(lrData, theta=theta, stopType=STOP_LOSS, batchSize=100, threshold=0.000001, learning_rate=0.001)

运行结果，

 

可以看到，这次迭代了109902次，损失大概在0.376925。比上次的损失小了很多。如果继续训练，损失应该还会更小的。

根据梯度变化停止训练：

代码如下：

if __name__ == '__main__':
    #因为第一行就是数据了，所有，要指定header参数为None
    #为了方便后续数据处理，再给数据加个表头names
    lrData = pd.read_csv('LogiReg_data.csv', header=None, names=['Score1', 'Score2', 'PASS'])
    #因为theta0只是一个偏置量，所以，相当于x0=1，所以要插入一个值为1的列
    lrData.insert(0, 'Ones', 1)
    #将数据转为矩阵的格式
    lrData = lrData.as_matrix()
    #初始化theta
    theta = np.zeros([1, 3])
    #开始训练并显示出损失
    #设定迭代次数
    # train(lrData, theta=theta, stopType=STOP_COUNT, batchSize=100, threshold=10000, learning_rate=0.001)
    # train(lrData, theta=theta, stopType=STOP_LOSS, batchSize=100, threshold=0.000001, learning_rate=0.001)
    train(lrData, theta=theta, stopType=STOP_GRAD, batchSize=100, threshold=0.005, learning_rate=0.001)

运行结果：

 

这次运行了1078181次，损失降到了0.222549.

那么，再来对比一下不同的梯度下降法的结果，为了对比各个梯度下降法的运行时间，修改一下train函数，打印一下运行时间，修改后的代码如下，

import time
#开始训练
def train(data, theta, stopType, batchSize, threshold, learning_rate):
    cur_time = time.time()
    theta, iterTime, errors = gradientDescent(data, theta, stopType, batchSize, threshold, learning_rate)
    sub_time = time.time() - cur_time
    print('theta:{}'.format(theta))
    print('iterTime:{}'.format(iterTime))
    print('sub_time:{}'.format(sub_time))
    print('last loss:{}'.format(errors[-1]))
    xy = plt.subplot()
    xy.plot(np.arange(len(errors)), errors, 'r')
    xy.set_xlabel('Iter Last Loss:{}'.format(errors[-1]))
    xy.set_ylabel('Cost')
    plt.show()

 

批量梯度下降法：

代码如下：

if __name__ == '__main__':
    #因为第一行就是数据了，所有，要指定header参数为None
    #为了方便后续数据处理，再给数据加个表头names
    lrData = pd.read_csv('LogiReg_data.csv', header=None, names=['Score1', 'Score2', 'PASS'])
    #因为theta0只是一个偏置量，所以，相当于x0=1，所以要插入一个值为1的列
    lrData.insert(0, 'Ones', 1)
    #将数据转为矩阵的格式
    lrData = lrData.as_matrix()
    #初始化theta
    theta = np.zeros([1, 3])
    #开始训练并显示出损失
    #设定迭代次数
    # train(lrData, theta=theta, stopType=STOP_COUNT, batchSize=100, threshold=10000, learning_rate=0.001)
    # train(lrData, theta=theta, stopType=STOP_LOSS, batchSize=100, threshold=0.000001, learning_rate=0.001)
    # train(lrData, theta=theta, stopType=STOP_GRAD, batchSize=100, threshold=0.005, learning_rate=0.001)
    train(lrData, theta=theta, stopType=STOP_COUNT, batchSize=100, threshold=100000, learning_rate=0.001)

运行结果：

损失大概为0.387388，用时14.78秒.

随机梯度下降法：

代码如下，

if __name__ == '__main__':
    #因为第一行就是数据了，所有，要指定header参数为None
    #为了方便后续数据处理，再给数据加个表头names
    lrData = pd.read_csv('LogiReg_data.csv', header=None, names=['Score1', 'Score2', 'PASS'])
    #因为theta0只是一个偏置量，所以，相当于x0=1，所以要插入一个值为1的列
    lrData.insert(0, 'Ones', 1)
    #将数据转为矩阵的格式
    lrData = lrData.as_matrix()
    #初始化theta
    theta = np.zeros([1, 3])
    #开始训练并显示出损失
    #设定迭代次数
    # train(lrData, theta=theta, stopType=STOP_COUNT, batchSize=100, threshold=10000, learning_rate=0.001)
    # train(lrData, theta=theta, stopType=STOP_LOSS, batchSize=100, threshold=0.000001, learning_rate=0.001)
    # train(lrData, theta=theta, stopType=STOP_GRAD, batchSize=100, threshold=0.005, learning_rate=0.001)
    # train(lrData, theta=theta, stopType=STOP_COUNT, batchSize=100, threshold=100000, learning_rate=0.001)
    train(lrData, theta=theta, stopType=STOP_COUNT, batchSize=1, threshold=100000, learning_rate=0.001)

 

可以看到，随机梯度下降波动很大，最后的结果也不好。我们可以将学习率调小一点看看，代码如下，

if __name__ == '__main__':
    #因为第一行就是数据了，所有，要指定header参数为None
    #为了方便后续数据处理，再给数据加个表头names
    lrData = pd.read_csv('LogiReg_data.csv', header=None, names=['Score1', 'Score2', 'PASS'])
    #因为theta0只是一个偏置量，所以，相当于x0=1，所以要插入一个值为1的列
    lrData.insert(0, 'Ones', 1)
    #将数据转为矩阵的格式
    lrData = lrData.as_matrix()
    #初始化theta
    theta = np.zeros([1, 3])
    #开始训练并显示出损失
    #设定迭代次数
    # train(lrData, theta=theta, stopType=STOP_COUNT, batchSize=100, threshold=10000, learning_rate=0.001)
    # train(lrData, theta=theta, stopType=STOP_LOSS, batchSize=100, threshold=0.000001, learning_rate=0.001)
    # train(lrData, theta=theta, stopType=STOP_GRAD, batchSize=100, threshold=0.005, learning_rate=0.001)
    # train(lrData, theta=theta, stopType=STOP_COUNT, batchSize=100, threshold=100000, learning_rate=0.001)
    train(lrData, theta=theta, stopType=STOP_COUNT, batchSize=1, threshold=100000, learning_rate=0.000001)

运行结果，

比上面的结果要好很多了，随机梯度下降法的特点就是训练速度很快，但是稳定性就比较差，而且需要很小的学习率。

小批量梯度下降法：

代码如下：

if __name__ == '__main__':
    #因为第一行就是数据了，所有，要指定header参数为None
    #为了方便后续数据处理，再给数据加个表头names
    lrData = pd.read_csv('LogiReg_data.csv', header=None, names=['Score1', 'Score2', 'PASS'])
    #因为theta0只是一个偏置量，所以，相当于x0=1，所以要插入一个值为1的列
    lrData.insert(0, 'Ones', 1)
    #将数据转为矩阵的格式
    lrData = lrData.as_matrix()
    #初始化theta
    theta = np.zeros([1, 3])
    #开始训练并显示出损失
    #设定迭代次数
    # train(lrData, theta=theta, stopType=STOP_COUNT, batchSize=100, threshold=10000, learning_rate=0.001)
    # train(lrData, theta=theta, stopType=STOP_LOSS, batchSize=100, threshold=0.000001, learning_rate=0.001)
    # train(lrData, theta=theta, stopType=STOP_GRAD, batchSize=100, threshold=0.005, learning_rate=0.001)
    # train(lrData, theta=theta, stopType=STOP_COUNT, batchSize=100, threshold=100000, learning_rate=0.001)
    # train(lrData, theta=theta, stopType=STOP_COUNT, batchSize=1, threshold=100000, learning_rate=0.001)
    train(lrData, theta=theta, stopType=STOP_COUNT, batchSize=30, threshold=100000, learning_rate=0.001)

 运行结果：

 

用时比批量梯度下降法少了大约一般，比随机梯度下降法用时稍多，但是损失也存在比较大的波动。

我们尝试将数据进行预处理，将数据按其属性（按列）减去其均值，然后除以其方差，最后的结果是，对于每个属性（每列）来说，所有的数据都聚集在0附近，方差为1。

我们先得安装一下sklearn库，执行以下命令，

sudo pip install sklearn

然后，代码如下，

if __name__ == '__main__':
    #因为第一行就是数据了，所有，要指定header参数为None
    #为了方便后续数据处理，再给数据加个表头names
    lrData = pd.read_csv('LogiReg_data.csv', header=None, names=['Score1', 'Score2', 'PASS'])
    #因为theta0只是一个偏置量，所以，相当于x0=1，所以要插入一个值为1的列
    lrData.insert(0, 'Ones', 1)
    #将数据转为矩阵的格式
    lrData = lrData.as_matrix()
    #预处理数据，第一列恒为1，所以不用预处理
    lrData[:, 1:3] = pp.scale(lrData[:, 1:3])
    #初始化theta
    theta = np.zeros([1, 3])
    #开始训练并显示出损失
    #设定迭代次数
    # train(lrData, theta=theta, stopType=STOP_COUNT, batchSize=100, threshold=10000, learning_rate=0.001)
    # train(lrData, theta=theta, stopType=STOP_LOSS, batchSize=100, threshold=0.000001, learning_rate=0.001)
    # train(lrData, theta=theta, stopType=STOP_GRAD, batchSize=100, threshold=0.005, learning_rate=0.001)
    # train(lrData, theta=theta, stopType=STOP_COUNT, batchSize=100, threshold=100000, learning_rate=0.001)
    # train(lrData, theta=theta, stopType=STOP_COUNT, batchSize=1, threshold=100000, learning_rate=0.000001)
    train(lrData, theta=theta, stopType=STOP_COUNT, batchSize=30, threshold=100000, learning_rate=0.001)

运行结果，

 

 这下曲线就很平滑了，而且，在很短时间内，迭代次数也比较小的情况下，得到了很不错的损失了。只迭代了十万次，得到的损失比上面迭代一百万次还小，而且时间也是远远小于上面的训练。可见，对数据进行预处理是非常高效的。

6、预测精度

最后，我们来看看模型训练的精度如何。使用上面小批量梯度下降法，且做了数据预处理的方法，代码如下，

 

#设定阈值
def predict(X, theta):
    return [1 if x >= 0.5 else 0 for x in model(X, theta)]

def test(X, theta):
    tmpX = X[:,:3]
    tmpY = X[:,3]
    pred = predict(tmpX, theta)
    correct = [1 if ((a == 1 and b == 1) or (a == 0 and b == 0)) else 0 for (a, b) in zip(pred, tmpY)]
    accuracy = (sum(map(int, correct)) % len(correct))
    print('accuracy = {0}%'.format(accuracy))

修改一下train函数，让它返回theta值，代码如下，

#开始训练
def train(data, theta, stopType, batchSize, threshold, learning_rate):
    cur_time = time.time()
    theta, iterTime, errors = gradientDescent(data, theta, stopType, batchSize, threshold, learning_rate)
    sub_time = time.time() - cur_time
    print('theta:{}'.format(theta))
    print('iterTime:{}'.format(iterTime))
    print('sub_time:{}'.format(sub_time))
    print('last loss:{}'.format(errors[-1]))
    xy = plt.subplot()
    xy.plot(np.arange(len(errors)), errors, 'r')
    xy.set_xlabel('Iter Last Loss:{}'.format(errors[-1]))
    xy.set_ylabel('Cost')
    # plt.show()
    return theta

然后，调用test函数，

if __name__ == '__main__':
    #因为第一行就是数据了，所有，要指定header参数为None
    #为了方便后续数据处理，再给数据加个表头names
    lrData = pd.read_csv('LogiReg_data.csv', header=None, names=['Score1', 'Score2', 'PASS'])
    #因为theta0只是一个偏置量，所以，相当于x0=1，所以要插入一个值为1的列
    lrData.insert(0, 'Ones', 1)
    #将数据转为矩阵的格式
    lrData = lrData.as_matrix()
    scaled_data = lrData.copy()
    #预处理数据，第一列恒为1，所以不用预处理
    lrData[:, 1:3] = pp.scale(lrData[:, 1:3])
    #初始化theta
    theta = np.zeros([1, 3])
    #开始训练并显示出损失
    #设定迭代次数
    # train(lrData, theta=theta, stopType=STOP_COUNT, batchSize=100, threshold=10000, learning_rate=0.001)
    # train(lrData, theta=theta, stopType=STOP_LOSS, batchSize=100, threshold=0.000001, learning_rate=0.001)
    # train(lrData, theta=theta, stopType=STOP_GRAD, batchSize=100, threshold=0.005, learning_rate=0.001)
    # train(lrData, theta=theta, stopType=STOP_COUNT, batchSize=100, threshold=100000, learning_rate=0.001)
    # train(lrData, theta=theta, stopType=STOP_COUNT, batchSize=1, threshold=100000, learning_rate=0.000001)
    theta = train(lrData, theta=theta, stopType=STOP_COUNT, batchSize=30, threshold=100000, learning_rate=0.001)
    test(lrData, theta)

运行结果，

 准确率为90% 。我试着将训练次数增加到100万，或者减小学习率，损失最低降到了0.203497，可能是训练的数据两不够大的原因吧，比较只有100个数据供训练。

完整代码如下，

#encoding:utf-8
import pandas as pd
import matplotlib.pyplot as plt
import numpy as np
import time
from sklearn import preprocessing as pp

#sigmoid函数
def sigmoid(z):
    return 1 / (1 + np.exp(-z))

#model函数
def model(X, theta):
    return sigmoid(np.dot(X, theta.T))

#损失函数cost
def cost(X, y, theta):
    left = np.multiply(y, np.log(model(X, theta)))
    right = np.multiply(1 - y, np.log(1 - model(X, theta)))
    return -np.sum(left + right) / len(X)

#计算梯度的函数
def gradient(X, y, theta):
    grad = np.zeros(theta.shape)
    error = (model(X, theta) - y).ravel()
    #求所有theta的梯度
    for i in range(len(theta.ravel())):
        term = np.multiply(error, X[:,i])
        grad[0, i] = np.sum(term) / len(X)
    return grad


#洗牌
def shuffle(data):
    np.random.shuffle(data)
    columns = data.shape[1]
    X = data[:, 0:columns-1]
    Y = data[:, columns-1:]
    return X, Y
#
# data = np.array([
#     [1, 2, 3],
#     [11, 12, 13],
#     [21, 22, 23],
#     [31, 32, 33],
#     [41, 42, 43],
# ])
#
# x, y = shuffle(data)
# print(x)
# print('------')
# print(y)

#停止策略
#设定迭代次数
STOP_COUNT = 1
#根据损失值停止训练
STOP_LOSS = 2
#根据梯度变化停止训练
STOP_GRAD = 3


def stopTrain(type, value, threshold):
    if type == STOP_COUNT:
        return value > threshold
    elif type == STOP_LOSS:
        return abs(value[-1] - value[-2]) < threshold
    elif type == STOP_GRAD:
        return np.linalg.norm(value) < threshold
    else:
        return False



#梯度下降法
#data : 数据  theta：系数  stopType：停止策略  batchSize：batch大小
#threshold：阈值  learning_rate：步长/学习率
def gradientDescent(data, theta, stopType, batchSize, threshold, learning_rate):
    #迭代次数
    iterTime = 0
    #batch 下标
    batchIndex = 0
    #对数据洗牌
    X, y = shuffle(data)
    #损失
    errors = [cost(X, y, theta)]

    while True:
        #计算梯度
        grad = gradient(X[batchIndex:batchIndex+batchSize], y[batchIndex:batchIndex+batchSize], theta)

        #更新参数
        theta = theta - learning_rate * grad
        #调整下标
        batchIndex += batchSize
        #迭代次数加一
        iterTime += 1
        #记录下损失值
        errors.append(cost(X, y, theta))
        if batchIndex >= len(X):
            batchIndex = 0
            # 重新对数据洗牌
            X, y = shuffle(data)

        if stopType == STOP_COUNT:
            value = iterTime
        elif stopType == STOP_LOSS:
            value = errors
        elif stopType == STOP_GRAD:
            value = grad
        else:
            stopType = STOP_COUNT
            value = iterTime

        if stopTrain(stopType, value, threshold):
            break
    return theta, iterTime, errors

#开始训练
def train(data, theta, stopType, batchSize, threshold, learning_rate):
    cur_time = time.time()
    theta, iterTime, errors = gradientDescent(data, theta, stopType, batchSize, threshold, learning_rate)
    sub_time = time.time() - cur_time
    print('theta:{}'.format(theta))
    print('iterTime:{}'.format(iterTime))
    print('sub_time:{}'.format(sub_time))
    print('last loss:{}'.format(errors[-1]))
    xy = plt.subplot()
    xy.plot(np.arange(len(errors)), errors, 'r')
    xy.set_xlabel('Iter Last Loss:{}'.format(errors[-1]))
    xy.set_ylabel('Cost')
    # plt.show()
    return theta

#设定阈值
def predict(X, theta):
    return [1 if x >= 0.5 else 0 for x in model(X, theta)]

def test(X, theta):
    tmpX = X[:,:3]
    tmpY = X[:,3]
    pred = predict(tmpX, theta)
    correct = [1 if ((a == 1 and b == 1) or (a == 0 and b == 0)) else 0 for (a, b) in zip(pred, tmpY)]
    accuracy = (sum(map(int, correct)) % len(correct))
    print('accuracy = {0}%'.format(accuracy))
#
if __name__ == '__main__':
    #因为第一行就是数据了，所有，要指定header参数为None
    #为了方便后续数据处理，再给数据加个表头names
    lrData = pd.read_csv('LogiReg_data.csv', header=None, names=['Score1', 'Score2', 'PASS'])
    #因为theta0只是一个偏置量，所以，相当于x0=1，所以要插入一个值为1的列
    lrData.insert(0, 'Ones', 1)
    #将数据转为矩阵的格式
    lrData = lrData.as_matrix()
    scaled_data = lrData.copy()
    #预处理数据，第一列恒为1，所以不用预处理
    lrData[:, 1:3] = pp.scale(lrData[:, 1:3])
    #初始化theta
    theta = np.zeros([1, 3])
    #开始训练并显示出损失
    #设定迭代次数
    # train(lrData, theta=theta, stopType=STOP_COUNT, batchSize=100, threshold=10000, learning_rate=0.001)
    # train(lrData, theta=theta, stopType=STOP_LOSS, batchSize=100, threshold=0.000001, learning_rate=0.001)
    # train(lrData, theta=theta, stopType=STOP_GRAD, batchSize=100, threshold=0.005, learning_rate=0.001)
    # train(lrData, theta=theta, stopType=STOP_COUNT, batchSize=100, threshold=100000, learning_rate=0.001)
    # train(lrData, theta=theta, stopType=STOP_COUNT, batchSize=1, threshold=100000, learning_rate=0.000001)
    theta = train(lrData, theta=theta, stopType=STOP_COUNT, batchSize=100, threshold=1000000, learning_rate=0.001)
    test(lrData, theta)

 

如果您感觉本篇博客对您有帮助，请打开支付宝，领个红包支持一下，祝您扫到99元，谢谢～～

__Fang Wei__
关注
专栏目录
逻辑回归算法与案例实战
qq_38290604的博客
05-15 1319
逻辑回归算法虽然名字听起来是一种回归算法，但是其本质确是一种分类算法。逻辑回归算法适用于二分类问题，它的本质是将预测值控制在0到1之间，对于大于0.5的结果归为类别1，对于小于0.5的结果归为0类。 Logistic回归与单位阶跃函数 由于逻辑回归的输出值要控制在0和1之间，而线性回归模型产生的预测值却是一个的实值，于是我们要将值转化为0到1之间的值。单位阶跃函数是一种理想的输出值在0到1之间...
回归算法实战_逻辑回归（Logistic Regression)
weixin_39612057的博客
12-16 167
一、Logistic回归概述 Logistic回归是一种分类方法，主要的思想是：根据现有的数据对分类边界线建立回归公式，找到最佳拟合参数集，从而实现最终的分类。相较于其他分类算法，Logistic算法实现代价小，也易于理解，但是容易发生欠拟合的情况。 一般过程分为： 1）收集准备数据：数据最好为可以"结构化数据"形式呈现的数据； 2）分析数据：描述性统计等方式了解数据的基...
《机器学习实战》Logistic回归算法（1）
热门推荐
Thinkgamer博客
04-25 2万+
转载请注明出处：http://blog.csdn.net/gamer_gyt 博主微博：http://weibo.com/234654758 Github：https://github.com/thinkgamer ================================================================= 《机器学习实战》系列博客是博主阅读《机器学习...
算法实战（一）
最新发布
CPanMirai的博客
01-09 506
基础算法编程
回归算法实战_2020年阿里最令人惊艳的，Python人工智能实战手册，全网首次公开...
weixin_39760295的博客
12-07 113
本书主要面向对人工智能、机器学习、数据分析等方面有强烈兴趣的初学者和爱好者，通过本书的学习，读者能够掌握机器学习中经典算法原理推导、整体流程以及其中数学公式与各种参数的作用。案例全部采用当下流行的Python语言，从最基础的工具包开始讲起，让大家熟练使用Python及其数据科学工具包进行机器学习和数据挖掘领域的项目实战任务，并处理其中遇到的种种问题。第1部分介绍了Python的工具包，包括科学计算...
机器学习算法实战——线性回归算法
06-19
各类算法是机器学习的一个入门要点。本课程详细讲解了线性回归算法的原理，推导过程、相关扩展方法和代码实战，并为数学基础不牢的入门人群复习所需要的数学知识，辅以多个代码实战，帮助您深入理解线性回归算法。
5.机器学习入门（五）回归算法实战分析一 训练数据
10-28
5.机器学习入门（五）回归算法实战分析一 训练数据，5.机器学习入门（五）回归算法实战分析一 训练数据
《人工智能之机器学习入门到实战》电子书
11-17
《人工智能之机器学习入门到实战》是一本专为初学者设计的教材，旨在引领读者从基础知识出发，逐步深入到实际应用领域，全面了解并掌握机器学习的核心概念和技术。这本书覆盖了从理论到实践的广泛话题，是理解人工...
机器学习实战 - k近邻算法（KNN算法）总结
04-12
适合机器学习实战入门新手 K-近邻算法，又称为 KNN 算法，是数据挖掘技术中原理最简单的算法。 KNN 的工作原理：给定一个已知类别标签的数据训练集，输入没有标签的新数据后，在训练数据集中找到与新数据最临近的 K ...
模式识别与机器学习实战 - KNN算法python实现 - 简单入门 -内含数据集和源码
01-10
KNN算法是一种监督学习方法，常用于分类和回归问题，尤其适合初学者入门。这里我们将通过Python编程语言来实践KNN算法，并结合实际案例进行演示。 首先，我们关注的案例之一是"约会网站配对"。在这个问题中，我们...
一篇搞定你的回归算法之实战篇
weixin_38834436的博客
03-29 502
啊
Java算法实战
林紫晗的博客
09-19 724
题目有这个一个9位数 它由123456789组成，每个数字出现仅且出现一次，数字的前一位能被1整除，前2位能被2整除。。。。前9位能被9整除，求这个数字。 解析首先，我们根据题目可以获得这些信息。 1. 这是个九位数，由123456789组成 2. 每个数字出现仅且出现一次 3. 数字的前一位能被1整除，前2位能被2整除。。。。前9位能被9整除。 那么我们先罗列出由123456789组成
数据结构和算法-算法实战
hixiaoxiaoniao的专栏
04-13 317
算法实战
算法实践（一）
linweiyanmadepeng的专栏
01-28 406
首先看第一个问题：输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字，例如，如果输入如下4 X 4矩阵： 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 ，则依次打印出数字 1,2,3,4,8,12,16,15,14,13,9,5,6,7,11,10. public class Solution {    public ArrayList print...
【模拟】算法实战
大三小白C++进阶之路
08-30 583
模拟算法的算法原理及其leetcode题目实战。
推荐算法实战
hadxu的博客
10-18 1430
推荐算法实战 本文基于《集体智慧编程》的第二章，提供推荐的一篇文章，不得不说，这本书真的很好，在写这一篇文章的时候，我已经看到优化那一章，单单从优化角度来讲，特别清晰，从最简单的随机优化开始，讲述了爬山法，到模拟退火算法，到最为流行的遗传算法，感觉很有必要将学习的过程记录下来，便于我，或初学者来进入机器学习领域。 1.协作性过滤     随着社会的发展，根据群体偏好来为人们提供推荐显得越来越
分治算法实战
实践求真知
03-29 363
一 分治算法介绍 1 分治法是一种很重要的算法 字面上的解释是“分而治之，就是把一个复杂的问题分成两个或更多的相同或相似的子问题，再把子问题分成更小的子问题……，直到最后子问题可以简单的直接求解，原问题的解即子问题的解的合并。这个技巧是很多高效算法的基础，如排序算法(快速排序，归并排序)，傅立叶变换(快速傅立叶变换)…… 2 分治算法可以求解的一些经典问题 二分搜索 大整数乘法 棋盘覆盖 合并排序 快速排序 线性时间选择 最接近点对问题
初级脚本算法编程实战
jinggaoniao的博客
07-30 228
1、翻转字符串算法挑战 function reverseString(str) { var strarr = str.split(""); strarr = strarr.reverse(); str = strarr.join(""); return str; } reverseString("hello"); 2、阶乘算法挑战 function factorialize(num) { if(num <= 1) return 1; return num*factorialize(
Python机器学习入门：实战六大算法详解
本文档是一份全面的机器学习算法总结，涵盖了机器学习的基本概念、常用算法及其应用、评估指标以及Python编程实践。首先，文章从基础入手，详细解释了机器学习的几个核心概念，包括： 1. 常用算法：涵盖了线性回归...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值