精华内容
下载资源
问答
  • 问题 描述 表达式描述 表达式 单变量线性回归 只含有一个特征/输入变量 一元一次表达式 ... 逻辑回归 含有个离散输出,解决分类问题 sigmoid函数 过拟合 有效适应训练...
    问题 描述 表达式描述 表达式
    单变量线性回归 只含有一个特征/输入变量 一元一次表达式
    多变量线性回归 含有多个特征/输入变量 多元一次函数
    多项式回归 含有多个特征/输入变量 多元多次函数
    逻辑回归 含有多个离散输出,解决分类问题 sigmoid函数
    过拟合 有效适应训练集,但泛化性能差  

    1、剔除一些不必要特征,如PCA

    2、正则化,保留所有特征,但减少参数的大小

    问题 梯度下降
    单变量线性回归

        

       

    多变量线性回归

         

    特征缩放:

    学习率:

    逻辑回归

    等价于

    求偏导得:

    正则化

    修改代价函数:

    令λ值很大,为了使cost function很小,所有θ(不包括θ0)都会一定程度减少。

    正则化线性回归

    正则化逻辑回归

     

    展开全文
  • 变量逻辑回归

    2020-07-29 19:34:06
    变量逻辑回归 数据 部分数据: admit,gre,gpa,rank 0,380,3.61,3 1,660,3.67,3 1,800,4,1 1,640,3.19,4 0,520,2.93,4 1,760,3,2 1,560,2.98,1 0,400,3.08,2 1,540,3.39,3 0,700,3.92,2 0,800,4,4 0,440,3.22,1 1...

    哑变量与逻辑回归

    数据

    部分数据:

    admit,gre,gpa,rank
    0,380,3.61,3
    1,660,3.67,3
    1,800,4,1
    1,640,3.19,4
    0,520,2.93,4
    1,760,3,2
    1,560,2.98,1
    0,400,3.08,2
    1,540,3.39,3
    0,700,3.92,2
    0,800,4,4
    0,440,3.22,1
    1,760,4,1
    0,700,3.08,2
    1,700,4,1
    

    导入库

    • numpy: Python的语言扩展,定义了数字的数组和矩阵

    • pandas: 直接处理和操作数据的主要package

    • statsmodels: 统计和计量经济学的package,包含了用于参数评估和统计测试的实用工具

    • pylab: 用于生成统计图

    # 导入库
    import pandas as pd
    import statsmodels.api as sm
    from matplotlib import pyplot as plt 
    import numpy as np
    

    读入数据
    辨别不同的因素对研究生录取的影响。

    数据集中的前三列可作为预测变量(predictorvariables):gpa/gre分数/rank表示本科生母校的声望。第四列admit则是二分类目标变量(binary targetvariable),它表明考生最终是否被录用。

    #读入数据:
    df = pd.read_csv('../测试数据/python/binary.csv')
    

    打印前5行

    # 打印前5行
    df.head()
    

    输出:

    
      admit	gre	gpa	rank
    0	0	380	3.61	3
    1	1	660	3.67	3
    2	1	800	4.00	1
    3	1	640	3.19	4
    4	0	520	2.93	4
    

    重命名字段

    # rank重命名为prestige
    df.columns = ['admit', 'gre', 'gpa', 'prestige']
    df.columns
    

    输出:

    Index(['admit', 'gre', 'gpa', 'prestige'], dtype='object')
    

    查看统计信息

    我们可以使用pandas的函数describe来给出数据的摘要

    # 统计摘要以及查看数据
    print('统计摘要:')
    df.describe()
    

    输出:

    
    		admit		gre			gpa			prestige
    count	400.000000	400.000000	400.000000	400.00000
    mean	0.317500	587.700000	3.389900	2.48500
    std	0.466087	115.516536	0.380567	0.94446
    min	0.000000	220.000000	2.260000	1.00000
    25%	0.000000	520.000000	3.130000	2.00000
    50%	0.000000	580.000000	3.395000	2.00000
    75%	1.000000	660.000000	3.670000	3.00000
    max	1.000000	800.000000	4.000000	4.00000
    

    查看每一列的标准差

    # 查看每一列的标准差
    print('标准差:')
    df.std()
    

    输出:

    admit         0.466087
    gre         115.516536
    gpa           0.380567
    prestige      0.944460
    dtype: float64
    

    频率表,表示prestinge与admin的值相应的数量关系

    pd.crosstab(df['admit'], df['prestige'], rownames=['admit'])
    

    输出:

    
    prestige	1	2	3	4
    admit				
    			0	28	97	93	55
    			1	33	54	28	12
    

    创建哑变量(虚拟变量)

    虚拟变量,也叫哑变量,可用来表示分类变量、非数量因素可能产生的影响。在计量经济学模型,需要经常考虑属性因素的影响。例如,职业、文化程度、季节等属性因素往往很难直接度量它们的大小。只能给出它们的“Yes—D=1”或”No—D=0”,或者它们的程度或等级。为了反映属性因素和提高模型的精度,必须将属性因素“量化”。通过构造0-1型的人工变量来量化属性因素。

    pandas提供了一系列分类变量的控制。我们可以用get_dummies来将”prestige”一列虚拟化。

    get_dummies为每个指定的列创建了新的带二分类预测变量的DataFrame,在本例中,prestige有四个级别:1,2,3以及4(1代表最有声望),prestige作为分类变量更加合适。当调用get_dummies时,会产生四列的dataframe,每一列表示四个级别中的一个。

    这样,数据原本的prestige属性就被prestige_x代替了,例如原本的数值为2,则prestige_2为1,prestige_1、prestige_3、prestige_4都为0。

    将新的虚拟变量加入到了原始的数据集中后,就不再需要原来的prestige列了。在此要强调一点,生成m个虚拟变量后,只要引入m-1个虚拟变量到数据集中,未引入的一个是作为基准对比的。

    最后,还需加上常数intercept,statemodels实现的逻辑回归需要显式指定。

    dummy_ranks = pd.get_dummies(df['prestige'], prefix='prestige')
    dummy_ranks.head()
    

    输出:

    
    	prestige_1	prestige_2	prestige_3	prestige_4
    0	0			0			1			0
    1	0			0			1			0
    2	1			0			0			0
    3	0			0			0			1
    4	0			0			0			1
    

    创建逻辑回归所需的dataframe

    除admit、gre、gpa外,加入了上面常见的虚拟变量

    注意,引入的虚拟变量列数应为虚拟变量总列数减1,减去的1列作为基准

    cols_to_keep = ['admit', 'gre', 'gpa']
    data = df[cols_to_keep].join(dummy_ranks.loc[ : , 'prestige_2':])
    data.head()
    

    输出:

    	admit	gre	gpa	prestige_2	prestige_3	prestige_4
    0	0		380	3.61	0	1	0
    1	1		660	3.67	0	1	0
    2	1		800	4.00	0	0	0
    3	1		640	3.19	0	0	1
    4	0		520	2.93	0	0	1
    

    添加逻辑回归所需的intercept变量

    # 需要自行添加逻辑回归所需的intercept变量
    # 最后,还需加上常数intercept,statemodels实现的逻辑回归需要显式指定。
    data['intercept'] = 1.0
    data.head()
    

    输出;

    
    	admit	gre	gpa	prestige_2	prestige_3	prestige_4	intercept
    0	0		380	3.61	0	1	0	1.0
    1	1		660	3.67	0	1	0	1.0
    2	1		800	4.00	0	0	0	1.0
    3	1		640	3.19	0	0	1	1.0
    4	0		520	2.93	0	0	1	1.0
    

    执行逻辑回归

    实际上完成逻辑回归是相当简单的,首先指定要预测变量的列,接着指定模型用于做预测的列,剩下的就由算法包去完成了

    本例中要预测的是admin列,使用到gre、gpa和虚拟变量prestige_2、prestige_3、prestige_4。

    prestige_1作为基准,所以排除掉,以防止多元共线性(multicollinearity)和引入分类变量的所有虚拟变量值所导致的陷阱(dummy variable trap)

    # 执行逻辑回归
    # 指定作为训练变量的列,不含目标列‘admit’
    train_clos = data.columns[1:]
    logit = sm.Logit(data['admit'], data[train_clos])
    

    拟合模型

    # 拟合模型
    result = logit.fit()
    

    输出:

    Optimization terminated successfully.
             Current function value: 0.573147
             Iterations 6
    

    构建训练集并进行预测

    # 构建预测集
    # 与训练集相似,一般也是通过pd.read_csv()读入
    # 在这里为方便,将训练集拷贝一份作为预测集
    import copy
    combos = copy.deepcopy(data)
    
    print(data.head())
    
    # 数据中的列要跟预测时用到的列一致
    predict_cols = combos.columns[1:]
    
    # 预测集也添加intercept变量
    combos['intercept'] = 1.0
    
    # 进行预测,并将预测评分存入predict列中
    combos['predict'] = result.predict(combos[predict_cols])
    print(combos.head())
    

    输出结果:

    admit  gre   gpa  prestige_2  prestige_3  prestige_4  intercept
    0      0  380  3.61           0           1           0        1.0
    1      1  660  3.67           0           1           0        1.0
    2      1  800  4.00           0           0           0        1.0
    3      1  640  3.19           0           0           1        1.0
    4      0  520  2.93           0           0           1        1.0
       admit  gre   gpa  prestige_2  prestige_3  prestige_4  intercept   predict
    0      0  380  3.61           0           1           0        1.0  0.172627
    1      1  660  3.67           0           1           0        1.0  0.292175
    2      1  800  4.00           0           0           0        1.0  0.738408
    3      1  640  3.19           0           0           1        1.0  0.178385
    4      0  520  2.93           0           0           1        1.0  0.118354
    

    查看预测结果

    # 预测完成后,predict 的值是介于 [0, 1] 间的概率值
    # 我们可以根据需要,提取预测结果
    # 例如,假定 predict > 0.5,则表示会被录取
    # 在这边我们检验一下上述选取结果的精确度
    total = 0
    hit = 0
    for value in combos.values:
        # 预测分数 predict, 是数据中的最后一列
        predict = value[-1]
        # 实际录取结果
        admit = int(value[0])
    
        # 假定预测概率大于0.5则表示预测被录取
        if predict > 0.5:
            total += 1
            # 表示预测命中
            if admit == 1:
                hit += 1
    
    # 输出结果
    print('Total: %d, Hit: %d, Precision: %.2f' % (total, hit, 100.0 * hit / total))
    
    

    输出:

    Total: 49, Hit: 30, Precision: 61.22
    

    查看结果的概要信息

    对于回归结果的解读:

    • 第4列为p值,标记为P>|z|,一般认为,p值小于0.05的自变量为显著的
    # 查看数据的要点
    # 模型系数,系数拟合的效果,总的拟合质量,一些统计度量
    # combos
    # print(result)
    result.summary()
    

    输出结果:

    Logit Regression Results
    Dep. Variable:	admit	No. Observations:	400
    Model:	Logit	Df Residuals:	394
    Method:	MLE	Df Model:	5
    Date:	Tue, 14 Jul 2020	Pseudo R-squ.:	0.08292
    Time:	11:11:27	Log-Likelihood:	-229.26
    converged:	True	LL-Null:	-249.99
    Covariance Type:	nonrobust	LLR p-value:	7.578e-08
    coef	std err	z	P>|z|	[0.025	0.975]
    gre	0.0023	0.001	2.070	0.038	0.000	0.004
    gpa	0.8040	0.332	2.423	0.015	0.154	1.454
    prestige_2	-0.6754	0.316	-2.134	0.033	-1.296	-0.055
    prestige_3	-1.3402	0.345	-3.881	0.000	-2.017	-0.663
    prestige_4	-1.5515	0.418	-3.713	0.000	-2.370	-0.733
    intercept	-3.9900	1.140	-3.500	0.000	-6.224	-1.756
    

    查看每个系数的置信区间

    result.conf_int()
    

    输出结果:

    
    0	1
    gre	0.000120	0.004409
    gpa	0.153684	1.454391
    prestige_2	-1.295751	-0.055135
    prestige_3	-2.016992	-0.663416
    prestige_4	-2.370399	-0.732529
    intercept	-6.224242	-1.755716
    

    查看相对危险度 odds ratio(OR)

    使用每个变量系数的指数来生成odds ratio,可知变量每单位的增加、减少对录取几率的影响。

    例如,如果学校的声望为2,则我们可以期待被录取的几率减少大概50%。UCLA上有一个对oddsratio更为深入的解释:在逻辑回归中如何解释oddsratios?。

    np.exp(result.params)
    

    输出:

    
    gre           1.002267
    gpa           2.234545
    prestige_2    0.508931
    prestige_3    0.261792
    prestige_4    0.211938
    intercept     0.018500
    dtype: float64
    

    使用置信区间来计算系数的影响

    # 使用置信区间来计算系数的影响,来更好地估计一个变量影响录取率的不确定性
    # odds ratios and 95% CI
    params = result.params
    conf = result.conf_int()
    conf['OR'] = params
    conf.columns = ['2.5%', '97.5%', 'OR']
    np.exp(conf)
    

    输出;

    	2.5%	97.5%	OR
    gre	1.000120	1.004418	1.002267
    gpa	1.166122	4.281877	2.234545
    prestige_2	0.273692	0.946358	0.508931
    prestige_3	0.133055	0.515089	0.261792
    prestige_4	0.093443	0.480692	0.211938
    intercept	0.001981	0.172783	0.018500
    

    评估分类器的效果

    为了评估我们分类器的效果,我们将使用每个输入值的逻辑组合(logical combination)来重新创建数据集,如此可以得知在不同的变量下预测录取可能性的增加、减少。

    首先我们使用名为 cartesian 的辅助函数来生成组合值

    我们使用 np.linspace 创建 “gre” 和 “gpa” 值的一个范围,即从指定的最大、最小值来创建一个线性间隔的值的范围。在本例子中,取已知的最大、最小值。

    # 根据最大、最小值生成 GRE、GPA 均匀分布的10个值,而不是生成所有可能的值
    gres = np.linspace(data['gre'].min(), data['gre'].max(), 10)
    print(gres)
    

    输出:

    [220.         284.44444444 348.88888889 413.33333333 477.77777778
     542.22222222 606.66666667 671.11111111 735.55555556 800.        ]
    
    gpas = np.linspace(data['gpa'].min(), data['gpa'].max(), 10)
    print(gpas)
    

    输出:

    [2.26       2.45333333 2.64666667 2.84       3.03333333 3.22666667
     3.42       3.61333333 3.80666667 4.        ]
    
    # 枚举所有的可能性
    from sklearn.utils.extmath import cartesian
    combos = pd.DataFrame(cartesian([gres, gpas, [1, 2, 3, 4], [1.]]))
    
    # 重新创建哑变量
    combos.columns = ['gre', 'gpa', 'prestige', 'intercept']
    dummy_ranks = pd.get_dummies(combos['prestige'], prefix='prestige')
    dummy_ranks.columns = ['prestige_1', 'prestige_2', 'prestige_3', 'prestige_4']
    
    # 只保留用于预测的列
    cols_to_keep = ['gre', 'gpa', 'prestige', 'intercept']
    combos = combos[cols_to_keep].join(dummy_ranks.loc[:, 'prestige_2':])
    combos.columns
    

    输出:

    Index(['gre', 'gpa', 'prestige', 'intercept', 'prestige_2', 'prestige_3',
           'prestige_4'],
          dtype='object')
    
    # 使用枚举的数据集来做预测
    # predict_cols = combos.columns[1:]
    # combos['admit_pred'] = result.predict(train_clos)
    combos['admit_pred'] = result.predict(combos[train_clos])
    combos.head()
    

    输出:

    
    	gre	gpa	prestige	intercept	prestige_2	prestige_3	prestige_4	admit_pred
    0	220.0	2.260000	1.0	1.0	0	0	0	0.157801
    1	220.0	2.260000	2.0	1.0	1	0	0	0.087056
    2	220.0	2.260000	3.0	1.0	0	1	0	0.046758
    3	220.0	2.260000	4.0	1.0	0	0	1	0.038194
    4	220.0	2.453333	1.0	1.0	0	0	0	0.179574
    

    可视化预测结果

    def isolate_and_plot(variable):
        # isolate gre and class rank
        grouped = pd.pivot_table(combos, values=['admit_pred'], index=[variable, 'prestige'],
                                aggfunc=np.mean)
        print(grouped.head())
     
        # in case you're curious as to what this looks like
        # print grouped.head()
        #                                 admit_pred
        # gre              prestige            
        # 220.000000 1               0.282462
        #                     2               0.169987
        #                     3               0.096544
        #                     4               0.079859
        # 284.444444 1               0.311718
     
        # make a plot
        colors = 'rbgyrbgy'
        for col in combos.prestige.unique():
            plt_data = grouped.loc[grouped.index.get_level_values(1)==col]
            plt.plot(plt_data.index.get_level_values(0), plt_data['admit_pred'],
                    color=colors[int(col)])
     
        plt.xlabel(variable)
        plt.ylabel("P(admit=1)")
        plt.legend(['1', '2', '3', '4'], loc='upper left', title='Prestige')
        plt.title("Prob(admit=1) isolating " + variable + " and presitge")
        plt.show()
    
    
    isolate_and_plot('gre')
    

    输出:
    在这里插入图片描述

    isolate_and_plot('gpa')
    

    输出:

    在这里插入图片描述

    展开全文
  • 第三章:逻辑回归 第四章:BP 神经网络 第五章:卷积神经网络 第六章:循环神经网络 第七章:决策树与随机森林 第八章:支持向量机 第九章:隐马尔科夫 第十章:聚类等算法 ... 多变量线性回归python实现机器学习...

    机器学习

    第一章:机器学习基础 第二章:线性回归 第三章:逻辑回归 第四章:BP 神经网络 第五章:卷积神经网络 第六章:循环神经网络 第七章:决策树与随机森林 第八章:支持向量机 第九章:隐马尔科夫 第十章:聚类等算法 ...

    github地址


    前言

    机器学习是从人工智能中产生的一个重要学科分支,是实现智能化的关键


    一、多变量线性回归?

    前面我们讲过单变量线性回归,就是只要一变量的线性回归,今天我们要讲的这个多变量线性回归,顾名思义就是由多个变量的线性回归。
    多变量回归的一般形式如下:
    在这里插入图片描述
    a代表截距,b1,b2,…,bk为回归系数。

    3.1 吴恩达多变量线性回归练习

    通过学习吴恩达的课程,我完成其多变量线性回归题,一共两个case

    3.1.1 版本一

    
    # 开发时间 ;2021/5/13 0013 13:24
    #房价预测
    
    #加载库
    import numpy as np
    import matplotlib.pyplot as plt
    import pandas as pd
    
    #加载数据集
    #第一列是房子的大小(平方英尺),第二列是卧室的数量,第三列是房子的价格。
    data=pd.read_csv('F:\\ML\\线性回归\\数据文件\\ex1data2.txt',names=['size','num_bedroom','price'],header=None)
    #print(data.head(5))
    '''
       size  num_bedroom   price
    0  2104            3  399900
    1  1600            3  329900
    2  2400            3  369000
    3  1416            2  232000
    4  3000            4  539900
    '''
    
    
    #归一化处理
    '''
    特征缩放/归一化
    对于多特征的机器学习问题,如果这些特征的取值在相近的范围内,则梯度下降法就能更快的收敛。
    例如,考虑取值范围相差较大的两个特征的情况,损失函数等值线将呈现出扁椭圆形,相差倍数越大,椭圆越扁。
    在这样的等值线上运行梯度下降,需要花很长一段时间,并可能来回波动,最终收敛到全局小值。
    改善这一状况的有效做法是特征缩放,使两个特征的取值范围靠近。此时损失函数等值线更接近圆,
    从数学上可以证明,梯度下降会找到一条更直接的路径(迭代次数减少)通向全局最小值。
    常用方法:除最大值,均值归一化等。
    
    在此实例中,房子的大小大约是卧室数量的1000倍。当特征有不同的数量级时,首先执行特征缩放可以使梯度下降收敛得更快。
    '''
    data=(data-data.mean())/data.std()
    #print(data.head(5))
    '''
           size  num_bedroom     price
    0  0.130010    -0.223675  0.475747
    1 -0.504190    -0.223675 -0.084074
    2  0.502476    -0.223675  0.228626
    3 -0.735723    -1.537767 -0.867025
    4  1.257476     1.090417  1.595389
    '''
    data.insert(0,'Ones',1) # 就是在第一列[0] 添加名字为Ones的一列数据,数值都是1
    X=data.iloc[:,:-1]#所有行,不取倒数第一列
    # y=data.iloc[:,3:4]
    y=data.iloc[:,-1]
    theta=np.zeros(X.shape[1])
    m=len(X)
    alpha=0.01
    #代价函数
    
    def Cost_function(X,y,theta):
        inner=(np.dot(X,theta)-y)**2
        return np.sum(inner)/2*m
    
    #梯度下降
    def gradient(X,y,theta):
        i=0
        for i in range(1000):
            i+=1
            theta=theta-(alpha/m)*np.dot(X.T,(np.dot(X,theta)-y))
        return theta
    
    theta=gradient(X,y,theta)
    print(theta)
    
    

    3.1.2 版本二

    import pandas
    import numpy as np
    import matplotlib.pyplot as plt
    
    
    def normalization(X):
        '''
        归一化
        :param X:
        :return:
        '''
        mu = np.mean(X, axis=0)
        # ddof的设置,会改变标准差的结算结果,因为总体误差和样本误差的计算公式不一样
        #标准差
        sigma = np.std(X, axis=0, ddof=1)
        X_norm = (X-mu)/ sigma
        return X_norm, mu, sigma
    
    
    def computeCostMulti(X, y, theta):
        """
        计算损失函数
        :param X:
        :param y:
        :param theta:
        :return:
        """
        m = X.shape[0]
        costs = X.dot(theta) - y
        total_cost = costs.transpose().dot(costs) / (2 * m)
        return total_cost[0][0]
    
    
    def gradientDescentMulti(X, y, theta, alpha, iterNum):
        """
        梯度下降实现
        :param X:
        :param y:
        :param theta:
        :param alpha:
        :param iterNum:
        :return:
        """
        m = len(X)
    
        J_history = list()
    
        for i in range(0, iterNum):
            costs = X.dot(theta) - y
            theta = theta - np.transpose(costs.transpose().dot(X) * (alpha / m))
    
            J_history.append(computeCostMulti(X, y, theta))
    
        return theta, J_history
    
    
    def learningRatePlot(X_norm, y):
        """
        不同学习速率下的梯度下降比较
        :param X_norm:
        :param y:
        :return:
        """
        colors = ['b', 'g', 'r', 'c', 'm', 'y', 'k']
        plt.figure()
        iter_num = 50
        # 如果学习速率取到3,损失函数的结果随着迭代次数增加而发散,值越来越大,不太适合在同一幅图中展示
        for i, al in enumerate([0.01, 0.03, 0.1, 0.3, 1]):
            ta = np.zeros((X_norm.shape[1], 1))
            ta, J_history = gradientDescentMulti(X_norm, y, ta, al, iter_num)
    
            plt.plot([i for i in range(len(J_history))], J_history, colors[i], label=str(al))
    
        plt.title("learning rate")
        plt.legend()
        plt.show()
    
    
    def normalEquation(X, y):
        """
        正规方程实现
        :param X:
        :param y:
        :return:
        """
        return np.linalg.inv(X.transpose().dot(X)).dot(X.transpose()).dot(y)
    
    
    if __name__ == '__main__':
        # 读取数据
        data_path = r'F:\\ML\\线性回归\\数据文件\\ex1data2.txt'
        data = pandas.read_csv(data_path, delimiter=",", header=None)
    
        # 切分特征和目标, 注意:索引是从0开始的
        X = data.iloc[:, 0:2].values
        y = data.iloc[:, 2:3].values
    
        # 数据标准化
        X_norm, mu, sigma = normalization(X)
    
        ones = np.ones((X_norm.shape[0], 1))
    
        # 假设函数中考虑截距的情况下,给每个样本增加一个为1的特征
        X_norm = np.c_[ones, X_norm]
    
        # 初始化theta
        theta = np.zeros((X_norm.shape[1], 1))
    
        # 梯度下降学习速率为0.01
        alpha = 0.01
        # 梯度下降迭代次数为400
        iterNum = 400
    
        # 梯度下降
        theta, J_history = gradientDescentMulti(X_norm, y, theta, alpha, iterNum)
    
        # 画出梯度下降过程中的收敛情况
        plt.figure()
        plt.plot([i for i in range(len(J_history))], J_history)
        plt.title("learning rate: %f" % alpha)
        plt.show()
    
        # 使用不同学习速率下的收敛情况
        learningRatePlot(X_norm, y)
    
        # 预测面积为1650,卧室数量为3的房子价格
        x_pre = np.array([1650, 3])
    
        x_pre_norm = (x_pre - mu) / sigma
        numpy_ones = np.ones((1,))
        x_pre_norm = np.concatenate((np.ones((1,)), x_pre_norm))
        price = x_pre_norm.dot(theta)
        print("通过梯度下降求解的参数预测面积1650、卧室数量3的房子价格为:%f" % price[0])
    
        # 下面使用正规方程计算theta
        X_ = np.c_[ones, data.iloc[:, 0:2].values]
        y_ = data.iloc[:, 2:3].values
    
        theta = normalEquation(X_, y)
    
        # 预测面积为1650,卧室数量为3的房子价格
        x_pre = np.array([1, 1650, 3])
        price = x_pre.dot(theta)
        print("通过正规方程求解的参数预测面积1650、卧室数量3的房子价格为:%f" % price[0])
       
    

    在这里插入图片描述
    在这里插入图片描述
    通过梯度下降求解的参数预测面积1650、卧室数量3的房子价格为:289314.620338
    通过正规方程求解的参数预测面积1650、卧室数量3的房子价格为:293081.464335

    3.2 股票预测

    通过上述学习,我们完成简单的股票预测

    #数据获取
    #从大型数据网站www.quandl.com获取
    #开盘价open 最高价high 最低价low 收盘价close 交易额volume 调整后的开盘价Adj.Open 最高价Adj.High 最低价Adj.Low 收盘价Adj.Close 交易额Adj.volume
    # 1 关于Quandl
    # Quandl是为投资专业人士提供金融,经济和替代数据的首选平台,拥有海量的经济和金融数据。
    #
    # 2 Quandl模块
    # Python有Quandl模块,通过Quandl模块可直接使用平台上的数据。Quandl包可以访问平台上所有免费的数据,但不是所有的数据都是免费的,部分数据需要付费才能使用。
    import quandl
    from sklearn import preprocessing
    df=quandl.get('WIKI/GOOGL')#预测Google股票再用
    #df=quandl.get('WIKI/AAPL')
    import math
    import numpy as np
    #定义预测列变量,它存放研究对象的标签名
    forecast_col='Adj. Close'
    #定义预测天数,这里设置为所有数据量长度的1%
    forecast_out=int(math.ceil(0.01*len(df)))
    #只用到df中的下面几个字段
    df=df[['Adj. Open','Adj. High','Adj. Low','Adj. Close','Adj. Volume']]
    #构造两个新的列
    #HL_PCT为股票最高价与最低价的变化百分比
    df["HL_PCT"]=(df['Adj. High']-df['Adj. Close'])/df['Adj. Close']*100.0
    #PCT_change为股票收盘价与开盘价的变化百分比
    df["PCT_change"]=(df['Adj. Close']-df['Adj. Open'])/df['Adj. Open']*100.0
    #因为sciket-learn并不会处理空数据,需要把为空的数据都设置为一个比较难出现的值,我们设置为-9999
    df.fillna(-9999,inplace=True)
    #用label代表该字段,是预测结果
    #通过让Adj.Close列的数据往前移动1%行来表示
    df['label']=df[forecast_col].shift(-forecast_out)
    #最后生成真正在模型中使用的数据x,y,以及预测时用到的数据
    X=np.array(df.drop(['label'],1))
    X=preprocessing.scale(X)
    # 上面生成label列时留下的最后1%行的数据,这些行并没有label数据,因此我们可以拿他们作为预测时用到的输入数据
    X_lately = X[-forecast_out:]
    X=X[:-forecast_out:]
    #抛弃label列中为空的那些行
    df.dropna(inplace=True)
    y=np.array(df['label'])
    
    from sklearn import model_selection,svm
    from sklearn.linear_model import LinearRegression
    # 开始前,先X和y把数据分成两部分,一部分用来训练,一部分用来测试
    X_train,X_test,y_train,y_test=model_selection.train_test_split(X,y,test_size=0.25)
    #生成线性回归对象
    clf=LinearRegression(n_jobs=-1)
    #开始训练
    clf.fit(X_train,y_train)
    #用测试数据评估准确性
    accuracy=clf.score(X_test,y_test)
    #进行预测
    forecast_set=clf.predict(X_lately)
    print(forecast_set,accuracy)
    import matplotlib.pyplot as plt
    from matplotlib import style
    import datetime
    #修改matplotlib样式
    style.use('ggplot')
    one_day=86400
    #在df中新建Rorecast列,用于存放预测结果的数据
    df['Forecast'] = np.nan
    # 取df最后一行的时间索引
    last_date = df.iloc[-1].name
    last_unix = last_date.timestamp()
    next_unix = last_unix + one_day
    # 遍历预测结果,用它往df追加行
    # 这些行除了Forecast字段,其他都设为np.nan
    for i in forecast_set:
        next_date = datetime.datetime.fromtimestamp(next_unix)
        next_unix += one_day
        # [np.nan for _ in range(len(df.columns) - 1)]生成不包含Forecast字段的列表
        # 而[i]是只包含Forecast值的列表
        # 上述两个列表拼接在一起就组成了新行,按日期追加到df的下面
        df.loc[next_date] = [np.nan for _ in range(len(df.columns) - 1)] + [i]
    
    # 开始绘图
    df['Adj. Close'].plot()
    df['Forecast'].plot()
    plt.legend(loc=4)
    plt.xlabel('Date')
    plt.ylabel('Price')
    plt.show()
    

    总结

    期待大家和我交流,留言或者私信,一起学习,一起进步!

    展开全文
  • 逻辑回归还是要多用离散变量

    千次阅读 2016-06-23 14:51:41
    在工业界,很少直接将连续值作为逻辑回归模型的特征输入,而是将连续特征离散化为一系列0、1特征交给逻辑回归模型,这样做的优势有以下几点: 离散特征的增加和减少都很容易,易于模型的快速迭代; 稀疏向量内积乘法...

    在工业界,很少直接将连续值作为逻辑回归模型的特征输入,而是将连续特征离散化为一系列0、1特征交给逻辑回归模型,这样做的优势有以下几点:

    1. 离散特征的增加和减少都很容易,易于模型的快速迭代;

    2. 稀疏向量内积乘法运算速度快,计算结果方便存储,容易扩展;

    3. 离散化后的特征对异常数据有很强的鲁棒性:比如一个特征是年龄>30是1,否则0。如果特征没有离散化,一个异常数据“年龄300岁”会给模型造成很大的干扰;
    4. 逻辑回归属于广义线性模型,表达能力受限;单变量离散化为N个后,每个变量有单独的权重,相当于为模型引入了非线性,能够提升模型表达能力,加大拟合;
    5. 离散化后可以进行特征交叉,由M+N个变量变为M*N个变量,进一步引入非线性,提升表达能力;
    6. 特征离散化后,模型会更稳定,比如如果对用户年龄离散化,20-30作为一个区间,不会因为一个用户年龄长了一岁就变成一个完全不同的人。当然处于区间相邻处的样本会刚好相反,所以怎么划分区间是门学问;
    7. 特征离散化以后,起到了简化了逻辑回归模型的作用,降低了模型过拟合的风险。

    李沐曾经说过:模型是使用离散特征还是连续特征,其实是一个“海量离散特征+简单模型” 同 “少量连续特征+复杂模型”的权衡。既可以离散化用线性模型,也可以用连续特征加深度学习。就看是喜欢折腾特征还是折腾模型了。通常来说,前者容易,而且可以n个人一起并行做,有成功经验;后者目前看很赞,能走多远还须拭目以待

    展开全文
  • 变量线性回归 import numpy as np import pandas as pd import matplotlib.pyplot as plt path = 'ex1data1.txt' data = pd.read_csv(path, header=None, names=['Population', 'Profit']) data.head()...
  • 【机器学习】多变量线性回归

    万次阅读 2019-12-16 22:37:05
    四、多变量线性回归(Linear Regression with Multiple Variables) 4.1 多维特征 参考视频: 4 - 1 - Multiple Features (8 min).mkv 目前为止,我们探讨了单变量/特征的回归模型,现在我们对房价模型增加更的特征,...
  • 机器学习——多变量线性回归

    千次阅读 2019-07-27 09:34:36
    但不知道 能卖多少,需要进行预测,而对于房子能卖多少钱,能对这个结果产生影响的不单单是,房屋的面积了,房子的地理位置,房子的楼层数等都会对价格产生影响,这样我们就需要使用多变量线性回归来预测房价了 ...
  • 逻辑回归处理离散变量

    千次阅读 2017-05-13 10:19:38
    在工业界,很少直接将连续值作为逻辑回归模型的特征输入,而是将连续特征离散化为一系列0、1特征交给逻辑回归模型,这样做的优势有以下几点:0. 离散特征的增加和减少都很容易,易于模型的快速迭代;1. 稀疏向量内积...
  • 逻辑回归(logistics regression)

    万次阅读 多人点赞 2018-11-10 22:39:17
    逻辑回归(logistics regression)  前几章分别讲了多元线性回归的推理思路和求解过程(解析解求解和梯度下降求解),文章并不以代码和公式推导过程为重点,目的是跟大家一起理解算法.前两章的内容是学习算法的基础,所以...
  • 多变量线性回归

    千次阅读 2016-12-04 11:03:40
    目前为止,我们探讨了单变量/特征的回归模型,现在我们对房价模型增加更的特征, 例如房间数楼层等,构成一个含有变量的模型,模型中的特征为(x1,x2,…,xn)增添更特征后,我们引入一系列新的注释: n 代表特征的...
  • 机器学习:多变量线性回归

    千次阅读 2015-08-09 11:27:27
    ************************************** 注:本系列博客是博主学习...本系列博客包括线性回归、逻辑回归、神经网络、机器学习的应用和系统设计、支持向量机、聚类、将维、异常检测、推荐系统及大规模机器学习等内容
  • 跟我一起机器学习系列文章将首发于公众号:月来客栈,欢迎文末扫码关注! 1 多变量逻辑回归 上一篇文章中笔者对于什么是逻辑回归,以及它能用来干什么做了一...所为多变量逻辑回归其实就是一个样本点有个特征属性...
  • matlab实现的分类逻辑回归

    热门讨论 2015-06-22 08:50:21
    matlab实现的分类逻辑回归,用于手写数字识别
  • 逻辑回归中的离散变量

    千次阅读 2016-09-06 14:56:49
    在工业界,很少直接将连续值作为逻辑回归模型的特征输入,而是将连续特征离散化为一系列0、1特征交给逻辑回归模型,这样做的优势有以下几点:0. 离散特征的增加和减少都很容易,易于模型的快速迭代;1. 稀疏向量内积...
  • 原文链接:http://tecdat.cn/?p=18169 比如说分类变量为是否幸存、是因变量,连续变量为年龄、是自变量,这两者可以做相关分析吗?两者又是否可以做回归分析? 我们考虑泰坦尼克号数据集,
  • 在使用逻辑回归分析之前尝试在不同阈值上将连续变量二等分的任何人都知道,估计的系数确实会发生变化,并且它们会发生很大的变化!这是否与结果不应依赖阈值的说法相符? 我们可以使用模拟进行检查。首先,我将逐步...
  • 逻辑回归详解

    千次阅读 2018-08-15 22:08:19
    什么是逻辑回归逻辑回归的损失函数、梯度下降算法推导与逻辑回归的 Python 实现
  • 逻辑回归 - 理论篇

    万次阅读 多人点赞 2014-07-16 15:42:14
    什么是逻辑回归? Logistic回归与多重线性回归实际上有很相同之处,最大的区别就在于它们的因变量不同,其他的基本都差不多。正是因为如此,这两种回归可以归于同一个家族,即广义线性模型(generalizedli...
  • 上一篇已经将所有变量都转化为woe值的形式,这里再另外补充一个小技巧—dummy变量的使用。    1.有时候我们的数据来源可能不是很真实,如客户自己填写的婚姻状况,假设婚姻状况不会要求客户提供证明,但此时...
  • 逻辑回归原理详解
  • 逻辑回归及美团逻辑回归总结

    千次阅读 2015-07-27 16:38:45
    什么是逻辑回归? Logistic回归与多重线性回归实际上有很相同之处,最大的区别就在于它们的因变量不同,其他的基本都差不多。正是因为如此,这两种回归可以归于同一个家族,即广义线性模型(generalizedlinear ...
  • 逻辑回归之为什么叫逻辑回归

    千次阅读 2019-01-31 11:18:12
    为什么叫逻辑回归? 我们先欣赏一条S型曲线: 再来欣赏一条长得比较像、但是比较直的“曲线”: 图一叫做 logistic function,又叫做 sigmod function。图二叫做单位阶跃函数。逻辑函数取值范围是(0, 1),单位阶跃...
  • 逻辑回归

    千次阅读 2019-09-20 09:38:27
    然而逻辑回归,是一种名为“回归”的线性分类器器,其本质是由线性回归变化而来的,一种广泛使用于分类问题中的广义回归算法。要理理解逻辑回归从何而来,得要先从线性回归开始。线性回归是机器器学习中最简单的的...
  • 回归是一种专用于共线性数据分析的有偏估计回归方法,实质上是一种改良的最小二乘估计法,通过放弃最小二乘法的无偏性,以损失部分信息、降低精度为代价获得回归系数更为符合实际、更可靠的回归方法,对病态数据的...
  • 线性回归与逻辑回归

    千次阅读 2017-11-10 17:10:59
    一、逻辑回归与线性回归 1、线性回归(Linear Regression) 一般理解上,线性回归输出一个标量wx+b,是连续值, ,用来处理回归问题,拟合函数如下: 2、逻辑回归(Logistic Regression) 逻辑回归又称对数几率...
  • 继续是机器学习课程的笔记,这节课介绍的是多变量的线性回归多变量线性回归多维特征上节课介绍的是单变量的线性回归,这节课则是进一步介绍多变量的线性回归方法。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 51,164
精华内容 20,465
关键字:

多变量逻辑回归