机器学习实战　logistic回归

logistic回归

梯度上升法

import numpy as np 

"""
function:
    加载数据
parameter:
    无
returns:
    dataMat - 数据集
    labelMat - 标签集
"""
def loadDataSet():
    dataMat = []#数据集
    labelMat = []#标签集
    fr = open('testSet.txt')
    for line in fr.readlines():
        lineArr = line.strip().split()
        dataMat.append([1.0, float(lineArr[0]), float(lineArr[1])])
        labelMat.append(int(lineArr[2]))
    return dataMat, labelMat 

"""
function:
    计算sigmoid函数
parameters:
    inX - 变量
return:
    ans - 结果
"""
def sigmoid(inX):
    ans = 1.0 / (1+np.exp(-inX))
    return ans

"""
function:
    梯度上升
parameters:
    dataMatIn - 数据集
    classLabels - 标签集
return:
    weights - 最优参数
"""
def gradAscent(dataMatIn, classLabels):
    dataMatrix = np.mat(dataMatIn)
    labelMat = np.mat(classLabels).transpose()#矩阵转置
    m,n = np.shape(dataMatrix)
    alpha = 0.001#步长
    maxCycles = 500#迭代次数
    weights = np.ones((n,1))
    for k in range(maxCycles):
        h = sigmoid(dataMatrix * weights)#100*3矩阵和100*1矩阵*乘，而不是dot乘
        error = labelMat - h#这里labelMat广播了
        weights = weights + alpha * dataMatrix.transpose() * error
    return weights 

if __name__ == "__main__":
    dataArr, labelMat = loadDataSet()
    w = gradAscent(dataArr,labelMat)
    print(w)

做图

import numpy as np
import matplotlib.pyplot as plt

"""
function:
    加载数据
parameter:
    无
returns:
    dataMat - 数据集
    labelMat - 标签集
"""
def loadDataSet():
    dataMat = []#数据集
    labelMat = []#标签集
    fr = open('testSet.txt')
    for line in fr.readlines():
        lineArr = line.strip().split()
        dataMat.append([1.0, float(lineArr[0]), float(lineArr[1])])
        labelMat.append(int(lineArr[2]))
    return dataMat, labelMat 

"""
function:
    计算sigmoid函数
parameters:
    inX - 变量
return:
    ans - 结果
"""
def sigmoid(inX):
    ans = 1.0 / (1+np.exp(-inX))
    return ans

"""
function:
    梯度上升
parameters:
    dataMatIn - 数据集
    classLabels - 标签集
return:
    weights - 最优参数
"""
def gradAscent(dataMatIn, classLabels):
    dataMatrix = np.mat(dataMatIn)
    labelMat = np.mat(classLabels).transpose()#矩阵转置
    m,n = np.shape(dataMatrix)
    alpha = 0.001#步长
    maxCycles = 500#迭代次数
    weights = np.ones((n,1))
    for k in range(maxCycles):
        h = sigmoid(dataMatrix * weights)#100*3矩阵和100*1矩阵*乘，而不是dot乘
        error = labelMat - h#这里labelMat广播了
        weights = weights + alpha * dataMatrix.transpose() * error
    return weights 

"""
function:
    做图
parameters:
    dataMat - 数据集
    weights - 系数
return:
    无
"""
def plotBestFit(dataMat,weights):
    dataMatrix = np.array(dataMat)
    x1 = dataMatrix[0:,1]
    y1 = dataMatrix[0:,2]
    plt.scatter(x1,y1,s=25,marker='o')
    plt.xlim([-4,4])
    plt.ylim([-5,20])
    x2 = np.arange(-3.0, 3.0, 0.1)
    y2 = (-weights[0]-weights[1]*x2)/weights[2]
    y2 = y2.T
    plt.plot(x2,y2)
    plt.show()

