精华内容
下载资源
问答
  • @转载 (基于随机森林算法的房屋价格预测模型) 【博客地址】:https://blog.csdn.net/sunyaowu315 【博客大纲地址】:https:/

    @转载【项目实战】基于随机森林算法的房屋价格预测模型

    【博客地址】:https://blog.csdn.net/sunyaowu315
    【博客大纲地址】:https://blog.csdn.net/sunyaowu315/article/details/82905347


      对数据分析、机器学习、数据科学、金融风控等感兴趣的小伙伴,需要数据集、代码、行业报告等各类学习资料,可关注微信公众号:风控圏子(别打错字,是圏子,不是圈子,算了直接复制吧!)

      关注公众号后,可联系圈子助手加入我们的机器学习风控讨论群和反欺诈讨论群。(记得要备注喔!)

      相互学习,共同成长。


    基于随机森林算法的房屋价格预测模型
    在这里插入图片描述

    
    
    # -*- coding: utf-8 -*-
    """
    Created on Wed Jul 25 17:17:16 2018
    
    @author: yaowu
    """
    #==============================================================================
    # 导入模块 : 导入所需要的模块
    # 数据清洗 : 在研究变量的基础上进行数据清洗
    # 变量筛选 : 
    # 建立模型 : 完成数据建模
    # 评估模型 : 最终评估模型质量
    #==============================================================================
    ## 1.1 导入模块
    # 导入一些数据分析和数据挖掘常用的包
    import numpy as np,pandas as pd,os,seaborn as sns,matplotlib.pyplot as plt
    from statsmodels.stats.outliers_influence import variance_inflation_factor  
    #statsmodels,统计模型,计量经济学是一个包含统计模型、统计测试和统计数据挖掘python模块
    #outliers_influence,
    #variance_inflation_factor,方差膨胀因子(Variance Inflation Factor,VIF):是指解释变量之间存在多重共线性时的方差与不存在多重共线性时的方差之比
    from sklearn.preprocessing import StandardScaler  
    #sklearn.preprocessing,数据预处理模块
    #StandardScaler,去均值和方差归一化模块
    from sklearn.decomposition import PCA
    #分解,降维
    ## 1.2 研究变量的情况 导入包之后加载一下数据集,查看一下数据的基础情况,再考虑下一步的处理
    # 加载一下数据,并打印部分数据,查看一下数据的情况
    os.chdir(r'C:\Users\A3\Desktop\2:项目\项目\项目19:基于随机森林算法的房屋价格预测模型\房屋价格预测')
    data_train = pd.read_csv('train.csv')
    data_test = pd.read_csv('test.csv')
    print(data_train.head())
    print(data_test.head())
    # 查看数据的列名和每列的数据格式,方便后面对数据进行处理
    #data_train.columns
    #data_train.info
    #查看数据结构
    data_train_dtypes = data_train.dtypes
    #print(data_train_dtypes)   
    '''
    #==============================================================================
    # 对因变量进行具体情况具体分析,主要查看因变量的统计情况,包含偏度和峰度等。
    # 峰度:峰度(Kurtosis)是描述某变量所有取值分布形态陡缓程度的统计量。
    # 它是和正态分布相比较的。
    # Kurtosis=0 与正态分布的陡缓程度相同。
    # Kurtosis>0 比正态分布的高峰更加陡峭——尖顶峰
    # Kurtosis<0 比正态分布的高峰来得平稳——平顶峰     
    # 计算公式:β = M_4 /σ^4 
    # 偏度:偏度(Skewness)是描述某变量取值分布对称性的统计量。
    # Skewness=0 分布形态与正态分布偏度相同
    # Skewness>0 正偏差数值较大,为正偏或右偏。长尾巴拖在右边。
    # Skewness<0 负偏差数值较大,为负偏或左偏。长尾巴拖在左边。 
    # 计算公式: S= (X^ - M_0)/δ Skewness 越大,分布形态偏移程度越大。
    #==============================================================================
    '''
    # 查看因变量价格的情况,进行基础分析
    sns.distplot(data_train['SalePrice'])
    plt.show()
    # 对房屋价格金额的数值图形化,查看一下
    sns.set(style="darkgrid")
    titanic = pd.DataFrame(data_train['SalePrice'].value_counts())
    titanic.columns = ['SalePrice_count']
    ax = sns.countplot(x="SalePrice_count", data=titanic)
    plt.show()
    
    # 从房屋价格的正态分布情况,查看房屋价格的峰度和偏度情况
    print('房屋价格偏度:%f' % (data_train['SalePrice'].skew()))
    print('房屋价格峰度:%f' % (data_train['SalePrice'].kurt()))
    '''
    #==============================================================================
    # 分析数据中的缺失值情况,如果超过阈值15%,则删除这个变量,其他变量根据类别或者是数值型变量进行填充。
    #   具体得到的情况如下:
    # 
    # 有缺失的对应的变量名称 
    # * PoolQC Pool quality 游泳池质量 
    # * MiscFeature Miscellaneous feature not covered in other categories 其他杂项,例如网球场、第二车库等 
    # * Alley Type of alley access to property 胡同小路,是碎石铺就的还是其他等等 
    # * Fence Fence quality 护栏质量 
    # * FireplaceQu Fireplace quality 壁炉的质量 
    # * LotFrontage Linear feet of street connected to property 街道情况 
    # * GarageFinish Interior finish of the garage 车库完成情况 
    # * GarageQual Garage quality 车库质量 
    # * GarageType Garage location 车库的位置 
    # * GarageYrBlt Year garage was built 车库的建筑年龄 
    # * GarageCond Garage condition 车库的条件 
    # * BsmtExposure Refers to walkout or garden level walls 花园的墙壁情况 
    # * BsmtFinType2 Rating of basement finished area (if multiple types) 地下室的完工面积 
    # * BsmtQual Evaluates the height of the basement 地下室的高度 
    # * BsmtCond Evaluates the general condition of the basement 地下室的质量情况 
    # * BsmtFinType1 Rating of basement finished area 地下室完工面积 
    # * MasVnrType Masonry veneer type 表层砌体类型 
    # * MasVnrArea Masonry veneer area in square feet 砖石镶面面积平方英尺 
    # * Electrical Electrical system 电气系统
    # 
    #==============================================================================
    '''
    # 在进行图形分析之前,先分析一下数据中缺失值的情况
    miss_data = data_train.isnull().sum().sort_values(ascending=False)  # 缺失值数量
    total = data_train.isnull().count()  # 总数量
    miss_data_tmp = (miss_data / total).sort_values(ascending=False)  # 缺失值占比
    # 添加百分号
    def precent(X):
        X = '%.2f%%' % (X * 100)
        return X
    miss_precent = miss_data_tmp.map(precent)
    # 根据缺失值占比倒序排序
    miss_data_precent = pd.concat([total, miss_precent, miss_data_tmp], axis=1, keys=[
                                  'total', 'Percent', 'Percent_tmp']).sort_values(by='Percent_tmp', ascending=False)
    # 有缺失值的变量打印出来
    print(miss_data_precent[miss_data_precent['Percent'] != '0.00%'])
    
    #* 将缺失值比例大于15%的数据全部删除,剩余数值型变量用众数填充、类别型变量用None填充。*
    
    drop_columns = miss_data_precent[miss_data_precent['Percent_tmp'] > 0.15].index
    data_train = data_train.drop(drop_columns, axis=1)
    data_test = data_test.drop(drop_columns, axis=1)
    # 类别型变量
    class_variable = [
        col for col in data_train.columns if data_train[col].dtypes == 'O']
    # 数值型变量
    numerical_variable = [
        col for col in data_train.columns if data_train[col].dtypes != 'O']  # 大写o
    print('类别型变量:%s' % class_variable, '数值型变量:%s' % numerical_variable)
    
    # 数值型变量用中位数填充,test集中最后一列为预测价格,所以不可以填充
    from sklearn.preprocessing import Imputer
    #Imputer填充模块
    padding = Imputer(strategy='median')
    data_train[numerical_variable] = padding.fit_transform(
        data_train[numerical_variable])
    data_test[numerical_variable[:-1]
              ] = padding.fit_transform(data_test[numerical_variable[:-1]])
    # 类别变量用None填充
    data_train[class_variable] = data_train[class_variable].fillna('None')
    data_test[class_variable] = data_test[class_variable].fillna('None')
    
    # 对所有的数据图形化,主要判别一下数据和因变量之间的关联性,后期我们再采用方差验证来选择变量。
    # 用图形化只是为了大致查看数据情况,构建简单模型使用。对变量的选择并不准确,对于较多变量,用图形先判断一下,也是一个办法;
    # 如果变量较多,这种办法效率低,并且准确度也差,下面随机选择了几个变量画图看一下状况,后期并不使用这种办法来选择变量
    
    # 根据变量,选择相关变量查看与因变量之间的关系
    # CentralAir 中央空调
    data = pd.concat([data_train['SalePrice'], data_train['CentralAir']], axis=1)
    fig = sns.boxplot(x='CentralAir', y="SalePrice", data=data)
    plt.title('CentralAir')
    plt.show()
    # 有中央空调的房价更高
    
    # MSSubClass 房屋类型
    data = pd.concat([data_train['SalePrice'], data_train['MSSubClass']], axis=1)
    fig = sns.boxplot(x='MSSubClass', y="SalePrice", data=data)
    plt.title('MSSubClass')
    plt.show()
    # 房屋类型方面和房屋价格之间关联度不大
    
    # MSZoning 房屋区域,例如有高密度住宅、低密度住宅,猜想这个变量和房屋价格之间的关系比较密切
    data = pd.concat([data_train['SalePrice'], data_train['MSZoning']], axis=1)
    fig = sns.boxplot(x='MSZoning', y="SalePrice", data=data)
    plt.title('MSZoning')
    plt.show()
    # 实际结果显示和房屋价格的关系不大
    
    
    # LotArea 这个变量猜想会与房屋价格有直接的关系
    fig = plt.figure()
    ax = fig.add_subplot(111)
    ax.scatter(x=data_train['SalePrice'], y=data_train['LotArea'])
    plt.xlabel('SalePrice')
    plt.ylabel('LotArea')
    plt.title('LotArea')
    plt.show()
    # 地块面积与房屋价格有较高相关性
    
    
    # Street
    data = pd.concat([data_train['SalePrice'], data_train['Street']], axis=1)
    fig = sns.boxplot(x='Street', y="SalePrice", data=data)
    plt.title('Street')
    plt.show()
    # 街道类型和房屋价格有较高相关性
    
    
    # LotShape
    data = pd.concat([data_train['SalePrice'], data_train['LotShape']], axis=1)
    fig = sns.boxplot(x='LotShape', y="SalePrice", data=data)
    plt.title('LotShape')
    plt.show()
    # 房屋形状和房屋价格相关不明显
    
    # LandContour
    data = pd.concat([data_train['SalePrice'], data_train['LandContour']], axis=1)
    fig = sns.boxplot(x='LandContour', y="SalePrice", data=data)
    plt.title('LandContour')
    plt.show()
    # 房屋所在地是否平整和房屋价格关系较弱
    
    # Utilities
    data = pd.concat([data_train['SalePrice'], data_train['Utilities']], axis=1)
    fig = sns.boxplot(x='Utilities', y="SalePrice", data=data)
    plt.title('Utilities')
    plt.show()
    # 公共设施和房屋价格基本无关系
    
    # LotConfig
    data = pd.concat([data_train['SalePrice'], data_train['LotConfig']], axis=1)
    fig = sns.boxplot(x='LotConfig', y="SalePrice", data=data)
    plt.title('LotConfig')
    plt.show()
    '''
    #==============================================================================
    # 因为变量较多,直接采用关系矩阵,查看各个变量和因变量之间的关系,使用的时候采用spearman系数,原因: 
    # Pearson 线性相关系数只是许多可能中的一种情况,为了使用Pearson 线性相关系数必须假设数 
    # 据是成对地从正态分布中取得的,并且数据至少在逻辑范畴内必须是等间距的数据。如果这两条件 
    # 不符合,一种可能就是采用Spearman 秩相关系数来代替Pearson 线性相关系数。Spearman 秩相关系 
    # 数是一个非参数性质(与分布无关)的秩统计参数,由Spearman 在1904 年提出,用来度量两个变 
    # 量之间联系的强弱(Lehmann and D’Abrera 1998)。Spearman 秩相关系数可以用于R 检验,同样可以 
    # 在数据的分布使得Pearson 线性相关系数不能用来描述或是用来描述或导致错误的结论时,作为变 
    # 量之间单调联系强弱的度量。
    # Spearman对原始变量的分布不作要求,属于非参数统计方法,适用范围要广些。
    # 理论上不论两个变量的总体分布形态、样本容量的大小如何,都可以用斯皮尔曼等级相关来进行研究 。
    #==============================================================================
    '''
    #==============================================================================
    # 变量处理 :
    # 
    # 在变量处理期间,我们先考虑处理更简单的数值型变量,再考虑处理复杂的类别型变量;
    # 
    # 其中数值型变量,需要先考虑和因变量的相关性,其次考虑变量两两之间的相关性,再考虑变量的多重共线性;
    # 
    # 类别型变量除了考虑相关性之外,需要进行编码。
    #==============================================================================
    # 绘制热力图,查看一下数值型变量之间的关系
    corrmat = data_train[numerical_variable].corr('spearman')
    f, ax = plt.subplots(figsize=(12, 9))
    ax.set_xticklabels(corrmat, rotation='horizontal')
    sns.heatmap(np.fabs(corrmat), square=False, center=1)
    label_y = ax.get_yticklabels()
    plt.setp(label_y, rotation=360)
    label_x = ax.get_xticklabels()
    plt.setp(label_x, rotation=90)
    plt.show()
    
    # 计算变量之间的相关性
    numerical_variable_corr = data_train[numerical_variable].corr('spearman')
    numerical_corr = numerical_variable_corr[
        numerical_variable_corr['SalePrice'] > 0.5]['SalePrice']
    print(numerical_corr.sort_values(ascending=False))
    index0 = numerical_corr.sort_values(ascending=False).index
    # 结合考虑两两变量之间的相关性
    print(data_train[index0].corr('spearman'))
    
    #==============================================================================
    # 结合上述情况,选择出如下的变量:
    # Variable	相关性
    # OverallQual	0.809829
    # GrLivArea	0.731310
    # GarageCars	0.690711
    # YearBuilt	0.652682
    # FullBath	    0.635957
    # TotalBsmtSF	0.602725
    # YearRemodAdd	0.571159
    # Fireplaces	0.519247
    #==============================================================================
    
    #在这个基础上再考虑变量之间的多重共线性
    new_numerical = ['OverallQual', 'GrLivArea', 'GarageCars',
                     'YearBuilt', 'FullBath', 'TotalBsmtSF', 'YearRemodAdd', 'Fireplaces']
    X = np.matrix(data_train[new_numerical])
    VIF_list = [variance_inflation_factor(X, i) for i in range(X.shape[1])]
    VIF_list
    #可以明显看到数据有很强的多重共线性,对数据进行标准化和降维
    
    Scaler = StandardScaler()
    data_train_numerical = Scaler.fit_transform(data_train[new_numerical])
    pca = PCA(n_components=7)
    newData_train = pca.fit_transform(data_train_numerical)
    newData_train
    
    Scaler = StandardScaler()
    data_test_numerical = Scaler.fit_transform(data_test[new_numerical])
    pca = PCA(n_components=7)
    newData_test = pca.fit_transform(data_test_numerical)
    newData_test
    
    newData_train = pd.DataFrame(newData_train)
    # newData
    y = np.matrix(newData_train)
    VIF_list = [variance_inflation_factor(y, i) for i in range(y.shape[1])]
    print(newData_train, VIF_list)
    
    #从上面的数据标准化和降维之后,已经消除了多重共线性了。接下来处理类别数据
    # 单因素方差分析
    
    from statsmodels.formula.api import ols
    #单因素方差分析模块
    from statsmodels.stats.anova import anova_lm
    #双因素方差分析模块
    a = '+'.join(class_variable)
    formula = 'SalePrice~ %s' % a
    anova_results = anova_lm(ols(formula, data_train).fit())
    print(anova_results.sort_values(by='PR(>F)'))
    #我们需要看的是单个自变量对因变量SalePrice的影响,因此这里使用单因素方差分析。 
    #分析结果中 P_values(PR(>F))越小,说明该变量对目标变量的影响越大。通常我们只选择 P_values 小于 0.05 的变量
    # 从变量列表和数据中剔除 P 值大于 0.05 的变量
    del_var = list(anova_results[anova_results['PR(>F)'] > 0.05].index)
    del_var
    # 移除变量
    for each in del_var:
        class_variable.remove(each)
    # 移除变量数据
    data_train = data_train.drop(del_var, axis=1)
    data_test = data_test.drop(del_var, axis=1)
    # 对类别型变量进行编码
    def factor_encode(data):
        map_dict = {}
        for each in data.columns[:-1]:
            piv = pd.pivot_table(data, values='SalePrice',
                                 index=each, aggfunc='mean')
            piv = piv.sort_values(by='SalePrice')
            piv['rank'] = np.arange(1, piv.shape[0] + 1)
            map_dict[each] = piv['rank'].to_dict()
        return map_dict
    
    # 调用上面的函数,对名义特征进行编码转换
    class_variable.append('SalePrice')
    map_dict = factor_encode(data_train[class_variable])
    for each_fea in class_variable[:-1]:
        data_train[each_fea] = data_train[each_fea].replace(map_dict[each_fea])
        data_test[each_fea] = data_test[each_fea].replace(map_dict[each_fea])
    #因为上面已经完成编码,这里我们再根据相关性判断和选择变量
    class_coding_corr=data_train[class_variable].corr('spearman')['SalePrice'].sort_values(ascending=False)
    print(class_coding_corr[class_coding_corr>0.5])
    class_0=class_coding_corr[class_coding_corr>0.5].index
    data_train[class_0].corr('spearman')
    #==============================================================================
    # SalePrice	Neighborhood	ExterQual	BsmtQual	KitchenQual	GarageFinish	GarageType	Foundation
    # SalePrice	1.000000	0.755779	0.684014	0.678026	0.672849	0.633974	0.598814	0.573580
    # Neighborhood	0.755779	1.000000	0.641588	0.650639	0.576106	0.542172	0.520204	0.584784
    # ExterQual	0.684014	0.641588	1.000000	0.645766	0.725266	0.536103	0.444759	0.609009
    # BsmtQual	   0.678026	0.650639	0.645766	1.000000	0.575112	0.555535	0.468710	0.669723
    # KitchenQual	0.672849	0.576106	0.725266	0.575112	1.000000	0.480438	0.412784	0.546736
    # GarageFinish	0.633974	0.542172	0.536103	0.555535	0.480438	1.000000	0.663870	0.516078
    # GarageType	0.598814	0.520204	0.444759	0.468710	0.412784	0.663870	1.000000	0.445793
    # Foundation	0.573580	0.584784	0.609009	0.669723	0.546736	0.516078	0.445793	1.000000
    #==============================================================================
    #查找两两之间的共线性之后,我们保留如下变量Neighborhood,ExterQual,BsmtQual,GarageFinish,GarageType,GarageType;
    #接下来尝试查看多重共线性
    class_variable = ['Neighborhood', 'ExterQual', 'BsmtQual',
                     'GarageFinish', 'GarageType', 'Foundation']
    X = np.matrix(data_train[class_variable])
    VIF_list = [variance_inflation_factor(X, i) for i in range(X.shape[1])]
    VIF_list
    #==============================================================================
    # [9.613821793463067,
    #  31.39188664149662,
    #  33.53637481741086,
    #  22.788724064203514,
    #  18.362389057630754,
    #  15.022566626297733]
    #==============================================================================
    Scaler = StandardScaler()
    data_train_class = Scaler.fit_transform(data_train[class_variable])
    pca = PCA(n_components=3)
    newData_train_class = pca.fit_transform(data_train_class)
    newData_train_class
    #==============================================================================
    # array([[-1.77187082,  0.39144961, -0.00666812],
    #        [-0.56662675, -0.71029462, -0.51616971],
    #        [-1.77187082,  0.39144961, -0.00666812],
    #        ...,
    #        [-1.53107491,  0.09189354, -1.97872919],
    #        [ 1.08133883, -0.73280347, -0.2622237 ],
    #        [-0.15886914, -1.39847287, -0.0633631 ]])
    #==============================================================================
    Scaler = StandardScaler()
    data_test_class = Scaler.fit_transform(data_test[class_variable])
    pca = PCA(n_components=3)
    newData_test_class = pca.fit_transform(data_test_class)
    newData_test_class
    #==============================================================================
    # array([[ 1.02960083, -0.69269663,  0.29882836],
    #        [ 1.02960083, -0.69269663,  0.29882836],
    #        [-1.36691619, -0.77507848, -1.26800226],
    #        ...,
    #        [ 1.62092967,  0.49991231,  0.28578798],
    #        [ 1.25970992,  2.79139405, -1.00467437],
    #        [-1.16601113, -0.81964858, -1.47794992]])
    #==============================================================================
    newData_train_class = pd.DataFrame(newData_train_class)
    y = np.matrix(newData_train_class)
    VIF_list = [variance_inflation_factor(y, i) for i in range(y.shape[1])]
    print(VIF_list)
    #==============================================================================
    # [1.0, 0.9999999999999993, 0.9999999999999996]
    #==============================================================================
    #训练集
    newData_train_class = pd.DataFrame(newData_train_class)
    newData_train_class.columns = ['降维后类别A','降维后类别B','降维后类别C']
    newData_train = pd.DataFrame(newData_train)
    newData_train.columns = ['降维后数值A','降维后数值B','降维后数值C','降维后数值D','降维后数值E','降维后数值F','降维后数值G']
    target = data_train['SalePrice']
    target = pd.DataFrame(target)
    train = pd.concat([newData_train_class,newData_train],axis=1, ignore_index=True)
    
    #测试集
    newData_test_class = pd.DataFrame(newData_test_class)
    newData_test_class.columns = ['降维后类别A','降维后类别B','降维后类别C']
    newData_test = pd.DataFrame(newData_test)
    newData_test.columns = ['降维后数值A','降维后数值B','降维后数值C','降维后数值D','降维后数值E','降维后数值F','降维后数值G']
    test = pd.concat([newData_test_class,newData_test],axis=1, ignore_index=True)
    
    from sklearn.model_selection import train_test_split
    #train_test_split函数用于将矩阵随机划分为训练子集和测试子集,并返回划分好的训练集测试集样本和训练集测试集标签
    from sklearn.ensemble import RandomForestRegressor
    #随机森林
    from sklearn.linear_model import LogisticRegression
    #逻辑回归
    from sklearn import svm
    #支持向量机
    train_data, test_data, train_target, test_target = train_test_split(train, target, test_size=0.2, random_state=0)
    # 当前参数为默认参数
    m = RandomForestRegressor()
    m.fit(train_data, train_target)
    from sklearn.metrics import r2_score
    score = r2_score(test_target,m.predict(test_data))
    print(score)
    #==============================================================================
    # 0.8407489786565608
    # D:\ProgramData\Anaconda3\lib\site-packages\ipykernel_launcher.py:4: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples,), for example using ravel().
    #   after removing the cwd from sys.path.
    #==============================================================================
    lr = LogisticRegression(C=1000.0,random_state=0)
    lr.fit(train_data, train_target)
    from sklearn.metrics import r2_score
    score = r2_score(test_target,lr.predict(test_data))
    print(score)
    #==============================================================================
    # D:\ProgramData\Anaconda3\lib\site-packages\sklearn\utils\validation.py:578: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().
    #   y = column_or_1d(y, warn=True)
    # 0.6380328421527758
    #==============================================================================
    clf = svm.SVC(kernel = 'poly')
    clf.fit(train_data, train_target)
    score = r2_score(test_target,clf.predict(test_data))
    print(score)
    #==============================================================================
    # D:\ProgramData\Anaconda3\lib\site-packages\sklearn\utils\validation.py:578: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().
    #   y = column_or_1d(y, warn=True)
    # 0.775319597309544
    #==============================================================================
    #==============================================================================
    # 结论就是逻辑回归等模型性能比较差,即使已经经过了正则化、PCA降维、去除多重共线性等。kaggle的比赛起手就应该用XGB。 
    # 下面尝试使用一下网格搜索的方式看能否提高一下随机森林的性能。
    #==============================================================================
    from sklearn.grid_search import GridSearchCV
    #网格搜索功能
    from sklearn.pipeline import Pipeline
    
    #==============================================================================
    # D:\ProgramData\Anaconda3\lib\site-packages\sklearn\cross_validation.py:41: DeprecationWarning: This module was deprecated in version 0.18 in favor of the model_selection module into which all the refactored classes and functions are moved. Also note that the interface of the new CV iterators are different from that of this module. This module will be removed in 0.20.
    #   "This module will be removed in 0.20.", DeprecationWarning)
    # D:\ProgramData\Anaconda3\lib\site-packages\sklearn\grid_search.py:42: DeprecationWarning: This module was deprecated in version 0.18 in favor of the model_selection module into which all the refactored classes and functions are moved. This module will be removed in 0.20.
    #   DeprecationWarning)
    #==============================================================================
    param_grid = {'n_estimators':[1,10,100,200,300,400,500,600,700,800,900,1000,1200],'max_features':('auto','sqrt','log2')}
    m = GridSearchCV(RandomForestRegressor(),param_grid)
    m=m.fit(train_data,train_target.values.ravel())
    print(m.best_score_)
    print(m.best_params_)
    #==============================================================================
    # 0.8642193810202421
    # {'max_features': 'sqrt', 'n_estimators': 500}
    #==============================================================================
    #通过网格搜索找到最佳的参数后,代入模型,模型完成
    m = RandomForestRegressor(n_estimators=200,max_features='sqrt')
    m.fit(train_data, train_target.values.ravel())
    predict = m.predict(test)
    test = pd.read_csv('test.csv')['Id']
    sub = pd.DataFrame()
    sub['Id'] = test
    sub['SalePrice'] = pd.Series(predict)
    sub.to_csv('Predictions.csv', index=False)
    
    print('finished!')
    ————————————————
    版权声明:本文为CSDN博主「CS正阳」的原创文章,遵循CC 4.0 BY-SA版权协议,转载请附上原文出处链接及本声明。
    原文链接:https://blog.csdn.net/sunyaowu315/article/details/82982989
    
    展开全文
  • 论文研究-基于Bagging与决策树算法的在线拍卖成交价格预测模型.pdf, 通过分析在线拍卖出价特点,利用决策树和Bagging算法建立了一种全新的在线拍卖成交价格预测模型.作者...
  • os.chdir(r'C:\Users\A3\Desktop\2:项目\项目\项目19:基于随机森林算法的房屋价格预测模型\房屋价格预测') data_train = pd.read_csv('train.csv') data_test = pd.read_csv('test.csv') print(data_train.head())...

    【博客地址】:https://blog.csdn.net/sunyaowu315
    【博客大纲地址】:https://blog.csdn.net/sunyaowu315/article/details/82905347


      对数据分析、机器学习、数据科学、金融风控等感兴趣的小伙伴,需要数据集、代码、行业报告等各类学习资料,可关注微信公众号:风控圏子(别打错字,是圏子,不是圈子,算了直接复制吧!)

      关注公众号后,可联系圈子助手加入我们的机器学习风控讨论群和反欺诈讨论群。(记得要备注喔!)

      相互学习,共同成长。


    基于随机森林算法的房屋价格预测模型
    在这里插入图片描述

    # -*- coding: utf-8 -*-
    """
    Created on Wed Jul 25 17:17:16 2018
    
    @author: yaowu
    """
    #==============================================================================
    # 导入模块 : 导入所需要的模块
    # 数据清洗 : 在研究变量的基础上进行数据清洗
    # 变量筛选 : 
    # 建立模型 : 完成数据建模
    # 评估模型 : 最终评估模型质量
    #==============================================================================
    ## 1.1 导入模块
    # 导入一些数据分析和数据挖掘常用的包
    import numpy as np,pandas as pd,os,seaborn as sns,matplotlib.pyplot as plt
    from statsmodels.stats.outliers_influence import variance_inflation_factor  
    #statsmodels,统计模型,计量经济学是一个包含统计模型、统计测试和统计数据挖掘python模块
    #outliers_influence,
    #variance_inflation_factor,方差膨胀因子(Variance Inflation Factor,VIF):是指解释变量之间存在多重共线性时的方差与不存在多重共线性时的方差之比
    from sklearn.preprocessing import StandardScaler  
    #sklearn.preprocessing,数据预处理模块
    #StandardScaler,去均值和方差归一化模块
    from sklearn.decomposition import PCA
    #分解,降维
    ## 1.2 研究变量的情况 导入包之后加载一下数据集,查看一下数据的基础情况,再考虑下一步的处理
    # 加载一下数据,并打印部分数据,查看一下数据的情况
    os.chdir(r'C:\Users\A3\Desktop\2:项目\项目\项目19:基于随机森林算法的房屋价格预测模型\房屋价格预测')
    data_train = pd.read_csv('train.csv')
    data_test = pd.read_csv('test.csv')
    print(data_train.head())
    print(data_test.head())
    # 查看数据的列名和每列的数据格式,方便后面对数据进行处理
    #data_train.columns
    #data_train.info
    #查看数据结构
    data_train_dtypes = data_train.dtypes
    #print(data_train_dtypes)   
    '''
    #==============================================================================
    # 对因变量进行具体情况具体分析,主要查看因变量的统计情况,包含偏度和峰度等。
    # 峰度:峰度(Kurtosis)是描述某变量所有取值分布形态陡缓程度的统计量。
    # 它是和正态分布相比较的。
    # Kurtosis=0 与正态分布的陡缓程度相同。
    # Kurtosis>0 比正态分布的高峰更加陡峭——尖顶峰
    # Kurtosis<0 比正态分布的高峰来得平稳——平顶峰     
    # 计算公式:β = M_4 /σ^4 
    # 偏度:偏度(Skewness)是描述某变量取值分布对称性的统计量。
    # Skewness=0 分布形态与正态分布偏度相同
    # Skewness>0 正偏差数值较大,为正偏或右偏。长尾巴拖在右边。
    # Skewness<0 负偏差数值较大,为负偏或左偏。长尾巴拖在左边。 
    # 计算公式: S= (X^ - M_0)/δ Skewness 越大,分布形态偏移程度越大。
    #==============================================================================
    '''
    # 查看因变量价格的情况,进行基础分析
    sns.distplot(data_train['SalePrice'])
    plt.show()
    # 对房屋价格金额的数值图形化,查看一下
    sns.set(style="darkgrid")
    titanic = pd.DataFrame(data_train['SalePrice'].value_counts())
    titanic.columns = ['SalePrice_count']
    ax = sns.countplot(x="SalePrice_count", data=titanic)
    plt.show()
    
    # 从房屋价格的正态分布情况,查看房屋价格的峰度和偏度情况
    print('房屋价格偏度:%f' % (data_train['SalePrice'].skew()))
    print('房屋价格峰度:%f' % (data_train['SalePrice'].kurt()))
    '''
    #==============================================================================
    # 分析数据中的缺失值情况,如果超过阈值15%,则删除这个变量,其他变量根据类别或者是数值型变量进行填充。
    #   具体得到的情况如下:
    # 
    # 有缺失的对应的变量名称 
    # * PoolQC Pool quality 游泳池质量 
    # * MiscFeature Miscellaneous feature not covered in other categories 其他杂项,例如网球场、第二车库等 
    # * Alley Type of alley access to property 胡同小路,是碎石铺就的还是其他等等 
    # * Fence Fence quality 护栏质量 
    # * FireplaceQu Fireplace quality 壁炉的质量 
    # * LotFrontage Linear feet of street connected to property 街道情况 
    # * GarageFinish Interior finish of the garage 车库完成情况 
    # * GarageQual Garage quality 车库质量 
    # * GarageType Garage location 车库的位置 
    # * GarageYrBlt Year garage was built 车库的建筑年龄 
    # * GarageCond Garage condition 车库的条件 
    # * BsmtExposure Refers to walkout or garden level walls 花园的墙壁情况 
    # * BsmtFinType2 Rating of basement finished area (if multiple types) 地下室的完工面积 
    # * BsmtQual Evaluates the height of the basement 地下室的高度 
    # * BsmtCond Evaluates the general condition of the basement 地下室的质量情况 
    # * BsmtFinType1 Rating of basement finished area 地下室完工面积 
    # * MasVnrType Masonry veneer type 表层砌体类型 
    # * MasVnrArea Masonry veneer area in square feet 砖石镶面面积平方英尺 
    # * Electrical Electrical system 电气系统
    # 
    #==============================================================================
    '''
    # 在进行图形分析之前,先分析一下数据中缺失值的情况
    miss_data = data_train.isnull().sum().sort_values(ascending=False)  # 缺失值数量
    total = data_train.isnull().count()  # 总数量
    miss_data_tmp = (miss_data / total).sort_values(ascending=False)  # 缺失值占比
    # 添加百分号
    def precent(X):
        X = '%.2f%%' % (X * 100)
        return X
    miss_precent = miss_data_tmp.map(precent)
    # 根据缺失值占比倒序排序
    miss_data_precent = pd.concat([total, miss_precent, miss_data_tmp], axis=1, keys=[
                                  'total', 'Percent', 'Percent_tmp']).sort_values(by='Percent_tmp', ascending=False)
    # 有缺失值的变量打印出来
    print(miss_data_precent[miss_data_precent['Percent'] != '0.00%'])
    
    #* 将缺失值比例大于15%的数据全部删除,剩余数值型变量用众数填充、类别型变量用None填充。*
    
    drop_columns = miss_data_precent[miss_data_precent['Percent_tmp'] > 0.15].index
    data_train = data_train.drop(drop_columns, axis=1)
    data_test = data_test.drop(drop_columns, axis=1)
    # 类别型变量
    class_variable = [
        col for col in data_train.columns if data_train[col].dtypes == 'O']
    # 数值型变量
    numerical_variable = [
        col for col in data_train.columns if data_train[col].dtypes != 'O']  # 大写o
    print('类别型变量:%s' % class_variable, '数值型变量:%s' % numerical_variable)
    
    # 数值型变量用中位数填充,test集中最后一列为预测价格,所以不可以填充
    from sklearn.preprocessing import Imputer
    #Imputer填充模块
    padding = Imputer(strategy='median')
    data_train[numerical_variable] = padding.fit_transform(
        data_train[numerical_variable])
    data_test[numerical_variable[:-1]
              ] = padding.fit_transform(data_test[numerical_variable[:-1]])
    # 类别变量用None填充
    data_train[class_variable] = data_train[class_variable].fillna('None')
    data_test[class_variable] = data_test[class_variable].fillna('None')
    
    # 对所有的数据图形化,主要判别一下数据和因变量之间的关联性,后期我们再采用方差验证来选择变量。
    # 用图形化只是为了大致查看数据情况,构建简单模型使用。对变量的选择并不准确,对于较多变量,用图形先判断一下,也是一个办法;
    # 如果变量较多,这种办法效率低,并且准确度也差,下面随机选择了几个变量画图看一下状况,后期并不使用这种办法来选择变量
    
    # 根据变量,选择相关变量查看与因变量之间的关系
    # CentralAir 中央空调
    data = pd.concat([data_train['SalePrice'], data_train['CentralAir']], axis=1)
    fig = sns.boxplot(x='CentralAir', y="SalePrice", data=data)
    plt.title('CentralAir')
    plt.show()
    # 有中央空调的房价更高
    
    # MSSubClass 房屋类型
    data = pd.concat([data_train['SalePrice'], data_train['MSSubClass']], axis=1)
    fig = sns.boxplot(x='MSSubClass', y="SalePrice", data=data)
    plt.title('MSSubClass')
    plt.show()
    # 房屋类型方面和房屋价格之间关联度不大
    
    # MSZoning 房屋区域,例如有高密度住宅、低密度住宅,猜想这个变量和房屋价格之间的关系比较密切
    data = pd.concat([data_train['SalePrice'], data_train['MSZoning']], axis=1)
    fig = sns.boxplot(x='MSZoning', y="SalePrice", data=data)
    plt.title('MSZoning')
    plt.show()
    # 实际结果显示和房屋价格的关系不大
    
    
    # LotArea 这个变量猜想会与房屋价格有直接的关系
    fig = plt.figure()
    ax = fig.add_subplot(111)
    ax.scatter(x=data_train['SalePrice'], y=data_train['LotArea'])
    plt.xlabel('SalePrice')
    plt.ylabel('LotArea')
    plt.title('LotArea')
    plt.show()
    # 地块面积与房屋价格有较高相关性
    
    
    # Street
    data = pd.concat([data_train['SalePrice'], data_train['Street']], axis=1)
    fig = sns.boxplot(x='Street', y="SalePrice", data=data)
    plt.title('Street')
    plt.show()
    # 街道类型和房屋价格有较高相关性
    
    
    # LotShape
    data = pd.concat([data_train['SalePrice'], data_train['LotShape']], axis=1)
    fig = sns.boxplot(x='LotShape', y="SalePrice", data=data)
    plt.title('LotShape')
    plt.show()
    # 房屋形状和房屋价格相关不明显
    
    # LandContour
    data = pd.concat([data_train['SalePrice'], data_train['LandContour']], axis=1)
    fig = sns.boxplot(x='LandContour', y="SalePrice", data=data)
    plt.title('LandContour')
    plt.show()
    # 房屋所在地是否平整和房屋价格关系较弱
    
    # Utilities
    data = pd.concat([data_train['SalePrice'], data_train['Utilities']], axis=1)
    fig = sns.boxplot(x='Utilities', y="SalePrice", data=data)
    plt.title('Utilities')
    plt.show()
    # 公共设施和房屋价格基本无关系
    
    # LotConfig
    data = pd.concat([data_train['SalePrice'], data_train['LotConfig']], axis=1)
    fig = sns.boxplot(x='LotConfig', y="SalePrice", data=data)
    plt.title('LotConfig')
    plt.show()
    '''
    #==============================================================================
    # 因为变量较多,直接采用关系矩阵,查看各个变量和因变量之间的关系,使用的时候采用spearman系数,原因: 
    # Pearson 线性相关系数只是许多可能中的一种情况,为了使用Pearson 线性相关系数必须假设数 
    # 据是成对地从正态分布中取得的,并且数据至少在逻辑范畴内必须是等间距的数据。如果这两条件 
    # 不符合,一种可能就是采用Spearman 秩相关系数来代替Pearson 线性相关系数。Spearman 秩相关系 
    # 数是一个非参数性质(与分布无关)的秩统计参数,由Spearman 在1904 年提出,用来度量两个变 
    # 量之间联系的强弱(Lehmann and D’Abrera 1998)。Spearman 秩相关系数可以用于R 检验,同样可以 
    # 在数据的分布使得Pearson 线性相关系数不能用来描述或是用来描述或导致错误的结论时,作为变 
    # 量之间单调联系强弱的度量。
    # Spearman对原始变量的分布不作要求,属于非参数统计方法,适用范围要广些。
    # 理论上不论两个变量的总体分布形态、样本容量的大小如何,都可以用斯皮尔曼等级相关来进行研究 。
    #==============================================================================
    '''
    #==============================================================================
    # 变量处理 :
    # 
    # 在变量处理期间,我们先考虑处理更简单的数值型变量,再考虑处理复杂的类别型变量;
    # 
    # 其中数值型变量,需要先考虑和因变量的相关性,其次考虑变量两两之间的相关性,再考虑变量的多重共线性;
    # 
    # 类别型变量除了考虑相关性之外,需要进行编码。
    #==============================================================================
    # 绘制热力图,查看一下数值型变量之间的关系
    corrmat = data_train[numerical_variable].corr('spearman')
    f, ax = plt.subplots(figsize=(12, 9))
    ax.set_xticklabels(corrmat, rotation='horizontal')
    sns.heatmap(np.fabs(corrmat), square=False, center=1)
    label_y = ax.get_yticklabels()
    plt.setp(label_y, rotation=360)
    label_x = ax.get_xticklabels()
    plt.setp(label_x, rotation=90)
    plt.show()
    
    # 计算变量之间的相关性
    numerical_variable_corr = data_train[numerical_variable].corr('spearman')
    numerical_corr = numerical_variable_corr[
        numerical_variable_corr['SalePrice'] > 0.5]['SalePrice']
    print(numerical_corr.sort_values(ascending=False))
    index0 = numerical_corr.sort_values(ascending=False).index
    # 结合考虑两两变量之间的相关性
    print(data_train[index0].corr('spearman'))
    
    #==============================================================================
    # 结合上述情况,选择出如下的变量:
    # Variable	相关性
    # OverallQual	0.809829
    # GrLivArea	0.731310
    # GarageCars	0.690711
    # YearBuilt	0.652682
    # FullBath	    0.635957
    # TotalBsmtSF	0.602725
    # YearRemodAdd	0.571159
    # Fireplaces	0.519247
    #==============================================================================
    
    #在这个基础上再考虑变量之间的多重共线性
    new_numerical = ['OverallQual', 'GrLivArea', 'GarageCars',
                     'YearBuilt', 'FullBath', 'TotalBsmtSF', 'YearRemodAdd', 'Fireplaces']
    X = np.matrix(data_train[new_numerical])
    VIF_list = [variance_inflation_factor(X, i) for i in range(X.shape[1])]
    VIF_list
    #可以明显看到数据有很强的多重共线性,对数据进行标准化和降维
    
    Scaler = StandardScaler()
    data_train_numerical = Scaler.fit_transform(data_train[new_numerical])
    pca = PCA(n_components=7)
    newData_train = pca.fit_transform(data_train_numerical)
    newData_train
    
    Scaler = StandardScaler()
    data_test_numerical = Scaler.fit_transform(data_test[new_numerical])
    pca = PCA(n_components=7)
    newData_test = pca.fit_transform(data_test_numerical)
    newData_test
    
    newData_train = pd.DataFrame(newData_train)
    # newData
    y = np.matrix(newData_train)
    VIF_list = [variance_inflation_factor(y, i) for i in range(y.shape[1])]
    print(newData_train, VIF_list)
    
    #从上面的数据标准化和降维之后,已经消除了多重共线性了。接下来处理类别数据
    # 单因素方差分析
    
    from statsmodels.formula.api import ols
    #单因素方差分析模块
    from statsmodels.stats.anova import anova_lm
    #双因素方差分析模块
    a = '+'.join(class_variable)
    formula = 'SalePrice~ %s' % a
    anova_results = anova_lm(ols(formula, data_train).fit())
    print(anova_results.sort_values(by='PR(>F)'))
    #我们需要看的是单个自变量对因变量SalePrice的影响,因此这里使用单因素方差分析。 
    #分析结果中 P_values(PR(>F))越小,说明该变量对目标变量的影响越大。通常我们只选择 P_values 小于 0.05 的变量
    # 从变量列表和数据中剔除 P 值大于 0.05 的变量
    del_var = list(anova_results[anova_results['PR(>F)'] > 0.05].index)
    del_var
    # 移除变量
    for each in del_var:
        class_variable.remove(each)
    # 移除变量数据
    data_train = data_train.drop(del_var, axis=1)
    data_test = data_test.drop(del_var, axis=1)
    # 对类别型变量进行编码
    def factor_encode(data):
        map_dict = {}
        for each in data.columns[:-1]:
            piv = pd.pivot_table(data, values='SalePrice',
                                 index=each, aggfunc='mean')
            piv = piv.sort_values(by='SalePrice')
            piv['rank'] = np.arange(1, piv.shape[0] + 1)
            map_dict[each] = piv['rank'].to_dict()
        return map_dict
    
    # 调用上面的函数,对名义特征进行编码转换
    class_variable.append('SalePrice')
    map_dict = factor_encode(data_train[class_variable])
    for each_fea in class_variable[:-1]:
        data_train[each_fea] = data_train[each_fea].replace(map_dict[each_fea])
        data_test[each_fea] = data_test[each_fea].replace(map_dict[each_fea])
    #因为上面已经完成编码,这里我们再根据相关性判断和选择变量
    class_coding_corr=data_train[class_variable].corr('spearman')['SalePrice'].sort_values(ascending=False)
    print(class_coding_corr[class_coding_corr>0.5])
    class_0=class_coding_corr[class_coding_corr>0.5].index
    data_train[class_0].corr('spearman')
    #==============================================================================
    # SalePrice	Neighborhood	ExterQual	BsmtQual	KitchenQual	GarageFinish	GarageType	Foundation
    # SalePrice	1.000000	0.755779	0.684014	0.678026	0.672849	0.633974	0.598814	0.573580
    # Neighborhood	0.755779	1.000000	0.641588	0.650639	0.576106	0.542172	0.520204	0.584784
    # ExterQual	0.684014	0.641588	1.000000	0.645766	0.725266	0.536103	0.444759	0.609009
    # BsmtQual	   0.678026	0.650639	0.645766	1.000000	0.575112	0.555535	0.468710	0.669723
    # KitchenQual	0.672849	0.576106	0.725266	0.575112	1.000000	0.480438	0.412784	0.546736
    # GarageFinish	0.633974	0.542172	0.536103	0.555535	0.480438	1.000000	0.663870	0.516078
    # GarageType	0.598814	0.520204	0.444759	0.468710	0.412784	0.663870	1.000000	0.445793
    # Foundation	0.573580	0.584784	0.609009	0.669723	0.546736	0.516078	0.445793	1.000000
    #==============================================================================
    #查找两两之间的共线性之后,我们保留如下变量Neighborhood,ExterQual,BsmtQual,GarageFinish,GarageType,GarageType;
    #接下来尝试查看多重共线性
    class_variable = ['Neighborhood', 'ExterQual', 'BsmtQual',
                     'GarageFinish', 'GarageType', 'Foundation']
    X = np.matrix(data_train[class_variable])
    VIF_list = [variance_inflation_factor(X, i) for i in range(X.shape[1])]
    VIF_list
    #==============================================================================
    # [9.613821793463067,
    #  31.39188664149662,
    #  33.53637481741086,
    #  22.788724064203514,
    #  18.362389057630754,
    #  15.022566626297733]
    #==============================================================================
    Scaler = StandardScaler()
    data_train_class = Scaler.fit_transform(data_train[class_variable])
    pca = PCA(n_components=3)
    newData_train_class = pca.fit_transform(data_train_class)
    newData_train_class
    #==============================================================================
    # array([[-1.77187082,  0.39144961, -0.00666812],
    #        [-0.56662675, -0.71029462, -0.51616971],
    #        [-1.77187082,  0.39144961, -0.00666812],
    #        ...,
    #        [-1.53107491,  0.09189354, -1.97872919],
    #        [ 1.08133883, -0.73280347, -0.2622237 ],
    #        [-0.15886914, -1.39847287, -0.0633631 ]])
    #==============================================================================
    Scaler = StandardScaler()
    data_test_class = Scaler.fit_transform(data_test[class_variable])
    pca = PCA(n_components=3)
    newData_test_class = pca.fit_transform(data_test_class)
    newData_test_class
    #==============================================================================
    # array([[ 1.02960083, -0.69269663,  0.29882836],
    #        [ 1.02960083, -0.69269663,  0.29882836],
    #        [-1.36691619, -0.77507848, -1.26800226],
    #        ...,
    #        [ 1.62092967,  0.49991231,  0.28578798],
    #        [ 1.25970992,  2.79139405, -1.00467437],
    #        [-1.16601113, -0.81964858, -1.47794992]])
    #==============================================================================
    newData_train_class = pd.DataFrame(newData_train_class)
    y = np.matrix(newData_train_class)
    VIF_list = [variance_inflation_factor(y, i) for i in range(y.shape[1])]
    print(VIF_list)
    #==============================================================================
    # [1.0, 0.9999999999999993, 0.9999999999999996]
    #==============================================================================
    #训练集
    newData_train_class = pd.DataFrame(newData_train_class)
    newData_train_class.columns = ['降维后类别A','降维后类别B','降维后类别C']
    newData_train = pd.DataFrame(newData_train)
    newData_train.columns = ['降维后数值A','降维后数值B','降维后数值C','降维后数值D','降维后数值E','降维后数值F','降维后数值G']
    target = data_train['SalePrice']
    target = pd.DataFrame(target)
    train = pd.concat([newData_train_class,newData_train],axis=1, ignore_index=True)
    
    #测试集
    newData_test_class = pd.DataFrame(newData_test_class)
    newData_test_class.columns = ['降维后类别A','降维后类别B','降维后类别C']
    newData_test = pd.DataFrame(newData_test)
    newData_test.columns = ['降维后数值A','降维后数值B','降维后数值C','降维后数值D','降维后数值E','降维后数值F','降维后数值G']
    test = pd.concat([newData_test_class,newData_test],axis=1, ignore_index=True)
    
    from sklearn.model_selection import train_test_split
    #train_test_split函数用于将矩阵随机划分为训练子集和测试子集,并返回划分好的训练集测试集样本和训练集测试集标签
    from sklearn.ensemble import RandomForestRegressor
    #随机森林
    from sklearn.linear_model import LogisticRegression
    #逻辑回归
    from sklearn import svm
    #支持向量机
    train_data, test_data, train_target, test_target = train_test_split(train, target, test_size=0.2, random_state=0)
    # 当前参数为默认参数
    m = RandomForestRegressor()
    m.fit(train_data, train_target)
    from sklearn.metrics import r2_score
    score = r2_score(test_target,m.predict(test_data))
    print(score)
    #==============================================================================
    # 0.8407489786565608
    # D:\ProgramData\Anaconda3\lib\site-packages\ipykernel_launcher.py:4: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples,), for example using ravel().
    #   after removing the cwd from sys.path.
    #==============================================================================
    lr = LogisticRegression(C=1000.0,random_state=0)
    lr.fit(train_data, train_target)
    from sklearn.metrics import r2_score
    score = r2_score(test_target,lr.predict(test_data))
    print(score)
    #==============================================================================
    # D:\ProgramData\Anaconda3\lib\site-packages\sklearn\utils\validation.py:578: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().
    #   y = column_or_1d(y, warn=True)
    # 0.6380328421527758
    #==============================================================================
    clf = svm.SVC(kernel = 'poly')
    clf.fit(train_data, train_target)
    score = r2_score(test_target,clf.predict(test_data))
    print(score)
    #==============================================================================
    # D:\ProgramData\Anaconda3\lib\site-packages\sklearn\utils\validation.py:578: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().
    #   y = column_or_1d(y, warn=True)
    # 0.775319597309544
    #==============================================================================
    #==============================================================================
    # 结论就是逻辑回归等模型性能比较差,即使已经经过了正则化、PCA降维、去除多重共线性等。kaggle的比赛起手就应该用XGB。 
    # 下面尝试使用一下网格搜索的方式看能否提高一下随机森林的性能。
    #==============================================================================
    from sklearn.grid_search import GridSearchCV
    #网格搜索功能
    from sklearn.pipeline import Pipeline
    
    #==============================================================================
    # D:\ProgramData\Anaconda3\lib\site-packages\sklearn\cross_validation.py:41: DeprecationWarning: This module was deprecated in version 0.18 in favor of the model_selection module into which all the refactored classes and functions are moved. Also note that the interface of the new CV iterators are different from that of this module. This module will be removed in 0.20.
    #   "This module will be removed in 0.20.", DeprecationWarning)
    # D:\ProgramData\Anaconda3\lib\site-packages\sklearn\grid_search.py:42: DeprecationWarning: This module was deprecated in version 0.18 in favor of the model_selection module into which all the refactored classes and functions are moved. This module will be removed in 0.20.
    #   DeprecationWarning)
    #==============================================================================
    param_grid = {'n_estimators':[1,10,100,200,300,400,500,600,700,800,900,1000,1200],'max_features':('auto','sqrt','log2')}
    m = GridSearchCV(RandomForestRegressor(),param_grid)
    m=m.fit(train_data,train_target.values.ravel())
    print(m.best_score_)
    print(m.best_params_)
    #==============================================================================
    # 0.8642193810202421
    # {'max_features': 'sqrt', 'n_estimators': 500}
    #==============================================================================
    #通过网格搜索找到最佳的参数后,代入模型,模型完成
    m = RandomForestRegressor(n_estimators=200,max_features='sqrt')
    m.fit(train_data, train_target.values.ravel())
    predict = m.predict(test)
    test = pd.read_csv('test.csv')['Id']
    sub = pd.DataFrame()
    sub['Id'] = test
    sub['SalePrice'] = pd.Series(predict)
    sub.to_csv('Predictions.csv', index=False)
    
    print('finished!')
    
    展开全文
  • K近邻模型、KNN算法1-构建预测模型 案例 假设你已经清洗好了一份同类型的商品信息和价格数据,如果给一个同品类全新的商品,你如何给它定价或预测它的价格? 比如,这个商品是红酒。你已经获取到了一批红酒的评级...

    K近邻模型、KNN算法1-构建预测模型

    案例

    假设你已经清洗好了一份同类型的商品信息和价格数据,如果给一个同品类全新的商品,你如何给它定价或预测它的价格?

    比如,这个商品是红酒。你已经获取到了一批红酒的评级、生产年份、瓶装大小等红酒属性数据,以及对应的红酒价格。现在请根据这个样本数据对一瓶红酒进行价格预测、价格区间概率预测。

    思路逻辑图

    Python代码

    #!/usr/bin/env python
    # -*- coding: utf-8 -*-
    #@Time: 2019-11-18 07:07
    #@Author: gaoll
    
    import time
    import random
    from random import randint
    import math
    import numpy as np
    import matplotlib.pyplot as plt
    
    #定义距离函数. 
    def euclidean(v1,v2):
    	d = 0.0
    	for i in range(len(v1)):
    		d+=(v1[i]-v2[i])**2
    	return math.sqrt(d)
    
    #计算距离。KNN算法距离计算完保存起来,使用时无需再计算
    def getdistances(data,vec1,distance=euclidean):
    	distancelist = []
    	for i in range(len(data)):
    		vec2=data[i]['input']
    		d = distance(vec1,vec2)
    		distancelist.append((d,i))
    	distancelist.sort()
    	return distancelist
    
    #定义权重公式
    #反函数
    def inverseweight(dist,num=1.0,const=0.1):
    	return num/(dist+const)
    #减法函数
    def substractweight(dist,const=1.0):
    	if dist>const:
    		return 0 
    	else:
    		return const - dist
    #高斯函数
    def gaussian(dist,sigma=10.0):
    	return math.e**(-dist**2/(2*sigma**2))
    
    #创建KNN函数,根据前k项估计,加权knn
    def createweightedknn(k,weighf=gaussian):
    	def weightedknn(data,vec1):
    			#按照距离值经过排序的列表
    		dlist = getdistances(data,vec1)
    		avg = 0
    		total_weight = 0.0
    		for i in range(k):
    			(dist,id) = dlist[i]
    			weight = weighf(dist)
    			avg+=data[id]['result']*weight
    			total_weight += weight
    		avg = avg/total_weight
    		return avg
    	return weightedknn
    
    #交叉验证--拆分测试集和训练集
    def dividedata(data,test=0.05):
    	trainset = []
    	testset = []
    	for row in data:
    		if random.random()<test:
    			testset.append(row)
    		else:
    			trainset.append(row)
    	return trainset,testset
    
    #定义评估函数。此处使用误差平方和函数
    def testalgorithm(algf,trainset,testset):
    	error =0
    	for row in testset:
    		vec = row['input']
    		guess = algf(trainset,vec)
    		error += (guess - row['result'])**2
    	return error
    
    #交叉验证
    def crossvalidate(algf,data,trials=100,test=0.05):
    	error = 0
    	for i in range(trials):
    		trainset,testset = dividedata(data,test)
    		error += testalgorithm(algf,trainset,testset)
    	if error ==0:
    		return 0
    	return error/trials
    
    #数据各列按一定比例放缩
    def rescale(data,scale):
    	scaled_data = []
    	for row in data:
    		scaled_input = [row['input'][i]*scale[i] for i in range(len(scale))]
    		scaled_data.append({'input':scaled_input,'result':row['result']})
    	return scaled_data
    
    #对向量做放缩
    def rescale_vec(vec,scale):
    	return [vec[i]*scale[i] for i in range(len(scale))]
    
    #定义scale损失函数
    def createcostf_scale(algf,data):
    	def costf_scale(scale):
    		scaled_data = rescale(data,scale)
    		return crossvalidate(algf,scaled_data,trials=10)
    	return costf_scale
    
    #定义k的损失函数
    def createcostf_k(data,algf=createweightedknn):
    	def costf_k(k):
    		weightedknn = algf(k=k,weighf=gaussian)
    		return crossvalidate(weightedknn,data)
    	return costf_k
    
    #区间概率预测
    def probguess(data,vec1,low,high,k=3,weightf=gaussian):
    	dlist = getdistances(data,vec1)
    	inweight = 0.0
    	totalweight= 0.0
    	for i in range(k):
    		(dist,id) = dlist[i]
    		weight = weightf(dist)
    		v = data[id]['result']
    		if v>=low and v<=high:
    			inweight += weight
    		totalweight += weight
    	if inweight == 0:
    		return 0
    	return inweight/totalweight
    
    #根据区间概率预测,绘制累计概率图
    def cumulativegragh(data,vec1,high,k=3,weightf=gaussian):
    	x = np.arange(0.0,high,0.1)
    	y = [probguess(data,vec1,0.0,t,k=k,weightf=weightf) for t in x]
    	fig = plt.figure()
    	ax=fig.add_subplot(1,1,1)
    	ax.plot(x,y)
    	fig.show()
    
    #使用KNN思想,绘制概率密度图
    def probalitygragh(data,vec1,high,k=3,weightf=gaussian,ss=5.0):
    	x = np.arange(0.0,high,0.1)
    	#得到每个小区间上的概率
    	probs = [probguess(data,vec1,v,v+0.1,k,weightf) for v in x]
    	#做平滑处理,即加上近邻概率的高斯权重
    	smoothed = []
    	for i in range(len(probs)):
    		sv = 0.0
    		for j in range(0,len(probs)):
    			dist = abs(i-j)*0.1
    			weight = weightf(dist,sigma=ss)
    			sv+=weight*probs[j]
    		smoothed.append(sv)
    	fig = plt.figure()
    	ax = fig.add_subplot(1,1,1)
    	ax.plot(x,smoothed)
    	fig.show()
    
    
    
    if __name__ == "__main__":
    	#记载数据
    	import wineprice
    	data = wineprice.wineset3()
    
    	#优化K,确定K的大致范围,这里设2-7
    	costf_k = createcostf_k(data,createweightedknn)
    	for i in range(2,8):
    		print(i,costf_k(i))
    
    	'''out:从简单从小,这里k=4交叉验证损失最小
    	2 62368.44691765818
    	3 66027.43378150972
    	4 61087.78286215031
    	5 65923.3855665127
    	6 67817.68744348118
    	7 67395.5927600834
    	'''
    	#以上述得出的k=4为基础,优化scale
    	import optimization 
    	weightedknn = createweightedknn(k=4)
    	domain = [(0,20)]*4
    	costf_scale = createcostf_scale(weightedknn,data)
    	#使用模拟退火算法优化缩放系数。--见前面的博文-优化算法
    	optimization.annealingoptimize(domain,costf_scale)
    	#Out[150]: [1, 13, 12, 0]
    
    	#K和放缩比例相互影响,这个确定的过程比较繁琐,可能要重复几次。
    	#这里经过3次相互交叉验证后,决定使用 k=3,scale=[8, 4, 3, 2]。
    	k = 3
    	scale = [8, 4, 3, 2]
    
    	scaled_data = rescale(data,scale)
    	weightedknn = createweightedknn(k=3,weighf=gaussian)
    	#交叉验证
    	crossvalidate(weightedknn,scaled_data)
    	#Out[153]: 62935.15164770742
    
    	#knn数值预测
    	TobePredict=[90, 35, 13, 3000.0]
    	scaled_tobepredict = rescale_vec(TobePredict,scale) #放缩
    	print(weightedknn(scaled_data,scaled_tobepredict))  #预测
    	#188.3792652896066
    
    	#价格区间预测
    	probguess(scaled_data,scaled_tobepredict,100,150)
    	#Out[106]: 1.2491095402673855e-05
    	probguess(scaled_data,scaled_tobepredict,100,180)
    	#Out[107]: 0.3000429516680889
    	probguess(scaled_data,scaled_tobepredict,100,200)
    	#Out[108]: 1.0
    
    	#累计概率图
    	cumulativegragh(scaled_data,scaled_tobepredict,300)
    
    	#概率密度图
    	probalitygragh(scaled_data,scaled_tobepredict,300)
        

    结果展示

    #1、累计概率图

    #2、概率密度图(从概率密度图中发现它的概率分布并不对称,说明有可能我们的数据中存在未知的隐藏变量,需要再详细询问获取的数据是否有漏标记说明的信息。)

    展开全文
  • 股票价格预测 Udacity-机器学习纳米学位课程:Project-6(Capstone项目) 项目概况 这是Udacity-机器学习纳米学位计划中列出的一系列项目中的第六个也是最后一个顶点项目。 投资公司,对冲基金甚至个人一直在使用...
  • 摘要如何准确地进行股票预测一直...基于上述问题,文中利用将遗传算法(GA)解决调参问题来保证模型预测的平衡性,由此构建了新型股票预测模型。该模型分为三部分,首先利用 LSTM 网络进行收盘价的预测,再利...

    摘要

    如何准确地进行股票预测一直是量化金融领域的重要问题。长短期记忆细胞神经网络(LSTM)的出现较好地解决了股票预测这类的复杂序列化数据学习的问题。然而前期研究结果表明单一使用该方法仍存在预测不平衡、陷入局部极值导致能力不佳的问题。基于上述问题,文中利用将遗传算法(GA)解决调参问题来保证模型预测的平衡性,由此构建了新型股票预测模型。该模型分为三部分,首先利用 LSTM 网络进行收盘价的预测,再利用基于遗传算法的判别机制,最终获取下一刻股票的涨跌信号。这一模型不同于先前的研究,主要针对 LSTM 模型的输出模块进行了改进。文中使用了中证500的日内分钟数据进行测试验证。实验得出,改进模型的各方面指标均优于单独的 LSTM 模型。

    1 引言

    股票市场的预测一直备受关注,然而由于其固有的噪声环境和相对于市场趋势的较大波动性,其掣肘因素特别多,因此该过程非常复杂。以往股票市场预测技术大致可分为基于预测的技术和基于聚类的技术两大类。本文主要讨论基于预测技术的股票价格预测问题。目前针对股票价格预测的研究有人工神经网络(ANN)、支 持向量机(SVM)、时 间序列模型、基于模糊的技术和随机性来优化定价模型等方法。

    在前人工作中,人工神经网络(ANN)已被证实善于处理复杂关系问题,但是神经网络的测试和训练速度较慢。此外,过度拟合、陷入局部极小值和黑盒技术是神经网络的缺点。SVM 的特征选择方法无法指出所需的最优特征数量,严重影响了系统精度,因 此 该 研 究 不 易 拓 展。Krauss将 随机森林方法应用到了股 票 预 测 问 题 上,取得了较好成绩。Fischer等评价,随机森林可以 作 为 任 何 创 新 机 器 学 习 模 型 的强大基准。GARCH 是 经 典 的 时 间 序 列 模 型,广 泛 应 用 于 时 间 序列的预测,但它们都假设时间序列的值是一个线性生成过程。然而,市场特征是非线性的,与政治和经济条件及其经营者的期望相互作用,使得 GARCH 假 设 不 适 用 于 许 多 金 融 时 间 序列应用。长短期记忆网络(LSTM)是一种时间递归神经网络,适合处理和预测时间序列中间隔和延迟相对较长的重要事件。这一技 术 特 征 与 股 票 预 测 问 题 有 着 很 高 的 契 合 度,LSTM 弥补了 GARCH 受限于线 性 模 型 的 问 题,极有可能为股票预测问 题 提 供 一 个 解 决 方 案。Fischer等 基于 S&P500数据通过 LSTM 模型进行收益率的预测。实验表明,收益率预测准确率在51%~54% 左 右,要 优 于 随 机 森 林 和 DNN 模型。这样的预测结果并不令人满意,导致准确率不理想的原因有很多,比如模型结构不佳、特 征 样 本 不 适 合、神经网络通病———陷入局部极值。在该问题的讨论中,有研究者调整了模型参数,结合多维度数据处理特征样本等。

    延续以往的研究,本 文 基 于 中 国 中证500 股票数据提出了一种基于 LSTM 网络的机器学习方法来预测未来价格,而后又在 LSTM 模型基础上改进为股票涨跌的预测,该方法采用遗传算法改进调参模型,从而提升了预测效果,弥补了单一应用 LSTM 网络的不足。

    总体框架设计

    股票预测模型分为两部分,由 LSTM 网络和涨跌决策模块组成,如图所示。我们设计了 LSTM 网络,用来学习股票历史数据规律,预测 出 下 一 时 刻 的 股 票 收 盘 价。涨跌决策模块用来将收盘价数据转换成涨跌信号。我们根据具体实验设计了两套算法,一是传统的阈值方式来定义涨跌;另一种是结合股票历史数据来自适应地调整阈值大小定义涨跌。

    11d63349169e2e92a98e2ed1bb82f35f.png

    遗传算法原理

    遗传算法(GA)是一种常用的求解方法,通常用于优化工程、计算机科学、经济管理等领域的问题。与蚁群算法和模拟退火算法等进化算法不同,GA 通过选择、交叉 和 突 变 个 体 来选择最佳物种进行生物繁殖。其模拟生物的进化来解决优化问题,程序化流程如图 所示。GA 算 法 的 核 心 在 于 将 实 际问题编码以便模拟生物的进化过程。为了模拟生态的进化过程,比较常见的方式是 引 入 基 因 链 的 概 念。经过编码把一个物种转换成一条基因链,两条基因链的部分基因进行交换重组,获得新的基因链,这样就完成一次物种进化。GA 算法成熟的编码方式有很多,如二进制编码、格雷码编码、排列编码等。我们选用二进制编 码 方 式 来 描 述 实 际 问 题,完成交叉变异过程。

    738ee9ffcdcce7d13a1147b16e68ad95.png

    结束语

    金 融 市 场 预 测 问 题 一 直 是 金 融 领 域 的 核 心 问题。随着机器学习技术 的 进 步,研 究 人 员 开 始 尝 试 将 机 器 学习模型应用到金融领 域 来 解 决 实 际 问 题。借 鉴 之 前 的 研 究,我们从 LSTM 神经网络入手,构建了用于预测股票收盘价 格的神经网络 模 型。 结 合 实 际 应 用 场 景,结 合 LSTM 模 型 和GA 算法来实现 股 票 价 格 的 涨 跌 预 测。通 过 实 验 分 析 发 现,LSTM 的预测在小幅变化 的 价 格 变 动 中 表 现 良 好,但 在 大 幅价格变化时表现 出 滞 后 的 现 象。 结 合 LSTM 和 GA 的 涨 跌预测模型能较为准确地预测市场的涨跌情况,对投资有一定的参考价值。

    展开全文
  • 在本文中,我们将使用神经网络,特别是LSTM模型预测时间序列数据的行为。需要解决的问题是经典的股市预测。所有使用的数据和代码都可以私信我。虽然这是一个老问题,但直到今天仍未解决。事实很简单:股价是由几个...
  • 结果表明,开通直销渠道不影响制造商的批发价定价,但可以迫使零售商降低零售价格;开通直销渠道使制造商在分散式供应链中和协调式供应链中都能获得更多利润,使零售商利润减少;只有当运作成本和消费者区域性差异都...
  • 为了验证股票的价格运动与过去应该是相似的这一假设,运用K近邻算法,将价格运动简单划分为涨跌两类进行预测,进行假设验证。使用滑窗方法比较现在的价格运动与何时的历史价格更为相似,将多个K近邻模型组合成集成...
  • Lasso模型和Ridge模型预测波士顿房屋租赁价格
  • Java实现线性回归模型算法

    万次阅读 2018-01-06 16:39:44
    让我们通过一个例子开始:这个例子就是预测住房价格的,我们要使用一个数据集,数据集包含一个地方的住房价格,这里我们要根据不同房屋尺寸所售出的价格,画出我们的数据集,比方说,如果你朋友的房子是1250平方尺...
  • 基于LSTM的股票预测模型_python实现_超详细

    万次阅读 多人点赞 2019-07-05 22:25:13
    文章目录一、背景二、主要技术介绍1、RNN模型2、LSTM模型3、控制门工作原理四、代码实现五、案例分析...因此本文想利用现有的模型算法,对股票价格进行预测,从而使自然人股民可以自己对股票进行预测。 理论上,...
  • 根据各个模型的最终预测表现分配不同的权重以改变其对最终结果影响的大小。对于正确率低的模型给予更低的权重,而正确率更高的模型给予更高的权重。 分类任务中的Voting 基本思想是选择所有机器学习算法当中输出最多...
  • Datawhale-零基础入门数据挖掘 - 二手车交易价格预测-模型融合 今天在一个比赛的top1的代码中看到了这样一句话分享给大家: 实际在竞赛中,你花下的时间应该通常是: 特征工程 > 模型融合 > 算法模型 > ...
  • 为了对股票价格进行准确、快速的在线预测,提出一种基于改进极限学习机算法(IELM)的股票价格在线预测模型。在极限学习机(ELM)中引入Cholesky分解方法,使网络权值随新样本的逐次加入递推更新,提高模型的泛化...
  • #多元线性回归预测房子的价格,构建一个房子价格的python模型。 ##ex1data2.txt中包含了房子价格的训练组。第一列是房子的尺寸(平方英尺),第二列是卧室的数量,第三列是房子的价格
  • 基于LSTM、RNN及滑动窗口CNN模型的股票价格预测 Abstract 股票市场或股票市场对当今经济产生深远影响。股价的上涨或者下跌对投资者的收益具有重要的决定作用。现有的预测方法使用线性(AR,MA,ARIMA)和非线性...
  • 文章目录前言一、了解...注意:该数据集已经经过预处理,可以直接用于预测价格区间。 一、了解数据 battery_power:电池一次可储存的总能量,单位为毫安时 blue :是否有蓝牙 clock_speed:微处理器执行指令的速度 du
  • 答案是肯定的,让我们使用机器学习中的回归算法预测世界上贵重金属之一,黄金的价格吧。 我们将建立一个机器学习线性回归模型,它将从黄金ETF (GLD)的历史价格中获取信息,并返回黄金ETF价格在第二天的预测值。 GLD...
  • 1.背景:针对股票市场中AR 模型的识别、建立和估计问题,利用AR 模型算法对股票价格进行预测。2.模型选取:股票的价格可视为随机信号,将此随机信号建模为:一个白噪声通过LTI系统的输出,通过原始数据求解 所建模型...
  • 例如,餐 厅根据每天的营业数据(包括菜谱价格、就餐人数、预定人数、特价菜 折扣等)预测就餐规模或营业额;网站根据访问的历史数据(包括新用 户的注册量、老用户的活跃度、网页内容的更新频率等)预测用户的支 付...
  • 股票预测相关模型.zip

    2019-07-11 16:42:52
    利用基本的机器学习算法股票价格走势进行简单的预测
  • 线性回归、BP神经网络、支持向量机、随机森林算法对比一、概念各种模型算法概念可以参考往期文章:开通头条号|细思极恐!股票价格竟是可预测Python集成算法二、关于XGboost回归预测锂电池的健康状态(SOH)现在做预测...
  •  针对股票市场中AR 模型的识别、建立和估计问题,利用AR 模型算法对股票价格进行预测。 2.模型选取:  股票的价格可视为随机信号,将此随机信号建模为:一个白噪声通过LTI系统的输出,通过原始数据求解 所建模型...
  • 汽车价格预测-源码

    2021-02-07 17:54:53
    汽车价格预测一直是研究的热点,因为它需要大量的努力和现场专家的知识。 我们在由不同汽车的售价及其规格组成的数据集上实施并评估了各种机器学习模型。 该项目有助于管理层了解价格随独立变量的确切变化。
  • 参考链接: 从Python获取输入 文章目录 ...因此本文想利用现有的模型算法,对股票价格进行预测,从而使自然人股民可以自己对股票进行预测。 理论上,股票价格是可以预测的,但是影响股票价格...

空空如也

空空如也

1 2 3 4 5 ... 18
收藏数 346
精华内容 138
关键字:

价格预测模型算法