精华内容
下载资源
问答
  • 线性回归)介绍() 数学模型2.1 一元线性回归公式2.2 方差 - 损失函数 Cost Function2.3 优化方法 Optimization Function2.4 算法步骤(三)Python 实现 ()介绍 机器学习即指机器可以自我学习,而机器...

    在这里插入图片描述

    (一)介绍

    机器学习即指机器可以自我学习,而机器学习的方法就是利用现有的数据和算法,解出算法的参,从而得到可以用的模型。

    监督学习就是利用已有的数据(我们叫X,或者特征),和数据的标注(叫Y),找到x和y之间的对应关系,或者说是函数f。

    回归分析是一种因变量为连续值的监督学习。而线性回归指一种x和y之间的关系为线性关系的回归分析。
    y=a1x1+a2x2+by=a1x1+a2x2+b
    ,这个叫线性关系。如果这里出现了x2,log(x),sin(x)x2,log(x), sin(x)之类的,那就不是线性关系了。

    而一元线性回归说的是,自变量x是一个纯量(scalar)。scalar类型的变量,是不可再分的。

    **举例:**找出算法工程师和程序员之间的工资关系。这里直接给出北京,上海,杭州,深圳,广州的工资。

    在这里插入图片描述
    画图分析他们之间的关系大致是线性:
    在这里插入图片描述
    这时候,我们就可以试着用一元线性回归去拟合(fit)他们之间的关系。

    (二) 数学模型

    2.1 一元线性回归公式

    公式:
    y=ax+b+εy=ax+b+ε

    y 为应变量 dependent variable
    x 为自变量 independent variable
    a 为斜率 coeffient
    b 为截距 intercept
    ε (读作epsilon)为误差,正态分布
    线性回归的目标是,找到一组a和b,使得ε最小
    y^=ax+b\widehat{y}=ax+b

    ε=yy^ε=y−\widehat{y}

    y^\widehat{y}​ 读作y hat,也读作y帽子。这里的帽子一般表示估计值,用来区别真实值y。

    下图帮助理解:
    在这里插入图片描述黑色的点为观测样本,即y=ax+b+εy=ax+b+ε

    x红色的线为回归线,即y^=ax+b\widehat{y}=ax+b

    x蓝色的线段为误差,即ε=yy^ε=y−\widehat{y}

    2.2 方差 - 损失函数 Cost Function

    在机器学习中,很多时候需要找到一个损失函数。有了损失函数,我们就可以经过不断地迭代,找到损失函数的全局或者局部最小值(或者最大值)。损失函数使得我们的问题转化成数学问题,从而可以用计算机求解。在线性回归中,我们用方差作为损失函数。我们的目标是使得方差最小。

    下面的表格解释了什么是方差。

    在这里插入图片描述

    其中SSE(Sum of Square Error)是总的方差,MSE(Mean Square Error)是方差的平均值。

    而这里的损失函数,用的是0.5 * MSE。即:
    J(a,b)=12ni=0n(yiyi^)2J(a,b)= \frac{1}{2n}\sum_{i=0}^{n} (yi​−\widehat{y​i}​)^{2}

    记住,这里的损失函数是针对参数a和b的函数,y和y^\widehat{y}其实都是已知的。

    2.3 优化方法 Optimization Function

    有了损失函数后,还需要一个方法,使得我们可以找到这个损失函数的最小值。机器学习里叫做优化方法。这里的优化方法,就是算损失的方向。或者说,当我的参数变化的时候,我的损失是变大了还是变小了。如果a变大了,损失变小了。那么,说明a增大这个方向是正确的,我们可以朝着这个方向继续小幅度的前进。反之,就应该考虑往相反的方向试试看。因为每个参数(a和b)都是一维的,所以,所谓的方向,无非就是正负符号。

    这里,我们需要用偏微分的方法,得到损失函数的变化量。即:

    在这里插入图片描述如果你已经忘了微积分,你暂时可以不必纠结上面的公式,只要知道公式给出了损失函数的变化就可以了。伟大的python还提供了sympy,你可以用sympy做微积分。这部分我也放在附件代码里了,有兴趣的可以看一下。

    之前说到,整过迭代过程是小幅度进行的。这里,就需要一个超参数来控制这个过程。这个超参数就是α,通常是0.01.

    这时,我们就可以去更新a和b的值:
    a=aαJa a=a−α\frac{∂J}{∂a}
    b=bαJb b=b−α\frac{∂J}{∂b}

    本身Ja​ \frac{∂J}{∂a}Jb​ \frac{∂J}{∂b}​ 是损失函数的变化量。如果损失函数随着a变大了,即Ja​ \frac{∂J}{∂a}为正。说明a的增大会导致损失函数的增大。那么是不是说,a的减小会使得损失函数减小呢?而我们的目标是使得J最小,所以,这个时候,我们的a要减小一点点。

    在这里插入图片描述

    2.4 算法步骤

    1. a和b的起始值设置为零

    2. 通过模型yˆ=ax+b

    3. y^=ax+b\widehat{y}​=ax+b,我们可以算出​y^\widehat{y}

    4. 有了​y^\widehat{y}​,就可以用优化方法算去更新参数

      重复2和3,直到找到J的最小值

    下图解释了模型,损失函数和优化方法之间的关系。

    模型,损失函数和优化方法之间的关系:
    在这里插入图片描述

    (三)Python 实现

    首先是模型 :

    def model(a, b, x):
        return a*x + b
    
    

    损失函数:

    def cost_function(a, b, x, y):
        n = 5
        return 0.5/n * (np.square(y-a*x-b)).sum()
    
    

    优化函数:

    def optimize(a,b,x,y):
        n = 5
        alpha = 1e-1
        y_hat = model(a,b,x)
        da = (1.0/n) * ((y_hat-y)*x).sum()
        db = (1.0/n) * ((y_hat-y).sum())
        a = a - alpha*da
        b = b - alpha*db
        return a, b
    
    

    三个函数中a和b是标量(scalar value),x和y是向量(vector)
    至此,一元线性回归的主要部分就14行代码。

    训练模型
    用scikit-learn训练和评价模型

    import numpy as np
    from sklearn.linear_model import LinearRegression
    import matplotlib.pyplot as plt
    %matplotlib inline
    
    x = [13854,12213,11009,10655,9503] #程序员工资,顺序为北京,上海,杭州,深圳,广州
    x = np.reshape(x,newshape=(5,1)) / 10000.0
    y =  [21332, 20162, 19138, 18621, 18016] #算法工程师,顺序和上面一致
    y = np.reshape(y,newshape=(5,1)) / 10000.0
    # 调用模型
    lr = LinearRegression()
    # 训练模型
    lr.fit(x,y)
    # 计算R平方
    print lr.score(x,y)
    # 计算y_hat
    y_hat = lr.predict(x)
    # 打印出图
    plt.scatter(x,y)
    plt.plot(x, y_hat)
    plt.show()
    
    
    

    有了模型,损失函数,优化函数,我们就可以训练模型了。
    这里给出分别训练1次,再训练5次,再训练10次,再训练100,再训练10000次的模型。

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    分析:随着训练次数的增加,回归线越来越接近样本了。自己写的线性回归比较简单,我只能目测凭直觉感觉损失函数已经达到了最小值。

    模型评价

    在机器学习中,模型的好坏是有标准的。在回归模型中,我们用R2R^{2} 来评价模型。公式:
    R2R^{2}=SSR/SST
    其中
    SSR=i=0n=(yi^y)SSR=\sum_{i=0}^{n}= (\widehat{yi}−\overline{y})
    SSR=i=0n=(yiy)SSR=\sum_{i=0}^{n}= (yi−\overline{y})
    y\overline{y}读作y bar,是y的平均值。
    可以证明SST=SSR+SSESST=SSR+SSE

    展开全文
  • 线性回归1.1 定义:利用线性回归方程的最小二乘函数对个或多个自变量因变量之间关系进行建模的方法。1.2 数据形式:数据:模型:解析解:2. 逻辑回归2.1 定义:输出分类器,函数的输出值为0或1为了能接受...

    e3a85850a9ef9acf6df8d719b47537a1.png

    90f15ac3570d2e769b37aa50beaeaf41.png
    本文框架

    1. 线性回归

    1.1 定义:

    利用线性回归方程的最小二乘函数对一个或多个自变量和因变量之间关系进行建模的方法。

    1.2 数据形式:

    数据:

    ffbccc0690db0e73a900a56804ccf427.png

    模型:

    8ecb05c6aaa16bbecfa09752af1db337.png

    解析解:

    b1c54ca9368866547fe5b4387d1a28a5.png

    2. 逻辑回归

    2.1 定义:

    二值型输出分类器,函数的输出值为0或1

    a3f1f3b4cb4874bacb6b8fca9373c2bc.png

    为了能接受所有输入然后预测出类别,即使得函数在跳跃点上从0瞬间跳跃到1,我们用sigmoid函数来表示分类器的函数形式。

    3e4797beb95abc2464f1bdb7554d9e38.png

    我们从图中可以看出,x=0时Sigmoid函数看起来很像跃迁函数

    2.2 逻辑回归函数

    1322fa82b9937296fb2a26e0496099dd.png

    af415e69660adb7a3c7f30f7b0acd5dd.png

    当P的值大于0.5,输出1;当P的值小于0.5,输出0。

    3. 实战

    3.1 线性回归:预测股票后五天的股价

    准备工作:数据下载

    #使用 pip install tushare 安装tushare python包
    import tushare as ts
    df = ts.get_hist_data('000001')
    print(df)
    df.to_csv('000001.csv')

    代码:

    #导入所需要的库
    import numpy as np # 数学计算
    import pandas as pd # 数据处理, 读取 CSV 文件 (e.g. pd.read_csv)
    import matplotlib.pyplot as plt #数据可视化
    from datetime import datetime as dt #时间处理
    
    #导入数据
    df = pd.read_csv('./000001.csv') 
    print(np.shape(df)) #打印数据的行和列
    
    #将data列数据从字符串类型变为日期类型,进而排序
    df['date'] = pd.to_datetime(df['date']) 
    df = df.set_index('date') #日期为索引
    df.sort_values(by=['date'], inplace=True, ascending=True) # 按照时间升序排列
    
    # 检测是否有缺失数据 NaNs
    df.dropna(axis=0 , inplace=True) #不存在的值,删除整行
    
    #导入线性回归模型
    from sklearn.linear_model import LinearRegression 
    from sklearn import preprocessing #预处理
    
    # 创建新的列, 包含预测值, 根据当前的数据预测5天以后的收盘价
    num = 5 # 预测5天后的情况
    df['label'] = df['close'].shift(-num) # 预测值,把5天后的收盘价作为预测值
                                         
    # 丢弃 'label', 'price_change', 'p_change', 不需要它们做预测(防止数据内线性相关,影响预测)
    Data = df.drop(['label', 'price_change', 'p_change'],axis=1)
    
    #处理X,y的数据类型
    X = Data.values #把X值变为数组类型
    X = preprocessing.scale(X)  #把数据都变为0-1之间的数
    X = X[:-num] #把最后五行去掉(没有labels)
    df.dropna(inplace=True) #去掉缺失值的行
    Target = df.label
    y = Target.values
    
    # 将数据分为训练数据和测试数据
    X_train, y_train = X[0:550, :], y[0:550] #把X的550个数据所有列,y的550个数据作为训练数据
    X_test, y_test = X[550:, -51:], y[550:606]
    
    lr = LinearRegression()
    lr.fit(X_train, y_train) #训练数据
    lr.score(X_test, y_test) # 使用绝对系数 R^2 评估模型(x在多大程度上决定了y)
    print('在测试数据集上面的预测准确率: {:.2f}'.format(lr.score(X_test, y_test)))
    
    # 做预测 
    X_Predict = X[-num:]
    Forecast = lr.predict(X_Predict)
    
    #画出预测结果:预测 2019-05-13 到 2019-05-17 , 一共 5 天的收盘价 
    trange = pd.date_range('2019-05-13', periods=num, freq='d')
    
    # 产生预测值dataframe
    Predict_df = pd.DataFrame(Forecast, index=trange)
    Predict_df.columns = ['forecast']
    
    # 将预测值添加到原始dataframe
    df = pd.read_csv('./000001.csv') 
    df['date'] = pd.to_datetime(df['date'])
    df = df.set_index('date')
    # 按照时间升序排列
    df.sort_values(by=['date'], inplace=True, ascending=True)
    df_concat = pd.concat([df, Predict_df], axis=1)
    df_concat = df_concat[df_concat.index.isin(Predict_df.index)]
    
    # 画预测值和实际值
    df_concat['close'].plot(color='green', linewidth=1) #实际值为绿色
    df_concat['forecast'].plot(color='orange', linewidth=3) #预测值为橙色
    plt.xlabel('Time')
    plt.ylabel('Price')
    plt.show()
    
    # 理解模型,计算每列在预测中所占的权重
    for idx, col_name in enumerate(['open', 'high', 'close', 'low', 'volume', 'ma5', 'ma10', 'ma20', 'v_ma5', 'v_ma10', 'v_ma20']):
        print("The coefficient for {} is {}".format(col_name, lr.coef_[idx]))

    结果:

    f9d7a083fb0339ba772a1b0435b6dc3c.png
    数据大小与预测准确率

    6d001721deed1bf59e7b471b7c3a6731.png
    实际值(绿)与预测值(橙)的对比

    2f4db6ca8955d85283f0039e1713351a.png
    每个变量所占权重

    3. 2 逻辑回归:预测Titanic乘客是否生还

    分析思路:

    c95a58ac4048fd637c2f68f5d61a17bf.png

    3.2.1 导入工具库和数据

    # 将数据读入 DataFrame
    df = pd.read_csv("./titanic_data.csv")
    
    # 预览数据
    df.head()

    f0606e9e0bc316ee8043b35c087ebae8.png
    数据的前五行

    我们预览数据,看到了乘客的一些属性特征:姓名、性别、年龄、家庭成员情况等。

    3.2.2 查看缺失数据

    # 查看数据集中各个特征缺失的情况
    df.isnull().sum()

    88da37a2f048b781c59068014a164964.png

    我们可以看出,该船乘客的年龄、仓位、登船地点信息缺失较严重,我们需要将数据可视化,采用合适的方法来处理这些缺失的数据

    • 年龄
    #画出年龄分布的直方图
    ax = df["age"].hist(bins=15, color='teal', alpha=0.6)
    ax.set(xlabel='age')
    plt.xlim(-10,85)
    plt.show()

    23c7521c341e33a0a76d4c21ebba5ee9.png
    正偏态分布

    由于“年龄”的偏度不为0, 使用均值替代缺失值不是最佳选择, 这里我们可以选择使用中间值替代缺失值:

    # 年龄的中间值,省略为空的数据,结果:28.00
    print('The median of "Age" is %.2f' %(df["age"].median(skipna=True)))
    • 仓位
    # 仓位缺失的百分比
    print('"Cabin" 缺失的百分比 %.2f%%' %((df['cabin'].isnull().sum()/df.shape[0])*100))

    有77.48% 的乘客的仓位都是缺失的, 最佳的选择是不使用这个特征的值.

    • 登船地点
    # 登船地点的缺失率
    print('"Embarked" 缺失的百分比 %.2f%%' %((df['embarked'].isnull().sum()/df.shape[0])*100))
    #只有 0.23% 的乘客的登船地点数据缺失, 可以使用众数替代缺失的值.
    print('按照登船地点分组 (C = Cherbourg, Q = Queenstown, S = Southampton):')
    print(df['embarked'].value_counts())
    sns.countplot(x='embarked', data=df, palette='Set2')
    plt.show()

    15d323e3017d89540ffc4a9b9f58bb36.png

    我们从图中可看出,绝大多数登船地点在S,可使用“S”代替缺失值

    • 对数据进行调整
    #年龄用中数填补,登船地点用众数,船舱删除
    data = df.copy()
    data["age"].fillna(df["age"].median(skipna=True), inplace=True)
    data["embarked"].fillna(df['embarked'].value_counts().idxmax(), inplace=True)
    data.drop('cabin', axis=1, inplace=True)

    查看现在数据的缺失情况:

    # 确认数据是否还包含缺失数据
    data.isnull().sum()

    a6f61ad9324341d3bb6094370a6079a6.png

    我们可以看到,还有个别属性有数据缺失,但数量不多,我们可以把有缺失数据的行全部删除:

    data.dropna(axis = 0,how = 'any',inplace = True)
    #查看数据缺失情况
    data.isnull().sum()

    6ac2e014e2167a5eba082f2136e5136d.png
    现在已经没有缺失数据了
    • 额外变量处理

    数据中的两个特征 “sibsp” (一同登船的兄弟姐妹或者配偶数量)与“parch”(一同登船的父母或子女数量)都是代表是否有同伴同行. 为了预防这两个特征具有多重共线性, 我们可以将这两个变量转为一个变量 “TravelAlone” (是否独自一人成行)

    # 创建一个新的变量'TravelAlone'记录是否独自成行, 丢弃“sibsp”与“parch”
    data['TravelAlone']=np.where((data["sibsp"]+data["parch"])>0, 0, 1)
    data.drop('sibsp', axis=1, inplace=True)
    data.drop('parch', axis=1, inplace=True)
    
    # 对 Embarked","Sex"进行独热编码, 从而将字符串类别转换为数值,丢弃 'name', 'ticket'
    final =pd.get_dummies(data, columns=["embarked","sex"])
    final.drop('name', axis=1, inplace=True)
    final.drop('ticket', axis=1, inplace=True)
    
    #数据头五行呈现
    final.head()

    ac55c3cad37588e131fc2d4faec003f0.png
    将不同属性用0,1编码

    3.2.3 数据分析

    我们需要对所有属性进行数据可视化,从而分析生还人员的特征,这里用票价、仓位举例:

    • 票价:
    plt.figure(figsize=(15,8))
    ax = sns.kdeplot(final["fare"][final.survived == 1], color="darkturquoise", shade=True)
    sns.kdeplot(final["fare"][final.survived == 0], color="lightcoral", shade=True)
    plt.legend(['Survived', 'Died'])
    plt.title('Density Plot of Fare for Surviving Population and Deceased Population')
    ax.set(xlabel='Fare')
    plt.xlim(-20,200)
    plt.show()

    420f4d6ef57faa0e043f34f56326dab4.png

    从图中我们可以看出,生还(蓝色)与遇难群体(粉色)的票价分布差异比较大, 说明这个特征对预测乘客是否生还非常重要。票价和仓位相关, 也许是仓位影响了逃生的效果, 我们接下来看仓位的分析。

    • 仓位:
    sns.barplot('pclass', 'survived', data=df, color="darkturquoise")
    plt.show()

    a539082bbd62bb4b1c9cf9d1f2969509.png

    很明显, 一等舱的乘客生还几率最高。

    3.2.4 逻辑回归预测生还率

    分析完所有属性后,我们打算使用年龄、票价、是否独自一人、仓位、登船地点、性别这几个特征来进行预测:

    # 使用如下特征做预测
    cols = ["age","fare","TravelAlone","pclass","embarked_C","embarked_S","sex_male"] 
    
    # 创建 X (特征) 和 y (类别标签)
    X = final[cols]
    y = final['survived']
    
    # 将 X 和 y 分为两个部分
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=2)
    
    # 检测 logistic regression 模型的性能
    #训练模型
    model = LogisticRegression()
    model.fit(X_train,y_train)
    #根据模型,以X_test为输入,生成变量y_pred
    y_pred = model.predict(X_test)
    print('Train/Test split results:')
    print("准确率为 %2.3f" % accuracy_score(y_test, y_pred))

    完整代码:

    #导入各种包
    import numpy as np 
    import pandas as pd 
    from sklearn import preprocessing
    import matplotlib.pyplot as plt 
    plt.rc("font", size=14)
    import seaborn as sns
    sns.set(style="white")  #设置seaborn画图的背景为白色
    sns.set(style="whitegrid", color_codes=True)
    
    # 将数据读入 DataFrame
    df = pd.read_csv("./titanic_data.csv")
    
    #对缺失数据进行处理
    data = df.copy()
    data["age"].fillna(df["age"].median(skipna=True), inplace=True)
    data["embarked"].fillna(df['embarked'].value_counts().idxmax(), inplace=True)
    data.drop('cabin', axis=1, inplace=True)
    
    #去掉所有有缺失数据的数据行
    data.dropna(axis = 0,how = 'any',inplace = True)
    
    ## 创建一个新的变量'TravelAlone'记录是否独自成行, 丢弃“sibsp” (一同登船的兄弟姐妹或者配偶数量)与“parch”(一同登船的父母或子女数量)
    data['TravelAlone']=np.where((data["sibsp"]+data["parch"])>0, 0, 1)
    data.drop('sibsp', axis=1, inplace=True)
    data.drop('parch', axis=1, inplace=True)
    
    # 对 Embarked","Sex"进行独热编码, 从而将字符串类别转换为数值,丢弃 'name', 'ticket'
    final =pd.get_dummies(data, columns=["embarked","sex"])
    final.drop('name', axis=1, inplace=True)
    final.drop('ticket', axis=1, inplace=True)
    
    #导入逻辑回归包
    from sklearn.linear_model import LogisticRegression
    from sklearn.model_selection import train_test_split
    from sklearn.metrics import accuracy_score
    
    # 使用如下特征做预测
    cols = ["age","fare","TravelAlone","pclass","embarked_C","embarked_S","sex_male"] 
    
    # 创建 X (特征) 和 y (类别标签)
    X = final[cols]
    y = final['survived']
    
    # 将 X 和 y 分为两个部分
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=2)
    
    # 检测 logistic regression 模型的性能
    #训练模型
    model = LogisticRegression()
    model.fit(X_train,y_train)
    #根据模型,以X_test为输入,生成变量y_pred
    y_pred = model.predict(X_test)
    
    #结果输出
    print('Train/Test split results:')
    print("准确率为 %2.3f" % accuracy_score(y_test, y_pred))
    

    结果:

    1ea87bbb21abb372027598e6a4fb30b2.png
    展开全文
  • 对离散型和连续特征列的选择 、CART分类树(待预测结果为离散数据): 选择具有最小Gain_GINI的属性及其属性值,作为最优分裂属性以及最优分裂属性值。Gain_GINI值越小,说明分之后的子样本的“纯净度”越高...

    CART分类回归树

    分类与回归树是二叉树,可以用于分类,也可以用于回归问题。
    区别:分类树输出的是样本的类别, 而回归树输出的是一个实数。

    对离散型和连续型特征列的选择

    一、CART分类树(待预测结果为离散数据)
    选择具有最小Gain_GINI的属性及其属性值,作为最优分裂属性以及最优分裂属性值。Gain_GINI值越小,说明二分之后的子样本的“纯净度”越高,即说明选择该属性(值)作为分裂属性(值)的效果越好。
    实现过程:

    1. 对于样本集S,计算GINI如下:
      在这里插入图片描述
      其中,在样本集S中,pk表示分类结果中第k个类别出现的频率;
    2. 对于含有N个样本的样本集S,根据属性A的第i个属性值,将数据集S划分成两部分,则划分成两部分之后,Gain_GINI计算如下:
      在这里插入图片描述
    3. 对于属性A,分别计算任意属性值将数据集划分成两部分之后的Gain_GINI,选取其中的最小值,作为属性A得到的最优二分方案;
    4. 对于样本集S,计算所有属性的最优二分方案,选取其中的最小值,作为样本集S的最优二分方案:所得到的属性A及其第i属性值,即为样本集S的最优分裂属性以及最优分裂属性值。

    举个简单的例子,如下图:
    在这里插入图片描述
    在上述图中,属性有3个,分别是有房情况,婚姻状况和年收入,其中有房情况和婚姻状况是离散的取值,而年收入是连续的取值。拖欠贷款者属于分类的结果。
    假设现在来看有房情况这个属性,那么按照它划分后的基尼增益计算如下:
    在这里插入图片描述
    在这里插入图片描述
    而对于婚姻状况属性来说,它的取值有3种,按照每种属性值分裂后基尼增益计算如下:
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    比较上述三种取值得到的基尼增益可知,以“已婚”这个取值来分裂婚姻状况属性是最好的

    二、CART回归树(待预测结果为连续型数据)
    区别于分类树选取Gain_GINI为评价分裂属性的指标,回归树选取Gain_σ(方差)为评价分裂属性的指标。选择具有最小Gain_σ的属性及其属性值,作为最优分裂属性以及最优分裂属性值。Gain_σ值越小,说明二分之后的子样本的“差异性”越小,说明选择该属性(值)作为分裂属性(值)的效果越好。
    实现过程:

    1. 对于含有连续预测结果的样本集S,总方差计算如下:
      在这里插入图片描述
      其中,μ表示样本集S中预测结果的均值,yk表示第k个样本预测结果;
    2. 对于含有N个样本的样本集S,根据属性A的第i个属性值,将数据集S划分成两部分,则划分成两部分之后,Gain_σ计算如下:
      在这里插入图片描述
    3. 对于属性A,分别计算任意属性值将数据集划分成两部分之后的Gain_σ,选取其中的最小值,作为属性A得到的最优二分方案;
    4. 对于样本集S,计算所有属性的最优二分方案,选取其中的最小值,作为样本集S的最优二分方案:所得到的属性A及其第i属性值,即为样本集S的最优分裂属性以及最优分裂属性值。

    继续拿上面那个数据集来讲解上述的步骤:
    1、 根据第1个属性值划分为<=125和>125两部分:
    <=125的有:125, 100, 70, 120, 95, 60, 85, 75, 90 均值为91.111
    >125的有:220 均值为220
    σ(S1) = 61.554
    σ(S2) = 0
    Gain_σ(S) = σ(S1) + σ(S2) = 61.554

    2、 根据第2个属性值划分为<=100和>100两部分:
    <=100的有:100, 70, 95, 60, 85, 75, 90 均值为82.143
    而>100的有:125,120,220 均值为155
    σ(S1) = 35.254
    σ(S2) = 79.687
    Gain_σ(S) = σ(S1) + σ(S2) = 114.941

    3、 根据第3个属性值划分为<=70和>70两部分:
    Gain_σ(S) = σ(S1) + σ(S2) =129.085

    4、 根据第4个属性值划分为<=120和>120两部分:
    Gain_σ(S) = σ(S1) + σ(S2) =117.144

    5、 根据第5个属性值划分为<=95和>95两部分:
    Gain_σ(S) = σ(S1) + σ(S2) =122.347

    6、 根据第6个属性值划分为<=60和>60两部分:
    Gain_σ(S) = σ(S1) + σ(S2) =128.798

    7、 根据第7个属性值划分为<=220和>220两部分:
    Gain_σ(S) = σ(S1) + σ(S2) =136.894

    8、 根据第8个属性值划分为<=85和>85两部分:
    Gain_σ(S) = σ(S1) + σ(S2) =126.656

    9、 根据第9个属性值划分为<=75和>75两部分:
    Gain_σ(S) = σ(S1) + σ(S2) =125.568

    10、 根据第10个属性值划分为<=90和>90两部分:
    Gain_σ(S) = σ(S1) + σ(S2) =125.511

    比较每一种划分得到的Gain_σ(S)可知,用“125”来划分“年收入”这个属性是最合适的
    这样一来,连续型的这个属性也可以被划分为两部分:
    在这里插入图片描述
    计算它的基尼增益:
    在这里插入图片描述
    到此每个属性的最优二分方案均已计算出,比较每个属性的基尼增益可得出:此数据集的最优分裂属性为“婚姻状况”(因为这个属性的基尼增益值最小,为0.3),以及最优分裂属性值为“已婚”。

    展开全文
  • 本章主要学习的就是线性回归和局部加权线性回归,并配有两个示例进行实战。 、回归   回归的目的是预测数值的目标值。最直接的办法是依据输入写出个目标值的计算公式。假如你想要预测姐姐...

    一、前言

      前面的章节介绍了分类,分类的目标变量是标称型数据,而本章将会对连续型的数据做出预测。本章主要学习的就是线性回归和局部加权线性回归,并配有两个示例进行实战。

    二、回归

      回归的目的是预测数值型的目标值。最直接的办法是依据输入写出一个目标值的计算公式。假如你想要预测姐姐男友汽车的功率大小,可能会这么计算:
    在这里插入图片描述
      这就是所谓的回归方程(regression equation),其中的0.0015和-0.99称作回归系数(regression weights),求这些回归系数的过程就是回归。一旦有了这些回归系数,再给定输入,做预测就非常容易了。具体的做法是用回归系数乘以输入值,再将结果全部加在一起,就得到了预测值。
      这里我们主要学习的是线性回归,如果预测值是通过两个输入项相乘得到的,那么这种方式就是非线性的回归模型。

    1、用线性回归找到最佳拟合直线

    假定输入数据存放在矩阵X中,结果存放在向量y中:
    在这里插入图片描述
    回归系数存放在向量w中:
    在这里插入图片描述
    那么对于给定的数据x1,即矩阵X的第一列数据,预测结果u1将会通过如下公式给出:
    在这里插入图片描述
      现在的问题是,手里有数据矩阵X和对应的标签向量y,怎么才能找到w呢?一个常用的方法就是找出使误差最小的w。这里的误差是指预测u值和真实y值之间的差值,使用该误差的简单累加将使得正差值和负差值相互抵消,所以我们采用平方误差。平方误差和可以写做:
    在这里插入图片描述
      要求误差的最小值,可以转换为对误差函数来求参数w的导数,使导数为0,得到的参数w就是最优解。
    现在,我们用矩阵表示的平方误差和对w进行求导:
    在这里插入图片描述
    如果对于矩阵求不熟悉的,可以移步这里:点击查看
    令上述公式等于0,得到:

    在这里插入图片描述
      w上方的小标记表示,这是当前可以估计出的w的最优解。从现有数据上估计出的w可能并不是数据中的真实w值,所以这里使用了一个”帽”符号来表示它仅是w的一个最佳估计。

      值得注意的是,上述公式中包含逆矩阵,也就是说,这个方程只在逆矩阵存在的时候使用,也即是这个矩阵是一个方阵,并且其行列式不为0。

      上述的最佳w求解是统计学中的常见问题,除了矩阵方法外还有很多其他方法可以解决。通过调用NumPy库里的矩阵方法,我们可以仅使用几行代码就完成所需功能。该方法也称作OLS, 意思是“普通小二乘法”(ordinary least squares)。

    查看数据集: 第一列都为1.0,即x0。第二列为x1,即x轴数据。第三列为x2,即y轴数据。
    在这里插入图片描述
    接下来,创建一个regression.py文件,并编写代码如下:

    # -*- coding: utf-8 -*-
    
    import numpy as np
    import matplotlib.pyplot as plt
    
    
    """
    加载数据
    Parameters:
        fileName:文件名
    Returns:
        dataMat: x数据集
        labelMat: y数据集
    """
    def loadDataSet(fileName):
        numFeat = len(open(fileName).readline().split('\t'))-1
        dataMat = []
        labelMat = []
        fr = open(fileName)
        for line in fr.readlines():
            lineArr = []
            curLine = line.strip().split('\t')
            for i in range(numFeat):
                lineArr.append(float(curLine[i]))
            dataMat.append(lineArr)
            labelMat.append(float(curLine[-1]))
        return dataMat,labelMat
    
    """
    绘制数据集
    Parameters:
        无
    Returns:
        无
    """
    def plotDataSet():
        xArr, yArr = loadDataSet('ex0.txt') #加载数据
        n = len(xArr) #样本数个数
        xcord = []; ycord = []  #样本点
        for i in range(n):
            xcord.append(xArr[i][1])
            ycord.append(yArr[i])
        fig = plt.figure()
        ax = fig.add_subplot(111)
        ax.scatter(xcord, ycord, s=20, c='blue', alpha=0.5) #绘制样本点
        plt.title('DataSet')
        plt.xlabel('X')
        plt.show()
    if __name__ == '__main__':
        plotDataSet()
    

    运行可以查看数据的分布如下所示:
    在这里插入图片描述
      接下来,我们根据前面推导的线性回归系数计算方法,求出线性回归系数向量,并根据回归系数向量绘制回归曲线,在regression.py文件中编写代码如下:

    """
    计算线性回归系数w
    Parameters:
        xArr: x数据集
        yArr: y数据集
    Returns:
        ws:回归系数
    """
    def standRegres(xArr,yArr):
        xMat = np.mat(xArr)
        yMat = np.mat(yArr).T
        xTx =xMat.T *xMat
        if np.linalg.det(xTx) == 0.0:
            print("This matrix is singular, cannot do inverse")
            return
        ws = xTx.I * (xMat.T*yMat)
        return ws
    
    """
    绘制回归曲线和数据点
    Parameters:
        无
    Returns:
        无
    """
    def plotRegression():
        xArr, yArr = loadDataSet('ex0.txt')
        ws = standRegres(xArr, yArr)  #计算回归系数
        xMat = np.mat(xArr)  #创建xMat矩阵
        yMat = np.mat(yArr)  #创建yMat矩阵
        xCopy = xMat.copy()  #深拷贝xMat矩阵
        xCopy.sort(0)   #排序
        yHat = xCopy*ws  #针对得到的回归系数,计算对应的y值
        fig = plt.figure()
        ax = fig.add_subplot(111)
        ax.plot(xCopy[:,1], yHat, c='red') #绘制回归曲线
        ax.scatter(xMat[:,1].flatten().A[0], yMat.flatten().A[0], s=20, c='blue', alpha=0.5)
        plt.title('DataSet')
        plt.xlabel('X')
        plt.show()
        
    
    if __name__ == '__main__':
        plotRegression()
    

    运行结果如下图所示:
    在这里插入图片描述
      如何判断拟合曲线的拟合效果呢?当然,我们可以根据自己的经验进行观察,除此之外,我们还可以使用corrcoef方法来比较预测值和真实值的相关性。在regression.py文件中编写代码如下:

    if __name__ == '__main__':
        #plotDataSet()
        #plotRegression()
        xArr, yArr = loadDataSet('ex0.txt')
        ws = standRegres(xArr, yArr)
        xMat = np.mat(xArr)
        yMat = np.mat(yArr)
        yHat = xMat * ws
        print(np.corrcoef(yHat.T, yMat))
    

    运行结果如下:
    在这里插入图片描述

      从运行结果可以看到一个矩阵,该矩阵包含所有两两组合的相关系数。对角线上的数据是1.0,因为yMat和自己的匹配最完美,而yHat和yMat的相关系数为0.98.

    2、局部加权线性回归

      线性回归的一个问题是有可能出现欠拟合现象,因为它求的是具有最小均方误差的无偏估计。显而易见,如果模型欠拟合将不能取得最好的预测效果。所以有些方法允许在估计中引入一些偏差,从而降低预测的均方误差。
      其中一个方法就是局部加权线性回归(Locally Weighted Linear Regression,LWLR)。在该算法中,我们给待预测点附近的每个点赋予一定的权重;然后在这个子集上基于最小均方差来进行普通的回归。这种算法每次预测均需要事先选取出对应的数据子集。该算法解出的回归系数w的形式如下:

      其中W是一个矩阵,这个公式跟我们上面推导的公式的区别就在于W,它用来给每个数据点赋予权重。
    LWLR使用“核”来对附件的点赋予更高的的权重。核的类型可以自由选择,最常用的核就是高斯核,高斯核对应的权重公式如下:
    在这里插入图片描述
    下面编写局部加权线性回归函数,在regression.py文件中写入代码如下:

    """
    使用局部加权线性回归计算回归系数w
    Parameters:
        testPoint: 测试样本点
        xArr: x数据集
        yArr:y数据集
        k:高斯核的k,自定义参数
    Returns:
        ws:回归系数
    """    
    def lwlr(testPoint, xArr, yArr, k=1.0):
        xMat = np.mat(xArr)
        yMat = np.mat(yArr).T
        m = np.shape(xMat)[0]
        weights = np.mat(np.eye((m)))
        for j in range(m):
            diffMat = testPoint-xMat[j,:]
            weights[j,j] = np.exp(diffMat*diffMat.T/(-2.0*k**2))
        xTx = xMat.T*(weights*xMat)
        if np.linalg.det(xTx) == 0.0:
            print("This matrix is singular, cannot do inverse")
            return
        ws = xTx.I * (xMat.T * (weights * yMat))
        return testPoint * ws
    
    """
    局部加权线性回归拟合数据
    Parameters:
        testArr: 测试数据集
        xArr: x数据集
        yArr: y数据集
        k:高斯核的k,自定义参数
    Returns: 拟合数据集
    """   
    def lwlrTest(testArr, xArr, yArr, k=1.0):
        m = np.shape(testArr)[0]
        yHat = np.zeros(m)
        for i in range(m):
            yHat[i] = lwlr(testArr[i], xArr, yArr, k)  #使用局部加权线性回归函数,对每个样本点进行预测
        return yHat
    
    """
    绘制多条局部加权回归曲线
    Parameters:
        无
    Returns:
        无
    """
    def plotLWLRegression():
        from matplotlib.font_manager import FontProperties
        font = FontProperties(fname=r"c:\windows\fonts\simsun.ttc", size=14)
        
        xArr, yArr = loadDataSet('ex0.txt')
        xMat = np.mat(xArr)
        yMat = np.mat(yArr)
        
        yHat_0 = lwlrTest(xArr, xArr, yArr, 1)
        yHat_1 = lwlrTest(xArr, xArr, yArr, 0.01)
        yHat_2 = lwlrTest(xArr, xArr, yArr, 0.003)
    
        
        srtInd = xMat[:,1].argsort(0)
        xSort = xMat[srtInd][:,0,:]
        
        fig, axs = plt.subplots(nrows=3, ncols=1,sharex=False, sharey=False, figsize=(10,8))
        axs[0].plot(xSort[:,1], yHat_0[srtInd], c='blue')
        axs[1].plot(xSort[:,1], yHat_1[srtInd], c='blue')
        axs[2].plot(xSort[:,1], yHat_2[srtInd], c='blue')
        
        axs[0].scatter(xMat[:,1].flatten().A[0], yMat.T.flatten().A[0], s=2, c='red')
        axs[1].scatter(xMat[:,1].flatten().A[0], yMat.T.flatten().A[0], s=2, c='red')
        axs[2].scatter(xMat[:,1].flatten().A[0], yMat.T.flatten().A[0], s=2, c='red')
        
        #设置标题,x轴label,y轴label
        axs0_title_text = axs[0].set_title(u'局部加权回归曲线,k=1.0',FontProperties=font)
        axs1_title_text = axs[1].set_title(u'局部加权回归曲线,k=0.01',FontProperties=font)
        axs2_title_text = axs[2].set_title(u'局部加权回归曲线,k=0.003',FontProperties=font)
        plt.setp(axs0_title_text, size=8, weight='bold', color='red')  
        plt.setp(axs1_title_text, size=8, weight='bold', color='red')  
        plt.setp(axs2_title_text, size=8, weight='bold', color='red')
        plt.xlabel('X')
        plt.show()
        
    if __name__ == '__main__':
        plotLWLRegression()
    
    

    运行结果如下图所示:

    在这里插入图片描述
      局部加权线性回归也存在一个问题,即增加了计算量,因为它度每个数据点做预测时都必须使用整个数据集。从图中可以看出,k=0.01时可以得到很好的估计,而k=0.003时则考虑了太多的噪声,进而导致了过拟合现象。

    三、示例:预测鲍鱼的年龄

      接下来,我们将回归用于真实的数据。有一份来自UCI数据集合的数据,记录了鲍鱼(一种介壳类水生动物)的年龄,鲍鱼年龄可以从鲍鱼壳的层数推算得到。
      可以先打开数据集看一下数据的形式:数据集是多维的,所以我们很难画出它的分布情况。每个维度数据的代表的含义没有给出,不过没有关系,我们只要知道最后一列的数据是y值就可以了,最后一列代表的是鲍鱼的真实年龄,前面几列的数据是一些鲍鱼的特征,例如鲍鱼壳的层数等。我们不做数据清理,直接用上所有特征,测试下我们的局部加权回归
    在这里插入图片描述

    在regression.py中写入如下代码:

    def BaoFishYear():
        abX, abY = loadDataSet('abalone.txt')
        print('训练集与测试集相同:局部加权线性回归,核k的大小对预测的影响:')
        yHat01 = lwlrTest(abX[0:99], abX[0:99], abY[0:99], 0.1)
        yHat1 = lwlrTest(abX[0:99], abX[0:99], abY[0:99], 1)
        yHat10 = lwlrTest(abX[0:99], abX[0:99], abY[0:99], 10)
        print('k=0.1时,误差大小为:',rssError(abY[0:99], yHat01.T))
        print('k=1  时,误差大小为:',rssError(abY[0:99], yHat1.T))
        print('k=10 时,误差大小为:',rssError(abY[0:99], yHat10.T))
        print('')
        
        print('训练集与测试集不同:局部加权线性回归,核k的大小是越小越好吗?更换数据集,测试结果如下:')
        yHat01 = lwlrTest(abX[100:199], abX[0:99], abY[0:99], 0.1)
        yHat1 = lwlrTest(abX[100:199], abX[0:99], abY[0:99], 1)
        yHat10 = lwlrTest(abX[100:199], abX[0:99], abY[0:99], 10)
        print('k=0.1时,误差大小为:',rssError(abY[100:199], yHat01.T))
        print('k=1  时,误差大小为:',rssError(abY[100:199], yHat1.T))
        print('k=10 时,误差大小为:',rssError(abY[100:199], yHat10.T))
        print('')
        
        print('训练集与测试集不同:简单的线性归回与k=1时的局部加权线性回归对比:')
        print('k=1时,误差大小为:', rssError(abY[100:199], yHat1.T))
        ws = standRegres(abX[0:99], abY[0:99])
        yHat = np.mat(abX[100:199]) * ws
        print('简单的线性回归误差大小:', rssError(abY[100:199], yHat.T.A))
    
    
    
    if __name__ == '__main__':
        #plotDataSet()
        #plotRegression()
        
    #    xArr, yArr = loadDataSet('ex0.txt')
    #    ws = standRegres(xArr, yArr)
    #    xMat = np.mat(xArr)
    #    yMat = np.mat(yArr)
    #    yHat = xMat * ws
    #    print(np.corrcoef(yHat.T, yMat))
    
    #    plotLWLRegression()
        
        BaoFishYear()
    

    运行结果如下:
    在这里插入图片描述
      可以看到,当k=0.1时,训练集误差小,但是应用于新的数据集之后,误差反而变大了。这就是经常说道的过拟合现象。我们训练的模型,我们要保证测试集准确率高,这样训练出的模型才可以应用于新的数据,也就是要加强模型的普适性。可以看到,当k=1时,局部加权线性回归和简单的线性回归得到的效果差不多。这也表明一点,必须在未知数据上比较效果才能选取到最佳模型。那么最佳的核大小是10吗?或许是,但如果想得到更好的效果,应该用10个不同的样本集做10次测试来比较结果。

      本示例展示了如何使用局部加权线性回归来构建模型,可以得到比普通线性回归更好的效果。局部加权线性回归的问题在于,每次必须在整个数据集上运行。也就是说为了做出预测,必须保存所有的训练数据。

    四、总结:

      回归是预测数值型目标值的过程。在回归方程中,求得特征对应的最佳回归系数的方法是最小化误差的平方和。本文主要讲述了简单线性回归和局部加权线性回归。局部加权线性回归的问题在于,每次必须在整个数据集上运行,计算量大。在局部加权线性回归中,过小的核可能导致过拟合现象,即测试集表现良好,训练集表现就很烂了。通过预测鲍鱼年龄的示例就可以很好的发现。训练的模型要在测试集比较它们的效果,而不是在训练集上。

    参考资料

    展开全文
  • 回归目录、前言、缩减...  前面我们介绍了线性回归和局部加权线性回归,并配有两示例——预测鲍鱼的年龄。但是在示例中数据集是多维的,有多个数据特征。如果数据的特征比样本点多应该怎么办?是否还可以使...
  • 首先大家了解一下Logistic回归,如下: logistic回归又称logistic回归分析,是...Logistic回归一般是标量的分归类。 然后大家了解一下Sigmoid函数,如下: Sigmoid函数是个在生物学中常见的S函数,也称为S...
  • (2)准备数据:回归需要数值数据,标称数据将被转化成数据 (3)分析数据:绘出数据的可视化维图将有助于对数据做出理解分析,在采用缩减法求得新回归系数之后,可以将新拟合线在图上作为对比 (4)...
  • 预测数据分析:分类及逻辑回归

    千次阅读 2018-05-15 18:15:56
    数据分析师(入门) DC学院回归和分类的区别分类:对离散变量进行预测(分类、多分类)回归:对数值变量进行预测区别:回归的y为数值连续变量;分类的y是类别离散变量分类问题1. 分类问题示例:信用卡 ...
  • 回归

    2020-04-05 21:58:10
    文章目录、回归概述、回归系数三、局部加权线性回归四...说到回归,一般都是指线性回归,所以本文里的回归和线性回归代表同个意思。 例:HorsePower = 0.0015 * annualSalary - 0.99 * hoursListeningToPublic...
  • 在此基础上,通过构建次规划模型对函数非参数回归预测模型的预测曲线进行修正,使其满足待预测日负荷特性指标要求。利用某省级电网夏季典型日负荷数据美国PJM电力公司冬季典型日负荷数据对所提方法进行测试,...
  • 阅读提示为了更好理解这篇文章,你可能需要了解:两因素方差分析平方的分解方差分析模型虚拟变量推荐先阅读用回归来理解方差分析():单因素方差分析用回归来理解方差分析():两因素方差分析文中涉及到的...
  • 回归模型可用于预测连续值,分类...是从线性回归中衍生出来的分类策略,通过将S函数用于线性预测而得到分类任务中每个标签的概率。逻辑回归种极其高效的概率计算机制。 1、线性回归 线性回归用于预测连续值...
  • 决策树():回归模型树

    千次阅读 2019-09-26 13:43:35
    下面介绍的回归篇文章介绍的分类树,都属于决策树范畴。分类树的模型是每个非叶子节点都是个分类特征,按照该分类特征的不同取值,将数据集分为多少个子集;并且分类树模型我们要找的是测试数据集的最终...
  • 主要讲解简单的线性回归和局部加权线性回归。 、什么是回归? 回归的目的是预测数值的目标值。他和我们之前做的分类是不一样的。最直接的办法是依据输入写出个目标值的计算公式。假如你想预测小姐姐男友...
  • 针对椒盐噪声的特点, 提出了种以回归型最小二乘支持向量机(Least square support vector regression , LS-SVR)为数据恢复算法的开关滤波器。首先利用max-min算子对滤波窗口中心点进行噪声判别, 若中心点不是窗口...
  • 理解回归关注的是个唯一的因变量(预测变量)和一个或多个数值自变量之间的关系。首先假设因变量自变量之间遵循线性关系。 单一线性回归:只有个单一的自变量 多元回归:多个自变量概念普通最小二乘估计:...
  • 1,多重共线性问题(Ridge回归和Lasso回归) 1.1,什么是多重共线性 我们在对多元线性回归的损失函数求导,并得出求解系数的式子和过程,在最后一步中我们需要左乘的逆矩阵,而逆矩阵存在的充分必要条件是特征矩阵...
  • R建模之回归

    2018-05-30 18:29:03
    节是建立线性回归模型以及对于其模型预测效果的讨论,这一节做一下模型中引入个离散预测变量。依然使用上一节中的usair数据集,在模型中增加x5(降水量:年度发生降雨的天数)作为预测变量,该预测变量有三...
  • 利用Logistics回归进行分类的主要思想是:根据现有数据对分类...接下来介绍这个输出分类器的数学原理 Logistic RegressionLinear Regression的原理是相似的,可以简单的描述为这样的过程: (1)找个合适...
  • 、引言、线性回归算法2.1 算法介绍目的:预测数值的目标值得到求取目标值的回归方程、回归系数求这些回归系数w的过程称为回归数据存放在矩阵X,回归系数存放在向量W中对于给定的输入数据X’,预测结果如何确定...
  • 分类和回归的区别在于:而回归的目标变量是连续数值的,如果预测鲍鱼的年龄,则可能是任意正数了。 1.1 回归 回归的目标变量是连续数值的,通过回归方程来实现。 1.2 分类 分类的目标变量是离散的,例如某件事...
  • 多因子量化模型,在实盘操作中有两种方法,第种是回归法,第种是打分法。回归法,多用于宏观因子建模,为Macroeconomic,最早由FAMA-French提出;打分法,多用于个股的风险因子暴露打分,为Fundamental,以...
  • - 用线性回归找到最佳拟合直线 优点:结果易于理解,计算上不复杂。 缺点:对非线性的数据...(2) 准备数据:回归需要数值数据,标称数据将被转成数据。 (3) 分析数据:绘出数据的可视化维图将有助于...
  • Logistic回归为概率非线性回归模型,是研究分类观察结果与一些影响因素之间关系的种多 变量分析方法。通常的问题是,研究某些因素条件下某个结果是否发生,比如医学中根据病人的一些症状来判断它是 否患有...
  • 相关和回归分析

    2020-03-25 13:12:04
    棣莫弗在求项分布的渐近公式中得到。C.F.高斯在研究测量误差时从另个角度导出了它。P.S.拉普拉斯高斯研究了它的性质。是个在数学、物理及工程等领域都非常重要的概率分布,在统计学的许多方面有着重大的影响...
  • 上文中说过,逻辑斯蒂回归虽然称为回归,但它实际上是种分类算法。...上文中的回归算法一样,我们有m条数据,每条数据有n个特征1个标签。不同的是,上文的标签是个连续变量,本文中的标签...
  • 逻辑回归

    千次阅读 2019-09-20 09:38:27
    之前我们接触了不不少带“回归字的算法,回归树,随机森林的回归,线性回归,无例外。他们都是区别于分类算法们,用来处理理预测连续标签的算法。然而逻辑回归,是种名为“回归”的线性分类器器,其本质...
  • 、线性回归与逻辑回归)线性回归 1. 算法概述 ...(2) 准备数据:回归需要数值数据,标称数据将被转成数据。(3) 分析数据:绘出数据的可视化维图将有助于对数据做出理解分...

空空如也

空空如也

1 2 3 4 5 ... 15
收藏数 286
精华内容 114
关键字:

一型回归和二型回归