if __name__ == "__main__":
    dataMat, labelMat = loadDataSet()
    weights = gradAscent(dataMat,labelMat)
    plotBestFit(dataMat,weights)

随机梯度上升

import numpy as np
import matplotlib.pyplot as plt

"""
function:
    加载数据
parameter:
    无
returns:
    dataMat - 数据集
    labelMat - 标签集
"""
def loadDataSet():
    dataMat = []#数据集
    labelMat = []#标签集
    fr = open('testSet.txt')
    for line in fr.readlines():
        lineArr = line.strip().split()
        dataMat.append([1.0, float(lineArr[0]), float(lineArr[1])])
        labelMat.append(int(lineArr[2]))
    return dataMat, labelMat 

"""
function:
    计算sigmoid函数
parameters:
    inX - 变量
return:
    ans - 结果
"""
def sigmoid(inX):
    ans = 1.0 / (1+np.exp(-inX))
    return ans

"""
function:
    梯度上升
parameters:
    dataMatIn - 数据集
    classLabels - 标签集
return:
    weights - 最优参数
"""
def gradAscent(dataMatIn, classLabels):
    dataMatrix = np.mat(dataMatIn)
    labelMat = np.mat(classLabels).transpose()#矩阵转置
    m,n = np.shape(dataMatrix)
    alpha = 0.001#步长
    maxCycles = 500#迭代次数
    weights = np.ones((n,1))
    for k in range(maxCycles):
        h = sigmoid(dataMatrix * weights)#100*3矩阵和100*1矩阵*乘，而不是dot乘
        error = labelMat - h#这里labelMat广播了
        weights = weights + alpha * dataMatrix.transpose() * error
    return weights 

"""
function:
    做图
parameters:
    dataMat - 数据集
    weights - 系数
return:
    无
"""
def plotBestFit(dataMat,weights):
    dataMatrix = np.array(dataMat)
    x1 = dataMatrix[0:,1]
    y1 = dataMatrix[0:,2]
    plt.scatter(x1,y1,s=25,marker='o')
    plt.xlim([-4,4])
    plt.ylim([-5,20])
    x2 = np.arange(-3.0, 3.0, 0.1)
    y2 = (-weights[0]-weights[1]*x2)/weights[2]
    y2 = y2.T
    plt.plot(x2,y2)
    plt.show()

"""
function:
    随机梯度上升
parameters:
    dataMatrix - 数据集
    classLabels - 标签集
return:
    weights - 参数
"""
def stocGradAscent0(dataMatrix, classLabels):
    m, n = np.shape(dataMatrix)
    alpha = 0.01
    weights = np.ones(n)
    for i in range(m):
        h = sigmoid(sum(dataMatrix[i]*weights))
        error = classLabels[i] - h
        weights = weights + alpha * error * dataMatrix[i]
    return weights 

if __name__ == "__main__":
    dataArr, labelMat = loadDataSet()
    weights = stocGradAscent0(np.array(dataArr),labelMat)
    plotBestFit(dataArr,weights)

随机梯度上升改进

import numpy as np
import matplotlib.pyplot as plt

"""
function:
    加载数据
parameter:
    无
returns:
    dataMat - 数据集
    labelMat - 标签集
"""
def loadDataSet():
    dataMat = []#数据集
    labelMat = []#标签集
    fr = open('testSet.txt')
    for line in fr.readlines():
        lineArr = line.strip().split()
        dataMat.append([1.0, float(lineArr[0]), float(lineArr[1])])
        labelMat.append(int(lineArr[2]))
    return dataMat, labelMat 

"""
function:
    计算sigmoid函数
parameters:
    inX - 变量
return:
    ans - 结果
"""
def sigmoid(inX):
    ans = 1.0 / (1+np.exp(-inX))
    return ans

