精华内容
下载资源
问答
  • 调用sklearn.linear_model中的LogisticRegression库,尝试通过对率回归对离散数据进行划分,对每个属性进行预测,选取正确率最大的属性作为根节点,并对该节点的每个属性取值进行划分选择,依此类推,最终绘制一棵...
  • 习题3.3 编程实现对率回归,并给出西瓜数据集3.0a上的结果。
  • 使用10折交叉验证法和留一法评测对率回归分类器标题有点长哈……这是第一次作业,来自周志华《机器学习》作业3.4,题目如下: 选择两个UCI数据集,比较10折交叉验证法和留一法所估计出的对率回归(逻辑回归)的错误...

    使用10折交叉验证法和留一法评测对率回归分类器

    标题有点长哈……这是第一次作业,来自周志华《机器学习》作业3.4,题目如下:

    选择两个UCI数据集,比较10折交叉验证法和留一法所估计出的对率回归(逻辑回归)的错误率。

    那么,首先下载数据。实验中我使用的是 IrisWine 这两个数据集,前者简单点,后者复杂点。要注意的是,这两个数据集都是3个分类,为了偷个懒,我就把第三个分类删了,保留前两个分类。

    分类器

    对率回归分类器还是很简单的,大体思路如下:

    假设输入数据维度 m,我们保存一个权重向量,在计算的时候直接计算 m 和权重向量的点积,然后将点积结果加上偏置值,最后将计算结果通过 Sigmoid 函数,并输出预测结果。

    为了方便起见,可以把偏置值一起放到权重向量中去,此时只要在数据中加上常数1即可,设加上常数以后的数据维度为 m + 1,则权重向量维度也为 m + 1。接下来给出损失函数如下。关于该函数的推导过程,斯坦福大学机器学习课程–逻辑回归算法 这篇博文已经写的非常详细了,大家可以直接看看。

    L(θ)=1mi=1m[yilogh0(xi)+(1yi)log(1h0(xi))]

    那么,现在的目标是使得损失函数最小,因为损失函数越小代表着我们模型的预测结果越准确。接下来使用梯度下降法,基本思想是:在损失函数的结果中,对权重向量的每个元素求偏导,并按照比例(学习速率)对权重进行修改。这样一来,权重将向着减少损失函数值的方向发展。具体的推导过程同样可见上面那篇博文。分类器代码如下:

    import numpy as np
    
    class Classifier(object):
        def __init__(self, attr_count, learn_rate=0.05):
            self.__attr_count__ = attr_count
            self.__learn_rate__ = learn_rate
            self.__weight__ = np.zeros(shape=[attr_count + 1], dtype=np.float32)
    
        def fit(self, value, label):
            value = np.append(value, [1.0])
            linear_result = np.dot(value, self.__weight__)
            sigmoid_result = 1.0 / (np.exp(-linear_result) + 1.0)
            for idx in range(self.__attr_count__ + 1):
                update_val = (sigmoid_result - label) * value[idx]
                self.__weight__[idx] -= self.__learn_rate__ * update_val
    
        def classify(self, value):
            value = np.append(value, [1.0])
            linear_result = np.dot(value, self.__weight__)
            if (1.0 / (np.exp(-linear_result) + 1.0)) > 0.5:
                return 1
            else:
                return 0
    

    准备数据

    训练数据的准备很简单,直接使用 Python 的文件操作,读入数据文件即可。其中涉及到一些数组的切片操作,为了提高学习效率,在训练之前使用 numpy 打乱了数据集。

    if __name__ == '__main__':
        # 读入并打乱 Wine 数据集
        data_str = open('Data/wine.data').readlines()
        np.random.shuffle(data_str)
        # 使用数组切片操作,分离数据和标签
        wine_value = np.ndarray([len(data_str), 13], np.float32)
        wine_label = np.ndarray([len(data_str)], np.int32)
        for outer_idx in range(len(data_str)):
            data = data_str[outer_idx].strip('\n').split(',')
            wine_value[outer_idx] = data[1:]
            wine_label[outer_idx] = data[0]
        # 进行训练和测试
        test_main(wine_value, wine_label, 13)

    训练和验证

    因为之前的分类器已经提供好了训练和测试的函数,所以直接调用即可。接下来使用10折交叉验证法和留一法进行验证。
    10折交叉验证法:将数据等分为10份,每次用其中9份训练,剩下1份测试,然后统计10次测试的评价错误率。
    留一法:将数据分为 k 份(k为数据大小),每次用 k - 1 条数据训练,用1条测试,统计总体错误率。
    使用简单的循环语句即可实现上述方法:

    def test_main(value, label, attr_count):
        batch_size = len(value) // 10
        total_correct_times = 0
        for idx in range(10):
            print('10折交叉验证:当前第 %d 次' % (idx + 1))
            correct_times = 0
            classifier = LinearClassifier.Classifier(attr_count)
            value_train = np.append(value[0:idx * batch_size], value[(idx + 1) * batch_size:], axis=0)
            label_train = np.append(label[0:idx * batch_size], label[(idx + 1) * batch_size:], axis=0)
            value_test = value[idx * batch_size:(idx + 1) * batch_size]
            label_test = label[idx * batch_size:(idx + 1) * batch_size]
            for repeat in range(TRAIN_TIMES):
                for sub_idx in range(len(value_train)):
                    classifier.fit(value_train[sub_idx], label_train[sub_idx])
            for sub_idx in range(len(value_test)):
                result = classifier.classify(value_test[sub_idx])
                if result == label_test[sub_idx]:
                    correct_times += 1
            total_correct_times += correct_times
            print('准确率:%.2f%%\n' % (correct_times * 100 / len(value_test)))
        print('10折交叉验证结束,平均准确率:%.2f%%\n' % (total_correct_times * 100 / len(value)))
        total_times = len(value)
        correct_times = 0
        for idx in range(total_times):
            print('留一法第 %d 次,共 %d 次' % (idx, total_times))
            classifier = LinearClassifier.Classifier(attr_count)
            value_train = np.append(value[0:idx], value[(idx + 1):], axis=0)
            label_train = np.append(label[0:idx], label[(idx + 1):], axis=0)
            value_test = value[idx]
            label_test = label[idx]
            for repeat in range(TRAIN_TIMES):
                for sub_idx in range(len(value_train)):
                    classifier.fit(value_train[sub_idx], label_train[sub_idx])
            result = classifier.classify(value_test)
            if result == label_test:
                correct_times += 1
        print('留一法验证结束,准确率:%.2f%%' % (correct_times * 100 / total_times))

    运行结果

    代码在 Python 3.5 环境中执行结果如下:

    使用 wine.data 进行验证

    10折交叉验证:当前第 1 次
    准确率:84.62%
    10折交叉验证:当前第 2 次
    准确率:84.62%
    10折交叉验证:当前第 3 次
    准确率:92.31%
    10折交叉验证:当前第 4 次
    准确率:92.31%
    10折交叉验证:当前第 5 次
    准确率:69.23%
    10折交叉验证:当前第 6 次
    准确率:84.62%
    10折交叉验证:当前第 7 次
    准确率:69.23%
    10折交叉验证:当前第 8 次
    准确率:92.31%
    10折交叉验证:当前第 9 次
    准确率:84.62%
    10折交叉验证:当前第 10 次
    准确率:92.31%
    10折交叉验证结束,平均准确率:84.62%

    开始使用留一法验证
    留一法验证结束,准确率:83.85%

    使用 iris.data 进行验证

    10折交叉验证:当前第 1 次
    准确率:100.00%
    10折交叉验证:当前第 2 次
    准确率:100.00%
    10折交叉验证:当前第 3 次
    准确率:100.00%
    10折交叉验证:当前第 4 次
    准确率:100.00%
    10折交叉验证:当前第 5 次
    准确率:100.00%
    10折交叉验证:当前第 6 次
    准确率:100.00%
    10折交叉验证:当前第 7 次
    准确率:100.00%
    10折交叉验证:当前第 8 次
    准确率:100.00%
    10折交叉验证:当前第 9 次
    准确率:100.00%
    10折交叉验证:当前第 10 次
    准确率:100.00%
    10折交叉验证结束,平均准确率:100.00%

    开始使用留一法验证
    留一法验证结束,准确率:100.00%

    从结果可见,10折交叉验证法和留一法结果基本一致,而 Iris 数据集由于数据维度较低,预测效果明显好于 Wine 数据集。
    详细代码和数据文件请访问:
    https://coding.net/u/dapanbest/p/MLHomeworks/git/tree/master/LinearModel
    完结撒花!

    展开全文
  • 西瓜书习题 3.3 编程实现对率回归

    千次阅读 多人点赞 2019-07-09 10:10:56
    西瓜书习题 3.3 编程实现对率回归,并给出西瓜数据集上的结果 西瓜数据集如下: ID density Sugar_content label 0 1 0.697 0.4600 1 1 2 0.774 0.3760 1 2 3 0.634 0.2640 1 3 4 ...

    西瓜书习题 3.3

    编程实现对率回归,并给出西瓜数据集上的结果

    西瓜数据集如下:

    	ID  density  Sugar_content  label
    
    0    1    0.697         0.4600      1
    1    2    0.774         0.3760      1
    2    3    0.634         0.2640      1
    3    4    0.608         0.3180      1
    4    5    0.556         0.2150      1
    5    6    0.403         0.2370      1
    6    7    0.481         0.1490      1
    7    8    0.437         0.2110      1
    8    9    0.666         0.0910      0
    9   10    0.243         0.0267      0
    10  11    0.245         0.0570      0
    11  12    0.343         0.0990      0
    12  13    0.639         0.1610      0
    13  14    0.657         0.1980      0
    14  15    0.360         0.3700      0
    15  16    0.593         0.0420      0
    16  17    0.719         0.1030      0
    

    这题的关键就在于对对率回归的理解,附上对率回归的手写版公式推导过程:
    在这里插入图片描述

    在这里插入图片描述

    推导RL的过程,得到了梯度公式,接下来用梯度上升算法实现RL(还有一种是用牛顿法实现,以后有时间在补充吧qwq~)

    import numpy as np
    import pandas as pd
    import matplotlib.pyplot as plt 
    
    #读取文件
    df = pd.read_csv('watermelon3.0alpha.csv')
    print(df)
    #方便矩阵运算,添一列1
    df['one'] = 1.0
    #将训练集装进矩阵
    train_X = np.mat(df[['one','density','Sugar_content']])
    #标签
    labels = np.mat(df[['label']])
    
    #sigmoid函数
    def sigmoid(z):
        return 1.0/(1.0 + np.exp(-z))
    
    
    
    #梯度上升算法
    def grad(train_X,labels,iters = 2000):
        m,n = train_X.shape
        #步长alpha
        alpha = 0.05
        #初始化权重,全设为1
        weights = np.ones((n,1))
        	
        #2000次迭代
        for k in range(iters):
            #沿着梯度方向,向前移动,并更新权重
            P = sigmoid(train_X.dot(weights))
            error = labels - P
            weights += alpha * np.dot(train_X.T,error)
    
        return weights
    
    #求出最优回归参数
    weights = grad(train_X,labels)
    print(weights)
    

    求得参数如下:

    [[-3.12066518]
     [ 0.76966008]
     [13.22972573]]
    
    #绘图
    x1,y1 = [],[]
    x2,y2 = [],[]
    x3,y3 = [],[]
    x4,y4 = [],[]
    
    for k in range(train_X.shape[0]):
        if labels[k] == 1:
            if sigmoid(np.dot(train_X[k,:],weights)) >= 0.5 :
                x1.append(train_X[k,1])
                y1.append(train_X[k,2])
            else:
                x2.append(train_X[k,1])
                y2.append(train_X[k,2]) 
        else:  
            if sigmoid(np.dot(train_X[k,:],weights)) < 0.5 :
                x3.append(train_X[k,1])
                y3.append(train_X[k,2])
            else:
                x4.append(train_X[k,1])
                y4.append(train_X[k,2])
                
    plt.scatter(x1,y1,s=30,c='red')
    plt.scatter(x2,y2,s=30,c='red',marker='x')
    plt.scatter(x3,y3,s=30,c='green')
    plt.scatter(x4,y4,s=30,c='green',marker='x')
    
    #绘制直线    w0 + w1x1 +w2x2 = 0
    X = np.arange(0,0.8,0.01)
    Y = -(weights[0] + weights[1] * X)/weights[2]
    
    #总结:绘制直线用 plot , 绘制散点 用scatrer
    plt.plot(X,Y)
    
    plt.xlabel('Density')
    plt.ylabel('Sugar_Content')
    plt.title("LogisticRegression")
    plt.show()
    

    在这里插入图片描述

    展开全文
  • 这里采用Python-sklearn的方式,环境搭建可参考 数据挖掘入门:Python开发环境搭建...编程实现对率回归: * 采用sklearn逻辑斯蒂回归库函数实现,通过查看混淆矩阵,绘制决策区域来查看模型分类效果; * 自...

    这里采用Python-sklearn的方式,环境搭建可参考 数据挖掘入门:Python开发环境搭建(eclipse-pydev模式).

    相关答案和源代码托管在我的Github上:PY131/Machine-Learning_ZhouZhihua.

    思路概要

    编程实现对率回归:
    * 采用sklearn逻辑斯蒂回归库函数实现,通过查看混淆矩阵,绘制决策区域来查看模型分类效果;
    * 自己编程实现,从极大化似然函数出发,采用梯度下降法得到最优参数,然后尝试了随机梯度下降法来优化过程。

    3.3 编程实现对率回归

    这里写图片描述

    所使用的数据集如下:

    这里写图片描述

    本题是本书的第一个编程练习,采用了自己编程实现和调用sklearn库函数两种不同的方式,详细解答和编码过程:(查看完整代码):

    1.获取数据、查看数据、预处理:

    观察数据可知,X包含(密度、含糖量)两个变量,y为西瓜是否好瓜分类(二分),由此生成.csv数据文件,在Python中用Numpy读取数据并采用matplotlib库可视化数据:

    样例代码:

    '''
    data importion
    '''
    import numpy as np
    import matplotlib.pyplot as plt  
    
    # load the CSV file as a numpy matrix
    dataset = np.loadtxt('../data/watermelon_3a.csv', delimiter=",")
    
    # separate the data from the target attributes
    X = dataset[:,1:3]
    y = dataset[:,3]
    
    # draw scatter diagram to show the raw data
    f1 = plt.figure(1)   
    plt.title('watermelon_3a')  
    plt.xlabel('density')  
    plt.ylabel('ratio_sugar')  
    plt.scatter(X[y == 0,0], X[y == 0,1], marker = 'o', color = 'k', s=100, label = 'bad')
    plt.scatter(X[y == 1,0], X[y == 1,1], marker = 'o', color = 'g', s=100, label = 'good')
    plt.legend(loc = 'upper right')  
    plt.show()

    数据散点图:

    这里写图片描述

    2.采用sklearn逻辑回归库函数直接拟合:

    虽然样本量很少,这里还是先划分训练集和测试集,采用sklearn.model_selection.train_test_split()实现,然后采用sklearn.linear_model.LogisticRegression,基于训练集直接拟合出逻辑回归模型,然后在测试集上评估模型(查看混淆矩阵和F1值)。

    样例代码:

    ''' 
    using sklearn lib for logistic regression
    '''
    from sklearn import model_selection
    from sklearn.linear_model import LogisticRegression
    from sklearn import metrics
    
    
    # generalization of test and train set
    X_train, X_test, y_train, y_test = model_selection.train_test_split(X, y, test_size=0.5, random_state=0)
    
    # model training
    log_model = LogisticRegression() 
    log_model.fit(X_train, y_train) 
    
    # model testing
    y_pred = log_model.predict(X_test)
    
    # summarize the accuracy of fitting
    print(metrics.confusion_matrix(y_test, y_pred))
    print(metrics.classification_report(y_test, y_pred))

    得出混淆矩阵和相关度量(查准率(准确率)、查全率(召回率),F1值)结果如下:

    [[4 1]
     [1 3]]
                 precision    recall  f1-score   support
    
            0.0       0.80      0.80      0.80         5
            1.0       0.75      0.75      0.75         4
    
    avg / total       0.78      0.78      0.78         9

    由混淆矩阵可以看到,由于样本本身数量较少,模型拟合效果一般,总体预测精度约为0.78。为提升精度,可以采用自助法进行重抽样扩充数据集,或是采用交叉验证选择最优模型。

    下图是采用matplotlib.contourf绘制的决策区域和边界,可以看出对率回归分类器还是成功的分出了绝大多数类:

    这里写图片描述

    3.自己编程实现逻辑斯蒂回归

    编程实现逻辑回归的主要工作是求取参数w和b(见书p59),最常用的参数估计方法是极大似然法,由于题3.1已经证得对数似然函数(见书3.27)是凸函数,存在最优解,这里考虑采用梯度下降法来迭代寻优。

    回顾一下Sigmoid函数,即逻辑斯蒂回归分类器的基础模型:

    这里写图片描述

    目的是基于数据集求出最优参数w和b,最常采用的是极大似然法,参数的似然函数为:

    这里写图片描述

    根据书p59,最大化上式等价于最小化下式:

    这里写图片描述

    题3.2已证上式为凸函数,一定存在最小值,但按照导数为零的解析求解方式较为困难,于是考虑采用梯度下降法来求解上式最小值时对应的参数。

    注:梯度下降法基本知识可参考书中附录p409页,也可直接采用书中p60式3.30偏导数公式。书中关于参数迭代改变式子如下:

    这里写图片描述

    对于迭代,可每次先根据(B.16)计算出梯度▽f(β),然后由(B.17)更新得出下一步的Δβ。

    接下来编程实现基本的梯度下降法:

    (1)首先编程实现对象式3.27:

    def likelihood_sub(x, y, beta):
        '''
        @param x: one sample variables
        @param y: one sample label
        @param beta: the parameter vector in 3.27
        @return: the sub_log-likelihood of 3.27  
        ''' 
        return -y * np.dot(beta, x.T) + np.math.log(1 + np.math.exp(np.dot(beta, x.T)))   
    
    def likelihood(X, y, beta):
        '''
        @param X: the sample variables matrix
        @param y: the sample label matrix
        @param beta: the parameter vector in 3.27
        @return: the log-likelihood of 3.27  
        '''
        sum = 0
        m,n = np.shape(X)  
    
        for i in range(m):
            sum += likelihood_sub(X[i], y[i], beta)
    
        return sum  

    (2)然后基于训练集(注意x->[x,1]),给出基于3.27似然函数的定步长梯度下降法,注意这里的偏梯度实现技巧:

    '''
    @param X: X is the variable matrix 
    @param y: y is the label array
    @return: the best parameter estimate of 3.27
    '''
    def gradDscent_1(X, y):  #implementation of basic gradDscent algorithms
    
        h = 0.1  # step length of iteration
        max_times= 500  # give the iterative times limit
        m, n = np.shape(X)
    
        beta = np.zeros(n)  # parameter and initial to 0
        delta_beta = np.ones(n)*h  # delta parameter and initial to h
        llh = 0
        llh_temp = 0
    
        for i in range(max_times):
            beta_temp = beta.copy()
    
            # for partial derivative 
            for j in range(n): 
                beta[j] += delta_beta[j]
                llh_tmp = likelihood(X, y, beta)
                delta_beta[j] = -h * (llh_tmp - llh) / delta_beta[j]                
                beta[j] = beta_temp[j]
    
            beta += delta_beta            
            llh = likelihood(X, y, beta)
    
        return beta

    通过追踪参数,查看其收敛曲线,然后来调节相关参数(步长h,迭代次数max_times)。下图是在当前参数取值下的beta曲线,可以看到其收敛良好:

    这里写图片描述

    (3)最后建立Sigmoid预测函数,对测试集数据进预测,得到混淆矩阵如下:

    [[ 4.  1.]
     [ 1.  3.]]

    可以看出其总体预测精度(7/9 ≈ 0.78)与调用sklearn库得出的结果相当。

    (4)采用随机梯度下降法来优化:上面采用的是全局定步长梯度下降法(称之为批量梯度下降),这种方法在可能会面临收敛过慢和收敛曲线波动情况的同时,每次迭代需要全局计算,计算量随数据量增大而急剧增大。所以尝试采用随机梯度下降来改善参数迭代寻优过程。

    随机梯度下降法的核心思想是增量学习:一次只用一个新样本来更新回归系数,从而形成在线流式处理。

    同时为了加快收敛,采用变步长的策略,h随着迭代次数逐渐减小。

    给出变步长随机梯度下降法的代码如下:

    def gradDscent_2(X, y):  #implementation of stochastic gradDscent algorithms
      '''
       @param X: X is the variable matrix 
       @param y: y is the label array
       @return: the best parameter estimate of 3.27
       '''
       import matplotlib.pyplot as plt  
    
       m, n = np.shape(X)
       h = 0.5  #  step length of iterator and initial
       beta = np.zeros(n)  # parameter and initial
       delta_beta = np.ones(n) * h
       llh = 0
       llh_temp = 0
    
       for i in range(m):
           beta_temp = beta.copy()  # for partial derivative 
    
           for j in range(n): 
               h = 0.5 * 1 / (1 + i + j)  # change step length of iterator 
               beta[j] += delta_beta[j]
               llh_tmp = likelihood_sub(X[i], y[i], beta)
               delta_beta[j] = -h * (llh_tmp - llh) / delta_beta[j]   
               beta[j] = beta_temp[j]  
    
           beta += delta_beta    
           llh = likelihood_sub(X[i], y[i], beta)
    
       return beta
    

    得出混淆矩阵:

    [[ 3.  2.]
     [ 0.  4.]]

    从结果看到的是:由于这里的西瓜数据集并不大,所以随机梯度下降法采用一次遍历所得的结果不太好,参数也没有完成收敛。这里只是给出随机梯度下降法的实现样例,这种方法在大数据集下相比批量梯度法应会有明显的优势。


    参考链接:
    由于这是本书第一个编程,索引资料较多,择其重要的一些列出如下:

    展开全文
  • 3.3编程实现对率回归

    千次阅读 2018-03-31 10:54:28
    """ Author: Victoria Created on: 2017.9.14 11:00 """ import matplotlib.pyplot as plt import numpy as np import pandas as pd def sigmoid(x): ... x:np.array...
    """
    Author: Victoria
    Created on: 2017.9.14 11:00
    """
    import matplotlib.pyplot as plt
    import numpy as np
    import pandas as pd
    
    def sigmoid(x):
        """
        Sigmoid function.
        Input:
            x:np.array
        Return:
            y: the same shape with x
        """
        y =1.0 / ( 1 + np.exp(-x))
        return y
    
    def newton(X, y):
        """
        Input:
            X: np.array with shape [N, 3]. Input.
            y: np.array with shape [N, 1]. Label.
        Return:
            beta: np.array with shape [1, 3]. Optimal params with newton method
        """
        N = X.shape[0]
        #initialization
        beta = np.ones((1, 3))
        #shape [N, 1]
        z = X.dot(beta.T)
        #log-likehood
        old_l = 0
        new_l = np.sum(y*z + np.log( 1+np.exp(z) ) )
        iters = 0
        while( np.abs(old_l-new_l) > 1e-5):
            #shape [N, 1]
            p1 = np.exp(z) / (1 + np.exp(z))
            #shape [N, N]
            p = np.diag((p1 * (1-p1)).reshape(N))
            #shape [1, 3]
            first_order = -np.sum(X * (y - p1), 0, keepdims=True)
            #shape [3, 3]
            second_order = X.T .dot(p).dot(X)
    
            #update
            beta -= first_order.dot(np.linalg.inv(second_order))
            z = X.dot(beta.T)
            old_l = new_l
            new_l = np.sum(y*z + np.log( 1+np.exp(z) ) )
    
            iters += 1
        print ("iters: ", iters)
        print (new_l)
        return beta
    
    def gradDescent(X, y):
        """
        Input:
            X: np.array with shape [N, 3]. Input.
            y: np.array with shape [N, 1]. Label.
        Return:
            beta: np.array with shape [1, 3]. Optimal params with gradient descent method
        """
    
        N = X.shape[0]
        lr = 0.05
        #initialization
        beta = np.ones((1, 3)) * 0.1
        #shape [N, 1]
        z = X.dot(beta.T)
    
        for i in range(150):
            #shape [N, 1]
            p1 = np.exp(z) / (1 + np.exp(z))
            #shape [N, N]
            p = np.diag((p1 * (1-p1)).reshape(N))
            #shape [1, 3]
            first_order = -np.sum(X * (y - p1), 0, keepdims=True)
    
            #update
            beta -= first_order * lr
            z = X.dot(beta.T)
    
        l = np.sum(y*z + np.log( 1+np.exp(z) ) )
        print (l)
        return beta
    
    if __name__=="__main__":
    
        #read data from csv file
        workbook = pd.read_csv("../data/watermelon_3a.csv", header=None)
        #this is the extension of x
        workbook.insert(3, "3", 1)
        X = workbook.values[:, 1:-1]
        y = workbook.values[:, 4].reshape(-1, 1)
    
        #plot training data
        positive_data = workbook.values[workbook.values[:, 4] == 1.0, :]
        negative_data = workbook.values[workbook.values[:, 4] == 0, :]
        plt.plot(positive_data[:, 1], positive_data[:, 2], 'bo')
        plt.plot(negative_data[:, 1], negative_data[:, 2], 'r+')
    
        #get optimal params beta with newton method
        beta = newton(X, y)
        newton_left = -( beta[0, 0]*0.1 + beta[0, 2] ) / beta[0, 1]
        newton_right = -( beta[0, 0]*0.9 + beta[0, 2] ) / beta[0, 1]
        plt.plot([0.1, 0.9], [newton_left, newton_right], 'g-')
    
        #get optimal params beta with gradient descent method
        beta = gradDescent(X, y)
        grad_descent_left = -( beta[0, 0]*0.1 + beta[0, 2] ) / beta[0, 1]
        grad_descent_right = -( beta[0, 0]*0.9 + beta[0, 2] ) / beta[0, 1]
        plt.plot([0.1, 0.9], [grad_descent_left, grad_descent_right], 'y-')
    
        plt.xlabel('density')
        plt.ylabel('sugar rate')
        plt.title("LR")
        plt.show()


    查看完整代码及数据集


    参考网址:

    https://blog.csdn.net/victoriaw/article/details/77989610

    展开全文
  • 这里采用Python-sklearn的方式,环境搭建可参考 数据挖掘入门:Python开发环境搭建(eclipse-pydev模式). 相关答案和源代码托管在我的Github上:PY131/Machine-...编程实现对率回归: * 采用sklearn逻辑斯蒂回...
  • 3.3编程实现对率回归,并给出西瓜数据集3.0α上的结果数据集: 1 0.697 0.460 1 2 0.774 0.376 1 3 0.634 0.264 1 4 0.608 0.318 1 5 0.556 0.215 1 6 0.403 0.237 1 7 0.481 0.149 1 8 0.437 0.211 1 9 0....
  • #对率回归和10折交叉验证用到sklearn库 http://scikit-learn.org/stable/ import numpy as np import pandas as pd import sklearn #iris数据 #sklearn可以用datasets方法加载iris数据集,查找数据集链接 ...
  • 首先,我们要构造跃阶函数,也就是sigmoid函数,书中给的函数是:   由这个跃阶函数来处理二分类问题。...附上好的対率回归的博客: https://blog.csdn.net/achuo/article/details/51160101
  • 第二步,用10次十折交叉验证法估计对率回归的精度。(这里所用的循环即为10次) # 十折交叉验证生成训练集和测试集 def tenfolds(): k = 0 truth = [] while k kf = model_selection.KFold(n_splits=10, ...
  • 数据如下: python 代码如下: #!/usr/bin/env python3 # -*- coding: utf-8 -*- """ Created on Tue Jan 30 10:05:01 2018 @author: llw """ #logistic regression ...from sklearn.cross_validation im
  • 程序对比了个股收益及大盘收益,并以个股收益作为自变量,设定默认截距,大盘上证综指进行回归分析并得出相应结论。
  • 采用压差法测定了旋流-静态微泡浮选柱内部的气含,分别通过单因素和正交试验研究了循环压力、进气量和起泡剂浓度3个因素气含的影响。在此基础上采用多元回归分析方法建立了试验条件下气含与3个因素之间的回归...
  • 渗透率是制约煤层气商业化开发至关重要的因素之一。...结果显示:柳林地区煤层渗透率回归方程具有较高的拟合度;多元逐步回归分析方法预测渗透率具有一定合理性;有利于煤层气开发的高渗区位于柳林地区中北部。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 136,028
精华内容 54,411
关键字:

对率回归