"""
function:
    梯度上升
parameters:
    dataMatIn - 数据集
    classLabels - 标签集
return:
    weights - 最优参数
"""
def gradAscent(dataMatIn, classLabels):
    dataMatrix = np.mat(dataMatIn)
    labelMat = np.mat(classLabels).transpose()#矩阵转置
    m,n = np.shape(dataMatrix)
    alpha = 0.001#步长
    maxCycles = 500#迭代次数
    weights = np.ones((n,1))
    for k in range(maxCycles):
        h = sigmoid(dataMatrix * weights)#100*3矩阵和100*1矩阵*乘，而不是dot乘
        error = labelMat - h#这里labelMat广播了
        weights = weights + alpha * dataMatrix.transpose() * error
    return weights 

"""
function:
    做图
parameters:
    dataMat - 数据集
    weights - 系数
return:
    无
"""
def plotBestFit(dataMat,weights):
    dataMatrix = np.array(dataMat)
    x1 = dataMatrix[0:,1]
    y1 = dataMatrix[0:,2]
    plt.scatter(x1,y1,s=25,marker='o')
    plt.xlim([-4,4])
    plt.ylim([-5,20])
    x2 = np.arange(-3.0, 3.0, 0.1)
    y2 = (-weights[0]-weights[1]*x2)/weights[2]
    y2 = y2.T
    plt.plot(x2,y2)
    plt.show()

"""
function:
    随机梯度上升
parameters:
    dataMatrix - 数据集
    classLabels - 标签集
return:
    weights - 参数
"""
def stocGradAscent0(dataMatrix, classLabels):
    m, n = np.shape(dataMatrix)
    alpha = 0.01
    weights = np.ones(n)
    for i in range(m):
        h = sigmoid(sum(dataMatrix[i]*weights))
        error = classLabels[i] - h
        weights = weights + alpha * error * dataMatrix[i]
    return weights 

"""
function:
    随机梯度上升改进
parameters:
    dataMatrix - 数据集
    classLabels - 标签集
    numIter - 迭代次数
return:
    weights - 参数
"""
def stocGradAscent1(dataMatrix, classLabels, numIter=150):
    m,n = np.shape(dataMatrix)
    weights = np.ones(n)
    for j in range(numIter):
        dataIndex = list(range(m))
        for i in range(m):
            alpha = 4 / (1.0+j+i)+0.01
            randIndex = int(np.random.uniform(0,len(dataIndex)))
            h = sigmoid(sum(dataMatrix[randIndex]*weights))
            error = classLabels[randIndex] - h
            weights = weights + alpha * error * dataMatrix[randIndex]
            del(dataIndex[randIndex])
    return weights 

if __name__ == "__main__":
    dataArr, labelMat = loadDataSet()
    weights = stocGradAscent1(np.array(dataArr),labelMat)
    plotBestFit(dataArr,weights)

从疝气病预测病马的死亡率

import numpy as np 

"""
function:
    计算sigmoid函数
parameters:
    inX - 变量
return:
    ans - 结果
"""
def sigmoid(inX):
    ans = 1.0 / (1+np.exp(-inX))
    return ans

"""
function:
    随机梯度上升改进
parameters:
    dataMatrix - 数据集
    classLabels - 标签集
    numIter - 迭代次数
return:
    weights - 参数
"""
def stocGradAscent1(dataMatrix, classLabels, numIter=150):
    m,n = np.shape(dataMatrix)
    weights = np.ones(n)
    for j in range(numIter):
        dataIndex = list(range(m))
        for i in range(m):
            alpha = 4 / (1.0+j+i)+0.01
            randIndex = int(np.random.uniform(0,len(dataIndex)))
            h = sigmoid(sum(dataMatrix[randIndex]*weights))
            error = classLabels[randIndex] - h
            weights = weights + alpha * error * dataMatrix[randIndex]
            del(dataIndex[randIndex])
    return weights 

"""
function:
    分类器
parameters:
    inX - 待分类向量
    weights - 参数
returns:
    分类结果
"""
def classifyVector(inX, weights):
    prob = sigmoid(sum(inX*weights))
    if prob > 0.5:
        return 1.0
    else:
        return 0.0

"""
function:
    整个计算流程
parameters:
    无
returns:
    erroRate - 错误率
"""
def colicTest():
    frTrain = open('horseColicTraining.txt')
    frTest = open('horseColicTest.txt')
    trainingSet = []
    trainingLabels = []
    for line in frTrain.readlines():
        currLine = line.strip().split('\t')
        lineArr = []
        for i in range(21):
            lineArr.append(float(currLine[i]))
        trainingSet.append(lineArr)
        trainingLabels.append(float(currLine[21]))
    trainWeights = stocGradAscent1(np.array(trainingSet),trainingLabels,500)
    errorCount = 0
    numTestVec = 0.0
    for line in frTest.readlines():
        numTestVec += 1.0
        currLine = line.strip().split('\t')
        lineArr = []
        for i in range(21):
            lineArr.append(float(currLine[i]))
        if (int(classifyVector(np.array(lineArr), trainWeights)) !=
                int(currLine[21])):
            errorCount += 1
    errorRate = (float(errorCount) / numTestVec)
    print("the error rate of this test is: %f" % errorRate)
    return errorRate 

def multiTest():
    numTests = 10
    errorSum = 0.0
    for k in range(numTests):
        errorSum += colicTest()
    print("after %d itrations the average error rate is: %f" % (numTests,errorSum/float(numTests)))

if __name__ == "__main__":
    multiTest()

原文地址：https://www.cnblogs.com/w-j-c/p/10483122.html

时间： 2024-08-28 22:05:42

机器学习实战　logistic回归的相关文章

机器学习实战——Logistic回归

回归概述(个人理解的总结) 回归是数学中的一种模拟离散数据点的数学模型的方法,拟合一个连续的函数从而可以对未知的离散数据点进行分类或预测.这种方法有一个统一的形式,给定n维特征的数据集合,对任意一个数据点Xi={x(1)i,x(2)i,...,x(n)i}的每个维度都有一个回归系数wi与之对应,整个模型就存在一个系数向量w={w1,w2...wn}.如果是系数向量w与特征Xi的线性组合,那么就是一个n空间下的超平面,如果对应分类问题,那么这个超平面就是分类器的决策平面(分类超平面).由于线性组合

[机器学习实战] Logistic回归

1. Logistic回归: 1)优点:计算代价不高,易于理解和实现: 2)缺点:容易欠拟合,分类精度可能不高: 3)适用数据类型:数值型和标称型数据: 2. 分类思想: 根据现有数据对分类边界线建立回归公式,以此进行分类. 这里借助sigmoid函数,其特点为当z为0时,sigmoid函数值为0.5:随着z的增大,对应的sigmoid值将逼近1: 而随着z的减小,sigmoid值将逼近0. σ(z) = 1/(1 + e-z) 上述 z = w0x0 + w1x1 + w2x2 + ....

机器学习实战 logistic回归 python代码

# -*- coding: utf-8 -*- """ Created on Sun Aug 06 15:57:18 2017 @author: mdz """ '''http://blog.chinaunix.net/xmlrpc.php?r=blog/article&uid=9162199&id=4223505''' import numpy as np #读取数据 def loadDataSet(): dataList=[]

机器学习实战-逻辑回归

什么是回归? 假设现在有些数据点,我用直线对这些点进行拟合(该线叫做最佳拟合直线),这个拟合的过程就叫做回归. Logistic回归? 这里,Logistic回归进行分类的主要思想:根据现有数据对分类的边界线建立回归公式,以此边界线进行分类.这里的回归指的是最佳拟合,就是要找到边界线的回归公式的最佳拟合的参数集.训练时使用最优化算法寻找最佳拟合参数. 基于Logistic回归和Sigmoid函数的分类对于边界线建立的回归函数,能够接受所有的输入然后预测出类别.例如,对于二分类的情况下,上述函数

机器学习之logistic回归与分类

logistic回归与分类是一种简单的分类算法.在分类的过程中只需要找到一个划分不同类的权重向量即可,对新的数据只需要乘上这个向量并比较就可以得到分类.比如下图的二分类问题: 每个样本点可以看成包含两个特征(x1,x2),现在需要把他们分开,如果这是训练集,他们本身属于哪一个类是已知的,比如说蓝色的属于0类,红色的属于1类,现在我们想通过这些数据建立一个分类标准可以将他们分开,这样再来了一个不知道类别的数据,我们看看这个标准就知道他是属于哪一类的. 像上面这个线性的,那么我们可以建立一个函数模型

机器学习笔记—Logistic回归

本文申明:本系列笔记全部为原创内容,如有转载请申明原地址出处.谢谢序言:what is logistic regression? Logistics 一词表示adj.逻辑的;[军]后勤学的n.[逻]数理逻辑;符号逻辑;[军]后勤学, “回归”是由英国著名生物学家兼统计学家高尔顿在研究人类遗传问题时提出来的.为了研究父代与子代身高的关系,高尔顿搜集了1078对父亲及其儿子的身高数据.他发现这些数据的散点图大致呈直线状态,也就是说,总的趋势是父亲的身高增加时,儿子的身高也倾向于增加.但是,高尔顿对

机器学习算法-logistic回归算法

Logistic回归算法调试一.算法原理 Logistic回归算法是一种优化算法,主要用用于只有两种标签的分类问题.其原理为对一些数据点用一条直线去拟合,对数据集进行划分.从广义上来讲这也是一种多元线性回归方法,所不同的是这种算法需要找出的是能够最大可能地将两个类别划分开来而不是根据直线关系预测因变量的值.Logistic回归算法的核心部分是sigmoid函数: 其中,xi为数据集的第i个特征.定义损失函数损失函数: 损失函数越小表明曲线拟合的效果就越好.利用梯度向上法更新x的系数W,求出W的

机器学习：logistic回归

逻辑回归是一个形式是Y=1/(1+E(-X))的函数,它的特点是: 1, 当X>0,随着X增大,Y很快的接近1: 2,当x<0,随着X的减小,Y很快的接近0: 3,当X=0时,Y=1/2. 由于逻辑回归的这种特性(在0-1之间连续),它被用来判断一个学习算法是否正确. 除了正确和不正确的结果之外,使用逻辑回归的好处在于,它还能告诉你,你离正确的结果还差多少,从而引导你向正确的方向前进.因此它常常和梯度上升的算法结合起来.下面的代码体现了这样的例子: 输入参数1是100行,2列的矩阵: 输入参数

机器学习实战-Logistics回归

Logistics回归:实战,有两个特征X0,X1.100个样本,进行Logistics回归 1.导入数据 1 def load_data_set(): 2 """ 3 加载数据集 4 :return:返回两个数组,普通数组 5 data_arr -- 原始数据的特征 6 label_arr -- 原始数据的标签,也就是每条样本对应的类别 7 """ 8 data_arr=[] 9 label_arr=[] 10 f=open('TestSet.

机器学习day14 机器学习实战树回归之CART与模型树

这几天完成了树回归的相关学习,这一部分内容挺多,收获也挺多,刚刚终于完成了全部内容,非常开心. 树回归这一章涉及了CART,CART树称作(classify and regression tree) 分类与回归树,既可以用于分类,也可以用于回归.这正是前面决策树没有说到的内容,在这里补充一下.正好也总结一下我们学的3种决策树. ID3:用信息增益来选择特性进行分类,只能处理分类问题.缺点是往往偏向于特性种类多的特性进行分解,比如特性A有2种选择,特性B有3种选择,混乱度差不多的情况下,ID3会偏

机器学习实战 logistic回归